public override void Assign(object val, NameEnv env)
{
// Disallow "[] = l", "[], a = l, l", "[[]] = [l]", etc
if (items.Length == 0)
{
throw Ops.SyntaxError("can't assign to " + EmptySequenceString, "<unknown>",
start.line, start.column, null, 0, IronPython.Hosting.Severity.Error);
}
IEnumerator ie = Ops.GetEnumerator(val);
int leftCount = items.Length;
object[] values = new object[leftCount];
int rightCount = Ops.GetEnumeratorValues(ie, ref values);
if (leftCount != rightCount)
{
throw Ops.ValueErrorForUnpackMismatch(leftCount, rightCount);
}
for (int i = 0; i < leftCount; i++)
{
items[i].Assign(values[i], env);
}
}
public override object Evaluate(NameEnv env)
{
object t = target.Evaluate(env);
object i = index.Evaluate(env);
return(Ops.GetIndex(t, i));
}
public override void Assign(object val, NameEnv env)
{
object t = target.Evaluate(env);
object i = index.Evaluate(env);
Ops.SetIndex(t, i, val);
}
public override object Evaluate(NameEnv env)
{
object e1 = slStart.Evaluate(env);
object e2 = slStop.Evaluate(env);
object e3 = slStep.Evaluate(env);
return(Ops.MakeSlice(e1, e2, e3));
}
public override object Evaluate(NameEnv env)
{
//!!! not right for compare
object l = left.Evaluate(env);
object r = right.Evaluate(env);
return(op.Evaluate(l, r));
}
public static object[] Evaluate(Expr[] items, NameEnv env)
{
object[] ret = new object[items.Length];
for (int i = 0; i < items.Length; i++)
{
ret[i] = items[i].Evaluate(env);
}
return(ret);
}
public override object Evaluate(NameEnv env)
{
IDictionary <object, object> dict = Ops.MakeDict(items.Length);
foreach (SliceExpr s in items)
{
dict[s.slStart.Evaluate(env)] = s.slStop.Evaluate(env);
}
return(dict);
}
public override object Execute(NameEnv env)
{
object v = rhs.Evaluate(env);
foreach (Expr e in lhs)
{
e.Assign(v, env);
}
return(NextStmt);
}
public override object Evaluate(NameEnv env)
{
object ret = left.Evaluate(env);
if (!Ops.IsTrue(ret))
{
return(right.Evaluate(env));
}
else
{
return(ret);
}
}
public override object Execute(NameEnv env)
{
object ret = Stmt.NextStmt;
foreach (Stmt stmt in stmts)
{
ret = stmt.Execute(env);
if (ret != Stmt.NextStmt)
{
break;
}
}
return(ret);
}
public override object Execute(NameEnv env)
{
Console.Out.Write("print> ");
foreach (Expr e in exprs)
{
object val = e.Evaluate(env);
Ops.PrintComma(env.globals.SystemState, val);
}
if (!trailingComma)
{
Ops.PrintNewline(env.globals.SystemState);
}
return(NextStmt);
}
public override object Execute(NameEnv env)
{
foreach (IfStmtTest t in tests)
{
object val = t.test.Evaluate(env);
if (Ops.IsTrue(val))
{
return(t.body.Execute(env));
}
}
if (elseStmt != null)
{
return(elseStmt.Execute(env));
}
return(NextStmt);
}
public override object Execute(NameEnv env)
{
object ret = NextStmt;
while (Ops.IsTrue(test.Evaluate(env)))
{
ret = body.Execute(env);
if (ret != NextStmt)
{
break;
}
}
return(ret);
// if (else_ != null) {
// else_.exec(env);
// }
}
public override object Execute(NameEnv env)
{
object ret = Stmt.NextStmt;
IEnumerator i = Ops.GetEnumerator(list.Evaluate(env));
while (i.MoveNext())
{
lhs.Assign(i.Current, env);
ret = body.Execute(env);
if (ret != NextStmt)
{
return(ret);
}
}
return(ret);
// if (else_ != null) {
// else_.exec(env);
// }
}
public override object Evaluate(NameEnv env)
{
object callee = target.Evaluate(env);
object[] cargs = new object[args.Length];
int index = 0;
foreach (Arg arg in args)
{
if (arg.name != null)
{
throw new NotImplementedException("keywords");
}
cargs[index++] = arg.expr.Evaluate(env);
}
switch (cargs.Length)
{
case 0: return(Ops.Call(callee));
default: return(Ops.Call(callee, cargs));
}
}
public override object Evaluate(NameEnv env)
{
return(Ops.Repr(expr.Evaluate(env)));
}
public override object Execute(NameEnv env)
{
return(NextStmt);
}
public override object Execute(NameEnv env)
{
return(expr.Evaluate(env));
}
public override object Evaluate(NameEnv env)
{
object t = target.Evaluate(env);
return(Ops.GetAttr(env.globals, t, SymbolTable.StringToId(name.GetString())));
}
public override object Execute(NameEnv env)
{
Ops.ImportFrom(env.globals, root.MakeString(), Name.ToStrings(names));
return(NextStmt);
}
public override void Assign(object val, NameEnv env)
{
object t = target.Evaluate(env);
Ops.SetAttr(env.globals, t, SymbolTable.StringToId(name.GetString()), val);
}
public virtual void Assign(object val, NameEnv env)
{
throw new NotImplementedException("Assign: " + this);
}
public override void Assign(object val, NameEnv env)
{
env.Set(name.GetString(), val);
}
public override object Evaluate(NameEnv env)
{
return(Ops.MakeList(Evaluate(items, env)));
}
public virtual object Execute(NameEnv env)
{
throw new NotImplementedException("execute: " + this);
}
public override void Assign(object val, NameEnv env)
{
expr.Assign(val, env);
}
public override object Execute(NameEnv env)
{
expr.Evaluate(env);
//!!! print it if in the right env
return(NextStmt);
}
public override object Evaluate(NameEnv env)
{
return(value);
}
public override object Evaluate(NameEnv env)
{
return(env.Get(name.GetString()));
}
public override object Evaluate(NameEnv env)
{
return(func.MakeFunction(env));
}