/** Return a String containing a DOT description that, when displayed, * will show the incoming state machine visually. All nodes reachable * from startState will be included. */ public virtual string GenerateGraph(State startState) { if (startState == null) { return(null); } // The output DOT graph for visualization StringTemplate dot = null; markedStates = new HashSet <int>(); if (startState is DFAState) { dot = GetTemplates().GetInstanceOf("dfa"); dot.SetAttribute("startState", startState.StateNumber); dot.SetAttribute("useBox", AntlrTool.internalOption_ShowNFAConfigsInDFA); WalkCreatingDFADOT(dot, (DFAState)startState); } else { dot = GetTemplates().GetInstanceOf("nfa"); dot.SetAttribute("startState", startState.StateNumber); WalkRuleNFACreatingDOT(dot, startState); } dot.SetAttribute("rankdir", rankdir); return(dot.Render()); }
public override StringTemplate GenExpr(CodeGenerator generator, TemplateGroup templates, DFA dfa) { StringTemplate result = Operands.Aggregate(default(StringTemplate), (template, operand) => { if (template == null) { return(operand.GenExpr(generator, templates, dfa)); } StringTemplate eST = null; if (templates != null) { eST = templates.GetInstanceOf("andPredicates"); } else { eST = new StringTemplate("(<left>&&<right>)"); } eST.SetAttribute("left", template); eST.SetAttribute("right", operand.GenExpr(generator, templates, dfa)); return(eST); }); return(result); }
public override string ToString() { GrammarAST decisionASTNode = probe.Dfa.DecisionASTNode; line = decisionASTNode.Line; charPositionInLine = decisionASTNode.CharPositionInLine; string fileName = probe.Dfa.Nfa.Grammar.FileName; if (fileName != null) { file = fileName; } StringTemplate st = GetMessageTemplate(); string ruleName = probe.Dfa.NFADecisionStartState.enclosingRule.Name; st.SetAttribute("ruleName", ruleName); List <int> sortedAlts = new List <int>(); sortedAlts.AddRange(altsWithRecursion); sortedAlts.Sort(); st.SetAttribute("alts", sortedAlts); return(base.ToString(st)); }
protected StringTemplate Template(string name) { StringTemplate st = generator.Templates.GetInstanceOf(name); chunks.Add(st); return(st); }
private void HandleTemplateExpression(string action) { StringTemplate st = Template("actionStringConstructor"); action = action.Substring(1, action.Length - 2); // stuff inside {...} st.SetAttribute("stringExpr", TranslateAction(action)); }
private void HandleEnclosingRuleScopeAttribute(string x, string y) { if (IsRuleRefInAlt(x)) { ErrorManager.GrammarError(ErrorManager.MSG_RULE_REF_AMBIG_WITH_RULE_IN_ALT, grammar, actionToken, x); } StringTemplate st = null; AttributeScope scope = enclosingRule.GetLocalAttributeScope(y); if (scope.IsPredefinedRuleScope) { st = Template("rulePropertyRef_" + y); grammar.ReferenceRuleLabelPredefinedAttribute(x); st.SetAttribute("scope", x); st.SetAttribute("attr", y); } else if (scope.IsPredefinedLexerRuleScope) { // perhaps not the most precise error message to use, but... ErrorManager.GrammarError(ErrorManager.MSG_RULE_HAS_NO_ARGS, grammar, actionToken, x); } else if (scope.IsParameterScope) { st = Template("parameterAttributeRef"); st.SetAttribute("attr", scope.GetAttribute(y)); } else { // must be return value st = Template("returnAttributeRef"); st.SetAttribute("ruleDescriptor", enclosingRule); st.SetAttribute("attr", scope.GetAttribute(y)); } }
public override String ToString() { GrammarAST decisionASTNode = probe.Dfa.DecisionASTNode; line = decisionASTNode.Line; charPositionInLine = decisionASTNode.CharPositionInLine; String fileName = probe.Dfa.Nfa.Grammar.FileName; if (fileName != null) { file = fileName; } StringTemplate st = GetMessageTemplate(); st.SetAttribute("targetRules", targetRules); st.SetAttribute("alt", alt); st.SetAttribute("callSiteStates", callSiteStates); var labels = probe.GetSampleNonDeterministicInputSequence(sampleBadState); String input = probe.GetInputSequenceDisplay(labels); st.SetAttribute("input", input); return(base.ToString(st)); }
private void HandleIndirectTemplateInstance(string text) { string action = text.Substring(1, text.Length - 1); StringTemplate st = generator.TranslateTemplateConstructor(enclosingRule.Name, outerAltNum, actionToken, action); chunks.Add(st); }
public override string ToString() { line = 0; charPositionInLine = 0; if (offendingToken != null) { line = offendingToken.Line; charPositionInLine = offendingToken.CharPositionInLine; } if (g != null) { file = g.FileName; } StringTemplate st = GetMessageTemplate(); if (arg != null) { st.SetAttribute("arg", arg); } if (arg2 != null) { st.SetAttribute("arg2", arg2); } return(base.ToString(st)); }
public override void PrefixAlt(GrammarAST altTree, GrammarAST rewriteTree, int alt) { altTree = GrammarAST.DupTree(altTree); rewriteTree = GrammarAST.DupTree(rewriteTree); StripSynPred(altTree); int nextPrec = Precedence(alt); // rewrite e to be e_[rec_arg] StringTemplate refST = recRuleTemplates.GetInstanceOf("recRuleRef"); refST.SetAttribute("ruleName", ruleName); refST.SetAttribute("arg", nextPrec); altTree = ReplaceRuleRefs(altTree, refST.Render()); string altText = Text(altTree); altText = altText.Trim(); altText += "{}"; // add empty alt to prevent pred hoisting StringTemplate nameST = recRuleTemplates.GetInstanceOf("recRuleName"); nameST.SetAttribute("ruleName", ruleName); rewriteTree = ReplaceRuleRefs(rewriteTree, nameST.Render()); string rewriteText = Text(rewriteTree); prefixAlts.Add(altText + (rewriteText != null ? " " + rewriteText : "")); //System.out.println("prefixAlt " + alt + ": " + altText + ", rewrite=" + rewriteText); }
private void HandleSetAttribute(string x, string y, string expr) { StringTemplate st = Template("actionSetAttribute"); st.SetAttribute("st", x); st.SetAttribute("attrName", y); st.SetAttribute("expr", TranslateAction(expr)); }
protected override void GenRecognizerHeaderFile(AntlrTool tool, CodeGenerator generator, Grammar grammar, StringTemplate headerFileST, string extName) { generator.Write(headerFileST, grammar.name + Grammar.grammarTypeToFileNameSuffix[(int)grammar.type] + extName); }
private void HandleDynamicAbsoluteIndexedScopeAttribute(string x, string y, string expr) { StringTemplate st = Template("scopeAttributeRef"); st.SetAttribute("scope", x); st.SetAttribute("attr", ResolveDynamicScope(x).GetAttribute(y)); st.SetAttribute("index", expr); }
protected internal virtual void GenRecognizerHeaderFile(AntlrTool tool, CodeGenerator generator, Grammar grammar, StringTemplate headerFileST, string extName) // e.g., ".h" { // no header file by default }
protected StringTemplate chooseWhereCyclicDFAsGo(AntlrTool tool, CodeGenerator generator, Grammar grammar, StringTemplate recognizerST, StringTemplate cyclicDFAST) { return(recognizerST); }
/// <summary> /// initialize template /// </summary> private static Antlr4.StringTemplate.Template InitializeTemplate() { var templateName = TemplatePath + "XmlScript.stg"; Antlr4.StringTemplate.TemplateGroup templateGroup = new Antlr4.StringTemplate.TemplateGroupFile(templateName); templateGroup.TrackCreationEvents = true; Antlr4.StringTemplate.Template template = templateGroup.GetInstanceOf("XmlScript"); return(template); }
public string GetArtificialPrimaryRule() { StringTemplate ruleST = recRuleTemplates.GetInstanceOf("recPrimaryRule"); ruleST.SetAttribute("ruleName", ruleName); ruleST.SetAttribute("alts", prefixAlts); ruleST.SetAttribute("alts", otherAlts); //Console.WriteLine(ruleST); return(ruleST.Render()); }
public string GetArtificialPrecStartRule() { StringTemplate ruleST = recRuleTemplates.GetInstanceOf("recRuleStart"); ruleST.SetAttribute("ruleName", ruleName); ruleST.SetAttribute("maxPrec", 0); //Console.WriteLine("start: " + ruleST); return(ruleST.Render()); }
protected internal virtual void GenRecognizerFile(AntlrTool tool, CodeGenerator generator, Grammar grammar, StringTemplate outputFileST) { string fileName = generator.GetRecognizerFileName(grammar.name, grammar.type); generator.Write(outputFileST, fileName); }
private void HandleSetExpressionAttribute(string a, string id, string expr) { StringTemplate st = Template("actionSetAttribute"); string action = a; action = action.Substring(1, action.Length - 2); // stuff inside {...} st.SetAttribute("st", TranslateAction(action)); st.SetAttribute("attrName", id); st.SetAttribute("expr", TranslateAction(expr)); }
public virtual StringTemplate GetDependencies() { LoadDependencyTemplates(); StringTemplate dependenciesST = templates.GetInstanceOf("dependencies"); dependenciesST.SetAttribute("in", GetDependenciesFileList()); dependenciesST.SetAttribute("out", GetGeneratedFileList()); dependenciesST.SetAttribute("grammarFileName", grammar.fileName); return(dependenciesST); }
/** Return a String containing a DOT description that, when displayed, * will show the incoming state machine visually. All nodes reachable * from startState will be included. */ public string GetRuleNFADOT(State startState) { // The output DOT graph for visualization StringTemplate dot = GetTemplates().GetInstanceOf("nfa"); markedStates = new HashSet <object>(); dot.SetAttribute("startState", startState.stateNumber); walkRuleNFACreatingDOT(dot, startState); return(dot.Render()); }
protected override void GenRecognizerFile(AntlrTool tool, CodeGenerator generator, Grammar grammar, StringTemplate outputFileST) { // Before we write this, and cause it to generate its string, // we need to add all the string literals that we are going to match // outputFileST.SetAttribute("literals", _strings); string fileName = generator.GetRecognizerFileName(grammar.name, grammar.type); generator.Write(outputFileST, fileName); }
public static string Render(string template, object model) { //var tpl = new Antlr4.StringTemplate.Template(template, '$', '$'); //tpl.Add("Model", model); //return tpl.Render(); var group = new Antlr4.StringTemplate.TemplateGroup('$', '$'); var tpl = new Antlr4.StringTemplate.Template(group, template); //register renderer for additional formatting from st file. group.RegisterRenderer(typeof(string), new StringAttributeRenderer()); tpl.Add("Model", model); return(tpl.Render()); }
private void HandleDynamicScopeAttribute(string x, string y) { AttributeScope scope = ResolveDynamicScope(x); if (scope != null) { StringTemplate st = Template("scopeAttributeRef"); st.SetAttribute("scope", x); st.SetAttribute("attr", scope.GetAttribute(y)); } else { // error: invalid dynamic attribute } }
private void HandleIsolatedLexerRuleReference(string name) { string label = enclosingRule.GetElementLabel(name, outerAltNum, generator); CheckElementRefUniqueness(name, false); if (label == null) { ErrorManager.GrammarError(ErrorManager.MSG_FORWARD_ELEMENT_REF, grammar, actionToken, name); } else { StringTemplate st = Template("lexerRuleLabel"); st.SetAttribute("label", label); } }
protected override void GenRecognizerHeaderFile(AntlrTool tool, CodeGenerator generator, Grammar grammar, StringTemplate headerFileST, string extName) { // Pick up the file name we are generating. This method will return a // a file suffixed with .c, so we must substring and add the extName // to it as we cannot assign into strings in Java. // string fileName = generator.GetRecognizerFileName(grammar.name, grammar.type); fileName = fileName.Substring(0, fileName.Length - 2) + extName; generator.Write(headerFileST, fileName); }
public override StringTemplate GenExpr(CodeGenerator generator, TemplateGroup templates, DFA dfa) { StringTemplate eST = null; if (templates != null) { eST = templates.GetInstanceOf("notPredicate"); } else { eST = new StringTemplate("!(<pred>)"); } eST.SetAttribute("pred", ctx.GenExpr(generator, templates, dfa)); return(eST); }
/** Do a depth-first walk of the state machine graph and * fill a DOT description template. Keep filling the * states and edges attributes. */ protected virtual void WalkCreatingDFADOT(StringTemplate dot, DFAState s) { if (markedStates.Contains(s.StateNumber)) { return; // already visited this node } markedStates.Add(s.StateNumber); // mark this node as completed. // first add this node StringTemplate st; if (s.IsAcceptState) { st = GetTemplates().GetInstanceOf("stopstate"); } else { st = GetTemplates().GetInstanceOf("state"); } st.SetAttribute("name", GetStateLabel(s)); dot.SetAttribute("states", st); // make a DOT edge for each transition for (int i = 0; i < s.NumberOfTransitions; i++) { Transition edge = (Transition)s.GetTransition(i); //Console.Out.WriteLine( "dfa " + s.dfa.decisionNumber + " edge from s" // + s.stateNumber + " [" + i + "] of " + s.NumberOfTransitions ); if (StripNonreducedStates) { if (edge.Target is DFAState && ((DFAState)edge.Target).AcceptStateReachable != Reachable.Yes) { continue; // don't generate nodes for terminal states } } st = GetTemplates().GetInstanceOf("edge"); st.SetAttribute("label", GetEdgeLabel(edge)); st.SetAttribute("src", GetStateLabel(s)); st.SetAttribute("target", GetStateLabel(edge.Target)); st.SetAttribute("arrowhead", arrowhead); dot.SetAttribute("edges", st); WalkCreatingDFADOT(dot, (DFAState)edge.Target); // keep walkin' } }
private void HandleRewriteAtomLabel(bool isRoot, out Template code, GrammarAST label) { string labelName = label.Text; Rule rule = grammar.GetRule(currentRuleName); Grammar.LabelElementPair pair = rule.GetLabel(labelName); if (labelName.Equals(currentRuleName)) { // special case; ref to old value via $ rule if (rule.HasRewrite(outerAltNum) && rule.GetRuleRefsInAlt(outerAltNum).Contains(labelName)) ErrorManager.GrammarError(ErrorManager.MSG_RULE_REF_AMBIG_WITH_RULE_IN_ALT, grammar, label.Token, labelName); Template labelST = templates.GetInstanceOf("prevRuleRootRef"); code = templates.GetInstanceOf("rewriteRuleLabelRef" + (isRoot ? "Root" : "")); code.SetAttribute("label", labelST); } else if (pair == null) { ErrorManager.GrammarError(ErrorManager.MSG_UNDEFINED_LABEL_REF_IN_REWRITE, grammar, label.Token, labelName); code = new Template(string.Empty); } else { string stName = null; switch (pair.type) { case LabelType.Token: stName = "rewriteTokenLabelRef"; break; case LabelType.WildcardTree: stName = "rewriteWildcardLabelRef"; break; case LabelType.WildcardTreeList: stName = "rewriteRuleListLabelRef"; // acts like rule ref list for ref break; case LabelType.Rule: stName = "rewriteRuleLabelRef"; break; case LabelType.TokenList: stName = "rewriteTokenListLabelRef"; break; case LabelType.RuleList: stName = "rewriteRuleListLabelRef"; break; } if (isRoot) stName += "Root"; code = templates.GetInstanceOf(stName); code.SetAttribute("label", labelName); } }
/** Do a depth-first walk of the state machine graph and * fill a DOT description template. Keep filling the * states and edges attributes. We know this is an NFA * for a rule so don't traverse edges to other rules and * don't go past rule end state. */ protected virtual void WalkRuleNFACreatingDOT( StringTemplate dot, State s ) { if ( markedStates.Contains( s.StateNumber ) ) { return; // already visited this node } markedStates.Add( s.StateNumber ); // mark this node as completed. // first add this node StringTemplate stateST; if ( s.IsAcceptState ) { stateST = GetTemplates().GetInstanceOf( "stopstate" ); } else { stateST = GetTemplates().GetInstanceOf( "state" ); } stateST.SetAttribute( "name", GetStateLabel( s ) ); dot.SetAttribute( "states", stateST ); if ( s.IsAcceptState ) { return; // don't go past end of rule node to the follow states } // special case: if decision point, then line up the alt start states // unless it's an end of block if ( ( (NFAState)s ).IsDecisionState ) { GrammarAST n = ( (NFAState)s ).associatedASTNode; if ( n != null && n.Type != ANTLRParser.EOB ) { StringTemplate rankST = GetTemplates().GetInstanceOf( "decision-rank" ); NFAState alt = (NFAState)s; while ( alt != null ) { rankST.SetAttribute( "states", GetStateLabel( alt ) ); if ( alt.transition[1] != null ) { alt = (NFAState)alt.transition[1].Target; } else { alt = null; } } dot.SetAttribute( "decisionRanks", rankST ); } } // make a DOT edge for each transition StringTemplate edgeST = null; for ( int i = 0; i < s.NumberOfTransitions; i++ ) { Transition edge = (Transition)s.GetTransition( i ); if ( edge is RuleClosureTransition ) { RuleClosureTransition rr = ( (RuleClosureTransition)edge ); // don't jump to other rules, but display edge to follow node edgeST = GetTemplates().GetInstanceOf( "edge" ); if ( rr.Rule.Grammar != grammar ) { edgeST.SetAttribute( "label", "<" + rr.Rule.Grammar.name + "." + rr.Rule.Name + ">" ); } else { edgeST.SetAttribute( "label", "<" + rr.Rule.Name + ">" ); } edgeST.SetAttribute( "src", GetStateLabel( s ) ); edgeST.SetAttribute( "target", GetStateLabel( rr.FollowState ) ); edgeST.SetAttribute( "arrowhead", arrowhead ); dot.SetAttribute( "edges", edgeST ); WalkRuleNFACreatingDOT( dot, rr.FollowState ); continue; } if ( edge.IsAction ) { edgeST = GetTemplates().GetInstanceOf( "action-edge" ); } else if ( edge.IsEpsilon ) { edgeST = GetTemplates().GetInstanceOf( "epsilon-edge" ); } else { edgeST = GetTemplates().GetInstanceOf( "edge" ); } edgeST.SetAttribute( "label", GetEdgeLabel( edge ) ); edgeST.SetAttribute( "src", GetStateLabel( s ) ); edgeST.SetAttribute( "target", GetStateLabel( edge.Target ) ); edgeST.SetAttribute( "arrowhead", arrowhead ); dot.SetAttribute( "edges", edgeST ); WalkRuleNFACreatingDOT( dot, edge.Target ); // keep walkin' } }
/** Create a grammar from file name. */ public Grammar( Tool tool, string fileName, CompositeGrammar composite ) { nameSpaceChecker = new NameSpaceChecker( this ); ll1Analyzer = new LL1Analyzer( this ); sanity = new GrammarSanity( this ); this.composite = composite; Tool = tool; FileName = fileName; // ensure we have the composite set to something if ( composite.DelegateGrammarTreeRoot == null ) { composite.SetDelegationRoot( this ); } else { defaultRuleModifier = composite.DelegateGrammarTreeRoot.Grammar.DefaultRuleModifier; } TemplateGroup lexerGrammarTemplateGroup = new TemplateGroupString(lexerGrammarTemplateText); _lexerGrammarTemplate = lexerGrammarTemplateGroup.GetInstanceOf("grammar"); target = CodeGenerator.LoadLanguageTarget((string)GetOption("language"), tool.TargetsDirectory); }
public void TestSetAttrOfExpr() { string action = "%{foo($ID.text).getST()}.y = z;"; string expecting = "(foo((ID1!=null?ID1.getText():null)).getST()).setAttribute(\"y\", z);"; ErrorQueue equeue = new ErrorQueue(); ErrorManager.SetErrorListener( equeue ); Grammar g = new Grammar( "grammar t;\n" + "options {\n" + " output=template;\n" + "}\n" + "\n" + "a : ID {" + action + "}\n" + " ;\n" + "\n" + "ID : 'a';\n" ); AntlrTool antlr = newTool(); CodeGenerator generator = new CodeGenerator( antlr, g, "Java" ); g.CodeGenerator = generator; generator.GenRecognizer(); // forces load of templates ActionTranslator translator = new ActionTranslator( generator, "a", new CommonToken( ANTLRParser.ACTION, action ), 1 ); string rawTranslation = translator.Translate(); StringTemplateGroup templates = new StringTemplateGroup(); StringTemplate actionST = new StringTemplate( templates, rawTranslation ); string found = actionST.Render(); assertNoErrors( equeue ); Assert.AreEqual( expecting, found ); }
/** Parse a rule we add artificially that is a list of the other lexer * rules like this: "Tokens : ID | INT | SEMI ;" nextToken() will invoke * this to set the current token. Add char literals before * the rule references. * * If in filter mode, we want every alt to backtrack and we need to * do k=1 to force the "first token def wins" rule. Otherwise, the * longest-match rule comes into play with LL(*). * * The ANTLRParser antlr.g file now invokes this when parsing a lexer * grammar, which I think is proper even though it peeks at the info * that later phases will (re)compute. It gets a list of lexer rules * and builds a string representing the rule; then it creates a parser * and adds the resulting tree to the grammar's tree. */ public GrammarAST AddArtificialMatchTokensRule( GrammarAST grammarAST, IList<string> ruleNames, IList<string> delegateNames, bool filterMode ) { StringTemplate matchTokenRuleST = null; if ( filterMode ) { matchTokenRuleST = new StringTemplate( ArtificialTokensRuleName + " options {k=1; backtrack=true;} : <rules; separator=\"|\">;"); } else { matchTokenRuleST = new StringTemplate( ArtificialTokensRuleName + " : <rules; separator=\"|\">;"); } // Now add token rule references for ( int i = 0; i < ruleNames.Count; i++ ) { string rname = (string)ruleNames[i]; matchTokenRuleST.SetAttribute( "rules", rname ); } for ( int i = 0; i < delegateNames.Count; i++ ) { string dname = (string)delegateNames[i]; matchTokenRuleST.SetAttribute( "rules", dname + ".Tokens" ); } GrammarAST r = ParseArtificialRule(matchTokenRuleST.Render()); AddRule(grammarAST, r); //addRule((GrammarAST)parser.getAST()); //return (GrammarAST)parser.getAST(); return r; }
private void HandleNotElementEnd(GrammarAST n, GrammarAST label, GrammarAST astSuffix, out Template code, IIntSet elements, GrammarAST start) { if (n.GetChild(0) != start) throw new System.InvalidOperationException(); string labelText = null; if (label != null) labelText = label.Text; code = GetTokenElementST("matchSet", "set", (GrammarAST)n.GetChild(0), astSuffix, labelText); code.SetAttribute("s", generator.GenSetExpr(templates, elements, 1, false)); int i = n.Token.TokenIndex; code.SetAttribute("elementIndex", i); if (grammar.type != GrammarType.Lexer) generator.GenerateLocalFollow(n, "set", currentRuleName, i); }
private void HandleFinallyClause(Template ruleTemplate, GrammarAST action) { IList<object> chunks = generator.TranslateAction(currentRuleName, action); ruleTemplate.SetAttribute("finally", chunks); }
protected override void GenRecognizerFile(AntlrTool tool, CodeGenerator generator, Grammar grammar, Template outputFileST) { if (!grammar.IsRoot) { Grammar rootGrammar = grammar.composite.RootGrammar; string actionScope = grammar.GetDefaultActionScope(grammar.type); IDictionary<string, object> actions; object rootNamespace; if (rootGrammar.Actions.TryGetValue(actionScope, out actions) && actions.TryGetValue("namespace", out rootNamespace)) { if (!grammar.Actions.TryGetValue(actionScope, out actions)) { actions = new Dictionary<string, object>(); grammar.Actions[actionScope] = actions; } actions["namespace"] = rootNamespace; } } generator.Templates.RegisterRenderer(typeof(string), new StringRenderer(generator, this)); base.GenRecognizerFile(tool, generator, grammar, outputFileST); }
private void HandleRewriteTemplateAfterId(out Template code, GrammarAST id, GrammarAST ind) { if (id != null && id.Text.Equals("template")) { code = templates.GetInstanceOf("rewriteInlineTemplate"); } else if (id != null) { code = templates.GetInstanceOf("rewriteExternalTemplate"); code.SetAttribute("name", id.Text); } else if (ind != null) { // must be \%({expr})(args) code = templates.GetInstanceOf("rewriteIndirectTemplate"); IList<object> chunks = generator.TranslateAction(currentRuleName, ind); code.SetAttribute("expr", chunks); } else { throw new ArgumentException(); } }
public void TestEscapedLessThanInAction() { Grammar g = new Grammar(); AntlrTool antlr = newTool(); CodeGenerator generator = new CodeGenerator( antlr, g, "Java" ); string action = "i<3; '<xmltag>'"; ActionTranslator translator = new ActionTranslator( generator, "a", new CommonToken( ANTLRParser.ACTION, action ), 0 ); string expecting = action; string rawTranslation = translator.Translate(); StringTemplateGroup templates = new StringTemplateGroup(); StringTemplate actionST = new StringTemplate( templates, "<action>" ); actionST.SetAttribute( "action", rawTranslation ); string found = actionST.Render(); Assert.AreEqual( expecting, found ); }
private void HandleRewriteTemplateAlt(out Template code) { code = templates.GetInstanceOf("rewriteEmptyTemplate"); }
public void TestDoNotTranslateScopeAttributeCompare() { string action = "if ($rule::foo == \"foo\" || 1) { System.out.println(\"ouch\"); }"; string expecting = "if (((rule_scope)rule_stack.peek()).foo == \"foo\" || 1) { System.out.println(\"ouch\"); }"; ErrorQueue equeue = new ErrorQueue(); ErrorManager.SetErrorListener( equeue ); Grammar g = new Grammar( "grammar a;\n" + "rule\n" + "scope {\n" + " String foo;" + "} :\n" + " twoIDs" + " ;\n" + "twoIDs:\n" + " ID ID {" + action + "}\n" + " ;\n" + "ID : 'id';" ); AntlrTool antlr = newTool(); CodeGenerator generator = new CodeGenerator( antlr, g, "Java" ); g.CodeGenerator = generator; generator.GenRecognizer(); ActionTranslator translator = new ActionTranslator( generator, "twoIDs", new CommonToken( ANTLRParser.ACTION, action ), 1 ); string rawTranslation = translator.Translate(); // check that we didn't use scopeSetAttributeRef int translation! bool foundScopeSetAttributeRef = false; for ( int i = 0; i < translator.chunks.Count; i++ ) { object chunk = translator.chunks[i]; if ( chunk is StringTemplate ) { if ( ( (StringTemplate)chunk ).Name.Equals( "/scopeSetAttributeRef" ) ) { foundScopeSetAttributeRef = true; } } } Assert.IsFalse(foundScopeSetAttributeRef, "action translator used scopeSetAttributeRef template in comparison!"); StringTemplateGroup templates = new StringTemplateGroup(); StringTemplate actionST = new StringTemplate( templates, rawTranslation ); string found = actionST.Render(); Assert.AreEqual(0, equeue.errors.Count, "unexpected errors: " + equeue); Assert.AreEqual( expecting, found ); }
public void TestIllegalAssignToLocalAttr() { string action = "$tree = null; $st = null; $start = 0; $stop = 0; $text = 0;"; string expecting = "retval.tree = null; retval.st = null; "; ErrorQueue equeue = new ErrorQueue(); ErrorManager.SetErrorListener( equeue ); Grammar g = new Grammar( "grammar a;\n" + "rule\n" + " : 'y' {" + action + "}\n" + " ;" ); AntlrTool antlr = newTool(); CodeGenerator generator = new CodeGenerator( antlr, g, "Java" ); g.CodeGenerator = generator; generator.GenRecognizer(); // forces load of templates ActionTranslator translator = new ActionTranslator( generator, "rule", new CommonToken( ANTLRParser.ACTION, action ), 1 ); string rawTranslation = translator.Translate(); int expectedMsgID = ErrorManager.MSG_WRITE_TO_READONLY_ATTR; var expectedErrors = new List<object>( 3 ); GrammarSemanticsMessage expectedMessage = new GrammarSemanticsMessage( expectedMsgID, g, null, "start", "" ); expectedErrors.Add( expectedMessage ); GrammarSemanticsMessage expectedMessage2 = new GrammarSemanticsMessage( expectedMsgID, g, null, "stop", "" ); expectedErrors.Add( expectedMessage2 ); GrammarSemanticsMessage expectedMessage3 = new GrammarSemanticsMessage( expectedMsgID, g, null, "text", "" ); expectedErrors.Add( expectedMessage3 ); checkErrors( equeue, expectedErrors ); StringTemplateGroup templates = new StringTemplateGroup(); StringTemplate actionST = new StringTemplate( templates, rawTranslation ); string found = actionST.Render(); Assert.AreEqual( expecting, found ); }
protected override void GenRecognizerHeaderFile( AntlrTool tool, CodeGenerator generator, Grammar grammar, StringTemplate headerFileST, string extName ) { generator.Write( headerFileST, grammar.name + Grammar.grammarTypeToFileNameSuffix[(int)grammar.type] + extName ); }
private void HandleRewriteAtomAction(bool isRoot, out Template code, GrammarAST action) { // actions in rewrite rules yield a tree object string actText = action.Text; IList<object> chunks = generator.TranslateAction(currentRuleName, action); code = templates.GetInstanceOf("rewriteNodeAction" + (isRoot ? "Root" : "")); code.SetAttribute("action", chunks); }
private void HandleRewriteTemplateAction(out Template code, GrammarAST action) { // set alt num for same reason as ARGLIST above action.outerAltNum = this.outerAltNum; code = templates.GetInstanceOf("rewriteAction"); code.SetAttribute("action", generator.TranslateAction(currentRuleName, action)); }
private void HandleRewriteAfterRewrite(Template code, GrammarAST r, ref GrammarAST pred, Template alt) { rewriteBlockNestingLevel = OUTER_REWRITE_NESTING_LEVEL; IList<object> predChunks = null; if (pred != null) predChunks = generator.TranslateAction(currentRuleName, pred); string description = grammar.GrammarTreeToString(r, false); description = generator.Target.GetTargetStringLiteralFromString(description); code.SetAttribute("alts.{pred,alt,description}", predChunks, alt, description); pred = null; }
private void HandleRewriteInit(out Template code, GrammarAST start) { code = null; if (state.backtracking == 0) { if (start.Type == REWRITES) { if (generator.Grammar.BuildTemplate) { code = templates.GetInstanceOf("rewriteTemplate"); } else { code = templates.GetInstanceOf("rewriteCode"); code.SetAttribute("treeLevel", OUTER_REWRITE_NESTING_LEVEL); code.SetAttribute("rewriteBlockLevel", OUTER_REWRITE_NESTING_LEVEL); code.SetAttribute("referencedElementsDeep", GetTokenTypesAsTargetLabels(start.rewriteRefsDeep)); HashSet<string> tokenLabels = grammar.GetLabels(start.rewriteRefsDeep, LabelType.Token); HashSet<string> tokenListLabels = grammar.GetLabels(start.rewriteRefsDeep, LabelType.TokenList); HashSet<string> ruleLabels = grammar.GetLabels(start.rewriteRefsDeep, LabelType.Rule); HashSet<string> ruleListLabels = grammar.GetLabels(start.rewriteRefsDeep, LabelType.RuleList); HashSet<string> wildcardLabels = grammar.GetLabels(start.rewriteRefsDeep, LabelType.WildcardTree); HashSet<string> wildcardListLabels = grammar.GetLabels(start.rewriteRefsDeep, LabelType.WildcardTreeList); // just in case they ref $r for "previous value", make a stream // from retval.tree Template retvalST = templates.GetInstanceOf("prevRuleRootRef"); ruleLabels.Add(retvalST.Render()); code.SetAttribute("referencedTokenLabels", tokenLabels); code.SetAttribute("referencedTokenListLabels", tokenListLabels); code.SetAttribute("referencedRuleLabels", ruleLabels); code.SetAttribute("referencedRuleListLabels", ruleListLabels); code.SetAttribute("referencedWildcardLabels", wildcardLabels); code.SetAttribute("referencedWildcardListLabels", wildcardListLabels); } } else { code = templates.GetInstanceOf("noRewrite"); code.SetAttribute("treeLevel", OUTER_REWRITE_NESTING_LEVEL); code.SetAttribute("rewriteBlockLevel", OUTER_REWRITE_NESTING_LEVEL); } } }
private void HandleGrammarInit(Grammar g, Template recognizerST, Template outputFileST, Template headerFileST) { if (state.backtracking == 0) { Init(g); this.recognizerST = recognizerST; this.outputFileST = outputFileST; this.headerFileST = headerFileST; string superClass = (string)g.GetOption("superClass"); outputOption = (string)g.GetOption("output"); if (superClass != null) recognizerST.SetAttribute("superClass", superClass); if (g.type != GrammarType.Lexer) { object labelType = g.GetOption("ASTLabelType"); if (labelType != null) recognizerST.SetAttribute("ASTLabelType", labelType); } if (g.type == GrammarType.TreeParser && g.GetOption("ASTLabelType") == null) ErrorManager.GrammarWarning(ErrorManager.MSG_MISSING_AST_TYPE_IN_TREE_GRAMMAR, g, null, g.name); if (g.type != GrammarType.TreeParser) { object labelType = g.GetOption("TokenLabelType"); if (labelType != null) recognizerST.SetAttribute("labelType", labelType); } recognizerST.SetAttribute("numRules", grammar.Rules.Count); outputFileST.SetAttribute("numRules", grammar.Rules.Count); headerFileST.SetAttribute("numRules", grammar.Rules.Count); } }
private void HandleElementSemanticPredicate(out Template code, GrammarAST sp) { code = templates.GetInstanceOf("validateSemanticPredicate"); code.SetAttribute("pred", generator.TranslateAction(currentRuleName, sp)); string description = generator.Target.GetTargetStringLiteralFromString(sp.Text); code.SetAttribute("description", description); }
private void HandleExceptionHandler(Template ruleTemplate, GrammarAST argAction, GrammarAST action) { IList<object> chunks = generator.TranslateAction(currentRuleName, action); ruleTemplate.SetAttribute("exceptions.{decl,action}", argAction.Text, chunks); }
private void HandleElementAction(out Template code, GrammarAST action, bool forced) { code = templates.GetInstanceOf(forced ? "execForcedAction" : "execAction"); code.SetAttribute("action", generator.TranslateAction(currentRuleName, action)); }
public void TestTemplateConstructorNoArgs() { string action = "x = %foo();"; string expecting = "x = templateLib.getInstanceOf(\"foo\");"; ErrorQueue equeue = new ErrorQueue(); ErrorManager.SetErrorListener( equeue ); Grammar g = new Grammar( "grammar t;\n" + "options {\n" + " output=template;\n" + "}\n" + "\n" + "a : ID {" + action + "}\n" + " ;\n" + "\n" + "ID : 'a';\n" ); AntlrTool antlr = newTool(); CodeGenerator generator = new CodeGenerator( antlr, g, "Java" ); g.CodeGenerator = generator; generator.GenRecognizer(); // forces load of templates ActionTranslator translator = new ActionTranslator( generator, "a", new CommonToken( ANTLRParser.ACTION, action ), 1 ); string rawTranslation = translator.Translate(); StringTemplateGroup templates = new StringTemplateGroup(); StringTemplate actionST = new StringTemplate( templates, rawTranslation ); string found = actionST.Render(); assertNoErrors( equeue ); Assert.AreEqual( expecting, found ); }
public virtual void SetSynPredGateIfNotAlready( StringTemplate gateST ) { string scope = GetDefaultActionScope( type ); IDictionary<string, object> actionsForGrammarScope; Actions.TryGetValue(scope, out actionsForGrammarScope); // if no synpredgate action set by user then set if ( actionsForGrammarScope == null || !actionsForGrammarScope.ContainsKey( Grammar.SynpredGateActionName ) ) { if ( actionsForGrammarScope == null ) { actionsForGrammarScope = new Dictionary<string, object>(); Actions[scope] = actionsForGrammarScope; } actionsForGrammarScope[Grammar.SynpredGateActionName] = gateST; } }
private void HandleElementCharRange(GrammarAST label, out Template code, GrammarAST a, GrammarAST b) { code = templates.GetInstanceOf("charRangeRef"); string low = generator.Target.GetTargetCharLiteralFromANTLRCharLiteral(generator, a.Text); string high = generator.Target.GetTargetCharLiteralFromANTLRCharLiteral(generator, b.Text); code.SetAttribute("a", low); code.SetAttribute("b", high); if (label != null) code.SetAttribute("label", label.Text); }
private void HandleRewriteEbnf(out Template code, GrammarAST start, Template rewriteBlockCode) { code = rewriteBlockCode; string description = grammar.GrammarTreeToString(start, false); description = generator.Target.GetTargetStringLiteralFromString(description); code.SetAttribute("description", description); }
/** Do a depth-first walk of the state machine graph and * fill a DOT description template. Keep filling the * states and edges attributes. */ protected virtual void WalkCreatingDFADOT( StringTemplate dot, DFAState s ) { if ( markedStates.Contains( s.StateNumber ) ) { return; // already visited this node } markedStates.Add( s.StateNumber ); // mark this node as completed. // first add this node StringTemplate st; if ( s.IsAcceptState ) { st = GetTemplates().GetInstanceOf( "stopstate" ); } else { st = GetTemplates().GetInstanceOf( "state" ); } st.SetAttribute( "name", GetStateLabel( s ) ); dot.SetAttribute( "states", st ); // make a DOT edge for each transition for ( int i = 0; i < s.NumberOfTransitions; i++ ) { Transition edge = (Transition)s.GetTransition( i ); //Console.Out.WriteLine( "dfa " + s.dfa.decisionNumber + " edge from s" // + s.stateNumber + " [" + i + "] of " + s.NumberOfTransitions ); if ( StripNonreducedStates ) { if ( edge.Target is DFAState && ( (DFAState)edge.Target ).AcceptStateReachable != Reachable.Yes ) { continue; // don't generate nodes for terminal states } } st = GetTemplates().GetInstanceOf( "edge" ); st.SetAttribute( "label", GetEdgeLabel( edge ) ); st.SetAttribute( "src", GetStateLabel( s ) ); st.SetAttribute( "target", GetStateLabel( edge.Target ) ); st.SetAttribute( "arrowhead", arrowhead ); dot.SetAttribute( "edges", st ); WalkCreatingDFADOT( dot, (DFAState)edge.Target ); // keep walkin' } }
private void HandleRewriteAtomTokenReference(bool isRoot, out Template code, GrammarAST start, GrammarAST term, GrammarAST arg) { string tokenName = start.Token.Text; string stName = "rewriteTokenRef"; Rule rule = grammar.GetRule(currentRuleName); ICollection<string> tokenRefsInAlt = rule.GetTokenRefsInAlt(outerAltNum); bool createNewNode = !tokenRefsInAlt.Contains(tokenName) || arg != null; if (createNewNode) stName = "rewriteImaginaryTokenRef"; if (isRoot) stName += "Root"; code = templates.GetInstanceOf(stName); code.SetAttribute("terminalOptions", term.terminalOptions); if (arg != null) { IList<object> args = generator.TranslateAction(currentRuleName, arg); code.SetAttribute("args", args); } code.SetAttribute("elementIndex", start.Token.TokenIndex); int ttype = grammar.GetTokenType(tokenName); string tok = generator.GetTokenTypeAsTargetLabel(ttype); code.SetAttribute("token", tok); if (grammar.GetTokenType(tokenName) == Label.INVALID) { ErrorManager.GrammarError(ErrorManager.MSG_UNDEFINED_TOKEN_REF_IN_REWRITE, grammar, start.Token, tokenName); // blank; no code gen code = new Template(string.Empty); } }
private void HandleRewriteAtomRuleReference(bool isRoot, out Template code, GrammarAST r) { string ruleRefName = r.Text; string stName = "rewriteRuleRef"; if (isRoot) stName += "Root"; code = templates.GetInstanceOf(stName); code.SetAttribute("rule", ruleRefName); if (grammar.GetRule(ruleRefName) == null) { ErrorManager.GrammarError(ErrorManager.MSG_UNDEFINED_RULE_REF, grammar, r.Token, ruleRefName); // blank; no code gen code = new Template(string.Empty); } else if (grammar.GetRule(currentRuleName).GetRuleRefsInAlt(ruleRefName, outerAltNum) == null) { ErrorManager.GrammarError(ErrorManager.MSG_REWRITE_ELEMENT_NOT_PRESENT_ON_LHS, grammar, r.Token, ruleRefName); // blank; no code gen code = new Template(string.Empty); } else { // track all rule refs as we must copy 2nd ref to rule and beyond if (!rewriteRuleRefs.Contains(ruleRefName)) rewriteRuleRefs.Add(ruleRefName); } }
/** Useful for when you are sure that you are not part of a composite * already. Used in Interp/RandomPhrase and testing. */ public Grammar(Tool tool) { nameSpaceChecker = new NameSpaceChecker( this ); ll1Analyzer = new LL1Analyzer( this ); sanity = new GrammarSanity( this ); builtFromString = true; composite = new CompositeGrammar( this ); Tool = tool; TemplateGroup lexerGrammarTemplateGroup = new TemplateGroupString(lexerGrammarTemplateText); _lexerGrammarTemplate = lexerGrammarTemplateGroup.GetInstanceOf("grammar"); string targetsDirectory = Path.Combine(AntlrTool.ToolPathRoot, "Targets"); target = CodeGenerator.LoadLanguageTarget((string)GetOption("language"), targetsDirectory); }
public override String ToString() { StringTemplate st = GetMessageTemplate(); st.SetAttribute("listOfCycles", cycles); return(base.ToString(st)); }