Included a minimal json lib in yue compiler tool.

3 files changed, 930 insertions, 1 deletions

diff --git a/src/3rdParty/colib/LICENSE b/src/3rdParty/colib/LICENSE
new file mode 100755
index 0000000..e0eddeb
--- /dev/null
+++ b/src/3rdParty/colib/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 colin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/3rdParty/colib/ljson.c b/src/3rdParty/colib/ljson.c
new file mode 100755
index 0000000..78f9070
--- /dev/null
+++ b/src/3rdParty/colib/ljson.c
@@ -0,0 +1,900 @@
+/**
+ * json解析器：只支持utf-8格式，Lua只支持64位的数字
+ */
+#define LUA_LIB
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <assert.h>
+#include <errno.h>
+#include <setjmp.h>
+#include <ctype.h>
+#include <limits.h>
+#include <float.h>
+#include <math.h>
+#include "lua.h"
+#include "lauxlib.h"
+
+// 内存分配函数，方便替换
+#define co_malloc malloc
+#define co_free free
+#define co_realloc realloc
+#define co_calloc calloc
+
+
+#if !defined(likely)
+#if defined(__GNUC__)
+#define likely(x)       (__builtin_expect(((x) != 0), 1))
+#define unlikely(x)     (__builtin_expect(((x) != 0), 0))
+#else
+#define likely(x)       (x)
+#define unlikely(x)     (x)
+#endif
+
+#endif
+
+//-----------------------------------------------------------------------------
+// membuffer
+
+#define STACK_BUFF_SIZE 512
+
+typedef struct membuffer {
+        char *b;                // 内存buffer
+        size_t sz;              // buffer已用长度
+        size_t cap;             // buffer实际大小
+        char s[STACK_BUFF_SIZE];
+} membuffer_t;
+
+// 初始化buffer
+static inline void membuffer_init(membuffer_t *buff) {
+        buff->b = buff->s;
+        buff->cap = STACK_BUFF_SIZE;
+        buff->sz = 0;
+}
+
+static inline void membuffer_add_size(membuffer_t *buff, size_t sz) {
+        buff->sz += sz;
+}
+
+static inline void membuffer_reset(membuffer_t *buff) {
+        buff->sz = 0;
+}
+
+static inline void membuffer_free(membuffer_t *buff) {
+        if (buff->b && buff->b != buff->s) {
+                co_free(buff->b);
+                buff->b = NULL;
+        }
+}
+
+static inline void _membuffer_grow(membuffer_t *buff, size_t needsz) {
+        if (buff->cap < needsz) {
+                size_t newcap = buff->cap * 2;
+                if (newcap < needsz)
+                        newcap = needsz;
+                if (buff->b == buff->s) {
+                        buff->b = (char*)co_malloc(newcap);
+                        memcpy(buff->b, buff->s, buff->sz);
+                } else {
+                        buff->b = (char*)co_realloc(buff->b, newcap);
+                }
+                buff->cap = newcap;
+        }
+}
+
+// 确保缓存中还有sz的可用空间
+static inline void membuffer_ensure_space(membuffer_t *buff, size_t sz) {
+        if (buff->sz + sz > buff->cap) {
+                _membuffer_grow(buff, buff->sz+sz);
+        }
+}
+
+// 压入一个字符
+static inline void membuffer_putc(membuffer_t *buff, char c) {
+        membuffer_ensure_space(buff, 1);
+        buff->b[buff->sz++] = c;
+}
+
+// 写入一段内存
+static inline void membuffer_putb(membuffer_t *buff, const void *b, size_t sz) {
+        membuffer_ensure_space(buff, sz);
+        memcpy(buff->b + buff->sz, b, sz);
+        buff->sz += sz;
+}
+
+// 压入一个字符：不检查空间(不安全版本)
+static inline void membuffer_putc_unsafe(membuffer_t *buff, char c) {
+        buff->b[buff->sz++] = c;
+}
+
+// 写入一段内存：不检查空间(不安全版本)
+static inline void membuffer_putb_unsafe(membuffer_t *buff, const void *b, size_t sz) {
+        memcpy(buff->b + buff->sz, b, sz);
+        buff->sz += sz;
+}
+
+// 取当前的指针
+static inline char* membuffer_getp(membuffer_t *buff) {
+        return buff->b + buff->sz;
+}
+
+//-----------------------------------------------------------------------------
+// parser
+
+//-------------------------------------
+// 与Lua相关的代码
+
+static inline void l_add_object(lua_State *L) {
+        luaL_checkstack(L, 6, NULL);
+        lua_createtable(L, 0, 4);
+}
+static inline void l_begin_pair(lua_State *L, const char *k, size_t sz) {
+        lua_pushlstring(L, k, sz);
+}
+static inline void l_end_pair(lua_State *L) {
+        lua_rawset(L, -3);
+}
+static inline void l_add_array(lua_State *L) {
+        luaL_checkstack(L, 6, NULL);
+        lua_createtable(L, 4, 0);
+}
+static inline void l_add_index(lua_State *L, int i) {
+        lua_rawseti(L, -2, i+1);
+}
+static inline void l_add_string(lua_State *L, const char *s, size_t sz) {
+        lua_pushlstring(L, s, sz);
+}
+static inline void l_add_float(lua_State *L, double f) {
+        lua_pushnumber(L, (lua_Number)f);
+}
+static inline void l_add_integer(lua_State *L, int64_t i) {
+        lua_pushinteger(L, (lua_Integer)i);
+}
+static inline void l_add_boolean(lua_State *L, int b) {
+        lua_pushboolean(L, b);
+}
+static inline void l_add_null(lua_State *L) {
+        lua_pushlightuserdata(L, NULL);
+}
+static inline void l_error(lua_State *L, const char *msg) {
+        luaL_error(L, msg);
+}
+
+// 解析事件
+#define ON_ADD_OBJECT(ud) l_add_object((lua_State*)(ud))
+#define ON_BEGIN_PAIR(ud, k, sz) l_begin_pair((lua_State*)(ud), k, sz)
+#define ON_END_PAIR(ud) l_end_pair((lua_State*)(ud))
+#define ON_ADD_ARRAY(ud) l_add_array((lua_State*)(ud))
+#define ON_ADD_INDEX(ud, i) l_add_index((lua_State*)(ud), i)
+#define ON_ADD_STRING(ud, s, sz) l_add_string((lua_State*)(ud), s, sz)
+#define ON_ADD_FLOAT(ud, f) l_add_float((lua_State*)(ud), f)
+#define ON_ADD_INTEGER(ud, i) l_add_integer((lua_State*)(ud), i)
+#define ON_ADD_BOOLEAN(ud, b) l_add_boolean((lua_State*)(ud), b)
+#define ON_ADD_NULL(ud) l_add_null((lua_State*)(ud))
+#define ON_ERROR(ud, msg) l_error((lua_State*)(ud), msg)
+
+//-------------------------------------
+// 解析json，这部分代码与Lua无关，是通用的解析器；如果要移植这部分代码，需要把 //>>> 开头的注释去掉
+
+// 错误消息的大小
+#define ERRMSG_SIZE 256
+
+// json解析器
+typedef struct {
+        const char *str;        // json字符串
+        const char *ptr;        // json字符串解析指针
+        void *ud;                       // 解析事件的用户数据
+        membuffer_t buff;       // 临时缓存
+        int curdepth;   // 当前层次
+        int maxdepth;   // 最大层次
+        int allowcomment; // 是否允许注释
+        char errmsg[ERRMSG_SIZE];       // 保存错误消息 
+        //>>>jmp_buf jb;                        // 用于实现从解析中出错直接跳出
+} json_parser_t;
+
+static inline void parser_init(json_parser_t *parser, const char *str, size_t size, void *ud,  
+        int maxdepth, int allowcomment) {
+        membuffer_init(&parser->buff);
+        membuffer_ensure_space(&parser->buff, size);
+        parser->str = str;
+        parser->ptr = str;
+        parser->ud = ud;
+        parser->maxdepth = maxdepth;
+        parser->curdepth = 0;
+        parser->allowcomment = allowcomment;
+}
+
+static inline void parser_free(json_parser_t *parser) {
+        membuffer_free(&parser->buff);
+}
+
+// 抛出错误
+static void parser_throw_error(json_parser_t *parser, const char *fmt, ...) {
+        membuffer_free(&parser->buff);
+        va_list arg;
+        va_start(arg, fmt);
+        vsnprintf(parser->errmsg, ERRMSG_SIZE, fmt, arg);
+        va_end(arg);
+        ON_ERROR(parser->ud, parser->errmsg);
+        // 直接跳出解析代码，由于Lua的lua_error也是用longjmp，所以下面的代码没有机会执行到。但其他语言就不一定。
+        //>>>longjmp(parser->jb, 1);
+}
+
+// 辅助宏
+#define peekchar(p) (*(p)->ptr)
+#define skipchar(p) (++(p)->ptr)
+#define get_and_next(p) (*(p)->ptr++)
+#define next_and_get(p) (*(++(p)->ptr))
+#define savechar(p, c) membuffer_putc_unsafe(&(p)->buff, (c))
+#define currpos(p) (size_t)((p)->ptr - (p)->str)
+
+// 取解析到的错误内容
+static const char* parser_error_content(json_parser_t *p) {
+        size_t n = currpos(p);
+        if (n > 50) n = 50;     // 调整这个数获得更长的内容
+        membuffer_reset(&p->buff);
+        membuffer_putb(&p->buff, p->ptr - n, n);
+        membuffer_putc(&p->buff, '\0');
+        return p->buff.b;
+}
+
+// 增加深度
+static inline void parser_add_depth(json_parser_t *p) {
+        p->curdepth++;
+        if (p->curdepth >= p->maxdepth)
+                parser_throw_error(p, "Too many nested data, max depth is %d, at: %s[:%lu]", p->maxdepth, 
+                        parser_error_content(p), currpos(p));
+}
+
+static inline void parser_skip_whitespaces(json_parser_t *p) {
+        // colin: 要支持注释，请将下面注释去掉
+        // if (likely(!p->allowcomment)) {
+                char ch = peekchar(p);
+                while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')
+                        ch = next_and_get(p);
+        // } else {
+        //      char ch = peekchar(p);
+        //      for (;;) {
+        //              while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')
+        //                      ch = next_and_get(p);
+        //              if (ch == '/') {
+        //                      ch = next_and_get(p);
+        //                      if (ch == '/') {
+        //                              ch = next_and_get(p);
+        //                              while (ch != '\n' && ch != '\r' && ch != '\0')
+        //                                      ch = next_and_get(p);
+        //                              continue;
+        //                      } else {
+        //                              parser_throw_error(p, "Invalid comment, at: %s[:%lu]", parser_error_content(p), currpos(p));
+        //                      }
+        //              }
+        //              break;
+        //      }
+        // }
+}
+
+static inline void parser_expect_char(json_parser_t *p, char c) {
+        if (likely(peekchar(p) == c))
+                skipchar(p);
+        else
+                parser_throw_error(p, "Expect '%c' at: %s[:%lu]", c, parser_error_content(p), currpos(p));
+}
+
+static inline void parser_process_false(json_parser_t *p) {
+        if (likely(p->ptr[0] == 'a' && p->ptr[1] == 'l' && p->ptr[2] == 's' && p->ptr[3] == 'e')) {
+                p->ptr += 4;
+                ON_ADD_BOOLEAN(p->ud, 0);
+        } else {
+                parser_throw_error(p, "Invalid boolean, at: %s[:%lu]", parser_error_content(p), currpos(p));
+        }
+}
+
+static inline void parser_process_true(json_parser_t *p) {
+        if (likely(p->ptr[0] == 'r' && p->ptr[1] == 'u' && p->ptr[2] == 'e')) {
+                p->ptr += 3;
+                ON_ADD_BOOLEAN(p->ud, 1);
+        } else {
+                parser_throw_error(p, "Invalid boolean, at: %s[:%lu]", parser_error_content(p), currpos(p));
+        }
+}
+
+static inline void parser_process_null(json_parser_t *p) {
+        if (likely(p->ptr[0] == 'u' && p->ptr[1] == 'l' && p->ptr[2] == 'l')) {
+                p->ptr += 3;
+                ON_ADD_NULL(p->ud);
+        } else {
+                parser_throw_error(p, "Invalid null, at: %s[:%lu]", parser_error_content(p), currpos(p));
+        }
+}
+
+static inline uint32_t parser_read_hex(json_parser_t *p) {
+        uint32_t cp = 0;
+        unsigned char ch;
+        int i = 4;
+        while (i--) {
+                ch = (unsigned char)get_and_next(p);
+                if ('0' <= ch && ch <= '9')
+                        ch -= '0';
+                else if (ch >= 'a' && ch <= 'f')
+                        ch = ch - 'a' + 10;
+                else if (ch >= 'A' && ch <= 'F')
+                        ch = ch - 'A' + 10;
+                else {
+                        parser_throw_error(p, "Invalid utf8 escape sequence, at: %s[:%lu]", parser_error_content(p), currpos(p));
+                        return cp;
+                }
+                cp = (cp << 4) + ch;
+        }
+        return cp;
+}
+
+static inline void parser_process_utf8esc(json_parser_t *p) {
+        uint32_t cp = parser_read_hex(p);
+        // UTF-16 surrogate pairs, see https://unicodebook.readthedocs.io/unicode_encodings.html#utf-16-surrogate-pairs
+        if (cp >= 0xD800 && cp <= 0xDBFF) {
+                char p0 = p->ptr[0];
+                char p1 = p->ptr[1];
+                if (p0 != '\\' || p1 != 'u')
+                        parser_throw_error(p, "Invalid utf8 escape sequence, at: %s[:%lu]", parser_error_content(p), currpos(p));
+                p->ptr += 2;
+                uint32_t cp2 = parser_read_hex(p);
+                if (cp2 < 0xDC00 || cp2 > 0xDFFF)
+                        parser_throw_error(p, "Invalid utf8 escape sequence, at: %s[:%lu]", parser_error_content(p), currpos(p));
+                cp = 0x10000 + (((cp & 0x03FF) << 10) | (cp2 & 0x03FF));
+        }
+        if (cp < 0x80) {
+                membuffer_putc_unsafe(&p->buff, (char)cp);
+        } else if (cp < 0x800) {
+                membuffer_putc_unsafe(&p->buff, 0xC0 | (cp >> 6));
+                membuffer_putc_unsafe(&p->buff, 0x80 | (cp & 0x3F));
+        } else if (cp < 0x10000) {
+                membuffer_putc_unsafe(&p->buff, 0xE0 | (cp >> 12));
+                membuffer_putc_unsafe(&p->buff, 0x80 | ((cp >> 6) & 0x3F));
+                membuffer_putc_unsafe(&p->buff, 0x80 | (cp & 0x3F));
+        } else {
+                membuffer_putc_unsafe(&p->buff, 0xF0 | (cp >> 18));
+                membuffer_putc_unsafe(&p->buff, 0x80 | ((cp >> 12) & 0x3F));
+                membuffer_putc_unsafe(&p->buff, 0x80 | ((cp >> 6) & 0x3F));
+                membuffer_putc_unsafe(&p->buff, 0x80 | (cp & 0x3F));
+        }
+}
+
+static const char escape2char[256] = {
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 0~19
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0, '\"',0,  0,  0,  0,  0,  // 20~39
+        0,  0,  0,  0,  0,  0,  0, '/', 0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 40~59
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 60~79
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0, '\\',0,  0,  0,  0,  0, '\b',0,  // 80~99
+        0,  0, '\f',0,  0,  0,  0,  0,  0,  0,  '\n',0,  0,  0, '\r',0, '\t',0,  0,  0,  // 100~119
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 120~139
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 140~159
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 160~179
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 180~199
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 200~219
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 220~239
+        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0,                  // 240~256
+};
+
+static inline void parser_process_string(json_parser_t *p) {
+        membuffer_reset(&p->buff);
+        char ch = get_and_next(p);
+        for (;;) {
+                if (ch == '\\') {
+                        unsigned char nch = (unsigned char)peekchar(p);
+                        if (likely(escape2char[nch])) {
+                                savechar(p, escape2char[nch]);
+                                skipchar(p);
+                        } else if (nch == 'u') {
+                                skipchar(p);
+                                parser_process_utf8esc(p);
+                        } else {
+                                parser_throw_error(p, "Invalid escape sequence, at: %s[:%lu]", parser_error_content(p), currpos(p));
+                        }
+                } else if (ch == '"') { 
+                        break;
+                } else if ((unsigned char)ch < 0x20) {
+                        parser_throw_error(p, "Invalid string, at: %s[:%lu]", parser_error_content(p), currpos(p));
+                } else {
+                        savechar(p, ch);
+                }
+                ch = get_and_next(p);
+        }
+}
+
+#define invalid_number(p) parser_throw_error(p, "Invalid value, at: %s[:%lu]", parser_error_content(p), currpos(p))
+#define MAXBY10         (int64_t)(922337203685477580)
+#define MAXLASTD        (int)(7)
+static double powersOf10[] = {10., 100., 1.0e4, 1.0e8, 1.0e16, 1.0e32, 1.0e64, 1.0e128, 1.0e256};
+static inline void parser_process_number(json_parser_t *p, char ch) {
+        double db;                              // 浮点数
+        int64_t in = 0;                 // 整型值
+        int isdouble = 0;               // 是否是浮点数
+        int neg = 0;                    // 是否是负数
+        int exponent = 0;               // 指数位数
+
+        if (ch == '-') {        // 负值
+                neg = 1;
+                ch = get_and_next(p);
+        }
+        if (unlikely(ch == '0')) {      // 0开头的后面只能是：.eE或\0
+                ch = peekchar(p);
+        } else if (likely(ch >= '1' && ch <= '9')) {
+                in = ch - '0';
+                ch = peekchar(p);
+                while (ch >= '0' && ch <= '9') {
+                        if (unlikely(in >= MAXBY10 && (in > MAXBY10 || (ch - '0') > MAXLASTD + neg))) { // 更大的数字就用浮点数表示
+                                isdouble = 1;
+                                db = (double)in;
+                                do {
+                                        db = db * 10.0 + (ch - '0');
+                                        ch = next_and_get(p);
+                                } while (ch >= '0' && ch <= '9');
+                                break;
+                        }
+                        in = in * 10 + (ch - '0');
+                        ch = next_and_get(p);
+                }
+        } else {
+                invalid_number(p);
+        }
+
+        if (ch == '.') {        // 小数点部分
+                if (likely(!isdouble)) {
+                        isdouble = 1;
+                        db = (double)in;
+                }
+                ch = next_and_get(p);
+                if (unlikely(!(ch >= '0' && ch <= '9')))
+                        invalid_number(p);  // .后面一定是数字
+                do {
+                        db = db * 10. + (ch - '0');
+                        exponent--;
+                        ch = next_and_get(p);
+                } while (ch >= '0' && ch <= '9');
+        }
+
+        if (ch == 'e' || ch == 'E') {   // 指数部分
+                if (!isdouble) {                // 有e强制认为是浮点数
+                        isdouble = 1;
+                        db = (double)in;
+                }
+                ch = next_and_get(p);
+                int eneg = 0;
+                if (ch == '-') {
+                        eneg = 1;
+                        ch = next_and_get(p);
+                } else if (ch == '+') {
+                        ch = next_and_get(p);
+                }
+                if (unlikely(!(ch >= '0' && ch <= '9')))
+                        invalid_number(p);  // 后面一定是数字
+                int exp = 0;
+                do {
+                        exp = exp * 10. + (ch - '0');
+                        ch = next_and_get(p);
+                } while (ch >= '0' && ch <= '9');
+                exponent += eneg ? (-exp) : (exp);
+        }
+
+        if (isdouble) {
+                int n = exponent < 0 ? -exponent : exponent;
+                if (unlikely(n>511)) 
+                        n = 511;        // inf
+                double p10 = 1.0;
+                double *d;
+                for (d = powersOf10; n != 0; n >>= 1, d += 1) {
+                        if (n & 1) p10 *= *d;
+                }
+                if (exponent < 0)
+                        db /= p10;
+                else
+                        db *= p10;
+                if (neg) db = -db;
+                ON_ADD_FLOAT(p->ud, db);
+        } else {
+                if (neg) in = -in;
+                ON_ADD_INTEGER(p->ud, in);
+        }
+}
+
+static void parser_process_value(json_parser_t *p);
+
+static inline void parser_process_object(json_parser_t *p) {
+        parser_add_depth(p);
+        ON_ADD_OBJECT(p->ud);
+        parser_skip_whitespaces(p);
+        char ch = peekchar(p);
+        if (ch == '}') {
+                skipchar(p);
+                p->curdepth--;
+                return;
+        }
+        for (;;) {
+                parser_expect_char(p, '"');
+                parser_process_string(p);               // key
+                ON_BEGIN_PAIR(p->ud, p->buff.b, p->buff.sz);
+
+                parser_skip_whitespaces(p);
+                parser_expect_char(p, ':');
+
+                parser_process_value(p);                        // value
+                ON_END_PAIR(p->ud);
+
+                parser_skip_whitespaces(p);
+                if (peekchar(p) == '}') {
+                        skipchar(p);
+                        p->curdepth--;
+                        return;
+                }
+                else {
+                        parser_expect_char(p, ',');
+                        parser_skip_whitespaces(p);
+                }
+        }
+}
+
+static inline void parser_process_array(json_parser_t *p) {
+        parser_add_depth(p);
+        ON_ADD_ARRAY(p->ud);
+        parser_skip_whitespaces(p);
+        char ch = peekchar(p);
+        if (ch == ']') {
+                skipchar(p);
+                p->curdepth--;
+                return;
+        }
+        int i;
+        for (i = 0; ;++i) {
+                parser_process_value(p);
+                ON_ADD_INDEX(p->ud, i);
+
+                parser_skip_whitespaces(p);
+                if (peekchar(p) == ']') {
+                        skipchar(p);
+                        p->curdepth--;
+                        return;
+                }
+                else {
+                        parser_expect_char(p, ',');
+                }
+        }
+}
+
+static void parser_process_value(json_parser_t *p) {
+        parser_skip_whitespaces(p);
+        char ch = get_and_next(p);
+        switch (ch) {
+                case 'f': 
+                        parser_process_false(p);
+                        break;
+                case 't':
+                        parser_process_true(p);
+                        break;
+                case 'n': 
+                        parser_process_null(p);
+                        break;
+                case '"':
+                        parser_process_string(p);
+                        ON_ADD_STRING(p->ud, p->buff.b, p->buff.sz);
+                        break;
+                case '{':
+                        parser_process_object(p);
+                        break;
+                case '[':
+                        parser_process_array(p);
+                        break;
+                default:
+                        parser_process_number(p, ch);
+                        break;
+        }
+}
+
+// 解析json文本
+static void parser_do_parse(const char *str, size_t size, void *ud, int maxdepth, int allowcomment) {
+        json_parser_t p;
+        parser_init(&p, str, size, ud, maxdepth, allowcomment);
+        //>>>if (setjmp(p.jb) == 0) {
+                parser_process_value(&p);
+                parser_skip_whitespaces(&p);
+                if (peekchar(&p) != '\0') {
+                        parser_throw_error(&p, "Expect '<eof>' but got '%c', at: %s[:%lu]", peekchar(&p), 
+                                parser_error_content(&p), currpos(&p));
+                }
+                parser_free(&p);
+        //>>>}
+}
+
+//-----------------------------------------------------------------------------
+// dumpper
+
+typedef struct {
+        membuffer_t buff;       // 临时缓存
+        int maxdepth;   // 最大层次
+        int format;                     // 是否格式化
+        int empty_as_array; // 空表是否当成数组
+        int num_as_str;         // 数字Key转为字符串
+        char errmsg[ERRMSG_SIZE];       // 保存错误消息 
+} json_dumpper_t;
+
+// 足够转换数字的缓存大小
+#define NUMBER_BUFF_SZ 44
+#define INTEGER_BUFF_SZ 24
+
+// 抛出错误
+static void dumpper_throw_error(json_dumpper_t *d, lua_State *L, const char *fmt, ...) {
+        membuffer_free(&d->buff);
+        va_list arg;
+        va_start(arg, fmt);
+        vsnprintf(d->errmsg, ERRMSG_SIZE, fmt, arg);
+        va_end(arg);
+        luaL_error(L, d->errmsg);
+}
+
+static void dumpper_process_integer(json_dumpper_t *d, lua_State *L, int idx) {
+        char nbuff[INTEGER_BUFF_SZ];
+        int i = INTEGER_BUFF_SZ;
+        membuffer_ensure_space(&d->buff, INTEGER_BUFF_SZ);
+        int64_t x = (int64_t)lua_tointeger(L, idx);
+        uint64_t ux = (uint64_t)x;
+        if (x < 0) {
+                membuffer_putc_unsafe(&d->buff, '-');
+                ux = ~ux + 1;
+        }
+        do {
+                nbuff[--i] = (ux % 10) + '0';
+        } while (ux /= 10);
+        membuffer_putb_unsafe(&d->buff, nbuff+i, INTEGER_BUFF_SZ-i);
+}
+
+static void dumpper_process_number(json_dumpper_t *d, lua_State *L, int idx) {
+        lua_Number num = lua_tonumber(L, idx);
+         if (isinf(num) || isnan(num))
+                 dumpper_throw_error(d, L, "The number is NaN or Infinity");
+        membuffer_ensure_space(&d->buff, NUMBER_BUFF_SZ);
+        char *p = membuffer_getp(&d->buff);
+        int len = sprintf(p, LUA_NUMBER_FMT, num);
+        membuffer_add_size(&d->buff, len);
+}
+
+// 字符转义表
+static const char char2escape[256] = {
+        'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't',  'n', 'u', 'f', 'r', 'u', 'u', 'u', 'u', 'u', 'u', // 0~19
+        'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u', 'u',  0,   0,  '"',   0,   0,   0,   0,   0, // 20~39
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  // 40~59
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  // 60~79
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,  '\\', 0,   0,   0,   0,   0,   0,   0,  // 80~99
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  // 100~119
+         0,   0,   0,   0,   0,   0,   0,  'u',  0,   0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  // 120~139
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  // 140~159
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  // 160~179
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  // 180~199
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  // 200~219
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  // 220~239
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,                      // 240~256
+};
+static const char hex_digits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+
+static void dumpper_process_string(json_dumpper_t *d, lua_State *L, int idx) {
+        membuffer_t *buff = &d->buff;
+        size_t len, i;
+        const char *str = lua_tolstring(L, idx, &len);
+        membuffer_ensure_space(buff, len * 6 + 2);
+        membuffer_putc_unsafe(buff, '\"');
+        char esc;
+        unsigned char ch;
+        for (i = 0; i < len; ++i) {
+                ch = (unsigned char)str[i];
+                esc = char2escape[ch];
+                if (likely(!esc)) 
+                        membuffer_putc_unsafe(buff, (char)ch);
+                else {
+                        membuffer_putc_unsafe(buff, '\\');
+                        membuffer_putc_unsafe(buff, esc);
+                        if (esc == 'u') {
+                                membuffer_putc_unsafe(buff, '0');
+                                membuffer_putc_unsafe(buff, '0');
+                                membuffer_putc_unsafe(buff, hex_digits[(unsigned char)esc >> 4]);
+                                membuffer_putc_unsafe(buff, hex_digits[(unsigned char)esc & 0xF]);
+                        }
+                }
+        }
+        membuffer_putc_unsafe(buff, '\"');
+}
+
+static void dumpper_process_value(json_dumpper_t *d, lua_State *L, int depth);
+
+static int dumpper_check_array(json_dumpper_t *d, lua_State *L, int *len) {
+        int asize = lua_rawlen(L, -1);
+        if (asize > 0) {
+                lua_pushinteger(L, asize);
+                if (lua_next(L, -2) == 0) {
+                        *len = asize;
+                        return 1;
+                } else {
+                        lua_pop(L, 2);
+                        return 0;
+                }
+        } else {
+                lua_pushnil(L);
+                if (lua_next(L, -2) == 0) {
+                        *len = asize;
+                        return d->empty_as_array;
+                } else {
+                        lua_pop(L, 2);
+                        return 0;
+                }
+        }
+}
+
+static inline void dumpper_add_indent(json_dumpper_t *d, int count) {
+        membuffer_ensure_space(&d->buff, count);
+        int i;
+        for (i = 0; i < count; ++i)
+                membuffer_putc_unsafe(&d->buff, '\t');
+}
+
+static void dumpper_process_array(json_dumpper_t *d, lua_State *L, int len, int depth) {
+        membuffer_t *buff = &d->buff;
+        membuffer_putc(buff, '[');
+
+        int i;
+        for (i = 1; i <= len; ++i) {
+                if (unlikely(d->format && i == 1)) membuffer_putc(buff, '\n');
+                lua_rawgeti(L, -1, i);
+                if (unlikely(d->format)) dumpper_add_indent(d, depth);
+                dumpper_process_value(d, L, depth);
+                lua_pop(L, 1);
+                if (i < len)
+                        membuffer_putc(buff, ',');
+                if (unlikely(d->format)) membuffer_putc(buff, '\n');
+        }
+
+        if (unlikely(d->format && i > 1))  dumpper_add_indent(d, depth-1);
+        membuffer_putc(buff, ']');
+}
+
+static void dumpper_process_object(json_dumpper_t *d, lua_State *L, int depth) {
+        membuffer_t *buff = &d->buff;
+        membuffer_putc(buff, '{');
+
+        int ktp;
+        int comma = 0;
+        lua_pushnil(L);         // t nil
+        while (lua_next(L, -2) != 0) {  // t k v
+                if (comma) {
+                        membuffer_putc(buff, ',');
+                        if (unlikely(d->format)) membuffer_putc(buff, '\n');
+                } else {
+                        comma = 1;
+                        if (unlikely(d->format)) membuffer_putc(buff, '\n');
+                } 
+                // key
+                ktp = lua_type(L, -2);
+                if (ktp == LUA_TSTRING) {
+                        if (unlikely(d->format)) dumpper_add_indent(d, depth);
+                        dumpper_process_string(d, L, -2);
+                        if (likely(!d->format))
+                                membuffer_putc(buff, ':');
+                        else
+                                membuffer_putb(buff, " : ", 3);
+                } else if (ktp == LUA_TNUMBER && d->num_as_str) {
+                        if (unlikely(d->format)) dumpper_add_indent(d, depth);
+                        membuffer_putc(buff, '\"');
+                        if (lua_isinteger(L, -2))
+                                dumpper_process_integer(d, L, -2);
+                        else
+                                dumpper_process_number(d, L, -2);
+                        if (likely(!d->format))
+                                membuffer_putb(buff, "\":", 2);
+                        else
+                                membuffer_putb(buff, "\" : ", 4);
+                } else {
+                        dumpper_throw_error(d, L, "Table key must be a string");
+                }
+                // value
+                dumpper_process_value(d, L, depth);
+                lua_pop(L, 1);
+        }
+        if (unlikely(d->format && comma)) {
+                membuffer_putc(buff, '\n');
+                dumpper_add_indent(d, depth-1);
+        } 
+        membuffer_putc(buff, '}');
+}
+
+static inline void dumpper_process_table(json_dumpper_t *d, lua_State *L, int depth) {
+        depth++;
+        if (depth > d->maxdepth)
+                dumpper_throw_error(d, L, "Too many nested data, max depth is %d", d->maxdepth);
+        luaL_checkstack(L, 6, NULL);
+
+        int len;
+        if (dumpper_check_array(d, L, &len))
+                dumpper_process_array(d, L, len, depth);
+        else
+                dumpper_process_object(d, L, depth);
+}
+
+static void dumpper_process_value(json_dumpper_t *d, lua_State *L, int depth) {
+        int tp = lua_type(L, -1);
+        switch (tp) {
+                case LUA_TSTRING:
+                        dumpper_process_string(d, L, -1);
+                        break;
+                case LUA_TNUMBER:
+                        if (lua_isinteger(L, -1))
+                                dumpper_process_integer(d, L, -1);
+                        else
+                                dumpper_process_number(d, L, -1);
+                        break;
+                case LUA_TBOOLEAN:
+                        if (lua_toboolean(L, -1))
+                                membuffer_putb(&d->buff, "true", 4);
+                        else
+                                membuffer_putb(&d->buff, "false", 5);
+                        break;
+                case LUA_TTABLE:
+                        dumpper_process_table(d, L, depth);
+                        break;
+                case LUA_TNIL:
+                        membuffer_putb(&d->buff, "null", 4);
+                        break;
+                case LUA_TLIGHTUSERDATA:
+                        if (lua_touserdata(L, -1) == NULL) {
+                                membuffer_putb(&d->buff, "null", 4);
+                                break;
+                        }
+                        goto error;
+                default:
+                error:
+                        dumpper_throw_error(d, L, "Unsupport type %s", lua_typename(L, tp));
+        }
+}
+
+//-----------------------------------------------------------------------------
+// 接口
+#define DEF_MAX_DEPTH 128
+
+// 从字符串加载：json.load(str, maxdepth) -> obj
+// 要求字符串必须以0结尾
+int colibc_json_load(lua_State *L) {
+        size_t size;
+        const char *str = luaL_checklstring(L, 1, &size);
+        int maxdepth = (int)luaL_optinteger(L, 2, DEF_MAX_DEPTH);
+        int allowcomment = lua_toboolean(L, 3);
+        parser_do_parse(str, size, L, maxdepth, allowcomment);
+        return 1;
+}
+
+// 保存到字符串: json.dump(obj) -> str
+int colibc_json_dump(lua_State *L) {
+        luaL_checkany(L, 1);
+        json_dumpper_t dumpper;
+        membuffer_init(&dumpper.buff);
+        dumpper.format = lua_toboolean(L, 2);
+        dumpper.empty_as_array = lua_toboolean(L, 3);
+        dumpper.num_as_str = lua_toboolean(L, 4);
+        dumpper.maxdepth = (int)luaL_optinteger(L, 5, DEF_MAX_DEPTH);
+
+        lua_settop(L, 1);
+        dumpper_process_value(&dumpper, L, 0);
+        lua_pushlstring(L, dumpper.buff.b, dumpper.buff.sz);
+        membuffer_free(&dumpper.buff);
+        return 1;
+}
+
+static const luaL_Reg lib[] = {
+        {"load", colibc_json_load},
+        {"dump", colibc_json_dump},
+        {NULL, NULL},
+};
+
+LUAMOD_API int luaopen_colibc_json(lua_State *L) {
+        luaL_newlib(L, lib);
+        // json.null
+        lua_pushlightuserdata(L, NULL);
+        lua_setfield(L, -2, "null");
+        return 1;
+}
diff --git a/src/yue.cpp b/src/yue.cpp
index 2c3a469..aebc31d 100644
--- a/src/yue.cpp
+++ b/src/yue.cpp
@@ -72,18 +72,26 @@ extern "C" {
 #include "lua.h"
 #include "lualib.h"
 int luaopen_yue(lua_State* L);
+int luaopen_colibc_json(lua_State* L);
 } // extern "C"
 
 static void openlibs(void* state) {
         lua_State* L = static_cast<lua_State*>(state);
         luaL_openlibs(L);
+        int top = lua_gettop(L);
 #if LUA_VERSION_NUM > 501
         luaL_requiref(L, "yue", luaopen_yue, 0);
+        luaL_requiref(L, "json", luaopen_colibc_json, 0);
 #else
         lua_pushcfunction(L, luaopen_yue);
         lua_call(L, 0, 0);
+        lua_getglobal(L, "package"); // package
+        lua_getfield(L, -1, "loaded"); // package loaded
+        lua_pushcfunction(L, luaopen_colibc_json);
+        lua_call(L, 0, 1); // package loaded json
+        lua_setfield(L, -2, "json"); // loaded["json"] = json, package loaded
 #endif
-        lua_pop(L, 1);
+        lua_settop(L, top);
 }
 
 void pushYue(lua_State* L, std::string_view name) {