View Javadoc

1   /*
2    * ASTASMetaTag.java
3    * 
4    * Copyright (c) 2006 David Holroyd
5    *
6    * Licensed under the Apache License, Version 2.0 (the "License");
7    * you may not use this file except in compliance with the License.
8    * You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
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 }