fix: 修复一堆问题

CMakeLists.txt

@@ -7,17 +7,31 @@ enable_testing()
 add_executable(wcc
     src/wcc.cpp
     src/include/wxml.h
+    src/include/night.h
     src/wcc/usage.cpp
     src/wxa/wxa.cpp
     src/wxml/rewrite.cpp
     src/wxml/name_allocator.cpp
+    src/wxml/string_templating/common.cpp
     src/wxml/string_templating/token.cpp
+    src/wxml/dom_lib/rvm_op_code_position_recorder.cpp
+    src/wxml/dom_lib/rvm_op_code_position.cpp
     src/wxml/dom_lib/parse_exception.cpp
     src/wxml/dom_lib/token.cpp
     src/wxml/dom_lib/common.cpp
     src/wxml/dom_lib/machine.cpp
     src/wxml/dom_lib/tokenizer.cpp
     src/wxml/dom_lib/parser.cpp
+    src/night/night.cpp
+    src/night/ns_ast_parse.cpp
+    src/night/ns_compile_js.cpp
+    src/night/ns_node.cpp
+    src/night/ns_sourcemap.cpp
+    src/night/ns_stream.cpp
+    src/night/ns_token.cpp
+    src/night/ns_god/ns_god.cpp
+    src/wxml/expr_lib/parser.cpp
+    src/wxml/expr_lib/expr_syntax_tree.cpp
     src/wxml/compiler.cpp
     src/wxml/dom_lib/str_cache.cpp
     src/wxml/dom_lib/wxml_dom.cpp

src/include/night.h

@@ -0,0 +1,275 @@
+#ifndef __NIGHT_H__
+#define __NIGHT_H__
+
+#include <iostream>
+#include <map>
+#include <vector>
+
+namespace night
+{
+    extern std::string NS_TYPE_BOOL;
+    extern std::string NS_TYPE_VAR;
+    extern std::string NS_TYPE_NUM;
+    extern std::string NS_TYPE_B_TYPE;
+    extern std::string NS_TYPE_OP_SELF;
+    extern std::string NS_TYPE_BINARY;
+    extern std::string NS_TYPE_ASSIGN;
+    extern std::string NS_TYPE_TERNARY;
+    extern std::string NS_TYPE_OBJ_DOT;
+    extern std::string NS_TYPE_OBJ_PROPERTY;
+    extern std::string NS_TYPE_OBJ_SELF_OP;
+    extern std::string NS_TYPE_OBJ_BLOCK;
+    extern std::string NS_TYPE_BRACKET;
+    extern std::string NS_TYPE_CALL;
+    extern std::string NS_TYPE_KW;
+    extern std::string NS_TYPE_SKIP;
+    extern std::string NS_TYPE_STR;
+    extern std::string NS_TYPE_PUNC;
+    extern std::string NS_TYPE_FUNC;
+    extern std::string NS_TYPE_PROG;
+    extern std::string NS_TYPE_PROG_NO_SEM;
+    extern std::string NS_TYPE_PROG_NO_SEM_REQUIRE;
+    extern std::string NS_TYPE_ARRAY;
+    extern std::string NS_TYPE_SWITCH;
+    extern std::string NS_TYPE_DO_WHILE;
+    extern std::string NS_TYPE_WHILE;
+    extern std::string NS_TYPE_FOR;
+    extern std::string NS_TYPE_IF;
+    extern std::string NS_TYPE_K_V;
+
+    extern std::string std_v_n;
+    extern std::string std_v_v_n;
+
+    void compile_ns(std::string const&,std::string const&,std::string const&,uint,std::string&,bool);
+    void compile_ns_with_sourcemap(std::string const&,std::string const&,std::string const&,std::string const&,uint,std::string&,std::string&);
+    void readfile(char const*, std::string &);
+    void writefile(char const*, std::string &);
+
+    class NSGod
+    {
+    private:
+        /* data */
+    public:
+        NSGod(/* args */);
+        ~NSGod();
+        void gen_girl(std::string);
+        void gen_son(std::string);
+        void hamlet(void);
+    };
+
+    class ns_node
+    {
+    private:
+        /* data */
+    public:
+        std::string offset_0;
+        std::string offset_24;
+        std::string offset_60;
+        std::string offset_108;
+        std::string offset_156;
+        night::ns_node * offset_180;
+        night::ns_node * offset_184;
+        night::ns_node * offset_192;
+        std::vector<night::ns_node *> offset_196;
+        std::vector<night::ns_node *> offset_228;
+        ns_node(/* args */);
+        ~ns_node();
+        std::string debug_no_space(void);
+    };
+    
+    class NSToken
+    {
+    private:
+        /* data */
+    public:
+        NSToken(/* args */);
+        ~NSToken();
+        bool eof(void);
+        void err(std::string const&,int,int,bool);
+        void get_tokens_for_sourcemap(std::map<std::string, uint> &, std::map<uint,std::string> &);
+        void next(void);
+        void pass(void);
+        void peek(void);
+        void push(night::ns_node *);
+        void read_comment_method_1(void);
+        void read_comment_method_2(void);
+        void read_next(void);
+        void read_number(std::string const&);
+        void read_string(char,std::string const&);
+        void read_var(std::string const&);
+        std::string read_while(bool (*)(char,void *),void *);
+        void rw_cb_number(char,void *);
+        void skip_comment(std::string &);
+        void tk_is_comment2(char,void *);
+        void tk_is_not_line_break(char,void *);
+        void tk_is_valid_op_str(char,void *);
+        void tk_is_var(char,void *);
+        void tk_is_var_start(char,void *);
+        void tk_is_whitespace(char,void *);
+    };
+    
+    class NSASTParse
+    {
+    private:
+        /* data */
+        std::string offset_0;
+        night::NSGod * offset_24;
+        night::NSToken * offset_28;
+        int offset_36;
+        int offset_40;
+        std::string offset_44;
+        int offset_52;
+    public:
+        NSASTParse(/* args */);
+        NSASTParse(std::string, night::NSToken *, night::NSGod *);
+        ~NSASTParse();
+        void ast_call(night::ns_node *);
+        void ast_code_block(void);
+        void ast_dispatch(bool);
+        void ast_do_while(void);
+        void ast_expression(void);
+        void ast_expression_no_binary(void);
+        void ast_expression_no_comma(void);
+        void ast_for(void);
+        void ast_function(void);
+        void ast_if(void);
+        void ast_new_array(void);
+        void ast_obj_block(void);
+        void ast_obj_dot(night::ns_node *);
+        void ast_obj_op(night::ns_node *);
+        void ast_obj_op_self(night::ns_node *);
+        void ast_op_self(void);
+        void ast_require(void);
+        void ast_switch(void);
+        void ast_ternary_expression(void);
+        void ast_trans_kw(void);
+        void ast_var(void);
+        void ast_varname(void);
+        void ast_while(void);
+        void end_line(void);
+        void ignore_buildin_kw(std::string const&);
+        void ignore_op(std::string const&);
+        void ignore_punc(std::string const&);
+        void ignore_punc_pass_sem(std::string const&);
+        void is_buildin_keywords(std::string const&);
+        void is_exp(night::ns_node *);
+        void is_obj_op_self(bool);
+        void is_op(std::string const&);
+
+        /**
+         * 是 op操作符 或者是 comma逗号
+        */
+        void is_op_or_comma(std::string const&);
+
+        void is_op_self(bool);
+
+        /**
+         * 是否是标点符号（punctuation）
+        */
+        void is_punctuation(std::string const&);
+        void is_save_for_division(night::ns_node *);
+        void make_binary_or_just_value(night::ns_node *,bool);
+        void make_call_or_just_expression(night::ns_node *);
+        void make_list_by_parser(
+            std::string const&,
+            std::string const&,
+            std::string const&,
+            std::string const&,
+            bool,
+            int,
+            std::string
+            );
+        void top_down(void);
+    };
+
+    class ns_sourcemap
+    {
+    private:
+        /* data */
+    public:
+        std::string offset_0;
+        ns_sourcemap(/* args */);
+        ~ns_sourcemap();
+    };
+    
+    class NSCompileJs
+    {
+    private:
+        /* data */
+        night::NSASTParse * offset_24;
+        std::vector<std::string> * offset_28;
+    public:
+        std::string offset_0;
+        std::vector<night::ns_sourcemap> offset_36;
+        int offset_48;
+        NSCompileJs(/* args */);
+        ~NSCompileJs();
+        std::string compile(night::ns_node *);
+        std::string compile_assign(night::ns_node *);
+        std::string compile_binary(night::ns_node *);
+        std::string compile_call(night::ns_node *);
+        std::string compile_do_while(night::ns_node *);
+        std::string compile_for(night::ns_node *);
+        std::string compile_function(night::ns_node *);
+        std::string compile_if(night::ns_node *);
+        std::string compile_k_v(night::ns_node *);
+        std::string compile_obj_dot(night::ns_node *);
+        std::string compile_obj_property(night::ns_node *);
+        std::string compile_obj_self_op(night::ns_node *);
+        void compile_once(std::string &, std::vector<std::string> *, bool);
+        std::string compile_op_self(night::ns_node *);
+        std::string compile_prog(night::ns_node *);
+        std::string compile_prog_no_sem(night::ns_node *);
+        std::string compile_switch(night::ns_node *);
+        std::string compile_ternary(night::ns_node *);
+        std::string compile_var(night::ns_node *);
+        std::string compile_while(night::ns_node *);
+    };
+    
+    class NSStream
+    {
+    private:
+        /* data */
+        std::string offset_24;
+        int offset_48 = 0;
+        int offset_52 = 0; // 当前行数
+        int offset_56 = 0; // 当前行第几个字符位置
+    public:
+        NSStream(/* args */);
+        NSStream(std::string const&,std::string const&,uint);
+        ~NSStream();
+        void eof(void);
+        void eof_2(void);
+        void err(std::string const&,int,int,bool);
+        void next(void);
+        void peek(void);
+        void peek_2(void);
+    };
+
+    namespace str
+    {
+        void get_token(std::string const&, int);
+        void path_combine(
+            std::string const&,
+            std::string const&,
+            std::string&
+            );
+    } // namespace str
+
+    namespace sourcemap
+    {
+        void gen_sourcemap_content(
+            std::string const&,
+            std::map<std::string,uint>,
+            std::map<uint,std::string>,
+            std::vector<night::ns_sourcemap> &,
+            int,
+            std::string&,
+            std::string*
+            );
+        void int2vlq(int);
+    } // namespace sourcemap
+    
+} // namespace night
+
+#endif

src/include/wxml.h

@@ -46,12 +46,14 @@ namespace WXML
         private:
             /* data */
         public:
+            bool offset_0;
+            std::string offset_4;
             Token(/* args */);
             ~Token();
         };
         
         
-        void Deal(
+        int Deal(
             char const*,
             std::string &,
             std::vector<WXML::StringTemplating::Token> &,
@@ -89,7 +91,8 @@ namespace WXML
             int offset_24 = 0; // ???
             int offset_40 = 0; // AttrsCompartor用到，怎么来不知道
             // int offset_48 = 0;
-            int offset_56 = 0; // ??? -3, -1
+            // ??? -3, -1
+            int offset_56 = 0;
             std::string offset_60 = ""; // ???
             Token();
             Token(std::string &);
@@ -152,6 +155,7 @@ namespace WXML
         */
         std::string resolvePath(std::string const& path1, std::string const& path2);
 
+        std::string  removern(std::string const&);
         
         /**
          * 
@@ -217,8 +221,9 @@ namespace WXML
         {
         private:
             /* data */
-            std::map<std::string, int> d;
+            std::map<std::string, int> offset_0;
-            std::vector<std::string> offset_6;
+            int offset_20 = 0;
+            std::vector<std::string> offset_24;
         public:
             StrCache(/* args */);
             ~StrCache();
@@ -232,6 +237,9 @@ namespace WXML
         private:
             /* data */
         public:
+            std::string offset_0;
+            int offset_4;
+            RVMOpCodePosition(std::string);
             RVMOpCodePosition(/* args */);
             ~RVMOpCodePosition();
         };
@@ -240,6 +248,8 @@ namespace WXML
         private:
             /* data */
         public:
+            int offset_0 = 0;
+            int offset_4 = 0;
             RVMOpCodePositionRecorder(/* args */);
             ~RVMOpCodePositionRecorder();
         };
@@ -352,6 +362,18 @@ namespace WXML
                 WXML::DOMLib::RVMOpCodePositionRecorder *,
                 bool,
                 const std::map<std::string,std::string> &);
+            int DealSingleTokenToOps(
+                std::string const&,
+                std::string&,
+                std::stringstream &,
+                std::map<std::string,WXML::DOMLib::RVMOpCodePosition> &,
+                WXML::DOMLib::Token *,
+                bool,
+                int,
+                bool,
+                WXML::DOMLib::RVMOpCodePositionRecorder *,
+                bool,
+                const std::map <std::string,std::string> &);
         };
         
 
@@ -501,6 +523,23 @@ namespace WXML
     
     namespace EXPRLib
     {
+        class Parser
+        {
+        private:
+            /* data */
+        public:
+            Parser(/* args */);
+            ~Parser();
+            int Parse(
+                std::string const& a2,
+                std::string const& a3,
+                int a4,
+                int a5,
+                std::string& a6,
+                bool a7);
+        };
+        
+        
         class Tokenizer
         {
         private:
@@ -517,6 +556,11 @@ namespace WXML
         public:
             ExprSyntaxTree(/* args */);
             ~ExprSyntaxTree();
+            void RenderAsOps(
+                std::stringstream & a2,
+                std::string const& a3,
+                bool & a4
+                );
         };
 
         class Token

src/night/night.cpp

@@ -0,0 +1,79 @@
+#include "../include/night.h"
+
+namespace night
+{
+    std::string NS_TYPE_BOOL;
+    std::string NS_TYPE_VAR;
+    std::string NS_TYPE_NUM;
+    std::string NS_TYPE_B_TYPE;
+    std::string NS_TYPE_OP_SELF;
+    std::string NS_TYPE_BINARY;
+    std::string NS_TYPE_ASSIGN;
+    std::string NS_TYPE_TERNARY;
+    std::string NS_TYPE_OBJ_DOT;
+    std::string NS_TYPE_OBJ_PROPERTY;
+    std::string NS_TYPE_OBJ_SELF_OP;
+    std::string NS_TYPE_OBJ_BLOCK;
+    std::string NS_TYPE_BRACKET;
+    std::string NS_TYPE_CALL;
+    std::string NS_TYPE_KW;
+    std::string NS_TYPE_SKIP;
+    std::string NS_TYPE_STR;
+    std::string NS_TYPE_PUNC;
+    std::string NS_TYPE_FUNC;
+    std::string NS_TYPE_PROG;
+    std::string NS_TYPE_PROG_NO_SEM;
+    std::string NS_TYPE_PROG_NO_SEM_REQUIRE;
+    std::string NS_TYPE_ARRAY;
+    std::string NS_TYPE_SWITCH;
+    std::string NS_TYPE_DO_WHILE;
+    std::string NS_TYPE_WHILE;
+    std::string NS_TYPE_FOR;
+    std::string NS_TYPE_IF;
+    std::string NS_TYPE_K_V;
+
+
+    std::string std_v_n = "";
+    std::string std_v_v_n = "";
+
+    void compile_ns(
+        std::string const& a1,
+        std::string const& a2,
+        std::string const& a3,
+        uint a4,
+        std::string& a5,
+        bool a6)
+    {
+        a5 = "";
+        night::NSStream v38(a1, a3, a4);
+        night::NSToken v27;
+        night::NSGod v17;
+        night::NSASTParse v39(a1, &v27, &v17);
+
+        v17.hamlet();
+
+    }
+
+    void compile_ns_with_sourcemap(
+        std::string const&,
+        std::string const&,
+        std::string const&,
+        std::string const&,
+        uint,
+        std::string&,
+        std::string&
+        )
+    {
+
+    }
+
+    void readfile(char const*, std::string &)
+    {
+
+    }
+
+    void writefile(char const*, std::string &)
+    {
+
+    }
+}

src/night/ns_ast_parse.cpp

@@ -0,0 +1,41 @@
+#include "../include/night.h"
+
+namespace night
+{
+    
+
+    NSASTParse::NSASTParse(/* args */)
+    {
+    }
+
+    NSASTParse::NSASTParse(std::string a2, night::NSToken * a3, night::NSGod * a4)
+    {
+        this->offset_0 = a2;
+        this->offset_24 = a4;
+        this->offset_28 = a3;
+        this->offset_36 = 0;
+        this->offset_40 = 0;
+        this->offset_44 = "";
+        this->offset_52 = 0;
+    }
+    
+    NSASTParse::~NSASTParse()
+    {
+    }
+
+    void NSASTParse::is_op_or_comma(std::string const&)
+    {
+
+    }
+    
+    void NSASTParse::is_punctuation(std::string const&)
+    {
+        
+    }
+
+    void NSASTParse::top_down()
+    {
+
+    }
+
+}

src/night/ns_compile_js.cpp

@@ -0,0 +1,285 @@
+#include "../include/night.h"
+
+namespace night
+{
+    
+    NSCompileJs::NSCompileJs(/* args */)
+    {
+    }
+    
+    NSCompileJs::~NSCompileJs()
+    {
+    }
+    
+    std::string NSCompileJs::compile_assign(night::ns_node * a3)
+    {
+        return this->compile_binary(a3);
+    }
+    std::string NSCompileJs::compile_binary(night::ns_node *a3)
+    {
+        this->compile(a3->offset_180);
+        std::string v10 = " " + a3->offset_156;
+        std::string v3 = v10.append(" ");
+        // this->offset_48 = 
+        this->compile(a3->offset_184);
+        // v10 = v7 + v8;
+        std::string v4 = "";
+        // v4 = v10.append(v9);
+        return v4;
+    }
+    std::string NSCompileJs::compile_call(night::ns_node *a3)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_do_while(night::ns_node *a3)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_for(night::ns_node *a3)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_function(night::ns_node *a3)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_if(night::ns_node *a3)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_k_v(night::ns_node *)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_obj_dot(night::ns_node *)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_obj_property(night::ns_node *)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_obj_self_op(night::ns_node *)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_op_self(night::ns_node *a3)
+    {
+        this->compile(a3->offset_192);
+        for (auto i = a3->offset_196.begin(); i != a3->offset_196.end(); i++)
+        {
+            this->compile(*i);
+        }
+        
+        return "";
+    }
+    std::string NSCompileJs::compile_switch(night::ns_node *)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_ternary(night::ns_node *a3)
+    {
+        std::string v6 = this->compile(a3->offset_180);
+        v6.append(":");
+        // += v7
+        this->offset_48++;
+        this->compile(a3->offset_184);
+        // += v7
+        return "";
+    }
+    std::string NSCompileJs::compile_var(night::ns_node *)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_while(night::ns_node *)
+    {
+        return "";
+    }
+    std::string NSCompileJs::compile_prog(night::ns_node *a3)
+    {
+        std::string v9 = a3->offset_108;
+        if (v9.size() == 0)
+        {
+            v9 = ";";
+        }
+        auto v4 = a3->offset_228;
+        int v6 = 0;
+        for (auto i = v4.begin(); i != v4.end(); i++)
+        {
+            this->compile(*i);
+            v6++;
+            if (v6 != v4.size())
+            {
+                // +=
+                this->offset_48 += v9.size();
+            }
+        }
+        return "";
+        
+    }
+    
+    std::string NSCompileJs::compile_prog_no_sem(night::ns_node *a3)
+    {
+        if (night::NS_TYPE_OBJ_BLOCK == a3->offset_0)
+        {
+            // +=
+            this->offset_48++;
+        }
+        for (auto i = a3->offset_228.begin(); i != a3->offset_228.end(); i++)
+        {
+            this->compile(*i);
+            // +=
+        }
+        if (night::NS_TYPE_OBJ_BLOCK == a3->offset_0)
+        {
+            // +=
+            this->offset_48++;
+        }
+        return "";
+    }
+    
+    std::string NSCompileJs::compile(night::ns_node * a3)
+    {
+        if (this->offset_0.size() == 0)
+        {
+            std::string v9 = a3->offset_0;
+            if (night::NS_TYPE_SKIP == v9)
+            {
+                return "";
+            }
+            if (v9 != night::NS_TYPE_NUM)
+            {
+                if (v9 == night::NS_TYPE_BOOL)
+                {
+                    // TODO...
+                    return "";
+                }
+                if (v9 == night::NS_TYPE_STR)
+                {
+                    // TODO...
+                    return "";
+                }
+                if (v9 != night::NS_TYPE_B_TYPE && v9 != night::NS_TYPE_PUNC)
+                {
+                    if (v9 != night::NS_TYPE_KW)
+                    {
+                        std::string result = "";
+                        if (v9 == night::NS_TYPE_VAR)
+                        {
+                            result = this->compile_var(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_K_V)
+                        {
+                            result = this->compile_k_v(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_IF)
+                        {
+                            result = this->compile_if(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_FOR)
+                        {
+                            result = this->compile_for(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_WHILE)
+                        {
+                            result = this->compile_while(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_DO_WHILE)
+                        {
+                            result = this->compile_do_while(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_SWITCH)
+                        {
+                            result = this->compile_switch(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_OBJ_SELF_OP)
+                        {
+                            result = this->compile_obj_self_op(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_OBJ_PROPERTY)
+                        {
+                            result = this->compile_obj_property(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_OBJ_DOT)
+                        {
+                            result = this->compile_obj_dot(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_OP_SELF)
+                        {
+                            result = this->compile_op_self(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_TERNARY)
+                        {
+                            result = this->compile_ternary(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_BINARY || v9 == night::NS_TYPE_ASSIGN)
+                        {
+                            result = this->compile_binary(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_FUNC)
+                        {
+                            result = this->compile_function(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_CALL)
+                        {
+                            result = this->compile_call(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_PROG)
+                        {
+                            result = this->compile_prog(a3);
+                        }
+                        else if (v9 == night::NS_TYPE_PROG_NO_SEM
+                        || v9 == night::NS_TYPE_PROG_NO_SEM_REQUIRE
+                        || v9 == night::NS_TYPE_OBJ_BLOCK
+                        || v9 == night::NS_TYPE_ARRAY
+                        || v9 == night::NS_TYPE_BRACKET)
+                        {
+                            result = this->compile_prog_no_sem(a3);
+                        }
+                        else
+                        {
+                            this->offset_0.assign(a3->offset_0);
+                        }
+                        return result;
+                    }
+                    std::string v10;
+                    if ("this" == a3->offset_60)
+                    {
+                        v10 = "(this.constructor===Window?{}:this)";
+                        this->offset_48++;
+                    }
+                    else
+                    {
+                        v10.assign(a3->offset_60);
+                    }
+                    night::ns_sourcemap v13;
+                    v13.offset_0 = a3->offset_24;
+                    std::string v18 = a3->offset_60;
+                    this->offset_36.push_back(v13);
+                    bool v5 = "this" == a3->offset_60;
+                    this->offset_48 = !v5 + v10.size() + this->offset_48 - 1;
+                    return v10;
+                }
+            }
+            this->offset_48 += a3->offset_60.size();
+            return a3->offset_60;
+        }
+        return "";
+    }
+
+    void NSCompileJs::compile_once(std::string &a3, std::vector<std::string> *a4, bool a5)
+    {
+        this->offset_28 = a4;
+        a3 = "";
+        this->offset_24->top_down();
+        night::ns_node v5;
+        if (a5)
+        {
+            std::string ret = v5.debug_no_space();
+            printf("ast :%s\n", ret.data());
+        }
+        std::string v9 = this->compile(&v5);
+        a3 = v9;
+    }
+
+}

src/night/ns_god/ns_god.cpp

@@ -0,0 +1,34 @@
+#include "../../include/night.h"
+namespace night
+{
+    
+    NSGod::NSGod(/* args */)
+    {
+    }
+    
+    NSGod::~NSGod()
+    {
+    }
+    
+    void NSGod::gen_girl(std::string a2)
+    {
+        if (night::std_v_n == a2)
+        {
+
+        }
+        if (night::std_v_v_n == a2)
+        {
+
+        }
+    }
+
+    void NSGod::gen_son(std::string)
+    {
+
+    }
+    
+    void NSGod::hamlet(void)
+    {
+
+    }
+} // namespace night

src/night/ns_node.cpp

@@ -0,0 +1,19 @@
+#include "../include/night.h"
+
+namespace night
+{
+    
+    ns_node::ns_node(/* args */)
+    {
+    }
+    
+    ns_node::~ns_node()
+    {
+    }
+    
+    std::string ns_node::debug_no_space()
+    {
+        return "";
+    }
+    
+}

src/night/ns_sourcemap.cpp

@@ -0,0 +1,13 @@
+#include "../include/night.h"
+
+namespace night
+{
+    
+    ns_sourcemap::ns_sourcemap(/* args */)
+    {
+    }
+    
+    ns_sourcemap::~ns_sourcemap()
+    {
+    }
+}

src/night/ns_stream.cpp

@@ -0,0 +1,45 @@
+#include "../include/night.h"
+
+namespace night
+{
+    
+    NSStream::NSStream(/* args */)
+    {
+    }
+    NSStream::NSStream(std::string const&,std::string const&,uint)
+    {
+    }
+    
+    NSStream::~NSStream()
+    {
+    }
+
+    void NSStream::peek(void)
+    {
+        if (this->offset_48 < this->offset_24.length())
+        {
+            char v3 = this->offset_24.at(this->offset_48);
+        }
+        else
+        {
+
+        }
+    }
+    void NSStream::peek_2(void)
+    {
+        if (this->offset_48 + 1 < this->offset_24.length())
+        {
+            char v3 = this->offset_24.at(this->offset_48 + 1);
+            if (v3 == '\n')
+            {
+                this->offset_52++;
+                this->offset_56 = 1;
+            }
+        }
+        else
+        {
+
+        }
+    }
+
+}

src/night/ns_token.cpp

@@ -0,0 +1,20 @@
+#include "../include/night.h"
+
+namespace night
+{
+    NSToken::NSToken(/* args */)
+    {
+    }
+    
+    NSToken::~NSToken()
+    {
+    }
+    void NSToken::peek(void)
+    {
+
+    }
+    void NSToken::read_next(void)
+    {
+
+    }
+}

src/night/sourcemap/sourcemap.cpp

@@ -0,0 +1,23 @@
+#include "../../include/night.h"
+namespace night
+{
+    
+    namespace sourcemap
+    {
+        void gen_sourcemap_content(
+            std::string const&,
+            std::map<std::string,uint>,
+            std::map<uint,std::string>,
+            std::vector<night::ns_sourcemap> &,
+            int,
+            std::string&,
+            std::string*)
+        {
+
+        }
+        void int2vlq(int)
+        {
+
+        }
+    } // namespace sourcemap
+} // namespace night

src/night/str/str.cpp

@@ -0,0 +1,16 @@
+#include "../../include/night.h"
+namespace night
+{
+    
+    namespace str
+    {
+        void get_token(std::string const&, int)
+        {
+
+        }
+        void path_combine(std::string const&, std::string const&, std::string&)
+        {
+
+        }
+    } // namespace str
+} // namespace night

src/wcc.cpp

@@ -543,7 +543,7 @@ std::string EscapeToJsonString(std::string const& a2)
         if (cur == '\\' || cur == '"' || cur <= 0x1Fu)
         {
             ret << "\\u";
-            ret << std::hex << std::setw(4) << std::setfill('0')<< cur;
+            ret << std::hex << std::setw(4) << std::setfill('0') << static_cast<int>(cur);
         }
         else
         {

src/wxml/compiler.cpp

@@ -5,6 +5,7 @@
 #include <set>
 #include <memory>
 #include <algorithm>
+#include "../include/night.h"
 
 namespace WXML{
     
@@ -123,7 +124,7 @@ namespace WXML{
                             data = data.append(v74);
                             auto v83 = WXML::Compiler::GetFuncId(a11, data);
                             std::string v72;
-                            // TODO: compile_ns
+                            night::compile_ns(filePath, v83, v79, v65, v72, 0);
                             int compilerResult = 1;
                             if (compilerResult)
                             {
@@ -242,18 +243,18 @@ namespace WXML{
                 v307_localVecStrMap1["__COMMON__"] = commonVec;
 
                 // mark - 10
-                for (int i = 0; i < splitedData.size(); i++)
+                for (auto i = splitedData.begin(); i != splitedData.end(); i++)
                 {
                     std::shared_ptr<std::stringstream> v328_ss(new std::stringstream());
-                    auto it = ssDataMap.lower_bound(splitedData[i]);
+                    auto it = ssDataMap.lower_bound(*i);
-                    if (it == ssDataMap.end())
+                    if (it == ssDataMap.end() || *i < it->first)
                     {
-                        ssDataMap.insert({splitedData[i], v328_ss});
+                        ssDataMap.insert({*i, v328_ss});
                     }
-                    std::string path = "./" + splitedData[i] + ".wxml";
+                    std::string path = "./" + *i + ".wxml";
                     std::vector<std::string> j;
                     j.push_back(path);
-                    v307_localVecStrMap1[splitedData[i]] = j;
+                    v307_localVecStrMap1[*i] = j;
                 }
                 // mark - 15
 
@@ -308,7 +309,18 @@ namespace WXML{
                 {
                     std::set<std::string> v328;
                     WXML::DOMLib::recurseDependencies(i->second, i->first, v328);
-                    // TODO: ...
+                    // std::vector<std::string> v278;
+                    // for (auto j = v328.begin(); j != v328.end(); j++)
+                    // {
+                    //     v278.push_back(*j);
+                    // }
+                    
+                    auto depList = dependencyListMap[i->first];
+                    for (auto j = v328.begin(); j != v328.end(); j++)
+                    {
+                        depList.push_back(*j);
+                    }
+                    dependencyListMap[i->first] = depList;
                 }
                 // mark - 45
                 for (auto i = v304.begin(); i != v304.end(); i++)
@@ -349,7 +361,7 @@ namespace WXML{
                 std::string const& fMark  // "f_" a22
                 */
                 std::string jj;
-                if (!isLLA)
+                if (isLLA)
                 {
                     jj = "global";
                 }
@@ -391,20 +403,52 @@ namespace WXML{
                     *ss << "codeURI,nv_decodeURIComponent,nv_encodeURI,nv_encodeURIComponent,$gdc,nv_JSON,_af,_gv,_ai,_grp,_gd,_gapi,$ix";
                     *ss << "c,_ic,_w,_ev,_tsd){";
                     *ss << "return function(path,global){" << lineEndMark;
-                    *ss << "if(typeof global==='undefined'){if (typeof __GWX_GLOBAL__==='undefined')global={};else global=__GWX_GLOBAL__;}" << lineEndMark;
+                    *ss << "if(typeof global==='undefined'){if (typeof __GWX_GLOBAL__==='undefined')global={};else global=__GWX_GLOBAL__;}";
                     *ss << "if(typeof __WXML_GLOBAL__ === 'undefined') {";
                     *ss << "__WXML_GLOBAL__={};" << lineEndMark;
+                    
+                /*
+                
+                std::map<std::string,std::string> const& fileContentMap, // a1
+                std::string& errorMessage,  // 错误信息 a2
+                std::map<std::string,std::string>& outputContentMap, // 输出 a3
+                std::map<std::string,std::string>& outputFuncMap,  // 输出 a4
+                std::map<std::string, std::vector<std::string>>& dependencyListMap, // a5
+                std::map<std::string, std::vector<std::string>>& componentListMap, // componentListMap a6
+                std::vector<std::string> const& splitedData,       // splitedData a7
+                std::map<std::string,std::string> const& mapData1, // mapData1 a8
+                bool isLLA,                // isLLA a9
+                std::string const& gwxMark,  // gwxMark a10
+                uint mark,                // mark a11
+                char lineEndMark,                // '\n' a12
+                std::string const& eMark1,  // 'e' a13
+                std::string const& charArr,  // const char off_5403C3[] = {'s','\0','e','\0'} a14
+                std::string const& ggMark,  // "gg" a15
+                std::string const& eMark,  // "e_" a16
+                std::string const& dMark,  // "d_" a17
+                std::string const& pMark,  // "p_" a18
+                std::string const& strEndMark,  // '\0' a19
+                std::string const& boxMark,  // "boxofchocolate" a20
+                std::string const& gdwxMark,  // "$gdwx" a21
+                std::string const& fMark  // "f_" a22
+                */
                     if ((mark & 0x80) != 0)
                     {
                         // TODO
+                        auto v252 = mapData1.find("life_cycle_callback_content");
+                        if (mapData1.end() != v252)
+                        {
+                            *ss << v252->second;
+                        }
                     }
                     *ss << "}";
                     *ss << "__WXML_GLOBAL__.modules = __WXML_GLOBAL__.modules || {};" << lineEndMark;
-                    if (v225 && gwxMark == "$gwx" && (mark & 0x60) == 0)
+                    if (v225 && gwxMark != "$gwx" && (mark & 0x60) == 0)
                     {
                         *ss << "$gwx('init', global);" << lineEndMark;
                     }
-                    *ss << "var " << eMark << "=global.entrys;" << lineEndMark;
+                    *ss << "var " << eMark << "={}" << lineEndMark;
+                    *ss << "if(typeof(global.entrys)==='undefined')global.entrys={};" << eMark << "=global.entrys;" << lineEndMark;
                     *ss << "var " << dMark << "={}" << lineEndMark;
                     *ss << "if(typeof(global.defines)==='undefined')global.defines={};" << dMark << "=global.defines;" << lineEndMark;
                     *ss << "var " << fMark << "={}" << lineEndMark;
@@ -426,9 +470,9 @@ namespace WXML{
                     // i->first v248
                     auto v97 = v307_localVecStrMap1[i->first];
                     int cnt = 0;
-                    for (auto i = v97.begin(); i != v97.end(); i++)
+                    for (auto i0 = v97.begin(); i0 != v97.end(); i0++)
                     {
-                        std::shared_ptr<WXML::DOMLib::WXMLDom> v244 = v304[*i];
+                        std::shared_ptr<WXML::DOMLib::WXMLDom> v244 = v304[*i0];
                         cnt++;
                         std::string v98 = std::to_string(cnt);
                         std::string v321 = v318 + "_" + v98;
@@ -448,7 +492,10 @@ namespace WXML{
                             *ss << "function Z(ops){z.push(ops)}";
                         }
                         *ss << lineEndMark;
-                        // TODO: RenderAllOpsAndRecord
+                        std::map<std::string,WXML::DOMLib::RVMOpCodePosition> v319;
+                        WXML::DOMLib::RVMOpCodePositionRecorder v300;
+                        // TODO: 待处理，死循环
+                        // v244->RenderAllOpsAndRecord(*i0, errorMessage, *ss, v319, &v300, (mark & 4) != 0, mapData1);
                         *ss << "})(__WXML_GLOBAL__.ops_cached." << v321 << ");";
                         *ss << "return __WXML_GLOBAL__.ops_cached." << v321 << lineEndMark;
                         *ss << "}" << lineEndMark;
@@ -483,9 +530,9 @@ namespace WXML{
                         *ss << "e.stack += '\\n    at ' + n.substring(2);console.error(e);}";
                         *ss << lineEndMark;
                         *ss << "}}}()" << lineEndMark;
-                        for (auto i = v309.begin(); i != v309.end(); i++)
+                        for (auto j = v309.begin(); j != v309.end(); j++)
                         {
-                            *ss << i->second << lineEndMark;
+                            *ss << j->second << lineEndMark;
                         }
                         
                     }
@@ -606,7 +653,8 @@ namespace WXML{
                                 }
                             }
                         }
-                        *ss << "}}" << lineEndMark;
+                        *ss << "]}" << lineEndMark;
+                        v228++;
 
                     }
                     *ss << "if(path&&" << eMark << "[path]){" << lineEndMark;
@@ -690,7 +738,7 @@ namespace WXML{
                     auto v197 = v307_localVecStrMap1[i->first];
                     *ss << "if(__vd_version_info__.delayedGwx||";
                     std::string v198 = "true";
-                    if (!( v225 || v197.size() > 0))
+                    if (!( v225 || v197.size() != 1))
                     {
                         v198 = "false";
                     }
@@ -846,7 +894,7 @@ namespace WXML{
             result << "';";
             result << a2;
             result << ".__wcc_version_info__={\"customComponents\":true,\"fixZeroRpx\":true,\"propValueDeepCopy\":false};";
-            result.str(a1);
+            a1 = result.str();
         }
         
         int RenderDefine(
@@ -908,30 +956,30 @@ namespace WXML{
                                              a20);
 
                 }
-                for (int i = 0; i < 6; i++)
+                for (int i = 0; i < a1.offset_72.size(); i++)
                 {
-                    /* code */
+                    auto cur = a1.offset_72[i];
-                    // WXML::Compiler::RenderDefine(
+                    WXML::Compiler::RenderDefine(
-                    //         v23 + 8 * i,
+                            *cur,
-                    //         a2,
+                            a2,
-                    //         a3,
+                            a3,
-                    //         a4,
+                            a4,
-                    //         a5,
+                            a5,
-                    //         a6,
+                            a6,
-                    //         a7,
+                            a7,
-                    //         a8,
+                            a8,
-                    //         a9,
+                            a9,
-                    //         a10,
+                            a10,
-                    //         a11,
+                            a11,
-                    //         a12,
+                            a12,
-                    //         a13,
+                            a13,
-                    //         a14,
+                            a14,
-                    //         a15,
+                            a15,
-                    //         a16,
+                            a16,
-                    //         a17,
+                            a17,
-                    //         a18,
+                            a18,
-                    //         a19,
+                            a19,
-                    //         a20);
+                            a20);
                 }
                 
                 

src/wxml/dom_lib/common.cpp

@@ -95,6 +95,18 @@ namespace WXML
         {
             return a1.second.offset_40 < a2.second.offset_40;
         }
+        
+        std::string removern(std::string const& a2)
+        {
+            std::string a1;
+            for (int i = 0; i < a2.length() - 1; i++)
+            {
+                char v3 = a2[i];
+                if (v3 != 13 || a2[i + 1] != '\n')
+                    a1.push_back(v3);
+            }
+            return a1;
+        }
     }
 
 }

src/wxml/dom_lib/rvm_op_code_position.cpp

@@ -7,6 +7,10 @@ namespace WXML
          * 感觉不太对，可能不是一个类
         */
         
+        RVMOpCodePosition::RVMOpCodePosition(std::string a)
+        {
+            this->offset_0 = a;
+        }
         RVMOpCodePosition::RVMOpCodePosition(/* args */)
         {
         }

src/wxml/dom_lib/str_cache.cpp

@@ -17,24 +17,32 @@ namespace WXML {
         void StrCache::RenderPathDefine(std::stringstream &ss)
         {
             ss << "var x=[";
-            // TODO...
+            for (int i = 0; i < this->offset_24.size(); i++)
-            // return ss;
+            {
+                if (i)
+                    ss << ",";
+                ss << "'";
+                WXML::Rewrite::ToStringCode(this->offset_24[i], ss);
+                ss << "'";
+            }
+            ss << "];";
+            
         }
         void StrCache::Insert(std::string s)
         {
-            if (!this->d.count(s))
+            if (!this->offset_0.count(s))
             {
-                // this->d[s] = this[5]; // ???
+                this->offset_0[s] = this->offset_20;
-                this->offset_6.push_back(s);
+                this->offset_24.push_back(s);
             }
         }
     
         int StrCache::GetStrID(std::string s)
         {
             int result = -1;
-            if(this->d.count(s))
+            if(this->offset_0.count(s))
             {
-                return this->d[s];
+                return this->offset_0[s];
             }
             return result;
         }

src/wxml/dom_lib/wxml_dom.cpp

@@ -7,7 +7,7 @@ namespace WXML {
     
     namespace DOMLib
     {
-
+        static const char *szWXIFControlAttrs[4] = { "wx-if", "wx:if", "wx:elif", "wx:else" };
         WXMLDom::WXMLDom(/* args */)
         {
         }
@@ -15,7 +15,243 @@ namespace WXML {
         WXMLDom::~WXMLDom()
         {
         }
-        const char off_553FDC[] = {'[','x','[','\0'};
+
+        int WXMLDom::DealSingleTokenToOps(
+            std::string const& a1,
+            std::string& a2,
+            std::stringstream & a3,
+            std::map<std::string,WXML::DOMLib::RVMOpCodePosition> & a4,
+            WXML::DOMLib::Token * a5,
+            bool a6,
+            int a7,
+            bool a8,
+            WXML::DOMLib::RVMOpCodePositionRecorder * a9,
+            bool a10,
+            const std::map<std::string,std::string> & a11
+            )
+        {
+            // DealSingleTokenToOps - 0
+            std::string v11;
+            if (a8)
+            {
+                v11 = a5->ToString();
+            }
+            else
+            {
+                v11 = a5->ToAttrContent();
+            }
+            std::vector<WXML::StringTemplating::Token> v77;
+            bool v77_b;
+            int d = WXML::StringTemplating::Deal(&v11[0], a2, v77, v77_b);
+            if (d)
+            {
+                throw this->Error(a1, *a5, "", "did you forget }}, ' or \"");
+            }
+            // DealSingleTokenToOps - 10
+            if ( a8) 
+            {
+                auto ptm = a11.find("plain_text_marker");
+                if (ptm != a11.end())
+                {
+                    
+                    WXML::StringTemplating::Token v85;
+                    v85.offset_0 = false;
+                    v85.offset_4 = ptm->second;
+                    v77.push_back(v85);
+                }
+            }
+            // DealSingleTokenToOps - 15
+            if (a7)
+            {
+                int v26;
+                if (v26 != a7)
+                {
+                    a5->offset_56 = -3;
+                    a5->offset_60 = "the very attr must be an expression (surrouned by `{{..}}`)";
+                    return -1;
+                }
+
+            }
+            // DealSingleTokenToOps - 20
+            if (v77.begin() == v77.end())
+            {
+                WXML::StringTemplating::Token token;
+                token.offset_0 = false;
+                token.offset_4 = "";
+                v77.push_back(token);
+            }
+            // DealSingleTokenToOps - 25
+            int v52 = 1;
+            if (v77.size() < 0x1C)
+            {
+                v52 = 0;
+                // TODO..
+            }
+            a3 << "Z(";
+            if (v52)
+            {
+                a3 << "[a,";
+                a9->offset_4++;
+            }
+            std::vector<std::pair<std::string,WXML::DOMLib::RVMOpCodePosition>> v80;
+            // DealSingleTokenToOps - 30
+            std::string v27 = "nt_";
+            if (a8)
+                v27 = "t_";
+            std::string v28 = "";
+            if (a6)
+            {
+                v28 = "_d";
+            }
+            for (int i = 0; i < v77.size(); i++)
+            {
+                if (i)
+                    a3 << ",";
+                auto v62 = v77[i];
+                std::string v29 = "s_";
+                if (v62.offset_0)
+                    v29 = "e_";
+                v29.append(v27);
+                v29.append(v62.offset_4);
+                v29.append(v28);
+                auto v63 = a4.find(v29);
+                if (v63 == a4.end())
+                {
+
+                    if (v77[i].offset_0)
+                    {
+                        WXML::EXPRLib::Parser vp;
+                        std::string v85 = "";
+                        int ret = vp.Parse(v77[i].offset_4, v85, 1, 1, a2, a6);
+                        if (ret)
+                        {
+                            a5->offset_56 = -3;
+                            a5->offset_60.assign(a2);
+                            a3 << "undefined";
+                            break;
+                        }
+                        WXML::EXPRLib::ExprSyntaxTree v70;
+                        v70.RenderAsOps(a3, v85, v77_b);
+                    }
+                    else
+                    {
+                        a3 << "[3,'";
+                        std::string r = WXML::DOMLib::removern(v77[i].offset_4);
+                        WXML::Rewrite::ToStringCode(r, a3);
+                        a3 << "']";
+                    }
+                    int v43 = -1;
+                    if (v52)
+                    {
+                        v43 = a9->offset_4;
+                    }
+                    WXML::DOMLib::RVMOpCodePosition pos;
+                    v80.push_back({"", pos});
+                }
+                else
+                {
+                    if (v63->second.offset_4 == -1 )
+                    {
+                        if (a10)
+                        {
+
+                            a3 << "z[";
+                            a3 << v63->second.offset_0;
+                            a3 << "][1]";
+                            a9->offset_4++;
+                            continue;
+                        }
+
+                        a3 << "z[";
+                        a3 << v63->second.offset_0;
+                    }
+                    else
+                    {
+                        
+                        a3 << "z[";
+                        a3 << v63->second.offset_0;
+                        if (a10)
+                        {
+                            a3 << "][1][";
+                        }
+                        else
+                        {
+                            a3 << "][";
+                        }
+                        a3 << v63->second.offset_4;
+                    }
+                    a3 << "]";
+                }
+                a9->offset_4++;
+            }
+            // DealSingleTokenToOps - 35
+            if (v52)
+                a3 << "]";
+            if (a5->offset_56 == -1)
+                a5->offset_56 = a9->offset_0;
+            a9->offset_0++;
+            for (auto i = v80.begin(); i != v80.end(); i++)
+            {
+                a4.emplace(i->first, i->second);
+            }
+            
+            if (a10)
+            {
+                a3 << ",['" << WXML::Rewrite::ToStringCode(a1);
+                a3 << "'," << a5->offset_8;
+                a3 << "," << a5->offset_12;
+                a3 << "])\n";
+            }
+            else
+            {
+                a3 << ")\n";
+            }
+            return 0;
+        }
+        void WXMLDom::RenderAllOpsAndRecord(
+            std::string const& a2,
+            std::string& a3,
+            std::stringstream & a4,
+            std::map<std::string,WXML::DOMLib::RVMOpCodePosition> &a5,
+            WXML::DOMLib::RVMOpCodePositionRecorder *a6,
+            bool a7,
+            const std::map<std::string,std::string> & a8
+            )
+        {
+            if (this->offset_0 == "TEXTNODE")
+            {
+                this->DealSingleTokenToOps(a2, a3, a4, a5, &this->offset_84, 0, 0, 1, a6, a7, a8);
+            }
+            else
+            {
+                for (auto i = this->offset_48.begin(); i != this->offset_48.end(); i++)
+                {
+                    if (
+                        i->second.offset_20
+                        && this->offset_0 != "import"
+                        && this->offset_0 != "include"
+                    )
+                    {
+                        if (
+                            this->offset_0 == "wx-template" && i->first == "data"
+                            || this->offset_0 == "wx-scope" && i->first == "wx:scope-data"
+                        )
+                        {
+                            this->DealSingleTokenToOps(a2, a3, a4, a5, &i->second, 1, 1, 0, a6, a7, a8);
+                        }
+                        else
+                        {
+                            this->DealSingleTokenToOps(a2, a3, a4, a5, &i->second, 0, 0, 0, a6, a7, a8);
+                        }
+                    }
+                }
+                for (int i = 0; i < this->offset_72.size(); i++)
+                {
+                    this->RenderAllOpsAndRecord(a2, a3, a4, a5, a6, a7, a8);
+                }
+                
+            }
+        }
         void WXMLDom::RenderMeAsFunction(
             std::string const& a2,
             std::string const& a3,
@@ -42,7 +278,7 @@ namespace WXML {
                 a7->GetNextName(name);
                 if (a15)
                 {
-                    a6 << a12 << off_553FDC;
+                    a6 << a12 << "[x[";
                     int id = offset_248.GetStrID(a2);
                     a6 << id;
                     a6 << "]][\"";
@@ -59,7 +295,7 @@ namespace WXML {
                 a6 << a11 << ",";
                 a6 << a10 << "){";
                 a6 << a13;
-                // if (a18)
+                if (a18.size())
                 {
                     a6 << "var z=" << a18 << "()" << a13;
                 }
@@ -76,7 +312,7 @@ namespace WXML {
                     a6 << WXML::Rewrite::ToStringCode(a2);
                     a6 << "\"],\"\",1)";
                     a6 << a13;
-                    a6 << "if(" << a14 << "[" << name << "]{_wl(";
+                    a6 << "if(" << a14 << "[" << name << "]){_wl(";
                     a6 << name << ",x[";
                     id = this->offset_248.GetStrID(a2);
                     a6 << id << "]);return}" << a13;
@@ -84,7 +320,8 @@ namespace WXML {
                     a6 << a14 << "[" << name << "]=true";
                     a6 << a13 << "try{" << a13;
                 }
-                // RenderChildren
+                std::map<std::string,std::string> v79;
+                // this->RenderChildren(a2, a3, a4, a11, a6, a7, a8, a9, a10, a12, a13, a16, a17, &v79);
                 if (a15)
                 {
                     a6 << "}catch(err){" << a13;
@@ -118,20 +355,278 @@ namespace WXML {
             std::map<std::string,std::string> * a15
             )
         {
+            // RenderChildren - 0
             auto size = a6.tellp();
             if (size > 52428800)
             {
-                throw "Interal error: generated code (>10M) will be too heavy to fly in a narrow wind.";
+                throw "RenderException Interal error: generated code (>10M) will be too heavy to fly in a narrow wind.";
             }
-            // while (/* condition */)
+            int v109 = 0;
-            // {
+            int v110 = 0;
-            //     /* code */
+            std::string v145;
-            // }
+            std::string v147;
-            int Stra;
+            for (int i = 0; i < this->offset_72.size(); i++)
-            // for (int i = 0; ; i = Stra)
+            {
-            // {
+                std::shared_ptr<WXML::DOMLib::WXMLDom> cur = this->offset_72[i];
-                
+                auto srcToken = cur->offset_48.find("src");
-            // }
+                if (
+                    (cur->offset_0 == "import"
+                    || cur->offset_0 == "wx-import")
+                    && ( srcToken != cur->offset_48.end())
+                )
+                {
+                    if (!v110)
+                    {
+                        a7->GetNextName(v145);
+                        a6 << "var " << v145 << "=" << a3 << "[x[";
+                        int StrID = this->offset_248.GetStrID(a2);
+                        a6 << StrID << "]].i" << a12;
+                    }
+                    v110++;
+                }
+                else if (cur->offset_0 == "include")
+                {
+                    if (srcToken != cur->offset_48.end())
+                    {
+                        if (!v109)
+                        {
+                            a7->GetNextName(v147);
+                            a6 << "var " << v147 << "=" << a3;
+                            a6 << "[x[" << this->offset_248.GetStrID(a2) << "]].j" << a12;
+                        }
+                    }
+                }
+            }
+            // RenderChildren - 5
+            std::string v149;
+            int Stra = 0;
+            for (int v127 = 0; v127 < this->offset_72.size(); v127++)
+            {
+                auto cur = this->offset_72[v127];
+                int Str = 1;
+                if (cur->offset_48.find("wx-if") == cur->offset_48.end())
+                {
+                    Str = cur->offset_48.end() != cur->offset_48.find("wx:if");
+                }
+                if (Str)
+                {
+                    a7->GetNextName(v149);
+                    cur->offset_220.assign(v149);
+                    Stra = 2;
+                    cur->offset_244 = 1;
+                }
+                else
+                {
+                    if (cur->offset_48.find("wx:elif") == cur->offset_48.end())
+                    {
+                        if (cur->offset_48.find("wx:else") != cur->offset_48.end())
+                        {
+                            if (Stra == 0)
+                            {
+                                throw this->Error(a2, cur->offset_84, "wx:else", "`wx:if not found, then something must be wrong`");
+                            }
+                            cur->offset_244 = v127;
+                            cur->offset_220.assign(v149);
+                        }
+                        Stra = 0;
+                    }
+                    else
+                    {
+                        if (Stra == 0)
+                        {
+                            throw this->Error(a2, cur->offset_84, "wx:elif", "`wx:if not found, then something must be wrong`");
+                        }
+                        Stra++;
+                        cur->offset_244 = v127;
+                        cur->offset_220.assign(v149);
+                    }
+                }
+
+            }
+            // RenderChildren - 10
+            std::string v151;
+            v151.assign(a5);
+            std::vector<std::pair<std::string,int>> v142;
+            for (int j = 0; j < this->offset_72.size(); j++)
+            {
+                std::shared_ptr<WXML::DOMLib::WXMLDom> cur = this->offset_72[j];
+                std::string v153;
+                const char **v98 = szWXIFControlAttrs;
+                if (cur->offset_244 <= 0)
+                {
+                    goto LABEL_56;
+                }
+                while (true)
+                {
+                    if (!*v98)
+                        break;
+                    auto v97 = cur->offset_48.find(*v98);
+                    if (v97 != cur->offset_48.end())
+                    {
+                        v153 = *v98;
+                        break;
+                    }
+                    ++v98;
+                }
+                if(cur->offset_48[v153].offset_56 == -3)
+                {
+                    throw this->Error(a2, cur->offset_48[v153], v153, cur->offset_48[v153].offset_60);
+                }
+                if(cur->offset_48[v153].offset_56 == -1 && v153 != "wx:else")
+                {
+                    throw this->Error(a2, cur->offset_84, v153, "value not set");
+                }
+                if (v153 == "wx-if" || v153 == "wx:if")
+                {
+                    a6 << "var " << cur->offset_220 << "=_v()" << a12;
+                    a6 << "_(" << a5 << "," << "," << cur->offset_220 << ")" << a12;
+                    a6 << "if(_oz(z," << cur->offset_48[v153].offset_56 << "," << a8 << ",";
+                    a6 << a9 << "," << a10 << ")){" << cur->offset_220 << ".wxVkey=";
+                    a6 << cur->offset_244 << a12;
+                    v142.emplace_back(cur->offset_220, 1);
+                    if (cur->offset_256)
+                        goto LABEL_54;
+                }
+                else
+                {
+                    if (v153 != "wx:elif")
+                    {
+                        a6 << "else{" << cur->offset_220 << ".wxVkey=" << cur->offset_244 << a12;
+                        if (!cur->offset_256)
+                            goto LABEL_55;
+                        LABEL_54:
+                        v142.emplace_back(cur->offset_220, 3);
+                        goto LABEL_55;
+                    }
+                    a6 << "else if(_oz(z," << cur->offset_48[v153].offset_56 << "," << a8 << "," << a9 << "," << a10 << ")){";
+                    a6 << cur->offset_220 << ".wxVkey=" << cur->offset_244 << a12;
+
+                    if (cur->offset_256)
+                        goto LABEL_54;
+                }
+                LABEL_55:
+                v151.assign(cur->offset_220);
+                LABEL_56:
+                if (
+                    cur->offset_0 == "import"
+                    || cur->offset_0 == "wx-import"
+                )
+                {
+                    auto srcToken = cur->offset_48.find("src");
+                    if (srcToken != cur->offset_48.end())
+                    {
+                        a6 << "_ai(" << v145 << ",x[";
+                        std::string v66 = srcToken->second.ToAttrContent();
+                        int v67 = this->offset_248.GetStrID(v66);
+                        a6 << v67 << "]," << a3 << ",x[" << this->offset_248.GetStrID(a2) << "],";
+                        a6 << cur->offset_92 << "," << cur->offset_96 << ")" << a12;
+                        goto LABEL_74;
+                    }
+                }
+                if (
+                    cur->offset_0 != "import"
+                    && cur->offset_0 != "wx-import"
+                )
+                {
+                    if (
+                        cur->offset_0 != "wx-repeat"
+                        && cur->offset_0 != "wx-template"
+                    )
+                    {
+                        std::string v155;
+                        a7->GetNextName(v155);
+                        a6 << "var " << v155 << "=_v()" << a12;
+                        a6 << "_(" << v151 << "," << v155 << ")" << a12;
+                        cur->RenderNonDefine(
+                            a2,
+                            a3,
+                            a4,
+                            v155,
+                            a6,
+                            a7,
+                            a8,
+                            a9,
+                            a10,
+                            a11,
+                            a12,
+                            a13,
+                            a14,
+                            a15);
+                        goto LABEL_74;
+                    }
+                    if (
+                        cur->offset_0 == "block"
+                        || cur->offset_0 == "include"
+                    )
+                    {
+                        cur->RenderNonDefine(
+                            a2,
+                            a3,
+                            a4,
+                            v151,
+                            a6,
+                            a7,
+                            a8,
+                            a9,
+                            a10,
+                            a11,
+                            a12,
+                            a13,
+                            a14,
+                            a15);
+                        goto LABEL_74;
+                    }
+                    if (cur->offset_0 == "wx-import")
+                    {
+                        if (cur->offset_0 == "wx-define")
+                        {
+                            std::string v155;
+                            a7->GetNextName(v155);
+                            cur->RenderNonDefine(
+                                a2,
+                                a3,
+                                a4,
+                                v155,
+                                a6,
+                                a7,
+                                a8,
+                                a9,
+                                a10,
+                                a11,
+                                a12,
+                                a13,
+                                a14,
+                                a15);
+                            a6 << "_(" << v151 << "," << v155 << ")" << a12;
+                            goto LABEL_74;
+                        }
+                    }
+                }
+                LABEL_74:
+                if (cur->offset_244 > 0)
+                {
+                    a6 << "}" << a12;
+                }
+            }
+            // RenderChildren - 15
+            for (int i = 0; i < v142.size(); i++)
+            {
+                a6 << v142[i].first << ".wxXCkey=" << v142[i].second << a12;
+            }
+            
+            // RenderChildren - 20
+            for (int i = 0; i < v110; i++)
+            {
+                a6 << v145 << ".pop()" << a12;
+            }
+            
+            // RenderChildren - 25
+            for (int i = 0; i < v109; i++)
+            {
+                a6 << v147 << ".pop()" << a12;
+            }
+            
+            // RenderChildren - 30
             
             
         }
@@ -410,7 +905,7 @@ namespace WXML {
             if (this->offset_0 == "block")
             {
                 
-                WXML::DOMLib::WXMLDom::RenderChildren(a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
+                this->RenderChildren(a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
                 goto LABEL_169;
             }
             

src/wxml/expr_lib/expr_syntax_tree.cpp

@@ -0,0 +1,26 @@
+#include "../../include/wxml.h"
+
+namespace WXML
+{
+    
+    namespace EXPRLib
+    {
+        
+            ExprSyntaxTree::ExprSyntaxTree(/* args */)
+            {
+
+            }
+            ExprSyntaxTree::~ExprSyntaxTree()
+            {
+
+            }
+            void ExprSyntaxTree::RenderAsOps(
+                std::stringstream & a2,
+                std::string const& a3,
+                bool & a4
+                )
+            {
+
+            }
+    }
+}

src/wxml/expr_lib/parser.cpp

@@ -0,0 +1,26 @@
+#include "../../include/wxml.h"
+
+namespace WXML
+{
+    
+    namespace EXPRLib
+    {
+        Parser::Parser(/* args */)
+        {
+        }
+        
+        Parser::~Parser()
+        {
+        }
+        int Parser::Parse(
+            std::string const& a2,
+            std::string const& a3,
+            int a4,
+            int a5,
+            std::string& a6,
+            bool a7)
+        {
+            return 0;
+        }
+    }
+} // namespace WXML

src/wxml/string_templating/common.cpp

@@ -4,14 +4,141 @@ namespace WXML
     namespace StringTemplating
     {
         
-        void Deal(
+        int Deal(
-            char const*Str,
+            char const* Str,
             std::string &a2,
             std::vector<WXML::StringTemplating::Token> &a3,
             bool & a4
             )
         {
+            int v4 = strlen(Str);
+            int v5 = 0;
+            int v12 = 0;
+            int v17 = 0;
+            int i;
+            for ( i = 0; i < v4 - 1; i++)
+            {
+                char v6 = Str[i];
+                char v7 = Str[i + 1];
+                if (v17 == 2)
+                {
+                    if (v6 == '\\')
+                    {
+                        ++i;
+                        continue;
+                    }
+                    v12 = 1;
+                    if (v6 != '"')
+                    {
+                        v12 = v17;
+                    }
+                    v17 = v12;
+                    continue;
+                }
+                if (v17 > 2)
+                {
+                    if (v6 == '\\')
+                    {
+                        i++;
+                        continue;
+                    }
+                    v12 = 1;
+                    if (v6 != '\'')
+                    {
+                        v12 = v17;
+                    }
+                    v17 = v12;
+                    continue;
+                }
+                if (v17)
+                {
+                    if (v6 != '}' || v7 != '}')
+                    {
+                        if (v6 == '"')
+                        {
+                            v17 = 2;
+                            continue;
+                        }
+                        v12 = 4;
+                        if (v6 != '\'')
+                        {
+                            v12 = v17;
+                        }
+                        v17 = v12;
+                        continue;
+                    }
+                    if (i > v5)
+                    {
+                        int v8 = i - 1;
+                        while (true)
+                        {
+                            char v9 = Str[v5];
+                            if (v9 != ' ' && v9 != '\t')
+                                break;
+                            ++v5;
+                        }
+                        while(v5 < v8)
+                        {
+                            char v10 = v8[Str];
+                            if (v10 != ' ' && v10 != '\t')
+                            {
+                                goto LABEL_30;
+                            }
+                            --v8;
+                        }
+                        if (v5 != v8)
+                        {
+                            goto LABEL_31;
+                        }
+                        LABEL_30:
+                        WXML::StringTemplating::Token v20;
+                        v20.offset_0 = true;
+                        std::string v19;
+                        // TODO: 待确认
+                        v19.append(Str, v5, v8 -v5 + 1);
+                        v20.offset_4 = v19;
+                        a3.push_back(v20);
+                        a4 = true;
+                        
+                    }
+                    LABEL_31:
+                    v17 = 0;
+                    v5 = i + 2;
+                    ++i;
+                }
+                else if (v6 == '{' && v7 == '{')
+                {
+                    if (i > v5)
+                    {
 
+                        WXML::StringTemplating::Token v20;
+                        std::string v19;
+                        v19.append(Str, v5, i -v5);
+                        v20.offset_0 = false;
+                        v20.offset_4 = v19;
+                        a3.push_back(v20);
+                    }
+                    v17 = 1;
+                    v5 = i + 2;
+                    i++;
+                }
+            }
+            if (v17) return 1;
+            int v13 = ~(i - v4);
+            if (i < v4 - 1)
+                v13 = 0;
+            int v14 = i + v13;
+            if (v5 <= v14)
+            {
+                WXML::StringTemplating::Token v20;
+                std::string v19;
+                v19.append(Str, v5, v14 - v5 + 1);
+                v20.offset_0 = false;
+                v20.offset_4 = v19;
+                a3.push_back(v20);
+            }
+            
+            return v17;
         }
     } // namespace StringTamplating
     

test/wcc.disassembly.cpp

@@ -11158,6 +11158,7 @@ struct _Unwind_Exception *__cdecl WXML::Compiler::RenderDefine(
   }
   for ( i = 0; ; ++i )
   {
+    // 18 * 4 = 72
     v23 = (*a1)[18];
     if ( (int)((*a1)[19] - v23) >> 3 <= i || lpuexcpt )
       break;
@@ -14363,6 +14364,7 @@ struct _Unwind_Exception *__cdecl WXML::Compiler::CompileLazy(
       std::string::basic_string((char *)&jj, (int)i1);
       WXML::DOMLib::StrCache::Insert(v255, (int)&jj);
       std::string::_M_dispose((void **)&jj);
+      // v304[i1]
       v134 = (volatile signed __int32 **)(*(_DWORD *)std::map<std::string,zcc::shared_ptr<WXML::DOMLib::WXMLDom>>::operator[](
                                                        &v304,
                                                        (int)i1)
@@ -15490,11 +15492,18 @@ _DWORD *__thiscall night::NSStream::peek(_DWORD *ecx0, night::NSStream *this)
   int v4; // edx
   char v5; // cl
 
+  // (_DWORD *)this + 12 -> this->offset_48
+  // (_DWORD *)this + 7 -> this->offset_28
   if ( *((_DWORD *)this + 12) < *((_DWORD *)this + 7) )
   {
+    // this->offset_24 std::string, offset_28 std::string.length()
+    // (_DWORD *)this + 6 -> this->offset_24
+    // (_DWORD *)this + 12 -> this->offset_48
     v3 = (char *)std::string::at((_DWORD *)this + 6, *((_DWORD *)this + 12));
+    // (_DWORD *)this + 14 -> this->offset_56
     v4 = *((_DWORD *)this + 14);
     v5 = *v3;
+    // (_DWORD *)this + 13 -> this->offset_52
     ecx0[1] = *((_DWORD *)this + 13);
     *(_BYTE *)ecx0 = v5;
     ecx0[2] = v4;
@@ -15514,16 +15523,17 @@ _DWORD *__thiscall night::NSStream::peek_2(_DWORD *ecx0, night::NSStream *this)
   char v3; // dl
   int v4; // ecx
   int v5; // eax
-
+  // this->offset_48 + 1 < this->offset_24.length()
   if ( (unsigned int)(*((_DWORD *)this + 12) + 1) < *((_DWORD *)this + 7) )
   {
+    // this->offset_24.at(this->offset_48 + 1)
     v3 = *(_BYTE *)std::string::at((_DWORD *)this + 6, *((_DWORD *)this + 12) + 1);
-    v4 = *((_DWORD *)this + 13);
+    v4 = *((_DWORD *)this + 13); // this->offset_52
-    v5 = *((_DWORD *)this + 14) + 1;
+    v5 = *((_DWORD *)this + 14) + 1;// this->offset_56 + 1
-    if ( v3 == 10 )
+    if ( v3 == '\n'/*10*/ )
     {
-      ++v4;
+      ++v4; // 行数
-      v5 = 1;
+      v5 = 1;// 当前行字符位置
     }
     *(_BYTE *)ecx0 = v3;
     ecx0[1] = v4;
@@ -15679,14 +15689,14 @@ unsigned __int8 __thiscall night::NSToken::skip_comment(night::NSStream **this,
     if ( result )
       break;
     result = (unsigned __int8)night::NSStream::peek(v5, this[1]);
-    if ( LOBYTE(v5[0]) != 47 )
+    if ( LOBYTE(v5[0]) != '/'/*47*/ )
       break;
     result = night::NSStream::eof_2(this[1]);
     if ( result )
       break;
     night::NSStream::peek_2(v5, this[1]);
     v4 = this[1];
-    if ( LOBYTE(v5[0]) == 47 )
+    if ( LOBYTE(v5[0]) == '/'/*47*/ )
     {
       night::NSStream::next(v5, v4);
       night::NSStream::next(v5, this[1]);
@@ -15695,7 +15705,7 @@ unsigned __int8 __thiscall night::NSToken::skip_comment(night::NSStream **this,
     else
     {
       result = (unsigned __int8)night::NSStream::peek_2(v5, v4);
-      if ( LOBYTE(v5[0]) != 42 )
+      if ( LOBYTE(v5[0]) != '*'/*42*/ )
         return result;
       night::NSStream::next(v5, this[1]);
       night::NSStream::next(v5, this[1]);
@@ -15746,7 +15756,7 @@ bool __stdcall night::NSASTParse::is_save_for_division(int a1)
       v3 = a1 + 60;
       if ( !std::operator==<char>("null", a1 + 60)
         && !std::operator==<char>("undefined", v3)
-        && !std::operator==<char>((char *)off_552620, v3) )
+        && !std::operator==<char>((char *)off_552620, v3) ) // "NaN"
       {
         v2 = std::operator==<char>("Infinity", v3);
         goto LABEL_22;
@@ -16041,11 +16051,12 @@ int __thiscall night::NSGod::gen_girl(void *this, int a2)
   int v7; // edx
   _DWORD *v9; // [esp+1Ch] [ebp-Ch] BYREF
 
-  v3 = operator new(0x1Cu);
+  v3 = operator new(0x1Cu); // 0x1C -> 28
-  *v3 = v3 + 2;
+  *v3 = v3 + 2; // v3.offset_8 缓冲区
-  v3[1] = 0;
+  v3[1] = 0; // v3.offset_4 长度
-  *((_BYTE *)v3 + 8) = 0;
+  *((_BYTE *)v3 + 8) = 0; // 缓冲区第一个字节是0
   v9 = v3;
+  // v3是一个std::string
   std::string::_M_assign((int)v3, a2);
   if ( std::operator==<char>((int)&night::std_v_n, a2) )
   {
@@ -19516,8 +19527,8 @@ void **__thiscall night::NSCompileJs::compile[abi:cxx11](void **this, int a2, _D
     std::string::basic_string((char *)v9, (int)a3);
     if ( std::operator==<char>((int)&night::NS_TYPE_SKIP, (int)v9) )
     {
-      std::string::basic_string(this, (char *)&byte_551F04);
+      std::string::basic_string(this, (char *)&byte_551F04); // '\0'
-LABEL_60:
+      LABEL_60: // 销毁数据，返回this
       std::string::_M_dispose(v9);
       return this;
     }
@@ -19547,7 +19558,7 @@ LABEL_60:
         std::string::basic_string(this, &v10);
         std::string::_M_dispose((void **)&v10);
         night::ns_sourcemap::~ns_sourcemap((void **)&v13);
-        goto LABEL_60;
+        goto LABEL_60; // 销毁数据，返回this
       }
       if ( std::operator==<char>((int)&night::NS_TYPE_STR, (int)v9) )
       {
@@ -19557,11 +19568,11 @@ LABEL_60:
         std::string::_M_dispose((void **)&v13);
         *(_DWORD *)(a2 + 48) += v11;
         std::string::basic_string(this, &v10);
-LABEL_10:
+    LABEL_10:
         v4 = &v10;
-LABEL_11:
+    LABEL_11:
         std::string::_M_dispose((void **)v4);
-        goto LABEL_60;
+        goto LABEL_60; // 销毁数据，返回this
       }
       if ( !std::operator==<char>((int)&night::NS_TYPE_B_TYPE, (int)v9)
         && !std::operator==<char>((int)&night::NS_TYPE_PUNC, (int)v9) )
@@ -19646,7 +19657,7 @@ LABEL_11:
             std::string::_M_assign(a2, (int)a3);
             std::string::basic_string(this, (char *)&byte_551F04);
           }
-          goto LABEL_60;
+          goto LABEL_60; // 销毁数据，返回
         }
         v10 = &v12;
         v11 = 0;
@@ -19671,27 +19682,29 @@ LABEL_11:
         v20[0] = 0;
         v21 = 0;
         v22 = 0;
+        // a3 + 6 -> a3.offset_24
         std::string::_M_assign((int)&v13, (int)(a3 + 6));
         v16 = a3[12];
         v17 = a3[13];
-        std::string::_M_assign((int)&v18, v7);
+        std::string::_M_assign((int)&v18, v7); // a3.offset_60
         v21 = a3[12];
-        v22 = *(_DWORD *)(a2 + 48);
+        v22 = *(_DWORD *)(a2 + 48); // a2.offset_48
         std::vector<night::ns_sourcemap>::push_back((night::ns_sourcemap **)(a2 + 36), (night::ns_sourcemap *)&v13);
         v5 = std::operator==<char>("this", v7);
         *(_DWORD *)(a2 + 48) = !v5 + v11 + *(_DWORD *)(a2 + 48) - 1;
         std::string::basic_string(this, &v10);
         night::ns_sourcemap::~ns_sourcemap((void **)&v13);
-        goto LABEL_10;
+        goto LABEL_10; // 销毁数据，返回this
       }
     }
+    // a3 + 15 -> a3.offset_60
     std::string::basic_string((char *)&v13, (int)(a3 + 15));
     *(_DWORD *)(a2 + 48) += v14;
     std::string::basic_string(this, &v13);
     v4 = &v13;
-    goto LABEL_11;
+    goto LABEL_11; // 销毁数据，返回
   }
-  std::string::basic_string(this, (char *)&byte_551F04);
+  std::string::basic_string(this, (char *)&byte_551F04); // "\0"
   return this;
 }
 
@@ -20246,6 +20259,7 @@ _DWORD *__thiscall night::NSCompileJs::compile_binary[abi:cxx11](_DWORD *this, i
   void *v9[6]; // [esp+80h] [ebp-38h] BYREF
   int v10[8]; // [esp+98h] [ebp-20h] BYREF
 
+  // a3.offset_180
   night::NSCompileJs::compile[abi:cxx11](a2, *(_DWORD *)(a3 + 180));
   std::operator+<char>((int)v10, " ", a3 + 156);
   v3 = std::string::append(v10, " ");
@@ -20450,11 +20464,12 @@ _DWORD *__thiscall night::NSCompileJs::compile_prog_no_sem[abi:cxx11](_DWORD *th
   *((_BYTE *)this + 8) = 0;
   if ( std::operator==<char>((int)&night::NS_TYPE_OBJ_BLOCK, a3) )
   {
-    std::string::operator+=(asc_5527F4);
+    std::string::operator+=(asc_5527F4); // "(\000)\000{"
     ++*(_DWORD *)(a2 + 48);
   }
   for ( lpuexcpt = 0; ; ++lpuexcpt )
   {
+    // a3.offset_228
     v3 = *(_DWORD **)(a3 + 228);
     if ( lpuexcpt >= (v3[1] - *v3) >> 2 )
       break;
@@ -20481,8 +20496,9 @@ char *__thiscall night::NSCompileJs::compile_once(char *this, int a2, unsigned i
   struct _Unwind_Exception *lpuexcpt; // [esp+18h] [ebp-60h]
   void *v9[8]; // [esp+58h] [ebp-20h] BYREF
 
+  // a2.offset_28
   *(_DWORD *)(a2 + 28) = a4;
-  std::string::operator=(a3, (char *)&byte_551F04);
+  std::string::operator=(a3, (char *)&byte_551F04); // "\0"
   v5 = (const char **)night::NSASTParse::top_down(*(int **)(a2 + 24));
   lpuexcpt = (struct _Unwind_Exception *)v5;
   if ( a5 )
@@ -20491,6 +20507,7 @@ char *__thiscall night::NSCompileJs::compile_once(char *this, int a2, unsigned i
     printf("ast :%s\n", (const char *)v9[0]);
     std::string::_M_dispose(v9);
   }
+  // night::ns_node *lpuexcpt
   night::NSCompileJs::compile[abi:cxx11](v9, a2, lpuexcpt);
   std::string::_M_assign((int)a3, (int)v9);
   std::string::basic_string(this, a2);
@@ -20535,7 +20552,7 @@ int __cdecl night::compile_ns(int a1, int a2, int a3, int a4, unsigned int *a5,
   void *v38[15]; // [esp+180h] [ebp-98h] BYREF
   void *v39[23]; // [esp+1BCh] [ebp-5Ch] BYREF
 
-  std::string::operator=(a5, (char *)&byte_551F04);
+  std::string::operator=(a5, (char *)&byte_551F04); // "\0"
   memset(v17, 0, sizeof(v17));
   night::NSStream::NSStream(v38, a1, a3, a4);
   v28[2] = (int)v28;
@@ -22215,14 +22232,14 @@ void **__cdecl WXML::DOMLib::removern(void **a1, _DWORD *a2)
   char v3; // al
   struct _Unwind_Exception *lpuexcpt; // [esp+18h] [ebp-40h]
 
-  std::string::basic_string(a1, (char *)&byte_5537CA);
+  std::string::basic_string(a1, (char *)&byte_5537CA); // '\0'
   for ( lpuexcpt = 0; ; lpuexcpt = (struct _Unwind_Exception *)((char *)lpuexcpt + 1) )
   {
     v2 = a2[1];
     if ( (unsigned int)lpuexcpt >= v2 )
       break;
     v3 = *((_BYTE *)lpuexcpt + *a2);
-    if ( v2 - 1 <= (unsigned int)lpuexcpt || v3 != 13 || *((_BYTE *)lpuexcpt + *a2 + 1) != 10 )
+    if ( v2 - 1 <= (unsigned int)lpuexcpt || v3 != 13 || *((_BYTE *)lpuexcpt + *a2 + 1) != '\n'/*10*/ )
       std::string::push_back(a1, v3);
   }
   return a1;
@@ -23683,7 +23700,7 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
   _DWORD *v107; // [esp+144h] [ebp-14h]
   int *v108; // [esp+148h] [ebp-10h]
   void *v109; // [esp+14Ch] [ebp-Ch]
-
+  // DealSingleTokenToOps - 0
   if ( a8 )
     v11 = WXML::DOMLib::Token::ToString[abi:cxx11]((int)a5);
   else
@@ -23694,11 +23711,12 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
   v79 = 0;
   LOBYTE(v77[0]) = 0;
   v48 = WXML::StringTemplating::Deal(v12, (int)a2, (char **)&v77[1], v77);
+  // DealSingleTokenToOps - 5
   if ( v48 )
   {
     exception = __cxa_allocate_exception(0x18u);
     std::string::basic_string(&Block, "did you forget }}, ' or \"");
-    std::string::basic_string((void **)&v85, (char *)&byte_5537CA);
+    std::string::basic_string((void **)&v85, (char *)&byte_5537CA); // '\0'
     WXML::DOMLib::WXMLDom::Error((int)exception, a1, (int)a5, (int *)&v85, (int *)&Block);
     std::string::_M_dispose((void **)&v85);
     std::string::_M_dispose(&Block);
@@ -23707,12 +23725,14 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
       (struct type_info *)&`typeinfo for WXML::DOMLib::RenderException,
       WXML::DOMLib::RenderException::~RenderException);
   }
+  // DealSingleTokenToOps - 10
   if ( a8 )
   {
     std::string::basic_string(&Block, "plain_text_marker");
     v59 = (struct _Unwind_Exception *)(a11 + 4);
     v53 = *(struct _Unwind_Exception **)(a11 + 8);
     lpuexcpt = (struct _Unwind_Exception *)(a11 + 4);
+    // 寻找key为plain_text_marker的元素
     while ( v53 )
     {
       v13 = (unsigned __int8)std::operator<<char>((int)v53 + 16, (int)&Block) == 0;
@@ -23763,7 +23783,7 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
       v86[0] = &v87;
       v86[1] = 0;
       v85 = 0;
-      std::string::operator=((unsigned int *)v86, (char *)&byte_5537CA);
+      std::string::operator=((unsigned int *)v86, (char *)&byte_5537CA); // '\0'
       lpuexcptb = *(struct _Unwind_Exception **)&v77[1];
       if ( *(_DWORD **)&v77[1] != v78 && **(_DWORD **)&v77[1] == 1 )
       {
@@ -23800,6 +23820,7 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
       if ( *(_DWORD **)&v77[1] != v78 && *(v78 - 7) == 1 )
         std::vector<WXML::StringTemplating::Token>::push_back((char **)&v77[1], &v85);
       lpuexcptc = 1;
+      // int v23
       v23 = 0;
       while ( -1227133513 * (((int)v78 - *(_DWORD *)&v77[1]) >> 2) > lpuexcptc )
       {
@@ -23825,6 +23846,7 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
       std::string::_M_dispose((void **)&v80);
     }
   }
+  // DealSingleTokenToOps - 15
   if ( a7 )
   {
     v25 = *(_DWORD **)&v77[1];
@@ -23836,12 +23858,14 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
     }
     if ( v26 != a7 )
     {
+      // a5.offset_56
       a5[14] = -3;
       std::string::operator=(a5 + 15, "the very attr must be an expression (surrouned by `{{..}}`)");
       v48 = -1;
-      goto LABEL_112;
+      goto LABEL_112; // 销毁数据，返回v48
     }
   }
+  // DealSingleTokenToOps - 20
   if ( v78 == *(_DWORD **)&v77[1] )
   {
     v89 = (int)&v91;
@@ -23853,6 +23877,7 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
     std::vector<WXML::StringTemplating::Token>::push_back((char **)&v77[1], &Block);
     std::string::_M_dispose((void **)&v89);
   }
+  // DealSingleTokenToOps - 25
   v52 = 1;
   if ( (unsigned int)v78 - *(_DWORD *)&v77[1] <= 0x1C )
   {
@@ -23870,18 +23895,21 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
     std::operator<<<std::char_traits<char>>(lpuexcptd, "[a,");
     ++a9[1];
   }
-  v27 = (const char *)&off_553AE9;
+  // DealSingleTokenToOps - 30
+  v27 = (const char *)&off_553AE9; // "nt_"
   v51 = 0;
   if ( a8 )
     v27 = "t_";
   v47 = (char *)v27;
-  v28 = &byte_5537CA;
+  v28 = &byte_5537CA; // '\0'
   if ( a6 )
-    v28 = (const char *)&unk_553AED;
+    v28 = (const char *)&unk_553AED; // "_d"
   v46 = (char *)v28;
   while ( -1227133513 * (((int)v78 - *(_DWORD *)&v77[1]) >> 2) > v51 )
   {
+    // v51 下标，在递增
     if ( v51 )
+      // a3
       std::operator<<<std::char_traits<char>>(lpuexcptd, ",");
     v83[1] = 0;
     v84 = 0;
@@ -23892,9 +23920,9 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
     if ( *v62 )
       v29 = "e_";
     std::string::operator=((unsigned int *)v83, v29);
-    std::string::append(v83, v47);
+    std::string::append(v83, v47); // v27
     std::string::append(v83, (int)(v62 + 1));
-    std::string::append(v83, v46);
+    std::string::append(v83, v46); // v28
     v57 = (_DWORD *)a4[2];
     v63 = a4 + 1;
     while ( v57 )
@@ -23961,10 +23989,10 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
         v104 = v34;
         v108 = 0;
         v109 = 0;
-        std::string::basic_string((void **)&v85, (char *)&byte_5537CA);
+        std::string::basic_string((void **)&v85, (char *)&byte_5537CA); // '\0'
         v66 = WXML::EXPRLib::Parser::Parse(
                 (int)&Block,
-                (char **)(*(_DWORD *)&v77[1] + v50 + 4),
+                (char **)(*(_DWORD *)&v77[1] + v50 + 4), // v77[i].offset_4
                 (int)&v85,
                 1,
                 1,
@@ -23999,7 +24027,7 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
         std::operator<<<std::char_traits<char>>(lpuexcptd, "']");
         std::string::_M_dispose(&Block);
       }
-      v68 = *a9;
+      v68 = *a9; // a9 WXML::DOMLib::RVMOpCodePositionRecorder *
       v43 = -1;
       if ( v52 )
         v43 = a9[1];
@@ -24034,7 +24062,7 @@ int __cdecl WXML::DOMLib::WXMLDom::DealSingleTokenToOps(
           std::operator<<<std::char_traits<char>>(lpuexcptd, "z[");
           v39 = (std::ostream::sentry *)std::ostream::operator<<(v63[10]);
           std::operator<<<std::char_traits<char>>(v39, "][1]");
-          goto LABEL_107;
+          goto LABEL_107; // a9.offset_4++ 下个循环
         }
         std::operator<<<std::char_traits<char>>(lpuexcptd, "z[");
         v40 = v63[10];
@@ -24057,6 +24085,7 @@ LABEL_107:
     std::string::_M_dispose(v83);
     ++v51;
   }
+  // DealSingleTokenToOps - 35
   if ( v52 )
     std::operator<<<std::char_traits<char>>(lpuexcptd, "]");
   v35 = *a9;
@@ -24066,10 +24095,12 @@ LABEL_107:
   a9[1] = 0;
   *a9 = v35 + 1;
   while ( (v81 - v80) >> 5 > v67 )
-    std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::RVMOpCodePosition>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::RVMOpCodePosition>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::RVMOpCodePosition>>>::_M_emplace_unique<std::pair&<std::string,WXML::DOMLib::RVMOpCodePosition>>(
+    std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::RVMOpCodePosition>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::RVMOpCodePosition>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::RVMOpCodePosition>>>
+    ::_M_emplace_unique<std::pair&<std::string,WXML::DOMLib::RVMOpCodePosition>>(
       a4,
       (int)&v80[32 * v67++]);
   std::vector<std::pair<std::string,WXML::DOMLib::RVMOpCodePosition>>::~vector((void ***)&v80);
+  // DealSingleTokenToOps - 40
   if ( a10 )
   {
     lpuexcpte = std::operator<<<std::char_traits<char>>(lpuexcptd, ",['");
@@ -24086,6 +24117,7 @@ LABEL_107:
   {
     std::operator<<<std::char_traits<char>>(lpuexcptd, ")\n");
   }
+  // DealSingleTokenToOps - 45
 LABEL_112:
   std::vector<WXML::StringTemplating::Token>::~vector((void **)&v77[1]);
   return v48;
@@ -24114,8 +24146,10 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderAllOpsAndRecord(
   }
   else
   {
+    // this->offset_60              this->offset_52
     for ( i = this[15]; (_DWORD *)i != this + 13; i = std::_Rb_tree_increment(i) )
     {
+      // i + 40 -> second
       if ( *(_DWORD *)(i + 60)
         && !std::operator==<char>((int)this, "import")
         && !std::operator==<char>((int)this, "include") )
@@ -24131,6 +24165,7 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderAllOpsAndRecord(
         }
       }
     }
+    // this[18] -> this->offset_72
     for ( j = 0; j < (this[19] - this[18]) >> 3; ++j )
       WXML::DOMLib::WXMLDom::RenderAllOpsAndRecord((int)a2, (int)a3, a4, (int)a5, (int)a6, a7, a8);
   }
@@ -25809,7 +25844,7 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
     std::string::_M_dispose((void **)&v155);
     __cxa_throw(
       exception,
-      (struct type_info *)&`typeinfo for'WXML::DOMLib::RenderException,
+      (struct type_info *)&`typeinfo for WXML::DOMLib::RenderException,
       WXML::DOMLib::RenderException::~RenderException);
   }
   v148 = 0;
@@ -25823,15 +25858,19 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
   v110 = 0;
   while ( 1 )
   {
+    // this->offset_72
     v15 = this[18];
-    if ( (this[19] - v15) >> 3 <= v137 )
+    if ( (this[19] - v15) >> 3 <= v137 ) // v137是下标，在递增
       break;
+    // v15 this->offset_72
+    // this->offset_72[i]
     if ( (std::operator==<char>(*(_DWORD *)(v15 + 8 * v137), "import")
        || std::operator==<char>(*(_DWORD *)(this[18] + 8 * v137), "wx-import"))
-      && (v124 = *(_DWORD *)(this[18] + 8 * v137),
+      && (v124 = *(_DWORD *)(this[18] + 8 * v137), // this->offset_72[i]
           v101 = (_DWORD *)(v124 + 52),
-          std::string::basic_string((void **)&v155, (char *)off_5539C8),
+          std::string::basic_string((void **)&v155, (char *)off_5539C8), // "src"
-          v125 = std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>::find(
+          v125 = std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>
+          ::find(
                    (_DWORD *)(v124 + 48),
                    (int)&v155),
           std::string::_M_dispose((void **)&v155),
@@ -25844,8 +25883,8 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
         v17 = std::operator<<<char>(v16, v145);
         v18 = std::operator<<<std::char_traits<char>>(v17, "=");
         v19 = std::operator<<<char>(v18, a3);
-        std::operator<<<std::char_traits<char>>(v19, (char *)off_553FDC);
+        std::operator<<<std::char_traits<char>>(v19, (char *)off_553FDC); // [x[
-        v130 = (_DWORD *)this[62];
+        v130 = (_DWORD *)this[62]; // this.offset_248
         std::string::basic_string((char *)&v155, (int)a2);
         StrID = WXML::DOMLib::StrCache::GetStrID(v130, (int)&v155);
         std::ostream::operator<<(StrID);
@@ -25857,11 +25896,14 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
     }
     else if ( std::operator==<char>(*(_DWORD *)(this[18] + 8 * v137), "include") )
     {
+      // this->offset_72[i]
+      // int v131
       v131 = *(_DWORD *)(this[18] + 8 * v137);
-      v126 = (_DWORD *)(v131 + 52);
+      v126 = (_DWORD *)(v131 + 52); // cur->offset_48.end()
-      std::string::basic_string((void **)&v155, (char *)off_5539C8);
+      std::string::basic_string((void **)&v155, (char *)off_5539C8); // "src"
-      v132 = std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>::find(
+      v132 = std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>
-               (_DWORD *)(v131 + 48),
+      ::find(
+               (_DWORD *)(v131 + 48), // cur->offset_48
                (int)&v155);
       std::string::_M_dispose((void **)&v155);
       if ( v132 != v126 )
@@ -25873,7 +25915,7 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
           v23 = std::operator<<<char>(v22, v147);
           v24 = std::operator<<<std::char_traits<char>>(v23, "=");
           v25 = std::operator<<<char>(v24, a3);
-          std::operator<<<std::char_traits<char>>(v25, (char *)off_553FDC);
+          std::operator<<<std::char_traits<char>>(v25, (char *)off_553FDC); // "[x["
           v133 = (_DWORD *)this[62];
           std::string::basic_string((char *)&v155, (int)a2);
           v26 = WXML::DOMLib::StrCache::GetStrID(v133, (int)&v155);
@@ -25886,30 +25928,34 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
       }
     }
     ++v137;
-  }
+  } // end while
+  // RenderChildren - 5
   v150 = 0;
   v149[0] = &v150;
   v149[1] = 0;
   v127 = 0;
   for ( i = 0; ; i = Stra )
   {
+    // this->offset_72
     v28 = this[18];
     if ( (this[19] - v28) >> 3 <= v127 )
       break;
-    Strc = *(char **)(v28 + 8 * v127);
+    Strc = *(char **)(v28 + 8 * v127); // cur
     v102 = Strc + 52;
     std::string::basic_string((void **)v153, "wx-if");
-    v29 = (char *)std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>::find(
+    v29 = (char *)std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>
-                    (_DWORD *)Strc + 12,
+    ::find(
-                    (int)v153);
+                    (_DWORD *)Strc + 12, // Strc.offset_48
+                    (int)v153); // "wx-if"
     Str = 1;
     if ( v102 == v29 )
     {
-      Strd = *(char **)(this[18] + 8 * v127);
+      Strd = *(char **)(this[18] + 8 * v127); // cur
       std::string::basic_string((void **)&v155, "wx:if");
-      Str = Strd + 52 != (char *)std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>::find(
+      Str = Strd + 52 != (char *)std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>
-                                   (_DWORD *)Strd + 12,
+      ::find(
-                                   (int)&v155);
+                                   (_DWORD *)Strd + 12,// Strd.offset_48
+                                   (int)&v155); // "wx:if"
       std::string::_M_dispose((void **)&v155);
     }
     std::string::_M_dispose((void **)v153);
@@ -25922,19 +25968,21 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
     }
     else
     {
-      Stre = *(char **)(this[18] + 8 * v127);
+      Stre = *(char **)(this[18] + 8 * v127); // cur
-      v103 = Stre + 52;
+      v103 = Stre + 52; // offset_52
       std::string::basic_string((void **)v151, "wx:elif");
-      Strf = (char *)std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>::find(
+      Strf = (char *)std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>
-                       (_DWORD *)Stre + 12,
+      ::find(
+                       (_DWORD *)Stre + 12, //offset_48
                        (int)v151);
       std::string::_M_dispose((void **)v151);
       if ( v103 == Strf )
       {
-        Strg = *(char **)(this[18] + 8 * v127);
+        Strg = *(char **)(this[18] + 8 * v127); // cur
         v104 = Strg + 52;
         std::string::basic_string((void **)v153, "wx:else");
-        Strh = (char *)std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>::find(
+        Strh = (char *)std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>
+        ::find(
                          (_DWORD *)Strg + 12,
                          (int)v153);
         std::string::_M_dispose((void **)v153);
@@ -25950,7 +25998,7 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
             std::string::_M_dispose((void **)&v155);
             __cxa_throw(
               v106,
-              (struct type_info *)&`typeinfo for'WXML::DOMLib::RenderException,
+              (struct type_info *)&`typeinfo for WXML::DOMLib::RenderException,
               WXML::DOMLib::RenderException::~RenderException);
           }
           v31 = *(_DWORD *)(this[18] + 8 * v127);
@@ -25971,7 +26019,7 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
           std::string::_M_dispose((void **)&v155);
           __cxa_throw(
             v105,
-            (struct type_info *)&`typeinfo for'WXML::DOMLib::RenderException,
+            (struct type_info *)&`typeinfo for WXML::DOMLib::RenderException,
             WXML::DOMLib::RenderException::~RenderException);
         }
         Stra = i + 1;
@@ -25981,7 +26029,8 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
       }
     }
     ++v127;
-  }
+  }// end while
+  // RenderChildren - 10
   v152 = 0;
   v151[0] = (int)&v152;
   v151[1] = 0;
@@ -25991,8 +26040,10 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
   for ( j = 0; (this[19] - this[18]) >> 3 > j; ++j )
   {
     std::string::_M_assign((int)v151, (int)a5);
+    // this->offset_72[j].offset_244
     if ( *(int *)(*(_DWORD *)(this[18] + 8 * j) + 244) <= 0 )
       goto LABEL_56;
+    // this->offset_72[j].offset_244 > 0
     v154 = 0;
     v153[0] = (int)&v154;
     v153[1] = 0;
@@ -26000,14 +26051,15 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
     while ( 1 )
     {
       Strb = *v98;
-      v96 = *(_DWORD *)(this[18] + 8 * j);
+      v96 = *(_DWORD *)(this[18] + 8 * j); // cur
       if ( !*v98 )
         break;
-      v95 = *(_DWORD *)(this[18] + 8 * j) + 52;
+      v95 = *(_DWORD *)(this[18] + 8 * j) + 52; // cur->offset_52
       std::string::basic_string((void **)&v155, Strb);
-      v97 = std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>::find(
+      v97 = std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>
-              (_DWORD *)(v96 + 48),
+      ::find(
-              (int)&v155);
+              (_DWORD *)(v96 + 48), // cur->offset_48
+              (int)&v155); // Strb v98
       std::string::_M_dispose((void **)&v155);
       ++v98;
       if ( v97 != (_DWORD *)v95 )
@@ -26017,7 +26069,7 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
       }
     }
     if ( *((_DWORD *)std::map<std::string,WXML::DOMLib::Token>::operator[](
-                       (_DWORD *)(*(_DWORD *)(this[18] + 8 * j) + 48),
+                       (_DWORD *)(*(_DWORD *)(this[18] + 8 * j) + 48), // cur->offset_48
                        (int)v153)
          + 14) == -3 )
     {
@@ -26032,7 +26084,7 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
       WXML::DOMLib::WXMLDom::Error((int)v107, a2, (int)v32, v153, v136);
       __cxa_throw(
         v107,
-        (struct type_info *)&`typeinfo for'WXML::DOMLib::RenderException,
+        (struct type_info *)&`typeinfo for WXML::DOMLib::RenderException,
         WXML::DOMLib::RenderException::~RenderException);
     }
     if ( *((_DWORD *)std::map<std::string,WXML::DOMLib::Token>::operator[](
@@ -26047,7 +26099,7 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
       std::string::_M_dispose((void **)&v155);
       __cxa_throw(
         v108,
-        (struct type_info *)&`typeinfo for'WXML::DOMLib::RenderException,
+        (struct type_info *)&`typeinfo for WXML::DOMLib::RenderException,
         WXML::DOMLib::RenderException::~RenderException);
     }
     if ( std::operator==<char>((int)v153, "wx-if") || std::operator==<char>((int)v153, "wx:if") )
@@ -26064,7 +26116,7 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
       std::operator<<<std::char_traits<char>>(v40, a12);
       std::operator<<<std::char_traits<char>>(v135, "if(_oz(z,");
       v41 = std::map<std::string,WXML::DOMLib::Token>::operator[](
-              (_DWORD *)(*(_DWORD *)(this[18] + 8 * j) + 48),
+              (_DWORD *)(*(_DWORD *)(this[18] + 8 * j) + 48), // cur->offset_48
               (int)v153);
       std::ostream::operator<<(*((_DWORD *)v41 + 14));
       v42 = std::operator<<<std::char_traits<char>>(v135, ",");
@@ -26098,7 +26150,7 @@ int __thiscall WXML::DOMLib::WXMLDom::RenderChildren(
         v50 = *(_DWORD *)(this[18] + 8 * j);
         if ( !*(_BYTE *)(v50 + 256) )
           goto LABEL_55;
-LABEL_54:
+        LABEL_54:
         std::string::basic_string((char *)&v155, v50 + 220);
         v157 = 3;
         std::vector<std::pair<std::string,int>>::emplace_back<std::pair<std::string,int>>((int)&v142, &v155);
@@ -26125,30 +26177,32 @@ LABEL_54:
       if ( *(_BYTE *)(v50 + 256) )
         goto LABEL_54;
     }
-LABEL_55:
+    LABEL_55:
     std::string::_M_assign((int)v151, *(_DWORD *)(this[18] + 8 * j) + 220);
     std::string::_M_dispose((void **)v153);
-LABEL_56:
+    // end this->offset_72[j].offset_244 > 0
+    LABEL_56:
     if ( std::operator==<char>(*(_DWORD *)(this[18] + 8 * j), "import")
       || std::operator==<char>(*(_DWORD *)(this[18] + 8 * j), "wx-import") )
     {
-      Stri = *(char **)(this[18] + 8 * j);
+      Stri = *(char **)(this[18] + 8 * j); // cur
       v99 = Stri + 52;
-      std::string::basic_string((void **)&v155, (char *)off_5539C8);
+      std::string::basic_string((void **)&v155, (char *)off_5539C8); // "src"
       Strj = (char *)std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>::find(
-                       (_DWORD *)Stri + 12,
+                       (_DWORD *)Stri + 12, // cur->offset_48
-                       (int)&v155);
+                       (int)&v155); // src
       std::string::_M_dispose((void **)&v155);
       if ( v99 != Strj )
       {
         v63 = std::operator<<<std::char_traits<char>>(v135, "_ai(");
         v64 = std::operator<<<char>(v63, v145);
-        std::operator<<<std::char_traits<char>>(v64, (char *)off_553CC8);
+        std::operator<<<std::char_traits<char>>(v64, (char *)off_553CC8); // ",x["
         v100 = (_DWORD *)this[62];
         Strk = *(char **)(this[18] + 8 * j);
-        std::string::basic_string((void **)v153, (char *)off_5539C8);
+        std::string::basic_string((void **)v153, (char *)off_5539C8); // "src"
-        v65 = std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>::find(
+        v65 = std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOMLib::Token>,std::_Select1st<std::pair<std::string const,WXML::DOMLib::Token>>,std::less<std::string>,std::allocator<std::pair<std::string const,WXML::DOMLib::Token>>>
-                (_DWORD *)Strk + 12,
+        ::find(
+                (_DWORD *)Strk + 12, // cur->offset_48
                 (int)v153);
         v66 = WXML::DOMLib::Token::ToAttrContent[abi:cxx11]((int)(v65 + 10));
         std::string::basic_string((char *)&v155, v66);
@@ -26159,7 +26213,7 @@ LABEL_56:
         std::operator<<<std::char_traits<char>>(v135, "],");
         v68 = std::operator<<<char>(v135, a3);
         std::operator<<<std::char_traits<char>>(v68, (char *)off_553CC8);
-        Strl = (char *)this[62];
+        Strl = (char *)this[62]; // 248
         std::string::basic_string((char *)&v155, (int)a2);
         v69 = WXML::DOMLib::StrCache::GetStrID(Strl, (int)&v155);
         std::ostream::operator<<(v69);
@@ -26208,7 +26262,7 @@ LABEL_56:
           a13,
           a14,
           a15);
-LABEL_73:
+        LABEL_73:
         std::string::_M_dispose((void **)&v155);
         goto LABEL_74;
       }
@@ -26266,13 +26320,14 @@ LABEL_73:
         }
       }
     }
-LABEL_74:
+    LABEL_74:
     if ( *(int *)(*(_DWORD *)(this[18] + 8 * j) + 244) > 0 )
     {
       v87 = std::operator<<<std::char_traits<char>>(v135, "}");
       std::operator<<<std::char_traits<char>>(v87, a12);
     }
   }
+  // RenderChildren - 15
   for ( lpuexcpta = 0;
         (unsigned int)lpuexcpta < -1227133513 * ((v143 - (int)v142) >> 2);
         lpuexcpta = (struct _Unwind_Exception *)((char *)lpuexcpta + 1) )
@@ -26282,18 +26337,21 @@ LABEL_74:
     v89 = (std::ostream::sentry *)std::ostream::operator<<(v142[7 * (_DWORD)lpuexcpta + 6]);
     std::operator<<<std::char_traits<char>>(v89, a12);
   }
+  // RenderChildren - 20
   for ( lpuexcptb = 0; v110 != lpuexcptb; lpuexcptb = (struct _Unwind_Exception *)((char *)lpuexcptb + 1) )
   {
     v90 = std::operator<<<char>(v135, v145);
     v91 = std::operator<<<std::char_traits<char>>(v90, ".pop()");
     std::operator<<<std::char_traits<char>>(v91, a12);
   }
+  // RenderChildren - 25
   for ( lpuexcptc = 0; v109 != lpuexcptc; lpuexcptc = (struct _Unwind_Exception *)((char *)lpuexcptc + 1) )
   {
     v92 = std::operator<<<char>(v135, v147);
     v93 = std::operator<<<std::char_traits<char>>(v92, ".pop()");
     std::operator<<<std::char_traits<char>>(v93, a12);
   }
+  // RenderChildren - 30
   std::vector<std::pair<std::string,int>>::~vector(&v142);
   std::string::_M_dispose((void **)v151);
   std::string::_M_dispose(v149);
@@ -29822,44 +29880,44 @@ int __cdecl WXML::StringTemplating::Deal(char *Str, int a2, char **a3, _BYTE *a4
   v17 = 0;
   while ( 1 )
   {
-    v6 = *((_BYTE *)lpuexcpt + (_DWORD)Str);
+    v6 = *((_BYTE *)lpuexcpt + (_DWORD)Str); // v6 = Str[lpuexcpt]
     if ( (int)lpuexcpt >= v16 || !v6 )
       break;
     v7 = *((_BYTE *)lpuexcpt + (_DWORD)Str + 1);
     if ( v17 == 2 )
     {
-      if ( v6 == 92 )
+      if ( v6 == '\\'/*92*/ )
         goto LABEL_37;
-      v11 = v6 == 34;
+      v11 = v6 == '"'/*34*/;
-LABEL_39:
+    LABEL_39:
       v12 = 1;
-LABEL_40:
+    LABEL_40:
       if ( !v11 )
         v12 = v17;
       v17 = v12;
-      goto LABEL_44;
+      goto LABEL_44; // ++ next while
     }
     if ( v17 > 2 )
     {
-      if ( v6 == 92 )
+      if ( v6 == '\\'/*92*/ )
       {
-LABEL_37:
+    LABEL_37:
         lpuexcpt = (struct _Unwind_Exception *)((char *)lpuexcpt + 1);
-        goto LABEL_44;
+        goto LABEL_44; // ++ next while
       }
-      v11 = v6 == 39;
+      v11 = v6 == '\''/*39*/;
       goto LABEL_39;
     }
     if ( v17 )
     {
-      if ( v6 != 125 || v7 != 125 )
+      if ( v6 != '}'/*125*/ || v7 != '}'/*125*/ )
       {
-        if ( v6 == 34 )
+        if ( v6 == '"'/*34*/ )
         {
           v17 = 2;
-          goto LABEL_44;
+          goto LABEL_44; // ++ next while
         }
-        v11 = v6 == 39;
+        v11 = v6 == '\''/*39*/;
         v12 = 4;
         goto LABEL_40;
       }
@@ -29869,20 +29927,20 @@ LABEL_37:
         while ( 1 )
         {
           v9 = Str[v5];
-          if ( v9 != 32 && v9 != 9 )
+          if ( v9 != ' '/*32*/ && v9 != '\t'/*9*/ )
             break;
           ++v5;
         }
         while ( v5 < (int)v8 )
         {
           v10 = v8[(_DWORD)Str];
-          if ( v10 != 32 && v10 != 9 )
+          if ( v10 != ' '/*32*/ && v10 != '\t'/*9*/ )
             goto LABEL_30;
           --v8;
         }
         if ( (char *)v5 != v8 )
           goto LABEL_31;
-LABEL_30:
+      LABEL_30:
         v21 = v23;
         v22 = 0;
         v23[0] = 0;
@@ -29895,12 +29953,12 @@ LABEL_30:
         *a4 = 1;
         std::string::_M_dispose((void **)&v21);
       }
-LABEL_31:
+      LABEL_31:
       v17 = 0;
       v5 = (int)lpuexcpt + 2;
       lpuexcpt = (struct _Unwind_Exception *)((char *)lpuexcpt + 1);
     }
-    else if ( v6 == 123 && v7 == 123 )
+    else if ( v6 == '{'/*123*/ && v7 == '{'/*123*/ )
     {
       if ( (int)lpuexcpt > v5 )
       {
@@ -29919,9 +29977,9 @@ LABEL_31:
       v5 = (int)lpuexcpt + 2;
       lpuexcpt = (struct _Unwind_Exception *)((char *)lpuexcpt + 1);
     }
-LABEL_44:
+    LABEL_44:
     lpuexcpt = (struct _Unwind_Exception *)((char *)lpuexcpt + 1);
-  }
+  } // end while
   if ( v17 )
     return 1;
   v13 = ~((unsigned int)lpuexcpt - v16);
@@ -53558,12 +53616,14 @@ void __thiscall night::NSASTParse::NSASTParse(int this, int a2, int a3, int a4)
   *(_DWORD *)(this + 48) = 0;
   *(_BYTE *)(this + 52) = 0;
   *(_DWORD *)(this + 44) = this + 52;
+
   *(_DWORD *)(this + 32) = 0;
   *(_DWORD *)(this + 28) = a3;
+
   *(_DWORD *)(this + 36) = 0;
   *(_DWORD *)(this + 24) = a4;
   *(_DWORD *)(this + 40) = 0;
-  std::string::operator=((unsigned int *)(this + 44), (char *)&byte_551F04);
+  std::string::operator=((unsigned int *)(this + 44), (char *)&byte_551F04); // "\0"
 }
 
 //----- (00471F5C) --------------------------------------------------------
@@ -177306,8 +177366,8 @@ char *__thiscall std::_Rb_tree<std::string,std::pair<std::string const,WXML::DOM
   int v13; // [esp+24h] [ebp-44h]
   struct _Unwind_Exception *lpuexcpt; // [esp+28h] [ebp-40h]
 
-  Block = (char *)operator new(0x30u);
+  Block = (char *)operator new(0x30u); // 0x30的空间
-  v10 = (void **)(Block + 16);
+  v10 = (void **)(Block + 16); // Block.offset_64
   std::string::basic_string(Block + 16, a2);
   v2 = *(_DWORD *)(a2 + 28);
   *((_DWORD *)Block + 10) = *(_DWORD *)(a2 + 24);

test/wcc.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+cd /mnt/d/Work/WeChatProjects/miniprogram-demo/miniprogram
+/root/github/wx-compiler/build/wcc "--config-path" "/mnt/d/Work/disassembly/wcc-exec/wcc/cmd1.txt" > /root/github/wx-compiler/test/wcc_linux.json
+/mnt/d/Work/disassembly/wcc-exec/wcc/wcc.exe "--config-path" "d:/Work/disassembly/wcc-exec/wcc/cmd1.txt" > /root/github/wx-compiler/test/wcc_win.json