public Choice(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, IList <CodeBlockForAlt> alts) : base(factory, blkOrEbnfRootAST) { this.alts = alts; }
public SemPred(OutputModelFactory factory, [NotNull] ActionAST ast) : base(factory, ast) { Debug.Assert(ast.atnState != null && ast.atnState.NumberOfTransitions == 1 && ast.atnState.Transition(0) is AbstractPredicateTransition); GrammarAST failNode = ast.GetOptionAST("fail"); predicate = ast.Text; if (predicate.StartsWith("{") && predicate.EndsWith("}?")) { predicate = predicate.Substring(1, predicate.Length - 3); } predicate = factory.GetTarget().GetTargetStringLiteralFromString(predicate); if (failNode == null) return; if (failNode is ActionAST) { ActionAST failActionNode = (ActionAST)failNode; RuleFunction rf = factory.GetCurrentRuleFunction(); failChunks = ActionTranslator.TranslateAction(factory, rf, failActionNode.Token, failActionNode); } else { msg = factory.GetTarget().GetTargetStringLiteralFromANTLRStringLiteral(factory.GetGenerator(), failNode.Text, true); } }
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 Choice(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, IList<CodeBlockForAlt> alts) : base(factory, blkOrEbnfRootAST) { this.alts = alts; }
public StructDecl(OutputModelFactory factory, Rule r) : base(factory, factory.GetTarget().GetRuleFunctionContextStructName(r)) { AddDispatchMethods(r); derivedFromName = r.name; provideCopyFrom = r.HasAltSpecificContexts(); }
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 RuleActionFunction(OutputModelFactory factory, Rule r, string ctxType) : base(factory) { name = r.name; ruleIndex = r.index; this.ctxType = ctxType; }
public AltLabelStructDecl(OutputModelFactory factory, Rule r, string label) : base(factory, r) { this.name = // override name set in super to the label ctx factory.GetTarget().GetAltLabelContextStructName(label); derivedFromName = label; }
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 MatchToken(OutputModelFactory factory, TerminalAST ast) : base(factory, ast) { Grammar g = factory.GetGrammar(); ttype = g.GetTokenType(ast.Text); name = factory.GetTarget().GetTokenTypeAsTargetLabel(g, ttype); }
public RuleElement(OutputModelFactory factory, GrammarAST ast) : base(factory, ast) { if (ast != null && ast.atnState != null) { stateNumber = ast.atnState.stateNumber; } }
protected SrcOp(OutputModelFactory factory, GrammarAST ast) : base(factory, ast) { if (ast != null) uniqueID = ast.Token.TokenIndex; enclosingBlock = factory.GetCurrentBlock(); enclosingRuleRunction = factory.GetCurrentRuleFunction(); }
public Loop(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, IList<CodeBlockForAlt> alts) : base(factory, blkOrEbnfRootAST, alts) { bool nongreedy = (blkOrEbnfRootAST is QuantifierAST) && !((QuantifierAST)blkOrEbnfRootAST).GetGreedy(); exitAlt = nongreedy ? 1 : alts.Count + 1; }
public ExceptionClause(OutputModelFactory factory, ActionAST catchArg, ActionAST catchAction) : base(factory, catchArg) { this.catchArg = new Action(factory, catchArg); this.catchAction = new Action(factory, catchAction); }
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; }
// @ModelElement public ThrowNoViableAlt error; public AltBlock(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, IList<CodeBlockForAlt> alts) : base(factory, blkOrEbnfRootAST, alts) { decision = ((BlockStartState)blkOrEbnfRootAST.atnState).decision; // interp.predict() throws exception // this.error = new ThrowNoViableAlt(factory, blkOrEbnfRootAST, null); }
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 Loop(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, IList <CodeBlockForAlt> alts) : base(factory, blkOrEbnfRootAST, alts) { bool nongreedy = (blkOrEbnfRootAST is QuantifierAST) && !((QuantifierAST)blkOrEbnfRootAST).GetGreedy(); exitAlt = nongreedy ? 1 : alts.Count + 1; }
public TestSetInline(OutputModelFactory factory, GrammarAST ast, IntervalSet set, int wordSize) : base(factory, ast) { bitsetWordSize = wordSize; Bitset[] withZeroOffset = CreateBitsets(factory, set, wordSize, true); Bitset[] withoutZeroOffset = CreateBitsets(factory, set, wordSize, false); this.bitsets = withZeroOffset.Length <= withoutZeroOffset.Length ? withZeroOffset : withoutZeroOffset; this.varName = "_la"; }
// @ModelElement public ThrowNoViableAlt error; public AltBlock(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, IList <CodeBlockForAlt> alts) : base(factory, blkOrEbnfRootAST, alts) { decision = ((BlockStartState)blkOrEbnfRootAST.atnState).decision; // interp.predict() throws exception // this.error = new ThrowNoViableAlt(factory, blkOrEbnfRootAST, null); }
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; }
protected SrcOp(OutputModelFactory factory, GrammarAST ast) : base(factory, ast) { if (ast != null) { uniqueID = ast.Token.TokenIndex; } enclosingBlock = factory.GetCurrentBlock(); enclosingRuleRunction = factory.GetCurrentRuleFunction(); }
public StarBlock(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, IList<CodeBlockForAlt> alts) : base(factory, blkOrEbnfRootAST, alts) { loopLabel = factory.GetTarget().GetLoopLabel(blkOrEbnfRootAST); StarLoopEntryState star = (StarLoopEntryState)blkOrEbnfRootAST.atnState; loopBackStateNumber = star.loopBackState.stateNumber; decision = star.decision; }
public MatchSet(OutputModelFactory factory, GrammarAST ast) : base(factory, ast) { SetTransition st = (SetTransition)ast.atnState.Transition(0); int wordSize = factory.GetGenerator().GetTarget().GetInlineTestSetWordSize(); expr = new TestSetInline(factory, null, st.set, wordSize); Decl.Decl d = new TokenTypeDecl(factory, expr.varName); factory.GetCurrentRuleFunction().AddLocalDecl(d); capture = new CaptureNextTokenType(factory, expr.varName); }
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 StarBlock(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, IList <CodeBlockForAlt> alts) : base(factory, blkOrEbnfRootAST, alts) { loopLabel = factory.GetTarget().GetLoopLabel(blkOrEbnfRootAST); StarLoopEntryState star = (StarLoopEntryState)blkOrEbnfRootAST.atnState; loopBackStateNumber = star.loopBackState.stateNumber; decision = star.decision; }
// public BitSetDecl expecting; public Sync(OutputModelFactory factory, GrammarAST blkOrEbnfRootAST, IntervalSet expecting, int decision, string position) : base(factory, blkOrEbnfRootAST) { this.decision = decision; // this.expecting = factory.createExpectingBitSet(ast, decision, expecting, position); // factory.defineBitSet(this.expecting); }
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 SerializedATN(OutputModelFactory factory, ATN atn, IList<string> ruleNames) : base(factory) { List<int> data = ATNSerializer.GetSerialized(atn, ruleNames); serialized = new List<string>(data.Count); foreach (int c in data) { string encoded = factory.GetTarget().EncodeIntAsCharEscape(c == -1 ? char.MaxValue : c); serialized.Add(encoded); } //System.Console.WriteLine(ATNSerializer.GetDecoded(factory.GetGrammar(), atn)); }
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 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 SerializedATN(OutputModelFactory factory, ATN atn, IList <string> ruleNames) : base(factory) { List <int> data = ATNSerializer.GetSerialized(atn, ruleNames); serialized = new List <string>(data.Count); foreach (int c in data) { string encoded = factory.GetTarget().EncodeIntAsCharEscape(c == -1 ? char.MaxValue : c); serialized.Add(encoded); } //System.Console.WriteLine(ATNSerializer.GetDecoded(factory.GetGrammar(), atn)); }
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 PlusBlock(OutputModelFactory factory, GrammarAST plusRoot, IList<CodeBlockForAlt> alts) : base(factory, plusRoot, alts) { BlockAST blkAST = (BlockAST)plusRoot.GetChild(0); PlusBlockStartState blkStart = (PlusBlockStartState)blkAST.atnState; PlusLoopbackState loop = blkStart.loopBackState; stateNumber = blkStart.loopBackState.stateNumber; blockStartStateNumber = blkStart.stateNumber; loopBackStateNumber = loop.stateNumber; this.error = GetThrowNoViableAlt(factory, plusRoot, null); decision = loop.decision; }
public Action(OutputModelFactory factory, ActionAST ast) : base(factory, ast) { RuleFunction rf = factory.GetCurrentRuleFunction(); if (ast != null) { chunks = ActionTranslator.TranslateAction(factory, rf, ast.Token, ast); } else { chunks = new List<ActionChunk>(); } //System.out.println("actions="+chunks); }
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); }
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; AccessModifier = System.StringComparer.OrdinalIgnoreCase.Equals(g.GetOptionString("useInternalAccessModifier"), "true") ? "internal" : "public"; IncludeDebuggerNonUserCodeAttribute = System.StringComparer.OrdinalIgnoreCase.Equals(g.GetOptionString("includeDebuggerNonUserCodeAttribute"), "true"); IncludeClsCompliantAttribute = !System.StringComparer.OrdinalIgnoreCase.Equals(g.GetOptionString("excludeClsCompliantAttribute"), "true"); // default is to include this to maintain existing behaviour }
public PlusBlock(OutputModelFactory factory, GrammarAST plusRoot, IList <CodeBlockForAlt> alts) : base(factory, plusRoot, alts) { BlockAST blkAST = (BlockAST)plusRoot.GetChild(0); PlusBlockStartState blkStart = (PlusBlockStartState)blkAST.atnState; PlusLoopbackState loop = blkStart.loopBackState; stateNumber = blkStart.loopBackState.stateNumber; blockStartStateNumber = blkStart.stateNumber; loopBackStateNumber = loop.stateNumber; this.error = GetThrowNoViableAlt(factory, plusRoot, null); decision = loop.decision; }
public virtual void FillNamedActions(OutputModelFactory factory, Rule r) { if (r.finallyAction != null) { finallyAction = new Action(factory, r.finallyAction); } namedActions = new Dictionary <string, Action>(); foreach (string name in r.namedActions.Keys) { ActionAST ast; r.namedActions.TryGetValue(name, out ast); namedActions[name] = new Action(factory, ast); } }
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 Action(OutputModelFactory factory, ActionAST ast) : base(factory, ast) { RuleFunction rf = factory.GetCurrentRuleFunction(); if (ast != null) { chunks = ActionTranslator.TranslateAction(factory, rf, ast.Token, ast); } else { chunks = new List <ActionChunk>(); } //System.out.println("actions="+chunks); }
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 Action(OutputModelFactory factory, StructDecl ctx, string action) : base(factory, null) { ActionAST ast = new ActionAST(new CommonToken(ANTLRParser.ACTION, action)); RuleFunction rf = factory.GetCurrentRuleFunction(); if (rf != null) { // we can translate ast.resolver = rf.rule; chunks = ActionTranslator.TranslateActionChunk(factory, rf, action, ast); } else { chunks = new List<ActionChunk>(); chunks.Add(new ActionText(ctx, action)); } }
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 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 Action(OutputModelFactory factory, StructDecl ctx, string action) : base(factory, null) { ActionAST ast = new ActionAST(new CommonToken(ANTLRParser.ACTION, action)); RuleFunction rf = factory.GetCurrentRuleFunction(); if (rf != null) { // we can translate ast.resolver = rf.rule; chunks = ActionTranslator.TranslateActionChunk(factory, rf, action, ast); } else { chunks = new List <ActionChunk>(); chunks.Add(new ActionText(ctx, action)); } }
public static IList<ActionChunk> TranslateAction(OutputModelFactory factory, RuleFunction rf, IToken tokenWithinAction, ActionAST node) { string action = tokenWithinAction.Text; if (action != null && action.Length > 0 && action[0] == '{') { int firstCurly = action.IndexOf('{'); int lastCurly = action.LastIndexOf('}'); if (firstCurly >= 0 && lastCurly >= 0) { action = action.Substring(firstCurly + 1, lastCurly - firstCurly - 1); // trim {...} } } return TranslateActionChunk(factory, rf, action, node); }
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); }