term.h

Go to the documentation of this file.

#pragma once
#ifndef INCLUDED_NEWLANG_TERM_
#define INCLUDED_NEWLANG_TERM_
 
#include <cstring>
 
#include "warning_push.h"
#include "location.hh"
#include "parser.h"
#include "warning_pop.h"
 
#include "dict.h"
#include "version.h"
 
namespace newlang {
 
#define NL_TERMS(_) \
        _(NONE) \
        \
        _(SPACE) \
        _(INDENT) \
        _(COMMENT) \
        _(CRLF) \
        \
        _(DOC_BEFORE) \
        _(DOC_AFTER) \
        \
        _(SEQUENCE) \
        _(BLOCK) \
        _(BLOCK_TRY) \
        _(BLOCK_PLUS) \
        _(BLOCK_MINUS) \
        \
        _(INT_PLUS) \
        _(INT_MINUS) \
        _(INT_REPEAT) \
        \
        _(NAME) \
        _(LOCAL) \
        _(STATIC) \
        _(MACRO) \
        _(MODULE) \
        _(NATIVE) \
        _(MANGLED) \
        \
        _(TYPE) \
        _(INTEGER) \
        _(NUMBER) \
        _(COMPLEX) \
        _(RATIONAL) \
        \
        _(STRWIDE) \
        _(STRCHAR) \
        _(TEMPLATE) \
        _(EVAL) \
        \
        _(EMPTY) \
        _(ARGS) \
        _(ARGUMENT) \
        _(NEWLANG) \
        _(TYPENAME) \
        _(TYPECAST) \
        _(TYPEDUCK) \
        _(UNKNOWN) \
        _(SYMBOL) \
        _(NAMESPACE) \
        _(PARENT) \
        _(ESCAPE) \
        \
        _(MACRO_SEQ) \
        _(MACRO_STR) \
        _(MACRO_DEL) \
        _(MACRO_TOSTR) \
        _(MACRO_CONCAT) \
        _(MACRO_ARGUMENT) \
        _(MACRO_ARGNAME) \
        _(MACRO_ARGPOS) \
        _(MACRO_ARGCOUNT) \
        _(MACRO_ATTR) \
        _(MACRO_EXPR) \
        \
        _(CREATE_NEW) \
        _(CREATE_USE) \
        _(ASSIGN) \
        _(PURE_USE) \
        _(PURE_NEW) \
        _(APPEND) \
        _(SWAP) \
        _(SYM_RULE) \
        \
        _(FUNCTION) \
        _(COROUTINE) \
        _(ITERATOR) \
        \
        _(FOLLOW) \
        _(WHILE) \
        _(DOWHILE) \
        _(MATCHING) \
        _(WITH) \
        _(TAKE) \
        \
        _(RANGE) \
        _(ELLIPSIS) \
        _(FILLING) \
        \
        _(INDEX) \
        _(FIELD) \
        \
        _(TENSOR) \
        _(SET) \
        _(DICT) \
        _(CLASS) \
        _(OP_LOGICAL) \
        _(OP_MATH) \
        _(OP_COMPARE) \
        _(OP_BITWISE) \
        _(EMBED)
#define NL_TERMS(_) \ …
 
    enum class TermID : uint8_t {
        END = 0,
#define DEFINE_ENUM(name) name,
        NL_TERMS(DEFINE_ENUM)
#undef DEFINE_ENUM
    };
    enum class TermID : uint8_t {…};
 
    inline const char* toString(TermID type) {
        switch (type) {
            case TermID::END:
                return "END";
 
#define DEFINE_CASE(name) \
  case TermID::name:     \
    return #name;
                NL_TERMS(DEFINE_CASE)
#undef DEFINE_CASE
 
            default:
                LOG_ERROR("UNKNOWN TERM TYPE %d", static_cast<int> (type));
                return "UNKNOWN TYPE ";
        }
    }
    inline const char* toString(TermID type) {…}
 
    size_t IndexArg(TermPtr term);
    std::string ParserMessage(std::string &buffer, int row, int col, const char *format, ...);
 
    inline static bool IsAnyCreate(TermID id) {
        return id == TermID::CREATE_NEW || id == TermID::CREATE_USE || id == TermID::ASSIGN || id == TermID::PURE_USE || id == TermID::PURE_NEW;
    }
    inline static bool IsAnyCreate(TermID id) {…}
 
    /*
     * 
     * 
     */
 
    /*
     * Класс для хренения имен переменных в соответствии с их областью видимости.
     * Имена внутренних областей могут перекрывать внешние, но в
     * одной области видимости (блоке) имена переменных должны быть уникальны.
     * 
     * Поиск простого имени происходит в соответствии с name lookup.
     * При добавлении имени без сигила, оно преобразуются в локальную переменную (var -> $var)
     * Статические переменные <дополнительно> регистрируются в root, если он задан.
     * За счет этого к статическим переменным можно обратиться по их полному имени из любого места модуля.
     */
 
    class StorageTerm : public std::map<std::string, TermPtr> {
    public:
 
        static constexpr std::string MODULE_ROOT = "\\\\";
        static constexpr std::string MODULE_MAIN = "\\\\";
 
        typedef std::map<std::string, StorageTerm> ModuleMapType;
 
        StorageTerm() {
        }
        StorageTerm() {…}
        StorageTerm(const StorageTerm &clone);
 
        bool RegisterName(TermPtr term, const std::string_view syn = "");
 
        std::string Dump() {
            std::string result;
#ifdef BUILD_UNITTEST
            {
                std::string list;
                auto iter = this->begin();
                while (iter != this->end()) {
                    if (!list.empty()) {
                        list += ", ";
                    }
 
                    list += iter->first;
                    iter++;
                }
 
                //                result += "(";
                result += list;
                result += "\n";
            }
#endif
            return result;
        }
        std::string Dump() {…}
    };
    class StorageTerm : public std::map<std::string, TermPtr> {…};
 
    struct ScopeVars {
        TermPtr scope_name; 
        StorageTerm vars; 
        bool function_name; 
        std::vector<std::string> ns_lookup; 
    };
    struct ScopeVars {…};
 
    class NameLookupStack : SCOPE(protected) std::deque< ScopeVars > { // use deque instead of vector as it preserves iterators when resizing
    public:
        GlobalObjects & m_glob; 
        StorageTerm::ModuleMapType & m_modules; 
        size_t m_block_num; 
    public:
 
        NameLookupStack(GlobalObjects &glob, StorageTerm::ModuleMapType & modules);
 
        void clear();
 
        virtual ~NameLookupStack() {
        }
        virtual ~NameLookupStack() {…}
 
        static std::string EnumerateString(const StringArray &names) {
            std::string fails;
            for (auto &elem : names) {
                if (!fails.empty()) {
                    fails += ", ";
                }
                fails += elem;
            }
            return fails;
        }
        static std::string EnumerateString(const StringArray &names) {…}
 
        /* 
         * 
         */
        void PushScope(TermPtr ns, bool is_function = false);
 
        void PopScope() {
            ASSERT(size() > 1); // First level reserved for static objects
            pop_back();
        }
        void PopScope() {…}
 
        void SetLookupNamespace(TermPtr ns);
 
        bool AddName(const TermPtr var, const char * alt_name = nullptr);
 
        //        bool FixTransaction();
        //        void RollbackNames_();
        //        void RemoveName_(const std::string_view int_name);
        TermPtr FindInternalName(std::string_view int_name);
 
 
        TermPtr LookupName(std::string name);
        TermPtr LookupNameVars(const std::string_view name);
        TermPtr LookupNameNamespace(const std::string_view ns, const std::string_view name);
 
 
        std::string MakeInternalName(const TermPtr & term, bool is_static);
        std::string MakeInternalName(const std::string_view name, bool is_static);
        void ExpandNamespace(std::string & name);
        std::string GetNamespace();
        std::string GetFuntionName();
 
        std::string MakeNamespace(int skip, bool is_global);
        bool CheckInterrupt(std::string_view name);
 
        std::string GetOffer() {
            return "";
        }
        std::string GetOffer() {…}
 
        bool LookupBlock_(TermPtr &term);
        std::string GetOfferBlock();
 
        std::string Dump();
 
    };
    class NameLookupStack : SCOPE(protected) std::deque< ScopeVars > { // use deque instead of vector as it preserves iterators when resizing {…};
 
    /*
     * 
     * 
     */
    class Term : public Dict<Term>, public std::enable_shared_from_this<Term> {
    public:
 
        static TermPtr Create(TermID id, const char *text, parser::token_type lex_type = parser::token_type::END, size_t len = std::string::npos, location *loc = nullptr, std::shared_ptr<std::string> source = nullptr) {
            return std::make_shared<Term>(id, text, lex_type, (len == std::string::npos ? strlen(text) : len), loc, source);
        }
        static TermPtr Create(TermID id, const char *text, parser::token_type lex_type = parser::token_type::END, size_t len = std::string::npos, location *loc = nullptr, std::shared_ptr<std::string> source = nullptr) {…}
 
        static TermPtr CreateSymbol(char sym) {
            return Create(TermID::SYMBOL, std::string(1, sym).c_str(), static_cast<parser::token_type> (sym));
        }
        static TermPtr CreateSymbol(char sym) {…}
 
 
        static TermPtr CreateNone();
        static TermPtr CreateNil();
        static TermPtr CreateDict();
        static TermPtr CreateName(std::string name, TermID id = TermID::NAME);
        static TermPtr CreateIntName(const std::string_view name, const std::string_view int_name, TermID id = TermID::NAME);
 
        TermPtr Clone() {
            TermPtr result = Term::Create(m_id, m_text.c_str(), m_lexer_type);
            *result.get() = *this;
            return result;
        }
        TermPtr Clone() {…}
 
        Term(TermID id, const char *text, parser::token_type lex_type, size_t len, location *loc, std::shared_ptr<std::string> source = nullptr) {
            m_lexer_type = lex_type;
            m_ref.reset();
            if (text && len) {
                m_text.assign(text, std::min(strlen(text), len));
            }
            if (loc) {
                m_line = loc->end.line;
                m_col = loc->end.column;
            } else {
                m_line = 0;
                m_col = 0;
            }
            m_source = source;
            m_is_call = false;
            m_is_const = false;
            m_bracket_depth = 0;
            m_is_owner = false;
            m_is_take = false;
            //            m_is_reference = false;
            m_level = 0;
 
            //            m_ref_restrict = RefType::RefNone;
            //            m_ref_type = RefType::RefNone;
 
            m_id = id;
        }
        Term(TermID id, const char *text, parser::token_type lex_type, size_t len, location *loc, std::shared_ptr<std::string> source = nullptr) {…}
 
        virtual ~Term() {
#if BUILD_UNTITEST
            LOG_DUMP("DeleteVar %d \"%s\" (%p)", static_cast<int> (m_id), m_text.c_str(), (void *) this);
#endif
            clear_();
        }
        virtual ~Term() {…}
 
        inline TermID getTermID() const {
            return m_id;
        }
        inline TermID getTermID() const  {…}
 
        inline const std::string & getName() const {
            return m_name_or_class;
        }
        inline const std::string & getName() const  {…}
 
        inline std::string & getName() {
            return m_name_or_class;
        }
        inline std::string & getName() {…}
 
        inline void SetName(std::string & name) {
            m_name_or_class = name;
        }
        inline void SetName(std::string & name) {…}
 
        inline std::string & getText() {
            return m_text;
        }
        inline std::string & getText() {…}
 
        inline const std::string & getText() const {
            return m_text;
        }
        inline const std::string & getText() const  {…}
 
        inline bool isRef() {
            return !!m_ref;
        }
        inline bool isRef() {…}
 
        inline bool isCall() const {
            return m_is_call;
        }
        inline bool isCall() const  {…}
 
        inline bool isInterrupt() const {
            switch (m_id) {
                case TermID::INT_PLUS:
                case TermID::INT_MINUS:
                case TermID::INT_REPEAT:
                    return true;
                default:
                    return false;
            }
        }
        inline bool isInterrupt() const  {…}
 
        inline bool isCreateNew() const {
            switch (m_id) {
                case TermID::CREATE_NEW:
                case TermID::PURE_NEW:
                    return true;
            }
            return false;
        }
        inline bool isCreateNew() const  {…}
 
        inline bool isCreateUse() const {
            switch (m_id) {
                case TermID::CREATE_USE:
                case TermID::PURE_USE:
                    return true;
            }
            return false;
        }
        inline bool isCreateUse() const  {…}
 
        inline bool isCreate() const {
            switch (m_id) {
                case TermID::APPEND:
                case TermID::CREATE_NEW:
                case TermID::CREATE_USE:
                case TermID::ASSIGN:
                case TermID::PURE_NEW:
                case TermID::PURE_USE:
                case TermID::SWAP:
                    return true;
            }
            return false;
        }
        inline bool isCreate() const  {…}
 
        inline bool isPure() const {
            switch (m_id) {
                case TermID::PURE_NEW:
                case TermID::PURE_USE:
                    return true;
            }
            return false;
        }
        inline bool isPure() const  {…}
 
        inline bool isNone() const {
            return m_id == TermID::NAME && m_text.compare("_") == 0;
        }
        inline bool isNone() const  {…}
 
        inline bool isMacro() const {
            return m_id == TermID::MACRO_DEL || (isCreate() && m_left && m_left->m_id == TermID::MACRO_SEQ);
        }
        inline bool isMacro() const  {…}
 
        inline bool isReturn() const {
            return m_id == TermID::INT_PLUS || m_id == TermID::INT_MINUS;
        }
        inline bool isReturn() const  {…}
 
        inline const std::string GetFullName() const {
            std::string result(m_text);
            //result.insert(isType(result) ? 1 : 0, m_ns_block);
            return result;
        }
        inline const std::string GetFullName() const  {…}
 
        inline bool isFunction() const {
            return m_id == TermID::FUNCTION;
        }
        inline bool isFunction() const  {…}
 
        inline bool isScalar() const {
            switch (m_id) {
                case TermID::INTEGER:
                case TermID::NUMBER:
                    return true;
            }
            return false;
        }
        inline bool isScalar() const  {…}
 
        inline bool isString() const {
            switch (m_id) {
                case TermID::STRWIDE:
                case TermID::STRCHAR:
                    return true;
            }
            return false;
        }
        inline bool isString() const  {…}
 
        inline bool isNamed() const {
            switch (m_id) {
                case TermID::NAME:
                case TermID::TYPE:
                case TermID::ARGS:
                case TermID::ARGUMENT:
                case TermID::LOCAL:
                case TermID::STATIC:
                case TermID::MODULE:
                    return true;
            }
            return false;
        }
        inline bool isNamed() const  {…}
 
        inline bool isLiteral() const {
            switch (m_id) {
                case TermID::INTEGER:
                case TermID::NUMBER:
                case TermID::STRWIDE:
                case TermID::STRCHAR:
                case TermID::RATIONAL:
                case TermID::DICT:
                case TermID::TENSOR:
                case TermID::RANGE:
                case TermID::END:
                    return true;
            }
            return false;
        }
        inline bool isLiteral() const  {…}
 
        inline bool isCalculated() const {
            switch (m_id) {
                case TermID::ARGUMENT:
                case TermID::ARGS:
                case TermID::NAME:
                case TermID::CREATE_NEW:
                case TermID::ASSIGN:
                case TermID::CREATE_USE:
                case TermID::RANGE:
                case TermID::TENSOR:
                case TermID::DICT:
                case TermID::OP_LOGICAL:
                case TermID::OP_MATH:
                case TermID::EVAL:
                    return true;
                default:
                    return isLiteral() || isCall(); // || IsFunction() || IsVariable()
            }
        }
        inline bool isCalculated() const  {…}
 
        inline static bool isExportName(const TermPtr &term) {
            return term->m_is_call || !isLocalName(term->m_text);
        }
        inline static bool isExportName(const TermPtr &term) {…}
 
        inline bool isExport() const {
            return m_id == TermID::MACRO_DEL || (isCreate() && (isExportName(m_left) || m_left->m_id == TermID::MACRO_SEQ));
        }
        inline bool isExport() const  {…}
 
        inline bool isBlock() const {
            switch (m_id) {
                case TermID::SEQUENCE:
                case TermID::BLOCK:
                case TermID::BLOCK_TRY:
                case TermID::BLOCK_PLUS:
                case TermID::BLOCK_MINUS:
                    return true;
            }
            return false;
        }
        inline bool isBlock() const  {…}
 
        bool is_variable_args() {
            return size() && at(size() - 1).second && at(size() - 1).second->getTermID() == TermID::ELLIPSIS;
        }
        bool is_variable_args() {…}
 
        void dump_items_(std::string &str) const {
            bool first = true;
            for (auto elem : * this) {
                if (first) {
                    first = false;
                } else {
                    str.append(", ");
                }
                if (!elem.second->m_name_or_class.empty()) {
                    str.append(elem.second->m_name_or_class);
 
                    if (elem.second->GetType() && !isDefaultType(elem.second->GetType())) {
                        str += elem.second->GetType()->asTypeString();
                    }
 
                    str.append("=");
                }
                //                LOG_DEBUG("%s %s", newlang::toString(elem.second->getTermID()), elem.second->m_text.c_str());
                str.append(elem.second->toString(true));
            }
        }
        void dump_items_(std::string &str) const  {…}
 
        std::string toString(bool nested = false) {
            std::string result; //(m_ref ? m_ref->m_text : "");
            result += m_name_or_class;
            if (m_left) {
                if (!result.empty()) {
                    result += "=";
                }
                ASSERT(this != m_left.get());
                result += m_left->toString();
            }
 
            TermPtr temp;
            std::string str_text;
            bool test;
            switch (m_id) {
                case TermID::END:// name=<END>
                    result += "<END>";
                    return result;
 
                case TermID::SPACE:
                case TermID::INDENT:
                case TermID::COMMENT:
                case TermID::CRLF:
                case TermID::FIELD:
                    return m_text;
 
                case TermID::MACRO_STR:
                    result = "@@@";
                    result += m_text;
                    result += "@@@";
                    return result;
 
 
                case TermID::ARGS:
                case TermID::ARGUMENT:
                case TermID::ITERATOR:
                    result += m_text;
                    if (size()) {
                        result += "(";
                        dump_items_(result);
                        result += ")";
                    }
                    return result;
 
                case TermID::INT_PLUS:
                case TermID::INT_MINUS:
                    if (m_namespace) {
                        result = m_namespace->m_text;
                        result += " ";
                    }
                    result += m_text;
                    if (m_right) {
                        result += " ";
                        result += m_right->toString();
                    }
                    return result;
 
                case TermID::INDEX:
                    result = "";
                    if (size()) {
                        result += "[";
                        dump_items_(result);
                        result += "]";
                    }
                    return result;
 
 
                case TermID::NONE:
                case TermID::PARENT:
                case TermID::MODULE:
                case TermID::NEWLANG:
                case TermID::NATIVE:
                case TermID::MANGLED:
                case TermID::MACRO:
                case TermID::LOCAL:
                case TermID::STATIC:
                case TermID::WITH:
                case TermID::TAKE:
                case TermID::NAME: // name=(1,second="two",3,<EMPTY>,5)
                    //                result(m_is_ref ? "&" : "");
                    ASSERT(!(m_dims && m_dims->size()));
 
                    result = "";
                    temp = shared_from_this();
                    if (temp->m_left) {
                        result = temp->m_left->toString();
                    }
                    while (!nested && temp->m_right) {
                        if (this == temp->m_right.get()) {
                            ASSERT(this != temp->m_right.get());
                        }
                        if (temp->m_right->m_left) {
                            if (this == temp->m_right->m_left.get()) {
                                break;
                            }
                            ASSERT(this != temp->m_right->m_left.get());
                        }
                        result += temp->m_right->toString(true);
                        temp = temp->m_right;
                    }
 
                    if (!m_normalized.empty()) {
                        result.insert(0, m_normalized);
                    } else {
                        result.insert(0, m_text);
                        if (m_namespace) {
                            result.insert(0, m_namespace->m_text);
                        }
                    }
 
                    if (m_ref) {
                        result.insert(0, m_ref->m_text);
                    }
                    if (m_is_const) {
                        result += "^";
                    }
                    //                    if (!m_name.empty()) {
                    //                        if (GetType()) {
                    //                            result = m_name + GetType()->asTypeString() + "=" + result;
                    //                            //                        } else {
                    //                            //                            result = m_name + "=" + result;
                    //                        }
                    //                    }
                    //                    LOG_DEBUG("3 %s", result.c_str());
                    if (size()) {
                        result += "(";
                        dump_items_(result);
                        result += ")";
                    } else if (m_is_call) {
                        result += "()";
                    }
                    if (m_name_or_class.empty() && GetType() && !isDefaultType(GetType())) {
                        result += GetType()->asTypeString();
                    }
 
                    //                    if (!m_follow.empty()) {
                    //                        ASSERT(m_follow.size() == 1);
                    //                        result += ",[...]-->";
                    //                        result += m_follow[0]->toString();
                    //                    }
 
                    return result;
 
                case TermID::STRCHAR:// name:="string"
                case TermID::STRWIDE:// name:="string"
                    //                    if (!result.empty()) {
                    //                        result += "=";
                    //                    }
                    result = m_id == TermID::STRWIDE ? "\"" : "'";
                    result += m_text;
                    result += m_id == TermID::STRWIDE ? "\"" : "'";
                    if (size()) {
                        result += "(";
                        dump_items_(result);
                        result += ")";
                    }
                    return result;
 
                case TermID::EVAL:
                    //                    if (!result.empty()) {
                    //                        result += "=";
                    //                    }
                    result = "`";
                    result += m_text;
                    result += "`";
                    return result;
 
                case TermID::INTEGER:// name:=123
                case TermID::NUMBER: // name:=123.0
                    //                    test = result.empty();
                    //                    if (GetType() && !m_name.empty()) {
                    //                        result += GetType()->asTypeString();
                    //                    }
                    //                    if (!test) {
                    //                        result += "=";
                    //                    }
                    result = m_text;
                    if (GetType() && !isDefaultType(GetType()) && m_name_or_class.empty()) {
                        result += GetType()->asTypeString();
                    }
                    return result;
 
                case TermID::ASSIGN:
                case TermID::CREATE_NEW:
                case TermID::CREATE_USE:
                case TermID::PURE_NEW:
                case TermID::PURE_USE:
                    //            case TermID::APPEND:
                    if (m_id == TermID::ASSIGN) {
                        result += m_text;
                    } else {
                        result += " " + m_text + " ";
                    }
                    if (m_right) {
                        result += m_right->toString();
                    }
                    if (!nested) {
                        result += ";";
                    }
                    return result;
 
                case TermID::APPEND:
                    result = m_left->toString();
                    //                result += "[]";
                    if (!m_name_or_class.empty()) {
                        result += "." + m_name_or_class;
                    }
                    result += " " + m_text + " ";
                    result += m_right->toString();
                    if (!nested) {
                        result += ";";
                    }
                    return result;
 
                case TermID::RANGE:
                    ASSERT(size() == 2 || size() == 3);
                    result = at(0).second->toString();
                    result += "..";
                    result += at(1).second->toString();
                    if (size() == 3) {
                        result += "..";
                        result += at(2).second->toString();
                        //                    result += ")";
                    }
                    return result;
 
                case TermID::FUNCTION:
 
                    result += " " + m_text + " ";
                    //                    result.insert(0, m_namespace);
                    //                result += "{";
                    if (m_right && this != m_right.get()) {
                        result += m_right->toString(true);
                        if (!result.empty() && result[result.size() - 1] != ';') {
                            result += ";";
                        }
                        for (int i = 0; i < m_right->size(); i++) {
                            result += m_right->at(i).second->toString();
                        }
                    }
                    //                result += "};";
                    return result;
 
                case TermID::TENSOR:
                    result += "[";
                    dump_items_(result);
                    result += ",";
                    result += "]";
                    if (GetType() && !isDefaultType(GetType())) {
                        result += GetType()->asTypeString();
                    }
                    return result;
 
                case TermID::DICT:
                    result += "(";
                    dump_items_(result);
                    result += ",";
                    result += ")";
                    if (!m_name_or_class.empty()) {
                        result += m_name_or_class;
                    }
                    if (GetType() && !isDefaultType(GetType())) {
                        result += GetType()->asTypeString();
                    }
                    return result;
 
                case TermID::TYPEDUCK:
                case TermID::TYPECAST:
                case TermID::TYPE:
                    if (m_id == TermID::TYPEDUCK) {
                        result += ":~~";
                        result += m_text.substr(1);
                    } else if (m_id == TermID::TYPECAST) {
                        result += ":~";
                        result += m_text.substr(1);
                    } else {
                        result += ":";
                        if (m_ref) {
                            result += m_ref->m_text;
                        }
                        result += m_text.substr(1);
                    }
                    if (m_dims && m_dims->size()) {
                        result += "[";
                        for (int i = 0; i < m_dims->size(); i++) {
                            if (i) {
                                result += ",";
                            }
                            result += m_dims->at(i).second->toString();
                        }
                        result += "]";
                    }
 
 
                    if (m_is_call) {
                        result += "(";
                        dump_items_(result);
                        result += ")";
                    }
                    return result;
 
                case TermID::EMBED: // name:={% function code %}
                    result += "{%";
                    result += m_text;
                    result += "%}";
                    if (m_right) {
                        result += m_right->toString();
                    }
                    return result;
 
                case TermID::WHILE: // [cond] <->  repeat;
                    result = "[" + result + "]";
                    result += m_text;
                    ASSERT(m_right);
                    result += m_right->toString();
                    result += ";";
                    return result;
 
                case TermID::DOWHILE:
                    result += m_text + "[";
                    ASSERT(m_right);
                    result += m_right->toString();
                    result += "];";
                    return result;
 
                case TermID::FOLLOW: // (cond) -> seq;
 
                    //                    if (m_follow.empty()) {
                    //                        result.insert(0, "[");
                    //                        result += "]-->{";
                    //                        ASSERT(m_right);
                    //                        result += m_right->toString();
                    //                        result += "}";
                    //                        if (m_right->m_right) {
                    //                            result += "-->";
                    //                            result += m_right->m_right->toString();
                    //                        }
                    //                    } else {
                    result.clear();
                    for (size_t i = 0; i < m_block.size(); i++) {
                        if (!result.empty()) {
                            result += ",\n ";
                        }
                        if (m_block[i]->m_left) {
                            result += "[";
                            result += m_block[i]->m_left->toString();
                            result += "]";
                        } else {
                            result += " ";
                        }
                        ASSERT(m_block[i]->m_right);
                        //                            if (m_follow[i]->m_right) {
                        result += "-->";
                        result += m_block[i]->m_right->toString();
                        if (!(m_block[i]->isBlock() || m_block[i]->getTermID() == TermID::EMBED)) {
                            result += ";";
                        }
                        //                            result += "}";
                        //                            } else {
                        //                                if (nested || (!nested && m_follow[i]->m_left)) {
                        //                                    result += "-->";
                        //                                }
                        //                                result += m_follow[i]->toString(true);
                        //                                if (!(m_follow[i]->isBlock() || m_follow[i]->getTermID() == TermID::EMBED)) {
                        //                                    result += ";";
                        //                                }
                        //                                if (nested || (!nested && m_follow[i]->m_left)) {
                        //                                    //                                result += "}";
                        //                                }
                        //                            }
                    }
                    //                    if (!nested) {
                    //                        result += ";";
                    //                    }
                    //                    }
 
                    return result;
                case TermID::SEQUENCE:
                case TermID::BLOCK:
                case TermID::BLOCK_TRY:
                case TermID::BLOCK_PLUS:
                case TermID::BLOCK_MINUS:
                    result = "";
                    if (m_namespace && !m_namespace->m_text.empty() && m_namespace->m_text[0] != '$') {
                        result += m_namespace->m_text;
                        result += " ";
                    }
                    //                    if (m_id == TermID::CALL_BLOCK || m_id == TermID::CALL_TRY) {
                    //                        result += "(";
                    //                        dump_items_(result);
                    //                        result += ")";
                    //                    }
                    if (m_id == TermID::SEQUENCE) {
                    } else if (m_id == TermID::BLOCK) {
                        result += "{";
                    } else if (m_id == TermID::BLOCK_TRY) {
                        result += "{*";
                    } else if (m_id == TermID::BLOCK_PLUS) {
                        result += "{+";
                    } else if (m_id == TermID::BLOCK_MINUS) {
                        result += "{-";
                    } else {
                        LOG_ABORT("Unknown block type %s (%d)", newlang::toString(m_id), static_cast<uint8_t> (m_id));
                    }
 
                    if (!m_name_or_class.empty()) {
                        result.insert(0, " ");
                        result.insert(0, m_name_or_class);
                    }
 
                    for (size_t i = 0; i < m_block.size(); i++) {
                        if (i) {
                            result += " ";
                        }
                        result += m_block[i]->toString(true);
                        if (!result.empty() && result[result.size() - 1] != ';') {
                            result += ";";
                        }
                    }
 
                    if (m_id == TermID::SEQUENCE) {
                    } else if (m_id == TermID::BLOCK) {
                        result += "}";
                    } else if (m_id == TermID::BLOCK_TRY) {
                        result += "*}";
                    } else if (m_id == TermID::BLOCK_PLUS) {
                        result += "+}";
                    } else if (m_id == TermID::BLOCK_MINUS) {
                        result += "-}";
                    } else {
                        LOG_ABORT("Unknown block type %s (%d)", newlang::toString(m_id), (int) m_id);
                    }
 
                    result += m_name_or_class;
                    return result;
 
                case TermID::OP_MATH:
                case TermID::OP_BITWISE:
                case TermID::OP_COMPARE:
                case TermID::OP_LOGICAL:
                    result += " ";
                    result += m_text;
                    result += " ";
                    if (m_right) {
                        result += m_right->toString();
                    }
                    return result;
 
                case TermID::ELLIPSIS:
                    if (m_left) {
                        result = m_left->toString();
                        result += " ";
                    }
                    result += m_text;
                    if (m_right) {
                        result += m_right->toString();
                    }
                    return result;
 
                case TermID::FILLING:
                    result += "...";
                    if (m_right) {
                        result += m_right->toString();
                    }
                    result += "...";
                    return result;
 
                case TermID::MACRO_DEL:
                case TermID::MACRO_SEQ:
                    result = m_text;
                    result += " ";
 
                    for (size_t i = 0; i < m_macro_seq.size(); i++) {
                        if (i) {
                            result += " ";
                        }
                        if (m_macro_seq[i]->getTermID() == TermID::NAME) {
                            result += m_macro_seq[i]->toString();
                        } else {
                            result += m_macro_seq[i]->m_text;
                        }
                    }
                    result += " ";
                    result += m_text;
                    return result;
 
                case TermID::NAMESPACE:
                case TermID::SYMBOL:
                case TermID::UNKNOWN:
                case TermID::RATIONAL:
                case TermID::COMPLEX:
                case TermID::MACRO_ARGCOUNT:
                case TermID::MACRO_ARGUMENT:
                case TermID::MACRO_ARGNAME:
                case TermID::MACRO_ARGPOS:
                case TermID::MACRO_TOSTR:
                    return m_text;
 
                case TermID::ESCAPE:
                    result = "@\\";
                    result += m_text;
                    return result;
 
                case TermID::EMPTY:
                    return result + "=";
 
 
                case TermID::CLASS:
                    result.clear();
 
                    bool comma = false;
                {
                    TermPtr next = shared_from_this();
                    while (next) {
                        if (comma) {
                            result += ", ";
                        } else {
                            comma = true;
                        }
                        result += next->GetFullName();
                        result += "(";
                        next->dump_items_(result);
                        result += ")";
                        next = next->m_right;
                    }
                }
 
                    result += "{";
                    for (size_t i = 0; i < m_block.size(); i++) {
                        if (i) {
                            result += " ";
                        }
                        result += m_block[i]->toString(true);
                        //                        if (m_block[i]->getTermID() != TermID::EMBED) {
                        //                            result += ";";
                        //                        }
                    }
                    result += "}";
 
                    return result;
 
            }
            LOG_RUNTIME("Fail toString() type %s, text:'%s'", newlang::toString(m_id), m_text.c_str());
        }
        std::string toString(bool nested = false) {…}
 
        inline std::ostream & Print(std::ostream &out = std::cout, const char *delimiter = nullptr) {
            std::string str;
            out << toString();
            return out;
        }
        inline std::ostream & Print(std::ostream &out = std::cout, const char *delimiter = nullptr) {…}
 
        inline TermPtr Begin() {
            if (m_left) {
                return m_left->Begin();
            }
            return shared_from_this();
        }
        inline TermPtr Begin() {…}
 
        inline TermPtr End() {
            if (m_right) {
                return m_right->End();
            }
            return shared_from_this();
        }
        inline TermPtr End() {…}
 
        void SetSource(std::shared_ptr<std::string> source) {
            if (m_source == source) {
                return;
            }
            m_source = source;
            //            if (m_type && m_type.get() != this) {
            //                m_type->SetSource(source);
            //            }
            //            for (int i = 0; i < size(); i++) {
            //                at(i).second->SetSource(m_source);
            //            }
            //            for (auto &elem : m_block) {
            //                if (elem.get() != this) {
            //                    elem->SetSource(m_source);
            //                }
            //            }
            //
            //            TermPtr next = shared_from_this()->m_right;
            //            while (next && !m_source) {
            //                next->SetSource(m_source);
            //                next = next->m_right;
            //            }
            //            next = shared_from_this()->m_left;
            //            while (next && !m_source) {
            //
            //                next->SetSource(m_source);
            //                next = next->m_left;
            //            }
        }
        void SetSource(std::shared_ptr<std::string> source) {…}
 
        inline void AppendLeft(TermPtr item) {
            if (!item->m_source) {
                item->m_source = m_source;
            }
            TermPtr next = shared_from_this();
            while (next->m_left) {
                ASSERT(next != next->m_left);
                next = next->m_left;
            }
            ASSERT(next != item);
            next->m_left = item;
        }
        inline void AppendLeft(TermPtr item) {…}
 
        inline void AppendRight(TermPtr item) {
            if (!item->m_source) {
                item->m_source = m_source;
            }
            TermPtr next = shared_from_this();
            if (next == item) {
                //            ASSERT(next != item);
            }
            while (next->m_right) {
                ASSERT(next != next->m_right);
                next = next->m_right;
            }
            next->m_right = item;
        }
        inline void AppendRight(TermPtr item) {…}
 
        inline void AppendText(const std::string & s) {
            m_text.append(s);
        }
        inline void AppendText(const std::string & s) {…}
 
        inline void AppendText(TermPtr txt) {
            m_text.append(txt->getText());
        }
        inline void AppendText(TermPtr txt) {…}
 
        void RightToBlock(std::vector<TermPtr> &vect, bool remove = true) {
            TermPtr next = shared_from_this();
            TermPtr prev;
 
            vect.clear();
            while (next) {
                if (next->getTermID() != TermID::END) {
                    vect.push_back(next);
                }
                prev = next;
                next = next->m_right;
                if (remove) {
                    prev->m_right.reset();
                }
            }
        }
        void RightToBlock(std::vector<TermPtr> &vect, bool remove = true) {…}
 
        inline void SetArgs(TermPtr args) {
            m_is_call = true;
            for (auto &elem : args->m_block) {
                if (isSystemName(elem->getName())) {
                    if (!m_sys_prop) {
                        m_sys_prop = Term::Create(TermID::DICT, "");
                    }
                    m_sys_prop->push_back(elem, elem->getName());
                } else {
                    if (m_sys_prop) {
                        NL_PARSER(elem, "Cannot pass arguments after any system attributes!");
                    }
                    push_back(elem, elem->getName());
                }
            }
            args->m_block.clear();
        }
        inline void SetArgs(TermPtr args) {…}
 
        TermPtr AppendBlock(TermPtr &item, TermID id, bool force = false) {
 
            if (force) {
                ASSERT(isBlock() && m_block.empty() && m_id == id);
                m_block.push_back(item);
                return shared_from_this();
            }
 
            TermPtr result;
            if (m_id == id || m_id == TermID::SEQUENCE) {
                if (m_id != id) {
                    m_id = id;
                }
                result = shared_from_this();
                if (item->isBlock()) {
                    if (this != item.get()) {
                        result->m_block.insert(result->m_block.end(), item->m_block.begin(), item->m_block.end());
                    } else {
                        //                        result = Term::Create(id, "", parser::token_type::END, 0, &item->m_lexer_loc);
                        //                        result->m_block.push_back(shared_from_this());
                    }
                } else {
                    result->m_block.push_back(item);
                }
            } else {
                ASSERT(!isBlock());
                result = Term::Create(id, "", parser::token_type::END, 0, &item->m_lexer_loc);
                result->m_block.push_back(shared_from_this());
                if (this != item.get()) {
                    result->m_block.push_back(item);
                }
                if (item->m_id == TermID::SEQUENCE) {
                    item->m_id = id;
                }
            }
            return result;
        }
        TermPtr AppendBlock(TermPtr &item, TermID id, bool force = false) {…}
 
        void clear_() override {
            Clear(true);
        }
        void clear_() override  {…}
 
        void Clear(bool clear_iterator_name) {
            if (m_left && m_right) {
                m_left->m_right = m_right;
                m_right->m_left = m_left;
                m_left.reset();
                m_right.reset();
            } else if (m_left) {
                m_left->m_right.reset();
                m_left.reset();
            } else if (m_right) {
 
                m_right->m_left.reset();
                m_right.reset();
            }
            m_id = TermID::END;
            m_text.clear();
            m_line = 0;
            m_col = 0;
 
            m_name_or_class.clear();
            m_text.clear();
            m_block.clear();
            m_block.clear();
            m_source.reset();
            m_docs.clear();
            m_macro_id.clear();
            m_macro_seq.clear();
            m_namespace.reset();
        }
        void Clear(bool clear_iterator_name) {…}
 
        inline TermPtr First() {
            if (m_left) {
 
                return m_left->First();
            }
            return shared_from_this();
        }
        inline TermPtr First() {…}
 
        inline TermPtr Last() {
            if (m_right) {
                return m_right->Last();
            }
            return shared_from_this();
        }
        inline TermPtr Last() {…}
 
        void MakeRef(TermPtr ref) {
            if (!(m_id == TermID::NAME || m_id == TermID::TYPE || m_id == TermID::STATIC || m_id == TermID::MACRO) || m_left || m_right) {
                LOG_RUNTIME("Cannon make referens value for %s!", toString().c_str());
            }
            m_ref = ref;
        }
        void MakeRef(TermPtr ref) {…}
 
        std::string asTypeString() const {
            std::string result = m_text;
            if (m_ref) {
                result.insert(1, m_ref->m_text);
            }
            if (size()) {
                result += "(";
                dump_items_(result);
                result += ")";
            }
            if (m_dims && m_dims->size()) {
                result += "[";
                bool first = true;
                for (size_t i = 0; i < m_dims->size(); i++) {
                    if (!first) {
                        result += ",";
                    }
                    result += m_dims->at(i).second->toString(true);
                    first = false;
                }
                result += "]";
            }
            return result;
        }
        std::string asTypeString() const  {…}
 
        void SetType(TermPtr type);
 
        inline TermPtr GetType() {
            return m_type;
        }
        inline TermPtr GetType() {…}
 
        inline bool TestConst() {
            if (isConstName(m_text)) {
                m_is_const = true;
                if (!isReservedName(m_text)) {
                    m_text.resize(m_text.size() - 1);
                }
            }
            return m_is_const;
        }
        inline bool TestConst() {…}
 
        static bool CheckTermEq(const TermPtr &term, const TermPtr &proto, bool type = false, RuntimePtr rt = nullptr);
 
        TermID m_id; 
        SourceType m_source; 
        int m_line; 
        int m_col; 
 
        TermPtr m_left; 
        TermPtr m_right; 
 
        BlockType m_block; 
        TermPtr m_type; 
 
        std::string m_text; 
        std::string m_name_or_class; 
        TermPtr m_namespace; 
        TermPtr m_dims; 
        BlockType m_docs; 
 
        size_t m_level; 
        bool m_is_owner; 
        bool m_is_take; 
        bool m_is_const; 
        bool m_is_call; 
        TermPtr m_ref; 
 
        BlockType m_attr; 
        //        bool m_is_reference;
 
        TermPtr m_sys_prop; 
 
        InternalName m_normalized; 
 
    public:
        int m_bracket_depth; 
        parser::token_type m_lexer_type; 
        parser::location_type m_lexer_loc; 
        BlockType m_macro_id; 
        BlockType m_macro_seq; 
 
        SCOPE(private) :
    };
    class Term : public Dict<Term>, public std::enable_shared_from_this<Term> {…};
 
    std::ostream & operator<<(std::ostream &out, newlang::TermPtr & var);
    std::ostream & operator<<(std::ostream &out, newlang::TermPtr var);
 
    class ScopePush {
    public:
        NameLookupStack &m_scope;
 
        ScopePush(NameLookupStack &scope, TermPtr ns, bool is_function = false) : m_scope(scope) {
            m_scope.PushScope(ns, is_function);
        }
        ScopePush(NameLookupStack &scope, TermPtr ns, bool is_function = false) : m_scope(scope) {…}
 
        ~ScopePush() {
            //            m_scope.RollbackNames_();
            m_scope.PopScope();
        }
        ~ScopePush() {…}
    };
    class ScopePush {…};
 
}
#endif // INCLUDED_NEWLANG_TERM_