1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package uk.co.badgersinfoil.metaas.impl;
20
21 import java.util.ArrayList;
22 import java.util.Collections;
23 import java.util.List;
24 import org.asdt.core.internal.antlr.AS3Parser;
25 import uk.co.badgersinfoil.metaas.ActionScriptFactory;
26 import uk.co.badgersinfoil.metaas.SyntaxException;
27 import uk.co.badgersinfoil.metaas.dom.ASMetaTag;
28 import uk.co.badgersinfoil.metaas.impl.antlr.LinkedListToken;
29 import uk.co.badgersinfoil.metaas.impl.antlr.LinkedListTree;
30
31
32 public class ASTASMetaTag extends ASTScriptElement implements ASMetaTag {
33
34 public ASTASMetaTag(LinkedListTree ast) {
35 super(ast);
36 }
37
38 public void addParam(String constant) {
39 addParam(toAST(constant));
40 }
41
42 private LinkedListTree toAST(String constant) {
43 return ASTUtils.newAST(AS3Parser.STRING_LITERAL, ActionScriptFactory.str(constant));
44 }
45
46 private void addParam(LinkedListTree str) {
47 LinkedListTree params = findOrAddParams();
48 if (params.getChildCount() > 0) {
49 params.appendToken(TokenBuilder.newComma());
50 params.appendToken(TokenBuilder.newSpace());
51 }
52 params.addChildWithTokens(str);
53 }
54
55 public void addParam(int constant) {
56 addParam(toAST(constant));
57 }
58
59 private LinkedListTree toAST(int constant) {
60 return ASTUtils.newAST(AS3Parser.DECIMAL_LITERAL, String.valueOf(constant));
61 }
62
63 public void addParam(boolean constant) {
64 addParam(toAST(constant));
65 }
66
67 private LinkedListTree toAST(boolean constant) {
68 LinkedListTree str;
69 if (constant) {
70 str = ASTUtils.newAST(AS3Parser.TRUE, "true");
71 } else {
72 str = ASTUtils.newAST(AS3Parser.FALSE, "false");
73 }
74 return str;
75 }
76
77 public void addParam(String name, String constant) {
78 addParam(name, toAST(constant));
79 }
80
81 private void addParam(String name, LinkedListTree val) {
82 LinkedListTree assign = ASTUtils.newImaginaryAST(AS3Parser.ASSIGN);
83 LinkedListTree ident = ASTUtils.newAST(AS3Parser.IDENT, name);
84 assign.addChildWithTokens(ident);
85 LinkedListToken assignToken = new LinkedListToken(AS3Parser.ASSIGN, "=");
86 assign.appendToken(assignToken);
87 assign.token = assignToken;
88 assign.addChildWithTokens(val);
89
90 addParam(assign);
91 }
92
93 public void addParam(String name, int constant) {
94 addParam(name, toAST(constant));
95 }
96
97 public void addParam(String name, boolean constant) {
98 addParam(name, toAST(constant));
99 }
100
101 public String getName() {
102 return ast.getFirstChild().getText();
103 }
104
105 public Object getParamValue(String name) {
106 LinkedListTree params = findParams();
107 if (params == null) {
108 return null;
109 }
110 for (ASTIterator i=new ASTIterator(params); i.hasNext(); ) {
111 LinkedListTree child = i.next();
112 if (child.getType()==AS3Parser.ASSIGN) {
113 if (child.getFirstChild().getText().equals(name)) {
114 return toParamValue(child.getLastChild());
115 }
116 }
117 }
118 return null;
119 }
120
121 public List getParams() {
122 LinkedListTree params = findParams();
123 if (params == null) {
124 return Collections.EMPTY_LIST;
125 }
126 List result = new ArrayList();
127 for (ASTIterator i=new ASTIterator(params); i.hasNext(); ) {
128 LinkedListTree param = i.next();
129 result.add(toParamValue(param));
130 }
131 return result;
132 }
133
134 private static Object toParamValue(LinkedListTree child) {
135 switch (child.getType()) {
136 case AS3Parser.STRING_LITERAL:
137 return ASTUtils.decodeStringLiteral(child.getText());
138 case AS3Parser.TRUE:
139 return Boolean.TRUE;
140 case AS3Parser.FALSE:
141 return Boolean.FALSE;
142 case AS3Parser.DECIMAL_LITERAL:
143 return Integer.valueOf(child.getText());
144 case AS3Parser.ASSIGN:
145 return new ASTParam(child);
146 default:
147 throw new SyntaxException("Unexpected type "+ASTUtils.tokenName(child));
148 }
149 }
150
151 private LinkedListTree findOrAddParams() {
152 LinkedListTree params = findParams();
153 if (params == null) {
154 params = ASTUtils.newParentheticAST(AS3Parser.ANNOTATION_PARAMS, AS3Parser.LPAREN, "(", AS3Parser.RPAREN, ")");
155 ast.addChildWithTokens(params);
156 }
157 return params;
158 }
159 private LinkedListTree findParams() {
160 return ASTUtils.findChildByType(ast, AS3Parser.ANNOTATION_PARAMS);
161 }
162
163 public static class ASTParam implements ASMetaTag.Param {
164 private LinkedListTree param;
165 public ASTParam(LinkedListTree param) {
166 this.param = param;
167 }
168 public String getName() {
169 return param.getFirstChild().getText();
170 }
171 public Object getValue() {
172 return toParamValue(param.getLastChild());
173 }
174 }
175 }