/** * jetbrick-template * http://subchen.github.io/jetbrick-template/ * * Copyright 2010-2014 Guoqiang Chen. All rights reserved. * Email: [email protected] * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package jetbrick.template.parser; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Member; import java.lang.reflect.Method; import java.util.ArrayDeque; import java.util.Collection; import java.util.Deque; import java.util.HashMap; import java.util.List; import java.util.Map; import javax.lang.model.SourceVersion; import jetbrick.template.JetContext; import jetbrick.template.JetEngine; import jetbrick.template.JetSecurityManager; import jetbrick.template.parser.code.BlockCode; import jetbrick.template.parser.code.Code; import jetbrick.template.parser.code.DefineExpressionCode; import jetbrick.template.parser.code.ForExpressionCode; import jetbrick.template.parser.code.MacroCode; import jetbrick.template.parser.code.ScopeCode; import jetbrick.template.parser.code.SegmentCode; import jetbrick.template.parser.code.SegmentListCode; import jetbrick.template.parser.code.TagCode; import jetbrick.template.parser.code.TemplateClassCode; import jetbrick.template.parser.code.TextCode; import jetbrick.template.parser.grammer.JetTemplateParser; import jetbrick.template.parser.grammer.JetTemplateParser.BlockContext; import jetbrick.template.parser.grammer.JetTemplateParser.Break_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.ConstantContext; import jetbrick.template.parser.grammer.JetTemplateParser.Continue_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Define_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Define_expressionContext; import jetbrick.template.parser.grammer.JetTemplateParser.Define_expression_listContext; import jetbrick.template.parser.grammer.JetTemplateParser.DirectiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Else_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Elseif_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_array_getContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_array_listContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_class_castContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_compare_conditionContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_compare_equalityContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_compare_notContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_compare_relationalContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_conditional_ternaryContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_constantContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_field_accessContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_function_callContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_groupContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_hash_mapContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_identifierContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_instanceofContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_math_binary_basicContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_math_binary_bitwiseContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_math_binary_shiftContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_math_unary_prefixContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_math_unary_suffixContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_method_invocationContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_new_arrayContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_new_objectContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_static_field_accessContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expr_static_method_invocationContext; import jetbrick.template.parser.grammer.JetTemplateParser.ExpressionContext; import jetbrick.template.parser.grammer.JetTemplateParser.Expression_listContext; import jetbrick.template.parser.grammer.JetTemplateParser.For_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.For_expressionContext; import jetbrick.template.parser.grammer.JetTemplateParser.Hash_map_entry_listContext; import jetbrick.template.parser.grammer.JetTemplateParser.If_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Include_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Invalid_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Macro_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Put_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Set_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Set_expressionContext; import jetbrick.template.parser.grammer.JetTemplateParser.Static_type_nameContext; import jetbrick.template.parser.grammer.JetTemplateParser.Stop_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.Tag_directiveContext; import jetbrick.template.parser.grammer.JetTemplateParser.TemplateContext; import jetbrick.template.parser.grammer.JetTemplateParser.TextContext; import jetbrick.template.parser.grammer.JetTemplateParser.TypeContext; import jetbrick.template.parser.grammer.JetTemplateParser.Type_argumentsContext; import jetbrick.template.parser.grammer.JetTemplateParser.Type_array_suffixContext; import jetbrick.template.parser.grammer.JetTemplateParser.Type_listContext; import jetbrick.template.parser.grammer.JetTemplateParser.Type_nameContext; import jetbrick.template.parser.grammer.JetTemplateParser.ValueContext; import jetbrick.template.parser.grammer.JetTemplateParserVisitor; import jetbrick.template.parser.support.ClassUtils; import jetbrick.template.parser.support.NumberClassUtils; import jetbrick.template.parser.support.PromotionUtils; import jetbrick.template.parser.support.TypedKlass; import jetbrick.template.parser.support.TypedKlassUtils; import jetbrick.template.resource.Resource; import jetbrick.template.runtime.JetTagContext; import jetbrick.template.utils.PathUtils; import jetbrick.template.utils.StringEscapeUtils; import org.antlr.v4.runtime.ParserRuleContext; import org.antlr.v4.runtime.Token; import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; import org.antlr.v4.runtime.tree.ParseTree; import org.antlr.v4.runtime.tree.TerminalNode; // Visitor 模式访问器，用来生成 Java 代码 public class JetTemplateCodeVisitor extends AbstractParseTreeVisitor<Code> implements JetTemplateParserVisitor<Code> { private final JetEngine engine; private final Resource resource; private final JetTemplateParser parser; private final VariableResolver resolver; private final JetSecurityManager securityManager; private final boolean globalSafeCall; private final boolean trimDirectiveLine; private final boolean trimDirectiveComments; private final String commentsPrefix; private final String commentsSuffix; private TemplateClassCode tcc; // private ScopeCode scopeCode; // 当前作用域对应的 Code private Map<String, MacroCode> macroMap; // 宏定义 private Map<String, TextCode> textCache; // 文本内容缓存(可以减少冗余 Text) private Deque<String> forStack; // 维护嵌套 #for 的堆栈，可以识别是否在嵌入在 #for 里面, 内部存储当前 for 的真实变量名 private int uuid = 1; // 计数器 public JetTemplateCodeVisitor(JetEngine engine, VariableResolver resolver, JetSecurityManager securityManager, JetTemplateParser parser, Resource resource) { this.engine = engine; this.parser = parser; this.resolver = resolver; this.securityManager = securityManager; this.resource = resource; this.globalSafeCall = engine.getConfig().isSyntaxSafecall(); this.trimDirectiveLine = engine.getConfig().isTrimDirectiveLine(); this.trimDirectiveComments = engine.getConfig().isTrimDirectiveComments(); this.commentsPrefix = engine.getConfig().getTrimDirectiveCommentsPrefix(); this.commentsSuffix = engine.getConfig().getTrimDirectiveCommentsSuffix(); this.textCache = new HashMap<String, TextCode>(32); this.forStack = new ArrayDeque<String>(8); // 专门处理是否存在未完成的解析 (1.2.8 在 parser.g4 中添加 EOF，此处代码已经无用) //Token token = parser.getCurrentToken(); //if (token.getType() != Token.EOF) { // throw reportError("Invalid " + token.getText() + " directive in here.", token); //} } @Override public Code visitTemplate(TemplateContext ctx) { tcc = new TemplateClassCode(); tcc.setPackageName(resource.getPackageName()); tcc.setClassName(resource.getClassName()); tcc.setTemplateName(resource.getName()); tcc.setEncoding(engine.getConfig().getOutputEncoding()); scopeCode = tcc.getMethodCode(); scopeCode.define(Code.CONTEXT_NAME, TypedKlass.JetContext); scopeCode.setBodyCode(ctx.block().accept(this)); return tcc; } @Override public Code visitBlock(BlockContext ctx) { int size = ctx.getChildCount(); BlockCode code = scopeCode.createBlockCode(size); if (size == 0) return code; for (int i = 0; i < size; i++) { ParseTree node = ctx.children.get(i); Code c = node.accept(this); if (node instanceof TextContext) { // 文本节点 TextCode textCode = (TextCode) c; if (trimDirectiveLine || trimDirectiveComments) { ParseTree prev = (i > 0) ? ctx.children.get(i - 1) : null; ParseTree next = (i < size - 1) ? ctx.children.get(i + 1) : null; boolean trimLeft; boolean keepLeftNewLine = false; if (prev == null) { trimLeft = !(ctx.getParent() instanceof TemplateContext); } else { trimLeft = prev instanceof DirectiveContext; if (trimLeft) { // inline directive, 对于一个内联的 #if, #for 指令，后面有要求保留一个 NewLine // @see https://github.com/subchen/jetbrick-template/issues/25 ParserRuleContext directive = (ParserRuleContext) ((DirectiveContext) prev).getChild(0); if (directive instanceof If_directiveContext || directive instanceof For_directiveContext) { if (directive.getStart().getLine() == directive.getStop().getLine()) { keepLeftNewLine = true; // 保留一个 NewLine } } } } boolean trimRight; if (next == null) { trimRight = !(ctx.getParent() instanceof TemplateContext); } else { trimRight = (next instanceof DirectiveContext); } // trim 指令两边的注释 if (trimDirectiveComments) { textCode.trimComments(trimLeft, trimRight, commentsPrefix, commentsSuffix); } // trim 指令两边的空白内容 if (trimDirectiveLine) { textCode.trimEmptyLine(trimLeft, trimRight, keepLeftNewLine); } // trim 掉 #tag 和 #macro 指令最后一个多余的 '\n' if (next == null) { if (ctx.getParent() instanceof Tag_directiveContext || ctx.getParent() instanceof Macro_directiveContext) { textCode.trimLastNewLine(); } } } if (!textCode.isEmpty()) { // 如果有相同内容的Text，则从缓存中读取 TextCode old = textCache.get(textCode.getText()); if (old == null) { old = textCode; textCache.put(textCode.getText(), textCode); // add text into field tcc.addField(textCode.getId(), textCode.getText()); } code.addLine(old.toString()); } } else { code.addChild(c); } } return code; } @Override public Code visitText(TextContext ctx) { Token token = ((TerminalNode) ctx.getChild(0)).getSymbol(); String text = token.getText(); switch (token.getType()) { case JetTemplateParser.TEXT_CDATA: text = text.substring(3, text.length() - 3); break; case JetTemplateParser.TEXT_ESCAPED_CHAR: text = text.substring(1); break; } String id = getUid("txt"); return new TextCode(id, text); } @Override public Code visitValue(ValueContext ctx) { Code code = ctx.expression().accept(this); String source = code.toString(); // 如果返回值是 void，那么不需要 print 语句。 if (code instanceof SegmentCode) { Class<?> klass = ((SegmentCode) code).getKlass(); if (Void.TYPE.equals(klass)) { return scopeCode.createLineCode(source + "; // line: " + ctx.getStart().getLine()); } } Token token = ((TerminalNode) ctx.getChild(0)).getSymbol(); if (token.getType() == JetTemplateParser.VALUE_ESCAPED_OPEN) { source = "JetUtils.asEscapeHtml(" + source + ")"; } if ("null".equals(source)) { // 防止编译出错 (也可以生成一个空行) source = "(Object)null"; } return scopeCode.createLineCode("$out.print(" + source + "); // line: " + ctx.getStart().getLine()); } @Override public Code visitDirective(DirectiveContext ctx) { return ctx.getChild(0).accept(this); } @Override public Code visitDefine_directive(Define_directiveContext ctx) { SegmentListCode define_expression_list = (SegmentListCode) ctx.define_expression_list().accept(this); BlockCode code = scopeCode.createBlockCode(define_expression_list.size()); for (SegmentCode node : define_expression_list.getChildren()) { DefineExpressionCode c = (DefineExpressionCode) node; String name = c.getName(); if (!scopeCode.define(name, c.getTypedKlass())) { throw reportError("Duplicate local variable " + name, c.getNode()); } String typeName = c.getTypedKlass().asBoxedTypedKlass().toString(); code.addLine(typeName + " " + name + " = (" + typeName + ") " + Code.CONTEXT_NAME + ".get(\"" + name + "\"); // line: " + c.getNode().getStart().getLine()); } return code; } @Override public Code visitDefine_expression_list(Define_expression_listContext ctx) { List<Define_expressionContext> define_expression_list = ctx.define_expression(); SegmentListCode code = new SegmentListCode(define_expression_list.size()); for (Define_expressionContext define_expression : define_expression_list) { code.addChild((SegmentCode) define_expression.accept(this)); } return code; } @Override public Code visitDefine_expression(Define_expressionContext ctx) { SegmentCode code = (SegmentCode) ctx.type().accept(this); String name = assert_java_identifier(ctx.IDENTIFIER(), true); return new DefineExpressionCode(code.getTypedKlass(), name, ctx); } @Override public Code visitSet_directive(Set_directiveContext ctx) { List<Set_expressionContext> set_expression_list = ctx.set_expression(); BlockCode code = scopeCode.createBlockCode(set_expression_list.size()); for (Set_expressionContext node : set_expression_list) { Code c = node.accept(this); if (c != null) { code.addChild(c); } } return code; } @Override public Code visitSet_expression(Set_expressionContext ctx) { String name = assert_java_identifier(ctx.IDENTIFIER(), true); SegmentCode code = (SegmentCode) ctx.expression().accept(this); boolean defining = false; // 是否同时定义一个变量 TypedKlass lhs = null; // 变量类型 TypeContext type = ctx.type(); if (type != null) { defining = true; // 定义一个变量 SegmentCode c = (SegmentCode) type.accept(this); lhs = c.getTypedKlass(); if (!scopeCode.define(name, lhs)) { throw reportError("Duplicate local variable " + name, ctx.IDENTIFIER()); } } else { // 直接赋值，如果变量没有定义，则先定义 lhs = scopeCode.resolve(name, false); defining = (lhs == null); if (defining) { lhs = code.getTypedKlass(); scopeCode.define(name, lhs); } } // 进行赋值语句类型检查 if (!ClassUtils.isAssignable(lhs.getKlass(), code.getKlass())) { // 是否支持正常赋值 if (!ClassUtils.isAssignable(code.getKlass(), lhs.getKlass())) { // 是否支持强制类型转换 throw reportError("Type mismatch: cannot convert from " + code.getTypedKlass().toString() + " to " + lhs.toString(), ctx); } } BlockCode c = scopeCode.createBlockCode(2); String source = name + " = (" + lhs.getSource() + ") " + code.toString() + "; // line: " + ctx.getStart().getLine(); if (defining) { source = lhs.getSource() + " " + source; } c.addLine(source); c.addLine(Code.CONTEXT_NAME + ".put(\"" + name + "\", " + name + ");"); return c; } @Override public Code visitPut_directive(Put_directiveContext ctx) { List<ExpressionContext> expression_list = ctx.expression(); int size = expression_list.size(); if (size == 0 || size % 2 == 1) { throw reportError("Mismatched arguments count for #put directive", ctx); } BlockCode code = scopeCode.createBlockCode(size / 2); for (int i = 0; i < size; i += 2) { SegmentCode name = (SegmentCode) expression_list.get(i).accept(this); SegmentCode value = (SegmentCode) expression_list.get(i + 1).accept(this); if (!String.class.equals(name.getKlass())) { throw reportError("The argument type can't cast to String.class for #put directive", name.getNode()); } assert_not_void_expression(value); code.addLine(Code.CONTEXT_NAME + ".putAsParents(" + name.toString() + ", " + value.toString() + "); // line: " + ctx.getStart().getLine()); } return code; } @Override public Code visitIf_directive(If_directiveContext ctx) { BlockCode code = scopeCode.createBlockCode(16); SegmentCode expr_code = (SegmentCode) ctx.expression().accept(this); code.addLine("if (" + get_if_expression_source(expr_code) + ") { // line: " + ctx.getStart().getLine()); scopeCode = scopeCode.push(); code.addChild(ctx.block().accept(this)); scopeCode = scopeCode.pop(); code.addLine("}"); // elseif ... List<Elseif_directiveContext> elseif_directive_list = ctx.elseif_directive(); for (Elseif_directiveContext elseif_directive : elseif_directive_list) { code.addChild(elseif_directive.accept(this)); } // else ... Else_directiveContext else_directive = ctx.else_directive(); if (else_directive != null) { code.addChild(else_directive.accept(this)); } return code; } @Override public Code visitElseif_directive(Elseif_directiveContext ctx) { BlockCode code = scopeCode.createBlockCode(16); SegmentCode expr_code = (SegmentCode) ctx.expression().accept(this); code.addLine("else if (" + get_if_expression_source(expr_code) + ") { // line: " + ctx.getStart().getLine()); scopeCode = scopeCode.push(); code.addChild(ctx.block().accept(this)); scopeCode = scopeCode.pop(); code.addLine("}"); return code; } @Override public Code visitElse_directive(Else_directiveContext ctx) { BlockCode code = scopeCode.createBlockCode(16); if (ctx.getParent() instanceof If_directiveContext) { code.addLine("else { // line: " + ctx.getStart().getLine()); } scopeCode = scopeCode.push(); code.addChild(ctx.block().accept(this)); scopeCode = scopeCode.pop(); if (ctx.getParent() instanceof If_directiveContext) { code.addLine("}"); } return code; } @Override public Code visitFor_directive(For_directiveContext ctx) { BlockCode code = scopeCode.createBlockCode(16); String id_for = getUid("for"); scopeCode = scopeCode.push(); // 注意：for循环变量的作用域要放在 for 内部， 防止出现变量重定义错误 ForExpressionCode for_expr_code = (ForExpressionCode) ctx.for_expression().accept(this); // for block forStack.push(id_for); Code for_block_code = ctx.block().accept(this); forStack.pop(); scopeCode = scopeCode.pop(); // for-else Else_directiveContext else_directive = ctx.else_directive(); Code for_else_block = (else_directive == null) ? null : else_directive.accept(this); // 生成代码 String id_foritem = getUid("foritem"); String typeName = for_expr_code.getKlassName(); String itemName = for_expr_code.getName(); code.addLine("Object " + id_foritem + " = context.get(\"" + itemName + "\"); // save it"); code.addLine("JetForIterator " + id_for + " = new JetForIterator(" + for_expr_code.toString() + ");"); code.addLine("while (" + id_for + ".hasNext()) { // line: " + ctx.getStart().getLine()); // class item = (class) it.next() ... code.addLine(" " + typeName + " " + itemName + " = (" + typeName + ") " + id_for + ".next();"); code.addLine(" context.put(\"" + itemName + "\", " + itemName + ");"); code.addChild(for_block_code); code.addLine("}"); code.addLine("context.put(\"" + itemName + "\", " + id_foritem + "); // reset it"); // for else ... if (for_else_block != null) { code.addLine("if (" + id_for + ".empty()) { // line: " + ctx.getStart().getLine()); code.addChild(for_else_block); code.addLine("}"); } return code; } @Override public Code visitFor_expression(For_expressionContext ctx) { String name = ctx.IDENTIFIER().getText(); SegmentCode code = (SegmentCode) ctx.expression().accept(this); assert_not_void_expression(code); TypedKlass resultKlass = null; TypeContext type = ctx.type(); if (type != null) { // 手动定义返回变量的类型 SegmentCode c = (SegmentCode) type.accept(this); resultKlass = c.getTypedKlass(); } else { // 根据 expression 来进行自动类型推导 Class<?> rhsKlass = code.getKlass(); if (rhsKlass.isArray()) { resultKlass = TypedKlass.create(rhsKlass.getComponentType(), code.getTypeArgs()); } else if (Map.class.isAssignableFrom(rhsKlass)) { resultKlass = TypedKlass.create(Map.Entry.class, code.getTypeArgs()); } else if (Collection.class.isAssignableFrom(rhsKlass)) { if (code.getTypeArgs() != null && code.getTypeArgs().length == 1) { resultKlass = code.getTypeArgs()[0]; } } } if (resultKlass == null) { resultKlass = TypedKlass.Object; } // 必须是 Boxed 对象，因为需要强制类型转换 from iterator.next() resultKlass = resultKlass.asBoxedTypedKlass(); if (!scopeCode.define(name, resultKlass)) { throw reportError("Duplicate local variable " + name, ctx.IDENTIFIER()); } return new ForExpressionCode(resultKlass, name, code.toString(), ctx); } @Override public Code visitBreak_directive(Break_directiveContext ctx) { assert_inside_of_for_directive(ctx, "#break"); ExpressionContext expression = ctx.expression(); String source; if (expression != null) { SegmentCode c = (SegmentCode) expression.accept(this); source = get_if_expression_source(c); } else { source = "true"; } source = "if (" + source + ") break; // line: " + ctx.getStart().getLine(); return scopeCode.createLineCode(source); } @Override public Code visitContinue_directive(Continue_directiveContext ctx) { assert_inside_of_for_directive(ctx, "#continue"); ExpressionContext expression = ctx.expression(); String source; if (expression != null) { SegmentCode c = (SegmentCode) expression.accept(this); source = get_if_expression_source(c); } else { source = "true"; } source = "if (" + source + ") continue; // line: " + ctx.getStart().getLine(); return scopeCode.createLineCode(source); } @Override public Code visitStop_directive(Stop_directiveContext ctx) { ExpressionContext expression = ctx.expression(); String source; if (expression != null) { SegmentCode c = (SegmentCode) expression.accept(this); source = get_if_expression_source(c); } else { source = "true"; } source = "if (" + source + ") return; // line: " + ctx.getStart().getLine(); return scopeCode.createLineCode(source); } @Override public Code visitInclude_directive(Include_directiveContext ctx) { Expression_listContext expression_list = ctx.expression_list(); SegmentListCode childrenCode = (SegmentListCode) expression_list.accept(this); if (childrenCode.size() > 2) { throw reportError("Arguments mismatch for #include directive.", ctx); } // argument 1: file SegmentCode fileCode = childrenCode.getChild(0); ExpressionContext fileExpression = expression_list.expression(0); if (!String.class.equals(fileCode.getKlass())) { throw reportError("Type mismatch: the first argument cannot convert from " + fileCode.getKlassName() + " to String", fileExpression); } // argument 2: parameters SegmentCode parametersCode = null; if (childrenCode.size() > 1) { parametersCode = childrenCode.getChild(1); if (!(Map.class.equals(parametersCode.getKlass()))) { throw reportError("Type mismatch: the second argument cannot convert from " + parametersCode.getKlassName() + " to Map", expression_list.expression(1)); } } // 如果 file 是常量，那么进行 file.exists() 校验 if (fileExpression instanceof Expr_constantContext) { String file = fileCode.toString(); file = file.substring(1, file.length() - 1); file = StringEscapeUtils.unescapeJava(file); file = PathUtils.getAbsolutionName(resource.getName(), file); if (!engine.lookupResource(file)) { throw reportError("FileNotFoundException: " + file, fileExpression); } } // 生成代码 StringBuilder source = new StringBuilder(); source.append("JetUtils.asInclude($ctx, "); source.append(fileCode.toString()); source.append(", (Map<String, Object>)"); source.append((parametersCode != null) ? parametersCode.toString() : "null"); source.append("); // line: "); source.append(ctx.getStart().getLine()); return scopeCode.createLineCode(source.toString()); } @Override public Code visitTag_directive(Tag_directiveContext ctx) { String text = ctx.getChild(0).getText(); String name = text.substring(5, text.length() - 1).trim(); TagCode tagCode = scopeCode.createTagCode(); tagCode.setTagId(getUid("tag")); scopeCode = tagCode.getMethodCode(); scopeCode.define(Code.CONTEXT_NAME, TypedKlass.JetContext); scopeCode.setBodyCode(ctx.block().accept(this)); // add body content scopeCode = scopeCode.pop(); // finding tag function Expression_listContext expression_list = ctx.expression_list(); SegmentListCode segmentListCode = (expression_list == null) ? SegmentListCode.EMPTY : (SegmentListCode) expression_list.accept(this); Class<?>[] parameterTypes = segmentListCode.getParameterTypes(JetTagContext.class); Method method = resolver.resolveTagMethod(name, parameterTypes); if (method == null) { throw reportError("Undefined tag definition: " + getMethodSignature(name, parameterTypes), ctx); } tagCode.setMethod(method); tagCode.setExpressionListCode(segmentListCode); return tagCode; } @Override public Code visitMacro_directive(Macro_directiveContext ctx) { String text = ctx.getChild(0).getText(); String name = text.substring(7, text.length() - 1).trim(); MacroCode macroCode = scopeCode.createMacroCode(); macroCode.setName(name); scopeCode = macroCode.getMethodCode(); scopeCode.define(Code.CONTEXT_NAME, TypedKlass.JetContext); // 处理参数 Define_expression_listContext define_expression_list = ctx.define_expression_list(); if (define_expression_list != null) { SegmentListCode define_list_code = (SegmentListCode) define_expression_list.accept(this); macroCode.setDefineListCode(define_list_code); // 设置参数 Context for (SegmentCode node : define_list_code.getChildren()) { DefineExpressionCode c = (DefineExpressionCode) node; scopeCode.define(c.getName(), c.getTypedKlass()); } } // 需要先定义 macro，这样可以支持 macro 的递归调用 (issue 102) if (macroMap == null) { macroMap = new HashMap<String, MacroCode>(8); } MacroCode old = macroMap.put(name, macroCode); if (old != null) { throw reportError("Duplicated macro defination " + name, ctx); } tcc.addMacro(macroCode); // 访问 macro body scopeCode.setBodyCode(ctx.block().accept(this)); // add body content scopeCode = scopeCode.pop(); return Code.EMPTY; } @Override public Code visitInvalid_directive(Invalid_directiveContext ctx) { throw reportError("Missing arguments for " + ctx.getText() + " directive.", ctx); } @Override public Code visitExpr_group(Expr_groupContext ctx) { SegmentCode code = (SegmentCode) ctx.expression().accept(this); String source = "(" + code.toString() + ")"; return new SegmentCode(code.getTypedKlass(), source, ctx); } @Override public Code visitExpr_constant(Expr_constantContext ctx) { return ctx.getChild(0).accept(this); } @Override public Code visitExpr_array_list(Expr_array_listContext ctx) { String source = "Collections.EMPTY_LIST"; Expression_listContext expression_list = ctx.expression_list(); if (expression_list != null) { Code code = expression_list.accept(this); source = "Arrays.asList(" + code.toString() + ")"; } return new SegmentCode(List.class, source, ctx); } @Override public Code visitExpr_hash_map(Expr_hash_mapContext ctx) { String source = "Collections.EMPTY_MAP"; Hash_map_entry_listContext hash_map_entry_list = ctx.hash_map_entry_list(); if (hash_map_entry_list != null) { Code code = hash_map_entry_list.accept(this); source = "JetUtils.asMap(" + code.toString() + ")"; } return new SegmentCode(Map.class, source, ctx); } @Override public Code visitHash_map_entry_list(Hash_map_entry_listContext ctx) { List<ExpressionContext> expression_list = ctx.expression(); SegmentListCode code = new SegmentListCode(expression_list.size()); for (ExpressionContext expression : expression_list) { code.addChild((SegmentCode) expression.accept(this)); } return code; } @Override public Code visitExpr_identifier(Expr_identifierContext ctx) { String name = assert_java_identifier(ctx.IDENTIFIER(), false); // 特殊处理 for 变量 if ("for".equals(name)) { assert_inside_of_for_directive(ctx, "Local variable \"for\""); // 强制映射成 JetForStatus $for String forStatus = forStack.peek(); // 取出 forStatus 的实际变量名 return new SegmentCode(TypedKlass.JetForStatus, forStatus, ctx); } // 找到变量的类型 TypedKlass resultKlass = scopeCode.resolve(name, false); if (resultKlass == null) { // 没有定义过，继续向上深度查找 resultKlass = scopeCode.resolve(name, true); // 没有定义过，则查找全局定义 if (resultKlass == null) { resultKlass = resolver.resolveVariable(name); } if (scopeCode.define(name, resultKlass, true)) { if (resultKlass == TypedKlass.Object) { //removed unsed warning in 1.2.0 //log.warn("line " + ctx.getStart().getLine() + ": Implicit definition for context variable: " + resultKlass.toString() + " " + name); } } } return new SegmentCode(resultKlass, name, ctx); } @Override public Code visitExpr_field_access(Expr_field_accessContext ctx) { SegmentCode code = (SegmentCode) ctx.expression().accept(this); String name = ctx.IDENTIFIER().getText(); assert_not_null_constantContext(code.getNode()); // 进行类型推导，找到方法的返回类型 code = code.asBoxedSegmentCode(); Class<?> beanClass = code.getKlass(); Member member = null; if ((!beanClass.isArray()) || (!"length".equals(name))) { // not array.length member = resolver.resolveProperty(beanClass, name); if (member == null) { // reportError name = name.substring(0, 1).toUpperCase() + name.substring(1); StringBuilder err = new StringBuilder(128); err.append("The method "); err.append("get" + name); err.append("() or "); err.append("is" + name); err.append("() is undefined for the type "); err.append(beanClass.getName()); err.append('.'); if (Object.class.equals(beanClass)) { err.append("\n advise: "); if (code.getNode() instanceof Expr_identifierContext) { err.append("Please use #define(type "); err.append(code.getNode().getText()); err.append(") to define variable type."); } else { err.append("Please use #set(type xxx = "); err.append(code.getNode().getText()); err.append(") to define expression type."); } } throw reportError(err.toString(), ctx.IDENTIFIER()); } } boolean isSafeCall = globalSafeCall || "?.".equals(ctx.getChild(1).getText()); // 生成code StringBuilder sb = new StringBuilder(64); TypedKlass resultKlass = null; if (member instanceof Method) { Method method = (Method) member; if (securityManager != null) { securityManager.checkMemberAccess(method); } // special code for Map.get() // https://github.com/subchen/jetbrick-template/issues/100 TypedKlass typedKlass = code.getTypedKlass(); if ("get".equals(method.getName()) && member.getDeclaringClass() == Map.class) { if (typedKlass.getTypeArgs().length >=2) { resultKlass = typedKlass.getTypeArgs()[1]; } } if (resultKlass == null) { resultKlass = TypedKlassUtils.getMethodReturnTypedKlass(method); } if (method.getParameterTypes().length == 0) { // getXXX() or isXXX() if (isSafeCall) { // 安全调用，防止 NullPointException boolean boxWhenSafeCall = false; if (resultKlass.isPrimitive()) { boxWhenSafeCall = true; resultKlass = resultKlass.asBoxedTypedKlass(); } sb.append("(("); sb.append(code.toString()); sb.append("==null)?("); sb.append(resultKlass.getSource()); sb.append(")null:"); if (boxWhenSafeCall) { sb.append(resultKlass.getSource()).append(".valueOf("); } sb.append(code.toString()); sb.append('.'); sb.append(method.getName()); sb.append("()"); if (boxWhenSafeCall) { sb.append(')'); } sb.append(')'); } else { sb.append(code.toString()); sb.append('.'); sb.append(method.getName()); sb.append("()"); } } else { // get(String) if (isSafeCall) { // 安全调用，防止 NullPointException boolean boxWhenSafeCall = false; if (resultKlass.isPrimitive()) { boxWhenSafeCall = true; resultKlass = resultKlass.asBoxedTypedKlass(); } sb.append("(("); sb.append(code.toString()); sb.append("==null)?("); sb.append(resultKlass.getSource()); sb.append(")null:"); if (boxWhenSafeCall) { sb.append(resultKlass.getSource()).append(".valueOf("); } sb.append(code.toString()); sb.append(".get(\""); sb.append(name); sb.append("\")"); if (boxWhenSafeCall) { sb.append(')'); } sb.append(')'); } else { sb.append(code.toString()); sb.append(".get(\""); sb.append(name); sb.append("\")"); } } } else { if (member instanceof Field) { if (securityManager != null) { securityManager.checkMemberAccess((Field) member); } resultKlass = TypedKlassUtils.getFieldTypedKlass((Field) member); } else { // array.length resultKlass = TypedKlass.create(Integer.TYPE); } if (isSafeCall) { // 安全调用，防止 NullPointException boolean boxWhenSafeCall = false; if (resultKlass.isPrimitive()) { boxWhenSafeCall = true; resultKlass = resultKlass.asBoxedTypedKlass(); } sb.append("(("); sb.append(code.toString()); sb.append("==null)?("); sb.append(resultKlass.getSource()); sb.append(")null:"); if (boxWhenSafeCall) { sb.append(resultKlass.getSource()).append(".valueOf("); } sb.append(code.toString()); sb.append('.'); sb.append(name); if (boxWhenSafeCall) { sb.append(')'); } sb.append(')'); } else { sb.append(code.toString()); sb.append('.'); sb.append(name); } } return new SegmentCode(resultKlass, sb.toString(), ctx); } @Override public Code visitExpr_method_invocation(Expr_method_invocationContext ctx) { // 处理参数 Expression_listContext expression_list = ctx.expression_list(); SegmentListCode segmentListCode = (expression_list == null) ? SegmentListCode.EMPTY : (SegmentListCode) expression_list.accept(this); Class<?>[] parameterTypes = segmentListCode.getParameterTypes(); // 查找方法 SegmentCode code = (SegmentCode) ctx.expression().accept(this); assert_not_null_constantContext(code.getNode()); code = code.asBoxedSegmentCode(); Class<?> beanClass = code.getKlass(); String name = ctx.IDENTIFIER().getText(); Method bean_method = resolver.resolveMethod(beanClass, name, parameterTypes); Method tool_method = (bean_method != null) ? null : resolver.resolveToolMethod(beanClass, name, parameterTypes); boolean tool_advanced = false; if (bean_method == null && tool_method == null) { tool_method = resolver.resolveToolMethod_advanced(beanClass, name, parameterTypes); tool_advanced = true; } if (bean_method == null && tool_method == null) { // reportError StringBuilder err = new StringBuilder(128); err.append("The method ").append(getMethodSignature(name, parameterTypes)); err.append(" is undefined for the type "); err.append(beanClass.getName()); err.append('.'); if (Object.class.equals(beanClass)) { err.append("\n advise: "); if (code.getNode() instanceof Expr_identifierContext) { err.append("Please use #define(type "); err.append(code.getNode().getText()); err.append(") to define variable type."); } else { err.append("Please use #set(type xxx = "); err.append(code.getNode().getText()); err.append(") to define expression type."); } } throw reportError(err.toString(), ctx.IDENTIFIER()); } boolean isSafeCall = globalSafeCall || "?.".equals(ctx.getChild(1).getText()); // 得到方法的返回类型 Method method = (bean_method == null) ? tool_method : bean_method; if (securityManager != null) { securityManager.checkMemberAccess(method); } TypedKlass resultKlass = TypedKlassUtils.getMethodReturnTypedKlass(method); boolean boxWhenSafeCall = resultKlass.isPrimitive(); if (isSafeCall) { resultKlass = resultKlass.asBoxedTypedKlass(); } // 生成code StringBuilder sb = new StringBuilder(64); if (tool_method != null) { // tool method if (isSafeCall) { // 安全调用，防止 NullPointException sb.append('('); sb.append(code.toString()); sb.append("==null)?("); sb.append(resultKlass.getSource()); sb.append(")null:"); if (boxWhenSafeCall) { sb.append(resultKlass.getSource()).append(".valueOf("); } } sb.append(ClassUtils.getShortClassName(tool_method.getDeclaringClass())); sb.append('.'); sb.append(name); sb.append('('); sb.append(code.toString()); if (tool_advanced) { sb.append(",$ctx"); } if (segmentListCode.size() > 0) { sb.append(','); } } else { if (isSafeCall) { // 安全调用，防止 NullPointException sb.append('('); sb.append(code.toString()); sb.append("==null)?("); sb.append(resultKlass.getSource()); sb.append(")null:"); if (boxWhenSafeCall) { sb.append(resultKlass.getSource()).append(".valueOf("); } } sb.append(code.toString()); sb.append('.'); sb.append(name); sb.append('('); } if (segmentListCode.size() > 0) { sb.append(segmentListCode.toString()); } sb.append(')'); if (isSafeCall) { // 为了安全起见，用()包起来 if (boxWhenSafeCall) { sb.append(')'); } sb.insert(0, '(').append(')'); } return new SegmentCode(resultKlass, sb.toString(), ctx); } @Override public Code visitExpr_function_call(Expr_function_callContext ctx) { // 处理参数 Expression_listContext expression_list = ctx.expression_list(); SegmentListCode segmentListCode = (expression_list == null) ? SegmentListCode.EMPTY : (SegmentListCode) expression_list.accept(this); Class<?>[] parameterTypes = segmentListCode.getParameterTypes(); // 查找方法 String name = ctx.IDENTIFIER().getText(); // 优先查找 macro MacroCode macroCode = null; if (macroMap != null) { macroCode = macroMap.get(name); if (macroCode != null) { // macro 参数匹配 SegmentListCode defineListCode = macroCode.getDefineListCode(); int size = (defineListCode == null) ? 0 : defineListCode.size(); if (parameterTypes.length != size) { throw reportError("Arguments mismatch for #macro " + getMethodSignature(name, parameterTypes) + ".", ctx.IDENTIFIER()); } for (int i = 0; i < parameterTypes.length; i++) { if (!ClassUtils.isAssignable(parameterTypes[i], defineListCode.getChild(i).getKlass())) { throw reportError("Arguments mismatch for #macro " + getMethodSignature(name, parameterTypes) + ".", ctx.IDENTIFIER()); } } // 生成 macro 调用 code StringBuilder sb = new StringBuilder(64); sb.append("$macro_").append(name); sb.append("($ctx"); if (segmentListCode.size() > 0) { sb.append(',').append(segmentListCode.toString()); } sb.append(')'); return new SegmentCode(TypedKlass.VOID, sb.toString(), ctx); } } // 查找扩展方法 boolean advanced = false; Method method = resolver.resolveFunction(name, parameterTypes); if (method == null) { method = resolver.resolveFunction_advanced(name, parameterTypes); advanced = true; } if (method == null) { throw reportError("Undefined function or arguments mismatch: " + getMethodSignature(name, parameterTypes) + ".", ctx.IDENTIFIER()); } if (securityManager != null) { securityManager.checkMemberAccess(method); } // 生成code StringBuilder sb = new StringBuilder(64); sb.append(ClassUtils.getShortClassName(method.getDeclaringClass())); sb.append('.'); sb.append(name); sb.append('('); if (advanced) { sb.append("$ctx"); } if (segmentListCode.size() > 0) { if (advanced) sb.append(','); sb.append(segmentListCode.toString()); } sb.append(')'); TypedKlass typedKlass = TypedKlassUtils.getMethodReturnTypedKlass(method); return new SegmentCode(typedKlass, sb.toString(), ctx); } @Override public Code visitExpr_static_field_access(Expr_static_field_accessContext ctx) { SegmentCode static_type_name_code = (SegmentCode) ctx.static_type_name().accept(this); String typeName = static_type_name_code.toString(); String name = ctx.IDENTIFIER().getText(); Class<?> beanClass = resolver.resolveClass(typeName); if (beanClass == null) { throw reportError("java.lang.ClassNotFoundException: " + typeName, static_type_name_code.getNode()); } Field field = resolver.resolveStaticField(beanClass, name); if (field == null) { throw reportError(name + " is not a static field for type " + beanClass.getName(), ctx.IDENTIFIER()); } if (securityManager != null) { securityManager.checkMemberAccess(field); } String source = ClassUtils.getShortClassName(field.getDeclaringClass()) + '.' + name; TypedKlass resultKlass = TypedKlassUtils.getFieldTypedKlass(field); return new SegmentCode(resultKlass, source, ctx); } @Override public Code visitExpr_static_method_invocation(Expr_static_method_invocationContext ctx) { SegmentCode static_type_name_code = (SegmentCode) ctx.static_type_name().accept(this); String typeName = static_type_name_code.toString(); String name = ctx.IDENTIFIER().getText(); // 获取静态 Class Class<?> beanClass = resolver.resolveClass(typeName); if (beanClass == null) { throw reportError("java.lang.ClassNotFoundException: " + typeName, static_type_name_code.getNode()); } // 处理参数 Expression_listContext expression_list = ctx.expression_list(); SegmentListCode segmentListCode = (expression_list == null) ? SegmentListCode.EMPTY : (SegmentListCode) expression_list.accept(this); Class<?>[] parameterTypes = segmentListCode.getParameterTypes(); Method method = resolver.resolveStaticMethod(beanClass, name, parameterTypes); if (method == null) { throw reportError("The static method " + getMethodSignature(name, parameterTypes) + " is undefined for the type " + beanClass.getName(), ctx.IDENTIFIER()); } if (securityManager != null) { securityManager.checkMemberAccess(method); } // 生成代码 StringBuilder sb = new StringBuilder(); sb.append(ClassUtils.getShortClassName(method.getDeclaringClass())); sb.append('.'); sb.append(name); sb.append('('); sb.append(segmentListCode.toString()); sb.append(')'); TypedKlass resultKlass = TypedKlassUtils.getMethodReturnTypedKlass(method); return new SegmentCode(resultKlass, sb.toString(), ctx); } @Override public Code visitStatic_type_name(Static_type_nameContext ctx) { List<TerminalNode> name_list = ctx.IDENTIFIER(); StringBuilder sb = new StringBuilder(); for (TerminalNode node : name_list) { if (sb.length() > 0) { sb.append('.'); } sb.append(node.getText()); } return new SegmentCode(TypedKlass.NULL, sb.toString(), ctx); } @Override public Code visitExpr_array_get(Expr_array_getContext ctx) { SegmentCode lhs = (SegmentCode) ctx.expression(0).accept(this); SegmentCode rhs = (SegmentCode) ctx.expression(1).accept(this); assert_not_null_constantContext(lhs.getNode()); assert_not_null_constantContext(rhs.getNode()); boolean isSafeCall = globalSafeCall || "?".equals(ctx.getChild(1).getText()); Class<?> lhsKlass = lhs.getKlass(); if (lhsKlass.isArray()) { if (!ClassUtils.isAssignable(Integer.TYPE, rhs.getKlass())) { throw reportError("Type mismatch: cannot convert from " + rhs.getKlassName() + " to int.", lhs.getNode()); } TypedKlass resultKlass = TypedKlass.create(lhsKlass.getComponentType(), lhs.getTypeArgs()); boolean boxWhenSafeCall = resultKlass.isPrimitive(); if (isSafeCall) { resultKlass = resultKlass.asBoxedTypedKlass(); } StringBuilder sb = new StringBuilder(); if (isSafeCall) { sb.append('('); sb.append(lhs.toString()); sb.append("==null?("); sb.append(resultKlass.getSource()); sb.append(")null:"); if (boxWhenSafeCall) { sb.append(resultKlass.getSource()).append(".valueOf("); } sb.append(lhs.toString()); sb.append('['); sb.append(rhs.toString()); sb.append(']'); if (boxWhenSafeCall) { sb.append(')'); } sb.append(')'); } else { sb.append(lhs.toString()); sb.append('['); sb.append(rhs.toString()); sb.append(']'); } return new SegmentCode(resultKlass, sb.toString(), ctx); } else { TypedKlass resultKlass = null; // try to List.get(index) or Map.get(name) or JetContext.get(name) if (List.class.isAssignableFrom(lhsKlass)) { if (!ClassUtils.isAssignable(Integer.TYPE, rhs.getKlass())) { throw reportError("The method get(int) in the type List is not applicable for the arguments (" + rhs.getKlassName() + ")", rhs.getNode()); } // 取出可能的List泛型 if (lhs.getTypeArgs() != null && lhs.getTypeArgs().length == 1) { resultKlass = lhs.getTypeArgs()[0]; } } else if (Map.class.isAssignableFrom(lhsKlass)) { // 取出可能的Map泛型 if (lhs.getTypeArgs() != null && lhs.getTypeArgs().length == 2) { resultKlass = lhs.getTypeArgs()[1]; // value 对应的泛型 } } else if (JetContext.class.isAssignableFrom(lhsKlass)) { if (!String.class.equals(rhs.getKlass())) { throw reportError("The method get(String) in the type JetContext is not applicable for the arguments (" + rhs.getKlassName() + ")", rhs.getNode()); } resultKlass = TypedKlass.Object; } else { throw reportError("Operator [] is not applicable for the object (" + lhs.getKlassName() + ").", ctx); } if (resultKlass == null) { resultKlass = TypedKlass.Object; } boolean boxWhenSafeCall = resultKlass.isPrimitive(); if (isSafeCall) { resultKlass = resultKlass.asBoxedTypedKlass(); } StringBuilder sb = new StringBuilder(); if (isSafeCall) { sb.append('('); sb.append(lhs.toString()); sb.append("==null?("); sb.append(resultKlass.getSource()); sb.append(")null:"); if (boxWhenSafeCall) { sb.append(resultKlass.getSource()).append(".valueOf("); } sb.append(lhs.toString()); sb.append(".get("); sb.append(rhs.toString()); sb.append(')'); if (boxWhenSafeCall) { sb.append(')'); } sb.append(')'); } else { sb.append(lhs.toString()); sb.append(".get("); sb.append(rhs.toString()); sb.append(')'); } return new SegmentCode(resultKlass, sb.toString(), ctx); } } @Override public Code visitExpr_new_object(Expr_new_objectContext ctx) { SegmentCode code = (SegmentCode) ctx.type().accept(this); Expression_listContext expression_list = ctx.expression_list(); SegmentListCode segmentListCode = (expression_list == null) ? SegmentListCode.EMPTY : (SegmentListCode) expression_list.accept(this); Class<?>[] parameterTypes = segmentListCode.getParameterTypes(); // 查找对应的构造函数 Class<?> beanClass = code.getKlass(); Constructor<?> constructor = resolver.resolveConstructor(beanClass, parameterTypes); if (constructor == null) { // reportError StringBuilder err = new StringBuilder(128); err.append("The constructor "); err.append(getMethodSignature(beanClass.getSimpleName(), parameterTypes)); err.append(" is undefined for the type "); err.append(beanClass.getName()); err.append('.'); throw reportError(err.toString(), ctx.type()); } // 生成代码 StringBuilder source = new StringBuilder(32); source.append("(new ").append(code.toString()).append('('); if (segmentListCode.size() > 0) { source.append(segmentListCode.toString()); } source.append("))"); return new SegmentCode(code.getTypedKlass(), source.toString(), ctx); } @Override public Code visitExpr_new_array(Expr_new_arrayContext ctx) { SegmentCode code = (SegmentCode) ctx.type().accept(this); if (code.getKlass().isArray()) { throw reportError("Cannot specify an array dimension after an empty dimension", ctx.type()); } StringBuilder typeSource = new StringBuilder(code.toString()); // 生成代码 StringBuilder source = new StringBuilder(32); source.append("(new ").append(code.toString()); for (ExpressionContext expression : ctx.expression()) { SegmentCode c = (SegmentCode) expression.accept(this); if (!ClassUtils.isAssignable(Integer.TYPE, c.getKlass())) { throw reportError("Type mismatch: cannot convert from " + c.getKlassName() + " to int.", expression); } source.append('[').append(c.toString()).append(']'); typeSource.append("[]"); } source.append(')'); TypedKlass resultKlass = resolver.resolveTypedKlass(typeSource.toString()); return new SegmentCode(resultKlass, source.toString(), ctx); } @Override public Code visitExpr_class_cast(Expr_class_castContext ctx) { SegmentCode code = (SegmentCode) ctx.type().accept(this); Code expr_code = ctx.expression().accept(this); String source = "((" + code.toString() + ")" + expr_code.toString() + ")"; return new SegmentCode(code.getTypedKlass(), source, ctx); } @Override public Code visitExpr_instanceof(Expr_instanceofContext ctx) { SegmentCode lhs = (SegmentCode) ctx.expression().accept(this); SegmentCode rhs = (SegmentCode) ctx.type().accept(this); if (!ClassUtils.isAssignable(lhs.getKlass(), rhs.getKlass()) && !ClassUtils.isAssignable(lhs.getKlass(), rhs.getKlass())) { throw reportError("Incompatible conditional operand types " + lhs.getKlassName() + " and " + rhs.getKlassName(), ctx.getChild(1)); } String source = "(" + lhs.toString() + " instanceof " + rhs.toString() + ")"; return new SegmentCode(Boolean.TYPE, source, ctx); } @Override public Code visitExpr_math_unary_suffix(Expr_math_unary_suffixContext ctx) { ExpressionContext expression = ctx.expression(); SegmentCode code = (SegmentCode) expression.accept(this); String op = ctx.getChild(1).getText(); assert_not_null_constantContext(expression); // ++, -- if (expression.getChildCount() == 1 && expression.getChild(0) instanceof ConstantContext) { throw reportError("Invalid argument to operation " + op + ", required: variable, found Value", expression); } // 类型检查 Class<?> resultKlass = PromotionUtils.get_unary_inc_dec(code.getKlass(), op); if (resultKlass == null) { throw reportError("The UnaryOperator \"" + op + "\" is not applicable for the operand " + code.getKlassName(), ctx.getChild(1)); } String source = "(" + code.toString() + op + ")"; return new SegmentCode(code.getTypedKlass(), source, ctx); } @Override public Code visitExpr_math_unary_prefix(Expr_math_unary_prefixContext ctx) { ExpressionContext expression = ctx.expression(); SegmentCode code = (SegmentCode) expression.accept(this); String op = ctx.getChild(0).getText(); assert_not_null_constantContext(expression); // 类型检查 Class<?> resultKlass; if (op.length() == 1) { // +, -, ~ resultKlass = PromotionUtils.get_unary_basic(code.getKlass(), op); } else { // ++, -- if (expression.getChildCount() == 1 && expression.getChild(0) instanceof ConstantContext) { throw reportError("Invalid argument to operation " + op + ", required: variable, found Value", expression); } resultKlass = PromotionUtils.get_unary_inc_dec(code.getKlass(), op); } if (resultKlass == null) { throw reportError("The UnaryOperator \"" + op + "\" is not applicable for the operand " + code.getKlassName(), ctx.getChild(0)); } String source = "(" + op + code.toString() + ")"; return new SegmentCode(code.getTypedKlass(), source, ctx); } @Override public Code visitExpr_math_binary_basic(Expr_math_binary_basicContext ctx) { SegmentCode lhs = (SegmentCode) ctx.expression(0).accept(this); SegmentCode rhs = (SegmentCode) ctx.expression(1).accept(this); String op = ctx.getChild(1).getText(); // 类型检查 Class<?> resultKlass = PromotionUtils.get_binary_basic(lhs.getKlass(), rhs.getKlass(), op); if (resultKlass == null) { throw reportError("The BinaryOperator \"" + op + "\" is not applicable for the operands " + lhs.getKlassName() + " and " + rhs.getKlassName(), ctx.getChild(1)); } String source = "(" + lhs.toString() + op + rhs.toString() + ")"; return new SegmentCode(resultKlass, source, ctx); } @Override public Code visitExpr_math_binary_shift(Expr_math_binary_shiftContext ctx) { SegmentCode lhs = (SegmentCode) ctx.expression(0).accept(this); SegmentCode rhs = (SegmentCode) ctx.expression(1).accept(this); // Combined '>' '>' => '>>' String op = ""; for (int i = 1; i < ctx.getChildCount() - 1; i++) { ParseTree node = ctx.getChild(i); if (node instanceof TerminalNode) { op = op + node.getText(); } } // 类型检查 Class<?> resultKlass = PromotionUtils.get_binary_shift(lhs.getKlass(), rhs.getKlass(), op); if (resultKlass == null) { throw reportError("The BinaryOperator \"" + op + "\" is not applicable for the operands " + lhs.getKlassName() + " and " + rhs.getKlassName(), ctx.getChild(1)); } String source = "(" + lhs.toString() + op + rhs.toString() + ")"; return new SegmentCode(resultKlass, source, ctx); } @Override public Code visitExpr_math_binary_bitwise(Expr_math_binary_bitwiseContext ctx) { SegmentCode lhs = (SegmentCode) ctx.expression(0).accept(this); SegmentCode rhs = (SegmentCode) ctx.expression(1).accept(this); String op = ctx.getChild(1).getText(); // 类型检查 Class<?> resultKlass = PromotionUtils.get_binary_bitwise(lhs.getKlass(), rhs.getKlass(), op); if (resultKlass == null) { throw reportError("The BinaryOperator \"" + op + "\" is not applicable for the operands " + lhs.getKlassName() + " and " + rhs.getKlassName(), ctx); } String source = "(" + lhs.toString() + op + rhs.toString() + ")"; return new SegmentCode(resultKlass, source, ctx); } @Override public Code visitExpr_compare_not(Expr_compare_notContext ctx) { SegmentCode code = (SegmentCode) ctx.expression().accept(this); String source = "(!" + get_if_expression_source(code) + ")"; return new SegmentCode(Boolean.TYPE, source, ctx); } @Override public Code visitExpr_compare_equality(Expr_compare_equalityContext ctx) { SegmentCode lhs = (SegmentCode) ctx.expression(0).accept(this); SegmentCode rhs = (SegmentCode) ctx.expression(1).accept(this); TerminalNode op = (TerminalNode) ctx.getChild(1); assert_not_void_expression(lhs); assert_not_void_expression(rhs); StringBuilder source = new StringBuilder(32); source.append("==".equals(op.getText()) ? "JetUtils.asEquals(" : "JetUtils.asNotEquals("); source.append(lhs.toString()); source.append(','); source.append(rhs.toString()); source.append(')'); return new SegmentCode(Boolean.TYPE, source.toString(), ctx); } @Override public Code visitExpr_compare_relational(Expr_compare_relationalContext ctx) { SegmentCode lhs = (SegmentCode) ctx.expression(0).accept(this); SegmentCode rhs = (SegmentCode) ctx.expression(1).accept(this); TerminalNode op = (TerminalNode) ctx.getChild(1); assert_not_void_expression(lhs); assert_not_void_expression(rhs); assert_not_null_constantContext(lhs.getNode()); assert_not_null_constantContext(rhs.getNode()); Class<?> c1 = lhs.getKlass(); Class<?> c2 = rhs.getKlass(); // 类型校验 boolean pass = true; if (NumberClassUtils.isNumbericClass(c1)) { pass = NumberClassUtils.isNumbericClass(c2); } else if (NumberClassUtils.isNumbericClass(c2)) { pass = false; } else { pass = c1.isAssignableFrom(c2) || c2.isAssignableFrom(c1); } if (pass == false) { throw reportError("The operator " + op.getText() + " is undefined for the argument type(s) " + lhs.getKlassName() + ", " + rhs.getKlassName(), op); } String suffix = ""; switch (op.getSymbol().getType()) { case JetTemplateParser.OP_RELATIONAL_GT: suffix = ">0"; break; case JetTemplateParser.OP_RELATIONAL_LT: suffix = "<0"; break; case JetTemplateParser.OP_RELATIONAL_GE: suffix = ">=0"; break; case JetTemplateParser.OP_RELATIONAL_LE: suffix = "<=0"; break; default: throw reportError("Unexpected operator :" + op.getText(), ctx); } StringBuilder source = new StringBuilder(32); source.append("(JetUtils.asCompareWith("); source.append(lhs.toString()); source.append(','); source.append(rhs.toString()); source.append(')'); source.append(suffix); source.append(')'); return new SegmentCode(Boolean.TYPE, source.toString(), ctx); } @Override public Code visitExpr_compare_condition(Expr_compare_conditionContext ctx) { SegmentCode lhs = (SegmentCode) ctx.expression(0).accept(this); SegmentCode rhs = (SegmentCode) ctx.expression(1).accept(this); String op = ctx.getChild(1).getText(); assert_not_void_expression(lhs); assert_not_void_expression(rhs); String source = "(" + get_if_expression_source(lhs) + op + get_if_expression_source(rhs) + ")"; return new SegmentCode(Boolean.TYPE, source, ctx); } @Override public Code visitExpr_conditional_ternary(Expr_conditional_ternaryContext ctx) { SegmentCode condition = (SegmentCode) ctx.expression(0).accept(this); SegmentCode lhs = (SegmentCode) ctx.expression(1).accept(this); SegmentCode rhs = (SegmentCode) ctx.expression(2).accept(this); String source = "(" + get_if_expression_source(condition) + "?" + lhs.toString() + ":" + rhs.toString() + ")"; TypedKlass klass = PromotionUtils.getResultClassForConditionalOperator(lhs.getTypedKlass(), rhs.getTypedKlass()); return new SegmentCode(klass, source, ctx); } @Override public Code visitConstant(ConstantContext ctx) { Token token = ((TerminalNode) ctx.getChild(0)).getSymbol(); String text = token.getText(); switch (token.getType()) { case JetTemplateParser.STRING_DOUBLE: return new SegmentCode(String.class, text, ctx); case JetTemplateParser.STRING_SINGLE: text = StringEscapeUtils.asCanonicalJavaString(text); return new SegmentCode(String.class, text, ctx); case JetTemplateParser.INTEGER: case JetTemplateParser.INTEGER_HEX: case JetTemplateParser.FLOATING_POINT: Class<?> klass; if (text.endsWith("l") || text.endsWith("L")) { klass = Long.TYPE; } else if (text.endsWith("f") || text.endsWith("F")) { klass = Float.TYPE; } else if (text.endsWith("d") || text.endsWith("D")) { klass = Double.TYPE; } else if (token.getType() == JetTemplateParser.FLOATING_POINT) { klass = Double.TYPE; // 浮点数默认是double } else { klass = Integer.TYPE; } return new SegmentCode(klass, text, ctx); case JetTemplateParser.KEYWORD_TRUE: return new SegmentCode(Boolean.TYPE, text, ctx); case JetTemplateParser.KEYWORD_FALSE: return new SegmentCode(Boolean.TYPE, text, ctx); case JetTemplateParser.KEYWORD_NULL: return new SegmentCode(TypedKlass.NULL, text, ctx); default: throw reportError("Unexpected token type :" + token.getType(), ctx); } } @Override public Code visitExpression_list(Expression_listContext ctx) { List<ExpressionContext> expression_list = ctx.expression(); SegmentListCode code = new SegmentListCode(expression_list.size()); for (ExpressionContext expression : expression_list) { SegmentCode c = (SegmentCode) expression.accept(this); assert_not_void_expression(c); code.addChild(c); } return code; } @Override public Code visitType(TypeContext ctx) { StringBuilder name = new StringBuilder(); for (TerminalNode node : ctx.IDENTIFIER()) { if (name.length() > 0) { name.append('.'); } name.append(node.getText()); } // 查找 klass Class<?> klass = resolver.resolveClass(name.toString()); if (klass == null) { StringBuilder sb = new StringBuilder(128); sb.append("java.lang.ClassNotFoundException: ").append(name); sb.append("\n advise: Please define package in 'import.packages' or use full qualified class name."); throw reportError(sb.toString(), ctx); } if (securityManager != null) { securityManager.checkMemberAccess(klass); } // 查找泛型类型 typeArgs TypedKlass[] typeArgs = TypedKlass.EMPTY_TYPE_ARGS; Type_argumentsContext type_arguments = ctx.type_arguments(); if (type_arguments != null) { SegmentListCode c = (SegmentListCode) type_arguments.accept(this); typeArgs = new TypedKlass[c.size()]; for (int i = 0; i < typeArgs.length; i++) { typeArgs[i] = c.getChild(i).getTypedKlass(); } } // 如果是数组类型，则把 klass 转成数组 String array_suffix = ""; List<Type_array_suffixContext> type_array_suffix = ctx.type_array_suffix(); for (Type_array_suffixContext c : type_array_suffix) { Code code = c.accept(this); array_suffix = array_suffix + code.toString(); } if (array_suffix.length() > 0) { // 转换成 Array Class, 重新 resolve String klassName = name.toString() + array_suffix; klass = resolver.resolveClass(klassName); if (klass == null) { throw reportError("java.lang.ClassNotFoundException: " + klassName, ctx); } } // 返回带有的泛型信息的 Class TypedKlass typedKlass = TypedKlass.create(klass, typeArgs); return new SegmentCode(typedKlass, typedKlass.toString(), ctx); } @Override public Code visitType_array_suffix(Type_array_suffixContext ctx) { return new SegmentCode((TypedKlass) null, "[]", ctx); } @Override public Code visitType_arguments(Type_argumentsContext ctx) { return ctx.type_list().accept(this); } @Override public Code visitType_list(Type_listContext ctx) { List<Type_nameContext> type_name_list = ctx.type_name(); SegmentListCode code = new SegmentListCode(type_name_list.size()); for (Type_nameContext type_name : type_name_list) { Code c = type_name.accept(this); code.addChild((SegmentCode) c); } return code; } @Override public Code visitType_name(Type_nameContext ctx) { TypeContext type = ctx.type(); if (type != null) { return type.accept(this); } // List<?> return new SegmentCode(TypedKlass.WildcharTypedKlass, "?", ctx); } // ----------------------------------------------------------- // 变量必须是合法的 java 变量 private String assert_java_identifier(ParseTree node, boolean isDefining) { String name = node.getText(); if ("for".equals(name)) { if (isDefining) { throw reportError("Syntax error on token \"" + name + "\" is not a valid identifier.", node); } return name; } if (Code.CONTEXT_NAME.equals(name)) { if (isDefining) { throw reportError("Duplicate local variable \"" + name + "\" is a reserved identifier.", node); } return name; } if (SourceVersion.isKeyword(name)) { throw reportError("Syntax error on token \"" + name + "\", It is not a valid identifier in Java.", node); } if (name.startsWith("$")) { throw reportError("Local variable \"" + name + "\" can't start with '$', it is a reserved identifier.", node); } return name; } // 检验 ctx 必须在 #for 里面, 但不能在 for-else 里面 private void assert_inside_of_for_directive(ParserRuleContext ctx, String name) { // 还有一种方法，直接看 forStack 是否为空就可以了 ParserRuleContext p = ctx.getParent(); while (p != null) { if (p instanceof For_directiveContext) { return; } if (p instanceof Else_directiveContext) { // 跳过可能的 for-else 的情况, 继续向上查找 // 当然如果时候 if-else 的情况, 也可以跳过这个 #if，没有问题 p = p.getParent(); } p = p.getParent(); } throw reportError(name + " cannot be used outside of a #for directive", ctx); } // 检测 void 类型 private void assert_not_void_expression(SegmentCode code) { if (Void.TYPE.equals(code.getKlass()) || Void.class.equals(code.getKlass())) { throw reportError("Unexpected void type in here.", code.getNode()); } } // 检测非 null 常量 private void assert_not_null_constantContext(ParserRuleContext node) { if (node.getStart().getType() == JetTemplateParser.KEYWORD_NULL) { throw reportError("Unexpected token: invalid keyword null in here.", node); } } // 确保返回的代码类型必须是 boolean 类型的 private String get_if_expression_source(SegmentCode code) { if (Boolean.TYPE.equals(code.getKlass())) { return code.toString(); } else { assert_not_void_expression(code); return "JetUtils.asBoolean(" + code.toString() + ")"; } } // ----------------------------------------------------------- // 创建一个全局唯一的变量名称 private String getUid(String prefix) { return "$" + prefix + "_" + (uuid++); } private RuntimeException reportError(String message, Object node) { if (node instanceof ParserRuleContext) { parser.notifyErrorListeners(((ParserRuleContext) node).getStart(), message, null); } else if (node instanceof TerminalNode) { parser.notifyErrorListeners(((TerminalNode) node).getSymbol(), message, null); } else if (node instanceof Token) { parser.notifyErrorListeners((Token) node, message, null); } return new SyntaxErrorException(message); } // 等到一个方法描述字符串 private String getMethodSignature(String name, Class<?>[] parameterTypes) { StringBuilder sb = new StringBuilder(); sb.append(name).append('('); for (int i = 0; i < parameterTypes.length; i++) { if (i > 0) { sb.append(','); } Class<?> type = parameterTypes[i]; sb.append(type == null ? "<null>" : type.getSimpleName()); } sb.append(')'); return sb.toString(); } }
