* src/gram.h (TIEM_NUMBER_MAX): New.

(item_number_of_rule_number, rule_number_of_item_number): Rename
as...
(rule_number_as_item_number, item_number_as_rule_number): these.
Adjust dependencies.
* src/output.c (vector_number_t, VECTOR_NUMBER_MAX)
(VECTOR_NUMBER_MIN, state_number_to_vector_number)
(symbol_number_to_vector_number): New.
(order): Of vector_number_t* type.
(base_t, BASE_MAX, BASE_MIN): New.
(froms, tos, width, pos, check): Of base_t type.
(action_number_t, ACTION_MIN, ACTION_MAX): New.
(actrow): Of action_number_t type.
(conflrow): Of unsigned int type.
(table_ninf, base_ninf): New.
(GENERATE_MUSCLE_INSERT_TABLE): Also output the `*_min' value.
(muscle_insert_int_table, muscle_insert_base_table)
(muscle_insert_rule_number_table): New.
(prepare_tokens): Output `toknum' as int_table.
(action_row): Returns a rule_number_t.
Use ACTION_MIN, not SHRT_MIN.
(token_actions): yydefact is rule_number_t*.
(table_ninf_remap): New.
(pack_table): Use it for `base' and `table'.
* data/yacc.c, data/glr.c, data/lalr1.cc (YYFLAG): Remove,
replaced with...
(YYPACT_NINF, YYTABLE_NINF): these.
(yypact, yytable): Compute their types instead of hard-coded
`short'.
* tests/regression.at (Web2c Actions): Adjust.

diff --git a/ChangeLog b/ChangeLog
index b9b7d58ebe70a17f4eaab7de51d8b006d4c5757a..1b40024db460dc0f69314faa0ea23511f622c8ec 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,36 @@
+2002-07-25  Akim Demaille  <akim@epita.fr>
+
+       * src/gram.h (TIEM_NUMBER_MAX): New.
+       (item_number_of_rule_number, rule_number_of_item_number): Rename
+       as...
+       (rule_number_as_item_number, item_number_as_rule_number): these.
+       Adjust dependencies.
+       * src/output.c (vector_number_t, VECTOR_NUMBER_MAX)
+       (VECTOR_NUMBER_MIN, state_number_to_vector_number)
+       (symbol_number_to_vector_number): New.
+       (order): Of vector_number_t* type.
+       (base_t, BASE_MAX, BASE_MIN): New.
+       (froms, tos, width, pos, check): Of base_t type.
+       (action_number_t, ACTION_MIN, ACTION_MAX): New.
+       (actrow): Of action_number_t type.
+       (conflrow): Of unsigned int type.
+       (table_ninf, base_ninf): New.
+       (GENERATE_MUSCLE_INSERT_TABLE): Also output the `*_min' value.
+       (muscle_insert_int_table, muscle_insert_base_table)
+       (muscle_insert_rule_number_table): New.
+       (prepare_tokens): Output `toknum' as int_table.
+       (action_row): Returns a rule_number_t.
+       Use ACTION_MIN, not SHRT_MIN.
+       (token_actions): yydefact is rule_number_t*.
+       (table_ninf_remap): New.
+       (pack_table): Use it for `base' and `table'.
+       * data/yacc.c, data/glr.c, data/lalr1.cc (YYFLAG): Remove,
+       replaced with...
+       (YYPACT_NINF, YYTABLE_NINF): these.
+       (yypact, yytable): Compute their types instead of hard-coded
+       `short'.
+       * tests/regression.at (Web2c Actions): Adjust.
+

 2002-07-19  Akim Demaille  <akim@epita.fr>
 
        * src/scan-gram.l (id): Can start with an underscore.
 2002-07-19  Akim Demaille  <akim@epita.fr>
 
        * src/scan-gram.l (id): Can start with an underscore.

diff --git a/data/glr.c b/data/glr.c
index 2d30eb9e1ee361dba277296620420a84c1ca634a..94e61bfc71c1e8834ad9d21dc21ab24362e02144 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -310,7 +310,7 @@ static const short yydefact[] =
   ]b4_defact[
 };
 
   ]b4_defact[
 };
 

-/* YYPGOTO[NTERM-NUM]. */
+/* YYPDEFGOTO[NTERM-NUM]. */

 static const short yydefgoto[] =
 {
   ]b4_defgoto[
 static const short yydefgoto[] =
 {
   ]b4_defgoto[


@@ -318,7 +318,8 @@ static const short yydefgoto[] =
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */

-static const short yypact[] =
+#define YYPACT_NINF ]b4_pact_ninf[
+static const ]b4_sint_type(b4_pact_max)[ yypact[] =

 {
   ]b4_pact[
 };
 {
   ]b4_pact[
 };


@@ -332,7 +333,8 @@ static const short yypgoto[] =
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.  */
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.  */

-static const short yytable[] =
+#define YYTABLE_NINF ]b4_table_ninf[
+static const ]b4_sint_type(b4_table_max)[ yytable[] =

 {
   ]b4_table[
 };
 {
   ]b4_table[
 };


@@ -389,10 +391,10 @@ int yyparse (void);
 #define YYRHSLOC(yyRhs,YYK) (yyRhs[YYK].yystate.yyloc)
 
 #ifndef YYLLOC_DEFAULT
 #define YYRHSLOC(yyRhs,YYK) (yyRhs[YYK].yystate.yyloc)
 
 #ifndef YYLLOC_DEFAULT

-# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN)           \
-  yyCurrent.yyfirst_line   = YYRHSLOC(yyRhs,1).yyfirst_line;      \
-  yyCurrent.yyfirst_column = YYRHSLOC(yyRhs,1).yyfirst_column;    \
-  yyCurrent.yylast_line    = YYRHSLOC(yyRhs,YYN).yylast_line;       \
+# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN)                 \
+  yyCurrent.yyfirst_line   = YYRHSLOC(yyRhs,1).yyfirst_line;   \
+  yyCurrent.yyfirst_column = YYRHSLOC(yyRhs,1).yyfirst_column; \
+  yyCurrent.yylast_line    = YYRHSLOC(yyRhs,YYN).yylast_line;  \

   yyCurrent.yylast_column  = YYRHSLOC(yyRhs,YYN).yylast_column;
 #endif
 
   yyCurrent.yylast_column  = YYRHSLOC(yyRhs,YYN).yylast_column;
 #endif
 


@@ -676,7 +678,7 @@ yylhsNonterm (yyRuleNum yyrule)
 static inline bool
 yyisDefaultedState (yyStateNum yystate)
 {
 static inline bool
 yyisDefaultedState (yyStateNum yystate)
 {

-  return yypact[yystate] == YYFLAG;
+  return yypact[yystate] == YYPACT_NINF;

 }
 
 /** The default reduction for STATE, assuming it has one. */
 }
 
 /** The default reduction for STATE, assuming it has one. */


@@ -731,7 +733,7 @@ yyisShiftAction (int yyaction)
 static inline bool
 yyisErrorAction (int yyaction)
 {
 static inline bool
 yyisErrorAction (int yyaction)
 {

-  return yyaction == 0 || yyaction == YYFLAG;
+  return yyaction == 0 || yyaction == YYPACT_NINF;

 }
 
                                /* GLRStates */
 }
 
                                /* GLRStates */


@@ -1497,7 +1499,7 @@ yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
       char* yyp;
       char* yymsg;
       yyn = yypact[yystack->yytops.yystates[0]->yylrState];
       char* yyp;
       char* yymsg;
       yyn = yypact[yystack->yytops.yystates[0]->yylrState];

-      if (yyn > YYFLAG && yyn < YYLAST)
+      if (YYPACT_NINF < yyn && yyn < YYLAST)

        {
          yycount = 0;
          /* Start YYX at -YYN if negative to avoid negative indexes in
        {
          yycount = 0;
          /* Start YYX at -YYN if negative to avoid negative indexes in


@@ -1563,7 +1565,7 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
        *yytokenp = YYTRANSLATE (yychar);
        YYDPRINTF ((stderr, "Read token %s\n", yytokenName (*yytokenp)));
        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
        *yytokenp = YYTRANSLATE (yychar);
        YYDPRINTF ((stderr, "Read token %s\n", yytokenName (*yytokenp)));
        yyj = yypact[yystack->yytops.yystates[0]->yylrState];

-       if (yyj == YYFLAG)
+       if (yyj == YYPACT_NINF)

          /* Something's not right; we shouldn't be here */
          yyFail (yystack, NULL);
        yyj += *yytokenp;
          /* Something's not right; we shouldn't be here */
          yyFail (yystack, NULL);
        yyj += *yytokenp;


@@ -1572,7 +1574,7 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
            if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0)
              return;
          }
            if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0)
              return;
          }

-       else if (yytable[yyj] != 0 && yytable[yyj] != YYFLAG)
+       else if (yytable[yyj] != 0 && yytable[yyj] != YYTABLE_NINF)

          return;
       } while (yytrue);
     }
          return;
       } while (yytrue);
     }


@@ -1592,7 +1594,7 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
   while (yystack->yytops.yystates[0] != NULL)
     {
       yyj = yypact[yystack->yytops.yystates[0]->yylrState] + YYTERROR;
   while (yystack->yytops.yystates[0] != NULL)
     {
       yyj = yypact[yystack->yytops.yystates[0]->yylrState] + YYTERROR;

-      if (yyj != YYFLAG + YYTERROR && yyj >= 0 && yyj <= YYLAST &&
+      if (yyj != YYPACT_NINF + YYTERROR && yyj >= 0 && yyj <= YYLAST &&

          yycheck[yyj] == YYTERROR && yyisShiftAction (yytable[yyj]))
        {
          yyglrShift (yystack, 0, yytable[yyj],
          yycheck[yyj] == YYTERROR && yyisShiftAction (yytable[yyj]))
        {
          yyglrShift (yystack, 0, yytable[yyj],

diff --git a/data/lalr1.cc b/data/lalr1.cc
index f0844bb2ab281486353c726ae210c72040e3e076..1a54700196e2f4df3a86909e2d2db943fbac6e38 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -223,11 +223,13 @@ namespace yy
     LocationStack location_stack_;
 
     /* Tables.  */
     LocationStack location_stack_;
 
     /* Tables.  */

-    static const short pact_[[]];
+    static const b4_sint_type(b4_pact_max) pact_[[]];
+    static const b4_sint_type(b4_pact_max) pact_ninf_;

     static const short defact_[[]];
     static const short pgoto_[[]];
     static const short defgoto_[[]];
     static const short defact_[[]];
     static const short pgoto_[[]];
     static const short defgoto_[[]];

-    static const short table_[[]];
+    static const b4_sint_type(b4_table_max) table_[[]];
+    static const b4_sint_type(b4_table_max) table_ninf_;

     static const short check_[[]];
     static const b4_uint_type(b4_r1_max) r1_[[]];
     static const b4_uint_type(b4_r2_max) r2_[[]];
     static const short check_[[]];
     static const b4_uint_type(b4_r1_max) r1_[[]];
     static const b4_uint_type(b4_r2_max) r2_[[]];


@@ -251,7 +253,6 @@ namespace yy
     /* Constants.  */
     static const int eof_;
     static const int last_;
     /* Constants.  */
     static const int eof_;
     static const int last_;

-    static const int flag_;

     static const int nnts_;
     static const int empty_;
     static const int final_;
     static const int nnts_;
     static const int empty_;
     static const int final_;


@@ -336,7 +337,7 @@ yy::b4_name::parse ()
 
   /* Try to take a decision without lookahead.  */
   n_ = pact_[[state_]];
 
   /* Try to take a decision without lookahead.  */
   n_ = pact_[[state_]];

-  if (n_ == flag_)
+  if (n_ == pact_ninf_)

     goto yydefault;
 
   /* Read a lookahead token.  */
     goto yydefault;
 
   /* Read a lookahead token.  */


@@ -375,7 +376,7 @@ yy::b4_name::parse ()
   n_ = table_[[n_]];
   if (n_ < 0)
     {
   n_ = table_[[n_]];
   if (n_ < 0)
     {

-      if (n_ == flag_)
+      if (n_ == table_ninf_)

        goto yyerrlab;
       else
        {
        goto yyerrlab;
       else
        {


@@ -492,7 +493,7 @@ yy::b4_name::parse ()
 
 #if YYERROR_VERBOSE
       n_ = pact_[[state_]];
 
 #if YYERROR_VERBOSE
       n_ = pact_[[state_]];

-      if (n_ > flag_ && n_ < last_)
+      if (pact_ninf_ < n_ && n_ < last_)

        {
          message = "parse error, unexpected ";
          message += name_[[ilooka_]];
        {
          message = "parse error, unexpected ";
          message += name_[[ilooka_]];


@@ -543,7 +544,7 @@ yy::b4_name::parse ()
   for (;;)
     {
       n_ = pact_[[state_]];
   for (;;)
     {
       n_ = pact_[[state_]];

-      if (n_ != flag_)
+      if (n_ != pact_ninf_)

        {
          n_ += terror_;
          if (0 <= n_ && n_ <= last_ && check_[[n_]] == terror_)
        {
          n_ += terror_;
          if (0 <= n_ && n_ <= last_ && check_[[n_]] == terror_)


@@ -628,7 +629,8 @@ yy::b4_name::lex_ ()
 
 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
 
 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */

-const short
+const b4_sint_type(b4_pact_max) yy::b4_name::pact_ninf_ = b4_pact_ninf;
+const b4_sint_type(b4_pact_max)

 yy::b4_name::pact_[[]] =
 {
   b4_pact
 yy::b4_name::pact_[[]] =
 {
   b4_pact


@@ -660,7 +662,8 @@ yy::b4_name::defgoto_[[]] =
 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.  */
 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.  */

-const short
+const b4_sint_type(b4_table_max) yy::b4_name::table_ninf_ = b4_table_ninf;
+const b4_sint_type(b4_table_max)

 yy::b4_name::table_[[]] =
 {
   b4_table
 yy::b4_name::table_[[]] =
 {
   b4_table


@@ -757,7 +760,6 @@ yy::b4_name::translate_ (int token)
 
 const int yy::b4_name::eof_ = 0;
 const int yy::b4_name::last_ = b4_last;
 
 const int yy::b4_name::eof_ = 0;
 const int yy::b4_name::last_ = b4_last;

-const int yy::b4_name::flag_ = b4_flag;

 const int yy::b4_name::nnts_ = b4_nterms_number;
 const int yy::b4_name::empty_ = -2;
 const int yy::b4_name::final_ = b4_final_state_number;
 const int yy::b4_name::nnts_ = b4_nterms_number;
 const int yy::b4_name::empty_ = -2;
 const int yy::b4_name::final_ = b4_final_state_number;

diff --git a/data/yacc.c b/data/yacc.c
index e69311c33522b698a2e539e2bbb1994d4e613733..b2d4cc538c7d6ccd79fa7943a433ffa466ec7e51 100644 (file)
--- a/data/yacc.c
+++ b/data/yacc.c
@@ -2,7 +2,8 @@ m4_divert(-1)                                                       -*- C -*-
 m4_include([c.m4])
 
 # Yacc compatible skeleton for Bison
 m4_include([c.m4])
 
 # Yacc compatible skeleton for Bison

-# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
+# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002
+# Free Software Foundation, Inc.

 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by


@@ -303,7 +304,6 @@ b4_location_if(
 
 /* YYFINAL -- State number of the termination state. */
 #define YYFINAL  b4_final_state_number
 
 /* YYFINAL -- State number of the termination state. */
 #define YYFINAL  b4_final_state_number

-#define YYFLAG  b4_flag

 #define YYLAST   b4_last
 
 /* YYNTOKENS -- Number of terminals. */
 #define YYLAST   b4_last
 
 /* YYNTOKENS -- Number of terminals. */


@@ -385,7 +385,7 @@ static const short yydefact[[]] =
   b4_defact
 };
 
   b4_defact
 };
 

-/* YYPGOTO[[NTERM-NUM]]. */
+/* YYDEFGOTO[[NTERM-NUM]]. */

 static const short yydefgoto[[]] =
 {
   b4_defgoto
 static const short yydefgoto[[]] =
 {
   b4_defgoto


@@ -393,7 +393,8 @@ static const short yydefgoto[[]] =
 
 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
 
 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */

-static const short yypact[[]] =
+#define YYPACT_NINF b4_pact_ninf
+static const b4_sint_type(b4_pact_max) yypact[[]] =

 {
   b4_pact
 };
 {
   b4_pact
 };


@@ -407,7 +408,8 @@ static const short yypgoto[[]] =
 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.  */
 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.  */

-static const short yytable[[]] =
+#define YYTABLE_NINF b4_table_ninf
+static const b4_sint_type(b4_table_max) yytable[[]] =

 {
   b4_table
 };
 {
   b4_table
 };


@@ -820,7 +822,7 @@ yybackup:
   /* First try to decide what to do without reference to lookahead token.  */
 
   yyn = yypact[yystate];
   /* First try to decide what to do without reference to lookahead token.  */
 
   yyn = yypact[yystate];

-  if (yyn == YYFLAG)
+  if (yyn == YYPACT_NINF)

     goto yydefault;
 
   /* Not known => get a lookahead token if don't already have one.  */
     goto yydefault;
 
   /* Not known => get a lookahead token if don't already have one.  */


@@ -855,7 +857,7 @@ yybackup:
     }
 
   yyn += yychar1;
     }
 
   yyn += yychar1;

-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)

     goto yydefault;
 
   yyn = yytable[yyn];
     goto yydefault;
 
   yyn = yytable[yyn];


@@ -869,7 +871,7 @@ yybackup:
 
   if (yyn < 0)
     {
 
   if (yyn < 0)
     {

-      if (yyn == YYFLAG)
+      if (yyn == YYTABLE_NINF)

        goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
        goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;


@@ -980,7 +982,7 @@ yyreduce:
   yyn = yyr1[yyn];
 
   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
   yyn = yyr1[yyn];
 
   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;

-  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)

     yystate = yytable[yystate];
   else
     yystate = yydefgoto[yyn - YYNTOKENS];
     yystate = yytable[yystate];
   else
     yystate = yydefgoto[yyn - YYNTOKENS];


@@ -1000,7 +1002,7 @@ yyerrlab:
 #if YYERROR_VERBOSE
       yyn = yypact[yystate];
 
 #if YYERROR_VERBOSE
       yyn = yypact[yystate];
 

-      if (yyn > YYFLAG && yyn < YYLAST)
+      if (YYPACT_NINF < yyn && yyn < YYLAST)

        {
          YYSIZE_T yysize = 0;
          char *yymsg;
        {
          YYSIZE_T yysize = 0;
          char *yymsg;


@@ -1090,7 +1092,7 @@ yyerrlab1:
   for (;;)
     {
       yyn = yypact[yystate];
   for (;;)
     {
       yyn = yypact[yystate];

-      if (yyn != YYFLAG)
+      if (yyn != YYPACT_NINF)

        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)

diff --git a/src/gram.h b/src/gram.h
index 71191a576eaefe7c342ec96857c96b9a49209b7e..36b19c1b03120dfdbc144eb8976175bb08c7dc5f 100644 (file)
--- a/src/gram.h
+++ b/src/gram.h
@@ -113,6 +113,7 @@ extern int nvars;
 
 typedef int item_number_t;
 # define ITEM_NUMBER_MAX ((item_number_t) INT_MAX)
 
 typedef int item_number_t;
 # define ITEM_NUMBER_MAX ((item_number_t) INT_MAX)

+# define ITEM_NUMBER_MIN ((item_number_t) MIN_MAX)

 extern item_number_t *ritem;
 extern unsigned int nritems;
 
 extern item_number_t *ritem;
 extern unsigned int nritems;
 


@@ -133,8 +134,8 @@ typedef short rule_number_t;
 # define RULE_NUMBER_MAX ((rule_number_t) SHRT_MAX)
 extern rule_number_t nrules;
 # define int_of_rule_number(RNum) ((int) (RNum))
 # define RULE_NUMBER_MAX ((rule_number_t) SHRT_MAX)
 extern rule_number_t nrules;
 # define int_of_rule_number(RNum) ((int) (RNum))

-# define item_number_of_rule_number(RNum) ((item_number_t) (- RNum))
-# define rule_number_of_item_number(INum) ((rule_number_t) (- INum))
+# define rule_number_as_item_number(RNum) ((item_number_t) (- RNum))
+# define item_number_as_rule_number(INum) ((rule_number_t) (- INum))

 
 
 /*--------.
 
 
 /*--------.

diff --git a/src/nullable.c b/src/nullable.c
index 635ea61921a8b740b30c7a8e1d6a87cc7792a4fc..c8b0b7d6c90d954c1fcf3edaa54d41010e079869 100644 (file)
--- a/src/nullable.c
+++ b/src/nullable.c
@@ -102,7 +102,7 @@ set_nullable (void)
        else
          {
            /* This rule has an empty RHS. */
        else
          {
            /* This rule has an empty RHS. */

-           assert (rule_number_of_item_number (rule->rhs[0]) == ruleno);
+           assert (item_number_as_rule_number (rule->rhs[0]) == ruleno);

            if (rule->useful && !nullable[rule->lhs->number])
              {
                nullable[rule->lhs->number] = 1;
            if (rule->useful && !nullable[rule->lhs->number])
              {
                nullable[rule->lhs->number] = 1;

diff --git a/src/output.c b/src/output.c
index dec92b85a34eaec1a00d64c9bf41378c42e8a119..735ef33ae22f3189629d26fc8f7fa55310b47513 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -76,7 +76,7 @@
    in a roundabout way, the bounds of the portion you are trying to
    examine.
 
    in a roundabout way, the bounds of the portion you are trying to
    examine.
 

-   Suppose that the portion of yytable starts at index P and the index
+   Suppose that the portion of YYTABLE starts at index P and the index

    to be examined within the portion is I.  Then if YYCHECK[P+I] != I,
    I is outside the bounds of what is actually allocated, and the
    default (from YYDEFACT or YYDEFGOTO) should be used.  Otherwise,
    to be examined within the portion is I.  Then if YYCHECK[P+I] != I,
    I is outside the bounds of what is actually allocated, and the
    default (from YYDEFACT or YYDEFGOTO) should be used.  Otherwise,


@@ -104,20 +104,80 @@
 /* From src/scan-skel.l. */
 void m4_invoke PARAMS ((const char *definitions));
 
 /* From src/scan-skel.l. */
 void m4_invoke PARAMS ((const char *definitions));
 

+
+/* Several tables will be indexed both by state and nonterminal
+   numbers.  We call `vector' such a thing (= either a state or a
+   symbol number.
+
+   Of course vector_number_t ought to be wide enough to contain
+   state_number_t and symbol_number_t.  */
+typedef short vector_number_t;
+#define VECTOR_NUMBER_MAX ((vector_number_t) SHRT_MAX)
+#define VECTOR_NUMBER_MIN ((vector_number_t) SHRT_MIN)
+#define state_number_to_vector_number(State) \
+   ((vector_number_t) State)
+#define symbol_number_to_vector_number(Symbol) \
+   ((vector_number_t) (state_number_as_int (nstates) + Symbol - ntokens))
+

 static int nvectors;
 static int nvectors;

-static int nentries;
-static state_number_t **froms = NULL;
-static state_number_t **tos = NULL;
+
+
+/* FROMS and TOS are indexed by vector_number_t.
+
+   If VECTOR is a nonterminal, (FROMS[VECTOR], TOS[VECTOR]) form an
+   array of state numbers of the non defaulted GOTO on VECTOR.
+
+   If VECTOR is a state, TOS[VECTOR] is the array of actions to do on
+   the (array of) symbols FROMS[VECTOR].
+
+   In both cases, TALLY[VECTOR] is the size of the arrays
+   FROMS[VECTOR], TOS[VECTOR]; and WIDTH[VECTOR] =
+   (FROMS[VECTOR][SIZE] - FROMS[VECTOR][0] + 1) where SIZE =
+   TALLY[VECTOR].
+
+   FROMS therefore contains symbol_number_t and action_number_t,
+   TOS state_number_t and action_number_t,
+   TALLY sizes,
+   WIDTH differences of FROMS.
+
+   Let base_t be the type of FROMS, TOS, and WIDTH.  */
+typedef int base_t;
+#define BASE_MAX ((base_t) INT_MAX)
+#define BASE_MIN ((base_t) INT_MIN)
+
+static base_t **froms = NULL;
+static base_t **tos = NULL;

 static unsigned int **conflict_tos = NULL;
 static short *tally = NULL;
 static unsigned int **conflict_tos = NULL;
 static short *tally = NULL;

-static short *width = NULL;
-static short *actrow = NULL;
-static short *conflrow = NULL;
-static short *state_count = NULL;
-static short *order = NULL;
-static short *base = NULL;
-static short *pos = NULL;
+static base_t *width = NULL;
+

 
 

+/* For a given state, N = ACTROW[SYMBOL]:
+
+   If N = 0, stands for `run the default action'.
+   If N = MIN, stands for `raise a parse error'.
+   If N > 0, stands for `shift SYMBOL and go to n'.
+   If N < 0, stands for `reduce -N'.  */
+typedef short action_t;
+#define ACTION_MAX ((action_t) SHRT_MAX)
+#define ACTION_MIN ((action_t) SHRT_MIN)
+
+static action_t *actrow = NULL;
+
+/* FROMS and TOS are reordered to be compressed.  ORDER[VECTOR] is the
+   new vector number of VECTOR.  We skip `empty' vectors (i.e.,
+   TALLY[VECTOR] = 0), and call these `entries'.  */
+static vector_number_t *order = NULL;
+static int nentries;
+
+static base_t *base = NULL;
+/* A distinguished value of BASE, negative infinite.  During the
+   computation equals to BASE_MIN, later mapped to BASE_NINF to
+   keep parser tables small.  */
+base_t base_ninf = 0;
+static base_t *pos = NULL;
+
+static unsigned int *conflrow = NULL;

 static unsigned int *conflict_table = NULL;
 static unsigned int *conflict_list = NULL;
 static int conflict_list_cnt;
 static unsigned int *conflict_table = NULL;
 static unsigned int *conflict_list = NULL;
 static int conflict_list_cnt;


@@ -127,8 +187,13 @@ static int conflict_list_free;
    We start with the original hard-coded value: SHRT_MAX
    (yes, not USHRT_MAX). */
 static size_t table_size = SHRT_MAX;
    We start with the original hard-coded value: SHRT_MAX
    (yes, not USHRT_MAX). */
 static size_t table_size = SHRT_MAX;

-static short *table = NULL;
-static short *check = NULL;
+static base_t *table = NULL;
+static base_t *check = NULL;
+/* The value used in TABLE to denote explicit parse errors
+   (%nonassoc), a negative infinite.  First defaults to ACTION_MIN,
+   but in order to keep small tables, renumbered as TABLE_ERROR, which
+   is the smallest (non error) value minus 1.  */
+base_t table_ninf = 0;

 static int lowzero;
 static int high;
 
 static int lowzero;
 static int high;
 


@@ -155,8 +220,8 @@ table_grow (size_t desired)
     fprintf (stderr, "growing table and check from: %d to %d\n",
             old_size, table_size);
 
     fprintf (stderr, "growing table and check from: %d to %d\n",
             old_size, table_size);
 

-  table = XREALLOC (table, short, table_size);
-  check = XREALLOC (check, short, table_size);
+  table = XREALLOC (table, base_t, table_size);
+  check = XREALLOC (check, base_t, table_size);

   if (glr_parser)
     conflict_table = XREALLOC (conflict_table, unsigned int, table_size);
 
   if (glr_parser)
     conflict_table = XREALLOC (conflict_table, unsigned int, table_size);
 


@@ -185,6 +250,7 @@ Name (const char *name,                                                     \
       int begin,                                                       \
       int end)                                                         \
 {                                                                      \
       int begin,                                                       \
       int end)                                                         \
 {                                                                      \

+  Type min = first;                                                    \

   Type max = first;                                                    \
   int i;                                                               \
   int j = 1;                                                           \
   Type max = first;                                                    \
   int i;                                                               \
   int j = 1;                                                           \


@@ -201,13 +267,19 @@ Name (const char *name,                                                   \
       else                                                             \
        ++j;                                                            \
       obstack_fgrow1 (&format_obstack, "%6d", table_data[i]);          \
       else                                                             \
        ++j;                                                            \
       obstack_fgrow1 (&format_obstack, "%6d", table_data[i]);          \

-      if (table_data[i] > max)                                         \
+      if (table_data[i] < min)                                         \
+       min = table_data[i];                                            \
+      if (max < table_data[i])                                         \

        max = table_data[i];                                            \
     }                                                                  \
   obstack_1grow (&format_obstack, 0);                                  \
   muscle_insert (name, obstack_finish (&format_obstack));              \
                                                                        \
        max = table_data[i];                                            \
     }                                                                  \
   obstack_1grow (&format_obstack, 0);                                  \
   muscle_insert (name, obstack_finish (&format_obstack));              \
                                                                        \

-  /* Build `NAME_max' in the obstack. */                               \
+  /* Build `NAME_min' and `NAME_max' in the obstack. */                        \
+  obstack_fgrow1 (&format_obstack, "%s_min", name);                    \
+  obstack_1grow (&format_obstack, 0);                                  \
+  MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack),            \
+                         (long int) min);                              \

   obstack_fgrow1 (&format_obstack, "%s_max", name);                    \
   obstack_1grow (&format_obstack, 0);                                  \
   MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack),            \
   obstack_fgrow1 (&format_obstack, "%s_max", name);                    \
   obstack_1grow (&format_obstack, 0);                                  \
   MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack),            \


@@ -215,7 +287,10 @@ Name (const char *name,                                                    \
 }
 
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_unsigned_int_table, unsigned int)
 }
 
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_unsigned_int_table, unsigned int)

+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_int_table, int)

 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_short_table, short)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_short_table, short)

+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_base_table, base_t)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_rule_number_table, rule_number_t)

 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number_t)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_item_number_table, item_number_t)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_state_number_table, state_number_t)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number_t)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_item_number_table, item_number_t)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_state_number_table, state_number_t)


@@ -266,14 +341,14 @@ prepare_tokens (void)
     muscle_insert ("tname", obstack_finish (&format_obstack));
   }
 
     muscle_insert ("tname", obstack_finish (&format_obstack));
   }
 

-    /* Output YYTOKNUM. */
+  /* Output YYTOKNUM. */

   {
     int i;
   {
     int i;

-    short *values = XCALLOC (short, ntokens + 1);
+    int *values = XCALLOC (int, ntokens + 1);

     for (i = 0; i < ntokens + 1; ++i)
       values[i] = symbols[i]->user_token_number;
     for (i = 0; i < ntokens + 1; ++i)
       values[i] = symbols[i]->user_token_number;

-    muscle_insert_short_table ("toknum", values,
-                              0, 1, ntokens + 1);
+    muscle_insert_int_table ("toknum", values,
+                            0, 1, ntokens + 1);

     free (values);
   }
 }
     free (values);
   }
 }


@@ -356,12 +431,12 @@ prepare_states (void)
 
 /*-------------------------------------------------------------------.
 | For GLR parsers, for each conflicted token in STATE, as indicated  |
 
 /*-------------------------------------------------------------------.
 | For GLR parsers, for each conflicted token in STATE, as indicated  |

-| by non-zero entries in conflrow, create a list of possible        |
+| by non-zero entries in CONFLROW, create a list of possible        |

 | reductions that are alternatives to the shift or reduction        |
 | currently recorded for that token in STATE.  Store the alternative |
 | reductions followed by a 0 in conflict_list, updating                     |
 | conflict_list_cnt, and storing an index to the start of the list   |
 | reductions that are alternatives to the shift or reduction        |
 | currently recorded for that token in STATE.  Store the alternative |
 | reductions followed by a 0 in conflict_list, updating                     |
 | conflict_list_cnt, and storing an index to the start of the list   |

-| back into conflrow.                                               |
+| back into CONFLROW.                                               |

 `-------------------------------------------------------------------*/
 
 static void
 `-------------------------------------------------------------------*/
 
 static void


@@ -377,11 +452,12 @@ conflict_row (state_t *state)
       {
        conflrow[j] = conflict_list_cnt;
 
       {
        conflrow[j] = conflict_list_cnt;
 

-       /* find all reductions for token j, and record all that do
-        * not match actrow[j] */
+       /* Find all reductions for token J, and record all that do not
+          match ACTROW[J].  */

        for (i = 0; i < state->nlookaheads; i += 1)
          if (bitset_test (state->lookaheads[i], j)
        for (i = 0; i < state->nlookaheads; i += 1)
          if (bitset_test (state->lookaheads[i], j)

-             && actrow[j] != -state->lookaheads_rule[i]->number)
+             && (actrow[j]
+                 != rule_number_as_item_number (state->lookaheads_rule[i]->number)))

            {
              assert (conflict_list_free > 0);
              conflict_list[conflict_list_cnt]
            {
              assert (conflict_list_free > 0);
              conflict_list[conflict_list_cnt]


@@ -390,7 +466,7 @@ conflict_row (state_t *state)
              conflict_list_free -= 1;
            }
 
              conflict_list_free -= 1;
            }
 

-       /* Leave a 0 at the end */
+       /* Leave a 0 at the end.  */

        assert (conflict_list_free > 0);
        conflict_list_cnt += 1;
        conflict_list_free -= 1;
        assert (conflict_list_free > 0);
        conflict_list_cnt += 1;
        conflict_list_free -= 1;


@@ -401,23 +477,23 @@ conflict_row (state_t *state)
 /*------------------------------------------------------------------.
 | Decide what to do for each type of token if seen as the lookahead |
 | token in specified state.  The value returned is used as the      |
 /*------------------------------------------------------------------.
 | Decide what to do for each type of token if seen as the lookahead |
 | token in specified state.  The value returned is used as the      |

-| default action (yydefact) for the state.  In addition, actrow is  |
+| default action (yydefact) for the state.  In addition, ACTROW is  |

 | filled with what to do for each kind of token, index by symbol    |
 | number, with zero meaning do the default action.  The value       |
 | filled with what to do for each kind of token, index by symbol    |
 | number, with zero meaning do the default action.  The value       |

-| SHRT_MIN, a very negative number, means this situation is an      |
+| ACTION_MIN, a very negative number, means this situation is an    |

 | error.  The parser recognizes this value specially.               |
 |                                                                   |
 | This is where conflicts are resolved.  The loop over lookahead    |
 | rules considered lower-numbered rules last, and the last rule     |
 | considered that likes a token gets to handle it.                  |
 | error.  The parser recognizes this value specially.               |
 |                                                                   |
 | This is where conflicts are resolved.  The loop over lookahead    |
 | rules considered lower-numbered rules last, and the last rule     |
 | considered that likes a token gets to handle it.                  |

-|                                                                  |
-| For GLR parsers, also sets conflrow[SYM] to an index into         |
+|                                                                   |
+| For GLR parsers, also sets CONFLROW[SYM] to an index into         |

 | conflict_list iff there is an unresolved conflict (s/r or r/r)    |
 | with symbol SYM. The default reduction is not used for a symbol   |
 | conflict_list iff there is an unresolved conflict (s/r or r/r)    |
 | with symbol SYM. The default reduction is not used for a symbol   |

-| that has any such conflicts.                                     |
+| that has any such conflicts.                                      |

 `------------------------------------------------------------------*/
 
 `------------------------------------------------------------------*/
 

-static int
+static rule_number_t

 action_row (state_t *state)
 {
   int i;
 action_row (state_t *state)
 {
   int i;


@@ -447,7 +523,7 @@ action_row (state_t *state)
             token follows.  */
          if (actrow[j] != 0)
            conflicted = conflrow[j] = 1;
             token follows.  */
          if (actrow[j] != 0)
            conflicted = conflrow[j] = 1;

-         actrow[j] = -state->lookaheads_rule[i]->number;
+         actrow[j] = rule_number_as_item_number (state->lookaheads_rule[i]->number);

        }
     }
 
        }
     }
 


@@ -471,11 +547,11 @@ action_row (state_t *state)
       }
 
   /* See which tokens are an explicit error in this state (due to
       }
 
   /* See which tokens are an explicit error in this state (due to

-     %nonassoc).  For them, record SHRT_MIN as the action.  */
+     %nonassoc).  For them, record ACTION_MIN as the action.  */

   for (i = 0; i < errp->num; i++)
     {
       symbol_number_t symbol = errp->symbols[i];
   for (i = 0; i < errp->num; i++)
     {
       symbol_number_t symbol = errp->symbols[i];

-      actrow[symbol] = SHRT_MIN;
+      actrow[symbol] = ACTION_MIN;

     }
 
   /* Now find the most common reduction and make it the default action
     }
 
   /* Now find the most common reduction and make it the default action


@@ -495,7 +571,7 @@ action_row (state_t *state)
              symbol_number_t j;
 
              for (j = 0; j < ntokens; j++)
              symbol_number_t j;
 
              for (j = 0; j < ntokens; j++)

-               if (actrow[j] == -rule)
+               if (actrow[j] == rule_number_as_item_number (rule))

                  count++;
 
              if (count > max)
                  count++;
 
              if (count > max)


@@ -515,7 +591,7 @@ action_row (state_t *state)
            {
              int j;
              for (j = 0; j < ntokens; j++)
            {
              int j;
              for (j = 0; j < ntokens; j++)

-               if (actrow[j] == -default_rule
+               if (actrow[j] == rule_number_as_item_number (default_rule)

                    && ! (glr_parser && conflrow[j]))
                  actrow[j] = 0;
            }
                    && ! (glr_parser && conflrow[j]))
                  actrow[j] = 0;
            }


@@ -527,7 +603,7 @@ action_row (state_t *state)
 
   if (default_rule == 0)
     for (i = 0; i < ntokens; i++)
 
   if (default_rule == 0)
     for (i = 0; i < ntokens; i++)

-      if (actrow[i] == SHRT_MIN)
+      if (actrow[i] == ACTION_MIN)

        actrow[i] = 0;
 
   if (conflicted)
        actrow[i] = 0;
 
   if (conflicted)


@@ -537,16 +613,21 @@ action_row (state_t *state)
 }
 
 
 }
 
 

+/*--------------------------------------------.
+| Set FROMS, TOS, TALLY and WIDTH for STATE.  |
+`--------------------------------------------*/
+

 static void
 save_row (state_number_t state)
 {
   symbol_number_t i;
   int count;
 static void
 save_row (state_number_t state)
 {
   symbol_number_t i;
   int count;

-  short *sp = NULL;
-  short *sp1 = NULL;
-  short *sp2 = NULL;
+  base_t *sp = NULL;
+  base_t *sp1 = NULL;
+  base_t *sp2 = NULL;

   unsigned int *sp3 = NULL;
 
   unsigned int *sp3 = NULL;
 

+  /* Number of non default actions in STATE.  */

   count = 0;
   for (i = 0; i < ntokens; i++)
     if (actrow[i] != 0)
   count = 0;
   for (i = 0; i < ntokens; i++)
     if (actrow[i] != 0)


@@ -555,13 +636,15 @@ save_row (state_number_t state)
   if (count == 0)
     return;
 
   if (count == 0)
     return;
 

-  froms[state] = sp1 = sp = XCALLOC (short, count);
-  tos[state] = sp2 = XCALLOC (short, count);
+  /* Allocate non defaulted actions.  */
+  froms[state] = sp1 = sp = XCALLOC (base_t, count);
+  tos[state] = sp2 = XCALLOC (base_t, count);

   if (glr_parser)
     conflict_tos[state] = sp3 = XCALLOC (unsigned int, count);
   else
     conflict_tos[state] = NULL;
 
   if (glr_parser)
     conflict_tos[state] = sp3 = XCALLOC (unsigned int, count);
   else
     conflict_tos[state] = NULL;
 

+  /* Store non defaulted actions.  */

   for (i = 0; i < ntokens; i++)
     if (actrow[i] != 0)
       {
   for (i = 0; i < ntokens; i++)
     if (actrow[i] != 0)
       {


@@ -590,11 +673,11 @@ token_actions (void)
   state_number_t i;
   int nconflict = conflicts_total_count ();
 
   state_number_t i;
   int nconflict = conflicts_total_count ();
 

-  short *yydefact = XCALLOC (short, nstates);
+  rule_number_t *yydefact = XCALLOC (rule_number_t, nstates);

 
 

-  actrow = XCALLOC (short, ntokens);
+  actrow = XCALLOC (action_t, ntokens);
+  conflrow = XCALLOC (unsigned int, ntokens);

 
 

-  conflrow = XCALLOC (short, ntokens);

   if (glr_parser)
     {
       conflict_list = XCALLOC (unsigned int, 1 + 2 * nconflict);
   if (glr_parser)
     {
       conflict_list = XCALLOC (unsigned int, 1 + 2 * nconflict);


@@ -610,8 +693,8 @@ token_actions (void)
       save_row (i);
     }
 
       save_row (i);
     }
 

-  muscle_insert_short_table ("defact", yydefact,
-                            yydefact[0], 1, nstates);
+  muscle_insert_rule_number_table ("defact", yydefact,
+                                  yydefact[0], 1, nstates);

   XFREE (actrow);
   XFREE (conflrow);
   XFREE (yydefact);
   XFREE (actrow);
   XFREE (conflrow);
   XFREE (yydefact);


@@ -783,19 +866,29 @@ symbol_printers_output (FILE *out)
 }
 
 
 }
 
 

+/*------------------------------------------------------------------.
+| Compute FROMS[VECTOR], TOS[VECTOR], TALLY[VECTOR], WIDTH[VECTOR], |
+| i.e., the information related to non defaulted GOTO on the nterm  |
+| SYMBOL.                                                           |
+|                                                                   |
+| DEFAULT_STATE is the principal destination on SYMBOL, i.e., the   |
+| default GOTO destination on SYMBOL.                               |
+`------------------------------------------------------------------*/
+

 static void
 save_column (symbol_number_t symbol, state_number_t default_state)
 {
   int i;
 static void
 save_column (symbol_number_t symbol, state_number_t default_state)
 {
   int i;

-  state_number_t *sp;
-  state_number_t *sp1;
-  state_number_t *sp2;
+  base_t *sp;
+  base_t *sp1;
+  base_t *sp2;

   int count;
   int count;

-  int symno = symbol - ntokens + state_number_as_int (nstates);
+  vector_number_t symno = symbol_number_to_vector_number (symbol);

 
   goto_number_t begin = goto_map[symbol];
   goto_number_t end = goto_map[symbol + 1];
 
 
   goto_number_t begin = goto_map[symbol];
   goto_number_t end = goto_map[symbol + 1];
 

+  /* Number of non default GOTO.  */

   count = 0;
   for (i = begin; i < end; i++)
     if (to_state[i] != default_state)
   count = 0;
   for (i = begin; i < end; i++)
     if (to_state[i] != default_state)


@@ -804,9 +897,11 @@ save_column (symbol_number_t symbol, state_number_t default_state)
   if (count == 0)
     return;
 
   if (count == 0)
     return;
 

-  froms[symno] = sp1 = sp = XCALLOC (short, count);
-  tos[symno] = sp2 = XCALLOC (short, count);
+  /* Allocate room for non defaulted gotos.  */
+  froms[symno] = sp1 = sp = XCALLOC (base_t, count);
+  tos[symno] = sp2 = XCALLOC (base_t, count);

 
 

+  /* Store the state numbers of the non defaulted gotos.  */

   for (i = begin; i < end; i++)
     if (to_state[i] != default_state)
       {
   for (i = begin; i < end; i++)
     if (to_state[i] != default_state)
       {


@@ -819,8 +914,12 @@ save_column (symbol_number_t symbol, state_number_t default_state)
 }
 
 
 }
 
 

+/*----------------------------------------------------------------.
+| Return `the' most common destination GOTO on SYMBOL (a nterm).  |
+`----------------------------------------------------------------*/
+

 static state_number_t
 static state_number_t

-default_goto (symbol_number_t symbol)
+default_goto (symbol_number_t symbol, short state_count[])

 {
   state_number_t s;
   int i;
 {
   state_number_t s;
   int i;


@@ -862,12 +961,14 @@ static void
 goto_actions (void)
 {
   symbol_number_t i;
 goto_actions (void)
 {
   symbol_number_t i;

-  state_number_t *yydefgoto = XMALLOC (state_number_t, nsyms - ntokens);
+  state_number_t *yydefgoto = XMALLOC (state_number_t, nvars);

 
 

-  state_count = XCALLOC (short, nstates);
+  /* For a given nterm I, STATE_COUNT[S] is the number of times there
+     is a GOTO to S on I.  */
+  short *state_count = XCALLOC (short, nstates);

   for (i = ntokens; i < nsyms; ++i)
     {
   for (i = ntokens; i < nsyms; ++i)
     {

-      state_number_t default_state = default_goto (i);
+      state_number_t default_state = default_goto (i, state_count);

       save_column (i, default_state);
       yydefgoto[i - ntokens] = default_state;
     }
       save_column (i, default_state);
       yydefgoto[i - ntokens] = default_state;
     }


@@ -879,8 +980,10 @@ goto_actions (void)
 }
 
 
 }
 
 

-/* The next few functions decide how to pack the actions and gotos
-   information into yytable. */
+/*------------------------------------------------------------------.
+| Compute ORDER, a reordering of vectors, in order to decide how to |
+| pack the actions and gotos information into yytable.              |
+`------------------------------------------------------------------*/

 
 static void
 sort_actions (void)
 
 static void
 sort_actions (void)


@@ -912,14 +1015,21 @@ sort_actions (void)
 }
 
 
 }
 
 

-static int
-matching_state (int vector)
+/* If VECTOR is a state which actions (reflected by FROMS, TOS, TALLY
+   and WIDTH of VECTOR) are common to a previous state, return this
+   state number.
+
+   In any other case, return -1.  */
+
+static state_number_t
+matching_state (vector_number_t vector)

 {
 {

-  int i = order[vector];
+  vector_number_t i = order[vector];

   int t;
   int w;
   int prev;
 
   int t;
   int w;
   int prev;
 

+  /* If VECTOR is a nterm, return -1.  */

   if (i >= (int) nstates)
     return -1;
 
   if (i >= (int) nstates)
     return -1;
 


@@ -928,10 +1038,12 @@ matching_state (int vector)
 
   for (prev = vector - 1; prev >= 0; prev--)
     {
 
   for (prev = vector - 1; prev >= 0; prev--)
     {

-      int j = order[prev];
+      vector_number_t j = order[prev];

       int k;
       int match = 1;
 
       int k;
       int match = 1;
 

+      /* Given how ORDER was computed, if the WIDTH or TALLY is
+        different, there cannot be a matching state.  */

       if (width[j] != w || tally[j] != t)
        return -1;
 
       if (width[j] != w || tally[j] != t)
        return -1;
 


@@ -947,15 +1059,15 @@ matching_state (int vector)
 }
 
 
 }
 
 

-static int
-pack_vector (int vector)
+static base_t
+pack_vector (vector_number_t vector)

 {
 {

-  int i = order[vector];
+  vector_number_t i = order[vector];

   int j;
   int t = tally[i];
   int loc = 0;
   int j;
   int t = tally[i];
   int loc = 0;

-  short *from = froms[i];
-  short *to = tos[i];
+  base_t *from = froms[i];
+  base_t *to = tos[i];

   unsigned int *conflict_to = conflict_tos[i];
 
   assert (t);
   unsigned int *conflict_to = conflict_tos[i];
 
   assert (t);


@@ -983,11 +1095,11 @@ pack_vector (int vector)
        {
          for (k = 0; k < t; k++)
            {
        {
          for (k = 0; k < t; k++)
            {

-             loc = j + state_number_as_int (from[k]);
-             table[loc] = state_number_as_int (to[k]);
+             loc = j + from[k];
+             table[loc] = to[k];

              if (glr_parser && conflict_to != NULL)
                conflict_table[loc] = conflict_to[k];
              if (glr_parser && conflict_to != NULL)
                conflict_table[loc] = conflict_to[k];

-             check[loc] = state_number_as_int (from[k]);
+             check[loc] = from[k];

            }
 
          while (table[lowzero] != 0)
            }
 
          while (table[lowzero] != 0)


@@ -996,6 +1108,8 @@ pack_vector (int vector)
          if (loc > high)
            high = loc;
 
          if (loc > high)
            high = loc;
 

+         if (j < BASE_MIN || BASE_MAX < j)
+           fatal ("base_t too small to hold %d\n", j);

          return j;
        }
     }
          return j;
        }
     }


@@ -1005,42 +1119,74 @@ pack_vector (int vector)
 }
 
 
 }
 
 

+/*-------------------------------------------------------------.
+| Remap the negative infinite in TAB from NINF to the greatest |
+| possible smallest value.  Return it.                         |
+|                                                              |
+| In most case this allows us to use shorts instead of ints in |
+| parsers.                                                     |
+`-------------------------------------------------------------*/
+
+static base_t
+table_ninf_remap (base_t tab[], size_t size, base_t ninf)
+{
+  base_t res = 0;
+  size_t i;
+
+  for (i = 0; i < size; i++)
+    if (tab[i] < res && tab[i] != ninf)
+      res = base[i];
+
+  --res;
+
+  for (i = 0; i < size; i++)
+    if (tab[i] == ninf)
+      tab[i] = res;
+
+  return res;
+}
+

 static void
 pack_table (void)
 {
   int i;
 static void
 pack_table (void)
 {
   int i;

-  int place;
-  int state;

 
 

-  base = XCALLOC (short, nvectors);
-  pos = XCALLOC (short, nentries);
-  table = XCALLOC (short, table_size);
+  base = XCALLOC (base_t, nvectors);
+  pos = XCALLOC (base_t, nentries);
+  table = XCALLOC (base_t, table_size);

   if (glr_parser)
     conflict_table = XCALLOC (unsigned int, table_size);
   if (glr_parser)
     conflict_table = XCALLOC (unsigned int, table_size);

-  check = XCALLOC (short, table_size);
+  check = XCALLOC (base_t, table_size);

 
   lowzero = 0;
   high = 0;
 
   for (i = 0; i < nvectors; i++)
 
   lowzero = 0;
   high = 0;
 
   for (i = 0; i < nvectors; i++)

-    base[i] = SHRT_MIN;
+    base[i] = BASE_MIN;

 
   for (i = 0; i < (int) table_size; i++)
     check[i] = -1;
 
   for (i = 0; i < nentries; i++)
     {
 
   for (i = 0; i < (int) table_size; i++)
     check[i] = -1;
 
   for (i = 0; i < nentries; i++)
     {

-      state = matching_state (i);
+      state_number_t state = matching_state (i);
+      base_t place;

 
       if (state < 0)
 
       if (state < 0)

+       /* A new set of state actions, or a nonterminal.  */

        place = pack_vector (i);
       else
        place = pack_vector (i);
       else

+       /* Action of I were already coded for STATE.  */

        place = base[state];
 
       pos[i] = place;
       base[order[i]] = place;
     }
 
        place = base[state];
 
       pos[i] = place;
       base[order[i]] = place;
     }
 

+  /* Use the greatest possible negative infinites.  */
+  base_ninf = table_ninf_remap (base, nvectors, BASE_MIN);
+  table_ninf = table_ninf_remap (table, high + 1, ACTION_MIN);
+

   for (i = 0; i < nvectors; i++)
     {
       XFREE (froms[i]);
   for (i = 0; i < nvectors; i++)
     {
       XFREE (froms[i]);


@@ -1054,18 +1200,20 @@ pack_table (void)
   free (pos);
 }
 
   free (pos);
 }
 

+

 /* the following functions output yytable, yycheck, yyconflp, yyconfl,
 /* the following functions output yytable, yycheck, yyconflp, yyconfl,

-   and the vectors whose elements index the portion starts */
+   and the vectors whose elements index the portion starts.  */

 
 static void
 output_base (void)
 {
 
 static void
 output_base (void)
 {

-  /* Output pact. */
-  muscle_insert_short_table ("pact", base,
+  /* Output PACT. */
+  muscle_insert_base_table ("pact", base,

                             base[0], 1, nstates);
                             base[0], 1, nstates);

+  MUSCLE_INSERT_INT ("pact_ninf", base_ninf);

 
 

-  /* Output pgoto. */
-  muscle_insert_short_table ("pgoto", base,
+  /* Output PGOTO. */
+  muscle_insert_base_table ("pgoto", base,

                             base[nstates], nstates + 1, nvectors);
   XFREE (base);
 }
                             base[nstates], nstates + 1, nvectors);
   XFREE (base);
 }


@@ -1074,8 +1222,9 @@ output_base (void)
 static void
 output_table (void)
 {
 static void
 output_table (void)
 {

-  muscle_insert_short_table ("table", table,
-                            table[0], 1, high + 1);
+  muscle_insert_base_table ("table", table,
+                           table[0], 1, high + 1);
+  MUSCLE_INSERT_INT ("table_ninf", table_ninf);

   XFREE (table);
 }
 
   XFREE (table);
 }
 


@@ -1105,8 +1254,8 @@ output_conflicts (void)
 static void
 output_check (void)
 {
 static void
 output_check (void)
 {

-  muscle_insert_short_table ("check", check,
-                            check[0], 1, high + 1);
+  muscle_insert_base_table ("check", check,
+                           check[0], 1, high + 1);

   XFREE (check);
 }
 
   XFREE (check);
 }
 


@@ -1126,11 +1275,11 @@ prepare_actions (void)
 
   nvectors = state_number_as_int (nstates) + nvars;
 
 
   nvectors = state_number_as_int (nstates) + nvars;
 

-  froms = XCALLOC (short *, nvectors);
-  tos = XCALLOC (short *, nvectors);
+  froms = XCALLOC (base_t *, nvectors);
+  tos = XCALLOC (base_t *, nvectors);

   conflict_tos = XCALLOC (unsigned int *, nvectors);
   tally = XCALLOC (short, nvectors);
   conflict_tos = XCALLOC (unsigned int *, nvectors);
   tally = XCALLOC (short, nvectors);

-  width = XCALLOC (short, nvectors);
+  width = XCALLOC (base_t, nvectors);

 
   token_actions ();
   bitsetv_free (LA);
 
   token_actions ();
   bitsetv_free (LA);


@@ -1141,7 +1290,7 @@ prepare_actions (void)
   XFREE (from_state);
   XFREE (to_state);
 
   XFREE (from_state);
   XFREE (to_state);
 

-  order = XCALLOC (short, nvectors);
+  order = XCALLOC (vector_number_t, nvectors);

   sort_actions ();
   pack_table ();
   free (order);
   sort_actions ();
   pack_table ();
   free (order);


@@ -1237,7 +1386,6 @@ prepare (void)
 
   /* States. */
   MUSCLE_INSERT_INT ("last", high);
 
   /* States. */
   MUSCLE_INSERT_INT ("last", high);

-  MUSCLE_INSERT_INT ("flag", SHRT_MIN);

   MUSCLE_INSERT_INT ("final_state_number", final_state->number);
   MUSCLE_INSERT_INT ("states_number", nstates);
 
   MUSCLE_INSERT_INT ("final_state_number", final_state->number);
   MUSCLE_INSERT_INT ("states_number", nstates);
 

diff --git a/src/print_graph.c b/src/print_graph.c
index 8f0144dae6e5e852ec619f31651b4c4f14b191cf..be7e196ee467fb1c6f60f812ad85d5877fc57512 100644 (file)
--- a/src/print_graph.c
+++ b/src/print_graph.c
@@ -70,7 +70,7 @@ print_core (struct obstack *oout, state_t *state)
       while (*sp >= 0)
        sp++;
 
       while (*sp >= 0)
        sp++;
 

-      rule = rule_number_of_item_number (*sp);
+      rule = item_number_as_rule_number (*sp);

 
       if (i)
        obstack_1grow (oout, '\n');
 
       if (i)
        obstack_1grow (oout, '\n');

diff --git a/src/reduce.c b/src/reduce.c
index 2f33e7ef59b08fa74a17a2b8c8c24a375e859642..fb97597216782d34b40842c78da262015560107f 100644 (file)
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -264,7 +264,7 @@ reduce_grammar_tables (void)
        item_number_t *rhsp = rules[r].rhs;
        for (/* Nothing. */; *rhsp >= 0; ++rhsp)
          /* Nothing. */;
        item_number_t *rhsp = rules[r].rhs;
        for (/* Nothing. */; *rhsp >= 0; ++rhsp)
          /* Nothing. */;

-       *rhsp = item_number_of_rule_number (r);
+       *rhsp = rule_number_as_item_number (r);

        rules[r].number = r;
       }
     nrules -= nuseless_productions;
        rules[r].number = r;
       }
     nrules -= nuseless_productions;

diff --git a/tests/regression.at b/tests/regression.at
index 352d7042e5282b84942bf69fdde45abe68bd6b76..489cc29c38fe201793773fbde9644cf81f6c03db 100644 (file)
--- a/tests/regression.at
+++ b/tests/regression.at
@@ -608,16 +608,16 @@ static const short yydefgoto[] =
 {
       -1,     2,     3,     4,     8
 };
 {
       -1,     2,     3,     4,     8
 };

-static const short yypact[] =
+static const signed char yypact[] =

 {
 {

-      -2,    -1,     4,-32768,     0,     2,-32768,    -2,-32768,    -2,
-  -32768,-32768
+      -2,    -1,     4,    -8,     0,     2,    -8,    -2,    -8,    -2,
+      -8,    -8

 };
 static const short yypgoto[] =
 {
 };
 static const short yypgoto[] =
 {

-  -32768,    -7,-32768,-32768,-32768
+      -8,    -7,    -8,    -8,    -8

 };
 };

-static const short yytable[] =
+static const signed char yytable[] =

 {
       10,     1,    11,     5,     6,     0,     7,     9
 };
 {
       10,     1,    11,     5,     6,     0,     7,     9
 };