View Javadoc
1   /*
2    * reserved comment block
3    * DO NOT REMOVE OR ALTER!
4    */
5   /*
6    * Copyright 2001-2004 The Apache Software Foundation.
7    *
8    * Licensed under the Apache License, Version 2.0 (the "License");
9    * you may not use this file except in compliance with the License.
10   * You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing, software
15   * distributed under the License is distributed on an "AS IS" BASIS,
16   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17   * See the License for the specific language governing permissions and
18   * limitations under the License.
19   */
20  /*
21   * $Id: AttributeValueTemplate.java,v 1.2.4.1 2005/09/01 10:26:57 pvedula Exp $
22   */
23  
24  package com.sun.org.apache.xalan.internal.xsltc.compiler;
25  
26  import java.util.Enumeration;
27  import java.util.Vector;
28  import java.util.StringTokenizer;
29  import java.util.NoSuchElementException;
30  
31  import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
32  import com.sun.org.apache.bcel.internal.generic.INVOKESPECIAL;
33  import com.sun.org.apache.bcel.internal.generic.INVOKEVIRTUAL;
34  import com.sun.org.apache.bcel.internal.generic.Instruction;
35  import com.sun.org.apache.bcel.internal.generic.InstructionList;
36  import com.sun.org.apache.bcel.internal.generic.NEW;
37  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator;
38  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
39  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator;
40  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;
41  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError;
42  
43  /**
44   * @author Jacek Ambroziak
45   * @author Santiago Pericas-Geertsen
46   */
47  final class AttributeValueTemplate extends AttributeValue {
48  
49      final static int OUT_EXPR = 0;
50      final static int IN_EXPR  = 1;
51      final static int IN_EXPR_SQUOTES = 2;
52      final static int IN_EXPR_DQUOTES = 3;
53      final static String DELIMITER = "\uFFFE";      // A Unicode nonchar
54  
55      public AttributeValueTemplate(String value, Parser parser,
56          SyntaxTreeNode parent)
57      {
58          setParent(parent);
59          setParser(parser);
60  
61          try {
62              parseAVTemplate(value, parser);
63          }
64          catch (NoSuchElementException e) {
65              reportError(parent, parser,
66                          ErrorMsg.ATTR_VAL_TEMPLATE_ERR, value);
67          }
68      }
69  
70      /**
71       * Two-pass parsing of ATVs. In the first pass, double curly braces are
72       * replaced by one, and expressions are delimited using DELIMITER. The
73       * second pass splits up the resulting buffer into literal and non-literal
74       * expressions. Errors are reported during the first pass.
75       */
76      private void parseAVTemplate(String text, Parser parser) {
77          StringTokenizer tokenizer =
78              new StringTokenizer(text, "{}\"\'", true);
79  
80          /*
81            * First pass: replace double curly braces and delimit expressions
82            * Simple automaton to parse ATVs, delimit expressions and report
83            * errors.
84            */
85          String t = null;
86          String lookahead = null;
87          StringBuffer buffer = new StringBuffer();
88          int state = OUT_EXPR;
89  
90          while (tokenizer.hasMoreTokens()) {
91              // Use lookahead if available
92              if (lookahead != null) {
93                  t = lookahead;
94                  lookahead = null;
95              }
96              else {
97                  t = tokenizer.nextToken();
98              }
99  
100             if (t.length() == 1) {
101                 switch (t.charAt(0)) {
102                     case '{':
103                         switch (state) {
104                             case OUT_EXPR:
105                                 lookahead = tokenizer.nextToken();
106                                 if (lookahead.equals("{")) {
107                                     buffer.append(lookahead);    // replace {{ by {
108                                     lookahead = null;
109                                 }
110                                 else {
111                                     buffer.append(DELIMITER);
112                                     state = IN_EXPR;
113                                 }
114                                 break;
115                             case IN_EXPR:
116                             case IN_EXPR_SQUOTES:
117                             case IN_EXPR_DQUOTES:
118                                 reportError(getParent(), parser,
119                                             ErrorMsg.ATTR_VAL_TEMPLATE_ERR, text);
120                                 break;
121                         }
122                         break;
123                     case '}':
124                         switch (state) {
125                             case OUT_EXPR:
126                                 lookahead = tokenizer.nextToken();
127                                 if (lookahead.equals("}")) {
128                                     buffer.append(lookahead);    // replace }} by }
129                                     lookahead = null;
130                                 }
131                                 else {
132                                     reportError(getParent(), parser,
133                                             ErrorMsg.ATTR_VAL_TEMPLATE_ERR, text);
134                                 }
135                                 break;
136                             case IN_EXPR:
137                                 buffer.append(DELIMITER);
138                                 state = OUT_EXPR;
139                                 break;
140                             case IN_EXPR_SQUOTES:
141                             case IN_EXPR_DQUOTES:
142                                 buffer.append(t);
143                                 break;
144                         }
145                         break;
146                     case '\'':
147                         switch (state) {
148                             case IN_EXPR:
149                                 state = IN_EXPR_SQUOTES;
150                                 break;
151                             case IN_EXPR_SQUOTES:
152                                 state = IN_EXPR;
153                                 break;
154                             case OUT_EXPR:
155                             case IN_EXPR_DQUOTES:
156                                 break;
157                         }
158                         buffer.append(t);
159                         break;
160                     case '\"':
161                         switch (state) {
162                             case IN_EXPR:
163                                 state = IN_EXPR_DQUOTES;
164                                 break;
165                             case IN_EXPR_DQUOTES:
166                                 state = IN_EXPR;
167                                 break;
168                             case OUT_EXPR:
169                             case IN_EXPR_SQUOTES:
170                                 break;
171                         }
172                         buffer.append(t);
173                         break;
174                     default:
175                         buffer.append(t);
176                         break;
177                 }
178             }
179             else {
180                 buffer.append(t);
181             }
182         }
183 
184         // Must be in OUT_EXPR at the end of parsing
185         if (state != OUT_EXPR) {
186             reportError(getParent(), parser,
187                         ErrorMsg.ATTR_VAL_TEMPLATE_ERR, text);
188         }
189 
190         /*
191           * Second pass: split up buffer into literal and non-literal expressions.
192           */
193         tokenizer = new StringTokenizer(buffer.toString(), DELIMITER, true);
194 
195         while (tokenizer.hasMoreTokens()) {
196             t = tokenizer.nextToken();
197 
198             if (t.equals(DELIMITER)) {
199                 addElement(parser.parseExpression(this, tokenizer.nextToken()));
200                 tokenizer.nextToken();      // consume other delimiter
201             }
202             else {
203                 addElement(new LiteralExpr(t));
204             }
205         }
206     }
207 
208     public Type typeCheck(SymbolTable stable) throws TypeCheckError {
209         final Vector contents = getContents();
210         final int n = contents.size();
211         for (int i = 0; i < n; i++) {
212             final Expression exp = (Expression)contents.elementAt(i);
213             if (!exp.typeCheck(stable).identicalTo(Type.String)) {
214                 contents.setElementAt(new CastExpr(exp, Type.String), i);
215             }
216         }
217         return _type = Type.String;
218     }
219 
220     public String toString() {
221         final StringBuffer buffer = new StringBuffer("AVT:[");
222         final int count = elementCount();
223         for (int i = 0; i < count; i++) {
224             buffer.append(elementAt(i).toString());
225             if (i < count - 1)
226                 buffer.append(' ');
227         }
228         return buffer.append(']').toString();
229     }
230 
231     public void translate(ClassGenerator classGen, MethodGenerator methodGen) {
232         if (elementCount() == 1) {
233             final Expression exp = (Expression)elementAt(0);
234             exp.translate(classGen, methodGen);
235         }
236         else {
237             final ConstantPoolGen cpg = classGen.getConstantPool();
238             final InstructionList il = methodGen.getInstructionList();
239             final int initBuffer = cpg.addMethodref(STRING_BUFFER_CLASS,
240                                                     "<init>", "()V");
241             final Instruction append =
242                 new INVOKEVIRTUAL(cpg.addMethodref(STRING_BUFFER_CLASS,
243                                                    "append",
244                                                    "(" + STRING_SIG + ")"
245                                                    + STRING_BUFFER_SIG));
246 
247             final int toString = cpg.addMethodref(STRING_BUFFER_CLASS,
248                                                   "toString",
249                                                   "()"+STRING_SIG);
250             il.append(new NEW(cpg.addClass(STRING_BUFFER_CLASS)));
251             il.append(DUP);
252             il.append(new INVOKESPECIAL(initBuffer));
253             // StringBuffer is on the stack
254             final Enumeration elements = elements();
255             while (elements.hasMoreElements()) {
256                 final Expression exp = (Expression)elements.nextElement();
257                 exp.translate(classGen, methodGen);
258                 il.append(append);
259             }
260             il.append(new INVOKEVIRTUAL(toString));
261         }
262     }
263 }