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

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

#define lundump_c
#define LUA_CORE

#include "lprefix.h"


#include <limits.h>
#include <string.h>

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


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.p, ts);  /* anchor it ('loadVector' can GC) */
        luaD_inctop(L);
        loadVector(S, getlngstr(ts), size);  /* load directly in final place */
        L->top.p--;  /* 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;
            case LUA_VNUMFLT:
                setfltvalue(o, loadNumber(S));
                break;
            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.p, 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;
}