1 /* 2 * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. 3 */ 4 /* 5 * Licensed to the Apache Software Foundation (ASF) under one or more 6 * contributor license agreements. See the NOTICE file distributed with 7 * this work for additional information regarding copyright ownership. 8 * The ASF licenses this file to You under the Apache License, Version 2.0 9 * (the "License"); you may not use this file except in compliance with 10 * the License. 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 com.sun.org.apache.bcel.internal.generic.ConstantPoolGen; 27 import com.sun.org.apache.bcel.internal.generic.INVOKESPECIAL; 28 import com.sun.org.apache.bcel.internal.generic.INVOKEVIRTUAL; 29 import com.sun.org.apache.bcel.internal.generic.Instruction; 30 import com.sun.org.apache.bcel.internal.generic.InstructionList; 31 import com.sun.org.apache.bcel.internal.generic.NEW; 32 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator; 33 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg; 34 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator; 35 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type; 36 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError; 37 import java.util.Iterator; 38 import java.util.List; 39 import java.util.NoSuchElementException; 40 import java.util.StringTokenizer; 41 42 /** 43 * @author Jacek Ambroziak 44 * @author Santiago Pericas-Geertsen 45 * @LastModified: Oct 2017 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 AttributeValueTemplate(String value, Parser parser, SyntaxTreeNode parent)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 */ parseAVTemplate(String text, Parser parser)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 StringBuilder buffer = new StringBuilder(); 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 typeCheck(SymbolTable stable)208 public Type typeCheck(SymbolTable stable) throws TypeCheckError { 209 final List<SyntaxTreeNode> contents = getContents(); 210 final int n = contents.size(); 211 for (int i = 0; i < n; i++) { 212 final Expression exp = (Expression)contents.get(i); 213 if (!exp.typeCheck(stable).identicalTo(Type.String)) { 214 contents.set(i, new CastExpr(exp, Type.String)); 215 } 216 } 217 return _type = Type.String; 218 } 219 toString()220 public String toString() { 221 final StringBuilder buffer = new StringBuilder("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 translate(ClassGenerator classGen, MethodGenerator methodGen)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 // StringBuilder is on the stack 254 final Iterator<SyntaxTreeNode> elements = elements(); 255 while (elements.hasNext()) { 256 final Expression exp = (Expression)elements.next(); 257 exp.translate(classGen, methodGen); 258 il.append(append); 259 } 260 il.append(new INVOKEVIRTUAL(toString)); 261 } 262 } 263 } 264