diff --git a/lopcodes.h b/lopcodes.h
index 878c4828..5b1856d8 100644
--- a/lopcodes.h
+++ b/lopcodes.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.h,v 1.6 1997/10/01 20:05:34 roberto Exp roberto $
+** $Id: lopcodes.h,v 1.7 1997/10/06 14:51:11 roberto Exp roberto $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -9,9 +9,9 @@
 
 
 /*
-** NOTICE: variants of the same opcode (like PUSH0, PUSHBYTE, PUSHWORD) must
-** be consecutive: First, those with built-in parameters, then with byte
-** parameter and last with word parameter.
+** NOTICE: variants of the same opcode must be consecutive: First, those
+** with byte parameter, then with built-in parameters, and last with
+** word parameter.
 */
 
 
@@ -20,15 +20,16 @@ typedef enum {
 -----------------------------------------------------------------------------*/
 ENDCODE,/*	-	-		-  */
 
-PUSHNIL,/*	-	-		nil  */
-PUSHNILS,/*	b	-		nil_1...nil_b  */
+PUSHNIL,/*	b	-		nil_0...nil_b  */
+PUSHNIL0,/*	-	-		nil  */
 
-PUSH0,/*	-	-		0.0  */
-PUSH1,/*	-	-		1.0  */
-PUSH2,/*	-	-		2.0  */
-PUSHBYTE,/*	b	-		(float)b  */
-PUSHWORD,/*	w	-		(float)w  */
+PUSHNUMBER,/*	b	-		(float)b  */
+PUSHNUMBER0,/*	-	-		0.0  */
+PUSHNUMBER1,/*	-	-		1.0  */
+PUSHNUMBER2,/*	-	-		2.0  */
+PUSHNUMBERW,/*	w	-		(float)w  */
 
+PUSHCONSTANT,/*	b	-		CNST[b] */
 PUSHCONSTANT0,/*-	-		CNST[0] */
 PUSHCONSTANT1,/*-	-		CNST[1] */
 PUSHCONSTANT2,/*-	-		CNST[2] */
@@ -37,15 +38,13 @@ PUSHCONSTANT4,/*-	-		CNST[4] */
 PUSHCONSTANT5,/*-	-		CNST[5] */
 PUSHCONSTANT6,/*-	-		CNST[6] */
 PUSHCONSTANT7,/*-	-		CNST[7] */
-PUSHCONSTANT8,/*-	-		CNST[8] */
-PUSHCONSTANT9,/*-	-		CNST[9] */
-PUSHCONSTANTB,/*b	-		CNST[b] */
-PUSHCONSTANT,/* w	-		CNST[w] */
+PUSHCONSTANTW,/*w	-		CNST[w] */
 
+PUSHUPVALUE,/*	b	-		Closure[b] */
 PUSHUPVALUE0,/*	-	-		Closure[0] */
 PUSHUPVALUE1,/*	-	-		Closure[1] */
-PUSHUPVALUE,/*	b	-		Closure[b] */
 
+PUSHLOCAL,/*	b	-		LOC[b]  */
 PUSHLOCAL0,/*	-	-		LOC[0]  */
 PUSHLOCAL1,/*	-	-		LOC[1]  */
 PUSHLOCAL2,/*	-	-		LOC[2]  */
@@ -54,10 +53,8 @@ PUSHLOCAL4,/*	-	-		LOC[4]  */
 PUSHLOCAL5,/*	-	-		LOC[5]  */
 PUSHLOCAL6,/*	-	-		LOC[6]  */
 PUSHLOCAL7,/*	-	-		LOC[7]  */
-PUSHLOCAL8,/*	-	-		LOC[8]  */
-PUSHLOCAL9,/*	-	-		LOC[9]  */
-PUSHLOCAL,/*	b	-		LOC[b]  */
 
+GETGLOBAL,/*	b 	-		VAR[CNST[b]]  */
 GETGLOBAL0,/*	-	-		VAR[CNST[0]]  */
 GETGLOBAL1,/*	-	-		VAR[CNST[1]]  */
 GETGLOBAL2,/*	-	-		VAR[CNST[2]]  */
@@ -66,19 +63,19 @@ GETGLOBAL4,/*	-	-		VAR[CNST[4]]  */
 GETGLOBAL5,/*	-	-		VAR[CNST[5]]  */
 GETGLOBAL6,/*	-	-		VAR[CNST[6]]  */
 GETGLOBAL7,/*	-	-		VAR[CNST[7]]  */
-GETGLOBAL8,/*	-	-		VAR[CNST[8]]  */
-GETGLOBAL9,/*	-	-		VAR[CNST[9]]  */
-GETGLOBALB,/*	b 	-		VAR[CNST[b]]  */
-GETGLOBAL,/*	w	-		VAR[CNST[w]]  */
+GETGLOBALW,/*	w	-		VAR[CNST[w]]  */
 
 GETTABLE,/*	-	i t		t[i]  */
 
-PUSHSELFB,/*	b	t		t t[CNST[b]]  */
-PUSHSELF,/*	w	t		t t[CNST[w]]  */
+PUSHSELF,/*	b	t		t t[CNST[b]]  */
+PUSHSELFW,/*	w	t		t t[CNST[w]]  */
 
-CREATEARRAYB,/*	b	-		newarray(size = b)  */
-CREATEARRAY,/*	w	-		newarray(size = w)  */
+CREATEARRAY,/*	b	-		newarray(size = b)  */
+CREATEARRAY0,/*	-	-		newarray(size = 0)  */
+CREATEARRAY1,/*	-	-		newarray(size = 1)  */
+CREATEARRAYW,/*	w	-		newarray(size = w)  */
 
+SETLOCAL,/*	b	x		-		LOC[b]=x  */
 SETLOCAL0,/*	-	x		-		LOC[0]=x  */
 SETLOCAL1,/*	-	x		-		LOC[1]=x  */
 SETLOCAL2,/*	-	x		-		LOC[2]=x  */
@@ -87,19 +84,28 @@ SETLOCAL4,/*	-	x		-		LOC[4]=x  */
 SETLOCAL5,/*	-	x		-		LOC[5]=x  */
 SETLOCAL6,/*	-	x		-		LOC[6]=x  */
 SETLOCAL7,/*	-	x		-		LOC[7]=x  */
-SETLOCAL8,/*	-	x		-		LOC[8]=x  */
-SETLOCAL9,/*	-	x		-		LOC[9]=x  */
-SETLOCAL,/*	b	x		-		LOC[b]=x  */
 
-SETGLOBALB,/*	b	x		-		VAR[CNST[b]]=x  */
-SETGLOBAL,/*	w	x		-		VAR[CNST[w]]=x  */
+SETGLOBAL,/*	b	x		-		VAR[CNST[b]]=x  */
+SETGLOBAL0,/*	-	x		-		VAR[CNST[0]]=x  */
+SETGLOBAL1,/*	-	x		-		VAR[CNST[1]]=x  */
+SETGLOBAL2,/*	-	x		-		VAR[CNST[2]]=x  */
+SETGLOBAL3,/*	-	x		-		VAR[CNST[3]]=x  */
+SETGLOBAL4,/*	-	x		-		VAR[CNST[4]]=x  */
+SETGLOBAL5,/*	-	x		-		VAR[CNST[5]]=x  */
+SETGLOBAL6,/*	-	x		-		VAR[CNST[6]]=x  */
+SETGLOBAL7,/*	-	x		-		VAR[CNST[7]]=x  */
+SETGLOBALW,/*	w	x		-		VAR[CNST[w]]=x  */
 
 SETTABLE0,/*	-	v i t		-		t[i]=v  */
+
 SETTABLE,/*	b	v a_b...a_1 i t	a_b...a_1 i t	t[i]=v  */
 
-SETLIST0,/*	b	v_b...v_1 t	-		t[i]=v_i  */
 SETLIST,/*	b c	v_b...v_1 t	-		t[i+c*FPF]=v_i  */
-SETMAP,/*	b	v_b k_b ...v_1 k_1 t	t	t[k_i]=v_i  */
+SETLIST0,/*	b	v_b...v_1 t	-		t[i]=v_i  */
+SETLISTW,/*	w c	v_b...v_1 t	-		t[i+c*FPF]=v_i  */
+
+SETMAP,/*	b	v_b k_b ...v_0 k_0 t	t	t[k_i]=v_i  */
+SETMAP0,/*	-	v_0 k_0 t		t	t[k_0]=v_0  */
 
 EQOP,/*		-	y x		(x==y)? 1 : nil  */
 NEQOP,/*	-	y x		(x~=y)? 1 : nil  */
@@ -117,25 +123,34 @@ MINUSOP,/*	-	x		-x  */
 NOTOP,/*	-	x		(x==nil)? 1 : nil  */
 
 ONTJMP,/*	b	x		(x!=nil)? x : -	(x!=nil)? PC+=b  */
+ONTJMPW,/*	w	x		(x!=nil)? x : -	(x!=nil)? PC+=w  */
 ONFJMP,/*	b	x		(x==nil)? x : -	(x==nil)? PC+=b  */
-JMPB,/*		b	-		-		PC+=b  */
-JMP,/*		w	-		-		PC+=w  */
-IFFJMPB,/*	b	x		-		(x==nil)? PC+=b  */
-IFFJMP,/*	w	x		-		(x==nil)? PC+=w  */
-IFTUPJMPB,/*	b	x		-		(x!=nil)? PC-=b  */
-IFTUPJMP,/*	w	x		-		(x!=nil)? PC-=w  */
-IFFUPJMPB,/*	b	x		-		(x==nil)? PC-=b  */
-IFFUPJMP,/*	w	x		-		(x==nil)? PC-=w  */
+ONFJMPW,/*	w	x		(x==nil)? x : -	(x==nil)? PC+=w  */
+JMP,/*		b	-		-		PC+=b  */
+JMPW,/*		w	-		-		PC+=w  */
+IFFJMP,/*	b	x		-		(x==nil)? PC+=b  */
+IFFJMPW,/*	w	x		-		(x==nil)? PC+=w  */
+IFTUPJMP,/*	b	x		-		(x!=nil)? PC-=b  */
+IFTUPJMPW,/*	w	x		-		(x!=nil)? PC-=w  */
+IFFUPJMP,/*	b	x		-		(x==nil)? PC-=b  */
+IFFUPJMPW,/*	w	x		-		(x==nil)? PC-=w  */
 
-CLOSUREB,/*	b	v_1...v_n	c(CNST[b]) */
-CLOSURE,/*	w	v_1...v_n	c(CNST[w]) */
+CLOSURE,/*	b	v_1...v_n	c(CNST[b]) */
+CLOSUREW,/*	w	v_1...v_n	c(CNST[w]) */
+
+CALLFUNC,/*	b c	v_c...v_1 f	r_b...r_1	f(v1,...,v_c)  */
+CALLFUNC0,/*	b	v_b...v_1 f	-		f(v1,...,v_b)  */
+CALLFUNC1,/*	b	v_b...v_1 f	r_1		f(v1,...,v_b)  */
 
-CALLFUNC,/*	b c	v_b...v_1 f	r_c...r_1	f(v1,...,v_b)  */
 RETCODE,/*	b	-		-  */
-SETLINE,/*	w	-		-		LINE=w  */
-POP1,/*		-	-		-		TOP-=1  */
-POP2,/*		-	-		-		TOP-=2  */
-POPS,/*		b	-		-		TOP-=b  */
+
+SETLINE,/*	b	-		-		LINE=b  */
+SETLINEW,/*	w	-		-		LINE=w  */
+
+POP,/*		b	-		-		TOP-=(b+1)  */
+POP0,/*		-	-		-		TOP-=1  */
+POP1,/*		-	-		-		TOP-=2  */
+
 ARGS,/*		b	-		-		TOP=BASE+b  */
 VARARGS/*	b	v_x...v_1	{v_1...v_x;n=x}	TOP=BASE+b+1  */
 } OpCode;
diff --git a/lua.stx b/lua.stx
index 28df6f36..fb85d18f 100644
--- a/lua.stx
+++ b/lua.stx
@@ -1,6 +1,6 @@
 %{
 /*
-** $Id: lua.stx,v 1.7 1997/10/01 20:05:34 roberto Exp roberto $
+** $Id: lua.stx,v 1.8 1997/10/06 14:51:11 roberto Exp roberto $
 ** Syntax analizer and code generator
 ** See Copyright Notice in lua.h
 */
@@ -23,9 +23,6 @@
 
 /* to avoid warnings generated by yacc */
 int luaY_parse (void);
-#define malloc luaM_malloc
-#define realloc luaM_realloc
-#define free luaM_free
 
 
 /* size of a "normal" jump instruction: OpCode + 1 byte */
@@ -118,23 +115,6 @@ static void code_byte (Byte c)
 }
 
 
-static void code_word_at (int pc, int n)
-{
-  if (n > MAX_WORD)
-    luaY_error("construction too big; unable to compile");
-  currState->f->code[pc] = n&0xFF;
-  currState->f->code[pc+1] = n>>8;
-}
-
-
-static void code_word (int n)
-{
-  check_pc(2);
-  currState->pc += 2;
-  code_word_at(currState->pc-2, n);
-}
-
-
 static void deltastack (int delta)
 {
   currState->stacksize += delta;
@@ -146,41 +126,55 @@ static void deltastack (int delta)
 }
 
 
+static int code_oparg_at (int pc, OpCode op, int builtin, int arg, int delta)
+{
+  deltastack(delta);
+  if (arg < builtin) {
+    currState->f->code[pc] = op+1+arg;
+    return 1;
+  }
+  else if (arg <= 255) {
+    currState->f->code[pc] = op;
+    currState->f->code[pc+1] = arg;
+    return 2;
+  }
+  else if (arg <= MAX_WORD) {
+    currState->f->code[pc] = op+1+builtin;
+    currState->f->code[pc+1] = arg&0xFF;
+    currState->f->code[pc+2] = arg>>8;
+    return 3;
+  }
+  else luaY_error("construction too big - unable to compile");
+  return 0;   /* to avoid warnings */
+}
+
+
+static int fix_opcode (int pc, OpCode op, int builtin, int arg)
+{
+  if (arg < builtin) {  /* close space */
+    movecode_down(pc+1, pc+2, currState->pc-(pc+2));
+    currState->pc--;
+  }
+  else if (arg > 255) {  /* open space */
+    check_pc(1);
+    movecode_up(pc+1, pc, currState->pc-pc);
+    currState->pc++;
+  }
+  return code_oparg_at(pc, op, builtin, arg, 0) - 2;
+}
+
+
+static void code_oparg (OpCode op, int builtin, int arg, int delta)
+{
+  check_pc(3);  /* maximum code size */
+  currState->pc += code_oparg_at(currState->pc, op, builtin, arg, delta);
+}
+
+
 static void code_opcode (OpCode op, int delta)
 {
-  code_byte(op);
   deltastack(delta);
-}
-
-
-static void code_opb (OpCode opbyte, int arg, int delta)
-{
-  code_opcode(opbyte, delta);
-  code_byte(arg);
-}
-
-static void code_opw (OpCode opbyte, int arg, int delta)
-{
-  code_opcode(opbyte, delta);
-  code_word(arg);
-}
-
-
-static void code_opborw (OpCode opbyte, int arg, int delta)
-{
-  if (arg <= 255)
-    code_opb(opbyte, arg, delta);
-  else
-    code_opw(opbyte+1, arg, delta);
-}
-
-
-static void code_oparg (OpCode firstop, OpCode opbyte, int arg, int delta)
-{
-  if (firstop+arg < opbyte)
-     code_opcode(firstop+arg, delta);
-  else
-    code_opborw(opbyte, arg, delta);
+  code_byte(op);
 }
 
 
@@ -193,7 +187,10 @@ static void code_pop (OpCode op)
 #define code_binop(op)	code_pop(op)
 
 
-#define code_neutralop(op)	code_byte(op)
+static void code_neutralop (OpCode op)
+{
+  code_opcode(op, 0);
+}
 
 /* unary operations get 1 argument and leave one, so they are neutral */
 #define code_unop(op)	code_neutralop(op)
@@ -201,7 +198,7 @@ static void code_pop (OpCode op)
 
 static void code_constant (int c)
 {
-  code_oparg(PUSHCONSTANT0, PUSHCONSTANTB, c, 1);
+  code_oparg(PUSHCONSTANT, 8, c, 1);
 }
 
 
@@ -237,7 +234,7 @@ static void code_string (TaggedString *s)
 }
 
 
-#define LIM 13
+#define LIM 20
 static int real_constant (real r)
 {
   /* check whether 'r' has appeared within the last LIM entries */
@@ -261,7 +258,7 @@ static void code_number (real f)
 {
   Word i;
   if (f >= 0 && f <= (real)MAX_WORD && (real)(i=(Word)f) == f)
-    code_oparg(PUSH0, PUSHBYTE, i, 1);  /* f has an (short) integer value */
+    code_oparg(PUSHNUMBER, 3, i, 1);  /* f has an (short) integer value */
   else
     code_constant(real_constant(f));
 }
@@ -270,18 +267,13 @@ static void code_number (real f)
 static void flush_record (int n)
 {
   if (n > 0)
-    code_opb(SETMAP, n, -2*n);
+    code_oparg(SETMAP, 1, n-1, -2*n);
 }
 
 static void flush_list (int m, int n)
 {
   if (n == 0) return;
-  if (m == 0)
-    code_opcode(SETLIST0, -n);
-  else if (m < 255)
-    code_opb(SETLIST, m, -n);
-  else
-    luaY_error("list constructor too long");
+  code_oparg(SETLIST, 1, m, -n);
   code_byte(n);
 }
 
@@ -375,7 +367,7 @@ static void pushupvalue (TaggedString *n)
   if (aux_localname(n, currState) >= 0)
     luaY_syntaxerror("cannot access an upvalue in current scope", n->str);
   i = indexupvalue(n);
-  code_oparg(PUSHUPVALUE0, PUSHUPVALUE, i, 1);
+  code_oparg(PUSHUPVALUE, 2, i, 1);
 }
 
 
@@ -383,7 +375,7 @@ void luaY_codedebugline (int line)
 {
   static int lastline = 0;
   if (lua_debug && line != lastline) {
-    code_opw(SETLINE, line, 0);
+    code_oparg(SETLINE, 0, line, 0);
     lastline = line;
   }
 }
@@ -392,22 +384,25 @@ void luaY_codedebugline (int line)
 static void adjuststack (int n)
 {
   if (n > 0)
-    code_oparg(POP1-1, POPS, n, -n);  /* POP1-1 = POP0 */
+    code_oparg(POP, 2, n-1, -n);
   else if (n < 0)
-    code_oparg(PUSHNIL-1, PUSHNILS, -n, -n);  /* PUSHNIL1-1 = PUSHNIL0 */
+    code_oparg(PUSHNIL, 1, (-n)-1, -n);
 }
 
 
-static long adjust_functioncall (long exp, int i)
+static long adjust_functioncall (long exp, int nresults)
 {
   if (exp <= 0)
     return -exp; /* exp is -list length */
   else {
     int temp = currState->f->code[exp];
-    currState->f->code[exp] = i;
-    if (i != MULT_RET)
-      deltastack(i);
-    return temp+i;
+    int nparams = currState->f->code[exp-1];
+    exp += fix_opcode(exp-2, CALLFUNC, 2, nresults);
+    currState->f->code[exp] = nparams;
+    if (nresults != MULT_RET)
+      deltastack(nresults);
+    deltastack(-(nparams+1));
+    return temp+nresults;
   }
 }
 
@@ -430,9 +425,9 @@ static void adjust_mult_assign (int vars, long exps)
 static void code_args (int dots)
 {
   if (!dots)
-    code_opb(ARGS, currState->nlocalvar, currState->nlocalvar);
+    code_oparg(ARGS, 0, currState->nlocalvar, currState->nlocalvar);
   else {
-    code_opb(VARARGS, currState->nlocalvar, currState->nlocalvar+1);
+    code_oparg(VARARGS, 0, currState->nlocalvar, currState->nlocalvar+1);
     add_localvar(luaS_new("arg"));
   }
 }
@@ -441,9 +436,9 @@ static void code_args (int dots)
 static void lua_pushvar (vardesc number)
 {
   if (number > 0)  /* global var */
-    code_oparg(GETGLOBAL0, GETGLOBALB, number-1, 1);
+    code_oparg(GETGLOBAL, 8, number-1, 1);
   else if (number < 0)  /* local var */
-    code_oparg(PUSHLOCAL0, PUSHLOCAL, (-number)-1, 1);
+    code_oparg(PUSHLOCAL, 8, (-number)-1, 1);
   else
     code_pop(GETTABLE);
 }
@@ -454,9 +449,9 @@ static void storevar (vardesc number)
   if (number == 0)  /* indexed var */
     code_opcode(SETTABLE0, -3);
   else if (number > 0)  /* global var */
-    code_opborw(SETGLOBALB, number-1, -1);
+    code_oparg(SETGLOBAL, 8, number-1, -1);
   else  /* number < 0 - local var */
-    code_oparg(SETLOCAL0, SETLOCAL, (-number)-1, -1);
+    code_oparg(SETLOCAL, 8, (-number)-1, -1);
 }
 
 
@@ -469,35 +464,16 @@ static int lua_codestore (int i, int left)
     return left;
   }
   else {  /* indexed var with values in between*/
-    code_pop(SETTABLE);
-    code_byte(left+i);  /* number of elements between table/index and value */
+    code_oparg(SETTABLE, 0, left+i, -1);
     return left+2;  /* table/index are not poped, since they are not on top */
   }
 }
 
 
-static int fix_opcode (int pc, OpCode op, int n)
-{
-  if (n <= 255) {
-    currState->f->code[pc] = op;
-    currState->f->code[pc+1] = n;
-    return 0;
-  }
-  else {
-    check_pc(1);  /* open space */
-    movecode_up(pc+1, pc, currState->pc-pc);
-    currState->pc++;
-    currState->f->code[pc] = op+1;  /* opcode must be word variant */
-    code_word_at(pc+1, n);
-    return 1;
-  }
-}
-
-
 static int fix_jump (int pc, OpCode op, int n)
 {
   /* jump is relative to position following jump instruction */
-  return fix_opcode(pc, op, n-(pc+JMPSIZE));
+  return fix_opcode(pc, op, 0, n-(pc+JMPSIZE));
 }
 
 
@@ -505,7 +481,7 @@ static void fix_upjmp (OpCode op, int pos)
 {
   int delta = currState->pc+JMPSIZE - pos;  /* jump is relative */
   if (delta > 255) delta++;
-  code_opborw(op, delta, 0);
+  code_oparg(op, 0, delta, 0);
 }
 
 
@@ -517,25 +493,20 @@ static void codeIf (int thenAdd, int elseAdd)
     elseinit = currState->pc;
   }
   else
-    elseinit += fix_jump(elseAdd, JMPB, currState->pc);
-  fix_jump(thenAdd, IFFJMPB, elseinit);
+    elseinit += fix_jump(elseAdd, JMP, currState->pc);
+  fix_jump(thenAdd, IFFJMP, elseinit);
 }
 
 
-static void code_shortcircuit (OpCode op, int pos)
+static void code_shortcircuit (int pc, OpCode op)
 {
-  int dist = currState->pc - (pos+JMPSIZE);
-  if (dist > 255)
-    luaY_error("and/or expression too long");
-  currState->f->code[pos] = op;
-  currState->f->code[pos+1] = dist;
+  fix_jump(pc, op, currState->pc);
 }
 
 
 static void codereturn (void)
 {
-  code_neutralop(RETCODE);
-  code_byte(currState->nlocalvar);
+  code_oparg(RETCODE, 0, currState->nlocalvar, 0);
   currState->stacksize = currState->nlocalvar;
 }
 
@@ -549,7 +520,7 @@ static void func_onstack (TProtoFunc *f)
   currState->f->consts[c].value.tf = (currState+1)->f;
   for (i=0; i<nupvalues; i++)
     lua_pushvar((currState+1)->upvalues[i]);
-  code_opborw(CLOSUREB, c, 1-nupvalues);
+  code_oparg(CLOSURE, 0, c, 1-nupvalues);
 }
 
 
@@ -585,7 +556,6 @@ static void init_func (void)
   currState->f->lineDefined = luaX_linenumber;
 }
 
-
 static TProtoFunc *close_func (void)
 {
   TProtoFunc *f = currState->f;
@@ -687,13 +657,13 @@ stat   : IF cond THEN block SaveWord elsepart END
 	 memcpy(&currState->f->code[currState->pc],
                 &currState->f->code[$2], expsize);
 	 movecode_down($2, $3, currState->pc-$2);
-	 newpos += fix_jump($2, JMPB, currState->pc-expsize);
-	 fix_upjmp(IFTUPJMPB, newpos);
+	 newpos += fix_jump($2, JMP, currState->pc-expsize);
+	 fix_upjmp(IFTUPJMP, newpos);
        }}
 
        | REPEAT GetPC block UNTIL expr1
        {
-	 fix_upjmp(IFFUPJMPB, $2);
+	 fix_upjmp(IFFUPJMP, $2);
 	 deltastack(-1);  /* pops condition */
        }
 
@@ -706,7 +676,7 @@ stat   : IF cond THEN block SaveWord elsepart END
 	    left = lua_codestore(i, left);
           adjuststack(left);  /* remove eventual 'garbage' left on stack */
        }}
-       | functioncall
+       | functioncall { adjust_functioncall($1, 0); }
        | LOCAL localdeclist decinit
        {
          currState->nlocalvar += $2;
@@ -757,7 +727,11 @@ ret	: /* empty */
 GetPC	: /* empty */ { $$ = currState->pc; }
 	;
 
-SaveWord : GetPC { $$ = $1; code_word(0);  /* open space */ }
+SaveWord : /* empty */
+	{ $$ = currState->pc;
+	  check_pc(JMPSIZE);
+	  currState->pc += JMPSIZE;  /* open space */
+	}
 	 ;
 
 SaveWordPop : SaveWord { $$ = $1; deltastack(-1);  /* pop condition */ }
@@ -787,33 +761,33 @@ expr :  '(' expr ')'     { $$ = $2; }
      |	expr1 CONC expr1 { code_binop(CONCOP);  $$ = 0; }
      |	'-' expr1 %prec UNARY	{ code_unop(MINUSOP); $$ = 0;}
      |	NOT expr1	 { code_unop(NOTOP);  $$ = 0;}
-     | table { $$ = 0; }
+     |  table 		 { $$ = 0; }
      |  varexp           { $$ = 0;}
      |  NUMBER           { code_number($1); $$ = 0; }
      |  STRING           { code_string($1); $$ = 0; }
-     |	NIL		 {code_opcode(PUSHNIL, 1); $$ = 0; }
+     |	NIL		 { adjuststack(-1); $$ = 0; }
      |  functioncall     { $$ = $1; }
-     | FUNCTION { init_func(); } body { func_onstack($3); $$ = 0; }
-     |	expr1 AND SaveWordPop expr1 { code_shortcircuit(ONFJMP, $3); $$ = 0; }
-     |	expr1 OR SaveWordPop expr1 { code_shortcircuit(ONTJMP, $3); $$ = 0; }
+     |  FUNCTION { init_func(); } body { func_onstack($3); $$ = 0; }
+     |	expr1 AND SaveWordPop expr1 { code_shortcircuit($3, ONFJMP); $$ = 0; }
+     |	expr1 OR SaveWordPop expr1 { code_shortcircuit($3, ONTJMP); $$ = 0; }
      ;
 
-table : '{' SaveWordPush fieldlist '}' { fix_opcode($2, CREATEARRAYB, $3); }
+table : '{' SaveWordPush fieldlist '}' { fix_opcode($2, CREATEARRAY, 2, $3); }
          ;
 
 functioncall : funcvalue funcParams
 	{
-	  code_opcode(CALLFUNC, -($1+$2+1));  /* ajdust counts results */
-	  code_byte($1+$2);
+	  code_byte(0);  /* save space for opcode */
+	  code_byte($1+$2);  /* number of parameters */
 	  $$ = currState->pc;
-	  code_byte(0);  /* may be adjusted by other rules */
+	  code_byte(0);  /* must be adjusted by other rules */
 	}
 	     ;
 
 funcvalue    : varexp { $$ = 0; }
 	     | varexp ':' NAME
 	     {
-               code_opborw(PUSHSELFB, string_constant($3, currState), 1);
+               code_oparg(PUSHSELF, 0, string_constant($3, currState), 1);
                $$ = 1;
 	     }
 	     ;
diff --git a/lvm.c b/lvm.c
index bc0c9dd8..91d923a4 100644
--- a/lvm.c
+++ b/lvm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.c,v 1.7 1997/10/01 20:05:34 roberto Exp roberto $
+** $Id: lvm.c,v 1.8 1997/10/06 14:51:11 roberto Exp roberto $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -284,25 +284,25 @@ StkId luaV_execute (Closure *cl, StkId base)
     int aux;
     switch ((OpCode)(aux = *pc++)) {
 
-      case PUSHNIL:
+      case PUSHNIL0:
         ttype(luaD_stack.top++) = LUA_T_NIL;
         break;
 
-      case PUSHNILS: {
-        int n = *pc++;
-        while (n--)
+      case PUSHNIL:
+        aux = *pc++;
+        do {
           ttype(luaD_stack.top++) = LUA_T_NIL;
+        } while (aux--);
         break;
-      }
 
-      case PUSHBYTE:
+      case PUSHNUMBER:
         aux = *pc++; goto pushnumber;
 
-      case PUSHWORD:
+      case PUSHNUMBERW:
         aux = next_word(pc); goto pushnumber;
 
-      case PUSH0: case PUSH1: case PUSH2:
-        aux -= PUSH0;
+      case PUSHNUMBER0: case PUSHNUMBER1: case PUSHNUMBER2:
+        aux -= PUSHNUMBER0;
       pushnumber:
         ttype(luaD_stack.top) = LUA_T_NUMBER;
         nvalue(luaD_stack.top) = aux;
@@ -312,25 +312,21 @@ StkId luaV_execute (Closure *cl, StkId base)
       case PUSHLOCAL:
         aux = *pc++; goto pushlocal;
 
-      case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2:
-      case PUSHLOCAL3: case PUSHLOCAL4: case PUSHLOCAL5:
-      case PUSHLOCAL6: case PUSHLOCAL7: case PUSHLOCAL8:
-      case PUSHLOCAL9:
+      case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2: case PUSHLOCAL3:
+      case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL6: case PUSHLOCAL7:
         aux -= PUSHLOCAL0;
       pushlocal:
         *luaD_stack.top++ = *((luaD_stack.stack+base) + aux);
         break;
 
-      case GETGLOBAL:
+      case GETGLOBALW:
         aux = next_word(pc); goto getglobal;
 
-      case GETGLOBALB:
+      case GETGLOBAL:
         aux = *pc++; goto getglobal;
 
-      case GETGLOBAL0: case GETGLOBAL1: case GETGLOBAL2:
-      case GETGLOBAL3: case GETGLOBAL4: case GETGLOBAL5:
-      case GETGLOBAL6: case GETGLOBAL7: case GETGLOBAL8:
-      case GETGLOBAL9:
+      case GETGLOBAL0: case GETGLOBAL1: case GETGLOBAL2: case GETGLOBAL3:
+      case GETGLOBAL4: case GETGLOBAL5: case GETGLOBAL6: case GETGLOBAL7:
         aux -= GETGLOBAL0;
       getglobal:
         luaV_getglobal(tsvalue(&consts[aux]));
@@ -340,10 +336,10 @@ StkId luaV_execute (Closure *cl, StkId base)
        luaV_gettable();
        break;
 
-      case PUSHSELF:
+      case PUSHSELFW:
         aux = next_word(pc); goto pushself;
 
-      case PUSHSELFB:
+      case PUSHSELF:
         aux = *pc++;
       pushself: {
         TObject receiver = *(luaD_stack.top-1);
@@ -353,16 +349,15 @@ StkId luaV_execute (Closure *cl, StkId base)
         break;
       }
 
-      case PUSHCONSTANT:
+      case PUSHCONSTANTW:
         aux = next_word(pc); goto pushconstant;
 
-      case PUSHCONSTANTB:
+      case PUSHCONSTANT:
         aux = *pc++; goto pushconstant;
 
       case PUSHCONSTANT0: case PUSHCONSTANT1: case PUSHCONSTANT2:
       case PUSHCONSTANT3: case PUSHCONSTANT4: case PUSHCONSTANT5:
-      case PUSHCONSTANT6: case PUSHCONSTANT7: case PUSHCONSTANT8:
-      case PUSHCONSTANT9:
+      case PUSHCONSTANT6: case PUSHCONSTANT7:
         aux -= PUSHCONSTANT0;
       pushconstant:
         *luaD_stack.top++ = consts[aux];
@@ -380,20 +375,22 @@ StkId luaV_execute (Closure *cl, StkId base)
       case SETLOCAL:
         aux = *pc++; goto setlocal;
 
-      case SETLOCAL0: case SETLOCAL1: case SETLOCAL2:
-      case SETLOCAL3: case SETLOCAL4: case SETLOCAL5:
-      case SETLOCAL6: case SETLOCAL7: case SETLOCAL8:
-      case SETLOCAL9:
+      case SETLOCAL0: case SETLOCAL1: case SETLOCAL2: case SETLOCAL3:
+      case SETLOCAL4: case SETLOCAL5: case SETLOCAL6: case SETLOCAL7:
         aux -= SETLOCAL0;
       setlocal:
         *((luaD_stack.stack+base) + aux) = *(--luaD_stack.top);
         break;
 
-      case SETGLOBAL:
+      case SETGLOBALW:
         aux = next_word(pc); goto setglobal;
 
-      case SETGLOBALB:
-        aux = *pc++;
+      case SETGLOBAL:
+        aux = *pc++; goto setglobal;
+
+      case SETGLOBAL0: case SETGLOBAL1: case SETGLOBAL2: case SETGLOBAL3:
+      case SETGLOBAL4: case SETGLOBAL5: case SETGLOBAL6: case SETGLOBAL7:
+        aux -= SETGLOBAL0;
       setglobal:
         luaV_setglobal(tsvalue(&consts[aux]));
         break;
@@ -406,6 +403,9 @@ StkId luaV_execute (Closure *cl, StkId base)
         luaV_settable(luaD_stack.top-3-(*pc++), 2);
         break;
 
+      case SETLISTW:
+        aux = next_word(pc); aux *= LFIELDS_PER_FLUSH; goto setlist;
+
       case SETLIST:
         aux = *(pc++) * LFIELDS_PER_FLUSH; goto setlist;
 
@@ -423,23 +423,27 @@ StkId luaV_execute (Closure *cl, StkId base)
         break;
       }
 
-      case SETMAP: {
-        int n = *(pc++);
-        TObject *arr = luaD_stack.top-(2*n)-1;
-        while (n--) {
+      case SETMAP0:
+        aux = 0; goto setmap;
+
+      case SETMAP:
+        aux = *(pc++);
+      setmap: {
+        TObject *arr = luaD_stack.top-(2*aux)-3;
+        do {
           *(luaH_set (avalue(arr), luaD_stack.top-2)) = *(luaD_stack.top-1);
           luaD_stack.top-=2;
-        }
+        } while (aux--);
         break;
       }
 
-      case POPS:
+      case POP:
         aux = *pc++; goto pop;
 
-      case POP1: case POP2:
-        aux -= (POP1-1);
+      case POP0: case POP1:
+        aux -= POP0;
       pop:
-        luaD_stack.top -= aux;
+        luaD_stack.top -= (aux+1);
         break;
 
       case ARGS:
@@ -451,10 +455,13 @@ StkId luaV_execute (Closure *cl, StkId base)
         adjust_varargs(base + *(pc++));
         break;
 
-      case CREATEARRAY:
+      case CREATEARRAYW:
         aux = next_word(pc); goto createarray;
 
-      case CREATEARRAYB:
+      case CREATEARRAY0: case CREATEARRAY1:
+        aux -= CREATEARRAY0; goto createarray;
+
+      case CREATEARRAY:
         aux = *pc++;
       createarray:
         luaC_checkGC();
@@ -569,58 +576,66 @@ StkId luaV_execute (Closure *cl, StkId base)
         nvalue(luaD_stack.top-1) = 1;
         break;
 
+      case ONTJMPW:
+        aux = next_word(pc); goto ontjmp;
+
       case ONTJMP:
         aux = *pc++;
+      ontjmp:
         if (ttype(luaD_stack.top-1) != LUA_T_NIL) pc += aux;
         else luaD_stack.top--;
         break;
 
+      case ONFJMPW:
+        aux = next_word(pc); goto onfjmp;
+
       case ONFJMP:
         aux = *pc++;
+      onfjmp:
         if (ttype(luaD_stack.top-1) == LUA_T_NIL) pc += aux;
         else luaD_stack.top--;
         break;
 
-      case JMP:
+      case JMPW:
         aux = next_word(pc); goto jmp;
 
-      case JMPB:
+      case JMP:
         aux = *pc++;
       jmp:
         pc += aux;
         break;
 
-      case IFFJMP:
+      case IFFJMPW:
         aux = next_word(pc); goto iffjmp;
 
-      case IFFJMPB:
+      case IFFJMP:
         aux = *pc++;
       iffjmp:
         if (ttype(--luaD_stack.top) == LUA_T_NIL) pc += aux;
         break;
 
-      case IFTUPJMP:
+      case IFTUPJMPW:
         aux = next_word(pc); goto iftupjmp;
 
-      case IFTUPJMPB:
+      case IFTUPJMP:
         aux = *pc++;
       iftupjmp:
         if (ttype(--luaD_stack.top) != LUA_T_NIL) pc -= aux;
         break;
 
-      case IFFUPJMP:
+      case IFFUPJMPW:
         aux = next_word(pc); goto iffupjmp;
 
-      case IFFUPJMPB:
+      case IFFUPJMP:
         aux = *pc++;
       iffupjmp:
         if (ttype(--luaD_stack.top) == LUA_T_NIL) pc -= aux;
         break;
 
-      case CLOSURE:
+      case CLOSUREW:
         aux = next_word(pc); goto closure;
 
-      case CLOSUREB:
+      case CLOSURE:
         aux = *pc++;
       closure:
         *luaD_stack.top++ = consts[aux];
@@ -628,9 +643,14 @@ StkId luaV_execute (Closure *cl, StkId base)
         luaC_checkGC();
         break;
 
-      case CALLFUNC: {
+      case CALLFUNC:
+        aux = *pc++; goto callfunc;
+
+      case CALLFUNC0: case CALLFUNC1:
+        aux -= CALLFUNC0;
+      callfunc: {
         StkId newBase = (luaD_stack.top-luaD_stack.stack)-(*pc++);
-        luaD_call(newBase, *pc++);
+        luaD_call(newBase, aux);
         break;
       }
 
@@ -642,19 +662,22 @@ StkId luaV_execute (Closure *cl, StkId base)
           luaD_callHook(base, LUA_T_MARK, 1);
         return (base + ((aux==RETCODE) ? *pc : 0));
 
-      case SETLINE: {
-        int line = next_word(pc);
+      case SETLINEW:
+        aux = next_word(pc); goto setline;
+
+      case SETLINE:
+        aux = *pc++;
+      setline:
         if ((luaD_stack.stack+base-1)->ttype != LUA_T_LINE) {
           /* open space for LINE value */
           luaD_openstack((luaD_stack.top-luaD_stack.stack)-base);
           base++;
           (luaD_stack.stack+base-1)->ttype = LUA_T_LINE;
         }
-        (luaD_stack.stack+base-1)->value.i = line;
+        (luaD_stack.stack+base-1)->value.i = aux;
         if (lua_linehook)
-          luaD_lineHook(line);
+          luaD_lineHook(aux);
         break;
-      }
 
 #ifdef DEBUG
       default: