 @@ -1,232 +1,242 @@
-/*	$NetBSD: ldump.c,v 1.10 2023/04/16 20:46:17 nikita Exp $	*/
+/*	$NetBSD: ldump.c,v 1.11 2023/04/17 21:17:57 nikita Exp $	*/
 /*
 ** Id: ldump.c
 ** save precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 #define ldump_c
 #define LUA_CORE
 #include "lprefix.h"
 #ifndef _KERNEL
 #include <stddef.h>
 #include <limits.h>
 #endif /* _KERNEL */
 #include "lua.h"
 #include "lobject.h"
 #include "lstate.h"
 #include "lundump.h"
 typedef struct {
   lua_State *L;
   lua_Writer writer;
   void *data;
   int strip;
   int status;
 } DumpState;
 /*
 ** All high-level dumps go through dumpVector; you can change it to
 ** change the endianness of the result
 */
 #define dumpVector(D,v,n)	dumpBlock(D,v,(n)*sizeof((v)[0]))
 #define dumpLiteral(D, s)	dumpBlock(D,s,sizeof(s) - sizeof(char))
 static void dumpBlock (DumpState *D, const void *b, size_t size) {
   if (D->status == 0 && size > 0) {
     lua_unlock(D->L);
     D->status = (*D->writer)(D->L, b, size, D->data);
     lua_lock(D->L);
+  }
+}
 #define dumpVar(D,x)		dumpVector(D,&x,1)
 static void dumpByte (DumpState *D, int y) {
   lu_byte x = (lu_byte)y;
   dumpVar(D, x);
+}
 #ifdef _KERNEL
 /* dumpInt Buff Size */
 #define DIBS    ((sizeof(size_t) * 8 / 7) + 1)
 #endif /* _KERNEL */
 #ifndef _KERNEL
 /*
 ** 'dumpSize' buffer size: each byte can store up to 7 bits. (The "+6"
 ** rounds up the division.)
 */
 #define DIBS    ((sizeof(size_t) * CHAR_BIT + 6) / 7)
 #endif /* _KERNEL */
 static void dumpSize (DumpState *D, size_t x) {
   lu_byte buff[DIBS];
   int n = 0;
   do {
     buff[DIBS - (++n)] = x & 0x7f;  /* fill buffer in reverse order */
     x >>= 7;
   } while (x != 0);
   buff[DIBS - 1] |= 0x80;  /* mark last byte */
   dumpVector(D, buff + DIBS - n, n);
+}
 static void dumpInt (DumpState *D, int x) {
   dumpSize(D, x);
+}
 static void dumpNumber (DumpState *D, lua_Number x) {
   dumpVar(D, x);
+}
 static void dumpInteger (DumpState *D, lua_Integer x) {
   dumpVar(D, x);
+}
 static void dumpString (DumpState *D, const TString *s) {
   if (s == NULL)
     dumpSize(D, 0);
   else {
     size_t size = tsslen(s);
     const char *str = getstr(s);
     dumpSize(D, size + 1);
     dumpVector(D, str, size);
+  }
+}
 static void dumpCode (DumpState *D, const Proto *f) {
   dumpInt(D, f->sizecode);
   dumpVector(D, f->code, f->sizecode);
+}
 static void dumpFunction(DumpState *D, const Proto *f, TString *psource);
 static void dumpConstants (DumpState *D, const Proto *f) {
   int i;
   int n = f->sizek;
   dumpInt(D, n);
   for (i = 0; i < n; i++) {
     const TValue *o = &f->k[i];
     int tt = ttypetag(o);
     dumpByte(D, tt);
     switch (tt) {
 #ifndef _KERNEL
       case LUA_VNUMFLT:
         dumpNumber(D, fltvalue(o));
         break;
 #endif /* _KERNEL */
       case LUA_VNUMINT:
         dumpInteger(D, ivalue(o));
         break;
       case LUA_VSHRSTR:
       case LUA_VLNGSTR:
         dumpString(D, tsvalue(o));
         break;
       default:
         lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE);
+    }
+  }
+}
 static void dumpProtos (DumpState *D, const Proto *f) {
   int i;
   int n = f->sizep;
   dumpInt(D, n);
   for (i = 0; i < n; i++)
     dumpFunction(D, f->p[i], f->source);
+}
 static void dumpUpvalues (DumpState *D, const Proto *f) {
   int i, n = f->sizeupvalues;
   dumpInt(D, n);
   for (i = 0; i < n; i++) {
     dumpByte(D, f->upvalues[i].instack);
     dumpByte(D, f->upvalues[i].idx);
     dumpByte(D, f->upvalues[i].kind);
+  }
+}
 static void dumpDebug (DumpState *D, const Proto *f) {
   int i, n;
   n = (D->strip) ? 0 : f->sizelineinfo;
   dumpInt(D, n);
   dumpVector(D, f->lineinfo, n);
   n = (D->strip) ? 0 : f->sizeabslineinfo;
   dumpInt(D, n);
   for (i = 0; i < n; i++) {
     dumpInt(D, f->abslineinfo[i].pc);
     dumpInt(D, f->abslineinfo[i].line);
+  }
   n = (D->strip) ? 0 : f->sizelocvars;
   dumpInt(D, n);
   for (i = 0; i < n; i++) {
     dumpString(D, f->locvars[i].varname);
     dumpInt(D, f->locvars[i].startpc);
     dumpInt(D, f->locvars[i].endpc);
+  }
   n = (D->strip) ? 0 : f->sizeupvalues;
   dumpInt(D, n);
   for (i = 0; i < n; i++)
     dumpString(D, f->upvalues[i].name);
+}
 static void dumpFunction (DumpState *D, const Proto *f, TString *psource) {
   if (D->strip || f->source == psource)
     dumpString(D, NULL);  /* no debug info or same source as its parent */
   else
     dumpString(D, f->source);
   dumpInt(D, f->linedefined);
   dumpInt(D, f->lastlinedefined);
   dumpByte(D, f->numparams);
   dumpByte(D, f->is_vararg);
   dumpByte(D, f->maxstacksize);
   dumpCode(D, f);
   dumpConstants(D, f);
   dumpUpvalues(D, f);
   dumpProtos(D, f);
   dumpDebug(D, f);
+}
 static void dumpHeader (DumpState *D) {
   dumpLiteral(D, LUA_SIGNATURE);
   dumpByte(D, LUAC_VERSION);
   dumpByte(D, LUAC_FORMAT);
   dumpLiteral(D, LUAC_DATA);
   dumpByte(D, sizeof(Instruction));
   dumpByte(D, sizeof(lua_Integer));
   dumpByte(D, sizeof(lua_Number));
   dumpInteger(D, LUAC_INT);
   dumpNumber(D, LUAC_NUM);
+}
 /*
 ** dump Lua function as precompiled chunk
 */
 int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data,
               int strip) {
   DumpState D;
   D.L = L;
   D.writer = w;
   D.data = data;
   D.strip = strip;
   D.status = 0;
   dumpHeader(&D);
   dumpByte(&D, f->sizeupvalues);
   dumpFunction(&D, f, NULL);
   return D.status;
+}

 @@ -1,339 +1,341 @@
-/*	$NetBSD: lundump.c,v 1.9 2023/04/16 20:46:17 nikita Exp $	*/
+/*	$NetBSD: lundump.c,v 1.10 2023/04/17 21:17:57 nikita Exp $	*/
 /*
 ** Id: lundump.c
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 #define lundump_c
 #define LUA_CORE
 #include "lprefix.h"
 #ifndef _KERNEL
 #include <limits.h>
 #include <string.h>
 #endif /* _KERNEL */
 #include "lua.h"
 #include "ldebug.h"
 #include "ldo.h"
 #include "lfunc.h"
 #include "lmem.h"
 #include "lobject.h"
 #include "lstring.h"
 #include "lundump.h"
 #include "lzio.h"
 #if !defined(luai_verifycode)
 #define luai_verifycode(L,f)  /* empty */
 #endif
 typedef struct {
   lua_State *L;
   ZIO *Z;
   const char *name;
 } LoadState;
 static l_noret error (LoadState *S, const char *why) {
   luaO_pushfstring(S->L, "%s: bad binary format (%s)", S->name, why);
   luaD_throw(S->L, LUA_ERRSYNTAX);
+}
 /*
 ** All high-level loads go through loadVector; you can change it to
 ** adapt to the endianness of the input
 */
 #define loadVector(S,b,n)	loadBlock(S,b,(n)*sizeof((b)[0]))
 static void loadBlock (LoadState *S, void *b, size_t size) {
   if (luaZ_read(S->Z, b, size) != 0)
     error(S, "truncated chunk");
+}
 #define loadVar(S,x)		loadVector(S,&x,1)
 static lu_byte loadByte (LoadState *S) {
   int b = zgetc(S->Z);
   if (b == EOZ)
     error(S, "truncated chunk");
   return cast_byte(b);
+}
 static size_t loadUnsigned (LoadState *S, size_t limit) {
   size_t x = 0;
   int b;
   limit >>= 7;
   do {
     b = loadByte(S);
     if (x >= limit)
       error(S, "integer overflow");
     x = (x << 7) | (b & 0x7f);
   } while ((b & 0x80) == 0);
   return x;
+}
 static size_t loadSize (LoadState *S) {
   return loadUnsigned(S, ~(size_t)0);
+}
 static int loadInt (LoadState *S) {
   return cast_int(loadUnsigned(S, INT_MAX));
+}
 static lua_Number loadNumber (LoadState *S) {
   lua_Number x;
   loadVar(S, x);
   return x;
+}
 static lua_Integer loadInteger (LoadState *S) {
   lua_Integer x;
   loadVar(S, x);
   return x;
+}
 /*
 ** Load a nullable string into prototype 'p'.
 */
 static TString *loadStringN (LoadState *S, Proto *p) {
   lua_State *L = S->L;
   TString *ts;
   size_t size = loadSize(S);
   if (size == 0)  /* no string? */
     return NULL;
   else if (--size <= LUAI_MAXSHORTLEN) {  /* short string? */
     char buff[LUAI_MAXSHORTLEN];
     loadVector(S, buff, size);  /* load string into buffer */
     ts = luaS_newlstr(L, buff, size);  /* create string */
+  }
   else {  /* long string */
     ts = luaS_createlngstrobj(L, size);  /* create string */
     setsvalue2s(L, L->top, ts);  /* anchor it ('loadVector' can GC) */
     luaD_inctop(L);
     loadVector(S, getstr(ts), size);  /* load directly in final place */
     L->top--;  /* pop string */
+  }
   luaC_objbarrier(L, p, ts);
   return ts;
+}
 /*
 ** Load a non-nullable string into prototype 'p'.
 */
 static TString *loadString (LoadState *S, Proto *p) {
   TString *st = loadStringN(S, p);
   if (st == NULL)
     error(S, "bad format for constant string");
   return st;
+}
 static void loadCode (LoadState *S, Proto *f) {
   int n = loadInt(S);
   f->code = luaM_newvectorchecked(S->L, n, Instruction);
   f->sizecode = n;
   loadVector(S, f->code, n);
+}
 static void loadFunction(LoadState *S, Proto *f, TString *psource);
 static void loadConstants (LoadState *S, Proto *f) {
   int i;
   int n = loadInt(S);
   f->k = luaM_newvectorchecked(S->L, n, TValue);
   f->sizek = n;
   for (i = 0; i < n; i++)
     setnilvalue(&f->k[i]);
   for (i = 0; i < n; i++) {
     TValue *o = &f->k[i];
     int t = loadByte(S);
     switch (t) {
       case LUA_VNIL:
         setnilvalue(o);
         break;
       case LUA_VFALSE:
         setbfvalue(o);
         break;
       case LUA_VTRUE:
         setbtvalue(o);
         break;
 #ifndef _KERNEL
       case LUA_VNUMFLT:
         setfltvalue(o, loadNumber(S));
         break;
 #endif /* _KERNEL */
       case LUA_VNUMINT:
         setivalue(o, loadInteger(S));
         break;
       case LUA_VSHRSTR:
       case LUA_VLNGSTR:
         setsvalue2n(S->L, o, loadString(S, f));
         break;
       default: lua_assert(0);
+    }
+  }
+}
 static void loadProtos (LoadState *S, Proto *f) {
   int i;
   int n = loadInt(S);
   f->p = luaM_newvectorchecked(S->L, n, Proto *);
   f->sizep = n;
   for (i = 0; i < n; i++)
     f->p[i] = NULL;
   for (i = 0; i < n; i++) {
     f->p[i] = luaF_newproto(S->L);
     luaC_objbarrier(S->L, f, f->p[i]);
     loadFunction(S, f->p[i], f->source);
+  }
+}
 /*
 ** Load the upvalues for a function. The names must be filled first,
 ** because the filling of the other fields can raise read errors and
 ** the creation of the error message can call an emergency collection;
 ** in that case all prototypes must be consistent for the GC.
 */
 static void loadUpvalues (LoadState *S, Proto *f) {
   int i, n;
   n = loadInt(S);
   f->upvalues = luaM_newvectorchecked(S->L, n, Upvaldesc);
   f->sizeupvalues = n;
   for (i = 0; i < n; i++)  /* make array valid for GC */
     f->upvalues[i].name = NULL;
   for (i = 0; i < n; i++) {  /* following calls can raise errors */
     f->upvalues[i].instack = loadByte(S);
     f->upvalues[i].idx = loadByte(S);
     f->upvalues[i].kind = loadByte(S);
+  }
+}
 static void loadDebug (LoadState *S, Proto *f) {
   int i, n;
   n = loadInt(S);
   f->lineinfo = luaM_newvectorchecked(S->L, n, ls_byte);
   f->sizelineinfo = n;
   loadVector(S, f->lineinfo, n);
   n = loadInt(S);
   f->abslineinfo = luaM_newvectorchecked(S->L, n, AbsLineInfo);
   f->sizeabslineinfo = n;
   for (i = 0; i < n; i++) {
     f->abslineinfo[i].pc = loadInt(S);
     f->abslineinfo[i].line = loadInt(S);
+  }
   n = loadInt(S);
   f->locvars = luaM_newvectorchecked(S->L, n, LocVar);
   f->sizelocvars = n;
   for (i = 0; i < n; i++)
     f->locvars[i].varname = NULL;
   for (i = 0; i < n; i++) {
     f->locvars[i].varname = loadStringN(S, f);
     f->locvars[i].startpc = loadInt(S);
     f->locvars[i].endpc = loadInt(S);
+  }
   n = loadInt(S);
   if (n != 0)  /* does it have debug information? */
     n = f->sizeupvalues;  /* must be this many */
   for (i = 0; i < n; i++)
     f->upvalues[i].name = loadStringN(S, f);
+}
 static void loadFunction (LoadState *S, Proto *f, TString *psource) {
   f->source = loadStringN(S, f);
   if (f->source == NULL)  /* no source in dump? */
     f->source = psource;  /* reuse parent's source */
   f->linedefined = loadInt(S);
   f->lastlinedefined = loadInt(S);
   f->numparams = loadByte(S);
   f->is_vararg = loadByte(S);
   f->maxstacksize = loadByte(S);
   loadCode(S, f);
   loadConstants(S, f);
   loadUpvalues(S, f);
   loadProtos(S, f);
   loadDebug(S, f);
+}
 static void checkliteral (LoadState *S, const char *s, const char *msg) {
   char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
   size_t len = strlen(s);
   loadVector(S, buff, len);
   if (memcmp(s, buff, len) != 0)
     error(S, msg);
+}
 static void fchecksize (LoadState *S, size_t size, const char *tname) {
   if (loadByte(S) != size)
     error(S, luaO_pushfstring(S->L, "%s size mismatch", tname));
+}
 #define checksize(S,t)	fchecksize(S,sizeof(t),#t)
 static void checkHeader (LoadState *S) {
   /* skip 1st char (already read and checked) */
   checkliteral(S, &LUA_SIGNATURE[1], "not a binary chunk");
   if (loadByte(S) != LUAC_VERSION)
     error(S, "version mismatch");
   if (loadByte(S) != LUAC_FORMAT)
     error(S, "format mismatch");
   checkliteral(S, LUAC_DATA, "corrupted chunk");
   checksize(S, Instruction);
   checksize(S, lua_Integer);
   checksize(S, lua_Number);
   if (loadInteger(S) != LUAC_INT)
     error(S, "integer format mismatch");
   if (loadNumber(S) != LUAC_NUM)
     error(S, "float format mismatch");
+}
 /*
 ** Load precompiled chunk.
 */
 LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
   LoadState S;
   LClosure *cl;
   if (*name == '@' || *name == '=')
     S.name = name + 1;
   else if (*name == LUA_SIGNATURE[0])
     S.name = "binary string";
   else
     S.name = name;
   S.L = L;
   S.Z = Z;
   checkHeader(&S);
   cl = luaF_newLclosure(L, loadByte(&S));
   setclLvalue2s(L, L->top, cl);
   luaD_inctop(L);
   cl->p = luaF_newproto(L);
   luaC_objbarrier(L, cl, cl->p);
   loadFunction(&S, cl->p, NULL);
   lua_assert(cl->nupvalues == cl->p->sizeupvalues);
   luai_verifycode(L, cl->p);
   return cl;
+}