1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-24 22:14:36 +02:00
vcmi/scripting/erm/ERMInterpreter.cpp

1775 lines
37 KiB
C++
Raw Normal View History

/*
* ERMInterpreter.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "ERMInterpreter.h"
#include <cctype>
namespace spirit = boost::spirit;
using ::scripting::ContextBase;
using namespace ::VERMInterpreter;
typedef int TUnusedType;
namespace ERMConverter
{
//console printer
using namespace ERM;
static const std::map<std::string, std::string> CMP_OPERATION =
{
{"<", "<"},
{">", ">"},
{">=", ">="},
{"=>", ">="},
{"<=", "<="},
{"=<", "<="},
{"=", "=="},
{"<>", "~="},
{"><", "~="},
};
struct Variable
{
std::string name = "";
std::string macro = "";
int index = 0;
Variable(const std::string & name_, int index_)
{
name = name_;
index = index_;
}
Variable(const std::string & macro_)
{
macro = macro_;
}
bool isEmpty() const
{
return (name == "") && (macro == "");
}
bool isMacro() const
{
return (name == "") && (macro != "");
}
bool isSpecial() const
{
return (name.size() > 0) && (name[0] == 'd');
}
std::string str() const
{
if(isEmpty())
{
return std::to_string(index);
}
else if(isMacro())
{
return boost::to_string(boost::format("M['%s']") % macro);
}
else if(isSpecial() && (name.size() == 1))
{
boost::format fmt;
fmt.parse("{'d', %d}");
fmt % index;
return fmt.str();
}
else if(isSpecial() && (name.size() != 1))
{
std::string ret;
{
boost::format fmt;
if(index == 0)
{
fmt.parse("Q['%s']");
fmt % name[name.size()-1];
}
else
{
fmt.parse("%s['%d']");
fmt % name[name.size()-1] % index;
}
ret = fmt.str();
}
for(int i = ((int) name.size())-2; i > 0; i--)
{
boost::format fmt("%s[tostring(%s)]");
fmt % name[i] % ret;
ret = fmt.str();
}
{
boost::format fmt;
fmt.parse("{'d', %s}");
fmt % ret;
return fmt.str();
}
}
else
{
std::string ret;
{
boost::format fmt;
if(index == 0)
{
fmt.parse("Q['%s']");
fmt % name[name.size()-1];
}
else
{
fmt.parse("%s['%d']");
fmt % name[name.size()-1] % index;
}
ret = fmt.str();
}
for(int i = ((int) name.size())-2; i >= 0; i--)
{
boost::format fmt("%s[tostring(%s)]");
fmt % name[i] % ret;
ret = fmt.str();
}
return ret;
}
}
};
struct LVL2IexpToVar
{
LVL2IexpToVar() = default;
Variable operator()(const TVarExpNotMacro & val) const
{
if(val.val.has_value())
return Variable(val.varsym, *val.val);
else
return Variable(val.varsym, 0);
}
Variable operator()(const TMacroUsage & val) const
{
return Variable(val.macro);
}
};
struct LVL1IexpToVar
{
LVL1IexpToVar() = default;
Variable operator()(const int & constant) const
{
return Variable("", constant);
}
Variable operator()(const TVarExp & var) const
{
return std::visit(LVL2IexpToVar(), var);
}
};
struct Condition
{
std::string operator()(const TComparison & cmp) const
{
Variable lhs = std::visit(LVL1IexpToVar(), cmp.lhs);
Variable rhs = std::visit(LVL1IexpToVar(), cmp.rhs);
auto sign = CMP_OPERATION.find(cmp.compSign);
if(sign == std::end(CMP_OPERATION))
throw EScriptExecError(std::string("Wrong comparison sign: ") + cmp.compSign);
boost::format fmt("(%s %s %s)");
fmt % lhs.str() % sign->second % rhs.str();
return fmt.str();
}
std::string operator()(const int & flag) const
{
return boost::to_string(boost::format("F['%d']") % flag);
}
};
struct ParamIO
{
ParamIO() = default;
std::string name = "";
bool isInput = false;
bool semi = false;
std::string semiCmpSign = "";
};
struct Converter
{
mutable std::ostream * out;
Converter(std::ostream * out_)
: out(out_)
{}
protected:
void put(const std::string & text) const
{
(*out) << text;
}
void putLine(const std::string & line) const
{
(*out) << line << std::endl;
}
void endLine() const
{
(*out) << std::endl;
}
};
struct GetBodyOption
{
virtual std::string operator()(const TVarConcatString & cmp) const
{
throw EScriptExecError("String concatenation not allowed in this receiver");
}
virtual std::string operator()(const TStringConstant & cmp) const
{
throw EScriptExecError("String constant not allowed in this receiver");
}
virtual std::string operator()(const TCurriedString & cmp) const
{
throw EScriptExecError("Curried string not allowed in this receiver");
}
virtual std::string operator()(const TSemiCompare & cmp) const
{
throw EScriptExecError("Semi comparison not allowed in this receiver");
}
virtual std::string operator()(const TMacroDef & cmp) const
{
throw EScriptExecError("Macro definition not allowed in this receiver");
}
virtual std::string operator()(const TIexp & cmp) const
{
throw EScriptExecError("i-expression not allowed in this receiver");
}
virtual std::string operator()(const TVarpExp & cmp) const
{
throw EScriptExecError("Varp expression not allowed in this receiver");
}
virtual std::string operator()(const spirit::unused_type & cmp) const
{
throw EScriptExecError("\'Nothing\' not allowed in this receiver");
}
};
struct BodyOption
{
ParamIO operator()(const TVarConcatString & cmp) const
{
throw EScriptExecError(std::string("String concatenation not allowed in this receiver|")+cmp.string.str+"|");
}
ParamIO operator()(const TStringConstant & cmp) const
{
boost::format fmt("[===[%s]===]");
fmt % cmp.str;
ParamIO ret;
ret.isInput = true;
ret.name = fmt.str();
return ret;
}
ParamIO operator()(const TCurriedString & cmp) const
{
throw EScriptExecError("Curried string not allowed in this receiver");
}
ParamIO operator()(const TSemiCompare & cmp) const
{
ParamIO ret;
ret.isInput = false;
ret.semi = true;
ret.semiCmpSign = cmp.compSign;
ret.name = (std::visit(LVL1IexpToVar(), cmp.rhs)).str();
return ret;
}
ParamIO operator()(const TMacroDef & cmp) const
{
throw EScriptExecError("Macro definition not allowed in this receiver");
}
ParamIO operator()(const TIexp & cmp) const
{
ParamIO ret;
ret.isInput = true;
2024-01-16 21:02:39 +02:00
ret.name = (std::visit(LVL1IexpToVar(), cmp)).str();
return ret;
}
ParamIO operator()(const TVarpExp & cmp) const
{
ParamIO ret;
ret.isInput = false;
ret.name = (std::visit(LVL2IexpToVar(), cmp.var)).str();
return ret;
}
ParamIO operator()(const spirit::unused_type & cmp) const
{
throw EScriptExecError("\'Nothing\' not allowed in this receiver");
}
};
struct Receiver : public Converter
{
Receiver(std::ostream * out_)
: Converter(out_)
{}
virtual void operator()(const TVRLogic & trig) const
{
throw EInterpreterError("VR logic is not allowed in this receiver!");
}
virtual void operator()(const TVRArithmetic & trig) const
{
throw EInterpreterError("VR arithmetic is not allowed in this receiver!");
}
virtual void operator()(const TNormalBodyOption & trig) const
{
throw EInterpreterError("Normal body is not allowed in this receiver!");
}
};
struct GenericReceiver : public Receiver
{
std::string name;
bool specialSemiCompare = false;
GenericReceiver(std::ostream * out_, const std::string & name_, bool specialSemiCompare_)
: Receiver(out_),
name(name_),
specialSemiCompare(specialSemiCompare_)
{}
using Receiver::operator();
void operator()(const TNormalBodyOption & trig) const override
{
std::string outParams;
std::string inParams;
std::string semiCompareDecl;
std::vector<std::string> compares;
bool hasOutput = false;
bool hasSemiCompare = false;
std::vector<ParamIO> optionParams;
if(trig.params.has_value())
{
for(auto & p : *trig.params)
optionParams.push_back(std::visit(BodyOption(), p));
}
int idx = 1;
int fidx = 1;
for(const ParamIO & p : optionParams)
{
if(p.isInput)
{
if(outParams.empty())
outParams = "_";
else
outParams += ", _";
inParams += ", ";
inParams += p.name;
}
else if(p.semi)
{
hasOutput = true;
hasSemiCompare = true;
std::string tempVar = std::string("s")+std::to_string(idx);
if(semiCompareDecl.empty())
{
semiCompareDecl = "local "+tempVar;
}
else
{
semiCompareDecl += ", ";
semiCompareDecl += tempVar;
}
if(outParams.empty())
{
outParams = tempVar;
}
else
{
outParams += ", ";
outParams += tempVar;
}
inParams += ", nil";
auto sign = CMP_OPERATION.find(p.semiCmpSign);
if(sign == std::end(CMP_OPERATION))
throw EScriptExecError(std::string("Wrong comparison sign: ") + p.semiCmpSign);
boost::format cmpFmt("F[%d] = (%s %s %s)");
cmpFmt % fidx % p.name % sign->second % tempVar;
compares.push_back(cmpFmt.str());
fidx++;
}
else
{
hasOutput = true;
if(outParams.empty())
{
outParams = p.name;
}
else
{
outParams += ", ";
outParams += p.name;
}
inParams += ", nil";
}
idx++;
}
if(hasSemiCompare)
{
putLine(semiCompareDecl);
}
boost::format callFormat;
if(hasOutput)
{
callFormat.parse("%s = %s:%s(x%s)");
callFormat % outParams;
}
else
{
callFormat.parse("%s:%s(x%s)");
}
callFormat % name;
callFormat % trig.optionCode;
callFormat % inParams;
putLine(callFormat.str());
for(auto & str : compares)
putLine(str);
}
};
struct FU : public Receiver
{
Variable v;
FU(std::ostream * out_, const ERM::TIexp & tid)
: Receiver(out_),
v(std::visit(LVL1IexpToVar(), tid))
{
}
FU(std::ostream * out_)
: Receiver(out_),
v("", 0)
{
}
using Receiver::operator();
void operator()(const TNormalBodyOption & trig) const override
{
switch(trig.optionCode)
{
case 'E':
{
putLine("do return end");
}
break;
default:
throw EInterpreterError("Unknown opcode in FU receiver");
break;
}
}
};
struct MC_S : public GetBodyOption
{
MC_S()
{}
using GetBodyOption::operator();
std::string operator()(const TMacroDef & cmp) const override
{
return cmp.macro;
}
};
struct MC : public Receiver
{
Variable v;
MC(std::ostream * out_, const ERM::TIexp & tid)
: Receiver(out_),
v(std::visit(LVL1IexpToVar(), tid))
{
}
MC(std::ostream * out_)
: Receiver(out_),
v("", 0)
{
}
using Receiver::operator();
void operator()(const TNormalBodyOption & option) const override
{
switch(option.optionCode)
{
case 'S':
{
if(option.params.has_value())
{
for(auto & p : *option.params)
{
std::string macroName = std::visit(MC_S(), p);
boost::format callFormat;
if(v.isEmpty())
{
callFormat.parse("ERM:addMacro('%s', 'v', '%s')");
callFormat % macroName % macroName;
}
else
{
callFormat.parse("ERM:addMacro('%s', '%s', '%d')");
callFormat % macroName % v.name % v.index;
}
putLine(callFormat.str());
}
}
}
break;
default:
throw EInterpreterError("Unknown opcode in MC receiver");
break;
}
}
};
struct VR_S : public GetBodyOption
{
VR_S()
{}
using GetBodyOption::operator();
std::string operator()(const TIexp & cmp) const override
{
auto v = std::visit(LVL1IexpToVar(), cmp);
return v.str();
}
std::string operator()(const TStringConstant & cmp) const override
{
boost::format fmt("[===[%s]===]");
fmt % cmp.str;
return fmt.str();
}
};
struct VR_H : public GetBodyOption
{
VR_H()
{}
using GetBodyOption::operator();
std::string operator()(const TIexp & cmp) const override
{
Variable p = std::visit(LVL1IexpToVar(), cmp);
if(p.index <= 0)
throw EScriptExecError("VR:H requires flag index");
if(p.name != "")
throw EScriptExecError("VR:H accept only flag index");
boost::format fmt("'%d'");
fmt % p.index;
return fmt.str();
}
};
struct VR_X : public GetBodyOption
{
VR_X()
{
}
using GetBodyOption::operator();
std::string operator()(const TIexp & cmp) const override
{
Variable p = std::visit(LVL1IexpToVar(), cmp);
return p.str();
}
};
struct VR : public Receiver
{
Variable v;
VR(std::ostream * out_, const ERM::TIexp & tid)
: Receiver(out_),
v(std::visit(LVL1IexpToVar(), tid))
{
}
using Receiver::operator();
void operator()(const TVRLogic & trig) const override
{
Variable rhs = std::visit(LVL1IexpToVar(), trig.var);
std::string opcode;
switch (trig.opcode)
{
case '&':
opcode = "bit.band";
break;
case '|':
opcode = "bit.bor";
break;
default:
throw EInterpreterError("Wrong opcode in VR logic expression!");
break;
}
boost::format fmt("%s = %s(%s, %s)");
fmt % v.str() % opcode % v.str() % rhs.str();
putLine(fmt.str());
}
void operator()(const TVRArithmetic & trig) const override
{
Variable rhs = std::visit(LVL1IexpToVar(), trig.rhs);
std::string opcode;
switch (trig.opcode)
{
case '+':
opcode = v.name[0] == 'z' ? ".." : "+";
break;
case '-':
case '*':
case '%':
opcode = trig.opcode;
break;
case ':':
opcode = "/";
break;
default:
throw EInterpreterError("Wrong opcode in VR arithmetic!");
break;
}
boost::format fmt("%s = %s %s %s");
fmt % v.str() % v.str() % opcode % rhs.str();
putLine(fmt.str());
}
void operator()(const TNormalBodyOption & trig) const override
{
switch(trig.optionCode)
{
case 'C': //setting/checking v vars
{
if(v.index <= 0)
throw EScriptExecError("VR:C requires indexed variable");
std::vector<ParamIO> optionParams;
if(trig.params.has_value())
{
for(auto & p : *trig.params)
optionParams.push_back(std::visit(BodyOption(), p));
}
auto index = v.index;
for(auto & p : optionParams)
{
boost::format fmt;
if(p.isInput)
fmt.parse("%s['%d'] = %s") % v.name % index % p.name;
else
fmt.parse("%s = %s['%d']") % p.name % v.name % index;
putLine(fmt.str());
index++;
}
}
break;
case 'H': //checking if string is empty
{
if(!trig.params.has_value() || trig.params->size() != 1)
throw EScriptExecError("VR:H option takes exactly 1 parameter!");
std::string opt = std::visit(VR_H(), (*trig.params)[0]);
boost::format fmt("ERM.VR(%s):H(%s)");
fmt % v.str() % opt;
putLine(fmt.str());
}
break;
case 'U':
{
if(!trig.params.has_value() || trig.params->size() != 1)
throw EScriptExecError("VR:H/U need 1 parameter!");
std::string opt = std::visit(VR_S(), (*trig.params)[0]);
boost::format fmt("ERM.VR(%s):%c(%s)");
fmt % v.str() % (trig.optionCode) % opt;
putLine(fmt.str());
}
break;
case 'M': //string operations
{
if(!trig.params.has_value() || trig.params->size() < 2)
throw EScriptExecError("VR:M needs at least 2 parameters!");
std::string opt = std::visit(VR_X(), (*trig.params)[0]);
int paramIndex = 1;
if(opt == "3")
{
boost::format fmt("%s = ERM.VR(%s):M3(");
fmt % v.str() % v.str();
put(fmt.str());
}
else
{
auto target = std::visit(VR_X(), (*trig.params)[paramIndex++]);
boost::format fmt("%s = ERM.VR(%s):M%s(");
fmt % target % v.str() % opt;
put(fmt.str());
}
for(int i = paramIndex; i < trig.params->size(); i++)
{
opt = std::visit(VR_X(), (*trig.params)[i]);
if(i > paramIndex) put(",");
put(opt);
}
putLine(")");
}
break;
case 'X': //bit xor
{
if(!trig.params.has_value() || trig.params->size() != 1)
throw EScriptExecError("VR:X option takes exactly 1 parameter!");
std::string opt = std::visit(VR_X(), (*trig.params)[0]);
boost::format fmt("%s = bit.bxor(%s, %s)");
fmt % v.str() % v.str() % opt;putLine(fmt.str());
}
break;
case 'R': //random variables
{
//TODO
putLine("--VR:R not implemented");
}
break;
case 'S': //setting variable
{
if(!trig.params.has_value() || trig.params->size() != 1)
throw EScriptExecError("VR:S option takes exactly 1 parameter!");
std::string opt = std::visit(VR_S(), (*trig.params)[0]);
put(v.str());
put(" = ");
put(opt);
endLine();
}
break;
case 'T': //random variables
{
//TODO
putLine("--VR:T not implemented");
}
break;
case 'V': //convert string to value
{
if(!trig.params.has_value() || trig.params->size() != 1)
throw EScriptExecError("VR:V option takes exactly 1 parameter!");
std::string opt = std::visit(VR_X(), (*trig.params)[0]);
boost::format fmt("%s = tostring(%s)");
fmt % v.str() % opt;
putLine(fmt.str());
}
break;
default:
throw EScriptExecError("Wrong VR receiver option!");
break;
}
}
};
struct ERMExp : public Converter
{
ERMExp(std::ostream * out_)
: Converter(out_)
{}
template <typename Visitor>
void performBody(const std::optional<ERM::Tbody> & body, const Visitor & visitor) const
{
if(body.has_value())
{
const ERM::Tbody & bo = *body;
for(int g=0; g<bo.size(); ++g)
{
std::visit(visitor, bo[g]);
}
}
}
void convert(const std::string & name, const std::optional<Tidentifier> & identifier, const std::optional<Tbody> & body) const
{
if(name == "VR")
{
if(!identifier.has_value())
throw EScriptExecError("VR receiver requires arguments");
ERM::Tidentifier tid = identifier.value();
if(tid.size() != 1)
throw EScriptExecError("VR receiver takes exactly 1 argument");
performBody(body, VR(out, tid[0]));
}
else if(name == "re")
{
if(!identifier.has_value())
throw EScriptExecError("re receiver requires arguments");
ERM::Tidentifier tid = identifier.value();
auto argc = tid.size();
if(argc > 0)
{
std::string loopCounter = (std::visit(LVL1IexpToVar(), tid.at(0))).str();
std::string startVal = argc > 1 ? (std::visit(LVL1IexpToVar(), tid.at(1))).str() : loopCounter;
std::string stopVal = argc > 2 ? (std::visit(LVL1IexpToVar(), tid.at(2))).str() : loopCounter;
std::string increment = argc > 3 ? (std::visit(LVL1IexpToVar(), tid.at(3))).str() : "1";
boost::format fmt("for __iter = %s, %s, %s do");
fmt % startVal % stopVal % increment;
putLine(fmt.str());
fmt.parse("%s = __iter");
fmt % loopCounter;
putLine(fmt.str());
}
else
{
throw EScriptExecError("re receiver requires arguments");
}
}
else if(name == "FU" && !identifier.has_value())
{
performBody(body, FU(out)); //assume FU:E
}
else if(name == "MC")
{
if(identifier.has_value())
{
ERM::Tidentifier tid = identifier.value();
if(tid.size() != 1)
throw EScriptExecError("MC receiver takes no more than 1 argument");
performBody(body, MC(out, tid[0]));
}
else
{
performBody(body, MC(out));
}
}
else
{
std::vector<std::string> identifiers;
if(identifier.has_value())
{
for(const auto & id : identifier.value())
{
Variable v = std::visit(LVL1IexpToVar(), id);
if(v.isSpecial())
throw ELineProblem("Special variable syntax ('d') is not allowed in receiver identifier");
identifiers.push_back(v.str());
}
}
std::string params;
for(auto iter = std::begin(identifiers); iter != std::end(identifiers); ++iter)
{
if(!params.empty())
params += ", ";
params += *iter;
}
if(body.has_value())
{
const ERM::Tbody & bo = *body;
if(bo.size() == 1)
{
boost::format fmt("ERM.%s(%s)");
fmt % name;
fmt % params;
GenericReceiver gr(out, fmt.str(), (name == "DO"));
std::visit(gr,bo[0]);
}
else
{
putLine("do");
boost::format fmt("local %s = ERM.%s(%s)");
fmt % name;
fmt % name;
fmt % params;
putLine(fmt.str());
performBody(body, GenericReceiver(out, name, (name=="DO") ));
putLine("end");
}
}
else
{
//is it an error?
logMod->warn("ERM receiver '%s %s' w/o body", name, params);
}
}
}
void convertConditionInner(const Tcondition & cond, char op) const
{
std::string lhs = std::visit(Condition(), cond.cond);
if(cond.ctype != '/')
op = cond.ctype;
switch (op)
{
case '&':
put(" and ");
break;
case '|':
put(" or ");
break;
default:
throw EInterpreterProblem(std::string("Wrong condition connection (") + cond.ctype + ") !");
break;
}
put(lhs);
if(cond.rhs.has_value())
{
switch (op)
{
case '&':
case '|':
break;
default:
throw EInterpreterProblem(std::string("Wrong condition connection (") + cond.ctype + ") !");
break;
}
convertConditionInner(cond.rhs->get(), op);
}
}
void convertCondition(const Tcondition & cond) const
{
//&c1/c2/c3|c4/c5/c6 -> (c1 & c2 & c3) | c4 | c5 | c6
std::string lhs = std::visit(Condition(), cond.cond);
put("if ");
put(lhs);
if(cond.rhs.has_value())
{
switch (cond.ctype)
{
case '&':
case '|':
break;
default:
throw EInterpreterProblem(std::string("Wrong condition connection (") + cond.ctype + ") !");
break;
}
convertConditionInner(cond.rhs->get(), cond.ctype);
}
putLine(" then ");
}
void convertReceiverOrInstruction(const std::optional<Tcondition> & condition,
const std::string & name,
const std::optional<Tidentifier> & identifier,
const std::optional<Tbody> & body) const
{
if(name=="if")
{
if(condition.has_value())
convertCondition(*condition);
else
putLine("if true then");
}
else if(name=="el")
{
putLine("else");
}
else if(name=="en")
{
putLine("end");
}
else
{
if(condition.has_value())
{
convertCondition(*condition);
convert(name, identifier, body);
putLine("end");
}
else
{
convert(name, identifier, body);
}
}
}
void operator()(const Ttrigger & trig) const
{
throw EInterpreterError("Triggers cannot be executed!");
}
void operator()(const TPostTrigger & trig) const
{
throw EInterpreterError("Post-triggers cannot be executed!");
}
void operator()(const Tinstruction & trig) const
{
convertReceiverOrInstruction(trig.condition, trig.name, trig.identifier, std::make_optional(trig.body));
}
void operator()(const Treceiver & trig) const
{
convertReceiverOrInstruction(trig.condition, trig.name, trig.identifier, trig.body);
}
};
struct Command : public Converter
{
Command(std::ostream * out_)
: Converter(out_)
{}
void operator()(const Tcommand & cmd) const
{
std::visit(ERMExp(out), cmd.cmd);
}
void operator()(const std::string & comment) const
{
(*out) << "-- " << comment;
endLine();
}
void operator()(const spirit::unused_type &) const
{
}
};
struct TLiteralEval
{
std::string operator()(const char & val)
{
return "{\"'\",'"+ std::to_string(val) +"'}";
}
std::string operator()(const double & val)
{
return std::to_string(val);
}
std::string operator()(const int & val)
{
return std::to_string(val);
}
std::string operator()(const std::string & val)
{
return "{\"'\",[===[" + val + "]===]}";
}
};
struct VOptionEval : public Converter
{
VOptionEval(std::ostream * out_)
: Converter(out_)
{}
void operator()(VNIL const & opt) const
{
(*out) << "{}";
}
void operator()(const boost::recursive_wrapper<VNode> & opt) const;
void operator()(const VSymbol & opt) const
{
(*out) << "\"" << opt.text << "\"";
}
void operator()(const TLiteral & opt) const
{
TLiteralEval tmp;
(*out) << std::visit(tmp, opt);
}
void operator()(const ERM::Tcommand & opt) const
{
//this is how FP works, evaluation == producing side effects
//TODO: can we evaluate to smth more useful?
//???
throw EVermScriptExecError("Using ERM options in VERM expression is not (yet) allowed");
// std::visit(ERMExp(out), opt.cmd);
}
};
void VOptionEval::operator()(const boost::recursive_wrapper<VNode> & opt) const
{
VNode tmpn(opt.get());
(*out) << "{";
for(VOption & op : tmpn.children)
{
std::visit(VOptionEval(out), op);
(*out) << ",";
}
(*out) << "}";
}
struct Line : public Converter
{
Line(std::ostream * out_)
: Converter(out_)
{}
void operator()(const TVExp & cmd) const
{
put("VERM:E");
VNode line(cmd);
VOptionEval eval(out);
eval(line);
endLine();
}
void operator()(const TERMline & cmd) const
{
std::visit(Command(out), cmd);
}
};
void convertInstructions(std::ostream & out, ERMInterpreter * owner)
{
out << "local function instructions()" << std::endl;
out << "local e, x, y = {}, {}, {}" << std::endl;
Line lineConverter(&out);
for(const LinePointer & lp : owner->instructions)
{
ERM::TLine & line = owner->retrieveLine(lp);
std::visit(lineConverter, line);
}
out << "end" << std::endl;
}
void convertFunctions(std::ostream & out, ERMInterpreter * owner, const std::vector<VERMInterpreter::Trigger> & triggers)
{
Line lineConverter(&out);
for(const VERMInterpreter::Trigger & trigger : triggers)
{
ERM::TLine & firstLine = owner->retrieveLine(trigger.line);
const ERM::TTriggerBase & trig = ERMInterpreter::retrieveTrigger(firstLine);
//TODO: condition
out << "ERM:addTrigger({" << std::endl;
if(!trig.identifier.has_value())
throw EInterpreterError("Function must have identifier");
ERM::Tidentifier tid = trig.identifier.value();
if(tid.empty())
throw EInterpreterError("Function must have identifier");
Variable v = std::visit(LVL1IexpToVar(), tid[0]);
if(v.isSpecial())
throw ELineProblem("Special variable syntax ('d') is not allowed in function definition");
out << "id = {" << v.str() << "}," << std::endl;
out << "name = 'FU'," << std::endl;
out << "fn = function (e, y, x)" << std::endl;
out << "local _" << std::endl;
LinePointer lp = trigger.line;
++lp;
for(; lp.isValid(); ++lp)
{
ERM::TLine curLine = owner->retrieveLine(lp);
if(owner->isATrigger(curLine))
break;
std::visit(lineConverter, curLine);
}
out << "end," << std::endl;
out << "})" << std::endl;
}
}
void convertTriggers(std::ostream & out, ERMInterpreter * owner, const VERMInterpreter::TriggerType & type, const std::vector<VERMInterpreter::Trigger> & triggers)
{
Line lineConverter(&out);
for(const VERMInterpreter::Trigger & trigger : triggers)
{
ERM::TLine & firstLine = owner->retrieveLine(trigger.line);
const ERM::TTriggerBase & trig = ERMInterpreter::retrieveTrigger(firstLine);
//TODO: condition
out << "ERM:addTrigger({" << std::endl;
std::vector<std::string> identifiers;
if(trig.identifier.has_value())
{
for(const auto & id : trig.identifier.value())
{
Variable v = std::visit(LVL1IexpToVar(), id);
if(v.isSpecial())
throw ELineProblem("Special variable syntax ('d') is not allowed in trigger definition");
identifiers.push_back(v.str());
}
}
out << "id = {";
for(const auto & id : identifiers)
out << "'" << id << "',";
out << "}," << std::endl;
out << "name = '" << trig.name << "'," << std::endl;
out << "fn = function (e, y)" << std::endl;
out << "local _" << std::endl;
LinePointer lp = trigger.line;
++lp;
for(; lp.isValid(); ++lp)
{
ERM::TLine curLine = owner->retrieveLine(lp);
if(owner->isATrigger(curLine))
break;
std::visit(lineConverter, curLine);
}
out << "end," << std::endl;
out << "})" << std::endl;
}
}
}
struct ScriptScanner
{
ERMInterpreter * interpreter;
LinePointer lp;
ScriptScanner(ERMInterpreter * interpr, const LinePointer & _lp) : interpreter(interpr), lp(_lp)
{}
void operator()(const TVExp & cmd) const
{
//
}
void operator()(const TERMline & cmd) const
{
if(std::holds_alternative<Tcommand>(cmd)) //TCommand
{
Tcommand tcmd = std::get<Tcommand>(cmd);
struct Visitor
{
void operator()(const ERM::Ttrigger& t) const
{
Trigger trig;
trig.line = l;
i->triggers[ TriggerType(t.name) ].push_back(trig);
}
void operator()(const ERM::Tinstruction&) const
{
i->instructions.push_back(l);
}
void operator()(const ERM::Treceiver&) const {}
void operator()(const ERM::TPostTrigger& pt) const
{
Trigger trig;
trig.line = l;
i->postTriggers[ TriggerType(pt.name) ].push_back(trig);
}
const decltype(interpreter)& i;
const LinePointer& l;
};
Visitor v{interpreter, lp};
std::visit(v, tcmd.cmd);
}
}
};
ERMInterpreter::ERMInterpreter(vstd::CLoggerBase * logger_)
: logger(logger_)
{
}
ERMInterpreter::~ERMInterpreter()
{
}
bool ERMInterpreter::isATrigger( const ERM::TLine & line )
{
if(std::holds_alternative<ERM::TVExp>(line))
{
TVExp vexp = std::get<TVExp>(line);
if(vexp.children.empty())
return false;
switch (getExpType(vexp.children[0]))
{
case SYMBOL:
return false;
break;
case TCMD:
return isCMDATrigger( std::get<ERM::Tcommand>(vexp.children[0]) );
break;
default:
return false;
break;
}
}
else if(std::holds_alternative<TERMline>(line))
{
TERMline ermline = std::get<TERMline>(line);
return std::holds_alternative<ERM::Tcommand>(ermline) && isCMDATrigger( std::get<ERM::Tcommand>(ermline) );
}
else
{
assert(0);
}
return false;
}
ERM::EVOtions ERMInterpreter::getExpType(const ERM::TVOption & opt)
{
struct Visitor
{
ERM::EVOtions operator()(const boost::recursive_wrapper<ERM::TVExp>&) const
{
return ERM::EVOtions::VEXP;
}
ERM::EVOtions operator()(const ERM::TSymbol&) const
{
return ERM::EVOtions::SYMBOL;
}
ERM::EVOtions operator()(char) const
{
return ERM::EVOtions::CHAR;
}
ERM::EVOtions operator()(double) const
{
return ERM::EVOtions::DOUBLE;
}
ERM::EVOtions operator()(int) const
{
return ERM::EVOtions::INT;
}
ERM::EVOtions operator()(const ERM::Tcommand&) const
{
return ERM::EVOtions::TCMD;
}
ERM::EVOtions operator()(const ERM::TStringConstant&) const
{
return ERM::EVOtions::STRINGC;
}
};
const Visitor v;
return std::visit(v, opt);
}
bool ERMInterpreter::isCMDATrigger(const ERM::Tcommand & cmd)
{
struct Visitor
{
bool operator()(const ERM::Ttrigger&) const { return true; }
bool operator()(const ERM::TPostTrigger&) const { return true; }
bool operator()(const ERM::Tinstruction&) const { return false; }
bool operator()(const ERM::Treceiver&) const { return false; }
};
const Visitor v;
return std::visit(v, cmd.cmd);
}
ERM::TLine & ERMInterpreter::retrieveLine(const LinePointer & linePtr)
{
return scripts.find(linePtr)->second;
}
ERM::TTriggerBase & ERMInterpreter::retrieveTrigger(ERM::TLine & line)
{
if(std::holds_alternative<ERM::TERMline>(line))
{
ERM::TERMline &tl = std::get<ERM::TERMline>(line);
if(std::holds_alternative<ERM::Tcommand>(tl))
{
ERM::Tcommand &tcm = std::get<ERM::Tcommand>(tl);
if(std::holds_alternative<ERM::Ttrigger>(tcm.cmd))
{
return std::get<ERM::Ttrigger>(tcm.cmd);
}
else if(std::holds_alternative<ERM::TPostTrigger>(tcm.cmd))
{
return std::get<ERM::TPostTrigger>(tcm.cmd);
}
throw ELineProblem("Given line is not a trigger!");
}
throw ELineProblem("Given line is not a command!");
}
throw ELineProblem("Given line is not an ERM trigger!");
}
std::string ERMInterpreter::loadScript(const std::string & name, const std::string & source)
{
CERMPreprocessor preproc(source);
const bool isVERM = preproc.version == CERMPreprocessor::Version::VERM;
ERMParser ep;
std::vector<LineInfo> buf = ep.parseFile(preproc);
for(int g=0; g<buf.size(); ++g)
scripts[LinePointer(static_cast<int>(buf.size()), g, buf[g].realLineNum)] = buf[g].tl;
for(auto p : scripts)
std::visit(ScriptScanner(this, p.first), p.second);
std::stringstream out;
out << "local ERM = require(\"core:erm\")" << std::endl;
if(isVERM)
{
out << "local VERM = require(\"core:verm\")" << std::endl;
}
out << "local _" << std::endl;
out << "local v, w, z, F, M, Q = ERM.v, ERM.w, ERM.z, ERM.F, ERM.M, ERM.Q" << std::endl;
ERMConverter::convertInstructions(out, this);
for(const auto & p : triggers)
{
const VERMInterpreter::TriggerType & tt = p.first;
if(tt.type == VERMInterpreter::TriggerType::FU)
{
ERMConverter::convertFunctions(out, this, p.second);
}
else
{
ERMConverter::convertTriggers(out, this, tt, p.second);
}
}
for(const auto & p : postTriggers)
;//TODO:postTriggers
out << "ERM:callInstructions(instructions)" << std::endl;
return out.str();
}
namespace VERMInterpreter
{
VOption convertToVOption(const ERM::TVOption & tvo)
{
struct OptionConverterVisitor
{
VOption operator()(const boost::recursive_wrapper<ERM::TVExp>& cmd) const
{
return boost::recursive_wrapper<VNode>(VNode(cmd.get()));
}
VOption operator()(const ERM::TSymbol & cmd) const
{
if(cmd.symModifier.empty())
return VSymbol(cmd.sym);
else
return boost::recursive_wrapper<VNode>(VNode(cmd));
}
VOption operator()(const char & cmd) const
{
return TLiteral(cmd);
}
VOption operator()(const double & cmd) const
{
return TLiteral(cmd);
}
VOption operator()(const int & cmd) const
{
return TLiteral(cmd);
}
VOption operator()(const ERM::Tcommand & cmd) const
{
return cmd;
}
VOption operator()(const ERM::TStringConstant & cmd) const
{
return TLiteral(cmd.str);
}
};
return std::visit(OptionConverterVisitor(), tvo);
}
VNode::VNode( const ERM::TVExp & exp )
{
for(int i=0; i<exp.children.size(); ++i)
{
children.push_back(convertToVOption(exp.children[i]));
}
processModifierList(exp.modifier, false);
}
VNode::VNode( const VOption & first, const VOptionList & rest ) /*merges given arguments into [a, rest] */
{
setVnode(first, rest);
}
VNode::VNode( const VOptionList & cdren ) : children(cdren)
{}
VNode::VNode( const ERM::TSymbol & sym )
{
children.car() = VSymbol(sym.sym);
processModifierList(sym.symModifier, true);
}
void VNode::setVnode( const VOption & first, const VOptionList & rest )
{
children.car() = first;
children.cdr() = rest;
}
void VNode::processModifierList( const std::vector<TVModifier> & modifierList, bool asSymbol )
{
for(int g=0; g<modifierList.size(); ++g)
{
if(asSymbol)
{
children.resize(children.size()+1);
for(auto i=children.size()-1; i >0; i--)
{
children[i] = children[i-1];
}
}
else
{
children.cdr() = VNode(children);
}
if(modifierList[g] == "`")
{
children.car() = VSymbol("`");
}
else if(modifierList[g] == ",!")
{
children.car() = VSymbol("comma-unlist");
}
else if(modifierList[g] == ",")
{
children.car() = VSymbol(",");
}
else if(modifierList[g] == "#'")
{
children.car() = VSymbol("get-func");
}
else if(modifierList[g] == "'")
{
children.car() = VSymbol("'");
}
else
throw EInterpreterError("Incorrect value of modifier!");
}
}
VermTreeIterator & VermTreeIterator::operator=( const VOption & opt )
{
switch (state)
{
case CAR:
if(parent->size() <= basePos)
parent->push_back(opt);
else
(*parent)[basePos] = opt;
break;
case NORM:
parent->resize(basePos+1);
(*parent)[basePos] = opt;
break;
default://should never happen
break;
}
return *this;
}
VermTreeIterator & VermTreeIterator::operator=( const std::vector<VOption> & opt )
{
switch (state)
{
case CAR:
//TODO: implement me
break;
case NORM:
parent->resize(basePos+1);
parent->insert(parent->begin()+basePos, opt.begin(), opt.end());
break;
default://should never happen
break;
}
return *this;
}
VermTreeIterator & VermTreeIterator::operator=( const VOptionList & opt )
{
return *this = opt;
}
VOption & VermTreeIterator::getAsItem()
{
if(state == CAR)
return (*parent)[basePos];
else
throw EInterpreterError("iterator is not in car state, cannot get as list");
}
size_t VermTreeIterator::size() const
{
return parent->size() - basePos;
}
VERMInterpreter::VOptionList VermTreeIterator::getAsList()
{
VOptionList ret;
for(int g = basePos; g<parent->size(); ++g)
{
ret.push_back((*parent)[g]);
}
return ret;
}
VermTreeIterator VOptionList::cdr()
{
VermTreeIterator ret(*this);
ret.basePos = 1;
return ret;
}
VermTreeIterator VOptionList::car()
{
VermTreeIterator ret(*this);
ret.state = VermTreeIterator::CAR;
return ret;
}
}