regex: Create and handle LEXACT nodes

[perl5.git] / perly.c

diff --git a/perly.c b/perly.c
index 8f3c5c8..41978fa 100644 (file)
--- a/perly.c
+++ b/perly.c
@@ -280,6 +280,8 @@ Perl_yyparse (pTHX_ int gramtype)
 
     /* initialise state for this parse */
     parser->yychar = gramtype;
+    yytoken = YYTRANSLATE(NATIVE_TO_UNI(parser->yychar));
+
     parser->yyerrstatus = 0;
     parser->yylen = 0;
     Newx(parser->stack, YYINITDEPTH, yy_stack_frame);
@@ -300,60 +302,63 @@ Perl_yyparse (pTHX_ int gramtype)
 
             parser->yylen = 0;
 
-            {
-                /* grow the stack? We always leave 1 spare slot,
-                 * in case of a '' -> 'foo' reduction.
-                 * Note that stack_max1 points to the (top-1)th allocated stack
-                 * element to make this check fast */
-
-                if (ps >= parser->stack_max1) {
-                    Size_t pos = ps - parser->stack;
-                    Size_t newsize = 2 * (parser->stack_max1 + 2 - parser->stack);
-                    /* this will croak on insufficient memory */
-                    Renew(parser->stack, newsize, yy_stack_frame);
-                    ps = parser->ps = parser->stack + pos;
-                    parser->stack_max1 = parser->stack + newsize - 1;
-
-                    YYDPRINTF((Perl_debug_log,
-                                    "parser stack size increased to %lu frames\n",
-                                    (unsigned long int)newsize));
-                }
+            /* Grow the stack? We always leave 1 spare slot, in case of a
+             * '' -> 'foo' reduction.
+             * Note that stack_max1 points to the (top-1)th allocated stack
+             * element to make this check faster */
+
+            if (ps >= parser->stack_max1) {
+                Size_t pos = ps - parser->stack;
+                Size_t newsize = 2 * (parser->stack_max1 + 2 - parser->stack);
+                /* this will croak on insufficient memory */
+                Renew(parser->stack, newsize, yy_stack_frame);
+                ps = parser->ps = parser->stack + pos;
+                parser->stack_max1 = parser->stack + newsize - 1;
+
+                YYDPRINTF((Perl_debug_log,
+                                "parser stack size increased to %lu frames\n",
+                                (unsigned long int)newsize));
             }
 
-        /* Do appropriate processing given the current state.  */
-        /* Read a lookahead token if we need one and don't already have one.  */
+            /* Do appropriate processing given the current state. Read a
+             * lookahead token if we need one and don't already have one.
+             * */
 
-            /* First try to decide what to do without reference to lookahead token.  */
+            /* First try to decide what to do without reference to
+             * lookahead token. */
 
             yyn = yypact[yystate];
             if (yyn == YYPACT_NINF)
                 goto yydefault;
 
-            /* Not known => get a lookahead token if don't already have one.  */
+            /* Not known => get a lookahead token if don't already have
+             * one.  YYCHAR is either YYEMPTY or YYEOF or a valid
+             * lookahead symbol. */
 
-            /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
             if (parser->yychar == YYEMPTY) {
                 YYDPRINTF ((Perl_debug_log, "Reading a token:\n"));
                 parser->yychar = yylex();
+                assert(parser->yychar >= 0);
+                if (parser->yychar == YYEOF) {
+                    YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
+                }
+                /* perly.tab is shipped based on an ASCII system, so need
+                 * to index it with characters translated to ASCII.
+                 * Although it's not designed for this purpose, we can use
+                 * NATIVE_TO_UNI here.  It returns its argument on ASCII
+                 * platforms, and on EBCDIC translates native to ascii in
+                 * the 0-255 range, leaving every other possible input
+                 * unchanged.  This jibes with yylex() returning some bare
+                 * characters in that range, but all tokens it returns are
+                 * either 0, or above 255.  There could be a problem if NULs
+                 * weren't 0, or were ever returned as raw chars by yylex() */
+                yytoken = YYTRANSLATE(NATIVE_TO_UNI(parser->yychar));
             }
 
-            if (parser->yychar <= YYEOF) {
-                parser->yychar = yytoken = YYEOF;
-                YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
-            }
-            else {
-                /* perly.tab is shipped based on an ASCII system, so need to index it
-                 * with characters translated to ASCII.  Although it's not designed for
-                 * this purpose, we can use NATIVE_TO_UNI here.  It returns its
-                 * argument on ASCII platforms, and on EBCDIC translates native to
-                 * ascii in the 0-255 range, leaving everything else unchanged.  This
-                 * jibes with yylex() returning some bare characters in that range, but
-                 * all tokens it returns are either 0, or above 255.  There could be a
-                 * problem if NULs weren't 0, or were ever returned as raw chars by
-                 * yylex() */
-                yytoken = YYTRANSLATE (NATIVE_TO_UNI(parser->yychar));
-                YYDSYMPRINTF ("Next token is", yytoken, &parser->yylval);
-            }
+            /* make sure no-one's changed yychar since the last call to yylex */
+            assert(yytoken == YYTRANSLATE(NATIVE_TO_UNI(parser->yychar)));
+            YYDSYMPRINTF("lookahead token is", yytoken, &parser->yylval);
+
 
             /* If the proper action on seeing token YYTOKEN is to reduce or to
              * detect an error, take that action.