nanocoat/lib/3rdparty/lua/ldump.c

   1 /*
   2 ** $Id: ldump.c $
   3 ** save precompiled Lua chunks
   4 ** See Copyright Notice in lua.h
   5 */
   6
   7 #define ldump_c
   8 #define LUA_CORE
   9
  10 #include "lprefix.h"
  11
  12
  13 #include <limits.h>
  14 #include <stddef.h>
  15
  16 #include "lua.h"
  17
  18 #include "lobject.h"
  19 #include "lstate.h"
  20 #include "lundump.h"
  21
  22
  23 typedef struct {
  24   lua_State *L;
  25   lua_Writer writer;
  26   void *data;
  27   int strip;
  28   int status;
  29 } DumpState;
  30
  31
  32 /*
  33 ** All high-level dumps go through dumpVector; you can change it to
  34 ** change the endianness of the result
  35 */
  36 #define dumpVector(D,v,n)       dumpBlock(D,v,(n)*sizeof((v)[0]))
  37
  38 #define dumpLiteral(D, s)       dumpBlock(D,s,sizeof(s) - sizeof(char))
  39
  40
  41 static void dumpBlock (DumpState *D, const void *b, size_t size) {
  42   if (D->status == 0 && size > 0) {
  43     lua_unlock(D->L);
  44     D->status = (*D->writer)(D->L, b, size, D->data);
  45     lua_lock(D->L);
  46   }
  47 }
  48
  49
  50 #define dumpVar(D,x)            dumpVector(D,&x,1)
  51
  52
  53 static void dumpByte (DumpState *D, int y) {
  54   lu_byte x = (lu_byte)y;
  55   dumpVar(D, x);
  56 }
  57
  58
  59 /*
  60 ** 'dumpSize' buffer size: each byte can store up to 7 bits. (The "+6"
  61 ** rounds up the division.)
  62 */
  63 #define DIBS    ((sizeof(size_t) * CHAR_BIT + 6) / 7)
  64
  65 static void dumpSize (DumpState *D, size_t x) {
  66   lu_byte buff[DIBS];
  67   int n = 0;
  68   do {
  69     buff[DIBS - (++n)] = x & 0x7f;  /* fill buffer in reverse order */
  70     x >>= 7;
  71   } while (x != 0);
  72   buff[DIBS - 1] |= 0x80;  /* mark last byte */
  73   dumpVector(D, buff + DIBS - n, n);
  74 }
  75
  76
  77 static void dumpInt (DumpState *D, int x) {
  78   dumpSize(D, x);
  79 }
  80
  81
  82 static void dumpNumber (DumpState *D, lua_Number x) {
  83   dumpVar(D, x);
  84 }
  85
  86
  87 static void dumpInteger (DumpState *D, lua_Integer x) {
  88   dumpVar(D, x);
  89 }
  90
  91
  92 static void dumpString (DumpState *D, const TString *s) {
  93   if (s == NULL)
  94     dumpSize(D, 0);
  95   else {
  96     size_t size = tsslen(s);
  97     const char *str = getstr(s);
  98     dumpSize(D, size + 1);
  99     dumpVector(D, str, size);
 100   }
 101 }
 102
 103
 104 static void dumpCode (DumpState *D, const Proto *f) {
 105   dumpInt(D, f->sizecode);
 106   dumpVector(D, f->code, f->sizecode);
 107 }
 108
 109
 110 static void dumpFunction(DumpState *D, const Proto *f, TString *psource);
 111
 112 static void dumpConstants (DumpState *D, const Proto *f) {
 113   int i;
 114   int n = f->sizek;
 115   dumpInt(D, n);
 116   for (i = 0; i < n; i++) {
 117     const TValue *o = &f->k[i];
 118     int tt = ttypetag(o);
 119     dumpByte(D, tt);
 120     switch (tt) {
 121       case LUA_VNUMFLT:
 122         dumpNumber(D, fltvalue(o));
 123         break;
 124       case LUA_VNUMINT:
 125         dumpInteger(D, ivalue(o));
 126         break;
 127       case LUA_VSHRSTR:
 128       case LUA_VLNGSTR:
 129         dumpString(D, tsvalue(o));
 130         break;
 131       default:
 132         lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE);
 133     }
 134   }
 135 }
 136
 137
 138 static void dumpProtos (DumpState *D, const Proto *f) {
 139   int i;
 140   int n = f->sizep;
 141   dumpInt(D, n);
 142   for (i = 0; i < n; i++)
 143     dumpFunction(D, f->p[i], f->source);
 144 }
 145
 146
 147 static void dumpUpvalues (DumpState *D, const Proto *f) {
 148   int i, n = f->sizeupvalues;
 149   dumpInt(D, n);
 150   for (i = 0; i < n; i++) {
 151     dumpByte(D, f->upvalues[i].instack);
 152     dumpByte(D, f->upvalues[i].idx);
 153     dumpByte(D, f->upvalues[i].kind);
 154   }
 155 }
 156
 157
 158 static void dumpDebug (DumpState *D, const Proto *f) {
 159   int i, n;
 160   n = (D->strip) ? 0 : f->sizelineinfo;
 161   dumpInt(D, n);
 162   dumpVector(D, f->lineinfo, n);
 163   n = (D->strip) ? 0 : f->sizeabslineinfo;
 164   dumpInt(D, n);
 165   for (i = 0; i < n; i++) {
 166     dumpInt(D, f->abslineinfo[i].pc);
 167     dumpInt(D, f->abslineinfo[i].line);
 168   }
 169   n = (D->strip) ? 0 : f->sizelocvars;
 170   dumpInt(D, n);
 171   for (i = 0; i < n; i++) {
 172     dumpString(D, f->locvars[i].varname);
 173     dumpInt(D, f->locvars[i].startpc);
 174     dumpInt(D, f->locvars[i].endpc);
 175   }
 176   n = (D->strip) ? 0 : f->sizeupvalues;
 177   dumpInt(D, n);
 178   for (i = 0; i < n; i++)
 179     dumpString(D, f->upvalues[i].name);
 180 }
 181
 182
 183 static void dumpFunction (DumpState *D, const Proto *f, TString *psource) {
 184   if (D->strip || f->source == psource)
 185     dumpString(D, NULL);  /* no debug info or same source as its parent */
 186   else
 187     dumpString(D, f->source);
 188   dumpInt(D, f->linedefined);
 189   dumpInt(D, f->lastlinedefined);
 190   dumpByte(D, f->numparams);
 191   dumpByte(D, f->is_vararg);
 192   dumpByte(D, f->maxstacksize);
 193   dumpCode(D, f);
 194   dumpConstants(D, f);
 195   dumpUpvalues(D, f);
 196   dumpProtos(D, f);
 197   dumpDebug(D, f);
 198 }
 199
 200
 201 static void dumpHeader (DumpState *D) {
 202   dumpLiteral(D, LUA_SIGNATURE);
 203   dumpByte(D, LUAC_VERSION);
 204   dumpByte(D, LUAC_FORMAT);
 205   dumpLiteral(D, LUAC_DATA);
 206   dumpByte(D, sizeof(Instruction));
 207   dumpByte(D, sizeof(lua_Integer));
 208   dumpByte(D, sizeof(lua_Number));
 209   dumpInteger(D, LUAC_INT);
 210   dumpNumber(D, LUAC_NUM);
 211 }
 212
 213
 214 /*
 215 ** dump Lua function as precompiled chunk
 216 */
 217 int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data,
 218               int strip) {
 219   DumpState D;
 220   D.L = L;
 221   D.writer = w;
 222   D.data = data;
 223   D.strip = strip;
 224   D.status = 0;
 225   dumpHeader(&D);
 226   dumpByte(&D, f->sizeupvalues);
 227   dumpFunction(&D, f, NULL);
 228   return D.status;
 229 }
 230