src/ops.statement.cpp

   1
   2 #include "private.h"
   3 using namespace Internal;
   4
   5
   6 Interpreter::Value Interpreter::operator()(ExpressionStatement<Iter,Interpreter::Value,FuncType> &node)
   7 {
   8     return node.children[0]->accept(*this);
   9 }
  10
  11 Interpreter::Value Interpreter::operator()(ReturnStatement<Iter,Interpreter::Value,FuncType> &node)
  12 {
  13     if(node.children.size()>0)
  14     {
  15         m_function_stack.push_back(node.children[0]->accept(*this));
  16     }
  17     return Interpreter::Value(typename Interpreter::Value::TagReturn());
  18 }
  19
  20 /*
  21 Interpreter::Value Interpreter::operator()(EvalStatement<Iter,Interpreter::Value,FuncType> &node)
  22 {
  23     Interpreter::Value treeval = node.children[0]->accept(*this);
  24     if(treeval.type() != Interpreter::Value::Type::Tree)
  25     {
  26         error("cannot eval non-tree.", node);
  27         return Interpreter::Value();
  28     }
  29     return treeval.tree()->accept(*this);
  30 }
  31 */
  32
  33 Interpreter::Value Interpreter::operator()(Eval<Iter,Interpreter::Value,FuncType> &node)
  34 {
  35     Interpreter::Value treeval = node.children[0]->accept(*this);
  36     if(treeval.type() != Interpreter::Value::Type::Tree)
  37     {
  38         error("cannot eval non-tree.", node);
  39         return Interpreter::Value();
  40     }
  41     return treeval.tree()->accept(*this);
  42 }
  43
  44
  45 Interpreter::Value Interpreter::operator()(ParseStatement<Iter,Interpreter::Value,FuncType> &node)
  46 {
  47     Interpreter::Value val = node.children[0]->accept(*this);
  48     if(val.type() != Interpreter::Value::Type::String)
  49     {
  50         error("parse argument needs to be string.", node);
  51         return Interpreter::Value();
  52     }
  53     return Interpreter::Value(Interpreter::Value::Type::Tree, m_parser(val.string().begin(), val.string().end()));
  54 }
  55
  56 Interpreter::Value Interpreter::operator()(ParseExpression<Iter,Interpreter::Value,FuncType> &node)
  57 {
  58     Interpreter::Value val = node.children[0]->accept(*this);
  59     if(val.type() != Interpreter::Value::Type::String)
  60     {
  61         error("parse argument needs to be string.", node);
  62         return Interpreter::Value();
  63     }
  64     return Interpreter::Value(Interpreter::Value::Type::Tree, m_parser.parse_expression(
  65         val.string().begin(), val.string().end()));
  66 }
  67
  68
  69 Interpreter::Value Interpreter::operator()(StatementList<Iter,Interpreter::Value,FuncType> &node)
  70 {
  71     for(auto child : node.children)
  72     {
  73         Interpreter::Value result = child->accept(*this);
  74         typename Interpreter::Value::Type t = result.internal_type();
  75         if(t >= Interpreter::Value::Type::Return && t<= Interpreter::Value::Type::Continue)
  76         {
  77             return result;
  78         }
  79     }
  80     return Interpreter::Value();
  81 }
  82
  83 Interpreter::Value Interpreter::operator()(IfStatement<Iter,Interpreter::Value,FuncType> &node)
  84 {
  85     Interpreter::Value cond = node.children[0]->accept(*this);
  86     if(cond.type() != Interpreter::Value::Type::Number)
  87     {
  88         error("if condition not a number.", node);
  89         return Interpreter::Value();
  90     }
  91     if(cond.number() != 0.0)
  92     {
  93         return node.children[1]->accept(*this);
  94     }
  95     else if(node.children.size()>2)
  96     {
  97         return node.children[2]->accept(*this);
  98     }
  99     return Interpreter::Value();
 100 }
 101
 102 Interpreter::Value Interpreter::operator()(WhileStatement<Iter,Interpreter::Value,FuncType> &node)
 103 {
 104     auto nullval = Value(0.0);
 105     while(true)
 106     {
 107         auto cond = node.children[0]->accept(*this);
 108         if(cond.type() != Interpreter::Value::Type::Number)
 109         {
 110             error("while condition not a number.", node);
 111         }
 112         if(cond == nullval)
 113         {
 114             break;
 115         }
 116         auto result = node.children[1]->accept(*this);
 117         typename Interpreter::Value::Type t = result.internal_type();
 118         if(t == Interpreter::Value::Type::Break || t == Interpreter::Value::Type::Return)
 119         {
 120             return result;
 121         }
 122     }
 123     return Interpreter::Value();
 124 }
 125
 126 Interpreter::Value Interpreter::operator()(ForStatement<Iter,Interpreter::Value,FuncType> &node)
 127 {
 128     LocalScope(*this);
 129     auto nullval = Value(0.0);
 130     node.children[0]->accept(*this);
 131     while(true)
 132     {
 133         Interpreter::Value cond = node.children[1]->accept(*this);
 134         if(cond.type() != Interpreter::Value::Type::Number)
 135         {
 136             error("while condition not a number.", node);
 137         }
 138         if(cond == nullval)
 139         {
 140             break;
 141         }
 142         Interpreter::Value result = node.children[3]->accept(*this);
 143         typename Interpreter::Value::Type t = result.internal_type();
 144         if(t == Interpreter::Value::Type::Break || t == Interpreter::Value::Type::Return)
 145         {
 146             return result;
 147         }
 148         node.children[2]->accept(*this);
 149     }
 150     return Interpreter::Value();
 151 }
 152
 153 Interpreter::Value Interpreter::operator()(ForEachStatement<Iter,Interpreter::Value,FuncType> &node)
 154 {
 155     if(node.children.size()==3)
 156     {
 157         Interpreter::Value value = node.children[0]->accept(*this);
 158         Interpreter::Value table = node.children[1]->accept(*this);
 159         Interpreter::Value::Type t = table.type();
 160         if(t != Interpreter::Value::Type::Table && t != Interpreter::Value::Type::Array)
 161         {
 162             error("for each argument is not a table or array", node);
 163         }
 164         LocalScope local(*this);
 165         if(t == Interpreter::Value::Type::Table)
 166         {
 167             for(auto entry : *table.table())
 168             {
 169                 setLocal(value, entry.second);
 170                 Interpreter::Value result = node.children[2]->accept(*this);
 171                 typename Interpreter::Value::Type result_t = result.internal_type();
 172                 if(result_t == Interpreter::Value::Type::Break || result_t == Interpreter::Value::Type::Return)
 173                 {
 174                     return result;
 175                 }
 176             }
 177         }
 178         else
 179         {
 180             for(auto entry : *table.array())
 181             {
 182                 setLocal(value, entry);
 183                 Interpreter::Value result = node.children[2]->accept(*this);
 184                 typename Interpreter::Value::Type result_t = result.type();
 185                 if(result_t == Interpreter::Value::Type::Break || result_t == Interpreter::Value::Type::Return)
 186                 {
 187                     return result;
 188                 }
 189             }
 190         }
 191     }
 192     else
 193     {
 194         Interpreter::Value key = node.children[0]->accept(*this);
 195         Interpreter::Value value = node.children[1]->accept(*this);
 196         Interpreter::Value table = node.children[2]->accept(*this);
 197         if(table.type() != Interpreter::Value::Type::Table)
 198         {
 199             error("for each argument is not a table", node);
 200         }
 201         LocalScope local(*this);
 202         for(auto entry : *table.table())
 203         {
 204             setLocal(key, entry.first);
 205             setLocal(value, entry.second);
 206             Interpreter::Value result = node.children[3]->accept(*this);
 207             typename Interpreter::Value::Type t = result.type();
 208             if(t == Interpreter::Value::Type::Break || t == Interpreter::Value::Type::Return)
 209             {
 210                 return result;
 211             }
 212         }
 213     }
 214     return Interpreter::Value();
 215 }
 216
 217 Interpreter::Value Interpreter::operator()(ContinueStatement<Iter,Interpreter::Value,FuncType> &)
 218 {
 219     return Interpreter::Value(typename Interpreter::Value::TagContinue());
 220 }
 221
 222 Interpreter::Value Interpreter::operator()(BreakStatement<Iter,Interpreter::Value,FuncType> &)
 223 {
 224     return Interpreter::Value(typename Interpreter::Value::TagBreak());
 225 }
 226
 227