public override ScriptCode/*!*/ MakeScriptCode(MSAst.Expression/*!*/ body, CompilerContext/*!*/ context, PythonAst/*!*/ ast) {
MSAst.Expression finalBody = Ast.Block(
new[] { _globalCtx },
Ast.Assign(
_globalCtx,
Ast.Call(typeof(PythonOps).GetMethod("CreateTopLevelCodeContext"),
_globalScope,
_language
)
),
body
);
PythonCompilerOptions pco = ((PythonCompilerOptions)context.Options);
string name = pco.ModuleName ?? "<unnamed>";
var lambda = Ast.Lambda<Func<Scope, LanguageContext, object>>(
finalBody,
name,
new[] { _globalScope, _language }
);
Func<Scope, LanguageContext, object> func;
// TODO: adaptive compilation should be eanbled
/*PythonContext pc = (PythonContext)context.SourceUnit.LanguageContext;
if (pc.ShouldInterpret(pco, context.SourceUnit)) {
func = CompilerHelpers.LightCompile(lambda);
} else*/ {
func = lambda.Compile(context.SourceUnit.EmitDebugSymbols);
}
return new PythonScriptCode(func, context.SourceUnit);
}
string Resolve(string variableName, PythonAst ast)
{
typeName = null;
this.variableName = variableName;
ast.Walk(this);
return typeName;
}
public override MSAst.LambdaExpression ReduceAst(PythonAst instance, string name) {
return Ast.Lambda<Func<CodeContext, FunctionCode, object>>(
AstUtils.Convert(instance.ReduceWorker(), typeof(object)),
name,
PythonAst._arrayFuncParams
);
}
public override ScriptCode/*!*/ MakeScriptCode(MSAst.Expression/*!*/ body, CompilerContext/*!*/ context, PythonAst/*!*/ ast, Dictionary<int, bool> handlerLocations, Dictionary<int, Dictionary<int, bool>> loopAndFinallyLocations) {
// create the CodeContext
PythonGlobal[] globalArray = new PythonGlobal[_globals.Count];
// now fill in the dictionary and create the array
foreach (var global in _globals) {
globalArray[global.Value.Index] = _globalVals[global.Key];
}
_array.Array = globalArray;
// finally build the funcion that's closed over the array and
string name = ((PythonCompilerOptions)context.Options).ModuleName ?? "<unnamed>";
var func = Ast.Lambda<Func<FunctionCode, object>>(
Ast.Block(
new[] { _globalArray, _globalContext },
Ast.Assign(_globalArray, Ast.Constant(globalArray)),
Ast.Assign(_globalContext, Ast.Constant(_context)),
Utils.Convert(body, typeof(object))
),
name,
new [] { AstGenerator._functionCode }
);
return new RuntimeScriptCode(context, func, ast, _context);
}
public override ScriptCode MakeScriptCode(PythonAst ast) {
PythonCompilerOptions pco = ast.CompilerContext.Options as PythonCompilerOptions;
// reduce to LightLambda then to Lambda
var code = (MSAst.Expression<LookupCompilationDelegate>)ast.Reduce().Reduce();
return new PythonSavableScriptCode(code, ast.SourceUnit, ast.GetNames(), pco.ModuleName);
}
public override ScriptCode/*!*/ MakeScriptCode(MSAst.Expression/*!*/ body, CompilerContext/*!*/ context, PythonAst/*!*/ ast) {
// create the CodeContext
PythonGlobal[] globalArray = new PythonGlobal[_globals.Count];
// now fill in the dictionary and create the array
foreach (var global in _globals) {
SymbolId globalName = SymbolTable.StringToId(global.Key);
globalArray[global.Value.Index] = _globalVals[globalName];
}
_array.Array = globalArray;
// finally build the funcion that's closed over the array and
string name = ((PythonCompilerOptions)context.Options).ModuleName ?? "<unnamed>";
var func = Ast.Lambda<Func<object>>(
Ast.Block(
new[] { _globalArray, _globalContext },
Ast.Assign(_globalArray, Ast.Constant(globalArray)),
Ast.Assign(_globalContext, Ast.Constant(_context)),
body
),
name,
new MSAst.ParameterExpression[0]
);
return new RuntimeScriptCode(context, func, ast, _context);
}
public DocumentationComment Parse(ProjectDom dom, string fileName, string content)
{
var document = new DocumentationComment(fileName);
var compilationUnit = new PythonCompilationUnit(fileName);
document.CompilationUnit = compilationUnit;
if (String.IsNullOrEmpty(content))
{
return(document);
}
var scriptSource = pythonEngine.CreateScriptSourceFromString(content, SourceCodeKind.File);
var context = new CompilerContext(HostingHelpers.GetSourceUnit(scriptSource),
compilerOptions, ErrorSink.Default);
var parser = IronPythonParserEngine.CreateParser(context, langOptions);
IronPythonAst ast = null;
try {
ast = parser.ParseFile(false);
} catch (SyntaxErrorException exc) {
// We could likely improve the error message
document.Errors.Add(new Error(exc.Line, exc.Column, exc.Message));
return(document);
}
walker.Reset();
ast.Walk(walker);
compilationUnit.Module = walker.Module;
compilationUnit.Build();
return(document);
}
public override ScriptCode/*!*/ MakeScriptCode(MSAst.Expression/*!*/ body, CompilerContext/*!*/ context, PythonAst/*!*/ ast) {
PythonCompilerOptions pco = ((PythonCompilerOptions)context.Options);
PythonContext pc = (PythonContext)context.SourceUnit.LanguageContext;
if (body is MSAst.ConstantExpression) {
object value = ((MSAst.ConstantExpression)body).Value;
return new PythonScriptCode(codeCtx => value, context.SourceUnit);
}
var lambda = Ast.Lambda<Func<CodeContext, object>>(
Utils.Convert(body, typeof(object)),
pco.ModuleName ?? "<unnamed>",
ArrayGlobalAllocator._globalContextList
);
Func<CodeContext, object> func;
if (pc.ShouldInterpret(pco, context.SourceUnit)) {
func = CompilerHelpers.LightCompile(lambda);
} else {
func = lambda.Compile(context.SourceUnit.EmitDebugSymbols);
}
return new PythonScriptCode(func, context.SourceUnit);
}
public override ScriptCode/*!*/ MakeScriptCode(MSAst.Expression/*!*/ lambda, CompilerContext/*!*/ compilerContext, PythonAst/*!*/ ast) {
PythonContext context = (PythonContext)compilerContext.SourceUnit.LanguageContext;
Type t = _typeGen.FinishType();
#if SILVERLIGHT
_finalType.Value = t;
#endif
// create the CodeContext for this optimized module
InitOptimizedCodeContext(t);
t.GetField("__global_context").SetValue(null, _context);
// publish the cached constants
foreach (var ci in _constants) {
FieldInfo fi = t.GetField(ci.Value.Field.Name);
fi.SetValue(null, ci.Key);
}
// publish all of the call site instances
foreach (SiteInfo si in _sites) {
FieldInfo fi = t.GetField(si.Field.Name);
fi.SetValue(null, CallSite.Create(si.DelegateType, si.Binder));
}
// initialize all of the cached symbol IDs.
ScriptingRuntimeHelpers.InitializeSymbols(t);
string name = ((PythonCompilerOptions)compilerContext.Options).ModuleName ?? "<unnamed>";
var func = Ast.Lambda<Func<object>>(lambda, name, new MSAst.ParameterExpression[0]);
return new RuntimeScriptCode(compilerContext, func, ast, _context);
}
public RuntimeScriptCode(PythonAst/*!*/ ast, CodeContext/*!*/ codeContext)
: base(ast) {
Debug.Assert(codeContext.GlobalScope.GetExtension(codeContext.LanguageContext.ContextId) != null);
Debug.Assert(ast.Type == typeof(MSAst.Expression<Func<FunctionCode, object>>));
_optimizedContext = codeContext;
}
public RuntimeScriptCode(CompilerContext/*!*/ context, MSAst.Expression<Func<object>>/*!*/ expression, PythonAst/*!*/ ast, CodeContext/*!*/ codeContext)
: base(context.SourceUnit) {
_code = expression;
_ast = ast;
_context = context;
_optimizedContext = codeContext;
}
public override ScriptCode/*!*/ MakeScriptCode(MSAst.Expression/*!*/ body, CompilerContext/*!*/ context, PythonAst/*!*/ ast) {
MSAst.ParameterExpression scope = Ast.Parameter(typeof(Scope), "$scope");
MSAst.ParameterExpression language = Ast.Parameter(typeof(LanguageContext), "$language ");
// finally build the funcion that's closed over the array and
var func = Ast.Lambda<Func<Scope, LanguageContext, object>>(
Ast.Block(
new[] { GlobalArray },
Ast.Assign(
GlobalArray,
Ast.Call(
null,
typeof(PythonOps).GetMethod("GetGlobalArray"),
scope
)
),
Utils.Convert(body, typeof(object))
),
((PythonCompilerOptions)context.Options).ModuleName,
new MSAst.ParameterExpression[] { scope, language }
);
PythonCompilerOptions pco = context.Options as PythonCompilerOptions;
return new SavableScriptCode(func, context.SourceUnit, GetNames(), pco.ModuleName);
}
public override LightLambdaExpression ReduceAst(PythonAst instance, string name) {
return Utils.LightLambda<LookupCompilationDelegate>(
typeof(object),
AstUtils.Convert(instance.ReduceWorker(), typeof(object)),
name,
PythonAst._arrayFuncParams
);
}
public RuntimeScriptCode(CompilerContext/*!*/ context, MSAst.Expression<Func<FunctionCode, object>>/*!*/ expression, PythonAst/*!*/ ast, CodeContext/*!*/ codeContext)
: base(context.SourceUnit) {
Debug.Assert(codeContext.GlobalScope.GetExtension(codeContext.LanguageContext.ContextId) != null);
_code = expression;
_ast = ast;
_context = context;
_optimizedContext = codeContext;
}
public override MSAst.LambdaExpression ReduceAst(PythonAst instance, string name) {
return Ast.Lambda<Func<FunctionCode, object>>(
Ast.Block(
new[] { PythonAst._globalArray, PythonAst._globalContext },
Ast.Assign(PythonAst._globalArray, instance.GlobalArrayInstance),
Ast.Assign(PythonAst._globalContext, Ast.Constant(instance.ModuleContext.GlobalContext)),
AstUtils.Convert(instance.ReduceWorker(), typeof(object))
),
name,
new[] { PythonAst._functionCode }
);
}
public override void PrepareScope(PythonAst ast, System.Runtime.CompilerServices.ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals, List<MSAst.Expression> init) {
locals.Add(PythonAst._globalArray);
init.Add(
Ast.Assign(
PythonAst._globalArray,
Ast.Call(
typeof(PythonOps).GetMethod("GetGlobalArrayFromContext"),
PythonAst._globalContext
)
)
);
}
public override ScriptCode/*!*/ MakeScriptCode(MSAst.Expression/*!*/ body, CompilerContext/*!*/ context, PythonAst/*!*/ ast, Dictionary<int, bool> handlerLocations, Dictionary<int, Dictionary<int, bool>> loopAndFinallyLocations) {
PythonCompilerOptions pco = ((PythonCompilerOptions)context.Options);
PythonContext pc = (PythonContext)context.SourceUnit.LanguageContext;
var lambda = Ast.Lambda<Func<CodeContext, FunctionCode, object>>(
Utils.Convert(body, typeof(object)),
pco.ModuleName ?? "<unnamed>",
ArrayGlobalAllocator._arrayFuncParams
);
return new PythonScriptCode(context, lambda, context.SourceUnit, handlerLocations, loopAndFinallyLocations, ast.Body.Span);
}
public override MSAst.LambdaExpression ReduceAst(PythonAst instance, string name) {
return Ast.Lambda<Func<CodeContext, FunctionCode, object>>(
Ast.Block(
new[] { PythonAst._globalArray },
Ast.Assign(
PythonAst._globalArray,
Ast.Call(
null,
typeof(PythonOps).GetMethod("GetGlobalArrayFromContext"),
IronPython.Compiler.Ast.PythonAst._globalContext
)
),
AstUtils.Convert(instance.ReduceWorker(), typeof(object))
),
name,
PythonAst._arrayFuncParams
);
}
public override LightLambdaExpression ReduceAst(PythonAst instance, string name) {
return Utils.LightLambda<LookupCompilationDelegate>(
typeof(object),
Ast.Block(
new[] { PythonAst._globalArray },
Ast.Assign(
PythonAst._globalArray,
Ast.Call(
null,
typeof(PythonOps).GetMethod("GetGlobalArrayFromContext"),
IronPython.Compiler.Ast.PythonAst._globalContext
)
),
AstUtils.Convert(instance.ReduceWorker(), typeof(object))
),
name,
PythonAst._arrayFuncParams
);
}
public override ScriptCode/*!*/ MakeScriptCode(MSAst.Expression/*!*/ body, CompilerContext/*!*/ context, PythonAst/*!*/ ast) {
MSAst.Expression finalBody = Ast.Block(
new[] { _globalCtx },
Ast.Assign(
_globalCtx,
Ast.Call(typeof(PythonOps).GetMethod("CreateTopLevelCodeContext"),
_globalScope,
_language
)
),
body
);
string name = ((PythonCompilerOptions)context.Options).ModuleName ?? "<unnamed>";
var lambda = Ast.Lambda<Func<Scope, LanguageContext, object>>(
finalBody,
name,
new[] { _globalScope, _language }
);
return new PythonScriptCode(lambda.Compile(context.SourceUnit.EmitDebugSymbols), context.SourceUnit);
}
public override ScriptCode/*!*/ MakeScriptCode(MSAst.Expression/*!*/ body, CompilerContext/*!*/ context, PythonAst/*!*/ ast, Dictionary<int, bool> handlerLocations, Dictionary<int, Dictionary<int, bool>> loopAndFinallyLocations) {
// finally build the funcion that's closed over the array
var func = Ast.Lambda<Func<CodeContext, FunctionCode, object>>(
Ast.Block(
new[] { GlobalArray },
Ast.Assign(
GlobalArray,
Ast.Call(
null,
typeof(PythonOps).GetMethod("GetGlobalArrayFromContext"),
IronPython.Compiler.Ast.ArrayGlobalAllocator._globalContext
)
),
Utils.Convert(body, typeof(object))
),
((PythonCompilerOptions)context.Options).ModuleName,
ArrayGlobalAllocator._arrayFuncParams
);
PythonCompilerOptions pco = context.Options as PythonCompilerOptions;
return new PythonSavableScriptCode(func, context.SourceUnit, GetNames(), pco.ModuleName);
}
public override LightLambdaExpression ReduceAst(PythonAst instance, string name)
{
return(Utils.LightLambda <Func <FunctionCode, object> >(typeof(object), AstUtils.Convert(instance.ReduceWorker(), typeof(object)), name, new[] { PythonAst._functionCode }));
}
private PythonAst ParseFileWorker(bool makeModule, bool returnValue) {
_globalParent = new PythonAst(makeModule, _languageFeatures, false, _context);
StartParsing();
List<Statement> l = new List<Statement>();
//
// A future statement must appear near the top of the module.
// The only lines that can appear before a future statement are:
// - the module docstring (if any),
// - comments,
// - blank lines, and
// - other future statements.
//
MaybeEatNewLine();
if (PeekToken(TokenKind.Constant)) {
Statement s = ParseStmt();
l.Add(s);
_fromFutureAllowed = false;
ExpressionStatement es = s as ExpressionStatement;
if (es != null) {
ConstantExpression ce = es.Expression as ConstantExpression;
if (ce != null && ce.Value is string) {
// doc string
_fromFutureAllowed = true;
}
}
}
MaybeEatNewLine();
// from __future__
if (_fromFutureAllowed) {
while (PeekToken(Tokens.KeywordFromToken)) {
Statement s = ParseStmt();
l.Add(s);
FromImportStatement fis = s as FromImportStatement;
if (fis != null && !fis.IsFromFuture) {
// end of from __future__
break;
}
}
}
// the end of from __future__ sequence
_fromFutureAllowed = false;
while (true) {
if (MaybeEat(TokenKind.EndOfFile)) break;
if (MaybeEatNewLine()) continue;
Statement s = ParseStmt();
l.Add(s);
}
Statement[] stmts = l.ToArray();
if (returnValue && stmts.Length > 0) {
ExpressionStatement exprStmt = stmts[stmts.Length - 1] as ExpressionStatement;
if (exprStmt != null) {
var retStmt = new ReturnStatement(exprStmt.Expression);
stmts[stmts.Length - 1] = retStmt;
retStmt.SetLoc(_globalParent, exprStmt.Expression.IndexSpan);
}
}
SuiteStatement ret = new SuiteStatement(stmts);
ret.SetLoc(_globalParent, 0, GetEnd());
return FinishParsing(ret);
}
public PythonAst ParseTopExpression() {
try {
// TODO: move from source unit .TrimStart(' ', '\t')
_globalParent = new PythonAst(false, _languageFeatures, false, _context);
ReturnStatement ret = new ReturnStatement(ParseTestListAsExpression());
ret.SetLoc(_globalParent, 0, 0);
return FinishParsing(ret);
} catch (BadSourceException bse) {
throw BadSourceError(bse);
}
}
public PythonAst ParseSingleStatement() {
try {
_globalParent = new PythonAst(false, _languageFeatures, true, _context);
StartParsing();
MaybeEatNewLine();
Statement statement = ParseStmt();
EatEndOfInput();
return FinishParsing(statement);
} catch (BadSourceException bse) {
throw BadSourceError(bse);
}
}
private PythonAst FinishParsing(Statement ret) {
var res = _globalParent;
_globalParent = null;
var lineLocs = _tokenizer.GetLineLocations();
// update line mapping
if (_sourceUnit.HasLineMapping) {
List<int> newLineMapping = new List<int>();
int last = 0;
for (int i = 0; i < lineLocs.Length; i++) {
while (newLineMapping.Count < i) {
newLineMapping.Add(last);
}
last = lineLocs[i] + 1;
newLineMapping.Add(lineLocs[i]);
}
lineLocs = newLineMapping.ToArray();
}
res.ParsingFinished(lineLocs, ret, _languageFeatures);
return res;
}
//[stmt_list] Newline | compound_stmt Newline
//stmt_list ::= simple_stmt (";" simple_stmt)* [";"]
//compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef
//Returns a simple or coumpound_stmt or null if input is incomplete
/// <summary>
/// Parse one or more lines of interactive input
/// </summary>
/// <returns>null if input is not yet valid but could be with more lines</returns>
public PythonAst ParseInteractiveCode(out ScriptCodeParseResult properties) {
bool parsingMultiLineCmpdStmt;
bool isEmptyStmt = false;
properties = ScriptCodeParseResult.Complete;
_globalParent = new PythonAst(false, _languageFeatures, true, _context);
StartParsing();
Statement ret = InternalParseInteractiveInput(out parsingMultiLineCmpdStmt, out isEmptyStmt);
if (_errorCode == 0) {
if (isEmptyStmt) {
properties = ScriptCodeParseResult.Empty;
} else if (parsingMultiLineCmpdStmt) {
properties = ScriptCodeParseResult.IncompleteStatement;
}
if (isEmptyStmt) {
return null;
}
return FinishParsing(ret);
} else {
if ((_errorCode & ErrorCodes.IncompleteMask) != 0) {
if ((_errorCode & ErrorCodes.IncompleteToken) != 0) {
properties = ScriptCodeParseResult.IncompleteToken;
return null;
}
if ((_errorCode & ErrorCodes.IncompleteStatement) != 0) {
if (parsingMultiLineCmpdStmt) {
properties = ScriptCodeParseResult.IncompleteStatement;
} else {
properties = ScriptCodeParseResult.IncompleteToken;
}
return null;
}
}
properties = ScriptCodeParseResult.Invalid;
return null;
}
}
public void SetLoc(PythonAst globalParent, IndexSpan span) {
_span = span;
_parent = globalParent;
}
public void SetLoc(PythonAst globalParent, int start, int end) {
_span = new IndexSpan(start, end > start ? end - start : start);
_parent = globalParent;
}
public void SetLoc(PythonAst globalParent, int start, int end)
{
_span = new IndexSpan(start, end > start ? end - start : start);
_parent = globalParent;
}
public override void PrepareScope(PythonAst ast, ReadOnlyCollectionBuilder <MSAst.ParameterExpression> locals, List <MSAst.Expression> init)
{
locals.Add(PythonAst._globalArray);
init.Add(Ast.Assign(PythonAst._globalArray, ast._arrayExpression));
}
public virtual ScriptCode MakeScriptCode(PythonAst ast) {
return new RuntimeScriptCode(ast, ast.ModuleContext.GlobalContext);
}
public void SetLoc(PythonAst globalParent, int start, int header, int end)
{
SetLoc(globalParent, start, end);
_indexHeader = header;
}
public override ScriptCode MakeScriptCode(PythonAst ast)
{
return(new PythonScriptCode(ast));
}
public LookupVisitor(PythonAst ast, MSAst.Expression globalContext)
{
_globalContext = globalContext;
_curScope = ast;
}
public abstract MSAst.LambdaExpression ReduceAst(PythonAst instance, string name);
public void SetLoc(PythonAst globalParent, IndexSpan span)
{
_span = span;
_parent = globalParent;
}
public virtual void PrepareScope(PythonAst ast, ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals, List<MSAst.Expression> init) {
}
public static void Check(PythonAst ast, CompilerContext context)
{
var finder = new StarredExpressionChecker(context);
ast.Walk(finder);
}