RRG-Proxmark3/client/deps/liblua/ldump.c

/*
** $Id: ldump.c $
** save precompiled Lua chunks
** See Copyright Notice in lua.h
*/

#define ldump_c
#define LUA_CORE

#include "lprefix.h"


#include <limits.h>
#include <stddef.h>

#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);
}


/*
** '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)

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) {
            case LUA_VNUMFLT:
                dumpNumber(D, fltvalue(o));
                break;
            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;
}