forked from IronLanguages/ironpython3
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathOnDiskScriptCode.cs
More file actions
99 lines (80 loc) · 3.61 KB
/
OnDiskScriptCode.cs
File metadata and controls
99 lines (80 loc) · 3.61 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the Apache 2.0 License.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using Microsoft.Scripting;
using Microsoft.Scripting.Runtime;
using Microsoft.Scripting.Utils;
using IronPython.Runtime;
using IronPython.Runtime.Operations;
namespace IronPython.Compiler {
/// <summary>
/// A ScriptCode which has been loaded from an assembly which is saved on disk.
/// </summary>
internal class OnDiskScriptCode : RunnableScriptCode {
private readonly LookupCompilationDelegate _target;
private CodeContext _optimizedContext;
private readonly string _moduleName;
public OnDiskScriptCode(LookupCompilationDelegate code, SourceUnit sourceUnit, string moduleName) :
base(MakeAstFromSourceUnit(sourceUnit)) {
_target = code;
_moduleName = moduleName;
}
/// <summary>
/// Creates a fake PythonAst object which is represenative of the on-disk script code.
/// </summary>
private static Ast.PythonAst MakeAstFromSourceUnit(SourceUnit sourceUnit) {
var compCtx = new CompilerContext(sourceUnit, new PythonCompilerOptions(), ErrorSink.Null);
return new Ast.PythonAst(compCtx);
}
public override object Run() {
CodeContext ctx = CreateContext();
try {
var funcCode = EnsureFunctionCode(_target, false, true);
PushFrame(ctx, funcCode);
return _target(ctx, funcCode);
} finally {
PopFrame();
}
}
public override object Run(Scope scope) {
if (scope == CreateScope()) {
return Run();
}
throw new NotSupportedException();
}
public string ModuleName {
get {
return _moduleName;
}
}
public override FunctionCode GetFunctionCode(bool register) {
return EnsureFunctionCode(_target, false, register);
}
public override Scope CreateScope() {
return CreateContext().GlobalScope;
}
internal CodeContext CreateContext() {
if (_optimizedContext == null) {
CachedOptimizedCodeAttribute[] attrs = (CachedOptimizedCodeAttribute[])_target.Method.GetCustomAttributes(typeof(CachedOptimizedCodeAttribute), false);
// create the CompilerContext for the ScriptCode
CachedOptimizedCodeAttribute optimizedCode = attrs[0];
// create the storage for the global scope
Dictionary<string, PythonGlobal> globals = new Dictionary<string, PythonGlobal>(StringComparer.Ordinal);
PythonGlobal[] globalArray = new PythonGlobal[optimizedCode.Names.Length];
var dict = new PythonDictionary(new GlobalDictionaryStorage(globals, globalArray));
ModuleContext mc = new ModuleContext(dict, (PythonContext)SourceUnit.LanguageContext);
CodeContext res = mc.GlobalContext;
for (int i = 0; i < optimizedCode.Names.Length; i++) {
string name = optimizedCode.Names[i];
globalArray[i] = globals[name] = new PythonGlobal(res, name);
}
_optimizedContext = CreateTopLevelCodeContext(dict, (PythonContext)SourceUnit.LanguageContext);
}
return _optimizedContext;
}
}
}