public void CompileAndEvaluateComplexListExpression() { Parser parser = new Parser("[1, 2, [a, b], 'spam']"); BindingEnvironment environment = new BindingEnvironment(); environment.SetValue("a", 1); environment.SetValue("b", 2); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ListExpression)); Assert.IsFalse(((ListExpression)expression).IsReadOnly); object result = expression.Evaluate(environment); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(IList)); IList list = (IList)result; Assert.AreEqual(4, list.Count); Assert.AreEqual(1, list[0]); Assert.AreEqual(2, list[1]); Assert.IsNotNull(list[2]); Assert.IsInstanceOfType(list[2], typeof(IList)); Assert.AreEqual("spam", list[3]); IList list2 = (IList)list[2]; Assert.IsNotNull(list2); Assert.AreEqual(2, list2.Count); Assert.AreEqual(1, list2[0]); Assert.AreEqual(2, list2[1]); }
public void CompileAndEvaluateAddExpression() { Parser parser = new Parser("1+2"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(BinaryOperatorExpression)); Assert.AreEqual(3, expression.Evaluate(new BindingEnvironment())); }
public void EvaluateSetVar() { Parser parser = new Parser(new StreamReader("setvar.py")); ICommand command = parser.CompileCommandList(); Machine machine = new Machine(); command.Execute(machine.Environment); Assert.AreEqual(1, machine.Environment.GetValue("a")); }
public void CompileAndEvaluateComplexExpressionWithParenthesis() { Parser parser = new Parser("(6+3)/(1+2)"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(BinaryOperatorExpression)); Assert.AreEqual(3, expression.Evaluate(new BindingEnvironment())); Assert.IsNull(parser.CompileExpression()); }
public void EvaluateImportFrom() { Parser parser = new Parser(new StreamReader("importfrom.py")); ICommand command = parser.CompileCommandList(); Machine machine = new Machine(); command.Execute(machine.Environment); Assert.AreEqual(1, machine.Environment.GetValue("one")); Assert.AreEqual(2, machine.Environment.GetValue("two")); }
private static bool ProcessFiles(string[] args, Machine machine) { bool hasfiles = false; foreach (var arg in args) { if (!arg.EndsWith(".py")) continue; hasfiles = true; Parser parser = new Parser(new StreamReader(arg)); ICommand command = parser.CompileCommandList(); command.Execute(machine.Environment); } return hasfiles; }
public void EvaluateImport() { Parser parser = new Parser(new StreamReader("import.py")); ICommand command = parser.CompileCommandList(); Machine machine = new Machine(); command.Execute(machine.Environment); object mod = machine.Environment.GetValue("setvar"); Assert.IsNotNull(mod); Assert.IsInstanceOfType(mod, typeof(IValues)); IValues modenv = (IValues)mod; Assert.AreEqual(1, modenv.GetValue("a")); }
public object Apply(IContext context, IList<object> arguments, IDictionary<string, object> namedArguments) { int nargs = arguments == null ? 0 : arguments.Count; if (nargs == 0) throw new TypeError("eval expected at least 1 arguments, got 0"); // TODO implement bytes or code object if (!(arguments[0] is string)) throw new TypeError("eval() arg 1 must be a string, bytes or code object"); Parser parser = new Parser((string)arguments[0]); IExpression expression = parser.CompileExpression(); if (expression == null) return null; return expression.Evaluate(context); }
public void CompileAndEvaluateArrayAsListExpression() { Parser parser = new Parser("[1,2,'spam']"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ListExpression)); Assert.IsFalse(((ListExpression)expression).IsReadOnly); object result = expression.Evaluate(new BindingEnvironment()); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(IList)); IList list = (IList)result; Assert.AreEqual(3, list.Count); Assert.AreEqual(1, list[0]); Assert.AreEqual(2, list[1]); Assert.AreEqual("spam", list[2]); }
public object Apply(IContext context, IList<object> arguments, IDictionary<string, object> namedArguments) { int nargs = arguments == null ? 0 : arguments.Count; if (nargs == 0) throw new TypeError("exec expected at least 1 arguments, got 0"); // TODO implement bytes or code object if (!(arguments[0] is string)) throw new TypeError("exec() arg 1 must be a string, bytes or code object"); Parser parser = new Parser((string)arguments[0]); ICommand command = parser.CompileCommandList(); if (command == null) return null; command.Execute(context); return null; }
public static void Main(string[] args) { PythonSharp.Machine machine = new PythonSharp.Machine(); if (args != null && args.Length > 0) if (ProcessFiles(args, machine)) return; PrintIntro(); Parser parser = new Parser(System.Console.In); while (true) { try { ICommand command = parser.CompileCommand(); if (command == null) break; if (command is ExpressionCommand) { IExpression expr = ((ExpressionCommand)command).Expression; var value = expr.Evaluate(machine.Environment); if (value != null) Console.WriteLine(ValueUtilities.AsPrintString(value)); } else command.Execute(machine.Environment); } catch (Exception ex) { System.Console.WriteLine(ex.Message); } } }
public static Module LoadModule(string name, IContext context) { Module module = null; if (TypeUtilities.IsNamespace(name)) { var types = TypeUtilities.GetTypesByNamespace(name); module = new Module(context.GlobalContext); foreach (var type in types) module.SetValue(type.Name, type); } else { string filename = ModuleUtilities.ModuleFileName(name); if (filename == null) throw new ImportError(string.Format("No module named {0}", name)); if (modules.ContainsKey(filename) && modules[filename].GlobalContext == context.GlobalContext) return modules[filename]; Parser parser = new Parser(new StreamReader(filename)); ICommand command = parser.CompileCommandList(); module = new Module(context.GlobalContext); string doc = CommandUtilities.GetDocString(command); command.Execute(module); module.SetValue("__doc__", doc); modules[filename] = module; } return module; }
public void CompileImportCompositeName() { Parser parser = new Parser("from System.IO import *"); ICommand command = parser.CompileCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(ImportFromCommand)); ImportFromCommand impcmd = (ImportFromCommand)command; Assert.AreEqual("System.IO", impcmd.ModuleName); Assert.IsNull(impcmd.Names); }
public void CompileImportCommandWithDottedName() { Parser parser = new Parser("import PythonSharp.Language"); ICommand command = parser.CompileCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(ImportCommand)); ImportCommand impcmd = (ImportCommand)command; Assert.AreEqual("PythonSharp.Language", impcmd.ModuleName); }
public void CompileImportCommand() { Parser parser = new Parser("import module"); ICommand command = parser.CompileCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(ImportCommand)); ImportCommand impcmd = (ImportCommand)command; Assert.AreEqual("module", impcmd.ModuleName); }
public void CompileIfCommandWithSingleThenCommandSameLine() { Parser parser = new Parser("if a: print(a)"); ICommand cmd = parser.CompileCommand(); Assert.IsNotNull(cmd); Assert.IsInstanceOfType(cmd, typeof(IfCommand)); IfCommand ifcmd = (IfCommand)cmd; Assert.IsNotNull(ifcmd.Condition); Assert.IsInstanceOfType(ifcmd.Condition, typeof(NameExpression)); Assert.IsNotNull(ifcmd.ThenCommand); Assert.IsInstanceOfType(ifcmd.ThenCommand, typeof(ExpressionCommand)); Assert.IsNull(parser.CompileCommand()); }
public void CompileIfCommandWithElifCommand() { Parser parser = new Parser("if a:\r\n print(a)\r\nelif b:\r\n print(a)\r\n print(b)"); ICommand cmd = parser.CompileCommand(); Assert.IsNotNull(cmd); Assert.IsInstanceOfType(cmd, typeof(IfCommand)); IfCommand ifcmd = (IfCommand)cmd; Assert.IsNotNull(ifcmd.Condition); Assert.IsInstanceOfType(ifcmd.Condition, typeof(NameExpression)); Assert.IsNotNull(ifcmd.ThenCommand); Assert.IsNotNull(ifcmd.ElseCommand); Assert.IsInstanceOfType(ifcmd.ElseCommand, typeof(IfCommand)); IfCommand elifcmd = (IfCommand)ifcmd.ElseCommand; Assert.IsNotNull(elifcmd.ThenCommand); Assert.IsInstanceOfType(elifcmd.ThenCommand, typeof(CompositeCommand)); Assert.IsNull(elifcmd.ElseCommand); Assert.IsNull(parser.CompileCommand()); }
public void CompileEmptyPrintFunction() { Parser parser = new Parser("print()"); ICommand command = parser.CompileCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(ExpressionCommand)); var exprcmd = (ExpressionCommand)command; Assert.IsNotNull(exprcmd.Expression); Assert.IsInstanceOfType(exprcmd.Expression, typeof(CallExpression)); var callexpr = (CallExpression)exprcmd.Expression; Assert.IsNotNull(callexpr.TargetExpression); Assert.IsInstanceOfType(callexpr.TargetExpression, typeof(NameExpression)); Assert.IsNull(callexpr.ArgumentExpressions); }
public void CompileExpressionList() { Parser parser = new Parser("a, b"); IList<IExpression> expressions = parser.CompileExpressionList(); Assert.IsNotNull(expressions); Assert.AreEqual(2, expressions.Count); Assert.IsInstanceOfType(expressions[0], typeof(NameExpression)); Assert.IsInstanceOfType(expressions[1], typeof(NameExpression)); }
public void CompileExpressionCommandWithName() { Parser parser = new Parser("a+2"); BindingEnvironment environment = new BindingEnvironment(); environment.SetValue("a", 1); ICommand command = parser.CompileCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(ExpressionCommand)); command.Execute(environment); ExpressionCommand exprcommand = (ExpressionCommand)command; Assert.IsNotNull(exprcommand.Expression); Assert.AreEqual(3, exprcommand.Expression.Evaluate(environment)); }
public void CompileExpressionCommandWithList() { Parser parser = new Parser("1, 2"); ICommand command = parser.CompileCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(ExpressionCommand)); command.Execute(null); ExpressionCommand exprcommand = (ExpressionCommand)command; Assert.IsNotNull(exprcommand.Expression); Assert.IsInstanceOfType(exprcommand.Expression, typeof(ListExpression)); Assert.IsTrue(((ListExpression)exprcommand.Expression).IsReadOnly); }
public void CompileEmptyTupleExpression() { Parser parser = new Parser("()"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ListExpression)); var lexpr = (ListExpression)expression; Assert.IsTrue(lexpr.IsReadOnly); Assert.AreEqual(0, lexpr.Expressions.Count); }
public void CompileEmptyReturn() { Parser parser = new Parser("return"); ICommand command = parser.CompileCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(ReturnCommand)); var retcommand = (ReturnCommand)command; Assert.IsNull(retcommand.Expression); }
public void CompileContinueCommand() { Parser parser = new Parser("continue"); var result = parser.CompileCommand(); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(ContinueCommand)); Assert.IsNull(parser.CompileCommand()); }
public void CompileImportFromCommand() { Parser parser = new Parser("from module import a, b"); ICommand command = parser.CompileCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(ImportFromCommand)); ImportFromCommand impcmd = (ImportFromCommand)command; Assert.AreEqual("module", impcmd.ModuleName); Assert.IsNotNull(impcmd.Names); Assert.AreEqual(2, impcmd.Names.Count); Assert.AreEqual("a", impcmd.Names.First()); Assert.AreEqual("b", impcmd.Names.Skip(1).First()); }
public void CompileFalseAsBooleanConstantExpression() { Parser parser = new Parser("False"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ConstantExpression)); ConstantExpression cexpr = (ConstantExpression)expression; Assert.AreEqual(false, cexpr.Value); }
public void CompileIndexedExpression() { Parser parser = new Parser("'spam'[1]"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(IndexedExpression)); IndexedExpression iexpr = (IndexedExpression)expression; Assert.AreEqual("spam", iexpr.TargetExpression.Evaluate(null)); Assert.AreEqual(1, iexpr.IndexExpression.Evaluate(null)); }
public void CompileCompositeCommandUsingSemicolonAndSpaces() { Parser parser = new Parser("spam = \"bar\"; one = 1"); ICommand command = parser.CompileCommandList(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(CompositeCommand)); }
public void CompileExpressionCommand() { Parser parser = new Parser("1+2"); ICommand command = parser.CompileCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(ExpressionCommand)); command.Execute(null); ExpressionCommand exprcommand = (ExpressionCommand)command; Assert.IsNotNull(exprcommand.Expression); Assert.AreEqual(3, exprcommand.Expression.Evaluate(null)); }
public void CompileEmptyCommandList() { Parser parser = new Parser(string.Empty); ICommand command = parser.CompileCommandList(); Assert.IsNull(command); }