Exemplo n.º 1
0
        /// <summary>
        /// 读取输入流中的下一个词法单元并提升输入流的字符位置。
        /// </summary>
        /// <param name="state">DFA 的起始状态。</param>
        /// <returns>词法单元读入是否成功。</returns>
        protected override bool InternalReadToken(int state)
        {
            stateStack.Clear();
            int startIndex = Source.Index;

            while (true)
            {
                state = TransitionState(state, base.Source.Read());
                if (state == -1)
                {
                    // 没有合适的转移,退出。
                    break;
                }
                IList <int> symbolIndex = base.LexerRule.States[state].SymbolIndex;
                if (symbolIndex.Count > 0)
                {
                    // 将接受状态记录在堆栈中。
                    stateStack.Push(new AcceptState(symbolIndex, Source.Index));
                }
            }
            // 遍历终结状态,执行相应动作。
            while (stateStack.Count > 0)
            {
                AcceptState astate = stateStack.Pop();
                for (int i = 0; i < astate.SymbolIndex.Count; i++)
                {
                    int acceptState = astate.SymbolIndex[i];
                    int lastIndex   = astate.Index;
                    // 将文本和流调整到与接受状态匹配的状态。
                    Source.Index = lastIndex;
                    DoAction(base.LexerRule.Symbols[acceptState].Action, acceptState);
                    if (!base.IsReject)
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
Exemplo n.º 2
0
        /// <summary>
        /// 读取输入流中的下一个词法单元并提升输入流的字符位置。
        /// </summary>
        /// <param name="state">DFA 的起始状态。</param>
        /// <returns>词法单元读入是否成功。</returns>
        protected override bool InternalReadToken(int state)
        {
            stateStack.Clear();
            int startIndex = Source.Index;

            while (true)
            {
                state = TransitionState(state, base.Source.Read());
                if (state == -1)
                {
                    // 没有合适的转移,退出。
                    break;
                }
                IList <int> symbolIndex = base.LexerRule.States[state].SymbolIndex;
                if (symbolIndex.Count > 0)
                {
                    // 将接受状态记录在堆栈中。
                    stateStack.Push(new AcceptState(symbolIndex, Source.Index));
                }
            }
            // 遍历终结状态,执行相应动作。
            while (stateStack.Count > 0)
            {
                AcceptState astate = stateStack.Pop();
                for (int i = 0; i < astate.SymbolIndex.Count; i++)
                {
                    int acceptState = astate.SymbolIndex[i];
                    if (acceptState >= base.LexerRule.SymbolCount)
                    {
                        // 跳过向前看的头状态。
                        break;
                    }
                    int lastIndex = astate.Index;
                    int?trailing  = base.LexerRule.Symbols[acceptState].Trailing;
                    if (trailing.HasValue)
                    {
                        // 是向前看状态。
                        int index = trailing.Value;
                        if (index > 0)
                        {
                            // 前面长度固定。
                            lastIndex = startIndex + index;
                        }
                        else if (index < 0)
                        {
                            // 后面长度固定,注意此时 index 是负数。
                            lastIndex += index;
                        }
                        else
                        {
                            // 前后长度都不固定,需要沿着堆栈向前找。
                            int target = int.MaxValue - acceptState;
                            for (int j = stateStack.Count - 1; j >= 0; j--)
                            {
                                if (ContainsTrailingHead(stateStack[j].SymbolIndex, target))
                                {
                                    lastIndex = stateStack[j].Index;
                                    break;
                                }
                            }
                        }
                    }
                    // 将文本和流调整到与接受状态匹配的状态。
                    Source.Index = lastIndex;
                    DoAction(base.LexerRule.Symbols[acceptState].Action, acceptState);
                    if (!base.IsReject)
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }