Mercurial Hosting > nabble

comparison src/nabble/naml/compiler/RunStateImpl.java @ 0:7ecd1a4ef557

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add content
author Franklin Schmidt <fschmidt@gmail.com>
date Thu, 21 Mar 2019 19:15:52 -0600
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:7ecd1a4ef557
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 }