FilesExpand file tree

master

/

OnDiskScriptCode.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

99 lines (80 loc) · 3.61 KB

master

/

OnDiskScriptCode.cs

Copy path

Top

File metadata and controls

• Code
• Blame

99 lines (80 loc) · 3.61 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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;

}

}

}