public override Expression.EvalResult Execute(MakeState s)
{
// run initializer
Expression.EvalResult ret = init.Execute(s);
if (ret.AsInt != 0)
{
return(ret);
}
while (true)
{
// check condition
if (test.Evaluate(s).AsInt == 0)
{
break;
}
// exec code
ret = code.Execute(s);
if (ret.AsInt != 0)
{
return(ret);
}
if (s.returns != null)
{
return(new Expression.EvalResult(0));
}
// run incrementer
incr.Execute(s);
}
return(new Expression.EvalResult(0));
}
public override Expression.EvalResult Execute(MakeState s)
{
Expression.EvalResult e = new Expression.EvalResult(val);
s.SetDefine(tok_name, e, assignop);
if (export)
{
ExportDef(tok_name, s);
}
return(new Expression.EvalResult(0));
}
internal static void ExportDef(string tag, MakeState s)
{
Expression.EvalResult e = s.GetDefine(tag);
MakeState cur_s = s.parent;
while (cur_s != null)
{
cur_s.SetDefine(tag, e);
cur_s = cur_s.parent;
}
}
public override Expression.EvalResult Execute(MakeState s)
{
LabelExpression le = new LabelExpression {
val = val
};
Expression.EvalResult e = le.Evaluate(s);
s.SetDefine(tok_name, e, assignop);
if (export)
{
ExportDef(tok_name, s);
}
return(new Expression.EvalResult(0));
}
public override Expression.EvalResult Execute(MakeState s)
{
Expression.EvalResult e = enumeration.Evaluate(s);
switch (e.Type)
{
case Expression.EvalResult.ResultType.Array:
foreach (Expression.EvalResult i in e.arrval)
{
//MakeState cur_s = s.Clone();
var cur_s = s;
cur_s.SetLocalDefine(val, i);
Expression.EvalResult ret = code.Execute(cur_s);
if (ret.AsInt != 0)
{
return(ret);
}
if (cur_s.returns != null)
{
s.returns = cur_s.returns;
return(new Expression.EvalResult(0));
}
}
return(new Expression.EvalResult(0));
case Expression.EvalResult.ResultType.Object:
// take a snapsnot now so we can still do updating from script code
List <string> objssk = new List <string>(e.objval.Keys);
foreach (var k in objssk)
{
var cur_s = s;
cur_s.SetLocalDefine(val, new Expression.EvalResult(k));
Expression.EvalResult ret = code.Execute(cur_s);
if (ret.AsInt != 0)
{
return(ret);
}
if (cur_s.returns != null)
{
s.returns = cur_s.returns;
return(new Expression.EvalResult(0));
}
}
return(new Expression.EvalResult(0));
default:
throw new ParseException("foreach: does not evaluate to array or object", sline, scol);
}
}
public void SetDefine(string tag, Expression.EvalResult e, bool export)
{
if (export == false)
{
SetLocalDefine(tag, e);
}
else
{
MakeState s = this;
while (s != null)
{
s.SetDefine(tag, e);
s = s.parent;
}
}
}
public override Expression.EvalResult Execute(MakeState s)
{
if (list != null)
{
foreach (Statement st in list)
{
Expression.EvalResult er = st.Execute(s);
if (!(st is ExpressionStatement) && er.AsInt != 0)
{
return(er);
}
if (s.returns != null)
{
return(s.returns);
}
}
}
return(new Expression.EvalResult(0));
}
public override Expression.EvalResult Execute(MakeState s)
{
if (s.IsDefined(v) == false)
{
throw new Exception("export: variable " + v + " is not defined in this scope");
}
Expression.EvalResult e = s.GetDefine(v);
s.SetDefine(v, e);
MakeState cur_s = s.parent;
while (cur_s != null)
{
cur_s.SetDefine(v, e);
cur_s = cur_s.parent;
}
return(new Expression.EvalResult(0));
}
private Expression.EvalResult follow_chain(Expression.EvalResult o,
List <Expression> chain, int cur_idx, int max_idx,
MakeState s)
{
var next_member = chain[cur_idx];
Expression.EvalResult next_result = null;
if (next_member is LabelIndexedExpression)
{
var lie = next_member as LabelIndexedExpression;
if (o.Type != Expression.EvalResult.ResultType.Array)
{
throw new Exception();
}
next_result = o.arrval[(int)lie.index.Evaluate(s).AsInt];
}
else if (next_member is LabelMemberExpression)
{
var lme = next_member as LabelMemberExpression;
if (o.Type != Expression.EvalResult.ResultType.Object)
{
throw new Exception();
}
next_result = o.objval[((LabelExpression)lme.member).val];
}
else
{
throw new NotImplementedException();
}
cur_idx++;
if (cur_idx == max_idx)
{
return(next_result);
}
return(follow_chain(next_result, chain, cur_idx, max_idx, s));
}
public void SetDefine(string tag, Expression.EvalResult e, Tokens assignop)
{
switch (assignop)
{
case Tokens.ASSIGN:
local_defs[tag] = e;
break;
case Tokens.ASSIGNIF:
if (!defs.ContainsKey(tag) && !local_defs.ContainsKey(tag))
{
local_defs[tag] = e;
}
break;
case Tokens.APPEND:
if (local_defs.ContainsKey(tag))
{
Expression.EvalResult src = local_defs[tag];
Expression append = new Expression {
a = src, b = e, op = Tokens.PLUS
};
local_defs[tag] = append.Evaluate(this);
}
else if (defs.ContainsKey(tag))
{
Expression.EvalResult src = defs[tag];
Expression append = new Expression {
a = src, b = e, op = Tokens.PLUS
};
local_defs[tag] = append.Evaluate(this);
}
else
{
defs[tag] = e;
}
break;
}
}
public override Expression.EvalResult Execute(MakeState s)
{
// if this is a conditional assign, we don't need to evaluate the RHS
// if the LHS is already assigned
if (assignop == Tokens.ASSIGNIF & tok_name is LabelExpression)
{
var tn = ((LabelExpression)tok_name).val;
if (s.IsDefined(tn))
{
return(new Expression.EvalResult(0));
}
}
Expression.EvalResult e = val.Evaluate(s);
if (tok_name is LabelExpression)
{
var tn = ((LabelExpression)tok_name).val;
s.SetDefine(tn, e, assignop);
if (export)
{
ExportDef(tn, s);
}
}
else if (tok_name is LabelMemberExpression)
{
// left-most member must be a define
var lme = tok_name as LabelMemberExpression;
if (!(lme.label is LabelExpression))
{
throw new Exception("unable to assign to " + tok_name.ToString());
}
var o = s.GetDefine(((LabelExpression)lme.label).val);
// Now iterate through the various members, looking for
// what to set
Expression cur_member_lval = lme.member;
while (true)
{
if (cur_member_lval is LabelExpression)
{
// we've reached the end of the chain
break;
}
else if (cur_member_lval is LabelMemberExpression)
{
var new_lme = cur_member_lval as LabelMemberExpression;
if (!(new_lme.label is LabelExpression))
{
throw new Exception("unable to assign to " + tok_name.ToString());
}
lme = new_lme;
cur_member_lval = lme.member;
if (o.Type != Expression.EvalResult.ResultType.Object)
{
throw new Exception();
}
o = o.objval[((LabelExpression)lme.label).val];
}
else
{
throw new NotImplementedException();
}
}
string member_name = ((LabelExpression)cur_member_lval).val;
o.objval[member_name] = e;
}
else if (tok_name is LabelIndexedExpression)
{
var chain = get_chain(tok_name);
// left-most member must be a define
var lme = chain[0];
if (!(lme is LabelExpression))
{
throw new Exception("unable to assign to " + tok_name.ToString());
}
var o = s.GetDefine(((LabelExpression)lme).val);
// Now iterate through the various members, looking for
// what to set
o = follow_chain(o, chain, 1, chain.Count - 1, s);
if (o.Type != Expression.EvalResult.ResultType.Array)
{
throw new Exception("unable to assign to " + tok_name.ToString());
}
var idx = ((LabelIndexedExpression)tok_name).index.Evaluate(s).AsInt;
// increase the array size as appropriate
if (idx >= o.arrval.Count)
{
o.arrval.Capacity = (int)idx * 3 / 2;
while (idx >= o.arrval.Count)
{
o.arrval.Add(new Expression.EvalResult {
Type = Expression.EvalResult.ResultType.Null
});
}
}
o.arrval[(int)idx] = e;
}
else
{
throw new NotImplementedException();
}
return(new Expression.EvalResult(0));
}
public void SetLocalDefine(string tag, Expression.EvalResult e)
{
local_defs[tag] = e;
}
public void SetDefine(string tag, Expression.EvalResult e)
{
defs[tag] = e;
}
