1 files changed, 529 insertions, 68 deletions

diff --git a/MoonParser/main.cpp b/MoonParser/main.cpp
index 202a8df..d0ef5c8 100644
--- a/MoonParser/main.cpp
+++ b/MoonParser/main.cpp
@@ -1,19 +1,36 @@
 #include <iostream>
-using std::cout;
 #include <string>
-using std::string;
+#include <codecvt>
 #include <unordered_set>
-using std::unordered_set;
 #include <stack>
-using std::stack;
 #include <algorithm>
 #include <sstream>
-using std::stringstream;
 #include <vector>
-using std::vector;
 #include "parserlib.hpp"
 using namespace parserlib;
 
+template<class Facet>
+struct deletable_facet : Facet
+{
+    template<class ...Args>
+    deletable_facet(Args&& ...args): Facet(std::forward<Args>(args)...) {}
+    ~deletable_facet() {}
+};
+typedef std::wstring_convert<deletable_facet<std::codecvt<char32_t, char, std::mbstate_t>>, char32_t> Converter;
+
+static inline std::string& trim(std::string& s)
+{
+        s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch)
+        {
+                return !std::isspace(ch);
+        }));
+        s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch)
+        {
+                return !std::isspace(ch);
+        }).base(), s.end());
+        return s;
+}
+
 #define p(expr) user(expr, [](const item_t& item) \
 { \
         stringstream stream; \
@@ -29,11 +46,11 @@ struct State
                 indents.push(0);
                 stringOpen = -1;
         }
-        stringstream buffer;
+        std::stringstream buffer;
         size_t stringOpen;
-        stack<int> indents;
-        stack<bool> doStack;
-        unordered_set<string> keywords = {
+        std::stack<int> indents;
+        std::stack<bool> doStack;
+        std::unordered_set<std::string> keywords = {
                 "and", "while", "else", "using", "continue",
                 "local", "not", "then", "return", "from",
                 "extends", "for", "do", "or", "export",
@@ -42,9 +59,123 @@ struct State
         };
 };
 
-struct Data
+class Data
 {
-        vector<char> bytes;
+public:
+        Data()
+        {
+                indent = 0;
+                callerStack.push(false);
+        }
+
+        Converter conv;
+        std::stringstream temp;
+        std::stringstream buffer;
+        std::vector<int> lineTable;
+        std::stack<bool> callerStack;
+        std::stack<std::string> withStack;
+
+        void beginLine(int line = -1)
+        {
+                for (int i = 0; i < indent; i++)
+                {
+                        buffer << '\t';
+                }
+                lineTable.push_back(line == -1 ? lineTable.back() : line);
+        }
+
+        void endLine()
+        {
+                buffer << '\n';
+        }
+
+        int indent;
+        struct Scope
+        {
+                Scope()
+                {
+                        localObjIndex = 0;
+                        localFnIndex = 0;
+                        localBaseIndex = 0;
+                        localWithIndex = 0;
+                }
+                int localObjIndex;
+                int localFnIndex;
+                int localBaseIndex;
+                int localWithIndex;
+                std::vector<std::string> locals;
+        };
+
+        std::string getNewLocalObj()
+        {
+                temp << "_obj_" << scope().localObjIndex;
+                scope().localObjIndex++;
+                std::string local = temp.str();
+                temp.str("");
+                temp.clear();
+                return local;
+        }
+
+        std::string getNewLocalFn()
+        {
+                temp << "_fn_" << scope().localObjIndex;
+                scope().localFnIndex++;
+                std::string local = temp.str();
+                temp.str("");
+                temp.clear();
+                return local;
+        }
+
+        std::string getNewLocalBase()
+        {
+                temp << "_base_" << scope().localBaseIndex;
+                scope().localBaseIndex++;
+                std::string local = temp.str();
+                temp.str("");
+                temp.clear();
+                return local;
+        }
+
+        bool isLocal(const std::string& var)
+        {
+                return _localVars.find(var) != _localVars.end();
+        }
+
+        void putLocal(const std::string& var)
+        {
+                if (_localVars.find(var) == _localVars.end())
+                {
+                        _localVars.insert(var);
+                        _scopeStack.top().locals.push_back(var);
+                }
+        }
+
+        void pushScope()
+        {
+                int lastWithIndex = scope().localWithIndex;
+                _scopeStack.emplace();
+                scope().localWithIndex = lastWithIndex + 1;
+                indent++;
+        }
+
+        Scope& scope()
+        {
+                return _scopeStack.top();
+        }
+
+        void popScope()
+        {
+                const auto& scope = _scopeStack.top();
+                for (const auto& var : scope.locals)
+                {
+                        _localVars.erase(var);
+                }
+                _scopeStack.pop();
+                indent--;
+        }
+private:
+        std::unordered_set<std::string> _localVars;
+        std::stack<Scope> _scopeStack;
 };
 
 rule Any = any();
@@ -88,8 +219,8 @@ rule Seperator = true_();
 rule Name = user(SpaceName, [](const item_t& item)
 {
         State* st = reinterpret_cast<State*>(item.user_data);
-        for (input_it i = item.begin; i != item.end; ++i) st->buffer << static_cast<char>(*i);
-        string name;
+        for (auto it = item.begin; it != item.end; ++it) st->buffer << static_cast<char>(*it);
+        std::string name;
         st->buffer >> name;
         st->buffer.str("");
         st->buffer.clear();
@@ -395,7 +526,8 @@ rule ChainItems = Seperator >> (chain_with_colon | ColonChain);
 
 extern rule Invoke, Slice;
 
-rule ChainItem = Invoke | DotChainItem | Slice | symx('[') >> Exp >> sym(']');
+rule Index = symx('[') >> Exp >> sym(']');
+rule ChainItem = Invoke | DotChainItem | Slice | Index;
 rule DotChainItem = symx('.') >> _Name;
 rule ColonChainItem = symx('\\') >> _Name;
 rule invoke_chain = Invoke >> -ChainItems;
@@ -553,8 +685,28 @@ rule Line = CheckIndent >> Statement | empty_line_stop;
 rule Block = Seperator >> Line >> *(+Break >> Line);
 rule BlockEnd = Block >> eof();
 
+class AstLeaf : public ast_node
+{
+public:
+        const std::string& getValue()
+        {
+                if (_value.empty())
+                {
+                        for (auto it = m_begin.m_it; it != m_end.m_it; ++it)
+                        {
+                                char ch = static_cast<char>(*it);
+                                _value.append(&ch, 1);
+                        }
+                        return trim(_value);
+                }
+                return _value;
+        }
+private:
+        std::string _value;
+};
+
 #define AST_LEAF(type) \
-class type##_t : public ast_node \
+class type##_t : public AstLeaf \
 { \
 public: \
         virtual int get_type() override { return ast_type<type##_t>(); }
@@ -570,59 +722,88 @@ public: \
 ast<type##_t> __##type##_t(type);
 
 AST_LEAF(Num)
-        double value;
         virtual void visit(void* ud) override
         {
-                stringstream stream;
-                for (input::iterator it = m_begin.m_it; it != m_end.m_it; ++it)
-                {
-                        stream << static_cast<char>(*it);
-                }
-                stream >> value;
+                Data* data = static_cast<Data*>(ud);
+                std::string str = data->conv.to_bytes(&*m_begin.m_it, &*m_end.m_it);
+                data->buffer << trim(str);
         }
 AST_END(Num)
 
 AST_LEAF(_Name)
-        virtual void construct(ast_stack& st) override
+        virtual void visit(void* ud) override
         {
-                stringstream stream;
-                for (input::iterator it = m_begin.m_it; it != m_end.m_it; ++it)
-                {
-                        stream << (char)*it;
-                }
-                stream >> value;
-                ast_node::construct(st);
+                Data* data = static_cast<Data*>(ud);
+                data->buffer << getValue();
         }
-        string value;
 AST_END(_Name)
 
 AST_NODE(Name)
         ast_ptr<_Name_t> name;
+        virtual void visit(void* ud) override
+        {
+                name->visit(ud);
+        }
 AST_END(Name)
 
 AST_LEAF(self)
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                data->buffer << "self";
+        }
 AST_END(self)
 
 AST_NODE(self_name)
         ast_ptr<_Name_t> name;
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                data->buffer << (data->callerStack.top() ? "self:" : "self.");
+                name->visit(ud);
+        }
 AST_END(self_name)
 
 AST_LEAF(self_class)
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                data->buffer << "self.__class";
+        }
 AST_END(self_class)
 
 AST_NODE(self_class_name)
         ast_ptr<_Name_t> name;
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                data->buffer << (data->callerStack.top() ? "self.__class:" : "self.__class.");
+                name->visit(ud);
+        }
 AST_END(self_class_name)
 
 AST_NODE(SelfName)
-        ast_ptr<ast_node> name;
+        ast_ptr<ast_node> name; // self_class_name_t | self_class_t | self_name_t | self_t
+        virtual void visit(void* ud) override
+        {
+                name->visit(ud);
+        }
 AST_END(SelfName)
 
 AST_NODE(KeyName)
-        ast_ptr<ast_node> name;
+        ast_ptr<ast_node> name; // SelfName_t | _Name_t
+        virtual void visit(void* ud) override
+        {
+                name->visit(ud);
+        }
 AST_END(KeyName)
 
 AST_LEAF(VarArg)
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                data->buffer << "...";
+        }
 AST_END(VarArg)
 
 AST_LEAF(local_flag)
@@ -634,6 +815,20 @@ AST_END(Seperator)
 AST_NODE(NameList)
         ast_ptr<Seperator_t> sep;
         ast_list<Name_t> names;
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                auto it = names.objects().begin();
+                Name_t* name = *it;
+                name->visit(ud);
+                ++it;
+                for (; it != names.objects().end(); ++it)
+                {
+                        name = *it;
+                        data->buffer << ", ";
+                        name->visit(ud);
+                }
+        }
 AST_END(NameList)
 
 AST_NODE(Local)
@@ -654,20 +849,157 @@ AST_NODE(Import)
         ast_ptr<Seperator_t> sep;
         ast_list<ImportName_t> names;
         ast_ptr<Exp_t> exp;
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                std::vector<std::tuple<const std::string*, bool>> nameItems;
+                nameItems.reserve(names.objects().size());
+                for (ImportName_t* importName : names.objects())
+                {
+                        if (Name_t* name = ast_cast<Name_t>(importName->name))
+                        {
+                                nameItems.push_back(std::make_tuple(&name->name->getValue(), false));
+                        }
+                        else
+                        {
+                                colon_import_name_t* colonName = ast_cast<colon_import_name_t>(importName->name);
+                                nameItems.push_back(std::make_tuple(&colonName->name->name->getValue(), true));
+                        }
+                }
+                data->buffer << "local ";
+                for (const auto& item : nameItems)
+                {
+                        data->buffer << *std::get<0>(item);
+                        if (&item != &nameItems.back())
+                        {
+                                data->buffer << ", ";
+                        }
+                }
+                data->endLine();
+
+                data->beginLine();
+                data->pushScope();
+                data->buffer << "do";
+                data->endLine();
+
+                std::string fromObj = data->getNewLocalObj();
+
+                data->beginLine();
+                data->buffer << "local " << fromObj << " = ";
+                ((ast_node*)exp.get())->visit(ud);
+                data->endLine();
+
+                data->beginLine();
+                for (const auto& item : nameItems)
+                {
+                        data->buffer << *std::get<0>(item);
+                        if (&item != &nameItems.back())
+                        {
+                                data->buffer << ", ";
+                        }
+                }
+                data->buffer << " = ";
+                for (const auto& item : nameItems)
+                {
+                        if (std::get<1>(item))
+                        {
+                                data->pushScope();
+                                data->buffer << "(function()";
+                                data->endLine();
+
+                                std::string varBase = data->getNewLocalBase();
+
+                                data->beginLine();
+                                data->buffer << "local " << varBase << " = " << fromObj;
+                                data->endLine();
+
+                                std::string varFn = data->getNewLocalFn();
+
+                                data->beginLine();
+                                data->buffer << "local " << varFn << " = " << varBase << '.' << *std::get<0>(item);
+                                data->endLine();
+
+                                data->beginLine();
+                                data->buffer << "return function(...)";
+                                data->endLine();
+
+                                data->beginLine();
+                                data->pushScope();
+                                data->buffer << varFn << '(' << varBase << ", ...)";
+                                data->endLine();
+
+                                data->beginLine();
+                                data->buffer << "end";
+                                data->popScope();
+                                data->endLine();
+
+                                data->beginLine();
+                                data->buffer << "end)()";
+                                data->popScope();
+                        }
+                        else
+                        {
+                                data->buffer << fromObj << '.' << *std::get<0>(item);
+                        }
+                        if (&item != &nameItems.back())
+                        {
+                                data->buffer << ", ";
+                        }
+                }
+                data->endLine();
+
+                data->beginLine();
+                data->buffer << "end";
+                data->popScope();
+        }
 AST_END(Import)
 
 AST_NODE(ExpListLow)
         ast_ptr<Seperator_t> sep;
         ast_list<Exp_t> exprs;
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                for (Exp_t* expr : exprs.objects())
+                {
+                        ((ast_node*)expr)->visit(ud);
+                        if (expr != exprs.objects().back())
+                        {
+                                data->buffer << ", ";
+                        }
+                }
+        }
 AST_END(ExpListLow)
 
 AST_NODE(ExpList)
         ast_ptr<Seperator_t> sep;
         ast_list<Exp_t> exprs;
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                for (Exp_t* expr : exprs.objects())
+                {
+                        ((ast_node*)expr)->visit(ud);
+                        if (expr != exprs.objects().back())
+                        {
+                                data->buffer << ", ";
+                        }
+                }
+        }
 AST_END(ExpList)
 
 AST_NODE(Return)
         ast_ptr<ExpListLow_t, true> valueList;
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                data->buffer << "return";
+                if (valueList && !valueList->exprs.objects().empty())
+                {
+                        data->buffer << ' ';
+                        valueList->visit(ud);
+                }
+        }
 AST_END(Return)
 
 class Assign_t;
@@ -677,6 +1009,18 @@ AST_NODE(With)
         ast_ptr<ExpList_t> valueList;
         ast_ptr<Assign_t, true> assigns;
         ast_ptr<Body_t> body;
+        /*
+        (function()
+    do
+      local _with_0 = Something()
+      _with_0:write("hello world")
+      return _with_0
+    end
+  end)()
+        */
+        virtual void visit(void* ud) override
+        {
+        }
 AST_END(With)
 
 AST_NODE(SwitchCase)
@@ -833,6 +1177,11 @@ class InvokeArgs_t;
 AST_NODE(ChainValue)
         ast_ptr<ast_node> caller; // Chain_t | Callable_t
         ast_ptr<InvokeArgs_t, true> arguments;
+
+        virtual void visit(void* ud) override
+        {
+
+        }
 AST_END(ChainValue)
 
 class KeyValue_t;
@@ -843,10 +1192,52 @@ AST_NODE(simple_table)
 AST_END(simple_table)
 
 class String_t;
-class SimpleValue_t;
+
+AST_NODE(SimpleValue)
+        ast_ptr<ast_node> value; /*
+        const_value_t |
+        If_t | Unless_t | Switch_t | With_t | ClassDecl_t | ForEach_t | For_t | While_t | Do_t |
+        unary_exp_t |
+        TblComprehension_t | TableLit_t | Comprehension_t | FunLit_t | Num_t;
+        */
+AST_END(SimpleValue)
+
+AST_NODE(Chain)
+        ast_ptr<ast_node> item; // chain_call_t | chain_item_t | chain_dot_chain_t | ColonChain_t
+AST_END(Chain)
 
 AST_NODE(Value)
         ast_ptr<ast_node> item; // SimpleValue_t | simple_table_t | ChainValue_t | String_t
+        virtual ast_node* get_flattened() override
+        {
+                if (SimpleValue_t* simpleValue = ast_cast<SimpleValue_t>(item))
+                {
+                        return simpleValue->value;
+                }
+                else if (simple_table_t* simple_table = ast_cast<simple_table_t>(item))
+                {
+                        return simple_table;
+                }
+                else if (ChainValue_t* chainValue = ast_cast<ChainValue_t>(item))
+                {
+                        if (chainValue->arguments)
+                        {
+                                return chainValue;
+                        }
+                        else
+                        {
+                                if (Chain_t* chain = ast_cast<Chain_t>(chainValue->caller))
+                                {
+                                        return chain->item;
+                                }
+                                else if (Callable_t* callable = ast_cast<Callable_t>(chainValue->caller))
+                                {
+                                        return callable->item;
+                                }
+                        }
+                }
+                return item;
+        }
 AST_END(Value)
 
 AST_LEAF(LuaString)
@@ -906,10 +1297,6 @@ AST_END(chain_dot_chain)
 
 class ColonChain_t;
 
-AST_NODE(Chain)
-        ast_ptr<ast_node> item; // chain_call_t | chain_item_t | chain_dot_chain_t | ColonChain_t
-AST_END(Chain)
-
 class Invoke_t;
 class Slice_t;
 
@@ -1068,15 +1455,6 @@ AST_NODE(unary_exp)
         ast_ptr<Exp_t> item;
 AST_END(unary_exp)
 
-AST_NODE(SimpleValue)
-        ast_ptr<ast_node> value; /*
-        const_value_t |
-        If_t | Unless_t | Switch_t | With_t | ClassDecl_t | ForEach_t | For_t | While_t | Do_t |
-        unary_exp_t |
-        TblComprehension_t | TableLit_t | Comprehension_t | FunLit_t | Num_t;
-        */
-AST_END(SimpleValue)
-
 AST_NODE(Assignment)
         ast_ptr<ExpList_t> assignable;
         ast_ptr<ast_node> target; // Update_t | Assign_t
@@ -1099,7 +1477,7 @@ AST_LEAF(BreakLoop)
 AST_END(BreakLoop)
 
 AST_NODE(Statement)
-        ast_ptr<ast_node> body; /*
+        ast_ptr<ast_node> content; /*
         Import_t | While_t | With_t | For_t | ForEach_t |
         Switch_t | Return_t | Local_t | Export_t | BreakLoop_t |
         Assignment_t | ExpList_t
@@ -1108,26 +1486,29 @@ AST_NODE(Statement)
 
         virtual void construct(ast_stack& st) override
         {
-                stringstream stream;
-                for (input::iterator it = m_begin.m_it; it != m_end.m_it; ++it)
-                {
-                        stream << (char)*it;
-                }
-                value = stream.str();
+                std::wstring_convert<deletable_facet<std::codecvt<char32_t, char, std::mbstate_t>>, char32_t> conv;
+                value = conv.to_bytes(&*m_begin.m_it, &*m_end.m_it);
                 ast_container::construct(st);
         }
 
         virtual void visit(void* ud) override
         {
-                cout << value << '\n';
+                std::cout << value << '\n';
         }
-        string value;
+        std::string value;
 AST_END(Statement)
 
 class Block_t;
 
 AST_NODE(Body)
         ast_ptr<ast_node> content; // Block | Statement
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                data->pushScope();
+                content->visit(ud);
+                data->popScope();
+        }
 AST_END(Body)
 
 AST_NODE(Line)
@@ -1144,7 +1525,7 @@ AST_NODE(Line)
         {
                 if (statment)
                 {
-                        cout << line << ": ";
+                        std::cout << line << ": ";
                         statment->visit(ud);
                 }
         }
@@ -1153,37 +1534,117 @@ AST_END(Line)
 AST_NODE(Block)
         ast_ptr<Seperator_t> sep;
         ast_list<Line_t> lines;
-
         virtual void visit(void* ud) override
         {
-                for (auto item : lines.objects())
+                Data* data = static_cast<Data*>(ud);
+                const auto& objs = lines.objects();
+                for (auto it = objs.begin(); it != objs.end(); ++it)
                 {
-                        item->visit(ud);
+                        Line_t* line = *it;
+                        if (!line->statment) continue;
+                        if (Local_t* local = ast_cast<Local_t>(line->statment->content))
+                        {
+                                if (local_flag_t* local_flag = ast_cast<local_flag_t>(local->name))
+                                {
+                                        std::vector<const std::string*> names;
+                                        for (auto cur = it; cur != objs.end(); ++cur)
+                                        {
+                                                Line_t* item = *cur;
+                                                if (!item->statment) continue;
+                                                if (Assignment_t* assignment = ast_cast<Assignment_t>(item->statment->content))
+                                                {
+                                                        for (Exp_t* expr : assignment->assignable->exprs.objects())
+                                                        {
+                                                                if (ChainValue_t* chainValue = ast_cast<ChainValue_t>(expr->value->item))
+                                                                if (Callable_t* callable = ast_cast<Callable_t>(chainValue->caller))
+                                                                if (Name_t* name = ast_cast<Name_t>(callable->item))
+                                                                {
+                                                                        const std::string& value = name->name->getValue();
+                                                                        if (local_flag->getValue() == "*")
+                                                                        {
+                                                                                names.push_back(&value);
+                                                                        }
+                                                                        else if (std::isupper(value[0]))
+                                                                        {
+                                                                                names.push_back(&value);
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+                                        }
+                                        if (!names.empty())
+                                        {
+                                                data->beginLine(line->m_begin.m_line);
+                                                data->buffer << "local ";
+                                                auto nameIt = names.begin();
+                                                auto name = *(*nameIt);
+                                                data->putLocal(name);
+                                                data->buffer << name;
+                                                nameIt++;
+                                                for (; nameIt != names.end(); ++nameIt)
+                                                {
+                                                        auto name = *(*nameIt);
+                                                        data->putLocal(name);
+                                                        data->buffer << ", ";
+                                                        data->buffer << name;
+                                                }
+                                                data->endLine();
+                                        }
+                                }
+                                else
+                                {
+                                        NameList_t* nameList = static_cast<NameList_t*>(local->name.get());
+                                        data->beginLine(line->m_begin.m_line);
+                                        data->buffer << "local ";
+                                        nameList->visit(ud);
+                                        for (Name_t* name : nameList->names.objects())
+                                        {
+                                                data->putLocal(name->name->getValue());
+                                        }
+                                        data->endLine();
+                                }
+                        }
+                        else
+                        {
+                                line->visit(ud);
+                        }
                 }
         }
 AST_END(Block)
 
+AST_NODE(BlockEnd)
+        ast_ptr<Block_t> block;
+        virtual void visit(void* ud) override
+        {
+                Data* data = static_cast<Data*>(ud);
+                data->pushScope();
+                block->visit(ud);
+                data->popScope();
+        }
+AST_END(BlockEnd)
+
 int main()
 {
-        string s = R"baddog()baddog";
-        input i(s.begin(), s.end());
+        std::wstring_convert<deletable_facet<std::codecvt<char32_t, char, std::mbstate_t>>, char32_t> conv;
+        std::string s = R"baddog(import \x, func, \memFunc from require "utils")baddog";
+        input i = conv.from_bytes(s);
 
         error_list el;
-        Block_t* root = nullptr;
+        Import_t* root = nullptr;
         State st;
-        if (parse(i, BlockEnd, el, root, &st))
+        if (parse(i, Import, el, root, &st))
         {
-                cout << "matched!\n";
+                std::cout << "matched!\n";
                 Data data;
                 root->visit(&data);
         }
         else
         {
-                cout << "not matched!\n";
+                std::cout << "not matched!\n";
                 for (error_list::iterator it = el.begin(); it != el.end(); ++it)
                 {
                         const error& err = *it;
-                        cout << "line " << err.m_begin.m_line << ", col " << err.m_begin.m_col << ": syntax error\n";
+                        std::cout << "line " << err.m_begin.m_line << ", col " << err.m_begin.m_col << ": syntax error\n";
                 }
         }
         system("pause");