# Exercising Bison on actual grammars. -*- Autotest -*-
-# Copyright (C) 1989, 1990, 1991, 1992, 2000, 2001, 2002, 2003, 2004
-# Free Software Foundation, Inc.
+# Copyright (C) 1989, 1990, 1991, 1992, 2000, 2001, 2002, 2003, 2004, 2005,
+# 2007 Free Software Foundation, Inc.
-# This program is free software; you can redistribute it and/or modify
+# 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
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
-
+#
# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-# 02111-1307, USA.
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
AT_BANNER([[Existing Grammars.]])
## ----------------- ##
| l_brace r_brace opt_semi opt_nls
;
-
pattern
: exp
| exp ',' exp
# 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]])
+AT_BISON_CHECK([[--verbose --defines input.y]])
AT_CLEANUP
-
## ----------------- ##
## GNU Cim Grammar. ##
## ----------------- ##
# It reported 80 SR && 99 RR conflicts instead of 78/10!!!
AT_DATA([[input.y]],
-[[%union {
- long int token;
- long int ival;
- long int arrdim;
- double rval;
- char *ident;
- char *tval;
- char stat_decl;
- }
+[[%union {}
%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
+ 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 HIDENTIFIER
+%token HBOOLEANKONST HINTEGERKONST HCHARACTERKONST
+%token HREALKONST
+%token HTEXTKONST
+
+
+%right HASSIGN
%left HORELSE
%left HANDTHEN
%left HEQV
%left HNOT
-%left <token> HVALRELOPERATOR HREFRELOPERATOR HOBJRELOPERATOR
+%left HVALRELOPERATOR HREFRELOPERATOR HOBJRELOPERATOR
%left HCONC
-%left <token> HTERMOPERATOR
-%left <token> UNEAR
-%left <token> HFACTOROPERATOR
+%left HTERMOPERATOR
+%left UNEAR
+%left HFACTOROPERATOR
%left HPRIMARYOPERATOR
%left HQUA
%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
+MAIN_MODULE : {}
+ MODULS
+ | 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;}
+ {}
+ HIDENTIFIER {}
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
+ {}
+ MBEE_TYPE HPROCEDURE
HIDENTIFIER
- { regDecl($6, type, KPROC, CCPROC);
- beginBlock(kind);}
- HEADING EMPTY_BLOCK
- { categ=CLOCAL;
- endBlock($1==NULL?$<ident>0:tag($1),CCCPROC);}
+ {}
+ HEADING EMPTY_BLOCK
+ {}
/* |
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_ITEM : HIDENTIFIER
EXT_IDENT
- { if($2!=NULL)yerror (3);
- regDecl($1, type, kind, categ);}*/
+ {}*/
;
EMPTY_BLOCK : /*EMPT*/
| HBEGIN HEND
;
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;}
+EXT_IDENT : /* EMPTY */
+ | HVALRELOPERATOR {}
+ HTEXTKONST
;
/* GRAMATIKK FOR TYPER */
-NO_TYPE : /*EMPT*/ { type=TNOTY;}
- ;
+NO_TYPE : /*EMPT*/
+ ;
MBEE_TYPE : NO_TYPE
- | 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;}
- ;
+ HIDENTIFIER
+ {}
+ HENDPAR
+ | HTEXT
+ | HBOOLEAN
+ | HCHARACTER
+ | HSHORT HINTEGER
+ | HINTEGER
+ | HREAL
+ | HLONG HREAL
+ ;
/* 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);}
- ;
+ EXPRESSION
+ HTHEN {}
+ BLOCK {}
+ MBEE_ELSE_PART {}*/
+ | HELSE {}
+ BLOCK
+ ;
+FOR_LIST : FOR_LIST_ELEMENT
+ | FOR_LIST_ELEMENT
+ HPAREXPSEPARATOR
+ FOR_LIST
+ ;
FOR_LIST_ELEMENT: EXPRESSION
- MBEE_F_L_EL_R_PT
- ;
+ 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);}
- ;
+ | HWHILE
+ EXPRESSION
+ | HSTEP
+ EXPRESSION
+ HUNTIL
+ EXPRESSION
+ ;
GOTO : HGO
- HTO
- | HGOTO
- ;
+ HTO
+ | HGOTO
+ ;
CONN_STATE_R_PT : WHEN_CLAUSE_LIST
- | HDO { beginBlock(KCON); mout(MDO);
- OBSBLOCK(); }
- BLOCK { endBlock(NULL,CCNO);
- MBEEENDBLOCK(); mout(MENDDO);}
- ;
+ | HDO {}
+ BLOCK
+ ;
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);}
- ;
+ HIDENTIFIER
+ HDO {}
+ BLOCK
+ | WHEN_CLAUSE_LIST
+ HWHEN
+ HIDENTIFIER
+ HDO {}
+ BLOCK
+ ;
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);}
+ | HOTHERWISE {}
+
+ BLOCK
+ ;
+ACTIVATOR : HACTIVATE
+ | HREACTIVATE
+ ;
+SCHEDULE : /*EMPT*/
+ | ATDELAY EXPRESSION {}
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);}
+ | BEFOREAFTER {}
+ EXPRESSION
+ ;
+ATDELAY : HAT
+ | HDELAY
+ ;
+BEFOREAFTER : HBEFORE
+ | HAFTER
+ ;
+PRIOR : /*EMPT*/
+ | HPRIOR
;
/* 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;}
+ EXPRESSION
+ HDO {}
+ BLOCK
+ | HIF
+ EXPRESSION
+ HTHEN {}
+ BLOCK {}
+ MBEE_ELSE_PART
| 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;}
+ HIDENTIFIER
+ HASSIGN {}
+ FOR_LIST
+ HDO {}
+ BLOCK
| GOTO
- EXPRESSION { mout(MGOTO);
- STOPOBSBLOCK(); $$=STATEMENT;}
+ EXPRESSION
| 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; }
+ EXPRESSION {}
+ CONN_STATE_R_PT
+ {}
+ MBEE_OTWI_CLAUS
+ | HINNER
+ | HIDENTIFIER
+ HLABELSEPARATOR
+ {}
+ DECLSTATEMENT
+ | EXPRESSION_SIMP
+ HBEGIN
+ {}
IMPORT_SPEC_MODULE
- { mout(MPRBLOCK);
- prefquantident=$1;
- beginBlock(KPRBLK);}
- MBEE_DECLSTMS
- HEND { endBlock(NULL,CCNO); mout(MENDPRBLOCK);
- $$=STATEMENT;}
+ {}
+ MBEE_DECLSTMS
+ HEND
| EXPRESSION_SIMP HBEGIN error HSTATEMENTSEPARATOR
- MBEE_DECLSTMS HEND { $$=STATEMENT;
- endBlock(NULL,CCNO); mout(MENDPRBLOCK);}
+ MBEE_DECLSTMS HEND
| EXPRESSION_SIMP HBEGIN error HEND
- { $$=STATEMENT;
- endBlock(NULL,CCNO); mout(MENDPRBLOCK);}
-
- | EXPRESSION_SIMP
- { STOPOBSBLOCK(); $$=STATEMENT;
- mout(MENDASSIGN);}
+ | EXPRESSION_SIMP
| 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;}
+ | HBEGIN
+ {}
+ MBEE_DECLSTMS
+ HEND
| MBEE_TYPE HPROCEDURE
- HIDENTIFIER
- { MBEENEWBLOCK(); mout(MPROCEDURE);
- regDecl($3, type, KPROC, categ);
- beginBlock(KPROC);}
- HEADING BLOCK { endBlock(NULL,CCNO); $$=DECLARATION;
- mout(MENDPROCEDURE);}
+ HIDENTIFIER
+ {}
+ HEADING BLOCK
| HIDENTIFIER
HCLASS
- NO_TYPE
- { $<ident>$=$1; }
+ NO_TYPE
+ {}
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);}
+ HIDENTIFIER
+ {}
+ HEADING
+ BLOCK
+ | HCLASS
+ NO_TYPE
+ HIDENTIFIER
+ {}
+ HEADING
+ BLOCK
+ | EXT_DECLARATION
+ | /*EMPT*/
+ ;
+IMPORT_SPEC_MODULE:
;
DECLSTATEMENT : MODULSTATEMENT
| TYPE
- HIDENTIFIER
+ HIDENTIFIER
MBEE_CONSTANT
- HPAREXPSEPARATOR
- { MBEENEWBLOCK();
- kind=KSIMPLE;
- regDecl($2, type, KSIMPLE, categ);
- categ=CLOCAL;}
- IDENTIFIER_LISTC { $$=DECLARATION;}
- | TYPE
- HIDENTIFIER
+ HPAREXPSEPARATOR
+ {}
+ IDENTIFIER_LISTC
+ | 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
+ | MBEE_TYPE
+ HARRAY {}
+ ARR_SEGMENT_LIST
+ | HSWITCH
+ HIDENTIFIER
+ HASSIGN {}
+ SWITCH_LIST
+ ;
+BLOCK : DECLSTATEMENT
+ | 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;}
+MBEE_DECLSTMS : MBEE_DECLSTMSU
+ ;
+MBEE_DECLSTMSU : DECLSTATEMENT
+ | MBEE_DECLSTMSU
+ HSTATEMENTSEPARATOR
+ DECLSTATEMENT
+ ;
+MODULS : MODULSTATEMENT
+ | MODULS HSTATEMENTSEPARATOR MODULSTATEMENT
;
/* GRAMATIKK FOR DEL AV DEKLARASJONER */
ARR_SEGMENT_LIST: ARR_SEGMENT
- | ARR_SEGMENT_LIST
- HPAREXPSEPARATOR
- 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;}
- ;
+ HBEGPAR
+ BAUND_PAIR_LIST HENDPAR
+ ;
+ARRAY_SEGMENT : ARRAY_SEGMENT_EL {}
+
+ | ARRAY_SEGMENT_EL
+ HPAREXPSEPARATOR
+ ARRAY_SEGMENT
+ ;
+ARRAY_SEGMENT_EL: HIDENTIFIER
+ ;
+BAUND_PAIR_LIST : BAUND_PAIR
+ | BAUND_PAIR
+ HPAREXPSEPARATOR
+ BAUND_PAIR_LIST
+ ;
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;}
- ;
+ HLABELSEPARATOR
+ EXPRESSION
+ ;
+SWITCH_LIST : EXPRESSION
+ | EXPRESSION
+ HPAREXPSEPARATOR
+ SWITCH_LIST
+ ;
+HEADING : MBEE_FMAL_PAR_P HSTATEMENTSEPARATOR {}
+ MBEE_MODE_PART {}
+ MBEE_SPEC_PART {}
+ MBEE_PROT_PART {}
+ MBEE_VIRT_PART
+ ;
MBEE_FMAL_PAR_P : /*EMPT*/
- | FMAL_PAR_PART
- ;
+ | FMAL_PAR_PART
+ ;
FMAL_PAR_PART : HBEGPAR NO_TYPE
- MBEE_LISTV HENDPAR
- ;
+ 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
- ;
+ | LISTV
+ ;
+LISTV : HIDENTIFIER
+ | FPP_CATEG HDOTDOTDOT
+ | HIDENTIFIER {}
+ HPAREXPSEPARATOR LISTV
+ | FPP_SPEC
+ | FPP_SPEC
+ HPAREXPSEPARATOR LISTV
+ ;
FPP_HEADING : HBEGPAR NO_TYPE
- FPP_MBEE_LISTV HENDPAR
- ;
+ 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_LISTV
+ ;
+FPP_LISTV : FPP_CATEG HDOTDOTDOT
+ | 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;}
- ;
+ | HVALUE HLABELSEPARATOR
+ | HVAR HLABELSEPARATOR
+ | /*EMPT*/
+ ;
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 {}
- ;
+ HIDENTIFIER
+ {}
+ FPP_HEADING {} { /* Yes, two "final" actions. */ }
+ ;
+IDENTIFIER_LISTV: HIDENTIFIER
+ | HDOTDOTDOT
+ | HIDENTIFIER {}
+ HPAREXPSEPARATOR IDENTIFIER_LISTV
+ ;
MBEE_MODE_PART : /*EMPT*/
- | MODE_PART
- ;
+ | 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
- ;
+ | 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 {}
+ IDENTIFIER_LISTV
+ HSTATEMENTSEPARATOR
+ ;
+VAR_PART : HVAR {}
+ IDENTIFIER_LISTV
+ HSTATEMENTSEPARATOR
+ ;
+VALUE_PART : HVALUE {}
+ IDENTIFIER_LISTV HSTATEMENTSEPARATOR
+ ;
MBEE_SPEC_PART : /*EMPT*/
- | SPEC_PART
- ;
+ | SPEC_PART
+ ;
SPEC_PART : ONE_SPEC
- | 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;}
- ;
+ | FPP_PROC_DECL_IN_SPEC HSTATEMENTSEPARATOR
+ | MBEE_TYPE HPROCEDURE HIDENTIFIER HSTATEMENTSEPARATOR
+ | MBEE_TYPE HPROCEDURE HIDENTIFIER HPAREXPSEPARATOR
+ IDENTIFIER_LIST HSTATEMENTSEPARATOR
+ ;
+SPECIFIER : TYPE
+ | MBEE_TYPE
+ HARRAY
+ | HLABEL
+ | HSWITCH
+ ;
PROC_DECL_IN_SPEC: MBEE_TYPE HPROCEDURE
- HIDENTIFIER
- { $<ival>$=categ;
- regDecl($3, type, KPROC, categ);
- beginBlock(KPROC);}
- HEADING
- { categ=$<ival>4; /* M} settes tilbake*/}
+ HIDENTIFIER
+ {}
+ HEADING
+ {}
MBEE_BEGIN_END
- { endBlock(NULL,CCNO);}
;
MBEE_BEGIN_END : /* EMPTY */
| HBEGIN HEND
;
MBEE_PROT_PART : /*EMPT*/
- | PROTECTION_PART
- ;
+ | 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;}
- ;
+ HSTATEMENTSEPARATOR
+ | PROTECTION_PART PROT_SPECIFIER
+ IDENTIFIER_LIST HSTATEMENTSEPARATOR
+ ;
+PROT_SPECIFIER : HHIDDEN
+ | HPROTECTED
+ | HHIDDEN
+ HPROTECTED
+ | HPROTECTED
+ HHIDDEN
+ ;
MBEE_VIRT_PART : /*EMPT*/
- | VIRTUAL_PART
- ;
+ | 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);}
- ;
+ HLABELSEPARATOR
+ MBEE_SPEC_PART
+ ;
+IDENTIFIER_LIST : HIDENTIFIER
+ | IDENTIFIER_LIST HPAREXPSEPARATOR
+ HIDENTIFIER
+ ;
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
+ | IDENTIFIER_LISTC HPAREXPSEPARATOR
+ HIDENTIFIER
+ MBEE_CONSTANT
+ ;
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);}
+ {}
+ EXPRESSION
;
/* GRAMATIKK FOR UTTRYKK */
-EXPRESSION : EXPRESSION_SIMP {}
- | HIF
- EXPRESSION
- HTHEN
- EXPRESSION
- HELSE
- EXPRESSION { mout(MELSEE);
- mout(MIFE);}
- ;
+EXPRESSION : EXPRESSION_SIMP
+ | HIF
+ EXPRESSION
+ HTHEN
+ EXPRESSION
+ HELSE
+ EXPRESSION
+ ;
EXPRESSION_SIMP : EXPRESSION_SIMP
HASSIGN
- EXPRESSION { if($2==HASSIGNREF)mout(MASSIGNR);
- else mout(MASSIGN);$$=NULL;}
+ EXPRESSION
|
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);}
- ;
+ HCONC
+ EXPRESSION_SIMP
+ | EXPRESSION_SIMP HOR
+ HELSE
+ EXPRESSION_SIMP
+ %prec HORELSE
+ | EXPRESSION_SIMP HAND
+ HTHEN
+ EXPRESSION_SIMP
+ %prec HANDTHEN
+ | EXPRESSION_SIMP
+ HEQV EXPRESSION_SIMP
+ | EXPRESSION_SIMP
+ HIMP EXPRESSION_SIMP
+ | EXPRESSION_SIMP
+ HOR EXPRESSION_SIMP
+ | EXPRESSION_SIMP
+ HAND EXPRESSION_SIMP
+ | HNOT EXPRESSION_SIMP
+ | EXPRESSION_SIMP
+ HVALRELOPERATOR
+ EXPRESSION_SIMP
+ | EXPRESSION_SIMP
+ HREFRELOPERATOR
+ EXPRESSION_SIMP
+ | EXPRESSION_SIMP
+ HOBJRELOPERATOR
+ EXPRESSION_SIMP
+ | HTERMOPERATOR
+ EXPRESSION_SIMP %prec UNEAR
+ | EXPRESSION_SIMP
+ HTERMOPERATOR
+ EXPRESSION_SIMP
+ | EXPRESSION_SIMP
+ HFACTOROPERATOR
+ EXPRESSION_SIMP
+ | EXPRESSION_SIMP
+ HPRIMARYOPERATOR
+ EXPRESSION_SIMP
+ | HBEGPAR
+ EXPRESSION HENDPAR
+ | HTEXTKONST
+ | HCHARACTERKONST
+ | HREALKONST
+ | HINTEGERKONST
+ | HBOOLEANKONST
+ | HNONE
+ | HIDENTIFIER
+ {}
+ MBEE_ARG_R_PT
+ | HTHIS HIDENTIFIER
+ | HNEW
+ HIDENTIFIER
+ ARG_R_PT
+ | EXPRESSION_SIMP
+ HDOT
+ EXPRESSION_SIMP
+ | EXPRESSION_SIMP
+ HQUA HIDENTIFIER
+ ;
+ARG_R_PT : /*EMPTY*/
+ | HBEGPAR
+ ARGUMENT_LIST HENDPAR
+ ;
+MBEE_ARG_R_PT : /*EMPTY*/
+ | HBEGPAR
+ ARGUMENT_LIST HENDPAR
+ ;
+ARGUMENT_LIST : EXPRESSION
+ | EXPRESSION
+ HPAREXPSEPARATOR
+ ARGUMENT_LIST
+ ;
%%
]])
# 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, [],
+AT_BISON_CHECK([[--verbose --defines input.y]], 0, [],
[[input.y: conflicts: 78 shift/reduce, 10 reduce/reduce
]])
AT_CLEANUP
-
## ----------------- ##
## GNU pic Grammar. ##
## ----------------- ##
# Bison once reported shift/reduce conflicts that it shouldn't have.
AT_DATA([[input.y]],
-[[%union {
- char *str;
- int n;
- double x;
- struct { double x, y; } pair;
- struct { double x; char *body; } if_data;
- struct { char *str; const char *filename; int lineno; } lstr;
- struct { double *v; int nv; int maxv; } dv;
- struct { double val; int is_multiplicative; } by;
- place pl;
- object *obj;
- corner crn;
- path *pth;
- object_spec *spec;
- saved_state *pstate;
- graphics_state state;
- object_type obtype;
-}
-
-%token <str> LABEL
-%token <str> VARIABLE
-%token <x> NUMBER
-%token <lstr> TEXT
-%token <lstr> COMMAND_LINE
-%token <str> DELIMITED
-%token <n> ORDINAL
+[[%union {}
+
+%token LABEL
+%token VARIABLE
+%token NUMBER
+%token TEXT
+%token COMMAND_LINE
+%token DELIMITED
+%token ORDINAL
%token TH
%token LEFT_ARROW_HEAD
%token RIGHT_ARROW_HEAD
%token AND
%token HERE
%token DOT_N
-%token DOT_E
+%token DOT_E
%token DOT_W
%token DOT_S
%token DOT_NE
%left CHOP SOLID DASHED DOTTED UP DOWN FILL COLORED OUTLINED
%left LABEL
-%left VARIABLE NUMBER '(' SIN COS ATAN2 LOG EXP SQRT K_MAX K_MIN INT RAND SRAND LAST
+%left VARIABLE NUMBER '(' SIN COS ATAN2 LOG EXP SQRT K_MAX K_MIN INT RAND SRAND LAST
%left ORDINAL HERE '`'
%left BOX CIRCLE ELLIPSE ARC LINE ARROW SPLINE '[' /* ] */
%right '!'
%right '^'
-%type <x> expr any_expr text_expr
-%type <by> optional_by
-%type <pair> expr_pair position_not_place
-%type <if_data> simple_if
-%type <obj> nth_primitive
-%type <crn> corner
-%type <pth> path label_path relative_path
-%type <pl> place label element element_list middle_element_list
-%type <spec> object_spec
-%type <pair> position
-%type <obtype> object_type
-%type <n> optional_ordinal_last ordinal
-%type <str> until
-%type <dv> sprintf_args
-%type <lstr> text print_args print_arg
-
%%
top:
optional_separator
| element_list
- {
- if (olist.head)
- print_picture(olist.head);
- }
;
-
element_list:
optional_separator middle_element_list optional_separator
- { $$ = $2; }
;
middle_element_list:
element
- { $$ = $1; }
| middle_element_list separator element
- { $$ = $1; }
;
optional_separator:
placeless_element:
VARIABLE '=' any_expr
- {
- define_variable($1, $3);
- a_delete $1;
- }
| VARIABLE ':' '=' any_expr
- {
- place *p = lookup_label($1);
- if (!p) {
- lex_error("variable `%1' not defined", $1);
- YYABORT;
- }
- p->obj = 0;
- p->x = $4;
- p->y = 0.0;
- a_delete $1;
- }
| UP
- { current_direction = UP_DIRECTION; }
| DOWN
- { current_direction = DOWN_DIRECTION; }
| LEFT
- { current_direction = LEFT_DIRECTION; }
| RIGHT
- { current_direction = RIGHT_DIRECTION; }
| COMMAND_LINE
- {
- olist.append(make_command_object($1.str, $1.filename,
- $1.lineno));
- }
| COMMAND print_args
- {
- olist.append(make_command_object($2.str, $2.filename,
- $2.lineno));
- }
| PRINT print_args
- {
- fprintf(stderr, "%s\n", $2.str);
- a_delete $2.str;
- fflush(stderr);
- }
| SH
- { delim_flag = 1; }
+ {}
DELIMITED
- {
- delim_flag = 0;
- if (safer_flag)
- lex_error("unsafe to run command `%1'", $3);
- else
- system($3);
- a_delete $3;
- }
| COPY TEXT
- {
- if (yychar < 0)
- do_lookahead();
- do_copy($2.str);
- // do not delete the filename
- }
| COPY TEXT THRU
- { delim_flag = 2; }
- DELIMITED
- { delim_flag = 0; }
+ {}
+ DELIMITED
+ {}
until
- {
- if (yychar < 0)
- do_lookahead();
- copy_file_thru($2.str, $5, $7);
- // do not delete the filename
- a_delete $5;
- a_delete $7;
- }
| COPY THRU
- { delim_flag = 2; }
+ {}
DELIMITED
- { delim_flag = 0; }
+ {}
until
- {
- if (yychar < 0)
- do_lookahead();
- copy_rest_thru($4, $6);
- a_delete $4;
- a_delete $6;
- }
| FOR VARIABLE '=' expr TO expr optional_by DO
- { delim_flag = 1; }
+ {}
DELIMITED
- {
- delim_flag = 0;
- if (yychar < 0)
- do_lookahead();
- do_for($2, $4, $6, $7.is_multiplicative, $7.val, $10);
- }
| simple_if
- {
- if (yychar < 0)
- do_lookahead();
- if ($1.x != 0.0)
- push_body($1.body);
- a_delete $1.body;
- }
| simple_if ELSE
- { delim_flag = 1; }
+ {}
DELIMITED
- {
- delim_flag = 0;
- if (yychar < 0)
- do_lookahead();
- if ($1.x != 0.0)
- push_body($1.body);
- else
- push_body($4);
- a_delete $1.body;
- a_delete $4;
- }
| reset_variables
| RESET
- { define_variable("scale", 1.0); }
;
reset_variables:
RESET VARIABLE
- {
- reset($2);
- a_delete $2;
- }
| reset_variables VARIABLE
- {
- reset($2);
- a_delete $2;
- }
| reset_variables ',' VARIABLE
- {
- reset($3);
- a_delete $3;
- }
;
print_args:
print_arg
- { $$ = $1; }
| print_args print_arg
- {
- $$.str = new char[strlen($1.str) + strlen($2.str) + 1];
- strcpy($$.str, $1.str);
- strcat($$.str, $2.str);
- a_delete $1.str;
- a_delete $2.str;
- if ($1.filename) {
- $$.filename = $1.filename;
- $$.lineno = $1.lineno;
- }
- else if ($2.filename) {
- $$.filename = $2.filename;
- $$.lineno = $2.lineno;
- }
- }
;
print_arg:
- expr %prec ','
- {
- $$.str = new char[GDIGITS + 1];
- sprintf($$.str, "%g", $1);
- $$.filename = 0;
- $$.lineno = 0;
- }
+ expr %prec ','
| text
- { $$ = $1; }
| position %prec ','
- {
- $$.str = new char[GDIGITS + 2 + GDIGITS + 1];
- sprintf($$.str, "%g, %g", $1.x, $1.y);
- $$.filename = 0;
- $$.lineno = 0;
- }
;
simple_if:
IF any_expr THEN
- { delim_flag = 1; }
+ {}
DELIMITED
- {
- delim_flag = 0;
- $$.x = $2;
- $$.body = $5;
- }
;
until:
/* empty */
- { $$ = 0; }
| UNTIL TEXT
- { $$ = $2.str; }
;
-
+
any_expr:
expr
- { $$ = $1; }
| text_expr
- { $$ = $1; }
;
-
+
text_expr:
text EQUALEQUAL text
- {
- $$ = strcmp($1.str, $3.str) == 0;
- a_delete $1.str;
- a_delete $3.str;
- }
| text NOTEQUAL text
- {
- $$ = strcmp($1.str, $3.str) != 0;
- a_delete $1.str;
- a_delete $3.str;
- }
| text_expr ANDAND text_expr
- { $$ = ($1 != 0.0 && $3 != 0.0); }
| text_expr ANDAND expr
- { $$ = ($1 != 0.0 && $3 != 0.0); }
| expr ANDAND text_expr
- { $$ = ($1 != 0.0 && $3 != 0.0); }
| text_expr OROR text_expr
- { $$ = ($1 != 0.0 || $3 != 0.0); }
| text_expr OROR expr
- { $$ = ($1 != 0.0 || $3 != 0.0); }
| expr OROR text_expr
- { $$ = ($1 != 0.0 || $3 != 0.0); }
| '!' text_expr
- { $$ = ($2 == 0.0); }
;
-
optional_by:
/* empty */
- {
- $$.val = 1.0;
- $$.is_multiplicative = 0;
- }
| BY expr
- {
- $$.val = $2;
- $$.is_multiplicative = 0;
- }
| BY '*' expr
- {
- $$.val = $3;
- $$.is_multiplicative = 1;
- }
;
element:
object_spec
- {
- $$.obj = $1->make_object(¤t_position,
- ¤t_direction);
- if ($$.obj == 0)
- YYABORT;
- delete $1;
- if ($$.obj)
- olist.append($$.obj);
- else {
- $$.x = current_position.x;
- $$.y = current_position.y;
- }
- }
| LABEL ':' optional_separator element
- {
- $$ = $4;
- define_label($1, & $$);
- a_delete $1;
- }
| LABEL ':' optional_separator position_not_place
- {
- $$.obj = 0;
- $$.x = $4.x;
- $$.y = $4.y;
- define_label($1, & $$);
- a_delete $1;
- }
| LABEL ':' optional_separator place
- {
- $$ = $4;
- define_label($1, & $$);
- a_delete $1;
- }
- | '{'
- {
- $<state>$.x = current_position.x;
- $<state>$.y = current_position.y;
- $<state>$.dir = current_direction;
- }
- element_list '}'
- {
- current_position.x = $<state>2.x;
- current_position.y = $<state>2.y;
- current_direction = $<state>2.dir;
- }
+ | '{' {} element_list '}'
+ {}
optional_element
- {
- $$ = $3;
- }
| placeless_element
- {
- $$.obj = 0;
- $$.x = current_position.x;
- $$.y = current_position.y;
- }
;
optional_element:
/* empty */
- {}
| element
- {}
;
object_spec:
BOX
- { $$ = new object_spec(BOX_OBJECT); }
| CIRCLE
- { $$ = new object_spec(CIRCLE_OBJECT); }
| ELLIPSE
- { $$ = new object_spec(ELLIPSE_OBJECT); }
| ARC
- {
- $$ = new object_spec(ARC_OBJECT);
- $$->dir = current_direction;
- }
| LINE
- {
- $$ = new object_spec(LINE_OBJECT);
- lookup_variable("lineht", & $$->segment_height);
- lookup_variable("linewid", & $$->segment_width);
- $$->dir = current_direction;
- }
| ARROW
- {
- $$ = new object_spec(ARROW_OBJECT);
- lookup_variable("lineht", & $$->segment_height);
- lookup_variable("linewid", & $$->segment_width);
- $$->dir = current_direction;
- }
| MOVE
- {
- $$ = new object_spec(MOVE_OBJECT);
- lookup_variable("moveht", & $$->segment_height);
- lookup_variable("movewid", & $$->segment_width);
- $$->dir = current_direction;
- }
| SPLINE
- {
- $$ = new object_spec(SPLINE_OBJECT);
- lookup_variable("lineht", & $$->segment_height);
- lookup_variable("linewid", & $$->segment_width);
- $$->dir = current_direction;
- }
| text %prec TEXT
- {
- $$ = new object_spec(TEXT_OBJECT);
- $$->text = new text_item($1.str, $1.filename, $1.lineno);
- }
| PLOT expr
- {
- $$ = new object_spec(TEXT_OBJECT);
- $$->text = new text_item(format_number(0, $2), 0, -1);
- }
| PLOT expr text
- {
- $$ = new object_spec(TEXT_OBJECT);
- $$->text = new text_item(format_number($3.str, $2),
- $3.filename, $3.lineno);
- a_delete $3.str;
- }
- | '['
- {
- saved_state *p = new saved_state;
- $<pstate>$ = p;
- p->x = current_position.x;
- p->y = current_position.y;
- p->dir = current_direction;
- p->tbl = current_table;
- p->prev = current_saved_state;
- current_position.x = 0.0;
- current_position.y = 0.0;
- current_table = new PTABLE(place);
- current_saved_state = p;
- olist.append(make_mark_object());
- }
+ | '['
+ {}
element_list ']'
- {
- current_position.x = $<pstate>2->x;
- current_position.y = $<pstate>2->y;
- current_direction = $<pstate>2->dir;
- $$ = new object_spec(BLOCK_OBJECT);
- olist.wrap_up_block(& $$->oblist);
- $$->tbl = current_table;
- current_table = $<pstate>2->tbl;
- current_saved_state = $<pstate>2->prev;
- delete $<pstate>2;
- }
| object_spec HEIGHT expr
- {
- $$ = $1;
- $$->height = $3;
- $$->flags |= HAS_HEIGHT;
- }
| object_spec RADIUS expr
- {
- $$ = $1;
- $$->radius = $3;
- $$->flags |= HAS_RADIUS;
- }
| object_spec WIDTH expr
- {
- $$ = $1;
- $$->width = $3;
- $$->flags |= HAS_WIDTH;
- }
| object_spec DIAMETER expr
- {
- $$ = $1;
- $$->radius = $3/2.0;
- $$->flags |= HAS_RADIUS;
- }
| object_spec expr %prec HEIGHT
- {
- $$ = $1;
- $$->flags |= HAS_SEGMENT;
- switch ($$->dir) {
- case UP_DIRECTION:
- $$->segment_pos.y += $2;
- break;
- case DOWN_DIRECTION:
- $$->segment_pos.y -= $2;
- break;
- case RIGHT_DIRECTION:
- $$->segment_pos.x += $2;
- break;
- case LEFT_DIRECTION:
- $$->segment_pos.x -= $2;
- break;
- }
- }
| object_spec UP
- {
- $$ = $1;
- $$->dir = UP_DIRECTION;
- $$->flags |= HAS_SEGMENT;
- $$->segment_pos.y += $$->segment_height;
- }
| object_spec UP expr
- {
- $$ = $1;
- $$->dir = UP_DIRECTION;
- $$->flags |= HAS_SEGMENT;
- $$->segment_pos.y += $3;
- }
| object_spec DOWN
- {
- $$ = $1;
- $$->dir = DOWN_DIRECTION;
- $$->flags |= HAS_SEGMENT;
- $$->segment_pos.y -= $$->segment_height;
- }
| object_spec DOWN expr
- {
- $$ = $1;
- $$->dir = DOWN_DIRECTION;
- $$->flags |= HAS_SEGMENT;
- $$->segment_pos.y -= $3;
- }
| object_spec RIGHT
- {
- $$ = $1;
- $$->dir = RIGHT_DIRECTION;
- $$->flags |= HAS_SEGMENT;
- $$->segment_pos.x += $$->segment_width;
- }
| object_spec RIGHT expr
- {
- $$ = $1;
- $$->dir = RIGHT_DIRECTION;
- $$->flags |= HAS_SEGMENT;
- $$->segment_pos.x += $3;
- }
| object_spec LEFT
- {
- $$ = $1;
- $$->dir = LEFT_DIRECTION;
- $$->flags |= HAS_SEGMENT;
- $$->segment_pos.x -= $$->segment_width;
- }
| object_spec LEFT expr
- {
- $$ = $1;
- $$->dir = LEFT_DIRECTION;
- $$->flags |= HAS_SEGMENT;
- $$->segment_pos.x -= $3;
- }
| object_spec FROM position
- {
- $$ = $1;
- $$->flags |= HAS_FROM;
- $$->from.x = $3.x;
- $$->from.y = $3.y;
- }
| object_spec TO position
- {
- $$ = $1;
- if ($$->flags & HAS_SEGMENT)
- $$->segment_list = new segment($$->segment_pos,
- $$->segment_is_absolute,
- $$->segment_list);
- $$->flags |= HAS_SEGMENT;
- $$->segment_pos.x = $3.x;
- $$->segment_pos.y = $3.y;
- $$->segment_is_absolute = 1;
- $$->flags |= HAS_TO;
- $$->to.x = $3.x;
- $$->to.y = $3.y;
- }
| object_spec AT position
- {
- $$ = $1;
- $$->flags |= HAS_AT;
- $$->at.x = $3.x;
- $$->at.y = $3.y;
- if ($$->type != ARC_OBJECT) {
- $$->flags |= HAS_FROM;
- $$->from.x = $3.x;
- $$->from.y = $3.y;
- }
- }
| object_spec WITH path
- {
- $$ = $1;
- $$->flags |= HAS_WITH;
- $$->with = $3;
- }
| object_spec WITH position %prec ','
- {
- $$ = $1;
- $$->flags |= HAS_WITH;
- position pos;
- pos.x = $3.x;
- pos.y = $3.y;
- $$->with = new path(pos);
- }
| object_spec BY expr_pair
- {
- $$ = $1;
- $$->flags |= HAS_SEGMENT;
- $$->segment_pos.x += $3.x;
- $$->segment_pos.y += $3.y;
- }
| object_spec THEN
- {
- $$ = $1;
- if ($$->flags & HAS_SEGMENT) {
- $$->segment_list = new segment($$->segment_pos,
- $$->segment_is_absolute,
- $$->segment_list);
- $$->flags &= ~HAS_SEGMENT;
- $$->segment_pos.x = $$->segment_pos.y = 0.0;
- $$->segment_is_absolute = 0;
- }
- }
| object_spec SOLID
- {
- $$ = $1; // nothing
- }
| object_spec DOTTED
- {
- $$ = $1;
- $$->flags |= IS_DOTTED;
- lookup_variable("dashwid", & $$->dash_width);
- }
| object_spec DOTTED expr
- {
- $$ = $1;
- $$->flags |= IS_DOTTED;
- $$->dash_width = $3;
- }
| object_spec DASHED
- {
- $$ = $1;
- $$->flags |= IS_DASHED;
- lookup_variable("dashwid", & $$->dash_width);
- }
| object_spec DASHED expr
- {
- $$ = $1;
- $$->flags |= IS_DASHED;
- $$->dash_width = $3;
- }
| object_spec FILL
- {
- $$ = $1;
- $$->flags |= IS_DEFAULT_FILLED;
- }
| object_spec FILL expr
- {
- $$ = $1;
- $$->flags |= IS_FILLED;
- $$->fill = $3;
- }
| object_spec SHADED text
- {
- $$ = $1;
- $$->flags |= (IS_SHADED | IS_FILLED);
- $$->shaded = new char[strlen($3.str)+1];
- strcpy($$->shaded, $3.str);
- }
| object_spec COLORED text
- {
- $$ = $1;
- $$->flags |= (IS_SHADED | IS_OUTLINED | IS_FILLED);
- $$->shaded = new char[strlen($3.str)+1];
- strcpy($$->shaded, $3.str);
- $$->outlined = new char[strlen($3.str)+1];
- strcpy($$->outlined, $3.str);
- }
| object_spec OUTLINED text
- {
- $$ = $1;
- $$->flags |= IS_OUTLINED;
- $$->outlined = new char[strlen($3.str)+1];
- strcpy($$->outlined, $3.str);
- }
| object_spec CHOP
- {
- $$ = $1;
- // line chop chop means line chop 0 chop 0
- if ($$->flags & IS_DEFAULT_CHOPPED) {
- $$->flags |= IS_CHOPPED;
- $$->flags &= ~IS_DEFAULT_CHOPPED;
- $$->start_chop = $$->end_chop = 0.0;
- }
- else if ($$->flags & IS_CHOPPED) {
- $$->end_chop = 0.0;
- }
- else {
- $$->flags |= IS_DEFAULT_CHOPPED;
- }
- }
| object_spec CHOP expr
- {
- $$ = $1;
- if ($$->flags & IS_DEFAULT_CHOPPED) {
- $$->flags |= IS_CHOPPED;
- $$->flags &= ~IS_DEFAULT_CHOPPED;
- $$->start_chop = 0.0;
- $$->end_chop = $3;
- }
- else if ($$->flags & IS_CHOPPED) {
- $$->end_chop = $3;
- }
- else {
- $$->start_chop = $$->end_chop = $3;
- $$->flags |= IS_CHOPPED;
- }
- }
| object_spec SAME
- {
- $$ = $1;
- $$->flags |= IS_SAME;
- }
| object_spec INVISIBLE
- {
- $$ = $1;
- $$->flags |= IS_INVISIBLE;
- }
| object_spec LEFT_ARROW_HEAD
- {
- $$ = $1;
- $$->flags |= HAS_LEFT_ARROW_HEAD;
- }
| object_spec RIGHT_ARROW_HEAD
- {
- $$ = $1;
- $$->flags |= HAS_RIGHT_ARROW_HEAD;
- }
| object_spec DOUBLE_ARROW_HEAD
- {
- $$ = $1;
- $$->flags |= (HAS_LEFT_ARROW_HEAD|HAS_RIGHT_ARROW_HEAD);
- }
| object_spec CW
- {
- $$ = $1;
- $$->flags |= IS_CLOCKWISE;
- }
| object_spec CCW
- {
- $$ = $1;
- $$->flags &= ~IS_CLOCKWISE;
- }
| object_spec text %prec TEXT
- {
- $$ = $1;
- text_item **p;
- for (p = & $$->text; *p; p = &(*p)->next)
- ;
- *p = new text_item($2.str, $2.filename, $2.lineno);
- }
| object_spec LJUST
- {
- $$ = $1;
- if ($$->text) {
- text_item *p;
- for (p = $$->text; p->next; p = p->next)
- ;
- p->adj.h = LEFT_ADJUST;
- }
- }
| object_spec RJUST
- {
- $$ = $1;
- if ($$->text) {
- text_item *p;
- for (p = $$->text; p->next; p = p->next)
- ;
- p->adj.h = RIGHT_ADJUST;
- }
- }
| object_spec ABOVE
- {
- $$ = $1;
- if ($$->text) {
- text_item *p;
- for (p = $$->text; p->next; p = p->next)
- ;
- p->adj.v = ABOVE_ADJUST;
- }
- }
| object_spec BELOW
- {
- $$ = $1;
- if ($$->text) {
- text_item *p;
- for (p = $$->text; p->next; p = p->next)
- ;
- p->adj.v = BELOW_ADJUST;
- }
- }
| object_spec THICKNESS expr
- {
- $$ = $1;
- $$->flags |= HAS_THICKNESS;
- $$->thickness = $3;
- }
| object_spec ALIGNED
- {
- $$ = $1;
- $$->flags |= IS_ALIGNED;
- }
;
text:
TEXT
- { $$ = $1; }
| SPRINTF '(' TEXT sprintf_args ')'
- {
- $$.filename = $3.filename;
- $$.lineno = $3.lineno;
- $$.str = do_sprintf($3.str, $4.v, $4.nv);
- a_delete $4.v;
- a_delete $3.str;
- }
;
sprintf_args:
/* empty */
- {
- $$.v = 0;
- $$.nv = 0;
- $$.maxv = 0;
- }
| sprintf_args ',' expr
- {
- $$ = $1;
- if ($$.nv >= $$.maxv) {
- if ($$.nv == 0) {
- $$.v = new double[4];
- $$.maxv = 4;
- }
- else {
- double *oldv = $$.v;
- $$.maxv *= 2;
- $$.v = new double[$$.maxv];
- memcpy($$.v, oldv, $$.nv*sizeof(double));
- a_delete oldv;
- }
- }
- $$.v[$$.nv] = $3;
- $$.nv += 1;
- }
;
position:
- position_not_place
- { $$ = $1; }
+ position_not_place
| place
- {
- position pos = $1;
- $$.x = pos.x;
- $$.y = pos.y;
- }
;
position_not_place:
expr_pair
- { $$ = $1; }
| position '+' expr_pair
- {
- $$.x = $1.x + $3.x;
- $$.y = $1.y + $3.y;
- }
| position '-' expr_pair
- {
- $$.x = $1.x - $3.x;
- $$.y = $1.y - $3.y;
- }
| '(' position ',' position ')'
- {
- $$.x = $2.x;
- $$.y = $4.y;
- }
| expr between position AND position
- {
- $$.x = (1.0 - $1)*$3.x + $1*$5.x;
- $$.y = (1.0 - $1)*$3.y + $1*$5.y;
- }
| expr '<' position ',' position '>'
- {
- $$.x = (1.0 - $1)*$3.x + $1*$5.x;
- $$.y = (1.0 - $1)*$3.y + $1*$5.y;
- }
;
between:
expr_pair:
expr ',' expr
- {
- $$.x = $1;
- $$.y = $3;
- }
| '(' expr_pair ')'
- { $$ = $2; }
;
place:
/* line at A left == line (at A) left */
label %prec CHOP
- { $$ = $1; }
| label corner
- {
- path pth($2);
- if (!pth.follow($1, & $$))
- YYABORT;
- }
| corner label
- {
- path pth($1);
- if (!pth.follow($2, & $$))
- YYABORT;
- }
| corner OF label
- {
- path pth($1);
- if (!pth.follow($3, & $$))
- YYABORT;
- }
| HERE
- {
- $$.x = current_position.x;
- $$.y = current_position.y;
- $$.obj = 0;
- }
;
label:
LABEL
- {
- place *p = lookup_label($1);
- if (!p) {
- lex_error("there is no place `%1'", $1);
- YYABORT;
- }
- $$ = *p;
- a_delete $1;
- }
| nth_primitive
- { $$.obj = $1; }
| label '.' LABEL
- {
- path pth($3);
- if (!pth.follow($1, & $$))
- YYABORT;
- }
;
ordinal:
ORDINAL
- { $$ = $1; }
| '`' any_expr TH
- {
- // XXX Check for overflow (and non-integers?).
- $$ = (int)$2;
- }
;
optional_ordinal_last:
LAST
- { $$ = 1; }
- | ordinal LAST
- { $$ = $1; }
+ | ordinal LAST
;
nth_primitive:
ordinal object_type
- {
- int count = 0;
- object *p;
- for (p = olist.head; p != 0; p = p->next)
- if (p->type() == $2 && ++count == $1) {
- $$ = p;
- break;
- }
- if (p == 0) {
- lex_error("there is no %1%2 %3", $1, ordinal_postfix($1),
- object_type_name($2));
- YYABORT;
- }
- }
| optional_ordinal_last object_type
- {
- int count = 0;
- object *p;
- for (p = olist.tail; p != 0; p = p->prev)
- if (p->type() == $2 && ++count == $1) {
- $$ = p;
- break;
- }
- if (p == 0) {
- lex_error("there is no %1%2 last %3", $1,
- ordinal_postfix($1), object_type_name($2));
- YYABORT;
- }
- }
;
object_type:
BOX
- { $$ = BOX_OBJECT; }
| CIRCLE
- { $$ = CIRCLE_OBJECT; }
| ELLIPSE
- { $$ = ELLIPSE_OBJECT; }
| ARC
- { $$ = ARC_OBJECT; }
| LINE
- { $$ = LINE_OBJECT; }
| ARROW
- { $$ = ARROW_OBJECT; }
| SPLINE
- { $$ = SPLINE_OBJECT; }
| '[' ']'
- { $$ = BLOCK_OBJECT; }
| TEXT
- { $$ = TEXT_OBJECT; }
;
label_path:
- '.' LABEL
- { $$ = new path($2); }
+ '.' LABEL
| label_path '.' LABEL
- {
- $$ = $1;
- $$->append($3);
- }
;
relative_path:
corner %prec CHOP
- { $$ = new path($1); }
/* give this a lower precedence than LEFT and RIGHT so that
[A: box] with .A left == [A: box] with (.A left) */
- | label_path %prec TEXT
- { $$ = $1; }
+ | label_path %prec TEXT
| label_path corner
- {
- $$ = $1;
- $$->append($2);
- }
;
path:
relative_path
- { $$ = $1; }
| '(' relative_path ',' relative_path ')'
- {
- $$ = $2;
- $$->set_ypath($4);
- }
+ {}
/* The rest of these rules are a compatibility sop. */
| ORDINAL LAST object_type relative_path
- {
- lex_warning("`%1%2 last %3' in `with' argument ignored",
- $1, ordinal_postfix($1), object_type_name($3));
- $$ = $4;
- }
| LAST object_type relative_path
- {
- lex_warning("`last %1' in `with' argument ignored",
- object_type_name($2));
- $$ = $3;
- }
| ORDINAL object_type relative_path
- {
- lex_warning("`%1%2 %3' in `with' argument ignored",
- $1, ordinal_postfix($1), object_type_name($2));
- $$ = $3;
- }
| LABEL relative_path
- {
- lex_warning("initial `%1' in `with' argument ignored", $1);
- a_delete $1;
- $$ = $2;
- }
;
corner:
DOT_N
- { $$ = &object::north; }
- | DOT_E
- { $$ = &object::east; }
+ | DOT_E
| DOT_W
- { $$ = &object::west; }
| DOT_S
- { $$ = &object::south; }
| DOT_NE
- { $$ = &object::north_east; }
| DOT_SE
- { $$ = &object:: south_east; }
| DOT_NW
- { $$ = &object::north_west; }
| DOT_SW
- { $$ = &object::south_west; }
| DOT_C
- { $$ = &object::center; }
| DOT_START
- { $$ = &object::start; }
| DOT_END
- { $$ = &object::end; }
- | TOP
- { $$ = &object::north; }
+ | TOP
| BOTTOM
- { $$ = &object::south; }
| LEFT
- { $$ = &object::west; }
| RIGHT
- { $$ = &object::east; }
| UPPER LEFT
- { $$ = &object::north_west; }
| LOWER LEFT
- { $$ = &object::south_west; }
| UPPER RIGHT
- { $$ = &object::north_east; }
| LOWER RIGHT
- { $$ = &object::south_east; }
| LEFT_CORNER
- { $$ = &object::west; }
| RIGHT_CORNER
- { $$ = &object::east; }
| UPPER LEFT_CORNER
- { $$ = &object::north_west; }
| LOWER LEFT_CORNER
- { $$ = &object::south_west; }
| UPPER RIGHT_CORNER
- { $$ = &object::north_east; }
| LOWER RIGHT_CORNER
- { $$ = &object::south_east; }
| NORTH
- { $$ = &object::north; }
| SOUTH
- { $$ = &object::south; }
| EAST
- { $$ = &object::east; }
| WEST
- { $$ = &object::west; }
| CENTER
- { $$ = &object::center; }
| START
- { $$ = &object::start; }
| END
- { $$ = &object::end; }
;
expr:
VARIABLE
- {
- if (!lookup_variable($1, & $$)) {
- lex_error("there is no variable `%1'", $1);
- YYABORT;
- }
- a_delete $1;
- }
| NUMBER
- { $$ = $1; }
| place DOT_X
- {
- if ($1.obj != 0)
- $$ = $1.obj->origin().x;
- else
- $$ = $1.x;
- }
| place DOT_Y
- {
- if ($1.obj != 0)
- $$ = $1.obj->origin().y;
- else
- $$ = $1.y;
- }
| place DOT_HT
- {
- if ($1.obj != 0)
- $$ = $1.obj->height();
- else
- $$ = 0.0;
- }
| place DOT_WID
- {
- if ($1.obj != 0)
- $$ = $1.obj->width();
- else
- $$ = 0.0;
- }
| place DOT_RAD
- {
- if ($1.obj != 0)
- $$ = $1.obj->radius();
- else
- $$ = 0.0;
- }
| expr '+' expr
- { $$ = $1 + $3; }
| expr '-' expr
- { $$ = $1 - $3; }
| expr '*' expr
- { $$ = $1 * $3; }
| expr '/' expr
- {
- if ($3 == 0.0) {
- lex_error("division by zero");
- YYABORT;
- }
- $$ = $1/$3;
- }
| expr '%' expr
- {
- if ($3 == 0.0) {
- lex_error("modulus by zero");
- YYABORT;
- }
- $$ = fmod($1, $3);
- }
| expr '^' expr
- {
- errno = 0;
- $$ = pow($1, $3);
- if (errno == EDOM) {
- lex_error("arguments to `^' operator out of domain");
- YYABORT;
- }
- if (errno == ERANGE) {
- lex_error("result of `^' operator out of range");
- YYABORT;
- }
- }
| '-' expr %prec '!'
- { $$ = -$2; }
| '(' any_expr ')'
- { $$ = $2; }
| SIN '(' any_expr ')'
- {
- errno = 0;
- $$ = sin($3);
- if (errno == ERANGE) {
- lex_error("sin result out of range");
- YYABORT;
- }
- }
| COS '(' any_expr ')'
- {
- errno = 0;
- $$ = cos($3);
- if (errno == ERANGE) {
- lex_error("cos result out of range");
- YYABORT;
- }
- }
| ATAN2 '(' any_expr ',' any_expr ')'
- {
- errno = 0;
- $$ = atan2($3, $5);
- if (errno == EDOM) {
- lex_error("atan2 argument out of domain");
- YYABORT;
- }
- if (errno == ERANGE) {
- lex_error("atan2 result out of range");
- YYABORT;
- }
- }
| LOG '(' any_expr ')'
- {
- errno = 0;
- $$ = log10($3);
- if (errno == ERANGE) {
- lex_error("log result out of range");
- YYABORT;
- }
- }
| EXP '(' any_expr ')'
- {
- errno = 0;
- $$ = pow(10.0, $3);
- if (errno == ERANGE) {
- lex_error("exp result out of range");
- YYABORT;
- }
- }
| SQRT '(' any_expr ')'
- {
- errno = 0;
- $$ = sqrt($3);
- if (errno == EDOM) {
- lex_error("sqrt argument out of domain");
- YYABORT;
- }
- }
| K_MAX '(' any_expr ',' any_expr ')'
- { $$ = $3 > $5 ? $3 : $5; }
| K_MIN '(' any_expr ',' any_expr ')'
- { $$ = $3 < $5 ? $3 : $5; }
| INT '(' any_expr ')'
- { $$ = floor($3); }
| RAND '(' any_expr ')'
- { $$ = 1.0 + floor(((rand()&0x7fff)/double(0x7fff))*$3); }
| RAND '(' ')'
- {
- /* return a random number in the range >=0, <1 */
- /* portable, but not very random */
- $$ = (rand() & 0x7fff) / double(0x8000);
- }
| SRAND '(' any_expr ')'
- {
- $$ = 0;
- srand((unsigned int)$3);
- }
| expr '<' expr
- { $$ = ($1 < $3); }
| expr LESSEQUAL expr
- { $$ = ($1 <= $3); }
| expr '>' expr
- { $$ = ($1 > $3); }
| expr GREATEREQUAL expr
- { $$ = ($1 >= $3); }
| expr EQUALEQUAL expr
- { $$ = ($1 == $3); }
| expr NOTEQUAL expr
- { $$ = ($1 != $3); }
| expr ANDAND expr
- { $$ = ($1 != 0.0 && $3 != 0.0); }
| expr OROR expr
- { $$ = ($1 != 0.0 || $3 != 0.0); }
| '!' expr
- { $$ = ($2 == 0.0); }
-
;
]])
# 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, [], [])
+AT_BISON_CHECK([[--verbose --defines input.y]], 0, [],
+[[input.y:453.11-48: warning: rule useless in parser due to conflicts: path: ORDINAL LAST object_type relative_path
+]])
AT_CLEANUP
projects / bison.git / blobdiff