[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
03-fyi-fix-rr-count.patch
|
From: |
Akim Demaille |
|
Subject: |
03-fyi-fix-rr-count.patch |
|
Date: |
Sun, 06 Jan 2002 21:50:53 +0100 |
Index: ChangeLog
from Akim Demaille <address@hidden>
Bison is dead wrong in its RR conflict reports.
* tests/torture.at (GNU Cim Grammar): New.
* src/conflicts.c (count_rr_conflicts): Fix.
Index: src/conflicts.c
--- src/conflicts.c Fri, 28 Dec 2001 16:47:09 +0100 akim
+++ src/conflicts.c Sun, 06 Jan 2002 20:56:48 +0100 akim
@@ -265,7 +265,7 @@
int count = 0;
int j;
for (j = 0; j < state->nlookaheads; ++j)
- if (BITISSET (LA (state->lookaheadsp), state->lookaheadsp + j))
+ if (BITISSET (LA (state->lookaheadsp + j), i))
count++;
if (count >= 2)
Index: tests/torture.at
--- tests/torture.at Thu, 13 Dec 2001 10:51:57 +0100 akim
+++ tests/torture.at Sun, 06 Jan 2002 21:09:14 +0100 akim
@@ -454,3 +454,855 @@ exp: WAIT_FOR_EOF exp | ;
AT_CHECK([[bison --verbose --defines input.y]])
AT_CLEANUP
+
+
+## ----------------- ##
+## GNU Cim Grammar. ##
+## ----------------- ##
+
+AT_SETUP([GNU Cim Grammar])
+
+# GNU Cim, the GNU Simula 87 Compiler.
+
+# Bison was once wrong, due to an incorrect computation of the RR conflicts.
+# It reported 80 SR && 99 RR conflicts instead of 78/10!!!
+
+AT_DATA([[input.y]],
+[[%union {
+ long token;
+ long ival;
+ long arrdim;
+ double rval;
+ char *ident;
+ char *tval;
+ char stat_decl;
+ }
+
+%token
+ HACTIVATE HAFTER /*HAND*/ HARRAY HAT
+ HBEFORE HBEGIN HBOOLEAN
+ HCHARACTER HCLASS /*HCOMMENT*/ HCONC
+ HDELAY HDO
+ HELSE HEND HEQ /*HEQV*/ HEXTERNAL
+ HFOR
+ HGE HGO HGOTO HGT
+ HHIDDEN
+ HIF /*HIMP*/ HIN HINNER HINSPECT HINTEGER HIS
+ HLABEL HLE HLONG HLT
+ HNAME HNE HNEW HNONE /*HNOT*/ HNOTEXT
+ /*HOR*/ HOTHERWISE
+ HPRIOR HPROCEDURE HPROTECTED
+ HQUA
+ HREACTIVATE HREAL HREF
+ HSHORT HSTEP HSWITCH
+ HTEXT HTHEN HTHIS HTO
+ HUNTIL
+ HVALUE HVAR HVIRTUAL
+ HWHEN HWHILE
+
+ HASSIGNVALUE HASSIGNREF
+ /*HDOT*/ HPAREXPSEPARATOR HLABELSEPARATOR HSTATEMENTSEPARATOR
+ HBEGPAR HENDPAR
+ HEQR HNER
+ HADD HSUB HMUL HDIV HINTDIV HEXP
+ HDOTDOTDOT
+
+%token <ident> HIDENTIFIER
+%token <ival> HBOOLEANKONST HINTEGERKONST HCHARACTERKONST
+%token <rval> HREALKONST
+%token <tval> HTEXTKONST
+
+%type <tval> EXT_IDENT
+%type <stat_decl> DECLSTATEMENT MODULSTATEMENT MBEE_DECLSTMS MBEE_DECLSTMSU
+%type <stat_decl> MODULS
+%type <ident> EXPRESSION_SIMP MBEE_ARG_R_PT
+%type <arrdim> BAUND_PAIR_LIST
+
+%right <token> HASSIGN
+%left HORELSE
+%left HANDTHEN
+%left HEQV
+%left HIMP
+%left HOR
+%left HAND
+
+%left HNOT
+
+%left <token> HVALRELOPERATOR HREFRELOPERATOR HOBJRELOPERATOR
+
+%left HCONC
+
+%left <token> HTERMOPERATOR
+%left <token> UNEAR
+%left <token> HFACTOROPERATOR
+%left HPRIMARYOPERATOR
+
+%left HQUA
+
+%left HDOT
+
+%start MAIN_MODULE
+%%
+/* GRAMATIKK FOR PROGRAM MODULES */
+MAIN_MODULE : { categ=CLOCAL; mout(MBLOCK);
+ beginBlock(KBLOKK);separat_comp=FALSE;}
+ MODULS { endBlock(NULL,CCNO); mout(MENDBLOCK);}
+ | error HSTATEMENTSEPARATOR MBEE_DECLSTMS
+ ;
+EXT_DECLARATION : HEXTERNAL
+ MBEE_TYPE
+ HPROCEDURE
+ { MBEENEWBLOCK();
+ kind=KPROC;}
+ EXT_LIST
+ |
+ HEXTERNAL
+ HIDENTIFIER
+ HPROCEDURE
+ { MBEENEWBLOCK();
+ type=TNOTY;
+ kind=KPROC;
+ if($2==Ckind)categ=CCPROC;else
+ yerror (1);
+ ysensitive=sensitive;
+ sensitive=ON;}
+ HIDENTIFIER { $<ident>$=$5;
+ sensitive=ysensitive;}
+ EXTERNAL_KIND_ITEM
+ { categ=CLOCAL;}
+ | HEXTERNAL
+ HCLASS
+ { MBEENEWBLOCK();
+ kind=KCLASS;}
+ EXT_LIST
+
+ ;
+EXTERNAL_KIND_ITEM: EXT_IDENT
+ HOBJRELOPERATOR
+ { if($2!=HIS)yerror (2);}
+ MBEE_TYPE HPROCEDURE
+ HIDENTIFIER
+ { regDecl($6, type, KPROC, CCPROC);
+ beginBlock(kind);}
+ HEADING EMPTY_BLOCK
+ { categ=CLOCAL;
+ endBlock($1==NULL?$<ident>0:tag($1),CCCPROC);}
+/* |
+ EXT_IDENT
+ { if($1!=NULL)yerror (3);
+ regDecl($0, type, kind, categ);}
+ MBEE_REST_EXT_LIST
+ { endBlock(NULL,CCNO);}
+ ;
+MBEE_REST_EXT_LIST: /* EMPTY
+ | HPAREXPSEPARATOR EXT_KIND_LIST
+ ;
+EXT_KIND_LIST : EXT_KIND_ITEM
+ | EXT_KIND_LIST HPAREXPSEPARATOR EXT_KIND_ITEM
+ ;
+EXT_KIND_ITEM : HIDENTIFIER
+ EXT_IDENT
+ { if($2!=NULL)yerror (3);
+ regDecl($1, type, kind, categ);}*/
+ ;
+EMPTY_BLOCK : /*EMPT*/
+ | HBEGIN HEND
+ ;
+EXT_LIST : EXT_ITEM
+ | EXT_LIST HPAREXPSEPARATOR EXT_ITEM
+ ;
+EXT_ITEM : HIDENTIFIER
+ EXT_IDENT
+ { lesinn_external_spec($1,$2, kind);}
+ ;
+EXT_IDENT : /* EMPTY */ { $$=NULL;}
+ | HVALRELOPERATOR { if($1!=HEQ)yerror (9);
+ external=TRUE;}
+ HTEXTKONST { $$=$3;external=FALSE;}
+ ;
+/* GRAMATIKK FOR TYPER */
+NO_TYPE : /*EMPT*/ { type=TNOTY;}
+ ;
+MBEE_TYPE : NO_TYPE
+ | TYPE
+ ;
+TYPE : HREF HBEGPAR
+ HIDENTIFIER
+ { prefquantident=$3;
+ type=TREF;}
+ HENDPAR
+ | HTEXT { type=TTEXT;}
+ | HBOOLEAN { type=TBOOL;}
+ | HCHARACTER { type=TCHAR;}
+ | HSHORT HINTEGER { type=TSHORT;}
+ | HINTEGER { type=TINTG;}
+ | HREAL { type=TREAL;}
+ | HLONG HREAL { type=TLONG;}
+ ;
+
+/* GRAMATIKK FOR DEL AV SETNINGER */
+MBEE_ELSE_PART : /*EMPT*/
+/* | HELSE
+ HIF
+ EXPRESSION
+ HTHEN { mout(MELSE);
+ mout(MIF);
+ OBSBLOCK();}
+ BLOCK { MBEEENDBLOCK();}
+ MBEE_ELSE_PART { mout(MENDIF);}*/
+ | HELSE { OBSBLOCK(); mout(MELSE);}
+ BLOCK { MBEEENDBLOCK();}
+ ;
+FOR_LIST : FOR_LIST_ELEMENT { mout(MENDSEP);
+ mout(MLISTSEP);}
+ | FOR_LIST_ELEMENT
+ HPAREXPSEPARATOR
+ FOR_LIST { mout(MLISTSEP);}
+ ;
+FOR_LIST_ELEMENT: EXPRESSION
+ MBEE_F_L_EL_R_PT
+ ;
+MBEE_F_L_EL_R_PT: /*EMPT*/
+ | HWHILE
+ EXPRESSION { mout(MFORWHILE);}
+ | HSTEP
+ EXPRESSION
+ HUNTIL
+ EXPRESSION { mout(MUNTIL);
+ mout(MSTEP);}
+ ;
+GOTO : HGO
+ HTO
+ | HGOTO
+ ;
+CONN_STATE_R_PT : WHEN_CLAUSE_LIST
+ | HDO { beginBlock(KCON); mout(MDO);
+ OBSBLOCK(); }
+ BLOCK { endBlock(NULL,CCNO);
+ MBEEENDBLOCK(); mout(MENDDO);}
+ ;
+WHEN_CLAUSE_LIST: HWHEN
+ HIDENTIFIER
+ HDO { beginBlock(KCON); mout(MIDENTIFIER);
+ OBSBLOCK(); moutId($2);
+ mout(MWHEN);}
+ BLOCK { endBlock(NULL,CCNO);
+ MBEEENDBLOCK(); mout(MENDWHEN);}
+ | WHEN_CLAUSE_LIST
+ HWHEN
+ HIDENTIFIER
+ HDO { beginBlock(KCON); mout(MIDENTIFIER);
+ OBSBLOCK(); moutId($3);
+ mout(MWHEN);}
+ BLOCK { endBlock(NULL,CCNO);
+ MBEEENDBLOCK(); mout(MENDWHEN);}
+ ;
+MBEE_OTWI_CLAUS : /*EMPT*/
+ | HOTHERWISE {OBSBLOCK(); mout(MOTHERWISE);}
+
+ BLOCK {MBEEENDBLOCK();mout(MENDOTHERWISE);}
+ ;
+ACTIVATOR : HACTIVATE { mout(MBOOLEANKONST);
+ moutIval(FALSE);}
+ | HREACTIVATE { mout(MBOOLEANKONST);
+ moutIval(TRUE);}
+ ;
+SCHEDULE : /*EMPT*/ { mout(MCHARACTERKONST);
+ moutIval(DIRECT);
+ mout(MINTEGERKONST);
+ moutIval(0);
+ mout(MNONE);
+ mout(MBOOLEANKONST);
+ moutIval(FALSE);}
+ | ATDELAY EXPRESSION { mout(MNONE);}
+ PRIOR
+ | BEFOREAFTER { mout(MINTEGERKONST);
+ moutIval(0);}
+ EXPRESSION { mout(MBOOLEANKONST);
+ moutIval(FALSE);}
+ ;
+ATDELAY : HAT { mout(MCHARACTERKONST);
+ moutIval(AT);}
+ | HDELAY { mout(MCHARACTERKONST);
+ moutIval(DELAYS);}
+ ;
+BEFOREAFTER : HBEFORE { mout(MCHARACTERKONST);
+ moutIval(BEFORE);}
+ | HAFTER { mout(MCHARACTERKONST);
+ moutIval(AFTER);}
+ ;
+PRIOR : /*EMPT*/ { mout(MBOOLEANKONST);
+ moutIval(FALSE);}
+ | HPRIOR { mout(MBOOLEANKONST);
+ moutIval(TRUE);}
+ ;
+/* GRAMATIKK FOR SETNINGER OG DEKLARASJONER */
+MODULSTATEMENT : HWHILE
+ EXPRESSION
+ HDO { STOPOBSBLOCK(); mout(MWHILE);
+ OBSBLOCK();}
+ BLOCK { MBEEENDBLOCK(); mout(MENDWHILE);
+ $$=STATEMENT;}
+ | HIF
+ EXPRESSION
+ HTHEN { STOPOBSBLOCK(); mout(MIF);
+ OBSBLOCK();}
+ BLOCK { MBEEENDBLOCK();}
+ MBEE_ELSE_PART { mout(MENDIF);
+ $$=STATEMENT;}
+ | HFOR
+ HIDENTIFIER
+ HASSIGN { STOPOBSBLOCK(); mout(MIDENTIFIER);
+ moutId($2);}
+ FOR_LIST
+ HDO { beginBlock(KFOR);
+ if($3==HASSIGNVALUE) mout(MFOR);
+ else mout(MFORR);
+ OBSBLOCK(); mout(MFORDO);}
+ BLOCK { MBEEENDBLOCK();
+ endBlock(NULL,CCNO); mout(MENDFOR);
+ $$=STATEMENT;}
+ | GOTO
+ EXPRESSION { mout(MGOTO);
+ STOPOBSBLOCK(); $$=STATEMENT;}
+ | HINSPECT
+ EXPRESSION { mout(MINSPECT);
+ STOPOBSBLOCK();
+ beginBlock(KINSP);}
+ CONN_STATE_R_PT
+ { endBlock(NULL,CCNO);}
+ MBEE_OTWI_CLAUS { mout(MENDINSPECT);
+ $$=STATEMENT;}
+ | HINNER { STOPOBSBLOCK(); mout(MINNER);
+ regInner(); $$=STATEMENT;}
+ | HIDENTIFIER
+ HLABELSEPARATOR
+ { STOPOBSBLOCK();
+ regDecl($1, TLABEL, KSIMPLE, categ);
mout(MLABEL);
+ moutId($1);
+ mout(MENDLABEL);}
+ DECLSTATEMENT { if($4<=DECLARATION)
+ { yerror (27);
+ $$=DECLARATION;}
+ else $$=$4;}
+ | EXPRESSION_SIMP
+ HBEGIN
+ { $<ident>$=$1; }
+ IMPORT_SPEC_MODULE
+ { mout(MPRBLOCK);
+ prefquantident=$1;
+ beginBlock(KPRBLK);}
+ MBEE_DECLSTMS
+ HEND { endBlock(NULL,CCNO); mout(MENDPRBLOCK);
+ $$=STATEMENT;}
+ | EXPRESSION_SIMP HBEGIN error HSTATEMENTSEPARATOR
+ MBEE_DECLSTMS HEND { $$=STATEMENT;
+ endBlock(NULL,CCNO); mout(MENDPRBLOCK);}
+ | EXPRESSION_SIMP HBEGIN error HEND
+ { $$=STATEMENT;
+ endBlock(NULL,CCNO); mout(MENDPRBLOCK);}
+
+ | EXPRESSION_SIMP
+ { STOPOBSBLOCK(); $$=STATEMENT;
+ mout(MENDASSIGN);}
+ | ACTIVATOR EXPRESSION SCHEDULE
+ { $$=STATEMENT;
+ mout(MENDSEP);
+ mout(MARGUMENTSEP);
+ mout(MARGUMENTSEP);
+ mout(MARGUMENTSEP);
+ mout(MARGUMENTSEP);
+ mout(MARGUMENTSEP);
+ mout(MARGUMENTSEP);
+ mout(MARGUMENT);
+ moutId(activateid);
+ mout(MENDASSIGN);}
+ | HBEGIN
+ { STOPOBSBLOCK();
+ OBSBLOCK();}
+ MBEE_DECLSTMS
+ HEND { MBEEENDBLOCK(); $$=STATEMENT;}
+ | MBEE_TYPE HPROCEDURE
+ HIDENTIFIER
+ { MBEENEWBLOCK(); mout(MPROCEDURE);
+ regDecl($3, type, KPROC, categ);
+ beginBlock(KPROC);}
+ HEADING BLOCK { endBlock(NULL,CCNO); $$=DECLARATION;
+ mout(MENDPROCEDURE);}
+ | HIDENTIFIER
+ HCLASS
+ NO_TYPE
+ { $<ident>$=$1; }
+ IMPORT_SPEC_MODULE
+ HIDENTIFIER
+ { prefquantident=$1;
+ mout(MCLASS);
+ regDecl($6, TNOTY, KCLASS, categ);
+ beginBlock(KCLASS);}
+ HEADING
+ BLOCK { endBlock(NULL,CCNO); $$=DECLARATION;
+ mout(MENDCLASS);}
+ | HCLASS
+ NO_TYPE
+ HIDENTIFIER
+ { prefquantident=0;
+ MBEENEWBLOCK(); mout(MCLASS);
+ regDecl($3, TNOTY, KCLASS, categ);
+ beginBlock(KCLASS);}
+ HEADING
+ BLOCK { endBlock(NULL,CCNO); $$=DECLARATION;
+ mout(MENDCLASS);}
+ | EXT_DECLARATION {
$$=EXTDECLARATION;}
+ | /*EMPT*/{ STOPOBSBLOCK(); $$=EMPTYSTATEMENT;}
+ ;
+IMPORT_SPEC_MODULE: { MBEENEWBLOCK();
+ kind=KCLASS;
+ if($<ident>0==simsetident &&
+ findDecl(simsetident,cblock,FALSE)==NULL)
+ lesinn_external_spec(simsetident,
+ SIMSETATRFILE, kind);
+ if($<ident>0==simulationident && findDecl(
+ simulationident,cblock,FALSE)==NULL)
+ lesinn_external_spec(simulationident,
+ SIMULATIONATRFILE, kind);
+ if(($<ident>0==fileident && findDecl(
+ fileident,cblock,FALSE)==NULL) ||
+ ($<ident>0==outfileident && findDecl(
+ outfileident,cblock,FALSE)==NULL) ||
+ ($<ident>0==infileident && findDecl(
+ infileident,cblock,FALSE)==NULL) ||
+ ($<ident>0==directfileident && findDecl(
+ directfileident,cblock,FALSE)==NULL) ||
+ ($<ident>0==printfileident && findDecl(
+ printfileident,cblock,FALSE)==NULL) ||
+ ($<ident>0==bytefileident && findDecl(
+ bytefileident,cblock,FALSE)==NULL) ||
+ ($<ident>0==inbytefileident && findDecl(
+ inbytefileident,cblock,FALSE)==NULL) ||
+ ($<ident>0==outbytefileident && findDecl(
+ outbytefileident,cblock,FALSE)==NULL) ||
+ ($<ident>0==directbytefileident &&
findDecl(
+ directbytefileident,cblock,FALSE)==NULL))
+ lesinn_external_spec(fileident,
+ FILEATRFILE, kind);}
+ ;
+DECLSTATEMENT : MODULSTATEMENT
+ | TYPE
+ HIDENTIFIER
+ MBEE_CONSTANT
+ HPAREXPSEPARATOR
+ { MBEENEWBLOCK();
+ kind=KSIMPLE;
+ regDecl($2, type, KSIMPLE, categ);
+ categ=CLOCAL;}
+ IDENTIFIER_LISTC { $$=DECLARATION;}
+ | TYPE
+ HIDENTIFIER
+ MBEE_CONSTANT
+ { MBEENEWBLOCK();
+ regDecl($2, type, KSIMPLE, categ);
+ categ=CLOCAL; $$=DECLARATION;}
+ | MBEE_TYPE
+ HARRAY { MBEENEWBLOCK();
+ kind=KARRAY;}
+ ARR_SEGMENT_LIST { $$=DECLARATION;}
+ | HSWITCH
+ HIDENTIFIER
+ HASSIGN { MBEENEWBLOCK(); mout(MIDENTIFIER);
+ moutId($2);
+ regDecl($2, TLABEL, KARRAY, categ);}
+ SWITCH_LIST { $$=DECLARATION;
+ mout(MSWITCH);
+ mout(MENDSWITCH);}
+ ;
+BLOCK : DECLSTATEMENT { if($1<=DECLARATION)yerror (29);}
+ | HBEGIN MBEE_DECLSTMS HEND
+ | HBEGIN error HSTATEMENTSEPARATOR MBEE_DECLSTMS HEND
+ | HBEGIN error HEND
+ ;
+MBEE_DECLSTMS : MBEE_DECLSTMSU { if($1<=DECLARATION)yerror (28);
+ $$=$1;}
+ ;
+MBEE_DECLSTMSU : DECLSTATEMENT { $$=$1;}
+ | MBEE_DECLSTMSU
+ HSTATEMENTSEPARATOR
+ DECLSTATEMENT { if($1>=STATEMENT && $3<=DECLARATION)
+ yerror (26);
+ $$=$3;}
+ ;
+MODULS : MODULSTATEMENT { if($1==DECLARATION)
+ {separat_comp=TRUE;gettimestamp();}
+ $$=$1;}
+ | MODULS HSTATEMENTSEPARATOR MODULSTATEMENT
+ { if($1>=STATEMENT && $3<=DECLARATION)
+ yerror (26);else
+ if($1>=STATEMENT
+ && $3!=EMPTYSTATEMENT)yerror (25);
+ if(separat_comp && $3==STATEMENT)
+ yerror (25);
+ if($3==DECLARATION && !separat_comp)
+ {separat_comp=TRUE;gettimestamp();}
+ $$=$3;}
+ ;
+/* GRAMATIKK FOR DEL AV DEKLARASJONER */
+ARR_SEGMENT_LIST: ARR_SEGMENT
+ | ARR_SEGMENT_LIST
+ HPAREXPSEPARATOR
+ ARR_SEGMENT
+ ;
+ARR_SEGMENT : ARRAY_SEGMENT
+ HBEGPAR
+ BAUND_PAIR_LIST HENDPAR { mout(MARRAY);
+ mout(MENDARRAY);
+ setArrayDim($3);}
+ ;
+ARRAY_SEGMENT : ARRAY_SEGMENT_EL { mout(MENDSEP);
+ mout(MARRAYSEP);}
+
+ | ARRAY_SEGMENT_EL
+ HPAREXPSEPARATOR
+ ARRAY_SEGMENT { mout(MARRAYSEP);}
+ ;
+ARRAY_SEGMENT_EL: HIDENTIFIER { mout(MIDENTIFIER);
+ moutId($1);
+ regDecl($1, type, kind,
categ);
+ if(lastArray==NULL)
+ lastArray=cblock->lastparloc;}
+ ;
+BAUND_PAIR_LIST : BAUND_PAIR { mout(MENDSEP);
+ mout(MBOUNDSEP);
+ $$=1;}
+ | BAUND_PAIR
+ HPAREXPSEPARATOR
+ BAUND_PAIR_LIST { mout(MBOUNDSEP);
+ $$=$3+1;}
+ ;
+BAUND_PAIR : EXPRESSION
+ HLABELSEPARATOR
+ EXPRESSION { mout(MBOUNDPARSEP);}
+ ;
+SWITCH_LIST : EXPRESSION { mout(MENDSEP);
+ mout(MSWITCHSEP);}
+ | EXPRESSION
+ HPAREXPSEPARATOR
+ SWITCH_LIST { mout(MSWITCHSEP);}
+ ;
+HEADING : MBEE_FMAL_PAR_P HSTATEMENTSEPARATOR { kind=KNOKD;}
+ MBEE_MODE_PART { categ=CSPEC;}
+ MBEE_SPEC_PART { kind=KNOKD;}
+ MBEE_PROT_PART { categ=CVIRT;}
+ MBEE_VIRT_PART
+ { categ=CLOCAL;}
+ ;
+MBEE_FMAL_PAR_P : /*EMPT*/
+ | FMAL_PAR_PART
+ ;
+FMAL_PAR_PART : HBEGPAR NO_TYPE
+ MBEE_LISTV HENDPAR
+ ;
+MBEE_LISTV : /*EMPT*/
+ | LISTV
+ ;
+LISTV : HIDENTIFIER { regDecl($1, type, KNOKD, CDEFLT);}
+ | FPP_CATEG HDOTDOTDOT { regDecl(varargsid,
TVARARGS, KNOKD, categ);}
+ | HIDENTIFIER { regDecl($1, type, KNOKD, CDEFLT);}
+ HPAREXPSEPARATOR LISTV
+ | FPP_SPEC
+ | FPP_SPEC
+ HPAREXPSEPARATOR LISTV
+ ;
+FPP_HEADING : HBEGPAR NO_TYPE
+ FPP_MBEE_LISTV HENDPAR
+ ;
+FPP_MBEE_LISTV : /*EMPT*/
+ | FPP_LISTV
+ ;
+FPP_LISTV : FPP_CATEG HDOTDOTDOT { regDecl(varargsid,
TVARARGS, KNOKD, categ);}
+ | FPP_SPEC
+ | FPP_SPEC
+ HPAREXPSEPARATOR LISTV
+ ;
+FPP_SPEC : FPP_CATEG SPECIFIER HIDENTIFIER
+ { regDecl($3, type, kind, categ);}
+ | FPP_CATEG FPP_PROC_DECL_IN_SPEC
+ ;
+FPP_CATEG : HNAME HLABELSEPARATOR
+ { categ=CNAME;}
+ | HVALUE HLABELSEPARATOR
+ { categ=CVALUE;}
+ | HVAR HLABELSEPARATOR
+ { categ=CVAR;}
+ | /*EMPT*/ { categ=CDEFLT;}
+ ;
+FPP_PROC_DECL_IN_SPEC: MBEE_TYPE HPROCEDURE
+ HIDENTIFIER
+ { $<ival>$=categ;
+ regDecl($3, type, KPROC, categ);
+ beginBlock(KPROC);}
+ FPP_HEADING
+ { categ=$<ival>4; /* M} settes
tilbake*/}
+ { endBlock(NULL,CCNO);}
+ ;
+IDENTIFIER_LISTV: HIDENTIFIER { regDecl($1, type, kind, categ);}
+ | HDOTDOTDOT { regDecl(varargsid, TVARARGS, kind,
categ);}
+ | HIDENTIFIER { regDecl($1, type, kind, categ);}
+ HPAREXPSEPARATOR IDENTIFIER_LISTV
+ ;
+MBEE_MODE_PART : /*EMPT*/
+ | MODE_PART
+ ;
+MODE_PART : NAME_PART
+ | VALUE_PART
+ | VAR_PART
+ | NAME_PART VALUE_PART
+ | VALUE_PART NAME_PART
+ | NAME_PART VAR_PART
+ | VAR_PART NAME_PART
+ | VALUE_PART VAR_PART
+ | VAR_PART VALUE_PART
+ | VAR_PART NAME_PART VALUE_PART
+ | NAME_PART VAR_PART VALUE_PART
+ | NAME_PART VALUE_PART VAR_PART
+ | VAR_PART VALUE_PART NAME_PART
+ | VALUE_PART VAR_PART NAME_PART
+ | VALUE_PART NAME_PART VAR_PART
+ ;
+NAME_PART : HNAME { categ=CNAME;}
+ IDENTIFIER_LISTV
+ HSTATEMENTSEPARATOR
+ ;
+VAR_PART : HVAR { categ=CVAR;}
+ IDENTIFIER_LISTV
+ HSTATEMENTSEPARATOR
+ ;
+VALUE_PART : HVALUE { categ=CVALUE;}
+ IDENTIFIER_LISTV HSTATEMENTSEPARATOR
+ ;
+MBEE_SPEC_PART : /*EMPT*/
+ | SPEC_PART
+ ;
+SPEC_PART : ONE_SPEC
+ | SPEC_PART ONE_SPEC
+ ;
+ONE_SPEC : SPECIFIER IDENTIFIER_LIST HSTATEMENTSEPARATOR
+ | NO_TYPE HPROCEDURE HIDENTIFIER HOBJRELOPERATOR
+ { if($4!=HIS) yerror (8);}
+ PROC_DECL_IN_SPEC HSTATEMENTSEPARATOR
+ | FPP_PROC_DECL_IN_SPEC HSTATEMENTSEPARATOR
+ | MBEE_TYPE HPROCEDURE HIDENTIFIER HSTATEMENTSEPARATOR
+ { yerror (45);}
+ | MBEE_TYPE HPROCEDURE HIDENTIFIER HPAREXPSEPARATOR
+ IDENTIFIER_LIST HSTATEMENTSEPARATOR
+ { yerror (45);}
+ ;
+SPECIFIER : TYPE { kind=KSIMPLE;}
+ | MBEE_TYPE
+ HARRAY { kind=KARRAY;}
+ | HLABEL { type=TLABEL;
+ kind=KSIMPLE;}
+ | HSWITCH { type=TLABEL;
+ kind=KARRAY;}
+ ;
+PROC_DECL_IN_SPEC: MBEE_TYPE HPROCEDURE
+ HIDENTIFIER
+ { $<ival>$=categ;
+ regDecl($3, type, KPROC, categ);
+ beginBlock(KPROC);}
+ HEADING
+ { categ=$<ival>4; /* M} settes
tilbake*/}
+ MBEE_BEGIN_END
+ { endBlock(NULL,CCNO);}
+ ;
+MBEE_BEGIN_END : /* EMPTY */
+ | HBEGIN HEND
+ ;
+MBEE_PROT_PART : /*EMPT*/
+ | PROTECTION_PART
+ ;
+PROTECTION_PART : PROT_SPECIFIER IDENTIFIER_LIST
+ HSTATEMENTSEPARATOR
+ | PROTECTION_PART PROT_SPECIFIER
+ IDENTIFIER_LIST HSTATEMENTSEPARATOR
+ ;
+PROT_SPECIFIER : HHIDDEN { categ=CHIDEN;}
+ | HPROTECTED { categ=CPROT;}
+ | HHIDDEN
+ HPROTECTED { categ=CHIPRO;}
+ | HPROTECTED
+ HHIDDEN { categ=CHIPRO;}
+ ;
+MBEE_VIRT_PART : /*EMPT*/
+ | VIRTUAL_PART
+ ;
+VIRTUAL_PART : HVIRTUAL
+ HLABELSEPARATOR
+ MBEE_SPEC_PART
+ ;
+IDENTIFIER_LIST : HIDENTIFIER { regDecl($1, type, kind, categ);}
+ | IDENTIFIER_LIST HPAREXPSEPARATOR
+ HIDENTIFIER { regDecl($3, type, kind, categ);}
+ ;
+IDENTIFIER_LISTC: HIDENTIFIER
+ MBEE_CONSTANT { regDecl($1, type, kind, categ);
+ categ=CLOCAL;}
+ | IDENTIFIER_LISTC HPAREXPSEPARATOR
+ HIDENTIFIER
+ MBEE_CONSTANT { regDecl($3, type, kind, categ);
+ categ=CLOCAL;}
+ ;
+MBEE_CONSTANT : /* EMPTY */
+ | HVALRELOPERATOR
+ { MBEENEWBLOCK();
+ if($1!=HEQ) yerror (8);
+ if(type==TREF)yerror (7);
+ categ=CCONSTU;
+ mout(MIDENTIFIER);
+ moutId($<token>0);}
+ EXPRESSION { mout(MASSIGN);
+ mout(MCONST);}
+ ;
+
+/* GRAMATIKK FOR UTTRYKK */
+EXPRESSION : EXPRESSION_SIMP {}
+ | HIF
+ EXPRESSION
+ HTHEN
+ EXPRESSION
+ HELSE
+ EXPRESSION { mout(MELSEE);
+ mout(MIFE);}
+ ;
+EXPRESSION_SIMP : EXPRESSION_SIMP
+ HASSIGN
+ EXPRESSION { if($2==HASSIGNREF)mout(MASSIGNR);
+ else mout(MASSIGN);$$=NULL;}
+ |
+
+ EXPRESSION_SIMP
+ HCONC
+ EXPRESSION_SIMP { mout(MCONC);$$=NULL;}
+ | EXPRESSION_SIMP HOR
+ HELSE
+ EXPRESSION_SIMP
+ %prec HORELSE { mout(MORELSEE);$$=NULL;}
+ | EXPRESSION_SIMP HAND
+ HTHEN
+ EXPRESSION_SIMP
+ %prec HANDTHEN { mout(MANDTHENE);$$=NULL;}
+ | EXPRESSION_SIMP
+ HEQV EXPRESSION_SIMP { mout(MEQV);$$=NULL;}
+ | EXPRESSION_SIMP
+ HIMP EXPRESSION_SIMP { mout(MIMP);$$=NULL;}
+ | EXPRESSION_SIMP
+ HOR EXPRESSION_SIMP { mout(MOR);$$=NULL;}
+ | EXPRESSION_SIMP
+ HAND EXPRESSION_SIMP { mout(MAND);$$=NULL;}
+ | HNOT EXPRESSION_SIMP { mout(MNOT);$$=NULL;}
+ | EXPRESSION_SIMP
+ HVALRELOPERATOR
+ EXPRESSION_SIMP
+ { switch($2)
+ { case HEQ: mout(MEQ);break;
+ case HNE: mout(MNE);break;
+ case HLT: mout(MLT);break;
+ case HLE: mout(MLE);break;
+ case HGT: mout(MGT);break;
+ case HGE: mout(MGE);break;
+ }; $$=NULL;}
+ | EXPRESSION_SIMP
+ HREFRELOPERATOR
+ EXPRESSION_SIMP
+ { if($2==HNER) mout(MNER);
+ else mout(MEQR);$$=NULL;}
+ | EXPRESSION_SIMP
+ HOBJRELOPERATOR
+ EXPRESSION_SIMP
+ { if($2==HIS) mout(MIS);
+ else mout(MINS);$$=NULL;}
+ | HTERMOPERATOR
+ EXPRESSION_SIMP %prec UNEAR
+ { if($1==HADD) mout(MUADD);
+ else mout(MUSUB);$$=NULL;}
+ | EXPRESSION_SIMP
+ HTERMOPERATOR
+ EXPRESSION_SIMP
+ { if($2==HADD) mout(MADD);
+ else mout(MSUB);$$=NULL;}
+ | EXPRESSION_SIMP
+ HFACTOROPERATOR
+ EXPRESSION_SIMP
+ { if($2==HMUL) mout(MMUL); else
+ if($2==HDIV) mout(MDIV);
+ else mout(MINTDIV);$$=NULL;}
+ | EXPRESSION_SIMP
+ HPRIMARYOPERATOR
+ EXPRESSION_SIMP { mout(MPRIMARY);$$=NULL;}
+ | HBEGPAR
+ EXPRESSION HENDPAR { mout(MNOOP);$$=NULL;}
+ | HTEXTKONST { mout(MTEXTKONST);
+ moutTval($1);$$=NULL;}
+ | HCHARACTERKONST { mout(MCHARACTERKONST);
+ moutIval($1);$$=NULL;}
+ | HREALKONST { mout(MREALKONST);
+ moutRval($1);$$=NULL;}
+ | HINTEGERKONST { mout(MINTEGERKONST);
+ moutIval($1);$$=NULL;}
+ | HBOOLEANKONST { mout(MBOOLEANKONST);
+ moutIval($1);$$=NULL;}
+ | HNONE { mout(MNONE);$$=NULL;}
+ | HIDENTIFIER
+ { $<ident>$=$1;}
+ MBEE_ARG_R_PT
+ | HTHIS HIDENTIFIER { mout(MTHIS);
+ moutId($2);$$=NULL;}
+ | HNEW
+ HIDENTIFIER
+ ARG_R_PT { mout(MNEWARG);
+ moutId($2);$$=NULL;}
+ | EXPRESSION_SIMP
+ HDOT
+ EXPRESSION_SIMP { mout(MDOT);$$=NULL;}
+ | EXPRESSION_SIMP
+ HQUA HIDENTIFIER { mout(MQUA);
+ moutId($3);$$=NULL;}
+ ;
+ARG_R_PT : /*EMPTY*/ { mout(MENDSEP);}
+ | HBEGPAR
+ ARGUMENT_LIST HENDPAR
+ ;
+MBEE_ARG_R_PT : /*EMPTY*/ { mout(MIDENTIFIER);
+ moutId($<ident>0);
+ $$=$<ident>0;}
+ | HBEGPAR
+ ARGUMENT_LIST HENDPAR { mout(MARGUMENT);
+ moutId($<ident>0);}
+ ;
+ARGUMENT_LIST : EXPRESSION { mout(MENDSEP);
+ mout(MARGUMENTSEP);}
+ | EXPRESSION
+ HPAREXPSEPARATOR
+ ARGUMENT_LIST { mout(MARGUMENTSEP);}
+ ;
+%%
+]])
+
+# Pass plenty of options, to exercise plenty of code, even if we
+# don't actually check the output. But SEGV is watching us, and
+# so might do dmalloc.
+AT_CHECK([[bison --verbose --defines input.y]], 0, [],
+[[input.y contains 78 shift/reduce conflicts and 10 reduce/reduce conflicts.
+]])
+
+AT_CHECK([[grep '^State.*contains' input.output]], 0,
+[[State 64 contains 14 shift/reduce conflicts.
+State 164 contains 1 shift/reduce conflict.
+State 201 contains 33 shift/reduce conflicts and 4 reduce/reduce conflicts.
+State 206 contains 1 shift/reduce conflict.
+State 240 contains 1 shift/reduce conflict.
+State 335 contains 9 shift/reduce conflicts and 2 reduce/reduce conflicts.
+State 356 contains 1 shift/reduce conflict.
+State 360 contains 9 shift/reduce conflicts and 2 reduce/reduce conflicts.
+State 427 contains 9 shift/reduce conflicts and 2 reduce/reduce conflicts.
+]])
+
+AT_CLEANUP
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- 03-fyi-fix-rr-count.patch,
Akim Demaille <=