* jetbrick-template

* http://subchen.github.io/jetbrick-template/

*

* Copyright 2010-2014 Guoqiang Chen. All rights reserved.

* Email: subchen@gmail.com

*

* 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.

*/

    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);

        // 生成代码

        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() ...

        String typeName = for_expr_code.getKlassName();

        code.addLine("  " + typeName + " " + for_expr_code.getName() + " = (" + typeName + ") " + id_for + ".next();");

        code.addChild(for_block_code);

        code.addLine("}");

        // 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);