private Token peek() { return lookahead(1); }
/** * default */ private Node parseDefault(){ expect(Default.class); Node when = new CaseNode.When(); when.setValue("default"); when.setBlock(this.parseBlockExpansion()); return when; }
private Node parseASTFilter() { Token token = expect(Filter.class); Filter filterToken = (Filter) token; AttributeList attr = (AttributeList) accept(AttributeList.class); token = expect(Colon.class); FilterNode node = new FilterNode(); node.setValue(filterToken.getValue()); node.setBlock(block()); node.setLineNumber(line()); node.setFileName(filename); node.setAttributes(convertToNodeAttributes(attr)); return node; }
private CaseConditionNode parseCaseCondition() { CaseConditionNode node = new CaseConditionNode(); Token token = null; if (peek() instanceof When) { token = expect(When.class); } else { token = expect(Default.class); node.setDefault(true); } node.setLineNumber(token.getLineNumber()); node.setFileName(filename); node.setValue(token.getValue()); node.setBlock(blockExpansion()); return node; }
private JadeTemplate getJadeTemplate(String name) throws IOException { Parser parser = new Parser("templates/" + name, JadeTemplateLoader.JADE_LOADER); Node root = parser.parse(); final JadeTemplate jadeTemplate = new JadeTemplate(); jadeTemplate.setTemplateLoader(JadeTemplateLoader.JADE_LOADER); jadeTemplate.setRootNode(root); return jadeTemplate; }
private Node blockExpansion() { if (peek() instanceof Colon) { Token token = expect(Colon.class); Colon colon = (Colon) token; BlockNode block = new BlockNode(); block.setLineNumber(colon.getLineNumber()); block.setFileName(filename); block.getNodes().add(parseExpr()); return block; } return block(); }
private Node parseTag() { Token token = advance(); String name = token.getValue(); TagNode tagNode = new TagNode(); tagNode.setLineNumber(lexer.getLineno()); tagNode.setFileName(filename); tagNode.setName(name); tagNode.setValue(name); tagNode.setSelfClosing(token.isSelfClosing()); return this.tag(tagNode); }
private Node parseText() { Token tok = expect(Text.class); Node[] tokens = this.parseInlineTagsInText(tok.getValue()); if (tokens.length == 1) return tokens[0]; BlockNode node = new BlockNode(); for (int i = 0; i < tokens.length; i++) { node.push(tokens[i]); } node.setValue(tok.getValue()); node.setLineNumber(tok.getLineNumber()); node.setFileName(filename); return node; }
/** * when */ private Node parseWhen(){ String val = this.expect(When.class).getValue(); CaseNode.When when = new CaseNode.When(); when.setValue(val); if (!(this.peek() instanceof Newline)) { when.setBlock(this.parseBlockExpansion()); } return when; }
private BlockNode parseYield() { advance(); BlockNode block = new BlockNode(); block.setLineNumber(lexer.getLineno()); block.setFileName(filename); block.setYield(true); return block; } private Node parseInterpolation() {
private Parser createParser(String templateName) { templateName = ensureJadeExtension(templateName); try { return new Parser(pathHelper.resolvePath(filename,templateName, basePath, templateLoader.getExtension()), basePath, templateLoader, expressionHandler); } catch (IOException e) { throw new JadeParserException(filename, lexer.getLineno(), templateLoader, "the template [" + templateName + "] could not be opened\n" + e.getMessage()); } }
private List<CaseConditionNode> whenBlock() { expect(Indent.class); List<CaseConditionNode> caseConditionalNodes = new LinkedList<CaseConditionNode>(); while (!(peek() instanceof Outdent) && !(peek() instanceof Eos)) { if (peek() instanceof Newline) { advance(); } else { caseConditionalNodes.add(this.parseCaseCondition()); } } if (peek() instanceof Outdent) { expect(Outdent.class); } return caseConditionalNodes; }
private Node parseDoctype() { Token token = expect(Doctype.class); Doctype doctype = (Doctype) token; DoctypeNode doctypeNode = new DoctypeNode(); doctypeNode.setValue(doctype.getValue()); return doctypeNode; }
@SuppressWarnings("rawtypes") private Token accept(Class clazz) { if (this.peek().getClass().equals(clazz)) { return lexer.advance(); } return null; }
public Parser(String filename, String basePath, TemplateLoader templateLoader, ExpressionHandler expressionHandler) throws IOException { this.filename = filename; this.basePath = basePath; this.templateLoader = templateLoader; this.expressionHandler = expressionHandler; lexer = new Lexer(filename, templateLoader,expressionHandler); characterParser = new CharacterParser(); getContexts().push(this); } public Parser(String src, String filename, String basePath, TemplateLoader templateLoader, ExpressionHandler expressionHandler) throws IOException {
private static JadeTemplate createTemplate(String filename, String basePath, TemplateLoader loader, ExpressionHandler expressionHandler) throws IOException { Parser parser = new Parser(filename, basePath, loader, expressionHandler); Node root = parser.parse(); JadeTemplate template = new JadeTemplate(); template.setExpressionHandler(expressionHandler); template.setTemplateLoader(loader); template.setRootNode(root); return template; }
private JadeTemplate createTemplate(String name) throws JadeException, IOException { JadeTemplate template = new JadeTemplate(); Parser parser = new Parser(name, basePath, templateLoader, expressionHandler); Node root = parser.parse(); template.setTemplateLoader(templateLoader); template.setExpressionHandler(expressionHandler); template.setRootNode(root); template.setPrettyPrint(prettyPrint); template.setMode(getMode()); return template; }