analyzer.java

Jamon是一个Java文本模板引擎

        }

        @Override
        public void outFragmentArgsNode(FragmentArgsNode p_node)
        {
            popStatementBlock();
        }

        @Override
        public void caseArgNode(ArgNode p_node)
        {
            getCurrentStatementBlock().addRequiredArg(p_node);
        }

        @Override
        public void caseOptionalArgNode(OptionalArgNode p_node)
        {
            getCurrentStatementBlock().addOptionalArg(p_node);
        }

        @Override
        public void inDefNode(DefNode p_node)
        {
            pushDefUnit(p_node.getName());
        }

        @Override
        public void outDefNode(DefNode p_def)
        {
            popStatementBlock();
        }

        @Override
        public void inMethodNode(MethodNode p_node)
        {
            pushMethodUnit(p_node.getName());
        }

        @Override
        public void outMethodNode(MethodNode p_node)
        {
            popStatementBlock();
        }

        @Override
        public void inAbsMethodNode(AbsMethodNode p_node)
        {
            if (! getTemplateUnit().isParent())
            {
                addError(
                    "Non-abstract templates cannot have abstract methods",
                    p_node.getLocation());
            }
            pushMethodUnit(p_node.getName());
        }

        @Override
        public void outAbsMethodNode(AbsMethodNode p_node)
        {
            popStatementBlock();
        }

        @Override
        public void inOverrideNode(OverrideNode p_node)
        {
            pushOverriddenMethodUnit(p_node);
        }

        @Override
        public void outOverrideNode(OverrideNode p_node)
        {
            popStatementBlock();
        }

        @Override public void caseGenericsParamNode(GenericsParamNode p_node)
        {
            if (m_templateUnit.isParent())
            {
                addError("<%generics> tag not allowed in abstract templates",
                         p_node.getLocation());
            }
            m_templateUnit.addGenericsParamNode(p_node);
        }

        @Override public void caseSimpleCallNode(SimpleCallNode p_node)
        {
            addStatement(makeCallStatement(p_node));
        }

        @Override
        public void caseChildCallNode(ChildCallNode p_node)
        {
            TemplateUnit unit = getTemplateUnit();
            if (! unit.isParent())
            {
                addError(
                    "<& *CHILD &> cannot be called from a template without an <%abstract> tag",
                    p_node.getLocation());
            }
            addStatement(new ChildCallStatement(unit.getInheritanceDepth()+1));
        }

        @Override
        public void caseClassNode(ClassNode p_node)
        {
            getTemplateUnit().addClassContent(p_node);
        }

        @Override public void caseTextNode(TextNode p_node)
        {
            addStatement(new LiteralStatement(
                p_node.getText(), p_node.getLocation(), m_templateIdentifier));
        }

        @Override public void caseLiteralNode(LiteralNode p_node)
        {
            addStatement(new LiteralStatement(
                p_node.getText(), p_node.getLocation(), m_templateIdentifier));
        }

        @Override
        public void inMultiFragmentCallNode(MultiFragmentCallNode p_node)
        {
            CallStatement s = makeCallStatement(p_node);
            addStatement(s);
            pushCallStatement(s);
        }

        @Override
        public void outMultiFragmentCallNode(MultiFragmentCallNode p_call)
        {
            popCallStatement();
        }

        @Override
        public void inNamedFragmentNode(NamedFragmentNode p_node)
        {
            getCurrentCallStatement().addFragmentImpl(
                pushFragmentUnitImpl(p_node.getName(), p_node.getLocation()), m_errors);
        }

        @Override
        public void outNamedFragmentNode(NamedFragmentNode p_node)
        {
            popStatementBlock();
        }

        @Override
        public void inFragmentCallNode(FragmentCallNode p_node)
        {
            CallStatement s = makeCallStatement(p_node);
            addStatement(s);
            s.addFragmentImpl(pushFragmentUnitImpl(null, p_node.getLocation()), m_errors);
        }

        @Override
        public void outFragmentCallNode(FragmentCallNode p_node)
        {
            popStatementBlock();
        }

        @Override public void inWhileNode(WhileNode p_node)
        {
            pushFlowControlBlock(
                p_node.getLocation(), "while (" + p_node.getCondition() + ")");
        }

        @Override public void outWhileNode(WhileNode p_node)
        {
            popStatementBlock();
        }

        @Override public void inForNode(ForNode p_node)
        {
            pushFlowControlBlock(
                p_node.getLocation(), "for (" + p_node.getLoopSpecifier() + ")");
        }

        @Override public void outForNode(ForNode p_node)
        {
            popStatementBlock();
        }

        @Override public void inIfNode(IfNode p_node)
        {
            pushFlowControlBlock(
                p_node.getLocation(), "if (" + p_node.getCondition() + ")");
        }

        @Override public void outIfNode(IfNode p_node)
        {
            popStatementBlock();
        }

        @Override public void inElseIfNode(ElseIfNode p_node)
        {
            pushFlowControlBlock(
                p_node.getLocation(), "else if (" + p_node.getCondition() + ")");
        }

        @Override public void outElseIfNode(ElseIfNode p_node)
        {
            popStatementBlock();
        }

        @Override public void inElseNode(ElseNode p_node)
        {
            pushFlowControlBlock(p_node.getLocation(), "else");
        }


        @Override public void outElseNode(ElseNode p_node)
        {
            popStatementBlock();
        }

        @Override public void outTopNode(TopNode p_node)
        {
        }

        @Override public void caseJavaNode(JavaNode p_node)
        {
            addStatement(new RawStatement(p_node.getJava(),
                                          p_node.getLocation(),
                                          m_templateIdentifier));
        }

        private class EmitAdapter extends AnalysisAdapter
        {
            EscapingDirective m_escapeCode = null;
            @Override
            public void caseEscapeNode(EscapeNode p_node)
            {
                m_escapeCode = EscapingDirective.get(p_node.getEscapeCode());
                if (m_escapeCode == null)
                {
                    addError("Unknown escaping directive '"
                             + p_node.getEscapeCode()+ "'",
                             p_node.getLocation());
                }
            }

            @Override
            public void caseDefaultEscapeNode(DefaultEscapeNode p_node)
            {
                m_escapeCode = getDefaultEscaping();
            }

            public EscapingDirective getEscape(AbstractEscapeNode p_node)
            {
                p_node.apply(this);
                return m_escapeCode;
            }
        }

        @Override
        public void caseEmitNode(EmitNode p_node)
        {
            addStatement(new WriteStatement
                         (p_node.getEmitExpression(),
                          new EmitAdapter().getEscape(p_node.getEscaping()),
                          p_node.getLocation(),
                          m_templateIdentifier,
                          m_emitMode));
        }
    }

    private String m_defaultEscaping;

    private EscapingDirective getDefaultEscaping()
    {
        return EscapingDirective.get(m_defaultEscaping);
    }

    private CallStatement makeCallStatement(AbstractComponentCallNode p_node)
    {
        String path = computePath(p_node.getCallPath());
        ParamValues paramValues = makeParamValues(p_node.getParams());
        FragmentUnit fragmentUnit =
            getCurrentStatementBlock().getFragmentUnitIntf(path);
        List<GenericCallParam> genericParams = p_node.getGenericParams();
        if (fragmentUnit != null)
        {
            if (!genericParams.isEmpty())
            {
                addError("Fragment" + " calls may not have generic params",
                         p_node.getLocation());
            }
            return new FargCallStatement(path,
                                         paramValues,
                                         fragmentUnit,
                                         p_node.getLocation(),
                                         m_templateIdentifier);
        }
        else
        {
            DefUnit defUnit = getTemplateUnit().getDefUnit(path);
            if (defUnit != null)
            {
                if (! genericParams.isEmpty())
                {
                    addError("def " + defUnit.getName() +
                             " is being called with generic parameters",
                             p_node.getLocation());
                }
                return new DefCallStatement(path,
                                            paramValues,
                                            defUnit,
                                            p_node.getLocation(),
                                            m_templateIdentifier);
            }
            else
            {
                MethodUnit methodUnit = getTemplateUnit().getMethodUnit(path);
                if (methodUnit != null)
                {
                    if (! genericParams.isEmpty())
                    {
                        addError("method" + methodUnit.getName() +
                                 " is being called with generic parameters",
                                 p_node.getLocation());
                    }
                    return new MethodCallStatement(path,
                                                   paramValues,
                                                   methodUnit,
                                                   p_node.getLocation(),
                                                   m_templateIdentifier);
                }
                else
                {
                    getTemplateUnit().addCallPath(getAbsolutePath(path));
                    return new ComponentCallStatement(
                        getAbsolutePath(path),
                        paramValues,
                        p_node.getLocation(),
                        m_templateIdentifier,
                        genericParams,
                        getTemplateUnit().getJamonContextType());
                }
            }
        }
    }

    private class ParamsAdapter extends DepthFirstAnalysisAdapter
    {
        public ParamValues getParamValues(AbstractParamsNode p_node)
        {
            p_node.apply(this);
            if (m_paramsList != null)
            {
                return new UnnamedParamValues(
                    m_paramsList, p_node.getLocation());
            }
            else
            {
                return new NamedParamValues(m_paramsMap, p_node.getLocation());
            }
        }

        @Override
        public void inNamedParamsNode(NamedParamsNode p_node)
        {
            m_paramsMap = new HashMap<String, String>();
        }

        @Override
        public void inUnnamedParamsNode(UnnamedParamsNode p_node)
        {
            m_paramsList = new LinkedList<String>();
        }

        @Override
        public void caseNamedParamNode(NamedParamNode p_node)
        {
            m_paramsMap.put(p_node.getName().getName(),
                            p_node.getValue().getValue());
        }

        @Override
        public void caseParamValueNode(ParamValueNode p_node)
        {
            m_paramsList.add(p_node.getValue());
        }

        private Map<String, String> m_paramsMap = null;
        private List<String> m_paramsList = null;
    }

    private ParamValues makeParamValues(AbstractParamsNode p_params)
    {
        return new ParamsAdapter().getParamValues(p_params);
    }

    private void addStatement(Statement p_statement)
    {
        getCurrentStatementBlock().addStatement(p_statement);
    }
}