diff --git a/lbuiltin.c b/lbuiltin.c
index f7ba5839..19524a25 100644
--- a/lbuiltin.c
+++ b/lbuiltin.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lbuiltin.c,v 1.115 2000/06/08 17:48:31 roberto Exp roberto $
+** $Id: lbuiltin.c,v 1.116 2000/06/12 13:52:05 roberto Exp roberto $
 ** Built-in functions
 ** See Copyright Notice in lua.h
 */
@@ -372,7 +372,7 @@ void luaB_tostring (lua_State *L) {
       lua_pushstring(L, "nil");
       return;
     default:
-      LUA_INTERNALERROR(L, "invalid type");
+      LUA_INTERNALERROR("invalid type");
   }
   lua_pushstring(L, buff);
 }
diff --git a/lcode.c b/lcode.c
index 4163c66d..c80ea0da 100644
--- a/lcode.c
+++ b/lcode.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.c,v 1.39 2000/06/26 19:28:31 roberto Exp roberto $
+** $Id: lcode.c,v 1.40 2000/06/28 20:20:36 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -191,7 +191,7 @@ void luaK_storevar (LexState *ls, const expdesc *var) {
       luaK_code2(fs, OP_SETTABLE, 3, 3);
       break;
     default:
-      LUA_INTERNALERROR(ls->L, "invalid var kind to store");
+      LUA_INTERNALERROR("invalid var kind to store");
   }
 }
 
@@ -207,7 +207,7 @@ static OpCode invertjump (OpCode op) {
     case OP_JMPT: case OP_JMPONT:  return OP_JMPF;
     case OP_JMPF: case OP_JMPONF:  return OP_JMPT;
     default:
-      LUA_INTERNALERROR(NULL, "invalid jump instruction");
+      LUA_INTERNALERROR("invalid jump instruction");
       return OP_END;  /* to avoid warnings */
   }
 }
@@ -282,7 +282,7 @@ static void luaK_testgo (FuncState *fs, expdesc *v, int invert, OpCode jump) {
   discharge1(fs, v);
   prevpos = fs->pc-1;
   previous = &fs->f->code[prevpos];
-  LUA_ASSERT(L, *previous==previous_instruction(fs), "no jump allowed here");
+  LUA_ASSERT(*previous==previous_instruction(fs), "no jump allowed here");
   if (!ISJUMP(GET_OPCODE(*previous)))
     prevpos = luaK_code1(fs, jump, NO_JUMP);
   else {  /* last instruction is already a jump */
@@ -382,13 +382,13 @@ void luaK_infix (LexState *ls, int op, expdesc *v) {
 void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) {
   FuncState *fs = ls->fs;
   if (op == TK_AND) {
-    LUA_ASSERT(ls->L, v1->u.l.t == NO_JUMP, "list must be closed");
+    LUA_ASSERT(v1->u.l.t == NO_JUMP, "list must be closed");
     discharge1(fs, v2);
     v1->u.l.t = v2->u.l.t;
     luaK_concat(fs, &v1->u.l.f, v2->u.l.f);
   }
   else if (op == TK_OR) {
-    LUA_ASSERT(ls->L, v1->u.l.f == NO_JUMP, "list must be closed");
+    LUA_ASSERT(v1->u.l.f == NO_JUMP, "list must be closed");
     discharge1(fs, v2);
     v1->u.l.f = v2->u.l.f;
     luaK_concat(fs, &v1->u.l.t, v2->u.l.t);
@@ -598,11 +598,11 @@ int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2) {
     case OP_GETINDEXED:
     case OP_TAILCALL:
     case OP_ADDI: {
-      LUA_INTERNALERROR(L, "instruction used only for optimizations");
+      LUA_INTERNALERROR("instruction used only for optimizations");
       break;
     }
     default: {
-      LUA_ASSERT(L, delta != VD, "invalid delta");
+      LUA_ASSERT(delta != VD, "invalid delta");
       break;
     }
   }
diff --git a/ldebug.c b/ldebug.c
index 6ab85434..00f8e94c 100644
--- a/ldebug.c
+++ b/ldebug.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.c,v 1.25 2000/06/28 20:20:36 roberto Exp roberto $
+** $Id: ldebug.c,v 1.26 2000/06/30 14:29:35 roberto Exp roberto $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
@@ -101,7 +101,7 @@ static int lua_nups (StkId f) {
 
 static int lua_currentpc (StkId f) {
   CallInfo *ci = infovalue(f);
-  LUA_ASSERT(L, ttype(f) == TAG_LMARK, "function has no pc");
+  LUA_ASSERT(ttype(f) == TAG_LMARK, "function has no pc");
   return (*ci->pc - 1) - ci->func->f.l->code;
 }
 
@@ -165,7 +165,7 @@ static void lua_funcinfo (lua_Debug *ar, StkId func) {
       ar->what = "C";
       break;
     default:
-      LUA_INTERNALERROR(L, "invalid `func' value");
+      LUA_INTERNALERROR("invalid `func' value");
   }
   if (ar->linedefined == 0)
     ar->what = "main";
@@ -245,24 +245,24 @@ static Instruction luaG_symbexec (const Proto *pt, int lastpc, int stackpos) {
     top++;  /* `arg' */
   while (pc < lastpc) {
     const Instruction i = code[pc++];
-    LUA_ASSERT(NULL, top <= pt->maxstacksize, "wrong stack");
+    LUA_ASSERT(top <= pt->maxstacksize, "wrong stack");
     switch (GET_OPCODE(i)) {
       case OP_RETURN: {
-        LUA_ASSERT(NULL, top >= GETARG_U(i), "wrong stack");
+        LUA_ASSERT(top >= GETARG_U(i), "wrong stack");
         top = GETARG_U(i);
         break;
       }
       case OP_CALL: {
         int nresults = GETARG_B(i);
         if (nresults == MULT_RET) nresults = 1;
-        LUA_ASSERT(NULL, top >= GETARG_A(i), "wrong stack");
+        LUA_ASSERT(top >= GETARG_A(i), "wrong stack");
         top = GETARG_A(i);
         while (nresults--)
           stack[top++] = pc-1;
         break;
       }
       case OP_TAILCALL: {
-        LUA_ASSERT(NULL, top >= GETARG_A(i), "wrong stack");
+        LUA_ASSERT(top >= GETARG_A(i), "wrong stack");
         top = GETARG_B(i);
         break;
       }
@@ -311,10 +311,10 @@ static Instruction luaG_symbexec (const Proto *pt, int lastpc, int stackpos) {
       }
       default: {
         int n;
-        LUA_ASSERT(NULL, luaK_opproperties[GET_OPCODE(i)].push != VD,
+        LUA_ASSERT(luaK_opproperties[GET_OPCODE(i)].push != VD,
                    "invalid opcode for default");
         top -= luaK_opproperties[GET_OPCODE(i)].pop;
-        LUA_ASSERT(NULL, top >= 0, "wrong stack");
+        LUA_ASSERT(top >= 0, "wrong stack");
         for (n=0; n<luaK_opproperties[GET_OPCODE(i)].push; n++)
           stack[top++] = pc-1;
       }
diff --git a/lgc.c b/lgc.c
index 3bcfd1b7..7bdc5790 100644
--- a/lgc.c
+++ b/lgc.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.c,v 1.57 2000/06/12 13:52:05 roberto Exp roberto $
+** $Id: lgc.c,v 1.58 2000/06/26 19:28:31 roberto Exp roberto $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -206,7 +206,7 @@ static void collectudatatab (lua_State *L, int all) {
     TString **p = &L->udt.hash[i];
     TString *next;
     while ((next = *p) != NULL) {
-      LUA_ASSERT(L, next->marked <= 1, "udata cannot be fixed");
+      LUA_ASSERT(next->marked <= 1, "udata cannot be fixed");
       if (next->marked > all) {  /* preserve? */
         next->marked = 0;
         p = &next->nexthash;
diff --git a/lobject.c b/lobject.c
index 7d26a981..4c2f427d 100644
--- a/lobject.c
+++ b/lobject.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.c,v 1.41 2000/06/12 13:52:05 roberto Exp roberto $
+** $Id: lobject.c,v 1.42 2000/06/26 19:28:31 roberto Exp roberto $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -45,7 +45,7 @@ int luaO_equalObj (const TObject *t1, const TObject *t2) {
     case TAG_CCLOSURE: case TAG_LCLOSURE:
       return clvalue(t1) == clvalue(t2);
     default:
-      LUA_ASSERT(L, ttype(t1) == TAG_NIL, "invalid type");
+      LUA_ASSERT(ttype(t1) == TAG_NIL, "invalid type");
       return 1; /* TAG_NIL */
   }
 }
diff --git a/lobject.h b/lobject.h
index 01235ffa..2185eac4 100644
--- a/lobject.h
+++ b/lobject.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.h,v 1.68 2000/06/26 19:28:31 roberto Exp roberto $
+** $Id: lobject.h,v 1.69 2000/06/28 20:20:36 roberto Exp roberto $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -15,11 +15,11 @@
 #ifdef DEBUG
 #undef NDEBUG
 #include <assert.h>
-#define LUA_INTERNALERROR(L,s)	assert(((void)s,0))
-#define LUA_ASSERT(L,c,s)	assert(((void)s,(c)))
+#define LUA_INTERNALERROR(s)	assert(((void)s,0))
+#define LUA_ASSERT(c,s)		assert(((void)s,(c)))
 #else
-#define LUA_INTERNALERROR(L,s)	/* empty */
-#define LUA_ASSERT(L,c,s)	/* empty */
+#define LUA_INTERNALERROR(s)	/* empty */
+#define LUA_ASSERT(c,s)		/* empty */
 #endif
 
 
diff --git a/lparser.c b/lparser.c
index 9ebd01be..74dd8dc1 100644
--- a/lparser.c
+++ b/lparser.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.c,v 1.100 2000/06/28 17:06:07 roberto Exp roberto $
+** $Id: lparser.c,v 1.101 2000/06/28 20:20:36 roberto Exp roberto $
 ** LL(1) Parser and code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -67,7 +67,7 @@ static void next (LexState *ls) {
 
 
 static void lookahead (LexState *ls) {
-  LUA_ASSERT(ls->L, ls->lookahead.token == TK_EOS, "two look-aheads");
+  LUA_ASSERT(ls->lookahead.token == TK_EOS, "two look-aheads");
   ls->lookahead.token = luaX_lex(ls);
 }
 
@@ -295,7 +295,7 @@ static void enterbreak (FuncState *fs, Breaklabel *bl) {
 
 static void leavebreak (FuncState *fs, Breaklabel *bl) {
   fs->bl = bl->previous;
-  LUA_ASSERT(fs->L, bl->stacklevel == fs->stacklevel, "wrong levels");
+  LUA_ASSERT(bl->stacklevel == fs->stacklevel, "wrong levels");
   luaK_patchlist(fs, bl->breaklist, luaK_getlabel(fs));
 }
 
@@ -349,7 +349,7 @@ static void close_func (LexState *ls) {
   luaI_registerlocalvar(ls, NULL, -1);  /* flag end of vector */
   luaM_reallocvector(L, f->locvars, fs->nvars, LocVar);
   ls->fs = fs->prev;
-  LUA_ASSERT(L, fs->bl == NULL, "wrong list end");
+  LUA_ASSERT(fs->bl == NULL, "wrong list end");
 }
 
 
@@ -363,8 +363,8 @@ Proto *luaY_parser (lua_State *L, ZIO *z) {
   chunk(&lexstate);
   check_condition(&lexstate, (lexstate.t.token == TK_EOS), "<eof> expected");
   close_func(&lexstate);
-  LUA_ASSERT(L, funcstate.prev == NULL, "wrong list end");
-  LUA_ASSERT(L, funcstate.nupvalues == 0, "no upvalues in main");
+  LUA_ASSERT(funcstate.prev == NULL, "wrong list end");
+  LUA_ASSERT(funcstate.nupvalues == 0, "no upvalues in main");
   return funcstate.f;
 }
 
@@ -1109,7 +1109,7 @@ static void chunk (LexState *ls) {
   while (!islast && !block_follow(ls->t.token)) {
     islast = stat(ls);
     optional(ls, ';');
-    LUA_ASSERT(ls->L, ls->fs->stacklevel == ls->fs->nlocalvar,
+    LUA_ASSERT(ls->fs->stacklevel == ls->fs->nlocalvar,
                "stack size != # local vars");
   }
 }
diff --git a/lref.c b/lref.c
index 97072843..cf355d51 100644
--- a/lref.c
+++ b/lref.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lref.c,v 1.13 2000/06/08 17:48:31 roberto Exp roberto $
+** $Id: lref.c,v 1.14 2000/06/12 13:52:05 roberto Exp roberto $
 ** reference mechanism
 ** See Copyright Notice in lua.h
 */
@@ -106,12 +106,12 @@ void luaR_invalidaterefs (lua_State *L) {
     struct Ref *r = &L->refArray[i];
     if (r->st == HOLD && !ismarked(&r->o))
       r->st = COLLECTED;
-    LUA_ASSERT(L, (r->st == LOCK && ismarked(&r->o)) ||
+    LUA_ASSERT((r->st == LOCK && ismarked(&r->o)) ||
                 r->st == COLLECTED ||
                 r->st == NONEXT ||
                (r->st < n && VALIDLINK(L, L->refArray[r->st].st, n)),
                "inconsistent ref table");
   }
-  LUA_ASSERT(L, VALIDLINK(L, L->refFree, n), "inconsistent ref table");
+  LUA_ASSERT(VALIDLINK(L, L->refFree, n), "inconsistent ref table");
 }
 
diff --git a/lstate.c b/lstate.c
index 24df5d4b..b91daf5b 100644
--- a/lstate.c
+++ b/lstate.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstate.c,v 1.26 2000/05/08 19:32:53 roberto Exp roberto $
+** $Id: lstate.c,v 1.27 2000/06/12 13:52:05 roberto Exp roberto $
 ** Global State
 ** See Copyright Notice in lua.h
 */
@@ -88,22 +88,22 @@ lua_State *lua_newstate (const char *s, ...) {
 
 void lua_close (lua_State *L) {
   luaC_collect(L, 1);  /* collect all elements */
-  LUA_ASSERT(L, L->rootproto == NULL, "list should be empty");
-  LUA_ASSERT(L, L->rootcl == NULL, "list should be empty");
-  LUA_ASSERT(L, L->roottable == NULL, "list should be empty");
+  LUA_ASSERT(L->rootproto == NULL, "list should be empty");
+  LUA_ASSERT(L->rootcl == NULL, "list should be empty");
+  LUA_ASSERT(L->roottable == NULL, "list should be empty");
   luaS_freeall(L);
   luaM_free(L, L->stack);
   luaM_free(L, L->IMtable);
   luaM_free(L, L->refArray);
   luaM_free(L, L->Mbuffer);
   luaM_free(L, L->Cblocks);
-  LUA_ASSERT(L, L->numCblocks == 0, "Cblocks still open");
-  LUA_ASSERT(L, L->nblocks == 0, "wrong count for nblocks");
-  LUA_ASSERT(L, L->Cstack.base == L->top, "C2Lua not empty");
+  LUA_ASSERT(L->numCblocks == 0, "Cblocks still open");
+  LUA_ASSERT(L->nblocks == 0, "wrong count for nblocks");
+  LUA_ASSERT(L->Cstack.base == L->top, "C2Lua not empty");
   luaM_free(L, L);
   if (L == lua_state) {
-    LUA_ASSERT(L, memdebug_numblocks == 0, "memory leak!");
-    LUA_ASSERT(L, memdebug_total == 0,"memory leak!");
+    LUA_ASSERT(memdebug_numblocks == 0, "memory leak!");
+    LUA_ASSERT(memdebug_total == 0,"memory leak!");
     lua_state = NULL;
   }
 }
diff --git a/lstring.c b/lstring.c
index ac526838..ffc834b8 100644
--- a/lstring.c
+++ b/lstring.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.c,v 1.38 2000/06/12 13:52:05 roberto Exp roberto $
+** $Id: lstring.c,v 1.39 2000/06/15 17:01:12 roberto Exp roberto $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -28,9 +28,9 @@ void luaS_init (lua_State *L) {
 
 
 void luaS_freeall (lua_State *L) {
-  LUA_ASSERT(L, L->strt.nuse==0, "non-empty string table");
+  LUA_ASSERT(L->strt.nuse==0, "non-empty string table");
   luaM_free(L, L->strt.hash);
-  LUA_ASSERT(L, L->udt.nuse==0, "non-empty udata table");
+  LUA_ASSERT(L->udt.nuse==0, "non-empty udata table");
   luaM_free(L, L->udt.hash);
 }
 
@@ -55,7 +55,7 @@ void luaS_resize (lua_State *L, stringtable *tb, int newsize) {
       TString *next = p->nexthash;  /* save next */
       unsigned long h = (tb == &L->strt) ? p->u.s.hash : IntPoint(p->u.d.value);
       int h1 = h&(newsize-1);  /* new position */
-      LUA_ASSERT(L, h%newsize == (h&(newsize-1)),
+      LUA_ASSERT(h%newsize == (h&(newsize-1)),
                     "a&(x-1) == a%x, for x power of 2");
       p->nexthash = newhash[h1];  /* chain it in new position */
       newhash[h1] = p;
diff --git a/ltable.c b/ltable.c
index 4b4f37ac..0e271e8c 100644
--- a/ltable.c
+++ b/ltable.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.c,v 1.48 2000/06/12 13:52:05 roberto Exp roberto $
+** $Id: ltable.c,v 1.49 2000/06/28 17:03:56 roberto Exp roberto $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -63,7 +63,7 @@ Node *luaH_mainposition (const Hash *t, const TObject *key) {
     default:
       return NULL;  /* invalid key */
   }
-  LUA_ASSERT(L, h%(unsigned int)t->size == (h&((unsigned int)t->size-1)),
+  LUA_ASSERT(h%(unsigned int)t->size == (h&((unsigned int)t->size-1)),
             "a&(x-1) == a%x, for x power of 2");
   return &t->node[h&(t->size-1)];
 }
@@ -140,7 +140,7 @@ void luaH_remove (Hash *t, TObject *key) {
     }
     ttype(key) = TAG_NUMBER;
     nvalue(key) = n;
-    LUA_ASSERT(L, luaH_mainposition(t, key) == mp, "cannot change hash");
+    LUA_ASSERT(luaH_mainposition(t, key) == mp, "cannot change hash");
   }
 }
 
@@ -196,7 +196,7 @@ static void rehash (lua_State *L, Hash *t) {
   Node *nold = t->node;
   int nelems = numuse(t);
   int i;
-  LUA_ASSERT(L, nelems<=oldsize, "wrong count");
+  LUA_ASSERT(nelems<=oldsize, "wrong count");
   if (nelems >= oldsize-oldsize/4)  /* using more than 3/4? */
     setnodevector(L, t, (lint32)oldsize*2);
   else if (nelems <= oldsize/4 &&  /* less than 1/4? */
diff --git a/lvm.c b/lvm.c
index 2fccacc6..ed29602c 100644
--- a/lvm.c
+++ b/lvm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.c,v 1.118 2000/06/27 19:00:36 roberto Exp roberto $
+** $Id: lvm.c,v 1.119 2000/06/28 20:20:36 roberto Exp roberto $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -384,7 +384,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
 
       case OP_PUSHNIL: {
         int n = GETARG_U(i);
-        LUA_ASSERT(L, n>0, "invalid argument");
+        LUA_ASSERT(n>0, "invalid argument");
         do {
           ttype(top++) = TAG_NIL;
         } while (--n > 0);
@@ -648,8 +648,8 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
         break;
 
       case OP_FORLOOP: {
-        LUA_ASSERT(L, ttype(top-1) == TAG_NUMBER, "invalid step");
-        LUA_ASSERT(L, ttype(top-2) == TAG_NUMBER, "invalid limit");
+        LUA_ASSERT(ttype(top-1) == TAG_NUMBER, "invalid step");
+        LUA_ASSERT(ttype(top-2) == TAG_NUMBER, "invalid limit");
         if (ttype(top-3) != TAG_NUMBER)
           lua_error(L, "`for' index must be a number");
         nvalue(top-3) += nvalue(top-1);  /* increment index */
@@ -675,7 +675,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
         }
         else {
           top += 2;  /* index,value */
-          LUA_ASSERT(L, top==L->top, "bad top");
+          LUA_ASSERT(top==L->top, "bad top");
         }
         break;
       }
@@ -683,8 +683,8 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
       case OP_LFORLOOP: {
         int n;
         top -= 2;  /* remove old index,value */
-        LUA_ASSERT(L, ttype(top-2) == TAG_TABLE, "invalid table");
-        LUA_ASSERT(L, ttype(top-1) == TAG_NUMBER, "invalid counter");
+        LUA_ASSERT(ttype(top-2) == TAG_TABLE, "invalid table");
+        LUA_ASSERT(ttype(top-1) == TAG_NUMBER, "invalid counter");
         L->top = top;
         n = luaA_next(L, hvalue(top-2), (int)nvalue(top-1));
         if (n == 0)  /* end loop? */