summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rwxr-xr-xsizesbin0 -> 8656 bytes
-rw-r--r--sizes.c9
-rw-r--r--src/lstrlib.js255
3 files changed, 264 insertions, 0 deletions
diff --git a/sizes b/sizes
new file mode 100755
index 0000000..eabd657
--- /dev/null
+++ b/sizes
Binary files differ
diff --git a/sizes.c b/sizes.c
new file mode 100644
index 0000000..647c169
--- /dev/null
+++ b/sizes.c
@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+int main(void) {
+
+ printf("sizeof(char): %lu\nsizeof(short): %lu\nsizeof(long): %lu\nsizeof(size_t): %lu\nsizeof(float): %lu\nsizeof(double): %lu\nsizeof(int): %lu\n",
+ sizeof(char), sizeof(short), sizeof(long), sizeof(size_t), sizeof(float), sizeof(double), sizeof(int));
+
+ return 0;
+} \ No newline at end of file
diff --git a/src/lstrlib.js b/src/lstrlib.js
index 02feff6..89d1f7f 100644
--- a/src/lstrlib.js
+++ b/src/lstrlib.js
@@ -12,6 +12,10 @@ const CT = lua.constant_types;
const L_ESC = '%'.charCodeAt(0);
+// (sizeof(size_t) < sizeof(int) ? MAX_SIZET : (size_t)(INT_MAX))
+const MAXSIZE = Number.MAX_SAFE_INTEGER;
+
+
/* translate a relative string position: negative means back from end */
const posrelat = function(pos, len) {
if (pos >= 0) return pos;
@@ -350,6 +354,256 @@ const str_format = function(L) {
return 1;
};
+/* value used for padding */
+const LUAL_PACKPADBYTE = 0x00;
+
+/* maximum size for the binary representation of an integer */
+const MAXINTSIZE = 16;
+
+const SZINT = 8; // Size of lua_Integer
+
+/* number of bits in a character */
+const NB = 8;
+
+/* mask for one character (NB 1's) */
+const MC = ((1 << NB) - 1)
+
+/*
+** information to pack/unpack stuff
+*/
+class Header {
+ constructor(L) {
+ this.L = L;
+ this.islittle = true;
+ this.maxalign = 1;
+ }
+}
+
+/*
+** options for pack/unpack
+*/
+const KOption = {
+ Kint: 0, /* signed integers */
+ Kuint: 1, /* unsigned integers */
+ Kfloat: 2, /* floating-point numbers */
+ Kchar: 3, /* fixed-length strings */
+ Kstring: 4, /* strings with prefixed length */
+ Kzstr: 5, /* zero-terminated strings */
+ Kpadding: 6, /* padding */
+ Kpaddalign: 7, /* padding for alignment */
+ Knop: 8 /* no-op (configuration or spaces) */
+};
+
+const digit = function(c) {
+ return '0'.charCodeAt(0) <= c && c <= '9'.charCodeAt(0);
+};
+
+const getnum = function(fmt, df) {
+ if (!digit(fmt)) /* no number? */
+ return df; /* return default value */
+ else {
+ let a = 0;
+ do {
+ a = a * 10 + ((fmt = fmt.slice(1))[0] - '0'.charCodeAt(0));
+ } while (digit(fmt[0]) && a <= (MAXSIZE - 9)/10);
+ return a;
+ }
+};
+
+/*
+** Read an integer numeral and raises an error if it is larger
+** than the maximum size for integers.
+*/
+const getnumlimit = function(h, fmt, df) {
+ let sz = getnum(fmt, df);
+ if (sz > MAXINTSIZE || sz <= 0)
+ lauxlib.luaL_error(h.L, `integral size (${sz}) out of limits [1,${MAXINTSIZE}]`);
+ return sz;
+};
+
+/*
+** Read and classify next option. 'size' is filled with option's size.
+*/
+const getoption = function(h, fmt) {
+ let r = {
+ opt: NaN,
+ size: NaN
+ };
+
+ r.opt = (fmt = fmt.slice(1))[0];
+ r.size = 0; /* default */
+ switch (r.opt) {
+ case 'b': r.size = 1; r.opt = KOption.Kint; return r; // sizeof(char): 1
+ case 'B': r.size = 1; r.opt = KOption.Kuint; return r;
+ case 'h': r.size = 2; r.opt = KOption.Kint; return r; // sizeof(short): 2
+ case 'H': r.size = 2; r.opt = KOption.Kuint; return r;
+ case 'l': r.size = 8; r.opt = KOption.Kint; return r; // sizeof(long): 8
+ case 'L': r.size = 8; r.opt = KOption.Kuint; return r;
+ case 'j': r.size = 8; r.opt = KOption.Kint; return r; // sizeof(lua_Integer): 8
+ case 'J': r.size = 8; r.opt = KOption.Kuint; return r;
+ case 'T': r.size = 8; r.opt = KOption.Kuint; return r; // sizeof(size_t): 8
+ case 'f': r.size = 4; r.opt = KOption.Kfloat; return r; // sizeof(float): 4
+ case 'd': r.size = 8; r.opt = KOption.Kfloat; return r; // sizeof(double): 8
+ case 'n': r.size = 8; r.opt = KOption.Kfloat; return r; // sizeof(lua_Number): 8
+ case 'i': r.size = getnumlimit(h, fmt, 4); r.opt = KOption.Kint; return r; // sizeof(int): 4
+ case 'I': r.size = getnumlimit(h, fmt, 4); r.opt = KOption.Kuint; return r;
+ case 's': r.size = getnumlimit(h, fmt, 8); r.opt = KOption.Kstring; return r;
+ }
+
+ r.opt = KOption.Knop;
+ return r;
+};
+
+/*
+** Read, classify, and fill other details about the next option.
+** 'psize' is filled with option's size, 'notoalign' with its
+** alignment requirements.
+** Local variable 'size' gets the size to be aligned. (Kpadal option
+** always gets its full alignment, other options are limited by
+** the maximum alignment ('maxalign'). Kchar option needs no alignment
+** despite its size.
+*/
+const getdetails = function(h, totalsize, fmt) {
+ let r = {
+ opt: NaN,
+ size: NaN,
+ ntoalign: NaN
+ };
+
+ let opt = getoption(h, fmt);
+ r.size = opt.size;
+ r.opt = opt.opt;
+ let align = r.size; /* usually, alignment follows size */
+ if (opt === KOption.Kpaddalign) { /* 'X' gets alignment from following option */
+ if (fmt[0] === 0)
+ lauxlib.luaL_argerror(h.L, 1, "invalid next option for option 'X'");
+ else {
+ let o = getoption(h, fmt);
+ align = o.size;
+ o = o.opt;
+ if (o === KOption.Kchar || align === 0)
+ lauxlib.luaL_argerror(h.L, 1, "invalid next option for option 'X'");
+ }
+ }
+ if (align <= 1 || opt === KOption.Kchar) /* need no alignment? */
+ r.ntoalign = 0;
+ else {
+ if (align > h.maxalign) /* enforce maximum alignment */
+ align = h.maxalign;
+ if ((align & (align -1)) !== 0) /* is 'align' not a power of 2? */
+ lauxlib.luaL_argerror(h.L, 1, "format asks for alignment not power of 2");
+ r.ntoalign = (align - (totalsize & (align - 1))) & (align - 1);
+ }
+ return r;
+};
+
+/*
+** Pack integer 'n' with 'size' bytes and 'islittle' endianness.
+** The final 'if' handles the case when 'size' is larger than
+** the size of a Lua integer, correcting the extra sign-extension
+** bytes if necessary (by default they would be zeros).
+*/
+const packint = function(b, n, islittle, size, neg) {
+ let buff = new Array(size);
+
+ buff[islittle ? 0 : size - 1] = n & MC; /* first byte */
+ for (let i = 1; i < size; i++) {
+ n >>= NB;
+ buff[islittle ? i : size - 1 - i] = n & MC;
+ }
+ if (neg && size > SZINT) { /* negative number need sign extension? */
+ for (let i = SZINT; i < size; i++) /* correct extra bytes */
+ buff[islittle ? i : size - 1 - i] = MC;
+ }
+ b.concat(buff); /* add result to buffer */
+};
+
+const packnum = function(b, n, islittle, size) {
+ let dv = new DataView(new ArrayBuffer(size));
+ dv.setFloat64(0, n, islittle);
+
+ for (let i = 0; i < 8; i++)
+ b.push(dv.getUint8(i, islittle));
+};
+
+const str_pack = function(L) {
+ let b = [];
+ let h = new Header();
+ let fmt = lauxlib.luaL_checkstring(L, 1); /* format string */
+ let arg = 1; /* current argument to pack */
+ let totalsize = 0; /* accumulate total size of result */
+ lapi.lua_pushnil(L); /* mark to separate arguments from string buffer */
+ while (fmt.length > 0) {
+ let details = getdetails(h, totalsize, fmt);
+ let opt = details.opt;
+ let size = details.size;
+ let ntoalign = details.ntoalign;
+ totalsize += ntoalign + size;
+ while (ntoalign-- > 0)
+ b.push(LUAL_PACKPADBYTE); /* fill alignment */
+ arg++;
+ switch (opt) {
+ case KOption.Kint: { /* signed integers */
+ let n = lauxlib.luaL_checkinteger(L, arg);
+ if (size < SZINT) { /* need overflow check? */
+ let lim = 1 << (size * 8) - 1;
+ lauxlib.luaL_argcheck(L, -lim <= n && n < lim, arg, "integer overflow");
+ }
+ packint(b, n, h.islittle, size, n < 0);
+ break;
+ }
+ case KOption.Kuint: { /* unsigned integers */
+ let n = lauxlib.luaL_checkinteger(L, arg);
+ if (size < SZINT)
+ lauxlib.luaL_argcheck(L, n < (1 << (size * NB)), arg, "unsigned overflow");
+ packint(b, n, h.islittle, size, false);
+ break;
+ }
+ case KOption.Kfloat: { /* floating-point options */
+ let n = lauxlib.luaL_checknumber(L, arg); /* get argument */
+ packnum(b, n, h.islittle, size);
+ break;
+ }
+ case KOption.Kchar: { /* fixed-size string */
+ let s = lauxlib.luaL_checkstring(L, arg);
+ s = L.stack[lapi.index2addr_(L, arg)].value;
+ let len = s.value.length;
+ lauxlib.luaL_argcheck(L, len <= size, arg, "string long than given size");
+ b.concat(s.value); /* add string */
+ while (len++ < size) /* pad extra space */
+ b.push(LUAL_PACKPADBYTE);
+ break;
+ }
+ case KOption.Kstring: { /* strings with length count */
+ let s = lauxlib.luaL_checkstring(L, arg);
+ s = L.stack[lapi.index2addr_(L, arg)].value;
+ let len = s.value.length;
+ lauxlib.luaL_argcheck(L, size >= NB || len < (1 << size * NB), arg, "string length does not fit in given size");
+ packint(b, len, h.islittle, size, 0); /* pack length */
+ b.concat(s.value);
+ totalsize += len;
+ break;
+ }
+ case KOption.Kzstr: { /* zero-terminated string */
+ let s = lauxlib.luaL_checkstring(L, arg);
+ s = L.stack[lapi.index2addr_(L, arg)].value;
+ let len = s.value.length;
+ lauxlib.luaL_argcheck(L, s.value.length === String.fromCharCode(...s.value).length, arg, "strings contains zeros");
+ b.concat(s.value);
+ b.push(0); /* add zero at the end */
+ totalsize += len + 1;
+ break;
+ }
+ case KOption.Kpadding: b.push(LUAL_PACKPADBYTE);
+ case KOption.Kpaddalign: case KOption.Knop:
+ arg--; /* undo increment */
+ break;
+ }
+ }
+ L.stack[L.top++] = new lobject.TValue(CT.LUA_TLNGSTR, b); // We don't want lua > js > lua string conversion here
+ return 1;
+};
+
const str_reverse = function(L) {
lapi.lua_pushstring(L, lauxlib.luaL_checkstring(L, 1).split("").reverse().join(""));
return 1;
@@ -401,6 +655,7 @@ const strlib = {
"format": str_format,
"len": str_len,
"lower": str_lower,
+ "pack": str_pack,
"rep": str_rep,
"reverse": str_reverse,
"sub": str_sub,