term.cpp

Go to the documentation of this file.

#include "term.h"
#include "runtime.h"
 
using namespace newlang;
 
size_t newlang::IndexArg(TermPtr term) {
    ASSERT(term);
    ASSERT(term->m_id == TermID::ARGUMENT);
    ASSERT(!term->m_text.empty());
    char * pEnd = nullptr;
    size_t index = std::strtoul(term->getText().data() + 1, &pEnd, 10);
    if (term->m_text.data() + term->getText().size() != pEnd) {
        LOG_RUNTIME("Float error '%s' or out of range!", term->getText().c_str());
    }
    return index;
}
 
/*
 * 
 * 
 */
 
TermPtr Term::CreateNone() {
    TermPtr result = Term::Create(TermID::NONE, "_");
    return result;
}
 
TermPtr Term::CreateNil() {
    TermPtr result = Term::Create(TermID::NONE, "_");
    return result;
}
 
TermPtr Term::CreateDict() {
    TermPtr result = Term::Create(TermID::DICT, "");
    return result;
}
 
TermPtr Term::CreateIntName(const std::string_view name, std::string_view int_name, TermID id) {
    TermPtr result = Term::Create(id, name.begin(), parser::token_type::NAME);
    result->m_normalized = int_name;
    return result;
}
 
TermPtr Term::CreateName(std::string name, TermID id) {
    TermPtr result = Term::Create(id, name.c_str(), parser::token_type::NAME);
    return result;
}
 
void Term::SetType(TermPtr type) {
    if (type) {
 
        //        if (type->m_list) {
        //            m_id = TermID::BLOCK;
        //            ListToVector(type, m_block);
        //        }
        //
        //        ASSERT(!type->m_list);
        //                ASSERT(type->m_type_allowed.empty());
        //                ASSERT(m_type_allowed.empty());
        //                m_type_allowed.push_back(type);
        m_type = type;
        //                m_type_name = m_type->asTypeString();
        // Check type
        if (m_id == TermID::INTEGER) {
            ObjType type_val = typeFromLimit(parseInteger(m_text.c_str()), ObjType::Bool);
            if (!canCastLimit(type_val, typeFromString(m_type, nullptr))) {
                NL_PARSER(type, "Error cast '%s' to integer type '%s'", m_text.c_str(), m_type->m_text.c_str());
            }
        } else if (m_id == TermID::NUMBER) {
            ObjType type_val = typeFromLimit(parseDouble(m_text.c_str()), ObjType::Float64);
            if (!canCastLimit(type_val, typeFromString(m_type, nullptr))) {
                NL_PARSER(type, "Error cast '%s' to numeric type '%s'", m_text.c_str(), m_type->m_text.c_str());
            }
        } else if (m_id == TermID::COMPLEX) {
            //            ObjType type_val = typeFromLimit(parseComplex(m_text.c_str()), ObjType::Complex64);
            //            if (!canCastLimit(type_val, typeFromString(m_type, nullptr))) {
            NL_PARSER(type, "Error cast '%s' to complex type '%s'", m_text.c_str(), m_type->m_text.c_str());
            //            }
        }
    } else if (!m_type) {
 
        // Default type
        if (m_id == TermID::INTEGER) {
            m_type = getDefaultType(typeFromLimit(parseInteger(m_text.c_str()), ObjType::Bool));
        } else if (m_id == TermID::NUMBER) {
            m_type = getDefaultType(typeFromLimit(parseDouble(m_text.c_str()), ObjType::Float64));
        } else if (m_id == TermID::COMPLEX) {
            NL_PARSER(type, "Error cast '%s' to complex type '%s'", m_text.c_str(), m_type->m_text.c_str());
            //            m_type = getDefaultType(typeFromLimit(parseComplex(m_text.c_str()), ObjType::Complex64));
        } else if (m_id == TermID::STRCHAR) {
            m_type = getDefaultType(ObjType::StrChar);
        } else if (m_id == TermID::STRWIDE) {
            m_type = getDefaultType(ObjType::StrWide);
        } else if (m_id == TermID::DICT) {
            m_type = getDefaultType(ObjType::Dictionary);
        } else if (m_id == TermID::RATIONAL) {
            m_type = getDefaultType(ObjType::Rational);
        } else if (m_id == TermID::RANGE) {
            m_type = getDefaultType(ObjType::Range);
        } else if (m_id == TermID::ITERATOR) {
            m_type = getDefaultType(ObjType::Iterator);
            //                } else if (m_id == TermID::INT_MINUS || m_id == TermID::INT_PLUS || m_id == TermID::INT_REPEAT) {
            //                    m_type = getDefaultType(ObjType::Interruption);
        }
    }
}
 
/*
 * 
 * 
 */
bool Term::CheckTermEq(const TermPtr &term1, const TermPtr &term2, bool type, RuntimePtr rt) {
    if (term1 == nullptr && term2 == nullptr) {
        return true;
    }
    if (!!term1 != !!term2) {
        if (type) {
            return true;
        }
        return false;
    }
    if (term1->m_text.compare(term2->m_text) != 0) {
        return false;
    }
    if (term1->isCall() != term2->isCall()) {
        return false;
    }
    if (!!term1->m_dims != !!term2->m_dims) {
        return false;
    }
    if (term1->m_dims && term2->m_dims && term1->m_dims->size() != term2->m_dims->size()) {
        return false;
    }
    for (int i = 0; term1->m_dims && i < term1->m_dims->size(); i++) {
        if (!CheckTermEq(term1->m_dims->at(i).second, term2->m_dims->at(i).second, false, rt)) {
            return false;
        }
    }
    if (term1->size() != term2->size()) {
        return false;
    }
    for (int i = 0; i < term1->size(); i++) {
        if (term1->at(i).first.compare(term2->at(i).first) != 0) {
            return false;
        }
        if (!CheckTermEq(term1->at(i).second, term2->at(i).second, false, rt)) {
            return false;
        }
    }
    return CheckTermEq(term1->m_type, term2->m_type, true, rt);
}
 
/*
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 */
 
NameLookupStack::NameLookupStack(GlobalObjects &glob, StorageTerm::ModuleMapType & modules) :
m_glob(glob), m_modules(modules), m_block_num(1) {
    clear();
}
 
void NameLookupStack::clear() {
    std::deque< ScopeVars >::clear();
    // First level for local_thread objects
    //    reserve(200);
    push_back({Term::Create(TermID::NAME, ""),
        {}, false,
        {}}
    );
    m_modules.clear();
    m_modules["\\\\"] = {};
}
 
void NameLookupStack::PushScope(TermPtr ns, bool is_function) {
 
    ScopeVars block;
    if (ns) {
        block.scope_name = ns;
        if (ns->m_text.rfind("::") != ns->m_text.size() - 2) {
            ns->m_text += "::";
        }
    } else {
        // An unnamed block has a unique numeric identifier (whereas in code the identifier cannot begin with a number)
        block.scope_name = Term::CreateName(std::to_string(m_block_num));
        block.scope_name->m_text += "::";
        m_block_num++;
    }
 
    block.function_name = is_function;
    push_back(block);
}
 
void NameLookupStack::SetLookupNamespace(TermPtr ns) {
    std::vector<std::string> list;
 
    TermPtr next = ns;
    bool is_clear = false;
    while (next) {
        list.push_back(next->m_text);
        if (next->m_text.compare("_") == 0) {
            is_clear = true;
            list.clear();
        } else {
            if (list.back().size() < 2 || !(list.back()[list.back().size() - 1] == ':' && list.back()[list.back().size() - 2] == ':')) {
                list.back() += "::";
            }
        }
        next = next->m_right;
    }
    if (is_clear && list.size() > 1) {
        NL_MESSAGE(LOG_LEVEL_INFO, ns, "Using the clear search symbol with a mamespace list!");
    }
    rbegin()->ns_lookup = list;
}
 
void NameLookupStack::ExpandNamespace(std::string & name) {
    size_t pos = name.find("@::");
    if (pos != std::string::npos) {
        name = name.replace(pos, 3, GetNamespace());
    }
    pos = name.find("$::");
    if (pos != std::string::npos) {
        name = name.replace(pos, 3, GetFuntionName());
    }
}
 
bool NameLookupStack::CheckInterrupt(std::string_view name) {
    std::string ns(name);
 
    if (!(ns.size() > 1 && ns[ns.size() - 1] == ':' && ns[ns.size() - 2] == ':')) {
        ns += "::";
    }
    auto iter = rbegin();
    while (iter != rend()) {
        if (iter->scope_name && iter->scope_name->m_namespace && iter->scope_name->m_namespace->m_text.compare(ns.c_str()) == 0) {
            return iter == rbegin();
        }
        iter++;
    }
    LOG_RUNTIME("Named block '%s' not found!", name.begin());
}
 
std::string NameLookupStack::MakeNamespace(int skip, bool is_global) {
    std::string result;
    auto iter = rbegin();
    if (skip > 0) {
        iter += skip;
    }
    int count = 0;
    while (iter != rend()) {
        if (result.find("::") == 0) {
            break;
        }
        if (skip < 0 && count == -skip) {
            break;
        }
        if (!is_global && iter == rbegin() && isdigit(iter->scope_name->m_text[0])) {
            // последний не именованный (цифровой) блок включается в имя только для локльных имен
            result.insert(0, iter->scope_name->m_text); // The namespace is always padded with ::
        } else if (!isdigit(iter->scope_name->m_text[0])) {
            // для глобальных имен не именованный (цифровой) блок в имя не включается
            result.insert(0, iter->scope_name->m_text); // The namespace is always padded with ::
        }
        iter++;
        count++;
    }
    return result;
}
 
std::string NameLookupStack::GetFuntionName() {
    auto iter = rbegin();
    while (iter != rend()) {
        if (iter->function_name) {
            ASSERT(iter->scope_name);
            return iter->scope_name->m_text;
        }
        iter++;
    }
    LOG_RUNTIME("Function name not found!");
}
 
std::string NameLookupStack::GetNamespace() {
    std::string result;
    auto iter = rbegin();
    while (iter != rend()) {
        if (result.find("::") == 0) {
            break;
        }
        ASSERT(iter->scope_name);
        // An unnamed block of code has a numeric name, 
        // and identifiers with a number at the beginning 
        //  of the name are prohibited by the language syntax.
        if (!isdigit(iter->scope_name->m_text[0])) {
            // The namespace is always padded with ::
            result.insert(0, iter->scope_name->m_text);
        }
        iter++;
    }
    return result;
}
 
std::string NameLookupStack::MakeInternalName(const TermPtr & term, bool is_static) {
    ASSERT(term);
    std::string name(term->m_text);
    if (term->m_namespace) {
        name.insert(0, term->m_namespace->m_text);
    }
    return MakeInternalName(name, is_static);
}
 
std::string NameLookupStack::MakeInternalName(const std::string_view name, bool is_static) {
 
    /*
     * ::var ::= 0;         # ::var:: static global 
     * var ::= 0;           # var:: static module (соханяется в stack[0])
     * $var := 0;           # var$ thread_local (соханяется в stack[0] <автоматически>)
     * 
     * @::var ::= 0;        # var::
     * :: :type := :Type;   # ::type::: type (static) global
     * :: :cls := Class(){};  # ::cls::: class (static) global
     * 
     * :type := :Type;      # type:::  type (static) module
     * :cls := Class(){};   # cls:::  class (static) module
     * @:: :type := :Type;     # type:::
     * @:: :cls := Class(){};  # cls:::
     * 
     * ns {
     *     $var := 0;       # var$  local
     *     var := 0;        # var$  local
     *     ::var := 0;      # ::var::  static (global)  (соханяется в stack[0])
     *     @::var ::= 0;    # ns::var:: static (module) (соханяется в stack[0])
     * 
     *     :type := :Type;     # ns::type:::    (соханяется в stack[0])
     *     :cls := Class(){};  # ns::cls:::     (соханяется в stack[0])
     * 
     *     @::func1() ::= {};   # ns::func1::   (соханяется в stack[0])
     *     func2() ::= {};      # ns::func2:: type (static) module  (соханяется в stack[0])
     *     $func3() ::= {};     # ns::func3$  вместо  ns::func3::   (соханяется в stack[0])
     * 
     * 
     * Деление объектов по времени жизни:
     * Постоянные (статические) vs Локальные (временные/на стеке/контролируемые)
     * Постоянные - значение объекта сохраняется между вызовами и один объект разделяется для всех всех потоков сразу.
     * Локальные - значение объекта уничтожается при завершении области видимости и в каждом потоке создается свой экзепляр.
     * Функции не могут быть локальными объектами и не могут быть переопределены, но могут быть перекрыты другой функцией.
     * 
     * Области видимости объектов по мере расширения:
     * локальная (текущий блок кода), область имен (объект класса), текущий модуль, пакет (несколько модулей), глобальная.
     * 
     * Если при создании объекта квалификатор (сигил) объекта не указан, т.е. при создании объекта указано простое имя, 
     * то время жизни объекта определяется типом создаваемого объекта.
     * При создании функции создается статический объект, т.е. func() ::= ... равнозначно определению  @::func() ::= ...
     * Перемененная создается локальной, т.е. var равнозначно определению  $var, если признак статического объекта не указан явно.
     * 
     * 
     * 
     * Фиксированный vs Динамический (размер по запросу)
     * 
     * Отличие от статических переменных С++
     * Момент выделения памяти зависит от реализации и может быть как во время компиляции (как в С++), 
     * так по запросу (при первом обращении при загрузке модуля).
     * Инициалиазция начальным значением, только в момент выполнения кода иницаилиазции (при загрузке модуля),
     * а не при старте приложения как в С++.
     */
 
    /*
     * Независимо от типа объекта, должна быть возможность создавать уникальные идентификаторы * как для глобальных, так и для локальных имен.
     * Алгоритм генерации уникального имени заключается в создании
     */
 
    ASSERT(!name.empty());
 
    std::string result(name);
    if (isTrivialName(name)) {
        if (is_static) {
            // Function or top scope - static for module/package
            result += "::";
            result.insert(0, GetNamespace());
        } else {
            // local name
            result += "$";
        }
    } else {
 
        size_t pos = result.find("@::");
        if (pos != std::string::npos) {
            result = result.replace(pos, 3, GetNamespace());
        } else if ((pos = result.find("$::")) != std::string::npos) {
            result = result.replace(pos, 3, GetFuntionName());
        }
 
        pos = result.find(":::");
        if (pos != std::string::npos) {
            // Global type
            std::rotate(std::begin(result) + pos, std::begin(result) + pos + 1, std::end(result));
        }
 
        if (isStaticName(result)) {
            // Full name
            result += "::";
        } else if (result[0] == ':') {
            // type or class
            std::rotate(std::begin(result), std::begin(result) + 1, std::end(result));
            result += "::";
            result.insert(0, GetNamespace());
        } else {
            if (result[0] != '$') {
                ASSERT(result[0] == '$'); // Local name
            }
            std::rotate(std::begin(result), std::begin(result) + 1, std::end(result));
            if (is_static) {
                result.insert(0, GetNamespace());
            }
        }
    }
    return result;
}
 
bool NameLookupStack::AddName(const TermPtr var, const char * alt_name) {
 
    ASSERT(var);
 
    std::string_view name;
    if (alt_name) {
        name = alt_name;
    } else {
        name = var->m_normalized;
    }
    if (name.empty()) {
        LOG_RUNTIME("Internal name of '%s' not exist!", var->toString().c_str());
    }
 
    auto found = m_modules[StorageTerm::MODULE_MAIN].find(name.begin());
    if (found != m_modules[StorageTerm::MODULE_MAIN].end()) {
        if (!Term::CheckTermEq(found->second, var)) {
            NL_MESSAGE(LOG_LEVEL_INFO, var, "Object '%s' does not match its pre-declaration as '%s'!",
                    name.begin(), found->second->toString().c_str());
        }
        return false;
    }
 
    if (isGlobalScope(name)) {
        var->m_level = 0;
    } else {
        var->m_level = size();
    }
 
    ASSERT(!empty());
 
    std::map<std::string, TermPtr> * map_level = &back().vars;
    if (isStaticName(name)) {
        map_level = &m_modules[StorageTerm::MODULE_MAIN];
    }
 
    if (map_level->find(name.begin()) != map_level->end()) {
        NL_MESSAGE(LOG_LEVEL_INFO, var, "Var '%s' already exist!", name.begin());
        return false;
    }
 
    map_level->insert({name.begin(), var});
 
    if (isGlobalScope(name)) {
        m_glob.RegisterObject(false, name, var, std::monostate{}); //VarData<std::monostate{}, const TermPtr > (std::monostate(), nullptr)
    }
    return true;
}
 
TermPtr NameLookupStack::FindInternalName(std::string_view int_name) {
 
    auto iter = rbegin();
    while (iter != rend()) {
        if (iter->vars.find(int_name.begin()) != iter->vars.end()) {
            return iter->vars.find(int_name.begin())->second;
        }
        iter++;
    }
 
    auto found = m_modules[StorageTerm::MODULE_MAIN].find(int_name.begin());
    if (found != m_modules[StorageTerm::MODULE_MAIN].end()) {
        return found->second;
    }
 
    VariablePair * glob = m_glob.FindObject(int_name);
    return glob ? glob->term : nullptr;
}
 
TermPtr NameLookupStack::LookupNameVars(const std::string_view name) {
    TermPtr found;
 
    if ((found = FindInternalName(name.begin()))) {
        return found;
    }
 
    std::string name_search;
    name_search = name.begin();
    name_search += "$";
    if ((found = FindInternalName(name_search))) {
        return found;
    }
 
    name_search = name.begin();
    name_search += "::";
    if ((found = FindInternalName(name_search))) {
        return found;
    }
 
    auto found2 = m_modules[StorageTerm::MODULE_MAIN].find(name_search);
    if (found2 != m_modules[StorageTerm::MODULE_MAIN].end()) {
        return found2->second;
    }
 
    name_search += ":";
    if ((found = FindInternalName(name_search))) {
        return found;
    }
    return nullptr;
}
 
TermPtr NameLookupStack::LookupNameNamespace(const std::string_view ns, const std::string_view name) {
    TermPtr found;
 
    if ((found = LookupNameVars(name))) {
        return found;
    }
 
    std::string name_search(ns.begin());
    name_search += name;
    if ((found = LookupNameVars(name_search))) {
        return found;
    }
    return nullptr;
}
 
TermPtr NameLookupStack::LookupName(std::string name) {
 
    if (isInternalName(name)) {
        return FindInternalName(name);
    }
 
    TermPtr found;
    bool full_search = isTrivialName(name);
    if (!full_search) {
        name = NormalizeName(name);
    }
    std::string temp;
    for (size_t skip = 0; skip < size(); skip++) {
 
        if ((found = LookupNameVars(name))) {
            return found;
        }
 
        if ((found = LookupNameNamespace(MakeNamespace(skip, false), name))) {
            return found;
        }
 
        for (auto &elem : at(size() - skip - 1).ns_lookup) {
            if ((found = LookupNameNamespace(elem, name))) {
                return found;
            }
        }
 
        //
        //        // Check local name
        //        temp = name;
        //        if (full_search) {
        //            temp += "$";
        //        }
        //        temp.insert(0, MakeNamespace(skip, false));
        //        if ((found = FindInternalName(temp))) {
        //            return found;
        //        }
        //        if (full_search) {
        //
        //            // Check static name local object
        //            temp = name;
        //            temp += "::";
        //            temp.insert(0, MakeNamespace(skip, false));
        //            if ((found = FindInternalName(temp))) {
        //                return found;
        //            }
        //        }
        //
        //        // Check static name
        //        temp = name;
        //        if (full_search) {
        //            temp += "::";
        //        }
        //        temp.insert(0, MakeNamespace(skip, true));
        //        if ((found = FindInternalName(temp))) {
        //            return found;
        //        }
        //
        //
        //        if (full_search) {
        //            // Check type name
        //            temp = name;
        //            temp += ":";
        //            temp.insert(0, MakeNamespace(skip, true));
        //            if ((found = FindInternalName(temp))) {
        //                return found;
        //            }
        //        }
        //
        //        //        if (isGlobalScope(temp)) {
        //        //            break;
        //        //        }
    }
 
    temp = name;
    if (full_search) {
        temp += "$";
        if ((found = FindInternalName(temp))) {
            return found;
        }
        temp = name;
        temp += "::";
        if ((found = FindInternalName(temp))) {
            return found;
        }
        temp = name;
        temp += ":";
        if ((found = FindInternalName(temp))) {
            return found;
        }
 
        temp = name;
        temp += "::";
        temp.insert(0, "::");
        if ((found = FindInternalName(temp))) {
            return found;
        }
        temp += ":";
        if ((found = FindInternalName(temp))) {
            return found;
        }
    }
    return FindInternalName(temp);
}
 
bool NameLookupStack::LookupBlock_(TermPtr & ns) {
    //    ASSERT(term->isInterrupt());
    if (ns->m_text.empty()) {
        NL_MESSAGE(LOG_LEVEL_INFO, ns, "Lookup block empty!");
        return false;
    }
    ExpandNamespace(ns->m_text);
    if (ns->m_text.compare("::") == 0) {
        return true;
    }
 
    auto iter = rbegin();
    while (iter != rend()) {
        ASSERT(iter->scope_name);
        if (iter->scope_name->m_text.compare(ns->m_text) == 0) {
            return true;
        }
        iter++;
    }
    NL_MESSAGE(LOG_LEVEL_INFO, ns, "Lookup block '%s' fail!%s", ns->m_text.c_str(), Dump().c_str());
    return false;
}
 
std::string NameLookupStack::GetOfferBlock() {
    if (empty()) {
        return "";
    }
    std::string result = " Possible block identifiers: '";
 
    std::string list_block;
    for (auto &elem : * this) {
        if (elem.scope_name) {
            if (!list_block.empty()) {
                list_block += ", ";
            }
            list_block += elem.scope_name->m_text;
        }
    }
    result += list_block;
    result += "'";
 
    return result;
}
 
std::string NameLookupStack::Dump() {
    std::string result;
#ifdef BUILD_UNITTEST
    auto iter = begin();
    while (iter != end()) {
        result += "Stack [";
        if (iter->scope_name) {
            result += iter->scope_name->m_text;
        }
        result += "]: ";
 
        std::string list;
        auto iter_list = iter->vars.begin();
        while (iter_list != iter->vars.end()) {
 
            if (!list.empty()) {
                list += ", ";
            }
 
            list += iter_list->first;
            iter_list++;
        }
 
        //        result += "(";
        result += list;
        result += "\n";
        iter++;
    }
#endif
    return result;
}
 
/*
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 *  
 */
 
bool StorageTerm::RegisterName(TermPtr term, const std::string_view syn) {
    InternalName name;
    if (syn.empty()) {
        name = term->m_normalized;
    } else {
        name = syn.begin();
    }
    ASSERT(!name.empty());
    if (find(name) != end()) {
 
        return false;
    }
    insert({name, term});
    return true;
}
 
StorageTerm::StorageTerm(const StorageTerm & clone) : std::map<std::string, TermPtr>(clone) {
    for (auto &elem : * this) {
 
        elem.second = elem.second->Clone();
    }
}
 
ObjPtr Obj::GetIndex(ObjPtr obj, TermPtr index_arg) {
    ASSERT(index_arg->size() == 1);
    TermPtr index = index_arg->at(0).second;
    ASSERT(index);
    if (index->getTermID() != TermID::INTEGER) {
        LOG_RUNTIME("Fail index type %s '%s'", newlang::toString(index->getTermID()), index->toString().c_str());
    }
    return GetIndex(obj, std::stoi(index->m_text.c_str()));
}