mars3142/wx_wherigo
1
0
Fork 0
Code Issues Pull Requests Wiki Activity

starting playing the wherigo

Browse Source 
Signed-off-by: Peter Siegmund <mars3142@noreply.mars3142.dev>
This commit is contained in:
Peter Siegmund
2026-02-13 02:41:12 +01:00
parent 50267e47dc
commit f9c45ca81f
34 changed files with 4055 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/lua-5.1.4/CMakeLists.txt
View File

@@ -2,6 +2,8 @@
cmake_minimum_required(VERSION 3.21)
project(lua LANGUAGES C)
set(LUA_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
set(LUA_SOURCES
src/lapi.c
src/lcode.c

153
components/lua-5.1.4/src/lundump.c
View File

@@ -2,6 +2,8 @@
** $Id: lundump.c,v 2.7.1.4 2008/04/04 19:51:41 roberto Exp $
** load precompiled Lua chunks
** See Copyright Notice in lua.h
**
** Modified to support loading 32-bit bytecode on 64-bit systems
*/
#include <string.h>
@@ -25,6 +27,11 @@ typedef struct {
ZIO* Z;
Mbuffer* b;
const char* name;
int swap; /* endianness swap required */
int sizeof_int; /* sizeof(int) in bytecode */
int sizeof_size_t; /* sizeof(size_t) in bytecode */
int sizeof_instr; /* sizeof(Instruction) in bytecode */
int sizeof_number; /* sizeof(lua_Number) in bytecode */
} LoadState;
#ifdef LUAC_TRUST_BINARIES
@@ -58,25 +65,114 @@ static int LoadChar(LoadState* S)
return x;
}
static void SwapBytes(void* b, size_t size)
{
char* p = (char*)b;
size_t i;
for (i = 0; i < size/2; i++) {
char temp = p[i];
p[i] = p[size - 1 - i];
p[size - 1 - i] = temp;
}
}
static int LoadInt(LoadState* S)
{
int x;
LoadVar(S,x);
if (S->sizeof_int == sizeof(int)) {
LoadVar(S,x);
if (S->swap) SwapBytes(&x, sizeof(x));
} else if (S->sizeof_int == 4 && sizeof(int) >= 4) {
/* 32-bit int from bytecode */
lu_int32 t;
LoadMem(S,&t,1,4);
if (S->swap) SwapBytes(&t, 4);
x = (int)t;
} else if (S->sizeof_int == 8 && sizeof(int) == 4) {
/* 64-bit int in bytecode on 32-bit system - use lower 32 bits */
lu_int32 lo, hi;
LoadMem(S, &lo, 1, 4);
LoadMem(S, &hi, 1, 4);
if (S->swap) {
SwapBytes(&lo, 4);
SwapBytes(&hi, 4);
x = (int)hi;
} else {
x = (int)lo;
}
} else {
error(S, "unsupported int size in bytecode");
x = 0;
}
IF (x<0, "bad integer");
return x;
}
static size_t LoadSize(LoadState* S)
{
size_t x;
if (S->sizeof_size_t == sizeof(size_t)) {
LoadVar(S,x);
if (S->swap) SwapBytes(&x, sizeof(x));
} else if (S->sizeof_size_t == 4 && sizeof(size_t) == 8) {
/* 32-bit bytecode on 64-bit system */
lu_int32 t;
LoadMem(S,&t,1,4);
if (S->swap) SwapBytes(&t, 4);
x = (size_t)t;
} else if (S->sizeof_size_t == 8 && sizeof(size_t) == 4) {
/* 64-bit bytecode on 32-bit system - use lower 32 bits */
lu_int32 lo, hi;
LoadMem(S, &lo, 1, 4);
LoadMem(S, &hi, 1, 4);
if (S->swap) {
SwapBytes(&lo, 4);
SwapBytes(&hi, 4);
x = (size_t)hi; /* big-endian: high bytes first */
} else {
x = (size_t)lo; /* little-endian: low bytes first */
}
} else {
error(S, "unsupported size_t size in bytecode");
x = 0;
}
return x;
}
static lua_Number LoadNumber(LoadState* S)
{
lua_Number x;
LoadVar(S,x);
if (S->sizeof_number == sizeof(lua_Number)) {
LoadVar(S,x);
if (S->swap) SwapBytes(&x, sizeof(x));
} else {
error(S, "unsupported lua_Number size in bytecode");
x = 0;
}
return x;
}
static Instruction LoadInstruction(LoadState* S)
{
Instruction x;
if (S->sizeof_instr == sizeof(Instruction)) {
LoadVar(S,x);
if (S->swap) SwapBytes(&x, sizeof(x));
} else if (S->sizeof_instr == 4) {
lu_int32 t;
LoadMem(S,&t,1,4);
if (S->swap) SwapBytes(&t, 4);
x = (Instruction)t;
} else {
error(S, "unsupported Instruction size in bytecode");
x = 0;
}
return x;
}
static TString* LoadString(LoadState* S)
{
size_t size;
LoadVar(S,size);
size_t size = LoadSize(S);
if (size==0)
return NULL;
else
@@ -89,10 +185,12 @@ static TString* LoadString(LoadState* S)
static void LoadCode(LoadState* S, Proto* f)
{
int n=LoadInt(S);
int i, n=LoadInt(S);
f->code=luaM_newvector(S->L,n,Instruction);
f->sizecode=n;
LoadVector(S,f->code,n,sizeof(Instruction));
for (i=0; i<n; i++) {
f->code[i] = LoadInstruction(S);
}
}
static Proto* LoadFunction(LoadState* S, TString* p);
@@ -140,7 +238,9 @@ static void LoadDebug(LoadState* S, Proto* f)
n=LoadInt(S);
f->lineinfo=luaM_newvector(S->L,n,int);
f->sizelineinfo=n;
LoadVector(S,f->lineinfo,n,sizeof(int));
for (i=0; i<n; i++) {
f->lineinfo[i] = LoadInt(S);
}
n=LoadInt(S);
f->locvars=luaM_newvector(S->L,n,LocVar);
f->sizelocvars=n;
@@ -184,9 +284,44 @@ static void LoadHeader(LoadState* S)
{
char h[LUAC_HEADERSIZE];
char s[LUAC_HEADERSIZE];
luaU_header(h);
int x = 1;
int local_endian = (unsigned char)(*(char*)&x);
int file_endian;
LoadBlock(S,s,LUAC_HEADERSIZE);
IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
/* Check signature */
luaU_header(h);
IF (memcmp(h,s,sizeof(LUA_SIGNATURE)-1)!=0, "not a precompiled chunk");
/* Check version */
IF (s[4] != LUAC_VERSION, "version mismatch in precompiled chunk");
/* Check format */
IF (s[5] != LUAC_FORMAT, "incompatible format");
/* Endianness */
file_endian = (unsigned char)s[6];
S->swap = (file_endian != local_endian);
/* Size information from bytecode */
S->sizeof_int = (unsigned char)s[7];
S->sizeof_size_t = (unsigned char)s[8];
S->sizeof_instr = (unsigned char)s[9];
S->sizeof_number = (unsigned char)s[10];
/* Validate sizes we can handle */
IF (S->sizeof_int != 4 && S->sizeof_int != 8 && S->sizeof_int != (int)sizeof(int),
"unsupported int size");
IF (S->sizeof_size_t != 4 && S->sizeof_size_t != 8,
"unsupported size_t size");
IF (S->sizeof_instr != 4 && S->sizeof_instr != (int)sizeof(Instruction),
"unsupported Instruction size");
IF (S->sizeof_number != (int)sizeof(lua_Number),
"incompatible lua_Number size");
/* Check integral flag */
IF (s[11] != (((lua_Number)0.5)==0), "incompatible number type");
}
/*