请自行约束两种语言数据结构语法上的不同，避开如下问题：

1、json本身不约束key是否符合一个编程语言中的变量名，所以编写用于和编程语言数据结构交互的json代码时应该注意key是否正确。

2、lua没有数组，利用哈希表实现的逻辑上的数组，在中间可以存在不连续的情况时json将无法识别。

3、lua的字符串key可以和数字key共存，这对于json来说，是不允许的。

这些代码我已经用了很久了，所以暂时不多解释了，依赖c++11以上的版本，

代码挺多，有需求可以直接复制，这么多代码的目的也就是更高性能，单纯的在C++里面跑，比谷歌的实现稍微快一点点。

好了，废话不多说，上代码

  1. #pragma once
  2. #include <string>
  3. #include <functional>
  4. #include <setjmp.h>
  5. #include <fstream>
  6. #include <vector>
  7.  
  8. namespace aqx {
  9.  
  10. #ifndef jsize_t
  11.     typedef unsigned int jsize_t;
  12. #endif
  13.  
  14. #ifndef jnumber_t
  15.     typedef double jnumber_t;
  16. #endif
  17.  
  18.     static short constexpr jsvt_null{ 0 };
  19.     static short constexpr jsvt_string{ 1 };
  20.     static short constexpr jsvt_number{ 2 };
  21.     static short constexpr jsvt_boolean{ 3 };
  22.     static short constexpr jsvt_object{ 4 };
  23.     static short constexpr jsvt_group{ 5 };
  24.  
  25.     namespace aqx_internal {
  26. #ifndef __AQX_UTF8_CHAR_LEN
  27. #define __AQX_UTF8_CHAR_LEN
  28.         static unsigned char utf8_char_len[] = {
  29.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  30.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  31.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  32.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  33.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  34.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  35.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  36.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  37.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  38.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  39.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  40.             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  41.             2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
  42.             2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
  43.             3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
  44.             4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1
  45.         };
  46. #endif
  47.  
  48.         static unsigned int json_char_state[] = {
  49.             0,0,0,0,0,0,0,0,0,32,96,0,0,96,0,0,
  50.             0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  51.             32,0,640,0,0,0,0,0,0,0,0,1048576,65536,8192,131072,512,
  52.             3072,3072,3072,3072,3072,3072,3072,3072,3072,3072,16,0,0,0,0,0,
  53.             0,1024,1024,1024,1024,5120,1024,0,0,0,0,0,0,0,0,0,
  54.             0,0,0,0,0,0,0,0,0,0,0,4,768,8,0,0,
  55.             0,17408,1024,1024,1024,21504,50176,0,0,0,0,0,278528,0,524800,0,
  56.             0,0,16896,16384,49664,279040,0,0,0,0,0,1,0,2,0,0
  57.         };
  58.  
  59.         static int u16c2u8c(unsigned long u16c, unsigned char *u8c) {
  60.             if (u16c <= 0x0000007F) {
  61.                 u8c[0] = u16c & 0x7F;
  62.                 return 1;
  63.             }
  64.             else if (u16c >= 0x00000080 && u16c <= 0x000007FF) {
  65.                 u8c[1] = (u16c & 0x3F) | 0x80;
  66.                 u8c[0] = ((u16c >> 6) & 0x1F) | 0xC0;
  67.                 return 2;
  68.             }
  69.             else if (u16c >= 0x00000800 && u16c <= 0x0000FFFF)
  70.             {
  71.                 u8c[2] = (u16c & 0x3F) | 0x80;
  72.                 u8c[1] = ((u16c >> 6) & 0x3F) | 0x80;
  73.                 u8c[0] = ((u16c >> 12) & 0x0F) | 0xE0;
  74.                 return 3;
  75.             }
  76.             else if (u16c >= 0x00010000 && u16c <= 0x001FFFFF)
  77.             {
  78.                 u8c[3] = (u16c & 0x3F) | 0x80;
  79.                 u8c[2] = ((u16c >> 6) & 0x3F) | 0x80;
  80.                 u8c[1] = ((u16c >> 12) & 0x3F) | 0x80;
  81.                 u8c[0] = ((u16c >> 18) & 0x07) | 0xF0;
  82.                 return 4;
  83.             }
  84.             else if (u16c >= 0x00200000 && u16c <= 0x03FFFFFF)
  85.             {
  86.                 u8c[4] = (u16c & 0x3F) | 0x80;
  87.                 u8c[3] = ((u16c >> 6) & 0x3F) | 0x80;
  88.                 u8c[2] = ((u16c >> 12) & 0x3F) | 0x80;
  89.                 u8c[1] = ((u16c >> 18) & 0x3F) | 0x80;
  90.                 u8c[0] = ((u16c >> 24) & 0x03) | 0xF8;
  91.                 return 5;
  92.             }
  93.             else if (u16c >= 0x04000000 && u16c <= 0x7FFFFFFF)
  94.             {
  95.                 u8c[5] = (u16c & 0x3F) | 0x80;
  96.                 u8c[4] = ((u16c >> 6) & 0x3F) | 0x80;
  97.                 u8c[3] = ((u16c >> 12) & 0x3F) | 0x80;
  98.                 u8c[2] = ((u16c >> 18) & 0x3F) | 0x80;
  99.                 u8c[1] = ((u16c >> 24) & 0x3F) | 0x80;
  100.                 u8c[0] = ((u16c >> 30) & 0x01) | 0xFC;
  101.                 return 6;
  102.             }
  103.  
  104.             return 0;
  105.         }
  106.  
  107.         namespace JSON_SYNTAX {
  108.             static constexpr auto _T_OBJECT_BEGIN{ static_cast<unsigned int>(0x01) };            // {
  109.             static constexpr auto _T_OBJECT_END{ static_cast<unsigned int>(0x02) };            // }
  110.             static constexpr auto _T_GROUP_BEGIN{ static_cast<unsigned int>(0x04) };            // [
  111.             static constexpr auto _T_GROUP_END{ static_cast<unsigned int>(0x08) };            // ]
  112.             static constexpr auto _T_VALUE{ static_cast<unsigned int>(0x10) };                // :
  113.             static constexpr auto _T_SPACE{ static_cast<unsigned int>(0x20) };                // 4个空白字符" \t\r\n"
  114.             static constexpr auto _T_ENDL{ static_cast<unsigned int>(0x40) };                    // 2个换行符"\r\n"
  115.             static constexpr auto _T_TEXT{ static_cast<unsigned int>(0x80) };                    // "
  116.             static constexpr auto _T_ESCAPE_BEGIN{ static_cast<unsigned int>(0x100) };            // 转义符开始 '\\'
  117.             static constexpr auto _T_ESCAPE_TYPE{ static_cast<unsigned int>(0x200) };            // 转义符类型 "nrtbfu\\"
  118.             static constexpr auto _T_HEX{ static_cast<unsigned int>(0x400) };                    // \u之后UTF16的4字符HEX，"abcdefABCDEF"
  119.             static constexpr auto _T_NUMBER{ static_cast<unsigned int>(0x800) };                // 数字"0-9"
  120.             static constexpr auto _T_E{ static_cast<unsigned int>(0x1000) };                    // 科学计数法 e或E
  121.             static constexpr auto _T_NEGATIVE{ static_cast<unsigned int>(0x2000) };            // 负数 -
  122.             static constexpr auto _T_BOOL{ static_cast<unsigned int>(0x4000) };                // true false
  123.             static constexpr auto _T_BOOL_BEGIN{ static_cast<unsigned int>(0x8000) };            // t f
  124.             static constexpr auto _T_NEXT{ static_cast<unsigned int>(0x10000) };                // ,
  125.             static constexpr auto _T_DECIMAL{ static_cast<unsigned int>(0x20000) };            // 小数点 .
  126.             static constexpr auto _T_NULL{ static_cast<unsigned int>(0x40000) };                // null
  127.             static constexpr auto _T_NULL_BEGIN{ static_cast<unsigned int>(0x80000) };            // n
  128.             static constexpr auto _T_POSITIVE{ static_cast<unsigned int>(0x100000) };                // +
  129.         }
  130.  
  131.         static constexpr auto _jnf{ static_cast<jsize_t>(-1) };
  132.  
  133.         template<typename _Ty> class _json_parser;
  134.  
  135.         class _jts_base {
  136.         public:
  137.             _jts_base() {
  138.                 text = nullptr;
  139.             }
  140.  
  141.             void init(const char *_Text, int _Size) {
  142.                 text = _Text;
  143.                 size = _Size;
  144.                 instr = false;
  145.                 flags = 0;
  146.                 index = 0;
  147.             }
  148.  
  149.             jsize_t open_instr() {
  150.                 instr = true;
  151.                 jsize_t _Result = flags;
  152.                 flags = 0;
  153.                 return _Result;
  154.             }
  155.  
  156.             void close_instr(jsize_t _Flags) {
  157.                 instr = false;
  158.                 flags = _Flags;
  159.             }
  160.  
  161.             jsize_t set_flags(jsize_t _Flags) {
  162.                 auto _Result = flags;
  163.                 flags = _Flags;
  164.                 return _Result;
  165.             }
  166.  
  167.             long subhextol(int left, int len) {
  168.                 long _Result = 0;
  169.                 int rlen = len;
  170.                 for (int i = 0; i < len; i++) {
  171.                     char c = text[--rlen];
  172.                     long _Tmp;
  173.                     switch (c) {
  174.                     case '0':
  175.                     case '1':
  176.                     case '2':
  177.                     case '3':
  178.                     case '4':
  179.                     case '5':
  180.                     case '6':
  181.                     case '7':
  182.                     case '8':
  183.                     case '9':
  184.                         _Tmp = c - '0';
  185.                         break;
  186.                     case 'a':
  187.                     case 'b':
  188.                     case 'c':
  189.                     case 'd':
  190.                     case 'e':
  191.                     case 'f':
  192.                         _Tmp = c - 'a' + 10;
  193.                         break;
  194.                     case 'A':
  195.                     case 'B':
  196.                     case 'C':
  197.                     case 'D':
  198.                     case 'E':
  199.                     case 'F':
  200.                         _Tmp = c - 'A' + 10;
  201.                         break;
  202.                     default:
  203.                         return 0;
  204.                     }
  205.                     _Result += (_Tmp << (i << 2));
  206.                 }
  207.                 return _Result;
  208.             }
  209.  
  210.         protected:
  211.             const char *text;
  212.             jsize_t size;
  213.             unsigned int s;
  214.             char c;
  215.             unsigned char cl;
  216.             bool instr;
  217.             unsigned int flags;
  218.             jsize_t index;
  219.             std::string tmp;
  220.         };
  221.  
  222.         class _jts_utf8 : public _jts_base
  223.         {
  224.         public:
  225.             int operator++() {
  226.  
  227.                 c = text[index];
  228.                 cl = utf8_char_len[(unsigned char)c];
  229.                 if (cl != 1) {
  230.                     if (flags == JSON_SYNTAX::_T_ESCAPE_TYPE || !instr)
  231.                         return -1;
  232.                     do {
  233.                         index += cl;
  234.                         c = text[index];
  235.                         cl = utf8_char_len[(unsigned char)c];
  236.                     } while (cl != 1);
  237.                 }
  238.                 s = json_char_state[c];
  239.                 if (flags & s) {
  240.                     index += cl;
  241.                     return 0;
  242.                 }
  243.  
  244.                 if (instr) {
  245.                     if (s & JSON_SYNTAX::_T_ENDL)
  246.                         return -1;
  247.  
  248.                     index += cl;
  249.                     return 0;
  250.                 }
  251.  
  252.                 return -1;
  253.             }
  254.  
  255.         private:
  256.             friend class _json_parser<_jts_utf8>;
  257.         };
  258.  
  259.         class _jts_gbk : public _jts_base
  260.         {
  261.         public:
  262.             int operator++() {
  263.                 c = text[index];
  264.                 cl = ((unsigned char)c & 0x80) ? 2 : 1;
  265.                 if (cl != 1) {
  266.                     if (flags == JSON_SYNTAX::_T_ESCAPE_TYPE || !instr)
  267.                         return -1;
  268.                     do {
  269.                         index += cl;
  270.                         c = text[index];
  271.                         cl = ((unsigned char)c & 0x80) ? 2 : 1;
  272.                     } while (cl != 1);
  273.                 }
  274.                 s = json_char_state[c];
  275.                 if (flags & s) {
  276.                     index += cl;
  277.                     return 0;
  278.                 }
  279.  
  280.                 if (instr) {
  281.                     if (s & JSON_SYNTAX::_T_ENDL)
  282.                         return -1;
  283.  
  284.                     index += cl;
  285.                     return 0;
  286.                 }
  287.  
  288.                 return -1;
  289.             }
  290.  
  291.         private:
  292.             friend class _json_parser<_jts_gbk>;
  293.         };
  294.  
  295.         class _json_tree {
  296.         public:
  297.             class node {
  298.             public:
  299.                 node() {
  300.                     _Size = 0;
  301.                     _Bgn = _Parent = _jnf;
  302.                 }
  303.  
  304.                 node(jsize_t _Pa) {
  305.                     _Size = 0;
  306.                     _Parent = _Pa;
  307.                     _Bgn = _jnf;
  308.                 }
  309.  
  310.                 jsize_t size() {
  311.                     return _Size;
  312.                 }
  313.  
  314.                 jsize_t begin() {
  315.                     return _Bgn;
  316.                 }
  317.  
  318.             private:
  319.                 friend class _json_parser<_jts_utf8>;
  320.                 friend class _json_parser<_jts_gbk>;
  321.                 friend class _json_tree;
  322.                 jsize_t _Size, _Bgn, _End, _Parent;
  323.             };
  324.  
  325.             class var {
  326.             public:
  327.  
  328.                 var() {
  329.                     Key = _jnf;
  330.                     Next = _jnf;
  331.                     Kty = 1;
  332.                     Type = 0;
  333.                 }
  334.  
  335.                 var(short _KTy, jsize_t _Key) {
  336.                     Next = _jnf;
  337.                     Kty = _KTy;
  338.                     Key = _Key;
  339.                     Type = 0;
  340.                 }
  341.  
  342.                 var(short _KTy, jsize_t _Key, short _Type, jsize_t _Val) {
  343.                     Next = _jnf;
  344.                     Kty = _KTy;
  345.                     Key = _Key;
  346.                     Type = _Type;
  347.                     Off = _Val;
  348.                 }
  349.  
  350.                 var(short _KTy, jsize_t _Key, short _Type, bool _Val) {
  351.                     Next = _jnf;
  352.                     Kty = _KTy;
  353.                     Key = _Key;
  354.                     Type = _Type;
  355.                     Stat = _Val;
  356.                 }
  357.  
  358.                 var(short _KTy, jsize_t _Key, short _Type, jnumber_t _Val) {
  359.                     Next = _jnf;
  360.                     Kty = _KTy;
  361.                     Key = _Key;
  362.                     Type = _Type;
  363.                     Number = _Val;
  364.                 }
  365.  
  366.                 short type() { return Type; }
  367.                 bool is_ikey() { return Kty == 1; }
  368.                 var *next(_json_tree &_Tree) {
  369.                     if (Next == _jnf)
  370.                         return nullptr;
  371.                     return _Tree.get_val(Next);
  372.                 }
  373.  
  374.                 jsize_t ikey() {
  375.                     return (is_ikey()) ? Key : _jnf;
  376.                 }
  377.  
  378.                 const char *skey(_json_tree &_Tree) {
  379.                     return (!is_ikey()) ? _Tree.get_text(Key) : "";
  380.                 }
  381.  
  382.                 bool toboolean() {
  383.                     return Stat;
  384.                 }
  385.  
  386.                 const char *tostring(_json_tree &_Tree) {
  387.                     return (type() == 1) ? _Tree.get_text(Off) : "";
  388.                 }
  389.  
  390.                 jnumber_t tonumber() {
  391.                     return (type() == 2) ? Number : 0;
  392.                 }
  393.  
  394.                 node *toobject(_json_tree &_Tree) {
  395.                     return (type() == aqx::jsvt_object || type() == aqx::jsvt_group) ? _Tree.get_node(Off) : nullptr;
  396.                 }
  397.  
  398.             private:
  399.                 friend class _json_parser<_jts_utf8>;
  400.                 friend class _json_parser<_jts_gbk>;
  401.                 friend class _json_tree;
  402.                 jsize_t Key;
  403.                 jsize_t Next;
  404.                 short Type;
  405.                 short Kty;
  406.                 union {
  407.                     bool Stat;
  408.                     jsize_t Off;
  409.                     jnumber_t Number;
  410.                 };
  411.             };
  412.  
  413.             _json_tree() {
  414.                 _Texts = { 0, 0, 0 };
  415.             }
  416.  
  417.             node *get_root() {
  418.                 if (_Nodes.size() < 2)return nullptr;
  419.                 return get_node(1);
  420.             }
  421.  
  422.             var *get_root_val() {
  423.                 if (_Nodes.size() < 2)return nullptr;
  424.                 return get_val(1);
  425.             }
  426.  
  427.             node *get_node(jsize_t _Ref) { return (_Ref < (jsize_t)_Nodes.size()) ? &(_Nodes[_Ref]) : nullptr; }
  428.             var *get_val(jsize_t _Ref) { return (_Ref < (jsize_t)_Vals.size()) ? &(_Vals[_Ref]) : nullptr; }
  429.             const char *get_text(jsize_t _Ref) { return (_Ref <= _Texts.size) ? _Texts.data + _Ref : nullptr; }
  430.  
  431.             void reserve(jsize_t _TextSize, jsize_t _Count) {
  432.                 if (_TextSize << 1 > _Texts.capacity)
  433.                     _Realloc_Texts(_TextSize << 1);
  434.                 _Vals.reserve(_Count << 1);
  435.                 _Nodes.reserve(_Count);
  436.             }
  437.  
  438.             void clear() {
  439.                 _Texts.size = 0;
  440.                 _Vals.clear();
  441.                 _Nodes.clear();
  442.             }
  443.  
  444.         private:
  445.             void _set_child(node *e, jsize_t v) {
  446.                 if (e->_Bgn == _jnf) {
  447.                     e->_Bgn = v;
  448.                     e->_End = v;
  449.                 }
  450.                 else {
  451.                     get_val(e->_End)->Next = v;
  452.                     e->_End = v;
  453.                 }
  454.             }
  455.  
  456.             jsize_t new_node(jsize_t _Node, jsize_t &_Name, short _Type) {
  457.                 jsize_t _Result = (jsize_t)_Nodes.size();
  458.                 _Nodes.push_back(node(_Node));
  459.                 jsize_t v = (jsize_t)_Vals.size();
  460.                 auto e = get_node(_Node);
  461.                 if (_Name != _jnf) {
  462.                     _Vals.push_back(var(0, _Name, _Type, _Result));
  463.                     _Name = _jnf;
  464.                     e->_Size++;
  465.                 }
  466.                 else
  467.                     _Vals.push_back(var(1, e->_Size++, _Type, _Result));
  468.                 _set_child(e, v);
  469.                 return _Result;
  470.             }
  471.  
  472.             jsize_t new_root() {
  473.                 jsize_t _Result = (jsize_t)_Nodes.size();
  474.                 _Nodes.push_back(node());
  475.                 jsize_t v = (jsize_t)_Vals.size();
  476.                 _Vals.push_back(var(1, _jnf, aqx::jsvt_object, _Result));
  477.                 return _Result;
  478.             }
  479.  
  480.             void _Realloc_Texts(jsize_t _NewCapacity = 0) {
  481.                 if (_NewCapacity != 0)
  482.                     _Texts.capacity = (_NewCapacity + (_NewCapacity >> 1));
  483.                 else
  484.                     _Texts.capacity = (_Texts.capacity + (_Texts.capacity >> 1));
  485.                 if (_Texts.capacity < 0x1000)
  486.                     _Texts.capacity = 0x1000;
  487.                 char *_Tmp = new char[_Texts.capacity];
  488.                 if (_Texts.data) {
  489.                     if (_Texts.size)
  490.                         memcpy_s(_Tmp, _Texts.capacity, _Texts.data, _Texts.size);
  491.                     delete _Texts.data;
  492.                 }
  493.                 _Texts.data = _Tmp;
  494.             }
  495.  
  496.             jsize_t new_text(const char *_Text, int _Len) {
  497.                 jsize_t x = _Texts.size + (sizeof(size_t) - (_Texts.size % sizeof(size_t)));
  498.                 if (x + _Len >= _Texts.capacity)
  499.                     _Realloc_Texts(x + _Len);
  500.                 char *_Target = _Texts.data + x;
  501.                 _Texts.size = x + (_Len--);
  502.                 memcpy_s(_Target, _Len, _Text, _Len);
  503.                 _Target[_Len] = 0;
  504.                 return x;
  505.             }
  506.  
  507.             void append_text(const char *_Text, int _Len) {
  508.                 if (_Texts.size + _Len >= _Texts.capacity)
  509.                     _Realloc_Texts(_Texts.size + _Len);
  510.                 char *_Target = _Texts.data + _Texts.size - 1;
  511.                 _Texts.size += _Len--;
  512.                 _Texts.size--;
  513.                 memcpy_s(_Target, _Len, _Text, _Len);
  514.                 _Target[_Len] = 0;
  515.             }
  516.  
  517.             void append_char(char _Chr) {
  518.                 if (_Texts.size + 1 >= _Texts.capacity)
  519.                     _Realloc_Texts(_Texts.size + 1);
  520.                 _Texts.data[_Texts.size - 1] = _Chr;
  521.                 _Texts.data[_Texts.size++] = 0;
  522.             }
  523.  
  524.             void back_text(int _Len) {
  525.                 _Texts.size -= _Len;
  526.                 _Texts.data[_Texts.size] = 0;
  527.             }
  528.  
  529.             jsize_t new_var_string(jsize_t _Node, jsize_t &_Name, jsize_t _Text) {
  530.                 jsize_t v = (jsize_t)_Vals.size();
  531.                 auto e = get_node(_Node);
  532.                 if (_Name != _jnf) {
  533.                     _Vals.push_back(var(0, _Name, aqx::jsvt_string, _Text));
  534.                     _Name = _jnf;
  535.                     e->_Size++;
  536.                 }
  537.                 else
  538.                     _Vals.push_back(var(1, e->_Size++, aqx::jsvt_string, _Text));
  539.                 _set_child(e, v);
  540.                 return v;
  541.             }
  542.  
  543.             jsize_t new_var_number(jsize_t _Node, jsize_t &_Name, jnumber_t _Number) {
  544.                 jsize_t v = (jsize_t)_Vals.size();
  545.                 auto e = get_node(_Node);
  546.                 if (_Name != _jnf) {
  547.                     _Vals.push_back(var(0, _Name, aqx::jsvt_number, _Number));
  548.                     _Name = _jnf;
  549.                     e->_Size++;
  550.                 }
  551.                 else
  552.                     _Vals.push_back(var(1, e->_Size++, aqx::jsvt_number, _Number));
  553.                 _set_child(e, v);
  554.                 return v;
  555.             }
  556.  
  557.             jsize_t new_var_boolean(jsize_t _Node, jsize_t &_Name, bool _Stat) {
  558.                 jsize_t v = (jsize_t)_Vals.size();
  559.                 auto e = get_node(_Node);
  560.                 if (_Name != _jnf) {
  561.                     _Vals.push_back(var(0, _Name, aqx::jsvt_boolean, _Stat));
  562.                     _Name = _jnf;
  563.                     e->_Size++;
  564.                 }
  565.                 else
  566.                     _Vals.push_back(var(1, e->_Size++, aqx::jsvt_boolean, _Stat));
  567.                 _set_child(e, v);
  568.                 return v;
  569.             }
  570.  
  571.             jsize_t new_var_null(jsize_t _Node, jsize_t &_Name) {
  572.                 jsize_t v = (jsize_t)_Vals.size();
  573.                 auto e = get_node(_Node);
  574.                 if (_Name != _jnf) {
  575.                     _Vals.push_back(var(0, _Name, aqx::jsvt_null, (jnumber_t)0));
  576.                     _Name = _jnf;
  577.                     e->_Size++;
  578.                 }
  579.                 else
  580.                     _Vals.push_back(var(1, e->_Size++, aqx::jsvt_null, (jnumber_t)0));
  581.                 _set_child(e, v);
  582.                 return v;
  583.             }
  584.  
  585.         private:
  586.             friend class _json_parser<_jts_utf8>;
  587.             friend class _json_parser<_jts_gbk>;
  588.             std::vector<var> _Vals;
  589.             std::vector<node> _Nodes;
  590.             struct _TEXTS_POOL { char *data; jsize_t size; jsize_t capacity; }_Texts;
  591.         };
  592.  
  593.         template<typename _Ty>
  594.         class _json_parser {
  595.         public:
  596.             _json_parser(_json_tree &_Tree) {
  597.                 tree = &_Tree;
  598.             }
  599.  
  600.             bool load_string(const char *_Text, jsize_t _Len = _jnf, bool _MultiRoot = false) {
  601.                 if ((int)_Len < 0)
  602.                     _Len = (jsize_t)strlen(_Text) + 1;
  603.                 jts.init(_Text, _Len);
  604.                 tree->clear();
  605.                 return j_root(_MultiRoot) == 0;
  606.             }
  607.  
  608.             bool load_file(const std::string _File, bool _MultiRoot = false) {
  609.                 std::ifstream f(_File.c_str(), std::ifstream::binary);
  610.                 if (!f)
  611.                     return false;
  612.                 f.seekg(0, f.end);
  613.                 size_t fs = (size_t)f.tellg();
  614.                 f.seekg(0, f.beg);
  615.                 char *_Buf = new char[fs + 2];
  616.                 _Buf[fs] = 0;
  617.                 _Buf[fs + 1] = 0;
  618.                 f.read(_Buf, fs);
  619.                 f.close();
  620.                 bool _Result = load_string(_Buf, (jsize_t)fs, _MultiRoot);
  621.                 delete _Buf;
  622.                 return _Result;
  623.             }
  624.  
  625.             jsize_t get_error_pos() {
  626.  
  627.                 /*for (int i = err_pos; i < err_pos + 10; i++)
  628.                     printf("%c", jts.text[i]);
  629.                 printf("\n");*/
  630.                 return err_pos;
  631.             }
  632.  
  633.         private:
  634.             void jtsnext() {
  635.                 if ((jts.index >= jts.size) || (++jts) != 0) {
  636.                     err_pos = jts.index;
  637.                     longjmp(_Rem, -1);
  638.                 }
  639.             }
  640.  
  641.             void j_ec(jsize_t &_Off, jsize_t &_TextOff) {
  642.                 jsize_t len = jts.index - _Off;
  643.                 if (_TextOff == (jsize_t)-1)
  644.                     _TextOff = tree->new_text(jts.text + _Off, len);
  645.                 else
  646.                     tree->append_text(jts.text + _Off, len);
  647.  
  648.                 jts.close_instr(JSON_SYNTAX::_T_ESCAPE_TYPE);
  649.                 jtsnext();
  650.                 if (jts.c == 'u') {
  651.                     jsize_t ecpos = jts.index;
  652.                     unsigned long _uc1 = 0;
  653.                     int _uc1_len = 0;
  654.                     char u8c[7];
  655.                     for (;;) {
  656.                         jts.set_flags(JSON_SYNTAX::_T_HEX);
  657.                         for (int i = 0; i < 4; i++) {
  658.                             jtsnext();
  659.                         }
  660.  
  661.                         unsigned long uc = (unsigned short)jts.subhextol(ecpos, jts.index - ecpos);
  662.                         if (_uc1 >= 0xD800 && _uc1 < 0xDBFF && uc >= 0xDC00 && uc < 0xDFFF) {
  663.                             int u8l = u16c2u8c((_uc1 - 0xD800) * 0x400 + (uc - 0xDC00) + 0x10000, (unsigned char*)u8c);
  664.                             u8c[u8l] = 0;
  665.                             tree->back_text(_uc1_len + 1);
  666.                             tree->append_text(u8c, u8l + 1);
  667.                             _uc1 = 0;
  668.                         }
  669.                         else {
  670.                             _uc1 = uc;
  671.                             _uc1_len = u16c2u8c(uc, (unsigned char*)u8c);
  672.                             u8c[_uc1_len] = 0;
  673.                             tree->append_text(u8c, _uc1_len + 1);
  674.                         }
  675.  
  676.                         jts.open_instr();
  677.                         if (jts.c != '\\') {
  678.                             _Off = jts.index;
  679.                             jts.index--;
  680.                             break;
  681.                         }
  682.  
  683.                         jts.close_instr(JSON_SYNTAX::_T_ESCAPE_TYPE);
  684.                         jtsnext();
  685.                         if (jts.c != 'u') {
  686.                             _Off = jts.index - 1;
  687.                             jts.index -= 2;
  688.                             break;
  689.                         }
  690.                     }
  691.                 }
  692.                 else {
  693.                     switch (jts.c)
  694.                     {
  695.                     case '\\':
  696.                         tree->append_char('\\');
  697.                         break;
  698.                     case 'n':
  699.                         tree->append_char('\n');
  700.                         break;
  701.                     case 'r':
  702.                         tree->append_char('\r');
  703.                         break;
  704.                     case 't':
  705.                         tree->append_char('\t');
  706.                         break;
  707.                     case 'b':
  708.                         tree->append_char('\b');
  709.                         break;
  710.                     case 'f':
  711.                         tree->append_char('\f');
  712.                         break;
  713.                     case '/':
  714.                         tree->append_char('/');
  715.                         break;
  716.                     }
  717.  
  718.                     _Off = jts.index;
  719.                 }
  720.  
  721.                 jts.open_instr(); //继续放飞自我
  722.             }
  723.  
  724.             void j_text(bool isname = false) {
  725.                 jsize_t pos = jts.index;
  726.                 auto f = jts.open_instr();//字符串里的东西就开始放飞自我了，允许所有，除了不能换行
  727.                 jsize_t text_off = (jsize_t)-1;
  728.                 jsize_t text_len = 0;
  729.  
  730.                 for (;;)
  731.                 {
  732.                     jtsnext();
  733.                     if (jts.c == '\\') {
  734.                         j_ec(pos, text_off);
  735.                     }
  736.                     else if (jts.c == '"') {
  737.                         break;
  738.                     }
  739.                 }
  740.  
  741.                 jts.close_instr(f);
  742.                 jsize_t len = jts.index - pos;
  743.                 if (text_off == (jsize_t)-1)
  744.                     text_off = tree->new_text(jts.text + pos, len);
  745.                 else
  746.                     tree->append_text(jts.text + pos, len);
  747.  
  748.                 if (isname)
  749.                     name_off = text_off;
  750.                 else
  751.                     tree->new_var_string(cur, name_off, text_off);
  752.             }
  753.  
  754.             void j_number() {
  755.                 //考虑到可能会传入常量字符串到json解析，所以，在不拷贝源字符串，不能修改源字符串的情况下，只有自己实现数字转换的代码，这里统一使用浮点类型进行计算
  756.  
  757.                 /*
  758.                 有一点没有遵循标准，标准对于数字前的多个0是不允许的，
  759.                 但是它允许了-0  -0.00000000000 0e00000000000 之类的这些同样无意义的东西存在
  760.                 而我没有判断这一点，因为我觉得这会带来额外的性能损失，也会使这段代码变得更为复杂，
  761.                 我认为这一点，不管这些无意义的0在哪，由程序员自行控制它，
  762.                 只约束头部，不管中间，尾巴的做法，除了降低性能，没有什么实际意义。
  763.                 */
  764.                 unsigned int myf;
  765.                 long double _Number = 0;
  766.                 long double factor;
  767.                 bool neg = false;
  768.                 if (jts.c == '-') {
  769.                     neg = true;
  770.                     jts.set_flags(JSON_SYNTAX::_T_NUMBER);
  771.                     jtsnext();
  772.                     myf = JSON_SYNTAX::_T_NUMBER | JSON_SYNTAX::_T_E | JSON_SYNTAX::_T_DECIMAL |
  773.                         JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_OBJECT_END | JSON_SYNTAX::_T_GROUP_END | JSON_SYNTAX::_T_NEXT;
  774.                     jts.set_flags(myf);
  775.                 }
  776.                 else
  777.                 {
  778.                     myf = JSON_SYNTAX::_T_NUMBER | JSON_SYNTAX::_T_E | JSON_SYNTAX::_T_DECIMAL |
  779.                         JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_OBJECT_END | JSON_SYNTAX::_T_GROUP_END | JSON_SYNTAX::_T_NEXT;
  780.                     jts.set_flags(myf);
  781.                 }
  782.  
  783.                 do { //整数部分
  784.                     _Number = _Number * 10 + (jts.c - '0');
  785.                     jtsnext();
  786.                 } while (jts.s & JSON_SYNTAX::_T_NUMBER);
  787.  
  788.                 if (jts.c == '.') {
  789.                     //小数点之后的数字
  790.                     factor = 1.0;
  791.                     jts.set_flags(JSON_SYNTAX::_T_NUMBER);
  792.                     jtsnext();
  793.                     myf ^= JSON_SYNTAX::_T_DECIMAL;//之后不再允许小数点
  794.                     jts.set_flags(myf);
  795.  
  796.                     do {
  797.                         factor *= 0.1;
  798.                         _Number += (jts.c - '0') * factor;
  799.                         jtsnext();
  800.                     } while (jts.s & JSON_SYNTAX::_T_NUMBER);
  801.                 }
  802.  
  803.                 if ((jts.c | 32) == 'e') {
  804.                     //科学计数的处理
  805.                     unsigned int expo = 0;//指数
  806.                     factor = 10.0;//因数
  807.                     //e之后，必须是+-或者数字，如果是+-，那么后面必须是一个数字
  808.                     //这里是json唯一允许+号出现的地方
  809.                     jts.set_flags(JSON_SYNTAX::_T_NUMBER | JSON_SYNTAX::_T_NEGATIVE | JSON_SYNTAX::_T_POSITIVE);
  810.                     jtsnext();
  811.                     if (jts.c == '-') {
  812.                         jts.set_flags(JSON_SYNTAX::_T_NUMBER);
  813.                         jtsnext();
  814.                         factor = 0.1;
  815.                     }
  816.                     else if (jts.c == '+') {
  817.                         jts.set_flags(JSON_SYNTAX::_T_NUMBER);
  818.                         jtsnext();
  819.                     }
  820.  
  821.                     jts.set_flags(JSON_SYNTAX::_T_NUMBER |
  822.                         JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_OBJECT_END | JSON_SYNTAX::_T_GROUP_END | JSON_SYNTAX::_T_NEXT);
  823.                     do {
  824.                         expo = 10 * expo + (jts.c - '0');
  825.                         jtsnext();
  826.                     } while (jts.s & JSON_SYNTAX::_T_NUMBER);
  827.  
  828.                     for (;;) {
  829.                         //根据指数计算因数的快速求幂的方法
  830.                         if (expo & 1)
  831.                             _Number *= factor;
  832.                         if ((expo >>= 1) == 0)
  833.                             break;
  834.                         factor *= factor;
  835.                     }
  836.                 }
  837.  
  838.                 if (!(jts.s & JSON_SYNTAX::_T_SPACE))//非空白字符时，倒退到上一个字符，由此处判断一下会由微小的性能提升，毕竟一次jtsnext()的代价更高一些
  839.                     --jts.index;
  840.                 tree->new_var_number(cur, name_off, (jnumber_t)(neg ? -_Number : _Number));
  841.             }
  842.  
  843.             void j_true() {
  844.                 jts.set_flags(JSON_SYNTAX::_T_BOOL);
  845.                 for (int i = 0; i < 3; i++) {
  846.                     jtsnext();
  847.                     if ("rue"[i] != jts.c) {
  848.                         err_pos = jts.index - 1;
  849.                         longjmp(_Rem, -1);
  850.                     }
  851.                 }
  852.                 tree->new_var_boolean(cur, name_off, true);
  853.             }
  854.  
  855.             void j_false() {
  856.                 jts.set_flags(JSON_SYNTAX::_T_BOOL);
  857.                 for (int i = 0; i < 4; i++) {
  858.                     jtsnext();
  859.                     if ("alse"[i] != jts.c) {
  860.                         err_pos = jts.index - 1;
  861.                         longjmp(_Rem, -1);
  862.                     }
  863.                 }
  864.                 tree->new_var_boolean(cur, name_off, false);
  865.             }
  866.  
  867.             void j_null() {
  868.                 jts.set_flags(JSON_SYNTAX::_T_NULL);
  869.                 for (int i = 0; i < 3; i++) {
  870.                     jtsnext();
  871.                     if ("ull"[i] != jts.c) {
  872.                         err_pos = jts.index - 1;
  873.                         longjmp(_Rem, -1);
  874.                     }
  875.                 }
  876.                 tree->new_var_null(cur, name_off);
  877.             }
  878.  
  879.             void j_value() {
  880.                 jts.set_flags(
  881.                     JSON_SYNTAX::_T_SPACE |            // 空白字符
  882.                     JSON_SYNTAX::_T_TEXT |            // "
  883.                     JSON_SYNTAX::_T_OBJECT_BEGIN |        // {
  884.                     JSON_SYNTAX::_T_GROUP_BEGIN |        // [
  885.                     JSON_SYNTAX::_T_NUMBER |            // 0-9
  886.                     JSON_SYNTAX::_T_NEGATIVE |            // -负号
  887.                     JSON_SYNTAX::_T_BOOL_BEGIN |        // true false开头
  888.                     JSON_SYNTAX::_T_NULL_BEGIN
  889.                 );
  890.  
  891.                 bool ok = false;
  892.                 do { jtsnext(); } while (jts.s & JSON_SYNTAX::_T_SPACE);
  893.  
  894.                 switch (jts.c) {
  895.                 case '"':
  896.                     j_text();
  897.                     break;
  898.                 case '{':
  899.                     j_object();
  900.                     break;
  901.                 case '[':
  902.                     j_group();
  903.                     break;
  904.                 case '-':
  905.                     j_number();
  906.                     break;
  907.                 case 't':
  908.                     j_true();
  909.                     break;
  910.                 case 'f':
  911.                     j_false();
  912.                     break;
  913.                 case 'n':
  914.                     j_null();
  915.                     break;
  916.                 default:
  917.                     if (jts.s & JSON_SYNTAX::_T_NUMBER) {
  918.                         j_number();
  919.                         break;
  920.                     }
  921.                     break;
  922.                 }
  923.             }
  924.  
  925.             void j_group() {
  926.                 // [ 之后，允许空白字符，"{0-9] true false null
  927.                 auto f = jts.set_flags(
  928.                     JSON_SYNTAX::_T_SPACE |            // 空白字符
  929.                     JSON_SYNTAX::_T_TEXT |            // "
  930.                     JSON_SYNTAX::_T_OBJECT_BEGIN |        // {
  931.                     JSON_SYNTAX::_T_GROUP_END |        // ]
  932.                     JSON_SYNTAX::_T_NUMBER |            // 0-9
  933.                     JSON_SYNTAX::_T_NEGATIVE |            // -负号
  934.                     JSON_SYNTAX::_T_BOOL_BEGIN |        // t f
  935.                     JSON_SYNTAX::_T_NULL_BEGIN |        // n
  936.                     JSON_SYNTAX::_T_GROUP_BEGIN        // 在遇到[时就递归前进
  937.                 );
  938.  
  939.                 auto _Node = cur;
  940.                 cur = tree->new_node(cur, name_off, aqx::jsvt_group);
  941.                 bool ok = false;
  942.  
  943.                 do {
  944.                     jtsnext();
  945.  
  946.                     switch (jts.c) {
  947.                     case '"':
  948.                         j_text();
  949.                         jts.set_flags(JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_NEXT | JSON_SYNTAX::_T_GROUP_END);
  950.                         break;
  951.                     case '{':
  952.                         j_object();
  953.                         jts.set_flags(JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_NEXT | JSON_SYNTAX::_T_GROUP_END);
  954.                         break;
  955.                     case '[':
  956.                         j_group();
  957.                         jts.set_flags(JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_NEXT | JSON_SYNTAX::_T_GROUP_END);
  958.                         break;
  959.                     case '-':
  960.                         j_number();
  961.                         jts.set_flags(JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_NEXT | JSON_SYNTAX::_T_GROUP_END);
  962.                         break;
  963.                     case 't':
  964.                         j_true();
  965.                         jts.set_flags(JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_NEXT | JSON_SYNTAX::_T_GROUP_END);
  966.                         break;
  967.                     case 'f':
  968.                         j_false();
  969.                         jts.set_flags(JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_NEXT | JSON_SYNTAX::_T_GROUP_END);
  970.                         break;
  971.                     case 'n':
  972.                         j_null();
  973.                         jts.set_flags(JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_NEXT | JSON_SYNTAX::_T_GROUP_END);
  974.                         break;
  975.                     case ']':
  976.                         ok = true;
  977.                         break;
  978.                     case ',':
  979.                         jts.set_flags(
  980.                             JSON_SYNTAX::_T_SPACE |            // 空白字符
  981.                             JSON_SYNTAX::_T_TEXT |            // "
  982.                             JSON_SYNTAX::_T_OBJECT_BEGIN |        // {
  983.                             JSON_SYNTAX::_T_NUMBER |            // 0-9
  984.                             JSON_SYNTAX::_T_NEGATIVE |            // -负号
  985.                             JSON_SYNTAX::_T_BOOL_BEGIN |        // t f
  986.                             JSON_SYNTAX::_T_NULL_BEGIN |        // n
  987.                             JSON_SYNTAX::_T_GROUP_BEGIN        // 在遇到[时就递归前进
  988.                         );
  989.                         break;
  990.                     default:
  991.                         if (jts.s & JSON_SYNTAX::_T_NUMBER) {
  992.                             j_number();
  993.                             break;
  994.                         }
  995.                         break;
  996.                     }
  997.                 } while (!ok);
  998.  
  999.                 jts.set_flags(f);
  1000.                 cur = _Node;
  1001.             }
  1002.  
  1003.             void j_object() {
  1004.                 auto _Node = cur;
  1005.                 cur = tree->new_node(cur, name_off, aqx::jsvt_object);
  1006.                 auto f = jts.set_flags(JSON_SYNTAX::_T_TEXT | JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_OBJECT_END);
  1007.                 bool ok = false;
  1008.                 do {
  1009.                     jtsnext();
  1010.                     switch (jts.c) {
  1011.                     case '"':
  1012.                         j_text(true);
  1013.                         //名称字符串结束后，只允许 : 和 空白字符
  1014.                         jts.set_flags(JSON_SYNTAX::_T_VALUE | JSON_SYNTAX::_T_SPACE);
  1015.                         break;
  1016.                     case ':':
  1017.                         j_value();
  1018.                         jts.set_flags(JSON_SYNTAX::_T_TEXT | JSON_SYNTAX::_T_SPACE | JSON_SYNTAX::_T_OBJECT_END | JSON_SYNTAX::_T_NEXT);
  1019.                         break;
  1020.                     case ',':
  1021.                         // 碰到逗号时，新的一轮开始，但此时不再允许花括号，也就是不允许{"a":1,}这样的
  1022.                         jts.set_flags(JSON_SYNTAX::_T_TEXT | JSON_SYNTAX::_T_SPACE);
  1023.                         break;
  1024.                     case '}':
  1025.                         ok = true;
  1026.                         break;
  1027.                     }
  1028.                 } while (!ok);
  1029.                 cur = _Node;
  1030.             }
  1031.  
  1032.             int j_root(bool _MultiRoot) {
  1033.                 if (setjmp(_Rem)) {
  1034.                     tree->clear();
  1035.                     return -1;
  1036.                 }
  1037.  
  1038.                 root = tree->new_root();
  1039.                 cur = root;
  1040.                 name_off = _jnf;
  1041.                 err_pos = 0;
  1042.                 jts.set_flags(JSON_SYNTAX::_T_OBJECT_BEGIN | JSON_SYNTAX::_T_GROUP_BEGIN | JSON_SYNTAX::_T_SPACE);
  1043.                 for (;;) {
  1044.                     jtsnext();
  1045.                     if (jts.c == '{') {
  1046.                         j_object();
  1047.                         break;
  1048.                     }
  1049.                     else if (jts.c == '[') {
  1050.                         j_group();
  1051.                         break;
  1052.                     }
  1053.                 }
  1054.  
  1055.                 if (!_MultiRoot) {
  1056.                     jts.open_instr();
  1057.                     for (;;) {
  1058.                         if (jts.index >= jts.size)
  1059.                             break;
  1060.  
  1061.                         char _Chr = jts.text[jts.index++];
  1062.                         if (!_Chr)
  1063.                             break;
  1064.  
  1065.                         if (!(json_char_state[(unsigned char)_Chr] & JSON_SYNTAX::_T_SPACE)) {
  1066.                             err_pos = jts.index - 1;
  1067.                             //tree->clear();
  1068.                             return -1;
  1069.                         }
  1070.                     }
  1071.                 }
  1072.                 return 0;
  1073.             }
  1074.  
  1075.         private:
  1076.             jmp_buf _Rem;
  1077.             _Ty jts;
  1078.             _json_tree *tree;
  1079.             jsize_t cur;
  1080.             jsize_t root;
  1081.             jsize_t name_off;
  1082.             jsize_t err_pos;
  1083.         };
  1084.  
  1085.     }
  1086.  
  1087.     using json_tree = aqx_internal::_json_tree;
  1088.  
  1089.     template<typename _Ty>
  1090.     using json_parser_t = aqx_internal::_json_parser<_Ty>;
  1091.  
  1092.     using jts_gbk = aqx_internal::_jts_gbk;
  1093.     using jts_utf8 = aqx_internal::_jts_utf8;
  1094.  
  1095. }
  1096.  
  1097. /*
  1098.  
  1099. //我已经把代码移植到C去了，最终我还是又回到C++来使用它，因为。。。C的性能，反而不如C++，无论是vc还是gcc都是不如c++...
  1100. //可能的原因是我对C的二进制优化的手法并不纯熟而导致的问题，完全照搬结构大概是不合理的做法，
  1101. //不过我认为更多的可能性还是，C入栈的参数比C++要多而导致的。
  1102. //毕竟，this指针总在cx si之间传，而C，要写入太多太多结构指针
  1103.  
  1104. //下面这一串是构建字符状态表的代码
  1105.  
  1106.     int sztext[128];
  1107.     memset(sztext, 0, 512);
  1108.  
  1109.     sztext['\"'] = aqx::aqx_internal::JSON_SYNTAX::_T_TEXT | aqx::aqx_internal::JSON_SYNTAX::_T_ESCAPE_TYPE;
  1110.     sztext[':'] = aqx::aqx_internal::JSON_SYNTAX::_T_VALUE;
  1111.     sztext[','] = aqx::aqx_internal::JSON_SYNTAX::_T_NEXT;
  1112.     sztext['{'] = aqx::aqx_internal::JSON_SYNTAX::_T_OBJECT_BEGIN;
  1113.     sztext['}'] = aqx::aqx_internal::JSON_SYNTAX::_T_OBJECT_END;
  1114.     sztext['['] = aqx::aqx_internal::JSON_SYNTAX::_T_GROUP_BEGIN;
  1115.     sztext[']'] = aqx::aqx_internal::JSON_SYNTAX::_T_GROUP_END;
  1116.     sztext['\\'] = aqx::aqx_internal::JSON_SYNTAX::_T_ESCAPE_BEGIN | aqx::aqx_internal::JSON_SYNTAX::_T_ESCAPE_TYPE;
  1117.     sztext['n'] = aqx::aqx_internal::JSON_SYNTAX::_T_ESCAPE_TYPE;
  1118.     sztext['r'] = aqx::aqx_internal::JSON_SYNTAX::_T_ESCAPE_TYPE;
  1119.     sztext['t'] = aqx::aqx_internal::JSON_SYNTAX::_T_ESCAPE_TYPE;
  1120.     sztext['b'] = aqx::aqx_internal::JSON_SYNTAX::_T_ESCAPE_TYPE;
  1121.     sztext['f'] = aqx::aqx_internal::JSON_SYNTAX::_T_ESCAPE_TYPE;
  1122.     sztext['u'] = aqx::aqx_internal::JSON_SYNTAX::_T_ESCAPE_TYPE;
  1123.     sztext['/'] = aqx::aqx_internal::JSON_SYNTAX::_T_ESCAPE_TYPE;
  1124.     sztext['\n'] = aqx::aqx_internal::JSON_SYNTAX::_T_ENDL | aqx::aqx_internal::JSON_SYNTAX::_T_SPACE;
  1125.     sztext['\r'] = aqx::aqx_internal::JSON_SYNTAX::_T_ENDL | aqx::aqx_internal::JSON_SYNTAX::_T_SPACE;
  1126.     sztext[' '] = aqx::aqx_internal::JSON_SYNTAX::_T_SPACE;
  1127.     sztext['\t'] = aqx::aqx_internal::JSON_SYNTAX::_T_SPACE;
  1128.  
  1129.     for (size_t i = 0; i < strlen("0123456789"); i++)
  1130.         sztext["0123456789"[i]] = aqx::aqx_internal::JSON_SYNTAX::_T_NUMBER | aqx::aqx_internal::JSON_SYNTAX::_T_HEX;
  1131.     for (size_t i = 0; i < strlen("abcdefABCDEF"); i++)
  1132.         sztext["abcdefABCDEF"[i]] = aqx::aqx_internal::JSON_SYNTAX::_T_HEX;
  1133.  
  1134.     sztext['.'] = aqx::aqx_internal::JSON_SYNTAX::_T_DECIMAL;
  1135.  
  1136.     sztext['+'] = aqx::aqx_internal::JSON_SYNTAX::_T_POSITIVE;
  1137.     sztext['-'] = aqx::aqx_internal::JSON_SYNTAX::_T_NEGATIVE;
  1138.     sztext['e'] |= aqx::aqx_internal::JSON_SYNTAX::_T_E;
  1139.     sztext['E'] |= aqx::aqx_internal::JSON_SYNTAX::_T_E;
  1140.  
  1141.     sztext['t'] |= aqx::aqx_internal::JSON_SYNTAX::_T_BOOL;
  1142.     sztext['t'] |= aqx::aqx_internal::JSON_SYNTAX::_T_BOOL_BEGIN;
  1143.     sztext['r'] |= aqx::aqx_internal::JSON_SYNTAX::_T_BOOL;
  1144.     sztext['u'] |= aqx::aqx_internal::JSON_SYNTAX::_T_BOOL;
  1145.     sztext['e'] |= aqx::aqx_internal::JSON_SYNTAX::_T_BOOL;
  1146.     sztext['f'] |= aqx::aqx_internal::JSON_SYNTAX::_T_BOOL;
  1147.     sztext['f'] |= aqx::aqx_internal::JSON_SYNTAX::_T_BOOL_BEGIN;
  1148.     sztext['a'] |= aqx::aqx_internal::JSON_SYNTAX::_T_BOOL;
  1149.     sztext['l'] |= aqx::aqx_internal::JSON_SYNTAX::_T_BOOL;
  1150.     sztext['s'] |= aqx::aqx_internal::JSON_SYNTAX::_T_BOOL;
  1151.  
  1152.     sztext['n'] |= aqx::aqx_internal::JSON_SYNTAX::_T_NULL_BEGIN;
  1153.     sztext['u'] |= aqx::aqx_internal::JSON_SYNTAX::_T_NULL;
  1154.     sztext['l'] |= aqx::aqx_internal::JSON_SYNTAX::_T_NULL;
  1155.     for (int y = 0; y < 8; y++)
  1156.     {
  1157.         for (int x = 0; x < 16; x++)
  1158.         {
  1159.             printf("%d,", sztext[y * 16 + x]);
  1160.         }
  1161.  
  1162.         printf("\n");
  1163.     }
  1164.  
  1165.     return 0;
  1166.  
  1167. */

封装给lua使用的库：

//ljsonlib.h

#pragma once

#include "lua/lua.hpp"

#include "aqx/json.h"

class ljson_convert {

public:

    ljson_convert(lua_State *_s, int ec);

    int table_to_json(int n);

    int json_to_table(const char *_Text, int _Len);

private:

    friend int lua_table_to_json(lua_State *s);

    void json_to_object(aqx::jsize_t _Ref);

    void json_to_group(aqx::jsize_t _Ref);

    int ec_mode;

    aqx::json_tree jt;

    aqx::json_parser_t<aqx::jts_gbk> *pgbk;

    aqx::json_parser_t<aqx::jts_utf8> *putf8;

    lua_State *s;

    std::string b;

};

//_CharEncoding为字符编码格式，默认为"gbk"，可以传入"utf8"

ljson_convert *lua_openljsonlib(lua_State *s, const char *_CharEncoding = "");
//ljsonlib.cpp

#include "pch.h"

#include "ljsonlib.h"

#define lua_isintnum(_Number_) (_Number_ - floor(_Number_) < 1e-6)

ljson_convert::ljson_convert(lua_State *_s, int ec) {

    s = _s;

    jt.reserve(0x1000, 0x400);

    b.reserve(0x1000);

    ec_mode = ec;

    if (!ec_mode)

        pgbk = new aqx::json_parser_t<aqx::jts_gbk>(jt);

    else

        putf8 = new aqx::json_parser_t<aqx::jts_utf8>(jt);

}

int ljson_convert::table_to_json(int n) {

    char sznum[128];

    lua_pushnil(s);

    int t = 0;

    if (!lua_next(s, n))

        return 0;

    switch (lua_type(s, -2)) {

    case LUA_TNUMBER:

        b += '[';

        t = 2;

        break;

    case LUA_TSTRING:

        b += "{\"";

        b += lua_tostring(s, -2);

        b += "\":";

        t = 1;

        break;

    default:

        lua_pop(s, 1);

        return -1;

    }

    switch (lua_type(s, -1)) {

    case LUA_TBOOLEAN:

        b += (lua_toboolean(s, -1) == 1) ? "true" : "false";

        break;

    case LUA_TNUMBER: {

        double dv = lua_tonumber(s, -1);

        if (lua_isintnum(dv))

            sprintf_s(sznum, 128, "%I64d", (long long)dv);

        else

            sprintf_s(sznum, 128, "%lf", dv);

        b += sznum;

        break;

    }

    case LUA_TSTRING:

        b += '"';

        b += lua_tostring(s, -1);

        b += '"';

        break;

    case LUA_TTABLE:

        if (table_to_json(-2)) {

            lua_pop(s, 1);

            return -1;

        }

        break;

    default:

        lua_pop(s, 1);

        return -1;

    }

    lua_pop(s, 1);

    while (lua_next(s, n)) {

        switch (lua_type(s, -2)) {

        case LUA_TNUMBER:

            b += ',';

            break;

        case LUA_TSTRING:

            b += ",\"";

            b += lua_tostring(s, -2);

            b += "\":";

            break;

        default:

            lua_pop(s, 1);

            return -1;

        }

        switch (lua_type(s, -1)) {

        case LUA_TBOOLEAN:

            b += (lua_toboolean(s, -1) == 1) ? "true" : "false";

            break;

        case LUA_TNUMBER: {

            double dv = lua_tonumber(s, -1);

            if (lua_isintnum(dv))

                sprintf_s(sznum, 128, "%I64d", (long long)dv);

            else

                sprintf_s(sznum, 128, "%lf", dv);

            b += sznum;

            break;

        }

        case LUA_TSTRING:

            b += '"';

            b += lua_tostring(s, -1);

            b += '"';

            break;

        case LUA_TTABLE:

            if (table_to_json(-2)) {

                lua_pop(s, 1);

                return -1;

            }

            break;

        default:

            lua_pop(s, 1);

            return -1;

        }

        lua_pop(s, 1);

    }

    b += t == 1 ? '}' : ']';

    return 0;

}

int ljson_convert::json_to_table(const char *_Text, int _Len) {

    if (!ec_mode)

    {

        if (!pgbk->load_string(_Text, _Len, true)) {

            return -1;

        }

    }

    else

    {

        if (!putf8->load_string(_Text, _Len, true))

            return -1;

    }

    auto root = jt.get_root();

    if (!root)

        return -1;

    json_to_object(root->begin());

    return 0;

}

void ljson_convert::json_to_object(aqx::jsize_t _Ref) {

    for (auto v = jt.get_val(_Ref); v != nullptr; v = v->next(jt)) {

        switch (v->type()) {

        case aqx::jsvt_null:

            lua_pushstring(s, v->skey(jt));

            lua_pushnil(s);

            lua_settable(s, -3);

            break;

        case aqx::jsvt_string:

            lua_pushstring(s, v->skey(jt));

            lua_pushstring(s, v->tostring(jt));

            lua_settable(s, -3);

            break;

        case aqx::jsvt_number:

        {

            lua_pushstring(s, v->skey(jt));

            double dv = v->tonumber();

            if (lua_isintnum(dv))

                lua_pushinteger(s, (intptr_t)dv);

            else

                lua_pushnumber(s, dv);

            lua_settable(s, -3);

            break;

        }

        case aqx::jsvt_boolean:

            lua_pushstring(s, v->skey(jt));

            lua_pushboolean(s, v->toboolean());

            lua_settable(s, -3);

            break;

        case aqx::jsvt_object: {

            auto n = v->toobject(jt);

            if (!n->size())

                break;

            lua_pushstring(s, v->skey(jt));

            lua_newtable(s);

            json_to_object(n->begin());

            lua_settable(s, -3);

            break;

        }

        case aqx::jsvt_group: {

            auto n = v->toobject(jt);

            if (!n->size()) {

                break;

            }

            lua_pushstring(s, v->skey(jt));

            lua_newtable(s);

            json_to_group(n->begin());

            lua_settable(s, -3);

            break;

        }

        }

    }

}

void ljson_convert::json_to_group(aqx::jsize_t _Ref) {

    int i = 1;

    for (auto v = jt.get_val(_Ref); v != nullptr; v = v->next(jt)) {

        switch (v->type()) {

        case aqx::jsvt_null:

            lua_pushnil(s);

            lua_rawseti(s, -2, i++);

            break;

        case aqx::jsvt_string:

            lua_pushstring(s, v->tostring(jt));

            lua_rawseti(s, -2, i++);

            break;

        case aqx::jsvt_number: {

            double dv = v->tonumber();

            if (lua_isintnum(dv))

                lua_pushinteger(s, (intptr_t)dv);

            else

                lua_pushnumber(s, dv);

            lua_rawseti(s, -2, i++);

            break;

        }

        case aqx::jsvt_boolean:

            lua_pushboolean(s, v->toboolean());

            break;

        case aqx::jsvt_object: {

            auto n = v->toobject(jt);

            if (!n->size())

                break;

            lua_newtable(s);

            json_to_object(n->begin());

            lua_rawseti(s, -2, i++);

            break;

        }

        case aqx::jsvt_group: {

            auto n = v->toobject(jt);

            if (!n->size())

                break;

            lua_newtable(s);

            json_to_group(n->begin());

            lua_rawseti(s, -2, i++);

            break;

        }

        }

    }

}

ljson_convert *get_ljson_convert(lua_State *s) {

    lua_getglobal(s, "__ljsonlib_convert_");

    if (lua_isnil(s, -1))

        return nullptr;

    return (ljson_convert*)lua_touserdata(s, -1);

}

int lua_table_to_json(lua_State *s)

{

    ljson_convert *pjc = get_ljson_convert(s);

    if (!pjc)

        return 0;

    if (!lua_gettop(s))

        return 0;

    if (lua_type(s, 1) != LUA_TTABLE)

        return 0;

    pjc->b.clear();

    if (pjc->table_to_json(1)) {

        pjc->b.clear();

    }

    lua_pushstring(s, pjc->b.c_str());

    return 1;

}

int lua_table_from_json(lua_State *s) {

    ljson_convert *pjc = get_ljson_convert(s);

    if (!pjc)

        return 0;

    if (!lua_gettop(s))

        return 0;

    if (lua_type(s, 1) != LUA_TSTRING)

        return 0;

    lua_newtable(s);

    if (!pjc->json_to_table(lua_tostring(s, 1), -1)) {

        return 1;

    }

    lua_pop(s, 1);

    return 0;

}

ljson_convert *lua_openljsonlib(lua_State *s, const char *_CharEncoding)

{

    ljson_convert *pjc = get_ljson_convert(s);

    if (pjc)return pjc;

    pjc = new ljson_convert(s, (strstr(_CharEncoding, "utf") == nullptr) ? 0 : 1);

    lua_pushlightuserdata(s, pjc);

    lua_setglobal(s, "__ljsonlib_convert_");

    lua_getglobal(s, "table");

    lua_pushcfunction(s, lua_table_to_json);

    lua_setfield(s, -2, "tojson");

    lua_pushcfunction(s, lua_table_from_json);

    lua_setfield(s, -2, "fromjson");

    return pjc;

}
// ConsoleApplication2.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。

//

#include "pch.h"

#include <thread>

#include <iostream>

#pragma comment(lib, "lua54.lib")

#include "lxsharelib.h"

#include "ljsonlib.h"

int main(int argc, char **argv)

{

    lua_State *s = luaL_newstate();

    luaL_openlibs(s);

    //使用这个接口，向lua本身的table对象中，添加两个函数table.tojson和table.fromjson

    auto p = lua_openljsonlib(s, "");//第2个参数可以传入"utf8"来应对utf8的lua文件，默认的情况下是gbk

    if (luaL_dofile(s, "G:\\vs2017\\ConsoleApplication2\\x64\\Release\\script\\testjson.lua"))

        printf("%s\n", lua_tostring(s, -1));

    lua_close(s);

    //用完之后，需要自己释放掉内存，这个问题没什么好办法解决，除非扩展到lua源码中，或者给lua_close实现回调

    delete p;

    return 0;

}

测试脚本代码：

-- testjson.lua

local t = {

    x = 3.14159,

    y = 2,

    z = {10,20,30,40,50}

};

local json_text = table.tojson(t);

print(json_text);--{"z":[10,20,30,40,50],"y":2,"x":3.141590}

local t2 = table.fromjson('{"a":1.21e-3,"b":2,"c":[3,4,5,6,7,"abcde"],"d":[]}');

print(t2)

--[[

    b:2

    a:0.00121

    c:table: 000001C74BABABE0

]]

for i, e in pairs(t2) do

    print(i..':'..tostring(e));

end

--[[

    1:3

    2:4

    3:5

    4:6

    5:7

    6:abcde

]]

for i, e in ipairs(t2.c) do

    print(i..':'..e);

end

{"y":2,"x":3.141590,"z":[10,20,30,40,50]}
table: 0000025A15D5EFC0
a:0.00121
c:table: 0000025A15D7A340
b:2
1:3
2:4
3:5
4:6
5:7
6:abcde

lua table与json的之间的互相转换高性能c++实现的更多相关文章

  1. cocos2d-x lua table与json的转换

    cocos2d-x lua table与json的转换 version: cocos2d-x 3.6 1.引入json库 require("src/cocos/cocos2d/json&qu ...

  2. 前端页面使用 Json对象与Json字符串之间的互相转换

    前言 在前端页面很多时候都会用到Json这种格式的数据,最近没有前端,后端的我也要什么都要搞,对于Json对象与Json字符串之间的转换终于摸清楚了几种方式,归纳如下! 一:Json对象转换为json ...

  3. 我为什么要再给lua写一个json模块

    最近要给自己编写的服务器加上json解析模块.根据我当前的项目,可以预测服务器中使用json的地方: 通信.由于与客户端通信使用google protocolbuffer,仅在与SDK通信中使用jso ...

  4. 高并发 Nginx+Lua OpenResty系列（7）——Lua开发库json

    JSON库 在进行数据传输时JSON格式目前应用广泛,因此从Lua对象与JSON字符串之间相互转换是一个非常常见的功能:目前Lua也有几个JSON库,如:cjson.dkjson.其中cjson的语法 ...

  5. Json——使用Json jar包实现Json字符串与Java对象或集合之间的互相转换

    总结一下利用Json相关jar包实现Java对象和集合与Json字符串之间的互相转换: 1.创建的User类: package com.ghj.packageofdomain; public clas ...

  6. cocos2d-x lua table数据存储

    cocos2d-x lua table数据存储 version: cocos2d-x 3.6 1. 将table转为json http://blog.csdn.net/songcf_faith/art ...

  7. Lua 数据类型和 Redis 数据类型之间转换

    当 Lua 通过 call() 或 pcall() 函数执行 Redis 命令的时候,命令的返回值会被转换成 Lua 数据结构. 同样地,当 Lua 脚本在 Redis 内置的解释器里运行时,Lua ...

  8. lua table integer index 特性

    table.maxn (table) Returns the largest positive numerical index of the given table, or zero if the t ...

  9. 树形打印lua table表

    为方便调试lua程序,往往想以树的形式打印出一个table,以观其表内数据.以下罗列了三种种关于树形打印lua table的方法;法一 local print = print local tconca ...

随机推荐

  1. 「总结」$dp1$

    大概就是做点题. 先列一下要做的题目列表,从\(UOJ\)上找的. 129寿司晚宴 348州区划分 370滑稽树上滑稽果 457数树 22外星人 37主旋律 300吉夫特 196线段树 311积劳成疾 ...

  2. Linux零基础之shell基础编程入门

    从程序员的角度来看, Shell本身是一种用C语言编写的程序,从用户的角度来看,Shell是用户与Linux操作系统沟通的桥梁.用户既可以输入命令执行,又可以利用 Shell脚本编程,完成更加复杂的操 ...

  3. 页表 Page tables

    逻辑地址与物理地址的转化 页表是由页表项(PTE)组成的数组.512个PTE构成一个页表页(Page-table page). PTE中包含了物理页码(PPN physical page number ...

  4. 你知道怎么使用Google两步验证保护账户安全吗？

    目录 为什么我们需要使用它? 对有些人来说,盗取密码比您想象的更简单 什么是Google两步验证? 多一道安全防线 什么是Google Authenticator ? 使用Google两步验证的好处 ...

  5. cf13B Letter A（分类+简单计算几何，，）

    题意: 给三个线段(每个线段的两个端点的坐标),问这三个线段能否组成字母A. 组成字母A的条件: 1.两个线段有公共端点. 2.这两个线段夹角小于等于90度. 3.第三个线段的两个端点分别在这两个线段 ...

  6. 微服务（七）Gateway服务网关

    1 为什么要有网关 权限控制:网关作为微服务入口,需要校验用户是是否有请求资格,如果没有则进行拦截. 路由和负载均衡:一切请求都必须先经过gateway,但网关不处理业务,而是根据某种规则,把请求转发 ...

  7. Linux ps -ef 命令输出解释

    UID: 程序拥有者PID:程序的 IDPPID:程序父级程序的 IDC:  CPU 使用的百分比STIME: 程序的启动时间TTY: 登录终端TIME : 程序使用掉 CPU 的时间CMD: 下达的 ...

  8. centos 7 安装nfs 实现主机目录共享

    多台服务器之间共享目录,实现每个服务器进入目录看到的内容都一样 服务器A 服务器B 1.服务器A和服务器B,安装 nfs-utils和rpcbind #yum install -y nfs-utils ...

  9. Linux ns 3. Mnt Namespace 详解

    1. 文件系统层次化 对 Linux 系统来说一切皆文件,Linux 使用树形的层次化结构来管理所有的文件对象. 完整的Linux文件系统,是由多种设备.多种文件系统组成的一个混合的树形结构.我们首先 ...

  10. adduser vs useradd

    Always use adduser (and deluser when deleting users) when you're creating new users from the command ...