src/interp.cpp

   1
   2 #include "private.h"
   3 #include "builtin.h"
   4
   5 using namespace Builtins;
   6 using Value = Interpreter::Value;
   7
   8 static void populate_modpath(Interpreter& ip)
   9 {
  10     ip.addModulePath(".");
  11     ip.addModulePath("./modules");
  12 }
  13
  14 template<typename Stream>
  15 static Value make_standard_handle(Interpreter* ip, Stream& strm)
  16 {
  17     auto tb = ip->makeTable();
  18     tb->set(ID_HANDLE, ip->makeUserPointer(&strm));
  19     for(auto pair: Builtins::FileMembers)
  20     {
  21         tb->set(pair.first, ip->makeFunction(pair.second));
  22     }
  23     return tb;
  24 }
  25
  26 Value Interpreter::makeString(const std::string& src)
  27 {
  28     return Value(src);
  29 }
  30
  31 Value Interpreter::makeNumber(Value::NumberType val)
  32 {
  33     return Value(Value::NumberType(val));
  34 }
  35
  36 std::shared_ptr<Array<Value>> Interpreter::makeArray()
  37 {
  38     return std::make_shared<Array<Value>>();
  39 }
  40
  41 std::shared_ptr<Table<Value>> Interpreter::makeTable()
  42 {
  43     return std::make_shared<Table<Value>>();
  44 }
  45
  46 Value Interpreter::makeFunction(Interpreter::FuncProto fun)
  47 {
  48     auto node = std::make_shared<Internal::Function<Iter,Value,FuncType>>();
  49     node->begin = node->end;
  50     auto nop = std::make_shared<Internal::Nop<Iter,Value,FuncType>>();
  51     nop->begin = nop->end;
  52     node->children[0] = nop;
  53     auto builtin = std::make_shared<Internal::BuiltinFunction<Iter,Value,FuncType>>();
  54     builtin->begin = builtin->end;
  55     builtin->function = fun;
  56     node->children[1] = builtin;
  57     return Value(Value::Type::Function, node);
  58 }
  59
  60 bool Interpreter::need(const Value& raw_in, Value& dest, Value::Type expected)
  61 {
  62     auto intype = raw_in.type();
  63     if(intype == expected)
  64     {
  65         dest = raw_in;
  66         return true;
  67     }
  68     return false;
  69 }
  70
  71 bool Interpreter::needNumber(const Value& raw_in, Value& dest)
  72 {
  73     return need(raw_in, dest, Value::Type::Number);
  74 }
  75
  76 bool Interpreter::needString(const Value& raw_in, Value& dest)
  77 {
  78     return need(raw_in, dest, Value::Type::String);
  79 }
  80
  81 bool Interpreter::needFunction(const Value& raw_in, Value& dest)
  82 {
  83     return need(raw_in, dest, Value::Type::Function);
  84 }
  85
  86 void Interpreter::beginLocalScope()
  87 {
  88     m_envstack.push_back(std::make_shared<Table<Value>>());
  89 }
  90
  91 void Interpreter::endLocalScope()
  92 {
  93     m_envstack.pop_back();
  94 }
  95
  96 void Interpreter::beginFunctionScope()
  97 {
  98     m_funstack.push_back(m_envstack.size());
  99     m_envstack.push_back(std::make_shared<Table<Value>>());
 100 }
 101
 102 void Interpreter::endFunctionScope()
 103 {
 104     m_envstack.pop_back();
 105     m_funstack.pop_back();
 106 }
 107
 108 Value Interpreter::get(Value key)
 109 {
 110     int top = m_envstack.size()-1;
 111     int bottom = m_funstack.back();
 112     for(int i = top; i>=bottom; --i)
 113     {
 114         Value value = m_envstack[i]->get(key);
 115         if(value.type() != Value::Type::Nil)
 116         {
 117             return value;
 118         }
 119     }
 120     return m_envstack[0]->get(key);
 121 }
 122
 123 void Interpreter::set(Value key, Value value)
 124 {
 125     m_envstack[m_funstack.back()]->set(key, value);
 126 }
 127
 128 void Interpreter::setLocal(Value key, Value value)
 129 {
 130     m_envstack.back()->set(key, value);
 131 }
 132
 133 void Interpreter::setGlobal(Value key, Value value)
 134 {
 135     m_envstack[0]->set(key, value);
 136 }
 137
 138 void Interpreter::setGlobalFunc(const std::string &name, Interpreter::FuncProto fun)
 139 {
 140     setGlobal(Value(name), makeFunction(fun));
 141 }
 142
 143 Interpreter::ModulePath Interpreter::getModulePath()
 144 {
 145     return m_modpath;
 146 }
 147
 148 void Interpreter::addModulePath(const std::string& path)
 149 {
 150     m_modpath.push_back(path);
 151 }
 152
 153 Interpreter::Interpreter()
 154 {
 155     beginFunctionScope();
 156     populate_modpath(*this);
 157     setGlobal(Value("true"),  Value(Value::NumberType(1)));
 158     setGlobal(Value("false"), Value(Value::NumberType(0)));
 159     setGlobalFunc("print", Stdlib::fn_print);
 160     setGlobalFunc("println", Stdlib::fn_println);
 161     setGlobalFunc("readline", Stdlib::fn_readline);
 162     setGlobalFunc("children", Stdlib::fn_children);
 163     setGlobalFunc("tokens", Stdlib::fn_tokens);
 164     setGlobalFunc("expand_node", Stdlib::fn_expand_node);
 165     setGlobalFunc("tostring", Stdlib::fn_tostring);
 166     setGlobalFunc("tonumber", Stdlib::fn_tonumber);
 167     // this creates the "File" class
 168     setGlobalFunc("File", OBJMEMBER_NAME(File, constructor));
 169
 170     // setting up IO table
 171     auto iotb = makeTable();
 172     iotb->set(makeString("stdout"), make_standard_handle(this, std::cout));
 173     iotb->set(makeString("stderr"), make_standard_handle(this, std::cerr));
 174     iotb->set(makeString("stdin"), make_standard_handle(this, std::cin));
 175     setGlobal(makeString("IO"), iotb);
 176 }
 177
 178 Interpreter::~Interpreter()
 179 {
 180     endFunctionScope();
 181 }
 182
 183 Value Interpreter::eval(const std::string &source)
 184 {
 185     //LocalScope scope(*this);
 186 #if 1
 187     //auto psr = m_parser(source.begin(), source.end());
 188     //auto root = m_parser.eval()->children[0];
 189     //return (*this)(*root);
 190     //return root->accept(*this);
 191     //return result;
 192     //return root->tree()->accept(*this);
 193     //return_t parse_expression(StrIter sbegin, StrIter send)
 194     //auto node = std::make_shared<Internal::Eval<Iter,Value,FuncType>>();
 195 #else
 196     ParserInstance ps;
 197     ps(source.begin(), source.end());
 198     Value result = ps.eval()->accept(*this);
 199     return result;
 200 #endif
 201     return Value();
 202
 203 }
 204
 205
 206 Value Interpreter::run(const std::string &source)
 207 {
 208     auto root = m_parser(source.begin(), source.end());
 209     Value result = root->accept(*this);
 210     return result;
 211 }