Examples with ST edu.princeton.cs.algs4.ST used on opensource projects

Example 71 with ST

use of edu.princeton.cs.algs4.ST in project stagen by wiztools.

the class STTemplateExecutor method render.

@Override
public String render(Map<String, Object> config, File templateFile) throws ExecutorException {
    try {
        final File tmplDir = templateFile.getParentFile();
        final String tmplName = Util.getBaseFileName(templateFile.getName());
        STGroup stg = new STRawGroupDir(tmplDir.toURI().toURL(), Charsets.UTF_8.name(), delimiterStartChar, delimiterStopChar);
        ST st = stg.getInstanceOf(tmplName);
        // Populate data:
        config.entrySet().stream().forEach((e) -> {
            st.add(e.getKey(), e.getValue());
        });
        return st.render();
    } catch (MalformedURLException ex) {
        throw new ExecutorException(ex);
    }
}

Example 72 with ST

use of edu.princeton.cs.algs4.ST in project antlr4 by tunnelvisionlabs.

the class LeftRecursiveRuleAnalyzer method getArtificialOpPrecRule.

// --------- get transformed rules ----------------
public String getArtificialOpPrecRule() {
    ST ruleST = recRuleTemplates.getInstanceOf("recRule");
    ruleST.add("ruleName", ruleName);
    ST ruleArgST = codegenTemplates.getInstanceOf("recRuleArg");
    ruleST.add("argName", ruleArgST);
    ST setResultST = codegenTemplates.getInstanceOf("recRuleSetResultAction");
    ruleST.add("setResultAction", setResultST);
    ruleST.add("userRetvals", retvals);
    LinkedHashMap<Integer, LeftRecursiveRuleAltInfo> opPrecRuleAlts = new LinkedHashMap<Integer, LeftRecursiveRuleAltInfo>();
    opPrecRuleAlts.putAll(binaryAlts);
    opPrecRuleAlts.putAll(ternaryAlts);
    opPrecRuleAlts.putAll(suffixAlts);
    for (int alt : opPrecRuleAlts.keySet()) {
        LeftRecursiveRuleAltInfo altInfo = opPrecRuleAlts.get(alt);
        ST altST = recRuleTemplates.getInstanceOf("recRuleAlt");
        ST predST = codegenTemplates.getInstanceOf("recRuleAltPredicate");
        predST.add("opPrec", precedence(alt));
        predST.add("ruleName", ruleName);
        altST.add("pred", predST);
        altST.add("alt", altInfo);
        altST.add("precOption", LeftRecursiveRuleTransformer.PRECEDENCE_OPTION_NAME);
        altST.add("opPrec", precedence(alt));
        ruleST.add("opAlts", altST);
    }
    ruleST.add("primaryAlts", prefixAndOtherAlts);
    tool.log("left-recursion", ruleST.render());
    return ruleST.render();
}

Example 73 with ST

use of edu.princeton.cs.algs4.ST in project antlr4 by tunnelvisionlabs.

the class LexerATNFactory method lexerCallCommand.

@Override
public Handle lexerCallCommand(GrammarAST ID, GrammarAST arg) {
    LexerAction lexerAction = createLexerAction(ID, arg);
    if (lexerAction != null) {
        return action(ID, lexerAction);
    }
    if (codegenTemplates == null) {
        // suppress reporting a single missing template when the target couldn't be loaded
        return epsilon(ID);
    }
    // fall back to standard action generation for the command
    ST cmdST = codegenTemplates.getInstanceOf("Lexer" + CharSupport.capitalize(ID.getText()) + "Command");
    if (cmdST == null) {
        g.tool.errMgr.grammarError(ErrorType.INVALID_LEXER_COMMAND, g.fileName, ID.token, ID.getText());
        return epsilon(ID);
    }
    if (cmdST.impl.formalArguments == null || !cmdST.impl.formalArguments.containsKey("arg")) {
        g.tool.errMgr.grammarError(ErrorType.UNWANTED_LEXER_COMMAND_ARGUMENT, g.fileName, ID.token, ID.getText());
        return epsilon(ID);
    }
    cmdST.add("arg", arg.getText());
    cmdST.add("grammar", arg.g);
    return action(cmdST.render());
}

Example 74 with ST

use of edu.princeton.cs.algs4.ST in project antlr4 by tunnelvisionlabs.

the class CodeGenerator method getTokenVocabOutput.

/**
 * Generate a token vocab file with all the token names/types.  For example:
 *  ID=7
 *  FOR=8
 *  'for'=8
 *
 *  This is independent of the target language; used by antlr internally
 */
ST getTokenVocabOutput() {
    ST vocabFileST = new ST(vocabFilePattern);
    Map<String, Integer> tokens = new LinkedHashMap<String, Integer>();
    // make constants for the token names
    for (String t : g.tokenNameToTypeMap.keySet()) {
        int tokenType = g.tokenNameToTypeMap.get(t);
        if (tokenType >= Token.MIN_USER_TOKEN_TYPE) {
            tokens.put(t, tokenType);
        }
    }
    vocabFileST.add("tokens", tokens);
    // now dump the strings
    Map<String, Integer> literals = new LinkedHashMap<String, Integer>();
    for (String literal : g.stringLiteralToTypeMap.keySet()) {
        int tokenType = g.stringLiteralToTypeMap.get(literal);
        if (tokenType >= Token.MIN_USER_TOKEN_TYPE) {
            literals.put(literal, tokenType);
        }
    }
    vocabFileST.add("literals", literals);
    return vocabFileST;
}

Example 75 with ST

use of edu.princeton.cs.algs4.ST in project antlr4 by tunnelvisionlabs.

the class OutputModelController method buildLeftRecursiveRuleFunction.

public void buildLeftRecursiveRuleFunction(LeftRecursiveRule r, LeftRecursiveRuleFunction function) {
    buildNormalRuleFunction(r, function);
    // now inject code to start alts
    Target target = delegate.getTarget();
    STGroup codegenTemplates = target.getTemplates();
    // pick out alt(s) for primaries
    CodeBlockForOuterMostAlt outerAlt = (CodeBlockForOuterMostAlt) function.code.get(0);
    List<CodeBlockForAlt> primaryAltsCode = new ArrayList<CodeBlockForAlt>();
    SrcOp primaryStuff = outerAlt.ops.get(0);
    if (primaryStuff instanceof Choice) {
        Choice primaryAltBlock = (Choice) primaryStuff;
        primaryAltsCode.addAll(primaryAltBlock.alts);
    } else {
        // just a single alt I guess; no block
        primaryAltsCode.add((CodeBlockForAlt) primaryStuff);
    }
    // pick out alt(s) for op alts
    StarBlock opAltStarBlock = (StarBlock) outerAlt.ops.get(1);
    CodeBlockForAlt altForOpAltBlock = opAltStarBlock.alts.get(0);
    List<CodeBlockForAlt> opAltsCode = new ArrayList<CodeBlockForAlt>();
    SrcOp opStuff = altForOpAltBlock.ops.get(0);
    if (opStuff instanceof AltBlock) {
        AltBlock opAltBlock = (AltBlock) opStuff;
        opAltsCode.addAll(opAltBlock.alts);
    } else {
        // just a single alt I guess; no block
        opAltsCode.add((CodeBlockForAlt) opStuff);
    }
    // Insert code in front of each primary alt to create specialized ctx if there was a label
    for (int i = 0; i < primaryAltsCode.size(); i++) {
        LeftRecursiveRuleAltInfo altInfo = r.recPrimaryAlts.get(i);
        if (altInfo.altLabel == null)
            continue;
        ST altActionST = codegenTemplates.getInstanceOf("recRuleReplaceContext");
        altActionST.add("ctxName", Utils.capitalize(altInfo.altLabel));
        Action altAction = new Action(delegate, function.altLabelCtxs.get(altInfo.altLabel), altActionST);
        CodeBlockForAlt alt = primaryAltsCode.get(i);
        alt.insertOp(0, altAction);
    }
    // Insert code to set ctx.stop after primary block and before op * loop
    ST setStopTokenAST = codegenTemplates.getInstanceOf("recRuleSetStopToken");
    Action setStopTokenAction = new Action(delegate, function.ruleCtx, setStopTokenAST);
    outerAlt.insertOp(1, setStopTokenAction);
    // Insert code to set _prevctx at start of * loop
    ST setPrevCtx = codegenTemplates.getInstanceOf("recRuleSetPrevCtx");
    Action setPrevCtxAction = new Action(delegate, function.ruleCtx, setPrevCtx);
    opAltStarBlock.addIterationOp(setPrevCtxAction);
    // Insert code in front of each op alt to create specialized ctx if there was an alt label
    for (int i = 0; i < opAltsCode.size(); i++) {
        ST altActionST;
        LeftRecursiveRuleAltInfo altInfo = r.recOpAlts.getElement(i);
        String templateName;
        if (altInfo.altLabel != null) {
            templateName = "recRuleLabeledAltStartAction";
            altActionST = codegenTemplates.getInstanceOf(templateName);
            altActionST.add("currentAltLabel", altInfo.altLabel);
        } else {
            templateName = "recRuleAltStartAction";
            altActionST = codegenTemplates.getInstanceOf(templateName);
            altActionST.add("ctxName", Utils.capitalize(r.name));
        }
        altActionST.add("ruleName", r.name);
        // add label of any lr ref we deleted
        altActionST.add("label", altInfo.leftRecursiveRuleRefLabel);
        if (altActionST.impl.formalArguments.containsKey("isListLabel")) {
            altActionST.add("isListLabel", altInfo.isListLabel);
        } else if (altInfo.isListLabel) {
            delegate.getGenerator().tool.errMgr.toolError(ErrorType.CODE_TEMPLATE_ARG_ISSUE, templateName, "isListLabel");
        }
        Action altAction = new Action(delegate, function.altLabelCtxs.get(altInfo.altLabel), altActionST);
        CodeBlockForAlt alt = opAltsCode.get(i);
        alt.insertOp(0, altAction);
    }
}