protected internal virtual void ReadLexerActions(ATN atn) { // // LEXER ACTIONS // if (atn.grammarType == ATNType.Lexer) { atn.lexerActions = new ILexerAction[ReadInt()]; for (int i_10 = 0; i_10 < atn.lexerActions.Length; i_10++) { LexerActionType actionType = (LexerActionType)ReadInt(); int data1 = ReadInt(); if (data1 == unchecked ((int)(0xFFFF))) { data1 = -1; } int data2 = ReadInt(); if (data2 == unchecked ((int)(0xFFFF))) { data2 = -1; } ILexerAction lexerAction = LexerActionFactory(actionType, data1, data2); atn.lexerActions[i_10] = lexerAction; } } }
public override Handle LexerCommand(GrammarAST ID) { ILexerAction lexerAction = CreateLexerAction(ID, null); 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 Template cmdST = codegenTemplates.GetInstanceOf("Lexer" + CharSupport.Capitalize(ID.Text) + "Command"); if (cmdST == null) { g.tool.errMgr.GrammarError(ErrorType.INVALID_LEXER_COMMAND, g.fileName, ID.Token, ID.Text); return(Epsilon(ID)); } if (cmdST.impl.FormalArguments != null && cmdST.impl.FormalArguments.Any(x => x.Name == "arg")) { g.tool.errMgr.GrammarError(ErrorType.MISSING_LEXER_COMMAND_ARGUMENT, g.fileName, ID.Token, ID.Text); return(Epsilon(ID)); } return(Action(cmdST.Render())); }
/// <summary> /// Constructs an executor for a sequence of /// <see cref="ILexerAction"/> /// actions. /// </summary> /// <param name="lexerActions">The lexer actions to execute.</param> public LexerActionExecutor(ILexerAction[] lexerActions) { this.lexerActions = lexerActions; int hash = MurmurHash.Initialize(); foreach (ILexerAction lexerAction in lexerActions) { hash = MurmurHash.Update(hash, lexerAction); } this.hashCode = MurmurHash.Finish(hash, lexerActions.Length); }
protected virtual int GetLexerActionIndex(ILexerAction lexerAction) { int lexerActionIndex; if (!actionToIndexMap.TryGetValue(lexerAction, out lexerActionIndex)) { lexerActionIndex = actionToIndexMap.Count; actionToIndexMap[lexerAction] = lexerActionIndex; indexToActionMap[lexerActionIndex] = lexerAction; } return(lexerActionIndex); }
protected virtual Handle Action(GrammarAST node, ILexerAction lexerAction) { ATNState left = NewState(node); ATNState right = NewState(node); bool isCtxDependent = false; int lexerActionIndex = GetLexerActionIndex(lexerAction); ActionTransition a = new ActionTransition(right, currentRule.index, lexerActionIndex, isCtxDependent); left.AddTransition(a); node.atnState = left; Handle h = new Handle(left, right); return(h); }
/// <summary> /// Execute the actions encapsulated by this executor within the context of a /// particular /// <see cref="Antlr4.Runtime.Lexer"/> /// . /// <p>This method calls /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/> /// to set the position of the /// <paramref name="input"/> /// /// <see cref="Antlr4.Runtime.ICharStream"/> /// prior to calling /// <see cref="ILexerAction.Execute(Antlr4.Runtime.Lexer)"/> /// on a position-dependent action. Before the /// method returns, the input position will be restored to the same position /// it was in when the method was invoked.</p> /// </summary> /// <param name="lexer">The lexer instance.</param> /// <param name="input"> /// The input stream which is the source for the current token. /// When this method is called, the current /// <see cref="Antlr4.Runtime.IIntStream.Index()"/> /// for /// <paramref name="input"/> /// should be the start of the following token, i.e. 1 /// character past the end of the current token. /// </param> /// <param name="startIndex"> /// The token start index. This value may be passed to /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/> /// to set the /// <paramref name="input"/> /// position to the beginning /// of the token. /// </param> public virtual void Execute(Lexer lexer, ICharStream input, int startIndex) { bool requiresSeek = false; int stopIndex = input.Index; try { foreach (ILexerAction lexerAction in lexerActions) { ILexerAction action = lexerAction; if (action is LexerIndexedCustomAction) { int offset = ((LexerIndexedCustomAction)action).Offset; input.Seek(startIndex + offset); action = ((LexerIndexedCustomAction)action).Action; requiresSeek = (startIndex + offset) != stopIndex; } else { if (action.IsPositionDependent) { input.Seek(stopIndex); requiresSeek = false; } } action.Execute(lexer); } } finally { if (requiresSeek) { input.Seek(stopIndex); } } }
protected virtual Handle Action(GrammarAST node, ILexerAction lexerAction) { ATNState left = NewState(node); ATNState right = NewState(node); bool isCtxDependent = false; int lexerActionIndex = GetLexerActionIndex(lexerAction); ActionTransition a = new ActionTransition(right, currentRule.index, lexerActionIndex, isCtxDependent); left.AddTransition(a); node.atnState = left; Handle h = new Handle(left, right); return h; }
protected virtual int GetLexerActionIndex(ILexerAction lexerAction) { int lexerActionIndex; if (!actionToIndexMap.TryGetValue(lexerAction, out lexerActionIndex)) { lexerActionIndex = actionToIndexMap.Count; actionToIndexMap[lexerAction] = lexerActionIndex; indexToActionMap[lexerActionIndex] = lexerAction; } return lexerActionIndex; }
public static Antlr4.Runtime.Atn.LexerActionExecutor Append(Antlr4.Runtime.Atn.LexerActionExecutor lexerActionExecutor, ILexerAction lexerAction) { if (lexerActionExecutor == null) { return new Antlr4.Runtime.Atn.LexerActionExecutor(new ILexerAction[] { lexerAction }); } ILexerAction[] lexerActions = Arrays.CopyOf(lexerActionExecutor.lexerActions, lexerActionExecutor.lexerActions.Length + 1); lexerActions[lexerActions.Length - 1] = lexerAction; return new Antlr4.Runtime.Atn.LexerActionExecutor(lexerActions); }
/// <summary> /// Constructs a new indexed custom action by associating a character offset /// with a /// <see cref="ILexerAction"/> /// . /// <p>Note: This class is only required for lexer actions for which /// <see cref="ILexerAction.IsPositionDependent()"/> /// returns /// <code>true</code> /// .</p> /// </summary> /// <param name="offset"> /// The offset into the input /// <see cref="Antlr4.Runtime.ICharStream"/> /// , relative to /// the token start index, at which the specified lexer action should be /// executed. /// </param> /// <param name="action"> /// The lexer action to execute at a particular offset in the /// input /// <see cref="Antlr4.Runtime.ICharStream"/> /// . /// </param> public LexerIndexedCustomAction(int offset, ILexerAction action) { this.offset = offset; this.action = action; }
public static Antlr4.Runtime.Atn.LexerActionExecutor Append(Antlr4.Runtime.Atn.LexerActionExecutor lexerActionExecutor, ILexerAction lexerAction) { if (lexerActionExecutor == null) { return(new Antlr4.Runtime.Atn.LexerActionExecutor(new ILexerAction[] { lexerAction })); } ILexerAction[] lexerActions = Arrays.CopyOf(lexerActionExecutor.lexerActions, lexerActionExecutor.lexerActions.Length + 1); lexerActions[lexerActions.Length - 1] = lexerAction; return(new Antlr4.Runtime.Atn.LexerActionExecutor(lexerActions)); }