[Tolk] Initial commit of TOLK Language: fork all sources from FunC

The Tolk Language will be positioned as "next-generation FunC".
It's literally a fork of a FunC compiler,
introducing familiar syntax similar to TypeScript,
but leaving all low-level optimizations untouched.

Note, that FunC sources are partially stored
in the parser/ folder (shared with TL/B).
In Tolk, nothing is shared.
Everything from parser/ is copied into tolk/ folder.

tolk/symtable.h

@@ -0,0 +1,175 @@
+/*
+    This file is part of TON Blockchain Library.
+
+    TON Blockchain Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    TON Blockchain Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+#include "srcread.h"
+#include "lexer.h"
+#include <vector>
+
+namespace tolk {
+
+/*
+ *
+ *   SYMBOL VALUES (DECLARED)
+ *
+ */
+
+typedef int var_idx_t;
+
+struct SymValBase {
+  enum { _Param, _Var, _Func, _Typename, _GlobVar, _Const };
+  int type;
+  int idx;
+  SymValBase(int _type, int _idx) : type(_type), idx(_idx) {
+  }
+  virtual ~SymValBase() = default;
+};
+
+/*
+ *
+ *   SYMBOL TABLE
+ *
+ */
+
+// defined outside this module (by the end user)
+int compute_symbol_subclass(std::string str);  // return 0 if unneeded
+
+typedef int sym_idx_t;
+
+struct Symbol {
+  std::string str;
+  sym_idx_t idx;
+  int subclass;
+  Symbol(std::string _str, sym_idx_t _idx, int _sc) : str(_str), idx(_idx), subclass(_sc) {
+  }
+  Symbol(std::string _str, sym_idx_t _idx) : str(_str), idx(_idx) {
+    subclass = compute_symbol_subclass(std::move(_str));
+  }
+  static std::string unknown_symbol_name(sym_idx_t i);
+};
+
+class SymTableBase {
+  unsigned p;
+  std::unique_ptr<Symbol>* sym_table;
+  sym_idx_t def_kw, def_sym;
+  static constexpr int max_kw_idx = 10000;
+  sym_idx_t keywords[max_kw_idx];
+
+ public:
+  SymTableBase(unsigned p_, std::unique_ptr<Symbol>* sym_table_)
+      : p(p_), sym_table(sym_table_), def_kw(0x100), def_sym(0) {
+    std::memset(keywords, 0, sizeof(keywords));
+  }
+  static constexpr sym_idx_t not_found = 0;
+  SymTableBase& add_keyword(std::string str, sym_idx_t idx = 0);
+  SymTableBase& add_kw_char(char c) {
+    return add_keyword(std::string{c}, c);
+  }
+  sym_idx_t lookup(std::string str, int mode = 0) {
+    return gen_lookup(str, mode);
+  }
+  sym_idx_t lookup_add(std::string str) {
+    return gen_lookup(str, 1);
+  }
+  Symbol* operator[](sym_idx_t i) const {
+    return sym_table[i].get();
+  }
+  bool is_keyword(sym_idx_t i) const {
+    return sym_table[i] && sym_table[i]->idx < 0;
+  }
+  std::string get_name(sym_idx_t i) const {
+    return sym_table[i] ? sym_table[i]->str : Symbol::unknown_symbol_name(i);
+  }
+  int get_subclass(sym_idx_t i) const {
+    return sym_table[i] ? sym_table[i]->subclass : 0;
+  }
+  Symbol* get_keyword(int i) const {
+    return ((unsigned)i < (unsigned)max_kw_idx) ? sym_table[keywords[i]].get() : nullptr;
+  }
+
+ protected:
+  sym_idx_t gen_lookup(std::string str, int mode = 0, sym_idx_t idx = 0);
+};
+
+template <unsigned pp>
+class SymTable : public SymTableBase {
+ public:
+  static constexpr int hprime = pp;
+  static int size() {
+    return pp + 1;
+  }
+
+ private:
+  std::unique_ptr<Symbol> sym[pp + 1];
+
+ public:
+  SymTable() : SymTableBase(pp, sym) {
+  }
+  SymTable& add_keyword(std::string str, sym_idx_t idx = 0) {
+    SymTableBase::add_keyword(str, idx);
+    return *this;
+  }
+  SymTable& add_kw_char(char c) {
+    return add_keyword(std::string{c}, c);
+  }
+};
+
+struct SymTableOverflow {
+  int sym_def;
+  SymTableOverflow(int x) : sym_def(x) {
+  }
+};
+
+struct SymTableKwRedef {
+  std::string kw;
+  SymTableKwRedef(std::string _kw) : kw(_kw) {
+  }
+};
+
+extern SymTable<100003> symbols;
+
+extern int scope_level;
+
+struct SymDef {
+  int level;
+  sym_idx_t sym_idx;
+  SymValBase* value;
+  SrcLocation loc;
+  SymDef(int lvl, sym_idx_t idx, const SrcLocation& _loc = {}, SymValBase* val = 0)
+      : level(lvl), sym_idx(idx), value(val), loc(_loc) {
+  }
+  bool has_name() const {
+    return sym_idx;
+  }
+  std::string name() const {
+    return symbols.get_name(sym_idx);
+  }
+};
+
+extern SymDef* sym_def[symbols.hprime + 1];
+extern SymDef* global_sym_def[symbols.hprime + 1];
+extern std::vector<std::pair<int, SymDef>> symbol_stack;
+extern std::vector<SrcLocation> scope_opened_at;
+
+void open_scope(Lexer& lex);
+void close_scope(Lexer& lex);
+SymDef* lookup_symbol(sym_idx_t idx, int flags = 3);
+SymDef* lookup_symbol(std::string name, int flags = 3);
+
+SymDef* define_global_symbol(sym_idx_t name_idx, bool force_new = false, const SrcLocation& loc = {});
+SymDef* define_symbol(sym_idx_t name_idx, bool force_new = false, const SrcLocation& loc = {});
+
+}  // namespace tolk