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