public override EvalResult Evaluate(MakeState s)
{
var mangled_name = Mangle(s, out var args_to_pass);
if (s.funcs.ContainsKey(mangled_name))
{
// add these here because error messages for a function
// call should relate to the location the function is
// called rather than defined
s.fcall = this;
return(s.funcs[mangled_name].Run(s, args_to_pass));
}
/*List<string> mangle_all = MangleAll(s);
* foreach (var mangled_name in mangle_all)
* {
* if (s.funcs.ContainsKey(mangled_name))
* {
* List<EvalResult> args_to_pass = new List<EvalResult>();
* foreach (Expression arg in args)
* args_to_pass.Add(arg.Evaluate(s));
* return s.funcs[mangled_name].Run(s, args_to_pass);
* }
* }*/
throw new Statement.SyntaxException("unable to find function " + Mangle(s, out var resultTypes), this);
}
public override EvalResult Evaluate(MakeState s)
{
FunctionStatement fs = new FunctionStatement();
fs.name = name;
fs.args = new List <FunctionStatement.FunctionArg>();
foreach (var arg in args)
{
fs.args.Add(new FunctionStatement.FunctionArg {
argtype = arg
});
}
var mangled = fs.Mangle();
if (s.funcs.ContainsKey(mangled))
{
fs.args = s.funcs[mangled].args;
fs.code = s.funcs[mangled].code;
return(new EvalResult(fs));
}
else
{
return(new EvalResult());
}
}
public override EvalResult Evaluate(MakeState s)
{
if (s.IsDefined(val))
{
return(s.GetDefine(val));
}
else if (s.funcs.ContainsKey(val))
{
return new EvalResult
{
Type = EvalResult.ResultType.Function,
funcval = new FunctionStatement
{
name = val
}
}
}
;
else
{
return new EvalResult()
{
Type = EvalResult.ResultType.Undefined, strval = val, orig_expr = this
}
};
}
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)
{
if (name != null)
{
var arg_types = new List <Expression.EvalResult.ResultType>();
foreach (var arg in args)
{
arg_types.Add(arg.argtype);
}
var mangled_names = FuncCall.MangleAll(name, arg_types, s);
foreach (var mangledname in mangled_names)
{
s.funcs[mangledname] = this;
if (export)
{
MakeState cur_s = s.parent;
while (cur_s != null)
{
cur_s.funcs[mangledname] = this;
cur_s = cur_s.parent;
}
}
}
}
return(new Expression.EvalResult(0));
}
public virtual MakeState Clone()
{
MakeState other = new MakeState();
CloneTo(other);
return(other);
}
public override EvalResult Evaluate(MakeState s)
{
FunctionStatement fs = new FunctionStatement();
fs.name = null;
fs.args = args;
fs.code = code;
return(new EvalResult(fs));
}
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));
}
public override EvalResult Evaluate(MakeState s)
{
Dictionary <string, EvalResult> ret = new Dictionary <string, EvalResult>();
foreach (ObjDef o in val)
{
ret[o.name] = o.val.Evaluate(s);
}
return(new EvalResult(ret));
}
public override EvalResult Evaluate(MakeState s)
{
List <EvalResult> ret = new List <EvalResult>();
foreach (Expression e in val)
{
ret.Add(e.Evaluate(s));
}
return(new EvalResult(ret));
}
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 string Mangle(MakeState s, out List <Expression.EvalResult> ers)
{
ers = new List <EvalResult>();
var ert = new List <EvalResult.ResultType>();
foreach (var arg in args)
{
var er = arg.Evaluate(s);
ers.Add(er);
ert.Add(er.Type);
}
return(Mangle(target, ert));
}
public override Expression.EvalResult Execute(MakeState s)
{
var f = include_file.Evaluate(s).strval;
var saved_this = s.GetDefine("THIS");
MakeState new_s = s.Clone();
var ret = TymakeLib.ExecuteFile(f, new_s);
s.SetDefine("THIS", saved_this, true);
return(ret);
}
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 override EvalResult Evaluate(MakeState s)
{
/* First, parse variables in the shell command */
StringBuilder sb = new StringBuilder();
int i = 0;
while (i < val.Length)
{
if (val[i] == '\\' && i < (val.Length - 1))
{
sb.Append(val[i++]);
sb.Append(val[i++]);
}
else if (val[i] == '$')
{
/* Now try and match the largest possible variable we can */
int j = i + 1;
string match = null;
while (j < (val.Length) && val[j] != '$')
{
string test = val.Substring(i + 1, j - i);
if (s.IsDefined(test))
{
match = test;
}
j++;
}
if (match != null)
{
sb.Append(s.GetDefine(match).strval);
i++;
i += match.Length;
}
else
{
sb.Append(val[i++]);
}
}
else
{
sb.Append(val[i++]);
}
}
return(new EvalResult(sb.ToString()));
}
public void Merge(MakeState other)
{
foreach (KeyValuePair <string, Expression.EvalResult> kvp in other.defs)
{
this.defs[kvp.Key] = kvp.Value;
}
foreach (KeyValuePair <string, Expression.EvalResult> kvp in other.local_defs)
{
this.local_defs[kvp.Key] = kvp.Value;
}
foreach (KeyValuePair <string, FunctionStatement> kvp in other.funcs)
{
this.funcs[kvp.Key] = kvp.Value;
}
}
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 (test.Evaluate(s).AsInt == 0)
{
if (else_block != null)
{
return(else_block.Execute(s));
}
}
else
{
if (if_block != null)
{
return(if_block.Execute(s));
}
}
return(new Expression.EvalResult(0));
}
public virtual Expression.EvalResult Run(MakeState s, List <Expression.EvalResult> passed_args)
{
MakeState new_s = s.Clone();
new_s.PromoteLocalDefines();
new_s.ClearLocalDefines();
for (int i = 0; i < args.Count; i++)
{
if (args[i].argtype == Expression.EvalResult.ResultType.Function)
{
FunctionStatement fs = new FunctionStatement();
var ofs = passed_args[i].funcval;
fs.name = args[i].name;
fs.args = ofs.args;
fs.code = ofs.code;
var arg_types = new List <Expression.EvalResult.ResultType>();
foreach (var arg in fs.args)
{
arg_types.Add(arg.argtype);
}
var mangledname = FuncCall.Mangle(fs.name, arg_types);
/* var mangled_names = FuncCall.MangleAll(fs.name, arg_types, s);
*
* foreach(var mangledname in mangled_names) */
new_s.funcs[mangledname] = fs;
}
else
{
new_s.SetLocalDefine(args[i].name, passed_args[i]);
}
}
code.Execute(new_s);
if (new_s.returns != null)
{
return(new_s.returns);
}
return(new Expression.EvalResult());
}
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));
}
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));
}
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 override EvalResult Evaluate(MakeState s)
{
EvalResult elabel = label.Evaluate(s);
EvalResult eindex = index.Evaluate(s);
switch (elabel.Type)
{
case EvalResult.ResultType.String:
return(new EvalResult(new string(elabel.strval[(int)eindex.AsInt], 1)));
case EvalResult.ResultType.Array:
{
var idx = eindex.AsInt;
if (idx < 0 || idx >= elabel.arrval.Count)
{
return new EvalResult {
Type = EvalResult.ResultType.Null
}
}
;
else
{
return(elabel.arrval[(int)idx]);
}
}
case EvalResult.ResultType.Object:
return(elabel.objval[eindex.strval]);
case EvalResult.ResultType.Undefined:
throw new Statement.SyntaxException("attempt to access array index of undefined object " + elabel.strval, this);
default:
throw new Statement.SyntaxException("indexing cannot be applied to object of type: " + elabel.Type.ToString(), this);
}
}
protected void CloneTo(MakeState other)
{
foreach (KeyValuePair <string, Expression.EvalResult> kvp in defs)
{
other.defs[kvp.Key] = kvp.Value;
}
foreach (KeyValuePair <string, Expression.EvalResult> kvp in local_defs)
{
other.local_defs[kvp.Key] = kvp.Value;
}
foreach (KeyValuePair <string, FunctionStatement> kvp in funcs)
{
other.funcs[kvp.Key] = kvp.Value;
}
other.parent = this;
other.search_paths = new List <string>(search_paths);
other.stdin = stdin;
other.stdout = stdout;
other.stderr = stderr;
}
public abstract Expression.EvalResult Execute(MakeState s);
public override Expression.EvalResult Execute(MakeState s)
{
throw new NotImplementedException();
}
public override Expression.EvalResult Execute(MakeState s)
{
return(expr.Evaluate(s));
}
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 override Expression.EvalResult Execute(MakeState s)
{
s.returns = v.Evaluate(s);
return(new Expression.EvalResult(0));
}