public static object Compile(ICallerContext context, string source, string filename, string kind, object flags, object dontInherit)
{
CompilerContext cc;
CompileFlags cflags = 0;
bool inheritContext = (dontInherit == null || Converter.ConvertToInt32(dontInherit) == 0);
if (inheritContext)
{
cc = context.CreateCompilerContext().CopyWithNewSourceFile(filename);
}
else
{
cc = new CompilerContext(filename);
}
if (flags != null)
{
cflags = (CompileFlags)Converter.ConvertToInt32(flags);
}
if ((cflags & ~(CompileFlags.CO_NESTED | CompileFlags.CO_GENERATOR_ALLOWED | CompileFlags.CO_FUTURE_DIVISION)) != 0)
{
throw Ops.ValueError("unrecognized flags");
}
cc.TrueDivision = inheritContext && context.TrueDivision || ((cflags & CompileFlags.CO_FUTURE_DIVISION) != 0);
Parser p = Parser.FromString(context.SystemState, cc, source);
FrameCode code;
if (kind == "exec")
{
Stmt s = p.ParseFileInput();
code = OutputGenerator.GenerateSnippet(cc, s, false);
}
else if (kind == "eval")
{
Expr e = p.ParseTestListAsExpression();
code = OutputGenerator.GenerateSnippet(cc, new ReturnStmt(e), true);
}
else if (kind == "single")
{
Stmt s = p.ParseSingleStatement();
code = OutputGenerator.GenerateSnippet(cc, s, true);
}
else
{
throw Ops.ValueError("compile() arg 3 must be 'exec' or 'eval' or 'single'");
}
return(new FunctionCode(code));
}
public static object ExecFile(ICallerContext context, object filename, object globals, object locals)
{
PythonModule mod = context.Module;
if (globals == null)
{
globals = mod.__dict__;
}
if (locals == null)
{
locals = globals;
}
string fname = Converter.ConvertToString(filename);
IDictionary <object, object> g = globals as IDictionary <object, object>;
if (g == null)
{
throw Ops.TypeError("execfile: arg 2 must be dictionary");
}
CompilerContext cc = context.CreateCompilerContext().CopyWithNewSourceFile(fname);
Parser p;
try {
p = Parser.FromFile(context.SystemState, cc);
} catch (UnauthorizedAccessException x) {
throw Ops.IOError(x.Message);
}
Stmt s = p.ParseFileInput();
IDictionary <object, object> l = locals as IDictionary <object, object>;
if (l == null)
{
throw Ops.TypeError("execfile: arg 3 must be dictionary");
}
Frame topFrame = new Frame(mod, g, l);
FrameCode code = OutputGenerator.GenerateSnippet(cc, s, false);
code.Run(topFrame);
return(null);
}
public static object Eval(ICallerContext context, string expression, IDictionary <object, object> globals, object locals)
{
if (locals != null && PythonOperator.IsMappingType(context, locals) == Ops.FALSE)
{
throw Ops.TypeError("locals must be mapping");
}
CompilerContext cc = context.CreateCompilerContext();
Parser p = Parser.FromString(context.SystemState, cc, expression.TrimStart(' ', '\t'));
Expr e = p.ParseTestListAsExpression();
PythonModule mod = new PythonModule("<eval>", globals, context.SystemState, null, context.ContextFlags);
if (Options.FastEval) //!!! experimenting with a HUGE (>100x) performance boost to simple evals
{
return(e.Evaluate(new NameEnv(mod, locals)));
}
else
{
Stmt s = new ReturnStmt(e);
FrameCode fc = OutputGenerator.GenerateSnippet(cc, s, false);
return(fc.Run(new Frame(mod, globals, locals)));
}
}
private static PythonModule LoadPythonSource(ICallerContext context, string name, PythonFile file, string filename)
{
CompilerContext cc = context.CreateCompilerContext().CopyWithNewSourceFile(filename);
Parser parser = Parser.FromString(context.SystemState, cc, file.Read());
return GenerateAndInitializeModule(context, cc, parser, name, filename);
}
private static PythonModule LoadPackageDirectory(ICallerContext context, string name, string filename)
{
string init = Path.Combine(filename, "__init__.py");
CompilerContext cc = context.CreateCompilerContext().CopyWithNewSourceFile(init);
Parser parser = Parser.FromFile(context.SystemState, cc);
Statement stmt = parser.ParseFileInput();
PythonModule module = OutputGenerator.GenerateModule(context.SystemState, cc, stmt, name);
module.Filename = init;
module.ModuleName = name;
return Importer.InitializeModule(init, module);
}
public static object LoadSource(ICallerContext context, string name, string pathname)
{
CompilerContext cc = context.CreateCompilerContext().CopyWithNewSourceFile(pathname);
Parser parser = Parser.FromFile(context.SystemState, cc);
return GenerateAndInitializeModule(context, cc, parser, name, pathname);
}
