src/interp.cpp

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