X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/2740f1691fb5c38a2538a3f30fa85b79d119beb5..62e5fc6ac9bd59f801ca43e7eb81d19960f3e306:/tests/existing.at?ds=sidebyside diff --git a/tests/existing.at b/tests/existing.at index fcb1af04..a34f9238 100644 --- a/tests/existing.at +++ b/tests/existing.at @@ -1,39 +1,80 @@ # Exercising Bison on actual grammars. -*- Autotest -*- -# Copyright (C) 1989, 1990, 1991, 1992, 2000, 2001, 2002, 2003 -# Free Software Foundation, Inc. +# Copyright (C) 1989-1992, 2000-2005, 2007, 2009-2012 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 . AT_BANNER([[Existing Grammars.]]) -## ----------------- ## -## GNU AWK Grammar. ## -## ----------------- ## -AT_SETUP([GNU AWK Grammar]) +# AT_TEST_EXISTING_GRAMMAR(DESCRIPTION, +# DECLS, GRAMMAR, INPUT, +# BISON-STDERR, LAST-STATE, LALR1-DIFF, +# [OTHER-CHECKS], +# [PARSER-EXIT-VALUE], +# [PARSER-STDOUT], [PARSER-STDERR]) +# -------------------------------------------------------------- +m4_define([AT_TEST_EXISTING_GRAMMAR], [_AT_TEST_EXISTING_GRAMMAR([$][1], $@)]) + +m4_define([_AT_TEST_EXISTING_GRAMMAR], +[ +dnl See how the parser tables have changed. As the .output format evolves, the +dnl diff comments with line numbers might be a pain to maintain. When that +dnl time comes, just use sed to drop the line numbers. For now, as LR(1) +dnl support is rapidly evolving, let's keep that information to be careful. +dnl However, we don't do diffs for canonical LR(1) because the diff is huge. +m4_pushdef([AT_LALR1_DIFF_CHECK], +[AT_CHECK([[sed 's/^%define lr.type .*$//' input.y > input-lalr.y]]) +AT_BISON_CHECK([[--report=all input-lalr.y]], [[0]], [ignore], [ignore]) +AT_CHECK([[diff -u input-lalr.output input.output \ + | sed -n '/^@@/,$p' | sed 's/^ $//']], + [[0]], [$1])]) + +AT_TEST_TABLES_AND_PARSE([$2[: LALR(1)]], [[LALR]], [[last-state]], + [[%define lr.type lalr +]$3], + [$4], [$5], [$6], [$7], + [AT_LALR1_DIFF_CHECK([$8])$9], [$10], [$11], [$12]) +AT_TEST_TABLES_AND_PARSE([$2[: IELR(1)]], [[IELR]], [[last-state]], + [[%define lr.type ielr +]$3], + [$4], [$5], [$6], [$7], + [AT_LALR1_DIFF_CHECK([$8])$9], [$10], [$11], [$12]) +AT_TEST_TABLES_AND_PARSE([$2[: Canonical LR(1)]], [[canonical LR]], + [[last-state,no-xml]], + [[%define lr.type canonical-lr +]$3], + [$4], [$5], [$6], [$7], + [$9], [$10], [$11], [$12]) + +m4_popdef([AT_LALR1_DIFF_CHECK]) +]) + + + +## ----------------------- ## +## GNU AWK 3.1.0 Grammar. ## +## ----------------------- ## # We have been careful to strip all the actions excepts the -# mid-rule actions. We rely on %expect to check that there are -# indeed 65 SR conflicts. +# mid-rule actions. # -# Bison was once wrong, due to an incorrect computation of nullable. -# It reported 485 SR conflicts! +# There are 65 SR conflicts. Bison was once wrong, due to an incorrect +# computation of nullable. It reported 485 SR conflicts! -AT_DATA([[input.y]], -[[%expect 65 +AT_TEST_EXISTING_GRAMMAR([[GNU AWK 3.1.0 Grammar]], +[[%error-verbose %token FUNC_CALL NAME REGEXP %token ERROR @@ -68,8 +109,8 @@ AT_DATA([[input.y]], %left INCREMENT DECREMENT %left '$' %left '(' ')' -%% - +]], +[[ start : opt_nls program opt_nls ; @@ -113,7 +154,6 @@ function_body | l_brace r_brace opt_semi opt_nls ; - pattern : exp | exp ',' exp @@ -347,81 +387,434 @@ semi comma : ',' opt_nls ; - -%% -]]) - -# 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_CLEANUP - +]], + +dnl INPUT +dnl +dnl For example, in AWK: +dnl +dnl getline $!4*0; +dnl +dnl The grammar below (from GNU AWK 3.1.0) using canonical LR(1) or IELR(1) +dnl parses it as: +dnl +dnl getline $!(4*0); +dnl +dnl That is, they shift `*' immediately and make it part of the getline +dnl argument. +dnl +dnl The grammar below using LALR(1) parses it as a syntax error. So does +dnl GNU AWK 3.0.6, 3.1.0, and 3.1.1. They reduce the full getline expression +dnl before shifting `*' even though `*' is not a valid lookahead. +dnl +dnl GNU AWK 3.1.2, 3.1.3, 3.1.4, and 3.1.5 parse it as: +dnl +dnl (getline $!4)*0; +dnl +dnl That is, like the other versions of GNU AWK, they reduce the full getline +dnl expression before shifting `*'. However, because of a different LHS on the +dnl getline rule, `*' actually is a valid lookahead. Solaris /usr/xpg4/bin/awk +dnl and the Open Group awk specification seem to agree: +dnl +dnl http://www.opengroup.org/pubs/online/7908799/xcu/awk.html +dnl +dnl /bin/nawk and /bin/awk on Solaris 10 report it as a syntax error, but they +dnl don't like even `print $!4;'. +[[LEX_GETLINE, '$', '!', YNUMBER, '*', YNUMBER, ';']], + +dnl BISON-STDERR +[AT_COND_CASE([[canonical LR]], +[[input.y: conflicts: 265 shift/reduce]], +[[input.y: conflicts: 65 shift/reduce]])[ +]], + +dnl LAST-STATE +[AT_COND_CASE([[LALR]], [[319]], [[canonical LR]], [[2358]], [[328]])], + +dnl LALR1-DIFF not used for canonical LR(1) because the diff is huge. +dnl Isocore map from LALR(1) state number to new state number plus descriptions +dnl of any change in the actions resulting in a change in accepted language: +dnl - 24 -> 320 +dnl - 16 -> 321 +dnl - 17 -> 322 +dnl - 20 -> 323 +dnl - 21 -> 324 +dnl - 54 -> 325 +dnl - 56 -> 326: reduce -> shift on '*', '/', and '%' +dnl - 58 -> 327: reduce -> shift on '*', '/', and '%' +dnl - 61 -> 328: reduce -> shift on '*', '/', and '%' +[AT_COND_CASE([[LALR]], [], +[[@@ -712,7 +712,7 @@ + 156 | . '$' non_post_simp_exp + + NAME shift, and go to state 9 +- '$' shift, and go to state 24 ++ '$' shift, and go to state 320 + + NAME [reduce using rule 152 (opt_variable)] + '$' [reduce using rule 152 (opt_variable)] +@@ -5379,7 +5379,7 @@ + 156 | . '$' non_post_simp_exp + + NAME shift, and go to state 9 +- '$' shift, and go to state 24 ++ '$' shift, and go to state 320 + + NAME [reduce using rule 152 (opt_variable)] + '$' [reduce using rule 152 (opt_variable)] +@@ -5399,7 +5399,7 @@ + 156 | . '$' non_post_simp_exp + + NAME shift, and go to state 9 +- '$' shift, and go to state 24 ++ '$' shift, and go to state 320 + + NAME [reduce using rule 152 (opt_variable)] + '$' [reduce using rule 152 (opt_variable)] +@@ -6214,7 +6214,7 @@ + 156 | . '$' non_post_simp_exp + + NAME shift, and go to state 9 +- '$' shift, and go to state 24 ++ '$' shift, and go to state 320 + + NAME [reduce using rule 152 (opt_variable)] + '$' [reduce using rule 152 (opt_variable)] +@@ -11099,3 +11099,274 @@ + 45 statement: LEX_FOR '(' opt_exp semi opt_nls exp semi opt_nls opt_exp r_paren opt_nls statement . + + $default reduce using rule 45 (statement) ++ ++ ++state 320 ++ ++ 139 non_post_simp_exp: . '!' simp_exp ++ 140 | . '(' exp r_paren ++ 141 | . LEX_BUILTIN '(' opt_expression_list r_paren ++ 142 | . LEX_LENGTH '(' opt_expression_list r_paren ++ 143 | . LEX_LENGTH ++ 144 | . FUNC_CALL '(' opt_expression_list r_paren ++ 145 | . variable ++ 146 | . INCREMENT variable ++ 147 | . DECREMENT variable ++ 148 | . YNUMBER ++ 149 | . YSTRING ++ 150 | . '-' simp_exp ++ 151 | . '+' simp_exp ++ 154 variable: . NAME ++ 155 | . NAME '[' expression_list ']' ++ 156 | . '$' non_post_simp_exp ++ 156 | '$' . non_post_simp_exp ++ ++ FUNC_CALL shift, and go to state 8 ++ NAME shift, and go to state 9 ++ YNUMBER shift, and go to state 10 ++ YSTRING shift, and go to state 11 ++ INCREMENT shift, and go to state 321 ++ DECREMENT shift, and go to state 322 ++ LEX_BUILTIN shift, and go to state 18 ++ LEX_LENGTH shift, and go to state 19 ++ '+' shift, and go to state 323 ++ '-' shift, and go to state 324 ++ '!' shift, and go to state 325 ++ '$' shift, and go to state 320 ++ '(' shift, and go to state 55 ++ ++ non_post_simp_exp go to state 62 ++ variable go to state 63 ++ ++ ++state 321 ++ ++ 146 non_post_simp_exp: INCREMENT . variable ++ 154 variable: . NAME ++ 155 | . NAME '[' expression_list ']' ++ 156 | . '$' non_post_simp_exp ++ ++ NAME shift, and go to state 9 ++ '$' shift, and go to state 320 ++ ++ variable go to state 50 ++ ++ ++state 322 ++ ++ 147 non_post_simp_exp: DECREMENT . variable ++ 154 variable: . NAME ++ 155 | . NAME '[' expression_list ']' ++ 156 | . '$' non_post_simp_exp ++ ++ NAME shift, and go to state 9 ++ '$' shift, and go to state 320 ++ ++ variable go to state 51 ++ ++ ++state 323 ++ ++ 130 simp_exp: . non_post_simp_exp ++ 131 | . simp_exp '^' simp_exp ++ 132 | . simp_exp '*' simp_exp ++ 133 | . simp_exp '/' simp_exp ++ 134 | . simp_exp '%' simp_exp ++ 135 | . simp_exp '+' simp_exp ++ 136 | . simp_exp '-' simp_exp ++ 137 | . variable INCREMENT ++ 138 | . variable DECREMENT ++ 139 non_post_simp_exp: . '!' simp_exp ++ 140 | . '(' exp r_paren ++ 141 | . LEX_BUILTIN '(' opt_expression_list r_paren ++ 142 | . LEX_LENGTH '(' opt_expression_list r_paren ++ 143 | . LEX_LENGTH ++ 144 | . FUNC_CALL '(' opt_expression_list r_paren ++ 145 | . variable ++ 146 | . INCREMENT variable ++ 147 | . DECREMENT variable ++ 148 | . YNUMBER ++ 149 | . YSTRING ++ 150 | . '-' simp_exp ++ 151 | . '+' simp_exp ++ 151 | '+' . simp_exp ++ 154 variable: . NAME ++ 155 | . NAME '[' expression_list ']' ++ 156 | . '$' non_post_simp_exp ++ ++ FUNC_CALL shift, and go to state 8 ++ NAME shift, and go to state 9 ++ YNUMBER shift, and go to state 10 ++ YSTRING shift, and go to state 11 ++ INCREMENT shift, and go to state 16 ++ DECREMENT shift, and go to state 17 ++ LEX_BUILTIN shift, and go to state 18 ++ LEX_LENGTH shift, and go to state 19 ++ '+' shift, and go to state 20 ++ '-' shift, and go to state 21 ++ '!' shift, and go to state 54 ++ '$' shift, and go to state 24 ++ '(' shift, and go to state 55 ++ ++ simp_exp go to state 326 ++ non_post_simp_exp go to state 35 ++ variable go to state 57 ++ ++ ++state 324 ++ ++ 130 simp_exp: . non_post_simp_exp ++ 131 | . simp_exp '^' simp_exp ++ 132 | . simp_exp '*' simp_exp ++ 133 | . simp_exp '/' simp_exp ++ 134 | . simp_exp '%' simp_exp ++ 135 | . simp_exp '+' simp_exp ++ 136 | . simp_exp '-' simp_exp ++ 137 | . variable INCREMENT ++ 138 | . variable DECREMENT ++ 139 non_post_simp_exp: . '!' simp_exp ++ 140 | . '(' exp r_paren ++ 141 | . LEX_BUILTIN '(' opt_expression_list r_paren ++ 142 | . LEX_LENGTH '(' opt_expression_list r_paren ++ 143 | . LEX_LENGTH ++ 144 | . FUNC_CALL '(' opt_expression_list r_paren ++ 145 | . variable ++ 146 | . INCREMENT variable ++ 147 | . DECREMENT variable ++ 148 | . YNUMBER ++ 149 | . YSTRING ++ 150 | . '-' simp_exp ++ 150 | '-' . simp_exp ++ 151 | . '+' simp_exp ++ 154 variable: . NAME ++ 155 | . NAME '[' expression_list ']' ++ 156 | . '$' non_post_simp_exp ++ ++ FUNC_CALL shift, and go to state 8 ++ NAME shift, and go to state 9 ++ YNUMBER shift, and go to state 10 ++ YSTRING shift, and go to state 11 ++ INCREMENT shift, and go to state 16 ++ DECREMENT shift, and go to state 17 ++ LEX_BUILTIN shift, and go to state 18 ++ LEX_LENGTH shift, and go to state 19 ++ '+' shift, and go to state 20 ++ '-' shift, and go to state 21 ++ '!' shift, and go to state 54 ++ '$' shift, and go to state 24 ++ '(' shift, and go to state 55 ++ ++ simp_exp go to state 327 ++ non_post_simp_exp go to state 35 ++ variable go to state 57 ++ ++ ++state 325 ++ ++ 130 simp_exp: . non_post_simp_exp ++ 131 | . simp_exp '^' simp_exp ++ 132 | . simp_exp '*' simp_exp ++ 133 | . simp_exp '/' simp_exp ++ 134 | . simp_exp '%' simp_exp ++ 135 | . simp_exp '+' simp_exp ++ 136 | . simp_exp '-' simp_exp ++ 137 | . variable INCREMENT ++ 138 | . variable DECREMENT ++ 139 non_post_simp_exp: . '!' simp_exp ++ 139 | '!' . simp_exp ++ 140 | . '(' exp r_paren ++ 141 | . LEX_BUILTIN '(' opt_expression_list r_paren ++ 142 | . LEX_LENGTH '(' opt_expression_list r_paren ++ 143 | . LEX_LENGTH ++ 144 | . FUNC_CALL '(' opt_expression_list r_paren ++ 145 | . variable ++ 146 | . INCREMENT variable ++ 147 | . DECREMENT variable ++ 148 | . YNUMBER ++ 149 | . YSTRING ++ 150 | . '-' simp_exp ++ 151 | . '+' simp_exp ++ 154 variable: . NAME ++ 155 | . NAME '[' expression_list ']' ++ 156 | . '$' non_post_simp_exp ++ ++ FUNC_CALL shift, and go to state 8 ++ NAME shift, and go to state 9 ++ YNUMBER shift, and go to state 10 ++ YSTRING shift, and go to state 11 ++ INCREMENT shift, and go to state 16 ++ DECREMENT shift, and go to state 17 ++ LEX_BUILTIN shift, and go to state 18 ++ LEX_LENGTH shift, and go to state 19 ++ '+' shift, and go to state 20 ++ '-' shift, and go to state 21 ++ '!' shift, and go to state 54 ++ '$' shift, and go to state 24 ++ '(' shift, and go to state 55 ++ ++ simp_exp go to state 328 ++ non_post_simp_exp go to state 35 ++ variable go to state 57 ++ ++ ++state 326 ++ ++ 131 simp_exp: simp_exp . '^' simp_exp ++ 132 | simp_exp . '*' simp_exp ++ 133 | simp_exp . '/' simp_exp ++ 134 | simp_exp . '%' simp_exp ++ 135 | simp_exp . '+' simp_exp ++ 136 | simp_exp . '-' simp_exp ++ 151 non_post_simp_exp: '+' simp_exp . [error, FUNC_CALL, NAME, YNUMBER, YSTRING, RELOP, APPEND_OP, MATCHOP, NEWLINE, LEX_IN, LEX_AND, LEX_OR, INCREMENT, DECREMENT, LEX_BUILTIN, LEX_LENGTH, '?', ':', ',', '<', '>', '|', TWOWAYIO, '+', '-', '!', '$', '(', ')', '@:>@', '{', ';'] ++ ++ '*' shift, and go to state 89 ++ '/' shift, and go to state 90 ++ '%' shift, and go to state 91 ++ '^' shift, and go to state 92 ++ ++ $default reduce using rule 151 (non_post_simp_exp) ++ ++ Conflict between rule 151 and token '+' resolved as reduce ('+' < UNARY). ++ Conflict between rule 151 and token '-' resolved as reduce ('-' < UNARY). ++ ++ ++state 327 ++ ++ 131 simp_exp: simp_exp . '^' simp_exp ++ 132 | simp_exp . '*' simp_exp ++ 133 | simp_exp . '/' simp_exp ++ 134 | simp_exp . '%' simp_exp ++ 135 | simp_exp . '+' simp_exp ++ 136 | simp_exp . '-' simp_exp ++ 150 non_post_simp_exp: '-' simp_exp . [error, FUNC_CALL, NAME, YNUMBER, YSTRING, RELOP, APPEND_OP, MATCHOP, NEWLINE, LEX_IN, LEX_AND, LEX_OR, INCREMENT, DECREMENT, LEX_BUILTIN, LEX_LENGTH, '?', ':', ',', '<', '>', '|', TWOWAYIO, '+', '-', '!', '$', '(', ')', '@:>@', '{', ';'] ++ ++ '*' shift, and go to state 89 ++ '/' shift, and go to state 90 ++ '%' shift, and go to state 91 ++ '^' shift, and go to state 92 ++ ++ $default reduce using rule 150 (non_post_simp_exp) ++ ++ Conflict between rule 150 and token '+' resolved as reduce ('+' < UNARY). ++ Conflict between rule 150 and token '-' resolved as reduce ('-' < UNARY). ++ ++ ++state 328 ++ ++ 131 simp_exp: simp_exp . '^' simp_exp ++ 132 | simp_exp . '*' simp_exp ++ 133 | simp_exp . '/' simp_exp ++ 134 | simp_exp . '%' simp_exp ++ 135 | simp_exp . '+' simp_exp ++ 136 | simp_exp . '-' simp_exp ++ 139 non_post_simp_exp: '!' simp_exp . [error, FUNC_CALL, NAME, YNUMBER, YSTRING, RELOP, APPEND_OP, MATCHOP, NEWLINE, LEX_IN, LEX_AND, LEX_OR, INCREMENT, DECREMENT, LEX_BUILTIN, LEX_LENGTH, '?', ':', ',', '<', '>', '|', TWOWAYIO, '+', '-', '!', '$', '(', ')', '@:>@', '{', ';'] ++ ++ '*' shift, and go to state 89 ++ '/' shift, and go to state 90 ++ '%' shift, and go to state 91 ++ '^' shift, and go to state 92 ++ ++ $default reduce using rule 139 (non_post_simp_exp) ++ ++ Conflict between rule 139 and token '+' resolved as reduce ('+' < UNARY). ++ Conflict between rule 139 and token '-' resolved as reduce ('-' < UNARY). +]])], + +dnl OTHER-CHECKS +[], + +dnl PARSER-EXIT-VALUE, PARSER-STDOUT, PARSER-STDERR +dnl In the case of the syntax error, the parser recovers, so it returns 0. +[[0]], +[], +[AT_COND_CASE([[LALR]], +[[syntax error, unexpected '*', expecting NEWLINE or '{' or ';' +]])]) ## ----------------- ## ## 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; - } - +AT_TEST_EXISTING_GRAMMAR([[GNU Cim Grammar]], +[[ %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 HIDENTIFIER -%token HBOOLEANKONST HINTEGERKONST HCHARACTERKONST -%token HREALKONST -%token HTEXTKONST - -%type EXT_IDENT -%type DECLSTATEMENT MODULSTATEMENT MBEE_DECLSTMS MBEE_DECLSTMSU -%type MODULS -%type EXPRESSION_SIMP MBEE_ARG_R_PT -%type BAUND_PAIR_LIST - -%right 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 @@ -431,13 +824,13 @@ AT_DATA([[input.y]], %left HNOT -%left HVALRELOPERATOR HREFRELOPERATOR HOBJRELOPERATOR +%left HVALRELOPERATOR HREFRELOPERATOR HOBJRELOPERATOR %left HCONC -%left HTERMOPERATOR -%left UNEAR -%left HFACTOROPERATOR +%left HTERMOPERATOR +%left UNEAR +%left HFACTOROPERATOR %left HPRIMARYOPERATOR %left HQUA @@ -445,57 +838,43 @@ AT_DATA([[input.y]], %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 +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 { $$=$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?$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 @@ -505,8 +884,7 @@ EXT_KIND_LIST : EXT_KIND_ITEM ; EXT_KIND_ITEM : HIDENTIFIER EXT_IDENT - { if($2!=NULL)yerror (3); - regDecl($1, type, kind, categ);}*/ + {}*/ ; EMPTY_BLOCK : /*EMPT*/ | HBEGIN HEND @@ -516,687 +894,490 @@ EXT_LIST : 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;} +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 - { $$=$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 - { $$=$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($0==simsetident && - findDecl(simsetident,cblock,FALSE)==NULL) - lesinn_external_spec(simsetident, - SIMSETATRFILE, kind); - if($0==simulationident && findDecl( - simulationident,cblock,FALSE)==NULL) - lesinn_external_spec(simulationident, - SIMULATIONATRFILE, kind); - if(($0==fileident && findDecl( - fileident,cblock,FALSE)==NULL) || - ($0==outfileident && findDecl( - outfileident,cblock,FALSE)==NULL) || - ($0==infileident && findDecl( - infileident,cblock,FALSE)==NULL) || - ($0==directfileident && findDecl( - directfileident,cblock,FALSE)==NULL) || - ($0==printfileident && findDecl( - printfileident,cblock,FALSE)==NULL) || - ($0==bytefileident && findDecl( - bytefileident,cblock,FALSE)==NULL) || - ($0==inbytefileident && findDecl( - inbytefileident,cblock,FALSE)==NULL) || - ($0==outbytefileident && findDecl( - outbytefileident,cblock,FALSE)==NULL) || - ($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 - { $$=categ; - regDecl($3, type, KPROC, categ); - beginBlock(KPROC);} - FPP_HEADING - { categ=$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 - { $$=categ; - regDecl($3, type, KPROC, categ); - beginBlock(KPROC);} - HEADING - { categ=$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($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 - { $$=$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($0); - $$=$0;} - | HBEGPAR - ARGUMENT_LIST HENDPAR { mout(MARGUMENT); - moutId($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: conflicts: 78 shift/reduce, 10 reduce/reduce -]]) - -AT_CHECK([[grep '^State.*conflicts:' input.output]], 0, + 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 + ; +]], + +dnl INPUT +[[]], + +dnl BISON-STDERR +[AT_COND_CASE([[canonical LR]], +[[input.y: conflicts: 1876 shift/reduce, 144 reduce/reduce]], +[[input.y: conflicts: 78 shift/reduce, 10 reduce/reduce]])[ +]], + +dnl LAST-STATE +[AT_COND_CASE([[canonical LR]], [[10425]], [[442]])], + +dnl LALR1-DIFF not used for canonical LR(1) because the diff is huge. +[], + +dnl OTHER-CHECKS +[AT_COND_CASE([[canonical LR]], [[]], +[AT_CHECK([[grep '^State.*conflicts:' input.output]], [[0]], [[State 64 conflicts: 14 shift/reduce State 164 conflicts: 1 shift/reduce State 201 conflicts: 33 shift/reduce, 4 reduce/reduce @@ -1206,48 +1387,26 @@ State 335 conflicts: 9 shift/reduce, 2 reduce/reduce State 356 conflicts: 1 shift/reduce State 360 conflicts: 9 shift/reduce, 2 reduce/reduce State 427 conflicts: 9 shift/reduce, 2 reduce/reduce -]]) - -AT_CLEANUP - - -## ----------------- ## -## GNU pic Grammar. ## -## ----------------- ## +]])])]) -AT_SETUP([GNU pic Grammar]) +## -------------------------------- ## +## GNU pic (Groff 1.18.1) Grammar. ## +## -------------------------------- ## # GNU pic, part of groff. # 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 LABEL -%token VARIABLE -%token NUMBER -%token TEXT -%token COMMAND_LINE -%token DELIMITED -%token ORDINAL +AT_TEST_EXISTING_GRAMMAR([[GNU pic (Groff 1.18.1) Grammar]], +[[%error-verbose + +%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 @@ -1292,7 +1451,7 @@ AT_DATA([[input.y]], %token AND %token HERE %token DOT_N -%token DOT_E +%token DOT_E %token DOT_W %token DOT_S %token DOT_NE @@ -1378,7 +1537,7 @@ parses properly. */ %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 '[' /* ] */ @@ -1405,45 +1564,20 @@ works */ %left '*' '/' '%' %right '!' %right '^' - -%type expr any_expr text_expr -%type optional_by -%type expr_pair position_not_place -%type simple_if -%type nth_primitive -%type corner -%type path label_path relative_path -%type place label element element_list middle_element_list -%type object_spec -%type position -%type object_type -%type optional_ordinal_last ordinal -%type until -%type sprintf_args -%type 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: @@ -1458,844 +1592,191 @@ 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; - } - | '{' - { - $$.x = current_position.x; - $$.y = current_position.y; - $$.dir = current_direction; - } - element_list '}' - { - current_position.x = $2.x; - current_position.y = $2.y; - current_direction = $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; - $$ = 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 = $2->x; - current_position.y = $2->y; - current_direction = $2->dir; - $$ = new object_spec(BLOCK_OBJECT); - olist.wrap_up_block(& $$->oblist); - $$->tbl = current_table; - current_table = $2->tbl; - current_saved_state = $2->prev; - delete $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: @@ -2305,449 +1786,1331 @@ 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_CLEANUP +]], + +dnl INPUT +dnl +dnl For example, in pic: +dnl +dnl .PS +dnl A: circle "A" +dnl B: A left +dnl circle "B" at B +dnl .PE +dnl +dnl Even using groff 1.19.2, the 3rd line above is a syntax error. Change +dnl "left" to "right", and it still is. However, add "upper" or "lower" before +dnl "left or "right" and it's accepted to mean ".nw", ".ne", ".sw", or ".se". +dnl (There seem to be no aliases for "north" and "south" that can stand alone +dnl without being followed by "of".) +[[VARIABLE, '=', LABEL, LEFT, DOT_X]], + +dnl BISON-STDERR +[[input.y:470.11-48: warning: rule useless in parser due to conflicts: path: ORDINAL LAST object_type relative_path +]], + +dnl LAST-STATE +[AT_COND_CASE([[LALR]], [[422]], [[canonical LR]], [[4833]], [[427]])], + +dnl LALR1-DIFF not used for canonical LR(1) because the diff is huge. +dnl Isocore map from LALR(1) state number to new state number plus descriptions +dnl of any change in the actions resulting in a change in accepted language: +dnl - 102 -> 423: reduce -> shift on LEFT and RIGHT +dnl - 237 -> 425 +dnl - 266 -> 424 +dnl - 339 -> 426 +dnl - 383 -> 427 +[AT_COND_CASE([[LALR]], [], +[[@@ -1223,7 +1223,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -1377,7 +1377,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -1854,7 +1854,7 @@ + + text go to state 162 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -2047,7 +2047,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -2571,7 +2571,7 @@ + position_not_place go to state 99 + expr_pair go to state 191 + place go to state 101 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -2732,7 +2732,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -2875,7 +2875,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -3018,7 +3018,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -3256,7 +3256,7 @@ + + state 102 + +- 146 place: label . [$end, LABEL, VARIABLE, NUMBER, TEXT, ORDINAL, LEFT_ARROW_HEAD, RIGHT_ARROW_HEAD, DOUBLE_ARROW_HEAD, LAST, UP, DOWN, LEFT, RIGHT, HEIGHT, RADIUS, WIDTH, DIAMETER, FROM, TO, AT, WITH, BY, THEN, SOLID, DOTTED, DASHED, CHOP, SAME, INVISIBLE, LJUST, RJUST, ABOVE, BELOW, AND, HERE, DOT_X, DOT_Y, DOT_HT, DOT_WID, DOT_RAD, SIN, COS, ATAN2, LOG, EXP, SQRT, K_MAX, K_MIN, INT, RAND, SRAND, CW, CCW, THICKNESS, FILL, COLORED, OUTLINED, SHADED, ALIGNED, SPRINTF, '(', '`', ',', '>', '+', '-', '!', ';', '}', '@:>@', ')'] ++ 146 place: label . [$end, LABEL, VARIABLE, NUMBER, TEXT, ORDINAL, LEFT_ARROW_HEAD, RIGHT_ARROW_HEAD, DOUBLE_ARROW_HEAD, LAST, UP, DOWN, LEFT, RIGHT, HEIGHT, RADIUS, WIDTH, DIAMETER, FROM, TO, AT, WITH, BY, THEN, SOLID, DOTTED, DASHED, CHOP, SAME, INVISIBLE, LJUST, RJUST, ABOVE, BELOW, HERE, DOT_X, DOT_Y, DOT_HT, DOT_WID, DOT_RAD, SIN, COS, ATAN2, LOG, EXP, SQRT, K_MAX, K_MIN, INT, RAND, SRAND, CW, CCW, THICKNESS, FILL, COLORED, OUTLINED, SHADED, ALIGNED, SPRINTF, '(', '`', '+', '-', '!', ';', '}', '@:>@'] + 147 | label . corner + 153 label: label . '.' LABEL + 180 corner: . DOT_N +@@ -3645,7 +3645,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -3804,7 +3804,7 @@ + text_expr go to state 239 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -4481,7 +4481,7 @@ + $default reduce using rule 89 (object_spec) + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -4673,7 +4673,7 @@ + $default reduce using rule 91 (object_spec) + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -4867,7 +4867,7 @@ + $default reduce using rule 95 (object_spec) + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -5065,7 +5065,7 @@ + $default reduce using rule 93 (object_spec) + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -5260,7 +5260,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -5403,7 +5403,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -5546,7 +5546,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -5689,7 +5689,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -6475,7 +6475,7 @@ + + expr_pair go to state 280 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -6633,7 +6633,7 @@ + $default reduce using rule 105 (object_spec) + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -6825,7 +6825,7 @@ + $default reduce using rule 107 (object_spec) + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -7017,7 +7017,7 @@ + $default reduce using rule 114 (object_spec) + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -7264,7 +7264,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -7408,7 +7408,7 @@ + $default reduce using rule 109 (object_spec) + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -7819,12 +7819,12 @@ + position_not_place go to state 296 + expr_pair go to state 100 + place go to state 297 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 + corner go to state 106 +- expr go to state 266 ++ expr go to state 424 + + + state 165 +@@ -7987,7 +7987,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -8172,7 +8172,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -8333,7 +8333,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -8494,7 +8494,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -8655,7 +8655,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -8816,7 +8816,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -8977,7 +8977,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -9138,7 +9138,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -9299,7 +9299,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -9460,7 +9460,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -9623,7 +9623,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -9784,7 +9784,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -9921,7 +9921,7 @@ + + $default reduce using rule 47 (any_expr) + +- between go to state 237 ++ between go to state 425 + + + state 193 +@@ -10152,7 +10152,7 @@ + + expr_pair go to state 317 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -10298,7 +10298,7 @@ + + expr_pair go to state 318 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -10622,7 +10622,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -10765,7 +10765,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -10908,7 +10908,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -11051,7 +11051,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -11194,7 +11194,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -11337,7 +11337,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -11480,7 +11480,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -11637,7 +11637,7 @@ + position_not_place go to state 99 + expr_pair go to state 100 + place go to state 101 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -11780,7 +11780,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -11923,7 +11923,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -12066,7 +12066,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -12209,7 +12209,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -12352,7 +12352,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -12495,7 +12495,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -12638,7 +12638,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -12794,12 +12794,12 @@ + position_not_place go to state 99 + expr_pair go to state 100 + place go to state 101 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 + corner go to state 106 +- expr go to state 266 ++ expr go to state 424 + + + state 238 +@@ -12937,7 +12937,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -13160,7 +13160,7 @@ + text_expr go to state 342 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -13319,7 +13319,7 @@ + text_expr go to state 344 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -13502,7 +13502,7 @@ + text_expr go to state 348 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -13661,7 +13661,7 @@ + text_expr go to state 350 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -13804,7 +13804,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -14747,7 +14747,7 @@ + position_not_place go to state 99 + expr_pair go to state 191 + place go to state 101 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -15074,7 +15074,7 @@ + text go to state 113 + expr_pair go to state 365 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -15693,12 +15693,12 @@ + position_not_place go to state 99 + expr_pair go to state 100 + place go to state 101 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 + corner go to state 106 +- expr go to state 266 ++ expr go to state 424 + + + state 315 +@@ -16124,7 +16124,7 @@ + + $default reduce using rule 239 (expr) + +- between go to state 237 ++ between go to state 425 + + Conflict between rule 239 and token OF resolved as shift ('<' < OF). + Conflict between rule 239 and token BETWEEN resolved as shift ('<' < BETWEEN). +@@ -17234,7 +17234,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -17416,7 +17416,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -17577,7 +17577,7 @@ + text_expr go to state 112 + text go to state 113 + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -17772,12 +17772,12 @@ + position_not_place go to state 99 + expr_pair go to state 100 + place go to state 101 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 + corner go to state 106 +- expr go to state 266 ++ expr go to state 424 + + + state 383 +@@ -18071,7 +18071,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -18221,7 +18221,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -18830,7 +18830,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -18987,7 +18987,7 @@ + '!' shift, and go to state 94 + + place go to state 114 +- label go to state 102 ++ label go to state 423 + ordinal go to state 103 + optional_ordinal_last go to state 104 + nth_primitive go to state 105 +@@ -19089,3 +19089,440 @@ + 29 placeless_element: FOR VARIABLE '=' expr TO expr optional_by DO $@6 DELIMITED . + + $default reduce using rule 29 (placeless_element) ++ ++ ++state 423 ++ ++ 146 place: label . [$end, AND, DOT_X, DOT_Y, DOT_HT, DOT_WID, DOT_RAD, ',', '>', '+', '-', ';', '}', '@:>@', ')'] ++ 147 | label . corner ++ 153 label: label . '.' LABEL ++ 180 corner: . DOT_N ++ 181 | . DOT_E ++ 182 | . DOT_W ++ 183 | . DOT_S ++ 184 | . DOT_NE ++ 185 | . DOT_SE ++ 186 | . DOT_NW ++ 187 | . DOT_SW ++ 188 | . DOT_C ++ 189 | . DOT_START ++ 190 | . DOT_END ++ 191 | . TOP ++ 192 | . BOTTOM ++ 193 | . LEFT ++ 194 | . RIGHT ++ 195 | . UPPER LEFT ++ 196 | . LOWER LEFT ++ 197 | . UPPER RIGHT ++ 198 | . LOWER RIGHT ++ 199 | . LEFT_CORNER ++ 200 | . RIGHT_CORNER ++ 201 | . UPPER LEFT_CORNER ++ 202 | . LOWER LEFT_CORNER ++ 203 | . UPPER RIGHT_CORNER ++ 204 | . LOWER RIGHT_CORNER ++ 205 | . NORTH ++ 206 | . SOUTH ++ 207 | . EAST ++ 208 | . WEST ++ 209 | . CENTER ++ 210 | . START ++ 211 | . END ++ ++ LEFT shift, and go to state 53 ++ RIGHT shift, and go to state 54 ++ DOT_N shift, and go to state 56 ++ DOT_E shift, and go to state 57 ++ DOT_W shift, and go to state 58 ++ DOT_S shift, and go to state 59 ++ DOT_NE shift, and go to state 60 ++ DOT_SE shift, and go to state 61 ++ DOT_NW shift, and go to state 62 ++ DOT_SW shift, and go to state 63 ++ DOT_C shift, and go to state 64 ++ DOT_START shift, and go to state 65 ++ DOT_END shift, and go to state 66 ++ TOP shift, and go to state 78 ++ BOTTOM shift, and go to state 79 ++ UPPER shift, and go to state 80 ++ LOWER shift, and go to state 81 ++ LEFT_CORNER shift, and go to state 82 ++ RIGHT_CORNER shift, and go to state 83 ++ NORTH shift, and go to state 84 ++ SOUTH shift, and go to state 85 ++ EAST shift, and go to state 86 ++ WEST shift, and go to state 87 ++ CENTER shift, and go to state 88 ++ END shift, and go to state 89 ++ START shift, and go to state 90 ++ '.' shift, and go to state 204 ++ ++ $default reduce using rule 146 (place) ++ ++ corner go to state 205 ++ ++ ++state 424 ++ ++ 140 position_not_place: expr . between position AND position ++ 141 | expr . '<' position ',' position '>' ++ 142 between: . BETWEEN ++ 143 | . OF THE WAY BETWEEN ++ 144 expr_pair: expr . ',' expr ++ 219 expr: expr . '+' expr ++ 220 | expr . '-' expr ++ 221 | expr . '*' expr ++ 222 | expr . '/' expr ++ 223 | expr . '%' expr ++ 224 | expr . '^' expr ++ 239 | expr . '<' expr ++ 240 | expr . LESSEQUAL expr ++ 241 | expr . '>' expr ++ 242 | expr . GREATEREQUAL expr ++ 243 | expr . EQUALEQUAL expr ++ 244 | expr . NOTEQUAL expr ++ 245 | expr . ANDAND expr ++ 246 | expr . OROR expr ++ ++ OF shift, and go to state 220 ++ BETWEEN shift, and go to state 221 ++ ANDAND shift, and go to state 222 ++ OROR shift, and go to state 223 ++ NOTEQUAL shift, and go to state 224 ++ EQUALEQUAL shift, and go to state 225 ++ LESSEQUAL shift, and go to state 226 ++ GREATEREQUAL shift, and go to state 227 ++ ',' shift, and go to state 228 ++ '<' shift, and go to state 229 ++ '>' shift, and go to state 230 ++ '+' shift, and go to state 231 ++ '-' shift, and go to state 232 ++ '*' shift, and go to state 233 ++ '/' shift, and go to state 234 ++ '%' shift, and go to state 235 ++ '^' shift, and go to state 236 ++ ++ between go to state 425 ++ ++ ++state 425 ++ ++ 134 position: . position_not_place ++ 135 | . place ++ 136 position_not_place: . expr_pair ++ 137 | . position '+' expr_pair ++ 138 | . position '-' expr_pair ++ 139 | . '(' position ',' position ')' ++ 140 | . expr between position AND position ++ 140 | expr between . position AND position ++ 141 | . expr '<' position ',' position '>' ++ 144 expr_pair: . expr ',' expr ++ 145 | . '(' expr_pair ')' ++ 146 place: . label ++ 147 | . label corner ++ 148 | . corner label ++ 149 | . corner OF label ++ 150 | . HERE ++ 151 label: . LABEL ++ 152 | . nth_primitive ++ 153 | . label '.' LABEL ++ 154 ordinal: . ORDINAL ++ 155 | . '`' any_expr TH ++ 156 optional_ordinal_last: . LAST ++ 157 | . ordinal LAST ++ 158 nth_primitive: . ordinal object_type ++ 159 | . optional_ordinal_last object_type ++ 180 corner: . DOT_N ++ 181 | . DOT_E ++ 182 | . DOT_W ++ 183 | . DOT_S ++ 184 | . DOT_NE ++ 185 | . DOT_SE ++ 186 | . DOT_NW ++ 187 | . DOT_SW ++ 188 | . DOT_C ++ 189 | . DOT_START ++ 190 | . DOT_END ++ 191 | . TOP ++ 192 | . BOTTOM ++ 193 | . LEFT ++ 194 | . RIGHT ++ 195 | . UPPER LEFT ++ 196 | . LOWER LEFT ++ 197 | . UPPER RIGHT ++ 198 | . LOWER RIGHT ++ 199 | . LEFT_CORNER ++ 200 | . RIGHT_CORNER ++ 201 | . UPPER LEFT_CORNER ++ 202 | . LOWER LEFT_CORNER ++ 203 | . UPPER RIGHT_CORNER ++ 204 | . LOWER RIGHT_CORNER ++ 205 | . NORTH ++ 206 | . SOUTH ++ 207 | . EAST ++ 208 | . WEST ++ 209 | . CENTER ++ 210 | . START ++ 211 | . END ++ 212 expr: . VARIABLE ++ 213 | . NUMBER ++ 214 | . place DOT_X ++ 215 | . place DOT_Y ++ 216 | . place DOT_HT ++ 217 | . place DOT_WID ++ 218 | . place DOT_RAD ++ 219 | . expr '+' expr ++ 220 | . expr '-' expr ++ 221 | . expr '*' expr ++ 222 | . expr '/' expr ++ 223 | . expr '%' expr ++ 224 | . expr '^' expr ++ 225 | . '-' expr ++ 226 | . '(' any_expr ')' ++ 227 | . SIN '(' any_expr ')' ++ 228 | . COS '(' any_expr ')' ++ 229 | . ATAN2 '(' any_expr ',' any_expr ')' ++ 230 | . LOG '(' any_expr ')' ++ 231 | . EXP '(' any_expr ')' ++ 232 | . SQRT '(' any_expr ')' ++ 233 | . K_MAX '(' any_expr ',' any_expr ')' ++ 234 | . K_MIN '(' any_expr ',' any_expr ')' ++ 235 | . INT '(' any_expr ')' ++ 236 | . RAND '(' any_expr ')' ++ 237 | . RAND '(' ')' ++ 238 | . SRAND '(' any_expr ')' ++ 239 | . expr '<' expr ++ 240 | . expr LESSEQUAL expr ++ 241 | . expr '>' expr ++ 242 | . expr GREATEREQUAL expr ++ 243 | . expr EQUALEQUAL expr ++ 244 | . expr NOTEQUAL expr ++ 245 | . expr ANDAND expr ++ 246 | . expr OROR expr ++ 247 | . '!' expr ++ ++ LABEL shift, and go to state 48 ++ VARIABLE shift, and go to state 49 ++ NUMBER shift, and go to state 50 ++ ORDINAL shift, and go to state 51 ++ LAST shift, and go to state 52 ++ LEFT shift, and go to state 53 ++ RIGHT shift, and go to state 54 ++ HERE shift, and go to state 55 ++ DOT_N shift, and go to state 56 ++ DOT_E shift, and go to state 57 ++ DOT_W shift, and go to state 58 ++ DOT_S shift, and go to state 59 ++ DOT_NE shift, and go to state 60 ++ DOT_SE shift, and go to state 61 ++ DOT_NW shift, and go to state 62 ++ DOT_SW shift, and go to state 63 ++ DOT_C shift, and go to state 64 ++ DOT_START shift, and go to state 65 ++ DOT_END shift, and go to state 66 ++ SIN shift, and go to state 67 ++ COS shift, and go to state 68 ++ ATAN2 shift, and go to state 69 ++ LOG shift, and go to state 70 ++ EXP shift, and go to state 71 ++ SQRT shift, and go to state 72 ++ K_MAX shift, and go to state 73 ++ K_MIN shift, and go to state 74 ++ INT shift, and go to state 75 ++ RAND shift, and go to state 76 ++ SRAND shift, and go to state 77 ++ TOP shift, and go to state 78 ++ BOTTOM shift, and go to state 79 ++ UPPER shift, and go to state 80 ++ LOWER shift, and go to state 81 ++ LEFT_CORNER shift, and go to state 82 ++ RIGHT_CORNER shift, and go to state 83 ++ NORTH shift, and go to state 84 ++ SOUTH shift, and go to state 85 ++ EAST shift, and go to state 86 ++ WEST shift, and go to state 87 ++ CENTER shift, and go to state 88 ++ END shift, and go to state 89 ++ START shift, and go to state 90 ++ '(' shift, and go to state 91 ++ '`' shift, and go to state 92 ++ '-' shift, and go to state 93 ++ '!' shift, and go to state 94 ++ ++ position go to state 426 ++ position_not_place go to state 99 ++ expr_pair go to state 100 ++ place go to state 101 ++ label go to state 423 ++ ordinal go to state 103 ++ optional_ordinal_last go to state 104 ++ nth_primitive go to state 105 ++ corner go to state 106 ++ expr go to state 424 ++ ++ ++state 426 ++ ++ 137 position_not_place: position . '+' expr_pair ++ 138 | position . '-' expr_pair ++ 140 | expr between position . AND position ++ ++ AND shift, and go to state 427 ++ '+' shift, and go to state 197 ++ '-' shift, and go to state 198 ++ ++ ++state 427 ++ ++ 134 position: . position_not_place ++ 135 | . place ++ 136 position_not_place: . expr_pair ++ 137 | . position '+' expr_pair ++ 138 | . position '-' expr_pair ++ 139 | . '(' position ',' position ')' ++ 140 | . expr between position AND position ++ 140 | expr between position AND . position ++ 141 | . expr '<' position ',' position '>' ++ 144 expr_pair: . expr ',' expr ++ 145 | . '(' expr_pair ')' ++ 146 place: . label ++ 147 | . label corner ++ 148 | . corner label ++ 149 | . corner OF label ++ 150 | . HERE ++ 151 label: . LABEL ++ 152 | . nth_primitive ++ 153 | . label '.' LABEL ++ 154 ordinal: . ORDINAL ++ 155 | . '`' any_expr TH ++ 156 optional_ordinal_last: . LAST ++ 157 | . ordinal LAST ++ 158 nth_primitive: . ordinal object_type ++ 159 | . optional_ordinal_last object_type ++ 180 corner: . DOT_N ++ 181 | . DOT_E ++ 182 | . DOT_W ++ 183 | . DOT_S ++ 184 | . DOT_NE ++ 185 | . DOT_SE ++ 186 | . DOT_NW ++ 187 | . DOT_SW ++ 188 | . DOT_C ++ 189 | . DOT_START ++ 190 | . DOT_END ++ 191 | . TOP ++ 192 | . BOTTOM ++ 193 | . LEFT ++ 194 | . RIGHT ++ 195 | . UPPER LEFT ++ 196 | . LOWER LEFT ++ 197 | . UPPER RIGHT ++ 198 | . LOWER RIGHT ++ 199 | . LEFT_CORNER ++ 200 | . RIGHT_CORNER ++ 201 | . UPPER LEFT_CORNER ++ 202 | . LOWER LEFT_CORNER ++ 203 | . UPPER RIGHT_CORNER ++ 204 | . LOWER RIGHT_CORNER ++ 205 | . NORTH ++ 206 | . SOUTH ++ 207 | . EAST ++ 208 | . WEST ++ 209 | . CENTER ++ 210 | . START ++ 211 | . END ++ 212 expr: . VARIABLE ++ 213 | . NUMBER ++ 214 | . place DOT_X ++ 215 | . place DOT_Y ++ 216 | . place DOT_HT ++ 217 | . place DOT_WID ++ 218 | . place DOT_RAD ++ 219 | . expr '+' expr ++ 220 | . expr '-' expr ++ 221 | . expr '*' expr ++ 222 | . expr '/' expr ++ 223 | . expr '%' expr ++ 224 | . expr '^' expr ++ 225 | . '-' expr ++ 226 | . '(' any_expr ')' ++ 227 | . SIN '(' any_expr ')' ++ 228 | . COS '(' any_expr ')' ++ 229 | . ATAN2 '(' any_expr ',' any_expr ')' ++ 230 | . LOG '(' any_expr ')' ++ 231 | . EXP '(' any_expr ')' ++ 232 | . SQRT '(' any_expr ')' ++ 233 | . K_MAX '(' any_expr ',' any_expr ')' ++ 234 | . K_MIN '(' any_expr ',' any_expr ')' ++ 235 | . INT '(' any_expr ')' ++ 236 | . RAND '(' any_expr ')' ++ 237 | . RAND '(' ')' ++ 238 | . SRAND '(' any_expr ')' ++ 239 | . expr '<' expr ++ 240 | . expr LESSEQUAL expr ++ 241 | . expr '>' expr ++ 242 | . expr GREATEREQUAL expr ++ 243 | . expr EQUALEQUAL expr ++ 244 | . expr NOTEQUAL expr ++ 245 | . expr ANDAND expr ++ 246 | . expr OROR expr ++ 247 | . '!' expr ++ ++ LABEL shift, and go to state 48 ++ VARIABLE shift, and go to state 49 ++ NUMBER shift, and go to state 50 ++ ORDINAL shift, and go to state 51 ++ LAST shift, and go to state 52 ++ LEFT shift, and go to state 53 ++ RIGHT shift, and go to state 54 ++ HERE shift, and go to state 55 ++ DOT_N shift, and go to state 56 ++ DOT_E shift, and go to state 57 ++ DOT_W shift, and go to state 58 ++ DOT_S shift, and go to state 59 ++ DOT_NE shift, and go to state 60 ++ DOT_SE shift, and go to state 61 ++ DOT_NW shift, and go to state 62 ++ DOT_SW shift, and go to state 63 ++ DOT_C shift, and go to state 64 ++ DOT_START shift, and go to state 65 ++ DOT_END shift, and go to state 66 ++ SIN shift, and go to state 67 ++ COS shift, and go to state 68 ++ ATAN2 shift, and go to state 69 ++ LOG shift, and go to state 70 ++ EXP shift, and go to state 71 ++ SQRT shift, and go to state 72 ++ K_MAX shift, and go to state 73 ++ K_MIN shift, and go to state 74 ++ INT shift, and go to state 75 ++ RAND shift, and go to state 76 ++ SRAND shift, and go to state 77 ++ TOP shift, and go to state 78 ++ BOTTOM shift, and go to state 79 ++ UPPER shift, and go to state 80 ++ LOWER shift, and go to state 81 ++ LEFT_CORNER shift, and go to state 82 ++ RIGHT_CORNER shift, and go to state 83 ++ NORTH shift, and go to state 84 ++ SOUTH shift, and go to state 85 ++ EAST shift, and go to state 86 ++ WEST shift, and go to state 87 ++ CENTER shift, and go to state 88 ++ END shift, and go to state 89 ++ START shift, and go to state 90 ++ '(' shift, and go to state 91 ++ '`' shift, and go to state 92 ++ '-' shift, and go to state 93 ++ '!' shift, and go to state 94 ++ ++ position go to state 402 ++ position_not_place go to state 99 ++ expr_pair go to state 100 ++ place go to state 101 ++ label go to state 423 ++ ordinal go to state 103 ++ optional_ordinal_last go to state 104 ++ nth_primitive go to state 105 ++ corner go to state 106 ++ expr go to state 424 +]])], + +dnl OTHER-CHECKS +[], + +dnl PARSER-EXIT-VALUE, PARSER-STDOUT, PARSER-STDERR +[AT_COND_CASE([[LALR]], [[1]], [[0]])], +[], +[AT_COND_CASE([[LALR]], +[[syntax error, unexpected LEFT +]])])