|
0
|
1 package nabble.naml.compiler;
|
|
|
2
|
|
|
3 import fschmidt.util.java.ArrayStack;
|
|
|
4 import fschmidt.util.java.Stack;
|
|
|
5
|
|
|
6 import java.lang.reflect.InvocationTargetException;
|
|
|
7 import java.util.HashMap;
|
|
|
8 import java.util.List;
|
|
|
9 import java.util.Map;
|
|
|
10
|
|
|
11
|
|
|
12 final class RunStateImpl implements RunState {
|
|
|
13 private final Stack<Object> stack = new ArrayStack<Object>();
|
|
|
14 private final Template template;
|
|
|
15 private final int callDepth;
|
|
|
16 private final Map<String,String> args = new HashMap<String,String>();
|
|
|
17 private final Map<String,Object> namespaceMap = new HashMap<String,Object>();
|
|
|
18 private final Map<Class,List<JavaNamespace>> extensionMap;
|
|
|
19 private Encoder encoder;
|
|
|
20 private final Map<Macro,Stack<Map<String,String>>> varsMap = new HashMap<Macro,Stack<Map<String,String>>>();
|
|
|
21
|
|
|
22 RunStateImpl(Template template,int callDepth,Encoder encoder) {
|
|
|
23 this.template = template;
|
|
|
24 this.callDepth = callDepth;
|
|
|
25 this.encoder = encoder;
|
|
|
26 this.extensionMap = template.program().extensionMap();
|
|
|
27 }
|
|
|
28
|
|
|
29 public Template template() {
|
|
|
30 return template;
|
|
|
31 }
|
|
|
32
|
|
|
33 public Program program() {
|
|
|
34 return template.program();
|
|
|
35 }
|
|
|
36
|
|
|
37 public int callDepth() {
|
|
|
38 return callDepth;
|
|
|
39 }
|
|
|
40
|
|
|
41 public void putArg(String name,String value) {
|
|
|
42 args.put(name,value);
|
|
|
43 }
|
|
|
44
|
|
|
45 public String getArg(String name) {
|
|
|
46 return args.get(name);
|
|
|
47 }
|
|
|
48
|
|
|
49 public Object getNamespace(String key) {
|
|
|
50 return namespaceMap.get(key);
|
|
|
51 }
|
|
|
52
|
|
|
53 public String saveNamespace(Object namespace) {
|
|
|
54 String key = namespace.toString();
|
|
|
55 namespaceMap.put(key,namespace);
|
|
|
56 return key;
|
|
|
57 }
|
|
|
58
|
|
|
59 public Object getFromStack(int i) {
|
|
|
60 if( i < 0 )
|
|
|
61 i = stack.size() + i;
|
|
|
62 return stack.get(i);
|
|
|
63 }
|
|
|
64
|
|
|
65 public int push(Object scope) {
|
|
|
66 return push(stack,extensionMap,scope);
|
|
|
67 }
|
|
|
68
|
|
|
69 static int push(Stack<Object> stack,Map<Class,List<JavaNamespace>> extensionMap,Object scope) {
|
|
|
70 stack.push(scope);
|
|
|
71 int pushed = 1;
|
|
|
72 List<JavaNamespace> extensions = extensionMap.get(scope.getClass());
|
|
|
73 if( extensions == null )
|
|
|
74 return 1;
|
|
|
75 for( JavaNamespace extension : extensions ) {
|
|
|
76 try {
|
|
|
77 stack.push(extension.extensionConstructor.newInstance(scope));
|
|
|
78 } catch(InstantiationException e) {
|
|
|
79 throw new TemplateRuntimeException(e);
|
|
|
80 } catch(IllegalAccessException e) {
|
|
|
81 throw new TemplateRuntimeException(e);
|
|
|
82 } catch(InvocationTargetException e) {
|
|
|
83 throw Compiler.interpFix(e);
|
|
|
84 }
|
|
|
85 }
|
|
|
86 return 1 + extensions.size();
|
|
|
87 }
|
|
|
88
|
|
|
89 public void pop(int n) {
|
|
|
90 pop(stack,n);
|
|
|
91 }
|
|
|
92
|
|
|
93 static void pop(Stack<Object> stack,int n) {
|
|
|
94 for( ; n > 0; n-- ) {
|
|
|
95 stack.pop();
|
|
|
96 }
|
|
|
97 }
|
|
|
98
|
|
|
99 public boolean hasNamespace(String namespace) {
|
|
|
100 throw new RuntimeException("hasNamespace only works at compile-time");
|
|
|
101 }
|
|
|
102
|
|
|
103 public boolean isInCommandStack(String commandName) {
|
|
|
104 throw new RuntimeException("isInStack only works at compile-time");
|
|
|
105 }
|
|
|
106
|
|
|
107 public Encoder getEncoder() {
|
|
|
108 return encoder;
|
|
|
109 }
|
|
|
110
|
|
|
111 public void setEncoder(Encoder encoder) {
|
|
|
112 this.encoder = encoder;
|
|
|
113 }
|
|
|
114
|
|
|
115 public Map<String,String> getVars(Macro macro) {
|
|
|
116 return varsMap.get(macro).peek();
|
|
|
117 }
|
|
|
118
|
|
|
119 public void pushVars(Macro macro) {
|
|
|
120 Stack<Map<String,String>> vars = varsMap.get(macro);
|
|
|
121 if( vars == null ) {
|
|
|
122 vars = new ArrayStack<Map<String,String>>();
|
|
|
123 varsMap.put(macro,vars);
|
|
|
124 }
|
|
|
125 vars.push(new HashMap<String,String>());
|
|
|
126 }
|
|
|
127
|
|
|
128 public void popVars(Macro macro) {
|
|
|
129 varsMap.get(macro).pop();
|
|
|
130 }
|
|
|
131
|
|
|
132 }
|
