Migrate lzio

Author: khvzak

.gitignore

@@ -1 +1,2 @@
+/.vscode
 /target

build/build.rs

@@ -35,6 +35,5 @@ fn main() {
         .file("build/lundump.c")
         .file("build/lutf8lib.c")
         .file("build/lvm.c")
-        .file("build/lzio.c")
         .compile("lua");
 }

build/lzio.c

@@ -19,3 +19,5 @@ fn main() {
         ) as i32)
     }
 }
+
+extern crate lua53_rs;

src/bin/lua.rs

@@ -0,0 +1,12 @@
+use libc::c_int;
+
+pub type jmp_buf = [libc::c_int; 37];
+
+/* chain list of long jump buffers */
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct lua_longjmp {
+    pub previous: *mut lua_longjmp,
+    pub b: jmp_buf,
+    pub status: c_int,
+}

src/ldo.rs

@@ -0,0 +1,29 @@
+use libc::c_int;
+
+use crate::llimits::lu_mem;
+use crate::lobject::TValue;
+
+/*
+** Upvalues for Lua closures
+*/
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct UpVal {
+    pub v: *mut TValue,   /* points to stack or to its own value */
+    pub refcount: lu_mem, /* reference counter */
+    pub u: C2RustUnnamed_3,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union C2RustUnnamed_3 {
+    pub open: C2RustUnnamed_4, /* (when open) */
+    pub value: TValue,         /* the value (when closed) */
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct C2RustUnnamed_4 {
+    pub next: *mut UpVal, /* linked list */
+    pub touched: c_int,   /* mark to avoid cycles with dead threads */
+}

src/lfunc.rs

@@ -0,0 +1,11 @@
+#![allow(non_camel_case_types, non_snake_case, dead_code)]
+
+pub(crate) mod ldo;
+pub(crate) mod lfunc;
+pub(crate) mod llimits;
+pub(crate) mod lobject;
+pub(crate) mod lstate;
+pub(crate) mod ltemp;
+pub(crate) mod ltm;
+pub(crate) mod lzio;
+pub(crate) mod types;

src/lib.rs

@@ -0,0 +1,27 @@
+use libc::{c_int, c_uchar, c_uint, ptrdiff_t, size_t};
+
+pub type lu_byte = c_uchar;
+pub type l_mem = ptrdiff_t;
+pub type lu_mem = size_t;
+pub type sig_atomic_t = c_int;
+
+/*
+** type for virtual-machine instructions;
+** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
+*/
+pub type Instruction = c_uint;
+
+/*
+** Size of cache for strings in the API. 'N' is the number of
+** sets (better be a prime) and "M" is the size of each set (M == 1
+** makes a direct cache.)
+*/
+pub const STRCACHE_N: usize = 53;
+pub const STRCACHE_M: usize = 2;
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@@ of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+pub const LUA_IDSIZE: usize = 60;

src/llimits.rs

@@ -0,0 +1,99 @@
+/*
+** About the realloc function:
+** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
+** ('osize' is the old size, 'nsize' is the new size)
+**
+** * frealloc(ud, NULL, x, s) creates a new block of size 's' (no
+** matter 'x').
+**
+** * frealloc(ud, p, x, 0) frees the block 'p'
+** (in this specific case, frealloc must return NULL);
+** particularly, frealloc(ud, NULL, 0, 0) does nothing
+** (which is equivalent to free(NULL) in ISO C)
+**
+** frealloc returns NULL if it cannot create or reallocate the area
+** (any reallocation to an equal or smaller size cannot fail!)
+*/
+
+pub const MINSIZEARRAY: libc::c_int = 4 as libc::c_int;
+
+pub unsafe fn luaM_growaux_(
+    mut L: *mut lua_State,
+    mut block: *mut libc::c_void,
+    mut size: *mut libc::c_int,
+    mut size_elems: size_t,
+    mut limit: libc::c_int,
+    mut what: *const libc::c_char,
+) -> *mut libc::c_void {
+    let mut newblock = 0 as *mut libc::c_void;
+    let mut newsize: libc::c_int = 0;
+    if *size >= limit / 2 as libc::c_int {
+        /* cannot double it? */
+        if *size >= limit {
+            /* cannot grow even a little? */
+            luaG_runerror(
+                L,
+                b"too many %s (limit is %d)\0" as *const u8 as *const libc::c_char,
+                what,
+                limit,
+            );
+        }
+        newsize = limit;
+    } else {
+        newsize = *size * 2 as libc::c_int;
+        if newsize < MINSIZEARRAY {
+            /* minimum size */
+            newsize = MINSIZEARRAY;
+        }
+    }
+    newblock = luaM_realloc_(
+        L,
+        block,
+        (*size as libc::c_ulong).checked_mul(size_elems),
+        (newsize as libc::c_ulong).checked_mul(size_elems),
+    );
+    /* update only when everything else is OK */
+    *size = newsize;
+    return newblock;
+}
+
+/*
+** generic allocation routine.
+*/
+
+pub unsafe fn luaM_realloc_(
+    mut L: *mut lua_State,
+    mut block: *mut libc::c_void,
+    mut osize: size_t,
+    mut nsize: size_t,
+) -> *mut libc::c_void {
+    let mut newblock = 0 as *mut libc::c_void;
+    let mut g = (*L).l_G;
+    let mut realosize = if !block.is_null() {
+        osize
+    } else {
+        0 as libc::c_int as libc::c_ulong
+    };
+    // TODO: HARDMEMTESTS
+    newblock = (((*g).frealloc).expect("non-null function pointer"))((*g).ud, block, osize, nsize);
+    if newblock.is_null() && nsize > 0 as libc::c_int as libc::c_ulong {
+        /* cannot fail when shrinking a block */
+        debug_assert!(nsize > realosize);
+        if !((*g).version).is_null() {
+            /* is state fully built? */
+            /* try to free some memory... */
+            luaC_fullgc(L, 1 as libc::c_int);
+            /* try again */
+            newblock =
+                (((*g).frealloc).expect("non-null function pointer"))((*g).ud, block, osize, nsize);
+        }
+        if newblock.is_null() {
+            luaD_throw(L, LUA_ERRMEM);
+        }
+    }
+    debug_assert!((nsize == 0) == newblock.is_null());
+    (*g).GCdebt = ((*g).GCdebt as libc::c_ulong)
+        .wrapping_add(nsize)
+        .wrapping_sub(realosize) as l_mem;
+    return newblock;
+}

src/lmem.rs

@@ -0,0 +1,116 @@
+use libc::{c_int, c_uint, c_void, size_t};
+
+use crate::llimits::lu_byte;
+use crate::types::{lua_CFunction, lua_Integer, lua_Number};
+
+/*
+** Common type has only the common header
+*/
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct GCObject {
+    pub next: *mut GCObject,
+    pub tt: lu_byte,
+    pub marked: lu_byte,
+}
+
+/*
+** Tagged Values. This is the basic representation of values in Lua,
+** an actual value plus a tag with its type.
+*/
+
+/*
+** Union of all Lua values
+*/
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union Value {
+    pub gc: *mut GCObject, /* collectable objects */
+    pub p: *mut c_void,    /* light userdata */
+    pub b: c_int,          /* booleans */
+    pub f: lua_CFunction,  /* light C functions */
+    pub i: lua_Integer,    /* integer numbers */
+    pub n: lua_Number,     /* float numbers */
+}
+
+pub type TValue = lua_TValue;
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct lua_TValue {
+    pub value_: Value,
+    pub tt_: c_int,
+}
+
+/*
+** ======================================================
+** types and prototypes
+** =======================================================
+*/
+
+pub type StkId = *mut TValue; /* index to stack elements */
+
+/*
+** Header for string value; string bytes follow the end of this structure
+** (aligned according to 'UTString'; see next).
+*/
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct TString {
+    pub next: *mut GCObject,
+    pub tt: lu_byte,
+    pub marked: lu_byte,
+    pub extra: lu_byte, /* reserved words for short strings; "has hash" for longs */
+    pub shrlen: lu_byte, /* length for short strings */
+    pub hash: c_uint,
+    pub u: C2RustUnnamed_5,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union C2RustUnnamed_5 {
+    pub lnglen: size_t,      /* length for long strings */
+    pub hnext: *mut TString, /* linked list for hash table */
+}
+
+/*
+** Tables
+*/
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union TKey {
+    pub nk: C2RustUnnamed_6,
+    pub tvk: TValue,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct C2RustUnnamed_6 {
+    pub value_: Value,
+    pub tt_: c_int,
+    pub next: c_int, /* for chaining (offset for next node) */
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct Node {
+    pub i_val: TValue,
+    pub i_key: TKey,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct Table {
+    pub next: *mut GCObject,
+    pub tt: lu_byte,
+    pub marked: lu_byte,
+    pub flags: lu_byte,     /* 1<<p means tagmethod(p) is not present */
+    pub lsizenode: lu_byte, /* log2 of size of 'node' array */
+    pub sizearray: c_uint,  /* size of 'array' array */
+    pub array: *mut TValue, /* array part */
+    pub node: *mut Node,
+    pub lastfree: *mut Node, /* any free position is before this position */
+    pub metatable: *mut Table,
+    pub gclist: *mut GCObject,
+}