示例#1
0
        private static Nfa rule()
        {
            int     num     = 0;
            NfaPair nfaPair = Alloc.NewNfaPair();
            Nfa     nfa;
            Nfa     end;

            if (MakeNfa.spec.current_token == Tokens.AT_BOL)
            {
                num |= 1;
                MakeNfa.gen.Advance();
                MakeNfa.expr(nfaPair);
                nfa      = Alloc.NewNfa(MakeNfa.spec);
                nfa.Edge = MakeNfa.spec.BOL;
                nfa.Next = nfaPair.start;
                end      = nfaPair.end;
            }
            else
            {
                MakeNfa.expr(nfaPair);
                nfa = nfaPair.start;
                end = nfaPair.end;
            }
            if (Tokens.AT_EOL == MakeNfa.spec.current_token)
            {
                MakeNfa.gen.Advance();
                NfaPair nfaPair2 = Alloc.NewNLPair(MakeNfa.spec);
                end.Next = Alloc.NewNfa(MakeNfa.spec);
                Nfa next = end.Next;
                next.Next         = nfaPair2.start;
                next.Sibling      = Alloc.NewNfa(MakeNfa.spec);
                next.Sibling.Edge = MakeNfa.spec.EOF;
                next.Sibling.Next = nfaPair2.end;
                end  = nfaPair2.end;
                num |= 2;
            }
            if (end == null)
            {
                Error.ParseError(Errors.ZERO, MakeNfa.gen.InputFilePath, MakeNfa.input.line_number);
            }
            end.SetAccept(MakeNfa.gen.packAccept());
            end.SetAnchor(num);
            return(nfa);
        }
示例#2
0
/*
 * Function: rule
 * Description: Recursive descent regular expression parser.
 */
        private static Nfa rule()
        {
            NfaPair pair;
            Nfa     start  = null;
            Nfa     end    = null;
            int     anchor = Spec.NONE;

#if DESCENT_DEBUG
            Utility.enter("rule", spec.lexeme, spec.current_token);
#endif

            pair = Alloc.NewNfaPair();

            if (Gen.AT_BOL == spec.current_token)
            {
                anchor = anchor | Spec.START;
                gen.Advance();
                expr(pair);

                start = Alloc.NewNfa(spec);
                start.SetEdge(spec.BOL);
                start.SetNext(pair.start);
                end = pair.end;
            }
            else
            {
                expr(pair);
                start = pair.start;
                end   = pair.end;
            }

            if (Gen.AT_EOL == spec.current_token)
            {
                gen.Advance();

                NfaPair nlpair = Alloc.NewNLPair(spec);
                end.SetNext(Alloc.NewNfa(spec));
                Nfa enext = end.GetNext();
                enext.SetNext(nlpair.start);
                enext.SetSib(Alloc.NewNfa(spec));
                enext.GetSib().SetEdge(spec.EOF);
                enext.GetSib().SetNext(nlpair.end);
                end = nlpair.end;

                anchor = anchor | Spec.END;
            }

            /* check for null rules */
            if (end == null)
            {
                Error.parse_error(Error.E_ZERO, input.line_number);
            }

            /* Handle end of regular expression */
            end.SetAccept(gen.packAccept());
            end.SetAnchor(anchor);

#if DESCENT_DEBUG
            Utility.leave("rule", spec.lexeme, spec.current_token);
#endif
            return(start);
        }