public LexerFile(OutputModelFactory factory, string fileName) : base(factory, fileName) { namedActions = BuildNamedActions(factory.GetGrammar()); genPackage = factory.GetGrammar().tool.genPackage; exportMacro = factory.GetGrammar().GetOptionString("exportMacro"); genListener = factory.GetGrammar().tool.gen_listener; genVisitor = factory.GetGrammar().tool.gen_visitor; }
public LexerFile(OutputModelFactory factory, string fileName) : base(factory, fileName) { namedActions = BuildNamedActions(factory.GetGrammar()); genPackage = factory.GetGrammar().tool.genPackage; exportMacro = factory.GetGrammar().GetOptionString("exportMacro"); genListener = factory.GetGrammar().tool.gen_listener; genVisitor = factory.GetGrammar().tool.gen_visitor; }
public ListenerFile(OutputModelFactory factory, string fileName) : base(factory, fileName) { Grammar g = factory.GetGrammar(); parserName = g.GetRecognizerName(); grammarName = g.name; namedActions = BuildNamedActions(factory.GetGrammar()); foreach (KeyValuePair <string, IList <RuleAST> > entry in g.contextASTs) { foreach (RuleAST ruleAST in entry.Value) { try { IDictionary <string, IList <System.Tuple <int, AltAST> > > labeledAlternatives = g.GetLabeledAlternatives(ruleAST); listenerNames.UnionWith(labeledAlternatives.Keys); } catch (RecognitionException) { } } } foreach (Rule r in g.rules.Values) { listenerNames.Add(r.GetBaseContext()); } foreach (Rule r in g.rules.Values) { IDictionary <string, IList <System.Tuple <int, AltAST> > > labels = r.GetAltLabels(); if (labels != null) { foreach (KeyValuePair <string, IList <System.Tuple <int, AltAST> > > pair in labels) { listenerLabelRuleNames[pair.Key] = r.name; } } } ActionAST ast; if (g.namedActions.TryGetValue("header", out ast) && ast != null) { header = new Action(factory, ast); } genPackage = factory.GetGrammar().tool.genPackage; exportMacro = factory.GetGrammar().GetOptionString("exportMacro"); }
public ListenerFile(OutputModelFactory factory, string fileName) : base(factory, fileName) { Grammar g = factory.GetGrammar(); parserName = g.GetRecognizerName(); grammarName = g.name; namedActions = BuildNamedActions(factory.GetGrammar()); foreach (KeyValuePair<string, IList<RuleAST>> entry in g.contextASTs) { foreach (RuleAST ruleAST in entry.Value) { try { IDictionary<string, IList<System.Tuple<int, AltAST>>> labeledAlternatives = g.GetLabeledAlternatives(ruleAST); listenerNames.UnionWith(labeledAlternatives.Keys); } catch (RecognitionException) { } } } foreach (Rule r in g.rules.Values) { listenerNames.Add(r.GetBaseContext()); } foreach (Rule r in g.rules.Values) { IDictionary<string, IList<System.Tuple<int, AltAST>>> labels = r.GetAltLabels(); if (labels != null) { foreach (KeyValuePair<string, IList<System.Tuple<int, AltAST>>> pair in labels) { listenerLabelRuleNames[pair.Key] = r.name; } } } ActionAST ast; if (g.namedActions.TryGetValue("header", out ast) && ast != null) header = new Action(factory, ast); genPackage = factory.GetGrammar().tool.genPackage; exportMacro = factory.GetGrammar().GetOptionString("exportMacro"); }
public MatchToken(OutputModelFactory factory, TerminalAST ast) : base(factory, ast) { Grammar g = factory.GetGrammar(); ttype = g.GetTokenType(ast.Text); name = factory.GetTarget().GetTokenTypeAsTargetLabel(g, ttype); }
public static IList <ActionChunk> TranslateActionChunk(OutputModelFactory factory, RuleFunction rf, string action, ActionAST node) { IToken tokenWithinAction = node.Token; ActionTranslator translator = new ActionTranslator(factory, node); translator.rf = rf; factory.GetGrammar().tool.Log("action-translator", "translate " + action); string altLabel = node.GetAltLabel(); if (rf != null) { translator.nodeContext = rf.ruleCtx; if (altLabel != null) { AltLabelStructDecl decl; rf.altLabelCtxs.TryGetValue(altLabel, out decl); translator.nodeContext = decl; } } ANTLRStringStream @in = new ANTLRStringStream(action); @in.Line = tokenWithinAction.Line; @in.CharPositionInLine = tokenWithinAction.CharPositionInLine; ActionSplitter trigger = new ActionSplitter(@in, translator); // forces eval, triggers listener methods trigger.GetActionTokens(); return(translator.chunks); }
private static Bitset[] CreateBitsets(OutputModelFactory factory, IntervalSet set, int wordSize, bool useZeroOffset) { IList<Bitset> bitsetList = new List<Bitset>(); foreach (int ttype in set.ToArray()) { Bitset current = bitsetList.Count > 0 ? bitsetList[bitsetList.Count - 1] : null; if (current == null || ttype > (current.shift + wordSize - 1)) { current = new Bitset(); if (useZeroOffset && ttype >= 0 && ttype < wordSize - 1) { current.shift = 0; } else { current.shift = ttype; } bitsetList.Add(current); } current.ttypes.Add(factory.GetTarget().GetTokenTypeAsTargetLabel(factory.GetGrammar(), ttype)); } return bitsetList.ToArray(); }
public ParserFile(OutputModelFactory factory, string fileName) : base(factory, fileName) { Grammar g = factory.GetGrammar(); namedActions = BuildNamedActions(factory.GetGrammar()); genPackage = g.tool.genPackage; exportMacro = factory.GetGrammar().GetOptionString("exportMacro"); // need the below members in the ST for Python, C++ genListener = g.tool.gen_listener; genVisitor = g.tool.gen_visitor; grammarName = g.name; if (g.GetOptionString("contextSuperClass") != null) { contextSuperClass = new ActionText(null, g.GetOptionString("contextSuperClass")); } }
public MatchToken(OutputModelFactory factory, TerminalAST ast) : base(factory, ast) { Grammar g = factory.GetGrammar(); ttype = g.GetTokenType(ast.Text); name = factory.GetTarget().GetTokenTypeAsTargetLabel(g, ttype); }
/** Build a file with a parser containing rule functions. Use the * controller as factory in SourceGenTriggers so it triggers code generation * extensions too, not just the factory functions in this factory. */ public virtual OutputModelObject BuildParserOutputModel(bool header) { CodeGenerator gen = @delegate.GetGenerator(); ParserFile file = ParserFile(gen.GetRecognizerFileName(header)); SetRoot(file); file.parser = Parser(file); Grammar g = @delegate.GetGrammar(); foreach (Rule r in g.rules.Values) { BuildRuleFunction(file.parser, r); } return(file); }
public ParserFile(OutputModelFactory factory, string fileName) : base(factory, fileName) { Grammar g = factory.GetGrammar(); namedActions = BuildNamedActions(factory.GetGrammar()); genPackage = g.tool.genPackage; exportMacro = factory.GetGrammar().GetOptionString("exportMacro"); // need the below members in the ST for Python, C++ genListener = g.tool.gen_listener; genVisitor = g.tool.gen_visitor; grammarName = g.name; if (g.GetOptionString("contextSuperClass") != null) { contextSuperClass = new ActionText(null, g.GetOptionString("contextSuperClass")); } }
public Lexer(OutputModelFactory factory, LexerFile file) : base(factory) { this.file = file; // who contains us? Grammar g = factory.GetGrammar(); channels = new LinkedHashMap<string, int>(g.channelNameToValueMap); modes = ((LexerGrammar)g).modes.Keys; }
public ThrowRecognitionException(OutputModelFactory factory, GrammarAST ast, IntervalSet expecting) : base(factory, ast) { //this.decision = ((BlockStartState)ast.ATNState).decision; grammarLine = ast.Line; grammarLine = ast.CharPositionInLine; grammarFile = factory.GetGrammar().fileName; //this.expecting = factory.createExpectingBitSet(ast, decision, expecting, "error"); // factory.defineBitSet(this.expecting); }
protected OutputFile(OutputModelFactory factory, string fileName) : base(factory) { this.fileName = fileName; Grammar g = factory.GetGrammar(); grammarFileName = g.fileName; ANTLRVersion = AntlrTool.VERSION; TokenLabelType = g.GetOptionString("TokenLabelType"); InputSymbolType = TokenLabelType; }
public Lexer(OutputModelFactory factory, LexerFile file) : base(factory) { this.file = file; // who contains us? Grammar g = factory.GetGrammar(); channels = new LinkedHashMap <string, int>(g.channelNameToValueMap); modes = ((LexerGrammar)g).modes.Keys; }
protected OutputFile(OutputModelFactory factory, string fileName) : base(factory) { this.fileName = fileName; Grammar g = factory.GetGrammar(); grammarFileName = g.fileName; ANTLRVersion = AntlrTool.VERSION; TokenLabelType = g.GetOptionString("TokenLabelType"); InputSymbolType = TokenLabelType; }
public LL1AltBlock(OutputModelFactory factory, GrammarAST blkAST, IList<CodeBlockForAlt> alts) : base(factory, blkAST, alts) { this.decision = ((DecisionState)blkAST.atnState).decision; /* Lookahead for each alt 1..n */ IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision]; altLook = GetAltLookaheadAsStringLists(altLookSets); IntervalSet expecting = IntervalSet.Or(altLookSets); // combine alt sets this.error = GetThrowNoViableAlt(factory, blkAST, expecting); }
public LL1StarBlockSingleAlt(OutputModelFactory factory, GrammarAST starRoot, IList<CodeBlockForAlt> alts) : base(factory, starRoot, alts) { StarLoopEntryState star = (StarLoopEntryState)starRoot.atnState; loopBackStateNumber = star.loopBackState.stateNumber; this.decision = star.decision; IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision]; Debug.Assert(altLookSets.Length == 2); IntervalSet enterLook = altLookSets[0]; IntervalSet exitLook = altLookSets[1]; loopExpr = AddCodeForLoopLookaheadTempVar(enterLook); }
public LL1AltBlock(OutputModelFactory factory, GrammarAST blkAST, IList <CodeBlockForAlt> alts) : base(factory, blkAST, alts) { this.decision = ((DecisionState)blkAST.atnState).decision; /* Lookahead for each alt 1..n */ IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision]; altLook = GetAltLookaheadAsStringLists(altLookSets); IntervalSet expecting = IntervalSet.Or(altLookSets); // combine alt sets this.error = GetThrowNoViableAlt(factory, blkAST, expecting); }
public LL1StarBlockSingleAlt(OutputModelFactory factory, GrammarAST starRoot, IList <CodeBlockForAlt> alts) : base(factory, starRoot, alts) { StarLoopEntryState star = (StarLoopEntryState)starRoot.atnState; loopBackStateNumber = star.loopBackState.stateNumber; this.decision = star.decision; IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision]; Debug.Assert(altLookSets.Length == 2); IntervalSet enterLook = altLookSets[0]; IntervalSet exitLook = altLookSets[1]; loopExpr = AddCodeForLoopLookaheadTempVar(enterLook); }
public LL1PlusBlockSingleAlt(OutputModelFactory factory, GrammarAST plusRoot, IList<CodeBlockForAlt> alts) : base(factory, plusRoot, alts) { BlockAST blkAST = (BlockAST)plusRoot.GetChild(0); PlusBlockStartState blkStart = (PlusBlockStartState)blkAST.atnState; stateNumber = blkStart.loopBackState.stateNumber; blockStartStateNumber = blkStart.stateNumber; PlusBlockStartState plus = (PlusBlockStartState)blkAST.atnState; this.decision = plus.loopBackState.decision; IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision]; IntervalSet loopBackLook = altLookSets[0]; loopExpr = AddCodeForLoopLookaheadTempVar(loopBackLook); }
public LL1PlusBlockSingleAlt(OutputModelFactory factory, GrammarAST plusRoot, IList <CodeBlockForAlt> alts) : base(factory, plusRoot, alts) { BlockAST blkAST = (BlockAST)plusRoot.GetChild(0); PlusBlockStartState blkStart = (PlusBlockStartState)blkAST.atnState; stateNumber = blkStart.loopBackState.stateNumber; blockStartStateNumber = blkStart.stateNumber; PlusBlockStartState plus = (PlusBlockStartState)blkAST.atnState; this.decision = plus.loopBackState.decision; IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision]; IntervalSet loopBackLook = altLookSets[0]; loopExpr = AddCodeForLoopLookaheadTempVar(loopBackLook); }
public IList<SrcOp> followExpr; // might not work in template if size>1 public LL1OptionalBlockSingleAlt(OutputModelFactory factory, GrammarAST blkAST, IList<CodeBlockForAlt> alts) : base(factory, blkAST, alts) { this.decision = ((DecisionState)blkAST.atnState).decision; /* Lookahead for each alt 1..n */ // IntervalSet[] altLookSets = LinearApproximator.getLL1LookaheadSets(dfa); IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision]; altLook = GetAltLookaheadAsStringLists(altLookSets); IntervalSet look = altLookSets[0]; IntervalSet followLook = altLookSets[1]; IntervalSet expecting = look.Or(followLook); this.error = GetThrowNoViableAlt(factory, blkAST, expecting); expr = AddCodeForLookaheadTempVar(look); followExpr = factory.GetLL1Test(followLook, blkAST); }
public virtual void Attr(string expr, IToken x) { gen.g.tool.Log("action-translator", "attr " + x); Attribute a = node.resolver.ResolveToAttribute(x.Text, node); if (a != null) { switch (a.dict.type) { case AttributeDict.DictType.ARG: chunks.Add(new ArgRef(nodeContext, x.Text)); break; case AttributeDict.DictType.RET: chunks.Add(new RetValueRef(rf.ruleCtx, x.Text)); break; case AttributeDict.DictType.LOCAL: chunks.Add(new LocalRef(nodeContext, x.Text)); break; case AttributeDict.DictType.PREDEFINED_RULE: chunks.Add(GetRulePropertyRef(x)); break; } } if (node.resolver.ResolvesToToken(x.Text, node)) { chunks.Add(new TokenRef(nodeContext, GetTokenLabel(x.Text))); // $label return; } if (node.resolver.ResolvesToLabel(x.Text, node)) { chunks.Add(new LabelRef(nodeContext, GetTokenLabel(x.Text))); // $x for x=ID etc... return; } if (node.resolver.ResolvesToListLabel(x.Text, node)) { chunks.Add(new ListLabelRef(nodeContext, x.Text)); // $ids for ids+=ID etc... return; } Rule r = factory.GetGrammar().GetRule(x.Text); if (r != null) { chunks.Add(new LabelRef(nodeContext, GetRuleLabel(x.Text))); // $r for r rule ref } }
public IList <SrcOp> followExpr; // might not work in template if size>1 public LL1OptionalBlockSingleAlt(OutputModelFactory factory, GrammarAST blkAST, IList <CodeBlockForAlt> alts) : base(factory, blkAST, alts) { this.decision = ((DecisionState)blkAST.atnState).decision; /* Lookahead for each alt 1..n */ // IntervalSet[] altLookSets = LinearApproximator.getLL1LookaheadSets(dfa); IntervalSet[] altLookSets = factory.GetGrammar().decisionLOOK[decision]; altLook = GetAltLookaheadAsStringLists(altLookSets); IntervalSet look = altLookSets[0]; IntervalSet followLook = altLookSets[1]; IntervalSet expecting = look.Or(followLook); this.error = GetThrowNoViableAlt(factory, blkAST, expecting); expr = AddCodeForLookaheadTempVar(look); followExpr = factory.GetLL1Test(followLook, blkAST); }
public LeftRecursiveRuleFunction(OutputModelFactory factory, LeftRecursiveRule r) : base(factory, r) { // Since we delete x=lr, we have to manually add decls for all labels // on left-recur refs to proper structs foreach (System.Tuple<GrammarAST, string> pair in r.leftRecursiveRuleRefLabels) { GrammarAST idAST = pair.Item1; string altLabel = pair.Item2; string label = idAST.Text; GrammarAST rrefAST = (GrammarAST)idAST.Parent.GetChild(1); if (rrefAST.Type == ANTLRParser.RULE_REF) { Rule targetRule = factory.GetGrammar().GetRule(rrefAST.Text); string ctxName = factory.GetTarget().GetRuleFunctionContextStructName(targetRule); RuleContextDecl d; if (idAST.Parent.Type == ANTLRParser.ASSIGN) { d = new RuleContextDecl(factory, label, ctxName); } else { d = new RuleContextListDecl(factory, label, ctxName); } StructDecl @struct = ruleCtx; if (altLabelCtxs != null) { AltLabelStructDecl s; if (altLabel != null && altLabelCtxs.TryGetValue(altLabel, out s) && s != null) @struct = s; // if alt label, use subctx } @struct.AddDecl(d); // stick in overall rule's ctx } } }
protected Recognizer(OutputModelFactory factory) : base(factory) { Grammar g = factory.GetGrammar(); grammarFileName = Path.GetFileName(g.fileName); grammarName = g.name; name = g.GetRecognizerName(); tokens = new LinkedHashMap <string, int>(); foreach (KeyValuePair <string, int> entry in g.tokenNameToTypeMap) { int ttype = entry.Value; if (ttype > 0) { tokens[entry.Key] = ttype; } } ruleNames = g.rules.Keys; rules = g.rules.Values; atn = new SerializedATN(factory, g.atn, g.GetRuleNames()); if (g.GetOptionString("superClass") != null) { superClass = new ActionText(null, g.GetOptionString("superClass")); } else { superClass = null; } #pragma warning disable CS0612 // Type or member is obsolete tokenNames = TranslateTokenStringsToTarget(g.GetTokenDisplayNames(), factory); #pragma warning restore CS0612 // Type or member is obsolete literalNames = TranslateTokenStringsToTarget(g.GetTokenLiteralNames(), factory); symbolicNames = TranslateTokenStringsToTarget(g.GetTokenSymbolicNames(), factory); abstractRecognizer = g.IsAbstract(); }
protected Recognizer(OutputModelFactory factory) : base(factory) { Grammar g = factory.GetGrammar(); grammarFileName = Path.GetFileName(g.fileName); grammarName = g.name; name = g.GetRecognizerName(); tokens = new LinkedHashMap<string, int>(); foreach (KeyValuePair<string, int> entry in g.tokenNameToTypeMap) { int ttype = entry.Value; if (ttype > 0) { tokens[entry.Key] = ttype; } } ruleNames = g.rules.Keys; rules = g.rules.Values; atn = new SerializedATN(factory, g.atn, g.GetRuleNames()); if (g.GetOptionString("superClass") != null) { superClass = new ActionText(null, g.GetOptionString("superClass")); } else { superClass = null; } #pragma warning disable CS0612 // Type or member is obsolete tokenNames = TranslateTokenStringsToTarget(g.GetTokenDisplayNames(), factory); #pragma warning restore CS0612 // Type or member is obsolete literalNames = TranslateTokenStringsToTarget(g.GetTokenLiteralNames(), factory); symbolicNames = TranslateTokenStringsToTarget(g.GetTokenSymbolicNames(), factory); abstractRecognizer = g.IsAbstract(); }
public static IList<ActionChunk> TranslateActionChunk(OutputModelFactory factory, RuleFunction rf, string action, ActionAST node) { IToken tokenWithinAction = node.Token; ActionTranslator translator = new ActionTranslator(factory, node); translator.rf = rf; factory.GetGrammar().tool.Log("action-translator", "translate " + action); string altLabel = node.GetAltLabel(); if (rf != null) { translator.nodeContext = rf.ruleCtx; if (altLabel != null) { AltLabelStructDecl decl; rf.altLabelCtxs.TryGetValue(altLabel, out decl); translator.nodeContext = decl; } } ANTLRStringStream @in = new ANTLRStringStream(action); @in.Line = tokenWithinAction.Line; @in.CharPositionInLine = tokenWithinAction.CharPositionInLine; ActionSplitter trigger = new ActionSplitter(@in, translator); // forces eval, triggers listener methods trigger.GetActionTokens(); return translator.chunks; }
public RuleFunction(OutputModelFactory factory, Rule r) : base(factory) { this.name = r.name; this.rule = r; if (r.modifiers != null && r.modifiers.Count > 0) { this.modifiers = new List<string>(); foreach (GrammarAST t in r.modifiers) modifiers.Add(t.Text); } modifiers = Utils.NodesToStrings(r.modifiers); index = r.index; int lfIndex = name.IndexOf(ATNSimulator.RuleVariantDelimiter); if (lfIndex >= 0) { variantOf = name.Substring(0, lfIndex); } if (r.name.Equals(r.GetBaseContext())) { ruleCtx = new StructDecl(factory, r); AddContextGetters(factory, r.g.contextASTs[r.name]); if (r.args != null) { ICollection<Attribute> decls = r.args.attributes.Values; if (decls.Count > 0) { args = new List<AttributeDecl>(); ruleCtx.AddDecls(decls); foreach (Attribute a in decls) { args.Add(new AttributeDecl(factory, a)); } ruleCtx.ctorAttrs = args; } } if (r.retvals != null) { ruleCtx.AddDecls(r.retvals.attributes.Values); } if (r.locals != null) { ruleCtx.AddDecls(r.locals.attributes.Values); } } else { if (r.args != null || r.retvals != null || r.locals != null) { throw new System.NotSupportedException("customized fields are not yet supported for customized context objects"); } } ruleLabels = r.GetElementLabelNames(); tokenLabels = r.GetTokenRefs(); if (r.exceptions != null) { exceptions = new List<ExceptionClause>(); foreach (GrammarAST e in r.exceptions) { ActionAST catchArg = (ActionAST)e.GetChild(0); ActionAST catchAction = (ActionAST)e.GetChild(1); exceptions.Add(new ExceptionClause(factory, catchArg, catchAction)); } } startState = factory.GetGrammar().atn.ruleToStartState[r.index]; }
public RuleFunction(OutputModelFactory factory, Rule r) : base(factory) { this.name = r.name; this.rule = r; if (r.modifiers != null && r.modifiers.Count > 0) { this.modifiers = new List <string>(); foreach (GrammarAST t in r.modifiers) { modifiers.Add(t.Text); } } modifiers = Utils.NodesToStrings(r.modifiers); index = r.index; int lfIndex = name.IndexOf(ATNSimulator.RuleVariantDelimiter); if (lfIndex >= 0) { variantOf = name.Substring(0, lfIndex); } if (r.name.Equals(r.GetBaseContext())) { ruleCtx = new StructDecl(factory, r); AddContextGetters(factory, r.g.contextASTs[r.name]); if (r.args != null) { ICollection <Attribute> decls = r.args.attributes.Values; if (decls.Count > 0) { args = new List <AttributeDecl>(); ruleCtx.AddDecls(decls); foreach (Attribute a in decls) { args.Add(new AttributeDecl(factory, a)); } ruleCtx.ctorAttrs = args; } } if (r.retvals != null) { ruleCtx.AddDecls(r.retvals.attributes.Values); } if (r.locals != null) { ruleCtx.AddDecls(r.locals.attributes.Values); } } else { if (r.args != null || r.retvals != null || r.locals != null) { throw new System.NotSupportedException("customized fields are not yet supported for customized context objects"); } } ruleLabels = r.GetElementLabelNames(); tokenLabels = r.GetTokenRefs(); if (r.exceptions != null) { exceptions = new List <ExceptionClause>(); foreach (GrammarAST e in r.exceptions) { ActionAST catchArg = (ActionAST)e.GetChild(0); ActionAST catchAction = (ActionAST)e.GetChild(1); exceptions.Add(new ExceptionClause(factory, catchArg, catchAction)); } } startState = factory.GetGrammar().atn.ruleToStartState[r.index]; }