From 0954b081d0efe2008d30eace30d1ae18e262a8ae Mon Sep 17 00:00:00 2001 From: marauder2k7 Date: Sun, 14 Apr 2024 07:08:17 +0100 Subject: [PATCH 1/5] GenerateCompiler -ReAdded generateCompiler.bat -Fixed paths in bat filse -Fixed paths for includes --- Engine/source/console/torquescript/CMDgram.y | 4 +- .../source/console/torquescript/CMDscan.cpp | 255 +++++++++--------- Engine/source/console/torquescript/CMDscan.l | 4 +- Engine/source/console/torquescript/bison.bat | 2 +- .../source/console/torquescript/cmdgram.cpp | 4 +- Engine/source/console/torquescript/cmdgram.h | 5 - .../console/torquescript/generateCompiler.bat | 3 + 7 files changed, 139 insertions(+), 138 deletions(-) create mode 100644 Engine/source/console/torquescript/generateCompiler.bat diff --git a/Engine/source/console/torquescript/CMDgram.y b/Engine/source/console/torquescript/CMDgram.y index c3e8846b8..942b00992 100644 --- a/Engine/source/console/torquescript/CMDgram.y +++ b/Engine/source/console/torquescript/CMDgram.y @@ -8,7 +8,7 @@ #include #include #include "console/console.h" -#include "console/compiler.h" +#include "console/torquescript/compiler.h" #include "console/consoleInternal.h" #include "core/strings/stringFunctions.h" @@ -166,7 +166,7 @@ decl_list : { $$ = nil; } | decl_list decl - { if(!gStatementList) { gStatementList = $2; } else { gStatementList->append($2); } } + { if(!Script::gStatementList) { Script::gStatementList = $2; } else { Script::gStatementList->append($2); } } ; decl diff --git a/Engine/source/console/torquescript/CMDscan.cpp b/Engine/source/console/torquescript/CMDscan.cpp index f1a844086..89fb5eb13 100644 --- a/Engine/source/console/torquescript/CMDscan.cpp +++ b/Engine/source/console/torquescript/CMDscan.cpp @@ -29,10 +29,6 @@ #include -#include "compiler.h" -#include "runtime.h" -#include "console/script.h" - /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ #ifdef c_plusplus @@ -555,9 +551,11 @@ char *yytext; #define YYLMAX 4096 #define YY_NO_UNISTD_H +#include #include "platform/platform.h" #include "core/stringTable.h" #include "console/console.h" +#include "console/torquescript/compiler.h" #include "console/dynamicTypes.h" #include "core/strings/stringFunctions.h" @@ -578,7 +576,10 @@ inline Token< T > MakeToken( T value, U32 lineNumber ) return result; } -#include "cmdgram.h" +#include "console/torquescript/cmdgram.h" + +// HACK: C++17 and beyond can't use register keyword +#define register using namespace Compiler; @@ -633,7 +634,7 @@ void CMDerror(const char * s, ...); // Reset the parser. void CMDrestart(FILE *in); -#line 635 "CMDscan.cpp" +#line 638 "CMDscan.cpp" /* Macros after this point can all be overridden by user definitions in * section 1. @@ -776,14 +777,14 @@ YY_MALLOC_DECL YY_DECL { - yy_state_type yy_current_state; - char *yy_cp, *yy_bp; - int yy_act; + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; -#line 105 "CMDscan.l" +#line 108 "CMDscan.l" ; -#line 785 "CMDscan.cpp" +#line 788 "CMDscan.cpp" if ( yy_init ) { @@ -825,7 +826,7 @@ YY_DECL yy_match: do { - YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; if ( yy_accept[yy_current_state] ) { yy_last_accepting_state = yy_current_state; @@ -868,187 +869,187 @@ do_action: /* This label is used only to access EOF actions. */ case 1: YY_RULE_SETUP -#line 107 "CMDscan.l" +#line 110 "CMDscan.l" { } YY_BREAK case 2: YY_RULE_SETUP -#line 108 "CMDscan.l" +#line 111 "CMDscan.l" { return(Sc_ScanDocBlock()); } YY_BREAK case 3: YY_RULE_SETUP -#line 109 "CMDscan.l" +#line 112 "CMDscan.l" ; YY_BREAK case 4: YY_RULE_SETUP -#line 110 "CMDscan.l" +#line 113 "CMDscan.l" ; YY_BREAK case 5: YY_RULE_SETUP -#line 111 "CMDscan.l" +#line 114 "CMDscan.l" {lineIndex++;} YY_BREAK case 6: YY_RULE_SETUP -#line 112 "CMDscan.l" +#line 115 "CMDscan.l" { return(Sc_ScanString(STRATOM)); } YY_BREAK case 7: YY_RULE_SETUP -#line 113 "CMDscan.l" +#line 116 "CMDscan.l" { return(Sc_ScanString(TAGATOM)); } YY_BREAK case 8: YY_RULE_SETUP -#line 114 "CMDscan.l" +#line 117 "CMDscan.l" { CMDlval.i = MakeToken< int >( opEQ, lineIndex ); return opEQ; } YY_BREAK case 9: YY_RULE_SETUP -#line 115 "CMDscan.l" +#line 118 "CMDscan.l" { CMDlval.i = MakeToken< int >( opNE, lineIndex ); return opNE; } YY_BREAK case 10: YY_RULE_SETUP -#line 116 "CMDscan.l" +#line 119 "CMDscan.l" { CMDlval.i = MakeToken< int >( opGE, lineIndex ); return opGE; } YY_BREAK case 11: YY_RULE_SETUP -#line 117 "CMDscan.l" +#line 120 "CMDscan.l" { CMDlval.i = MakeToken< int >( opLE, lineIndex ); return opLE; } YY_BREAK case 12: YY_RULE_SETUP -#line 118 "CMDscan.l" +#line 121 "CMDscan.l" { CMDlval.i = MakeToken< int >( opAND, lineIndex ); return opAND; } YY_BREAK case 13: YY_RULE_SETUP -#line 119 "CMDscan.l" +#line 122 "CMDscan.l" { CMDlval.i = MakeToken< int >( opOR, lineIndex ); return opOR; } YY_BREAK case 14: YY_RULE_SETUP -#line 120 "CMDscan.l" +#line 123 "CMDscan.l" { CMDlval.i = MakeToken< int >( opCOLONCOLON, lineIndex ); return opCOLONCOLON; } YY_BREAK case 15: YY_RULE_SETUP -#line 121 "CMDscan.l" +#line 124 "CMDscan.l" { CMDlval.i = MakeToken< int >( opMINUSMINUS, lineIndex ); return opMINUSMINUS; } YY_BREAK case 16: YY_RULE_SETUP -#line 122 "CMDscan.l" +#line 125 "CMDscan.l" { CMDlval.i = MakeToken< int >( opPLUSPLUS, lineIndex ); return opPLUSPLUS; } YY_BREAK case 17: YY_RULE_SETUP -#line 123 "CMDscan.l" +#line 126 "CMDscan.l" { CMDlval.i = MakeToken< int >( opSTREQ, lineIndex ); return opSTREQ; } YY_BREAK case 18: YY_RULE_SETUP -#line 124 "CMDscan.l" +#line 127 "CMDscan.l" { CMDlval.i = MakeToken< int >( opSTRNE, lineIndex ); return opSTRNE; } YY_BREAK case 19: YY_RULE_SETUP -#line 125 "CMDscan.l" +#line 128 "CMDscan.l" { CMDlval.i = MakeToken< int >( opSHL, lineIndex ); return opSHL; } YY_BREAK case 20: YY_RULE_SETUP -#line 126 "CMDscan.l" +#line 129 "CMDscan.l" { CMDlval.i = MakeToken< int >( opSHR, lineIndex ); return opSHR; } YY_BREAK case 21: YY_RULE_SETUP -#line 127 "CMDscan.l" +#line 130 "CMDscan.l" { CMDlval.i = MakeToken< int >( opPLASN, lineIndex ); return opPLASN; } YY_BREAK case 22: YY_RULE_SETUP -#line 128 "CMDscan.l" +#line 131 "CMDscan.l" { CMDlval.i = MakeToken< int >( opMIASN, lineIndex ); return opMIASN; } YY_BREAK case 23: YY_RULE_SETUP -#line 129 "CMDscan.l" +#line 132 "CMDscan.l" { CMDlval.i = MakeToken< int >( opMLASN, lineIndex ); return opMLASN; } YY_BREAK case 24: YY_RULE_SETUP -#line 130 "CMDscan.l" +#line 133 "CMDscan.l" { CMDlval.i = MakeToken< int >( opDVASN, lineIndex ); return opDVASN; } YY_BREAK case 25: YY_RULE_SETUP -#line 131 "CMDscan.l" +#line 134 "CMDscan.l" { CMDlval.i = MakeToken< int >( opMODASN, lineIndex ); return opMODASN; } YY_BREAK case 26: YY_RULE_SETUP -#line 132 "CMDscan.l" +#line 135 "CMDscan.l" { CMDlval.i = MakeToken< int >( opANDASN, lineIndex ); return opANDASN; } YY_BREAK case 27: YY_RULE_SETUP -#line 133 "CMDscan.l" +#line 136 "CMDscan.l" { CMDlval.i = MakeToken< int >( opXORASN, lineIndex ); return opXORASN; } YY_BREAK case 28: YY_RULE_SETUP -#line 134 "CMDscan.l" +#line 137 "CMDscan.l" { CMDlval.i = MakeToken< int >( opORASN, lineIndex ); return opORASN; } YY_BREAK case 29: YY_RULE_SETUP -#line 135 "CMDscan.l" +#line 138 "CMDscan.l" { CMDlval.i = MakeToken< int >( opSLASN, lineIndex ); return opSLASN; } YY_BREAK case 30: YY_RULE_SETUP -#line 136 "CMDscan.l" +#line 139 "CMDscan.l" { CMDlval.i = MakeToken< int >( opSRASN, lineIndex ); return opSRASN; } YY_BREAK case 31: YY_RULE_SETUP -#line 137 "CMDscan.l" +#line 140 "CMDscan.l" { CMDlval.i = MakeToken< int >( opINTNAME, lineIndex ); return opINTNAME; } YY_BREAK case 32: YY_RULE_SETUP -#line 138 "CMDscan.l" +#line 141 "CMDscan.l" { CMDlval.i = MakeToken< int >( opINTNAMER, lineIndex ); return opINTNAMER; } YY_BREAK case 33: YY_RULE_SETUP -#line 139 "CMDscan.l" +#line 142 "CMDscan.l" { CMDlval.i = MakeToken< int >( '\n', lineIndex ); return '@'; } YY_BREAK case 34: YY_RULE_SETUP -#line 140 "CMDscan.l" +#line 143 "CMDscan.l" { CMDlval.i = MakeToken< int >( '\t', lineIndex ); return '@'; } YY_BREAK case 35: YY_RULE_SETUP -#line 141 "CMDscan.l" +#line 144 "CMDscan.l" { CMDlval.i = MakeToken< int >( ' ', lineIndex ); return '@'; } YY_BREAK case 36: YY_RULE_SETUP -#line 142 "CMDscan.l" +#line 145 "CMDscan.l" { CMDlval.i = MakeToken< int >( 0, lineIndex ); return '@'; } YY_BREAK case 37: YY_RULE_SETUP -#line 143 "CMDscan.l" +#line 146 "CMDscan.l" { /* this comment stops syntax highlighting from getting messed up when editing the lexer in TextPad */ int c = 0, l; for ( ; ; ) @@ -1074,222 +1075,222 @@ YY_RULE_SETUP } YY_BREAK case 38: -#line 167 "CMDscan.l" -case 39: -#line 168 "CMDscan.l" -case 40: -#line 169 "CMDscan.l" -case 41: #line 170 "CMDscan.l" -case 42: +case 39: #line 171 "CMDscan.l" -case 43: +case 40: #line 172 "CMDscan.l" -case 44: +case 41: #line 173 "CMDscan.l" -case 45: +case 42: #line 174 "CMDscan.l" -case 46: +case 43: #line 175 "CMDscan.l" -case 47: +case 44: #line 176 "CMDscan.l" -case 48: +case 45: #line 177 "CMDscan.l" -case 49: +case 46: #line 178 "CMDscan.l" -case 50: +case 47: #line 179 "CMDscan.l" -case 51: +case 48: #line 180 "CMDscan.l" -case 52: +case 49: #line 181 "CMDscan.l" -case 53: +case 50: #line 182 "CMDscan.l" -case 54: +case 51: #line 183 "CMDscan.l" -case 55: +case 52: #line 184 "CMDscan.l" -case 56: +case 53: #line 185 "CMDscan.l" -case 57: +case 54: #line 186 "CMDscan.l" -case 58: +case 55: #line 187 "CMDscan.l" -case 59: +case 56: #line 188 "CMDscan.l" -case 60: +case 57: #line 189 "CMDscan.l" +case 58: +#line 190 "CMDscan.l" +case 59: +#line 191 "CMDscan.l" +case 60: +#line 192 "CMDscan.l" case 61: YY_RULE_SETUP -#line 189 "CMDscan.l" +#line 192 "CMDscan.l" { CMDlval.i = MakeToken< int >( CMDtext[ 0 ], lineIndex ); return CMDtext[ 0 ]; } YY_BREAK case 62: YY_RULE_SETUP -#line 190 "CMDscan.l" +#line 193 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwIN, lineIndex ); return(rwIN); } YY_BREAK case 63: YY_RULE_SETUP -#line 191 "CMDscan.l" +#line 194 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwCASEOR, lineIndex ); return(rwCASEOR); } YY_BREAK case 64: YY_RULE_SETUP -#line 192 "CMDscan.l" +#line 195 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwBREAK, lineIndex ); return(rwBREAK); } YY_BREAK case 65: YY_RULE_SETUP -#line 193 "CMDscan.l" +#line 196 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwRETURN, lineIndex ); return(rwRETURN); } YY_BREAK case 66: YY_RULE_SETUP -#line 194 "CMDscan.l" +#line 197 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwELSE, lineIndex ); return(rwELSE); } YY_BREAK case 67: YY_RULE_SETUP -#line 195 "CMDscan.l" +#line 198 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwASSERT, lineIndex ); return(rwASSERT); } YY_BREAK case 68: YY_RULE_SETUP -#line 196 "CMDscan.l" +#line 199 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwWHILE, lineIndex ); return(rwWHILE); } YY_BREAK case 69: YY_RULE_SETUP -#line 197 "CMDscan.l" +#line 200 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwDO, lineIndex ); return(rwDO); } YY_BREAK case 70: YY_RULE_SETUP -#line 198 "CMDscan.l" +#line 201 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwIF, lineIndex ); return(rwIF); } YY_BREAK case 71: YY_RULE_SETUP -#line 199 "CMDscan.l" +#line 202 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwFOREACHSTR, lineIndex ); return(rwFOREACHSTR); } YY_BREAK case 72: YY_RULE_SETUP -#line 200 "CMDscan.l" +#line 203 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwFOREACH, lineIndex ); return(rwFOREACH); } YY_BREAK case 73: YY_RULE_SETUP -#line 201 "CMDscan.l" +#line 204 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwFOR, lineIndex ); return(rwFOR); } YY_BREAK case 74: YY_RULE_SETUP -#line 202 "CMDscan.l" +#line 205 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwCONTINUE, lineIndex ); return(rwCONTINUE); } YY_BREAK case 75: YY_RULE_SETUP -#line 203 "CMDscan.l" +#line 206 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwDEFINE, lineIndex ); return(rwDEFINE); } YY_BREAK case 76: YY_RULE_SETUP -#line 204 "CMDscan.l" +#line 207 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwDECLARE, lineIndex ); return(rwDECLARE); } YY_BREAK case 77: YY_RULE_SETUP -#line 205 "CMDscan.l" +#line 208 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwDECLARESINGLETON, lineIndex ); return(rwDECLARESINGLETON); } YY_BREAK case 78: YY_RULE_SETUP -#line 206 "CMDscan.l" +#line 209 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwDATABLOCK, lineIndex ); return(rwDATABLOCK); } YY_BREAK case 79: YY_RULE_SETUP -#line 207 "CMDscan.l" +#line 210 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwCASE, lineIndex ); return(rwCASE); } YY_BREAK case 80: YY_RULE_SETUP -#line 208 "CMDscan.l" +#line 211 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwSWITCHSTR, lineIndex ); return(rwSWITCHSTR); } YY_BREAK case 81: YY_RULE_SETUP -#line 209 "CMDscan.l" +#line 212 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwSWITCH, lineIndex ); return(rwSWITCH); } YY_BREAK case 82: YY_RULE_SETUP -#line 210 "CMDscan.l" +#line 213 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwDEFAULT, lineIndex ); return(rwDEFAULT); } YY_BREAK case 83: YY_RULE_SETUP -#line 211 "CMDscan.l" +#line 214 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwPACKAGE, lineIndex ); return(rwPACKAGE); } YY_BREAK case 84: YY_RULE_SETUP -#line 212 "CMDscan.l" +#line 215 "CMDscan.l" { CMDlval.i = MakeToken< int >( rwNAMESPACE, lineIndex ); return(rwNAMESPACE); } YY_BREAK case 85: YY_RULE_SETUP -#line 213 "CMDscan.l" +#line 216 "CMDscan.l" { CMDlval.i = MakeToken< int >( 1, lineIndex ); return INTCONST; } YY_BREAK case 86: YY_RULE_SETUP -#line 214 "CMDscan.l" +#line 217 "CMDscan.l" { CMDlval.i = MakeToken< int >( 0, lineIndex ); return INTCONST; } YY_BREAK case 87: YY_RULE_SETUP -#line 215 "CMDscan.l" +#line 218 "CMDscan.l" { return(Sc_ScanVar()); } YY_BREAK case 88: YY_RULE_SETUP -#line 216 "CMDscan.l" +#line 220 "CMDscan.l" { return Sc_ScanIdent(); } YY_BREAK case 89: YY_RULE_SETUP -#line 217 "CMDscan.l" +#line 221 "CMDscan.l" return(Sc_ScanHex()); YY_BREAK case 90: YY_RULE_SETUP -#line 218 "CMDscan.l" +#line 222 "CMDscan.l" { CMDtext[CMDleng] = 0; CMDlval.i = MakeToken< int >( dAtoi(CMDtext), lineIndex ); return INTCONST; } YY_BREAK case 91: YY_RULE_SETUP -#line 219 "CMDscan.l" +#line 223 "CMDscan.l" return Sc_ScanNum(); YY_BREAK case 92: YY_RULE_SETUP -#line 220 "CMDscan.l" +#line 224 "CMDscan.l" return(ILLEGAL_TOKEN); YY_BREAK case 93: YY_RULE_SETUP -#line 221 "CMDscan.l" +#line 225 "CMDscan.l" return(ILLEGAL_TOKEN); YY_BREAK case 94: YY_RULE_SETUP -#line 222 "CMDscan.l" +#line 226 "CMDscan.l" ECHO; YY_BREAK -#line 1291 "CMDscan.cpp" +#line 1294 "CMDscan.cpp" case YY_STATE_EOF(INITIAL): yyterminate(); @@ -1432,9 +1433,9 @@ case YY_STATE_EOF(INITIAL): static int yy_get_next_buffer() { - char *dest = yy_current_buffer->yy_ch_buf; - char *source = yytext_ptr; - int number_to_move, i; + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; int ret_val; if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) @@ -1562,14 +1563,14 @@ static int yy_get_next_buffer() static yy_state_type yy_get_previous_state() { - yy_state_type yy_current_state; - char *yy_cp; + register yy_state_type yy_current_state; + register char *yy_cp; yy_current_state = yy_start; for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) { - YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { yy_last_accepting_state = yy_current_state; @@ -1601,10 +1602,10 @@ static yy_state_type yy_try_NUL_trans( yy_current_state ) yy_state_type yy_current_state; #endif { - int yy_is_jam; - char *yy_cp = yy_c_buf_p; + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; - YY_CHAR yy_c = 1; + register YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { yy_last_accepting_state = yy_current_state; @@ -1625,14 +1626,14 @@ yy_state_type yy_current_state; #ifndef YY_NO_UNPUT #ifdef YY_USE_PROTOS -static void yyunput( int c, char *yy_bp ) +static void yyunput( int c, register char *yy_bp ) #else static void yyunput( c, yy_bp ) int c; -char *yy_bp; +register char *yy_bp; #endif { - char *yy_cp = yy_c_buf_p; + register char *yy_cp = yy_c_buf_p; /* undo effects of setting up yytext */ *yy_cp = yy_hold_char; @@ -1640,10 +1641,10 @@ char *yy_bp; if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ - int number_to_move = yy_n_chars + 2; - char *dest = &yy_current_buffer->yy_ch_buf[ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ yy_current_buffer->yy_buf_size + 2]; - char *source = + register char *source = &yy_current_buffer->yy_ch_buf[number_to_move]; while ( source > yy_current_buffer->yy_ch_buf ) @@ -2097,7 +2098,7 @@ yyconst char *s2; int n; #endif { - int i; + register int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } @@ -2149,7 +2150,7 @@ int main() return 0; } #endif -#line 222 "CMDscan.l" +#line 226 "CMDscan.l" static const char *scanBuffer; @@ -2340,7 +2341,7 @@ static int Sc_ScanDocBlock() static int Sc_ScanString(int ret) { CMDtext[CMDleng - 1] = 0; - if(!TorqueScript::getRuntime()->collapseEscapedCharacters(CMDtext+1)) + if(!collapseEscape(CMDtext+1)) return -1; dsize_t bufferLen = dStrlen( CMDtext ); diff --git a/Engine/source/console/torquescript/CMDscan.l b/Engine/source/console/torquescript/CMDscan.l index ab2c61a72..1ba26aca6 100644 --- a/Engine/source/console/torquescript/CMDscan.l +++ b/Engine/source/console/torquescript/CMDscan.l @@ -9,7 +9,7 @@ #include "platform/platform.h" #include "core/stringTable.h" #include "console/console.h" -#include "console/compiler.h" +#include "console/torquescript/compiler.h" #include "console/dynamicTypes.h" #include "core/strings/stringFunctions.h" @@ -30,7 +30,7 @@ inline Token< T > MakeToken( T value, U32 lineNumber ) return result; } -#include "console/cmdgram.h" +#include "console/torquescript/cmdgram.h" // HACK: C++17 and beyond can't use register keyword #define register diff --git a/Engine/source/console/torquescript/bison.bat b/Engine/source/console/torquescript/bison.bat index d48aaebbb..1558b1807 100644 --- a/Engine/source/console/torquescript/bison.bat +++ b/Engine/source/console/torquescript/bison.bat @@ -1,6 +1,6 @@ echo Changing to %4 ... cd %4 echo Generating %2 and %3 with prefix %1. -..\..\bin\bison\bison.exe -o %2 %3 --defines -p %1 +..\..\..\bin\bison\bison.exe -o %2 %3 --defines -p %1 echo Renaming %2 to %5 . move /Y %2 %5 \ No newline at end of file diff --git a/Engine/source/console/torquescript/cmdgram.cpp b/Engine/source/console/torquescript/cmdgram.cpp index 34c7737d3..dcaf39641 100644 --- a/Engine/source/console/torquescript/cmdgram.cpp +++ b/Engine/source/console/torquescript/cmdgram.cpp @@ -95,7 +95,7 @@ #include #include #include "console/console.h" -#include "compiler.h" +#include "console/torquescript/compiler.h" #include "console/consoleInternal.h" #include "core/strings/stringFunctions.h" @@ -2390,3 +2390,5 @@ yyerrhandle: goto yynewstate; } #line 617 "cmdgram.y" + + diff --git a/Engine/source/console/torquescript/cmdgram.h b/Engine/source/console/torquescript/cmdgram.h index 5316b2fda..83736a565 100644 --- a/Engine/source/console/torquescript/cmdgram.h +++ b/Engine/source/console/torquescript/cmdgram.h @@ -1,6 +1,3 @@ -#ifndef _CMDGRAM_H_ -#define _CMDGRAM_H_ - typedef union { Token< char > c; Token< int > i; @@ -93,5 +90,3 @@ typedef union { extern YYSTYPE CMDlval; - -#endif diff --git a/Engine/source/console/torquescript/generateCompiler.bat b/Engine/source/console/torquescript/generateCompiler.bat new file mode 100644 index 000000000..aa9fe3bb4 --- /dev/null +++ b/Engine/source/console/torquescript/generateCompiler.bat @@ -0,0 +1,3 @@ + +call bison.bat CMD CMDgram.c CMDgram.y . CMDgram.cpp +..\..\..\bin\flex\flex -PCMD -oCMDscan.cpp CMDscan.l From 83b3f01928f7415ddf621498826e24b4366dc25a Mon Sep 17 00:00:00 2001 From: marauder2k7 Date: Sun, 14 Apr 2024 22:17:41 +0100 Subject: [PATCH 2/5] update bison flex -Updated bison flex exe files to the latest windows version i could find -Regenned the compiler..... alot of changes..... --- Engine/bin/bison-flex/FlexLexer.h | 220 + Engine/bin/bison-flex/README.md | 34 + Engine/bin/{bison => bison-flex}/bison.hairy | 0 Engine/bin/{bison => bison-flex}/bison.simple | 0 Engine/bin/bison-flex/changelog.md | 166 + .../bison-flex/custom_build_rules/README.md | 173 + .../bison-flex/custom_build_rules/docs/1.png | Bin 0 -> 31654 bytes .../bison-flex/custom_build_rules/docs/2.png | Bin 0 -> 11445 bytes .../bison-flex/custom_build_rules/docs/3.png | Bin 0 -> 7316 bytes .../bison-flex/custom_build_rules/docs/4.png | Bin 0 -> 12213 bytes .../bison-flex/custom_build_rules/docs/5.png | Bin 0 -> 11534 bytes .../bison-flex/custom_build_rules/docs/6.png | Bin 0 -> 15611 bytes .../docs/BisonProperties.png | Bin 0 -> 27186 bytes .../docs/FlexProperties.png | Bin 0 -> 26767 bytes .../custom_build_rules/docs/Flex_debuging.png | Bin 0 -> 27219 bytes .../custom_build_rules/docs/Properties.png | Bin 0 -> 31446 bytes .../custom_build_rules/docs/Verbosity.png | Bin 0 -> 29722 bytes .../win_bison_custom_build.props | 23 + .../win_bison_custom_build.targets | 91 + .../win_bison_only/win_bison_custom_build.xml | 281 + .../win_flex_bison_custom_build.props | 43 + .../win_flex_bison_custom_build.targets | 178 + .../win_flex_bison_custom_build.xml | 521 ++ .../win_flex_only/win_flex_custom_build.props | 23 + .../win_flex_custom_build.targets | 94 + .../win_flex_only/win_flex_custom_build.xml | 243 + Engine/bin/bison-flex/data/README.md | 227 + Engine/bin/bison-flex/data/bison-default.css | 61 + Engine/bin/bison-flex/data/local.mk | 58 + Engine/bin/bison-flex/data/m4sugar/foreach.m4 | 362 ++ Engine/bin/bison-flex/data/m4sugar/m4sugar.m4 | 3329 +++++++++++ Engine/bin/bison-flex/data/skeletons/bison.m4 | 1241 ++++ .../bin/bison-flex/data/skeletons/c++-skel.m4 | 27 + Engine/bin/bison-flex/data/skeletons/c++.m4 | 778 +++ .../bin/bison-flex/data/skeletons/c-like.m4 | 72 + .../bin/bison-flex/data/skeletons/c-skel.m4 | 27 + Engine/bin/bison-flex/data/skeletons/c.m4 | 1125 ++++ .../bin/bison-flex/data/skeletons/d-skel.m4 | 26 + Engine/bin/bison-flex/data/skeletons/d.m4 | 628 ++ Engine/bin/bison-flex/data/skeletons/glr.c | 2763 +++++++++ Engine/bin/bison-flex/data/skeletons/glr.cc | 397 ++ Engine/bin/bison-flex/data/skeletons/glr2.cc | 3533 +++++++++++ .../bison-flex/data/skeletons/java-skel.m4 | 27 + Engine/bin/bison-flex/data/skeletons/java.m4 | 502 ++ Engine/bin/bison-flex/data/skeletons/lalr1.cc | 1633 ++++++ Engine/bin/bison-flex/data/skeletons/lalr1.d | 1326 +++++ .../bin/bison-flex/data/skeletons/lalr1.java | 1303 +++++ .../bin/bison-flex/data/skeletons/location.cc | 380 ++ Engine/bin/bison-flex/data/skeletons/stack.hh | 157 + .../bin/bison-flex/data/skeletons/traceon.m4 | 2 + .../bin/bison-flex/data/skeletons/variant.hh | 525 ++ Engine/bin/bison-flex/data/skeletons/yacc.c | 2209 +++++++ Engine/bin/bison-flex/data/xslt/bison.xsl | 105 + Engine/bin/bison-flex/data/xslt/xml2dot.xsl | 401 ++ Engine/bin/bison-flex/data/xslt/xml2text.xsl | 572 ++ Engine/bin/bison-flex/data/xslt/xml2xhtml.xsl | 765 +++ Engine/bin/bison/bison.exe | Bin 196096 -> 0 bytes Engine/bin/bison/bison.html | 4501 --------------- Engine/bin/flex/flex.exe | Bin 181248 -> 0 bytes Engine/bin/flex/flex_1.html | 4079 ------------- .../source/console/torquescript/CMDscan.cpp | 2017 ++++--- Engine/source/console/torquescript/bison.bat | 2 +- .../source/console/torquescript/cmdgram.cpp | 5139 ++++++++++------- Engine/source/console/torquescript/cmdgram.h | 226 +- .../console/torquescript/generateCompiler.bat | 2 +- 65 files changed, 31010 insertions(+), 11607 deletions(-) create mode 100644 Engine/bin/bison-flex/FlexLexer.h create mode 100644 Engine/bin/bison-flex/README.md rename Engine/bin/{bison => bison-flex}/bison.hairy (100%) rename Engine/bin/{bison => bison-flex}/bison.simple (100%) create mode 100644 Engine/bin/bison-flex/changelog.md create mode 100644 Engine/bin/bison-flex/custom_build_rules/README.md create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/1.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/2.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/3.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/4.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/5.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/6.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/BisonProperties.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/FlexProperties.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/Flex_debuging.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/Properties.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/docs/Verbosity.png create mode 100644 Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.props create mode 100644 Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.targets create mode 100644 Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.xml create mode 100644 Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.props create mode 100644 Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.targets create mode 100644 Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.xml create mode 100644 Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.props create mode 100644 Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.targets create mode 100644 Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.xml create mode 100644 Engine/bin/bison-flex/data/README.md create mode 100644 Engine/bin/bison-flex/data/bison-default.css create mode 100644 Engine/bin/bison-flex/data/local.mk create mode 100644 Engine/bin/bison-flex/data/m4sugar/foreach.m4 create mode 100644 Engine/bin/bison-flex/data/m4sugar/m4sugar.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/bison.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/c++-skel.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/c++.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/c-like.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/c-skel.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/c.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/d-skel.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/d.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/glr.c create mode 100644 Engine/bin/bison-flex/data/skeletons/glr.cc create mode 100644 Engine/bin/bison-flex/data/skeletons/glr2.cc create mode 100644 Engine/bin/bison-flex/data/skeletons/java-skel.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/java.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/lalr1.cc create mode 100644 Engine/bin/bison-flex/data/skeletons/lalr1.d create mode 100644 Engine/bin/bison-flex/data/skeletons/lalr1.java create mode 100644 Engine/bin/bison-flex/data/skeletons/location.cc create mode 100644 Engine/bin/bison-flex/data/skeletons/stack.hh create mode 100644 Engine/bin/bison-flex/data/skeletons/traceon.m4 create mode 100644 Engine/bin/bison-flex/data/skeletons/variant.hh create mode 100644 Engine/bin/bison-flex/data/skeletons/yacc.c create mode 100644 Engine/bin/bison-flex/data/xslt/bison.xsl create mode 100644 Engine/bin/bison-flex/data/xslt/xml2dot.xsl create mode 100644 Engine/bin/bison-flex/data/xslt/xml2text.xsl create mode 100644 Engine/bin/bison-flex/data/xslt/xml2xhtml.xsl delete mode 100644 Engine/bin/bison/bison.exe delete mode 100644 Engine/bin/bison/bison.html delete mode 100644 Engine/bin/flex/flex.exe delete mode 100644 Engine/bin/flex/flex_1.html diff --git a/Engine/bin/bison-flex/FlexLexer.h b/Engine/bin/bison-flex/FlexLexer.h new file mode 100644 index 000000000..c4dad2b14 --- /dev/null +++ b/Engine/bin/bison-flex/FlexLexer.h @@ -0,0 +1,220 @@ +// -*-C++-*- +// FlexLexer.h -- define interfaces for lexical analyzer classes generated +// by flex + +// Copyright (c) 1993 The Regents of the University of California. +// All rights reserved. +// +// This code is derived from software contributed to Berkeley by +// Kent Williams and Tom Epperly. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: + +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. + +// Neither the name of the University nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. + +// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR +// IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE. + +// This file defines FlexLexer, an abstract class which specifies the +// external interface provided to flex C++ lexer objects, and yyFlexLexer, +// which defines a particular lexer class. +// +// If you want to create multiple lexer classes, you use the -P flag +// to rename each yyFlexLexer to some other xxFlexLexer. You then +// include in your other sources once per lexer class: +// +// #undef yyFlexLexer +// #define yyFlexLexer xxFlexLexer +// #include +// +// #undef yyFlexLexer +// #define yyFlexLexer zzFlexLexer +// #include +// ... + +#ifndef __FLEX_LEXER_H +// Never included before - need to define base class. +#define __FLEX_LEXER_H + +#include + +extern "C++" { + +struct yy_buffer_state; +typedef int yy_state_type; + +class FlexLexer +{ +public: + virtual ~FlexLexer() { } + + const char* YYText() const { return yytext; } + int YYLeng() const { return yyleng; } + + virtual void + yy_switch_to_buffer( yy_buffer_state* new_buffer ) = 0; + virtual yy_buffer_state* yy_create_buffer( std::istream* s, int size ) = 0; + virtual yy_buffer_state* yy_create_buffer( std::istream& s, int size ) = 0; + virtual void yy_delete_buffer( yy_buffer_state* b ) = 0; + virtual void yyrestart( std::istream* s ) = 0; + virtual void yyrestart( std::istream& s ) = 0; + + virtual int yylex() = 0; + + // Call yylex with new input/output sources. + int yylex( std::istream& new_in, std::ostream& new_out ) + { + switch_streams( new_in, new_out ); + return yylex(); + } + + int yylex( std::istream* new_in, std::ostream* new_out = 0) + { + switch_streams( new_in, new_out ); + return yylex(); + } + + // Switch to new input/output streams. A nil stream pointer + // indicates "keep the current one". + virtual void switch_streams( std::istream* new_in, + std::ostream* new_out ) = 0; + virtual void switch_streams( std::istream& new_in, + std::ostream& new_out ) = 0; + + int lineno() const { return yylineno; } + + int debug() const { return yy_flex_debug; } + void set_debug( int flag ) { yy_flex_debug = flag; } + +protected: + char* yytext; + int yyleng; + int yylineno; // only maintained if you use %option yylineno + int yy_flex_debug; // only has effect with -d or "%option debug" +}; + +} +#endif // FLEXLEXER_H + +#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce) +// Either this is the first time through (yyFlexLexerOnce not defined), +// or this is a repeated include to define a different flavor of +// yyFlexLexer, as discussed in the flex manual. +# define yyFlexLexerOnce + +extern "C++" { + +class yyFlexLexer : public FlexLexer { +public: + // arg_yyin and arg_yyout default to the cin and cout, but we + // only make that assignment when initializing in yylex(). + yyFlexLexer( std::istream& arg_yyin, std::ostream& arg_yyout ); + yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 ); +private: + void ctor_common(); + +public: + + virtual ~yyFlexLexer(); + + void yy_switch_to_buffer( yy_buffer_state* new_buffer ); + yy_buffer_state* yy_create_buffer( std::istream* s, int size ); + yy_buffer_state* yy_create_buffer( std::istream& s, int size ); + void yy_delete_buffer( yy_buffer_state* b ); + void yyrestart( std::istream* s ); + void yyrestart( std::istream& s ); + + void yypush_buffer_state( yy_buffer_state* new_buffer ); + void yypop_buffer_state(); + + virtual int yylex(); + virtual void switch_streams( std::istream& new_in, std::ostream& new_out ); + virtual void switch_streams( std::istream* new_in = 0, std::ostream* new_out = 0 ); + virtual int yywrap(); + +protected: + virtual int LexerInput( char* buf, int max_size ); + virtual void LexerOutput( const char* buf, int size ); + virtual void LexerError( const char* msg ); + + void yyunput( int c, char* buf_ptr ); + int yyinput(); + + void yy_load_buffer_state(); + void yy_init_buffer( yy_buffer_state* b, std::istream& s ); + void yy_flush_buffer( yy_buffer_state* b ); + + int yy_start_stack_ptr; + int yy_start_stack_depth; + int* yy_start_stack; + + void yy_push_state( int new_state ); + void yy_pop_state(); + int yy_top_state(); + + yy_state_type yy_get_previous_state(); + yy_state_type yy_try_NUL_trans( yy_state_type current_state ); + int yy_get_next_buffer(); + + std::istream yyin; // input source for default LexerInput + std::ostream yyout; // output sink for default LexerOutput + + // yy_hold_char holds the character lost when yytext is formed. + char yy_hold_char; + + // Number of characters read into yy_ch_buf. + int yy_n_chars; + + // Points to current character in buffer. + char* yy_c_buf_p; + + int yy_init; // whether we need to initialize + int yy_start; // start state number + + // Flag which is used to allow yywrap()'s to do buffer switches + // instead of setting up a fresh yyin. A bit of a hack ... + int yy_did_buffer_switch_on_eof; + + + size_t yy_buffer_stack_top; /**< index of top of stack. */ + size_t yy_buffer_stack_max; /**< capacity of stack. */ + yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */ + void yyensure_buffer_stack(void); + + // The following are not always needed, but may be depending + // on use of certain flex features (like REJECT or yymore()). + + yy_state_type yy_last_accepting_state; + char* yy_last_accepting_cpos; + + yy_state_type* yy_state_buf; + yy_state_type* yy_state_ptr; + + char* yy_full_match; + int* yy_full_state; + int yy_full_lp; + + int yy_lp; + int yy_looking_for_trail_begin; + + int yy_more_flag; + int yy_more_len; + int yy_more_offset; + int yy_prev_more_offset; +}; + +} + +#endif // yyFlexLexer || ! yyFlexLexerOnce diff --git a/Engine/bin/bison-flex/README.md b/Engine/bin/bison-flex/README.md new file mode 100644 index 000000000..b4e96ec46 --- /dev/null +++ b/Engine/bin/bison-flex/README.md @@ -0,0 +1,34 @@ +# WinFlexBison - Flex and Bison for Microsoft Windows + +WinFlexBison is a Windows port of [Flex (the fast lexical analyser)](https://github.com/westes/flex/) and [GNU Bison (parser generator)](https://www.gnu.org/software/bison/). +Both win_flex and win_bison are based on upstream sources but depend on system libraries only. + +**NOTE**: +* 2.4.x versions include GNU Bison version 2.7 +* 2.5.x versions include GNU Bison version 3.x.x + +## License +Flex uses a [BSD license](flex/src/COPYING), GNU Bison is [licensed under the GNU General Public License (GPLv3+)](bison/src/COPYING). +All build scripts in WinFlexBison are distributed under GPLv3+. See [COPYING](COPYING) for details. + +All documentation, especially those under custom_build_rules/doc, is distributed under the GNU Free Documentation License (FDL 1.3+). + +## Build status +Bison 3.x (master) [![Build status](https://ci.appveyor.com/api/projects/status/58lcjnr0mb9uc8c8/branch/master?svg=true)](https://ci.appveyor.com/project/lexxmark/winflexbison/branch/master) and, for compatibility reasons, Bison 2.7 (bison2.7) [![Build status](https://ci.appveyor.com/api/projects/status/58lcjnr0mb9uc8c8/branch/bison2.7?svg=true)](https://ci.appveyor.com/project/lexxmark/winflexbison/branch/bison2.7) + +## Downloads +https://github.com/lexxmark/winflexbison/releases provides stable versions. +To test non-released development versions see the artifacts provided by CI under "Build status". + +## Changelog +The release page includes the full Changelog but you may also see the [changelog.md](changelog.md) file. + +## Build requirements +* Visual Studio 2017 or newer +* optional: CMake (when building with CMake) + +## HowTo +You may use win_flex and win_bison directly on the command line or [use them via CustomBuildRules in VisualStudio](custom_build_rules/README.md). + +## Example flex/bison files +See https://github.com/meyerd/flex-bison-example diff --git a/Engine/bin/bison/bison.hairy b/Engine/bin/bison-flex/bison.hairy similarity index 100% rename from Engine/bin/bison/bison.hairy rename to Engine/bin/bison-flex/bison.hairy diff --git a/Engine/bin/bison/bison.simple b/Engine/bin/bison-flex/bison.simple similarity index 100% rename from Engine/bin/bison/bison.simple rename to Engine/bin/bison-flex/bison.simple diff --git a/Engine/bin/bison-flex/changelog.md b/Engine/bin/bison-flex/changelog.md new file mode 100644 index 000000000..5d80cecce --- /dev/null +++ b/Engine/bin/bison-flex/changelog.md @@ -0,0 +1,166 @@ +## Changelog + +**NOTE**: + * 2.4.x versions include bison version 2.7 + * 2.5.x versions include bison version 3.x + +### version 2.5.25 + * upgrade win_bison to version 3.8.2 + * upgrade m4 to version 1.4.19 + +### version 2.5.24 + * upgrade win_bison to version 3.7.4 + * upgrade m4 to version 1.4.18 + * upgrade gnulib + * removed VS2015 support + * fixed win_bison --update option (renaming opened file) + +### version 2.5.23 + * upgrade win_bison to version 3.7.1 + +### version 2.5.22 + * upgrade win_bison to version 3.5.0 + +### version 2.5.21 + * avoid _m4eof lines in generated bison code while printing warnings + +### version 2.5.20 + * recovered invoking win_bison from different folders + +### version 2.5.19 + * upgrade win_bison to version 3.4.1 + +### version 2.5.18 + * upgrade win_bison to version 3.3.2 + +### version 2.5.17 + * upgrade win_bison to version 3.3.1 + +### version 2.5.16 + * upgrade win_bison to version 3.1 + * write output flex/bison files in binary mode "wb" that means use '\n' EOL not '\r\n' + * documentation about how to use the custom build-rules is now included + +### versions 2.4.12/2.5.15 + * upgrade win_bison to version 3.0.5 + +### versions 2.4.12/2.5.14 + * revert to Visual Studio 2015 due to false positive virus alarms for win_flex.exe + +### versions 2.4.11/2.5.13 + * fixed VS 2017 compilation errors in location.cc + +### versions 2.4.11/2.5.12 + * migrate to Visual Studio 2017 + +### versions 2.4.10/2.5.11 + * upgrade win_flex to version 2.6.4 + * fixed compilation warnings + +### versions 2.4.9/2.5.10 + * data folder was up to dated for bison 3.0.4 + +### versions 2.4.9/2.5.9 + * recovered --header-file win_flex option + +### versions 2.4.8/2.5.8 + * fixed outdated FlexLexer.h file + +### versions 2.4.7/2.5.7 + * upgrade win_flex to version 2.6.3 + * fixed compilation warnings + +### versions 2.4.6/2.5.6 + * upgrade win_bison to version 3.0.4 + * win_bison v2.7 is unchanged + * add separate custom build rules + * for win_bison `custom_build_rules\win_bison_only` + * and win_flex `custom_build_rules\win_flex_only` + +### versions 2.4.5/2.5.5 + * fix missing Additional Options in custom build rules + * fix incorrect "----header-file" option in flex custom build rules + * add some extra flex options to Visual Studio property pages: + 1. Prefix (--prefix="...") + 2. C++ Class Name (--yyclass="...") + +###versions 2.4.4/2.5.4 + * fix silent errors in custom build rules + * add some flex/bison options to Visual Studio property pages: + * Bison: + 1. Output File Name (--output="...") + 2. Defines File Name (--defines="...") + 3. Debug (--debug) + 4. Verbose (--verbose) + 5. No lines (--no-lines) + 6. File Prefix (--file-prefix="...") + 7. Graph File (--graph="...") + 8. Warnings (--warnings="...") + 9. Report (--report="...") + 10. Report File Name (--report-file="...") + + * Flex: + 1. Output File Name (--outfile="...") + 2. Header File Name (--header-file="...") + 3. Windows compatibility mode (--wincompat) + 4. Case-insensitive mode (--case-insensitive) + 5. Lex-compatibility mode (--lex-compat) + 6. Start Condition Stacks (--stack) + 7. Bison Bridge Mode (--bison-bridge) + 8. No #line Directives (--noline) + 9. Generate Reentrant Scanner (--reentrant) + 10. Generate C++ Scanner (--c++) + 11. Debug Mode (--debug) + +### versions 2.4.3/2.5.3 + * fix incorrect #line directives in win_flex.exe +see https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=542482 + +### versions 2.4.2/2.5.2 + * backport parallel invocations of win_bison version 2.7 + * win_bison of version 3.0 is unchanged + +### versions 2.4.1/2.5.1 + * remove XSI extention syntax for fprintf function (not implemented in windows) + * this fixes Graphviz files generation for bison + +**NOTE**: + * 2.4.x versions will include bison version 2.7 + * 2.5.x versions will include bison version 3.0 + +### version 2.5 + * upgrade win_bison to version 3.0 and make temporary win_bison's files process unique (so parallel invocations of win_bison are possible) + +**NOTE**: Several deprecated features were removed in bison 3.0 so this version can break your projects. +Please see http://savannah.gnu.org/forum/forum.php?forum_id=7663 +For the reason of compatibility I don't change win_flex_bison-latest.zip to refer to win_flex_bison-2.5.zip file. +It still refer to win_flex_bison-2.4.zip + +### version 2.4 + * fix problem with "m4_syscmd is not implemented" message. + * Now win_bison should output correct diagnostic and error messages. + +### version 2.3 + * hide __attribute__ construction for non GCC compilers + +### version 2.2 + * added --wincompat option to win_flex (this option changes `` unix include with `` windows analog + also `isatty/fileno` functions changed to `_isatty/_fileno`) +fixed two "'<' : signed/unsigned mismatch" warnings in win_flex generated file + +### version 2.1 + * fixed crash when execute win_bison.exe under WindowsXP (argv[0] don't have full application path) + * added win_flex_bison-latest.zip package to freeze download link + +### version 2.0 + * upgrade win_bison to version 2.7 and win_flex to version 2.5.37 + +### version 1.2 + * fixed win_flex.exe #line directives (some #line directives in output file were with unescaped backslashes) + +### version 1.1 + * fixed win_flex.exe parallel invocations (now all temporary files are process specific) + * added FLEX_TMP_DIR environment variable support to redirect temporary files folder + * added '.exe' to program name in win_flex.exe --version output (CMake support) + * fixed win_bison.exe to use "/data" subfolder related to executable path rather than current working directory + * added BISON_PKGDATADIR environment variable to redirect "/data" subfolder to a different place diff --git a/Engine/bin/bison-flex/custom_build_rules/README.md b/Engine/bin/bison-flex/custom_build_rules/README.md new file mode 100644 index 000000000..181d7d80f --- /dev/null +++ b/Engine/bin/bison-flex/custom_build_rules/README.md @@ -0,0 +1,173 @@ + +How to setup custom build rules for Visual Studio 2010 and up. +--------------- + +First of all you should have the necessary files. +Custom Build rules are separated into a file triplet of `.xml`, `.targets` and `.props`. + +You find the custom build rules for win_flex_bison in the **custom_build_rules** directory of the win_flex_bison archive. + +You may choose to install one of the following rule set + +* the combined rules - [alternative download][1]: + * [win_flex_bison_custom_build.props ](win_flex_bison/win_flex_bison_custom_build.props) + * [win_flex_bison_custom_build.targets](win_flex_bison/win_flex_bison_custom_build.targets) + * [win_flex_bison_custom_build.xml ](win_flex_bison/win_flex_bison_custom_build.xml) + +* flex only rules - [alternative download][2]: + * [win_flex_custom_build.props ](win_flex_only/win_flex_custom_build.props) + * [win_flex_custom_build.targets ](win_flex_only/win_flex_custom_build.targets) + * [win_flex_custom_build.xml ](win_flex_only/win_flex_custom_build.xml) + +* bison only rules - [alternative download][3]: + * [win_bison_custom_build.props ](win_bison_only/win_bison_custom_build.props) + * [win_bison_custom_build.targets](win_bison_only/win_bison_custom_build.targets) + * [win_bison_custom_build.xml ](win_bison_only/win_bison_custom_build.xml) + +This documentation uses the combined rule-set but can be used for all rule-sets. + +[1]: https://sourceforge.net/projects/winflexbison/files/win_flex_bison_custom_build_rules.zip/download "Combined build rules for Bison and Flex" +[2]: https://sourceforge.net/projects/winflexbison/files/win_flex_custom_build_rules.zip/download "Build rules for Flex only" +[3]: https://sourceforge.net/projects/winflexbison/files/win_bison_custom_build_rules.zip/download "Build rules for Bison only" + +---- + +Launch Visual Studio and open an VC/VC++ project. +Open context menu for project item in Solution Explorer panel and select "**Build Customizations...**" menu item. +(Note: newer VS versions have this below sub-menu "**Build Dependencies...**".) + +![Build Customizations in Solution Explorer](docs/1.png) + +---- + +In popup dialog "Visual C++ Build Customization Files" press "**Find Existing...**" button. + +![Customization Files](docs/2.png) + +---- + +In Open File dialog select "**win_flex_bison_custom_build.targets**" file and press "Open". +(Note: you may have to switch the file filter to "(*.*) all files".) + +---- + +You will see "Add Search Path?" message box, press "Yes". + +![Adding Search Path](docs/3.png) + +---- + +In "Visual C++ Build Customization Files" dialog check just added item **win_flex_bison_custom_build** and press "OK". + +![activate custom build rule](docs/4.png) + +---- + +Now you can add flex and bison files to the project... + +![project with flex and bison files added](docs/5.png) + +... and build. +In build output you should see something like this: + +~~~~ + +1>------ Rebuild All started: Project: ConsoleApplication1, Configuration: Debug Win32 ------ +1> Process sample bison file +1> Process sample flex file +1> stdafx.cpp +1> ConsoleApplication1.cpp +1> Generating Code... +1> ConsoleApplication1.vcxproj -> C:\Users\ConsoleApplication1\Debug\ConsoleApplication1.exe +========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ========== + +~~~~ + +----- + +For **sample.y** bison file there are two output files: **sample.tab.h** and **sample.tab.cpp**. +For **sample.l** flex file you'll got **sample.flex.cpp**. + +Now you can add them to the project and build. (*Don't forget to exclude cpp files from using precompiled headers*) + +![Include generated files into Solution](docs/6.png) + +~~~~ + +1>------ Build started: Project: ConsoleApplication1, Configuration: Debug Win32 ------ +1> Process sample bison file +1> Process sample flex file +1> sample.tab.cpp +1> sample.flex.cpp +1> Generating Code... +1> ConsoleApplication1.vcxproj -> C:\Users\ConsoleApplication1\Debug\ConsoleApplication1.exe +========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ========== + +~~~~ + +---- + +If your flex/bison file is incorrect and you've got an error. But you don't see actual error message, something like this: + +~~~~ + +1>------ Build started: Project: ConsoleApplication2, Configuration: Debug Win32 ------ +1> Process "grammar.y" bison file +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: The command " +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: start /B /WAIT /D "C:...\ConsoleApplication2\ConsoleApplication2\" win_bison.exe --output="grammar.tab.cpp" --defines="grammar.tab.h" --graph="1.dot" "grammar.y" +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: exit /b %errorlevel%" exited with code 1. +========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ========== + +~~~~ + +You can change Build Output Verbosity from "Minimal" to "Normal" in "Options" dialog + +![Verbosity](docs/Verbosity.png) + +Then you will see more detailed output: + +~~~~ + +1>BisonTarget: +1> Process "grammar.y" bison file +1> grammar.y:51.1-4: error: invalid directive: '%sdw' +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: The command " +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: start /B /WAIT /D "C:...\ConsoleApplication2\" win_bison.exe --output="grammar.tab.cpp" --defines="grammar.tab.h" --graph="1.dot" "grammar.y" +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: exit /b %errorlevel%" exited with code 1. +1> +1>Build FAILED. +1> +1>Time Elapsed 00:00:01.21 +========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ========== + +~~~~ + +---- + +Also you can tune some flex/bison options in files properties dialog: + +![Opening File Properties](docs/Properties.png) +![Property Page for Flex sources](docs/FlexProperties.png) +![Property Page for Bison sources](docs/BisonProperties.png) + +---- + + +To debug your scanner or parser you can set break points right into **sample.y** or **sample.l** code. + +![Debugging Flex source files](docs/Flex_debuging.png) + +---- + + +To use the Visual C++ Code editor for Flex/Bison files instead of the text editor adjust your editor settings as follows: + +* click **Options** on the **Tools** menu, expand the **Text Editor** node and select **File Extension** +* type extension **`l`** in the **Extension** field and choose **Microsoft Visual C++** in the **Editor** drop-down field, click **Add** +* do the same for the extension **`y`** + +You now have syntax highlighting, code-completion and show definition options in your Flex/Bison source. + +---- + +Enjoy! diff --git a/Engine/bin/bison-flex/custom_build_rules/docs/1.png b/Engine/bin/bison-flex/custom_build_rules/docs/1.png new file mode 100644 index 0000000000000000000000000000000000000000..e29510ecbc1ea268999bcea34e4251071b1fb81e GIT binary patch literal 31654 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

6gBN@G|Vx-zT`q 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 literal 0 HcmV?d00001 diff --git a/Engine/bin/bison-flex/custom_build_rules/docs/4.png b/Engine/bin/bison-flex/custom_build_rules/docs/4.png new file mode 100644 index 0000000000000000000000000000000000000000..288d79a2a5ae39861f0f81adeffd2bc814972b59 GIT binary patch literal 12213 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 literal 0 HcmV?d00001 diff --git a/Engine/bin/bison-flex/custom_build_rules/docs/5.png b/Engine/bin/bison-flex/custom_build_rules/docs/5.png new file mode 100644 index 0000000000000000000000000000000000000000..5b9e18f6d299232582980f37ab31551759623de2 GIT binary patch literal 11534 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 a_jto=Prr=RS)YTD4=Bp2%9KkR2mLRwDRyrF literal 0 HcmV?d00001 diff --git a/Engine/bin/bison-flex/custom_build_rules/docs/6.png b/Engine/bin/bison-flex/custom_build_rules/docs/6.png new file mode 100644 index 0000000000000000000000000000000000000000..5f51155ffb93e3e16ca6db013db5033f5a5b949b GIT binary patch literal 15611 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 Ck!u(L literal 0 HcmV?d00001 diff --git a/Engine/bin/bison-flex/custom_build_rules/docs/BisonProperties.png b/Engine/bin/bison-flex/custom_build_rules/docs/BisonProperties.png new file mode 100644 index 0000000000000000000000000000000000000000..309365884771fa0c6be1086bcf17ae0b9ec5dfc4 GIT binary patch literal 27186 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 literal 0 HcmV?d00001 diff --git a/Engine/bin/bison-flex/custom_build_rules/docs/Properties.png b/Engine/bin/bison-flex/custom_build_rules/docs/Properties.png new file mode 100644 index 0000000000000000000000000000000000000000..e636e764fe0d03d42a2c16ff0c6ec11efc560266 GIT binary patch literal 31446 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 literal 0 HcmV?d00001 diff --git a/Engine/bin/bison-flex/custom_build_rules/docs/Verbosity.png b/Engine/bin/bison-flex/custom_build_rules/docs/Verbosity.png new file mode 100644 index 0000000000000000000000000000000000000000..b2997ba70a49d96ef05f409364103e6a9ab91411 GIT binary patch literal 29722 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 Jg~Ix;{vS=7cLM+b literal 0 HcmV?d00001 diff --git a/Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.props b/Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.props new file mode 100644 index 000000000..d27b3a4b0 --- /dev/null +++ b/Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.props @@ -0,0 +1,23 @@ + + + + Midl + CustomBuild + + + _SelectedFiles;$(BisonDependsOn) + + + + %(Filename).tab.cpp + %(Filename).tab.h + +start /B /WAIT /D "%(RootDir)%(Directory)" win_bison.exe [AllOptions] [AdditionalOptions] "%(Filename)%(Extension)" +exit /b %errorlevel% + %(RootDir)%(Directory)%(OutputFile);%(RootDir)%(Directory)%(DefinesFile); + Process "%(Filename)%(Extension)" bison file + + + \ No newline at end of file diff --git a/Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.targets b/Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.targets new file mode 100644 index 000000000..feb0de252 --- /dev/null +++ b/Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.targets @@ -0,0 +1,91 @@ + + + + + + BisonTarget + + + + $(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml + + + + + + + + @(Bison, '|') + + + + + + + + + $(ComputeLinkInputsTargets); + ComputeBisonOutput; + + + $(ComputeLibInputsTargets); + ComputeBisonOutput; + + + + + + + + + + + + \ No newline at end of file diff --git a/Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.xml b/Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.xml new file mode 100644 index 000000000..1d51e6260 --- /dev/null +++ b/Engine/bin/bison-flex/custom_build_rules/win_bison_only/win_bison_custom_build.xml @@ -0,0 +1,281 @@ + + + + + + + + + + General + + + + + Bison Options + + + + + Command Line + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Execute Before + + + Specifies the targets for the build customization to run before. + + + + + + + + + + + Execute After + + + Specifies the targets for the build customization to run after. + + + + + + + + + + + + + + Additional Options + + + Additional Options + + + + + + + \ No newline at end of file diff --git a/Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.props b/Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.props new file mode 100644 index 000000000..17317d6cb --- /dev/null +++ b/Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.props @@ -0,0 +1,43 @@ + + + + Midl + CustomBuild + + + _SelectedFiles;$(BisonDependsOn) + + + + %(Filename).tab.cpp + %(Filename).tab.h + +start /B /WAIT /D "%(RootDir)%(Directory)" win_bison.exe [AllOptions] [AdditionalOptions] "%(Filename)%(Extension)" +exit /b %errorlevel% + %(RootDir)%(Directory)%(OutputFile);%(RootDir)%(Directory)%(DefinesFile); + Process "%(Filename)%(Extension)" bison file + + + + Midl + CustomBuild + + + _SelectedFiles;$(FlexDependsOn) + + + + %(Filename).flex.cpp + true + +start /B /WAIT /D "%(RootDir)%(Directory)" win_flex.exe [AllOptions] [AdditionalOptions] "%(Filename)%(Extension)" +exit /b %errorlevel% + %(RootDir)%(Directory)%(OutputFile); + Process "%(Filename)%(Extension)" flex file + + + \ No newline at end of file diff --git a/Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.targets b/Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.targets new file mode 100644 index 000000000..2fabf7453 --- /dev/null +++ b/Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.targets @@ -0,0 +1,178 @@ + + + + + + BisonTarget + + + FlexTarget + + + + $(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml + + + $(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml + + + + + + + + @(Bison, '|') + + + + + + + + + $(ComputeLinkInputsTargets); + ComputeBisonOutput; + + + $(ComputeLibInputsTargets); + ComputeBisonOutput; + + + + + + + + + + + + + + + + + + @(Flex, '|') + + + + + + + + + $(ComputeLinkInputsTargets); + ComputeFlexOutput; + + + $(ComputeLibInputsTargets); + ComputeFlexOutput; + + + + + + + + + + + + \ No newline at end of file diff --git a/Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.xml b/Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.xml new file mode 100644 index 000000000..20c429ca2 --- /dev/null +++ b/Engine/bin/bison-flex/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.xml @@ -0,0 +1,521 @@ + + + + + + + + + + General + + + + + Bison Options + + + + + Command Line + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Execute Before + + + Specifies the targets for the build customization to run before. + + + + + + + + + + + Execute After + + + Specifies the targets for the build customization to run after. + + + + + + + + + + + + + + Additional Options + + + Additional Options + + + + + + + + + + + + + + General + + + + + Flex Options + + + + + Command Line + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Execute Before + + + Specifies the targets for the build customization to run before. + + + + + + + + + + + Execute After + + + Specifies the targets for the build customization to run after. + + + + + + + + + + + + + + Additional Options + + + Additional Options + + + + + + + \ No newline at end of file diff --git a/Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.props b/Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.props new file mode 100644 index 000000000..9203b4ae0 --- /dev/null +++ b/Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.props @@ -0,0 +1,23 @@ + + + + Midl + CustomBuild + + + _SelectedFiles;$(FlexDependsOn) + + + + %(Filename).flex.cpp + true + +start /B /WAIT /D "%(RootDir)%(Directory)" win_flex.exe [AllOptions] [AdditionalOptions] "%(Filename)%(Extension)" +exit /b %errorlevel% + %(RootDir)%(Directory)%(OutputFile); + Process "%(Filename)%(Extension)" flex file + + + \ No newline at end of file diff --git a/Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.targets b/Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.targets new file mode 100644 index 000000000..2e8155507 --- /dev/null +++ b/Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.targets @@ -0,0 +1,94 @@ + + + + + + FlexTarget + + + + $(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml + + + + + + + + @(Flex, '|') + + + + + + + + + $(ComputeLinkInputsTargets); + ComputeFlexOutput; + + + $(ComputeLibInputsTargets); + ComputeFlexOutput; + + + + + + + + + + + + \ No newline at end of file diff --git a/Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.xml b/Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.xml new file mode 100644 index 000000000..a47157445 --- /dev/null +++ b/Engine/bin/bison-flex/custom_build_rules/win_flex_only/win_flex_custom_build.xml @@ -0,0 +1,243 @@ + + + + + + + + + + General + + + + + Flex Options + + + + + Command Line + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Execute Before + + + Specifies the targets for the build customization to run before. + + + + + + + + + + + Execute After + + + Specifies the targets for the build customization to run after. + + + + + + + + + + + + + + Additional Options + + + Additional Options + + + + + + + \ No newline at end of file diff --git a/Engine/bin/bison-flex/data/README.md b/Engine/bin/bison-flex/data/README.md new file mode 100644 index 000000000..09886ea81 --- /dev/null +++ b/Engine/bin/bison-flex/data/README.md @@ -0,0 +1,227 @@ +This directory contains data needed by Bison. + +# Directory Content +## Skeletons +Bison skeletons: the general shapes of the different parser kinds, that are +specialized for specific grammars by the bison program. + +Currently, the supported skeletons are: + +- yacc.c + It used to be named bison.simple: it corresponds to C Yacc + compatible LALR(1) parsers. + +- lalr1.cc + Produces a C++ parser class. + +- lalr1.java + Produces a Java parser class. + +- glr.c + A Generalized LR C parser based on Bison's LALR(1) tables. + +- glr.cc + A Generalized LR C++ parser. Actually a C++ wrapper around glr.c. + +These skeletons are the only ones supported by the Bison team. Because the +interface between skeletons and the bison program is not finished, *we are +not bound to it*. In particular, Bison is not mature enough for us to +consider that "foreign skeletons" are supported. + +## m4sugar +This directory contains M4sugar, sort of an extended library for M4, which +is used by Bison to instantiate the skeletons. + +## xslt +This directory contains XSLT programs that transform Bison's XML output into +various formats. + +- bison.xsl + A library of routines used by the other XSLT programs. + +- xml2dot.xsl + Conversion into GraphViz's dot format. + +- xml2text.xsl + Conversion into text. + +- xml2xhtml.xsl + Conversion into XHTML. + +# Implementation Notes About the Skeletons + +"Skeleton" in Bison parlance means "backend": a skeleton is fed by the bison +executable with LR tables, facts about the symbols, etc. and they generate +the output (say parser.cc, parser.hh, location.hh, etc.). They are only in +charge of generating the parser and its auxiliary files, they do not +generate the XML output, the parser.output reports, nor the graphical +rendering. + +The bits of information passing from bison to the backend is named +"muscles". Muscles are passed to M4 via its standard input: it's a set of +m4 definitions. To see them, use `--trace=muscles`. + +Except for muscles, whose names are generated by bison, the skeletons have +no constraint at all on the macro names: there is no technical/theoretical +limitation, as long as you generate the output, you can do what you want. +However, of course, that would be a bad idea if, say, the C and C++ +skeletons used different approaches and had completely different +implementations. That would be a maintenance nightmare. + +Below, we document some of the macros that we use in several of the +skeletons. If you are to write a new skeleton, please, implement them for +your language. Overall, be sure to follow the same patterns as the existing +skeletons. + +## Vocabulary + +We use "formal arguments", or "formals" for short, to denote the declared +parameters of a function (e.g., `int argc, const char **argv`). Yes, this +is somewhat contradictory with `param` in the `%param` directives. + +We use "effective arguments", or "args" for short, to denote the values +passed in function calls (e.g., `argc, argv`). + +## Symbols + +### `b4_symbol(NUM, FIELD)` +In order to unify the handling of the various aspects of symbols (tag, type +name, whether terminal, etc.), bison.exe defines one macro per (token, +field), where field can `has_id`, `id`, etc.: see +`prepare_symbol_definitions()` in `src/output.c`. + +NUM can be: +- `empty` to denote the "empty" pseudo-symbol when it exists, +- `eof`, `error`, or `undef` +- a symbol number. + +FIELD can be: + +- `has_id`: 0 or 1 + Whether the symbol has an `id`. + +- `id`: string (e.g., `exp`, `NUM`, or `TOK_NUM` with api.token.prefix) + If `has_id`, the name of the token kind (prefixed by api.token.prefix if + defined), otherwise empty. Guaranteed to be usable as a C identifier. + This is used to define the token kind (i.e., the enum used by the return + value of yylex). Should be named `token_kind`. + +- `tag`: string + A human readable representation of the symbol. Can be `'foo'`, + `'foo.id'`, `'"foo"'` etc. + +- `code`: integer + The token code associated to the token kind `id`. + The external number as used by yylex. Can be ASCII code when a character, + some number chosen by bison, or some user number in the case of `%token + FOO `. Corresponds to `yychar` in `yacc.c`. + +- `is_token`: 0 or 1 + Whether this is a terminal symbol. + +- `kind_base`: string (e.g., `YYSYMBOL_exp`, `YYSYMBOL_NUM`) + The base of the symbol kind, i.e., the enumerator of this symbol (token or + nonterminal) which is mapped to its `number`. + +- `kind`: string + Same as `kind_base`, but possibly with a prefix in some languages. E.g., + EOF's `kind_base` and `kind` are `YYSYMBOL_YYEOF` in C, but are + `S_YYEMPTY` and `symbol_kind::S_YYEMPTY` in C++. + +- `number`: integer + The code associated to the `kind`. + The internal number (computed from the external number by yytranslate). + Corresponds to yytoken in yacc.c. This is the same number that serves as + key in b4_symbol(NUM, FIELD). + + In bison, symbols are first assigned increasing numbers in order of + appearance (but tokens first, then nterms). After grammar reduction, + unused nterms are then renumbered to appear last (i.e., first tokens, then + used nterms and finally unused nterms). This final number NUM is the one + contained in this field, and it is the one used as key in `b4_symbol(NUM, + FIELD)`. + + The code of the rule actions, however, is emitted before we know what + symbols are unused, so they use the original numbers. To avoid confusion, + they actually use "orig NUM" instead of just "NUM". bison also emits + definitions for `b4_symbol(orig NUM, number)` that map from original + numbers to the new ones. `b4_symbol` actually resolves `orig NUM` in the + other case, i.e., `b4_symbol(orig 42, tag)` would return the tag of the + symbols whose original number was 42. + +- `has_type`: 0, 1 + Whether has a semantic value. + +- `type_tag`: string + When api.value.type=union, the generated name for the union member. + yytype_INT etc. for symbols that has_id, otherwise yytype_1 etc. + +- `type`: string + If it has a semantic value, its type tag, or, if variant are used, + its type. + In the case of api.value.type=union, type is the real type (e.g. int). + +- `slot`: string + If it has a semantic value, the name of the union member (i.e., bounces to + either `type_tag` or `type`). It would be better to fix our mess and + always use `type` for the true type of the member, and `type_tag` for the + name of the union member. + +- `has_printer`: 0, 1 +- `printer`: string +- `printer_file`: string +- `printer_line`: integer +- `printer_loc`: location + If the symbol has a printer, everything about it. + +- `has_destructor`, `destructor`, `destructor_file`, `destructor_line`, `destructor_loc` + Likewise. + +### `b4_symbol_value(VAL, [SYMBOL-NUM], [TYPE-TAG])` +Expansion of $$, $1, $3, etc. + +The semantic value from a given VAL. +- `VAL`: some semantic value storage (typically a union). e.g., `yylval` +- `SYMBOL-NUM`: the symbol number from which we extract the type tag. +- `TYPE-TAG`, the user forced the ``. + +The result can be used safely, it is put in parens to avoid nasty precedence +issues. + +### `b4_lhs_value(SYMBOL-NUM, [TYPE])` +Expansion of `$$` or `$$`, for symbol `SYMBOL-NUM`. + +### `b4_rhs_data(RULE-LENGTH, POS)` +The data corresponding to the symbol `#POS`, where the current rule has +`RULE-LENGTH` symbols on RHS. + +### `b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE])` +Expansion of `$POS`, where the current rule has `RULE-LENGTH` symbols +on RHS. + + diff --git a/Engine/bin/bison-flex/data/bison-default.css b/Engine/bin/bison-flex/data/bison-default.css new file mode 100644 index 000000000..aadaba178 --- /dev/null +++ b/Engine/bin/bison-flex/data/bison-default.css @@ -0,0 +1,61 @@ +/* Default styling rules for Bison when doing terminal output. + Copyright (C) 2019-2021 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + 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, see . */ + +/* This is an experimental feature. The class names may change in the + future. */ + +/* Diagnostics. */ +.warning { color: purple; } +.error { color: red; } +.note { color: cyan; } + +.fixit-insert { color: green; } + +/* Semantic values in Bison's own parser traces. */ +.value { color: green; } + +/* "Sections" in traces (--trace). */ +.trace0 { color: green; } + +/* Syntax error messages. */ +.expected { color: green; } +.unexpected { color: red; } + + +/* Counterexamples. */ + +/* Cex: point in rule. */ +.cex-dot { color: red; } + +/* Cex: coloring various rules. */ +.cex-0 { color: yellow; } +.cex-1 { color: green; } +.cex-2 { color: blue; } +.cex-3 { color: purple; } +.cex-4 { color: violet; } +.cex-5 { color: orange; } +.cex-6 { color: brown; } +.cex-7 { color: mauve; } +.cex-8 { color: #013220; } /* Dark green. */ +.cex-9 { color: #e75480; } /* Dark pink. */ +.cex-10 { color: cyan; } +.cex-11 { color: orange; } + +/* Cex: derivation rewriting steps. */ +.cex-step { font-style: italic; } + +/* Cex: leaves of a derivation. */ +.cex-leaf { font-weight: 600; } diff --git a/Engine/bin/bison-flex/data/local.mk b/Engine/bin/bison-flex/data/local.mk new file mode 100644 index 000000000..c51d287cc --- /dev/null +++ b/Engine/bin/bison-flex/data/local.mk @@ -0,0 +1,58 @@ +## Copyright (C) 2002, 2005-2015, 2018-2021 Free Software Foundation, +## Inc. + +## This program is free software: you can redistribute it and/or modify +## it under the terms of the GNU General Public License as published by +## 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, see . + +dist_pkgdata_DATA = \ + data/README.md \ + data/bison-default.css + +skeletonsdir = $(pkgdatadir)/skeletons +dist_skeletons_DATA = \ + data/skeletons/bison.m4 \ + data/skeletons/c++-skel.m4 \ + data/skeletons/c++.m4 \ + data/skeletons/c-like.m4 \ + data/skeletons/c-skel.m4 \ + data/skeletons/c.m4 \ + data/skeletons/glr.c \ + data/skeletons/glr.cc \ + data/skeletons/glr2.cc \ + data/skeletons/java-skel.m4 \ + data/skeletons/java.m4 \ + data/skeletons/lalr1.cc \ + data/skeletons/lalr1.java \ + data/skeletons/location.cc \ + data/skeletons/stack.hh \ + data/skeletons/traceon.m4 \ + data/skeletons/variant.hh \ + data/skeletons/yacc.c + +# Experimental support for the D language. +dist_skeletons_DATA += \ + data/skeletons/d-skel.m4 \ + data/skeletons/d.m4 \ + data/skeletons/lalr1.d + +m4sugardir = $(pkgdatadir)/m4sugar +dist_m4sugar_DATA = \ + data/m4sugar/foreach.m4 \ + data/m4sugar/m4sugar.m4 + +xsltdir = $(pkgdatadir)/xslt +dist_xslt_DATA = \ + data/xslt/bison.xsl \ + data/xslt/xml2dot.xsl \ + data/xslt/xml2text.xsl \ + data/xslt/xml2xhtml.xsl diff --git a/Engine/bin/bison-flex/data/m4sugar/foreach.m4 b/Engine/bin/bison-flex/data/m4sugar/foreach.m4 new file mode 100644 index 000000000..2052d44c2 --- /dev/null +++ b/Engine/bin/bison-flex/data/m4sugar/foreach.m4 @@ -0,0 +1,362 @@ +# -*- Autoconf -*- +# This file is part of Autoconf. +# foreach-based replacements for recursive functions. +# Speeds up GNU M4 1.4.x by avoiding quadratic $@ recursion, but penalizes +# GNU M4 1.6 by requiring more memory and macro expansions. +# +# Copyright (C) 2008-2017, 2020 Free Software Foundation, Inc. + +# This file is part of Autoconf. 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 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. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see . + +# Written by Eric Blake. + +# In M4 1.4.x, every byte of $@ is rescanned. This means that an +# algorithm on n arguments that recurses with one less argument each +# iteration will scan n * (n + 1) / 2 arguments, for O(n^2) time. In +# M4 1.6, this was fixed so that $@ is only scanned once, then +# back-references are made to information stored about the scan. +# Thus, n iterations need only scan n arguments, for O(n) time. +# Additionally, in M4 1.4.x, recursive algorithms did not clean up +# memory very well, requiring O(n^2) memory rather than O(n) for n +# iterations. +# +# This file is designed to overcome the quadratic nature of $@ +# recursion by writing a variant of m4_foreach that uses m4_for rather +# than $@ recursion to operate on the list. This involves more macro +# expansions, but avoids the need to rescan a quadratic number of +# arguments, making these replacements very attractive for M4 1.4.x. +# On the other hand, in any version of M4, expanding additional macros +# costs additional time; therefore, in M4 1.6, where $@ recursion uses +# fewer macros, these replacements actually pessimize performance. +# Additionally, the use of $10 to mean the tenth argument violates +# POSIX; although all versions of m4 1.4.x support this meaning, a +# future m4 version may switch to take it as the first argument +# concatenated with a literal 0, so the implementations in this file +# are not future-proof. Thus, this file is conditionally included as +# part of m4_init(), only when it is detected that M4 probably has +# quadratic behavior (ie. it lacks the macro __m4_version__). +# +# Please keep this file in sync with m4sugar.m4. + +# _m4_foreach(PRE, POST, IGNORED, ARG...) +# --------------------------------------- +# Form the common basis of the m4_foreach and m4_map macros. For each +# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion +# easier, and must be supplied rather than implicit. +# +# This version minimizes the number of times that $@ is evaluated by +# using m4_for to generate a boilerplate into _m4_f then passing $@ to +# that temporary macro. Thus, the recursion is done in m4_for without +# reparsing any user input, and is not quadratic. For an idea of how +# this works, note that m4_foreach(i,[1,2],[i]) calls +# _m4_foreach([m4_define([i],],[)i],[],[1],[2]) +# which defines _m4_f: +# $1[$4]$2[]$1[$5]$2[]_m4_popdef([_m4_f]) +# then calls _m4_f([m4_define([i],],[)i],[],[1],[2]) for a net result: +# m4_define([i],[1])i[]m4_define([i],[2])i[]_m4_popdef([_m4_f]). +m4_define([_m4_foreach], +[m4_if([$#], [3], [], + [m4_pushdef([_m4_f], _m4_for([4], [$#], [1], + [$0_([1], [2],], [)])[_m4_popdef([_m4_f])])_m4_f($@)])]) + +m4_define([_m4_foreach_], +[[$$1[$$3]$$2[]]]) + +# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) +# ----------------------------------------------------------- +# Find the first VAL that SWITCH matches, and expand the corresponding +# IF-VAL. If there are no matches, expand DEFAULT. +# +# Use m4_for to create a temporary macro in terms of a boilerplate +# m4_if with final cleanup. If $# is even, we have DEFAULT; if it is +# odd, then rounding the last $# up in the temporary macro is +# harmless. For example, both m4_case(1,2,3,4,5) and +# m4_case(1,2,3,4,5,6) result in the intermediate _m4_case being +# m4_if([$1],[$2],[$3],[$1],[$4],[$5],_m4_popdef([_m4_case])[$6]) +m4_define([m4_case], +[m4_if(m4_eval([$# <= 2]), [1], [$2], +[m4_pushdef([_$0], [m4_if(]_m4_for([2], m4_eval([($# - 1) / 2 * 2]), [2], + [_$0_(], [)])[_m4_popdef( + [_$0])]m4_dquote($m4_eval([($# + 1) & ~1]))[)])_$0($@)])]) + +m4_define([_m4_case_], +[$0_([1], [$1], m4_incr([$1]))]) + +m4_define([_m4_case__], +[[[$$1],[$$2],[$$3],]]) + +# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) +# ----------------------------------------------------- +# m4 equivalent of +# +# if (SWITCH =~ RE1) +# VAL1; +# elif (SWITCH =~ RE2) +# VAL2; +# elif ... +# ... +# else +# DEFAULT +# +# We build the temporary macro _m4_b: +# m4_define([_m4_b], _m4_defn([_m4_bmatch]))_m4_b([$1], [$2], [$3])... +# _m4_b([$1], [$m-1], [$m])_m4_b([], [], [$m+1]_m4_popdef([_m4_b])) +# then invoke m4_unquote(_m4_b($@)), for concatenation with later text. +m4_define([m4_bmatch], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [$2], + [m4_pushdef([_m4_b], [m4_define([_m4_b], + _m4_defn([_$0]))]_m4_for([3], m4_eval([($# + 1) / 2 * 2 - 1]), + [2], [_$0_(], [)])[_m4_b([], [],]m4_dquote([$]m4_eval( + [($# + 1) / 2 * 2]))[_m4_popdef([_m4_b]))])m4_unquote(_m4_b($@))])]) + +m4_define([_m4_bmatch], +[m4_if(m4_bregexp([$1], [$2]), [-1], [], [[$3]m4_define([$0])])]) + +m4_define([_m4_bmatch_], +[$0_([1], m4_decr([$1]), [$1])]) + +m4_define([_m4_bmatch__], +[[_m4_b([$$1], [$$2], [$$3])]]) + + +# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) +# ------------------------------------------------------------------- +# Similar to m4_if, except that each TEST is expanded when encountered. +# If the expansion of TESTn matches the string VALn, the result is IF-VALn. +# The result is DEFAULT if no tests passed. This macro allows +# short-circuiting of expensive tests, where it pays to arrange quick +# filter tests to run first. +# +# m4_cond already guarantees either 3*n or 3*n + 1 arguments, 1 <= n. +# We only have to speed up _m4_cond, by building the temporary _m4_c: +# m4_define([_m4_c], _m4_defn([m4_unquote]))_m4_c([m4_if(($1), [($2)], +# [[$3]m4_define([_m4_c])])])_m4_c([m4_if(($4), [($5)], +# [[$6]m4_define([_m4_c])])])..._m4_c([m4_if(($m-2), [($m-1)], +# [[$m]m4_define([_m4_c])])])_m4_c([[$m+1]]_m4_popdef([_m4_c])) +# We invoke m4_unquote(_m4_c($@)), for concatenation with later text. +m4_define([_m4_cond], +[m4_pushdef([_m4_c], [m4_define([_m4_c], + _m4_defn([m4_unquote]))]_m4_for([2], m4_eval([$# / 3 * 3 - 1]), [3], + [$0_(], [)])[_m4_c(]m4_dquote(m4_dquote( + [$]m4_eval([$# / 3 * 3 + 1])))[_m4_popdef([_m4_c]))])m4_unquote(_m4_c($@))]) + +m4_define([_m4_cond_], +[$0_(m4_decr([$1]), [$1], m4_incr([$1]))]) + +m4_define([_m4_cond__], +[[_m4_c([m4_if(($$1), [($$2)], [[$$3]m4_define([_m4_c])])])]]) + +# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# m4_bpatsubsts already validated an odd number of arguments; we only +# need to speed up _m4_bpatsubsts. To avoid nesting, we build the +# temporary _m4_p: +# m4_define([_m4_p], [$1])m4_define([_m4_p], +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$2], [$3]))m4_define([_m4_p], +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$4], [$5]))m4_define([_m4_p],... +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$m-1], [$m]))m4_unquote( +# _m4_defn([_m4_p])_m4_popdef([_m4_p])) +m4_define([_m4_bpatsubsts], +[m4_pushdef([_m4_p], [m4_define([_m4_p], + ]m4_dquote([$]1)[)]_m4_for([3], [$#], [2], [$0_(], + [)])[m4_unquote(_m4_defn([_m4_p])_m4_popdef([_m4_p]))])_m4_p($@)]) + +m4_define([_m4_bpatsubsts_], +[$0_(m4_decr([$1]), [$1])]) + +m4_define([_m4_bpatsubsts__], +[[m4_define([_m4_p], +m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$$1], [$$2]))]]) + +# m4_shiftn(N, ...) +# ----------------- +# Returns ... shifted N times. Useful for recursive "varargs" constructs. +# +# m4_shiftn already validated arguments; we only need to speed up +# _m4_shiftn. If N is 3, then we build the temporary _m4_s, defined as +# ,[$5],[$6],...,[$m]_m4_popdef([_m4_s]) +# before calling m4_shift(_m4_s($@)). +m4_define([_m4_shiftn], +[m4_if(m4_incr([$1]), [$#], [], [m4_pushdef([_m4_s], + _m4_for(m4_eval([$1 + 2]), [$#], [1], + [[,]m4_dquote($], [)])[_m4_popdef([_m4_s])])m4_shift(_m4_s($@))])]) + +# m4_do(STRING, ...) +# ------------------ +# This macro invokes all its arguments (in sequence, of course). It is +# useful for making your macros more structured and readable by dropping +# unnecessary dnl's and have the macros indented properly. +# +# Here, we use the temporary macro _m4_do, defined as +# $1[]$2[]...[]$n[]_m4_popdef([_m4_do]) +m4_define([m4_do], +[m4_if([$#], [0], [], + [m4_pushdef([_$0], _m4_for([1], [$#], [1], + [$], [[[]]])[_m4_popdef([_$0])])_$0($@)])]) + +# m4_dquote_elt(ARGS) +# ------------------- +# Return ARGS as an unquoted list of double-quoted arguments. +# +# _m4_foreach to the rescue. +m4_define([m4_dquote_elt], +[m4_if([$#], [0], [], [[[$1]]_m4_foreach([,m4_dquote(], [)], $@)])]) + +# m4_reverse(ARGS) +# ---------------- +# Output ARGS in reverse order. +# +# Invoke _m4_r($@) with the temporary _m4_r built as +# [$m], [$m-1], ..., [$2], [$1]_m4_popdef([_m4_r]) +m4_define([m4_reverse], +[m4_if([$#], [0], [], [$#], [1], [[$1]], +[m4_pushdef([_m4_r], [[$$#]]_m4_for(m4_decr([$#]), [1], [-1], + [[, ]m4_dquote($], [)])[_m4_popdef([_m4_r])])_m4_r($@)])]) + + +# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) +# ------------------------------------------------------------- +# Perform a pairwise grouping of consecutive ARGs, by expanding +# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the +# final argument is expanded with END-EXPR([ARGn]). +# +# Build the temporary macro _m4_map_args_pair, with the $2([$m+1]) +# only output if $# is odd: +# $1([$3], [$4])[]$1([$5], [$6])[]...$1([$m-1], +# [$m])[]m4_default([$2], [$1])([$m+1])[]_m4_popdef([_m4_map_args_pair]) +m4_define([m4_map_args_pair], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], + [$#], [2], [], + [$#], [3], [m4_default([$2], [$1])([$3])[]], + [m4_pushdef([_$0], _m4_for([3], + m4_eval([$# / 2 * 2 - 1]), [2], [_$0_(], [)])_$0_end( + [1], [2], [$#])[_m4_popdef([_$0])])_$0($@)])]) + +m4_define([_m4_map_args_pair_], +[$0_([1], [$1], m4_incr([$1]))]) + +m4_define([_m4_map_args_pair__], +[[$$1([$$2], [$$3])[]]]) + +m4_define([_m4_map_args_pair_end], +[m4_if(m4_eval([$3 & 1]), [1], [[m4_default([$$2], [$$1])([$$3])[]]])]) + +# m4_join(SEP, ARG1, ARG2...) +# --------------------------- +# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG +# is the empty string. No expansion is performed on SEP or ARGs. +# +# Use a self-modifying separator, since we don't know how many +# arguments might be skipped before a separator is first printed, but +# be careful if the separator contains $. _m4_foreach to the rescue. +m4_define([m4_join], +[m4_pushdef([_m4_sep], [m4_define([_m4_sep], _m4_defn([m4_echo]))])]dnl +[_m4_foreach([_$0([$1],], [)], $@)_m4_popdef([_m4_sep])]) + +m4_define([_m4_join], +[m4_if([$2], [], [], [_m4_sep([$1])[$2]])]) + +# m4_joinall(SEP, ARG1, ARG2...) +# ------------------------------ +# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. +# No expansion is performed on SEP or ARGs. +# +# A bit easier than m4_join. _m4_foreach to the rescue. +m4_define([m4_joinall], +[[$2]m4_if(m4_eval([$# <= 2]), [1], [], + [_m4_foreach([$1], [], m4_shift($@))])]) + +# m4_list_cmp(A, B) +# ----------------- +# Compare the two lists of integer expressions A and B. +# +# m4_list_cmp takes care of any side effects; we only override +# _m4_list_cmp_raw, where we can safely expand lists multiple times. +# First, insert padding so that both lists are the same length; the +# trailing +0 is necessary to handle a missing list. Next, create a +# temporary macro to perform pairwise comparisons until an inequality +# is found. For example, m4_list_cmp([1], [1,2]) creates _m4_cmp as +# m4_if(m4_eval([($1) != ($3)]), [1], [m4_cmp([$1], [$3])], +# m4_eval([($2) != ($4)]), [1], [m4_cmp([$2], [$4])], +# [0]_m4_popdef([_m4_cmp])) +# then calls _m4_cmp([1+0], [0*2], [1], [2+0]) +m4_define([_m4_list_cmp_raw], +[m4_if([$1], [$2], 0, + [_m4_list_cmp($1+0_m4_list_pad(m4_count($1), m4_count($2)), + $2+0_m4_list_pad(m4_count($2), m4_count($1)))])]) + +m4_define([_m4_list_pad], +[m4_if(m4_eval($1 < $2), [1], + [_m4_for(m4_incr([$1]), [$2], [1], [,0*])])]) + +m4_define([_m4_list_cmp], +[m4_pushdef([_m4_cmp], [m4_if(]_m4_for( + [1], m4_eval([$# >> 1]), [1], [$0_(], [,]m4_eval([$# >> 1])[)])[ + [0]_m4_popdef([_m4_cmp]))])_m4_cmp($@)]) + +m4_define([_m4_list_cmp_], +[$0_([$1], m4_eval([$1 + $2]))]) + +m4_define([_m4_list_cmp__], +[[m4_eval([($$1) != ($$2)]), [1], [m4_cmp([$$1], [$$2])], +]]) + +# m4_max(EXPR, ...) +# m4_min(EXPR, ...) +# ----------------- +# Return the decimal value of the maximum (or minimum) in a series of +# integer expressions. +# +# _m4_foreach to the rescue; we only need to replace _m4_minmax. Here, +# we need a temporary macro to track the best answer so far, so that +# the foreach expression is tractable. +m4_define([_m4_minmax], +[m4_pushdef([_m4_best], m4_eval([$2]))_m4_foreach( + [m4_define([_m4_best], $1(_m4_best,], [))], m4_shift($@))]dnl +[_m4_best[]_m4_popdef([_m4_best])]) + +# m4_set_add_all(SET, VALUE...) +# ----------------------------- +# Add each VALUE into SET. This is O(n) in the number of VALUEs, and +# can be faster than calling m4_set_add for each VALUE. +# +# _m4_foreach to the rescue. If no deletions have occurred, then +# avoid the speed penalty of m4_set_add. +m4_define([m4_set_add_all], +[m4_if([$#], [0], [], [$#], [1], [], + [m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) + + m4_len(_m4_foreach(m4_ifdef([_m4_set_cleanup($1)], + [[m4_set_add]], [[_$0]])[([$1],], [)], $@))))])]) + +m4_define([_m4_set_add_all], +[m4_ifdef([_m4_set([$1],$2)], [], + [m4_define([_m4_set([$1],$2)], + [1])m4_pushdef([_m4_set([$1])], [$2])-])]) diff --git a/Engine/bin/bison-flex/data/m4sugar/m4sugar.m4 b/Engine/bin/bison-flex/data/m4sugar/m4sugar.m4 new file mode 100644 index 000000000..b42fc1a6d --- /dev/null +++ b/Engine/bin/bison-flex/data/m4sugar/m4sugar.m4 @@ -0,0 +1,3329 @@ +divert(-1)# -*- Autoconf -*- +# This file is part of Autoconf. +# Base M4 layer. +# Requires GNU M4. +# +# Copyright (C) 1999-2017, 2020 Free Software Foundation, Inc. + +# This file is part of Autoconf. 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 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. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see . + +# Written by Akim Demaille. + +# Set the quotes, whatever the current quoting system. +changequote() +changequote([, ]) + +# Some old m4's don't support m4exit. But they provide +# equivalent functionality by core dumping because of the +# long macros we define. +ifdef([__gnu__], , +[errprint(M4sugar requires GNU M4. Install it before installing M4sugar or +set the M4 environment variable to its absolute file name.) +m4exit(2)]) + + +## ------------------------------- ## +## 1. Simulate --prefix-builtins. ## +## ------------------------------- ## + +# m4_define +# m4_defn +# m4_undefine +define([m4_define], defn([define])) +define([m4_defn], defn([defn])) +define([m4_undefine], defn([undefine])) + +m4_undefine([define]) +m4_undefine([defn]) +m4_undefine([undefine]) + + +# m4_copy(SRC, DST) +# ----------------- +# Define DST as the definition of SRC. +# What's the difference between: +# 1. m4_copy([from], [to]) +# 2. m4_define([to], [from($@)]) +# Well, obviously 1 is more expensive in space. Maybe 2 is more expensive +# in time, but because of the space cost of 1, it's not that obvious. +# Nevertheless, one huge difference is the handling of `$0'. If `from' +# uses `$0', then with 1, `to''s `$0' is `to', while it is `from' in 2. +# The user would certainly prefer to see `to'. +# +# This definition is in effect during m4sugar initialization, when +# there are no pushdef stacks; later on, we redefine it to something +# more powerful for all other clients to use. +m4_define([m4_copy], +[m4_define([$2], m4_defn([$1]))]) + + +# m4_rename(SRC, DST) +# ------------------- +# Rename the macro SRC to DST. +m4_define([m4_rename], +[m4_copy([$1], [$2])m4_undefine([$1])]) + + +# m4_rename_m4(MACRO-NAME) +# ------------------------ +# Rename MACRO-NAME to m4_MACRO-NAME. +m4_define([m4_rename_m4], +[m4_rename([$1], [m4_$1])]) + + +# m4_copy_unm4(m4_MACRO-NAME) +# --------------------------- +# Copy m4_MACRO-NAME to MACRO-NAME. +m4_define([m4_copy_unm4], +[m4_copy([$1], m4_bpatsubst([$1], [^m4_\(.*\)], [[\1]]))]) + + +# Some m4 internals have names colliding with tokens we might use. +# Rename them a` la `m4 --prefix-builtins'. Conditionals first, since +# some subsequent renames are conditional. +m4_rename_m4([ifdef]) +m4_rename([ifelse], [m4_if]) + +m4_rename_m4([builtin]) +m4_rename_m4([changecom]) +m4_rename_m4([changequote]) +m4_ifdef([changeword],dnl conditionally available in 1.4.x +[m4_undefine([changeword])]) +m4_rename_m4([debugfile]) +m4_rename_m4([debugmode]) +m4_rename_m4([decr]) +m4_rename_m4([divnum]) +m4_rename_m4([dumpdef]) +m4_rename_m4([errprint]) +m4_rename_m4([esyscmd]) +m4_rename_m4([eval]) +m4_rename_m4([format]) +m4_undefine([include]) +m4_rename_m4([incr]) +m4_rename_m4([index]) +m4_rename_m4([indir]) +m4_rename_m4([len]) +m4_rename([m4exit], [m4_exit]) +m4_undefine([m4wrap]) +m4_ifdef([mkstemp],dnl added in M4 1.4.8 +[m4_rename_m4([mkstemp]) +m4_copy([m4_mkstemp], [m4_maketemp]) +m4_undefine([maketemp])], +[m4_rename_m4([maketemp]) +m4_copy([m4_maketemp], [m4_mkstemp])]) +m4_rename([patsubst], [m4_bpatsubst]) +m4_rename_m4([popdef]) +m4_rename_m4([pushdef]) +m4_rename([regexp], [m4_bregexp]) +m4_rename_m4([shift]) +m4_undefine([sinclude]) +m4_rename_m4([substr]) +m4_ifdef([symbols],dnl present only in alpha-quality 1.4o +[m4_rename_m4([symbols])]) +m4_rename_m4([syscmd]) +m4_rename_m4([sysval]) +m4_rename_m4([traceoff]) +m4_rename_m4([traceon]) +m4_rename_m4([translit]) + +# _m4_defn(ARG) +# ------------- +# _m4_defn is for internal use only - it bypasses the wrapper, so it +# must only be used on one argument at a time, and only on macros +# known to be defined. Make sure this still works if the user renames +# m4_defn but not _m4_defn. +m4_copy([m4_defn], [_m4_defn]) + +# _m4_divert_raw(NUM) +# ------------------- +# _m4_divert_raw is for internal use only. Use this instead of +# m4_builtin([divert], NUM), so that tracing diversion flow is easier. +m4_rename([divert], [_m4_divert_raw]) + +# _m4_popdef(ARG...) +# ------------------ +# _m4_popdef is for internal use only - it bypasses the wrapper, so it +# must only be used on macros known to be defined. Make sure this +# still works if the user renames m4_popdef but not _m4_popdef. +m4_copy([m4_popdef], [_m4_popdef]) + +# _m4_undefine(ARG...) +# -------------------- +# _m4_undefine is for internal use only - it bypasses the wrapper, so +# it must only be used on macros known to be defined. Make sure this +# still works if the user renames m4_undefine but not _m4_undefine. +m4_copy([m4_undefine], [_m4_undefine]) + +# _m4_undivert(NUM...) +# -------------------- +# _m4_undivert is for internal use only, and should always be given +# arguments. Use this instead of m4_builtin([undivert], NUM...), so +# that tracing diversion flow is easier. +m4_rename([undivert], [_m4_undivert]) + + +## ------------------- ## +## 2. Error messages. ## +## ------------------- ## + + +# m4_location +# ----------- +# Output the current file, colon, and the current line number. +m4_define([m4_location], +[__file__:__line__]) + + +# m4_errprintn(MSG) +# ----------------- +# Same as `errprint', but with the missing end of line. +m4_define([m4_errprintn], +[m4_errprint([$1 +])]) + + +# m4_warning(MSG) +# --------------- +# Warn the user. +m4_define([m4_warning], +[m4_errprintn(m4_location[: warning: $1])]) + + +# m4_fatal(MSG, [EXIT-STATUS]) +# ---------------------------- +# Fatal the user. :) +m4_define([m4_fatal], +[m4_errprintn(m4_location[: error: $1] +m4_expansion_stack)m4_exit(m4_if([$2],, 1, [$2]))]) + + +# m4_assert(EXPRESSION, [EXIT-STATUS = 1]) +# ---------------------------------------- +# This macro ensures that EXPRESSION evaluates to true, and exits if +# EXPRESSION evaluates to false. +m4_define([m4_assert], +[m4_if(m4_eval([$1]), 0, + [m4_fatal([assert failed: $1], [$2])])]) + + + +## ------------- ## +## 3. Warnings. ## +## ------------- ## + + +# _m4_warn(CATEGORY, MESSAGE, [STACK-TRACE]) +# ------------------------------------------ +# Report a MESSAGE to the user if the CATEGORY of warnings is enabled. +# This is for traces only. +# If present, STACK-TRACE is a \n-separated list of "LOCATION: MESSAGE", +# where the last line (and no other) ends with "the top level". +# +# Within m4, the macro is a no-op. This macro really matters +# when autom4te post-processes the trace output. +m4_define([_m4_warn], []) + + +# m4_warn(CATEGORY, MESSAGE) +# -------------------------- +# Report a MESSAGE to the user if the CATEGORY of warnings is enabled. +m4_define([m4_warn], +[_m4_warn([$1], [$2], +m4_ifdef([_m4_expansion_stack], [m4_expansion_stack]))]) + + + +## ------------------- ## +## 4. File inclusion. ## +## ------------------- ## + + +# We also want to neutralize include (and sinclude for symmetry), +# but we want to extend them slightly: warn when a file is included +# several times. This is, in general, a dangerous operation, because +# too many people forget to quote the first argument of m4_define. +# +# For instance in the following case: +# m4_define(foo, [bar]) +# then a second reading will turn into +# m4_define(bar, [bar]) +# which is certainly not what was meant. + +# m4_include_unique(FILE) +# ----------------------- +# Declare that the FILE was loading; and warn if it has already +# been included. +m4_define([m4_include_unique], +[m4_ifdef([m4_include($1)], + [m4_warn([syntax], [file `$1' included several times])])dnl +m4_define([m4_include($1)])]) + + +# m4_include(FILE) +# ---------------- +# Like the builtin include, but warns against multiple inclusions. +m4_define([m4_include], +[m4_include_unique([$1])dnl +m4_builtin([include], [$1])]) + + +# m4_sinclude(FILE) +# ----------------- +# Like the builtin sinclude, but warns against multiple inclusions. +m4_define([m4_sinclude], +[m4_include_unique([$1])dnl +m4_builtin([sinclude], [$1])]) + + + +## ------------------------------------ ## +## 5. Additional branching constructs. ## +## ------------------------------------ ## + +# Both `m4_ifval' and `m4_ifset' tests against the empty string. The +# difference is that `m4_ifset' is specialized on macros. +# +# In case of arguments of macros, eg. $1, it makes little difference. +# In the case of a macro `FOO', you don't want to check `m4_ifval(FOO, +# TRUE)', because if `FOO' expands with commas, there is a shifting of +# the arguments. So you want to run `m4_ifval([FOO])', but then you just +# compare the *string* `FOO' against `', which, of course fails. +# +# So you want the variation `m4_ifset' that expects a macro name as $1. +# If this macro is both defined and defined to a non empty value, then +# it runs TRUE, etc. + + +# m4_ifblank(COND, [IF-BLANK], [IF-TEXT]) +# m4_ifnblank(COND, [IF-TEXT], [IF-BLANK]) +# ---------------------------------------- +# If COND is empty, or consists only of blanks (space, tab, newline), +# then expand IF-BLANK, otherwise expand IF-TEXT. This differs from +# m4_ifval only if COND has just whitespace, but it helps optimize in +# spite of users who mistakenly leave trailing space after what they +# thought was an empty argument: +# macro( +# [] +# ) +# +# Writing one macro in terms of the other causes extra overhead, so +# we inline both definitions. +m4_define([m4_ifblank], +[m4_if(m4_translit([[$1]], [ ][ ][ +]), [], [$2], [$3])]) + +m4_define([m4_ifnblank], +[m4_if(m4_translit([[$1]], [ ][ ][ +]), [], [$3], [$2])]) + + +# m4_ifval(COND, [IF-TRUE], [IF-FALSE]) +# ------------------------------------- +# If COND is not the empty string, expand IF-TRUE, otherwise IF-FALSE. +# Comparable to m4_ifdef. +m4_define([m4_ifval], +[m4_if([$1], [], [$3], [$2])]) + + +# m4_n(TEXT) +# ---------- +# If TEXT is not empty, return TEXT and a new line, otherwise nothing. +m4_define([m4_n], +[m4_if([$1], + [], [], + [$1 +])]) + + +# m4_ifvaln(COND, [IF-TRUE], [IF-FALSE]) +# -------------------------------------- +# Same as `m4_ifval', but add an extra newline to IF-TRUE or IF-FALSE +# unless that argument is empty. +m4_define([m4_ifvaln], +[m4_if([$1], + [], [m4_n([$3])], + [m4_n([$2])])]) + + +# m4_ifset(MACRO, [IF-TRUE], [IF-FALSE]) +# -------------------------------------- +# If MACRO has no definition, or of its definition is the empty string, +# expand IF-FALSE, otherwise IF-TRUE. +m4_define([m4_ifset], +[m4_ifdef([$1], + [m4_ifval(_m4_defn([$1]), [$2], [$3])], + [$3])]) + + +# m4_ifndef(NAME, [IF-NOT-DEFINED], [IF-DEFINED]) +# ----------------------------------------------- +m4_define([m4_ifndef], +[m4_ifdef([$1], [$3], [$2])]) + + +# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) +# ----------------------------------------------------------- +# m4 equivalent of +# switch (SWITCH) +# { +# case VAL1: +# IF-VAL1; +# break; +# case VAL2: +# IF-VAL2; +# break; +# ... +# default: +# DEFAULT; +# break; +# }. +# All the values are optional, and the macro is robust to active +# symbols properly quoted. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_case], +[m4_if([$#], 0, [], + [$#], 1, [], + [$#], 2, [$2], + [$1], [$2], [$3], + [$0([$1], m4_shift3($@))])]) + + +# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) +# ----------------------------------------------------- +# m4 equivalent of +# +# if (SWITCH =~ RE1) +# VAL1; +# elif (SWITCH =~ RE2) +# VAL2; +# elif ... +# ... +# else +# DEFAULT +# +# All the values are optional, and the macro is robust to active symbols +# properly quoted. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_bmatch], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [$2], + [m4_if(m4_bregexp([$1], [$2]), -1, [$0([$1], m4_shift3($@))], + [$3])])]) + +# m4_argn(N, ARGS...) +# ------------------- +# Extract argument N (greater than 0) from ARGS. Example: +# m4_define([b], [B]) +# m4_argn([2], [a], [b], [c]) => b +# +# Rather than using m4_car(m4_shiftn([$1], $@)), we exploit the fact that +# GNU m4 can directly reference any argument, through an indirect macro. +m4_define([m4_argn], +[m4_assert([0 < $1])]dnl +[m4_pushdef([_$0], [_m4_popdef([_$0])]m4_dquote([$]m4_incr([$1])))_$0($@)]) + + +# m4_car(ARGS...) +# m4_cdr(ARGS...) +# --------------- +# Manipulate m4 lists. m4_car returns the first argument. m4_cdr +# bundles all but the first argument into a quoted list. These two +# macros are generally used with list arguments, with quoting removed +# to break the list into multiple m4 ARGS. +m4_define([m4_car], [[$1]]) +m4_define([m4_cdr], +[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], + [$#], 1, [], + [m4_dquote(m4_shift($@))])]) + +# _m4_cdr(ARGS...) +# ---------------- +# Like m4_cdr, except include a leading comma unless only one argument +# remains. Why? Because comparing a large list against [] is more +# expensive in expansion time than comparing the number of arguments; so +# _m4_cdr can be used to reduce the number of arguments when it is time +# to end recursion. +m4_define([_m4_cdr], +[m4_if([$#], 1, [], + [, m4_dquote(m4_shift($@))])]) + + + +# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) +# ------------------------------------------------------------------- +# Similar to m4_if, except that each TEST is expanded when encountered. +# If the expansion of TESTn matches the string VALn, the result is IF-VALn. +# The result is DEFAULT if no tests passed. This macro allows +# short-circuiting of expensive tests, where it pays to arrange quick +# filter tests to run first. +# +# For an example, consider a previous implementation of _AS_QUOTE_IFELSE: +# +# m4_if(m4_index([$1], [\]), [-1], [$2], +# m4_eval(m4_index([$1], [\\]) >= 0), [1], [$2], +# m4_eval(m4_index([$1], [\$]) >= 0), [1], [$2], +# m4_eval(m4_index([$1], [\`]) >= 0), [1], [$3], +# m4_eval(m4_index([$1], [\"]) >= 0), [1], [$3], +# [$2]) +# +# Here, m4_index is computed 5 times, and m4_eval 4, even if $1 contains +# no backslash. It is more efficient to do: +# +# m4_cond([m4_index([$1], [\])], [-1], [$2], +# [m4_eval(m4_index([$1], [\\]) >= 0)], [1], [$2], +# [m4_eval(m4_index([$1], [\$]) >= 0)], [1], [$2], +# [m4_eval(m4_index([$1], [\`]) >= 0)], [1], [$3], +# [m4_eval(m4_index([$1], [\"]) >= 0)], [1], [$3], +# [$2]) +# +# In the common case of $1 with no backslash, only one m4_index expansion +# occurs, and m4_eval is avoided altogether. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_cond], +[m4_if([$#], [0], [m4_fatal([$0: cannot be called without arguments])], + [$#], [1], [$1], + m4_eval([$# % 3]), [2], [m4_fatal([$0: missing an argument])], + [_$0($@)])]) + +m4_define([_m4_cond], +[m4_if(($1), [($2)], [$3], + [$#], [3], [], + [$#], [4], [$4], + [$0(m4_shift3($@))])]) + + +## ---------------------------------------- ## +## 6. Enhanced version of some primitives. ## +## ---------------------------------------- ## + +# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# All the values are optional, and the macro is robust to active symbols +# properly quoted. +# +# I would have liked to name this macro `m4_bpatsubst', unfortunately, +# due to quotation problems, I need to double quote $1 below, therefore +# the anchors are broken :( I can't let users be trapped by that. +# +# Recall that m4_shift3 always results in an argument. Hence, we need +# to distinguish between a final deletion vs. ending recursion. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_bpatsubsts], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2]))], + [$#], 3, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2], [$3]))], + [_$0($@m4_if(m4_eval($# & 1), 0, [,]))])]) +m4_define([_m4_bpatsubsts], +[m4_if([$#], 2, [$1], + [$0(m4_builtin([patsubst], [[$1]], [$2], [$3]), + m4_shift3($@))])]) + + +# m4_copy(SRC, DST) +# ----------------- +# Define the pushdef stack DST as a copy of the pushdef stack SRC; +# give an error if DST is already defined. This is particularly nice +# for copying self-modifying pushdef stacks, where the top definition +# includes one-shot initialization that is later popped to the normal +# definition. This version intentionally does nothing if SRC is +# undefined. +# +# Some macros simply can't be renamed with this method: namely, anything +# involved in the implementation of m4_stack_foreach_sep. +m4_define([m4_copy], +[m4_ifdef([$2], [m4_fatal([$0: won't overwrite defined macro: $2])], + [m4_stack_foreach_sep([$1], [m4_pushdef([$2],], [)])])]dnl +[m4_ifdef([m4_location($1)], [m4_define([m4_location($2)], m4_location)])]) + + +# m4_copy_force(SRC, DST) +# m4_rename_force(SRC, DST) +# ------------------------- +# Like m4_copy/m4_rename, except blindly overwrite any existing DST. +# Note that m4_copy_force tolerates undefined SRC, while m4_rename_force +# does not. +m4_define([m4_copy_force], +[m4_ifdef([$2], [_m4_undefine([$2])])m4_copy($@)]) + +m4_define([m4_rename_force], +[m4_ifdef([$2], [_m4_undefine([$2])])m4_rename($@)]) + + +# m4_define_default(MACRO, VALUE) +# ------------------------------- +# If MACRO is undefined, set it to VALUE. +m4_define([m4_define_default], +[m4_ifndef([$1], [m4_define($@)])]) + + +# m4_default(EXP1, EXP2) +# m4_default_nblank(EXP1, EXP2) +# ----------------------------- +# Returns EXP1 if not empty/blank, otherwise EXP2. Expand the result. +# +# m4_default is called on hot paths, so inline the contents of m4_ifval, +# for one less round of expansion. +m4_define([m4_default], +[m4_if([$1], [], [$2], [$1])]) + +m4_define([m4_default_nblank], +[m4_ifblank([$1], [$2], [$1])]) + + +# m4_default_quoted(EXP1, EXP2) +# m4_default_nblank_quoted(EXP1, EXP2) +# ------------------------------------ +# Returns EXP1 if non empty/blank, otherwise EXP2. Leave the result quoted. +# +# For comparison: +# m4_define([active], [ACTIVE]) +# m4_default([active], [default]) => ACTIVE +# m4_default([], [active]) => ACTIVE +# -m4_default([ ], [active])- => - - +# -m4_default_nblank([ ], [active])- => -ACTIVE- +# m4_default_quoted([active], [default]) => active +# m4_default_quoted([], [active]) => active +# -m4_default_quoted([ ], [active])- => - - +# -m4_default_nblank_quoted([ ], [active])- => -active- +# +# m4_default macro is called on hot paths, so inline the contents of m4_ifval, +# for one less round of expansion. +m4_define([m4_default_quoted], +[m4_if([$1], [], [[$2]], [[$1]])]) + +m4_define([m4_default_nblank_quoted], +[m4_ifblank([$1], [[$2]], [[$1]])]) + + +# m4_defn(NAME) +# ------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). This replacement is not a full-featured +# replacement: if any of the defined macros contain unbalanced quoting, but +# when pasted together result in a well-quoted string, then only native m4 +# support is able to get it correct. But that's where quadrigraphs come in +# handy, if you really need unbalanced quotes inside your macros. +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_defn], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_defn([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + + +# m4_dumpdef(NAME...) +# ------------------- +# In m4 1.4.x, dumpdef writes to the current debugfile, rather than +# stderr. This in turn royally confuses autom4te; so we follow the +# lead of newer m4 and always dump to stderr. Unlike the original, +# this version requires an argument, since there is no convenient way +# in m4 1.4.x to grab the names of all defined macros. Newer m4 +# always dumps to stderr, regardless of the current debugfile; it also +# provides m4symbols as a way to grab all current macro names. But +# dumpdefs is not frequently called, so we don't need to worry about +# conditionally using these newer features. Also, this version +# doesn't sort multiple arguments. +# +# If we detect m4 1.6 or newer, then provide an alternate definition, +# installed during m4_init, that allows builtins through. +# Unfortunately, there is no nice way in m4 1.4.x to dump builtins. +m4_define([m4_dumpdef], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_ifdef([$1], [m4_errprintn( + [$1: ]m4_dquote(_m4_defn([$1])))], [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + +m4_define([_m4_dumpdef], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_builtin([dumpdef], [$1])], + [m4_map_args_sep([m4_builtin([dumpdef],], [)], [], $@)])]) + + +# m4_dumpdefs(NAME...) +# -------------------- +# Similar to `m4_dumpdef(NAME)', but if NAME was m4_pushdef'ed, display its +# value stack (most recent displayed first). Also, this version silently +# ignores undefined macros, rather than erroring out. +# +# This macro cheats, because it relies on the current definition of NAME +# while the second argument of m4_stack_foreach_lifo is evaluated (which +# would be undefined according to the API). +m4_define([m4_dumpdefs], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_stack_foreach_lifo([$1], [m4_dumpdef([$1])m4_ignore])], + [m4_map_args([$0], $@)])]) + +# m4_esyscmd_s(COMMAND) +# --------------------- +# Like m4_esyscmd, except strip any trailing newlines, thus behaving +# more like shell command substitution. +m4_define([m4_esyscmd_s], +[m4_chomp_all(m4_esyscmd([$1]))]) + + +# m4_popdef(NAME) +# --------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_popdef], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_popdef([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + + +# m4_shiftn(N, ...) +# ----------------- +# Returns ... shifted N times. Useful for recursive "varargs" constructs. +# +# Autoconf does not use this macro, because it is inherently slower than +# calling the common cases of m4_shift2 or m4_shift3 directly. But it +# might as well be fast for other clients, such as Libtool. One way to +# do this is to expand $@ only once in _m4_shiftn (otherwise, for long +# lists, the expansion of m4_if takes twice as much memory as what the +# list itself occupies, only to throw away the unused branch). The end +# result is strictly equivalent to +# m4_if([$1], 1, [m4_shift(,m4_shift(m4_shift($@)))], +# [_m4_shiftn(m4_decr([$1]), m4_shift(m4_shift($@)))]) +# but with the final `m4_shift(m4_shift($@)))' shared between the two +# paths. The first leg uses a no-op m4_shift(,$@) to balance out the (). +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_shiftn], +[m4_assert(0 < $1 && $1 < $#)_$0($@)]) + +m4_define([_m4_shiftn], +[m4_if([$1], 1, [m4_shift(], + [$0(m4_decr([$1])]), m4_shift(m4_shift($@)))]) + +# m4_shift2(...) +# m4_shift3(...) +# -------------- +# Returns ... shifted twice, and three times. Faster than m4_shiftn. +m4_define([m4_shift2], [m4_shift(m4_shift($@))]) +m4_define([m4_shift3], [m4_shift(m4_shift(m4_shift($@)))]) + +# _m4_shift2(...) +# _m4_shift3(...) +# --------------- +# Like m4_shift2 or m4_shift3, except include a leading comma unless shifting +# consumes all arguments. Why? Because in recursion, it is nice to +# distinguish between 1 element left and 0 elements left, based on how many +# arguments this shift expands to. +m4_define([_m4_shift2], +[m4_if([$#], [2], [], + [, m4_shift(m4_shift($@))])]) +m4_define([_m4_shift3], +[m4_if([$#], [3], [], + [, m4_shift(m4_shift(m4_shift($@)))])]) + + +# m4_undefine(NAME) +# ----------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_undefine], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_undefine([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + +# _m4_wrap(PRE, POST) +# ------------------- +# Helper macro for m4_wrap and m4_wrap_lifo. Allows nested calls to +# m4_wrap within wrapped text. Use _m4_defn and _m4_popdef for speed. +m4_define([_m4_wrap], +[m4_ifdef([$0_text], + [m4_define([$0_text], [$1]_m4_defn([$0_text])[$2])], + [m4_builtin([m4wrap], [m4_unquote( + _m4_defn([$0_text])_m4_popdef([$0_text]))])m4_define([$0_text], [$1$2])])]) + +# m4_wrap(TEXT) +# ------------- +# Append TEXT to the list of hooks to be executed at the end of input. +# Whereas the order of the original may be LIFO in the underlying m4, +# this version is always FIFO. +m4_define([m4_wrap], +[_m4_wrap([], [$1[]])]) + +# m4_wrap_lifo(TEXT) +# ------------------ +# Prepend TEXT to the list of hooks to be executed at the end of input. +# Whereas the order of m4_wrap may be FIFO in the underlying m4, this +# version is always LIFO. +m4_define([m4_wrap_lifo], +[_m4_wrap([$1[]])]) + +## ------------------------- ## +## 7. Quoting manipulation. ## +## ------------------------- ## + + +# m4_apply(MACRO, LIST) +# --------------------- +# Invoke MACRO, with arguments provided from the quoted list of +# comma-separated quoted arguments. If LIST is empty, invoke MACRO +# without arguments. The expansion will not be concatenated with +# subsequent text. +m4_define([m4_apply], +[m4_if([$2], [], [$1], [$1($2)])[]]) + +# _m4_apply(MACRO, LIST) +# ---------------------- +# Like m4_apply, except do nothing if LIST is empty. +m4_define([_m4_apply], +[m4_if([$2], [], [], [$1($2)[]])]) + + +# m4_count(ARGS) +# -------------- +# Return a count of how many ARGS are present. +m4_define([m4_count], [$#]) + + +# m4_curry(MACRO, ARG...) +# ----------------------- +# Perform argument currying. The expansion of this macro is another +# macro that takes exactly one argument, appends it to the end of the +# original ARG list, then invokes MACRO. For example: +# m4_curry([m4_curry], [m4_reverse], [1])([2])([3]) => 3, 2, 1 +# Not quite as practical as m4_incr, but you could also do: +# m4_define([add], [m4_eval(([$1]) + ([$2]))]) +# m4_define([add_one], [m4_curry([add], [1])]) +# add_one()([2]) => 3 +m4_define([m4_curry], [$1(m4_shift($@,)_$0]) +m4_define([_m4_curry], [[$1])]) + + +# m4_do(STRING, ...) +# ------------------ +# This macro invokes all its arguments (in sequence, of course). It is +# useful for making your macros more structured and readable by dropping +# unnecessary dnl's and have the macros indented properly. No concatenation +# occurs after a STRING; use m4_unquote(m4_join(,STRING)) for that. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_do], +[m4_if([$#], 0, [], + [$#], 1, [$1[]], + [$1[]$0(m4_shift($@))])]) + + +# m4_dquote(ARGS) +# --------------- +# Return ARGS as a quoted list of quoted arguments. +m4_define([m4_dquote], [[$@]]) + + +# m4_dquote_elt(ARGS) +# ------------------- +# Return ARGS as an unquoted list of double-quoted arguments. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_dquote_elt], +[m4_if([$#], [0], [], + [$#], [1], [[[$1]]], + [[[$1]],$0(m4_shift($@))])]) + + +# m4_echo(ARGS) +# ------------- +# Return the ARGS, with the same level of quoting. Whitespace after +# unquoted commas are consumed. +m4_define([m4_echo], [$@]) + + +# m4_expand(ARG) +# _m4_expand(ARG) +# --------------- +# Return the expansion of ARG as a single string. Unlike +# m4_quote($1), this preserves whitespace following single-quoted +# commas that appear within ARG. It also deals with shell case +# statements. +# +# m4_define([active], [ACT, IVE]) +# m4_define([active2], [[ACT, IVE]]) +# m4_quote(active, active2) +# => ACT,IVE,ACT, IVE +# m4_expand([active, active2]) +# => ACT, IVE, ACT, IVE +# +# Unfortunately, due to limitations in m4, ARG must expand to +# something with balanced quotes (use quadrigraphs to get around +# this), and should not contain the unlikely delimiters -=<{( or +# )}>=-. It is possible to have unbalanced quoted `(' or `)', as well +# as unbalanced unquoted `)'. m4_expand can handle unterminated +# comments or dnl on the final line, at the expense of speed; it also +# aids in detecting attempts to incorrectly change the current +# diversion inside ARG. Meanwhile, _m4_expand is faster but must be +# given a terminated expansion, and has no safety checks for +# mis-diverted text. +# +# Exploit that extra unquoted () will group unquoted commas and the +# following whitespace. m4_bpatsubst can't handle newlines inside $1, +# and m4_substr strips quoting. So we (ab)use m4_changequote, using +# temporary quotes to remove the delimiters that conveniently included +# the unquoted () that were added prior to the changequote. +# +# Thanks to shell case statements, too many people are prone to pass +# underquoted `)', so we try to detect that by passing a marker as a +# fourth argument; if the marker is not present, then we assume that +# we encountered an early `)', and re-expand the first argument, but +# this time with one more `(' in the second argument and in the +# open-quote delimiter. We must also ignore the slop from the +# previous try. The final macro is thus half line-noise, half art. +m4_define([m4_expand], +[m4_pushdef([m4_divert], _m4_defn([_m4_divert_unsafe]))]dnl +[m4_pushdef([m4_divert_push], _m4_defn([_m4_divert_unsafe]))]dnl +[m4_chomp(_$0([$1 +]))_m4_popdef([m4_divert], [m4_divert_push])]) + +m4_define([_m4_expand], [$0_([$1], [(], -=<{($1)}>=-, [}>=-])]) + +m4_define([_m4_expand_], +[m4_if([$4], [}>=-], + [m4_changequote([-=<{$2], [)}>=-])$3m4_changequote([, ])], + [$0([$1], [($2], -=<{($2$1)}>=-, [}>=-])m4_ignore$2])]) + + +# m4_ignore(ARGS) +# --------------- +# Expands to nothing. Useful for conditionally ignoring an arbitrary +# number of arguments (see _m4_list_cmp for an example). +m4_define([m4_ignore]) + + +# m4_make_list(ARGS) +# ------------------ +# Similar to m4_dquote, this creates a quoted list of quoted ARGS. This +# version is less efficient than m4_dquote, but separates each argument +# with a comma and newline, rather than just comma, for readability. +# When developing an m4sugar algorithm, you could temporarily use +# m4_pushdef([m4_dquote],m4_defn([m4_make_list])) +# around your code to make debugging easier. +m4_define([m4_make_list], [m4_join([, +], m4_dquote_elt($@))]) + + +# m4_noquote(STRING) +# ------------------ +# Return the result of ignoring all quotes in STRING and invoking the +# macros it contains. Among other things, this is useful for enabling +# macro invocations inside strings with [] blocks (for instance regexps +# and help-strings). On the other hand, since all quotes are disabled, +# any macro expanded during this time that relies on nested [] quoting +# will likely crash and burn. This macro is seldom useful; consider +# m4_unquote or m4_expand instead. +m4_define([m4_noquote], +[m4_changequote([-=<{(],[)}>=-])$1-=<{()}>=-m4_changequote([,])]) + + +# m4_quote(ARGS) +# -------------- +# Return ARGS as a single argument. Any whitespace after unquoted commas +# is stripped. There is always output, even when there were no arguments. +# +# It is important to realize the difference between `m4_quote(exp)' and +# `[exp]': in the first case you obtain the quoted *result* of the +# expansion of EXP, while in the latter you just obtain the string +# `exp'. +m4_define([m4_quote], [[$*]]) + + +# _m4_quote(ARGS) +# --------------- +# Like m4_quote, except that when there are no arguments, there is no +# output. For conditional scenarios (such as passing _m4_quote as the +# macro name in m4_mapall), this feature can be used to distinguish between +# one argument of the empty string vs. no arguments. However, in the +# normal case with arguments present, this is less efficient than m4_quote. +m4_define([_m4_quote], +[m4_if([$#], [0], [], [[$*]])]) + + +# m4_reverse(ARGS) +# ---------------- +# Output ARGS in reverse order. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_reverse], +[m4_if([$#], [0], [], [$#], [1], [[$1]], + [$0(m4_shift($@)), [$1]])]) + + +# m4_unquote(ARGS) +# ---------------- +# Remove one layer of quotes from each ARG, performing one level of +# expansion. For one argument, m4_unquote([arg]) is more efficient than +# m4_do([arg]), but for multiple arguments, the difference is that +# m4_unquote separates arguments with commas while m4_do concatenates. +# Follow this macro with [] if concatenation with subsequent text is +# undesired. +m4_define([m4_unquote], [$*]) + + +## -------------------------- ## +## 8. Implementing m4 loops. ## +## -------------------------- ## + + +# m4_for(VARIABLE, FIRST, LAST, [STEP = +/-1], EXPRESSION) +# -------------------------------------------------------- +# Expand EXPRESSION defining VARIABLE to FROM, FROM + 1, ..., TO with +# increments of STEP. Both limits are included, and bounds are +# checked for consistency. The algorithm is robust to indirect +# VARIABLE names. Changing VARIABLE inside EXPRESSION will not impact +# the number of iterations. +# +# Uses _m4_defn for speed, and avoid dnl in the macro body. Factor +# the _m4_for call so that EXPRESSION is only parsed once. +m4_define([m4_for], +[m4_pushdef([$1], m4_eval([$2]))]dnl +[m4_cond([m4_eval(([$3]) > ([$2]))], 1, + [m4_pushdef([_m4_step], m4_eval(m4_default_quoted([$4], + 1)))m4_assert(_m4_step > 0)_$0(_m4_defn([$1]), + m4_eval((([$3]) - ([$2])) / _m4_step * _m4_step + ([$2])), _m4_step,], + [m4_eval(([$3]) < ([$2]))], 1, + [m4_pushdef([_m4_step], m4_eval(m4_default_quoted([$4], + -1)))m4_assert(_m4_step < 0)_$0(_m4_defn([$1]), + m4_eval((([$2]) - ([$3])) / -(_m4_step) * _m4_step + ([$2])), _m4_step,], + [m4_pushdef([_m4_step])_$0(_m4_defn([$1]), _m4_defn([$1]), 0,])]dnl +[[m4_define([$1],], [)$5])m4_popdef([_m4_step], [$1])]) + +# _m4_for(COUNT, LAST, STEP, PRE, POST) +# ------------------------------------- +# Core of the loop, no consistency checks, all arguments are plain +# numbers. Expand PRE[COUNT]POST, then alter COUNT by STEP and +# iterate if COUNT is not LAST. +m4_define([_m4_for], +[$4[$1]$5[]m4_if([$1], [$2], [], + [$0(m4_eval([$1 + $3]), [$2], [$3], [$4], [$5])])]) + + +# Implementing `foreach' loops in m4 is much more tricky than it may +# seem. For example, the old M4 1.4.4 manual had an incorrect example, +# which looked like this (when translated to m4sugar): +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], +# | [m4_pushdef([$1])_foreach([$1], [$2], [$3])m4_popdef([$1])]) +# | m4_define([_arg1], [$1]) +# | m4_define([_foreach], +# | [m4_if([$2], [()], , +# | [m4_define([$1], _arg1$2)$3[]_foreach([$1], (m4_shift$2), [$3])])]) +# +# But then if you run +# +# | m4_define(a, 1) +# | m4_define(b, 2) +# | m4_define(c, 3) +# | foreach([f], [([a], [(b], [c)])], [echo f +# | ]) +# +# it gives +# +# => echo 1 +# => echo (2,3) +# +# which is not what is expected. +# +# Of course the problem is that many quotes are missing. So you add +# plenty of quotes at random places, until you reach the expected +# result. Alternatively, if you are a quoting wizard, you directly +# reach the following implementation (but if you really did, then +# apply to the maintenance of m4sugar!). +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) +# | m4_define([_arg1], [[$1]]) +# | m4_define([_foreach], +# | [m4_if($2, [()], , +# | [m4_define([$1], [_arg1$2])$3[]_foreach([$1], [(m4_shift$2)], [$3])])]) +# +# which this time answers +# +# => echo a +# => echo (b +# => echo c) +# +# Bingo! +# +# Well, not quite. +# +# With a better look, you realize that the parens are more a pain than +# a help: since anyway you need to quote properly the list, you end up +# with always using an outermost pair of parens and an outermost pair +# of quotes. Rejecting the parens both eases the implementation, and +# simplifies the use: +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) +# | m4_define([_arg1], [$1]) +# | m4_define([_foreach], +# | [m4_if($2, [], , +# | [m4_define([$1], [_arg1($2)])$3[]_foreach([$1], [m4_shift($2)], [$3])])]) +# +# +# Now, just replace the `$2' with `m4_quote($2)' in the outer `m4_if' +# to improve robustness, and you come up with a nice implementation +# that doesn't require extra parentheses in the user's LIST. +# +# But wait - now the algorithm is quadratic, because every recursion of +# the algorithm keeps the entire LIST and merely adds another m4_shift to +# the quoted text. If the user has a lot of elements in LIST, you can +# bring the system to its knees with the memory m4 then requires, or trip +# the m4 --nesting-limit recursion factor. The only way to avoid +# quadratic growth is ensure m4_shift is expanded prior to the recursion. +# Hence the design below. +# +# The M4 manual now includes a chapter devoted to this issue, with +# the lessons learned from m4sugar. And still, this design is only +# optimal for M4 1.6; see foreach.m4 for yet more comments on why +# M4 1.4.x uses yet another implementation. + + +# m4_foreach(VARIABLE, LIST, EXPRESSION) +# -------------------------------------- +# +# Expand EXPRESSION assigning each value of the LIST to VARIABLE. +# LIST should have the form `item_1, item_2, ..., item_n', i.e. the +# whole list must *quoted*. Quote members too if you don't want them +# to be expanded. +# +# This macro is robust to active symbols: +# | m4_define(active, [ACT, IVE]) +# | m4_foreach(Var, [active, active], [-Var-]) +# => -ACT--IVE--ACT--IVE- +# +# | m4_foreach(Var, [[active], [active]], [-Var-]) +# => -ACT, IVE--ACT, IVE- +# +# | m4_foreach(Var, [[[active]], [[active]]], [-Var-]) +# => -active--active- +# +# This macro is called frequently, so avoid extra expansions such as +# m4_ifval and dnl. Also, since $2 might be quite large, try to use it +# as little as possible in _m4_foreach; each extra use requires that much +# more memory for expansion. So, rather than directly compare $2 against +# [] and use m4_car/m4_cdr for recursion, we instead unbox the list (which +# requires swapping the argument order in the helper), insert an ignored +# third argument, and use m4_shift3 to detect when recursion is complete, +# at which point this looks very much like m4_map_args. +m4_define([m4_foreach], +[m4_if([$2], [], [], + [m4_pushdef([$1])_$0([m4_define([$1],], [)$3], [], + $2)m4_popdef([$1])])]) + +# _m4_foreach(PRE, POST, IGNORED, ARG...) +# --------------------------------------- +# Form the common basis of the m4_foreach and m4_map macros. For each +# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion +# easier, and must be supplied rather than implicit. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([_m4_foreach], +[m4_if([$#], [3], [], + [$1[$4]$2[]$0([$1], [$2], m4_shift3($@))])]) + + +# m4_foreach_w(VARIABLE, LIST, EXPRESSION) +# ---------------------------------------- +# Like m4_foreach, but the list is whitespace separated. Depending on +# EXPRESSION, it may be more efficient to use m4_map_args_w. +# +# This macro is robust to active symbols: +# m4_foreach_w([Var], [ active +# b act\ +# ive ], [-Var-])end +# => -active--b--active-end +# +# This used to use a slower implementation based on m4_foreach: +# m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3]) +m4_define([m4_foreach_w], +[m4_pushdef([$1])m4_map_args_w([$2], + [m4_define([$1],], [)$3])m4_popdef([$1])]) + + +# m4_map(MACRO, LIST) +# m4_mapall(MACRO, LIST) +# ---------------------- +# Invoke MACRO($1), MACRO($2) etc. where $1, $2... are the elements of +# LIST. $1, $2... must in turn be lists, appropriate for m4_apply. +# If LIST contains an empty sublist, m4_map skips the expansion of +# MACRO, while m4_mapall expands MACRO with no arguments. +# +# Since LIST may be quite large, we want to minimize how often it +# appears in the expansion. Rather than use m4_car/m4_cdr iteration, +# we unbox the list, and use _m4_foreach for iteration. For m4_map, +# an empty list behaves like an empty sublist and gets ignored; for +# m4_mapall, we must special-case the empty list. +m4_define([m4_map], +[_m4_foreach([_m4_apply([$1],], [)], [], $2)]) + +m4_define([m4_mapall], +[m4_if([$2], [], [], + [_m4_foreach([m4_apply([$1],], [)], [], $2)])]) + + +# m4_map_sep(MACRO, [SEPARATOR], LIST) +# m4_mapall_sep(MACRO, [SEPARATOR], LIST) +# --------------------------------------- +# Invoke MACRO($1), SEPARATOR, MACRO($2), ..., MACRO($N) where $1, +# $2... $N are the elements of LIST, and are in turn lists appropriate +# for m4_apply. SEPARATOR is expanded, in order to allow the creation +# of a list of arguments by using a single-quoted comma as the +# separator. For each empty sublist, m4_map_sep skips the expansion +# of MACRO and SEPARATOR, while m4_mapall_sep expands MACRO with no +# arguments. +# +# For m4_mapall_sep, merely expand the first iteration without the +# separator, then include separator as part of subsequent recursion; +# but avoid extra expansion of LIST's side-effects via a helper macro. +# For m4_map_sep, things are trickier - we don't know if the first +# list element is an empty sublist, so we must define a self-modifying +# helper macro and use that as the separator instead. +m4_define([m4_map_sep], +[m4_pushdef([m4_Sep], [m4_define([m4_Sep], _m4_defn([m4_unquote]))])]dnl +[_m4_foreach([_m4_apply([m4_Sep([$2])[]$1],], [)], [], $3)m4_popdef([m4_Sep])]) + +m4_define([m4_mapall_sep], +[m4_if([$3], [], [], [_$0([$1], [$2], $3)])]) + +m4_define([_m4_mapall_sep], +[m4_apply([$1], [$3])_m4_foreach([m4_apply([$2[]$1],], [)], m4_shift2($@))]) + +# m4_map_args(EXPRESSION, ARG...) +# ------------------------------- +# Expand EXPRESSION([ARG]) for each argument. More efficient than +# m4_foreach([var], [ARG...], [EXPRESSION(m4_defn([var]))]) +# Shorthand for m4_map_args_sep([EXPRESSION(], [)], [], ARG...). +m4_define([m4_map_args], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [], + [$#], [2], [$1([$2])[]], + [_m4_foreach([$1(], [)], $@)])]) + + +# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) +# ------------------------------------------------------------- +# Perform a pairwise grouping of consecutive ARGs, by expanding +# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the +# final argument is expanded with END-EXPR([ARGn]). +# +# For example: +# m4_define([show], [($*)m4_newline])dnl +# m4_map_args_pair([show], [], [a], [b], [c], [d], [e])dnl +# => (a,b) +# => (c,d) +# => (e) +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_map_args_pair], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], + [$#], [2], [], + [$#], [3], [m4_default([$2], [$1])([$3])[]], + [$#], [4], [$1([$3], [$4])[]], + [$1([$3], [$4])[]$0([$1], [$2], m4_shift(m4_shift3($@)))])]) + + +# m4_map_args_sep([PRE], [POST], [SEP], ARG...) +# --------------------------------------------- +# Expand PRE[ARG]POST for each argument, with SEP between arguments. +m4_define([m4_map_args_sep], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [], + [$#], [2], [], + [$#], [3], [], + [$#], [4], [$1[$4]$2[]], + [$1[$4]$2[]_m4_foreach([$3[]$1], [$2], m4_shift3($@))])]) + + +# m4_map_args_w(STRING, [PRE], [POST], [SEP]) +# ------------------------------------------- +# Perform the expansion of PRE[word]POST[] for each word in STRING +# separated by whitespace. More efficient than: +# m4_foreach_w([var], [STRING], [PRE[]m4_defn([var])POST]) +# Additionally, expand SEP between words. +# +# As long as we have to use m4_bpatsubst to split the string, we might +# as well make it also apply PRE and POST; this avoids iteration +# altogether. But we must be careful of any \ in PRE or POST. +# _m4_strip returns a quoted string, but that's okay, since it also +# supplies an empty leading and trailing argument due to our +# intentional whitespace around STRING. We use m4_substr to strip the +# empty elements and remove the extra layer of quoting. +m4_define([m4_map_args_w], +[_$0(_m4_split([ ]m4_flatten([$1])[ ], [[ ]+], + m4_if(m4_index([$2$3$4], [\]), [-1], [[$3[]$4[]$2]], + [m4_bpatsubst([[$3[]$4[]$2]], [\\], [\\\\])])), + m4_len([[]$3[]$4]), m4_len([$4[]$2[]]))]) + +m4_define([_m4_map_args_w], +[m4_substr([$1], [$2], m4_eval(m4_len([$1]) - [$2] - [$3]))]) + + +# m4_stack_foreach(MACRO, FUNC) +# m4_stack_foreach_lifo(MACRO, FUNC) +# ---------------------------------- +# Pass each stacked definition of MACRO to the one-argument macro FUNC. +# m4_stack_foreach proceeds in FIFO order, while m4_stack_foreach_lifo +# processes the topmost definitions first. In addition, FUNC should +# not push or pop definitions of MACRO, and should not expect anything about +# the active definition of MACRO (it will not be the topmost, and may not +# be the one passed to FUNC either). +# +# Some macros simply can't be examined with this method: namely, +# anything involved in the implementation of _m4_stack_reverse. +m4_define([m4_stack_foreach], +[_m4_stack_reverse([$1], [m4_tmp-$1])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1], [$2(_m4_defn([m4_tmp-$1]))])]) + +m4_define([m4_stack_foreach_lifo], +[_m4_stack_reverse([$1], [m4_tmp-$1], [$2(_m4_defn([m4_tmp-$1]))])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1])]) + +# m4_stack_foreach_sep(MACRO, [PRE], [POST], [SEP]) +# m4_stack_foreach_sep_lifo(MACRO, [PRE], [POST], [SEP]) +# ------------------------------------------------------ +# Similar to m4_stack_foreach and m4_stack_foreach_lifo, in that every +# definition of a pushdef stack will be visited. But rather than +# passing the definition as a single argument to a macro, this variant +# expands the concatenation of PRE[]definition[]POST, and expands SEP +# between consecutive expansions. Note that m4_stack_foreach([a], [b]) +# is equivalent to m4_stack_foreach_sep([a], [b(], [)]). +m4_define([m4_stack_foreach_sep], +[_m4_stack_reverse([$1], [m4_tmp-$1])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1], [$2[]_m4_defn([m4_tmp-$1])$3], [$4[]])]) + +m4_define([m4_stack_foreach_sep_lifo], +[_m4_stack_reverse([$1], [m4_tmp-$1], [$2[]_m4_defn([m4_tmp-$1])$3], [$4[]])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1])]) + + +# _m4_stack_reverse(OLD, NEW, [ACTION], [SEP]) +# -------------------------------------------- +# A recursive worker for pushdef stack manipulation. Destructively +# copy the OLD stack into the NEW, and expanding ACTION for each +# iteration. After the first iteration, SEP is promoted to the front +# of ACTION (note that SEP should include a trailing [] if it is to +# avoid interfering with ACTION). The current definition is examined +# after the NEW has been pushed but before OLD has been popped; this +# order is important, as ACTION is permitted to operate on either +# _m4_defn([OLD]) or _m4_defn([NEW]). Since the operation is +# destructive, this macro is generally used twice, with a temporary +# macro name holding the swapped copy. +m4_define([_m4_stack_reverse], +[m4_ifdef([$1], [m4_pushdef([$2], + _m4_defn([$1]))$3[]_m4_popdef([$1])$0([$1], [$2], [$4$3])])]) + + + +## --------------------------- ## +## 9. More diversion support. ## +## --------------------------- ## + + +# m4_cleardivert(DIVERSION-NAME...) +# --------------------------------- +# Discard any text in DIVERSION-NAME. +# +# This works even inside m4_expand. +m4_define([m4_cleardivert], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [_m4_divert_raw([-1])m4_undivert($@)_m4_divert_raw( + _m4_divert(_m4_defn([_m4_divert_diversion]), [-]))])]) + + +# _m4_divert(DIVERSION-NAME or NUMBER, [NOWARN]) +# ---------------------------------------------- +# If DIVERSION-NAME is the name of a diversion, return its number, +# otherwise if it is a NUMBER return it. Issue a warning about +# the use of a number instead of a name, unless NOWARN is provided. +m4_define([_m4_divert], +[m4_ifdef([_m4_divert($1)], + [m4_indir([_m4_divert($1)])], + [m4_if([$2], [], [m4_warn([syntax], + [prefer named diversions])])$1])]) + +# KILL is only used to suppress output. +m4_define([_m4_divert(KILL)], -1) + +# The empty diversion name is a synonym for 0. +m4_define([_m4_divert()], 0) + + +# m4_divert_stack +# --------------- +# Print the diversion stack, if it's nonempty. The caller is +# responsible for any leading or trailing newline. +m4_define([m4_divert_stack], +[m4_stack_foreach_sep_lifo([_m4_divert_stack], [], [], [ +])]) + + +# m4_divert_stack_push(MACRO-NAME, DIVERSION-NAME) +# ------------------------------------------------ +# Form an entry of the diversion stack from caller MACRO-NAME and +# entering DIVERSION-NAME and push it. +m4_define([m4_divert_stack_push], +[m4_pushdef([_m4_divert_stack], m4_location[: $1: $2])]) + + +# m4_divert(DIVERSION-NAME) +# ------------------------- +# Change the diversion stream to DIVERSION-NAME. +m4_define([m4_divert], +[m4_popdef([_m4_divert_stack])]dnl +[m4_define([_m4_divert_diversion], [$1])]dnl +[m4_divert_stack_push([$0], [$1])]dnl +[_m4_divert_raw(_m4_divert([$1]))]) + + +# m4_divert_push(DIVERSION-NAME, [NOWARN]) +# ---------------------------------------- +# Change the diversion stream to DIVERSION-NAME, while stacking old values. +# For internal use only: if NOWARN is not empty, DIVERSION-NAME can be a +# number instead of a name. +m4_define([m4_divert_push], +[m4_divert_stack_push([$0], [$1])]dnl +[m4_pushdef([_m4_divert_diversion], [$1])]dnl +[_m4_divert_raw(_m4_divert([$1], [$2]))]) + + +# m4_divert_pop([DIVERSION-NAME]) +# ------------------------------- +# Change the diversion stream to its previous value, unstacking it. +# If specified, verify we left DIVERSION-NAME. +# When we pop the last value from the stack, we divert to -1. +m4_define([m4_divert_pop], +[m4_if([$1], [], [], + [$1], _m4_defn([_m4_divert_diversion]), [], + [m4_fatal([$0($1): diversion mismatch: +]m4_divert_stack)])]dnl +[_m4_popdef([_m4_divert_stack], [_m4_divert_diversion])]dnl +[m4_ifdef([_m4_divert_diversion], [], + [m4_fatal([too many m4_divert_pop])])]dnl +[_m4_divert_raw(_m4_divert(_m4_defn([_m4_divert_diversion]), [-]))]) + + +# m4_divert_text(DIVERSION-NAME, CONTENT) +# --------------------------------------- +# Output CONTENT into DIVERSION-NAME (which may be a number actually). +# An end of line is appended for free to CONTENT. +m4_define([m4_divert_text], +[m4_divert_push([$1])$2 +m4_divert_pop([$1])]) + + +# m4_divert_once(DIVERSION-NAME, CONTENT) +# --------------------------------------- +# Output CONTENT into DIVERSION-NAME once, if not already there. +# An end of line is appended for free to CONTENT. +m4_define([m4_divert_once], +[m4_expand_once([m4_divert_text([$1], [$2])])]) + + +# _m4_divert_unsafe(DIVERSION-NAME) +# --------------------------------- +# Issue a warning that the attempt to change the current diversion to +# DIVERSION-NAME is unsafe, because this macro is being expanded +# during argument collection of m4_expand. +m4_define([_m4_divert_unsafe], +[m4_fatal([$0: cannot change diversion to `$1' inside m4_expand])]) + + +# m4_undivert(DIVERSION-NAME...) +# ------------------------------ +# Undivert DIVERSION-NAME. Unlike the M4 version, this requires at +# least one DIVERSION-NAME; also, due to support for named diversions, +# this should not be used to undivert files. +m4_define([m4_undivert], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [_m4_undivert(_m4_divert([$1]))], + [m4_map_args([$0], $@)])]) + + +## --------------------------------------------- ## +## 10. Defining macros with bells and whistles. ## +## --------------------------------------------- ## + +# `m4_defun' is basically `m4_define' but it equips the macro with the +# needed machinery for `m4_require'. A macro must be m4_defun'd if +# either it is m4_require'd, or it m4_require's. +# +# Two things deserve attention and are detailed below: +# 1. Implementation of m4_require +# 2. Keeping track of the expansion stack +# +# 1. Implementation of m4_require +# =============================== +# +# Of course m4_defun calls m4_provide, so that a macro which has +# been expanded is not expanded again when m4_require'd, but the +# difficult part is the proper expansion of macros when they are +# m4_require'd. +# +# The implementation is based on three ideas, (i) using diversions to +# prepare the expansion of the macro and its dependencies (by Franc,ois +# Pinard), (ii) expand the most recently m4_require'd macros _after_ +# the previous macros (by Axel Thimm), and (iii) track instances of +# provide before require (by Eric Blake). +# +# +# The first idea: why use diversions? +# ----------------------------------- +# +# When a macro requires another, the other macro is expanded in new +# diversion, GROW. When the outer macro is fully expanded, we first +# undivert the most nested diversions (GROW - 1...), and finally +# undivert GROW. To understand why we need several diversions, +# consider the following example: +# +# | m4_defun([TEST1], [Test...m4_require([TEST2])1]) +# | m4_defun([TEST2], [Test...m4_require([TEST3])2]) +# | m4_defun([TEST3], [Test...3]) +# +# Because m4_require is not required to be first in the outer macros, we +# must keep the expansions of the various levels of m4_require separated. +# Right before executing the epilogue of TEST1, we have: +# +# GROW - 2: Test...3 +# GROW - 1: Test...2 +# GROW: Test...1 +# BODY: +# +# Finally the epilogue of TEST1 undiverts GROW - 2, GROW - 1, and +# GROW into the regular flow, BODY. +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: Test...3; Test...2; Test...1 +# +# (The semicolons are here for clarification, but of course are not +# emitted.) This is what Autoconf 2.0 (I think) to 2.13 (I'm sure) +# implement. +# +# +# The second idea: first required first out +# ----------------------------------------- +# +# The natural implementation of the idea above is buggy and produces +# very surprising results in some situations. Let's consider the +# following example to explain the bug: +# +# | m4_defun([TEST1], [m4_require([TEST2a])m4_require([TEST2b])]) +# | m4_defun([TEST2a], []) +# | m4_defun([TEST2b], [m4_require([TEST3])]) +# | m4_defun([TEST3], [m4_require([TEST2a])]) +# | +# | AC_INIT +# | TEST1 +# +# The dependencies between the macros are: +# +# 3 --- 2b +# / \ is m4_require'd by +# / \ left -------------------- right +# 2a ------------ 1 +# +# If you strictly apply the rules given in the previous section you get: +# +# GROW - 2: TEST3 +# GROW - 1: TEST2a; TEST2b +# GROW: TEST1 +# BODY: +# +# (TEST2a, although required by TEST3 is not expanded in GROW - 3 +# because is has already been expanded before in GROW - 1, so it has +# been AC_PROVIDE'd, so it is not expanded again) so when you undivert +# the stack of diversions, you get: +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: TEST3; TEST2a; TEST2b; TEST1 +# +# i.e., TEST2a is expanded after TEST3 although the latter required the +# former. +# +# Starting from 2.50, we use an implementation provided by Axel Thimm. +# The idea is simple: the order in which macros are emitted must be the +# same as the one in which macros are expanded. (The bug above can +# indeed be described as: a macro has been m4_provide'd before its +# dependent, but it is emitted after: the lack of correlation between +# emission and expansion order is guilty). +# +# How to do that? You keep the stack of diversions to elaborate the +# macros, but each time a macro is fully expanded, emit it immediately. +# +# In the example above, when TEST2a is expanded, but it's epilogue is +# not run yet, you have: +# +# GROW - 2: +# GROW - 1: TEST2a +# GROW: Elaboration of TEST1 +# BODY: +# +# The epilogue of TEST2a emits it immediately: +# +# GROW - 2: +# GROW - 1: +# GROW: Elaboration of TEST1 +# BODY: TEST2a +# +# TEST2b then requires TEST3, so right before the epilogue of TEST3, you +# have: +# +# GROW - 2: TEST3 +# GROW - 1: Elaboration of TEST2b +# GROW: Elaboration of TEST1 +# BODY: TEST2a +# +# The epilogue of TEST3 emits it: +# +# GROW - 2: +# GROW - 1: Elaboration of TEST2b +# GROW: Elaboration of TEST1 +# BODY: TEST2a; TEST3 +# +# TEST2b is now completely expanded, and emitted: +# +# GROW - 2: +# GROW - 1: +# GROW: Elaboration of TEST1 +# BODY: TEST2a; TEST3; TEST2b +# +# and finally, TEST1 is finished and emitted: +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: TEST2a; TEST3; TEST2b: TEST1 +# +# The idea is simple, but the implementation is a bit involved. If +# you are like me, you will want to see the actual functioning of this +# implementation to be convinced. The next section gives the full +# details. +# +# +# The Axel Thimm implementation at work +# ------------------------------------- +# +# We consider the macros above, and this configure.ac: +# +# AC_INIT +# TEST1 +# +# You should keep the definitions of _m4_defun_pro, _m4_defun_epi, and +# m4_require at hand to follow the steps. +# +# This implementation tries not to assume that the current diversion is +# BODY, so as soon as a macro (m4_defun'd) is expanded, we first +# record the current diversion under the name _m4_divert_dump (denoted +# DUMP below for short). This introduces an important difference with +# the previous versions of Autoconf: you cannot use m4_require if you +# are not inside an m4_defun'd macro, and especially, you cannot +# m4_require directly from the top level. +# +# We have not tried to simulate the old behavior (better yet, we +# diagnose it), because it is too dangerous: a macro m4_require'd from +# the top level is expanded before the body of `configure', i.e., before +# any other test was run. I let you imagine the result of requiring +# AC_STDC_HEADERS for instance, before AC_PROG_CC was actually run.... +# +# After AC_INIT was run, the current diversion is BODY. +# * AC_INIT was run +# DUMP: undefined +# diversion stack: BODY |- +# +# * TEST1 is expanded +# The prologue of TEST1 sets _m4_divert_dump, which is the diversion +# where the current elaboration will be dumped, to the current +# diversion. It also m4_divert_push to GROW, where the full +# expansion of TEST1 and its dependencies will be elaborated. +# DUMP: BODY +# BODY: empty +# diversions: GROW, BODY |- +# +# * TEST1 requires TEST2a +# _m4_require_call m4_divert_pushes another temporary diversion, +# GROW - 1, and expands TEST2a in there. +# DUMP: BODY +# BODY: empty +# GROW - 1: TEST2a +# diversions: GROW - 1, GROW, BODY |- +# Then the content of the temporary diversion is moved to DUMP and the +# temporary diversion is popped. +# DUMP: BODY +# BODY: TEST2a +# diversions: GROW, BODY |- +# +# * TEST1 requires TEST2b +# Again, _m4_require_call pushes GROW - 1 and heads to expand TEST2b. +# DUMP: BODY +# BODY: TEST2a +# diversions: GROW - 1, GROW, BODY |- +# +# * TEST2b requires TEST3 +# _m4_require_call pushes GROW - 2 and expands TEST3 here. +# (TEST3 requires TEST2a, but TEST2a has already been m4_provide'd, so +# nothing happens.) +# DUMP: BODY +# BODY: TEST2a +# GROW - 2: TEST3 +# diversions: GROW - 2, GROW - 1, GROW, BODY |- +# Then the diversion is appended to DUMP, and popped. +# DUMP: BODY +# BODY: TEST2a; TEST3 +# diversions: GROW - 1, GROW, BODY |- +# +# * TEST1 requires TEST2b (contd.) +# The content of TEST2b is expanded... +# DUMP: BODY +# BODY: TEST2a; TEST3 +# GROW - 1: TEST2b, +# diversions: GROW - 1, GROW, BODY |- +# ... and moved to DUMP. +# DUMP: BODY +# BODY: TEST2a; TEST3; TEST2b +# diversions: GROW, BODY |- +# +# * TEST1 is expanded: epilogue +# TEST1's own content is in GROW... +# DUMP: BODY +# BODY: TEST2a; TEST3; TEST2b +# GROW: TEST1 +# diversions: BODY |- +# ... and it's epilogue moves it to DUMP and then undefines DUMP. +# DUMP: undefined +# BODY: TEST2a; TEST3; TEST2b; TEST1 +# diversions: BODY |- +# +# +# The third idea: track macros provided before they were required +# --------------------------------------------------------------- +# +# Using just the first two ideas, Autoconf 2.50 through 2.63 still had +# a subtle bug for more than seven years. Let's consider the +# following example to explain the bug: +# +# | m4_defun([TEST1], [1]) +# | m4_defun([TEST2], [2[]m4_require([TEST1])]) +# | m4_defun([TEST3], [3 TEST1 m4_require([TEST2])]) +# | TEST3 +# +# After the prologue of TEST3, we are collecting text in GROW with the +# intent of dumping it in BODY during the epilogue. Next, we +# encounter the direct invocation of TEST1, which provides the macro +# in place in GROW. From there, we encounter a requirement for TEST2, +# which must be collected in a new diversion. While expanding TEST2, +# we encounter a requirement for TEST1, but since it has already been +# expanded, the Axel Thimm algorithm states that we can treat it as a +# no-op. But that would lead to an end result of `2 3 1', meaning +# that we have once again output a macro (TEST2) prior to its +# requirements (TEST1). +# +# The problem can only occur if a single defun'd macro first provides, +# then later indirectly requires, the same macro. Note that directly +# expanding then requiring a macro is okay: because the dependency was +# met, the require phase can be a no-op. For that matter, the outer +# macro can even require two helpers, where the first helper expands +# the macro, and the second helper indirectly requires the macro. +# Out-of-order expansion is only present if the inner macro is +# required by something that will be hoisted in front of where the +# direct expansion occurred. In other words, we must be careful not +# to warn on: +# +# | m4_defun([TEST4], [4]) +# | m4_defun([TEST5], [5 TEST4 m4_require([TEST4])]) +# | TEST5 => 5 4 +# +# or even the more complex: +# +# | m4_defun([TEST6], [6]) +# | m4_defun([TEST7], [7 TEST6]) +# | m4_defun([TEST8], [8 m4_require([TEST6])]) +# | m4_defun([TEST9], [9 m4_require([TEST8])]) +# | m4_defun([TEST10], [10 m4_require([TEST7]) m4_require([TEST9])]) +# | TEST10 => 7 6 8 9 10 +# +# So, to detect whether a require was direct or indirect, m4_defun and +# m4_require track the name of the macro that caused a diversion to be +# created (using the stack _m4_diverting, coupled with an O(1) lookup +# _m4_diverting([NAME])), and m4_provide stores the name associated +# with the diversion at which a macro was provided. A require call is +# direct if it occurs within the same diversion where the macro was +# provided, or if the diversion associated with the providing context +# has been collected. +# +# The implementation of the warning involves tracking the set of +# macros which have been provided since the start of the outermost +# defun'd macro (the set is named _m4_provide). When starting an +# outermost macro, the set is emptied; when a macro is provided, it is +# added to the set; when require expands the body of a macro, it is +# removed from the set; and when a macro is indirectly required, the +# set is checked. If a macro is in the set, then it has been provided +# before it was required, and we satisfy dependencies by expanding the +# macro as if it had never been provided; in the example given above, +# this means we now output `1 2 3 1'. Meanwhile, a warning is issued +# to inform the user that her macros trigger the bug in older autoconf +# versions, and that her output file now contains redundant contents +# (and possibly new problems, if the repeated macro was not +# idempotent). Meanwhile, macros defined by m4_defun_once instead of +# m4_defun are idempotent, avoiding any warning or duplicate output. +# +# +# 2. Keeping track of the expansion stack +# ======================================= +# +# When M4 expansion goes wrong it is often extremely hard to find the +# path amongst macros that drove to the failure. What is needed is +# the stack of macro `calls'. One could imagine that GNU M4 would +# maintain a stack of macro expansions, unfortunately it doesn't, so +# we do it by hand. This is of course extremely costly, but the help +# this stack provides is worth it. Nevertheless to limit the +# performance penalty this is implemented only for m4_defun'd macros, +# not for define'd macros. +# +# Each time we enter an m4_defun'd macros, we add a definition in +# _m4_expansion_stack, and when we exit the macro, we remove it (thanks +# to pushdef/popdef). m4_stack_foreach is used to print the expansion +# stack in the rare cases when it's needed. +# +# In addition, we want to detect circular m4_require dependencies. +# Each time we expand a macro FOO we define _m4_expanding(FOO); and +# m4_require(BAR) simply checks whether _m4_expanding(BAR) is defined. + + +# m4_expansion_stack +# ------------------ +# Expands to the entire contents of the expansion stack. The caller +# must supply a trailing newline. This macro always prints a +# location; check whether _m4_expansion_stack is defined to filter out +# the case when no defun'd macro is in force. +m4_define([m4_expansion_stack], +[m4_stack_foreach_sep_lifo([_$0], [_$0_entry(], [) +])m4_location[: the top level]]) + +# _m4_expansion_stack_entry(MACRO) +# -------------------------------- +# Format an entry for MACRO found on the expansion stack. +m4_define([_m4_expansion_stack_entry], +[_m4_defn([m4_location($1)])[: $1 is expanded from...]]) + +# m4_expansion_stack_push(MACRO) +# ------------------------------ +# Form an entry of the expansion stack on entry to MACRO and push it. +m4_define([m4_expansion_stack_push], +[m4_pushdef([_m4_expansion_stack], [$1])]) + + +# _m4_divert(GROW) +# ---------------- +# This diversion is used by the m4_defun/m4_require machinery. It is +# important to keep room before GROW because for each nested +# AC_REQUIRE we use an additional diversion (i.e., two m4_require's +# will use GROW - 2. More than 3 levels has never seemed to be +# needed.) +# +# ... +# - GROW - 2 +# m4_require'd code, 2 level deep +# - GROW - 1 +# m4_require'd code, 1 level deep +# - GROW +# m4_defun'd macros are elaborated here. + +m4_define([_m4_divert(GROW)], 10000) + + +# _m4_defun_pro(MACRO-NAME) +# ------------------------- +# The prologue for Autoconf macros. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and m4_defn overhead. +m4_define([_m4_defun_pro], +[m4_ifdef([_m4_expansion_stack], [], [_m4_defun_pro_outer([$1])])]dnl +[m4_expansion_stack_push([$1])m4_pushdef([_m4_expanding($1)])]) + +m4_define([_m4_defun_pro_outer], +[m4_set_delete([_m4_provide])]dnl +[m4_pushdef([_m4_diverting([$1])])m4_pushdef([_m4_diverting], [$1])]dnl +[m4_pushdef([_m4_divert_dump], m4_divnum)m4_divert_push([GROW])]) + +# _m4_defun_epi(MACRO-NAME) +# ------------------------- +# The Epilogue for Autoconf macros. MACRO-NAME only helps tracing +# the PRO/EPI pairs. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and m4_popdef overhead. +m4_define([_m4_defun_epi], +[_m4_popdef([_m4_expanding($1)], [_m4_expansion_stack])]dnl +[m4_ifdef([_m4_expansion_stack], [], [_m4_defun_epi_outer([$1])])]dnl +[m4_provide([$1])]) + +m4_define([_m4_defun_epi_outer], +[_m4_popdef([_m4_divert_dump], [_m4_diverting([$1])], [_m4_diverting])]dnl +[m4_divert_pop([GROW])m4_undivert([GROW])]) + + +# _m4_divert_dump +# --------------- +# If blank, we are outside of any defun'd macro. Otherwise, expands +# to the diversion number (not name) where require'd macros should be +# moved once completed. +m4_define([_m4_divert_dump]) + + +# m4_divert_require(DIVERSION, NAME-TO-CHECK, [BODY-TO-EXPAND]) +# ------------------------------------------------------------- +# Same as m4_require, but BODY-TO-EXPAND goes into the named DIVERSION; +# requirements still go in the current diversion though. +# +m4_define([m4_divert_require], +[m4_ifdef([_m4_expanding($2)], + [m4_fatal([$0: circular dependency of $2])])]dnl +[m4_if(_m4_divert_dump, [], + [m4_fatal([$0($2): cannot be used outside of an m4_defun'd macro])])]dnl +[m4_provide_if([$2], [], + [_m4_require_call([$2], [$3], _m4_divert([$1], [-]))])]) + + +# m4_defun(NAME, EXPANSION, [MACRO = m4_define]) +# ---------------------------------------------- +# Define a macro NAME which automatically provides itself. Add +# machinery so the macro automatically switches expansion to the +# diversion stack if it is not already using it, prior to EXPANSION. +# In this case, once finished, it will bring back all the code +# accumulated in the diversion stack. This, combined with m4_require, +# achieves the topological ordering of macros. We don't use this +# macro to define some frequently called macros that are not involved +# in ordering constraints, to save m4 processing. +# +# MACRO is an undocumented argument; when set to m4_pushdef, and NAME +# is already defined, the new definition is added to the pushdef +# stack, rather than overwriting the current definition. It can thus +# be used to write self-modifying macros, which pop themselves to a +# previously m4_define'd definition so that subsequent use of the +# macro is faster. +m4_define([m4_defun], +[m4_define([m4_location($1)], m4_location)]dnl +[m4_default([$3], [m4_define])([$1], + [_m4_defun_pro(]m4_dquote($[0])[)$2[]_m4_defun_epi(]m4_dquote($[0])[)])]) + + +# m4_defun_init(NAME, INIT, COMMON) +# --------------------------------- +# Like m4_defun, but split EXPANSION into two portions: INIT which is +# done only the first time NAME is invoked, and COMMON which is +# expanded every time. +# +# For now, the COMMON definition is always m4_define'd, giving an even +# lighter-weight definition. m4_defun allows self-providing, but once +# a macro is provided, m4_require no longer cares if it is m4_define'd +# or m4_defun'd. m4_defun also provides location tracking to identify +# dependency bugs, but once the INIT has been expanded, we know there +# are no dependency bugs. However, if a future use needs COMMON to be +# m4_defun'd, we can add a parameter, similar to the third parameter +# to m4_defun. +m4_define([m4_defun_init], +[m4_define([$1], [$3[]])m4_defun([$1], + [$2[]_m4_popdef(]m4_dquote($[0])[)m4_indir(]m4_dquote($[0])dnl +[m4_if(]m4_dquote($[#])[, [0], [], ]m4_dquote([,$]@)[))], [m4_pushdef])]) + + +# m4_defun_once(NAME, EXPANSION) +# ------------------------------ +# Like m4_defun, but guarantee that EXPANSION only happens once +# (thereafter, using NAME is a no-op). +# +# If _m4_divert_dump is empty, we are called at the top level; +# otherwise, we must ensure that we are required in front of the +# current defun'd macro. Use a helper macro so that EXPANSION need +# only occur once in the definition of NAME, since it might be large. +m4_define([m4_defun_once], +[m4_define([m4_location($1)], m4_location)]dnl +[m4_define([$1], [_m4_defun_once([$1], [$2], m4_if(_m4_divert_dump, [], + [[_m4_defun_pro([$1])m4_unquote(], [)_m4_defun_epi([$1])]], +m4_ifdef([_m4_diverting([$1])], [-]), [-], [[m4_unquote(], [)]], + [[_m4_require_call([$1],], [, _m4_divert_dump)]]))])]) + +m4_define([_m4_defun_once], +[m4_pushdef([$1])$3[$2[]m4_provide([$1])]$4]) + + +# m4_pattern_forbid(ERE, [WHY]) +# ----------------------------- +# Declare that no token matching the forbidden perl extended regular +# expression ERE should be seen in the output unless... +m4_define([m4_pattern_forbid], []) + + +# m4_pattern_allow(ERE) +# --------------------- +# ... that token also matches the allowed extended regular expression ERE. +# Both used via traces, by autom4te post-processing. +m4_define([m4_pattern_allow], []) + + +## --------------------------------- ## +## 11. Dependencies between macros. ## +## --------------------------------- ## + + +# m4_before(THIS-MACRO-NAME, CALLED-MACRO-NAME) +# --------------------------------------------- +# Issue a warning if CALLED-MACRO-NAME was called before THIS-MACRO-NAME. +m4_define([m4_before], +[m4_provide_if([$2], + [m4_warn([syntax], [$2 was called before $1])])]) + + +# m4_require(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK]) +# ----------------------------------------------------------- +# If NAME-TO-CHECK has never been expanded (actually, if it is not +# m4_provide'd), expand BODY-TO-EXPAND *before* the current macro +# expansion; follow the expansion with a newline. Once expanded, emit +# it in _m4_divert_dump. Keep track of the m4_require chain in +# _m4_expansion_stack. +# +# The normal cases are: +# +# - NAME-TO-CHECK == BODY-TO-EXPAND +# Which you can use for regular macros with or without arguments, e.g., +# m4_require([AC_PROG_CC], [AC_PROG_CC]) +# m4_require([AC_CHECK_HEADERS(threads.h)], [AC_CHECK_HEADERS(threads.h)]) +# which is just the same as +# m4_require([AC_PROG_CC]) +# m4_require([AC_CHECK_HEADERS(threads.h)]) +# +# - BODY-TO-EXPAND == m4_indir([NAME-TO-CHECK]) +# In the case of macros with irregular names. For instance: +# m4_require([AC_LANG_COMPILER(C)], [indir([AC_LANG_COMPILER(C)])]) +# which means `if the macro named `AC_LANG_COMPILER(C)' (the parens are +# part of the name, it is not an argument) has not been run, then +# call it.' +# Had you used +# m4_require([AC_LANG_COMPILER(C)], [AC_LANG_COMPILER(C)]) +# then m4_require would have tried to expand `AC_LANG_COMPILER(C)', i.e., +# call the macro `AC_LANG_COMPILER' with `C' as argument. +# +# You could argue that `AC_LANG_COMPILER', when it receives an argument +# such as `C' should dispatch the call to `AC_LANG_COMPILER(C)'. But this +# `extension' prevents `AC_LANG_COMPILER' from having actual arguments that +# it passes to `AC_LANG_COMPILER(C)'. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and other overhead on the common path. +m4_define([m4_require], +[m4_ifdef([_m4_expanding($1)], + [m4_fatal([$0: circular dependency of $1])])]dnl +[m4_if(_m4_divert_dump, [], + [m4_fatal([$0($1): cannot be used outside of an ]dnl +m4_if([$0], [m4_require], [[m4_defun]], [[AC_DEFUN]])['d macro])])]dnl +[m4_provide_if([$1], [m4_set_contains([_m4_provide], [$1], + [_m4_require_check([$1], _m4_defn([m4_provide($1)]), [$0])], [m4_ignore])], + [_m4_require_call])([$1], [$2], _m4_divert_dump)]) + + +# _m4_require_call(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK], +# DIVERSION-NUMBER) +# ----------------------------------------------------------------- +# If m4_require decides to expand the body, it calls this macro. The +# expansion is placed in DIVERSION-NUMBER. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and other overhead on the common path. +# The use of a witness macro protecting the warning allows aclocal +# to silence any warnings when probing for what macros are required +# and must therefore be located, when using the Autoconf-without-aclocal-m4 +# autom4te language. For more background, see: +# https://lists.gnu.org/archive/html/automake-patches/2012-11/msg00035.html +m4_define([_m4_require_call], +[m4_pushdef([_m4_divert_grow], m4_decr(_m4_divert_grow))]dnl +[m4_pushdef([_m4_diverting([$1])])m4_pushdef([_m4_diverting], [$1])]dnl +[m4_divert_push(_m4_divert_grow, [-])]dnl +[m4_if([$2], [], [$1], [$2]) +m4_provide_if([$1], [m4_set_remove([_m4_provide], [$1])], + [m4_ifndef([m4_require_silent_probe], + [m4_warn([syntax], [$1 is m4_require'd but not m4_defun'd])])])]dnl +[_m4_divert_raw($3)_m4_undivert(_m4_divert_grow)]dnl +[m4_divert_pop(_m4_divert_grow)_m4_popdef([_m4_divert_grow], +[_m4_diverting([$1])], [_m4_diverting])]) + + +# _m4_require_check(NAME-TO-CHECK, OWNER, CALLER) +# ----------------------------------------------- +# NAME-TO-CHECK has been identified as previously expanded in the +# diversion owned by OWNER. If this is a problem, warn on behalf of +# CALLER and return _m4_require_call; otherwise return m4_ignore. +m4_define([_m4_require_check], +[m4_if(_m4_defn([_m4_diverting]), [$2], [m4_ignore], + m4_ifdef([_m4_diverting([$2])], [-]), [-], [m4_warn([syntax], + [$3: `$1' was expanded before it was required +https://www.gnu.org/software/autoconf/manual/autoconf.html#Expanded-Before-Required])_m4_require_call], + [m4_ignore])]) + + +# _m4_divert_grow +# --------------- +# The counter for _m4_require_call. +m4_define([_m4_divert_grow], _m4_divert([GROW])) + + +# m4_expand_once(TEXT, [WITNESS = TEXT]) +# -------------------------------------- +# If TEXT has never been expanded, expand it *here*. Use WITNESS as +# as a memory that TEXT has already been expanded. +m4_define([m4_expand_once], +[m4_provide_if(m4_default_quoted([$2], [$1]), + [], + [m4_provide(m4_default_quoted([$2], [$1]))[]$1])]) + + +# m4_provide(MACRO-NAME) +# ---------------------- +m4_define([m4_provide], +[m4_ifdef([m4_provide($1)], [], +[m4_set_add([_m4_provide], [$1], [m4_define([m4_provide($1)], + m4_ifdef([_m4_diverting], [_m4_defn([_m4_diverting])]))])])]) + + +# m4_provide_if(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED) +# ------------------------------------------------------- +# If MACRO-NAME is provided do IF-PROVIDED, else IF-NOT-PROVIDED. +# The purpose of this macro is to provide the user with a means to +# check macros which are provided without letting her know how the +# information is coded. +m4_define([m4_provide_if], +[m4_ifdef([m4_provide($1)], + [$2], [$3])]) + + +## --------------------- ## +## 12. Text processing. ## +## --------------------- ## + + +# m4_cr_letters +# m4_cr_LETTERS +# m4_cr_Letters +# ------------- +m4_define([m4_cr_letters], [abcdefghijklmnopqrstuvwxyz]) +m4_define([m4_cr_LETTERS], [ABCDEFGHIJKLMNOPQRSTUVWXYZ]) +m4_define([m4_cr_Letters], +m4_defn([m4_cr_letters])dnl +m4_defn([m4_cr_LETTERS])dnl +) + + +# m4_cr_digits +# ------------ +m4_define([m4_cr_digits], [0123456789]) + + +# m4_cr_alnum +# ----------- +m4_define([m4_cr_alnum], +m4_defn([m4_cr_Letters])dnl +m4_defn([m4_cr_digits])dnl +) + + +# m4_cr_symbols1 +# m4_cr_symbols2 +# -------------- +m4_define([m4_cr_symbols1], +m4_defn([m4_cr_Letters])dnl +_) + +m4_define([m4_cr_symbols2], +m4_defn([m4_cr_symbols1])dnl +m4_defn([m4_cr_digits])dnl +) + +# m4_cr_all +# --------- +# The character range representing everything, with `-' as the last +# character, since it is special to m4_translit. Use with care, because +# it contains characters special to M4 (fortunately, both ASCII and EBCDIC +# have [] in order, so m4_defn([m4_cr_all]) remains a valid string). It +# also contains characters special to terminals, so it should never be +# displayed in an error message. Also, attempts to map [ and ] to other +# characters via m4_translit must deal with the fact that m4_translit does +# not add quotes to the output. +# +# In EBCDIC, $ is immediately followed by *, which leads to problems +# if m4_cr_all is inlined into a macro definition; so swap them. +# +# It is mainly useful in generating inverted character range maps, for use +# in places where m4_translit is faster than an equivalent m4_bpatsubst; +# the regex `[^a-z]' is equivalent to: +# m4_translit(m4_dquote(m4_defn([m4_cr_all])), [a-z]) +m4_define([m4_cr_all], +m4_translit(m4_dquote(m4_format(m4_dquote(m4_for( + ,1,255,,[[%c]]))m4_for([i],1,255,,[,i]))), [$*-], [*$])-) + + +# _m4_define_cr_not(CATEGORY) +# --------------------------- +# Define m4_cr_not_CATEGORY as the inverse of m4_cr_CATEGORY. +m4_define([_m4_define_cr_not], +[m4_define([m4_cr_not_$1], + m4_translit(m4_dquote(m4_defn([m4_cr_all])), + m4_defn([m4_cr_$1])))]) + + +# m4_cr_not_letters +# m4_cr_not_LETTERS +# m4_cr_not_Letters +# m4_cr_not_digits +# m4_cr_not_alnum +# m4_cr_not_symbols1 +# m4_cr_not_symbols2 +# ------------------ +# Inverse character sets +_m4_define_cr_not([letters]) +_m4_define_cr_not([LETTERS]) +_m4_define_cr_not([Letters]) +_m4_define_cr_not([digits]) +_m4_define_cr_not([alnum]) +_m4_define_cr_not([symbols1]) +_m4_define_cr_not([symbols2]) + + +# m4_newline([STRING]) +# -------------------- +# Expands to a newline, possibly followed by STRING. Exists mostly for +# formatting reasons. +m4_define([m4_newline], [ +$1]) + + +# m4_re_escape(STRING) +# -------------------- +# Escape RE active characters in STRING. +m4_define([m4_re_escape], +[m4_bpatsubst([$1], + [[][*+.?\^$]], [\\\&])]) + + +# m4_re_string +# ------------ +# Regexp for `[a-zA-Z_0-9]*' +# m4_dquote provides literal [] for the character class. +m4_define([m4_re_string], +m4_dquote(m4_defn([m4_cr_symbols2]))dnl +[*]dnl +) + + +# m4_re_word +# ---------- +# Regexp for `[a-zA-Z_][a-zA-Z_0-9]*' +m4_define([m4_re_word], +m4_dquote(m4_defn([m4_cr_symbols1]))dnl +m4_defn([m4_re_string])dnl +) + + +# m4_tolower(STRING) +# m4_toupper(STRING) +# ------------------ +# These macros convert STRING to lowercase or uppercase. +# +# Rather than expand the m4_defn each time, we inline them up front. +m4_define([m4_tolower], +[m4_translit([[$1]], ]m4_dquote(m4_defn([m4_cr_LETTERS]))[, + ]m4_dquote(m4_defn([m4_cr_letters]))[)]) +m4_define([m4_toupper], +[m4_translit([[$1]], ]m4_dquote(m4_defn([m4_cr_letters]))[, + ]m4_dquote(m4_defn([m4_cr_LETTERS]))[)]) + + +# m4_split(STRING, [REGEXP]) +# -------------------------- +# Split STRING into an m4 list of quoted elements. The elements are +# quoted with [ and ]. Beginning spaces and end spaces *are kept*. +# Use m4_strip to remove them. +# +# REGEXP specifies where to split. Default is [\t ]+. +# +# If STRING is empty, the result is an empty list. +# +# Pay attention to the m4_changequotes. When m4 reads the definition of +# m4_split, it still has quotes set to [ and ]. Luckily, these are matched +# in the macro body, so the definition is stored correctly. Use the same +# alternate quotes as m4_noquote; it must be unlikely to appear in $1. +# +# Also, notice that $1 is quoted twice, since we want the result to +# be quoted. Then you should understand that the argument of +# patsubst is -=<{(STRING)}>=- (i.e., with additional -=<{( and )}>=-). +# +# This macro is safe on active symbols, i.e.: +# m4_define(active, ACTIVE) +# m4_split([active active ])end +# => [active], [active], []end +# +# Optimize on regex of ` ' (space), since m4_foreach_w already guarantees +# that the list contains single space separators, and a common case is +# splitting a single-element list. This macro is called frequently, +# so avoid unnecessary dnl inside the definition. +m4_define([m4_split], +[m4_if([$1], [], [], + [$2], [ ], [m4_if(m4_index([$1], [ ]), [-1], [[[$1]]], + [_$0([$1], [$2], [, ])])], + [$2], [], [_$0([$1], [[ ]+], [, ])], + [_$0([$1], [$2], [, ])])]) + +m4_define([_m4_split], +[m4_changequote([-=<{(],[)}>=-])]dnl +[[m4_bpatsubst(-=<{(-=<{($1)}>=-)}>=-, -=<{($2)}>=-, + -=<{(]$3[)}>=-)]m4_changequote([, ])]) + + +# m4_chomp(STRING) +# m4_chomp_all(STRING) +# -------------------- +# Return STRING quoted, but without a trailing newline. m4_chomp +# removes at most one newline, while m4_chomp_all removes all +# consecutive trailing newlines. Embedded newlines are not touched, +# and a trailing backslash-newline leaves just a trailing backslash. +# +# m4_bregexp is slower than m4_index, and we don't always want to +# remove all newlines; hence the two variants. We massage characters +# to give a nicer pattern to match, particularly since m4_bregexp is +# line-oriented. Both versions must guarantee a match, to avoid bugs +# with precision -1 in m4_format in older m4. +m4_define([m4_chomp], +[m4_format([[%.*s]], m4_index(m4_translit([[$1]], [ +/.], [/ ])[./.], [/.]), [$1])]) + +m4_define([m4_chomp_all], +[m4_format([[%.*s]], m4_bregexp(m4_translit([[$1]], [ +/], [/ ]), [/*$]), [$1])]) + + +# m4_flatten(STRING) +# ------------------ +# If STRING contains end of lines, replace them with spaces. If there +# are backslashed end of lines, remove them. This macro is safe with +# active symbols. +# m4_define(active, ACTIVE) +# m4_flatten([active +# act\ +# ive])end +# => active activeend +# +# In m4, m4_bpatsubst is expensive, so first check for a newline. +m4_define([m4_flatten], +[m4_if(m4_index([$1], [ +]), [-1], [[$1]], + [m4_translit(m4_bpatsubst([[[$1]]], [\\ +]), [ +], [ ])])]) + + +# m4_strip(STRING) +# ---------------- +# Expands into STRING with tabs and spaces singled out into a single +# space, and removing leading and trailing spaces. +# +# This macro is robust to active symbols. +# m4_define(active, ACTIVE) +# m4_strip([ active active ])end +# => active activeend +# +# First, notice that we guarantee trailing space. Why? Because regular +# expressions are greedy, and `.* ?' would always group the space into the +# .* portion. The algorithm is simpler by avoiding `?' at the end. The +# algorithm correctly strips everything if STRING is just ` '. +# +# Then notice the second pattern: it is in charge of removing the +# leading/trailing spaces. Why not just `[^ ]'? Because they are +# applied to over-quoted strings, i.e. more or less [STRING], due +# to the limitations of m4_bpatsubsts. So the leading space in STRING +# is the *second* character; equally for the trailing space. +m4_define([m4_strip], +[m4_bpatsubsts([$1 ], + [[ ]+], [ ], + [^. ?\(.*\) .$], [[[\1]]])]) + + +# m4_normalize(STRING) +# -------------------- +# Apply m4_flatten and m4_strip to STRING. +# +# The argument is quoted, so that the macro is robust to active symbols: +# +# m4_define(active, ACTIVE) +# m4_normalize([ act\ +# ive +# active ])end +# => active activeend + +m4_define([m4_normalize], +[m4_strip(m4_flatten([$1]))]) + + +# m4_validate_w(STRING) +# --------------------- +# Expands into m4_normalize(m4_expand([STRING])), but if that is not +# the same as just m4_normalize([STRING]), issue a warning. +# +# This is used in several Autoconf macros that take a +# whitespace-separated list of symbols as an argument. Ideally that +# list would not be expanded before use, but several packages used +# `dnl' to put comments inside those lists, so they must be expanded +# for compatibility's sake. +m4_define([m4_validate_w], +[_m4_validate_w(m4_normalize([$1]), m4_normalize(m4_expand([$1])))]) + +m4_define([_m4_validate_w], +[m4_if([$1], [$2], [], + [m4_warn([obsolete], [whitespace-separated list contains macros; +in a future version of Autoconf they will not be expanded]dnl +m4_if(m4_bregexp([$1], [\bdn[l]\b]), -1, [], [ +note: `dn@&t@l' is a macro]))])dnl +[$2]]) + + +# m4_join(SEP, ARG1, ARG2...) +# --------------------------- +# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG +# is the empty string. No expansion is performed on SEP or ARGs. +# +# Since the number of arguments to join can be arbitrarily long, we +# want to avoid having more than one $@ in the macro definition; +# otherwise, the expansion would require twice the memory of the already +# long list. Hence, m4_join merely looks for the first non-empty element, +# and outputs just that element; while _m4_join looks for all non-empty +# elements, and outputs them following a separator. The final trick to +# note is that we decide between recursing with $0 or _$0 based on the +# nested m4_if ending with `_'. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_join], +[m4_if([$#], [1], [], + [$#], [2], [[$2]], + [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift2($@))])]) +m4_define([_m4_join], +[m4_if([$#$2], [2], [], + [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift2($@))])]) + +# m4_joinall(SEP, ARG1, ARG2...) +# ------------------------------ +# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. +# No expansion is performed on SEP or ARGs. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_joinall], [[$2]_$0([$1], m4_shift($@))]) +m4_define([_m4_joinall], +[m4_if([$#], [2], [], [[$1$3]$0([$1], m4_shift2($@))])]) + +# m4_combine([SEPARATOR], PREFIX-LIST, [INFIX], SUFFIX...) +# -------------------------------------------------------- +# Produce the pairwise combination of every element in the quoted, +# comma-separated PREFIX-LIST with every element from the SUFFIX arguments. +# Each pair is joined with INFIX, and pairs are separated by SEPARATOR. +# No expansion occurs on SEPARATOR, INFIX, or elements of either list. +# +# For example: +# m4_combine([, ], [[a], [b], [c]], [-], [1], [2], [3]) +# => a-1, a-2, a-3, b-1, b-2, b-3, c-1, c-2, c-3 +# +# This definition is a bit hairy; the thing to realize is that we want +# to construct m4_map_args_sep([[prefix$3]], [], [[$1]], m4_shift3($@)) +# as the inner loop, using each prefix generated by the outer loop, +# and without recalculating m4_shift3 every outer iteration. +m4_define([m4_combine], +[m4_if([$2], [], [], m4_eval([$# > 3]), [1], +[m4_map_args_sep([m4_map_args_sep(m4_dquote(], [)[[$3]], [], [[$1]],]]]dnl +[m4_dquote(m4_dquote(m4_shift3($@)))[[)], [[$1]], $2)])]) + + +# m4_append(MACRO-NAME, STRING, [SEPARATOR]) +# ------------------------------------------ +# Redefine MACRO-NAME to hold its former content plus `SEPARATOR`'STRING' +# at the end. It is valid to use this macro with MACRO-NAME undefined, +# in which case no SEPARATOR is added. Be aware that the criterion is +# `not being defined', and not `not being empty'. +# +# Note that neither STRING nor SEPARATOR are expanded here; rather, when +# you expand MACRO-NAME, they will be expanded at that point in time. +# +# This macro is robust to active symbols. It can be used to grow +# strings. +# +# | m4_define(active, ACTIVE)dnl +# | m4_append([sentence], [This is an])dnl +# | m4_append([sentence], [ active ])dnl +# | m4_append([sentence], [symbol.])dnl +# | sentence +# | m4_undefine([active])dnl +# | sentence +# => This is an ACTIVE symbol. +# => This is an active symbol. +# +# It can be used to define hooks. +# +# | m4_define(active, ACTIVE)dnl +# | m4_append([hooks], [m4_define([act1], [act2])])dnl +# | m4_append([hooks], [m4_define([act2], [active])])dnl +# | m4_undefine([active])dnl +# | act1 +# | hooks +# | act1 +# => act1 +# => +# => active +# +# It can also be used to create lists, although this particular usage was +# broken prior to autoconf 2.62. +# | m4_append([list], [one], [, ])dnl +# | m4_append([list], [two], [, ])dnl +# | m4_append([list], [three], [, ])dnl +# | list +# | m4_dquote(list) +# => one, two, three +# => [one],[two],[three] +# +# Note that m4_append can benefit from amortized O(n) m4 behavior, if +# the underlying m4 implementation is smart enough to avoid copying existing +# contents when enlarging a macro's definition into any pre-allocated storage +# (m4 1.4.x unfortunately does not implement this optimization). We do +# not implement m4_prepend, since it is inherently O(n^2) (pre-allocated +# storage only occurs at the end of a macro, so the existing contents must +# always be moved). +# +# Use _m4_defn for speed. +m4_define([m4_append], +[m4_define([$1], m4_ifdef([$1], [_m4_defn([$1])[$3]])[$2])]) + + +# m4_append_uniq(MACRO-NAME, STRING, [SEPARATOR], [IF-UNIQ], [IF-DUP]) +# -------------------------------------------------------------------- +# Like `m4_append', but append only if not yet present. Additionally, +# expand IF-UNIQ if STRING was appended, or IF-DUP if STRING was already +# present. Also, warn if SEPARATOR is not empty and occurs within STRING, +# as the algorithm no longer guarantees uniqueness. +# +# Note that while m4_append can be O(n) (depending on the quality of the +# underlying M4 implementation), m4_append_uniq is inherently O(n^2) +# because each append operation searches the entire string. +m4_define([m4_append_uniq], +[m4_ifval([$3], [m4_if(m4_index([$2], [$3]), [-1], [], + [m4_warn([syntax], + [$0: `$2' contains `$3'])])])_$0($@)]) +m4_define([_m4_append_uniq], +[m4_ifdef([$1], + [m4_if(m4_index([$3]_m4_defn([$1])[$3], [$3$2$3]), [-1], + [m4_append([$1], [$2], [$3])$4], [$5])], + [m4_define([$1], [$2])$4])]) + +# m4_append_uniq_w(MACRO-NAME, STRINGS) +# ------------------------------------- +# For each of the words in the whitespace separated list STRINGS, append +# only the unique strings to the definition of MACRO-NAME. +# +# Use _m4_defn for speed. +m4_define([m4_append_uniq_w], +[m4_map_args_w([$2], [_m4_append_uniq([$1],], [, [ ])])]) + + +# m4_escape(STRING) +# ----------------- +# Output quoted STRING, but with embedded #, $, [ and ] turned into +# quadrigraphs. +# +# It is faster to check if STRING is already good using m4_translit +# than to blindly perform four m4_bpatsubst. +# +# Because the translit is stripping quotes, it must also neutralize +# anything that might be in a macro name, as well as comments, commas, +# and parentheses. All the problem characters are unified so that a +# single m4_index can scan the result. +# +# Rather than expand m4_defn every time m4_escape is expanded, we +# inline its expansion up front. +m4_define([m4_escape], +[m4_if(m4_index(m4_translit([$1], + [[]#,()]]m4_dquote(m4_defn([m4_cr_symbols2]))[, [$$$]), [$]), + [-1], [m4_echo], [_$0])([$1])]) + +m4_define([_m4_escape], +[m4_changequote([-=<{(],[)}>=-])]dnl +[m4_bpatsubst(m4_bpatsubst(m4_bpatsubst(m4_bpatsubst( + -=<{(-=<{(-=<{(-=<{(-=<{($1)}>=-)}>=-)}>=-)}>=-)}>=-, + -=<{(#)}>=-, -=<{(@%:@)}>=-), + -=<{(\[)}>=-, -=<{(@<:@)}>=-), + -=<{(\])}>=-, -=<{(@:>@)}>=-), + -=<{(\$)}>=-, -=<{(@S|@)}>=-)m4_changequote([,])]) + + +# m4_text_wrap(STRING, [PREFIX], [FIRST-PREFIX], [WIDTH]) +# ------------------------------------------------------- +# Expands into STRING wrapped to hold in WIDTH columns (default = 79). +# If PREFIX is given, each line is prefixed with it. If FIRST-PREFIX is +# specified, then the first line is prefixed with it. As a special case, +# if the length of FIRST-PREFIX is greater than that of PREFIX, then +# FIRST-PREFIX will be left alone on the first line. +# +# No expansion occurs on the contents STRING, PREFIX, or FIRST-PREFIX, +# although quadrigraphs are correctly recognized. More precisely, +# you may redefine m4_qlen to recognize whatever escape sequences that +# you will post-process. +# +# Typical outputs are: +# +# m4_text_wrap([Short string */], [ ], [/* ], 20) +# => /* Short string */ +# +# m4_text_wrap([Much longer string */], [ ], [/* ], 20) +# => /* Much longer +# => string */ +# +# m4_text_wrap([Short doc.], [ ], [ --short ], 30) +# => --short Short doc. +# +# m4_text_wrap([Short doc.], [ ], [ --too-wide ], 30) +# => --too-wide +# => Short doc. +# +# m4_text_wrap([Super long documentation.], [ ], [ --too-wide ], 30) +# => --too-wide +# => Super long +# => documentation. +# +# FIXME: there is no checking of a longer PREFIX than WIDTH, but do +# we really want to bother with people trying each single corner +# of a software? +# +# This macro does not leave a trailing space behind the last word of a line, +# which complicates it a bit. The algorithm is otherwise stupid and simple: +# all the words are preceded by m4_Separator which is defined to empty for +# the first word, and then ` ' (single space) for all the others. +# +# The algorithm uses a helper that uses $2 through $4 directly, rather than +# using local variables, to avoid m4_defn overhead, or expansion swallowing +# any $. It also bypasses m4_popdef overhead with _m4_popdef since no user +# macro expansion occurs in the meantime. Also, the definition is written +# with m4_do, to avoid time wasted on dnl during expansion (since this is +# already a time-consuming macro). +m4_define([m4_text_wrap], +[_$0(m4_escape([$1]), [$2], m4_default_quoted([$3], [$2]), + m4_default_quoted([$4], [79]))]) + +m4_define([_m4_text_wrap], +m4_do(dnl set up local variables, to avoid repeated calculations +[[m4_pushdef([m4_Indent], m4_qlen([$2]))]], +[[m4_pushdef([m4_Cursor], m4_qlen([$3]))]], +[[m4_pushdef([m4_Separator], [m4_define([m4_Separator], [ ])])]], +dnl expand the first prefix, then check its length vs. regular prefix +dnl same length: nothing special +dnl prefix1 longer: output on line by itself, and reset cursor +dnl prefix1 shorter: pad to length of prefix, and reset cursor +[[[$3]m4_cond([m4_Cursor], m4_Indent, [], + [m4_eval(m4_Cursor > m4_Indent)], [1], [ +[$2]m4_define([m4_Cursor], m4_Indent)], + [m4_format([%*s], m4_max([0], + m4_eval(m4_Indent - m4_Cursor)), [])m4_define([m4_Cursor], m4_Indent)])]], +dnl now, for each word, compute the cursor after the word is output, then +dnl check if the cursor would exceed the wrap column +dnl if so, reset cursor, and insert newline and prefix +dnl if not, insert the separator (usually a space) +dnl either way, insert the word +[[m4_map_args_w([$1], [$0_word(], [, [$2], [$4])])]], +dnl finally, clean up the local variables +[[_m4_popdef([m4_Separator], [m4_Cursor], [m4_Indent])]])) + +m4_define([_m4_text_wrap_word], +[m4_define([m4_Cursor], m4_eval(m4_Cursor + m4_qlen([$1]) + 1))]dnl +[m4_if(m4_eval(m4_Cursor > ([$3])), + [1], [m4_define([m4_Cursor], m4_eval(m4_Indent + m4_qlen([$1]) + 1)) +[$2]], + [m4_Separator[]])[$1]]) + +# m4_text_box(MESSAGE, [FRAME-CHARACTER = `-']) +# --------------------------------------------- +# Turn MESSAGE into: +# ## ------- ## +# ## MESSAGE ## +# ## ------- ## +# using FRAME-CHARACTER in the border. +# +# Quadrigraphs are correctly recognized. More precisely, you may +# redefine m4_qlen to recognize whatever escape sequences that you +# will post-process. +m4_define([m4_text_box], +[m4_pushdef([m4_Border], + m4_translit(m4_format([[[%*s]]], m4_decr(m4_qlen(_m4_expand([$1 +]))), []), [ ], m4_default_quoted([$2], [-])))]dnl +[[##] _m4_defn([m4_Border]) [##] +[##] $1 [##] +[##] _m4_defn([m4_Border]) [##]_m4_popdef([m4_Border])]) + + +# m4_qlen(STRING) +# --------------- +# Expands to the length of STRING after autom4te converts all quadrigraphs. +# +# If you use some other means of post-processing m4 output rather than +# autom4te, then you may redefine this macro to recognize whatever +# escape sequences your post-processor will handle. For that matter, +# m4_define([m4_qlen], m4_defn([m4_len])) is sufficient if you don't +# do any post-processing. +# +# Avoid bpatsubsts for the common case of no quadrigraphs. Cache +# results, as configure scripts tend to ask about lengths of common +# strings like `/*' and `*/' rather frequently. Minimize the number +# of times that $1 occurs in m4_qlen, so there is less text to parse +# on a cache hit. +m4_define([m4_qlen], +[m4_ifdef([$0-$1], [_m4_defn([$0-]], [_$0(])[$1])]) +m4_define([_m4_qlen], +[m4_define([m4_qlen-$1], +m4_if(m4_index([$1], [@]), [-1], [m4_len([$1])], + [m4_len(m4_bpatsubst([[$1]], + [@\(\(<:\|:>\|S|\|%:\|\{:\|:\}\)\(@\)\|&t@\)], + [\3]))]))_m4_defn([m4_qlen-$1])]) + +# m4_copyright_condense(TEXT) +# --------------------------- +# Condense the copyright notice in TEXT to only display the final +# year, wrapping the results to fit in 80 columns. +m4_define([m4_copyright_condense], +[m4_text_wrap(m4_bpatsubst(m4_flatten([[$1]]), +[(C)[- ,0-9]*\([1-9][0-9][0-9][0-9]\)], [(C) \1]))]) + +## ----------------------- ## +## 13. Number processing. ## +## ----------------------- ## + +# m4_cmp(A, B) +# ------------ +# Compare two integer expressions. +# A < B -> -1 +# A = B -> 0 +# A > B -> 1 +m4_define([m4_cmp], +[m4_eval((([$1]) > ([$2])) - (([$1]) < ([$2])))]) + + +# m4_list_cmp(A, B) +# ----------------- +# +# Compare the two lists of integer expressions A and B. For instance: +# m4_list_cmp([1, 0], [1]) -> 0 +# m4_list_cmp([1, 0], [1, 0]) -> 0 +# m4_list_cmp([1, 2], [1, 0]) -> 1 +# m4_list_cmp([1, 2, 3], [1, 2]) -> 1 +# m4_list_cmp([1, 2, -3], [1, 2]) -> -1 +# m4_list_cmp([1, 0], [1, 2]) -> -1 +# m4_list_cmp([1], [1, 2]) -> -1 +# m4_define([xa], [oops])dnl +# m4_list_cmp([[0xa]], [5+5]) -> 0 +# +# Rather than face the overhead of m4_case, we use a helper function whose +# expansion includes the name of the macro to invoke on the tail, either +# m4_ignore or m4_unquote. This is particularly useful when comparing +# long lists, since less text is being expanded for deciding when to end +# recursion. The recursion is between a pair of macros that alternate +# which list is trimmed by one element; this is more efficient than +# calling m4_cdr on both lists from a single macro. Guarantee exactly +# one expansion of both lists' side effects. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_list_cmp], +[_$0_raw(m4_dquote($1), m4_dquote($2))]) + +m4_define([_m4_list_cmp_raw], +[m4_if([$1], [$2], [0], [_m4_list_cmp_1([$1], $2)])]) + +m4_define([_m4_list_cmp], +[m4_if([$1], [], [0m4_ignore], [$2], [0], [m4_unquote], [$2m4_ignore])]) + +m4_define([_m4_list_cmp_1], +[_m4_list_cmp_2([$2], [m4_shift2($@)], $1)]) + +m4_define([_m4_list_cmp_2], +[_m4_list_cmp([$1$3], m4_cmp([$3+0], [$1+0]))( + [_m4_list_cmp_1(m4_dquote(m4_shift3($@)), $2)])]) + +# m4_max(EXPR, ...) +# m4_min(EXPR, ...) +# ----------------- +# Return the decimal value of the maximum (or minimum) in a series of +# integer expressions. +# +# M4 1.4.x doesn't provide ?:. Hence this huge m4_eval. Avoid m4_eval +# if both arguments are identical, but be aware of m4_max(0xa, 10) (hence +# the use of <=, not just <, in the second multiply). +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_max], +[m4_if([$#], [0], [m4_fatal([too few arguments to $0])], + [$#], [1], [m4_eval([$1])], + [$#$1], [2$2], [m4_eval([$1])], + [$#], [2], [_$0($@)], + [_m4_minmax([_$0], $@)])]) + +m4_define([_m4_max], +[m4_eval((([$1]) > ([$2])) * ([$1]) + (([$1]) <= ([$2])) * ([$2]))]) + +m4_define([m4_min], +[m4_if([$#], [0], [m4_fatal([too few arguments to $0])], + [$#], [1], [m4_eval([$1])], + [$#$1], [2$2], [m4_eval([$1])], + [$#], [2], [_$0($@)], + [_m4_minmax([_$0], $@)])]) + +m4_define([_m4_min], +[m4_eval((([$1]) < ([$2])) * ([$1]) + (([$1]) >= ([$2])) * ([$2]))]) + +# _m4_minmax(METHOD, ARG1, ARG2...) +# --------------------------------- +# Common recursion code for m4_max and m4_min. METHOD must be _m4_max +# or _m4_min, and there must be at least two arguments to combine. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([_m4_minmax], +[m4_if([$#], [3], [$1([$2], [$3])], + [$0([$1], $1([$2], [$3]), m4_shift3($@))])]) + + +# m4_sign(A) +# ---------- +# The sign of the integer expression A. +m4_define([m4_sign], +[m4_eval((([$1]) > 0) - (([$1]) < 0))]) + + + +## ------------------------ ## +## 14. Version processing. ## +## ------------------------ ## + + +# m4_version_unletter(VERSION) +# ---------------------------- +# Normalize beta version numbers with letters to numeric expressions, which +# can then be handed to m4_eval for the purpose of comparison. +# +# Nl -> (N+1).-1.(l#) +# +# for example: +# [2.14a] -> [0,2,14+1,-1,[0r36:a]] -> 2.15.-1.10 +# [2.14b] -> [0,2,15+1,-1,[0r36:b]] -> 2.15.-1.11 +# [2.61aa.b] -> [0,2.61,1,-1,[0r36:aa],+1,-1,[0r36:b]] -> 2.62.-1.370.1.-1.11 +# [08] -> [0,[0r10:0]8] -> 8 +# +# This macro expects reasonable version numbers, but can handle double +# letters and does not expand any macros. Original version strings can +# use both `.' and `-' separators. +# +# Inline constant expansions, to avoid m4_defn overhead. +# _m4_version_unletter is the real workhorse used by m4_version_compare, +# but since [0r36:a] and commas are less readable than 10 and dots, we +# provide a wrapper for human use. +m4_define([m4_version_unletter], +[m4_substr(m4_map_args([.m4_eval], m4_unquote(_$0([$1]))), [3])]) +m4_define([_m4_version_unletter], +[m4_bpatsubst(m4_bpatsubst(m4_translit([[[[0,$1]]]], [.-], [,,]),]dnl +m4_dquote(m4_dquote(m4_defn([m4_cr_Letters])))[[+], + [+1,-1,[0r36:\&]]), [,0], [,[0r10:0]])]) + + +# m4_version_compare(VERSION-1, VERSION-2) +# ---------------------------------------- +# Compare the two version numbers and expand into +# -1 if VERSION-1 < VERSION-2 +# 0 if = +# 1 if > +# +# Since _m4_version_unletter does not output side effects, we can +# safely bypass the overhead of m4_version_cmp. +m4_define([m4_version_compare], +[_m4_list_cmp_raw(_m4_version_unletter([$1]), _m4_version_unletter([$2]))]) + + +# m4_PACKAGE_NAME +# m4_PACKAGE_TARNAME +# m4_PACKAGE_VERSION +# m4_PACKAGE_STRING +# m4_PACKAGE_BUGREPORT +# -------------------- +# If m4sugar/version.m4 is present, then define version strings. This +# file is optional, provided by Autoconf but absent in Bison. +m4_sinclude([m4sugar/version.m4]) + + +# m4_version_prereq(VERSION, [IF-OK], [IF-NOT = FAIL]) +# ---------------------------------------------------- +# Check this Autoconf version against VERSION. +m4_define([m4_version_prereq], +m4_ifdef([m4_PACKAGE_VERSION], +[[m4_if(m4_version_compare(]m4_dquote(m4_defn([m4_PACKAGE_VERSION]))[, [$1]), + [-1], + [m4_default([$3], + [m4_fatal([Autoconf version $1 or higher is required], + [63])])], + [$2])]], +[[m4_fatal([m4sugar/version.m4 not found])]])) + + +## ------------------ ## +## 15. Set handling. ## +## ------------------ ## + +# Autoconf likes to create arbitrarily large sets; for example, as of +# this writing, the configure.ac for coreutils tracks a set of more +# than 400 AC_SUBST. How do we track all of these set members, +# without introducing duplicates? We could use m4_append_uniq, with +# the set NAME residing in the contents of the macro NAME. +# Unfortunately, m4_append_uniq is quadratic for set creation, because +# it costs O(n) to search the string for each of O(n) insertions; not +# to mention that with m4 1.4.x, even using m4_append is slow, costing +# O(n) rather than O(1) per insertion. Other set operations, not used +# by Autoconf but still possible by manipulation of the definition +# tracked in macro NAME, include O(n) deletion of one element and O(n) +# computation of set size. Because the set is exposed to the user via +# the definition of a single macro, we cannot cache any data about the +# set without risking the cache being invalidated by the user +# redefining NAME. +# +# Can we do better? Yes, because m4 gives us an O(1) search function +# for free: ifdef. Additionally, even m4 1.4.x gives us an O(1) +# insert operation for free: pushdef. But to use these, we must +# represent the set via a group of macros; to keep the set consistent, +# we must hide the set so that the user can only manipulate it through +# accessor macros. The contents of the set are maintained through two +# access points; _m4_set([name]) is a pushdef stack of values in the +# set, useful for O(n) traversal of the set contents; while the +# existence of _m4_set([name],value) with no particular value is +# useful for O(1) querying of set membership. And since the user +# cannot externally manipulate the set, we are free to add additional +# caching macros for other performance improvements. Deletion can be +# O(1) per element rather than O(n), by reworking the definition of +# _m4_set([name],value) to be 0 or 1 based on current membership, and +# adding _m4_set_cleanup(name) to defer the O(n) cleanup of +# _m4_set([name]) until we have another reason to do an O(n) +# traversal. The existence of _m4_set_cleanup(name) can then be used +# elsewhere to determine if we must dereference _m4_set([name],value), +# or assume that definition implies set membership. Finally, size can +# be tracked in an O(1) fashion with _m4_set_size(name). +# +# The quoting in _m4_set([name],value) is chosen so that there is no +# ambiguity with a set whose name contains a comma, and so that we can +# supply the value via _m4_defn([_m4_set([name])]) without needing any +# quote manipulation. + +# m4_set_add(SET, VALUE, [IF-UNIQ], [IF-DUP]) +# ------------------------------------------- +# Add VALUE as an element of SET. Expand IF-UNIQ on the first +# addition, and IF-DUP if it is already in the set. Addition of one +# element is O(1), such that overall set creation is O(n). +# +# We do not want to add a duplicate for a previously deleted but +# unpruned element, but it is just as easy to check existence directly +# as it is to query _m4_set_cleanup($1). +m4_define([m4_set_add], +[m4_ifdef([_m4_set([$1],$2)], + [m4_if(m4_indir([_m4_set([$1],$2)]), [0], + [m4_define([_m4_set([$1],$2)], + [1])_m4_set_size([$1], [m4_incr])$3], [$4])], + [m4_define([_m4_set([$1],$2)], + [1])m4_pushdef([_m4_set([$1])], + [$2])_m4_set_size([$1], [m4_incr])$3])]) + +# m4_set_add_all(SET, VALUE...) +# ----------------------------- +# Add each VALUE into SET. This is O(n) in the number of VALUEs, and +# can be faster than calling m4_set_add for each VALUE. +# +# Implement two recursion helpers; the check variant is slower but +# handles the case where an element has previously been removed but +# not pruned. The recursion helpers ignore their second argument, so +# that we can use the faster m4_shift2 and 2 arguments, rather than +# _m4_shift2 and one argument, as the signal to end recursion. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_set_add_all], +[m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) + + m4_len(m4_ifdef([_m4_set_cleanup($1)], [_$0_check], [_$0])([$1], $@))))]) + +m4_define([_m4_set_add_all], +[m4_if([$#], [2], [], + [m4_ifdef([_m4_set([$1],$3)], [], + [m4_define([_m4_set([$1],$3)], [1])m4_pushdef([_m4_set([$1])], + [$3])-])$0([$1], m4_shift2($@))])]) + +m4_define([_m4_set_add_all_check], +[m4_if([$#], [2], [], + [m4_set_add([$1], [$3])$0([$1], m4_shift2($@))])]) + +# m4_set_contains(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) +# ------------------------------------------------------ +# Expand IF-PRESENT if SET contains VALUE, otherwise expand IF-ABSENT. +# This is always O(1). +m4_define([m4_set_contains], +[m4_ifdef([_m4_set_cleanup($1)], + [m4_if(m4_ifdef([_m4_set([$1],$2)], + [m4_indir([_m4_set([$1],$2)])], [0]), [1], [$3], [$4])], + [m4_ifdef([_m4_set([$1],$2)], [$3], [$4])])]) + +# m4_set_contents(SET, [SEP]) +# --------------------------- +# Expand to a single string containing all the elements in SET, +# separated by SEP, without modifying SET. No provision is made for +# disambiguating set elements that contain non-empty SEP as a +# sub-string, or for recognizing a set that contains only the empty +# string. Order of the output is not guaranteed. If any elements +# have been previously removed from the set, this action will prune +# the unused memory. This is O(n) in the size of the set before +# pruning. +# +# Use _m4_popdef for speed. The existence of _m4_set_cleanup($1) +# determines which version of _1 helper we use. +m4_define([m4_set_contents], +[m4_set_map_sep([$1], [], [], [[$2]])]) + +# _m4_set_contents_1(SET) +# _m4_set_contents_1c(SET) +# _m4_set_contents_2(SET, [PRE], [POST], [SEP]) +# --------------------------------------------- +# Expand to a list of quoted elements currently in the set, each +# surrounded by PRE and POST, and moving SEP in front of PRE on +# recursion. To avoid nesting limit restrictions, the algorithm must +# be broken into two parts; _1 destructively copies the stack in +# reverse into _m4_set_($1), producing no output; then _2 +# destructively copies _m4_set_($1) back into the stack in reverse. +# If no elements were deleted, then this visits the set in the order +# that elements were inserted. Behavior is undefined if PRE/POST/SEP +# tries to recursively list or modify SET in any way other than +# calling m4_set_remove on the current element. Use _1 if all entries +# in the stack are guaranteed to be in the set, and _1c to prune +# removed entries. Uses _m4_defn and _m4_popdef for speed. +m4_define([_m4_set_contents_1], +[_m4_stack_reverse([_m4_set([$1])], [_m4_set_($1)])]) + +m4_define([_m4_set_contents_1c], +[m4_ifdef([_m4_set([$1])], + [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), + [m4_pushdef([_m4_set_($1)], _m4_defn([_m4_set([$1])]))], + [_m4_popdef([_m4_set([$1],]_m4_defn( + [_m4_set([$1])])[)])])_m4_popdef([_m4_set([$1])])$0([$1])], + [_m4_popdef([_m4_set_cleanup($1)])])]) + +m4_define([_m4_set_contents_2], +[_m4_stack_reverse([_m4_set_($1)], [_m4_set([$1])], + [$2[]_m4_defn([_m4_set_($1)])$3], [$4[]])]) + +# m4_set_delete(SET) +# ------------------ +# Delete all elements in SET, and reclaim any memory occupied by the +# set. This is O(n) in the set size. +# +# Use _m4_defn and _m4_popdef for speed. +m4_define([m4_set_delete], +[m4_ifdef([_m4_set([$1])], + [_m4_popdef([_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], + [_m4_set([$1])])$0([$1])], + [m4_ifdef([_m4_set_cleanup($1)], + [_m4_popdef([_m4_set_cleanup($1)])])m4_ifdef( + [_m4_set_size($1)], + [_m4_popdef([_m4_set_size($1)])])])]) + +# m4_set_difference(SET1, SET2) +# ----------------------------- +# Produce a LIST of quoted elements that occur in SET1 but not SET2. +# Output a comma prior to any elements, to distinguish the empty +# string from no elements. This can be directly used as a series of +# arguments, such as for m4_join, or wrapped inside quotes for use in +# m4_foreach. Order of the output is not guaranteed. +# +# Short-circuit the idempotence relation. +m4_define([m4_set_difference], +[m4_if([$1], [$2], [], [m4_set_map_sep([$1], [_$0([$2],], [)])])]) + +m4_define([_m4_set_difference], +[m4_set_contains([$1], [$2], [], [,[$2]])]) + +# m4_set_dump(SET, [SEP]) +# ----------------------- +# Expand to a single string containing all the elements in SET, +# separated by SEP, then delete SET. In general, if you only need to +# list the contents once, this is faster than m4_set_contents. No +# provision is made for disambiguating set elements that contain +# non-empty SEP as a sub-string. Order of the output is not +# guaranteed. This is O(n) in the size of the set before pruning. +# +# Use _m4_popdef for speed. Use existence of _m4_set_cleanup($1) to +# decide if more expensive recursion is needed. +m4_define([m4_set_dump], +[m4_ifdef([_m4_set_size($1)], + [_m4_popdef([_m4_set_size($1)])])m4_ifdef([_m4_set_cleanup($1)], + [_$0_check], [_$0])([$1], [], [$2])]) + +# _m4_set_dump(SET, [SEP], [PREP]) +# _m4_set_dump_check(SET, [SEP], [PREP]) +# -------------------------------------- +# Print SEP and the current element, then delete the element and +# recurse with empty SEP changed to PREP. The check variant checks +# whether the element has been previously removed. Use _m4_defn and +# _m4_popdef for speed. +m4_define([_m4_set_dump], +[m4_ifdef([_m4_set([$1])], + [[$2]_m4_defn([_m4_set([$1])])_m4_popdef([_m4_set([$1],]_m4_defn( + [_m4_set([$1])])[)], [_m4_set([$1])])$0([$1], [$2$3])])]) + +m4_define([_m4_set_dump_check], +[m4_ifdef([_m4_set([$1])], + [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), + [[$2]_m4_defn([_m4_set([$1])])])_m4_popdef( + [_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], + [_m4_set([$1])])$0([$1], [$2$3])], + [_m4_popdef([_m4_set_cleanup($1)])])]) + +# m4_set_empty(SET, [IF-EMPTY], [IF-ELEMENTS]) +# -------------------------------------------- +# Expand IF-EMPTY if SET has no elements, otherwise IF-ELEMENTS. +m4_define([m4_set_empty], +[m4_ifdef([_m4_set_size($1)], + [m4_if(m4_indir([_m4_set_size($1)]), [0], [$2], [$3])], [$2])]) + +# m4_set_foreach(SET, VAR, ACTION) +# -------------------------------- +# For each element of SET, define VAR to the element and expand +# ACTION. ACTION should not recursively list SET's contents, add +# elements to SET, nor delete any element from SET except the one +# currently in VAR. The order that the elements are visited in is not +# guaranteed. This is faster than the corresponding m4_foreach([VAR], +# m4_indir([m4_dquote]m4_set_listc([SET])), [ACTION]) +m4_define([m4_set_foreach], +[m4_pushdef([$2])m4_set_map_sep([$1], +[m4_define([$2],], [)$3])m4_popdef([$2])]) + +# m4_set_intersection(SET1, SET2) +# ------------------------------- +# Produce a LIST of quoted elements that occur in both SET1 or SET2. +# Output a comma prior to any elements, to distinguish the empty +# string from no elements. This can be directly used as a series of +# arguments, such as for m4_join, or wrapped inside quotes for use in +# m4_foreach. Order of the output is not guaranteed. +# +# Iterate over the smaller set, and short-circuit the idempotence +# relation. +m4_define([m4_set_intersection], +[m4_if([$1], [$2], [m4_set_listc([$1])], + m4_eval(m4_set_size([$2]) < m4_set_size([$1])), [1], [$0([$2], [$1])], + [m4_set_map_sep([$1], [_$0([$2],], [)])])]) + +m4_define([_m4_set_intersection], +[m4_set_contains([$1], [$2], [,[$2]])]) + +# m4_set_list(SET) +# m4_set_listc(SET) +# ----------------- +# Produce a LIST of quoted elements of SET. This can be directly used +# as a series of arguments, such as for m4_join or m4_set_add_all, or +# wrapped inside quotes for use in m4_foreach or m4_map. With +# m4_set_list, there is no way to distinguish an empty set from a set +# containing only the empty string; with m4_set_listc, a leading comma +# is output if there are any elements. +m4_define([m4_set_list], +[m4_set_map_sep([$1], [], [], [,])]) + +m4_define([m4_set_listc], +[m4_set_map_sep([$1], [,])]) + +# m4_set_map(SET, ACTION) +# ----------------------- +# For each element of SET, expand ACTION with a single argument of the +# current element. ACTION should not recursively list SET's contents, +# add elements to SET, nor delete any element from SET except the one +# passed as an argument. The order that the elements are visited in +# is not guaranteed. This is faster than either of the corresponding +# m4_map_args([ACTION]m4_set_listc([SET])) +# m4_set_foreach([SET], [VAR], [ACTION(m4_defn([VAR]))]) +m4_define([m4_set_map], +[m4_set_map_sep([$1], [$2(], [)])]) + +# m4_set_map_sep(SET, [PRE], [POST], [SEP]) +# ----------------------------------------- +# For each element of SET, expand PRE[value]POST[], and expand SEP +# between elements. +m4_define([m4_set_map_sep], +[m4_ifdef([_m4_set_cleanup($1)], [_m4_set_contents_1c], + [_m4_set_contents_1])([$1])_m4_set_contents_2($@)]) + +# m4_set_remove(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) +# ---------------------------------------------------- +# If VALUE is an element of SET, delete it and expand IF-PRESENT. +# Otherwise expand IF-ABSENT. Deleting a single value is O(1), +# although it leaves memory occupied until the next O(n) traversal of +# the set which will compact the set. +# +# Optimize if the element being removed is the most recently added, +# since defining _m4_set_cleanup($1) slows down so many other macros. +# In particular, this plays well with m4_set_foreach and m4_set_map. +m4_define([m4_set_remove], +[m4_set_contains([$1], [$2], [_m4_set_size([$1], + [m4_decr])m4_if(_m4_defn([_m4_set([$1])]), [$2], + [_m4_popdef([_m4_set([$1],$2)], [_m4_set([$1])])], + [m4_define([_m4_set_cleanup($1)])m4_define( + [_m4_set([$1],$2)], [0])])$3], [$4])]) + +# m4_set_size(SET) +# ---------------- +# Expand to the number of elements currently in SET. This operation +# is O(1), and thus more efficient than m4_count(m4_set_list([SET])). +m4_define([m4_set_size], +[m4_ifdef([_m4_set_size($1)], [m4_indir([_m4_set_size($1)])], [0])]) + +# _m4_set_size(SET, ACTION) +# ------------------------- +# ACTION must be either m4_incr or m4_decr, and the size of SET is +# changed accordingly. If the set is empty, ACTION must not be +# m4_decr. +m4_define([_m4_set_size], +[m4_define([_m4_set_size($1)], + m4_ifdef([_m4_set_size($1)], [$2(m4_indir([_m4_set_size($1)]))], + [1]))]) + +# m4_set_union(SET1, SET2) +# ------------------------ +# Produce a LIST of double quoted elements that occur in either SET1 +# or SET2, without duplicates. Output a comma prior to any elements, +# to distinguish the empty string from no elements. This can be +# directly used as a series of arguments, such as for m4_join, or +# wrapped inside quotes for use in m4_foreach. Order of the output is +# not guaranteed. +# +# We can rely on the fact that m4_set_listc prunes SET1, so we don't +# need to check _m4_set([$1],element) for 0. Short-circuit the +# idempotence relation. +m4_define([m4_set_union], +[m4_set_listc([$1])m4_if([$1], [$2], [], + [m4_set_map_sep([$2], [_$0([$1],], [)])])]) + +m4_define([_m4_set_union], +[m4_ifdef([_m4_set([$1],$2)], [], [,[$2]])]) + + +## ------------------- ## +## 16. File handling. ## +## ------------------- ## + + +# It is a real pity that M4 comes with no macros to bind a diversion +# to a file. So we have to deal without, which makes us a lot more +# fragile than we should. + + +# m4_file_append(FILE-NAME, CONTENT) +# ---------------------------------- +m4_define([m4_file_append], +[m4_syscmd([cat >>$1 <<_m4eof +$2 +_m4eof +]) +m4_if(m4_sysval, [0], [], + [m4_fatal([$0: cannot write: $1])])]) + + + +## ------------------------ ## +## 17. Setting M4sugar up. ## +## ------------------------ ## + +# _m4_divert_diversion should be defined. +m4_divert_push([KILL]) + +# m4_init +# ------- +# Initialize the m4sugar language. +m4_define([m4_init], +[# All the M4sugar macros start with `m4_', except `dnl' kept as is +# for sake of simplicity. +m4_pattern_forbid([^_?m4_]) +m4_pattern_forbid([^dnl$]) + +# If __m4_version__ is defined, we assume that we are being run by M4 +# 1.6 or newer, thus $@ recursion is linear, and debugmode(+do) +# is available for faster checks of dereferencing undefined macros +# and forcing dumpdef to print to stderr regardless of debugfile. +# But if it is missing, we assume we are being run by M4 1.4.x, that +# $@ recursion is quadratic, and that we need foreach-based +# replacement macros. Also, m4 prior to 1.4.8 loses track of location +# during m4wrap text; __line__ should never be 0. +# +# Use the raw builtin to avoid tripping up include tracing. +# Meanwhile, avoid m4_copy, since it temporarily undefines m4_defn. +m4_ifdef([__m4_version__], +[m4_debugmode([+do]) +m4_define([m4_defn], _m4_defn([_m4_defn])) +m4_define([m4_dumpdef], _m4_defn([_m4_dumpdef])) +m4_define([m4_popdef], _m4_defn([_m4_popdef])) +m4_define([m4_undefine], _m4_defn([_m4_undefine]))], +[m4_builtin([include], [m4sugar/foreach.m4]) +m4_wrap_lifo([m4_if(__line__, [0], [m4_pushdef([m4_location], +]]m4_dquote(m4_dquote(m4_dquote(__file__:__line__)))[[)])])]) + +# Rewrite the first entry of the diversion stack. +m4_divert([KILL]) + +# Check the divert push/pop perfect balance. +# Some users are prone to also use m4_wrap to register last-minute +# m4_divert_text; so after our diversion cleanups, we restore +# KILL as the bottom of the diversion stack. +m4_wrap([m4_popdef([_m4_divert_diversion])m4_ifdef( + [_m4_divert_diversion], [m4_fatal([$0: unbalanced m4_divert_push: +]m4_divert_stack)])_m4_popdef([_m4_divert_stack])m4_divert_push([KILL])]) +]) diff --git a/Engine/bin/bison-flex/data/skeletons/bison.m4 b/Engine/bin/bison-flex/data/skeletons/bison.m4 new file mode 100644 index 000000000..b7bf5c5c7 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/bison.m4 @@ -0,0 +1,1241 @@ + -*- Autoconf -*- + +# Language-independent M4 Macros for Bison. + +# Copyright (C) 2002, 2004-2015, 2018-2021 Free Software Foundation, +# Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + + + +# m4_gsub(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# Really similar to m4_bpatsubsts, but behaves properly with quotes. +# See m4.at's "Generating Comments". Super inelegant, but so far, I +# did not find any better solution. +m4_define([b4_gsub], +[m4_bpatsubst(m4_bpatsubst(m4_bpatsubst([[[[$1]]]], + [$2], [$3]), + [$4], [$5]), + [$6], [$7])]) + +# m4_shift2 and m4_shift3 are provided by m4sugar. +m4_define([m4_shift4], [m4_shift(m4_shift(m4_shift(m4_shift($@))))]) + + +## ---------------- ## +## Identification. ## +## ---------------- ## + +# b4_generated_by +# --------------- +m4_define([b4_generated_by], +[b4_comment([A Bison parser, made by GNU Bison b4_version_string.]) +]) + +# b4_copyright(TITLE, [YEARS]) +# ---------------------------- +# If YEARS are not defined, use b4_copyright_years. +m4_define([b4_copyright], +[b4_generated_by +b4_comment([$1 + +]m4_dquote(m4_text_wrap([Copyright (C) +]m4_ifval([$2], [[$2]], [m4_defn([b4_copyright_years])])[ +Free Software Foundation, Inc.]))[ + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +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, see .]) + +b4_comment([As a special exception, you may create a larger work that contains +part or all of the Bison parser skeleton and distribute that work +under terms of your choice, so long as that work isn't itself a +parser generator using the skeleton or a modified version thereof +as a parser skeleton. Alternatively, if you modify or redistribute +the parser skeleton itself, you may (at your option) remove this +special exception, which will cause the skeleton and the resulting +Bison output files to be licensed under the GNU General Public +License without this special exception. + +This special exception was added by the Free Software Foundation in +version 2.2 of Bison.]) +]) + + +# b4_disclaimer +# ------------- +# Issue a warning about private implementation details. +m4_define([b4_disclaimer], +[b4_comment([DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +especially those whose name start with YY_ or yy_. They are +private implementation details that can be changed or removed.]) +]) + + + +# b4_required_version_if(VERSION, IF_NEWER, IF_OLDER) +# --------------------------------------------------- +# If the version %require'd by the user is VERSION (or newer) expand +# IF_NEWER, otherwise IF_OLDER. VERSION should be an integer, e.g., +# 302 for 3.2. +m4_define([b4_required_version_if], +[m4_if(m4_eval($1 <= b4_required_version), + [1], [$2], [$3])]) + + +## -------- ## +## Output. ## +## -------- ## + +# b4_output_begin(FILE1, FILE2) +# ----------------------------- +# Enable output, i.e., send to diversion 0, expand after "#", and +# generate the tag to output into FILE. Must be followed by EOL. +# FILE is FILE1 concatenated to FILE2. FILE2 can be empty, or be +# absolute: do the right thing. +m4_define([b4_output_begin], +[m4_changecom() +m4_divert_push(0)dnl +@output(m4_unquote([$1])@,m4_unquote([$2])@)@dnl +]) + + +# b4_output_end +# ------------- +# Output nothing, restore # as comment character (no expansions after #). +m4_define([b4_output_end], +[m4_divert_pop(0) +m4_changecom([#]) +]) + + +# b4_divert_kill(CODE) +# -------------------- +# Expand CODE for its side effects, discard its output. +m4_define([b4_divert_kill], +[m4_divert_text([KILL], [$1])]) + + +# b4_define_silent(MACRO, CODE) +# ----------------------------- +# Same as m4_define, but throw away the expansion of CODE. +m4_define([b4_define_silent], +[m4_define([$1], [b4_divert_kill([$2])])]) + + +## ---------------- ## +## Error handling. ## +## ---------------- ## + +# The following error handling macros print error directives that should not +# become arguments of other macro invocations since they would likely then be +# mangled. Thus, they print to stdout directly. + +# b4_cat(TEXT) +# ------------ +# Write TEXT to stdout. Precede the final newline with an @ so that it's +# escaped. For example: +# +# b4_cat([[@complain(invalid input@)]]) +m4_define([b4_cat], +[m4_syscmd([cat <<'_m4eof' +]m4_bpatsubst(m4_dquote($1), [_m4eof], [_m4@`eof])[@ +_m4eof +])dnl +m4_if(m4_sysval, [0], [], [m4_fatal([$0: cannot write to stdout])])]) + +# b4_error(KIND, START, END, FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------------------------- +# Write @KIND(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_error([[complain]], [[input.y:2.3]], [[input.y:5.4]], +# [[invalid %s]], [[foo]]) +m4_define([b4_error], +[b4_cat([[@complain][(]$1[@,]$2[@,]$3[@,]$4[]]dnl +[m4_if([$#], [4], [], + [m4_foreach([b4_arg], + m4_dquote(m4_shift4($@)), + [[@,]b4_arg])])[@)]])]) + +# b4_warn(FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------ +# Write @warn(FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_warn([[invalid value for '%s': %s]], [[foo]], [[3]]) +# +# As a simple test suite, this: +# +# m4_divert(-1) +# m4_define([asdf], [ASDF]) +# m4_define([fsa], [FSA]) +# m4_define([fdsa], [FDSA]) +# b4_warn_at([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]]) +# b4_warn_at([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]]) +# b4_warn_at() +# b4_warn_at(1) +# b4_warn_at(1, 2) +# +# Should produce this without newlines: +# +# @warn_at([asdf), asdf]@,@,@,[fsa), fsa]@,[fdsa), fdsa]@) +# @warn(asdf), asdf@,@,@,fsa), fsa@,fdsa), fdsa@) +# @warn(@) +# @warn(1@) +# @warn(1@,2@) +m4_define([b4_warn], +[b4_warn_at([], [], $@)]) + +# b4_warn_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# --------------------------------------------------- +# Write @warn(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_warn_at([[input.y:2.3]], [[input.y:5.4]], [[invalid %s]], [[foo]]) +m4_define([b4_warn_at], +[b4_error([[warn]], $@)]) + +# b4_complain(FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------- +# Bounce to b4_complain_at. +# +# See b4_warn example. +m4_define([b4_complain], +[b4_complain_at([], [], $@)]) + +# b4_complain_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------------------------- +# Write @complain(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# See b4_warn_at example. +m4_define([b4_complain_at], +[b4_error([[complain]], $@)]) + +# b4_fatal(FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------- +# Bounce to b4_fatal_at. +# +# See b4_warn example. +m4_define([b4_fatal], +[b4_fatal_at([], [], $@)]) + +# b4_fatal_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------------------- +# Write @fatal(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout and exit. +# +# See b4_warn_at example. +m4_define([b4_fatal_at], +[b4_error([[fatal]], $@)dnl +m4_exit(1)]) + +# b4_canary(MSG) +# -------------- +# Issue a warning on stderr and in the output. Used in the test suite +# to catch spurious m4 evaluations. +m4_define([b4_canary], +[m4_errprintn([dead canary: $1])DEAD CANARY($1)]) + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_ints_in(INT1, INT2, LOW, HIGH) +# --------------------------------- +# Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise. +m4_define([b4_ints_in], +[m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])]) + + +# b4_subtract(LHS, RHS) +# --------------------- +# Evaluate LHS - RHS if they are integer literals, otherwise expand +# to (LHS) - (RHS). +m4_define([b4_subtract], +[m4_bmatch([$1$2], [^[0123456789]*$], + [m4_eval([$1 - $2])], + [($1) - ($2)])]) + +# b4_join(ARG1, ...) +# _b4_join(ARG1, ...) +# ------------------- +# Join with comma, skipping empty arguments. +# b4_join calls itself recursively until it sees the first non-empty +# argument, then calls _b4_join (i.e., `_$0`) which prepends each +# non-empty argument with a comma. +m4_define([b4_join], +[m4_if([$#$1], + [1], [], + [m4_ifval([$1], + [$1[]_$0(m4_shift($@))], + [$0(m4_shift($@))])])]) + +# _b4_join(ARGS1, ...) +# -------------------- +m4_define([_b4_join], +[m4_if([$#$1], + [1], [], + [m4_ifval([$1], [, $1])[]$0(m4_shift($@))])]) + + + + +# b4_integral_parser_tables_map(MACRO) +# ------------------------------------- +# Map MACRO on all the integral tables. MACRO is expected to have +# the signature MACRO(TABLE-NAME, CONTENT, COMMENT). +m4_define([b4_integral_parser_tables_map], +[$1([pact], [b4_pact], + [[YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing +STATE-NUM.]]) + +$1([defact], [b4_defact], + [[YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. +Performed when YYTABLE does not specify something else to do. Zero +means the default is an error.]]) + +$1([pgoto], [b4_pgoto], [[YYPGOTO[NTERM-NUM].]]) + +$1([defgoto], [b4_defgoto], [[YYDEFGOTO[NTERM-NUM].]]) + +$1([table], [b4_table], + [[YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If +positive, shift that token. If negative, reduce the rule whose +number is the opposite. If YYTABLE_NINF, syntax error.]]) + +$1([check], [b4_check]) + +$1([stos], [b4_stos], + [[YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of +state STATE-NUM.]]) + +$1([r1], [b4_r1], + [[YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.]]) + +$1([r2], [b4_r2], + [[YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.]]) +]) + + +# b4_parser_tables_declare +# b4_parser_tables_define +# ------------------------ +# Define/declare the (deterministic) parser tables. +m4_define([b4_parser_tables_declare], +[b4_integral_parser_tables_map([b4_integral_parser_table_declare])]) + +m4_define([b4_parser_tables_define], +[b4_integral_parser_tables_map([b4_integral_parser_table_define])]) + + + +## ------------------ ## +## Decoding options. ## +## ------------------ ## + +# b4_flag_if(FLAG, IF-TRUE, IF-FALSE) +# ----------------------------------- +# Run IF-TRUE if b4_FLAG_flag is 1, IF-FALSE if FLAG is 0, otherwise fail. +m4_define([b4_flag_if], +[m4_case(b4_$1_flag, + [0], [$3], + [1], [$2], + [m4_fatal([invalid $1 value: ]b4_$1_flag)])]) + + +# b4_define_flag_if(FLAG) +# ----------------------- +# Define "b4_FLAG_if(IF-TRUE, IF-FALSE)" that depends on the +# value of the Boolean FLAG. +m4_define([b4_define_flag_if], +[_b4_define_flag_if($[1], $[2], [$1])]) + +# _b4_define_flag_if($1, $2, FLAG) +# -------------------------------- +# Work around the impossibility to define macros inside macros, +# because issuing '[$1]' is not possible in M4. GNU M4 should provide +# $$1 a la M5/TeX. +m4_define([_b4_define_flag_if], +[m4_if([$1$2], $[1]$[2], [], + [m4_fatal([$0: Invalid arguments: $@])])dnl +m4_define([b4_$3_if], + [b4_flag_if([$3], [$1], [$2])])]) + + +# b4_FLAG_if(IF-TRUE, IF-FALSE) +# ----------------------------- +# Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise. +b4_define_flag_if([glr]) # Whether a GLR parser is requested. +b4_define_flag_if([has_translations]) # Whether some tokens are internationalized. +b4_define_flag_if([header]) # Whether a header is requested. +b4_define_flag_if([nondeterministic]) # Whether conflicts should be handled. +b4_define_flag_if([token_table]) # Whether yytoken_table is demanded. +b4_define_flag_if([yacc]) # Whether POSIX Yacc is emulated. + + +# b4_glr_cc_if([IF-TRUE], [IF-FALSE]) +# ----------------------------------- +m4_define([b4_glr_cc_if], + [m4_if(b4_skeleton, ["glr.cc"], $@)]) + +# b4_glr2_cc_if([IF-TRUE], [IF-FALSE]) +# ------------------------------------ +m4_define([b4_glr2_cc_if], + [m4_if(b4_skeleton, ["glr2.cc"], $@)]) + +## --------- ## +## Symbols. ## +## --------- ## + +# For a description of the Symbol handling, see README.md. +# +# The following macros provide access to symbol related values. + +# __b4_symbol(NUM, FIELD) +# ----------------------- +# Fetch FIELD of symbol #NUM. Fail if undefined. +m4_define([__b4_symbol], +[m4_indir([b4_symbol($1, $2)])]) + + +# _b4_symbol(NUM, FIELD) +# ---------------------- +# Fetch FIELD of symbol #NUM (or "orig NUM", see README.md). +# Fail if undefined. +m4_define([_b4_symbol], +[m4_ifdef([b4_symbol($1, number)], + [__b4_symbol(m4_indir([b4_symbol($1, number)]), $2)], + [__b4_symbol([$1], [$2])])]) + + +# b4_symbol_token_kind(NUM) +# ------------------------- +# The token kind of this symbol. +m4_define([b4_symbol_token_kind], +[b4_percent_define_get([api.token.prefix])dnl +_b4_symbol([$1], [id])]) + + +# b4_symbol_kind_base(NUM) +# ------------------------ +# Build the name of the kind of this symbol. It must always exist, +# otherwise some symbols might not be represented in the enum, which +# might be compiled into too small a type to contain all the symbol +# numbers. +m4_define([b4_symbol_prefix], [b4_percent_define_get([api.symbol.prefix])]) +m4_define([b4_symbol_kind_base], +[b4_percent_define_get([api.symbol.prefix])dnl +m4_case([$1], + [-2], [[YYEMPTY]], + [0], [[YYEOF]], + [1], [[YYerror]], + [2], [[YYUNDEF]], + [m4_case(b4_symbol([$1], [tag]), + [$accept], [[YYACCEPT]], + [b4_symbol_if([$1], [has_id], _b4_symbol([$1], [id]), + [m4_bpatsubst([$1-][]_b4_symbol([$1], [tag]), [[^a-zA-Z_0-9]+], [_])])])])]) + + +# b4_symbol_kind(NUM) +# ------------------- +# Same as b4_symbol_kind, but possibly with a prefix in some +# languages. E.g., EOF's kind_base and kind are YYSYMBOL_YYEOF in C, +# but are S_YYEMPTY and symbol_kind::S_YYEMPTY in C++. +m4_copy([b4_symbol_kind_base], [b4_symbol_kind]) + + +# b4_symbol_slot(NUM) +# ------------------- +# The name of union member that contains the value of these symbols. +# Currently, we are messy, this should actually be type_tag, but type_tag +# has several meanings. +m4_define([b4_symbol_slot], +[m4_case(b4_percent_define_get([[api.value.type]]), + [union], [b4_symbol([$1], [type_tag])], + [variant], [b4_symbol([$1], [type_tag])], + [b4_symbol([$1], [type])])]) + + +# b4_symbol(NUM, FIELD) +# --------------------- +# Fetch FIELD of symbol #NUM (or "orig NUM", or "empty"). Fail if undefined. +# +# If FIELD = id, prepend the token prefix. +m4_define([b4_symbol], +[m4_if([$1], [empty], [b4_symbol([-2], [$2])], + [$1], [eof], [b4_symbol([0], [$2])], + [$1], [error], [b4_symbol([1], [$2])], + [$1], [undef], [b4_symbol([2], [$2])], + [m4_case([$2], + [id], [b4_symbol_token_kind([$1])], + [kind_base], [b4_symbol_kind_base([$1])], + [kind], [b4_symbol_kind([$1])], + [slot], [b4_symbol_slot([$1])], + [_b4_symbol($@)])])]) + + +# b4_symbol_if(NUM, FIELD, IF-TRUE, IF-FALSE) +# ------------------------------------------- +# If FIELD about symbol #NUM is 1 expand IF-TRUE, if is 0, expand IF-FALSE. +# Otherwise an error. +m4_define([b4_symbol_if], +[m4_case(b4_symbol([$1], [$2]), + [1], [$3], + [0], [$4], + [m4_fatal([$0: field $2 of $1 is not a Boolean:] b4_symbol([$1], [$2]))])]) + + +# b4_symbol_tag_comment(SYMBOL-NUM) +# --------------------------------- +# Issue a comment giving the tag of symbol NUM. +m4_define([b4_symbol_tag_comment], +[b4_comment([b4_symbol([$1], [tag])]) +]) + + +# b4_symbol_action(SYMBOL-NUM, ACTION) +# ------------------------------------ +# Run the action ACTION ("destructor" or "printer") for SYMBOL-NUM. +m4_define([b4_symbol_action], +[b4_symbol_if([$1], [has_$2], +[b4_dollar_pushdef([(*yyvaluep)], + [$1], + [], + [(*yylocationp)])dnl + _b4_symbol_case([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], [b4_symbol([$1], [$2_file])])dnl +b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@])dnl + break; + +b4_dollar_popdef[]dnl +])]) + + +# b4_symbol_destructor(SYMBOL-NUM) +# b4_symbol_printer(SYMBOL-NUM) +# -------------------------------- +m4_define([b4_symbol_destructor], [b4_symbol_action([$1], [destructor])]) +m4_define([b4_symbol_printer], [b4_symbol_action([$1], [printer])]) + + +# b4_symbol_actions(ACTION, [KIND = yykind]) +# ------------------------------------------ +# Emit the symbol actions for ACTION ("destructor" or "printer"). +# Dispatch on KIND. +m4_define([b4_symbol_actions], +[m4_pushdef([b4_actions_], m4_expand([b4_symbol_foreach([b4_symbol_$1])]))dnl +m4_ifval(m4_defn([b4_actions_]), +[switch (m4_default([$2], [yykind])) + { +m4_defn([b4_actions_])[]dnl + default: + break; + }dnl +], +[b4_use(m4_default([$2], [yykind]));])dnl +m4_popdef([b4_actions_])dnl +]) + +# _b4_symbol_case(SYMBOL-NUM) +# --------------------------- +# Issue a "case NUM" for SYMBOL-NUM. Ends with its EOL to make it +# easier to use with m4_map, but then, use []dnl to suppress the last +# one. +m4_define([_b4_symbol_case], +[case b4_symbol([$1], [kind]): b4_symbol_tag_comment([$1])]) +]) + + +# b4_symbol_foreach(MACRO) +# ------------------------ +# Invoke MACRO(SYMBOL-NUM) for each SYMBOL-NUM. +m4_define([b4_symbol_foreach], + [m4_map([$1], m4_defn([b4_symbol_numbers]))]) + +# b4_symbol_map(MACRO) +# -------------------- +# Return a list (possibly empty elements) of MACRO invoked for each +# SYMBOL-NUM. +m4_define([b4_symbol_map], +[m4_map_args_sep([$1(], [)], [,], b4_symbol_numbers)]) + + +# b4_token_visible_if(NUM, IF-TRUE, IF-FALSE) +# ------------------------------------------- +# Whether NUM denotes a token kind that has an exported definition +# (i.e., shows in enum yytokentype). +m4_define([b4_token_visible_if], +[b4_symbol_if([$1], [is_token], + [b4_symbol_if([$1], [has_id], [$2], [$3])], + [$3])]) + + +# b4_token_has_definition(NUM) +# ---------------------------- +# 1 if NUM is visible, nothing otherwise. +m4_define([b4_token_has_definition], +[b4_token_visible_if([$1], [1])]) + +# b4_any_token_visible_if([IF-TRUE], [IF-FALSE]) +# ---------------------------------------------- +# Whether there is a token that needs to be defined. +m4_define([b4_any_token_visible_if], +[m4_ifval(b4_symbol_foreach([b4_token_has_definition]), + [$1], [$2])]) + + +# b4_token_format(FORMAT, NUM) +# ---------------------------- +# If token NUM has a visible ID, format FORMAT with ID, USER_NUMBER. +m4_define([b4_token_format], +[b4_token_visible_if([$2], +[m4_format([[$1]], + b4_symbol([$2], [id]), + b4_symbol([$2], b4_api_token_raw_if([[number]], [[code]])))])]) + + +# b4_last_enum_token +# ------------------ +# The code of the last token visible token. +m4_define([_b4_last_enum_token], +[b4_token_visible_if([$1], + [m4_define([b4_last_enum_token], [$1])])]) +b4_symbol_foreach([_b4_last_enum_token]) + +# b4_last_symbol +# -------------- +# The code of the last symbol. +m4_define([b4_last_symbol], m4_eval(b4_tokens_number + b4_nterms_number - 1)) + +## ------- ## +## Types. ## +## ------- ## + +# _b4_type_action(NUMS) +# --------------------- +# Run actions for the symbol NUMS that all have the same type-name. +# Skip NUMS that have no type-name. +# +# To specify the action to run, define b4_dollar_dollar(SYMBOL-NUM, +# TAG, TYPE). +m4_define([_b4_type_action], +[b4_symbol_if([$1], [has_type], +[m4_map([ _b4_symbol_case], [$@])[]dnl + b4_dollar_dollar([b4_symbol([$1], [number])], + [b4_symbol([$1], [tag])], + [b4_symbol([$1], [type])]); + break; + +])]) + +# b4_type_foreach(MACRO, [SEP]) +# ----------------------------- +# Invoke MACRO(SYMBOL-NUMS) for each set of SYMBOL-NUMS for each type set. +m4_define([b4_type_foreach], + [m4_map_sep([$1], [$2], m4_defn([b4_type_names]))]) + + + +## ----------- ## +## Synclines. ## +## ----------- ## + +# b4_basename(NAME) +# ----------------- +# Similar to POSIX basename; the differences don't matter here. +# Beware that NAME is not evaluated. +m4_define([b4_basename], +[m4_bpatsubst([$1], [^.*/\([^/]+\)/*$], [\1])]) + + +# b4_syncline(LINE, FILE)dnl +# -------------------------- +# Should always be following by a dnl. +# +# Emit "#line LINE FILE /* __LINE__ __FILE__ */". +m4_define([b4_syncline], +[b4_flag_if([synclines], +[b4_sync_start([$1], [$2])[]dnl +b4_sync_end([__line__], [b4_basename(m4_quote(__file__))]) +])]) + +# b4_sync_start(LINE, FILE) +# ----------------------- +# Syncline for the new place. Typically a directive for the compiler. +m4_define([b4_sync_start], [b4_comment([$2:$1])]) + +# b4_sync_end(LINE, FILE) +# ----------------------- +# Syncline for the current place, which ends. Typically a comment +# left for the reader. +m4_define([b4_sync_end], [ b4_comment([$2:$1])] +) +# This generates dependencies on the Bison skeletons hence lots of +# useless 'git diff'. This location is useless for the regular +# user (who does not care about the skeletons) and is actually not +# useful for Bison developers too (I, Akim, never used this to locate +# the code in skeletons that generated output). So disable it +# completely. If someone thinks this was actually useful, a %define +# variable should be provided to control the level of verbosity of +# '#line', in replacement of --no-lines. +m4_define([b4_sync_end]) + + +# b4_user_code(USER-CODE) +# ----------------------- +# Emit code from the user, ending it with synclines. +m4_define([b4_user_code], +[$1 +b4_syncline([@oline@], [@ofile@])]) + + +# b4_define_user_code(MACRO, COMMENT) +# ----------------------------------- +# From b4_MACRO, if defined, build b4_user_MACRO that includes the synclines. +m4_define([b4_define_user_code], +[m4_define([b4_user_$1], + [m4_ifdef([b4_$1], + [m4_ifval([$2], + [b4_comment([$2]) +])b4_user_code([b4_$1])])])]) + +# b4_user_actions +# b4_user_initial_action +# b4_user_post_prologue +# b4_user_pre_prologue +# b4_user_union_members +# ---------------------- +# Macros that issue user code, ending with synclines. +b4_define_user_code([actions]) +b4_define_user_code([initial_action], [User initialization code.]) +b4_define_user_code([post_prologue], [Second part of user prologue.]) +b4_define_user_code([pre_prologue], [First part of user prologue.]) +b4_define_user_code([union_members]) + + +# b4_check_user_names(WHAT, USER-LIST, BISON-NAMESPACE) +# ----------------------------------------------------- +# Complain if any name of type WHAT is used by the user (as recorded in +# USER-LIST) but is not used by Bison (as recorded by macros in the +# namespace BISON-NAMESPACE). +# +# USER-LIST must expand to a list specifying all user occurrences of all names +# of type WHAT. Each item in the list must be a triplet specifying one +# occurrence: name, start boundary, and end boundary. Empty string names are +# fine. An empty list is fine. +# +# For example, to define b4_foo_user_names to be used for USER-LIST with three +# name occurrences and with correct quoting: +# +# m4_define([b4_foo_user_names], +# [[[[[[bar]], [[parser.y:1.7]], [[parser.y:1.16]]]], +# [[[[bar]], [[parser.y:5.7]], [[parser.y:5.16]]]], +# [[[[baz]], [[parser.y:8.7]], [[parser.y:8.16]]]]]]) +# +# The macro BISON-NAMESPACE(bar) must be defined iff the name bar of type WHAT +# is used by Bison (in the front-end or in the skeleton). Empty string names +# are fine, but it would be ugly for Bison to actually use one. +# +# For example, to use b4_foo_bison_names for BISON-NAMESPACE and define that +# the names bar and baz are used by Bison: +# +# m4_define([b4_foo_bison_names(bar)]) +# m4_define([b4_foo_bison_names(baz)]) +# +# To invoke b4_check_user_names with TYPE foo, with USER-LIST +# b4_foo_user_names, with BISON-NAMESPACE b4_foo_bison_names, and with correct +# quoting: +# +# b4_check_user_names([[foo]], [b4_foo_user_names], +# [[b4_foo_bison_names]]) +m4_define([b4_check_user_names], +[m4_foreach([b4_occurrence], $2, +[m4_pushdef([b4_occurrence], b4_occurrence)dnl +m4_pushdef([b4_user_name], m4_car(b4_occurrence))dnl +m4_pushdef([b4_start], m4_car(m4_shift(b4_occurrence)))dnl +m4_pushdef([b4_end], m4_shift2(b4_occurrence))dnl +m4_ifndef($3[(]m4_quote(b4_user_name)[)], + [b4_complain_at([b4_start], [b4_end], + [[%s '%s' is not used]], + [$1], [b4_user_name])])[]dnl +m4_popdef([b4_occurrence])dnl +m4_popdef([b4_user_name])dnl +m4_popdef([b4_start])dnl +m4_popdef([b4_end])dnl +])]) + + + +## --------------------- ## +## b4_percent_define_*. ## +## --------------------- ## + + +# b4_percent_define_use(VARIABLE) +# ------------------------------- +# Declare that VARIABLE was used. +m4_define([b4_percent_define_use], +[m4_define([b4_percent_define_bison_variables(]$1[)])dnl +]) + +# b4_percent_define_get(VARIABLE, [DEFAULT]) +# ------------------------------------------ +# Mimic muscle_percent_define_get in ../src/muscle-tab.h. That is, if +# the %define variable VARIABLE is defined, emit its value. Contrary +# to its C counterpart, return DEFAULT otherwise. Also, record +# Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_get([[foo]]) +m4_define([b4_percent_define_get], +[b4_percent_define_use([$1])dnl +_b4_percent_define_ifdef([$1], + [m4_indir([b4_percent_define(]$1[)])], + [$2])]) + +# b4_percent_define_get_loc(VARIABLE) +# ----------------------------------- +# Mimic muscle_percent_define_get_loc in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is undefined, complain fatally since that's +# a Bison or skeleton error. Otherwise, return its definition location in a +# form appropriate for the first two arguments of b4_warn_at, b4_complain_at, or +# b4_fatal_at. Don't record this as a Bison usage of VARIABLE as there's no +# reason to suspect that the user-supplied value has yet influenced the output. +# +# For example: +# +# b4_complain_at(b4_percent_define_get_loc([[foo]]), [[invalid foo]]) +m4_define([b4_percent_define_get_loc], +[m4_ifdef([b4_percent_define_loc(]$1[)], + [m4_pushdef([b4_loc], m4_indir([b4_percent_define_loc(]$1[)]))dnl +b4_loc[]dnl +m4_popdef([b4_loc])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_define_get_kind(VARIABLE) +# ------------------------------------ +# Get the kind (code, keyword, string) of VARIABLE, i.e., how its +# value was defined (braces, not delimiters, quotes). +# +# If the %define variable VARIABLE is undefined, complain fatally +# since that's a Bison or skeleton error. Don't record this as a +# Bison usage of VARIABLE as there's no reason to suspect that the +# user-supplied value has yet influenced the output. +m4_define([b4_percent_define_get_kind], +[m4_ifdef([b4_percent_define_kind(]$1[)], + [m4_indir([b4_percent_define_kind(]$1[)])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_define_get_syncline(VARIABLE)dnl +# ------------------------------------------- +# Should always be following by a dnl. +# +# Mimic muscle_percent_define_get_syncline in ../src/muscle-tab.h exactly. +# That is, if the %define variable VARIABLE is undefined, complain fatally +# since that's a Bison or skeleton error. Otherwise, return its definition +# location as a b4_syncline invocation. Don't record this as a Bison usage of +# VARIABLE as there's no reason to suspect that the user-supplied value has yet +# influenced the output. +# +# For example: +# +# b4_percent_define_get_syncline([[foo]]) +m4_define([b4_percent_define_get_syncline], +[m4_ifdef([b4_percent_define_syncline(]$1[)], + [m4_indir([b4_percent_define_syncline(]$1[)])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# _b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE]) +# ------------------------------------------------------ +# If the %define variable VARIABLE is defined, expand IF-TRUE, else expand +# IF-FALSE. Don't record usage of VARIABLE. +# +# For example: +# +# _b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]]) +m4_define([_b4_percent_define_ifdef], +[m4_ifdef([b4_percent_define(]$1[)], + [$2], + [$3])]) + +# b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE]) +# ------------------------------------------------------ +# Mimic muscle_percent_define_ifdef in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is defined, expand IF-TRUE, else expand +# IF-FALSE. Also, record Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]]) +m4_define([b4_percent_define_ifdef], +[_b4_percent_define_ifdef([$1], + [b4_percent_define_use([$1])$2], + [$3])]) + + +# b4_percent_define_check_file_complain(VARIABLE) +# ----------------------------------------------- +# Warn about %define variable VARIABLE having an incorrect +# value. +m4_define([b4_percent_define_check_file_complain], +[b4_complain_at(b4_percent_define_get_loc([$1]), + [[%%define variable '%s' requires 'none' or '"..."' values]], + [$1])]) + + +# b4_percent_define_check_file(MACRO, VARIABLE, DEFAULT) +# ------------------------------------------------------ +# If the %define variable VARIABLE: +# - is undefined, then if DEFAULT is non-empty, define MACRO to DEFAULT +# - is a string, define MACRO to its value +# - is the keyword 'none', do nothing +# - otherwise, warn about the incorrect value. +m4_define([b4_percent_define_check_file], +[b4_percent_define_ifdef([$2], + [m4_case(b4_percent_define_get_kind([$2]), + [string], + [m4_define([$1], b4_percent_define_get([$2]))], + [keyword], + [m4_if(b4_percent_define_get([$2]), [none], [], + [b4_percent_define_check_file_complain([$2])])], + [b4_percent_define_check_file_complain([$2])]) + ], + [m4_ifval([$3], + [m4_define([$1], [$3])])]) +]) + + + +## --------- ## +## Options. ## +## --------- ## + + +# b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE]) +# -------------------------------------------------------- +# Mimic muscle_percent_define_flag_if in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is defined to "" or "true", expand IF-TRUE. +# If it is defined to "false", expand IF-FALSE. Complain if it is undefined +# (a Bison or skeleton error since the default value should have been set +# already) or defined to any other value (possibly a user error). Also, record +# Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_flag_if([[foo]], [[it's true]], [[it's false]]) +m4_define([b4_percent_define_flag_if], +[b4_percent_define_ifdef([$1], + [m4_case(b4_percent_define_get([$1]), + [], [$2], [true], [$2], [false], [$3], + [m4_expand_once([b4_complain_at(b4_percent_define_get_loc([$1]), + [[invalid value for %%define Boolean variable '%s']], + [$1])], + [[b4_percent_define_flag_if($1)]])])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + + +# b4_percent_define_default(VARIABLE, DEFAULT, [KIND = keyword]) +# -------------------------------------------------------------- +# Mimic muscle_percent_define_default in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is undefined, set its value to DEFAULT. +# Don't record this as a Bison usage of VARIABLE as there's no reason to +# suspect that the value has yet influenced the output. +# +# For example: +# +# b4_percent_define_default([[foo]], [[default value]]) +m4_define([_b4_percent_define_define], +[m4_define([b4_percent_define(]$1[)], [$2])dnl +m4_define([b4_percent_define_kind(]$1[)], + [m4_default([$3], [keyword])])dnl +m4_define([b4_percent_define_loc(]$1[)], + [[[[:-1.-1]], + [[:-1.-1]]]])dnl +m4_define([b4_percent_define_syncline(]$1[)], [[]])]) + +m4_define([b4_percent_define_default], +[_b4_percent_define_ifdef([$1], [], + [_b4_percent_define_define($@)])]) + + +# b4_percent_define_if_define(NAME, [VARIABLE = NAME]) +# ---------------------------------------------------- +# Define b4_NAME_if that executes its $1 or $2 depending whether +# VARIABLE was %defined. The characters '.' and `-' in VARIABLE are mapped +# to '_'. +m4_define([_b4_percent_define_if_define], +[m4_define(m4_bpatsubst([b4_$1_if], [[-.]], [_]), + [b4_percent_define_default([m4_default([$2], [$1])], [[false]])dnl +b4_percent_define_flag_if(m4_default([$2], [$1]), + [$3], [$4])])]) + +m4_define([b4_percent_define_if_define], +[_b4_percent_define_if_define([$1], [$2], $[1], $[2])]) + + +# b4_percent_define_check_kind(VARIABLE, KIND, [DIAGNOSTIC = complain]) +# --------------------------------------------------------------------- +m4_define([b4_percent_define_check_kind], +[_b4_percent_define_ifdef([$1], + [m4_if(b4_percent_define_get_kind([$1]), [$2], [], + [b4_error([m4_default([$3], [complain])], + b4_percent_define_get_loc([$1]), + [m4_case([$2], + [code], [[%%define variable '%s' requires '{...}' values]], + [keyword], [[%%define variable '%s' requires keyword values]], + [string], [[%%define variable '%s' requires '"..."' values]])], + [$1])])])dnl +]) + + +# b4_percent_define_check_values(VALUES) +# -------------------------------------- +# Mimic muscle_percent_define_check_values in ../src/muscle-tab.h exactly +# except that the VALUES structure is more appropriate for M4. That is, VALUES +# is a list of sublists of strings. For each sublist, the first string is the +# name of a %define variable, and all remaining strings in that sublist are the +# valid values for that variable. Complain if such a variable is undefined (a +# Bison error since the default value should have been set already) or defined +# to any other value (possibly a user error). Don't record this as a Bison +# usage of the variable as there's no reason to suspect that the value has yet +# influenced the output. +# +# For example: +# +# b4_percent_define_check_values([[[[foo]], [[foo-value1]], [[foo-value2]]]], +# [[[[bar]], [[bar-value1]]]]) +m4_define([b4_percent_define_check_values], +[m4_foreach([b4_sublist], m4_quote($@), + [_b4_percent_define_check_values(b4_sublist)])]) + +m4_define([_b4_percent_define_check_values], +[_b4_percent_define_ifdef([$1], + [b4_percent_define_check_kind(]$1[, [keyword], [deprecated])dnl + m4_pushdef([b4_good_value], [0])dnl + m4_if($#, 1, [], + [m4_foreach([b4_value], m4_dquote(m4_shift($@)), + [m4_if(m4_indir([b4_percent_define(]$1[)]), b4_value, + [m4_define([b4_good_value], [1])])])])dnl + m4_if(b4_good_value, [0], + [b4_complain_at(b4_percent_define_get_loc([$1]), + [[invalid value for %%define variable '%s': '%s']], + [$1], + m4_dquote(m4_indir([b4_percent_define(]$1[)]))) + m4_foreach([b4_value], m4_dquote(m4_shift($@)), + [b4_error([[note]], b4_percent_define_get_loc([$1]), [] + [[accepted value: '%s']], + m4_dquote(b4_value))])])dnl + m4_popdef([b4_good_value])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_code_get([QUALIFIER]) +# -------------------------------- +# If any %code blocks for QUALIFIER are defined, emit them beginning with a +# comment and ending with synclines and a newline. If QUALIFIER is not +# specified or empty, do this for the unqualified %code blocks. Also, record +# Bison's usage of QUALIFIER (if specified) by defining +# b4_percent_code_bison_qualifiers(QUALIFIER). +# +# For example, to emit any unqualified %code blocks followed by any %code +# blocks for the qualifier foo: +# +# b4_percent_code_get +# b4_percent_code_get([[foo]]) +m4_define([b4_percent_code_get], +[m4_pushdef([b4_macro_name], [[b4_percent_code(]$1[)]])dnl +m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])dnl +m4_ifdef(b4_macro_name, +[b4_comment(m4_if([$#], [0], [[[Unqualified %code blocks.]]], + [[["%code ]$1[" blocks.]]])) +b4_user_code([m4_indir(b4_macro_name)])])dnl +m4_popdef([b4_macro_name])]) + +# b4_percent_code_ifdef(QUALIFIER, IF-TRUE, [IF-FALSE]) +# ----------------------------------------------------- +# If any %code blocks for QUALIFIER (or unqualified %code blocks if +# QUALIFIER is empty) are defined, expand IF-TRUE, else expand IF-FALSE. +# Also, record Bison's usage of QUALIFIER (if specified) by defining +# b4_percent_code_bison_qualifiers(QUALIFIER). +m4_define([b4_percent_code_ifdef], +[m4_ifdef([b4_percent_code(]$1[)], + [m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])$2], + [$3])]) + + +## ------------------ ## +## Common variables. ## +## ------------------ ## + + +# b4_parse_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT]) +# b4_parse_trace_if([IF-DEBUG-TRACES-ARE-ENABLED], [IF-NOT]) +# b4_token_ctor_if([IF-YYLEX-RETURNS-A-TOKEN], [IF-NOT]) +# ---------------------------------------------------------- +b4_percent_define_if_define([api.token.raw]) +b4_percent_define_if_define([token_ctor], [api.token.constructor]) +b4_percent_define_if_define([locations]) # Whether locations are tracked. +b4_percent_define_if_define([parse.assert]) +b4_percent_define_if_define([parse.trace]) +b4_percent_define_if_define([posix]) + + +# b4_bison_locations_if([IF-TRUE]) +# -------------------------------- +# Expand IF-TRUE if using locations, and using the default location +# type. +m4_define([b4_bison_locations_if], +[b4_locations_if([b4_percent_define_ifdef([[api.location.type]], [], [$1])])]) + + + +# %define parse.error "(custom|detailed|simple|verbose)" +# ------------------------------------------------------ +b4_percent_define_default([[parse.error]], [[simple]]) +b4_percent_define_check_values([[[[parse.error]], + [[custom]], [[detailed]], [[simple]], [[verbose]]]]) + +# b4_parse_error_case(CASE1, THEN1, CASE2, THEN2, ..., ELSE) +# ---------------------------------------------------------- +m4_define([b4_parse_error_case], +[m4_case(b4_percent_define_get([[parse.error]]), $@)]) + +# b4_parse_error_bmatch(PATTERN1, THEN1, PATTERN2, THEN2, ..., ELSE) +# ------------------------------------------------------------------ +m4_define([b4_parse_error_bmatch], +[m4_bmatch(b4_percent_define_get([[parse.error]]), $@)]) + + + +# b4_union_if([IF-UNION-ARE-USED], [IF-NOT]) +# b4_variant_if([IF-VARIANT-ARE-USED], [IF-NOT]) +# ---------------------------------------------- +# Depend on whether api.value.type is union, or variant. +m4_define([b4_union_flag], [[0]]) +m4_define([b4_variant_flag], [[0]]) +b4_percent_define_ifdef([[api.value.type]], + [m4_case(b4_percent_define_get_kind([[api.value.type]]), [keyword], + [m4_case(b4_percent_define_get([[api.value.type]]), + [union], [m4_define([b4_union_flag], [[1]])], + [variant], [m4_define([b4_variant_flag], [[1]])])])]) +b4_define_flag_if([union]) +b4_define_flag_if([variant]) + + +## ----------------------------------------------------------- ## +## After processing the skeletons, check that all the user's ## +## %define variables and %code qualifiers were used by Bison. ## +## ----------------------------------------------------------- ## + +m4_define([b4_check_user_names_wrap], +[m4_ifdef([b4_percent_]$1[_user_]$2[s], + [b4_check_user_names([[%]$1 $2], + [b4_percent_]$1[_user_]$2[s], + [[b4_percent_]$1[_bison_]$2[s]])])]) + +m4_wrap_lifo([ +b4_check_user_names_wrap([[define]], [[variable]]) +b4_check_user_names_wrap([[code]], [[qualifier]]) +]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# m4_define_default([b4_lex_param], []) dnl breaks other skeletons +m4_define_default([b4_epilogue], []) +m4_define_default([b4_parse_param], []) + +# The initial column and line. +m4_define_default([b4_location_initial_column], [1]) +m4_define_default([b4_location_initial_line], [1]) + + +## --------------- ## +## Sanity checks. ## +## --------------- ## + +# api.location.type={...} (C, C++ and Java). +b4_percent_define_check_kind([api.location.type], [code], [deprecated]) + +# api.position.type={...} (Java). +b4_percent_define_check_kind([api.position.type], [code], [deprecated]) + +# api.prefix >< %name-prefix. +b4_percent_define_check_kind([api.prefix], [code], [deprecated]) +b4_percent_define_ifdef([api.prefix], +[m4_ifdef([b4_prefix], +[b4_complain_at(b4_percent_define_get_loc([api.prefix]), + [['%s' and '%s' cannot be used together]], + [%name-prefix], + [%define api.prefix])])]) + +# api.token.prefix={...} +# Make it a warning for those who used betas of Bison 3.0. +b4_percent_define_check_kind([api.token.prefix], [code], [deprecated]) + +# api.value.type >< %union. +b4_percent_define_ifdef([api.value.type], +[m4_ifdef([b4_union_members], +[b4_complain_at(b4_percent_define_get_loc([api.value.type]), + [['%s' and '%s' cannot be used together]], + [%union], + [%define api.value.type])])]) + +# api.value.type=union >< %yacc. +b4_percent_define_ifdef([api.value.type], +[m4_if(b4_percent_define_get([api.value.type]), [union], +[b4_yacc_if(dnl +[b4_complain_at(b4_percent_define_get_loc([api.value.type]), + [['%s' and '%s' cannot be used together]], + [%yacc], + [%define api.value.type "union"])])])]) + +# api.value.union.name. +b4_percent_define_check_kind([api.value.union.name], [keyword]) + +# parse.error (custom|detailed) >< token-table. +b4_token_table_if( +[b4_parse_error_bmatch([custom\|detailed], +[b4_complain_at(b4_percent_define_get_loc([parse.error]), + [['%s' and '%s' cannot be used together]], + [%token-table], + [%define parse.error (custom|detailed)])])]) diff --git a/Engine/bin/bison-flex/data/skeletons/c++-skel.m4 b/Engine/bin/bison-flex/data/skeletons/c++-skel.m4 new file mode 100644 index 000000000..f22002b96 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/c++-skel.m4 @@ -0,0 +1,27 @@ + -*- Autoconf -*- + +# C++ skeleton dispatching for Bison. + +# Copyright (C) 2006-2007, 2009-2015, 2018-2021 Free Software +# Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +b4_glr_if( [m4_define([b4_used_skeleton], [b4_skeletonsdir/[glr.cc]])]) +b4_nondeterministic_if([m4_define([b4_used_skeleton], [b4_skeletonsdir/[glr.cc]])]) + +m4_define_default([b4_used_skeleton], [b4_skeletonsdir/[lalr1.cc]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/Engine/bin/bison-flex/data/skeletons/c++.m4 b/Engine/bin/bison-flex/data/skeletons/c++.m4 new file mode 100644 index 000000000..2ae8423ab --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/c++.m4 @@ -0,0 +1,778 @@ + -*- Autoconf -*- + +# C++ skeleton for Bison + +# Copyright (C) 2002-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +# Sanity checks, before defaults installed by c.m4. +b4_percent_define_ifdef([[api.value.union.name]], + [b4_complain_at(b4_percent_define_get_loc([[api.value.union.name]]), + [named %union is invalid in C++])]) + +b4_percent_define_default([[api.symbol.prefix]], [[S_]]) + +m4_include(b4_skeletonsdir/[c.m4]) + +b4_percent_define_check_kind([api.namespace], [code], [deprecated]) +b4_percent_define_check_kind([api.parser.class], [code], [deprecated]) + + +## ----- ## +## C++. ## +## ----- ## + +# b4_comment(TEXT, [PREFIX]) +# -------------------------- +# Put TEXT in comment. Prefix all the output lines with PREFIX. +m4_define([b4_comment], +[_b4_comment([$1], [$2// ], [$2// ])]) + + +# b4_inline(hh|cc) +# ---------------- +# Expand to `inline\n ` if $1 is hh. +m4_define([b4_inline], +[m4_case([$1], + [cc], [], + [hh], [[inline + ]], + [m4_fatal([$0: invalid argument: $1])])]) + + +# b4_cxx_portability +# ------------------ +m4_define([b4_cxx_portability], +[#if defined __cplusplus +# define YY_CPLUSPLUS __cplusplus +#else +# define YY_CPLUSPLUS 199711L +#endif + +// Support move semantics when possible. +#if 201103L <= YY_CPLUSPLUS +# define YY_MOVE std::move +# define YY_MOVE_OR_COPY move +# define YY_MOVE_REF(Type) Type&& +# define YY_RVREF(Type) Type&& +# define YY_COPY(Type) Type +#else +# define YY_MOVE +# define YY_MOVE_OR_COPY copy +# define YY_MOVE_REF(Type) Type& +# define YY_RVREF(Type) const Type& +# define YY_COPY(Type) const Type& +#endif + +// Support noexcept when possible. +#if 201103L <= YY_CPLUSPLUS +# define YY_NOEXCEPT noexcept +# define YY_NOTHROW +#else +# define YY_NOEXCEPT +# define YY_NOTHROW throw () +#endif + +// Support constexpr when possible. +#if 201703 <= YY_CPLUSPLUS +# define YY_CONSTEXPR constexpr +#else +# define YY_CONSTEXPR +#endif[]dnl +]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +b4_percent_define_default([[api.parser.class]], [[parser]]) + +# Don't do that so that we remember whether we're using a user +# request, or the default value. +# +# b4_percent_define_default([[api.location.type]], [[location]]) + +b4_percent_define_default([[api.filename.type]], [[const std::string]]) +# Make it a warning for those who used betas of Bison 3.0. +b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix])) + +b4_percent_define_default([[define_location_comparison]], + [m4_if(b4_percent_define_get([[filename_type]]), + [std::string], [[true]], [[false]])]) + + + +## ----------- ## +## Namespace. ## +## ----------- ## + +m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])]) + + +# Don't permit an empty b4_namespace_ref. Any '::parser::foo' appended to it +# would compile as an absolute reference with 'parser' in the global namespace. +# b4_namespace_open would open an anonymous namespace and thus establish +# internal linkage. This would compile. However, it's cryptic, and internal +# linkage for the parser would be specified in all translation units that +# include the header, which is always generated. If we ever need to permit +# internal linkage somehow, surely we can find a cleaner approach. +m4_if(m4_bregexp(b4_namespace_ref, [^[ ]*$]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), + [[namespace reference is empty]])]) + +# Instead of assuming the C++ compiler will do it, Bison should reject any +# invalid b4_namespace_ref that would be converted to a valid +# b4_namespace_open. The problem is that Bison doesn't always output +# b4_namespace_ref to uncommented code but should reserve the ability to do so +# in future releases without risking breaking any existing user grammars. +# Specifically, don't allow empty names as b4_namespace_open would just convert +# those into anonymous namespaces, and that might tempt some users. +m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*::]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), + [[namespace reference has consecutive "::"]])]) +m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*$]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), + [[namespace reference has a trailing "::"]])]) + +m4_define([b4_namespace_open], +[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])dnl +[namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref), + [^\(.\)[ ]*::], [\1])), + [::], [ { namespace ])[ {]])]) + +m4_define([b4_namespace_close], +[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])dnl +m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]), + [^\(.\)[ ]*\(::\)?\([^][:]\|:[^:]\)*], + [\1])), + [::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])]) + + +## ------------- ## +## Token kinds. ## +## ------------- ## + + +# b4_token_enums +# -------------- +# Output the definition of the token kinds. +m4_define([b4_token_enums], +[[enum token_kind_type + { + ]b4_symbol([-2], [id])[ = -2, +]b4_symbol_foreach([b4_token_enum])dnl +[ };]dnl +]) + + + +## -------------- ## +## Symbol kinds. ## +## -------------- ## + +# b4_declare_symbol_enum +# ---------------------- +# The definition of the symbol internal numbers as an enum. +# Defining YYEMPTY here is important: it forces the compiler +# to use a signed type, which matters for yytoken. +m4_define([b4_declare_symbol_enum], +[[enum symbol_kind_type + { + YYNTOKENS = ]b4_tokens_number[, ///< Number of tokens. + ]b4_symbol(empty, kind_base)[ = -2, +]b4_symbol_foreach([ b4_symbol_enum])dnl +[ };]]) + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + + +# b4_value_type_declare +# --------------------- +# Declare value_type. +m4_define([b4_value_type_declare], +[b4_value_type_setup[]dnl +[ /// Symbol semantic values. +]m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), +[code], +[[ typedef ]b4_percent_define_get([[api.value.type]])[ value_type;]], +[m4_bmatch(b4_percent_define_get([[api.value.type]]), +[union\|union-directive], +[[ union value_type + { +]b4_user_union_members[ + };]])])dnl +]) + + +# b4_public_types_declare +# ----------------------- +# Define the public types: token, semantic value, location, and so forth. +# Depending on %define token_lex, may be output in the header or source file. +m4_define([b4_public_types_declare], +[b4_glr2_cc_if( +[b4_value_type_declare], +[[#ifdef ]b4_api_PREFIX[STYPE +# ifdef __GNUC__ +# pragma GCC message "bison: do not #define ]b4_api_PREFIX[STYPE in C++, use %define api.value.type" +# endif + typedef ]b4_api_PREFIX[STYPE value_type; +#else +]b4_value_type_declare[ +#endif + /// Backward compatibility (Bison 3.8). + typedef value_type semantic_type; +]])[]b4_locations_if([ + /// Symbol locations. + typedef b4_percent_define_get([[api.location.type]], + [[location]]) location_type;])[ + + /// Syntax errors thrown from user actions. + struct syntax_error : std::runtime_error + { + syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m) + : std::runtime_error (m)]b4_locations_if([ + , location (l)])[ + {} + + syntax_error (const syntax_error& s) + : std::runtime_error (s.what ())]b4_locations_if([ + , location (s.location)])[ + {} + + ~syntax_error () YY_NOEXCEPT YY_NOTHROW;]b4_locations_if([ + + location_type location;])[ + }; + + /// Token kinds. + struct token + { + ]b4_token_enums[]b4_glr2_cc_if([], [[ + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type yytokentype;]])[ + }; + + /// Token kind, as returned by yylex. + typedef token::token_kind_type token_kind_type;]b4_glr2_cc_if([], [[ + + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type token_type;]])[ + + /// Symbol kinds. + struct symbol_kind + { + ]b4_declare_symbol_enum[ + }; + + /// (Internal) symbol kind. + typedef symbol_kind::symbol_kind_type symbol_kind_type; + + /// The number of tokens. + static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS; +]]) + + +# b4_symbol_type_define +# --------------------- +# Define symbol_type, the external type for symbols used for symbol +# constructors. +m4_define([b4_symbol_type_define], +[[ /// A complete symbol. + /// + /// Expects its Base type to provide access to the symbol kind + /// via kind (). + /// + /// Provide access to semantic value]b4_locations_if([ and location])[. + template + struct basic_symbol : Base + { + /// Alias to Base. + typedef Base super_type; + + /// Default constructor. + basic_symbol () YY_NOEXCEPT + : value ()]b4_locations_if([ + , location ()])[ + {} + +#if 201103L <= YY_CPLUSPLUS + /// Move constructor. + basic_symbol (basic_symbol&& that) + : Base (std::move (that)) + , value (]b4_variant_if([], [std::move (that.value)]))b4_locations_if([ + , location (std::move (that.location))])[ + {]b4_variant_if([ + b4_symbol_variant([this->kind ()], [value], [move], + [std::move (that.value)]) + ])[} +#endif + + /// Copy constructor. + basic_symbol (const basic_symbol& that);]b4_variant_if([[ + + /// Constructors for typed symbols. +]b4_type_foreach([b4_basic_symbol_constructor_define], [ +])], [[ + /// Constructor for valueless symbols. + basic_symbol (typename Base::kind_type t]b4_locations_if([, + YY_MOVE_REF (location_type) l])[); + + /// Constructor for symbols with semantic value. + basic_symbol (typename Base::kind_type t, + YY_RVREF (value_type) v]b4_locations_if([, + YY_RVREF (location_type) l])[); +]])[ + /// Destroy the symbol. + ~basic_symbol () + { + clear (); + } + +]b4_glr2_cc_if([[ + /// Copy assignment. + basic_symbol& operator= (const basic_symbol& that) + { + Base::operator= (that);]b4_variant_if([[ + ]b4_symbol_variant([this->kind ()], [value], [copy], + [that.value])], [[ + value = that.value]])[;]b4_locations_if([[ + location = that.location;]])[ + return *this; + } + + /// Move assignment. + basic_symbol& operator= (basic_symbol&& that) + { + Base::operator= (std::move (that));]b4_variant_if([[ + ]b4_symbol_variant([this->kind ()], [value], [move], + [std::move (that.value)])], [[ + value = std::move (that.value)]])[;]b4_locations_if([[ + location = std::move (that.location);]])[ + return *this; + } +]])[ + + /// Destroy contents, and record that is empty. + void clear () YY_NOEXCEPT + {]b4_variant_if([[ + // User destructor. + symbol_kind_type yykind = this->kind (); + basic_symbol& yysym = *this; + (void) yysym; + switch (yykind) + { +]b4_symbol_foreach([b4_symbol_destructor])dnl +[ default: + break; + } + + // Value type destructor. +]b4_symbol_variant([[yykind]], [[value]], [[template destroy]])])[ + Base::clear (); + } + +]b4_parse_error_bmatch( +[custom\|detailed], +[[ /// The user-facing name of this symbol. + const char *name () const YY_NOEXCEPT + { + return ]b4_parser_class[::symbol_name (this->kind ()); + }]], +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + /// The user-facing name of this symbol. + const char *name () const YY_NOEXCEPT + { + return ]b4_parser_class[::symbol_name (this->kind ()); + } +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /// The user-facing name of this symbol. + std::string name () const YY_NOEXCEPT + { + return ]b4_parser_class[::symbol_name (this->kind ()); + }]])[]b4_glr2_cc_if([], [[ + + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT;]])[ + + /// Whether empty. + bool empty () const YY_NOEXCEPT; + + /// Destructive move, \a s is emptied into this. + void move (basic_symbol& s); + + /// The semantic value. + value_type value;]b4_locations_if([ + + /// The location. + location_type location;])[ + + private: +#if YY_CPLUSPLUS < 201103L + /// Assignment operator. + basic_symbol& operator= (const basic_symbol& that); +#endif + }; + + /// Type access provider for token (enum) based symbols. + struct by_kind + { + /// The symbol kind as needed by the constructor. + typedef token_kind_type kind_type; + + /// Default constructor. + by_kind () YY_NOEXCEPT; + +#if 201103L <= YY_CPLUSPLUS + /// Move constructor. + by_kind (by_kind&& that) YY_NOEXCEPT; +#endif + + /// Copy constructor. + by_kind (const by_kind& that) YY_NOEXCEPT; + + /// Constructor from (external) token numbers. + by_kind (kind_type t) YY_NOEXCEPT; + +]b4_glr2_cc_if([[ + /// Copy assignment. + by_kind& operator= (const by_kind& that); + + /// Move assignment. + by_kind& operator= (by_kind&& that); +]])[ + + /// Record that this symbol is empty. + void clear () YY_NOEXCEPT; + + /// Steal the symbol kind from \a that. + void move (by_kind& that); + + /// The (internal) type number (corresponding to \a type). + /// \a empty when empty. + symbol_kind_type kind () const YY_NOEXCEPT;]b4_glr2_cc_if([], [[ + + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT;]])[ + + /// The symbol kind. + /// \a ]b4_symbol_prefix[YYEMPTY when empty. + symbol_kind_type kind_; + };]b4_glr2_cc_if([], [[ + + /// Backward compatibility for a private implementation detail (Bison 3.6). + typedef by_kind by_type;]])[ + + /// "External" symbols: returned by the scanner. + struct symbol_type : basic_symbol + {]b4_variant_if([[ + /// Superclass. + typedef basic_symbol super_type; + + /// Empty symbol. + symbol_type () YY_NOEXCEPT {} + + /// Constructor for valueless symbols, and symbols from each type. +]b4_type_foreach([_b4_symbol_constructor_define])dnl + ])[}; +]]) + + +# b4_public_types_define(hh|cc) +# ----------------------------- +# Provide the implementation needed by the public types. +m4_define([b4_public_types_define], +[[ // basic_symbol. + template + ]b4_parser_class[::basic_symbol::basic_symbol (const basic_symbol& that) + : Base (that) + , value (]b4_variant_if([], [that.value]))b4_locations_if([ + , location (that.location)])[ + {]b4_variant_if([ + b4_symbol_variant([this->kind ()], [value], [copy], + [YY_MOVE (that.value)]) + ])[} + +]b4_variant_if([], [[ + /// Constructor for valueless symbols. + template + ]b4_parser_class[::basic_symbol::basic_symbol (]b4_join( + [typename Base::kind_type t], + b4_locations_if([YY_MOVE_REF (location_type) l]))[) + : Base (t) + , value ()]b4_locations_if([ + , location (l)])[ + {} + + template + ]b4_parser_class[::basic_symbol::basic_symbol (]b4_join( + [typename Base::kind_type t], + [YY_RVREF (value_type) v], + b4_locations_if([YY_RVREF (location_type) l]))[) + : Base (t) + , value (]b4_variant_if([], [YY_MOVE (v)])[)]b4_locations_if([ + , location (YY_MOVE (l))])[ + {]b4_variant_if([[ + (void) v; + ]b4_symbol_variant([this->kind ()], [value], [YY_MOVE_OR_COPY], [YY_MOVE (v)])])[}]])[ + +]b4_glr2_cc_if([], [[ + template + ]b4_parser_class[::symbol_kind_type + ]b4_parser_class[::basic_symbol::type_get () const YY_NOEXCEPT + { + return this->kind (); + } +]])[ + + template + bool + ]b4_parser_class[::basic_symbol::empty () const YY_NOEXCEPT + { + return this->kind () == ]b4_symbol(empty, kind)[; + } + + template + void + ]b4_parser_class[::basic_symbol::move (basic_symbol& s) + { + super_type::move (s); + ]b4_variant_if([b4_symbol_variant([this->kind ()], [value], [move], + [YY_MOVE (s.value)])], + [value = YY_MOVE (s.value);])[]b4_locations_if([ + location = YY_MOVE (s.location);])[ + } + + // by_kind. + ]b4_inline([$1])b4_parser_class[::by_kind::by_kind () YY_NOEXCEPT + : kind_ (]b4_symbol(empty, kind)[) + {} + +#if 201103L <= YY_CPLUSPLUS + ]b4_inline([$1])b4_parser_class[::by_kind::by_kind (by_kind&& that) YY_NOEXCEPT + : kind_ (that.kind_) + { + that.clear (); + } +#endif + + ]b4_inline([$1])b4_parser_class[::by_kind::by_kind (const by_kind& that) YY_NOEXCEPT + : kind_ (that.kind_) + {} + + ]b4_inline([$1])b4_parser_class[::by_kind::by_kind (token_kind_type t) YY_NOEXCEPT + : kind_ (yytranslate_ (t)) + {} + +]b4_glr2_cc_if([[ + ]b4_inline([$1])]b4_parser_class[::by_kind& + b4_parser_class[::by_kind::by_kind::operator= (const by_kind& that) + { + kind_ = that.kind_; + return *this; + } + + ]b4_inline([$1])]b4_parser_class[::by_kind& + b4_parser_class[::by_kind::by_kind::operator= (by_kind&& that) + { + kind_ = that.kind_; + that.clear (); + return *this; + } +]])[ + + ]b4_inline([$1])[void + ]b4_parser_class[::by_kind::clear () YY_NOEXCEPT + { + kind_ = ]b4_symbol(empty, kind)[; + } + + ]b4_inline([$1])[void + ]b4_parser_class[::by_kind::move (by_kind& that) + { + kind_ = that.kind_; + that.clear (); + } + + ]b4_inline([$1])[]b4_parser_class[::symbol_kind_type + ]b4_parser_class[::by_kind::kind () const YY_NOEXCEPT + { + return kind_; + } + +]b4_glr2_cc_if([], [[ + ]b4_inline([$1])[]b4_parser_class[::symbol_kind_type + ]b4_parser_class[::by_kind::type_get () const YY_NOEXCEPT + { + return this->kind (); + } +]])[ +]]) + + +# b4_token_constructor_define +# ---------------------------- +# Define make_FOO for all the token kinds. +# Use at class-level. Redefined in variant.hh. +m4_define([b4_token_constructor_define], []) + + +# b4_yytranslate_define(cc|hh) +# ---------------------------- +# Define yytranslate_. Sometimes used in the header file ($1=hh), +# sometimes in the cc file. +m4_define([b4_yytranslate_define], +[ b4_inline([$1])b4_parser_class[::symbol_kind_type + ]b4_parser_class[::yytranslate_ (int t) YY_NOEXCEPT + { +]b4_api_token_raw_if( +[[ return static_cast (t);]], +[[ // YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to + // TOKEN-NUM as returned by yylex. + static + const ]b4_int_type_for([b4_translate])[ + translate_table[] = + { + ]b4_translate[ + }; + // Last valid token kind. + const int code_max = ]b4_code_max[; + + if (t <= 0) + return symbol_kind::]b4_symbol_prefix[YYEOF; + else if (t <= code_max) + return static_cast (translate_table[t]); + else + return symbol_kind::]b4_symbol_prefix[YYUNDEF;]])[ + } +]]) + + +# b4_lhs_value([TYPE]) +# -------------------- +m4_define([b4_lhs_value], +[b4_symbol_value([yyval], [$1])]) + + +# b4_rhs_value(RULE-LENGTH, POS, [TYPE]) +# -------------------------------------- +# FIXME: Dead code. +m4_define([b4_rhs_value], +[b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, POS) +# --------------------------------- +# Expansion of @POS, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(yylocation_stack_@{($1) - ($2)@})]) + + +# b4_parse_param_decl +# ------------------- +# Extra formal arguments of the constructor. +# Change the parameter names from "foo" into "foo_yyarg", so that +# there is no collision bw the user chosen attribute name, and the +# argument name in the constructor. +m4_define([b4_parse_param_decl], +[m4_ifset([b4_parse_param], + [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])]) + +m4_define([b4_parse_param_decl_1], +[$1_yyarg]) + + + +# b4_parse_param_cons +# ------------------- +# Extra initialisations of the constructor. +m4_define([b4_parse_param_cons], + [m4_ifset([b4_parse_param], + [ + b4_cc_constructor_calls(b4_parse_param)])]) +m4_define([b4_cc_constructor_calls], + [m4_map_sep([b4_cc_constructor_call], [, + ], [$@])]) +m4_define([b4_cc_constructor_call], + [$2 ($2_yyarg)]) + +# b4_parse_param_vars +# ------------------- +# Extra instance variables. +m4_define([b4_parse_param_vars], + [m4_ifset([b4_parse_param], + [ + // User arguments. +b4_cc_var_decls(b4_parse_param)])]) +m4_define([b4_cc_var_decls], + [m4_map_sep([b4_cc_var_decl], [ +], [$@])]) +m4_define([b4_cc_var_decl], + [ $1;]) + + +## ---------## +## Values. ## +## ---------## + +# b4_yylloc_default_define +# ------------------------ +# Define YYLLOC_DEFAULT. +m4_define([b4_yylloc_default_define], +[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +# ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).begin = YYRHSLOC (Rhs, 1).begin; \ + (Current).end = YYRHSLOC (Rhs, N).end; \ + } \ + else \ + { \ + (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ + } \ + while (false) +# endif +]]) + +## -------- ## +## Checks. ## +## -------- ## + +b4_token_ctor_if([b4_variant_if([], + [b4_fatal_at(b4_percent_define_get_loc(api.token.constructor), + [cannot use '%s' without '%s'], + [%define api.token.constructor], + [%define api.value.type variant]))])]) diff --git a/Engine/bin/bison-flex/data/skeletons/c-like.m4 b/Engine/bin/bison-flex/data/skeletons/c-like.m4 new file mode 100644 index 000000000..a9bbc2e86 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/c-like.m4 @@ -0,0 +1,72 @@ + -*- Autoconf -*- + +# Common code for C-like languages (C, C++, Java, etc.) + +# Copyright (C) 2012-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + + +# _b4_comment(TEXT, OPEN, CONTINUE, END) +# -------------------------------------- +# Put TEXT in comment. Avoid trailing spaces: don't indent empty lines. +# Avoid adding indentation to the first line, as the indentation comes +# from OPEN. That's why we don't patsubst([$1], [^\(.\)], [ \1]). +# Turn "*/" in TEXT into "* /" so that we don't unexpectedly close +# the comments before its end. +# +# Prefix all the output lines with PREFIX. +m4_define([_b4_comment], +[$2[]b4_gsub(m4_expand([$1]), + [[*]/], [*\\/], + [/[*]], [/\\*], + [ +\(.\)], [ +$3\1])$4]) + + +# b4_comment(TEXT, [PREFIX]) +# -------------------------- +# Put TEXT in comment. Prefix all the output lines with PREFIX. +m4_define([b4_comment], +[_b4_comment([$1], [$2/* ], [$2 ], [ */])]) + + + + +# _b4_dollar_dollar(VALUE, SYMBOL-NUM, FIELD, DEFAULT-FIELD) +# ---------------------------------------------------------- +# If FIELD (or DEFAULT-FIELD) is non-null, return "VALUE.FIELD", +# otherwise just VALUE. Be sure to pass "(VALUE)" if VALUE is a +# pointer. +m4_define([_b4_dollar_dollar], +[b4_symbol_value([$1], + [$2], + m4_if([$3], [[]], + [[$4]], [[$3]]))]) + +# b4_dollar_pushdef(VALUE-POINTER, SYMBOL-NUM, [TYPE_TAG], LOCATION) +# b4_dollar_popdef +# ------------------------------------------------------------------ +# Define b4_dollar_dollar for VALUE-POINTER and DEFAULT-FIELD, +# and b4_at_dollar for LOCATION. +m4_define([b4_dollar_pushdef], +[m4_pushdef([b4_dollar_dollar], + [_b4_dollar_dollar([$1], [$2], m4_dquote($][1), [$3])])dnl +m4_pushdef([b4_at_dollar], [$4])dnl +]) +m4_define([b4_dollar_popdef], +[m4_popdef([b4_at_dollar])dnl +m4_popdef([b4_dollar_dollar])dnl +]) diff --git a/Engine/bin/bison-flex/data/skeletons/c-skel.m4 b/Engine/bin/bison-flex/data/skeletons/c-skel.m4 new file mode 100644 index 000000000..ac6ddd687 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/c-skel.m4 @@ -0,0 +1,27 @@ + -*- Autoconf -*- + +# C skeleton dispatching for Bison. + +# Copyright (C) 2006-2007, 2009-2015, 2018-2021 Free Software +# Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +b4_glr_if( [m4_define([b4_used_skeleton], [b4_skeletonsdir/[glr.c]])]) +b4_nondeterministic_if([m4_define([b4_used_skeleton], [b4_skeletonsdir/[glr.c]])]) + +m4_define_default([b4_used_skeleton], [b4_skeletonsdir/[yacc.c]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/Engine/bin/bison-flex/data/skeletons/c.m4 b/Engine/bin/bison-flex/data/skeletons/c.m4 new file mode 100644 index 000000000..2425b0715 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/c.m4 @@ -0,0 +1,1125 @@ + -*- Autoconf -*- + +# C M4 Macros for Bison. + +# Copyright (C) 2002, 2004-2015, 2018-2021 Free Software Foundation, +# Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +m4_include(b4_skeletonsdir/[c-like.m4]) + +# b4_tocpp(STRING) +# ---------------- +# Convert STRING into a valid C macro name. +m4_define([b4_tocpp], +[m4_toupper(m4_bpatsubst(m4_quote($1), [[^a-zA-Z0-9]+], [_]))]) + + +# b4_cpp_guard(FILE) +# ------------------ +# A valid C macro name to use as a CPP header guard for FILE. +m4_define([b4_cpp_guard], +[[YY_]b4_tocpp(m4_defn([b4_prefix])/[$1])[_INCLUDED]]) + + +# b4_cpp_guard_open(FILE) +# b4_cpp_guard_close(FILE) +# ------------------------ +# If FILE does not expand to nothing, open/close CPP inclusion guards for FILE. +m4_define([b4_cpp_guard_open], +[m4_ifval(m4_quote($1), +[#ifndef b4_cpp_guard([$1]) +# define b4_cpp_guard([$1])])]) + +m4_define([b4_cpp_guard_close], +[m4_ifval(m4_quote($1), +[#endif b4_comment([!b4_cpp_guard([$1])])])]) + + +## ---------------- ## +## Identification. ## +## ---------------- ## + +# b4_identification +# ----------------- +# Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or +# b4_pull_flag if they use the values of the %define variables api.pure or +# api.push-pull. +m4_define([b4_identification], +[[/* Identify Bison output, and Bison version. */ +#define YYBISON ]b4_version[ + +/* Bison version string. */ +#define YYBISON_VERSION "]b4_version_string[" + +/* Skeleton name. */ +#define YYSKELETON_NAME ]b4_skeleton[]m4_ifdef([b4_pure_flag], [[ + +/* Pure parsers. */ +#define YYPURE ]b4_pure_flag])[]m4_ifdef([b4_push_flag], [[ + +/* Push parsers. */ +#define YYPUSH ]b4_push_flag])[]m4_ifdef([b4_pull_flag], [[ + +/* Pull parsers. */ +#define YYPULL ]b4_pull_flag])[ +]]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# b4_api_prefix, b4_api_PREFIX +# ---------------------------- +# Corresponds to %define api.prefix +b4_percent_define_default([[api.prefix]], [[yy]]) +m4_define([b4_api_prefix], +[b4_percent_define_get([[api.prefix]])]) +m4_define([b4_api_PREFIX], +[m4_toupper(b4_api_prefix)]) + + +# b4_prefix +# --------- +# If the %name-prefix is not given, it is api.prefix. +m4_define_default([b4_prefix], [b4_api_prefix]) + +# If the %union is not named, its name is YYSTYPE. +b4_percent_define_default([[api.value.union.name]], + [b4_api_PREFIX[][STYPE]]) + +b4_percent_define_default([[api.symbol.prefix]], [[YYSYMBOL_]]) + +## ------------------------ ## +## Pure/impure interfaces. ## +## ------------------------ ## + +# b4_yylex_formals +# ---------------- +# All the yylex formal arguments. +# b4_lex_param arrives quoted twice, but we want to keep only one level. +m4_define([b4_yylex_formals], +[b4_pure_if([[[b4_api_PREFIX[STYPE *yylvalp]], [[&yylval]]][]dnl +b4_locations_if([, [b4_api_PREFIX[LTYPE *yyllocp], [&yylloc]]])])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param)]) + + +# b4_yylex +# -------- +# Call yylex. +m4_define([b4_yylex], +[b4_function_call([yylex], [int], b4_yylex_formals)]) + + +# b4_user_args +# ------------ +m4_define([b4_user_args], +[m4_ifset([b4_parse_param], [, b4_user_args_no_comma])]) + +# b4_user_args_no_comma +# --------------------- +m4_define([b4_user_args_no_comma], +[m4_ifset([b4_parse_param], [b4_args(b4_parse_param)])]) + + +# b4_user_formals +# --------------- +# The possible parse-params formal arguments preceded by a comma. +m4_define([b4_user_formals], +[m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])]) + + +# b4_parse_param +# -------------- +# If defined, b4_parse_param arrives double quoted, but below we prefer +# it to be single quoted. +m4_define([b4_parse_param], +b4_parse_param) + + +# b4_parse_param_for(DECL, FORMAL, BODY) +# --------------------------------------- +# Iterate over the user parameters, binding the declaration to DECL, +# the formal name to FORMAL, and evaluating the BODY. +m4_define([b4_parse_param_for], +[m4_foreach([$1_$2], m4_defn([b4_parse_param]), +[m4_pushdef([$1], m4_unquote(m4_car($1_$2)))dnl +m4_pushdef([$2], m4_shift($1_$2))dnl +$3[]dnl +m4_popdef([$2])dnl +m4_popdef([$1])dnl +])]) + + +# b4_use(EXPR) +# ------------ +# Pacify the compiler about some maybe unused value. +m4_define([b4_use], +[YY_USE ($1)]) + +# b4_parse_param_use([VAL], [LOC]) +# -------------------------------- +# 'YY_USE' VAL, LOC if locations are enabled, and all the parse-params. +m4_define([b4_parse_param_use], +[m4_ifvaln([$1], [ b4_use([$1]);])dnl +b4_locations_if([m4_ifvaln([$2], [ b4_use([$2]);])])dnl +b4_parse_param_for([Decl], [Formal], [ b4_use(Formal); +])dnl +]) + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return a narrow int type able to handle integers ranging from MIN +# to MAX (included) in portable C code. Assume MIN and MAX fall in +# 'int' range. +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [-127], [127]), [1], [signed char], + b4_ints_in($@, [0], [255]), [1], [unsigned char], + + b4_ints_in($@, [-32767], [32767]), [1], [short], + b4_ints_in($@, [0], [65535]), [1], [unsigned short], + + [int])]) + +# b4_c99_int_type(MIN, MAX) +# ------------------------- +# Like b4_int_type, but for C99. +# b4_c99_int_type_define replaces b4_int_type with this. +m4_define([b4_c99_int_type], +[m4_if(b4_ints_in($@, [-127], [127]), [1], [yytype_int8], + b4_ints_in($@, [0], [255]), [1], [yytype_uint8], + + b4_ints_in($@, [-32767], [32767]), [1], [yytype_int16], + b4_ints_in($@, [0], [65535]), [1], [yytype_uint16], + + [int])]) + +# b4_c99_int_type_define +# ---------------------- +# Define private types suitable for holding small integers in C99 or later. +m4_define([b4_c99_int_type_define], +[m4_copy_force([b4_c99_int_type], [b4_int_type])dnl +[#ifdef short +# undef short +#endif + +/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure + and (if available) are included + so that the code can choose integer types of a good width. */ + +#ifndef __PTRDIFF_MAX__ +# include /* INFRINGES ON USER NAME SPACE */ +# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_STDINT_H +# endif +#endif + +/* Narrow types that promote to a signed type and that can represent a + signed or unsigned integer of at least N bits. In tables they can + save space and decrease cache pressure. Promoting to a signed type + helps avoid bugs in integer arithmetic. */ + +#ifdef __INT_LEAST8_MAX__ +typedef __INT_LEAST8_TYPE__ yytype_int8; +#elif defined YY_STDINT_H +typedef int_least8_t yytype_int8; +#else +typedef signed char yytype_int8; +#endif + +#ifdef __INT_LEAST16_MAX__ +typedef __INT_LEAST16_TYPE__ yytype_int16; +#elif defined YY_STDINT_H +typedef int_least16_t yytype_int16; +#else +typedef short yytype_int16; +#endif + +/* Work around bug in HP-UX 11.23, which defines these macros + incorrectly for preprocessor constants. This workaround can likely + be removed in 2023, as HPE has promised support for HP-UX 11.23 + (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of + . */ +#ifdef __hpux +# undef UINT_LEAST8_MAX +# undef UINT_LEAST16_MAX +# define UINT_LEAST8_MAX 255 +# define UINT_LEAST16_MAX 65535 +#endif + +#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST8_TYPE__ yytype_uint8; +#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST8_MAX <= INT_MAX) +typedef uint_least8_t yytype_uint8; +#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX +typedef unsigned char yytype_uint8; +#else +typedef short yytype_uint8; +#endif + +#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST16_TYPE__ yytype_uint16; +#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST16_MAX <= INT_MAX) +typedef uint_least16_t yytype_uint16; +#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX +typedef unsigned short yytype_uint16; +#else +typedef int yytype_uint16; +#endif]]) + + +# b4_sizes_types_define +# --------------------- +# Define YYPTRDIFF_T/YYPTRDIFF_MAXIMUM, YYSIZE_T/YYSIZE_MAXIMUM, +# and YYSIZEOF. +m4_define([b4_sizes_types_define], +[[#ifndef YYPTRDIFF_T +# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ +# define YYPTRDIFF_T __PTRDIFF_TYPE__ +# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ +# elif defined PTRDIFF_MAX +# ifndef ptrdiff_t +# include /* INFRINGES ON USER NAME SPACE */ +# endif +# define YYPTRDIFF_T ptrdiff_t +# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX +# else +# define YYPTRDIFF_T long +# define YYPTRDIFF_MAXIMUM LONG_MAX +# endif +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned +# endif +#endif + +#define YYSIZE_MAXIMUM \ + YY_CAST (YYPTRDIFF_T, \ + (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ + ? YYPTRDIFF_MAXIMUM \ + : YY_CAST (YYSIZE_T, -1))) + +#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) +]]) + + +# b4_int_type_for(NAME) +# --------------------- +# Return a narrow int type able to handle numbers ranging from +# 'NAME_min' to 'NAME_max' (included). +m4_define([b4_int_type_for], +[b4_int_type($1_min, $1_max)]) + + +# b4_table_value_equals(TABLE, VALUE, LITERAL, SYMBOL) +# ---------------------------------------------------- +# Without inducing a comparison warning from the compiler, check if the +# literal value LITERAL equals VALUE from table TABLE, which must have +# TABLE_min and TABLE_max defined. SYMBOL denotes +m4_define([b4_table_value_equals], +[m4_if(m4_eval($3 < m4_indir([b4_]$1[_min]) + || m4_indir([b4_]$1[_max]) < $3), [1], + [[0]], + [(($2) == $4)])]) + + +## ----------------- ## +## Compiler issues. ## +## ----------------- ## + +# b4_attribute_define([noreturn]) +# ------------------------------- +# Provide portable compiler "attributes". If "noreturn" is passed, define +# _Noreturn. +m4_define([b4_attribute_define], +[[#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) +# else +# define YY_ATTRIBUTE_PURE +# endif +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +# else +# define YY_ATTRIBUTE_UNUSED +# endif +#endif + +]m4_bmatch([$1], [\bnoreturn\b], [[/* The _Noreturn keyword of C11. */ +]dnl This is close to lib/_Noreturn.h, except that we do enable +dnl the use of [[noreturn]], because _Noreturn is used in places +dnl where [[noreturn]] works in C++. We need this in particular +dnl because of glr.cc which compiles code from glr.c in C++. +dnl And the C++ compiler chokes on _Noreturn. Also, we do not +dnl use C' _Noreturn in C++, to avoid -Wc11-extensions warnings. +[#ifndef _Noreturn +# if (defined __cplusplus \ + && ((201103 <= __cplusplus && !(__GNUC__ == 4 && __GNUC_MINOR__ == 7)) \ + || (defined _MSC_VER && 1900 <= _MSC_VER))) +# define _Noreturn [[noreturn]] +# elif ((!defined __cplusplus || defined __clang__) \ + && (201112 <= (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) \ + || (!defined __STRICT_ANSI__ \ + && (4 < __GNUC__ + (7 <= __GNUC_MINOR__) \ + || (defined __apple_build_version__ \ + ? 6000000 <= __apple_build_version__ \ + : 3 < __clang_major__ + (5 <= __clang_minor__)))))) + /* _Noreturn works as-is. */ +# elif (2 < __GNUC__ + (8 <= __GNUC_MINOR__) || defined __clang__ \ + || 0x5110 <= __SUNPRO_C) +# define _Noreturn __attribute__ ((__noreturn__)) +# elif 1200 <= (defined _MSC_VER ? _MSC_VER : 0) +# define _Noreturn __declspec (noreturn) +# else +# define _Noreturn +# endif +#endif + +]])[/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YY_USE(E) ((void) (E)) +#else +# define YY_USE(E) /* empty */ +#endif + +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") +# else +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# endif +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif + +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif +]]) + + +# b4_cast_define +# -------------- +m4_define([b4_cast_define], +[# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif[]dnl +]) + + +# b4_null_define +# -------------- +# Portability issues: define a YY_NULLPTR appropriate for the current +# language (C, C++98, or C++11). +# +# In C++ pre C++11 it is standard practice to use 0 (not NULL) for the +# null pointer. In C, prefer ((void*)0) to avoid having to include stdlib.h. +m4_define([b4_null_define], +[# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) +# endif +# endif[]dnl +]) + + +# b4_null +# ------- +# Return a null pointer constant. +m4_define([b4_null], [YY_NULLPTR]) + + + +## ---------## +## Values. ## +## ---------## + +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) +# ------------------------------------------------------------- +# Define "yy" whose contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[m4_ifvaln([$3], [b4_comment([$3])])dnl +static const b4_int_type_for([$2]) yy$1[[]] = +{ + $2 +};dnl +]) + + +## ------------- ## +## Token kinds. ## +## ------------- ## + +# Because C enums are not scoped, because tokens are exposed in the +# header, and because these tokens are common to all the parsers, we +# need to make sure their names don't collide: use the api.prefix. +# YYEOF is special, since the user may give it a different name. +m4_define([b4_symbol(-2, id)], [b4_api_PREFIX[][EMPTY]]) +m4_define([b4_symbol(-2, tag)], [[No symbol.]]) + +m4_if(b4_symbol(eof, id), [YYEOF], + [m4_define([b4_symbol(0, id)], [b4_api_PREFIX[][EOF]])]) +m4_define([b4_symbol(1, id)], [b4_api_PREFIX[][error]]) +m4_define([b4_symbol(2, id)], [b4_api_PREFIX[][UNDEF]]) + + +# b4_token_define(TOKEN-NUM) +# -------------------------- +# Output the definition of this token as #define. +m4_define([b4_token_define], +[b4_token_format([#define %s %s], [$1])]) + +# b4_token_defines +# ---------------- +# Output the definition of the tokens. +m4_define([b4_token_defines], +[[/* Token kinds. */ +#define ]b4_symbol(empty, [id])[ -2 +]m4_join([ +], b4_symbol_map([b4_token_define])) +]) + + +# b4_token_enum(TOKEN-NUM) +# ------------------------ +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[b4_token_visible_if([$1], + [m4_format([ %-30s %s], + m4_format([[%s = %s%s%s]], + b4_symbol([$1], [id]), + b4_symbol([$1], b4_api_token_raw_if([[number]], [[code]])), + m4_if([$1], b4_last_enum_token, [], [[,]])), + [b4_symbol_tag_comment([$1])])])]) + + +# b4_token_enums +# -------------- +# The definition of the token kinds. +m4_define([b4_token_enums], +[b4_any_token_visible_if([[/* Token kinds. */ +#ifndef ]b4_api_PREFIX[TOKENTYPE +# define ]b4_api_PREFIX[TOKENTYPE + enum ]b4_api_prefix[tokentype + { + ]b4_symbol(empty, [id])[ = -2, +]b4_symbol_foreach([b4_token_enum])dnl +[ }; + typedef enum ]b4_api_prefix[tokentype ]b4_api_prefix[token_kind_t; +#endif +]])]) + + +# b4_token_enums_defines +# ---------------------- +# The definition of the tokens (if there are any) as enums and, +# if POSIX Yacc is enabled, as #defines. +m4_define([b4_token_enums_defines], +[b4_token_enums[]b4_yacc_if([b4_token_defines])]) + + +# b4_symbol_translate(STRING) +# --------------------------- +# Used by "bison" in the array of symbol names to mark those that +# require translation. +m4_define([b4_symbol_translate], +[[N_($1)]]) + + + +## -------------- ## +## Symbol kinds. ## +## -------------- ## + +# b4_symbol_enum(SYMBOL-NUM) +# -------------------------- +# Output the definition of this symbol as an enum. +m4_define([b4_symbol_enum], +[m4_format([ %-40s %s], + m4_format([[%s = %s%s%s]], + b4_symbol([$1], [kind_base]), + [$1], + m4_if([$1], b4_last_symbol, [], [[,]])), + [b4_symbol_tag_comment([$1])])]) + + +# b4_declare_symbol_enum +# ---------------------- +# The definition of the symbol internal numbers as an enum. +# Defining YYEMPTY here is important: it forces the compiler +# to use a signed type, which matters for yytoken. +m4_define([b4_declare_symbol_enum], +[[/* Symbol kind. */ +enum yysymbol_kind_t +{ + ]b4_symbol(empty, [kind_base])[ = -2, +]b4_symbol_foreach([b4_symbol_enum])dnl +[}; +typedef enum yysymbol_kind_t yysymbol_kind_t; +]])]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_symbol_value(VAL, [SYMBOL-NUM], [TYPE-TAG]) +# ---------------------------------------------- +# See README. +m4_define([b4_symbol_value], +[m4_ifval([$3], + [($1.$3)], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [($1.b4_symbol([$2], [type]))], + [$1])], + [$1])])]) + + +## ---------------------- ## +## Defining C functions. ## +## ---------------------- ## + + +# b4_formals([DECL1, NAME1], ...) +# ------------------------------- +# The formal arguments of a C function definition. +m4_define([b4_formals], +[m4_if([$#], [0], [void], + [$#$1], [1], [void], + [m4_map_sep([b4_formal], [, ], [$@])])]) + +m4_define([b4_formal], +[$1]) + + +# b4_function_declare(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ------------------------------------------------------------ +# Declare the function NAME. +m4_define([b4_function_declare], +[$2 $1 (b4_formals(m4_shift2($@)));[]dnl +]) + + + +## --------------------- ## +## Calling C functions. ## +## --------------------- ## + + +# b4_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ----------------------------------------------------------- +# Call the function NAME with arguments NAME1, NAME2 etc. +m4_define([b4_function_call], +[$1 (b4_args(m4_shift2($@)))[]dnl +]) + + +# b4_args([DECL1, NAME1], ...) +# ---------------------------- +# Output the arguments NAME1, NAME2... +m4_define([b4_args], +[m4_map_sep([b4_arg], [, ], [$@])]) + +m4_define([b4_arg], +[$2]) + + +## ----------- ## +## Synclines. ## +## ----------- ## + +# b4_sync_start(LINE, FILE) +# ------------------------- +m4_define([b4_sync_start], [[#]line $1 $2]) + + +## -------------- ## +## User actions. ## +## -------------- ## + +# b4_case(LABEL, STATEMENTS, [COMMENTS]) +# -------------------------------------- +m4_define([b4_case], +[ case $1:m4_ifval([$3], [ b4_comment([$3])]) +$2 +b4_syncline([@oline@], [@ofile@])dnl + break;]) + + +# b4_predicate_case(LABEL, CONDITIONS) +# ------------------------------------ +m4_define([b4_predicate_case], +[ case $1: + if (! ( +$2)) YYERROR; +b4_syncline([@oline@], [@ofile@])dnl + break;]) + + +# b4_yydestruct_define +# -------------------- +# Define the "yydestruct" function. +m4_define_default([b4_yydestruct_define], +[[/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +yydestruct (const char *yymsg, + yysymbol_kind_t yykind, YYSTYPE *yyvaluep]b4_locations_if(dnl +[[, YYLTYPE *yylocationp]])[]b4_user_formals[) +{ +]b4_parse_param_use([yyvaluep], [yylocationp])dnl +[ if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + ]b4_symbol_actions([destructor])[ + YY_IGNORE_MAYBE_UNINITIALIZED_END +}]dnl +]) + + +# b4_yy_symbol_print_define +# ------------------------- +# Define the "yy_symbol_print" function. +m4_define_default([b4_yy_symbol_print_define], +[[ +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ + +static void +yy_symbol_value_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep]b4_locations_if(dnl +[[, YYLTYPE const * const yylocationp]])[]b4_user_formals[) +{ + FILE *yyoutput = yyo; +]b4_parse_param_use([yyoutput], [yylocationp])dnl +[ if (!yyvaluep) + return;] +b4_percent_code_get([[pre-printer]])dnl + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + b4_symbol_actions([printer]) + YY_IGNORE_MAYBE_UNINITIALIZED_END +b4_percent_code_get([[post-printer]])dnl +[} + + +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ + +static void +yy_symbol_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep]b4_locations_if(dnl +[[, YYLTYPE const * const yylocationp]])[]b4_user_formals[) +{ + YYFPRINTF (yyo, "%s %s (", + yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); + +]b4_locations_if([ YYLOCATION_PRINT (yyo, yylocationp); + YYFPRINTF (yyo, ": "); +])dnl +[ yy_symbol_value_print (yyo, yykind, yyvaluep]dnl +b4_locations_if([, yylocationp])[]b4_user_args[); + YYFPRINTF (yyo, ")"); +}]dnl +]) + + +## ---------------- ## +## api.value.type. ## +## ---------------- ## + + +# ---------------------- # +# api.value.type=union. # +# ---------------------- # + +# b4_symbol_type_register(SYMBOL-NUM) +# ----------------------------------- +# Symbol SYMBOL-NUM has a type (for variant) instead of a type-tag. +# Extend the definition of %union's body (b4_union_members) with a +# field of that type, and extend the symbol's "type" field to point to +# the field name, instead of the type name. +m4_define([b4_symbol_type_register], +[m4_define([b4_symbol($1, type_tag)], + [b4_symbol_if([$1], [has_id], + [b4_symbol([$1], [id])], + [yykind_[]b4_symbol([$1], [number])])])dnl +m4_append([b4_union_members], +m4_expand([m4_format([ %-40s %s], + m4_expand([b4_symbol([$1], [type]) b4_symbol([$1], [type_tag]);]), + [b4_symbol_tag_comment([$1])])])) +]) + + +# b4_type_define_tag(SYMBOL1-NUM, ...) +# ------------------------------------ +# For the batch of symbols SYMBOL1-NUM... (which all have the same +# type), enhance the %union definition for each of them, and set +# there "type" field to the field tag name, instead of the type name. +m4_define([b4_type_define_tag], +[b4_symbol_if([$1], [has_type], + [m4_map([b4_symbol_type_register], [$@])]) +]) + + +# b4_symbol_value_union(VAL, SYMBOL-NUM, [TYPE]) +# ---------------------------------------------- +# Same of b4_symbol_value, but when api.value.type=union. +m4_define([b4_symbol_value_union], +[m4_ifval([$3], + [(*($3*)(&$1))], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [($1.b4_symbol([$2], [type_tag]))], + [$1])], + [$1])])]) + + +# b4_value_type_setup_union +# ------------------------- +# Setup support for api.value.type=union. Symbols are defined with a +# type instead of a union member name: build the corresponding union, +# and give the symbols their tag. +m4_define([b4_value_type_setup_union], +[m4_define([b4_union_members]) +b4_type_foreach([b4_type_define_tag]) +m4_copy_force([b4_symbol_value_union], [b4_symbol_value]) +]) + + +# -------------------------- # +# api.value.type = variant. # +# -------------------------- # + +# b4_value_type_setup_variant +# --------------------------- +# Setup support for api.value.type=variant. By default, fail, specialized +# by other skeletons. +m4_define([b4_value_type_setup_variant], +[b4_complain_at(b4_percent_define_get_loc([[api.value.type]]), + [['%s' does not support '%s']], + [b4_skeleton], + [%define api.value.type variant])]) + + +# _b4_value_type_setup_keyword +# ---------------------------- +# api.value.type is defined with a keyword/string syntax. Check if +# that is properly defined, and prepare its use. +m4_define([_b4_value_type_setup_keyword], +[b4_percent_define_check_values([[[[api.value.type]], + [[none]], + [[union]], + [[union-directive]], + [[variant]], + [[yystype]]]])dnl +m4_case(b4_percent_define_get([[api.value.type]]), + [union], [b4_value_type_setup_union], + [variant], [b4_value_type_setup_variant])]) + + +# b4_value_type_setup +# ------------------- +# Check if api.value.type is properly defined, and possibly prepare +# its use. +b4_define_silent([b4_value_type_setup], +[# Define default value. +b4_percent_define_ifdef([[api.value.type]], [], +[# %union => api.value.type=union-directive +m4_ifdef([b4_union_members], +[m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [union-directive])], +[# no tag seen => api.value.type={int} +m4_if(b4_tag_seen_flag, 0, +[m4_define([b4_percent_define_kind(api.value.type)], [code]) +m4_define([b4_percent_define(api.value.type)], [int])], +[# otherwise api.value.type=yystype +m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [yystype])])])]) + +# Set up. +m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), + [keyword\|string], [_b4_value_type_setup_keyword]) +]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + + +# b4_value_type_define +# -------------------- +m4_define([b4_value_type_define], +[b4_value_type_setup[]dnl +/* Value type. */ +m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), +[code], +[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED +typedef ]b4_percent_define_get([[api.value.type]])[ ]b4_api_PREFIX[STYPE; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1 +# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 +#endif +]], +[m4_bmatch(b4_percent_define_get([[api.value.type]]), +[union\|union-directive], +[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED +]b4_percent_define_get_syncline([[api.value.union.name]])dnl +[union ]b4_percent_define_get([[api.value.union.name]])[ +{ +]b4_user_union_members[ +}; +]b4_percent_define_get_syncline([[api.value.union.name]])dnl +[typedef union ]b4_percent_define_get([[api.value.union.name]])[ ]b4_api_PREFIX[STYPE; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1 +# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 +#endif +]])])]) + + +# b4_location_type_define +# ----------------------- +m4_define([b4_location_type_define], +[[/* Location type. */ +]b4_percent_define_ifdef([[api.location.type]], +[[typedef ]b4_percent_define_get([[api.location.type]])[ ]b4_api_PREFIX[LTYPE; +]], +[[#if ! defined ]b4_api_PREFIX[LTYPE && ! defined ]b4_api_PREFIX[LTYPE_IS_DECLARED +typedef struct ]b4_api_PREFIX[LTYPE ]b4_api_PREFIX[LTYPE; +struct ]b4_api_PREFIX[LTYPE +{ + int first_line; + int first_column; + int last_line; + int last_column; +}; +# define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1 +# define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1 +#endif +]])]) + + +# b4_declare_yylstype +# ------------------- +# Declarations that might either go into the header (if --header) or +# in the parser body. Declare YYSTYPE/YYLTYPE, and yylval/yylloc. +m4_define([b4_declare_yylstype], +[b4_value_type_define[]b4_locations_if([ +b4_location_type_define]) + +b4_pure_if([], [[extern ]b4_api_PREFIX[STYPE ]b4_prefix[lval; +]b4_locations_if([[extern ]b4_api_PREFIX[LTYPE ]b4_prefix[lloc;]])])[]dnl +]) + + +# b4_YYDEBUG_define +# ----------------- +m4_define([b4_YYDEBUG_define], +[[/* Debug traces. */ +]m4_if(b4_api_prefix, [yy], +[[#ifndef YYDEBUG +# define YYDEBUG ]b4_parse_trace_if([1], [0])[ +#endif]], +[[#ifndef ]b4_api_PREFIX[DEBUG +# if defined YYDEBUG +#if YYDEBUG +# define ]b4_api_PREFIX[DEBUG 1 +# else +# define ]b4_api_PREFIX[DEBUG 0 +# endif +# else /* ! defined YYDEBUG */ +# define ]b4_api_PREFIX[DEBUG ]b4_parse_trace_if([1], [0])[ +# endif /* ! defined YYDEBUG */ +#endif /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl +]) + +# b4_declare_yydebug +# ------------------ +m4_define([b4_declare_yydebug], +[b4_YYDEBUG_define[ +#if ]b4_api_PREFIX[DEBUG +extern int ]b4_prefix[debug; +#endif][]dnl +]) + +# b4_yylloc_default_define +# ------------------------ +# Define YYLLOC_DEFAULT. +m4_define([b4_yylloc_default_define], +[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (0) +#endif +]]) + +# b4_yylocation_print_define +# -------------------------- +# Define YYLOCATION_PRINT. +m4_define([b4_yylocation_print_define], +[b4_locations_if([[ +/* YYLOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +# ifndef YYLOCATION_PRINT + +# if defined YY_LOCATION_PRINT + + /* Temporary convenience wrapper in case some people defined the + undocumented and private YY_LOCATION_PRINT macros. */ +# define YYLOCATION_PRINT(File, Loc) YY_LOCATION_PRINT(File, *(Loc)) + +# elif defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL + +/* Print *YYLOCP on YYO. Private, do not rely on its existence. */ + +YY_ATTRIBUTE_UNUSED +static int +yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp) +{ + int res = 0; + int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0; + if (0 <= yylocp->first_line) + { + res += YYFPRINTF (yyo, "%d", yylocp->first_line); + if (0 <= yylocp->first_column) + res += YYFPRINTF (yyo, ".%d", yylocp->first_column); + } + if (0 <= yylocp->last_line) + { + if (yylocp->first_line < yylocp->last_line) + { + res += YYFPRINTF (yyo, "-%d", yylocp->last_line); + if (0 <= end_col) + res += YYFPRINTF (yyo, ".%d", end_col); + } + else if (0 <= end_col && yylocp->first_column < end_col) + res += YYFPRINTF (yyo, "-%d", end_col); + } + return res; +} + +# define YYLOCATION_PRINT yy_location_print_ + + /* Temporary convenience wrapper in case some people defined the + undocumented and private YY_LOCATION_PRINT macros. */ +# define YY_LOCATION_PRINT(File, Loc) YYLOCATION_PRINT(File, &(Loc)) + +# else + +# define YYLOCATION_PRINT(File, Loc) ((void) 0) + /* Temporary convenience wrapper in case some people defined the + undocumented and private YY_LOCATION_PRINT macros. */ +# define YY_LOCATION_PRINT YYLOCATION_PRINT + +# endif +# endif /* !defined YYLOCATION_PRINT */]]) +]) + +# b4_yyloc_default +# ---------------- +# Expand to a possible default value for yylloc. +m4_define([b4_yyloc_default], +[[ +# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL + = { ]m4_join([, ], + m4_defn([b4_location_initial_line]), + m4_defn([b4_location_initial_column]), + m4_defn([b4_location_initial_line]), + m4_defn([b4_location_initial_column]))[ } +# endif +]]) diff --git a/Engine/bin/bison-flex/data/skeletons/d-skel.m4 b/Engine/bin/bison-flex/data/skeletons/d-skel.m4 new file mode 100644 index 000000000..2a38f02f2 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/d-skel.m4 @@ -0,0 +1,26 @@ + -*- Autoconf -*- + +# D skeleton dispatching for Bison. + +# Copyright (C) 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +b4_glr_if( [b4_complain([%%glr-parser not supported for D])]) +b4_nondeterministic_if([b4_complain([%%nondeterministic-parser not supported for D])]) + +m4_define_default([b4_used_skeleton], [b4_skeletonsdir/[lalr1.d]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/Engine/bin/bison-flex/data/skeletons/d.m4 b/Engine/bin/bison-flex/data/skeletons/d.m4 new file mode 100644 index 000000000..c0632e472 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/d.m4 @@ -0,0 +1,628 @@ + -*- Autoconf -*- + +# D language support for Bison + +# Copyright (C) 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + + +m4_include(b4_skeletonsdir/[c-like.m4]) + + +# b4_symbol_action(SYMBOL-NUM, ACTION) +# ------------------------------------ +# Run the action ACTION ("destructor" or "printer") for SYMBOL-NUM. +m4_define([b4_symbol_action], +[b4_symbol_if([$1], [has_$2], +[b4_dollar_pushdef([yyval], + [$1], + [], + [yyloc])dnl + _b4_symbol_case([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], [b4_symbol([$1], [$2_file])])dnl +b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@])dnl + break; + +b4_dollar_popdef[]dnl +])]) + + +# b4_use(EXPR) +# ------------ +# Pacify the compiler about some maybe unused value. +m4_define([b4_use], +[]) + + +# b4_sync_start(LINE, FILE) +# ------------------------- +m4_define([b4_sync_start], [[#]line $1 $2]) + + +# b4_list2(LIST1, LIST2) +# ---------------------- +# Join two lists with a comma if necessary. +m4_define([b4_list2], + [$1[]m4_ifval(m4_quote($1), [m4_ifval(m4_quote($2), [[, ]])])[]$2]) + + +# b4_percent_define_get3(DEF, PRE, POST, NOT) +# ------------------------------------------- +# Expand to the value of DEF surrounded by PRE and POST if it's %define'ed, +# otherwise NOT. +m4_define([b4_percent_define_get3], + [m4_ifval(m4_quote(b4_percent_define_get([$1])), + [$2[]b4_percent_define_get([$1])[]$3], [$4])]) + +# b4_percent_define_if_get2(ARG1, ARG2, DEF, NOT) +# ----------------------------------------------- +# Expand to the value of DEF if ARG1 or ARG2 are %define'ed, +# otherwise NOT. +m4_define([b4_percent_define_if_get2], + [m4_ifval(m4_quote(b4_percent_define_get([$1])), + [$3], [m4_ifval(m4_quote(b4_percent_define_get([$2])), + [$3], [$4])])]) + +# b4_percent_define_class_before_interface(CLASS, INTERFACE) +# ---------------------------------------------------------- +# Expand to a ', ' if both a class and an interface have been %define'ed +m4_define([b4_percent_define_class_before_interface], + [m4_ifval(m4_quote(b4_percent_define_get([$1])), + [m4_ifval(m4_quote(b4_percent_define_get([$2])), + [, ])])]) + + +# b4_flag_value(BOOLEAN-FLAG) +# --------------------------- +m4_define([b4_flag_value], [b4_flag_if([$1], [true], [false])]) + + +# b4_parser_class_declaration +# --------------------------- +# The declaration of the parser class ("class YYParser"), with all its +# qualifiers/annotations. +b4_percent_define_default([[api.parser.abstract]], [[false]]) +b4_percent_define_default([[api.parser.final]], [[false]]) +b4_percent_define_default([[api.parser.public]], [[false]]) + +m4_define([b4_parser_class_declaration], +[b4_percent_define_get3([api.parser.annotations], [], [ ])dnl +b4_percent_define_flag_if([api.parser.public], [public ])dnl +b4_percent_define_flag_if([api.parser.abstract], [abstract ])dnl +b4_percent_define_flag_if([api.parser.final], [final ])dnl +[class ]b4_parser_class[]dnl +b4_percent_define_if_get2([api.parser.extends], [api.parser.implements], [ : ])dnl +b4_percent_define_get([api.parser.extends])dnl +b4_percent_define_class_before_interface([api.parser.extends], [api.parser.implements])dnl +b4_percent_define_get([api.parser.implements])]) + + +# b4_lexer_if(TRUE, FALSE) +# ------------------------ +m4_define([b4_lexer_if], +[b4_percent_code_ifdef([[lexer]], [$1], [$2])]) + + +# b4_position_type_if(TRUE, FALSE) +# -------------------------------- +m4_define([b4_position_type_if], +[b4_percent_define_ifdef([[position_type]], [$1], [$2])]) + + +# b4_location_type_if(TRUE, FALSE) +# -------------------------------- +m4_define([b4_location_type_if], +[b4_percent_define_ifdef([[location_type]], [$1], [$2])]) + + +# b4_identification +# ----------------- +m4_define([b4_identification], +[[/** Version number for the Bison executable that generated this parser. */ + public static immutable string yy_bison_version = "]b4_version_string["; + + /** Name of the skeleton that generated this parser. */ + public static immutable string yy_bison_skeleton = ]b4_skeleton[; +]]) + + +## ------------ ## +## Data types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# MIN to MAX (included). +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [-128], [127]), [1], [byte], + b4_ints_in($@, [-32768], [32767]), [1], [short], + [int])]) + +# b4_int_type_for(NAME) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# `NAME_min' to `NAME_max' (included). +m4_define([b4_int_type_for], +[b4_int_type($1_min, $1_max)]) + +# b4_null +# ------- +m4_define([b4_null], [null]) + + +# b4_integral_parser_table_define(NAME, DATA, COMMENT) +#----------------------------------------------------- +# Define "yy" whose contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[m4_ifvaln([$3], [b4_comment([$3], [ ])])dnl +private static immutable b4_int_type_for([$2])[[]] yy$1_ = +@{ + $2 +@};dnl +]) + + +## ------------- ## +## Token kinds. ## +## ------------- ## + +m4_define([b4_symbol(-2, id)], [[YYEMPTY]]) +b4_percent_define_default([[api.token.raw]], [[true]]) + +# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) +# --------------------------------------- +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[b4_token_format([ %s = %s, +], [$1])]) + +# b4_token_enums +# -------------- +# Output the definition of the tokens as enums. +m4_define([b4_token_enums], +[/* Token kinds. */ +public enum TokenKind { + ]b4_symbol(empty, id)[ = -2, +b4_symbol_foreach([b4_token_enum])dnl +} +]) + +# b4_symbol_translate(STRING) +# --------------------------- +# Used by "bison" in the array of symbol names to mark those that +# require translation. +m4_define([b4_symbol_translate], +[[_($1)]]) + + +# _b4_token_constructor_define(SYMBOL-NUM) +# ---------------------------------------- +# Define Symbol.FOO for SYMBOL-NUM. +m4_define([_b4_token_constructor_define], +[b4_token_visible_if([$1], +[[ + static auto ]b4_symbol([$1], [id])[(]b4_symbol_if([$1], [has_type], +[b4_union_if([b4_symbol([$1], [type]], +[[typeof(YYSemanticType.]b4_symbol([$1], [type])[]])) [val]])dnl +[]b4_locations_if([b4_symbol_if([$1], [has_type], [[, ]])[Location l]])[) + { + return Symbol(TokenKind.]b4_symbol([$1], [id])[]b4_symbol_if([$1], [has_type], + [[, val]])[]b4_locations_if([[, l]])[); + }]])]) + +# b4_token_constructor_define +# --------------------------- +# Define Symbol.FOO for each token kind FOO. +m4_define([b4_token_constructor_define], +[[ + /* Implementation of token constructors for each symbol type visible to + * the user. The code generates static methods that have the same names + * as the TokenKinds. + */]b4_symbol_foreach([_b4_token_constructor_define])dnl +]) + +## -------------- ## +## Symbol kinds. ## +## -------------- ## + +# b4_symbol_kind(NUM) +# ------------------- +m4_define([b4_symbol_kind], +[SymbolKind.b4_symbol_kind_base($@)]) + + +# b4_symbol_enum(SYMBOL-NUM) +# -------------------------- +# Output the definition of this symbol as an enum. +m4_define([b4_symbol_enum], +[m4_format([ %-30s %s], + m4_format([[%s = %s,]], + b4_symbol([$1], [kind_base]), + [$1]), + [b4_symbol_tag_comment([$1])])]) + + +# b4_declare_symbol_enum +# ---------------------- +# The definition of the symbol internal numbers as an enum. +# Defining YYEMPTY here is important: it forces the compiler +# to use a signed type, which matters for yytoken. +m4_define([b4_declare_symbol_enum], +[[ /* Symbol kinds. */ + struct SymbolKind + { + enum + { + ]b4_symbol(empty, kind_base)[ = -2, /* No symbol. */ +]b4_symbol_foreach([b4_symbol_enum])dnl +[ } + + private int yycode_; + alias yycode_ this; + + this(int code) + { + yycode_ = code; + } + + /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + final void toString(W)(W sink) const + if (isOutputRange!(W, char)) + { + immutable string[] yy_sname = @{ + ]b4_symbol_names[ + @};]b4_has_translations_if([[ + /* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is + internationalizable. */ + immutable ]b4_int_type_for([b4_translatable])[[] yytranslatable = @{ + ]b4_translatable[ + @};]])[ + + put(sink, yy_sname[yycode_]); + } + } +]]) + + +# b4_case(ID, CODE, [COMMENTS]) +# ----------------------------- +m4_define([b4_case], [ case $1:m4_ifval([$3], [ b4_comment([$3])]) +$2 + break;]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +m4_define([b4_yystype], [b4_percent_define_get([[stype]])]) +b4_percent_define_default([[stype]], [[YYSemanticType]])]) + +# %name-prefix +m4_define_default([b4_prefix], [[YY]]) + +b4_percent_define_default([[api.parser.class]], [b4_prefix[]Parser])]) +m4_define([b4_parser_class], [b4_percent_define_get([[api.parser.class]])]) + +#b4_percent_define_default([[location_type]], [Location])]) +m4_define([b4_location_type], b4_percent_define_ifdef([[location_type]],[b4_percent_define_get([[location_type]])],[YYLocation])) + +#b4_percent_define_default([[position_type]], [Position])]) +m4_define([b4_position_type], b4_percent_define_ifdef([[position_type]],[b4_percent_define_get([[position_type]])],[YYPosition])) + + +## ---------------- ## +## api.value.type. ## +## ---------------- ## + + +# ---------------------- # +# api.value.type=union. # +# ---------------------- # + +# b4_symbol_type_register(SYMBOL-NUM) +# ----------------------------------- +# Symbol SYMBOL-NUM has a type (for union) instead of a type-tag. +# Extend the definition of %union's body (b4_union_members) with a +# field of that type, and extend the symbol's "type" field to point to +# the field name, instead of the type name. +m4_define([b4_symbol_type_register], +[m4_define([b4_symbol($1, type_tag)], + [b4_symbol_if([$1], [has_id], + [b4_symbol([$1], [id])], + [yykind_[]b4_symbol([$1], [number])])])dnl +m4_append([b4_union_members], +m4_expand([m4_format([ %-40s %s], + m4_expand([b4_symbol([$1], [type]) b4_symbol([$1], [type_tag]);]), + [b4_symbol_tag_comment([$1])])])) +]) + + +# b4_type_define_tag(SYMBOL1-NUM, ...) +# ------------------------------------ +# For the batch of symbols SYMBOL1-NUM... (which all have the same +# type), enhance the %union definition for each of them, and set +# there "type" field to the field tag name, instead of the type name. +m4_define([b4_type_define_tag], +[b4_symbol_if([$1], [has_type], + [m4_map([b4_symbol_type_register], [$@])]) +]) + + +# b4_symbol_value_union(VAL, SYMBOL-NUM, [TYPE]) +# ---------------------------------------------- +# Same of b4_symbol_value, but when api.value.type=union. +m4_define([b4_symbol_value_union], +[m4_ifval([$3], + [(*($3*)(&$1))], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [($1.b4_symbol([$2], [type_tag]))], + [$1])], + [$1])])]) + + +# b4_value_type_setup_union +# ------------------------- +# Setup support for api.value.type=union. Symbols are defined with a +# type instead of a union member name: build the corresponding union, +# and give the symbols their tag. +m4_define([b4_value_type_setup_union], +[m4_define([b4_union_members]) +b4_type_foreach([b4_type_define_tag]) +m4_copy_force([b4_symbol_value_union], [b4_symbol_value]) +]) + + +# _b4_value_type_setup_keyword +# ---------------------------- +# api.value.type is defined with a keyword/string syntax. Check if +# that is properly defined, and prepare its use. +m4_define([_b4_value_type_setup_keyword], +[b4_percent_define_check_values([[[[api.value.type]], + [[none]], + [[union]], + [[union-directive]], + [[yystype]]]])dnl +m4_case(b4_percent_define_get([[api.value.type]]), + [union], [b4_value_type_setup_union])]) + + +# b4_value_type_setup +# ------------------- +# Check if api.value.type is properly defined, and possibly prepare +# its use. +b4_define_silent([b4_value_type_setup], +[ +# Define default value. +b4_percent_define_ifdef([[api.value.type]], [], +[# %union => api.value.type=union-directive +m4_ifdef([b4_union_members], +[m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [union-directive])], +[# no tag seen => api.value.type={int} +m4_if(b4_tag_seen_flag, 0, +[m4_define([b4_percent_define_kind(api.value.type)], [code]) +m4_define([b4_percent_define(api.value.type)], [int])], +[# otherwise api.value.type=yystype +m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [yystype])])])]) + +# Set up. +m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), + [keyword], [_b4_value_type_setup_keyword]) +]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_symbol_value(VAL, [SYMBOL-NUM], [TYPE-TAG]) +# ---------------------------------------------- +# See README. FIXME: factor in c-like? +m4_define([b4_symbol_value], +[m4_ifval([$3], + [($1.$3)], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [($1.b4_symbol([$2], [type]))], + [$1])], + [$1])])]) + +# b4_lhs_value(SYMBOL-NUM, [TYPE]) +# -------------------------------- +# See README. +m4_define([b4_lhs_value], +[b4_symbol_value([yyval], [$1], [$2])]) + + +# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) +# -------------------------------------------------- +# See README. +# +# In this simple implementation, %token and %type have class names +# between the angle brackets. +m4_define([b4_rhs_value], +[b4_symbol_value([(yystack.valueAt (b4_subtract([$1], [$2])))], [$3], [$4])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, POS) +# --------------------------------- +# Expansion of @POS, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[yystack.locationAt (b4_subtract($@))]) + + +# b4_lex_param +# b4_parse_param +# -------------- +# If defined, b4_lex_param arrives double quoted, but below we prefer +# it to be single quoted. Same for b4_parse_param. + +# TODO: should be in bison.m4 +m4_define_default([b4_lex_param], [[]])) +m4_define([b4_lex_param], b4_lex_param)) +m4_define([b4_parse_param], b4_parse_param)) + +# b4_lex_param_decl +# ------------------- +# Extra formal arguments of the constructor. +m4_define([b4_lex_param_decl], +[m4_ifset([b4_lex_param], + [b4_remove_comma([$1], + b4_param_decls(b4_lex_param))], + [$1])]) + +m4_define([b4_param_decls], + [m4_map([b4_param_decl], [$@])]) +m4_define([b4_param_decl], [, $1]) + +m4_define([b4_remove_comma], [m4_ifval(m4_quote($1), [$1, ], [])m4_shift2($@)]) + + + +# b4_parse_param_decl +# ------------------- +# Extra formal arguments of the constructor. +m4_define([b4_parse_param_decl], +[m4_ifset([b4_parse_param], + [b4_remove_comma([$1], + b4_param_decls(b4_parse_param))], + [$1])]) + + + +# b4_lex_param_call +# ------------------- +# Delegating the lexer parameters to the lexer constructor. +m4_define([b4_lex_param_call], + [m4_ifset([b4_lex_param], + [b4_remove_comma([$1], + b4_param_calls(b4_lex_param))], + [$1])]) +m4_define([b4_param_calls], + [m4_map([b4_param_call], [$@])]) +m4_define([b4_param_call], [, $2]) + + + +# b4_parse_param_cons +# ------------------- +# Extra initialisations of the constructor. +m4_define([b4_parse_param_cons], + [m4_ifset([b4_parse_param], + [b4_constructor_calls(b4_parse_param)])]) + +m4_define([b4_constructor_calls], + [m4_map([b4_constructor_call], [$@])]) +m4_define([b4_constructor_call], + [this.$2 = $2; + ]) + + + +# b4_parse_param_vars +# ------------------- +# Extra instance variables. +m4_define([b4_parse_param_vars], + [m4_ifset([b4_parse_param], + [ + /* User arguments. */ +b4_var_decls(b4_parse_param)])]) + +m4_define([b4_var_decls], + [m4_map_sep([b4_var_decl], [ +], [$@])]) +m4_define([b4_var_decl], + [ protected $1;]) + + +# b4_public_types_declare +# ----------------------- +# Define the public types: token, semantic value, location, and so forth. +# Depending on %define token_lex, may be output in the header or source file. +m4_define([b4_public_types_declare], +[[ +alias Symbol = ]b4_parser_class[.Symbol; +alias Value = ]b4_yystype[;]b4_locations_if([[ +alias Location = ]b4_location_type[; +alias Position = ]b4_position_type[;]b4_push_if([[ +alias PUSH_MORE = ]b4_parser_class[.YYPUSH_MORE; +alias ABORT = ]b4_parser_class[.YYABORT; +alias ACCEPT = ]b4_parser_class[.YYACCEPT;]])[]])[ +]]) + + +# b4_basic_symbol_constructor_define +# ---------------------------------- +# Create Symbol struct constructors for all the visible types. +m4_define([b4_basic_symbol_constructor_define], +[b4_token_visible_if([$1], +[[ this(TokenKind token]b4_symbol_if([$1], [has_type], +[[, ]b4_union_if([], [[typeof(YYSemanticType.]])b4_symbol([$1], [type])dnl +[]b4_union_if([], [[) ]])[ val]])[]b4_locations_if([[, Location loc]])[) + { + kind = yytranslate_(token);]b4_union_if([b4_symbol_if([$1], [has_type], [[ + static foreach (member; __traits(allMembers, YYSemanticType)) + { + static if (is(typeof(mixin("value_." ~ member)) == ]b4_symbol([$1], [type])[)) + { + mixin("value_." ~ member ~ " = val;"); + } + }]])], [b4_symbol_if([$1], [has_type], [[ + value_.]b4_symbol([$1], [type])[ = val;]])])[]b4_locations_if([ + location_ = loc;])[ + } +]])]) + + +# b4_symbol_type_define +# --------------------- +# Define symbol_type, the external type for symbols used for symbol +# constructors. +m4_define([b4_symbol_type_define], +[[ + /** + * A complete symbol + */ + struct Symbol + { + private SymbolKind kind; + private Value value_;]b4_locations_if([[ + private Location location_;]])[ + +]b4_type_foreach([b4_basic_symbol_constructor_define])[ + SymbolKind token() { return kind; } + Value value() { return value_; }]b4_locations_if([[ + Location location() { return location_; }]])[ +]b4_token_ctor_if([b4_token_constructor_define])[ + } +]]) diff --git a/Engine/bin/bison-flex/data/skeletons/glr.c b/Engine/bin/bison-flex/data/skeletons/glr.c new file mode 100644 index 000000000..fab3733f1 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/glr.c @@ -0,0 +1,2763 @@ +# -*- C -*- + +# GLR skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + + +# If we are loaded by glr.cc, do not override c++.m4 definitions by +# those of c.m4. +m4_if(b4_skeleton, ["glr.c"], + [m4_include(b4_skeletonsdir/[c.m4])]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + +# Included header. +b4_percent_define_default([[api.header.include]], + [["@basename(]b4_spec_header_file[@)"]]) + +## ------------------------ ## +## Pure/impure interfaces. ## +## ------------------------ ## + +b4_define_flag_if([pure]) +# If glr.cc is including this file and thus has already set b4_pure_flag, +# do not change the value of b4_pure_flag, and do not record a use of api.pure. +m4_ifndef([b4_pure_flag], +[b4_percent_define_default([[api.pure]], [[false]]) + m4_define([b4_pure_flag], + [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])]) + +# b4_yyerror_args +# --------------- +# Optional effective arguments passed to yyerror: user args plus yylloc, and +# a trailing comma. +m4_define([b4_yyerror_args], +[b4_pure_if([b4_locations_if([yylocp, ])])dnl +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) + + +# b4_lyyerror_args +# ---------------- +# Same as above, but on the lookahead, hence &yylloc instead of yylocp. +m4_define([b4_lyyerror_args], +[b4_pure_if([b4_locations_if([&yylloc, ])])dnl +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) + + +# b4_pure_args +# ------------ +# Same as b4_yyerror_args, but with a leading comma. +m4_define([b4_pure_args], +[b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args]) + + +# b4_lpure_args +# ------------- +# Same as above, but on the lookahead, hence &yylloc instead of yylocp. +m4_define([b4_lpure_args], +[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args]) + + + +# b4_pure_formals +# --------------- +# Arguments passed to yyerror: user formals plus yylocp with leading comma. +m4_define([b4_pure_formals], +[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals]) + + +# b4_locuser_formals(LOC = yylocp) +# -------------------------------- +# User formal arguments, possibly preceded by location argument. +m4_define([b4_locuser_formals], +[b4_locations_if([, YYLTYPE *m4_default([$1], [yylocp])])[]b4_user_formals]) + + +# b4_locuser_args(LOC = yylocp) +# ----------------------------- +m4_define([b4_locuser_args], +[b4_locations_if([, m4_default([$1], [yylocp])])[]b4_user_args]) + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value(SYMBOL-NUM, [TYPE]) +# -------------------------------- +# See README. +m4_define([b4_lhs_value], +[b4_symbol_value([(*yyvalp)], [$1], [$2])]) + + +# b4_rhs_data(RULE-LENGTH, POS) +# ----------------------------- +# See README. +m4_define([b4_rhs_data], +[YY_CAST (yyGLRStackItem const *, yyvsp)@{YYFILL (b4_subtract([$2], [$1]))@}.yystate]) + + +# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) +# -------------------------------------------------- +# Expansion of $$ or $$, for symbol SYMBOL-NUM. +m4_define([b4_rhs_value], +[b4_symbol_value([b4_rhs_data([$1], [$2]).yysemantics.yyval], [$3], [$4])]) + + + +## ----------- ## +## Locations. ## +## ----------- ## + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(*yylocp)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(b4_rhs_data([$1], [$2]).yyloc)]) + + +# b4_call_merger(MERGER-NUM, MERGER-NAME, SYMBOL-SUM) +# --------------------------------------------------- +m4_define([b4_call_merger], +[b4_case([$1], + [ b4_symbol_if([$3], [has_type], + [yy0->b4_symbol($3, slot) = $2 (*yy0, *yy1);], + [*yy0 = $2 (*yy0, *yy1);])])]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + +# b4_shared_declarations +# ---------------------- +# Declaration that might either go into the header (if --header) +# or open coded in the parser body. glr.cc has its own definition. +m4_if(b4_skeleton, ["glr.c"], +[m4_define([b4_shared_declarations], +[b4_declare_yydebug[ +]b4_percent_code_get([[requires]])[ +]b4_token_enums[ +]b4_declare_yylstype[ +int ]b4_prefix[parse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[); +]b4_percent_code_get([[provides]])[]dnl +]) +]) + +## -------------- ## +## Output files. ## +## -------------- ## + +# Unfortunately the order of generation between the header and the +# implementation file matters (for glr.c) because of the current +# implementation of api.value.type=union. In that case we still use a +# union for YYSTYPE, but we generate the contents of this union when +# setting up YYSTYPE. This is needed for other aspects, such as +# defining yy_symbol_value_print, since we need to now the name of the +# members of this union. +# +# To avoid this issue, just generate the header before the +# implementation file. But we should also make them more independent. + +# ----------------- # +# The header file. # +# ----------------- # + +# glr.cc produces its own header. +b4_glr_cc_if([], +[b4_header_if( +[b4_output_begin([b4_spec_header_file]) +b4_copyright([Skeleton interface for Bison GLR parsers in C], + [2002-2015, 2018-2021])[ +]b4_cpp_guard_open([b4_spec_mapped_header_file])[ +]b4_shared_declarations[ +]b4_cpp_guard_close([b4_spec_mapped_header_file])[ +]b4_output_end[ +]])]) + + +# ------------------------- # +# The implementation file. # +# ------------------------- # + +b4_output_begin([b4_parser_file_name]) +b4_copyright([Skeleton implementation for Bison GLR parsers in C], + [2002-2015, 2018-2021])[ +/* C GLR parser skeleton written by Paul Hilfinger. */ + +]b4_disclaimer[ +]b4_identification[ + +]b4_percent_code_get([[top]])[ +]m4_if(b4_api_prefix, [yy], [], +[[/* Substitute the type names. */ +#define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[ +#define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[ +]m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define ]b4_glr_cc_if([yy_parse_impl], [yyparse])[ ]b4_prefix[]b4_glr_cc_if([_parse_impl], [parse])[ +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug]]b4_pure_if([], [[ +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])]))[ + +]b4_user_pre_prologue[ +]b4_cast_define[ +]b4_null_define[ + +]b4_header_if([[#include ]b4_percent_define_get([[api.header.include]])], + [b4_shared_declarations])[ + +]b4_glr_cc_if([b4_glr_cc_setup], + [b4_declare_symbol_enum])[ + +/* Default (constant) value used for initialization for null + right-hand sides. Unlike the standard yacc.c template, here we set + the default value of $$ to a zeroed-out value. Since the default + value is undefined, this behavior is technically correct. */ +static YYSTYPE yyval_default;]b4_locations_if([[ +static YYLTYPE yyloc_default][]b4_yyloc_default;])[ + +]b4_user_post_prologue[ +]b4_percent_code_get[]dnl + +[#include +#include +#include +#include +#include + +]b4_c99_int_type_define[ +]b4_sizes_types_define[ + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif +]b4_has_translations_if([ +#ifndef N_ +# define N_(Msgid) Msgid +#endif +])[ + +#ifndef YYFREE +# define YYFREE free +#endif +#ifndef YYMALLOC +# define YYMALLOC malloc +#endif +#ifndef YYREALLOC +# define YYREALLOC realloc +#endif + +#ifdef __cplusplus + typedef bool yybool; +# define yytrue true +# define yyfalse false +#else + /* When we move to stdbool, get rid of the various casts to yybool. */ + typedef signed char yybool; +# define yytrue 1 +# define yyfalse 0 +#endif + +#ifndef YYSETJMP +# include +# define YYJMP_BUF jmp_buf +# define YYSETJMP(Env) setjmp (Env) +/* Pacify Clang and ICC. */ +# define YYLONGJMP(Env, Val) \ + do { \ + longjmp (Env, Val); \ + YY_ASSERT (0); \ + } while (yyfalse) +#endif + +]b4_attribute_define([noreturn])[ + +]b4_parse_assert_if([[#ifdef NDEBUG +# define YY_ASSERT(E) ((void) (0 && (E))) +#else +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_ASSERT(E) assert (E) +#endif +]], +[[#define YY_ASSERT(E) ((void) (0 && (E)))]])[ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL ]b4_final_state_number[ +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST ]b4_last[ + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS ]b4_tokens_number[ +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS ]b4_nterms_number[ +/* YYNRULES -- Number of rules. */ +#define YYNRULES ]b4_rules_number[ +/* YYNSTATES -- Number of states. */ +#define YYNSTATES ]b4_states_number[ +/* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */ +#define YYMAXRHS ]b4_r2_max[ +/* YYMAXLEFT -- Maximum number of symbols to the left of a handle + accessed by $0, $-1, etc., in any rule. */ +#define YYMAXLEFT ]b4_max_left_semantic_context[ + +/* YYMAXUTOK -- Last valid token kind. */ +#define YYMAXUTOK ]b4_code_max[ + +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ +]b4_api_token_raw_if(dnl +[[#define YYTRANSLATE(YYX) YY_CAST (yysymbol_kind_t, YYX)]], +[[#define YYTRANSLATE(YYX) \ + (0 <= (YYX) && (YYX) <= YYMAXUTOK \ + ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ + : ]b4_symbol_prefix[YYUNDEF) + +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex. */ +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = +{ + ]b4_translate[ +};]])[ + +#if ]b4_api_PREFIX[DEBUG +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const ]b4_int_type_for([b4_rline])[ yyrline[] = +{ + ]b4_rline[ +}; +#endif + +#define YYPACT_NINF (]b4_pact_ninf[) +#define YYTABLE_NINF (]b4_table_ninf[) + +]b4_parser_tables_define[ + +/* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ +static const ]b4_int_type_for([b4_dprec])[ yydprec[] = +{ + ]b4_dprec[ +}; + +/* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ +static const ]b4_int_type_for([b4_merger])[ yymerger[] = +{ + ]b4_merger[ +}; + +/* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as + in the case of predicates. */ +static const yybool yyimmediate[] = +{ + ]b4_immediate[ +}; + +/* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of + list of conflicting reductions corresponding to action entry for + state STATE-NUM in yytable. 0 means no conflicts. The list in + yyconfl is terminated by a rule number of 0. */ +static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = +{ + ]b4_conflict_list_heads[ +}; + +/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by + 0, pointed into by YYCONFLP. */ +]dnl Do not use b4_int_type_for here, since there are places where +dnl pointers onto yyconfl are taken, whose type is "short*". +dnl We probably ought to introduce a type for confl. +[static const short yyconfl[] = +{ + ]b4_conflicting_rules[ +}; + +]b4_locations_if([[ +]b4_yylloc_default_define[ +# define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) +]])[ + +]b4_pure_if( +[ +#undef yynerrs +#define yynerrs (yystackp->yyerrcnt) +#undef yychar +#define yychar (yystackp->yyrawchar) +#undef yylval +#define yylval (yystackp->yyval) +#undef yylloc +#define yylloc (yystackp->yyloc) +m4_if(b4_prefix[], [yy], [], +[#define b4_prefix[]nerrs yynerrs +#define b4_prefix[]char yychar +#define b4_prefix[]lval yylval +#define b4_prefix[]lloc yylloc])], +[YYSTYPE yylval;]b4_locations_if([[ +YYLTYPE yylloc;]])[ + +int yynerrs; +int yychar;])[ + +enum { YYENOMEM = -2 }; + +typedef enum { yyok, yyaccept, yyabort, yyerr, yynomem } YYRESULTTAG; + +#define YYCHK(YYE) \ + do { \ + YYRESULTTAG yychk_flag = YYE; \ + if (yychk_flag != yyok) \ + return yychk_flag; \ + } while (0) + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH ]b4_stack_depth_init[ +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH ]b4_stack_depth_max[ +#endif + +/* Minimum number of free items on the stack allowed after an + allocation. This is to allow allocation and initialization + to be completed by functions that call yyexpandGLRStack before the + stack is expanded, thus insuring that all necessary pointers get + properly redirected to new data. */ +#define YYHEADROOM 2 + +#ifndef YYSTACKEXPANDABLE +# define YYSTACKEXPANDABLE 1 +#endif + +#if YYSTACKEXPANDABLE +# define YY_RESERVE_GLRSTACK(Yystack) \ + do { \ + if (Yystack->yyspaceLeft < YYHEADROOM) \ + yyexpandGLRStack (Yystack); \ + } while (0) +#else +# define YY_RESERVE_GLRSTACK(Yystack) \ + do { \ + if (Yystack->yyspaceLeft < YYHEADROOM) \ + yyMemoryExhausted (Yystack); \ + } while (0) +#endif + +/** State numbers. */ +typedef int yy_state_t; + +/** Rule numbers. */ +typedef int yyRuleNum; + +/** Item references. */ +typedef short yyItemNum; + +typedef struct yyGLRState yyGLRState; +typedef struct yyGLRStateSet yyGLRStateSet; +typedef struct yySemanticOption yySemanticOption; +typedef union yyGLRStackItem yyGLRStackItem; +typedef struct yyGLRStack yyGLRStack; + +struct yyGLRState +{ + /** Type tag: always true. */ + yybool yyisState; + /** Type tag for yysemantics. If true, yyval applies, otherwise + * yyfirstVal applies. */ + yybool yyresolved; + /** Number of corresponding LALR(1) machine state. */ + yy_state_t yylrState; + /** Preceding state in this stack */ + yyGLRState* yypred; + /** Source position of the last token produced by my symbol */ + YYPTRDIFF_T yyposn; + union { + /** First in a chain of alternative reductions producing the + * nonterminal corresponding to this state, threaded through + * yynext. */ + yySemanticOption* yyfirstVal; + /** Semantic value for this state. */ + YYSTYPE yyval; + } yysemantics;]b4_locations_if([[ + /** Source location for this state. */ + YYLTYPE yyloc;]])[ +}; + +struct yyGLRStateSet +{ + yyGLRState** yystates; + /** During nondeterministic operation, yylookaheadNeeds tracks which + * stacks have actually needed the current lookahead. During deterministic + * operation, yylookaheadNeeds[0] is not maintained since it would merely + * duplicate yychar != ]b4_symbol(empty, id)[. */ + yybool* yylookaheadNeeds; + YYPTRDIFF_T yysize; + YYPTRDIFF_T yycapacity; +}; + +struct yySemanticOption +{ + /** Type tag: always false. */ + yybool yyisState; + /** Rule number for this reduction */ + yyRuleNum yyrule; + /** The last RHS state in the list of states to be reduced. */ + yyGLRState* yystate; + /** The lookahead for this reduction. */ + int yyrawchar; + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ + /** Next sibling in chain of options. To facilitate merging, + * options are chained in decreasing order by address. */ + yySemanticOption* yynext; +}; + +/** Type of the items in the GLR stack. The yyisState field + * indicates which item of the union is valid. */ +union yyGLRStackItem { + yyGLRState yystate; + yySemanticOption yyoption; +}; + +struct yyGLRStack { + int yyerrState; +]b4_locations_if([[ /* To compute the location of the error token. */ + yyGLRStackItem yyerror_range[3];]])[ +]b4_pure_if( +[ + int yyerrcnt; + int yyrawchar; + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ +])[ + YYJMP_BUF yyexception_buffer; + yyGLRStackItem* yyitems; + yyGLRStackItem* yynextFree; + YYPTRDIFF_T yyspaceLeft; + yyGLRState* yysplitPoint; + yyGLRState* yylastDeleted; + yyGLRStateSet yytops; +}; + +#if YYSTACKEXPANDABLE +static void yyexpandGLRStack (yyGLRStack* yystackp); +#endif + +_Noreturn static void +yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) +{ + if (yymsg != YY_NULLPTR) + yyerror (]b4_yyerror_args[yymsg); + YYLONGJMP (yystackp->yyexception_buffer, 1); +} + +_Noreturn static void +yyMemoryExhausted (yyGLRStack* yystackp) +{ + YYLONGJMP (yystackp->yyexception_buffer, 2); +} + +/** Accessing symbol of state YYSTATE. */ +static inline yysymbol_kind_t +yy_accessing_symbol (yy_state_t yystate) +{ + return YY_CAST (yysymbol_kind_t, yystos[yystate]); +} + +#if ]b4_parse_error_case([simple], [b4_api_PREFIX[DEBUG || ]b4_token_table_flag], [[1]])[ +/* The user-facing name of the symbol whose (internal) number is + YYSYMBOL. No bounds checking. */ +static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; + +]b4_parse_error_bmatch([simple\|verbose], +[[/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + ]b4_tname[ +}; + +static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + return yytname[yysymbol]; +}]], +[[static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + static const char *const yy_sname[] = + { + ]b4_symbol_names[ + };]b4_has_translations_if([[ + /* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is + internationalizable. */ + static ]b4_int_type_for([b4_translatable])[ yytranslatable[] = + { + ]b4_translatable[ + }; + return (yysymbol < YYNTOKENS && yytranslatable[yysymbol] + ? _(yy_sname[yysymbol]) + : yy_sname[yysymbol]);]], [[ + return yy_sname[yysymbol];]])[ +}]])[ +#endif + +/** Left-hand-side symbol for rule #YYRULE. */ +static inline yysymbol_kind_t +yylhsNonterm (yyRuleNum yyrule) +{ + return YY_CAST (yysymbol_kind_t, yyr1[yyrule]); +} + +#if ]b4_api_PREFIX[DEBUG + +# ifndef YYFPRINTF +# define YYFPRINTF fprintf +# endif + +# define YY_FPRINTF \ + YY_IGNORE_USELESS_CAST_BEGIN YY_FPRINTF_ + +# define YY_FPRINTF_(Args) \ + do { \ + YYFPRINTF Args; \ + YY_IGNORE_USELESS_CAST_END \ + } while (0) + +# define YY_DPRINTF \ + YY_IGNORE_USELESS_CAST_BEGIN YY_DPRINTF_ + +# define YY_DPRINTF_(Args) \ + do { \ + if (yydebug) \ + YYFPRINTF Args; \ + YY_IGNORE_USELESS_CAST_END \ + } while (0) + +]b4_yylocation_print_define[ + +]b4_yy_symbol_print_define[ + +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ + do { \ + if (yydebug) \ + { \ + YY_FPRINTF ((stderr, "%s ", Title)); \ + yy_symbol_print (stderr, Kind, Value]b4_locuser_args([Location])[); \ + YY_FPRINTF ((stderr, "\n")); \ + } \ + } while (0) + +static inline void +yy_reduce_print (yybool yynormal, yyGLRStackItem* yyvsp, YYPTRDIFF_T yyk, + yyRuleNum yyrule]b4_user_formals[); + +# define YY_REDUCE_PRINT(Args) \ + do { \ + if (yydebug) \ + yy_reduce_print Args; \ + } while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; + +static void yypstack (yyGLRStack* yystackp, YYPTRDIFF_T yyk) + YY_ATTRIBUTE_UNUSED; +static void yypdumpstack (yyGLRStack* yystackp) + YY_ATTRIBUTE_UNUSED; + +#else /* !]b4_api_PREFIX[DEBUG */ + +# define YY_DPRINTF(Args) do {} while (yyfalse) +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) +# define YY_REDUCE_PRINT(Args) + +#endif /* !]b4_api_PREFIX[DEBUG */ + +]b4_parse_error_case( + [simple], +[[]], +[[#ifndef yystrlen +# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) +#endif + +]b4_parse_error_bmatch( + [detailed\|verbose], +[[#ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +yystpcpy (char *yydest, const char *yysrc) +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +#endif]])[ + +]b4_parse_error_case( + [verbose], +[[#ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYPTRDIFF_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYPTRDIFF_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + else + goto append; + + append: + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (yyres) + return yystpcpy (yyres, yystr) - yyres; + else + return yystrlen (yystr); +} +#endif +]])])[ + +/** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting + * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred + * containing the pointer to the next state in the chain. */ +static void yyfillin (yyGLRStackItem *, int, int) YY_ATTRIBUTE_UNUSED; +static void +yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) +{ + int i; + yyGLRState *s = yyvsp[yylow0].yystate.yypred; + for (i = yylow0-1; i >= yylow1; i -= 1) + { +#if ]b4_api_PREFIX[DEBUG + yyvsp[i].yystate.yylrState = s->yylrState; +#endif + yyvsp[i].yystate.yyresolved = s->yyresolved; + if (s->yyresolved) + yyvsp[i].yystate.yysemantics.yyval = s->yysemantics.yyval; + else + /* The effect of using yyval or yyloc (in an immediate rule) is + * undefined. */ + yyvsp[i].yystate.yysemantics.yyfirstVal = YY_NULLPTR;]b4_locations_if([[ + yyvsp[i].yystate.yyloc = s->yyloc;]])[ + s = yyvsp[i].yystate.yypred = s->yypred; + } +} + +]m4_define([b4_yygetToken_call], + [[yygetToken (&yychar][]b4_pure_if([, yystackp])[]b4_user_args[)]])[ +/** If yychar is empty, fetch the next token. */ +static inline yysymbol_kind_t +yygetToken (int *yycharp][]b4_pure_if([, yyGLRStack* yystackp])[]b4_user_formals[) +{ + yysymbol_kind_t yytoken; +]b4_parse_param_use()dnl +[ if (*yycharp == ]b4_symbol(empty, id)[) + { + YY_DPRINTF ((stderr, "Reading a token\n"));]b4_glr_cc_if([[ +#if YY_EXCEPTIONS + try + { +#endif // YY_EXCEPTIONS + *yycharp = ]b4_yylex[; +#if YY_EXCEPTIONS + } + catch (const ]b4_namespace_ref[::]b4_parser_class[::syntax_error& yyexc) + { + YY_DPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));]b4_locations_if([ + yylloc = yyexc.location;])[ + yyerror (]b4_lyyerror_args[yyexc.what ()); + // Map errors caught in the scanner to the undefined token, + // so that error handling is started. However, record this + // with this special value of yychar. + *yycharp = ]b4_symbol(error, id)[; + } +#endif // YY_EXCEPTIONS]], [[ + *yycharp = ]b4_yylex[;]])[ + } + if (*yycharp <= ]b4_symbol(eof, [id])[) + { + *yycharp = ]b4_symbol(eof, [id])[; + yytoken = ]b4_symbol_prefix[YYEOF; + YY_DPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (*yycharp); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + return yytoken; +} + +/* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in + * YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1. + * For convenience, always return YYLOW1. */ +static inline int yyfill (yyGLRStackItem *, int *, int, yybool) + YY_ATTRIBUTE_UNUSED; +static inline int +yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal) +{ + if (!yynormal && yylow1 < *yylow) + { + yyfillin (yyvsp, *yylow, yylow1); + *yylow = yylow1; + } + return yylow1; +} + +/** Perform user action for rule number YYN, with RHS length YYRHSLEN, + * and top stack item YYVSP. YYLVALP points to place to put semantic + * value ($$), and yylocp points to place for location information + * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT, + * yyerr for YYERROR, yyabort for YYABORT, yynomem for YYNOMEM. */ +static YYRESULTTAG +yyuserAction (yyRuleNum yyrule, int yyrhslen, yyGLRStackItem* yyvsp, + yyGLRStack* yystackp, YYPTRDIFF_T yyk, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + const yybool yynormal YY_ATTRIBUTE_UNUSED = yystackp->yysplitPoint == YY_NULLPTR; + int yylow = 1; +]b4_parse_param_use([yyvalp], [yylocp])dnl +[ YY_USE (yyk); + YY_USE (yyrhslen); +# undef yyerrok +# define yyerrok (yystackp->yyerrState = 0) +# undef YYACCEPT +# define YYACCEPT return yyaccept +# undef YYABORT +# define YYABORT return yyabort +# undef YYNOMEM +# define YYNOMEM return yynomem +# undef YYERROR +# define YYERROR return yyerrok, yyerr +# undef YYRECOVERING +# define YYRECOVERING() (yystackp->yyerrState != 0) +# undef yyclearin +# define yyclearin (yychar = ]b4_symbol(empty, id)[) +# undef YYFILL +# define YYFILL(N) yyfill (yyvsp, &yylow, (N), yynormal) +# undef YYBACKUP +# define YYBACKUP(Token, Value) \ + return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")), \ + yyerrok, yyerr + + if (yyrhslen == 0) + *yyvalp = yyval_default; + else + *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yyval;]b4_locations_if([[ + /* Default location. */ + YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); + yystackp->yyerror_range[1].yystate.yyloc = *yylocp;]])[ + /* If yyk == -1, we are running a deferred action on a temporary + stack. In that case, YY_REDUCE_PRINT must not play with YYFILL, + so pretend the stack is "normal". */ + YY_REDUCE_PRINT ((yynormal || yyk == -1, yyvsp, yyk, yyrule]b4_user_args[));]b4_glr_cc_if([[ +#if YY_EXCEPTIONS + typedef ]b4_namespace_ref[::]b4_parser_class[::syntax_error syntax_error; + try + { +#endif // YY_EXCEPTIONS]])[ + switch (yyrule) + { +]b4_user_actions[ + default: break; + }]b4_glr_cc_if([[ +#if YY_EXCEPTIONS + } + catch (const syntax_error& yyexc) + { + YY_DPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));]b4_locations_if([ + *yylocp = yyexc.location;])[ + yyerror (]b4_yyerror_args[yyexc.what ()); + YYERROR; + } +#endif // YY_EXCEPTIONS]])[ + YY_SYMBOL_PRINT ("-> $$ =", yylhsNonterm (yyrule), yyvalp, yylocp); + + return yyok; +# undef yyerrok +# undef YYABORT +# undef YYACCEPT +# undef YYNOMEM +# undef YYERROR +# undef YYBACKUP +# undef yyclearin +# undef YYRECOVERING +} + + +static void +yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) +{ + YY_USE (yy0); + YY_USE (yy1); + + switch (yyn) + { +]b4_mergers[ + default: break; + } +} + + /* Bison grammar-table manipulation. */ + +]b4_yydestruct_define[ + +/** Number of symbols composing the right hand side of rule #RULE. */ +static inline int +yyrhsLength (yyRuleNum yyrule) +{ + return yyr2[yyrule]; +} + +static void +yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) +{ + if (yys->yyresolved) + yydestruct (yymsg, yy_accessing_symbol (yys->yylrState), + &yys->yysemantics.yyval]b4_locuser_args([&yys->yyloc])[); + else + { +#if ]b4_api_PREFIX[DEBUG + if (yydebug) + { + if (yys->yysemantics.yyfirstVal) + YY_FPRINTF ((stderr, "%s unresolved", yymsg)); + else + YY_FPRINTF ((stderr, "%s incomplete", yymsg)); + YY_SYMBOL_PRINT ("", yy_accessing_symbol (yys->yylrState), YY_NULLPTR, &yys->yyloc); + } +#endif + + if (yys->yysemantics.yyfirstVal) + { + yySemanticOption *yyoption = yys->yysemantics.yyfirstVal; + yyGLRState *yyrh; + int yyn; + for (yyrh = yyoption->yystate, yyn = yyrhsLength (yyoption->yyrule); + yyn > 0; + yyrh = yyrh->yypred, yyn -= 1) + yydestroyGLRState (yymsg, yyrh]b4_user_args[); + } + } +} + +#define yypact_value_is_default(Yyn) \ + ]b4_table_value_equals([[pact]], [[Yyn]], [b4_pact_ninf], [YYPACT_NINF])[ + +/** True iff LR state YYSTATE has only a default reduction (regardless + * of token). */ +static inline yybool +yyisDefaultedState (yy_state_t yystate) +{ + return yypact_value_is_default (yypact[yystate]); +} + +/** The default reduction for YYSTATE, assuming it has one. */ +static inline yyRuleNum +yydefaultAction (yy_state_t yystate) +{ + return yydefact[yystate]; +} + +#define yytable_value_is_error(Yyn) \ + ]b4_table_value_equals([[table]], [[Yyn]], [b4_table_ninf], [YYTABLE_NINF])[ + +/** The action to take in YYSTATE on seeing YYTOKEN. + * Result R means + * R < 0: Reduce on rule -R. + * R = 0: Error. + * R > 0: Shift to state R. + * Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list + * of conflicting reductions. + */ +static inline int +yygetLRActions (yy_state_t yystate, yysymbol_kind_t yytoken, const short** yyconflicts) +{ + int yyindex = yypact[yystate] + yytoken; + if (yytoken == ]b4_symbol(error, kind)[) + { + // This is the error token. + *yyconflicts = yyconfl; + return 0; + } + else if (yyisDefaultedState (yystate) + || yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) + { + *yyconflicts = yyconfl; + return -yydefact[yystate]; + } + else if (! yytable_value_is_error (yytable[yyindex])) + { + *yyconflicts = yyconfl + yyconflp[yyindex]; + return yytable[yyindex]; + } + else + { + *yyconflicts = yyconfl + yyconflp[yyindex]; + return 0; + } +} + +/** Compute post-reduction state. + * \param yystate the current state + * \param yysym the nonterminal to push on the stack + */ +static inline yy_state_t +yyLRgotoState (yy_state_t yystate, yysymbol_kind_t yysym) +{ + int yyr = yypgoto[yysym - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) + return yytable[yyr]; + else + return yydefgoto[yysym - YYNTOKENS]; +} + +static inline yybool +yyisShiftAction (int yyaction) +{ + return 0 < yyaction; +} + +static inline yybool +yyisErrorAction (int yyaction) +{ + return yyaction == 0; +} + + /* GLRStates */ + +/** Return a fresh GLRStackItem in YYSTACKP. The item is an LR state + * if YYISSTATE, and otherwise a semantic option. Callers should call + * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient + * headroom. */ + +static inline yyGLRStackItem* +yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState) +{ + yyGLRStackItem* yynewItem = yystackp->yynextFree; + yystackp->yyspaceLeft -= 1; + yystackp->yynextFree += 1; + yynewItem->yystate.yyisState = yyisState; + return yynewItem; +} + +/** Add a new semantic action that will execute the action for rule + * YYRULE on the semantic values in YYRHS to the list of + * alternative actions for YYSTATE. Assumes that YYRHS comes from + * stack #YYK of *YYSTACKP. */ +static void +yyaddDeferredAction (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yyGLRState* yystate, + yyGLRState* yyrhs, yyRuleNum yyrule) +{ + yySemanticOption* yynewOption = + &yynewGLRStackItem (yystackp, yyfalse)->yyoption; + YY_ASSERT (!yynewOption->yyisState); + yynewOption->yystate = yyrhs; + yynewOption->yyrule = yyrule; + if (yystackp->yytops.yylookaheadNeeds[yyk]) + { + yynewOption->yyrawchar = yychar; + yynewOption->yyval = yylval;]b4_locations_if([ + yynewOption->yyloc = yylloc;])[ + } + else + yynewOption->yyrawchar = ]b4_symbol(empty, id)[; + yynewOption->yynext = yystate->yysemantics.yyfirstVal; + yystate->yysemantics.yyfirstVal = yynewOption; + + YY_RESERVE_GLRSTACK (yystackp); +} + + /* GLRStacks */ + +/** Initialize YYSET to a singleton set containing an empty stack. */ +static yybool +yyinitStateSet (yyGLRStateSet* yyset) +{ + yyset->yysize = 1; + yyset->yycapacity = 16; + yyset->yystates + = YY_CAST (yyGLRState**, + YYMALLOC (YY_CAST (YYSIZE_T, yyset->yycapacity) + * sizeof yyset->yystates[0])); + if (! yyset->yystates) + return yyfalse; + yyset->yystates[0] = YY_NULLPTR; + yyset->yylookaheadNeeds + = YY_CAST (yybool*, + YYMALLOC (YY_CAST (YYSIZE_T, yyset->yycapacity) + * sizeof yyset->yylookaheadNeeds[0])); + if (! yyset->yylookaheadNeeds) + { + YYFREE (yyset->yystates); + return yyfalse; + } + memset (yyset->yylookaheadNeeds, + 0, + YY_CAST (YYSIZE_T, yyset->yycapacity) * sizeof yyset->yylookaheadNeeds[0]); + return yytrue; +} + +static void yyfreeStateSet (yyGLRStateSet* yyset) +{ + YYFREE (yyset->yystates); + YYFREE (yyset->yylookaheadNeeds); +} + +/** Initialize *YYSTACKP to a single empty stack, with total maximum + * capacity for all stacks of YYSIZE. */ +static yybool +yyinitGLRStack (yyGLRStack* yystackp, YYPTRDIFF_T yysize) +{ + yystackp->yyerrState = 0; + yynerrs = 0; + yystackp->yyspaceLeft = yysize; + yystackp->yyitems + = YY_CAST (yyGLRStackItem*, + YYMALLOC (YY_CAST (YYSIZE_T, yysize) + * sizeof yystackp->yynextFree[0])); + if (!yystackp->yyitems) + return yyfalse; + yystackp->yynextFree = yystackp->yyitems; + yystackp->yysplitPoint = YY_NULLPTR; + yystackp->yylastDeleted = YY_NULLPTR; + return yyinitStateSet (&yystackp->yytops); +} + + +#if YYSTACKEXPANDABLE +# define YYRELOC(YYFROMITEMS, YYTOITEMS, YYX, YYTYPE) \ + &((YYTOITEMS) \ + - ((YYFROMITEMS) - YY_REINTERPRET_CAST (yyGLRStackItem*, (YYX))))->YYTYPE + +/** If *YYSTACKP is expandable, extend it. WARNING: Pointers into the + stack from outside should be considered invalid after this call. + We always expand when there are 1 or fewer items left AFTER an + allocation, so that we can avoid having external pointers exist + across an allocation. */ +static void +yyexpandGLRStack (yyGLRStack* yystackp) +{ + yyGLRStackItem* yynewItems; + yyGLRStackItem* yyp0, *yyp1; + YYPTRDIFF_T yynewSize; + YYPTRDIFF_T yyn; + YYPTRDIFF_T yysize = yystackp->yynextFree - yystackp->yyitems; + if (YYMAXDEPTH - YYHEADROOM < yysize) + yyMemoryExhausted (yystackp); + yynewSize = 2*yysize; + if (YYMAXDEPTH < yynewSize) + yynewSize = YYMAXDEPTH; + yynewItems + = YY_CAST (yyGLRStackItem*, + YYMALLOC (YY_CAST (YYSIZE_T, yynewSize) + * sizeof yynewItems[0])); + if (! yynewItems) + yyMemoryExhausted (yystackp); + for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize; + 0 < yyn; + yyn -= 1, yyp0 += 1, yyp1 += 1) + { + *yyp1 = *yyp0; + if (*YY_REINTERPRET_CAST (yybool *, yyp0)) + { + yyGLRState* yys0 = &yyp0->yystate; + yyGLRState* yys1 = &yyp1->yystate; + if (yys0->yypred != YY_NULLPTR) + yys1->yypred = + YYRELOC (yyp0, yyp1, yys0->yypred, yystate); + if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != YY_NULLPTR) + yys1->yysemantics.yyfirstVal = + YYRELOC (yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); + } + else + { + yySemanticOption* yyv0 = &yyp0->yyoption; + yySemanticOption* yyv1 = &yyp1->yyoption; + if (yyv0->yystate != YY_NULLPTR) + yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); + if (yyv0->yynext != YY_NULLPTR) + yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); + } + } + if (yystackp->yysplitPoint != YY_NULLPTR) + yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems, + yystackp->yysplitPoint, yystate); + + for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1) + if (yystackp->yytops.yystates[yyn] != YY_NULLPTR) + yystackp->yytops.yystates[yyn] = + YYRELOC (yystackp->yyitems, yynewItems, + yystackp->yytops.yystates[yyn], yystate); + YYFREE (yystackp->yyitems); + yystackp->yyitems = yynewItems; + yystackp->yynextFree = yynewItems + yysize; + yystackp->yyspaceLeft = yynewSize - yysize; +} +#endif + +static void +yyfreeGLRStack (yyGLRStack* yystackp) +{ + YYFREE (yystackp->yyitems); + yyfreeStateSet (&yystackp->yytops); +} + +/** Assuming that YYS is a GLRState somewhere on *YYSTACKP, update the + * splitpoint of *YYSTACKP, if needed, so that it is at least as deep as + * YYS. */ +static inline void +yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) +{ + if (yystackp->yysplitPoint != YY_NULLPTR && yystackp->yysplitPoint > yys) + yystackp->yysplitPoint = yys; +} + +/** Invalidate stack #YYK in *YYSTACKP. */ +static inline void +yymarkStackDeleted (yyGLRStack* yystackp, YYPTRDIFF_T yyk) +{ + if (yystackp->yytops.yystates[yyk] != YY_NULLPTR) + yystackp->yylastDeleted = yystackp->yytops.yystates[yyk]; + yystackp->yytops.yystates[yyk] = YY_NULLPTR; +} + +/** Undelete the last stack in *YYSTACKP that was marked as deleted. Can + only be done once after a deletion, and only when all other stacks have + been deleted. */ +static void +yyundeleteLastStack (yyGLRStack* yystackp) +{ + if (yystackp->yylastDeleted == YY_NULLPTR || yystackp->yytops.yysize != 0) + return; + yystackp->yytops.yystates[0] = yystackp->yylastDeleted; + yystackp->yytops.yysize = 1; + YY_DPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); + yystackp->yylastDeleted = YY_NULLPTR; +} + +static inline void +yyremoveDeletes (yyGLRStack* yystackp) +{ + YYPTRDIFF_T yyi, yyj; + yyi = yyj = 0; + while (yyj < yystackp->yytops.yysize) + { + if (yystackp->yytops.yystates[yyi] == YY_NULLPTR) + { + if (yyi == yyj) + YY_DPRINTF ((stderr, "Removing dead stacks.\n")); + yystackp->yytops.yysize -= 1; + } + else + { + yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi]; + /* In the current implementation, it's unnecessary to copy + yystackp->yytops.yylookaheadNeeds[yyi] since, after + yyremoveDeletes returns, the parser immediately either enters + deterministic operation or shifts a token. However, it doesn't + hurt, and the code might evolve to need it. */ + yystackp->yytops.yylookaheadNeeds[yyj] = + yystackp->yytops.yylookaheadNeeds[yyi]; + if (yyj != yyi) + YY_DPRINTF ((stderr, "Rename stack %ld -> %ld.\n", + YY_CAST (long, yyi), YY_CAST (long, yyj))); + yyj += 1; + } + yyi += 1; + } +} + +/** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with (resolved) semantic + * value *YYVALP and source location *YYLOCP. */ +static inline void +yyglrShift (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yy_state_t yylrState, + YYPTRDIFF_T yyposn, + YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[) +{ + yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; + + yynewState->yylrState = yylrState; + yynewState->yyposn = yyposn; + yynewState->yyresolved = yytrue; + yynewState->yypred = yystackp->yytops.yystates[yyk]; + yynewState->yysemantics.yyval = *yyvalp;]b4_locations_if([ + yynewState->yyloc = *yylocp;])[ + yystackp->yytops.yystates[yyk] = yynewState; + + YY_RESERVE_GLRSTACK (yystackp); +} + +/** Shift stack #YYK of *YYSTACKP, to a new state corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with the (unresolved) + * semantic value of YYRHS under the action for YYRULE. */ +static inline void +yyglrShiftDefer (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yy_state_t yylrState, + YYPTRDIFF_T yyposn, yyGLRState* yyrhs, yyRuleNum yyrule) +{ + yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; + YY_ASSERT (yynewState->yyisState); + + yynewState->yylrState = yylrState; + yynewState->yyposn = yyposn; + yynewState->yyresolved = yyfalse; + yynewState->yypred = yystackp->yytops.yystates[yyk]; + yynewState->yysemantics.yyfirstVal = YY_NULLPTR; + yystackp->yytops.yystates[yyk] = yynewState; + + /* Invokes YY_RESERVE_GLRSTACK. */ + yyaddDeferredAction (yystackp, yyk, yynewState, yyrhs, yyrule); +} + +#if ]b4_api_PREFIX[DEBUG + +/*----------------------------------------------------------------------. +| Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. | +`----------------------------------------------------------------------*/ + +static inline void +yy_reduce_print (yybool yynormal, yyGLRStackItem* yyvsp, YYPTRDIFF_T yyk, + yyRuleNum yyrule]b4_user_formals[) +{ + int yynrhs = yyrhsLength (yyrule);]b4_locations_if([ + int yylow = 1;])[ + int yyi; + YY_FPRINTF ((stderr, "Reducing stack %ld by rule %d (line %d):\n", + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule])); + if (! yynormal) + yyfillin (yyvsp, 1, -yynrhs); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YY_FPRINTF ((stderr, " $%d = ", yyi + 1)); + yy_symbol_print (stderr, + yy_accessing_symbol (yyvsp[yyi - yynrhs + 1].yystate.yylrState), + &yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yyval]b4_locations_if([, + &]b4_rhs_location(yynrhs, yyi + 1))[]dnl + b4_user_args[); + if (!yyvsp[yyi - yynrhs + 1].yystate.yyresolved) + YY_FPRINTF ((stderr, " (unresolved)")); + YY_FPRINTF ((stderr, "\n")); + } +} +#endif + +/** Pop the symbols consumed by reduction #YYRULE from the top of stack + * #YYK of *YYSTACKP, and perform the appropriate semantic action on their + * semantic values. Assumes that all ambiguities in semantic values + * have been previously resolved. Set *YYVALP to the resulting value, + * and *YYLOCP to the computed location (if any). Return value is as + * for userAction. */ +static inline YYRESULTTAG +yydoAction (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yyRuleNum yyrule, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + int yynrhs = yyrhsLength (yyrule); + + if (yystackp->yysplitPoint == YY_NULLPTR) + { + /* Standard special case: single stack. */ + yyGLRStackItem* yyrhs + = YY_REINTERPRET_CAST (yyGLRStackItem*, yystackp->yytops.yystates[yyk]); + YY_ASSERT (yyk == 0); + yystackp->yynextFree -= yynrhs; + yystackp->yyspaceLeft += yynrhs; + yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; + return yyuserAction (yyrule, yynrhs, yyrhs, yystackp, yyk, + yyvalp]b4_locuser_args[); + } + else + { + yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + yyGLRState* yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred + = yystackp->yytops.yystates[yyk]; + int yyi;]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[ + for (yyi = 0; yyi < yynrhs; yyi += 1) + { + yys = yys->yypred; + YY_ASSERT (yys); + } + yyupdateSplit (yystackp, yys); + yystackp->yytops.yystates[yyk] = yys; + return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yystackp, yyk, yyvalp]b4_locuser_args[); + } +} + +/** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE, + * and push back on the resulting nonterminal symbol. Perform the + * semantic action associated with YYRULE and store its value with the + * newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently + * unambiguous. Otherwise, store the deferred semantic action with + * the new state. If the new state would have an identical input + * position, LR state, and predecessor to an existing state on the stack, + * it is identified with that existing state, eliminating stack #YYK from + * *YYSTACKP. In this case, the semantic value is + * added to the options for the existing state's semantic value. + */ +static inline YYRESULTTAG +yyglrReduce (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yyRuleNum yyrule, + yybool yyforceEval]b4_user_formals[) +{ + YYPTRDIFF_T yyposn = yystackp->yytops.yystates[yyk]->yyposn; + + if (yyforceEval || yystackp->yysplitPoint == YY_NULLPTR) + { + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ + + YYRESULTTAG yyflag = yydoAction (yystackp, yyk, yyrule, &yyval]b4_locuser_args([&yyloc])[); + if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULLPTR) + YY_DPRINTF ((stderr, + "Parse on stack %ld rejected by rule %d (line %d).\n", + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule])); + if (yyflag != yyok) + return yyflag; + yyglrShift (yystackp, yyk, + yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, + yylhsNonterm (yyrule)), + yyposn, &yyval]b4_locations_if([, &yyloc])[); + } + else + { + YYPTRDIFF_T yyi; + int yyn; + yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk]; + yy_state_t yynewLRState; + + for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule); + 0 < yyn; yyn -= 1) + { + yys = yys->yypred; + YY_ASSERT (yys); + } + yyupdateSplit (yystackp, yys); + yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); + YY_DPRINTF ((stderr, + "Reduced stack %ld by rule %d (line %d); action deferred. " + "Now in state %d.\n", + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule], + yynewLRState)); + for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) + if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULLPTR) + { + yyGLRState *yysplit = yystackp->yysplitPoint; + yyGLRState *yyp = yystackp->yytops.yystates[yyi]; + while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) + { + if (yyp->yylrState == yynewLRState && yyp->yypred == yys) + { + yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule); + yymarkStackDeleted (yystackp, yyk); + YY_DPRINTF ((stderr, "Merging stack %ld into stack %ld.\n", + YY_CAST (long, yyk), YY_CAST (long, yyi))); + return yyok; + } + yyp = yyp->yypred; + } + } + yystackp->yytops.yystates[yyk] = yys; + yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule); + } + return yyok; +} + +static YYPTRDIFF_T +yysplitStack (yyGLRStack* yystackp, YYPTRDIFF_T yyk) +{ + if (yystackp->yysplitPoint == YY_NULLPTR) + { + YY_ASSERT (yyk == 0); + yystackp->yysplitPoint = yystackp->yytops.yystates[yyk]; + } + if (yystackp->yytops.yycapacity <= yystackp->yytops.yysize) + { + YYPTRDIFF_T state_size = YYSIZEOF (yystackp->yytops.yystates[0]); + YYPTRDIFF_T half_max_capacity = YYSIZE_MAXIMUM / 2 / state_size; + if (half_max_capacity < yystackp->yytops.yycapacity) + yyMemoryExhausted (yystackp); + yystackp->yytops.yycapacity *= 2; + + { + yyGLRState** yynewStates + = YY_CAST (yyGLRState**, + YYREALLOC (yystackp->yytops.yystates, + (YY_CAST (YYSIZE_T, yystackp->yytops.yycapacity) + * sizeof yynewStates[0]))); + if (yynewStates == YY_NULLPTR) + yyMemoryExhausted (yystackp); + yystackp->yytops.yystates = yynewStates; + } + + { + yybool* yynewLookaheadNeeds + = YY_CAST (yybool*, + YYREALLOC (yystackp->yytops.yylookaheadNeeds, + (YY_CAST (YYSIZE_T, yystackp->yytops.yycapacity) + * sizeof yynewLookaheadNeeds[0]))); + if (yynewLookaheadNeeds == YY_NULLPTR) + yyMemoryExhausted (yystackp); + yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; + } + } + yystackp->yytops.yystates[yystackp->yytops.yysize] + = yystackp->yytops.yystates[yyk]; + yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize] + = yystackp->yytops.yylookaheadNeeds[yyk]; + yystackp->yytops.yysize += 1; + return yystackp->yytops.yysize - 1; +} + +/** True iff YYY0 and YYY1 represent identical options at the top level. + * That is, they represent the same rule applied to RHS symbols + * that produce the same terminal symbols. */ +static yybool +yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1) +{ + if (yyy0->yyrule == yyy1->yyrule) + { + yyGLRState *yys0, *yys1; + int yyn; + for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, + yyn = yyrhsLength (yyy0->yyrule); + yyn > 0; + yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) + if (yys0->yyposn != yys1->yyposn) + return yyfalse; + return yytrue; + } + else + return yyfalse; +} + +/** Assuming identicalOptions (YYY0,YYY1), destructively merge the + * alternative semantic values for the RHS-symbols of YYY1 and YYY0. */ +static void +yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) +{ + yyGLRState *yys0, *yys1; + int yyn; + for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, + yyn = yyrhsLength (yyy0->yyrule); + 0 < yyn; + yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) + { + if (yys0 == yys1) + break; + else if (yys0->yyresolved) + { + yys1->yyresolved = yytrue; + yys1->yysemantics.yyval = yys0->yysemantics.yyval; + } + else if (yys1->yyresolved) + { + yys0->yyresolved = yytrue; + yys0->yysemantics.yyval = yys1->yysemantics.yyval; + } + else + { + yySemanticOption** yyz0p = &yys0->yysemantics.yyfirstVal; + yySemanticOption* yyz1 = yys1->yysemantics.yyfirstVal; + while (yytrue) + { + if (yyz1 == *yyz0p || yyz1 == YY_NULLPTR) + break; + else if (*yyz0p == YY_NULLPTR) + { + *yyz0p = yyz1; + break; + } + else if (*yyz0p < yyz1) + { + yySemanticOption* yyz = *yyz0p; + *yyz0p = yyz1; + yyz1 = yyz1->yynext; + (*yyz0p)->yynext = yyz; + } + yyz0p = &(*yyz0p)->yynext; + } + yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal; + } + } +} + +/** Y0 and Y1 represent two possible actions to take in a given + * parsing state; return 0 if no combination is possible, + * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ +static int +yypreference (yySemanticOption* y0, yySemanticOption* y1) +{ + yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule; + int p0 = yydprec[r0], p1 = yydprec[r1]; + + if (p0 == p1) + { + if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) + return 0; + else + return 1; + } + if (p0 == 0 || p1 == 0) + return 0; + if (p0 < p1) + return 3; + if (p1 < p0) + return 2; + return 0; +} + +static YYRESULTTAG +yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[); + + +/** Resolve the previous YYN states starting at and including state YYS + * on *YYSTACKP. If result != yyok, some states may have been left + * unresolved possibly with empty semantic option chains. Regardless + * of whether result = yyok, each state has been left with consistent + * data so that yydestroyGLRState can be invoked if necessary. */ +static YYRESULTTAG +yyresolveStates (yyGLRState* yys, int yyn, + yyGLRStack* yystackp]b4_user_formals[) +{ + if (0 < yyn) + { + YY_ASSERT (yys->yypred); + YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[)); + if (! yys->yyresolved) + YYCHK (yyresolveValue (yys, yystackp]b4_user_args[)); + } + return yyok; +} + +/** Resolve the states for the RHS of YYOPT on *YYSTACKP, perform its + * user action, and return the semantic value and location in *YYVALP + * and *YYLOCP. Regardless of whether result = yyok, all RHS states + * have been destroyed (assuming the user action destroys all RHS + * semantic values if invoked). */ +static YYRESULTTAG +yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + int yynrhs = yyrhsLength (yyopt->yyrule); + YYRESULTTAG yyflag = + yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[); + if (yyflag != yyok) + { + yyGLRState *yys; + for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1) + yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); + return yyflag; + } + + yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[ + { + int yychar_current = yychar; + YYSTYPE yylval_current = yylval;]b4_locations_if([ + YYLTYPE yylloc_current = yylloc;])[ + yychar = yyopt->yyrawchar; + yylval = yyopt->yyval;]b4_locations_if([ + yylloc = yyopt->yyloc;])[ + yyflag = yyuserAction (yyopt->yyrule, yynrhs, + yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yystackp, -1, yyvalp]b4_locuser_args[); + yychar = yychar_current; + yylval = yylval_current;]b4_locations_if([ + yylloc = yylloc_current;])[ + } + return yyflag; +} + +#if ]b4_api_PREFIX[DEBUG +static void +yyreportTree (yySemanticOption* yyx, int yyindent) +{ + int yynrhs = yyrhsLength (yyx->yyrule); + int yyi; + yyGLRState* yys; + yyGLRState* yystates[1 + YYMAXRHS]; + yyGLRState yyleftmost_state; + + for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) + yystates[yyi] = yys; + if (yys == YY_NULLPTR) + { + yyleftmost_state.yyposn = 0; + yystates[0] = &yyleftmost_state; + } + else + yystates[0] = yys; + + if (yyx->yystate->yyposn < yys->yyposn + 1) + YY_FPRINTF ((stderr, "%*s%s -> \n", + yyindent, "", yysymbol_name (yylhsNonterm (yyx->yyrule)), + yyx->yyrule - 1)); + else + YY_FPRINTF ((stderr, "%*s%s -> \n", + yyindent, "", yysymbol_name (yylhsNonterm (yyx->yyrule)), + yyx->yyrule - 1, YY_CAST (long, yys->yyposn + 1), + YY_CAST (long, yyx->yystate->yyposn))); + for (yyi = 1; yyi <= yynrhs; yyi += 1) + { + if (yystates[yyi]->yyresolved) + { + if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) + YY_FPRINTF ((stderr, "%*s%s \n", yyindent+2, "", + yysymbol_name (yy_accessing_symbol (yystates[yyi]->yylrState)))); + else + YY_FPRINTF ((stderr, "%*s%s \n", yyindent+2, "", + yysymbol_name (yy_accessing_symbol (yystates[yyi]->yylrState)), + YY_CAST (long, yystates[yyi-1]->yyposn + 1), + YY_CAST (long, yystates[yyi]->yyposn))); + } + else + yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); + } +} +#endif + +static YYRESULTTAG +yyreportAmbiguity (yySemanticOption* yyx0, + yySemanticOption* yyx1]b4_pure_formals[) +{ + YY_USE (yyx0); + YY_USE (yyx1); + +#if ]b4_api_PREFIX[DEBUG + YY_FPRINTF ((stderr, "Ambiguity detected.\n")); + YY_FPRINTF ((stderr, "Option 1,\n")); + yyreportTree (yyx0, 2); + YY_FPRINTF ((stderr, "\nOption 2,\n")); + yyreportTree (yyx1, 2); + YY_FPRINTF ((stderr, "\n")); +#endif + + yyerror (]b4_yyerror_args[YY_("syntax is ambiguous")); + return yyabort; +}]b4_locations_if([[ + +/** Resolve the locations for each of the YYN1 states in *YYSTACKP, + * ending at YYS1. Has no effect on previously resolved states. + * The first semantic option of a state is always chosen. */ +static void +yyresolveLocations (yyGLRState *yys1, int yyn1, + yyGLRStack *yystackp]b4_user_formals[) +{ + if (0 < yyn1) + { + yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[); + if (!yys1->yyresolved) + { + yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; + int yynrhs; + yySemanticOption *yyoption = yys1->yysemantics.yyfirstVal; + YY_ASSERT (yyoption); + yynrhs = yyrhsLength (yyoption->yyrule); + if (0 < yynrhs) + { + yyGLRState *yys; + int yyn; + yyresolveLocations (yyoption->yystate, yynrhs, + yystackp]b4_user_args[); + for (yys = yyoption->yystate, yyn = yynrhs; + yyn > 0; + yys = yys->yypred, yyn -= 1) + yyrhsloc[yyn].yystate.yyloc = yys->yyloc; + } + else + { + /* Both yyresolveAction and yyresolveLocations traverse the GSS + in reverse rightmost order. It is only necessary to invoke + yyresolveLocations on a subforest for which yyresolveAction + would have been invoked next had an ambiguity not been + detected. Thus the location of the previous state (but not + necessarily the previous state itself) is guaranteed to be + resolved already. */ + yyGLRState *yyprevious = yyoption->yystate; + yyrhsloc[0].yystate.yyloc = yyprevious->yyloc; + } + YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs); + } + } +}]])[ + +/** Resolve the ambiguity represented in state YYS in *YYSTACKP, + * perform the indicated actions, and set the semantic value of YYS. + * If result != yyok, the chain of semantic options in YYS has been + * cleared instead or it has been left unmodified except that + * redundant options may have been removed. Regardless of whether + * result = yyok, YYS has been left with consistent data so that + * yydestroyGLRState can be invoked if necessary. */ +static YYRESULTTAG +yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[) +{ + yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal; + yySemanticOption* yybest = yyoptionList; + yySemanticOption** yypp; + yybool yymerge = yyfalse; + YYSTYPE yyval; + YYRESULTTAG yyflag;]b4_locations_if([ + YYLTYPE *yylocp = &yys->yyloc;])[ + + for (yypp = &yyoptionList->yynext; *yypp != YY_NULLPTR; ) + { + yySemanticOption* yyp = *yypp; + + if (yyidenticalOptions (yybest, yyp)) + { + yymergeOptionSets (yybest, yyp); + *yypp = yyp->yynext; + } + else + { + switch (yypreference (yybest, yyp)) + { + case 0:]b4_locations_if([[ + yyresolveLocations (yys, 1, yystackp]b4_user_args[);]])[ + return yyreportAmbiguity (yybest, yyp]b4_pure_args[); + break; + case 1: + yymerge = yytrue; + break; + case 2: + break; + case 3: + yybest = yyp; + yymerge = yyfalse; + break; + default: + /* This cannot happen so it is not worth a YY_ASSERT (yyfalse), + but some compilers complain if the default case is + omitted. */ + break; + } + yypp = &yyp->yynext; + } + } + + if (yymerge) + { + yySemanticOption* yyp; + int yyprec = yydprec[yybest->yyrule]; + yyflag = yyresolveAction (yybest, yystackp, &yyval]b4_locuser_args[); + if (yyflag == yyok) + for (yyp = yybest->yynext; yyp != YY_NULLPTR; yyp = yyp->yynext) + { + if (yyprec == yydprec[yyp->yyrule]) + { + YYSTYPE yyval_other;]b4_locations_if([ + YYLTYPE yydummy;])[ + yyflag = yyresolveAction (yyp, yystackp, &yyval_other]b4_locuser_args([&yydummy])[); + if (yyflag != yyok) + { + yydestruct ("Cleanup: discarding incompletely merged value for", + yy_accessing_symbol (yys->yylrState), + &yyval]b4_locuser_args[); + break; + } + yyuserMerge (yymerger[yyp->yyrule], &yyval, &yyval_other); + } + } + } + else + yyflag = yyresolveAction (yybest, yystackp, &yyval]b4_locuser_args([yylocp])[); + + if (yyflag == yyok) + { + yys->yyresolved = yytrue; + yys->yysemantics.yyval = yyval; + } + else + yys->yysemantics.yyfirstVal = YY_NULLPTR; + return yyflag; +} + +static YYRESULTTAG +yyresolveStack (yyGLRStack* yystackp]b4_user_formals[) +{ + if (yystackp->yysplitPoint != YY_NULLPTR) + { + yyGLRState* yys; + int yyn; + + for (yyn = 0, yys = yystackp->yytops.yystates[0]; + yys != yystackp->yysplitPoint; + yys = yys->yypred, yyn += 1) + continue; + YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp + ]b4_user_args[)); + } + return yyok; +} + +/** Called when returning to deterministic operation to clean up the extra + * stacks. */ +static void +yycompressStack (yyGLRStack* yystackp) +{ + /* yyr is the state after the split point. */ + yyGLRState *yyr; + + if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == YY_NULLPTR) + return; + + { + yyGLRState *yyp, *yyq; + for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = YY_NULLPTR; + yyp != yystackp->yysplitPoint; + yyr = yyp, yyp = yyq, yyq = yyp->yypred) + yyp->yypred = yyr; + } + + yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems; + yystackp->yynextFree = YY_REINTERPRET_CAST (yyGLRStackItem*, yystackp->yysplitPoint) + 1; + yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems; + yystackp->yysplitPoint = YY_NULLPTR; + yystackp->yylastDeleted = YY_NULLPTR; + + while (yyr != YY_NULLPTR) + { + yystackp->yynextFree->yystate = *yyr; + yyr = yyr->yypred; + yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate; + yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate; + yystackp->yynextFree += 1; + yystackp->yyspaceLeft -= 1; + } +} + +static YYRESULTTAG +yyprocessOneStack (yyGLRStack* yystackp, YYPTRDIFF_T yyk, + YYPTRDIFF_T yyposn]b4_pure_formals[) +{ + while (yystackp->yytops.yystates[yyk] != YY_NULLPTR) + { + yy_state_t yystate = yystackp->yytops.yystates[yyk]->yylrState; + YY_DPRINTF ((stderr, "Stack %ld Entering state %d\n", + YY_CAST (long, yyk), yystate)); + + YY_ASSERT (yystate != YYFINAL); + + if (yyisDefaultedState (yystate)) + { + YYRESULTTAG yyflag; + yyRuleNum yyrule = yydefaultAction (yystate); + if (yyrule == 0) + { + YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk))); + yymarkStackDeleted (yystackp, yyk); + return yyok; + } + yyflag = yyglrReduce (yystackp, yyk, yyrule, yyimmediate[yyrule]]b4_user_args[); + if (yyflag == yyerr) + { + YY_DPRINTF ((stderr, + "Stack %ld dies " + "(predicate failure or explicit user error).\n", + YY_CAST (long, yyk))); + yymarkStackDeleted (yystackp, yyk); + return yyok; + } + if (yyflag != yyok) + return yyflag; + } + else + { + yysymbol_kind_t yytoken = ]b4_yygetToken_call[; + const short* yyconflicts; + const int yyaction = yygetLRActions (yystate, yytoken, &yyconflicts); + yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; + + for (/* nothing */; *yyconflicts; yyconflicts += 1) + { + YYRESULTTAG yyflag; + YYPTRDIFF_T yynewStack = yysplitStack (yystackp, yyk); + YY_DPRINTF ((stderr, "Splitting off stack %ld from %ld.\n", + YY_CAST (long, yynewStack), YY_CAST (long, yyk))); + yyflag = yyglrReduce (yystackp, yynewStack, + *yyconflicts, + yyimmediate[*yyconflicts]]b4_user_args[); + if (yyflag == yyok) + YYCHK (yyprocessOneStack (yystackp, yynewStack, + yyposn]b4_pure_args[)); + else if (yyflag == yyerr) + { + YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yynewStack))); + yymarkStackDeleted (yystackp, yynewStack); + } + else + return yyflag; + } + + if (yyisShiftAction (yyaction)) + break; + else if (yyisErrorAction (yyaction)) + { + YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk))); + yymarkStackDeleted (yystackp, yyk); + break; + } + else + { + YYRESULTTAG yyflag = yyglrReduce (yystackp, yyk, -yyaction, + yyimmediate[-yyaction]]b4_user_args[); + if (yyflag == yyerr) + { + YY_DPRINTF ((stderr, + "Stack %ld dies " + "(predicate failure or explicit user error).\n", + YY_CAST (long, yyk))); + yymarkStackDeleted (yystackp, yyk); + break; + } + else if (yyflag != yyok) + return yyflag; + } + } + } + return yyok; +} + +]b4_parse_error_case([simple], [], +[[/* Put in YYARG at most YYARGN of the expected tokens given the + current YYSTACKP, and return the number of tokens stored in YYARG. If + YYARG is null, return the number of expected tokens (guaranteed to + be less than YYNTOKENS). */ +static int +yypcontext_expected_tokens (const yyGLRStack* yystackp, + yysymbol_kind_t yyarg[], int yyargn) +{ + /* Actual size of YYARG. */ + int yycount = 0; + int yyn = yypact[yystackp->yytops.yystates[0]->yylrState]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[ + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); + } + } + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = ]b4_symbol(empty, kind)[; + return yycount; +}]])[ + +]b4_parse_error_bmatch( + [custom], +[[/* User defined function to report a syntax error. */ +typedef yyGLRStack yypcontext_t; +static int +yyreport_syntax_error (const yyGLRStack* yystackp]b4_user_formals[); + +/* The kind of the lookahead of this context. */ +static yysymbol_kind_t +yypcontext_token (const yyGLRStack *yystackp) YY_ATTRIBUTE_UNUSED; + +static yysymbol_kind_t +yypcontext_token (const yyGLRStack *yystackp) +{ + YY_USE (yystackp); + yysymbol_kind_t yytoken = yychar == ]b4_symbol(empty, id)[ ? ]b4_symbol(empty, kind)[ : YYTRANSLATE (yychar); + return yytoken; +} + +]b4_locations_if([[/* The location of the lookahead of this context. */ +static const YYLTYPE * +yypcontext_location (const yyGLRStack *yystackp) YY_ATTRIBUTE_UNUSED; + +static const YYLTYPE * +yypcontext_location (const yyGLRStack *yystackp) +{ + YY_USE (yystackp); + return &yylloc; +}]])], + [detailed\|verbose], +[[static int +yy_syntax_error_arguments (const yyGLRStack* yystackp, + yysymbol_kind_t yyarg[], int yyargn) +{ + yysymbol_kind_t yytoken = yychar == ]b4_symbol(empty, id)[ ? ]b4_symbol(empty, kind)[ : YYTRANSLATE (yychar); + /* Actual size of YYARG. */ + int yycount = 0; + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != ]b4_symbol(empty, kind)[) + { + int yyn; + if (yyarg) + yyarg[yycount] = yytoken; + ++yycount; + yyn = yypcontext_expected_tokens (yystackp, + yyarg ? yyarg + 1 : yyarg, yyargn - 1); + if (yyn == YYENOMEM) + return YYENOMEM; + else + yycount += yyn; + } + return yycount; +} +]])[ + + +static void +yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) +{ + if (yystackp->yyerrState != 0) + return; +]b4_parse_error_case( + [custom], +[[ if (yyreport_syntax_error (yystackp]b4_user_args[)) + yyMemoryExhausted (yystackp);]], + [simple], +[[ yyerror (]b4_lyyerror_args[YY_("syntax error"));]], +[[ { + yybool yysize_overflow = yyfalse; + char* yymsg = YY_NULLPTR; + enum { YYARGS_MAX = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULLPTR; + /* Arguments of yyformat: reported tokens (one for the "unexpected", + one per "expected"). */ + yysymbol_kind_t yyarg[YYARGS_MAX]; + /* Cumulated lengths of YYARG. */ + YYPTRDIFF_T yysize = 0; + + /* Actual size of YYARG. */ + int yycount + = yy_syntax_error_arguments (yystackp, yyarg, YYARGS_MAX); + if (yycount == YYENOMEM) + yyMemoryExhausted (yystackp); + + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: /* Avoid compiler warnings. */ + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + /* Compute error message size. Don't count the "%s"s, but reserve + room for the terminator. */ + yysize = yystrlen (yyformat) - 2 * yycount + 1; + { + int yyi; + for (yyi = 0; yyi < yycount; ++yyi) + { + YYPTRDIFF_T yysz + = ]b4_parse_error_case( + [verbose], [[yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]])]], + [[yystrlen (yysymbol_name (yyarg[yyi]))]]);[ + if (YYSIZE_MAXIMUM - yysize < yysz) + yysize_overflow = yytrue; + else + yysize += yysz; + } + } + + if (!yysize_overflow) + yymsg = YY_CAST (char *, YYMALLOC (YY_CAST (YYSIZE_T, yysize))); + + if (yymsg) + { + char *yyp = yymsg; + int yyi = 0; + while ((*yyp = *yyformat)) + { + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + {]b4_parse_error_case([verbose], [[ + yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]);]], [[ + yyp = yystpcpy (yyp, yysymbol_name (yyarg[yyi++]));]])[ + yyformat += 2; + } + else + { + ++yyp; + ++yyformat; + } + } + yyerror (]b4_lyyerror_args[yymsg); + YYFREE (yymsg); + } + else + { + yyerror (]b4_lyyerror_args[YY_("syntax error")); + yyMemoryExhausted (yystackp); + } + }]])[ + yynerrs += 1; +} + +/* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP, + yylval, and yylloc are the syntactic category, semantic value, and location + of the lookahead. */ +static void +yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) +{ + if (yystackp->yyerrState == 3) + /* We just shifted the error token and (perhaps) took some + reductions. Skip tokens until we can proceed. */ + while (yytrue) + { + yysymbol_kind_t yytoken; + int yyj; + if (yychar == ]b4_symbol(eof, [id])[) + yyFail (yystackp][]b4_lpure_args[, YY_NULLPTR); + if (yychar != ]b4_symbol(empty, id)[) + {]b4_locations_if([[ + /* We throw away the lookahead, but the error range + of the shifted error token must take it into account. */ + yyGLRState *yys = yystackp->yytops.yystates[0]; + yyGLRStackItem yyerror_range[3]; + yyerror_range[1].yystate.yyloc = yys->yyloc; + yyerror_range[2].yystate.yyloc = yylloc; + YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Error: discarding", + yytoken, &yylval]b4_locuser_args([&yylloc])[); + yychar = ]b4_symbol(empty, id)[; + } + yytoken = ]b4_yygetToken_call[; + yyj = yypact[yystackp->yytops.yystates[0]->yylrState]; + if (yypact_value_is_default (yyj)) + return; + yyj += yytoken; + if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken) + { + if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) + return; + } + else if (! yytable_value_is_error (yytable[yyj])) + return; + } + + /* Reduce to one stack. */ + { + YYPTRDIFF_T yyk; + for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1) + if (yystackp->yytops.yystates[yyk] != YY_NULLPTR) + break; + if (yyk >= yystackp->yytops.yysize) + yyFail (yystackp][]b4_lpure_args[, YY_NULLPTR); + for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1) + yymarkStackDeleted (yystackp, yyk); + yyremoveDeletes (yystackp); + yycompressStack (yystackp); + } + + /* Pop stack until we find a state that shifts the error token. */ + yystackp->yyerrState = 3; + while (yystackp->yytops.yystates[0] != YY_NULLPTR) + { + yyGLRState *yys = yystackp->yytops.yystates[0]; + int yyj = yypact[yys->yylrState]; + if (! yypact_value_is_default (yyj)) + { + yyj += ]b4_symbol(error, kind)[; + if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == ]b4_symbol(error, kind)[ + && yyisShiftAction (yytable[yyj])) + { + /* Shift the error token. */ + int yyaction = yytable[yyj];]b4_locations_if([[ + /* First adjust its location.*/ + YYLTYPE yyerrloc; + yystackp->yyerror_range[2].yystate.yyloc = yylloc; + YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ + YY_SYMBOL_PRINT ("Shifting", yy_accessing_symbol (yyaction), + &yylval, &yyerrloc); + yyglrShift (yystackp, 0, yyaction, + yys->yyposn, &yylval]b4_locations_if([, &yyerrloc])[); + yys = yystackp->yytops.yystates[0]; + break; + } + }]b4_locations_if([[ + yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ + if (yys->yypred != YY_NULLPTR) + yydestroyGLRState ("Error: popping", yys]b4_user_args[); + yystackp->yytops.yystates[0] = yys->yypred; + yystackp->yynextFree -= 1; + yystackp->yyspaceLeft += 1; + } + if (yystackp->yytops.yystates[0] == YY_NULLPTR) + yyFail (yystackp][]b4_lpure_args[, YY_NULLPTR); +} + +#define YYCHK1(YYE) \ + do { \ + switch (YYE) { \ + case yyok: break; \ + case yyabort: goto yyabortlab; \ + case yyaccept: goto yyacceptlab; \ + case yyerr: goto yyuser_error; \ + case yynomem: goto yyexhaustedlab; \ + default: goto yybuglab; \ + } \ + } while (0) + +/*----------. +| yyparse. | +`----------*/ + +int +]b4_glr_cc_if([yy_parse_impl], [yyparse])[ (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[) +{ + int yyresult; + yyGLRStack yystack; + yyGLRStack* const yystackp = &yystack; + YYPTRDIFF_T yyposn; + + YY_DPRINTF ((stderr, "Starting parse\n")); + + yychar = ]b4_symbol(empty, id)[; + yylval = yyval_default;]b4_locations_if([ + yylloc = yyloc_default;])[ +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [], [yylloc])dnl + b4_user_initial_action +b4_dollar_popdef])[]dnl +[ + if (! yyinitGLRStack (yystackp, YYINITDEPTH)) + goto yyexhaustedlab; + switch (YYSETJMP (yystack.yyexception_buffer)) + { + case 0: break; + case 1: goto yyabortlab; + case 2: goto yyexhaustedlab; + default: goto yybuglab; + } + yyglrShift (&yystack, 0, 0, 0, &yylval]b4_locations_if([, &yylloc])[); + yyposn = 0; + + while (yytrue) + { + /* For efficiency, we have two loops, the first of which is + specialized to deterministic operation (single stack, no + potential ambiguity). */ + /* Standard mode. */ + while (yytrue) + { + yy_state_t yystate = yystack.yytops.yystates[0]->yylrState; + YY_DPRINTF ((stderr, "Entering state %d\n", yystate)); + if (yystate == YYFINAL) + goto yyacceptlab; + if (yyisDefaultedState (yystate)) + { + yyRuleNum yyrule = yydefaultAction (yystate); + if (yyrule == 0) + {]b4_locations_if([[ + yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[)); + } + else + { + yysymbol_kind_t yytoken = ]b4_yygetToken_call;[ + const short* yyconflicts; + int yyaction = yygetLRActions (yystate, yytoken, &yyconflicts); + if (*yyconflicts) + /* Enter nondeterministic mode. */ + break; + if (yyisShiftAction (yyaction)) + { + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + yychar = ]b4_symbol(empty, id)[; + yyposn += 1; + yyglrShift (&yystack, 0, yyaction, yyposn, &yylval]b4_locations_if([, &yylloc])[); + if (0 < yystack.yyerrState) + yystack.yyerrState -= 1; + } + else if (yyisErrorAction (yyaction)) + {]b4_locations_if([[ + yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + /* Issue an error message unless the scanner already + did. */ + if (yychar != ]b4_symbol(error, id)[) + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + else + YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[)); + } + } + + /* Nondeterministic mode. */ + while (yytrue) + { + yysymbol_kind_t yytoken_to_shift; + YYPTRDIFF_T yys; + + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + yystackp->yytops.yylookaheadNeeds[yys] = yychar != ]b4_symbol(empty, id)[; + + /* yyprocessOneStack returns one of three things: + + - An error flag. If the caller is yyprocessOneStack, it + immediately returns as well. When the caller is finally + yyparse, it jumps to an error label via YYCHK1. + + - yyok, but yyprocessOneStack has invoked yymarkStackDeleted + (&yystack, yys), which sets the top state of yys to NULL. Thus, + yyparse's following invocation of yyremoveDeletes will remove + the stack. + + - yyok, when ready to shift a token. + + Except in the first case, yyparse will invoke yyremoveDeletes and + then shift the next token onto all remaining stacks. This + synchronization of the shift (that is, after all preceding + reductions on all stacks) helps prevent double destructor calls + on yylval in the event of memory exhaustion. */ + + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[)); + yyremoveDeletes (&yystack); + if (yystack.yytops.yysize == 0) + { + yyundeleteLastStack (&yystack); + if (yystack.yytops.yysize == 0) + yyFail (&yystack][]b4_lpure_args[, YY_("syntax error")); + YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); + YY_DPRINTF ((stderr, "Returning to deterministic operation.\n"));]b4_locations_if([[ + yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + + /* If any yyglrShift call fails, it will fail after shifting. Thus, + a copy of yylval will already be on stack 0 in the event of a + failure in the following loop. Thus, yychar is set to ]b4_symbol(empty, id)[ + before the loop to make sure the user destructor for yylval isn't + called twice. */ + yytoken_to_shift = YYTRANSLATE (yychar); + yychar = ]b4_symbol(empty, id)[; + yyposn += 1; + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + { + yy_state_t yystate = yystack.yytops.yystates[yys]->yylrState; + const short* yyconflicts; + int yyaction = yygetLRActions (yystate, yytoken_to_shift, + &yyconflicts); + /* Note that yyconflicts were handled by yyprocessOneStack. */ + YY_DPRINTF ((stderr, "On stack %ld, ", YY_CAST (long, yys))); + YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); + yyglrShift (&yystack, yys, yyaction, yyposn, + &yylval]b4_locations_if([, &yylloc])[); + YY_DPRINTF ((stderr, "Stack %ld now in state %d\n", + YY_CAST (long, yys), + yystack.yytops.yystates[yys]->yylrState)); + } + + if (yystack.yytops.yysize == 1) + { + YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); + YY_DPRINTF ((stderr, "Returning to deterministic operation.\n")); + yycompressStack (&yystack); + break; + } + } + continue; + yyuser_error: + yyrecoverSyntaxError (&yystack]b4_user_args[); + yyposn = yystack.yytops.yystates[0]->yyposn; + } + + yyacceptlab: + yyresult = 0; + goto yyreturnlab; + + yybuglab: + YY_ASSERT (yyfalse); + goto yyabortlab; + + yyabortlab: + yyresult = 1; + goto yyreturnlab; + + yyexhaustedlab: + yyerror (]b4_lyyerror_args[YY_("memory exhausted")); + yyresult = 2; + goto yyreturnlab; + + yyreturnlab: + if (yychar != ]b4_symbol(empty, id)[) + yydestruct ("Cleanup: discarding lookahead", + YYTRANSLATE (yychar), &yylval]b4_locuser_args([&yylloc])[); + + /* If the stack is well-formed, pop the stack until it is empty, + destroying its entries as we go. But free the stack regardless + of whether it is well-formed. */ + if (yystack.yyitems) + { + yyGLRState** yystates = yystack.yytops.yystates; + if (yystates) + { + YYPTRDIFF_T yysize = yystack.yytops.yysize; + YYPTRDIFF_T yyk; + for (yyk = 0; yyk < yysize; yyk += 1) + if (yystates[yyk]) + { + while (yystates[yyk]) + { + yyGLRState *yys = yystates[yyk];]b4_locations_if([[ + yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ + if (yys->yypred != YY_NULLPTR) + yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); + yystates[yyk] = yys->yypred; + yystack.yynextFree -= 1; + yystack.yyspaceLeft += 1; + } + break; + } + } + yyfreeGLRStack (&yystack); + } + + return yyresult; +} + +/* DEBUGGING ONLY */ +#if ]b4_api_PREFIX[DEBUG +/* Print *YYS and its predecessors. */ +static void +yy_yypstack (yyGLRState* yys) +{ + if (yys->yypred) + { + yy_yypstack (yys->yypred); + YY_FPRINTF ((stderr, " -> ")); + } + YY_FPRINTF ((stderr, "%d@@%ld", yys->yylrState, YY_CAST (long, yys->yyposn))); +} + +/* Print YYS (possibly NULL) and its predecessors. */ +static void +yypstates (yyGLRState* yys) +{ + if (yys == YY_NULLPTR) + YY_FPRINTF ((stderr, "")); + else + yy_yypstack (yys); + YY_FPRINTF ((stderr, "\n")); +} + +/* Print the stack #YYK. */ +static void +yypstack (yyGLRStack* yystackp, YYPTRDIFF_T yyk) +{ + yypstates (yystackp->yytops.yystates[yyk]); +} + +/* Print all the stacks. */ +static void +yypdumpstack (yyGLRStack* yystackp) +{ +#define YYINDEX(YYX) \ + YY_CAST (long, \ + ((YYX) \ + ? YY_REINTERPRET_CAST (yyGLRStackItem*, (YYX)) - yystackp->yyitems \ + : -1)) + + yyGLRStackItem* yyp; + for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1) + { + YY_FPRINTF ((stderr, "%3ld. ", + YY_CAST (long, yyp - yystackp->yyitems))); + if (*YY_REINTERPRET_CAST (yybool *, yyp)) + { + YY_ASSERT (yyp->yystate.yyisState); + YY_ASSERT (yyp->yyoption.yyisState); + YY_FPRINTF ((stderr, "Res: %d, LR State: %d, posn: %ld, pred: %ld", + yyp->yystate.yyresolved, yyp->yystate.yylrState, + YY_CAST (long, yyp->yystate.yyposn), + YYINDEX (yyp->yystate.yypred))); + if (! yyp->yystate.yyresolved) + YY_FPRINTF ((stderr, ", firstVal: %ld", + YYINDEX (yyp->yystate.yysemantics.yyfirstVal))); + } + else + { + YY_ASSERT (!yyp->yystate.yyisState); + YY_ASSERT (!yyp->yyoption.yyisState); + YY_FPRINTF ((stderr, "Option. rule: %d, state: %ld, next: %ld", + yyp->yyoption.yyrule - 1, + YYINDEX (yyp->yyoption.yystate), + YYINDEX (yyp->yyoption.yynext))); + } + YY_FPRINTF ((stderr, "\n")); + } + + YY_FPRINTF ((stderr, "Tops:")); + { + YYPTRDIFF_T yyi; + for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) + YY_FPRINTF ((stderr, "%ld: %ld; ", YY_CAST (long, yyi), + YYINDEX (yystackp->yytops.yystates[yyi]))); + YY_FPRINTF ((stderr, "\n")); + } +#undef YYINDEX +} +#endif + +#undef yylval +#undef yychar +#undef yynerrs]b4_locations_if([ +#undef yylloc]) + +m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define yyparse ]b4_prefix[parse +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yydebug ]b4_prefix[debug +#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])])[ + +]b4_glr_cc_if([b4_glr_cc_pre_epilogue +b4_glr_cc_cleanup])[ +]b4_percent_code_get([[epilogue]])[]dnl +b4_epilogue[]dnl +b4_output_end diff --git a/Engine/bin/bison-flex/data/skeletons/glr.cc b/Engine/bin/bison-flex/data/skeletons/glr.cc new file mode 100644 index 000000000..7181402f3 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/glr.cc @@ -0,0 +1,397 @@ +# C++ GLR skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + + +# This skeleton produces a C++ class that encapsulates a C glr parser. +# This is in order to reduce the maintenance burden. The glr.c +# skeleton is clean and pure enough so that there are no real +# problems. The C++ interface is the same as that of lalr1.cc. In +# fact, glr.c can replace yacc.c without the user noticing any +# difference, and similarly for glr.cc replacing lalr1.cc. +# +# The passing of parse-params +# +# The additional arguments are stored as members of the parser +# object, yyparser. The C routines need to carry yyparser +# throughout the C parser; that's easy: make yyparser an +# additional parse-param. But because the C++ skeleton needs to +# know the "real" original parse-param, we save them +# (b4_parse_param_orig). Note that b4_parse_param is overquoted +# (and c.m4 strips one level of quotes). This is a PITA, and +# explains why there are so many levels of quotes. +# +# The locations +# +# We use location.cc just like lalr1.cc, but because glr.c stores +# the locations in a union, the position and location classes +# must not have a constructor. Therefore, contrary to lalr1.cc, we +# must not define "b4_location_constructors". As a consequence the +# user must initialize the first positions (in particular the +# filename member). + +# We require a pure interface. +m4_define([b4_pure_flag], [1]) + +m4_include(b4_skeletonsdir/[c++.m4]) +b4_bison_locations_if([m4_include(b4_skeletonsdir/[location.cc])]) + +m4_define([b4_parser_class], + [b4_percent_define_get([[api.parser.class]])]) + +# Save the parse parameters. +m4_define([b4_parse_param_orig], m4_defn([b4_parse_param])) + +# b4_parse_param_wrap +# ------------------- +# New ones. +m4_ifset([b4_parse_param], +[m4_define([b4_parse_param_wrap], + [[b4_namespace_ref::b4_parser_class[& yyparser], [[yyparser]]],] +m4_defn([b4_parse_param]))], +[m4_define([b4_parse_param_wrap], + [[b4_namespace_ref::b4_parser_class[& yyparser], [[yyparser]]]]) +]) + + +# b4_yy_symbol_print_define +# ------------------------- +# Bypass the default implementation to generate the "yy_symbol_print" +# and "yy_symbol_value_print" functions. +m4_define([b4_yy_symbol_print_define], +[[/*--------------------. +| Print this symbol. | +`--------------------*/ + +static void +yy_symbol_print (FILE *, ]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken, + const ]b4_namespace_ref::b4_parser_class[::value_type *yyvaluep]b4_locations_if([[, + const ]b4_namespace_ref::b4_parser_class[::location_type *yylocationp]])[]b4_user_formals[) +{ +]b4_parse_param_use[]dnl +[ yyparser.yy_symbol_print_ (yytoken, yyvaluep]b4_locations_if([, yylocationp])[); +} +]])[ + +# Hijack the initial action to initialize the locations. +]b4_bison_locations_if([m4_define([b4_initial_action], +[yylloc.initialize ();]m4_ifdef([b4_initial_action], [ +m4_defn([b4_initial_action])]))])[ + +# Hijack the post prologue to declare yyerror. +]m4_append([b4_post_prologue], +[b4_syncline([@oline@], [@ofile@])dnl +[static void +yyerror (]b4_locations_if([[const ]b4_namespace_ref::b4_parser_class[::location_type *yylocationp, + ]])[]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param), + ])[const char* msg);]])[ + +# Inserted before the epilogue to define implementations (yyerror, parser member +# functions etc.). +]m4_define([b4_glr_cc_pre_epilogue], +[b4_syncline([@oline@], [@ofile@])dnl +[ +/*------------------. +| Report an error. | +`------------------*/ + +static void +yyerror (]b4_locations_if([[const ]b4_namespace_ref::b4_parser_class[::location_type *yylocationp, + ]])[]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param), + ])[const char* msg) +{ +]b4_parse_param_use[]dnl +[ yyparser.error (]b4_locations_if([[*yylocationp, ]])[msg); +} + + +]b4_namespace_open[ +]dnl In this section, the parse params are the original parse_params. +m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl +[ /// Build a parser object. + ]b4_parser_class::b4_parser_class[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ + :])[ +#if ]b4_api_PREFIX[DEBUG + ]m4_ifset([b4_parse_param], [ ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ +#endif]b4_parse_param_cons[ + {} + + ]b4_parser_class::~b4_parser_class[ () + {} + + ]b4_parser_class[::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW + {} + + int + ]b4_parser_class[::operator() () + { + return parse (); + } + + int + ]b4_parser_class[::parse () + { + return ::yy_parse_impl (*this]b4_user_args[); + } + +#if ]b4_api_PREFIX[DEBUG + /*--------------------. + | Print this symbol. | + `--------------------*/ + + void + ]b4_parser_class[::yy_symbol_value_print_ (symbol_kind_type yykind, + const value_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) const + {]b4_locations_if([[ + YY_USE (yylocationp);]])[ + YY_USE (yyvaluep); + std::ostream& yyo = debug_stream (); + std::ostream& yyoutput = yyo; + YY_USE (yyoutput); + ]b4_symbol_actions([printer])[ + } + + + void + ]b4_parser_class[::yy_symbol_print_ (symbol_kind_type yykind, + const value_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) const + { + *yycdebug_ << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << yysymbol_name (yykind) << " ("]b4_locations_if([[ + << *yylocationp << ": "]])[; + yy_symbol_value_print_ (yykind, yyvaluep]b4_locations_if([[, yylocationp]])[); + *yycdebug_ << ')'; + } + + std::ostream& + ]b4_parser_class[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class[::debug_level_type + ]b4_parser_class[::debug_level () const + { + return yydebug; + } + + void + ]b4_parser_class[::set_debug_level (debug_level_type l) + { + // Actually, it is yydebug which is really used. + yydebug = l; + } + +#endif +]m4_popdef([b4_parse_param])dnl +b4_namespace_close[]dnl +]) + + +m4_define([b4_define_symbol_kind], +[m4_format([#define %-15s %s], + b4_symbol($][1, kind_base), + b4_namespace_ref[::]b4_parser_class[::symbol_kind::]b4_symbol($1, kind_base)) +]) + +# b4_glr_cc_setup +# --------------- +# Setup redirections for glr.c: Map the names used in c.m4 to the ones used +# in c++.m4. +m4_define([b4_glr_cc_setup], +[[]b4_attribute_define[ +]b4_null_define[ + +// This skeleton is based on C, yet compiles it as C++. +// So expect warnings about C style casts. +#if defined __clang__ && 306 <= __clang_major__ * 100 + __clang_minor__ +# pragma clang diagnostic ignored "-Wold-style-cast" +#elif defined __GNUC__ && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# pragma GCC diagnostic ignored "-Wold-style-cast" +#endif + +// On MacOS, PTRDIFF_MAX is defined as long long, which Clang's +// -pedantic reports as being a C++11 extension. +#if defined __APPLE__ && YY_CPLUSPLUS < 201103L \ + && defined __clang__ && 4 <= __clang_major__ +# pragma clang diagnostic ignored "-Wc++11-long-long" +#endif + +#undef ]b4_symbol(empty, [id])[ +#define ]b4_symbol(empty, [id])[ ]b4_namespace_ref[::]b4_parser_class[::token::]b4_symbol(empty, [id])[ +#undef ]b4_symbol(eof, [id])[ +#define ]b4_symbol(eof, [id])[ ]b4_namespace_ref[::]b4_parser_class[::token::]b4_symbol(eof, [id])[ +#undef ]b4_symbol(error, [id])[ +#define ]b4_symbol(error, [id])[ ]b4_namespace_ref[::]b4_parser_class[::token::]b4_symbol(error, [id])[ + +#ifndef ]b4_api_PREFIX[STYPE +# define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class[::value_type +#endif +#ifndef ]b4_api_PREFIX[LTYPE +# define ]b4_api_PREFIX[LTYPE ]b4_namespace_ref[::]b4_parser_class[::location_type +#endif + +typedef ]b4_namespace_ref[::]b4_parser_class[::symbol_kind_type yysymbol_kind_t; + +// Expose C++ symbol kinds to C. +]b4_define_symbol_kind(-2)dnl +b4_symbol_foreach([b4_define_symbol_kind])])[ +]]) + + +m4_define([b4_undef_symbol_kind], +[[#undef ]b4_symbol($1, kind_base)[ +]]) + + +# b4_glr_cc_cleanup +# ----------------- +# Remove redirections for glr.c. +m4_define([b4_glr_cc_cleanup], +[[#undef ]b4_symbol(empty, [id])[ +#undef ]b4_symbol(eof, [id])[ +#undef ]b4_symbol(error, [id])[ + +]b4_undef_symbol_kind(-2)dnl +b4_symbol_foreach([b4_undef_symbol_kind])dnl +]) + + +# b4_shared_declarations(hh|cc) +# ----------------------------- +# Declaration that might either go into the header (if --header, $1 = hh) +# or in the implementation file. +m4_define([b4_shared_declarations], +[m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl +b4_percent_code_get([[requires]])[ +#include +#include +#include + +]b4_cxx_portability[ +]m4_ifdef([b4_location_include], + [[# include ]b4_location_include])[ +]b4_variant_if([b4_variant_includes])[ + +// Whether we are compiled with exception support. +#ifndef YY_EXCEPTIONS +# if defined __GNUC__ && !defined __EXCEPTIONS +# define YY_EXCEPTIONS 0 +# else +# define YY_EXCEPTIONS 1 +# endif +#endif + +]b4_YYDEBUG_define[ + +]b4_namespace_open[ + +]b4_bison_locations_if([m4_ifndef([b4_location_file], + [b4_location_define])])[ + + /// A Bison parser. + class ]b4_parser_class[ + { + public: +]b4_public_types_declare[ + + /// Build a parser object. + ]b4_parser_class[ (]b4_parse_param_decl[); + virtual ~]b4_parser_class[ (); + + /// Parse. An alias for parse (). + /// \returns 0 iff parsing succeeded. + int operator() (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + +#if ]b4_api_PREFIX[DEBUG + /// The current debugging stream. + std::ostream& debug_stream () const; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + typedef int debug_level_type; + /// The current debugging level. + debug_level_type debug_level () const; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); +#endif + + /// Report a syntax error.]b4_locations_if([[ + /// \param loc where the syntax error is found.]])[ + /// \param msg a description of the syntax error. + virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); + +# if ]b4_api_PREFIX[DEBUG + public: + /// \brief Report a symbol value on the debug stream. + /// \param yykind The symbol kind. + /// \param yyvaluep Its semantic value.]b4_locations_if([[ + /// \param yylocationp Its location.]])[ + virtual void yy_symbol_value_print_ (symbol_kind_type yykind, + const value_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) const; + /// \brief Report a symbol on the debug stream. + /// \param yykind The symbol kind. + /// \param yyvaluep Its semantic value.]b4_locations_if([[ + /// \param yylocationp Its location.]])[ + virtual void yy_symbol_print_ (symbol_kind_type yykind, + const value_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) const; + private: + /// Debug stream. + std::ostream* yycdebug_; +#endif + +]b4_parse_param_vars[ + }; + +]b4_namespace_close[ + +]b4_percent_code_get([[provides]])[ +]m4_popdef([b4_parse_param])dnl +])[ + +]b4_header_if( +[b4_output_begin([b4_spec_header_file]) +b4_copyright([Skeleton interface for Bison GLR parsers in C++], + [2002-2015, 2018-2021])[ +// C++ GLR parser skeleton written by Akim Demaille. + +]b4_disclaimer[ +]b4_cpp_guard_open([b4_spec_mapped_header_file])[ +]b4_shared_declarations[ +]b4_cpp_guard_close([b4_spec_mapped_header_file])[ +]b4_output_end]) + +# Let glr.c (and b4_shared_declarations) believe that the user +# arguments include the parser itself. +m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_wrap])) +m4_include(b4_skeletonsdir/[glr.c]) +m4_popdef([b4_parse_param]) diff --git a/Engine/bin/bison-flex/data/skeletons/glr2.cc b/Engine/bin/bison-flex/data/skeletons/glr2.cc new file mode 100644 index 000000000..757d68d49 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/glr2.cc @@ -0,0 +1,3533 @@ +# C++ GLR skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +m4_include(b4_skeletonsdir/[c++.m4]) + +# api.value.type=variant is valid. +m4_define([b4_value_type_setup_variant]) + +# b4_tname_if(TNAME-NEEDED, TNAME-NOT-NEEDED) +# ------------------------------------------- +m4_define([b4_tname_if], +[m4_case(b4_percent_define_get([[parse.error]]), + [verbose], [$1], + [b4_token_table_if([$1], + [$2])])]) + +b4_bison_locations_if([ + m4_define([b4_location_constructors]) + m4_include(b4_skeletonsdir/[location.cc])]) +b4_variant_if([m4_include(b4_skeletonsdir/[variant.hh])]) + +m4_define([b4_parser_class], + [b4_percent_define_get([[api.parser.class]])]) + +]m4_define([b4_define_symbol_kind], +[m4_format([#define %-15s %s], + b4_symbol($][1, kind_base), + b4_namespace_ref[::]b4_parser_class[::symbol_kind::]b4_symbol($1, kind_base)) +]) + + +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) +# ------------------------------------------------------------- +# Define "yy" whose contents is CONTENT. Does not use "static", +# should be in unnamed namespace. +m4_define([b4_integral_parser_table_define], +[m4_ifvaln([$3], [ b4_comment([$3])])dnl + const b4_int_type_for([$2]) yy$1[[]] = + { + $2 + };dnl +]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + + + +## ------------ ## +## Interfaces. ## +## ------------ ## + +# b4_user_formals +# --------------- +# The possible parse-params formal arguments preceded by a comma. +# +# This is not shared with yacc.c in c.m4 because GLR relies on ISO C +# formal argument declarations. +m4_define([b4_user_formals], +[m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])]) + + +# b4_symbol_kind(NUM) +# ------------------- +m4_define([b4_symbol_kind], +[symbol_kind::b4_symbol_kind_base($@)]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value(SYMBOL-NUM, [TYPE]) +# -------------------------------- +# See README. +m4_define([b4_lhs_value], +[b4_symbol_value([(*yyvalp)], [$1], [$2])]) + + +# b4_rhs_data(RULE-LENGTH, POS) +# ----------------------------- +# See README. +m4_define([b4_rhs_data], +[(static_cast(yyvsp))@{YYFILL (b4_subtract([$2], [$1]))@}.getState()]) + + +# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) +# -------------------------------------------------- +# Expansion of $$ or $$, for symbol SYMBOL-NUM. +m4_define([b4_rhs_value], +[b4_symbol_value([b4_rhs_data([$1], [$2]).value ()], [$3], [$4])]) + + + +## ----------- ## +## Locations. ## +## ----------- ## + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(*yylocp)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(b4_rhs_data([$1], [$2]).yyloc)]) + + +# b4_symbol_action(SYMBOL-NUM, KIND) +# ---------------------------------- +# Run the action KIND (destructor or printer) for SYMBOL-NUM. +# Same as in C, but using references instead of pointers. +# +# Currently we need two different b4_symbol_action: once for the +# self-contained symbols, and another time for yy_destroy_ and +# yy_symbol_value_print_, which don't use genuine symbols yet. +m4_define([b4_symbol_action], +[b4_symbol_if([$1], [has_$2], +[m4_pushdef([b4_symbol_value], m4_defn([b4_symbol_value_template]))[]dnl +b4_dollar_pushdef([yysym.value], + [$1], + [], + [yysym.location])dnl + _b4_symbol_case([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], [b4_symbol([$1], [$2_file])])dnl + b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@])dnl + break; + +m4_popdef([b4_symbol_value])[]dnl +b4_dollar_popdef[]dnl +])]) + + +# b4_symbol_action_for_yyval(SYMBOL-NUM, KIND) +# -------------------------------------------- +# Run the action KIND (destructor or printer) for SYMBOL-NUM. +# Same as in C, but using references instead of pointers. +m4_define([b4_symbol_action_for_yyval], +[b4_symbol_if([$1], [has_$2], +[b4_dollar_pushdef([yyval], + [$1], + [], + [yyloc])dnl + _b4_symbol_case([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], [b4_symbol([$1], [$2_file])])dnl + b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@])dnl + break; + +b4_dollar_popdef[]dnl +])]) + + +# b4_call_merger(MERGER-NUM, MERGER-NAME, SYMBOL-SUM) +# --------------------------------------------------- +m4_define([b4_call_merger], +[b4_case([$1], + [ b4_symbol_if([$3], [has_type], + [b4_variant_if([yy0.as< b4_symbol($3, type) > () = $2 (yy0.as< b4_symbol($3, type) >(), yy1.as< b4_symbol($3, type) >());], + [yy0.b4_symbol($3, slot) = $2 (yy0, yy1);])], + [yy0 = $2 (yy0, yy1);])])]) + +# b4_yylex +# -------- +# Call yylex. +m4_define([b4_yylex], +[b4_token_ctor_if( +[b4_function_call([yylex], + [symbol_type], m4_ifdef([b4_lex_param], b4_lex_param))], +[b4_function_call([yylex], [int], + [[value_type *], [&this->yyla.value]][]dnl +b4_locations_if([, [[location_type *], [&this->yyla.location]]])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param))])]) + + +# b4_shared_declarations(hh|cc) +# ----------------------------- +# Declaration that might either go into the header (if --header, $1 = hh) +# or in the implementation file. +m4_define([b4_shared_declarations], +[b4_percent_code_get([[requires]])[ +#include +#include // ptrdiff_t +#include // memcpy +#include +#include +#include +#include +#include +#include +#include + +]b4_cxx_portability[ +]m4_ifdef([b4_location_include], + [[# include ]b4_location_include])[ +]b4_variant_if([b4_variant_includes])[ + +]b4_YYDEBUG_define[ + +]b4_namespace_open[ + +]b4_bison_locations_if([m4_ifndef([b4_location_file], + [b4_location_define])])[ + + /// A Bison parser. + class ]b4_parser_class[ + { + public: +]b4_public_types_declare[ +]b4_symbol_type_define[ + + // FIXME: should be private eventually. + class glr_stack; + class glr_state; + + /// Build a parser object. + ]b4_parser_class[ (]b4_parse_param_decl[); + ~]b4_parser_class[ (); + + /// Parse. An alias for parse (). + /// \returns 0 iff parsing succeeded. + int operator() (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + int parse (); + +#if ]b4_api_PREFIX[DEBUG + /// The current debugging stream. + std::ostream& debug_stream () const; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + using debug_level_type = int; + /// The current debugging level. + debug_level_type debug_level () const; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); +#endif + + /// Report a syntax error.]b4_locations_if([[ + /// \param loc where the syntax error is found.]])[ + /// \param msg a description of the syntax error. + void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); + +]b4_parse_error_bmatch( +[custom\|detailed], +[[ /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static const char *symbol_name (symbol_kind_type yysymbol);]], +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static const char *symbol_name (symbol_kind_type yysymbol); +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static std::string symbol_name (symbol_kind_type yysymbol);]])[ + +]b4_token_constructor_define[ +]b4_parse_error_bmatch([custom\|detailed\|verbose], [[ + class context + { + public: + context (glr_stack& yystack, const symbol_type& yyla); + const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; } + symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); }]b4_locations_if([[ + const location_type& location () const YY_NOEXCEPT { return yyla_.location; } +]])[ + /// Put in YYARG at most YYARGN of the expected tokens, and return the + /// number of tokens stored in YYARG. If YYARG is null, return the + /// number of expected tokens (guaranteed to be less than YYNTOKENS). + int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; + + private: + glr_stack& yystack_; + const symbol_type& yyla_; + }; +]])[ +# if ]b4_api_PREFIX[DEBUG + public: + /// \brief Report a symbol value on the debug stream. + /// \param yykind The symbol kind. + /// \param yyval Its semantic value.]b4_locations_if([[ + /// \param yyloc Its location.]])[ + void yy_symbol_value_print_ (symbol_kind_type yykind, + const value_type& yyval]b4_locations_if([[, + const location_type& yyloc]])[) const; + /// \brief Report a symbol on the debug stream. + /// \param yykind The symbol kind. + /// \param yyval Its semantic value.]b4_locations_if([[ + /// \param yyloc Its location.]])[ + void yy_symbol_print_ (symbol_kind_type yykind, + const value_type& yyval]b4_locations_if([[, + const location_type& yyloc]])[) const; + private: + /// Debug stream. + std::ostream* yycdebug_; +#endif + +]b4_parse_error_bmatch( +[custom], [[ + private: + /// Report a syntax error + /// \param yyctx the context in which the error occurred. + void report_syntax_error (const context& yyctx) const;]], +[detailed\|verbose], [[ + private: + /// The arguments of the error message. + int yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const; + + /// Generate an error message. + /// \param yyctx the context in which the error occurred. + virtual std::string yysyntax_error_ (const context& yyctx) const;]])[ + + /// Convert a scanner token kind \a t to a symbol kind. + /// In theory \a t should be a token_kind_type, but character literals + /// are valid, yet not members of the token_kind_type enum. + static symbol_kind_type yytranslate_ (int t) YY_NOEXCEPT; + +]b4_parse_error_bmatch( +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + /// For a symbol, its name in clear. + static const char* const yytname_[]; +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /// Convert the symbol name \a n to a form suitable for a diagnostic. + static std::string yytnamerr_ (const char *yystr); + + /// For a symbol, its name in clear. + static const char* const yytname_[]; +]])[ + + /// \brief Reclaim the memory associated to a symbol. + /// \param yymsg Why this token is reclaimed. + /// If null, print nothing. + /// \param yykind The symbol kind. + void yy_destroy_ (const char* yymsg, symbol_kind_type yykind, + value_type& yyval]b4_locations_if([[, + location_type& yyloc]])[); + +]b4_parse_param_vars[ + // Needs access to yy_destroy_, report_syntax_error, etc. + friend glr_stack; + }; + +]b4_token_ctor_if([b4_yytranslate_define([$1])[ +]b4_public_types_define([$1])])[ +]b4_namespace_close[ + +]b4_percent_code_get([[provides]])[ +]])[ + + +## -------------- ## +## Output files. ## +## -------------- ## + + +# ------------- # +# Header file. # +# ------------- # + +]b4_header_if([[ +]b4_output_begin([b4_spec_header_file])[ +]b4_copyright([Skeleton interface for Bison GLR parsers in C++], + [2002-2015, 2018-2021])[ +// C++ GLR parser skeleton written by Valentin Tolmer. + +]b4_disclaimer[ +]b4_cpp_guard_open([b4_spec_mapped_header_file])[ +]b4_shared_declarations([hh])[ +]b4_cpp_guard_close([b4_spec_mapped_header_file])[ +]b4_output_end])[ + + +# --------------------- # +# Implementation file. # +# --------------------- # + +]b4_output_begin([b4_parser_file_name])[ +]b4_copyright([Skeleton implementation for Bison GLR parsers in C], + [2002-2015, 2018-2021])[ +// C++ GLR parser skeleton written by Valentin Tolmer. + +]b4_disclaimer[ +]b4_identification[ + +]b4_percent_code_get([[top]])[ +]m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define yyparse ]b4_prefix[parse +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug]])[ + +]b4_user_pre_prologue[ + +]b4_null_define[ + +]b4_header_if([[#include "@basename(]b4_spec_header_file[@)"]], + [b4_shared_declarations([cc])])[ + +namespace +{ + /* Default (constant) value used for initialization for null + right-hand sides. Unlike the standard yacc.c template, here we set + the default value of $$ to a zeroed-out value. Since the default + value is undefined, this behavior is technically correct. */ + ]b4_namespace_ref[::]b4_parser_class[::value_type yyval_default; +} + +]b4_user_post_prologue[ +]b4_percent_code_get[ + +#include +#include + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + +// Whether we are compiled with exception support. +#ifndef YY_EXCEPTIONS +# if defined __GNUC__ && !defined __EXCEPTIONS +# define YY_EXCEPTIONS 0 +# else +# define YY_EXCEPTIONS 1 +# endif +#endif + +#ifndef YYFREE +# define YYFREE free +#endif +#ifndef YYMALLOC +# define YYMALLOC malloc +#endif + +#ifndef YYSETJMP +# include +# define YYJMP_BUF jmp_buf +# define YYSETJMP(Env) setjmp (Env) +/* Pacify Clang and ICC. */ +# define YYLONGJMP(Env, Val) \ + do { \ + longjmp (Env, Val); \ + YYASSERT (0); \ + } while (false) +#endif + +]b4_attribute_define([noreturn])[ + +#if defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_NULL_DEREFERENCE_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wnull-dereference\"") +# define YY_IGNORE_NULL_DEREFERENCE_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_IGNORE_NULL_DEREFERENCE_BEGIN +# define YY_IGNORE_NULL_DEREFERENCE_END +#endif + +]b4_null_define[ +]b4_cast_define[ + +// FIXME: Use the same conventions as lalr1.cc. +]b4_parse_assert_if[ +#ifndef YYASSERT +# define YYASSERT(Condition) ((void) ((Condition) || (abort (), 0))) +#endif + +#ifdef YYDEBUG +# define YYDASSERT(Condition) YYASSERT(Condition) +#else +# define YYDASSERT(Condition) +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL ]b4_final_state_number[ +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST ]b4_last[ + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS ]b4_tokens_number[ +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS ]b4_nterms_number[ +/* YYNRULES -- Number of rules. */ +#define YYNRULES ]b4_rules_number[ +/* YYNSTATES -- Number of states. */ +#define YYNSTATES ]b4_states_number[ +/* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */ +#define YYMAXRHS ]b4_r2_max[ +/* YYMAXLEFT -- Maximum number of symbols to the left of a handle + accessed by $0, $-1, etc., in any rule. */ +#define YYMAXLEFT ]b4_max_left_semantic_context[ + +namespace +{ +#if ]b4_api_PREFIX[DEBUG + /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ + const ]b4_int_type_for([b4_rline])[ yyrline[] = + { + ]b4_rline[ + }; +#endif + +#define YYPACT_NINF ]b4_pact_ninf[ +#define YYTABLE_NINF ]b4_table_ninf[ + +]b4_parser_tables_define[ + + /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ + const ]b4_int_type_for([b4_dprec])[ yydprec[] = + { + ]b4_dprec[ + }; + + /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ + const ]b4_int_type_for([b4_merger])[ yymerger[] = + { + ]b4_merger[ + }; + + /* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as + in the case of predicates. */ + const bool yyimmediate[] = + { + ]b4_immediate[ + }; + + /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of + list of conflicting reductions corresponding to action entry for + state STATE-NUM in yytable. 0 means no conflicts. The list in + yyconfl is terminated by a rule number of 0. */ + const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = + { + ]b4_conflict_list_heads[ + }; + + /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by + 0, pointed into by YYCONFLP. */ + ]dnl Do not use b4_int_type_for here, since there are places where + dnl pointers onto yyconfl are taken, whose type is "short*". + dnl We probably ought to introduce a type for confl. + [const short yyconfl[] = + { + ]b4_conflicting_rules[ + }; +} // namespace + + +/* Error token number */ +#define YYTERROR 1 + +]b4_locations_if([[ +]b4_yylloc_default_define[ +# define YYRHSLOC(Rhs, K) ((Rhs)[K].getState().yyloc) +]])[ + +enum YYRESULTTAG { yyok, yyaccept, yyabort, yyerr }; + +#define YYCHK(YYE) \ + do { \ + YYRESULTTAG yychk_flag = YYE; \ + if (yychk_flag != yyok) \ + return yychk_flag; \ + } while (false) + +#if ]b4_api_PREFIX[DEBUG + +#define YYCDEBUG if (!yydebug) {} else std::cerr + +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ + do { \ + if (yydebug) \ + { \ + std::cerr << Title << ' '; \ + yyparser.yy_symbol_print_ (Kind, Value]b4_locations_if([, Location])[); \ + std::cerr << '\n'; \ + } \ + } while (false) + +# define YY_REDUCE_PRINT(Args) \ + do { \ + if (yydebug) \ + yystateStack.yy_reduce_print Args; \ + } while (false) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; + +namespace +{ + using glr_stack = ]b4_namespace_ref[::]b4_parser_class[::glr_stack; + using glr_state = ]b4_namespace_ref[::]b4_parser_class[::glr_state; + + void yypstack (const glr_stack& yystack, size_t yyk) + YY_ATTRIBUTE_UNUSED; + void yypdumpstack (const glr_stack& yystack) + YY_ATTRIBUTE_UNUSED; +} + +#else /* !]b4_api_PREFIX[DEBUG */ + +# define YYCDEBUG if (true) {} else std::cerr +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) {} +# define YY_REDUCE_PRINT(Args) {} + +#endif /* !]b4_api_PREFIX[DEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH ]b4_stack_depth_init[ +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH ]b4_stack_depth_max[ +#endif + +/* Minimum number of free items on the stack allowed after an + allocation. This is to allow allocation and initialization + to be completed by functions that call yyexpandGLRStack before the + stack is expanded, thus insuring that all necessary pointers get + properly redirected to new data. */ +#define YYHEADROOM 2 + +#ifndef YYSTACKEXPANDABLE +# define YYSTACKEXPANDABLE 1 +#endif + +namespace +{ + template + class strong_index_alias + { + public: + static strong_index_alias create (std::ptrdiff_t value) + { + strong_index_alias result; + result.value_ = value; + return result; + } + + std::ptrdiff_t const& get () const { return value_; } + + size_t uget () const { return static_cast (value_); } + + strong_index_alias operator+ (std::ptrdiff_t other) const + { + return strong_index_alias (get () + other); + } + + void operator+= (std::ptrdiff_t other) + { + value_ += other; + } + + strong_index_alias operator- (std::ptrdiff_t other) + { + return strong_index_alias (get () - other); + } + + void operator-= (std::ptrdiff_t other) + { + value_ -= other; + } + + size_t operator- (strong_index_alias other) + { + return strong_index_alias (get () - other.get ()); + } + + strong_index_alias& operator++ () + { + ++value_; + return *this; + } + + bool isValid () const + { + return value_ != INVALID_INDEX; + } + + void setInvalid() + { + value_ = INVALID_INDEX; + } + + bool operator== (strong_index_alias other) + { + return get () == other.get (); + } + + bool operator!= (strong_index_alias other) + { + return get () != other.get (); + } + + bool operator< (strong_index_alias other) + { + return get () < other.get (); + } + + private: + static const std::ptrdiff_t INVALID_INDEX; + + // WARNING: 0-initialized. + std::ptrdiff_t value_; + }; // class strong_index_alias + + template + const std::ptrdiff_t strong_index_alias::INVALID_INDEX = + std::numeric_limits::max (); + + using state_set_index = strong_index_alias; + + state_set_index create_state_set_index (std::ptrdiff_t value) + { + return state_set_index::create (value); + } + + /** State numbers, as in LALR(1) machine */ + using state_num = int; + + /** Rule numbers, as in LALR(1) machine */ + using rule_num = int; + + using parser_type = ]b4_namespace_ref[::]b4_parser_class[; + using glr_state = parser_type::glr_state; + using symbol_kind = parser_type::symbol_kind; + using symbol_kind_type = parser_type::symbol_kind_type; + using symbol_type = parser_type::symbol_type; + using value_type = parser_type::value_type;]b4_locations_if([[ + using location_type = parser_type::location_type;]])[ + + // Forward declarations. + class glr_stack_item; + class semantic_option; +} // namespace + +namespace +{ + /** Accessing symbol of state YYSTATE. */ + inline symbol_kind_type + yy_accessing_symbol (state_num yystate) + { + return YY_CAST (symbol_kind_type, yystos[yystate]); + } + + /** Left-hand-side symbol for rule #YYRULE. */ + inline symbol_kind_type + yylhsNonterm (rule_num yyrule) + { + return static_cast(yyr1[yyrule]); + } + + /** Number of symbols composing the right hand side of rule #RULE. */ + inline int + yyrhsLength (rule_num yyrule) + { + return yyr2[yyrule]; + } +} + +namespace ]b4_namespace_ref[ +{ + class ]b4_parser_class[::glr_state + { + public: + glr_state () + : yyresolved (false) + , yylrState (0) + , yyposn (0) + , yypred (0) + , yyfirstVal (0)]b4_locations_if([[ + , yyloc ()]])[]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {} + + /// Build with a semantic value. + glr_state (state_num lrState, size_t posn, const value_type& val]b4_locations_if([[, const location_type& loc]])[) + : yyresolved (true) + , yylrState (lrState) + , yyposn (posn) + , yypred (0) + , yyval (]b4_variant_if([], [[val]])[)]b4_locations_if([[ + , yyloc (loc)]])[]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {]b4_variant_if([[ + ]b4_symbol_variant([yy_accessing_symbol (lrState)], + [yyval], [copy], [val])])[} + + /// Build with a semantic option. + glr_state (state_num lrState, size_t posn) + : yyresolved (false) + , yylrState (lrState) + , yyposn (posn) + , yypred (0) + , yyfirstVal (0)]b4_locations_if([[ + , yyloc ()]])[]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {} + + glr_state (const glr_state& other) + : yyresolved (other.yyresolved) + , yylrState (other.yylrState) + , yyposn (other.yyposn) + , yypred (0)]b4_locations_if([[ + , yyloc (other.yyloc)]])[]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + { + setPred (other.pred ()); + if (other.yyresolved)]b4_variant_if([[ + { + new (&yyval) value_type (); + ]b4_symbol_variant([yy_accessing_symbol (other.yylrState)], + [yyval], [copy], [other.value ()])[ + }]], [[ + new (&yyval) value_type (other.value ());]])[ + else + { + yyfirstVal = 0; + setFirstVal (other.firstVal ()); + }]b4_parse_assert_if([[ + check_();]])[ + } + + ~glr_state () + {]b4_parse_assert_if([[ + check_ ();]])[ + if (yyresolved) + {]b4_variant_if([[ + symbol_kind_type yykind = yy_accessing_symbol (yylrState); + // FIXME: User destructors. + // Value type destructor. + ]b4_symbol_variant([[yykind]], [[yyval]], [[template destroy]])])[ + yyval.~value_type (); + }]b4_parse_assert_if([[ + magic_ = 0;]])[ + } + + glr_state& operator= (const glr_state& other) + {]b4_parse_assert_if([[ + check_ (); + other.check_ ();]])[ + if (!yyresolved && other.yyresolved) + new (&yyval) value_type; + yyresolved = other.yyresolved; + yylrState = other.yylrState; + yyposn = other.yyposn; + setPred (other.pred ()); + if (other.yyresolved)]b4_variant_if([[ + ]b4_symbol_variant([yy_accessing_symbol (other.yylrState)], + [yyval], [copy], [other.value ()])], [[ + value () = other.value ();]])[ + else + setFirstVal (other.firstVal ());]b4_locations_if([[ + yyloc = other.yyloc;]])[ + return *this; + } + + /** Type tag for the semantic value. If true, yyval applies, otherwise + * yyfirstVal applies. */ + bool yyresolved; + /** Number of corresponding LALR(1) machine state. */ + state_num yylrState; + /** Source position of the last token produced by my symbol */ + size_t yyposn; + + /// Only call pred() and setPred() on objects in yyitems, not temporaries. + glr_state* pred (); + const glr_state* pred () const; + void setPred (const glr_state* state); + + /// Only call firstVal() and setFirstVal() on objects in yyitems, not + /// temporaries. + semantic_option* firstVal (); + const semantic_option* firstVal () const; + void setFirstVal (const semantic_option* option); + + value_type& value () + {]b4_parse_assert_if([[ + check_ ();]])[ + return yyval; + } + + const value_type& value () const + {]b4_parse_assert_if([[ + check_ ();]])[ + return yyval; + } + + void + destroy (char const *yymsg, ]b4_namespace_ref[::]b4_parser_class[& yyparser); + + /* DEBUGGING ONLY */ + #if ]b4_api_PREFIX[DEBUG + void yy_yypstack () const + {]b4_parse_assert_if([[ + check_ ();]])[ + if (pred () != YY_NULLPTR) + { + pred ()->yy_yypstack (); + std::cerr << " -> "; + } + std::cerr << yylrState << "@@" << yyposn; + } + #endif + + std::ptrdiff_t indexIn (const glr_stack_item* array) const YY_ATTRIBUTE_UNUSED; + + glr_stack_item* asItem () + {]b4_parse_assert_if([[ + check_ ();]])[ + return asItem(this); + } + + const glr_stack_item* asItem () const + {]b4_parse_assert_if([[ + check_ ();]])[ + return asItem (this); + } + + private: + template + static const glr_stack_item* asItem (const T* state) + { + return reinterpret_cast(state); + } + template + static glr_stack_item* asItem (T* state) + { + return reinterpret_cast (state); + } + static const char *as_pointer_ (const glr_state *state) + { + return reinterpret_cast (state); + } + static char *as_pointer_ (glr_state *state) + { + return reinterpret_cast (state); + } + /** Preceding state in this stack */ + std::ptrdiff_t yypred; + union { + /** First in a chain of alternative reductions producing the + * nonterminal corresponding to this state, threaded through + * yyfirstVal. Value "0" means empty. */ + std::ptrdiff_t yyfirstVal; + /** Semantic value for this state. */ + value_type yyval; + };]b4_locations_if([[ + // FIXME: Why public? + public: + /** Source location for this state. */ + location_type yyloc;]])[ + +]b4_parse_assert_if([[ + public: + // Check invariants. + void check_ () const + { + YY_IGNORE_NULL_DEREFERENCE_BEGIN + YYASSERT (this->magic_ == MAGIC); + YY_IGNORE_NULL_DEREFERENCE_END + } + + // A magic number to check our pointer arithmetic is sane. + enum { MAGIC = 713705 }; + unsigned int magic_;]])[ + }; // class ]b4_parser_class[::glr_state +} // namespace ]b4_namespace_ref[ + + +namespace +{ + /** A stack of GLRState representing the different heads during + * nondeterministic evaluation. */ + class glr_state_set + { + public: + /** Initialize YYSET to a singleton set containing an empty stack. */ + glr_state_set () + : yylastDeleted (YY_NULLPTR) + { + yystates.push_back (YY_NULLPTR); + yylookaheadNeeds.push_back (false); + } + + // Behave like a vector of states. + glr_state*& operator[] (state_set_index index) + { + return yystates[index.uget()]; + } + + glr_state* operator[] (state_set_index index) const + { + return yystates[index.uget()]; + } + + size_t size () const + { + return yystates.size (); + } + + std::vector::iterator begin () + { + return yystates.begin (); + } + + std::vector::iterator end () + { + return yystates.end (); + } + + bool lookaheadNeeds (state_set_index index) const + { + return yylookaheadNeeds[index.uget ()]; + } + + bool setLookaheadNeeds (state_set_index index, bool value) + { + return yylookaheadNeeds[index.uget ()] = value; + } + + /** Invalidate stack #YYK. */ + void + yymarkStackDeleted (state_set_index yyk) + { + size_t k = yyk.uget (); + if (yystates[k] != YY_NULLPTR) + yylastDeleted = yystates[k]; + yystates[k] = YY_NULLPTR; + } + + /** Undelete the last stack in *this that was marked as deleted. Can + only be done once after a deletion, and only when all other stacks have + been deleted. */ + void + yyundeleteLastStack () + { + if (yylastDeleted == YY_NULLPTR || !yystates.empty ()) + return; + yystates.push_back (yylastDeleted); + YYCDEBUG << "Restoring last deleted stack as stack #0.\n"; + clearLastDeleted (); + } + + /** Remove the dead stacks (yystates[i] == YY_NULLPTR) and shift the later + * ones. */ + void + yyremoveDeletes () + { + size_t newsize = yystates.size (); + /* j is the number of live stacks we have seen. */ + for (size_t i = 0, j = 0; j < newsize; ++i) + { + if (yystates[i] == YY_NULLPTR) + { + if (i == j) + { + YYCDEBUG << "Removing dead stacks.\n"; + } + newsize -= 1; + } + else + { + yystates[j] = yystates[i]; + /* In the current implementation, it's unnecessary to copy + yylookaheadNeeds[i] since, after + yyremoveDeletes returns, the parser immediately either enters + deterministic operation or shifts a token. However, it doesn't + hurt, and the code might evolve to need it. */ + yylookaheadNeeds[j] = yylookaheadNeeds[i]; + if (j != i) + { + YYCDEBUG << "Rename stack " << i << " -> " << j << ".\n"; + } + j += 1; + } + } + yystates.resize (newsize); + yylookaheadNeeds.resize (newsize); + } + + + state_set_index + yysplitStack (state_set_index yyk) + { + const size_t k = yyk.uget (); + yystates.push_back (yystates[k]); + yylookaheadNeeds.push_back (yylookaheadNeeds[k]); + return create_state_set_index (static_cast (yystates.size () - 1)); + } + + void clearLastDeleted () + { + yylastDeleted = YY_NULLPTR; + } + + private: + + std::vector yystates; + /** During nondeterministic operation, yylookaheadNeeds tracks which + * stacks have actually needed the current lookahead. During deterministic + * operation, yylookaheadNeeds[0] is not maintained since it would merely + * duplicate !yyla.empty (). */ + std::vector yylookaheadNeeds; + + /** The last stack we invalidated. */ + glr_state* yylastDeleted; + }; // class glr_state_set +} // namespace + +namespace +{ + class semantic_option + { + public: + semantic_option () + : yyrule (0) + , yystate (0) + , yynext (0) + , yyla ()]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {} + + semantic_option (rule_num rule) + : yyrule (rule) + , yystate (0) + , yynext (0) + , yyla ()]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {} + + semantic_option (const semantic_option& that) + : yyrule (that.yyrule) + , yystate (that.yystate) + , yynext (that.yynext) + , yyla (that.yyla)]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {]b4_parse_assert_if([[ + that.check_ ();]])[ + } + + // Needed for the assignment in yynewSemanticOption. + semantic_option& operator= (const semantic_option& that) + {]b4_parse_assert_if([[ + check_ (); + that.check_ ();]])[ + yyrule = that.yyrule; + yystate = that.yystate; + yynext = that.yynext; + yyla = that.yyla; + return *this; + } + + /// Only call state() and setState() on objects in yyitems, not temporaries. + glr_state* state(); + const glr_state* state() const; + void setState(const glr_state* s); + + const semantic_option* next () const YY_ATTRIBUTE_UNUSED; + semantic_option* next (); + void setNext (const semantic_option* s); + + std::ptrdiff_t indexIn (const glr_stack_item* array) const YY_ATTRIBUTE_UNUSED; + + /** True iff YYY0 and YYY1 represent identical options at the top level. + * That is, they represent the same rule applied to RHS symbols + * that produce the same terminal symbols. */ + bool + isIdenticalTo (const semantic_option& yyy1) const + {]b4_parse_assert_if([[ + check_ (); + yyy1.check_ ();]])[ + if (this->yyrule == yyy1.yyrule) + { + const glr_state *yys0, *yys1; + int yyn; + for (yys0 = this->state(), + yys1 = yyy1.state(), + yyn = yyrhsLength (this->yyrule); + yyn > 0; + yys0 = yys0->pred(), + yys1 = yys1->pred(), yyn -= 1) + if (yys0->yyposn != yys1->yyposn) + return false; + return true; + } + else + return false; + } + + /** Assuming identicalOptions (YYY0,YYY1), destructively merge the + * alternative semantic values for the RHS-symbols of YYY1 and YYY0. */ + void + mergeWith (semantic_option& yyy1) + {]b4_parse_assert_if([[ + check_ (); + yyy1.check_ ();]])[ + glr_state *yys0 = this->state (); + glr_state *yys1 = yyy1.state (); + for (int yyn = yyrhsLength (this->yyrule); + yyn > 0; + yyn -= 1, yys0 = yys0->pred (), yys1 = yys1->pred ()) + { + if (yys0 == yys1) + break; + else if (yys0->yyresolved) + { + yys1->yyresolved = true;]b4_variant_if([[ + YYASSERT (yys1->yylrState == yys0->yylrState); + ]b4_symbol_variant([yy_accessing_symbol (yys0->yylrState)], + [yys1->value ()], [copy], [yys0->value ()])], [[ + yys1->value () = yys0->value ();]])[ + } + else if (yys1->yyresolved) + { + yys0->yyresolved = true;]b4_variant_if([[ + YYASSERT (yys0->yylrState == yys1->yylrState); + ]b4_symbol_variant([yy_accessing_symbol (yys1->yylrState)], + [yys0->value ()], [copy], [yys1->value ()])], [[ + yys0->value () = yys1->value ();]])[ + } + else + { + semantic_option* yyz0prev = YY_NULLPTR; + semantic_option* yyz0 = yys0->firstVal(); + semantic_option* yyz1 = yys1->firstVal(); + while (true) + { + if (yyz1 == yyz0 || yyz1 == YY_NULLPTR) + break; + else if (yyz0 == YY_NULLPTR) + { + if (yyz0prev != YY_NULLPTR) + yyz0prev->setNext (yyz1); + else + yys0->setFirstVal (yyz1); + break; + } + else if (yyz0 < yyz1) + { + semantic_option* yyz = yyz0; + if (yyz0prev != YY_NULLPTR) + yyz0prev->setNext(yyz1); + else + yys0->setFirstVal(yyz1); + yyz1 = yyz1->next(); + yyz0->setNext(yyz); + } + yyz0prev = yyz0; + yyz0 = yyz0->next(); + } + yys1->setFirstVal(yys0->firstVal()); + } + } + } + +#if ]b4_api_PREFIX[DEBUG + void yyreportTree (size_t yyindent = 2) const + {]b4_parse_assert_if([[ + check_ ();]])[ + int yynrhs = yyrhsLength (this->yyrule); + const glr_state* yystates[1 + YYMAXRHS]; + glr_state yyleftmost_state; + + { + const glr_state* yys = this->state(); + for (int yyi = yynrhs; 0 < yyi; yyi -= 1) + { + yystates[yyi] = yys; + yys = yys->pred(); + } + if (yys == YY_NULLPTR) + { + yyleftmost_state.yyposn = 0; + yystates[0] = &yyleftmost_state; + } + else + yystates[0] = yys; + } + + std::string yylhs = ]b4_namespace_ref[::]b4_parser_class[::symbol_name (yylhsNonterm (this->yyrule)); + YYASSERT(this->state()); + if (this->state()->yyposn < yystates[0]->yyposn + 1) + std::cerr << std::string(yyindent, ' ') << yylhs << " -> yyrule - 1 << ", empty>\n"; + else + std::cerr << std::string(yyindent, ' ') << yylhs << " -> yyrule - 1 << ", tokens " + << yystates[0]->yyposn + 1 << " .. " + << this->state()->yyposn << ">\n"; + for (int yyi = 1; yyi <= yynrhs; yyi += 1) + { + if (yystates[yyi]->yyresolved) + { + std::string yysym = ]b4_namespace_ref[::]b4_parser_class[::symbol_name (yy_accessing_symbol (yystates[yyi]->yylrState)); + if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) + std::cerr << std::string(yyindent + 2, ' ') << yysym + << " \n"; + else + std::cerr << std::string(yyindent + 2, ' ') << yysym + << " yyposn + 1 + << " .. " << yystates[yyi]->yyposn << ">\n"; + } + else + yystates[yyi]->firstVal ()->yyreportTree (yyindent+2); + } + } +#endif + + /** Rule number for this reduction */ + rule_num yyrule; + + private: + template + static const glr_stack_item* asItem(const T* state) + { + return reinterpret_cast(state); + } + template + static glr_stack_item* asItem(T* state) + { + return reinterpret_cast(state); + } + /** The last RHS state in the list of states to be reduced. */ + std::ptrdiff_t yystate; + /** Next sibling in chain of options. To facilitate merging, + * options are chained in decreasing order by address. */ + std::ptrdiff_t yynext; + + public: + /** The lookahead for this reduction. */ + symbol_type yyla; + +]b4_parse_assert_if([[ + public: + // Check invariants. + void check_ () const + { + YY_IGNORE_NULL_DEREFERENCE_BEGIN + YYASSERT (this->magic_ == MAGIC); + YY_IGNORE_NULL_DEREFERENCE_END + } + + // A magic number to check our pointer arithmetic is sane. + enum { MAGIC = 0xeff1cace }; + unsigned int magic_;]])[ + }; // class semantic_option +} // namespace + +namespace +{ + /** Type of the items in the GLR stack. + * It can be either a glr_state or a semantic_option. The is_state_ field + * indicates which item of the union is valid. */ + class glr_stack_item + { + public: + glr_stack_item (bool state = true) + : is_state_ (state)]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + { + if (is_state_) + new (&raw_) glr_state; + else + new (&raw_) semantic_option; + } + + glr_stack_item (const glr_stack_item& other) YY_NOEXCEPT YY_NOTHROW + : is_state_ (other.is_state_)]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {]b4_parse_assert_if([[ + other.check_ ();]])[ + std::memcpy (raw_, other.raw_, union_size); + } + + glr_stack_item& operator= (glr_stack_item other) + {]b4_parse_assert_if([[ + check_ (); + other.check_ ();]])[ + std::swap (is_state_, other.is_state_); + std::swap (raw_, other.raw_); + return *this; + } + + ~glr_stack_item () + {]b4_parse_assert_if([[ + check_ ();]])[ + if (is_state ()) + getState ().~glr_state (); + else + getOption ().~semantic_option (); + } + + void setState (const glr_state &state) + {]b4_parse_assert_if([[ + check_ (); + state.check_ ();]])[ + if (this != state.asItem ()) + { + if (is_state_) + getState ().~glr_state (); + else + getOption ().~semantic_option (); + new (&raw_) glr_state (state); + is_state_ = true; + } + } + + glr_state& getState () + {]b4_parse_assert_if([[ + check_ ();]])[ + YYDASSERT (is_state ()); + void *yyp = raw_; + glr_state& res = *static_cast (yyp);]b4_parse_assert_if([[ + res.check_ ();]])[ + return res; + } + + const glr_state& getState () const + {]b4_parse_assert_if([[ + check_ ();]])[ + YYDASSERT (is_state ()); + const void *yyp = raw_; + const glr_state& res = *static_cast (yyp);]b4_parse_assert_if([[ + res.check_ ();]])[ + return res; + } + + semantic_option& getOption () + {]b4_parse_assert_if([[ + check_ ();]])[ + YYDASSERT (!is_state ()); + void *yyp = raw_; + return *static_cast (yyp); + } + const semantic_option& getOption () const + {]b4_parse_assert_if([[ + check_ ();]])[ + YYDASSERT (!is_state ()); + const void *yyp = raw_; + return *static_cast (yyp); + } + bool is_state () const + {]b4_parse_assert_if([[ + check_ ();]])[ + return is_state_; + } + + private: + /// The possible contents of raw_. Since they have constructors, they cannot + /// be directly included in the union. + union contents + { + char yystate[sizeof (glr_state)]; + char yyoption[sizeof (semantic_option)]; + }; + enum { union_size = sizeof (contents) }; + union { + /// Strongest alignment constraints. + long double yyalign_me; + /// A buffer large enough to store the contents. + char raw_[union_size]; + }; + /** Type tag for the union. */ + bool is_state_; +]b4_parse_assert_if([[ + public: + // Check invariants. + void check_ () const + { + YYASSERT (this->magic_ == MAGIC); + YYASSERT (this->is_state_ == false || this->is_state_ == true); + } + // A magic number to check our pointer arithmetic is sane. + enum { MAGIC = 0xDEAD1ACC }; // 3735886540. + const unsigned int magic_;]])[ + }; // class glr_stack_item +} // namespace + +glr_state* glr_state::pred () +{]b4_parse_assert_if([[ + check_ ();]])[ + YY_IGNORE_NULL_DEREFERENCE_BEGIN + return yypred ? &asItem (as_pointer_ (this) - yypred)->getState () : YY_NULLPTR; + YY_IGNORE_NULL_DEREFERENCE_END +} + +const glr_state* glr_state::pred () const +{]b4_parse_assert_if([[ + check_ ();]])[ + YY_IGNORE_NULL_DEREFERENCE_BEGIN + return yypred ? &asItem (as_pointer_ (this) - yypred)->getState () : YY_NULLPTR; + YY_IGNORE_NULL_DEREFERENCE_END +} + +void glr_state::setPred (const glr_state* state) +{]b4_parse_assert_if([[ + check_ (); + if (state) + state->check_ ();]])[ + yypred = state ? as_pointer_ (this) - as_pointer_ (state) : 0; +} + +semantic_option* glr_state::firstVal () +{]b4_parse_assert_if([[ + check_ ();]])[ + return yyfirstVal ? &(asItem(this) - yyfirstVal)->getOption() : YY_NULLPTR; +} + +const semantic_option* glr_state::firstVal () const +{]b4_parse_assert_if([[ + check_ ();]])[ + return yyfirstVal ? &(asItem(this) - yyfirstVal)->getOption() : YY_NULLPTR; +} + +void glr_state::setFirstVal (const semantic_option* option) +{]b4_parse_assert_if([[ + check_ ();]])[ + yyfirstVal = option ? asItem(this) - asItem(option) : 0; +} + +std::ptrdiff_t glr_state::indexIn (const glr_stack_item* array) const +{]b4_parse_assert_if([[ + check_ ();]])[ + return asItem(this) - array; +} + +std::ptrdiff_t semantic_option::indexIn (const glr_stack_item* array) const +{ + return asItem(this) - array; +} + +glr_state* semantic_option::state () +{ + YY_IGNORE_NULL_DEREFERENCE_BEGIN + return yystate ? &(asItem(this) - yystate)->getState() : YY_NULLPTR; + YY_IGNORE_NULL_DEREFERENCE_END +} + +const glr_state* semantic_option::state () const +{ + return yystate ? &(asItem(this) - yystate)->getState() : YY_NULLPTR; +} + +void semantic_option::setState (const glr_state* s) +{ + yystate = s ? asItem(this) - asItem(s) : 0; +} + +const semantic_option* semantic_option::next () const +{ + return yynext ? &(asItem(this) - yynext)->getOption() : YY_NULLPTR; +} + +semantic_option* semantic_option::next () +{ + return yynext ? &(asItem(this) - yynext)->getOption() : YY_NULLPTR; +} + +void semantic_option::setNext (const semantic_option* s) +{ + yynext = s ? asItem(this) - asItem(s) : 0; +} + +void glr_state::destroy (char const* yymsg, ]b4_namespace_ref[::]b4_parser_class[& yyparser) +{]b4_parse_assert_if([[ + check_ ();]])[ + if (yyresolved) + yyparser.yy_destroy_ (yymsg, yy_accessing_symbol(yylrState), + value ()]b4_locations_if([, yyloc])[); + else + { +#if ]b4_api_PREFIX[DEBUG + YYCDEBUG << yymsg + << (firstVal() ? " unresolved " : " incomplete ") + << (yy_accessing_symbol (yylrState) < YYNTOKENS ? "token" : "nterm") + << ' ' << yyparser.symbol_name (yy_accessing_symbol (yylrState)) + << " ("]b4_locations_if([[ + << yyloc << ": "]])[ + << ")\n"; +#endif + if (firstVal() != YY_NULLPTR) + { + semantic_option& yyoption = *firstVal (); + glr_state *yyrh = yyoption.state (); + for (int yyn = yyrhsLength (yyoption.yyrule); yyn > 0; yyn -= 1) + { + yyrh->destroy (yymsg, yyparser); + yyrh = yyrh->pred(); + } + } + } +} + + +#undef YYFILL +#define YYFILL(N) yyfill (yyvsp, yylow, (N), yynormal) + +namespace +{ + class state_stack + { + public: + using parser_type = ]b4_namespace_ref[::]b4_parser_class[; + using symbol_kind = parser_type::symbol_kind; + using value_type = parser_type::value_type;]b4_locations_if([[ + using location_type = parser_type::location_type;]])[ + + /** Initialize to a single empty stack, with total maximum + * capacity for all stacks of YYSIZE. */ + state_stack (size_t yysize) + : yysplitPoint (YY_NULLPTR) + { + yyitems.reserve (yysize); + } + +#if YYSTACKEXPANDABLE + /** Returns false if it tried to expand but could not. */ + bool + yyexpandGLRStackIfNeeded () + { + return YYHEADROOM <= spaceLeft () || yyexpandGLRStack (); + } + + private: + /** If *this is expandable, extend it. WARNING: Pointers into the + stack from outside should be considered invalid after this call. + We always expand when there are 1 or fewer items left AFTER an + allocation, so that we can avoid having external pointers exist + across an allocation. */ + bool + yyexpandGLRStack () + { + const size_t oldsize = yyitems.size(); + if (YYMAXDEPTH - YYHEADROOM < oldsize) + return false; + const size_t yynewSize = YYMAXDEPTH < 2 * oldsize ? YYMAXDEPTH : 2 * oldsize; + const glr_stack_item *oldbase = &yyitems[0]; + + yyitems.reserve (yynewSize); + const glr_stack_item *newbase = &yyitems[0]; + + // Adjust the pointers. Perform raw pointer arithmetic, as there + // is no reason for objects to be aligned on their size. + const ptrdiff_t disp + = reinterpret_cast (newbase) - reinterpret_cast (oldbase); + if (yysplitPoint) + const_cast (yysplitPoint) + = reinterpret_cast (reinterpret_cast (const_cast (yysplitPoint)) + disp); + + for (std::vector::iterator + i = yytops.begin (), + yyend = yytops.end (); + i != yyend; ++i) + if (glr_state_not_null (*i)) + *i = reinterpret_cast(reinterpret_cast(*i) + disp); + + return true; + } + + public: +#else + bool yyexpandGLRStackIfNeeded () + { + return YYHEADROOM <= spaceLeft (); + } +#endif +#undef YYSTACKEXPANDABLE + + static bool glr_state_not_null (glr_state* s) + { + return s != YY_NULLPTR; + } + + bool + reduceToOneStack () + { + using iterator = std::vector::iterator; + const iterator yybegin = yytops.begin(); + const iterator yyend = yytops.end(); + const iterator yyit = std::find_if(yybegin, yyend, glr_state_not_null); + if (yyit == yyend) + return false; + for (state_set_index yyk = create_state_set_index(yyit + 1 - yybegin); + yyk.uget() != numTops(); ++yyk) + yytops.yymarkStackDeleted (yyk); + yytops.yyremoveDeletes (); + yycompressStack (); + return true; + } + + /** Called when returning to deterministic operation to clean up the extra + * stacks. */ + void + yycompressStack () + { + if (yytops.size() != 1 || !isSplit()) + return; + + // yyr is the state after the split point. + glr_state* yyr = YY_NULLPTR; + for (glr_state *yyp = firstTop(), *yyq = yyp->pred(); + yyp != yysplitPoint; + yyr = yyp, yyp = yyq, yyq = yyp->pred()) + yyp->setPred(yyr); + + // This const_cast is okay, since anyway we have access to the mutable + // yyitems into which yysplitPoint points. + glr_stack_item* nextFreeItem + = const_cast (yysplitPoint)->asItem () + 1; + yysplitPoint = YY_NULLPTR; + yytops.clearLastDeleted (); + + while (yyr != YY_NULLPTR) + { + nextFreeItem->setState (*yyr); + glr_state& nextFreeState = nextFreeItem->getState(); + yyr = yyr->pred(); + nextFreeState.setPred(&(nextFreeItem - 1)->getState()); + setFirstTop (&nextFreeState); + ++nextFreeItem; + } + yyitems.resize(static_cast(nextFreeItem - yyitems.data())); + } + + bool isSplit() const { + return yysplitPoint != YY_NULLPTR; + } + + // Present the interface of a vector of glr_stack_item. + std::vector::const_iterator begin () const + { + return yyitems.begin (); + } + + std::vector::const_iterator end () const + { + return yyitems.end (); + } + + size_t size() const + { + return yyitems.size (); + } + + glr_stack_item& operator[] (size_t i) + { + return yyitems[i]; + } + + glr_stack_item& stackItemAt (size_t index) + { + return yyitems[index]; + } + + size_t numTops () const + { + return yytops.size (); + } + + glr_state* firstTop () const + { + return yytops[create_state_set_index (0)]; + } + + glr_state* topAt (state_set_index i) const + { + return yytops[i]; + } + + void setFirstTop (glr_state* value) + { + yytops[create_state_set_index (0)] = value; + } + + void setTopAt (state_set_index i, glr_state* value) + { + yytops[i] = value; + } + + void pop_back () + { + yyitems.pop_back (); + } + + void pop_back (size_t n) + { + yyitems.resize (yyitems.size () - n); + } + + state_set_index + yysplitStack (state_set_index yyk) + { + if (!isSplit ()) + { + YYASSERT (yyk.get () == 0); + yysplitPoint = topAt (yyk); + } + return yytops.yysplitStack (yyk); + } + + /** Assuming that YYS is a GLRState somewhere on *this, update the + * splitpoint of *this, if needed, so that it is at least as deep as + * YYS. */ + void + yyupdateSplit (glr_state& yys) + { + if (isSplit() && &yys < yysplitPoint) + yysplitPoint = &yys; + } + + /** Return a fresh GLRState. + * Callers should call yyreserveStack afterwards to make sure there is + * sufficient headroom. */ + glr_state& yynewGLRState (const glr_state& newState) + { + glr_state& state = yyitems[yynewGLRStackItem (true)].getState (); +#if false && 201103L <= YY_CPLUSPLUS + state = std::move (newState); +#else + state = newState; +#endif + return state; + } + + /** Return a fresh SemanticOption. + * Callers should call yyreserveStack afterwards to make sure there is + * sufficient headroom. */ + semantic_option& yynewSemanticOption (semantic_option newOption) + { + semantic_option& option = yyitems[yynewGLRStackItem (false)].getOption (); + option = std::move (newOption); + return option; + } + + /* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in + * YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1. + * For convenience, always return YYLOW1. */ + int + yyfill (glr_stack_item *yyvsp, int &yylow, int yylow1, bool yynormal) + { + if (!yynormal && yylow1 < yylow) + { + yyfillin (yyvsp, yylow, yylow1); + yylow = yylow1; + } + return yylow1; + } + + /** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting + * at YYVSP[YYLOW0].getState().pred(). Leaves YYVSP[YYLOW1].getState().pred() + * containing the pointer to the next state in the chain. */ + void + yyfillin (glr_stack_item *yyvsp, int yylow0, int yylow1) + { + glr_state* s = yyvsp[yylow0].getState().pred(); + YYASSERT(s != YY_NULLPTR); + for (int i = yylow0-1; i >= yylow1; i -= 1, s = s->pred()) + { + glr_state& yys = yyvsp[i].getState(); +#if ]b4_api_PREFIX[DEBUG + yys.yylrState = s->yylrState; +#endif + yys.yyresolved = s->yyresolved; + if (s->yyresolved) + {]b4_variant_if([[ + new (&yys.value ()) value_type (); + ]b4_symbol_variant([yy_accessing_symbol (s->yylrState)], + [yys.value ()], [copy], [s->value ()])], [[ + new (&yys.value ()) value_type (s->value ());]])[ + } + else + /* The effect of using yyval or yyloc (in an immediate + * rule) is undefined. */ + yys.setFirstVal (YY_NULLPTR);]b4_locations_if([[ + yys.yyloc = s->yyloc;]])[ + yys.setPred(s->pred()); + } + } + +#if ]b4_api_PREFIX[DEBUG + + /*----------------------------------------------------------------------. + | Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. | + `----------------------------------------------------------------------*/ + + void + yy_reduce_print (bool yynormal, glr_stack_item* yyvsp, state_set_index yyk, + rule_num yyrule, parser_type& yyparser) + { + int yynrhs = yyrhsLength (yyrule);]b4_locations_if([ + int yylow = 1;])[ + int yyi; + std::cerr << "Reducing stack " << yyk.get() << " by rule " << yyrule - 1 + << " (line " << int (yyrline[yyrule]) << "):\n"; + if (! yynormal) + yyfillin (yyvsp, 1, -yynrhs); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + std::cerr << " $" << yyi + 1 << " = "; + yyparser.yy_symbol_print_ + (yy_accessing_symbol (yyvsp[yyi - yynrhs + 1].getState().yylrState), + yyvsp[yyi - yynrhs + 1].getState().value ()]b4_locations_if([[, + ]b4_rhs_location(yynrhs, yyi + 1)])[); + if (!yyvsp[yyi - yynrhs + 1].getState().yyresolved) + std::cerr << " (unresolved)"; + std::cerr << '\n'; + } + } + + +#define YYINDEX(YYX) \ + ((YYX) == YY_NULLPTR ? -1 : (YYX)->indexIn (yyitems.data ())) + + void + dumpStack () const + { + for (size_t yyi = 0; yyi < size(); ++yyi) + { + const glr_stack_item& item = yyitems[yyi]; + std::cerr << std::setw(3) << yyi << ". "; + if (item.is_state()) + { + std::cerr << "Res: " << item.getState().yyresolved + << ", LR State: " << item.getState().yylrState + << ", posn: " << item.getState().yyposn + << ", pred: " << YYINDEX(item.getState().pred()); + if (! item.getState().yyresolved) + std::cerr << ", firstVal: " + << YYINDEX(item.getState().firstVal()); + } + else + { + std::cerr << "Option. rule: " << item.getOption().yyrule - 1 + << ", state: " << YYINDEX(item.getOption().state()) + << ", next: " << YYINDEX(item.getOption().next()); + } + std::cerr << '\n'; + } + std::cerr << "Tops:"; + for (state_set_index yyi = create_state_set_index(0); yyi.uget() < numTops(); ++yyi) { + std::cerr << yyi.get() << ": " << YYINDEX(topAt(yyi)) << "; "; + } + std::cerr << '\n'; + } + +#undef YYINDEX +#endif + + YYRESULTTAG + yyreportAmbiguity (const semantic_option& yyx0, + const semantic_option& yyx1, parser_type& yyparser]b4_locations_if([, const location_type& yyloc])[) + { + YY_USE (yyx0); + YY_USE (yyx1); + +#if ]b4_api_PREFIX[DEBUG + std::cerr << "Ambiguity detected.\n" + "Option 1,\n"; + yyx0.yyreportTree (); + std::cerr << "\nOption 2,\n"; + yyx1.yyreportTree (); + std::cerr << '\n'; +#endif + + yyparser.error (]b4_locations_if([yyloc, ])[YY_("syntax is ambiguous")); + return yyabort; + } + +#if ]b4_api_PREFIX[DEBUG + /* Print YYS (possibly NULL) and its predecessors. */ + void + yypstates (const glr_state* yys) const + { + if (yys != YY_NULLPTR) + yys->yy_yypstack(); + else + std::cerr << ""; + std::cerr << '\n'; + } +#endif + + private: + size_t spaceLeft() const + { + return yyitems.capacity() - yyitems.size(); + } + + /** Return a fresh GLRStackItem in this. The item is an LR state + * if YYIS_STATE, and otherwise a semantic option. Callers should call + * yyreserveStack afterwards to make sure there is sufficient + * headroom. */ + size_t + yynewGLRStackItem (bool yyis_state) + { + YYDASSERT(yyitems.size() < yyitems.capacity()); + yyitems.push_back(glr_stack_item(yyis_state)); + return yyitems.size() - 1; + } + + + public: + std::vector yyitems; + // Where the stack splits. Anything below this address is deterministic. + const glr_state* yysplitPoint; + glr_state_set yytops; + }; // class state_stack +} // namespace + +#undef YYFILL +#define YYFILL(N) yystateStack.yyfill (yyvsp, yylow, (N), yynormal) + +namespace ]b4_namespace_ref[ +{ + class ]b4_parser_class[::glr_stack + { + public: +]b4_parse_error_bmatch([custom\|detailed\|verbose], [[ + // Needs access to yypact_value_is_default, etc. + friend context; +]])[ + + glr_stack (size_t yysize, parser_type& yyparser_yyarg]m4_ifset([b4_parse_param], [, b4_parse_param_decl])[) + : yyerrState (0) + , yystateStack (yysize) + , yyerrcnt (0) + , yyla () + , yyparser (yyparser_yyarg)]m4_ifset([b4_parse_param], [,b4_parse_param_cons])[ + {} + + ~glr_stack () + { + if (!this->yyla.empty ()) + yyparser.yy_destroy_ ("Cleanup: discarding lookahead", + this->yyla.kind (), this->yyla.value]b4_locations_if([, this->yyla.location])[); + popall_ (); + } + + int yyerrState; +]b4_locations_if([[ /* To compute the location of the error token. */ + glr_stack_item yyerror_range[3];]])[ + state_stack yystateStack; + int yyerrcnt; + symbol_type yyla; + YYJMP_BUF yyexception_buffer; + parser_type& yyparser; + + #define YYCHK1(YYE) \ + do { \ + switch (YYE) { \ + case yyok: \ + break; \ + case yyabort: \ + goto yyabortlab; \ + case yyaccept: \ + goto yyacceptlab; \ + case yyerr: \ + goto yyuser_error; \ + default: \ + goto yybuglab; \ + } \ + } while (false) + + int + parse () + { + int yyresult; + size_t yyposn; + + YYCDEBUG << "Starting parse\n"; + + this->yyla.clear (); +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yyla.value], [], [], [yyla.location])dnl + b4_user_initial_action +b4_dollar_popdef])[]dnl +[ + switch (YYSETJMP (this->yyexception_buffer)) + { + case 0: break; + case 1: goto yyabortlab; + case 2: goto yyexhaustedlab; + default: goto yybuglab; + } + this->yyglrShift (create_state_set_index(0), 0, 0, this->yyla.value]b4_locations_if([, this->yyla.location])[); + yyposn = 0; + + while (true) + { + /* For efficiency, we have two loops, the first of which is + specialized to deterministic operation (single stack, no + potential ambiguity). */ + /* Standard mode */ + while (true) + { + const state_num yystate = this->firstTopState()->yylrState; + YYCDEBUG << "Entering state " << yystate << '\n'; + if (yystate == YYFINAL) + goto yyacceptlab; + if (yy_is_defaulted_state (yystate)) + { + const rule_num yyrule = yy_default_action (yystate); + if (yyrule == 0) + {]b4_locations_if([[ + this->yyerror_range[1].getState().yyloc = this->yyla.location;]])[ + this->yyreportSyntaxError (); + goto yyuser_error; + } + YYCHK1 (this->yyglrReduce (create_state_set_index(0), yyrule, true)); + } + else + { + yyget_token (); + const short* yyconflicts; + const int yyaction = yygetLRActions (yystate, this->yyla.kind (), yyconflicts); + if (*yyconflicts != 0) + break; + if (yy_is_shift_action (yyaction)) + { + YY_SYMBOL_PRINT ("Shifting", this->yyla.kind (), this->yyla.value, this->yyla.location); + yyposn += 1; + // FIXME: we should move yylval. + this->yyglrShift (create_state_set_index(0), yyaction, yyposn, this->yyla.value]b4_locations_if([, this->yyla.location])[); + yyla.clear (); + if (0 < this->yyerrState) + this->yyerrState -= 1; + } + else if (yy_is_error_action (yyaction)) + {]b4_locations_if([[ + this->yyerror_range[1].getState().yyloc = this->yyla.location;]])[ + /* Don't issue an error message again for exceptions + thrown from the scanner. */ + if (this->yyla.kind () != ]b4_symbol(error, kind)[) + this->yyreportSyntaxError (); + goto yyuser_error; + } + else + YYCHK1 (this->yyglrReduce (create_state_set_index(0), -yyaction, true)); + } + } + + while (true) + { + for (state_set_index yys = create_state_set_index(0); yys.uget() < this->yystateStack.numTops(); ++yys) + this->yystateStack.yytops.setLookaheadNeeds(yys, !this->yyla.empty ()); + + /* yyprocessOneStack returns one of three things: + + - An error flag. If the caller is yyprocessOneStack, it + immediately returns as well. When the caller is finally + yyparse, it jumps to an error label via YYCHK1. + + - yyok, but yyprocessOneStack has invoked yymarkStackDeleted + (yys), which sets the top state of yys to NULL. Thus, + yyparse's following invocation of yyremoveDeletes will remove + the stack. + + - yyok, when ready to shift a token. + + Except in the first case, yyparse will invoke yyremoveDeletes and + then shift the next token onto all remaining stacks. This + synchronization of the shift (that is, after all preceding + reductions on all stacks) helps prevent double destructor calls + on yylval in the event of memory exhaustion. */ + + for (state_set_index yys = create_state_set_index (0); yys.uget () < this->yystateStack.numTops (); ++yys) + YYCHK1 (this->yyprocessOneStack (yys, yyposn]b4_locations_if([, &this->yyla.location])[)); + this->yystateStack.yytops.yyremoveDeletes (); + if (this->yystateStack.yytops.size() == 0) + { + this->yystateStack.yytops.yyundeleteLastStack (); + if (this->yystateStack.yytops.size() == 0) + this->yyFail (]b4_locations_if([&this->yyla.location, ])[YY_("syntax error")); + YYCHK1 (this->yyresolveStack ()); + YYCDEBUG << "Returning to deterministic operation.\n";]b4_locations_if([[ + this->yyerror_range[1].getState ().yyloc = this->yyla.location;]])[ + this->yyreportSyntaxError (); + goto yyuser_error; + } + + /* If any yyglrShift call fails, it will fail after shifting. Thus, + a copy of yylval will already be on stack 0 in the event of a + failure in the following loop. Thus, yyla is emptied + before the loop to make sure the user destructor for yylval isn't + called twice. */ + symbol_kind_type yytoken_to_shift = this->yyla.kind (); + this->yyla.kind_ = ]b4_symbol(empty, kind)[; + yyposn += 1; + for (state_set_index yys = create_state_set_index (0); yys.uget () < this->yystateStack.numTops (); ++yys) + { + const state_num yystate = this->topState (yys)->yylrState; + const short* yyconflicts; + const int yyaction = yygetLRActions (yystate, yytoken_to_shift, yyconflicts); + /* Note that yyconflicts were handled by yyprocessOneStack. */ + YYCDEBUG << "On stack " << yys.get() << ", "; + YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, this->yyla.value, this->yyla.location); + this->yyglrShift (yys, yyaction, yyposn, this->yyla.value]b4_locations_if([, this->yyla.location])[); + YYCDEBUG << "Stack " << yys.get() << " now in state " + << this->topState(yys)->yylrState << '\n'; + } +]b4_variant_if([[ + // FIXME: User destructors. + // Value type destructor. + ]b4_symbol_variant([[yytoken_to_shift]], [[this->yyla.value]], [[template destroy]])])[ + + if (this->yystateStack.yytops.size () == 1) + { + YYCHK1 (this->yyresolveStack ()); + YYCDEBUG << "Returning to deterministic operation.\n"; + this->yystateStack.yycompressStack (); + break; + } + } + continue; + yyuser_error: + this->yyrecoverSyntaxError (]b4_locations_if([&this->yyla.location])[); + yyposn = this->firstTopState()->yyposn; + } + + yyacceptlab: + yyresult = 0; + goto yyreturn; + + yybuglab: + YYASSERT (false); + goto yyabortlab; + + yyabortlab: + yyresult = 1; + goto yyreturn; + + yyexhaustedlab: + yyparser.error (]b4_locations_if([this->yyla.location, ])[YY_("memory exhausted")); + yyresult = 2; + goto yyreturn; + + yyreturn: + return yyresult; + } + #undef YYCHK1 + + void yyreserveGlrStack () + { + if (!yystateStack.yyexpandGLRStackIfNeeded ()) + yyMemoryExhausted (); + } + + _Noreturn void + yyMemoryExhausted () + { + YYLONGJMP (yyexception_buffer, 2); + } + + _Noreturn void + yyFail (]b4_locations_if([location_type* yylocp, ])[const char* yymsg) + { + if (yymsg != YY_NULLPTR) + yyparser.error (]b4_locations_if([*yylocp, ])[yymsg); + YYLONGJMP (yyexception_buffer, 1); + } + + /* GLRStates */ + + + /** Add a new semantic action that will execute the action for rule + * YYRULE on the semantic values in YYRHS to the list of + * alternative actions for YYSTATE. Assumes that YYRHS comes from + * stack #YYK of *this. */ + void + yyaddDeferredAction (state_set_index yyk, glr_state* yystate, + glr_state* yyrhs, rule_num yyrule) + { + semantic_option& yyopt = yystateStack.yynewSemanticOption (semantic_option (yyrule)); + yyopt.setState (yyrhs); + yyopt.setNext (yystate->firstVal ()); + if (yystateStack.yytops.lookaheadNeeds (yyk)) + yyopt.yyla = this->yyla; + yystate->setFirstVal (&yyopt); + + yyreserveGlrStack (); + } + + #if ]b4_api_PREFIX[DEBUG + void yypdumpstack () const + { + yystateStack.dumpStack(); + } + #endif + + void + yyreportSyntaxError () + { + if (yyerrState != 0) + return; +]b4_parse_error_case( +[simple], [[ + std::string msg = YY_("syntax error"); + yyparser.error (]b4_join(b4_locations_if([yyla.location]), [[YY_MOVE (msg)]])[);]], +[custom], [[ + context yyctx (*this, yyla); + yyparser.report_syntax_error (yyctx);]], +[[ + context yyctx (*this, yyla); + std::string msg = yyparser.yysyntax_error_ (yyctx); + yyparser.error (]b4_join(b4_locations_if([yyla.location]), [[YY_MOVE (msg)]])[);]])[ + yyerrcnt += 1; + } + + /* Recover from a syntax error on this, assuming that yytoken, + yylval, and yylloc are the syntactic category, semantic value, and location + of the lookahead. */ + void + yyrecoverSyntaxError (]b4_locations_if([location_type* yylocp])[) + { + if (yyerrState == 3) + /* We just shifted the error token and (perhaps) took some + reductions. Skip tokens until we can proceed. */ + while (true) + { + if (this->yyla.kind () == ]b4_symbol(eof, kind)[) + yyFail (]b4_locations_if([yylocp, ])[YY_NULLPTR); + if (this->yyla.kind () != ]b4_symbol(empty, kind)[) + {]b4_locations_if([[ + /* We throw away the lookahead, but the error range + of the shifted error token must take it into account. */ + glr_state *yys = firstTopState(); + yyerror_range[1].getState().yyloc = yys->yyloc; + yyerror_range[2].getState().yyloc = this->yyla.location; + YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ + yyparser.yy_destroy_ ("Error: discarding", + this->yyla.kind (), this->yyla.value]b4_locations_if([, this->yyla.location])[);]b4_variant_if([[ + // Value type destructor. + ]b4_symbol_variant([[this->yyla.kind ()]], [[this->yyla.value]], [[template destroy]])])[ + this->yyla.kind_ = ]b4_symbol(empty, kind)[; + } + yyget_token (); + int yyj = yypact[firstTopState()->yylrState]; + if (yypact_value_is_default (yyj)) + return; + yyj += this->yyla.kind (); + if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != this->yyla.kind ()) + { + if (yydefact[firstTopState()->yylrState] != 0) + return; + } + else if (! yytable_value_is_error (yytable[yyj])) + return; + } + + if (!yystateStack.reduceToOneStack()) + yyFail (]b4_locations_if([yylocp, ])[YY_NULLPTR); + + /* Now pop stack until we find a state that shifts the error token. */ + yyerrState = 3; + while (firstTopState () != YY_NULLPTR) + { + glr_state *yys = firstTopState (); + int yyj = yypact[yys->yylrState]; + if (! yypact_value_is_default (yyj)) + { + yyj += YYTERROR; + if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR + && yy_is_shift_action (yytable[yyj])) + { + /* Shift the error token. */]b4_locations_if([[ + /* First adjust its location.*/ + location_type yyerrloc; + yyerror_range[2].getState().yyloc = this->yyla.location; + YYLLOC_DEFAULT (yyerrloc, (yyerror_range), 2);]])[ + YY_SYMBOL_PRINT ("Shifting", yy_accessing_symbol (yytable[yyj]), + this->yyla.value, yyerrloc); + yyglrShift (create_state_set_index(0), yytable[yyj], + yys->yyposn, yyla.value]b4_locations_if([, yyerrloc])[); + yys = firstTopState(); + break; + } + }]b4_locations_if([[ + yyerror_range[1].getState().yyloc = yys->yyloc;]])[ + if (yys->pred() != YY_NULLPTR) + yys->destroy ("Error: popping", yyparser); + yystateStack.setFirstTop(yys->pred()); + yystateStack.pop_back(); + } + if (firstTopState() == YY_NULLPTR) + yyFail (]b4_locations_if([yylocp, ])[YY_NULLPTR); + } + + YYRESULTTAG + yyprocessOneStack (state_set_index yyk, + size_t yyposn]b4_locations_if([, location_type* yylocp])[) + { + while (yystateStack.topAt(yyk) != YY_NULLPTR) + { + const state_num yystate = topState(yyk)->yylrState; + YYCDEBUG << "Stack " << yyk.get() + << " Entering state " << yystate << '\n'; + + YYASSERT (yystate != YYFINAL); + + if (yy_is_defaulted_state (yystate)) + { + const rule_num yyrule = yy_default_action (yystate); + if (yyrule == 0) + { + YYCDEBUG << "Stack " << yyk.get() << " dies.\n"; + yystateStack.yytops.yymarkStackDeleted (yyk); + return yyok; + } + const YYRESULTTAG yyflag + = yyglrReduce (yyk, yyrule, yyimmediate[yyrule]); + if (yyflag == yyerr) + { + YYCDEBUG << "Stack " << yyk.get() << " dies" + " (predicate failure or explicit user error).\n"; + yystateStack.yytops.yymarkStackDeleted (yyk); + return yyok; + } + if (yyflag != yyok) + return yyflag; + } + else + { + yystateStack.yytops.setLookaheadNeeds(yyk, true); + yyget_token (); + const short* yyconflicts; + const int yyaction = yygetLRActions (yystate, this->yyla.kind (), yyconflicts); + + for (; *yyconflicts != 0; ++yyconflicts) + { + state_set_index yynewStack = yystateStack.yysplitStack (yyk); + YYCDEBUG << "Splitting off stack " << yynewStack.get() + << " from " << yyk.get() << ".\n"; + YYRESULTTAG yyflag = + yyglrReduce (yynewStack, *yyconflicts, yyimmediate[*yyconflicts]); + if (yyflag == yyok) + YYCHK (yyprocessOneStack (yynewStack, + yyposn]b4_locations_if([, yylocp])[)); + else if (yyflag == yyerr) + { + YYCDEBUG << "Stack " << yynewStack.get() << " dies.\n"; + yystateStack.yytops.yymarkStackDeleted (yynewStack); + } + else + return yyflag; + } + + if (yy_is_shift_action (yyaction)) + break; + else if (yy_is_error_action (yyaction)) + { + YYCDEBUG << "Stack " << yyk.get() << " dies.\n"; + yystateStack.yytops.yymarkStackDeleted (yyk); + break; + } + else + { + YYRESULTTAG yyflag + = yyglrReduce (yyk, -yyaction, yyimmediate[-yyaction]); + if (yyflag == yyerr) + { + YYCDEBUG << "Stack " << yyk.get() << " dies" + " (predicate failure or explicit user error).\n"; + yystateStack.yytops.yymarkStackDeleted (yyk); + break; + } + else if (yyflag != yyok) + return yyflag; + } + } + } + return yyok; + } + + /** Perform user action for rule number YYN, with RHS length YYRHSLEN, + * and top stack item YYVSP. YYVALP points to place to put semantic + * value ($$), and yylocp points to place for location information + * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT, + * yyerr for YYERROR, yyabort for YYABORT. */ + YYRESULTTAG + yyuserAction (rule_num yyrule, int yyrhslen, glr_stack_item* yyvsp, state_set_index yyk, + value_type* yyvalp]b4_locations_if([, location_type* yylocp])[) + { + bool yynormal YY_ATTRIBUTE_UNUSED = !yystateStack.isSplit(); + int yylow = 1; +]b4_parse_param_use([yyvalp], [yylocp])dnl +[ YY_USE (yyk); + YY_USE (yyrhslen); + # undef yyerrok + # define yyerrok (yyerrState = 0) + # undef YYACCEPT + # define YYACCEPT return yyaccept + # undef YYABORT + # define YYABORT return yyabort + # undef YYERROR + # define YYERROR return yyerrok, yyerr + # undef YYRECOVERING + # define YYRECOVERING() (yyerrState != 0) + # undef yytoken + # define yytoken this->yyla.kind_ + # undef yyclearin + # define yyclearin (yytoken = ]b4_symbol(empty, kind)[) + # undef YYBACKUP + # define YYBACKUP(Token, Value) \ + return yyparser.error (]b4_locations_if([*yylocp, ])[YY_("syntax error: cannot back up")), \ + yyerrok, yyerr + +]b4_variant_if([[ + /* Variants are always initialized to an empty instance of the + correct type. The default '$$ = $1' action is NOT applied + when using variants. */ + // However we really need to prepare yyvsp now if we want to get + // correct locations, so invoke YYFILL for $1 anyway. + (void) YYFILL (1-yyrhslen); + ]b4_symbol_variant([[yylhsNonterm (yyrule)]], [(*yyvalp)], [emplace])], [[ + if (yyrhslen == 0) + *yyvalp = yyval_default; + else + *yyvalp = yyvsp[YYFILL (1-yyrhslen)].getState().value ();]])[]b4_locations_if([[ + /* Default location. */ + YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); + yyerror_range[1].getState().yyloc = *yylocp; +]])[ + /* If yyk == -1, we are running a deferred action on a temporary + stack. In that case, YY_REDUCE_PRINT must not play with YYFILL, + so pretend the stack is "normal". */ + YY_REDUCE_PRINT ((yynormal || yyk == create_state_set_index (-1), yyvsp, yyk, yyrule, yyparser)); + #if YY_EXCEPTIONS + try + { + #endif // YY_EXCEPTIONS + switch (yyrule) + { + ]b4_user_actions[ + default: break; + } + #if YY_EXCEPTIONS + } + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';]b4_locations_if([ + *yylocp = yyexc.location;])[ + yyparser.error (]b4_locations_if([*yylocp, ])[yyexc.what ()); + YYERROR; + } + #endif // YY_EXCEPTIONS + YY_SYMBOL_PRINT ("-> $$ =", yylhsNonterm (yyrule), *yyvalp, *yylocp); + + return yyok; + # undef yyerrok + # undef YYABORT + # undef YYACCEPT + # undef YYERROR + # undef YYBACKUP + # undef yytoken + # undef yyclearin + # undef YYRECOVERING + } + + YYRESULTTAG + yyresolveStack () + { + if (yystateStack.isSplit ()) + { + int yyn = 0; + for (glr_state* yys = firstTopState (); + yys != yystateStack.yysplitPoint; + yys = yys->pred ()) + yyn += 1; + YYCHK (yyresolveStates (*firstTopState (), yyn)); + } + return yyok; + } + + /** Pop the symbols consumed by reduction #YYRULE from the top of stack + * #YYK of *YYSTACKP, and perform the appropriate semantic action on their + * semantic values. Assumes that all ambiguities in semantic values + * have been previously resolved. Set *YYVALP to the resulting value, + * and *YYLOCP to the computed location (if any). Return value is as + * for userAction. */ + YYRESULTTAG + yydoAction (state_set_index yyk, rule_num yyrule, + value_type* yyvalp]b4_locations_if([, location_type* yylocp])[) + { + const int yynrhs = yyrhsLength (yyrule); + + if (!yystateStack.isSplit()) + { + /* Standard special case: single stack. */ + YYASSERT (yyk.get() == 0); + glr_stack_item* yyrhs = yystateStack.firstTop()->asItem(); + const YYRESULTTAG res + = yyuserAction (yyrule, yynrhs, yyrhs, yyk, yyvalp]b4_locations_if([, yylocp])[); + yystateStack.pop_back(static_cast(yynrhs)); + yystateStack.setFirstTop(&yystateStack[yystateStack.size() - 1].getState()); + return res; + } + else + { + glr_stack_item yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + glr_state* yys = yystateStack.topAt(yyk); + yyrhsVals[YYMAXRHS + YYMAXLEFT].getState().setPred(yys);]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].getState().yyloc = yys->yyloc;]])[ + for (int yyi = 0; yyi < yynrhs; yyi += 1) + { + yys = yys->pred(); + YYASSERT (yys != YY_NULLPTR); + } + yystateStack.yyupdateSplit (*yys); + yystateStack.setTopAt(yyk, yys); + return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yyk, + yyvalp]b4_locations_if([, yylocp])[); + } + } + + /** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE, + * and push back on the resulting nonterminal symbol. Perform the + * semantic action associated with YYRULE and store its value with the + * newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently + * unambiguous. Otherwise, store the deferred semantic action with + * the new state. If the new state would have an identical input + * position, LR state, and predecessor to an existing state on the stack, + * it is identified with that existing state, eliminating stack #YYK from + * *YYSTACKP. In this case, the semantic value is + * added to the options for the existing state's semantic value. + */ + YYRESULTTAG + yyglrReduce (state_set_index yyk, rule_num yyrule, bool yyforceEval) + { + size_t yyposn = topState(yyk)->yyposn; + + if (yyforceEval || !yystateStack.isSplit()) + { + value_type val;]b4_locations_if([[ + location_type loc;]])[ + + YYRESULTTAG yyflag = yydoAction (yyk, yyrule, &val]b4_locations_if([, &loc])[); + if (yyflag == yyerr && yystateStack.isSplit()) + {]b4_parse_trace_if([[ + YYCDEBUG << "Parse on stack " << yyk.get () + << " rejected by rule " << yyrule - 1 + << " (line " << int (yyrline[yyrule]) << ").\n"; + ]])[} + if (yyflag != yyok) + return yyflag; + yyglrShift (yyk, + yyLRgotoState (topState(yyk)->yylrState, + yylhsNonterm (yyrule)), + yyposn, val]b4_locations_if([, loc])[);]b4_variant_if([[ + // FIXME: User destructors. + // Value type destructor. + ]b4_symbol_variant([[yylhsNonterm (yyrule)]], [[val]], [[template destroy]])])[ + } + else + { + glr_state *yys = yystateStack.topAt(yyk); + glr_state *yys0 = yys; + for (int yyn = yyrhsLength (yyrule); 0 < yyn; yyn -= 1) + { + yys = yys->pred(); + YYASSERT (yys != YY_NULLPTR); + } + yystateStack.yyupdateSplit (*yys); + state_num yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));]b4_parse_trace_if([[ + YYCDEBUG << "Reduced stack " << yyk.get () + << " by rule " << yyrule - 1 << " (line " << int (yyrline[yyrule]) + << "); action deferred. Now in state " << yynewLRState + << ".\n";]])[ + for (state_set_index yyi = create_state_set_index(0); yyi.uget() < yystateStack.numTops(); ++yyi) + if (yyi != yyk && yystateStack.topAt(yyi) != YY_NULLPTR) + { + const glr_state* yysplit = yystateStack.yysplitPoint; + glr_state* yyp = yystateStack.topAt(yyi); + while (yyp != yys && yyp != yysplit + && yyp->yyposn >= yyposn) + { + if (yyp->yylrState == yynewLRState + && yyp->pred() == yys) + { + yyaddDeferredAction (yyk, yyp, yys0, yyrule); + yystateStack.yytops.yymarkStackDeleted (yyk); + YYCDEBUG << "Merging stack " << yyk.get () + << " into stack " << yyi.get () << ".\n"; + return yyok; + } + yyp = yyp->pred(); + } + } + yystateStack.setTopAt(yyk, yys); + yyglrShiftDefer (yyk, yynewLRState, yyposn, yys0, yyrule); + } + return yyok; + } + + /** Shift stack #YYK of *YYSTACKP, to a new state corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with the (unresolved) + * semantic value of YYRHS under the action for YYRULE. */ + void + yyglrShiftDefer (state_set_index yyk, state_num yylrState, + size_t yyposn, glr_state* yyrhs, rule_num yyrule) + { + glr_state& yynewState = yystateStack.yynewGLRState ( + glr_state (yylrState, yyposn)); + yynewState.setPred (yystateStack.topAt (yyk)); + yystateStack.setTopAt (yyk, &yynewState); + + /* Invokes yyreserveStack. */ + yyaddDeferredAction (yyk, &yynewState, yyrhs, yyrule); + } + + /** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with (resolved) semantic + * value YYVAL_ARG and source location YYLOC_ARG. */ + void + yyglrShift (state_set_index yyk, state_num yylrState, + size_t yyposn, + const value_type& yyval_arg]b4_locations_if([, const location_type& yyloc_arg])[) + { + glr_state& yynewState = yystateStack.yynewGLRState ( + glr_state (yylrState, yyposn, yyval_arg]b4_locations_if([, yyloc_arg])[)); + yynewState.setPred (yystateStack.topAt(yyk)); + yystateStack.setTopAt (yyk, &yynewState); + yyreserveGlrStack (); + } + +#if ]b4_api_PREFIX[DEBUG + void + yypstack (state_set_index yyk) const + { + yystateStack.yypstates (yystateStack.topAt (yyk)); + } +#endif + + glr_state* topState(state_set_index i) { + return yystateStack.topAt(i); + } + + glr_state* firstTopState() { + return yystateStack.firstTop(); + } + + private: + + void popall_ () + { + /* If the stack is well-formed, pop the stack until it is empty, + destroying its entries as we go. But free the stack regardless + of whether it is well-formed. */ + for (state_set_index k = create_state_set_index(0); k.uget() < yystateStack.numTops(); k += 1) + if (yystateStack.topAt(k) != YY_NULLPTR) + { + while (yystateStack.topAt(k) != YY_NULLPTR) + { + glr_state* state = topState(k);]b4_locations_if([[ + yyerror_range[1].getState().yyloc = state->yyloc;]])[ + if (state->pred() != YY_NULLPTR) + state->destroy ("Cleanup: popping", yyparser); + yystateStack.setTopAt(k, state->pred()); + yystateStack.pop_back(); + } + break; + } + } + + /** Resolve the previous YYN states starting at and including state YYS + * on *YYSTACKP. If result != yyok, some states may have been left + * unresolved possibly with empty semantic option chains. Regardless + * of whether result = yyok, each state has been left with consistent + * data so that destroy can be invoked if necessary. */ + YYRESULTTAG + yyresolveStates (glr_state& yys, int yyn) + { + if (0 < yyn) + { + YYASSERT (yys.pred() != YY_NULLPTR); + YYCHK (yyresolveStates (*yys.pred(), yyn-1)); + if (! yys.yyresolved) + YYCHK (yyresolveValue (yys)); + } + return yyok; + } + + static void + yyuserMerge (int yyn, value_type& yy0, value_type& yy1) + { + YY_USE (yy0); + YY_USE (yy1); + + switch (yyn) + { +]b4_mergers[ + default: break; + } + } + + /** Resolve the ambiguity represented in state YYS in *YYSTACKP, + * perform the indicated actions, and set the semantic value of YYS. + * If result != yyok, the chain of semantic options in YYS has been + * cleared instead or it has been left unmodified except that + * redundant options may have been removed. Regardless of whether + * result = yyok, YYS has been left with consistent data so that + * destroy can be invoked if necessary. */ + YYRESULTTAG + yyresolveValue (glr_state& yys) + { + semantic_option* yybest = yys.firstVal(); + YYASSERT(yybest != YY_NULLPTR); + bool yymerge = false; + YYRESULTTAG yyflag;]b4_locations_if([ + location_type *yylocp = &yys.yyloc;])[ + + semantic_option* yypPrev = yybest; + for (semantic_option* yyp = yybest->next(); + yyp != YY_NULLPTR; ) + { + if (yybest->isIdenticalTo (*yyp)) + { + yybest->mergeWith (*yyp); + yypPrev->setNext(yyp->next()); + yyp = yypPrev->next(); + } + else + { + switch (yypreference (*yybest, *yyp)) + { + case 0:]b4_locations_if([[ + yyresolveLocations (yys, 1);]])[ + return yystateStack.yyreportAmbiguity (*yybest, *yyp, yyparser]b4_locations_if([, *yylocp])[); + break; + case 1: + yymerge = true; + break; + case 2: + break; + case 3: + yybest = yyp; + yymerge = false; + break; + default: + /* This cannot happen so it is not worth a YYASSERT (false), + but some compilers complain if the default case is + omitted. */ + break; + } + yypPrev = yyp; + yyp = yyp->next(); + } + } + + value_type val; + if (yymerge) + { + int yyprec = yydprec[yybest->yyrule]; + yyflag = yyresolveAction (*yybest, &val]b4_locations_if([, yylocp])[); + if (yyflag == yyok) + for (semantic_option* yyp = yybest->next(); + yyp != YY_NULLPTR; + yyp = yyp->next()) + { + if (yyprec == yydprec[yyp->yyrule]) + { + value_type yyval_other;]b4_locations_if([ + location_type yydummy;])[ + yyflag = yyresolveAction (*yyp, &yyval_other]b4_locations_if([, &yydummy])[); + if (yyflag != yyok) + { + yyparser.yy_destroy_ ("Cleanup: discarding incompletely merged value for", + yy_accessing_symbol (yys.yylrState), + this->yyla.value]b4_locations_if([, *yylocp])[); + break; + } + yyuserMerge (yymerger[yyp->yyrule], val, yyval_other);]b4_variant_if([[ + // FIXME: User destructors. + // Value type destructor. + ]b4_symbol_variant([[yy_accessing_symbol (yys.yylrState)]], [[yyval_other]], [[template destroy]])])[ + } + } + } + else + yyflag = yyresolveAction (*yybest, &val]b4_locations_if([, yylocp])[); + + if (yyflag == yyok) + { + yys.yyresolved = true; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN]b4_variant_if([[ + new (&yys.value ()) value_type (); + ]b4_symbol_variant([yy_accessing_symbol (yys.yylrState)], + [yys.value ()], [copy], [val])], [[ + new (&yys.value ()) value_type (val);]])[ + + YY_IGNORE_MAYBE_UNINITIALIZED_END + } + else + yys.setFirstVal(YY_NULLPTR); +]b4_variant_if([[ + // FIXME: User destructors. + // Value type destructor. + ]b4_symbol_variant([[yy_accessing_symbol (yys.yylrState)]], [[val]], [[template destroy]])])[ + return yyflag; + } + + /** Resolve the states for the RHS of YYOPT on *YYSTACKP, perform its + * user action, and return the semantic value and location in *YYVALP + * and *YYLOCP. Regardless of whether result = yyok, all RHS states + * have been destroyed (assuming the user action destroys all RHS + * semantic values if invoked). */ + YYRESULTTAG + yyresolveAction (semantic_option& yyopt, value_type* yyvalp]b4_locations_if([, location_type* yylocp])[) + { + glr_state* yyoptState = yyopt.state(); + YYASSERT(yyoptState != YY_NULLPTR); + int yynrhs = yyrhsLength (yyopt.yyrule); + YYRESULTTAG yyflag = yyresolveStates (*yyoptState, yynrhs); + if (yyflag != yyok) + { + for (glr_state *yys = yyoptState; yynrhs > 0; yys = yys->pred(), yynrhs -= 1) + yys->destroy ("Cleanup: popping", yyparser); + return yyflag; + } + + glr_stack_item yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + yyrhsVals[YYMAXRHS + YYMAXLEFT].getState().setPred(yyopt.state());]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].getState().yyloc = yyoptState->yyloc;]])[ + { + symbol_type yyla_current = std::move (this->yyla); + this->yyla = std::move (yyopt.yyla); + yyflag = yyuserAction (yyopt.yyrule, yynrhs, + yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + create_state_set_index (-1), + yyvalp]b4_locations_if([, yylocp])[); + this->yyla = std::move (yyla_current); + } + return yyflag; + }]b4_locations_if([[ + + /** Resolve the locations for each of the YYN1 states in *YYSTACKP, + * ending at YYS1. Has no effect on previously resolved states. + * The first semantic option of a state is always chosen. */ + void + yyresolveLocations (glr_state &yys1, int yyn1) + { + if (0 < yyn1) + { + yyresolveLocations (*yys1.pred(), yyn1 - 1); + if (!yys1.yyresolved) + { + glr_stack_item yyrhsloc[1 + YYMAXRHS]; + YYASSERT (yys1.firstVal() != YY_NULLPTR); + semantic_option& yyoption = *yys1.firstVal(); + const int yynrhs = yyrhsLength (yyoption.yyrule); + if (0 < yynrhs) + { + yyresolveLocations (*yyoption.state(), yynrhs); + const glr_state *yys = yyoption.state(); + for (int yyn = yynrhs; yyn > 0; yyn -= 1) + { + yyrhsloc[yyn].getState().yyloc = yys->yyloc; + yys = yys->pred(); + } + } + else + { + /* Both yyresolveAction and yyresolveLocations traverse the GSS + in reverse rightmost order. It is only necessary to invoke + yyresolveLocations on a subforest for which yyresolveAction + would have been invoked next had an ambiguity not been + detected. Thus the location of the previous state (but not + necessarily the previous state itself) is guaranteed to be + resolved already. */ + YY_IGNORE_NULL_DEREFERENCE_BEGIN + yyrhsloc[0].getState().yyloc = yyoption.state()->yyloc; + YY_IGNORE_NULL_DEREFERENCE_END + } + YYLLOC_DEFAULT ((yys1.yyloc), yyrhsloc, yynrhs); + } + } + }]])[ + + /** If yytoken is empty, fetch the next token. */ + void + yyget_token () + { +]b4_parse_param_use()dnl +[ if (this->yyla.empty ()) + { + YYCDEBUG << "Reading a token\n"; +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + {]b4_token_ctor_if([[ + symbol_type yylookahead (]b4_yylex[); + yyla.move (yylookahead);]], [[ + yyla.kind_ = yyparser.yytranslate_ (]b4_yylex[);]])[ + } +#if YY_EXCEPTIONS + catch (const parser_type::syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what () << '\n';]b4_locations_if([ + this->yyla.location = yyexc.location;])[ + yyparser.error (]b4_locations_if([this->yyla.location, ])[yyexc.what ()); + // Map errors caught in the scanner to the error token, so that error + // handling is started. + this->yyla.kind_ = ]b4_symbol(error, kind)[; + } + } +#endif // YY_EXCEPTIONS + if (this->yyla.kind () == ]b4_symbol(eof, kind)[) + YYCDEBUG << "Now at end of input.\n"; + else + YY_SYMBOL_PRINT ("Next token is", this->yyla.kind (), this->yyla.value, this->yyla.location); + } + + + /* Bison grammar-table manipulation. */ + + /** The action to take in YYSTATE on seeing YYTOKEN. + * Result R means + * R < 0: Reduce on rule -R. + * R = 0: Error. + * R > 0: Shift to state R. + * Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list + * of conflicting reductions. + */ + static int + yygetLRActions (state_num yystate, symbol_kind_type yytoken, const short*& yyconflicts) + { + int yyindex = yypact[yystate] + yytoken; + if (yytoken == ]b4_symbol(error, kind)[) + { + // This is the error token. + yyconflicts = yyconfl; + return 0; + } + else if (yy_is_defaulted_state (yystate) + || yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) + { + yyconflicts = yyconfl; + return -yydefact[yystate]; + } + else if (! yytable_value_is_error (yytable[yyindex])) + { + yyconflicts = yyconfl + yyconflp[yyindex]; + return yytable[yyindex]; + } + else + { + yyconflicts = yyconfl + yyconflp[yyindex]; + return 0; + } + } + + /** Compute post-reduction state. + * \param yystate the current state + * \param yysym the nonterminal to push on the stack + */ + static state_num + yyLRgotoState (state_num yystate, symbol_kind_type yysym) + { + const int yyr = yypgoto[yysym - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) + return yytable[yyr]; + else + return yydefgoto[yysym - YYNTOKENS]; + } + + static bool + yypact_value_is_default (state_num yystate) + { + return ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf], [YYPACT_NINF])[; + } + + static bool + yytable_value_is_error (int yytable_value YY_ATTRIBUTE_UNUSED) + { + return ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf], [YYTABLE_NINF])[; + } + + static bool + yy_is_shift_action (int yyaction) YY_NOEXCEPT + { + return 0 < yyaction; + } + + static bool + yy_is_error_action (int yyaction) YY_NOEXCEPT + { + return yyaction == 0; + } + + /** Whether LR state YYSTATE has only a default reduction + * (regardless of token). */ + static bool + yy_is_defaulted_state (state_num yystate) + { + return yypact_value_is_default (yypact[yystate]); + } + + /** The default reduction for YYSTATE, assuming it has one. */ + static rule_num + yy_default_action (state_num yystate) + { + return yydefact[yystate]; + } + + /* GLRStacks */ + + /** Y0 and Y1 represent two possible actions to take in a given + * parsing state; return 0 if no combination is possible, + * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ + static int + yypreference (const semantic_option& y0, const semantic_option& y1) + { + const rule_num r0 = y0.yyrule, r1 = y1.yyrule; + const int p0 = yydprec[r0], p1 = yydprec[r1]; + + if (p0 == p1) + { + if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) + return 0; + else + return 1; + } + else if (p0 == 0 || p1 == 0) + return 0; + else if (p0 < p1) + return 3; + else if (p1 < p0) + return 2; + else + return 0; + } + +]b4_parse_param_vars[ + }; // class ]b4_parser_class[::glr_stack +} // namespace ]b4_namespace_ref[ + + +#if ]b4_api_PREFIX[DEBUG +namespace +{ + void + yypstack (const glr_stack& yystack, size_t yyk) + { + yystack.yypstack (create_state_set_index (static_cast (yyk))); + } + + void + yypdumpstack (const glr_stack& yystack) + { + yystack.yypdumpstack (); + } +} +#endif + +]b4_namespace_open[ + /// Build a parser object. + ]b4_parser_class::b4_parser_class[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ + :])[ +#if ]b4_api_PREFIX[DEBUG + ]m4_ifset([b4_parse_param], [ ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ +#endif]b4_parse_param_cons[ + {} + + ]b4_parser_class::~b4_parser_class[ () + {} + + ]b4_parser_class[::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW + {} + + int + ]b4_parser_class[::operator() () + { + return parse (); + } + + int + ]b4_parser_class[::parse () + { + glr_stack yystack(YYINITDEPTH, *this]b4_user_args[); + return yystack.parse (); + } + +]b4_parse_error_bmatch([custom\|detailed], +[[ const char * + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + static const char *const yy_sname[] = + { + ]b4_symbol_names[ + };]b4_has_translations_if([[ + /* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is + internationalizable. */ + static ]b4_int_type_for([b4_translatable])[ yytranslatable[] = + { + ]b4_translatable[ + }; + return (yysymbol < YYNTOKENS && yytranslatable[yysymbol] + ? _(yy_sname[yysymbol]) + : yy_sname[yysymbol]);]], [[ + return yy_sname[yysymbol];]])[ + } +]], +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + const char * + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + return yytname_[yysymbol]; + } +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + std::string + ]b4_parser_class[::yytnamerr_ (const char *yystr) + { + if (*yystr == '"') + { + std::string yyr; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + else + goto append; + + append: + default: + yyr += *yyp; + break; + + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } + + std::string + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + return yytnamerr_ (yytname_[yysymbol]); + } +]])[ + +]b4_parse_error_bmatch([simple\|verbose], +[[#if ]b4_api_PREFIX[DEBUG]b4_tname_if([[ || 1]])[ + // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + // First, the terminals, then, starting at \a YYNTOKENS, nonterminals. + const char* + const ]b4_parser_class[::yytname_[] = + { + ]b4_tname[ + }; +#endif +]])[ + +]b4_parse_error_bmatch([custom\|detailed\|verbose], [[ + // ]b4_parser_class[::context. + ]b4_parser_class[::context::context (glr_stack& yystack, const symbol_type& yyla) + : yystack_ (yystack) + , yyla_ (yyla) + {} + + int + ]b4_parser_class[::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const + { + // Actual number of expected tokens + int yycount = 0; + const int yyn = yypact[yystack_.firstTopState()->yylrState]; + if (!yystack_.yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for this + state because they are default actions. */ + const int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + const int yychecklim = YYLAST - yyn + 1; + const int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[ + && !yystack_.yytable_value_is_error (yytable[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx); + } + } + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = ]b4_symbol(empty, kind)[; + return yycount; + } + +]])[ + +]b4_parse_error_bmatch([detailed\|verbose], [[ + int + ]b4_parser_class[::yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const + { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yyla) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yyla. (However, yyla is currently not documented for users.) + */ + + if (!yyctx.lookahead ().empty ()) + { + if (yyarg) + yyarg[0] = yyctx.token (); + int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); + return yyn + 1; + } + return 0; + } + + // Generate an error message. + std::string + ]b4_parser_class[::yysyntax_error_ (const context& yyctx) const + { + // Its maximum. + enum { YYARGS_MAX = 5 }; + // Arguments of yyformat. + symbol_kind_type yyarg[YYARGS_MAX]; + int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); + + char const* yyformat = YY_NULLPTR; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: // Avoid compiler warnings. + YYCASE_ (0, YY_("syntax error")); + YYCASE_ (1, YY_("syntax error, unexpected %s")); + YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + std::string yyres; + // Argument number. + std::ptrdiff_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += symbol_name (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres; + }]])[ + + void + ]b4_parser_class[::yy_destroy_ (const char* yymsg, symbol_kind_type yykind, + value_type& yyval]b4_locations_if([[, + location_type& yyloc]])[) + { + YY_USE (yyval);]b4_locations_if([[ + YY_USE (yyloc);]])[ + if (!yymsg) + yymsg = "Deleting"; + ]b4_parser_class[& yyparser = *this; + YY_USE (yyparser); + YY_SYMBOL_PRINT (yymsg, yykind, yyval, yyloc); + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + ]m4_do([m4_pushdef([b4_symbol_action], m4_defn([b4_symbol_action_for_yyval]))], + [b4_symbol_actions([destructor])], + [m4_popdef([b4_symbol_action])])[ + YY_IGNORE_MAYBE_UNINITIALIZED_END + } + +#if ]b4_api_PREFIX[DEBUG + /*--------------------. + | Print this symbol. | + `--------------------*/ + + void + ]b4_parser_class[::yy_symbol_value_print_ (symbol_kind_type yykind, + const value_type& yyval]b4_locations_if([[, + const location_type& yyloc]])[) const + {]b4_locations_if([[ + YY_USE (yyloc);]])[ + YY_USE (yyval); + std::ostream& yyo = debug_stream (); + YY_USE (yyo); + ]m4_do([m4_pushdef([b4_symbol_action], m4_defn([b4_symbol_action_for_yyval]))], + [b4_symbol_actions([printer])], + [m4_popdef([b4_symbol_action])])[ + } + + void + ]b4_parser_class[::yy_symbol_print_ (symbol_kind_type yykind, + const value_type& yyval]b4_locations_if([[, + const location_type& yyloc]])[) const + { + *yycdebug_ << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << symbol_name (yykind) << " ("]b4_locations_if([[ + << yyloc << ": "]])[; + yy_symbol_value_print_ (yykind, yyval]b4_locations_if([[, yyloc]])[); + *yycdebug_ << ')'; + } + + std::ostream& + ]b4_parser_class[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class[::debug_level_type + ]b4_parser_class[::debug_level () const + { + return yydebug; + } + + void + ]b4_parser_class[::set_debug_level (debug_level_type l) + { + // Actually, it is yydebug which is really used. + yydebug = l; + } +#endif // ]b4_api_PREFIX[DEBUG + +]b4_token_ctor_if([], [b4_yytranslate_define([cc])])[ + +]b4_token_ctor_if([], [[ + /*---------. + | symbol. | + `---------*/ +]b4_public_types_define([cc])])[ +]b4_namespace_close[]dnl +b4_epilogue[]dnl +b4_output_end diff --git a/Engine/bin/bison-flex/data/skeletons/java-skel.m4 b/Engine/bin/bison-flex/data/skeletons/java-skel.m4 new file mode 100644 index 000000000..11cbc4999 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/java-skel.m4 @@ -0,0 +1,27 @@ + -*- Autoconf -*- + +# Java skeleton dispatching for Bison. + +# Copyright (C) 2007, 2009-2015, 2018-2021 Free Software Foundation, +# Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +b4_glr_if( [b4_complain([%%glr-parser not supported for Java])]) +b4_nondeterministic_if([b4_complain([%%nondeterministic-parser not supported for Java])]) + +m4_define_default([b4_used_skeleton], [b4_skeletonsdir/[lalr1.java]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/Engine/bin/bison-flex/data/skeletons/java.m4 b/Engine/bin/bison-flex/data/skeletons/java.m4 new file mode 100644 index 000000000..8b0828b0b --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/java.m4 @@ -0,0 +1,502 @@ + -*- Autoconf -*- + +# Java language support for Bison + +# Copyright (C) 2007-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +m4_include(b4_skeletonsdir/[c-like.m4]) + + +# b4_list2(LIST1, LIST2) +# ---------------------- +# Join two lists with a comma if necessary. +m4_define([b4_list2], + [$1[]m4_ifval(m4_quote($1), [m4_ifval(m4_quote($2), [[, ]])])[]$2]) + + +# b4_percent_define_get3(DEF, PRE, POST, NOT) +# ------------------------------------------- +# Expand to the value of DEF surrounded by PRE and POST if it's %define'ed, +# otherwise NOT. +m4_define([b4_percent_define_get3], + [m4_ifval(m4_quote(b4_percent_define_get([$1])), + [$2[]b4_percent_define_get([$1])[]$3], [$4])]) + + + +# b4_flag_value(BOOLEAN-FLAG) +# --------------------------- +m4_define([b4_flag_value], [b4_flag_if([$1], [true], [false])]) + + +# b4_parser_class_declaration +# --------------------------- +# The declaration of the parser class ("class YYParser"), with all its +# qualifiers/annotations. +b4_percent_define_default([[api.parser.abstract]], [[false]]) +b4_percent_define_default([[api.parser.final]], [[false]]) +b4_percent_define_default([[api.parser.public]], [[false]]) +b4_percent_define_default([[api.parser.strictfp]], [[false]]) + +m4_define([b4_parser_class_declaration], +[b4_percent_define_get3([api.parser.annotations], [], [ ])dnl +b4_percent_define_flag_if([api.parser.public], [public ])dnl +b4_percent_define_flag_if([api.parser.abstract], [abstract ])dnl +b4_percent_define_flag_if([api.parser.final], [final ])dnl +b4_percent_define_flag_if([api.parser.strictfp], [strictfp ])dnl +[class ]b4_parser_class[]dnl +b4_percent_define_get3([api.parser.extends], [ extends ])dnl +b4_percent_define_get3([api.parser.implements], [ implements ])]) + + +# b4_lexer_if(TRUE, FALSE) +# ------------------------ +m4_define([b4_lexer_if], +[b4_percent_code_ifdef([[lexer]], [$1], [$2])]) + + +# b4_identification +# ----------------- +m4_define([b4_identification], +[[ /** Version number for the Bison executable that generated this parser. */ + public static final String bisonVersion = "]b4_version_string["; + + /** Name of the skeleton that generated this parser. */ + public static final String bisonSkeleton = ]b4_skeleton[; +]]) + + +## ------------ ## +## Data types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# MIN to MAX (included). +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [-128], [127]), [1], [byte], + b4_ints_in($@, [-32768], [32767]), [1], [short], + [int])]) + +# b4_int_type_for(NAME) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# 'NAME_min' to 'NAME_max' (included). +m4_define([b4_int_type_for], +[b4_int_type($1_min, $1_max)]) + +# b4_null +# ------- +m4_define([b4_null], [null]) + + +# b4_typed_parser_table_define(TYPE, NAME, DATA, COMMENT) +# ------------------------------------------------------- +# We use intermediate functions (e.g., yypact_init) to work around the +# 64KB limit for JVM methods. See +# https://lists.gnu.org/r/help-bison/2008-11/msg00004.html. +m4_define([b4_typed_parser_table_define], +[m4_ifval([$4], [b4_comment([$4]) + ])dnl +[private static final ]$1[[] yy$2_ = yy$2_init(); + private static final ]$1[[] yy$2_init() + { + return new ]$1[[] + { + ]$3[ + }; + }]]) + + +# b4_integral_parser_table_define(NAME, DATA, COMMENT) +#----------------------------------------------------- +m4_define([b4_integral_parser_table_define], +[b4_typed_parser_table_define([b4_int_type_for([$2])], [$1], [$2], [$3])]) + + +## ------------- ## +## Token kinds. ## +## ------------- ## + + +# b4_token_enum(TOKEN-NUM) +# ------------------------ +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[b4_token_visible_if([$1], + [m4_format([[ /** Token %s, to be returned by the scanner. */ + static final int %s = %s%s; +]], + b4_symbol([$1], [tag]), + b4_symbol([$1], [id]), + b4_symbol([$1], b4_api_token_raw_if([[number]], [[code]])))])]) + + +# b4_token_enums +# -------------- +# Output the definition of the tokens (if there are) as enums. +m4_define([b4_token_enums], +[b4_any_token_visible_if([ /* Token kinds. */ +b4_symbol_foreach([b4_token_enum])])]) + + + +## -------------- ## +## Symbol kinds. ## +## -------------- ## + + +# b4_symbol_kind(NUM) +# ------------------- +m4_define([b4_symbol_kind], +[SymbolKind.b4_symbol_kind_base($@)]) + + +# b4_symbol_enum(SYMBOL-NUM) +# -------------------------- +# Output the definition of this symbol as an enum. +m4_define([b4_symbol_enum], +[m4_format([ %-30s %s], + m4_format([[%s(%s)%s]], + b4_symbol([$1], [kind_base]), + [$1], + m4_if([$1], b4_last_symbol, [[;]], [[,]])), + [b4_symbol_tag_comment([$1])])]) + + +# b4_declare_symbol_enum +# ---------------------- +# The definition of the symbol internal numbers as an enum. +m4_define([b4_declare_symbol_enum], +[[ public enum SymbolKind + { +]b4_symbol_foreach([b4_symbol_enum])[ + + private final int yycode_; + + SymbolKind (int n) { + this.yycode_ = n; + } + + private static final SymbolKind[] values_ = { + ]m4_map_args_sep([b4_symbol_kind(], [)], [, + ], b4_symbol_numbers)[ + }; + + static final SymbolKind get(int code) { + return values_[code]; + } + + public final int getCode() { + return this.yycode_; + } + +]b4_parse_error_bmatch( +[simple\|verbose], +[[ /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + private static String yytnamerr_(String yystr) + { + if (yystr.charAt (0) == '"') + { + StringBuffer yyr = new StringBuffer(); + strip_quotes: for (int i = 1; i < yystr.length(); i++) + switch (yystr.charAt(i)) + { + case '\'': + case ',': + break strip_quotes; + + case '\\': + if (yystr.charAt(++i) != '\\') + break strip_quotes; + /* Fall through. */ + default: + yyr.append(yystr.charAt(i)); + break; + + case '"': + return yyr.toString(); + } + } + return yystr; + } + + /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at \a YYNTOKENS_, nonterminals. */ + ]b4_typed_parser_table_define([String], [tname], [b4_tname])[ + + /* The user-facing name of this symbol. */ + public final String getName() { + return yytnamerr_(yytname_[yycode_]); + } +]], +[custom\|detailed], +[[ /* YYNAMES_[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at \a YYNTOKENS_, nonterminals. */ + ]b4_typed_parser_table_define([String], [names], [b4_symbol_names])[ + + /* The user-facing name of this symbol. */ + public final String getName() { + return yynames_[yycode_]; + }]])[ + }; +]])]) + + + +# b4_case(ID, CODE, [COMMENTS]) +# ----------------------------- +# We need to fool Java's stupid unreachable code detection. +m4_define([b4_case], +[ case $1:m4_ifval([$3], [ b4_comment([$3])]) + if (yyn == $1) + $2; + break; +]) + + +# b4_predicate_case(LABEL, CONDITIONS) +# ------------------------------------ +m4_define([b4_predicate_case], +[ case $1: + if (! ($2)) YYERROR; + break; +]) + + +## -------- ## +## Checks. ## +## -------- ## + +b4_percent_define_check_kind([[api.value.type]], [code], [deprecated]) + +b4_percent_define_check_kind([[annotations]], [code], [deprecated]) +b4_percent_define_check_kind([[extends]], [code], [deprecated]) +b4_percent_define_check_kind([[implements]], [code], [deprecated]) +b4_percent_define_check_kind([[init_throws]], [code], [deprecated]) +b4_percent_define_check_kind([[lex_throws]], [code], [deprecated]) +b4_percent_define_check_kind([[api.parser.class]], [code], [deprecated]) +b4_percent_define_check_kind([[throws]], [code], [deprecated]) + + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +m4_define([b4_yystype], [b4_percent_define_get([[api.value.type]])]) +b4_percent_define_default([[api.value.type]], [[Object]]) +b4_percent_define_default([[api.symbol.prefix]], [[S_]]) + +# b4_api_prefix, b4_api_PREFIX +# ---------------------------- +# Corresponds to %define api.prefix +b4_percent_define_default([[api.prefix]], [[YY]]) +m4_define([b4_api_prefix], +[b4_percent_define_get([[api.prefix]])]) +m4_define([b4_api_PREFIX], +[m4_toupper(b4_api_prefix)]) + +# b4_prefix +# --------- +# If the %name-prefix is not given, it is api.prefix. +m4_define_default([b4_prefix], [b4_api_prefix]) + +b4_percent_define_default([[api.parser.class]], [b4_prefix[]Parser]) +m4_define([b4_parser_class], [b4_percent_define_get([[api.parser.class]])]) + +b4_percent_define_default([[lex_throws]], [[java.io.IOException]]) +m4_define([b4_lex_throws], [b4_percent_define_get([[lex_throws]])]) + +b4_percent_define_default([[throws]], []) +m4_define([b4_throws], [b4_percent_define_get([[throws]])]) + +b4_percent_define_default([[init_throws]], []) +m4_define([b4_init_throws], [b4_percent_define_get([[init_throws]])]) + +b4_percent_define_default([[api.location.type]], [Location]) +m4_define([b4_location_type], [b4_percent_define_get([[api.location.type]])]) + +b4_percent_define_default([[api.position.type]], [Position]) +m4_define([b4_position_type], [b4_percent_define_get([[api.position.type]])]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_symbol_translate(STRING) +# --------------------------- +# Used by "bison" in the array of symbol names to mark those that +# require translation. +m4_define([b4_symbol_translate], +[[i18n($1)]]) + + +# b4_trans(STRING) +# ---------------- +# Translate a string if i18n is enabled. Avoid collision with b4_translate. +m4_define([b4_trans], +[b4_has_translations_if([i18n($1)], [$1])]) + + + +# b4_symbol_value(VAL, [SYMBOL-NUM], [TYPE-TAG]) +# ---------------------------------------------- +# See README. +m4_define([b4_symbol_value], +[m4_ifval([$3], + [(($3)($1))], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [((b4_symbol([$2], [type]))($1))], + [$1])], + [$1])])]) + + +# b4_lhs_value([SYMBOL-NUM], [TYPE]) +# ---------------------------------- +# See README. +m4_define([b4_lhs_value], [yyval]) + + +# b4_rhs_data(RULE-LENGTH, POS) +# ----------------------------- +# See README. +m4_define([b4_rhs_data], +[yystack.valueAt (b4_subtract($@))]) + +# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) +# -------------------------------------------------- +# See README. +# +# In this simple implementation, %token and %type have class names +# between the angle brackets. +m4_define([b4_rhs_value], +[b4_symbol_value([b4_rhs_data([$1], [$2])], [$3], [$4])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, POS) +# --------------------------------- +# Expansion of @POS, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[yystack.locationAt (b4_subtract($@))]) + + +# b4_lex_param +# b4_parse_param +# -------------- +# If defined, b4_lex_param arrives double quoted, but below we prefer +# it to be single quoted. Same for b4_parse_param. + +# TODO: should be in bison.m4 +m4_define_default([b4_lex_param], [[]]) +m4_define([b4_lex_param], b4_lex_param) +m4_define([b4_parse_param], b4_parse_param) + +# b4_lex_param_decl +# ----------------- +# Extra formal arguments of the constructor. +m4_define([b4_lex_param_decl], +[m4_ifset([b4_lex_param], + [b4_remove_comma([$1], + b4_param_decls(b4_lex_param))], + [$1])]) + +m4_define([b4_param_decls], + [m4_map([b4_param_decl], [$@])]) +m4_define([b4_param_decl], [, $1]) + +m4_define([b4_remove_comma], [m4_ifval(m4_quote($1), [$1, ], [])m4_shift2($@)]) + + + +# b4_parse_param_decl +# ------------------- +# Extra formal arguments of the constructor. +m4_define([b4_parse_param_decl], +[m4_ifset([b4_parse_param], + [b4_remove_comma([$1], + b4_param_decls(b4_parse_param))], + [$1])]) + + + +# b4_lex_param_call +# ----------------- +# Delegating the lexer parameters to the lexer constructor. +m4_define([b4_lex_param_call], + [m4_ifset([b4_lex_param], + [b4_remove_comma([$1], + b4_param_calls(b4_lex_param))], + [$1])]) +m4_define([b4_param_calls], + [m4_map([b4_param_call], [$@])]) +m4_define([b4_param_call], [, $2]) + + + +# b4_parse_param_cons +# ------------------- +# Extra initialisations of the constructor. +m4_define([b4_parse_param_cons], + [m4_ifset([b4_parse_param], + [b4_constructor_calls(b4_parse_param)])]) + +m4_define([b4_constructor_calls], + [m4_map([b4_constructor_call], [$@])]) +m4_define([b4_constructor_call], + [this.$2 = $2; + ]) + + + +# b4_parse_param_vars +# ------------------- +# Extra instance variables. +m4_define([b4_parse_param_vars], + [m4_ifset([b4_parse_param], + [ + /* User arguments. */ +b4_var_decls(b4_parse_param)])]) + +m4_define([b4_var_decls], + [m4_map_sep([b4_var_decl], [ +], [$@])]) +m4_define([b4_var_decl], + [ protected final $1;]) + + + +# b4_maybe_throws(THROWS) +# ----------------------- +# Expand to either an empty string or "throws THROWS". +m4_define([b4_maybe_throws], + [m4_ifval($1, [ throws $1])]) diff --git a/Engine/bin/bison-flex/data/skeletons/lalr1.cc b/Engine/bin/bison-flex/data/skeletons/lalr1.cc new file mode 100644 index 000000000..7cb69d3db --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/lalr1.cc @@ -0,0 +1,1633 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +m4_include(b4_skeletonsdir/[c++.m4]) + +# api.value.type=variant is valid. +m4_define([b4_value_type_setup_variant]) + +# parse.lac +b4_percent_define_default([[parse.lac]], [[none]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]]) +b4_define_flag_if([lac]) +m4_define([b4_lac_flag], + [m4_if(b4_percent_define_get([[parse.lac]]), + [none], [[0]], [[1]])]) + + +# b4_tname_if(TNAME-NEEDED, TNAME-NOT-NEEDED) +# ------------------------------------------- +m4_define([b4_tname_if], +[m4_case(b4_percent_define_get([[parse.error]]), + [verbose], [$1], + [b4_token_table_if([$1], + [$2])])]) + + +# b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT) +# -------------------------------------------------------------- +# Declare "parser::yy_" whose contents is CONTENT. +m4_define([b4_integral_parser_table_declare], +[m4_ifval([$3], [b4_comment([$3], [ ]) +])dnl + static const b4_int_type_for([$2]) yy$1_[[]];dnl +]) + +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) +# ------------------------------------------------------------- +# Define "parser::yy_" whose contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[ const b4_int_type_for([$2]) + b4_parser_class::yy$1_[[]] = + { + $2 + };dnl +]) + + +# b4_symbol_kind(NUM) +# ------------------- +m4_define([b4_symbol_kind], +[symbol_kind::b4_symbol_kind_base($@)]) + + +# b4_symbol_value_template(VAL, SYMBOL-NUM, [TYPE]) +# ------------------------------------------------- +# Same as b4_symbol_value, but used in a template method. It makes +# a difference when using variants. Note that b4_value_type_setup_union +# overrides b4_symbol_value, so we must override it again. +m4_copy([b4_symbol_value], [b4_symbol_value_template]) +m4_append([b4_value_type_setup_union], +[m4_copy_force([b4_symbol_value_union], [b4_symbol_value_template])]) + +# b4_lhs_value(SYMBOL-NUM, [TYPE]) +# -------------------------------- +# See README. +m4_define([b4_lhs_value], +[b4_symbol_value([yylhs.value], [$1], [$2])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[yylhs.location]) + + +# b4_rhs_data(RULE-LENGTH, POS) +# ----------------------------- +# See README. +m4_define([b4_rhs_data], +[yystack_@{b4_subtract($@)@}]) + + +# b4_rhs_state(RULE-LENGTH, POS) +# ------------------------------ +# The state corresponding to the symbol #POS, where the current +# rule has RULE-LENGTH symbols on RHS. +m4_define([b4_rhs_state], +[b4_rhs_data([$1], [$2]).state]) + + +# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) +# -------------------------------------------------- +# See README. +m4_define([_b4_rhs_value], +[b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3], [$4])]) + +m4_define([b4_rhs_value], +[b4_percent_define_ifdef([api.value.automove], + [YY_MOVE (_b4_rhs_value($@))], + [_b4_rhs_value($@)])]) + + +# b4_rhs_location(RULE-LENGTH, POS) +# --------------------------------- +# Expansion of @POS, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[b4_rhs_data([$1], [$2]).location]) + + +# b4_symbol_action(SYMBOL-NUM, KIND) +# ---------------------------------- +# Run the action KIND (destructor or printer) for SYMBOL-NUM. +# Same as in C, but using references instead of pointers. +m4_define([b4_symbol_action], +[b4_symbol_if([$1], [has_$2], +[m4_pushdef([b4_symbol_value], m4_defn([b4_symbol_value_template]))[]dnl +b4_dollar_pushdef([yysym.value], + [$1], + [], + [yysym.location])dnl + _b4_symbol_case([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], [b4_symbol([$1], [$2_file])])dnl + b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@])dnl + break; + +m4_popdef([b4_symbol_value])[]dnl +b4_dollar_popdef[]dnl +])]) + + +# b4_yylex +# -------- +# Call yylex. +m4_define([b4_yylex], +[b4_token_ctor_if( +[b4_function_call([yylex], + [symbol_type], m4_ifdef([b4_lex_param], b4_lex_param))], +[b4_function_call([yylex], [int], + [[value_type *], [&yyla.value]][]dnl +b4_locations_if([, [[location_type *], [&yyla.location]]])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param))])]) + + +m4_pushdef([b4_copyright_years], + [2002-2015, 2018-2021]) + +m4_define([b4_parser_class], + [b4_percent_define_get([[api.parser.class]])]) + +b4_bison_locations_if([# Backward compatibility. + m4_define([b4_location_constructors]) + m4_include(b4_skeletonsdir/[location.cc])]) +m4_include(b4_skeletonsdir/[stack.hh]) +b4_variant_if([m4_include(b4_skeletonsdir/[variant.hh])]) + + +# b4_shared_declarations(hh|cc) +# ----------------------------- +# Declaration that might either go into the header (if --header, $1 = hh) +# or in the implementation file. +m4_define([b4_shared_declarations], +[b4_percent_code_get([[requires]])[ +]b4_parse_assert_if([# include ])[ +# include // std::abort +# include +# include +# include +# include + +]b4_cxx_portability[ +]m4_ifdef([b4_location_include], + [[# include ]b4_location_include])[ +]b4_variant_if([b4_variant_includes])[ + +]b4_attribute_define[ +]b4_cast_define[ +]b4_null_define[ + +]b4_YYDEBUG_define[ + +]b4_namespace_open[ + +]b4_bison_locations_if([m4_ifndef([b4_location_file], + [b4_location_define])])[ + + /// A Bison parser. + class ]b4_parser_class[ + { + public: +]b4_public_types_declare[ +]b4_symbol_type_define[ + /// Build a parser object. + ]b4_parser_class[ (]b4_parse_param_decl[); + virtual ~]b4_parser_class[ (); + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + ]b4_parser_class[ (const ]b4_parser_class[&) = delete; + /// Non copyable. + ]b4_parser_class[& operator= (const ]b4_parser_class[&) = delete; +#endif + + /// Parse. An alias for parse (). + /// \returns 0 iff parsing succeeded. + int operator() (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + +#if ]b4_api_PREFIX[DEBUG + /// The current debugging stream. + std::ostream& debug_stream () const YY_ATTRIBUTE_PURE; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + typedef int debug_level_type; + /// The current debugging level. + debug_level_type debug_level () const YY_ATTRIBUTE_PURE; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); +#endif + + /// Report a syntax error.]b4_locations_if([[ + /// \param loc where the syntax error is found.]])[ + /// \param msg a description of the syntax error. + virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); + + /// Report a syntax error. + void error (const syntax_error& err); + +]b4_parse_error_bmatch( +[custom\|detailed], +[[ /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static const char *symbol_name (symbol_kind_type yysymbol);]], +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static const char *symbol_name (symbol_kind_type yysymbol); +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static std::string symbol_name (symbol_kind_type yysymbol);]])[ + +]b4_token_constructor_define[ +]b4_parse_error_bmatch([custom\|detailed\|verbose], [[ + class context + { + public: + context (const ]b4_parser_class[& yyparser, const symbol_type& yyla); + const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; } + symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); }]b4_locations_if([[ + const location_type& location () const YY_NOEXCEPT { return yyla_.location; } +]])[ + /// Put in YYARG at most YYARGN of the expected tokens, and return the + /// number of tokens stored in YYARG. If YYARG is null, return the + /// number of expected tokens (guaranteed to be less than YYNTOKENS). + int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; + + private: + const ]b4_parser_class[& yyparser_; + const symbol_type& yyla_; + }; +]])[ + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + ]b4_parser_class[ (const ]b4_parser_class[&); + /// Non copyable. + ]b4_parser_class[& operator= (const ]b4_parser_class[&); +#endif +]b4_lac_if([[ + /// Check the lookahead yytoken. + /// \returns true iff the token will be eventually shifted. + bool yy_lac_check_ (symbol_kind_type yytoken) const; + /// Establish the initial context if no initial context currently exists. + /// \returns true iff the token will be eventually shifted. + bool yy_lac_establish_ (symbol_kind_type yytoken); + /// Discard any previous initial lookahead context because of event. + /// \param event the event which caused the lookahead to be discarded. + /// Only used for debbuging output. + void yy_lac_discard_ (const char* event);]])[ + + /// Stored state numbers (used for stacks). + typedef ]b4_int_type(0, m4_eval(b4_states_number - 1))[ state_type; +]b4_parse_error_bmatch( +[custom], [[ + /// Report a syntax error + /// \param yyctx the context in which the error occurred. + void report_syntax_error (const context& yyctx) const;]], +[detailed\|verbose], [[ + /// The arguments of the error message. + int yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const; + + /// Generate an error message. + /// \param yyctx the context in which the error occurred. + virtual std::string yysyntax_error_ (const context& yyctx) const;]])[ + /// Compute post-reduction state. + /// \param yystate the current state + /// \param yysym the nonterminal to push on the stack + static state_type yy_lr_goto_state_ (state_type yystate, int yysym); + + /// Whether the given \c yypact_ value indicates a defaulted state. + /// \param yyvalue the value to check + static bool yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT; + + /// Whether the given \c yytable_ value indicates a syntax error. + /// \param yyvalue the value to check + static bool yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT; + + static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_; + static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_; + + /// Convert a scanner token kind \a t to a symbol kind. + /// In theory \a t should be a token_kind_type, but character literals + /// are valid, yet not members of the token_kind_type enum. + static symbol_kind_type yytranslate_ (int t) YY_NOEXCEPT; + +]b4_parse_error_bmatch( +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + /// For a symbol, its name in clear. + static const char* const yytname_[]; +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /// Convert the symbol name \a n to a form suitable for a diagnostic. + static std::string yytnamerr_ (const char *yystr); + + /// For a symbol, its name in clear. + static const char* const yytname_[]; +]])[ + + // Tables. +]b4_parser_tables_declare[ + +#if ]b4_api_PREFIX[DEBUG +]b4_integral_parser_table_declare([rline], [b4_rline], + [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ + /// Report on the debug stream that the rule \a r is going to be reduced. + virtual void yy_reduce_print_ (int r) const; + /// Print the state stack on the debug stream. + virtual void yy_stack_print_ () const; + + /// Debugging level. + int yydebug_; + /// Debug stream. + std::ostream* yycdebug_; + + /// \brief Display a symbol kind, value and location. + /// \param yyo The output stream. + /// \param yysym The symbol. + template + void yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const; +#endif + + /// \brief Reclaim the memory associated to a symbol. + /// \param yymsg Why this token is reclaimed. + /// If null, print nothing. + /// \param yysym The symbol. + template + void yy_destroy_ (const char* yymsg, basic_symbol& yysym) const; + + private: + /// Type access provider for state based symbols. + struct by_state + { + /// Default constructor. + by_state () YY_NOEXCEPT; + + /// The symbol kind as needed by the constructor. + typedef state_type kind_type; + + /// Constructor. + by_state (kind_type s) YY_NOEXCEPT; + + /// Copy constructor. + by_state (const by_state& that) YY_NOEXCEPT; + + /// Record that this symbol is empty. + void clear () YY_NOEXCEPT; + + /// Steal the symbol kind from \a that. + void move (by_state& that); + + /// The symbol kind (corresponding to \a state). + /// \a ]b4_symbol(empty, kind)[ when empty. + symbol_kind_type kind () const YY_NOEXCEPT; + + /// The state number used to denote an empty symbol. + /// We use the initial state, as it does not have a value. + enum { empty_state = 0 }; + + /// The state. + /// \a empty when empty. + state_type state; + }; + + /// "Internal" symbol: element of the stack. + struct stack_symbol_type : basic_symbol + { + /// Superclass. + typedef basic_symbol super_type; + /// Construct an empty symbol. + stack_symbol_type (); + /// Move or copy construction. + stack_symbol_type (YY_RVREF (stack_symbol_type) that); + /// Steal the contents from \a sym to build this. + stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym); +#if YY_CPLUSPLUS < 201103L + /// Assignment, needed by push_back by some old implementations. + /// Moves the contents of that. + stack_symbol_type& operator= (stack_symbol_type& that); + + /// Assignment, needed by push_back by other implementations. + /// Needed by some other old implementations. + stack_symbol_type& operator= (const stack_symbol_type& that); +#endif + }; + +]b4_stack_define[ + + /// Stack type. + typedef stack stack_type; + + /// The stack. + stack_type yystack_;]b4_lac_if([[ + /// The stack for LAC. + /// Logically, the yy_lac_stack's lifetime is confined to the function + /// yy_lac_check_. We just store it as a member of this class to hold + /// on to the memory and to avoid frequent reallocations. + /// Since yy_lac_check_ is const, this member must be mutable. + mutable std::vector yylac_stack_; + /// Whether an initial LAC context was established. + bool yy_lac_established_; +]])[ + + /// Push a new state on the stack. + /// \param m a debug message to display + /// if null, no trace is output. + /// \param sym the symbol + /// \warning the contents of \a s.value is stolen. + void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym); + + /// Push a new look ahead token on the state on the stack. + /// \param m a debug message to display + /// if null, no trace is output. + /// \param s the state + /// \param sym the symbol (for its value and location). + /// \warning the contents of \a sym.value is stolen. + void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym); + + /// Pop \a n symbols from the stack. + void yypop_ (int n = 1) YY_NOEXCEPT; + + /// Constants. + enum + { + yylast_ = ]b4_last[, ///< Last index in yytable_. + yynnts_ = ]b4_nterms_number[, ///< Number of nonterminal symbols. + yyfinal_ = ]b4_final_state_number[ ///< Termination state number. + }; + +]b4_parse_param_vars[ +]b4_percent_code_get([[yy_bison_internal_hook]])[ + }; + +]b4_token_ctor_if([b4_yytranslate_define([$1])[ +]b4_public_types_define([$1])])[ +]b4_namespace_close[ + +]b4_percent_code_get([[provides]])[ +]])[ + + +## -------------- ## +## Output files. ## +## -------------- ## + +# ------------- # +# Header file. # +# ------------- # + +]b4_header_if([[ +]b4_output_begin([b4_spec_header_file])[ +]b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])[ + +/** + ** \file ]b4_spec_mapped_header_file[ + ** Define the ]b4_namespace_ref[::parser class. + */ + +// C++ LALR(1) parser skeleton written by Akim Demaille. + +]b4_disclaimer[ +]b4_cpp_guard_open([b4_spec_mapped_header_file])[ +]b4_shared_declarations(hh)[ +]b4_cpp_guard_close([b4_spec_mapped_header_file])[ +]b4_output_end[ +]])[ + + +# --------------------- # +# Implementation file. # +# --------------------- # + +]b4_output_begin([b4_parser_file_name])[ +]b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])[ +]b4_disclaimer[ +]b4_percent_code_get([[top]])[]dnl +m4_if(b4_prefix, [yy], [], +[ +// Take the name prefix into account. +[#]define yylex b4_prefix[]lex])[ + +]b4_user_pre_prologue[ + +]b4_header_if([[#include "@basename(]b4_spec_header_file[@)"]], + [b4_shared_declarations([cc])])[ + +]b4_user_post_prologue[ +]b4_percent_code_get[ + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include // FIXME: INFRINGES ON USER NAME SPACE. +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif +]b4_has_translations_if([ +#ifndef N_ +# define N_(Msgid) Msgid +#endif +])[ + +// Whether we are compiled with exception support. +#ifndef YY_EXCEPTIONS +# if defined __GNUC__ && !defined __EXCEPTIONS +# define YY_EXCEPTIONS 0 +# else +# define YY_EXCEPTIONS 1 +# endif +#endif + +]b4_locations_if([dnl +[#define YYRHSLOC(Rhs, K) ((Rhs)[K].location) +]b4_yylloc_default_define])[ + +// Enable debugging if requested. +#if ]b4_api_PREFIX[DEBUG + +// A pseudo ostream that takes yydebug_ into account. +# define YYCDEBUG if (yydebug_) (*yycdebug_) + +# define YY_SYMBOL_PRINT(Title, Symbol) \ + do { \ + if (yydebug_) \ + { \ + *yycdebug_ << Title << ' '; \ + yy_print_ (*yycdebug_, Symbol); \ + *yycdebug_ << '\n'; \ + } \ + } while (false) + +# define YY_REDUCE_PRINT(Rule) \ + do { \ + if (yydebug_) \ + yy_reduce_print_ (Rule); \ + } while (false) + +# define YY_STACK_PRINT() \ + do { \ + if (yydebug_) \ + yy_stack_print_ (); \ + } while (false) + +#else // !]b4_api_PREFIX[DEBUG + +# define YYCDEBUG if (false) std::cerr +# define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol) +# define YY_REDUCE_PRINT(Rule) static_cast (0) +# define YY_STACK_PRINT() static_cast (0) + +#endif // !]b4_api_PREFIX[DEBUG + +#define yyerrok (yyerrstatus_ = 0) +#define yyclearin (yyla.clear ()) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYRECOVERING() (!!yyerrstatus_) + +]b4_namespace_open[ + /// Build a parser object. + ]b4_parser_class::b4_parser_class[ (]b4_parse_param_decl[) +#if ]b4_api_PREFIX[DEBUG + : yydebug_ (false), + yycdebug_ (&std::cerr)]b4_lac_if([,], [m4_ifset([b4_parse_param], [,])])[ +#else +]b4_lac_if([ :], [m4_ifset([b4_parse_param], [ :])])[ +#endif]b4_lac_if([[ + yy_lac_established_ (false)]m4_ifset([b4_parse_param], [,])])[]b4_parse_param_cons[ + {} + + ]b4_parser_class::~b4_parser_class[ () + {} + + ]b4_parser_class[::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW + {} + + /*---------. + | symbol. | + `---------*/ + +]b4_token_ctor_if([], [b4_public_types_define([cc])])[ + + // by_state. + ]b4_parser_class[::by_state::by_state () YY_NOEXCEPT + : state (empty_state) + {} + + ]b4_parser_class[::by_state::by_state (const by_state& that) YY_NOEXCEPT + : state (that.state) + {} + + void + ]b4_parser_class[::by_state::clear () YY_NOEXCEPT + { + state = empty_state; + } + + void + ]b4_parser_class[::by_state::move (by_state& that) + { + state = that.state; + that.clear (); + } + + ]b4_parser_class[::by_state::by_state (state_type s) YY_NOEXCEPT + : state (s) + {} + + ]b4_parser_class[::symbol_kind_type + ]b4_parser_class[::by_state::kind () const YY_NOEXCEPT + { + if (state == empty_state) + return ]b4_symbol(empty, kind)[; + else + return YY_CAST (symbol_kind_type, yystos_[+state]); + } + + ]b4_parser_class[::stack_symbol_type::stack_symbol_type () + {} + + ]b4_parser_class[::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that) + : super_type (YY_MOVE (that.state)]b4_variant_if([], [, YY_MOVE (that.value)])b4_locations_if([, YY_MOVE (that.location)])[) + {]b4_variant_if([ + b4_symbol_variant([that.kind ()], + [value], [YY_MOVE_OR_COPY], [YY_MOVE (that.value)])])[ +#if 201103L <= YY_CPLUSPLUS + // that is emptied. + that.state = empty_state; +#endif + } + + ]b4_parser_class[::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that) + : super_type (s]b4_variant_if([], [, YY_MOVE (that.value)])[]b4_locations_if([, YY_MOVE (that.location)])[) + {]b4_variant_if([ + b4_symbol_variant([that.kind ()], + [value], [move], [YY_MOVE (that.value)])])[ + // that is emptied. + that.kind_ = ]b4_symbol(empty, kind)[; + } + +#if YY_CPLUSPLUS < 201103L + ]b4_parser_class[::stack_symbol_type& + ]b4_parser_class[::stack_symbol_type::operator= (const stack_symbol_type& that) + { + state = that.state; + ]b4_variant_if([b4_symbol_variant([that.kind ()], + [value], [copy], [that.value])], + [[value = that.value;]])[]b4_locations_if([ + location = that.location;])[ + return *this; + } + + ]b4_parser_class[::stack_symbol_type& + ]b4_parser_class[::stack_symbol_type::operator= (stack_symbol_type& that) + { + state = that.state; + ]b4_variant_if([b4_symbol_variant([that.kind ()], + [value], [move], [that.value])], + [[value = that.value;]])[]b4_locations_if([ + location = that.location;])[ + // that is emptied. + that.state = empty_state; + return *this; + } +#endif + + template + void + ]b4_parser_class[::yy_destroy_ (const char* yymsg, basic_symbol& yysym) const + { + if (yymsg) + YY_SYMBOL_PRINT (yymsg, yysym);]b4_variant_if([], [ + + // User destructor. + b4_symbol_actions([destructor], [yysym.kind ()])])[ + } + +#if ]b4_api_PREFIX[DEBUG + template + void + ]b4_parser_class[::yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const + { + std::ostream& yyoutput = yyo; + YY_USE (yyoutput); + if (yysym.empty ()) + yyo << "empty symbol"; + else + { + symbol_kind_type yykind = yysym.kind (); + yyo << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << yysym.name () << " ("]b4_locations_if([ + << yysym.location << ": "])[; + ]b4_symbol_actions([printer])[ + yyo << ')'; + } + } +#endif + + void + ]b4_parser_class[::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym) + { + if (m) + YY_SYMBOL_PRINT (m, sym); + yystack_.push (YY_MOVE (sym)); + } + + void + ]b4_parser_class[::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym) + { +#if 201103L <= YY_CPLUSPLUS + yypush_ (m, stack_symbol_type (s, std::move (sym))); +#else + stack_symbol_type ss (s, sym); + yypush_ (m, ss); +#endif + } + + void + ]b4_parser_class[::yypop_ (int n) YY_NOEXCEPT + { + yystack_.pop (n); + } + +#if ]b4_api_PREFIX[DEBUG + std::ostream& + ]b4_parser_class[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class[::debug_level_type + ]b4_parser_class[::debug_level () const + { + return yydebug_; + } + + void + ]b4_parser_class[::set_debug_level (debug_level_type l) + { + yydebug_ = l; + } +#endif // ]b4_api_PREFIX[DEBUG + + ]b4_parser_class[::state_type + ]b4_parser_class[::yy_lr_goto_state_ (state_type yystate, int yysym) + { + int yyr = yypgoto_[yysym - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) + return yytable_[yyr]; + else + return yydefgoto_[yysym - YYNTOKENS]; + } + + bool + ]b4_parser_class[::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT + { + return yyvalue == yypact_ninf_; + } + + bool + ]b4_parser_class[::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT + { + return yyvalue == yytable_ninf_; + } + + int + ]b4_parser_class[::operator() () + { + return parse (); + } + + int + ]b4_parser_class[::parse () + { + int yyn; + /// Length of the RHS of the rule being reduced. + int yylen = 0; + + // Error handling. + int yynerrs_ = 0; + int yyerrstatus_ = 0; + + /// The lookahead symbol. + symbol_type yyla;]b4_locations_if([[ + + /// The locations where the error started and ended. + stack_symbol_type yyerror_range[3];]])[ + + /// The return value of parse (). + int yyresult;]b4_lac_if([[ + + // Discard the LAC context in case there still is one left from a + // previous invocation. + yy_lac_discard_ ("init");]])[ + +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + YYCDEBUG << "Starting parse\n"; + +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yyla.value], [], [], [yyla.location])dnl + b4_user_initial_action +b4_dollar_popdef])[]dnl + + [ /* Initialize the stack. The initial state will be set in + yynewstate, since the latter expects the semantical and the + location values to have been already stored, initialize these + stacks with a primary value. */ + yystack_.clear (); + yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla)); + + /*-----------------------------------------------. + | yynewstate -- push a new symbol on the stack. | + `-----------------------------------------------*/ + yynewstate: + YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n'; + YY_STACK_PRINT (); + + // Accept? + if (yystack_[0].state == yyfinal_) + YYACCEPT; + + goto yybackup; + + + /*-----------. + | yybackup. | + `-----------*/ + yybackup: + // Try to take a decision without lookahead. + yyn = yypact_[+yystack_[0].state]; + if (yy_pact_value_is_default_ (yyn)) + goto yydefault; + + // Read a lookahead token. + if (yyla.empty ()) + { + YYCDEBUG << "Reading a token\n"; +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + {]b4_token_ctor_if([[ + symbol_type yylookahead (]b4_yylex[); + yyla.move (yylookahead);]], [[ + yyla.kind_ = yytranslate_ (]b4_yylex[);]])[ + } +#if YY_EXCEPTIONS + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; + error (yyexc); + goto yyerrlab1; + } +#endif // YY_EXCEPTIONS + } + YY_SYMBOL_PRINT ("Next token is", yyla); + + if (yyla.kind () == ]b4_symbol(error, kind)[) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yyla.kind_ = ]b4_symbol(undef, kind)[; + goto yyerrlab1; + } + + /* If the proper action on seeing token YYLA.TYPE is to reduce or + to detect an error, take that action. */ + yyn += yyla.kind (); + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ()) + {]b4_lac_if([[ + if (!yy_lac_establish_ (yyla.kind ())) + goto yyerrlab;]])[ + goto yydefault; + } + + // Reduce or error. + yyn = yytable_[yyn]; + if (yyn <= 0) + { + if (yy_table_value_is_error_ (yyn)) + goto yyerrlab;]b4_lac_if([[ + if (!yy_lac_establish_ (yyla.kind ())) + goto yyerrlab; +]])[ + yyn = -yyn; + goto yyreduce; + } + + // Count tokens shifted since error; after three, turn off error status. + if (yyerrstatus_) + --yyerrstatus_; + + // Shift the lookahead token. + yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla));]b4_lac_if([[ + yy_lac_discard_ ("shift");]])[ + goto yynewstate; + + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + yydefault: + yyn = yydefact_[+yystack_[0].state]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + + /*-----------------------------. + | yyreduce -- do a reduction. | + `-----------------------------*/ + yyreduce: + yylen = yyr2_[yyn]; + { + stack_symbol_type yylhs; + yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]);]b4_variant_if([[ + /* Variants are always initialized to an empty instance of the + correct type. The default '$$ = $1' action is NOT applied + when using variants. */ + ]b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [emplace])], [[ + /* If YYLEN is nonzero, implement the default value of the + action: '$$ = $1'. Otherwise, use the top of the stack. + + Otherwise, the following line sets YYLHS.VALUE to garbage. + This behavior is undocumented and Bison users should not rely + upon it. */ + if (yylen) + yylhs.value = yystack_@{yylen - 1@}.value; + else + yylhs.value = yystack_@{0@}.value;]])[ +]b4_locations_if([dnl +[ + // Default location. + { + stack_type::slice range (yystack_, yylen); + YYLLOC_DEFAULT (yylhs.location, range, yylen); + yyerror_range[1].location = yylhs.location; + }]])[ + + // Perform the reduction. + YY_REDUCE_PRINT (yyn); +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + switch (yyn) + { +]b4_user_actions[ + default: + break; + } + } +#if YY_EXCEPTIONS + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; + error (yyexc); + YYERROR; + } +#endif // YY_EXCEPTIONS + YY_SYMBOL_PRINT ("-> $$ =", yylhs); + yypop_ (yylen); + yylen = 0; + + // Shift the result of the reduction. + yypush_ (YY_NULLPTR, YY_MOVE (yylhs)); + } + goto yynewstate; + + + /*--------------------------------------. + | yyerrlab -- here on detecting error. | + `--------------------------------------*/ + yyerrlab: + // If not already recovering from an error, report this error. + if (!yyerrstatus_) + { + ++yynerrs_;]b4_parse_error_case( + [simple], [[ + std::string msg = YY_("syntax error"); + error (]b4_join(b4_locations_if([yyla.location]), [[YY_MOVE (msg)]])[);]], + [custom], [[ + context yyctx (*this, yyla); + report_syntax_error (yyctx);]], + [[ + context yyctx (*this, yyla); + std::string msg = yysyntax_error_ (yyctx); + error (]b4_join(b4_locations_if([yyla.location]), [[YY_MOVE (msg)]])[);]])[ + } + +]b4_locations_if([[ + yyerror_range[1].location = yyla.location;]])[ + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + // Return failure if at end of input. + if (yyla.kind () == ]b4_symbol(eof, kind)[) + YYABORT; + else if (!yyla.empty ()) + { + yy_destroy_ ("Error: discarding", yyla); + yyla.clear (); + } + } + + // Else will try to reuse lookahead token after shifting the error token. + goto yyerrlab1; + + + /*---------------------------------------------------. + | yyerrorlab -- error raised explicitly by YYERROR. | + `---------------------------------------------------*/ + yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and + the label yyerrorlab therefore never appears in user code. */ + if (false) + YYERROR; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + yypop_ (yylen); + yylen = 0; + YY_STACK_PRINT (); + goto yyerrlab1; + + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + yyerrlab1: + yyerrstatus_ = 3; // Each real token shifted decrements this. + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[+yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += ]b4_symbol(error, kind)[; + if (0 <= yyn && yyn <= yylast_ + && yycheck_[yyn] == ]b4_symbol(error, kind)[) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + // Pop the current state because it cannot handle the error token. + if (yystack_.size () == 1) + YYABORT; +]b4_locations_if([[ + yyerror_range[1].location = yystack_[0].location;]])[ + yy_destroy_ ("Error: popping", yystack_[0]); + yypop_ (); + YY_STACK_PRINT (); + } + { + stack_symbol_type error_token; +]b4_locations_if([[ + yyerror_range[2].location = yyla.location; + YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[ + + // Shift the error token.]b4_lac_if([[ + yy_lac_discard_ ("error recovery");]])[ + error_token.state = state_type (yyn); + yypush_ ("Shifting", YY_MOVE (error_token)); + } + goto yynewstate; + + + /*-------------------------------------. + | yyacceptlab -- YYACCEPT comes here. | + `-------------------------------------*/ + yyacceptlab: + yyresult = 0; + goto yyreturn; + + + /*-----------------------------------. + | yyabortlab -- YYABORT comes here. | + `-----------------------------------*/ + yyabortlab: + yyresult = 1; + goto yyreturn; + + + /*-----------------------------------------------------. + | yyreturn -- parsing is finished, return the result. | + `-----------------------------------------------------*/ + yyreturn: + if (!yyla.empty ()) + yy_destroy_ ("Cleanup: discarding lookahead", yyla); + + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + yypop_ (yylen); + YY_STACK_PRINT (); + while (1 < yystack_.size ()) + { + yy_destroy_ ("Cleanup: popping", yystack_[0]); + yypop_ (); + } + + return yyresult; + } +#if YY_EXCEPTIONS + catch (...) + { + YYCDEBUG << "Exception caught: cleaning lookahead and stack\n"; + // Do not try to display the values of the reclaimed symbols, + // as their printers might throw an exception. + if (!yyla.empty ()) + yy_destroy_ (YY_NULLPTR, yyla); + + while (1 < yystack_.size ()) + { + yy_destroy_ (YY_NULLPTR, yystack_[0]); + yypop_ (); + } + throw; + } +#endif // YY_EXCEPTIONS + } + + void + ]b4_parser_class[::error (const syntax_error& yyexc) + { + error (]b4_join(b4_locations_if([yyexc.location]), + [[yyexc.what ()]])[); + } + +]b4_parse_error_bmatch([custom\|detailed], +[[ const char * + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + static const char *const yy_sname[] = + { + ]b4_symbol_names[ + };]b4_has_translations_if([[ + /* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is + internationalizable. */ + static ]b4_int_type_for([b4_translatable])[ yytranslatable[] = + { + ]b4_translatable[ + }; + return (yysymbol < YYNTOKENS && yytranslatable[yysymbol] + ? _(yy_sname[yysymbol]) + : yy_sname[yysymbol]);]], [[ + return yy_sname[yysymbol];]])[ + } +]], +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + const char * + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + return yytname_[yysymbol]; + } +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + std::string + ]b4_parser_class[::yytnamerr_ (const char *yystr) + { + if (*yystr == '"') + { + std::string yyr; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + else + goto append; + + append: + default: + yyr += *yyp; + break; + + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } + + std::string + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + return yytnamerr_ (yytname_[yysymbol]); + } +]])[ + +]b4_parse_error_bmatch([custom\|detailed\|verbose], [[ + // ]b4_parser_class[::context. + ]b4_parser_class[::context::context (const ]b4_parser_class[& yyparser, const symbol_type& yyla) + : yyparser_ (yyparser) + , yyla_ (yyla) + {} + + int + ]b4_parser_class[::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const + { + // Actual number of expected tokens + int yycount = 0; +]b4_lac_if([[ +#if ]b4_api_PREFIX[DEBUG + // Execute LAC once. We don't care if it is successful, we + // only do it for the sake of debugging output. + if (!yyparser_.yy_lac_established_) + yyparser_.yy_lac_check_ (yyla_.kind ()); +#endif + + for (int yyx = 0; yyx < YYNTOKENS; ++yyx) + { + symbol_kind_type yysym = YY_CAST (symbol_kind_type, yyx); + if (yysym != ]b4_symbol(error, kind)[ + && yysym != ]b4_symbol(undef, kind)[ + && yyparser_.yy_lac_check_ (yysym)) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = yysym; + } + }]], [[ + const int yyn = yypact_[+yyparser_.yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + const int yyxbegin = yyn < 0 ? -yyn : 0; + // Stay within bounds of both yycheck and yytname. + const int yychecklim = yylast_ - yyn + 1; + const int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[ + && !yy_table_value_is_error_ (yytable_[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx); + } + } +]])[ + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = ]b4_symbol(empty, kind)[; + return yycount; + } + +]])[ + +]b4_lac_if([[ + bool + ]b4_parser_class[::yy_lac_check_ (symbol_kind_type yytoken) const + { + // Logically, the yylac_stack's lifetime is confined to this function. + // Clear it, to get rid of potential left-overs from previous call. + yylac_stack_.clear (); + // Reduce until we encounter a shift and thereby accept the token. +#if ]b4_api_PREFIX[DEBUG + YYCDEBUG << "LAC: checking lookahead " << symbol_name (yytoken) << ':'; +#endif + std::ptrdiff_t lac_top = 0; + while (true) + { + state_type top_state = (yylac_stack_.empty () + ? yystack_[lac_top].state + : yylac_stack_.back ()); + int yyrule = yypact_[+top_state]; + if (yy_pact_value_is_default_ (yyrule) + || (yyrule += yytoken) < 0 || yylast_ < yyrule + || yycheck_[yyrule] != yytoken) + { + // Use the default action. + yyrule = yydefact_[+top_state]; + if (yyrule == 0) + { + YYCDEBUG << " Err\n"; + return false; + } + } + else + { + // Use the action from yytable. + yyrule = yytable_[yyrule]; + if (yy_table_value_is_error_ (yyrule)) + { + YYCDEBUG << " Err\n"; + return false; + } + if (0 < yyrule) + { + YYCDEBUG << " S" << yyrule << '\n'; + return true; + } + yyrule = -yyrule; + } + // By now we know we have to simulate a reduce. + YYCDEBUG << " R" << yyrule - 1; + // Pop the corresponding number of values from the stack. + { + std::ptrdiff_t yylen = yyr2_[yyrule]; + // First pop from the LAC stack as many tokens as possible. + std::ptrdiff_t lac_size = std::ptrdiff_t (yylac_stack_.size ()); + if (yylen < lac_size) + { + yylac_stack_.resize (std::size_t (lac_size - yylen)); + yylen = 0; + } + else if (lac_size) + { + yylac_stack_.clear (); + yylen -= lac_size; + } + // Only afterwards look at the main stack. + // We simulate popping elements by incrementing lac_top. + lac_top += yylen; + } + // Keep top_state in sync with the updated stack. + top_state = (yylac_stack_.empty () + ? yystack_[lac_top].state + : yylac_stack_.back ()); + // Push the resulting state of the reduction. + state_type state = yy_lr_goto_state_ (top_state, yyr1_[yyrule]); + YYCDEBUG << " G" << int (state); + yylac_stack_.push_back (state); + } + } + + // Establish the initial context if no initial context currently exists. + bool + ]b4_parser_class[::yy_lac_establish_ (symbol_kind_type yytoken) + { + /* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + yy_lac_establish_ should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). + + For parse.lac=full, the implementation of yy_lac_establish_ is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. */ + if (yy_lac_established_) + return true; + else + { +#if ]b4_api_PREFIX[DEBUG + YYCDEBUG << "LAC: initial context established for " + << symbol_name (yytoken) << '\n'; +#endif + yy_lac_established_ = true; + return yy_lac_check_ (yytoken); + } + } + + // Discard any previous initial lookahead context. + void + ]b4_parser_class[::yy_lac_discard_ (const char* event) + { + /* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ + if (yy_lac_established_) + { + YYCDEBUG << "LAC: initial context discarded due to " + << event << '\n'; + yy_lac_established_ = false; + } + }]])[ + +]b4_parse_error_bmatch([detailed\|verbose], [[ + int + ]b4_parser_class[::yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const + { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yyla) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yyla. (However, yyla is currently not documented for users.)]b4_lac_if([[ + In the first two cases, it might appear that the current syntax + error should have been detected in the previous state when + yy_lac_check was invoked. However, at that time, there might + have been a different syntax error that discarded a different + initial context during error recovery, leaving behind the + current lookahead.]], [[ + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state.]])[ + */ + + if (!yyctx.lookahead ().empty ()) + { + if (yyarg) + yyarg[0] = yyctx.token (); + int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); + return yyn + 1; + } + return 0; + } + + // Generate an error message. + std::string + ]b4_parser_class[::yysyntax_error_ (const context& yyctx) const + { + // Its maximum. + enum { YYARGS_MAX = 5 }; + // Arguments of yyformat. + symbol_kind_type yyarg[YYARGS_MAX]; + int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); + + char const* yyformat = YY_NULLPTR; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: // Avoid compiler warnings. + YYCASE_ (0, YY_("syntax error")); + YYCASE_ (1, YY_("syntax error, unexpected %s")); + YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + std::string yyres; + // Argument number. + std::ptrdiff_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += symbol_name (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres; + }]])[ + + + const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class::yypact_ninf_ = b4_pact_ninf[; + + const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class::yytable_ninf_ = b4_table_ninf[; + +]b4_parser_tables_define[ + +]b4_parse_error_bmatch([simple\|verbose], +[[#if ]b4_api_PREFIX[DEBUG]b4_tname_if([[ || 1]])[ + // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + // First, the terminals, then, starting at \a YYNTOKENS, nonterminals. + const char* + const ]b4_parser_class[::yytname_[] = + { + ]b4_tname[ + }; +#endif +]])[ + +#if ]b4_api_PREFIX[DEBUG][ +]b4_integral_parser_table_define([rline], [b4_rline])[ + + void + ]b4_parser_class[::yy_stack_print_ () const + { + *yycdebug_ << "Stack now"; + for (stack_type::const_iterator + i = yystack_.begin (), + i_end = yystack_.end (); + i != i_end; ++i) + *yycdebug_ << ' ' << int (i->state); + *yycdebug_ << '\n'; + } + + void + ]b4_parser_class[::yy_reduce_print_ (int yyrule) const + { + int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + // Print the symbols being reduced, and their result. + *yycdebug_ << "Reducing stack by rule " << yyrule - 1 + << " (line " << yylno << "):\n"; + // The symbols being reduced. + for (int yyi = 0; yyi < yynrhs; yyi++) + YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", + ]b4_rhs_data(yynrhs, yyi + 1)[); + } +#endif // ]b4_api_PREFIX[DEBUG + +]b4_token_ctor_if([], [b4_yytranslate_define([cc])])[ +]b4_namespace_close[ +]b4_epilogue[]dnl +b4_output_end + + +m4_popdef([b4_copyright_years])dnl diff --git a/Engine/bin/bison-flex/data/skeletons/lalr1.d b/Engine/bin/bison-flex/data/skeletons/lalr1.d new file mode 100644 index 000000000..973037722 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/lalr1.d @@ -0,0 +1,1326 @@ +# D skeleton for Bison -*- autoconf -*- + +# Copyright (C) 2007-2012, 2019-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +m4_include(b4_skeletonsdir/[d.m4]) + +b4_header_if([b4_complain([%header/%defines does not make sense in D])]) + +# parse.lac +b4_percent_define_default([[parse.lac]], [[none]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]]) +b4_define_flag_if([lac]) +m4_define([b4_lac_flag], + [m4_if(b4_percent_define_get([[parse.lac]]), + [none], [[0]], [[1]])]) + + +## --------------- ## +## api.push-pull. ## +## --------------- ## + +b4_percent_define_default([[api.push-pull]], [[pull]]) +b4_percent_define_check_values([[[[api.push-pull]], + [[pull]], [[push]], [[both]]]]) + +# Define m4 conditional macros that encode the value +# of the api.push-pull flag. +b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) +b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) +m4_case(b4_percent_define_get([[api.push-pull]]), + [pull], [m4_define([b4_push_flag], [[0]])], + [push], [m4_define([b4_pull_flag], [[0]])]) + +# Define a macro to be true when api.push-pull has the value "both". +m4_define([b4_both_if],[b4_push_if([b4_pull_if([$1],[$2])],[$2])]) + +# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing +# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the +# behavior of Bison at all when push parsing is already requested. +b4_define_flag_if([use_push_for_pull]) +b4_use_push_for_pull_if([ + b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], + [m4_define([b4_push_flag], [[1]])])]) + + +# Define a macro to encapsulate the parse state variables. This +# allows them to be defined either in parse() when doing pull parsing, +# or as class instance variable when doing push parsing. +b4_output_begin([b4_parser_file_name]) +b4_copyright([Skeleton implementation for Bison LALR(1) parsers in D], + [2007-2012, 2019-2021])[ +]b4_disclaimer[ +]b4_percent_define_ifdef([package], [module b4_percent_define_get([package]); +])[ +version(D_Version2) { +} else { + static assert(false, "need compiler for D Version 2"); +} + +]b4_user_pre_prologue[ +]b4_user_post_prologue[ +]b4_percent_code_get([[imports]])[ +import std.format; +import std.conv; + +/** + * Handle error message internationalisation. + */ +static if (!is(typeof(YY_))) { + version(YYENABLE_NLS) + { + version(ENABLE_NLS) + { + extern(C) char* dgettext(const char*, const char*); + string YY_(const char* s) + { + return to!string(dgettext("bison-runtime", s)); + } + } + } + static if (!is(typeof(YY_))) + { + pragma(inline, true) + string YY_(string msg) { return msg; } + } +} + +/** + * A Bison parser, automatically generated from ]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[. + * + * @@author LALR (1) parser skeleton written by Paolo Bonzini. + * Port to D language was done by Oliver Mangold. + */ + +/** + * Communication interface between the scanner and the Bison-generated + * parser ]b4_parser_class[. + */ +public interface Lexer +{ + /** + * Entry point for the scanner. Returns the token identifier corresponding + * to the next token and prepares to return the semantic value + * ]b4_locations_if([and beginning/ending positions ])[of the token. + * @@return the token identifier corresponding to the next token. */ + Symbol yylex (); + + /** + * Entry point for error reporting. Emits an error + * ]b4_locations_if([referring to the given location ])[in a user-defined way. + *]b4_locations_if([[ + * @@param loc The location of the element to which the + * error message is related]])[ + * @@param s The string for the error message. */ + void yyerror (]b4_locations_if([[const Location loc, ]])[string s); +]b4_parse_error_bmatch([custom], [[ + /** + * Build and emit a "syntax error" message in a user-defined way. + * + * @@param ctx The context of the error. + */ + void reportSyntaxError(]b4_parser_class[.Context ctx); +]])[ +} + +]b4_public_types_declare[ + +]b4_locations_if([b4_position_type_if([[ +static assert(__traits(compiles, + (new Position[1])[0]=(new Position[1])[0]), + "struct/class Position must be default-constructible " + "and assignable"); +static assert(__traits(compiles, (new string[1])[0]=(new Position).toString()), + "error: struct/class Position must have toString method"); +]], [[ + /** + * A struct denoting a point in the input.*/ +public struct ]b4_position_type[ { + + /** The column index within the line of input. */ + public int column = 1; + /** The line number within an input file. */ + public int line = 1; + /** The name of the input file. */ + public string filename = null; + + /** + * A string representation of the position. */ + public string toString() const { + if (filename) + return format("%s:%d.%d", filename, line, column); + else + return format("%d.%d", line, column); + } +} +]])b4_location_type_if([[ +static assert(__traits(compiles, (new Location((new Position[1])[0]))) && + __traits(compiles, (new Location((new Position[1])[0], (new Position[1])[0]))), + "error: struct/class Location must have " + "default constructor and constructors this(Position) and this(Position, Position)."); +static assert(__traits(compiles, (new Location[1])[0].begin=(new Location[1])[0].begin) && + __traits(compiles, (new Location[1])[0].begin=(new Location[1])[0].end) && + __traits(compiles, (new Location[1])[0].end=(new Location[1])[0].begin) && + __traits(compiles, (new Location[1])[0].end=(new Location[1])[0].end), + "error: struct/class Location must have assignment-compatible " + "members/properties 'begin' and 'end'."); +static assert(__traits(compiles, (new string[1])[0]=(new Location[1])[0].toString()), + "error: struct/class Location must have toString method."); + +private immutable bool yy_location_is_class = !__traits(compiles, *(new Location((new Position[1])[0])));]], [[ +/** + * A struct defining a pair of positions. Positions, defined by the + * Position struct, denote a point in the input. + * Locations represent a part of the input through the beginning + * and ending positions. */ +public struct ]b4_location_type[ +{ + /** The first, inclusive, position in the range. */ + public Position begin; + + /** The first position beyond the range. */ + public Position end; + + /** + * Create a Location denoting an empty range located at + * a given point. + * @@param loc The position at which the range is anchored. */ + public this(Position loc) + { + this.begin = this.end = loc; + } + + /** + * Create a Location from the endpoints of the range. + * @@param begin The first position included in the range. + * @@param end The first position beyond the range. */ + public this(Position begin, Position end) + { + this.begin = begin; + this.end = end; + } + + /** + * Reset initial location to final location. + */ + public void step() + { + this.begin = this.end; + } + + /** + * A representation of the location. + */ + public string toString() const + { + auto end_col = 0 < end.column ? end.column - 1 : 0; + auto res = begin.toString (); + if (end.filename && begin.filename != end.filename) + res ~= "-" ~ format("%s:%d.%d", end.filename, end.line, end_col); + else if (begin.line < end.line) + res ~= "-" ~ format("%d.%d", end.line, end_col); + else if (begin.column < end_col) + res ~= "-" ~ format("%d", end_col); + return res; + } +} + +private immutable bool yy_location_is_class = false; + +]])])[]b4_value_type_setup[]m4_ifdef([b4_user_union_members], [private union YYSemanticType +{ +b4_user_union_members +};], +[m4_if(b4_tag_seen_flag, 0, +[[private alias int YYSemanticType;]])])[ +]b4_token_enums[ +]b4_parser_class_declaration[ +{ + ]b4_identification[ + +]b4_declare_symbol_enum[ + +]b4_locations_if([[ + private final Location yylloc_from_stack (ref YYStack rhs, int n) + { + static if (yy_location_is_class) { + if (n > 0) + return new Location (rhs.locationAt (n-1).begin, rhs.locationAt (0).end); + else + return new Location (rhs.locationAt (0).end); + } else { + if (n > 0) + return Location (rhs.locationAt (n-1).begin, rhs.locationAt (0).end); + else + return Location (rhs.locationAt (0).end); + } + }]])[ + +]b4_lexer_if([[ private class YYLexer implements Lexer { +]b4_percent_code_get([[lexer]])[ + } +]])[ + /** The object doing lexical analysis for us. */ + private Lexer yylexer; + +]b4_parse_param_vars[ + +]b4_lexer_if([[ + /** + * Instantiate the Bison-generated parser. + */ + public this] (b4_parse_param_decl([b4_lex_param_decl])[) { +]b4_percent_code_get([[init]])[]b4_lac_if([[ + this.yylacStack = new int[]; + this.yylacEstablished = false;]])[ + this (new YYLexer(]b4_lex_param_call[)); + } +]])[ + + /** + * Instantiate the Bison-generated parser. + * @@param yylexer The scanner that will supply tokens to the parser. + */ + ]b4_lexer_if([[protected]], [[public]]) [this (]b4_parse_param_decl([[Lexer yylexer]])[) { + this.yylexer = yylexer;]b4_parse_trace_if([[ + this.yyDebugStream = stderr;]])[ +]b4_parse_param_cons[ + } +]b4_parse_trace_if([[ + import std.stdio; + private File yyDebugStream; + + /** + * The File on which the debugging output is + * printed. + */ + public File getDebugStream () { return yyDebugStream; } + + /** + * Set the std.File on which the debug output is printed. + * @@param s The stream that is used for debugging output. + */ + public final void setDebugStream(File s) { yyDebugStream = s; } + + private int yydebug = 0; + + /** + * Answer the verbosity of the debugging output; 0 means that all kinds of + * output from the parser are suppressed. + */ + public final int getDebugLevel() { return yydebug; } + + /** + * Set the verbosity of the debugging output; 0 means that all kinds of + * output from the parser are suppressed. + * @@param level The verbosity level for debugging output. + */ + public final void setDebugLevel(int level) { yydebug = level; } + + protected final void yycdebug (string s) { + if (0 < yydebug) + yyDebugStream.write (s); + } + + protected final void yycdebugln (string s) { + if (0 < yydebug) + yyDebugStream.writeln (s); + } +]])[ + private final ]b4_parser_class[.Symbol yylex () { + return yylexer.yylex (); + } + + protected final void yyerror (]b4_locations_if([[const Location loc, ]])[string s) { + yylexer.yyerror (]b4_locations_if([loc, ])[s); + } + + /** + * The number of syntax errors so far. + */ + public int numberOfErrors() const { return yynerrs_; } + private int yynerrs_ = 0; + + /** + * Returned by a Bison action in order to stop the parsing process and + * return success (true). */ + public static immutable int YYACCEPT = 0; + + /** + * Returned by a Bison action in order to stop the parsing process and + * return failure (false). */ + public static immutable int YYABORT = 1; +]b4_push_if([ + /** + * Returned by a Bison action in order to request a new token. + */ + public static immutable int YYPUSH_MORE = 4;])[ + + /** + * Returned by a Bison action in order to start error recovery without + * printing an error message. */ + public static immutable int YYERROR = 2; + + // Internal return codes that are not supported for user semantic + // actions. + private static immutable int YYERRLAB = 3; + private static immutable int YYNEWSTATE = 4; + private static immutable int YYDEFAULT = 5; + private static immutable int YYREDUCE = 6; + private static immutable int YYERRLAB1 = 7; + private static immutable int YYRETURN = 8; +]b4_push_if([[ private static immutable int YYGETTOKEN = 9; /* Signify that a new token is expected when doing push-parsing. */]])[ + +]b4_locations_if([ + private static immutable YYSemanticType yy_semantic_null;])[ + private int yyerrstatus_ = 0; + + private void yyerrok() + { + yyerrstatus_ = 0; + } + + // Lookahead symbol kind. + SymbolKind yytoken = ]b4_symbol(empty, kind)[; + + /* State. */ + int yyn = 0; + int yylen = 0; + int yystate = 0; + + YYStack yystack; + + int label = YYNEWSTATE; + + /* Error handling. */ +]b4_locations_if([[ + /// The location where the error started. + Location yyerrloc; + + /// Location of the lookahead. + Location yylloc; + + /// @@$. + Location yyloc;]])[ + + /// Semantic value of the lookahead. + Value yylval; + + /** + * Whether error recovery is being done. In this state, the parser + * reads token until it reaches a known state, and then restarts normal + * operation. */ + public final bool recovering () + { + return yyerrstatus_ == 0; + } + + /** Compute post-reduction state. + * @@param yystate the current state + * @@param yysym the nonterminal to push on the stack + */ + private int yyLRGotoState(int yystate, int yysym) { + int yyr = yypgoto_[yysym - yyntokens_] + yystate; + if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) + return yytable_[yyr]; + else + return yydefgoto_[yysym - yyntokens_]; + } + + private int yyaction (int yyn, ref YYStack yystack, int yylen) + { + Value yyval;]b4_locations_if([[ + Location yyloc = yylloc_from_stack (yystack, yylen);]])[ + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. Otherwise, use the top of the stack. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. */ + if (yylen > 0) + yyval = yystack.valueAt (yylen - 1); + else + yyval = yystack.valueAt (0); + +]b4_parse_trace_if([[ + yy_reduce_print (yyn, yystack);]])[ + + switch (yyn) + { +]b4_user_actions[ + default: break; + } + +]b4_parse_trace_if([[ + yy_symbol_print ("-> $$ =", to!SymbolKind (yyr1_[yyn]), yyval]b4_locations_if([, yyloc])[);]])[ + + yystack.pop (yylen); + yylen = 0; + + /* Shift the result of the reduction. */ + int yystate = yyLRGotoState(yystack.stateAt(0), yyr1_[yyn]); + yystack.push (yystate, yyval]b4_locations_if([, yyloc])[); + return YYNEWSTATE; + } + +]b4_parse_trace_if([[ + /*--------------------------------. + | Print this symbol on YYOUTPUT. | + `--------------------------------*/ + + private final void yy_symbol_print (string s, SymbolKind yykind, + ref Value yyval]b4_locations_if([, ref Location yyloc])[) + { + if (0 < yydebug) + { + File yyo = yyDebugStream; + yyo.write(s); + yyo.write(yykind < yyntokens_ ? " token " : " nterm "); + yyo.write(format("%s", yykind)); + yyo.write(" ("]b4_locations_if([ ~ yyloc.toString() ~ ": "])[); + ]b4_symbol_actions([printer])[ + yyo.write(")\n"); + } + } +]])[ +]b4_symbol_type_define[ +]b4_push_if([[ + /** + * Push Parse input from external lexer + * + * @@param yyla current Symbol + * + * @@return YYACCEPT, YYABORT, YYPUSH_MORE + */ + public int pushParse(Symbol yyla)]], [[ + /** + * Parse input from the scanner that was specified at object construction + * time. Return whether the end of the input was reached successfully. + * + * @@return true if the parsing succeeds. Note that this does not + * imply that there were no syntax errors. + */ + public bool parse()]])[ + {]b4_push_if([[ + if (!this.pushParseInitialized) + { + pushParseInitialize(); + yyerrstatus_ = 0; + } + else + label = YYGETTOKEN; + + bool push_token_consumed = true; +]], [[ bool yyresult;]b4_lac_if([[ + // Discard the LAC context in case there still is one left from a + // previous invocation. + yylacDiscard("init");]])[]b4_parse_trace_if([[ + + yycdebugln ("Starting parse");]])[ + yyerrstatus_ = 0; + +]m4_ifdef([b4_initial_action], [ +m4_pushdef([b4_at_dollar], [yylloc])dnl +m4_pushdef([b4_dollar_dollar], [yylval])dnl + /* User initialization code. */ + b4_user_initial_action +m4_popdef([b4_dollar_dollar])dnl +m4_popdef([b4_at_dollar])])dnl + + [ /* Initialize the stack. */ + yystack.push (yystate, yylval]b4_locations_if([, yylloc])[); + + label = YYNEWSTATE;]])[ + for (;;) + final switch (label) + { + /* New state. Unlike in the C/C++ skeletons, the state is already + pushed when we come here. */ + case YYNEWSTATE:]b4_parse_trace_if([[ + yycdebugln (format("Entering state %d", yystate)); + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + + /* Accept? */ + if (yystate == yyfinal_)]b4_push_if([[ + { + label = YYACCEPT; + break; + }]], [[ + return true;]])[ + + /* Take a decision. First try without lookahead. */ + yyn = yypact_[yystate]; + if (yyPactValueIsDefault(yyn)) + { + label = YYDEFAULT; + break; + }]b4_push_if([[ + goto case; + + case YYGETTOKEN:]])[ + + /* Read a lookahead token. */ + if (yytoken == ]b4_symbol(empty, kind)[) + {]b4_push_if([[ + if (!push_token_consumed) + return YYPUSH_MORE;]])[]b4_parse_trace_if([[ + yycdebugln ("Reading a token");]])[]b4_push_if([[ + yytoken = yyla.token; + yylval = yyla.value;]b4_locations_if([[ + yylloc = yyla.location;]])[ + push_token_consumed = false;]], [[ + Symbol yysymbol = yylex(); + yytoken = yysymbol.token(); + yylval = yysymbol.value();]b4_locations_if([[ + yylloc = yysymbol.location();]])[]])[ + } + + /* Token already converted to internal form. */]b4_parse_trace_if([[ + yy_symbol_print ("Next token is", yytoken, yylval]b4_locations_if([, yylloc])[);]])[ + + if (yytoken == ]b4_symbol(error, kind)[) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yytoken = ]b4_symbol(undef, kind)[;]b4_locations_if([[ + yyerrloc = yylloc;]])[ + label = YYERRLAB1; + } + else + { + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) {]b4_lac_if([[ + if (!yylacEstablish(yystack, yytoken)) + label = YYERRLAB; + else]])[ + label = YYDEFAULT; + } + /* <= 0 means reduce or error. */ + else if ((yyn = yytable_[yyn]) <= 0) + { + if (yyTableValueIsError(yyn)) + label = YYERRLAB;]b4_lac_if([[ + else if (!yylacEstablish(yystack, yytoken)) + label = YYERRLAB;]])[ + else + { + yyn = -yyn; + label = YYREDUCE; + } + } + else + { + /* Shift the lookahead token. */]b4_parse_trace_if([[ + yy_symbol_print ("Shifting", yytoken, yylval]b4_locations_if([, yylloc])[);]])[ + + /* Discard the token being shifted. */ + yytoken = ]b4_symbol(empty, kind)[; + + /* Count tokens shifted since error; after three, turn off error + * status. */ + if (yyerrstatus_ > 0) + --yyerrstatus_; + + yystate = yyn; + yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);]b4_lac_if([[ + yylacDiscard("shift");]])[ + label = YYNEWSTATE; + } + } + break; + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + case YYDEFAULT: + yyn = yydefact_[yystate]; + if (yyn == 0) + label = YYERRLAB; + else + label = YYREDUCE; + break; + + /*-----------------------------. + | yyreduce -- Do a reduction. | + `-----------------------------*/ + case YYREDUCE: + yylen = yyr2_[yyn]; + label = yyaction (yyn, yystack, yylen); + yystate = yystack.stateAt (0); + break; + + /*--------------------------------------. + | yyerrlab -- here on detecting error. | + `--------------------------------------*/ + case YYERRLAB: + /* If not already recovering from an error, report this error. */ + if (yyerrstatus_ == 0) + { + ++yynerrs_; + yyreportSyntaxError(new Context(]b4_lac_if([[this, ]])[yystack, yytoken]b4_locations_if([[, yylloc]])[)); + } +]b4_locations_if([ + yyerrloc = yylloc;])[ + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + * error, discard it. */ + + /* Return failure if at end of input. */ + if (yytoken == ]b4_symbol(eof, [kind])[)]b4_push_if([[ + { + label = YYABORT; + break; + }]], [[ + return false;]])[ + else + yytoken = ]b4_symbol(empty, kind)[; + } + + /* Else will try to reuse lookahead token after shifting the error + * token. */ + label = YYERRLAB1; + break; + + /*-------------------------------------------------. + | errorlab -- error raised explicitly by YYERROR. | + `-------------------------------------------------*/ + case YYERROR:]b4_locations_if([ + yyerrloc = yystack.locationAt (yylen - 1);])[ + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + yystack.pop (yylen); + yylen = 0; + yystate = yystack.stateAt (0); + label = YYERRLAB1; + break; + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + case YYERRLAB1: + yyerrstatus_ = 3; /* Each real token shifted decrements this. */ + + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[yystate]; + if (!yyPactValueIsDefault(yyn)) + { + yyn += ]b4_symbol(error, kind)[; + if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == ]b4_symbol(error, kind)[) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yystack.height == 1)]b4_push_if([[ + { + label = YYABORT; + break; + }]],[[ + return false;]])[ + +]b4_locations_if([ yyerrloc = yystack.locationAt (0);])[ + yystack.pop (); + yystate = yystack.stateAt (0);]b4_parse_trace_if([[ + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + }]b4_push_if([[ + if (label == YYABORT) + /* Leave the switch. */ + break; +]])[ +]b4_locations_if([ + /* Muck with the stack to setup for yylloc. */ + yystack.push (0, yy_semantic_null, yylloc); + yystack.push (0, yy_semantic_null, yyerrloc); + yyloc = yylloc_from_stack (yystack, 2); + yystack.pop (2);])[ + + /* Shift the error token. */]b4_lac_if([[ + yylacDiscard("error recovery");]])[]b4_parse_trace_if([[ + yy_symbol_print ("Shifting", to!SymbolKind (yystos_[yyn]), yylval]b4_locations_if([, yyloc])[);]])[ + yystate = yyn; + yystack.push (yyn, yylval]b4_locations_if([, yyloc])[); + label = YYNEWSTATE; + break; + + /* Accept. */ + case YYACCEPT:]b4_push_if([[ + this.pushParseInitialized = false;]b4_parse_trace_if([[ + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + return YYACCEPT;]], [[ + yyresult = true; + label = YYRETURN; + break;]])[ + + /* Abort. */ + case YYABORT:]b4_push_if([[ + this.pushParseInitialized = false;]b4_parse_trace_if([[ + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + return YYABORT;]], [[ + yyresult = false; + label = YYRETURN; + break;]])[ +]b4_push_if([[]], [[ ][case YYRETURN:]b4_parse_trace_if([[ + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + return yyresult;]])[ + } + assert(0); + } + +]b4_push_if([[ + bool pushParseInitialized = false; + + /** + * (Re-)Initialize the state of the push parser. + */ + public void pushParseInitialize() + { + + /* Lookahead and lookahead in internal form. */ + this.yytoken = ]b4_symbol(empty, kind)[; + + /* State. */ + this.yyn = 0; + this.yylen = 0; + this.yystate = 0; + destroy(this.yystack); + this.label = YYNEWSTATE; +]b4_lac_if([[ + destroy(this.yylacStack); + this.yylacEstablished = false;]])[ + + /* Error handling. */ + this.yynerrs_ = 0; +]b4_locations_if([ + /* The location where the error started. */ + this.yyerrloc = Location(Position(), Position()); + this.yylloc = Location(Position(), Position());])[ + + /* Semantic value of the lookahead. */ + //destroy(this.yylval); + + /* Initialize the stack. */ + yystack.push(this.yystate, this.yylval]b4_locations_if([, this.yylloc])[); + + this.pushParseInitialized = true; + }]])[]b4_both_if([[ + /** + * Parse input from the scanner that was specified at object construction + * time. Return whether the end of the input was reached successfully. + * This version of parse() is defined only when api.push-push=both. + * + * @@return true if the parsing succeeds. Note that this does not + * imply that there were no syntax errors. + */ + bool parse() + { + int status = 0; + do { + status = this.pushParse(yylex()); + } while (status == YYPUSH_MORE); + return status == YYACCEPT; + }]])[ + + // Generate an error message. + private final void yyreportSyntaxError(Context yyctx) + {]b4_parse_error_bmatch( +[custom], [[ + yylexer.reportSyntaxError(yyctx);]], +[detailed], [[ + if (yyctx.getToken() != ]b4_symbol(empty, kind)[) + { + // FIXME: This method of building the message is not compatible + // with internationalization. + immutable int argmax = 5; + SymbolKind[] yyarg = new SymbolKind[argmax]; + int yycount = yysyntaxErrorArguments(yyctx, yyarg, argmax); + string res, yyformat; + switch (yycount) + { + case 1: + yyformat = YY_("syntax error, unexpected %s"); + res = format(yyformat, yyarg[0]); + break; + case 2: + yyformat = YY_("syntax error, unexpected %s, expecting %s"); + res = format(yyformat, yyarg[0], yyarg[1]); + break; + case 3: + yyformat = YY_("syntax error, unexpected %s, expecting %s or %s"); + res = format(yyformat, yyarg[0], yyarg[1], yyarg[2]); + break; + case 4: + yyformat = YY_("syntax error, unexpected %s, expecting %s or %s or %s"); + res = format(yyformat, yyarg[0], yyarg[1], yyarg[2], yyarg[3]); + break; + case 5: + yyformat = YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); + res = format(yyformat, yyarg[0], yyarg[1], yyarg[2], yyarg[3], yyarg[4]); + break; + default: + res = YY_("syntax error"); + break; + } + yyerror(]b4_locations_if([yyctx.getLocation(), ])[res); + }]], +[[simple]], [[ + yyerror(]b4_locations_if([yyctx.getLocation(), ])[YY_("syntax error"));]])[ + } + +]b4_parse_error_bmatch( +[detailed], [[ + private int yysyntaxErrorArguments(Context yyctx, SymbolKind[] yyarg, int yyargn) { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, + then the only way this function was invoked is if the + default action is an error action. In that case, don't + check for expected tokens because there are none. + - The only way there can be no lookahead present (in tok) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this + state is a consistent state with a default action. There + might have been a previous inconsistent state, consistent + state with a non-default action, or user semantic action + that manipulated yychar. (However, yychar is currently out + of scope during semantic actions.) + - Of course, the expected token list depends on states to + have correct lookahead information, and it depends on the + parser not to perform extra reductions after fetching a + lookahead from the scanner and before detecting a syntax + error. Thus, state merging (from LALR or IELR) and default + reductions corrupt the expected token list. However, the + list is correct for canonical LR with one exception: it + will still contain any token that will not be accepted due + to an error action in a later state. + */ + int yycount = 0; + if (yyctx.getToken() != ]b4_symbol(empty, kind)[) + { + if (yyarg !is null) + yyarg[yycount] = yyctx.getToken(); + yycount += 1; + yycount += yyctx.getExpectedTokens(yyarg, 1, yyargn); + } + return yycount; + } +]])[ + + + /** + * Information needed to get the list of expected tokens and to forge + * a syntax error diagnostic. + */ + public static final class Context + {]b4_lac_if([[ + private ]b4_parser_class[ yyparser;]])[ + private const(YYStack) yystack; + private SymbolKind yytoken;]b4_locations_if([[ + private const(Location) yylocation;]])[ + + this(]b4_lac_if([[]b4_parser_class[ parser, ]])[YYStack stack, SymbolKind kind]b4_locations_if([[, Location loc]])[) + {]b4_lac_if([[ + yyparser = parser;]])[ + yystack = stack; + yytoken = kind;]b4_locations_if([[ + yylocation = loc;]])[ + } + + final SymbolKind getToken() const + { + return yytoken; + }]b4_locations_if([[ + + final const(Location) getLocation() const + { + return yylocation; + }]])[ + /** + * Put in YYARG at most YYARGN of the expected tokens given the + * current YYCTX, and return the number of tokens stored in YYARG. If + * YYARG is null, return the number of expected tokens (guaranteed to + * be less than YYNTOKENS). + */ + int getExpectedTokens(SymbolKind[] yyarg, int yyargn)]b4_lac_if([[]], [[ const]])[ + { + return getExpectedTokens(yyarg, 0, yyargn); + } + + int getExpectedTokens(SymbolKind[] yyarg, int yyoffset, int yyargn)]b4_lac_if([[]], [[ const]])[ + { + int yycount = yyoffset;]b4_lac_if([b4_parse_trace_if([[ + // Execute LAC once. We don't care if it is successful, we + // only do it for the sake of debugging output. + + if (!yyparser.yylacEstablished) + yyparser.yylacCheck(yystack, yytoken); +]])[ + for (int yyx = 0; yyx < yyntokens_; ++yyx) + { + SymbolKind yysym = SymbolKind(yyx); + if (yysym != ]b4_symbol(error, kind)[ + && yysym != ]b4_symbol(undef, kind)[ + && yyparser.yylacCheck(yystack, yysym)) + { + if (yyarg == null) + yycount += 1; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = yysym; + } + }]], [[ + int yyn = yypact_[this.yystack.stateAt(0)]; + if (!yyPactValueIsDefault(yyn)) + { + /* Start YYX at -YYN if negative to avoid negative + indexes in YYCHECK. In other words, skip the first + -YYN actions for this state because they are default + actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = yylast_ - yyn + 1; + int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[ + && !yyTableValueIsError(yytable_[yyx + yyn])) + { + if (yyarg is null) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = SymbolKind(yyx); + } + }]])[ + if (yyarg !is null && yycount == yyoffset && yyoffset < yyargn) + yyarg[yyoffset] = ]b4_symbol(empty, kind)[; + return yycount - yyoffset; + } + } + +]b4_lac_if([[ + /** Check the lookahead yytoken. + * \returns true iff the token will be eventually shifted. + */ + bool yylacCheck(const YYStack yystack, SymbolKind yytoken) + { + // Logically, the yylacStack's lifetime is confined to this function. + // Clear it, to get rid of potential left-overs from previous call. + destroy(yylacStack); + // Reduce until we encounter a shift and thereby accept the token. +]b4_parse_trace_if([[ + yycdebug("LAC: checking lookahead " ~ format("%s", yytoken) ~ ":");]])[ + int lacTop = 0; + while (true) + { + int topState = (yylacStack.length == 0 + ? yystack.stateAt(lacTop) + : yylacStack[$ - 1]); + int yyrule = yypact_[topState]; + if (yyPactValueIsDefault(yyrule) + || (yyrule += yytoken) < 0 || yylast_ < yyrule + || yycheck_[yyrule] != yytoken) + { + // Use the default action. + yyrule = yydefact_[+topState]; + if (yyrule == 0) + {]b4_parse_trace_if([[ + yycdebugln(" Err");]])[ + return false; + } + } + else + { + // Use the action from yytable. + yyrule = yytable_[yyrule]; + if (yyTableValueIsError(yyrule)) + {]b4_parse_trace_if([[ + yycdebugln(" Err");]])[ + return false; + } + if (0 < yyrule) + {]b4_parse_trace_if([[ + yycdebugln(" S" ~ to!string(yyrule));]])[ + return true; + } + yyrule = -yyrule; + } + // By now we know we have to simulate a reduce. +]b4_parse_trace_if([[ + yycdebug(" R" ~ to!string(yyrule - 1));]])[ + // Pop the corresponding number of values from the stack. + { + int yylen = yyr2_[yyrule]; + // First pop from the LAC stack as many tokens as possible. + int lacSize = cast (int) yylacStack.length; + if (yylen < lacSize) + { + yylacStack.length -= yylen; + yylen = 0; + } + else if (lacSize != 0) + { + destroy(yylacStack); + yylen -= lacSize; + } + // Only afterwards look at the main stack. + // We simulate popping elements by incrementing lacTop. + lacTop += yylen; + } + // Keep topState in sync with the updated stack. + topState = (yylacStack.length == 0 + ? yystack.stateAt(lacTop) + : yylacStack[$ - 1]); + // Push the resulting state of the reduction. + int state = yyLRGotoState(topState, yyr1_[yyrule]);]b4_parse_trace_if([[ + yycdebug(" G" ~ to!string(state));]])[ + yylacStack.length++; + yylacStack[$ - 1] = state; + } + } + + /** Establish the initial context if no initial context currently exists. + * \returns true iff the token will be eventually shifted. + */ + bool yylacEstablish(YYStack yystack, SymbolKind yytoken) + { + /* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + yylacEstablish should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). + + For parse.lac=full, the implementation of yylacEstablish is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. */ + if (yylacEstablished) + return true; + else + {]b4_parse_trace_if([[ + yycdebugln("LAC: initial context established for " ~ format("%s", yytoken));]])[ + yylacEstablished = true; + return yylacCheck(yystack, yytoken); + } + } + + /** Discard any previous initial lookahead context because of event. + * \param event the event which caused the lookahead to be discarded. + * Only used for debbuging output. */ + void yylacDiscard(string event) + { + /* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ + if (yylacEstablished) + {]b4_parse_trace_if([[ + yycdebugln("LAC: initial context discarded due to " ~ event);]])[ + yylacEstablished = false; + } + } + + /** The stack for LAC. + * Logically, the yylacStack's lifetime is confined to the function + * yylacCheck. We just store it as a member of this class to hold + * on to the memory and to avoid frequent reallocations. + */ + int[] yylacStack; + /** Whether an initial LAC context was established. */ + bool yylacEstablished; +]])[ + + /** + * Whether the given yypact_ value indicates a defaulted state. + * @@param yyvalue the value to check + */ + private static bool yyPactValueIsDefault(int yyvalue) + { + return yyvalue == yypact_ninf_; + } + + /** + * Whether the given yytable_ value indicates a syntax error. + * @@param yyvalue the value to check + */ + private static bool yyTableValueIsError(int yyvalue) + { + return yyvalue == yytable_ninf_; + } + + /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ + private static immutable ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[; + + /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If YYTABLE_NINF_, syntax error. */ + private static immutable ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[; + + ]b4_parser_tables_define[ + +]b4_parse_trace_if([[ + /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ + private static immutable ]b4_int_type_for([b4_rline])[[] yyrline_ = + @{ + ]b4_rline[ + @}; + + // Report on the debug stream that the rule yyrule is going to be reduced. + private final void yy_reduce_print (int yyrule, ref YYStack yystack) + { + if (yydebug == 0) + return; + + int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + /* Print the symbols being reduced, and their result. */ + yycdebugln (format("Reducing stack by rule %d (line %d):", + yyrule - 1, yylno)); + + /* The symbols being reduced. */ + for (int yyi = 0; yyi < yynrhs; yyi++) + yy_symbol_print (format(" $%d =", yyi + 1), + to!SymbolKind (yystos_[yystack.stateAt(yynrhs - (yyi + 1))]), + ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([, + b4_rhs_location(yynrhs, yyi + 1)])[); + } +]])[ + + private static auto yytranslate_ (int t) + { +]b4_api_token_raw_if( +[[ return SymbolKind(t);]], +[[ /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ + immutable ]b4_int_type_for([b4_translate])[[] translate_table = + @{ + ]b4_translate[ + @}; + + // Last valid token kind. + immutable int code_max = ]b4_code_max[; + + if (t <= 0) + return ]b4_symbol(eof, kind)[; + else if (t <= code_max) + return SymbolKind(translate_table[t]); + else + return ]b4_symbol(undef, kind)[;]])[ + } + + private static immutable int yylast_ = ]b4_last[; + private static immutable int yynnts_ = ]b4_nterms_number[; + private static immutable int yyfinal_ = ]b4_final_state_number[; + private static immutable int yyntokens_ = ]b4_tokens_number[; + + private final struct YYStackElement { + int state; + Value value;]b4_locations_if( + b4_location_type[[] location;])[ + } + + private final struct YYStack { + private YYStackElement[] stack = []; + + public final ulong height() + { + return stack.length; + } + + public final void push (int state, Value value]dnl + b4_locations_if([, ref Location loc])[) + { + stack ~= YYStackElement(state, value]b4_locations_if([, loc])[); + } + + public final void pop () + { + pop (1); + } + + public final void pop (int num) + { + stack.length -= num; + } + + public final int stateAt (int i) const + { + return stack[$-i-1].state; + } + +]b4_locations_if([[ + public final ref Location locationAt (int i) + { + return stack[$-i-1].location; + }]])[ + + public final ref Value valueAt (int i) + { + return stack[$-i-1].value; + } +]b4_parse_trace_if([[ + // Print the state stack on the debug stream. + public final void print (File stream) + { + stream.write ("Stack now"); + for (int i = 0; i < stack.length; i++) + stream.write (" ", stack[i].state); + stream.writeln (); + }]])[ + } +]b4_percent_code_get[ +} +]b4_percent_code_get([[epilogue]])[]dnl +b4_epilogue[]dnl +b4_output_end diff --git a/Engine/bin/bison-flex/data/skeletons/lalr1.java b/Engine/bin/bison-flex/data/skeletons/lalr1.java new file mode 100644 index 000000000..1bbecca13 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/lalr1.java @@ -0,0 +1,1303 @@ +# Java skeleton for Bison -*- java -*- + +# Copyright (C) 2007-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +m4_include(b4_skeletonsdir/[java.m4]) + +b4_header_if([b4_complain([%header/%defines does not make sense in Java])]) + +m4_define([b4_symbol_no_destructor_assert], +[b4_symbol_if([$1], [has_destructor], + [b4_complain_at(m4_unquote(b4_symbol([$1], [destructor_loc])), + [%destructor does not make sense in Java])])]) +b4_symbol_foreach([b4_symbol_no_destructor_assert]) + +## --------------- ## +## api.push-pull. ## +## --------------- ## + +b4_percent_define_default([[api.push-pull]], [[pull]]) +b4_percent_define_check_values([[[[api.push-pull]], + [[pull]], [[push]], [[both]]]]) + +# Define m4 conditional macros that encode the value +# of the api.push-pull flag. +b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) +b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) +m4_case(b4_percent_define_get([[api.push-pull]]), + [pull], [m4_define([b4_push_flag], [[0]])], + [push], [m4_define([b4_pull_flag], [[0]])]) + +# Define a macro to be true when api.push-pull has the value "both". +m4_define([b4_both_if],[b4_push_if([b4_pull_if([$1],[$2])],[$2])]) + +# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing +# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the +# behavior of Bison at all when push parsing is already requested. +b4_define_flag_if([use_push_for_pull]) +b4_use_push_for_pull_if([ + b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], + [m4_define([b4_push_flag], [[1]])])]) + +# Define a macro to encapsulate the parse state variables. This +# allows them to be defined either in parse() when doing pull parsing, +# or as class instance variable when doing push parsing. +m4_define([b4_define_state], +[[ + /* Lookahead token kind. */ + int yychar = YYEMPTY_; + /* Lookahead symbol kind. */ + SymbolKind yytoken = null; + + /* State. */ + int yyn = 0; + int yylen = 0; + int yystate = 0; + YYStack yystack = new YYStack (); + int label = YYNEWSTATE; + +]b4_locations_if([[ + /* The location where the error started. */ + ]b4_location_type[ yyerrloc = null; + + /* Location. */ + ]b4_location_type[ yylloc = new ]b4_location_type[ (null, null);]])[ + + /* Semantic value of the lookahead. */ + ]b4_yystype[ yylval = null; +]]) + +# parse.lac +b4_percent_define_default([[parse.lac]], [[none]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]]) +b4_define_flag_if([lac]) +m4_define([b4_lac_flag], + [m4_if(b4_percent_define_get([[parse.lac]]), + [none], [[0]], [[1]])]) + + +## ------------- ## +## Parser File. ## +## ------------- ## + +b4_output_begin([b4_parser_file_name])[ +]b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java], + [2007-2015, 2018-2021])[ +]b4_disclaimer[ +]b4_percent_define_ifdef([api.package], [package b4_percent_define_get([api.package]);[ +]])[ +]b4_user_pre_prologue[ +]b4_user_post_prologue[ +import java.text.MessageFormat; +import java.util.ArrayList; +]b4_percent_code_get([[imports]])[ +/** + * A Bison parser, automatically generated from ]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[. + * + * @@author LALR (1) parser skeleton written by Paolo Bonzini. + */ +]b4_parser_class_declaration[ +{ +]b4_identification[ +][ +]b4_parse_error_bmatch( + [detailed\|verbose], [[ + /** + * True if verbose error messages are enabled. + */ + private boolean yyErrorVerbose = true; + + /** + * Whether verbose error messages are enabled. + */ + public final boolean getErrorVerbose() { return yyErrorVerbose; } + + /** + * Set the verbosity of error messages. + * @@param verbose True to request verbose error messages. + */ + public final void setErrorVerbose(boolean verbose) + { yyErrorVerbose = verbose; } +]])[ + +]b4_locations_if([[ + /** + * A class defining a pair of positions. Positions, defined by the + * ]b4_position_type[ class, denote a point in the input. + * Locations represent a part of the input through the beginning + * and ending positions. + */ + public static class ]b4_location_type[ { + /** + * The first, inclusive, position in the range. + */ + public ]b4_position_type[ begin; + + /** + * The first position beyond the range. + */ + public ]b4_position_type[ end; + + /** + * Create a ]b4_location_type[ denoting an empty range located at + * a given point. + * @@param loc The position at which the range is anchored. + */ + public ]b4_location_type[ (]b4_position_type[ loc) { + this.begin = this.end = loc; + } + + /** + * Create a ]b4_location_type[ from the endpoints of the range. + * @@param begin The first position included in the range. + * @@param end The first position beyond the range. + */ + public ]b4_location_type[ (]b4_position_type[ begin, ]b4_position_type[ end) { + this.begin = begin; + this.end = end; + } + + /** + * Print a representation of the location. For this to be correct, + * ]b4_position_type[ should override the equals + * method. + */ + public String toString() { + if (begin.equals (end)) + return begin.toString(); + else + return begin.toString() + "-" + end.toString(); + } + } + + private ]b4_location_type[ yylloc(YYStack rhs, int n) + { + if (0 < n) + return new ]b4_location_type[(rhs.locationAt(n-1).begin, rhs.locationAt(0).end); + else + return new ]b4_location_type[(rhs.locationAt(0).end); + }]])[ + +]b4_declare_symbol_enum[ + + /** + * Communication interface between the scanner and the Bison-generated + * parser ]b4_parser_class[. + */ + public interface Lexer { +]b4_token_enums[ + /** Deprecated, use ]b4_symbol(eof, id)[ instead. */ + public static final int EOF = ]b4_symbol(eof, id)[; +]b4_pull_if([b4_locations_if([[ + /** + * Method to retrieve the beginning position of the last scanned token. + * @@return the position at which the last scanned token starts. + */ + ]b4_position_type[ getStartPos(); + + /** + * Method to retrieve the ending position of the last scanned token. + * @@return the first position beyond the last scanned token. + */ + ]b4_position_type[ getEndPos();]])[ + + /** + * Method to retrieve the semantic value of the last scanned token. + * @@return the semantic value of the last scanned token. + */ + ]b4_yystype[ getLVal(); + + /** + * Entry point for the scanner. Returns the token identifier corresponding + * to the next token and prepares to return the semantic value + * ]b4_locations_if([and beginning/ending positions ])[of the token. + * @@return the token identifier corresponding to the next token. + */ + int yylex()]b4_maybe_throws([b4_lex_throws])[; +]])[ + /** + * Emit an error]b4_locations_if([ referring to the given location])[in a user-defined way. + * + *]b4_locations_if([[ @@param loc The location of the element to which the + * error message is related.]])[ + * @@param msg The string for the error message. + */ + void yyerror(]b4_locations_if([b4_location_type[ loc, ]])[String msg); + +]b4_parse_error_bmatch( + [custom], [[ + /** + * Build and emit a "syntax error" message in a user-defined way. + * + * @@param ctx The context of the error. + */ + void reportSyntaxError(Context ctx); +]])[ + } + +]b4_lexer_if([[ + private class YYLexer implements Lexer { +]b4_percent_code_get([[lexer]])[ + } + +]])[ + /** + * The object doing lexical analysis for us. + */ + private Lexer yylexer; + +]b4_parse_param_vars[ + +]b4_lexer_if([[ + /** + * Instantiates the Bison-generated parser. + */ + public ]b4_parser_class[(]b4_parse_param_decl([b4_lex_param_decl])[)]b4_maybe_throws([b4_init_throws])[ + { +]b4_percent_code_get([[init]])[]b4_lac_if([[ + this.yylacStack = new ArrayList(); + this.yylacEstablished = false;]])[ + this.yylexer = new YYLexer(]b4_lex_param_call[); +]b4_parse_param_cons[ + } +]])[ + + /** + * Instantiates the Bison-generated parser. + * @@param yylexer The scanner that will supply tokens to the parser. + */ + ]b4_lexer_if([[protected]], [[public]]) b4_parser_class[(]b4_parse_param_decl([[Lexer yylexer]])[)]b4_maybe_throws([b4_init_throws])[ + { +]b4_percent_code_get([[init]])[]b4_lac_if([[ + this.yylacStack = new ArrayList(); + this.yylacEstablished = false;]])[ + this.yylexer = yylexer; +]b4_parse_param_cons[ + } + +]b4_parse_trace_if([[ + private java.io.PrintStream yyDebugStream = System.err; + + /** + * The PrintStream on which the debugging output is printed. + */ + public final java.io.PrintStream getDebugStream() { return yyDebugStream; } + + /** + * Set the PrintStream on which the debug output is printed. + * @@param s The stream that is used for debugging output. + */ + public final void setDebugStream(java.io.PrintStream s) { yyDebugStream = s; } + + private int yydebug = 0; + + /** + * Answer the verbosity of the debugging output; 0 means that all kinds of + * output from the parser are suppressed. + */ + public final int getDebugLevel() { return yydebug; } + + /** + * Set the verbosity of the debugging output; 0 means that all kinds of + * output from the parser are suppressed. + * @@param level The verbosity level for debugging output. + */ + public final void setDebugLevel(int level) { yydebug = level; } +]])[ + + private int yynerrs = 0; + + /** + * The number of syntax errors so far. + */ + public final int getNumberOfErrors() { return yynerrs; } + + /** + * Print an error message via the lexer. + *]b4_locations_if([[ Use a null location.]])[ + * @@param msg The error message. + */ + public final void yyerror(String msg) { + yylexer.yyerror(]b4_locations_if([[(]b4_location_type[)null, ]])[msg); + } +]b4_locations_if([[ + /** + * Print an error message via the lexer. + * @@param loc The location associated with the message. + * @@param msg The error message. + */ + public final void yyerror(]b4_location_type[ loc, String msg) { + yylexer.yyerror(loc, msg); + } + + /** + * Print an error message via the lexer. + * @@param pos The position associated with the message. + * @@param msg The error message. + */ + public final void yyerror(]b4_position_type[ pos, String msg) { + yylexer.yyerror(new ]b4_location_type[ (pos), msg); + }]])[ +]b4_parse_trace_if([[ + protected final void yycdebugNnl(String s) { + if (0 < yydebug) + yyDebugStream.print(s); + } + + protected final void yycdebug(String s) { + if (0 < yydebug) + yyDebugStream.println(s); + }]])[ + + private final class YYStack { + private int[] stateStack = new int[16];]b4_locations_if([[ + private ]b4_location_type[[] locStack = new ]b4_location_type[[16];]])[ + private ]b4_yystype[[] valueStack = new ]b4_yystype[[16]; + + public int size = 16; + public int height = -1; + + public final void push(int state, ]b4_yystype[ value]b4_locations_if([, ]b4_location_type[ loc])[) { + height++; + if (size == height) { + int[] newStateStack = new int[size * 2]; + System.arraycopy(stateStack, 0, newStateStack, 0, height); + stateStack = newStateStack;]b4_locations_if([[ + ]b4_location_type[[] newLocStack = new ]b4_location_type[[size * 2]; + System.arraycopy(locStack, 0, newLocStack, 0, height); + locStack = newLocStack;]]) + + b4_yystype[[] newValueStack = new ]b4_yystype[[size * 2]; + System.arraycopy(valueStack, 0, newValueStack, 0, height); + valueStack = newValueStack; + + size *= 2; + } + + stateStack[height] = state;]b4_locations_if([[ + locStack[height] = loc;]])[ + valueStack[height] = value; + } + + public final void pop() { + pop(1); + } + + public final void pop(int num) { + // Avoid memory leaks... garbage collection is a white lie! + if (0 < num) { + java.util.Arrays.fill(valueStack, height - num + 1, height + 1, null);]b4_locations_if([[ + java.util.Arrays.fill(locStack, height - num + 1, height + 1, null);]])[ + } + height -= num; + } + + public final int stateAt(int i) { + return stateStack[height - i]; + } +]b4_locations_if([[ + + public final ]b4_location_type[ locationAt(int i) { + return locStack[height - i]; + } +]])[ + public final ]b4_yystype[ valueAt(int i) { + return valueStack[height - i]; + } + + // Print the state stack on the debug stream. + public void print(java.io.PrintStream out) { + out.print ("Stack now"); + + for (int i = 0; i <= height; i++) { + out.print(' '); + out.print(stateStack[i]); + } + out.println(); + } + } + + /** + * Returned by a Bison action in order to stop the parsing process and + * return success (true). + */ + public static final int YYACCEPT = 0; + + /** + * Returned by a Bison action in order to stop the parsing process and + * return failure (false). + */ + public static final int YYABORT = 1; + +]b4_push_if([ + /** + * Returned by a Bison action in order to request a new token. + */ + public static final int YYPUSH_MORE = 4;])[ + + /** + * Returned by a Bison action in order to start error recovery without + * printing an error message. + */ + public static final int YYERROR = 2; + + /** + * Internal return codes that are not supported for user semantic + * actions. + */ + private static final int YYERRLAB = 3; + private static final int YYNEWSTATE = 4; + private static final int YYDEFAULT = 5; + private static final int YYREDUCE = 6; + private static final int YYERRLAB1 = 7; + private static final int YYRETURN = 8; +]b4_push_if([[ private static final int YYGETTOKEN = 9; /* Signify that a new token is expected when doing push-parsing. */]])[ + + private int yyerrstatus_ = 0; + +]b4_push_if([b4_define_state])[ + /** + * Whether error recovery is being done. In this state, the parser + * reads token until it reaches a known state, and then restarts normal + * operation. + */ + public final boolean recovering () + { + return yyerrstatus_ == 0; + } + + /** Compute post-reduction state. + * @@param yystate the current state + * @@param yysym the nonterminal to push on the stack + */ + private int yyLRGotoState(int yystate, int yysym) { + int yyr = yypgoto_[yysym - YYNTOKENS_] + yystate; + if (0 <= yyr && yyr <= YYLAST_ && yycheck_[yyr] == yystate) + return yytable_[yyr]; + else + return yydefgoto_[yysym - YYNTOKENS_]; + } + + private int yyaction(int yyn, YYStack yystack, int yylen)]b4_maybe_throws([b4_throws])[ + { + /* If YYLEN is nonzero, implement the default value of the action: + '$$ = $1'. Otherwise, use the top of the stack. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. */ + ]b4_yystype[ yyval = (0 < yylen) ? yystack.valueAt(yylen - 1) : yystack.valueAt(0);]b4_locations_if([[ + ]b4_location_type[ yyloc = yylloc(yystack, yylen);]])[]b4_parse_trace_if([[ + + yyReducePrint(yyn, yystack);]])[ + + switch (yyn) + { + ]b4_user_actions[ + default: break; + }]b4_parse_trace_if([[ + + yySymbolPrint("-> $$ =", SymbolKind.get(yyr1_[yyn]), yyval]b4_locations_if([, yyloc])[);]])[ + + yystack.pop(yylen); + yylen = 0; + /* Shift the result of the reduction. */ + int yystate = yyLRGotoState(yystack.stateAt(0), yyr1_[yyn]); + yystack.push(yystate, yyval]b4_locations_if([, yyloc])[); + return YYNEWSTATE; + } + +]b4_parse_trace_if([[ + /*--------------------------------. + | Print this symbol on YYOUTPUT. | + `--------------------------------*/ + + private void yySymbolPrint(String s, SymbolKind yykind, + ]b4_yystype[ yyvalue]b4_locations_if([, ]b4_location_type[ yylocation])[) { + if (0 < yydebug) { + yycdebug(s + + (yykind.getCode() < YYNTOKENS_ ? " token " : " nterm ") + + yykind.getName() + " ("]b4_locations_if([ + + yylocation + ": "])[ + + (yyvalue == null ? "(null)" : yyvalue.toString()) + ")"); + } + }]])[ + +]b4_push_if([],[[ + /** + * Parse input from the scanner that was specified at object construction + * time. Return whether the end of the input was reached successfully. + * + * @@return true if the parsing succeeds. Note that this does not + * imply that there were no syntax errors. + */ + public boolean parse()]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[]])[ +]b4_push_if([ + /** + * Push Parse input from external lexer + * + * @@param yylextoken current token + * @@param yylexval current lval]b4_locations_if([[ + * @@param yylexloc current position]])[ + * + * @@return YYACCEPT, YYABORT, YYPUSH_MORE + */ + public int push_parse(int yylextoken, b4_yystype yylexval[]b4_locations_if([, b4_location_type yylexloc]))b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])])[ + {]b4_locations_if([[ + /* @@$. */ + ]b4_location_type[ yyloc;]])[ +]b4_push_if([],[[ +]b4_define_state[ +]b4_lac_if([[ + // Discard the LAC context in case there still is one left from a + // previous invocation. + yylacDiscard("init");]])[ +]b4_parse_trace_if([[ + yycdebug ("Starting parse");]])[ + yyerrstatus_ = 0; + yynerrs = 0; + + /* Initialize the stack. */ + yystack.push (yystate, yylval]b4_locations_if([, yylloc])[); +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [], [yylloc])dnl + b4_user_initial_action +b4_dollar_popdef[]dnl +])[ +]])[ +]b4_push_if([[ + if (!this.push_parse_initialized) + { + push_parse_initialize (); +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [], [yylloc])dnl + b4_user_initial_action +b4_dollar_popdef[]dnl +])[]b4_parse_trace_if([[ + yycdebug ("Starting parse");]])[ + yyerrstatus_ = 0; + } else + label = YYGETTOKEN; + + boolean push_token_consumed = true; +]])[ + for (;;) + switch (label) + { + /* New state. Unlike in the C/C++ skeletons, the state is already + pushed when we come here. */ + case YYNEWSTATE:]b4_parse_trace_if([[ + yycdebug ("Entering state " + yystate); + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + + /* Accept? */ + if (yystate == YYFINAL_) + ]b4_push_if([{label = YYACCEPT; break;}], + [return true;])[ + + /* Take a decision. First try without lookahead. */ + yyn = yypact_[yystate]; + if (yyPactValueIsDefault (yyn)) + { + label = YYDEFAULT; + break; + } +]b4_push_if([ /* Fall Through */ + + case YYGETTOKEN:])[ + /* Read a lookahead token. */ + if (yychar == YYEMPTY_) + { +]b4_push_if([[ + if (!push_token_consumed) + return YYPUSH_MORE;]b4_parse_trace_if([[ + yycdebug ("Reading a token");]])[ + yychar = yylextoken; + yylval = yylexval;]b4_locations_if([ + yylloc = yylexloc;])[ + push_token_consumed = false;]], [b4_parse_trace_if([[ + yycdebug ("Reading a token");]])[ + yychar = yylexer.yylex (); + yylval = yylexer.getLVal();]b4_locations_if([[ + yylloc = new ]b4_location_type[(yylexer.getStartPos(), + yylexer.getEndPos());]])[ +]])[ + } + + /* Convert token to internal form. */ + yytoken = yytranslate_ (yychar);]b4_parse_trace_if([[ + yySymbolPrint("Next token is", yytoken, + yylval]b4_locations_if([, yylloc])[);]])[ + + if (yytoken == ]b4_symbol(error, kind)[) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yychar = Lexer.]b4_symbol(undef, id)[; + yytoken = ]b4_symbol(undef, kind)[;]b4_locations_if([[ + yyerrloc = yylloc;]])[ + label = YYERRLAB1; + } + else + { + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken.getCode(); + if (yyn < 0 || YYLAST_ < yyn || yycheck_[yyn] != yytoken.getCode()) {]b4_lac_if([[ + if (!yylacEstablish(yystack, yytoken)) { + label = YYERRLAB; + } else]])[ + label = YYDEFAULT; + } + + /* <= 0 means reduce or error. */ + else if ((yyn = yytable_[yyn]) <= 0) + { + if (yyTableValueIsError(yyn)) { + label = YYERRLAB; + }]b4_lac_if([[ else if (!yylacEstablish(yystack, yytoken)) { + label = YYERRLAB; + }]])[ else { + yyn = -yyn; + label = YYREDUCE; + } + } + + else + { + /* Shift the lookahead token. */]b4_parse_trace_if([[ + yySymbolPrint("Shifting", yytoken, + yylval]b4_locations_if([, yylloc])[); +]])[ + /* Discard the token being shifted. */ + yychar = YYEMPTY_; + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus_ > 0) + --yyerrstatus_; + + yystate = yyn; + yystack.push(yystate, yylval]b4_locations_if([, yylloc])[);]b4_lac_if([[ + yylacDiscard("shift");]])[ + label = YYNEWSTATE; + } + } + break; + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + case YYDEFAULT: + yyn = yydefact_[yystate]; + if (yyn == 0) + label = YYERRLAB; + else + label = YYREDUCE; + break; + + /*-----------------------------. + | yyreduce -- Do a reduction. | + `-----------------------------*/ + case YYREDUCE: + yylen = yyr2_[yyn]; + label = yyaction(yyn, yystack, yylen); + yystate = yystack.stateAt(0); + break; + + /*------------------------------------. + | yyerrlab -- here on detecting error | + `------------------------------------*/ + case YYERRLAB: + /* If not already recovering from an error, report this error. */ + if (yyerrstatus_ == 0) + { + ++yynerrs; + if (yychar == YYEMPTY_) + yytoken = null; + yyreportSyntaxError(new Context(this, yystack, yytoken]b4_locations_if([[, yylloc]])[)); + } +]b4_locations_if([[ + yyerrloc = yylloc;]])[ + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= Lexer.]b4_symbol(eof, id)[) + { + /* Return failure if at end of input. */ + if (yychar == Lexer.]b4_symbol(eof, id)[) + ]b4_push_if([{label = YYABORT; break;}], [return false;])[ + } + else + yychar = YYEMPTY_; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + label = YYERRLAB1; + break; + + /*-------------------------------------------------. + | errorlab -- error raised explicitly by YYERROR. | + `-------------------------------------------------*/ + case YYERROR:]b4_locations_if([[ + yyerrloc = yystack.locationAt (yylen - 1);]])[ + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + yystack.pop (yylen); + yylen = 0; + yystate = yystack.stateAt(0); + label = YYERRLAB1; + break; + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + case YYERRLAB1: + yyerrstatus_ = 3; /* Each real token shifted decrements this. */ + + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[yystate]; + if (!yyPactValueIsDefault (yyn)) + { + yyn += ]b4_symbol(error, kind)[.getCode(); + if (0 <= yyn && yyn <= YYLAST_ + && yycheck_[yyn] == ]b4_symbol(error, kind)[.getCode()) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the + * error token. */ + if (yystack.height == 0) + ]b4_push_if([{label = YYABORT; break;}],[return false;])[ + +]b4_locations_if([[ + yyerrloc = yystack.locationAt (0);]])[ + yystack.pop (); + yystate = yystack.stateAt(0);]b4_parse_trace_if([[ + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + } + + if (label == YYABORT) + /* Leave the switch. */ + break; + +]b4_locations_if([[ + /* Muck with the stack to setup for yylloc. */ + yystack.push (0, null, yylloc); + yystack.push (0, null, yyerrloc); + yyloc = yylloc (yystack, 2); + yystack.pop (2);]])[ + + /* Shift the error token. */]b4_lac_if([[ + yylacDiscard("error recovery");]])[]b4_parse_trace_if([[ + yySymbolPrint("Shifting", SymbolKind.get(yystos_[yyn]), + yylval]b4_locations_if([, yyloc])[);]])[ + + yystate = yyn; + yystack.push (yyn, yylval]b4_locations_if([, yyloc])[); + label = YYNEWSTATE; + break; + + /* Accept. */ + case YYACCEPT: + ]b4_push_if([this.push_parse_initialized = false; return YYACCEPT;], + [return true;])[ + + /* Abort. */ + case YYABORT: + ]b4_push_if([this.push_parse_initialized = false; return YYABORT;], + [return false;])[ + } +} +]b4_push_if([[ + boolean push_parse_initialized = false; + + /** + * (Re-)Initialize the state of the push parser. + */ + public void push_parse_initialize () + { + /* Lookahead and lookahead in internal form. */ + this.yychar = YYEMPTY_; + this.yytoken = null; + + /* State. */ + this.yyn = 0; + this.yylen = 0; + this.yystate = 0; + this.yystack = new YYStack();]b4_lac_if([[ + this.yylacStack = new ArrayList(); + this.yylacEstablished = false;]])[ + this.label = YYNEWSTATE; + + /* Error handling. */ + this.yynerrs = 0;]b4_locations_if([[ + /* The location where the error started. */ + this.yyerrloc = null; + this.yylloc = new ]b4_location_type[ (null, null);]])[ + + /* Semantic value of the lookahead. */ + this.yylval = null; + + yystack.push (this.yystate, this.yylval]b4_locations_if([, this.yylloc])[); + + this.push_parse_initialized = true; + + } +]b4_locations_if([[ + /** + * Push parse given input from an external lexer. + * + * @@param yylextoken current token + * @@param yylexval current lval + * @@param yyylexpos current position + * + * @@return YYACCEPT, YYABORT, YYPUSH_MORE + */ + public int push_parse(int yylextoken, ]b4_yystype[ yylexval, ]b4_position_type[ yylexpos)]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[ { + return push_parse(yylextoken, yylexval, new ]b4_location_type[(yylexpos)); + } +]])])[ + +]b4_both_if([[ + /** + * Parse input from the scanner that was specified at object construction + * time. Return whether the end of the input was reached successfully. + * This version of parse() is defined only when api.push-push=both. + * + * @@return true if the parsing succeeds. Note that this does not + * imply that there were no syntax errors. + */ + public boolean parse()]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[ { + if (yylexer == null) + throw new NullPointerException("Null Lexer"); + int status; + do { + int token = yylexer.yylex(); + ]b4_yystype[ lval = yylexer.getLVal();]b4_locations_if([[ + ]b4_location_type[ yyloc = new ]b4_location_type[(yylexer.getStartPos(), yylexer.getEndPos()); + status = push_parse(token, lval, yyloc);]], [[ + status = push_parse(token, lval);]])[ + } while (status == YYPUSH_MORE); + return status == YYACCEPT; + } +]])[ + + /** + * Information needed to get the list of expected tokens and to forge + * a syntax error diagnostic. + */ + public static final class Context { + Context(]b4_parser_class[ parser, YYStack stack, SymbolKind token]b4_locations_if([[, ]b4_location_type[ loc]])[) { + yyparser = parser; + yystack = stack; + yytoken = token;]b4_locations_if([[ + yylocation = loc;]])[ + } + + private ]b4_parser_class[ yyparser; + private YYStack yystack; + + + /** + * The symbol kind of the lookahead token. + */ + public final SymbolKind getToken() { + return yytoken; + } + + private SymbolKind yytoken;]b4_locations_if([[ + + /** + * The location of the lookahead. + */ + public final ]b4_location_type[ getLocation() { + return yylocation; + } + + private ]b4_location_type[ yylocation;]])[ + static final int NTOKENS = ]b4_parser_class[.YYNTOKENS_; + + /** + * Put in YYARG at most YYARGN of the expected tokens given the + * current YYCTX, and return the number of tokens stored in YYARG. If + * YYARG is null, return the number of expected tokens (guaranteed to + * be less than YYNTOKENS). + */ + int getExpectedTokens(SymbolKind yyarg[], int yyargn) { + return getExpectedTokens (yyarg, 0, yyargn); + } + + int getExpectedTokens(SymbolKind yyarg[], int yyoffset, int yyargn) { + int yycount = yyoffset;]b4_lac_if([b4_parse_trace_if([[ + // Execute LAC once. We don't care if it is successful, we + // only do it for the sake of debugging output. + if (!yyparser.yylacEstablished) + yyparser.yylacCheck(yystack, yytoken); +]])[ + for (int yyx = 0; yyx < YYNTOKENS_; ++yyx) + { + SymbolKind yysym = SymbolKind.get(yyx); + if (yysym != ]b4_symbol(error, kind)[ + && yysym != ]b4_symbol(undef, kind)[ + && yyparser.yylacCheck(yystack, yysym)) + { + if (yyarg == null) + yycount += 1; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = yysym; + } + }]], [[ + int yyn = yypact_[this.yystack.stateAt(0)]; + if (!yyPactValueIsDefault(yyn)) + { + /* Start YYX at -YYN if negative to avoid negative + indexes in YYCHECK. In other words, skip the first + -YYN actions for this state because they are default + actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST_ - yyn + 1; + int yyxend = yychecklim < NTOKENS ? yychecklim : NTOKENS; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[.getCode() + && !yyTableValueIsError(yytable_[yyx + yyn])) + { + if (yyarg == null) + yycount += 1; + else if (yycount == yyargn) + return 0; // FIXME: this is incorrect. + else + yyarg[yycount++] = SymbolKind.get(yyx); + } + }]])[ + if (yyarg != null && yycount == yyoffset && yyoffset < yyargn) + yyarg[yycount] = null; + return yycount - yyoffset; + } + } + +]b4_lac_if([[ + /** Check the lookahead yytoken. + * \returns true iff the token will be eventually shifted. + */ + boolean yylacCheck(YYStack yystack, SymbolKind yytoken) + { + // Logically, the yylacStack's lifetime is confined to this function. + // Clear it, to get rid of potential left-overs from previous call. + yylacStack.clear(); + // Reduce until we encounter a shift and thereby accept the token. + yycdebugNnl("LAC: checking lookahead " + yytoken.getName() + ":"); + int lacTop = 0; + while (true) + { + int topState = (yylacStack.isEmpty() + ? yystack.stateAt(lacTop) + : yylacStack.get(yylacStack.size() - 1)); + int yyrule = yypact_[topState]; + if (yyPactValueIsDefault(yyrule) + || (yyrule += yytoken.getCode()) < 0 || YYLAST_ < yyrule + || yycheck_[yyrule] != yytoken.getCode()) + { + // Use the default action. + yyrule = yydefact_[+topState]; + if (yyrule == 0) { + yycdebug(" Err"); + return false; + } + } + else + { + // Use the action from yytable. + yyrule = yytable_[yyrule]; + if (yyTableValueIsError(yyrule)) { + yycdebug(" Err"); + return false; + } + if (0 < yyrule) { + yycdebug(" S" + yyrule); + return true; + } + yyrule = -yyrule; + } + // By now we know we have to simulate a reduce. + yycdebugNnl(" R" + (yyrule - 1)); + // Pop the corresponding number of values from the stack. + { + int yylen = yyr2_[yyrule]; + // First pop from the LAC stack as many tokens as possible. + int lacSize = yylacStack.size(); + if (yylen < lacSize) { + // yylacStack.setSize(lacSize - yylen); + for (/* Nothing */; 0 < yylen; yylen -= 1) { + yylacStack.remove(yylacStack.size() - 1); + } + yylen = 0; + } else if (lacSize != 0) { + yylacStack.clear(); + yylen -= lacSize; + } + // Only afterwards look at the main stack. + // We simulate popping elements by incrementing lacTop. + lacTop += yylen; + } + // Keep topState in sync with the updated stack. + topState = (yylacStack.isEmpty() + ? yystack.stateAt(lacTop) + : yylacStack.get(yylacStack.size() - 1)); + // Push the resulting state of the reduction. + int state = yyLRGotoState(topState, yyr1_[yyrule]); + yycdebugNnl(" G" + state); + yylacStack.add(state); + } + } + + /** Establish the initial context if no initial context currently exists. + * \returns true iff the token will be eventually shifted. + */ + boolean yylacEstablish(YYStack yystack, SymbolKind yytoken) { + /* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + yylacEstablish should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). + + For parse.lac=full, the implementation of yylacEstablish is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. */ + if (yylacEstablished) { + return true; + } else { + yycdebug("LAC: initial context established for " + yytoken.getName()); + yylacEstablished = true; + return yylacCheck(yystack, yytoken); + } + } + + /** Discard any previous initial lookahead context because of event. + * \param event the event which caused the lookahead to be discarded. + * Only used for debbuging output. */ + void yylacDiscard(String event) { + /* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ + if (yylacEstablished) { + yycdebug("LAC: initial context discarded due to " + event); + yylacEstablished = false; + } + } + + /** The stack for LAC. + * Logically, the yylacStack's lifetime is confined to the function + * yylacCheck. We just store it as a member of this class to hold + * on to the memory and to avoid frequent reallocations. + */ + ArrayList yylacStack; + /** Whether an initial LAC context was established. */ + boolean yylacEstablished; +]])[ + +]b4_parse_error_bmatch( +[detailed\|verbose], [[ + private int yysyntaxErrorArguments(Context yyctx, SymbolKind[] yyarg, int yyargn) { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, + then the only way this function was invoked is if the + default action is an error action. In that case, don't + check for expected tokens because there are none. + - The only way there can be no lookahead present (in tok) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this + state is a consistent state with a default action. There + might have been a previous inconsistent state, consistent + state with a non-default action, or user semantic action + that manipulated yychar. (However, yychar is currently out + of scope during semantic actions.) + - Of course, the expected token list depends on states to + have correct lookahead information, and it depends on the + parser not to perform extra reductions after fetching a + lookahead from the scanner and before detecting a syntax + error. Thus, state merging (from LALR or IELR) and default + reductions corrupt the expected token list. However, the + list is correct for canonical LR with one exception: it + will still contain any token that will not be accepted due + to an error action in a later state. + */ + int yycount = 0; + if (yyctx.getToken() != null) + { + if (yyarg != null) + yyarg[yycount] = yyctx.getToken(); + yycount += 1; + yycount += yyctx.getExpectedTokens(yyarg, 1, yyargn); + } + return yycount; + } +]])[ + + /** + * Build and emit a "syntax error" message in a user-defined way. + * + * @@param ctx The context of the error. + */ + private void yyreportSyntaxError(Context yyctx) {]b4_parse_error_bmatch( +[custom], [[ + yylexer.reportSyntaxError(yyctx);]], +[detailed\|verbose], [[ + if (yyErrorVerbose) { + final int argmax = 5; + SymbolKind[] yyarg = new SymbolKind[argmax]; + int yycount = yysyntaxErrorArguments(yyctx, yyarg, argmax); + String[] yystr = new String[yycount]; + for (int yyi = 0; yyi < yycount; ++yyi) { + yystr[yyi] = yyarg[yyi].getName(); + } + String yyformat; + switch (yycount) { + default: + case 0: yyformat = ]b4_trans(["syntax error"])[; break; + case 1: yyformat = ]b4_trans(["syntax error, unexpected {0}"])[; break; + case 2: yyformat = ]b4_trans(["syntax error, unexpected {0}, expecting {1}"])[; break; + case 3: yyformat = ]b4_trans(["syntax error, unexpected {0}, expecting {1} or {2}"])[; break; + case 4: yyformat = ]b4_trans(["syntax error, unexpected {0}, expecting {1} or {2} or {3}"])[; break; + case 5: yyformat = ]b4_trans(["syntax error, unexpected {0}, expecting {1} or {2} or {3} or {4}"])[; break; + } + yyerror(]b4_locations_if([[yyctx.yylocation, ]])[new MessageFormat(yyformat).format(yystr)); + } else { + yyerror(]b4_locations_if([[yyctx.yylocation, ]])[]b4_trans(["syntax error"])[); + }]], +[simple], [[ + yyerror(]b4_locations_if([[yyctx.yylocation, ]])[]b4_trans(["syntax error"])[);]])[ + } + + /** + * Whether the given yypact_ value indicates a defaulted state. + * @@param yyvalue the value to check + */ + private static boolean yyPactValueIsDefault(int yyvalue) { + return yyvalue == yypact_ninf_; + } + + /** + * Whether the given yytable_ + * value indicates a syntax error. + * @@param yyvalue the value to check + */ + private static boolean yyTableValueIsError(int yyvalue) { + return yyvalue == yytable_ninf_; + } + + private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[; + private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[; + +]b4_parser_tables_define[ + +]b4_parse_trace_if([[ + ]b4_integral_parser_table_define([rline], [b4_rline], + [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ + + + // Report on the debug stream that the rule yyrule is going to be reduced. + private void yyReducePrint (int yyrule, YYStack yystack) + { + if (yydebug == 0) + return; + + int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + /* Print the symbols being reduced, and their result. */ + yycdebug ("Reducing stack by rule " + (yyrule - 1) + + " (line " + yylno + "):"); + + /* The symbols being reduced. */ + for (int yyi = 0; yyi < yynrhs; yyi++) + yySymbolPrint(" $" + (yyi + 1) + " =", + SymbolKind.get(yystos_[yystack.stateAt(yynrhs - (yyi + 1))]), + ]b4_rhs_data(yynrhs, yyi + 1)b4_locations_if([, + b4_rhs_location(yynrhs, yyi + 1)])[); + }]])[ + + /* YYTRANSLATE_(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ + private static final SymbolKind yytranslate_(int t) +]b4_api_token_raw_if(dnl +[[ { + return SymbolKind.get(t); + } +]], +[[ { + // Last valid token kind. + int code_max = ]b4_code_max[; + if (t <= 0) + return ]b4_symbol(eof, kind)[; + else if (t <= code_max) + return SymbolKind.get(yytranslate_table_[t]); + else + return ]b4_symbol(undef, kind)[; + } + ]b4_integral_parser_table_define([translate_table], [b4_translate])[ +]])[ + + private static final int YYLAST_ = ]b4_last[; + private static final int YYEMPTY_ = -2; + private static final int YYFINAL_ = ]b4_final_state_number[; + private static final int YYNTOKENS_ = ]b4_tokens_number[; + +]b4_percent_code_get[ +} +]b4_percent_code_get([[epilogue]])[]dnl +b4_epilogue[]dnl +b4_output_end diff --git a/Engine/bin/bison-flex/data/skeletons/location.cc b/Engine/bin/bison-flex/data/skeletons/location.cc new file mode 100644 index 000000000..3870b2bcc --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/location.cc @@ -0,0 +1,380 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + +m4_pushdef([b4_copyright_years], + [2002-2015, 2018-2021]) + + +# b4_location_file +# ---------------- +# Name of the file containing the position/location class, +# if we want this file. +b4_percent_define_check_file([b4_location_file], + [[api.location.file]], + b4_header_if([[location.hh]])) + +# b4_location_include +# ------------------- +# If location.hh is to be generated, the name under which should it be +# included. +# +# b4_location_path +# ---------------- +# The path to use for the CPP guard. +m4_ifdef([b4_location_file], +[m4_define([b4_location_include], + [b4_percent_define_get([[api.location.include]], + ["b4_location_file"])]) + m4_define([b4_location_path], + b4_percent_define_get([[api.location.include]], + ["b4_mapped_dir_prefix[]b4_location_file"])) + m4_define([b4_location_path], + m4_substr(m4_defn([b4_location_path]), 1, m4_eval(m4_len(m4_defn([b4_location_path])) - 2))) + ]) + + +# b4_position_file +# ---------------- +# Name of the file containing the position class, if we want this file. +b4_header_if( + [b4_required_version_if( + [30200], [], + [m4_ifdef([b4_location_file], + [m4_define([b4_position_file], [position.hh])])])]) + + + +# b4_location_define +# ------------------ +# Define the position and location classes. +m4_define([b4_location_define], +[[ /// A point in a source file. + class position + { + public: + /// Type for file name. + typedef ]b4_percent_define_get([[api.filename.type]])[ filename_type; + /// Type for line and column numbers. + typedef int counter_type; +]m4_ifdef([b4_location_constructors], [[ + /// Construct a position. + explicit position (filename_type* f = YY_NULLPTR, + counter_type l = ]b4_location_initial_line[, + counter_type c = ]b4_location_initial_column[) + : filename (f) + , line (l) + , column (c) + {} + +]])[ + /// Initialization. + void initialize (filename_type* fn = YY_NULLPTR, + counter_type l = ]b4_location_initial_line[, + counter_type c = ]b4_location_initial_column[) + { + filename = fn; + line = l; + column = c; + } + + /** \name Line and Column related manipulators + ** \{ */ + /// (line related) Advance to the COUNT next lines. + void lines (counter_type count = 1) + { + if (count) + { + column = ]b4_location_initial_column[; + line = add_ (line, count, ]b4_location_initial_line[); + } + } + + /// (column related) Advance to the COUNT next columns. + void columns (counter_type count = 1) + { + column = add_ (column, count, ]b4_location_initial_column[); + } + /** \} */ + + /// File name to which this position refers. + filename_type* filename; + /// Current line number. + counter_type line; + /// Current column number. + counter_type column; + + private: + /// Compute max (min, lhs+rhs). + static counter_type add_ (counter_type lhs, counter_type rhs, counter_type min) + { + return lhs + rhs < min ? min : lhs + rhs; + } + }; + + /// Add \a width columns, in place. + inline position& + operator+= (position& res, position::counter_type width) + { + res.columns (width); + return res; + } + + /// Add \a width columns. + inline position + operator+ (position res, position::counter_type width) + { + return res += width; + } + + /// Subtract \a width columns, in place. + inline position& + operator-= (position& res, position::counter_type width) + { + return res += -width; + } + + /// Subtract \a width columns. + inline position + operator- (position res, position::counter_type width) + { + return res -= width; + } +]b4_percent_define_flag_if([[define_location_comparison]], [[ + /// Compare two position objects. + inline bool + operator== (const position& pos1, const position& pos2) + { + return (pos1.line == pos2.line + && pos1.column == pos2.column + && (pos1.filename == pos2.filename + || (pos1.filename && pos2.filename + && *pos1.filename == *pos2.filename))); + } + + /// Compare two position objects. + inline bool + operator!= (const position& pos1, const position& pos2) + { + return !(pos1 == pos2); + } +]])[ + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param pos a reference to the position to redirect + */ + template + std::basic_ostream& + operator<< (std::basic_ostream& ostr, const position& pos) + { + if (pos.filename) + ostr << *pos.filename << ':'; + return ostr << pos.line << '.' << pos.column; + } + + /// Two points in a source file. + class location + { + public: + /// Type for file name. + typedef position::filename_type filename_type; + /// Type for line and column numbers. + typedef position::counter_type counter_type; +]m4_ifdef([b4_location_constructors], [ + /// Construct a location from \a b to \a e. + location (const position& b, const position& e) + : begin (b) + , end (e) + {} + + /// Construct a 0-width location in \a p. + explicit location (const position& p = position ()) + : begin (p) + , end (p) + {} + + /// Construct a 0-width location in \a f, \a l, \a c. + explicit location (filename_type* f, + counter_type l = ]b4_location_initial_line[, + counter_type c = ]b4_location_initial_column[) + : begin (f, l, c) + , end (f, l, c) + {} + +])[ + /// Initialization. + void initialize (filename_type* f = YY_NULLPTR, + counter_type l = ]b4_location_initial_line[, + counter_type c = ]b4_location_initial_column[) + { + begin.initialize (f, l, c); + end = begin; + } + + /** \name Line and Column related manipulators + ** \{ */ + public: + /// Reset initial location to final location. + void step () + { + begin = end; + } + + /// Extend the current location to the COUNT next columns. + void columns (counter_type count = 1) + { + end += count; + } + + /// Extend the current location to the COUNT next lines. + void lines (counter_type count = 1) + { + end.lines (count); + } + /** \} */ + + + public: + /// Beginning of the located region. + position begin; + /// End of the located region. + position end; + }; + + /// Join two locations, in place. + inline location& + operator+= (location& res, const location& end) + { + res.end = end.end; + return res; + } + + /// Join two locations. + inline location + operator+ (location res, const location& end) + { + return res += end; + } + + /// Add \a width columns to the end position, in place. + inline location& + operator+= (location& res, location::counter_type width) + { + res.columns (width); + return res; + } + + /// Add \a width columns to the end position. + inline location + operator+ (location res, location::counter_type width) + { + return res += width; + } + + /// Subtract \a width columns to the end position, in place. + inline location& + operator-= (location& res, location::counter_type width) + { + return res += -width; + } + + /// Subtract \a width columns to the end position. + inline location + operator- (location res, location::counter_type width) + { + return res -= width; + } +]b4_percent_define_flag_if([[define_location_comparison]], [[ + /// Compare two location objects. + inline bool + operator== (const location& loc1, const location& loc2) + { + return loc1.begin == loc2.begin && loc1.end == loc2.end; + } + + /// Compare two location objects. + inline bool + operator!= (const location& loc1, const location& loc2) + { + return !(loc1 == loc2); + } +]])[ + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param loc a reference to the location to redirect + ** + ** Avoid duplicate information. + */ + template + std::basic_ostream& + operator<< (std::basic_ostream& ostr, const location& loc) + { + location::counter_type end_col + = 0 < loc.end.column ? loc.end.column - 1 : 0; + ostr << loc.begin; + if (loc.end.filename + && (!loc.begin.filename + || *loc.begin.filename != *loc.end.filename)) + ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col; + else if (loc.begin.line < loc.end.line) + ostr << '-' << loc.end.line << '.' << end_col; + else if (loc.begin.column < end_col) + ostr << '-' << end_col; + return ostr; + } +]]) + + +m4_ifdef([b4_position_file], [[ +]b4_output_begin([b4_dir_prefix], [b4_position_file])[ +]b4_generated_by[ +// Starting with Bison 3.2, this file is useless: the structure it +// used to define is now defined in "]b4_location_file[". +// +// To get rid of this file: +// 1. add '%require "3.2"' (or newer) to your grammar file +// 2. remove references to this file from your build system +// 3. if you used to include it, include "]b4_location_file[" instead. + +#include ]b4_location_include[ +]b4_output_end[ +]]) + + +m4_ifdef([b4_location_file], [[ +]b4_output_begin([b4_dir_prefix], [b4_location_file])[ +]b4_copyright([Locations for Bison parsers in C++])[ +/** + ** \file ]b4_location_path[ + ** Define the ]b4_namespace_ref[::location class. + */ + +]b4_cpp_guard_open([b4_location_path])[ + +# include +# include + +]b4_null_define[ + +]b4_namespace_open[ +]b4_location_define[ +]b4_namespace_close[ +]b4_cpp_guard_close([b4_location_path])[ +]b4_output_end[ +]]) + + +m4_popdef([b4_copyright_years]) diff --git a/Engine/bin/bison-flex/data/skeletons/stack.hh b/Engine/bin/bison-flex/data/skeletons/stack.hh new file mode 100644 index 000000000..98913258f --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/stack.hh @@ -0,0 +1,157 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + + +# b4_stack_file +# ------------- +# Name of the file containing the stack class, if we want this file. +b4_header_if([b4_required_version_if([30200], [], + [m4_define([b4_stack_file], [stack.hh])])]) + + +# b4_stack_define +# --------------- +m4_define([b4_stack_define], +[[ /// A stack with random access from its top. + template > + class stack + { + public: + // Hide our reversed order. + typedef typename S::iterator iterator; + typedef typename S::const_iterator const_iterator; + typedef typename S::size_type size_type; + typedef typename std::ptrdiff_t index_type; + + stack (size_type n = 200) YY_NOEXCEPT + : seq_ (n) + {} + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + stack (const stack&) = delete; + /// Non copyable. + stack& operator= (const stack&) = delete; +#endif + + /// Random access. + /// + /// Index 0 returns the topmost element. + const T& + operator[] (index_type i) const + { + return seq_[size_type (size () - 1 - i)]; + } + + /// Random access. + /// + /// Index 0 returns the topmost element. + T& + operator[] (index_type i) + { + return seq_[size_type (size () - 1 - i)]; + } + + /// Steal the contents of \a t. + /// + /// Close to move-semantics. + void + push (YY_MOVE_REF (T) t) + { + seq_.push_back (T ()); + operator[] (0).move (t); + } + + /// Pop elements from the stack. + void + pop (std::ptrdiff_t n = 1) YY_NOEXCEPT + { + for (; 0 < n; --n) + seq_.pop_back (); + } + + /// Pop all elements from the stack. + void + clear () YY_NOEXCEPT + { + seq_.clear (); + } + + /// Number of elements on the stack. + index_type + size () const YY_NOEXCEPT + { + return index_type (seq_.size ()); + } + + /// Iterator on top of the stack (going downwards). + const_iterator + begin () const YY_NOEXCEPT + { + return seq_.begin (); + } + + /// Bottom of the stack. + const_iterator + end () const YY_NOEXCEPT + { + return seq_.end (); + } + + /// Present a slice of the top of a stack. + class slice + { + public: + slice (const stack& stack, index_type range) YY_NOEXCEPT + : stack_ (stack) + , range_ (range) + {} + + const T& + operator[] (index_type i) const + { + return stack_[range_ - i]; + } + + private: + const stack& stack_; + index_type range_; + }; + + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + stack (const stack&); + /// Non copyable. + stack& operator= (const stack&); +#endif + /// The wrapped container. + S seq_; + }; +]]) + +m4_ifdef([b4_stack_file], +[b4_output_begin([b4_dir_prefix], [b4_stack_file])[ +]b4_generated_by[ +// Starting with Bison 3.2, this file is useless: the structure it +// used to define is now defined with the parser itself. +// +// To get rid of this file: +// 1. add '%require "3.2"' (or newer) to your grammar file +// 2. remove references to this file from your build system. +]b4_output_end[ +]]) diff --git a/Engine/bin/bison-flex/data/skeletons/traceon.m4 b/Engine/bin/bison-flex/data/skeletons/traceon.m4 new file mode 100644 index 000000000..344d7d1c5 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/traceon.m4 @@ -0,0 +1,2 @@ +dnl GNU M4 treats -dV in a position-independent manner. +m4_debugmode(V)m4_traceon()dnl diff --git a/Engine/bin/bison-flex/data/skeletons/variant.hh b/Engine/bin/bison-flex/data/skeletons/variant.hh new file mode 100644 index 000000000..2a490e8fa --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/variant.hh @@ -0,0 +1,525 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# 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, see . + + +## --------- ## +## variant. ## +## --------- ## + +# b4_assert +# --------- +# The name of YY_ASSERT. +m4_define([b4_assert], + [b4_api_PREFIX[]_ASSERT]) + + +# b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS]) +# ------------------------------------------------ +# Run some ACTION ("build", or "destroy") on YYVAL of symbol type +# YYTYPE. +m4_define([b4_symbol_variant], +[m4_pushdef([b4_dollar_dollar], + [$2.$3< $][3 > (m4_shift3($@))])dnl +switch ($1) + { +b4_type_foreach([_b4_type_action])[]dnl + default: + break; + } +m4_popdef([b4_dollar_dollar])dnl +]) + + +# _b4_char_sizeof_counter +# ----------------------- +# A counter used by _b4_char_sizeof_dummy to create fresh symbols. +m4_define([_b4_char_sizeof_counter], +[0]) + +# _b4_char_sizeof_dummy +# --------------------- +# At each call return a new C++ identifier. +m4_define([_b4_char_sizeof_dummy], +[m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl +dummy[]_b4_char_sizeof_counter]) + + +# b4_char_sizeof(SYMBOL-NUMS) +# --------------------------- +# To be mapped on the list of type names to produce: +# +# char dummy1[sizeof (type_name_1)]; +# char dummy2[sizeof (type_name_2)]; +# +# for defined type names. +m4_define([b4_char_sizeof], +[b4_symbol_if([$1], [has_type], +[ +m4_map([ b4_symbol_tag_comment], [$@])dnl + char _b4_char_sizeof_dummy@{sizeof (b4_symbol([$1], [type]))@}; +])]) + + +# b4_variant_includes +# ------------------- +# The needed includes for variants support. +m4_define([b4_variant_includes], +[b4_parse_assert_if([[#include +#ifndef ]b4_assert[ +# include +# define ]b4_assert[ assert +#endif +]])]) + + + +## -------------------------- ## +## Adjustments for variants. ## +## -------------------------- ## + + +# b4_value_type_declare +# --------------------- +# Define value_type. +m4_define([b4_value_type_declare], +[[ /// A buffer to store and retrieve objects. + /// + /// Sort of a variant, but does not keep track of the nature + /// of the stored data, since that knowledge is available + /// via the current parser state. + class value_type + { + public: + /// Type of *this. + typedef value_type self_type; + + /// Empty construction. + value_type () YY_NOEXCEPT + : yyraw_ ()]b4_parse_assert_if([ + , yytypeid_ (YY_NULLPTR)])[ + {} + + /// Construct and fill. + template + value_type (YY_RVREF (T) t)]b4_parse_assert_if([ + : yytypeid_ (&typeid (T))])[ + {]b4_parse_assert_if([[ + ]b4_assert[ (sizeof (T) <= size);]])[ + new (yyas_ ()) T (YY_MOVE (t)); + } + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + value_type (const self_type&) = delete; + /// Non copyable. + self_type& operator= (const self_type&) = delete; +#endif + + /// Destruction, allowed only if empty. + ~value_type () YY_NOEXCEPT + {]b4_parse_assert_if([ + ]b4_assert[ (!yytypeid_); + ])[} + +# if 201103L <= YY_CPLUSPLUS + /// Instantiate a \a T in here from \a t. + template + T& + emplace (U&&... u) + {]b4_parse_assert_if([[ + ]b4_assert[ (!yytypeid_); + ]b4_assert[ (sizeof (T) <= size); + yytypeid_ = & typeid (T);]])[ + return *new (yyas_ ()) T (std::forward (u)...); + } +# else + /// Instantiate an empty \a T in here. + template + T& + emplace () + {]b4_parse_assert_if([[ + ]b4_assert[ (!yytypeid_); + ]b4_assert[ (sizeof (T) <= size); + yytypeid_ = & typeid (T);]])[ + return *new (yyas_ ()) T (); + } + + /// Instantiate a \a T in here from \a t. + template + T& + emplace (const T& t) + {]b4_parse_assert_if([[ + ]b4_assert[ (!yytypeid_); + ]b4_assert[ (sizeof (T) <= size); + yytypeid_ = & typeid (T);]])[ + return *new (yyas_ ()) T (t); + } +# endif + + /// Instantiate an empty \a T in here. + /// Obsolete, use emplace. + template + T& + build () + { + return emplace (); + } + + /// Instantiate a \a T in here from \a t. + /// Obsolete, use emplace. + template + T& + build (const T& t) + { + return emplace (t); + } + + /// Accessor to a built \a T. + template + T& + as () YY_NOEXCEPT + {]b4_parse_assert_if([[ + ]b4_assert[ (yytypeid_); + ]b4_assert[ (*yytypeid_ == typeid (T)); + ]b4_assert[ (sizeof (T) <= size);]])[ + return *yyas_ (); + } + + /// Const accessor to a built \a T (for %printer). + template + const T& + as () const YY_NOEXCEPT + {]b4_parse_assert_if([[ + ]b4_assert[ (yytypeid_); + ]b4_assert[ (*yytypeid_ == typeid (T)); + ]b4_assert[ (sizeof (T) <= size);]])[ + return *yyas_ (); + } + + /// Swap the content with \a that, of same type. + /// + /// Both variants must be built beforehand, because swapping the actual + /// data requires reading it (with as()), and this is not possible on + /// unconstructed variants: it would require some dynamic testing, which + /// should not be the variant's responsibility. + /// Swapping between built and (possibly) non-built is done with + /// self_type::move (). + template + void + swap (self_type& that) YY_NOEXCEPT + {]b4_parse_assert_if([[ + ]b4_assert[ (yytypeid_); + ]b4_assert[ (*yytypeid_ == *that.yytypeid_);]])[ + std::swap (as (), that.as ()); + } + + /// Move the content of \a that to this. + /// + /// Destroys \a that. + template + void + move (self_type& that) + { +# if 201103L <= YY_CPLUSPLUS + emplace (std::move (that.as ())); +# else + emplace (); + swap (that); +# endif + that.destroy (); + } + +# if 201103L <= YY_CPLUSPLUS + /// Move the content of \a that to this. + template + void + move (self_type&& that) + { + emplace (std::move (that.as ())); + that.destroy (); + } +#endif + + /// Copy the content of \a that to this. + template + void + copy (const self_type& that) + { + emplace (that.as ()); + } + + /// Destroy the stored \a T. + template + void + destroy () + { + as ().~T ();]b4_parse_assert_if([ + yytypeid_ = YY_NULLPTR;])[ + } + + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + value_type (const self_type&); + /// Non copyable. + self_type& operator= (const self_type&); +#endif + + /// Accessor to raw memory as \a T. + template + T* + yyas_ () YY_NOEXCEPT + { + void *yyp = yyraw_; + return static_cast (yyp); + } + + /// Const accessor to raw memory as \a T. + template + const T* + yyas_ () const YY_NOEXCEPT + { + const void *yyp = yyraw_; + return static_cast (yyp); + } + + /// An auxiliary type to compute the largest semantic type. + union union_type + {]b4_type_foreach([b4_char_sizeof])[ }; + + /// The size of the largest semantic type. + enum { size = sizeof (union_type) }; + + /// A buffer to store semantic values. + union + { + /// Strongest alignment constraints. + long double yyalign_me_; + /// A buffer large enough to store any of the semantic values. + char yyraw_[size]; + };]b4_parse_assert_if([ + + /// Whether the content is built: if defined, the name of the stored type. + const std::type_info *yytypeid_;])[ + }; +]]) + + +# How the semantic value is extracted when using variants. + +# b4_symbol_value(VAL, SYMBOL-NUM, [TYPE]) +# ---------------------------------------- +# See README. +m4_define([b4_symbol_value], +[m4_ifval([$3], + [$1.as< $3 > ()], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [$1.as < b4_symbol([$2], [type]) > ()], + [$1])], + [$1])])]) + +# b4_symbol_value_template(VAL, SYMBOL-NUM, [TYPE]) +# ------------------------------------------------- +# Same as b4_symbol_value, but used in a template method. +m4_define([b4_symbol_value_template], +[m4_ifval([$3], + [$1.template as< $3 > ()], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [$1.template as < b4_symbol([$2], [type]) > ()], + [$1])], + [$1])])]) + + + +## ------------- ## +## make_SYMBOL. ## +## ------------- ## + + +# _b4_includes_tokens(SYMBOL-NUM...) +# ---------------------------------- +# Expands to non-empty iff one of the SYMBOL-NUM denotes +# a token. +m4_define([_b4_is_token], + [b4_symbol_if([$1], [is_token], [1])]) +m4_define([_b4_includes_tokens], + [m4_map([_b4_is_token], [$@])]) + + +# _b4_token_maker_define(SYMBOL-NUM) +# ---------------------------------- +# Declare make_SYMBOL for SYMBOL-NUM. Use at class-level. +m4_define([_b4_token_maker_define], +[b4_token_visible_if([$1], +[#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_[]_b4_symbol([$1], [id]) (b4_join( + b4_symbol_if([$1], [has_type], + [b4_symbol([$1], [type]) v]), + b4_locations_if([location_type l]))) + { + return symbol_type (b4_join([token::b4_symbol([$1], [id])], + b4_symbol_if([$1], [has_type], [std::move (v)]), + b4_locations_if([std::move (l)]))); + } +#else + static + symbol_type + make_[]_b4_symbol([$1], [id]) (b4_join( + b4_symbol_if([$1], [has_type], + [const b4_symbol([$1], [type])& v]), + b4_locations_if([const location_type& l]))) + { + return symbol_type (b4_join([token::b4_symbol([$1], [id])], + b4_symbol_if([$1], [has_type], [v]), + b4_locations_if([l]))); + } +#endif +])]) + + +# b4_token_kind(SYMBOL-NUM) +# ------------------------- +# Some tokens don't have an ID. +m4_define([b4_token_kind], +[b4_symbol_if([$1], [has_id], + [token::b4_symbol([$1], [id])], + [b4_symbol([$1], [code])])]) + + +# _b4_tok_in(SYMBOL-NUM, ...) +# --------------------------- +# See b4_tok_in below. The SYMBOL-NUMs... are tokens only. +# +# We iterate over the tokens to group them by "range" of token numbers (not +# symbols numbers!). +# +# b4_fst is the start of that range. +# b4_prev is the previous value. +# b4_val is the current value. +# If b4_val is the successor of b4_prev in token numbers, update the latter, +# otherwise emit the code for range b4_fst .. b4_prev. +# $1 is also used as a terminator in the foreach, but it will not be printed. +# +m4_define([_b4_tok_in], +[m4_pushdef([b4_prev], [$1])dnl +m4_pushdef([b4_fst], [$1])dnl +m4_pushdef([b4_sep], [])dnl +m4_foreach([b4_val], m4_dquote(m4_shift($@, $1)), + [m4_if(b4_symbol(b4_val, [code]), m4_eval(b4_symbol(b4_prev, [code]) + 1), [], + [b4_sep[]m4_if(b4_fst, b4_prev, + [tok == b4_token_kind(b4_fst)], + [(b4_token_kind(b4_fst) <= tok && tok <= b4_token_kind(b4_prev))])[]dnl +m4_define([b4_fst], b4_val)dnl +m4_define([b4_sep], [ + || ])])dnl +m4_define([b4_prev], b4_val)])dnl +m4_popdef([b4_sep])dnl +m4_popdef([b4_fst])dnl +m4_popdef([b4_prev])dnl +]) + + +# _b4_filter_tokens(SYMBOL-NUM, ...) +# ---------------------------------- +# Expand as the list of tokens amongst SYMBOL-NUM. +m4_define([_b4_filter_tokens], +[m4_pushdef([b4_sep])dnl +m4_foreach([b4_val], [$@], + [b4_symbol_if(b4_val, [is_token], [b4_sep[]b4_val[]m4_define([b4_sep], [,])])])dnl +m4_popdef([b4_sep])dnl +]) + + +# b4_tok_in(SYMBOL-NUM, ...) +# --------------------------- +# A C++ conditional that checks that `tok` is a member of this list of symbol +# numbers. +m4_define([b4_tok_in], + [_$0(_b4_filter_tokens($@))]) + + + + +# _b4_symbol_constructor_define(SYMBOL-NUM...) +# -------------------------------------------- +# Define a symbol_type constructor common to all the SYMBOL-NUM (they +# have the same type). Use at class-level. +m4_define([_b4_symbol_constructor_define], +[m4_ifval(_b4_includes_tokens($@), +[[#if 201103L <= YY_CPLUSPLUS + symbol_type (]b4_join( + [int tok], + b4_symbol_if([$1], [has_type], + [b4_symbol([$1], [type]) v]), + b4_locations_if([location_type l]))[) + : super_type (]b4_join([token_kind_type (tok)], + b4_symbol_if([$1], [has_type], [std::move (v)]), + b4_locations_if([std::move (l)]))[) +#else + symbol_type (]b4_join( + [int tok], + b4_symbol_if([$1], [has_type], + [const b4_symbol([$1], [type])& v]), + b4_locations_if([const location_type& l]))[) + : super_type (]b4_join([token_kind_type (tok)], + b4_symbol_if([$1], [has_type], [v]), + b4_locations_if([l]))[) +#endif + {]b4_parse_assert_if([[ +#if !defined _MSC_VER || defined __clang__ + ]b4_assert[ (]b4_tok_in($@)[); +#endif + ]])[} +]])]) + + +# b4_basic_symbol_constructor_define(SYMBOL-NUM) +# ---------------------------------------------- +# Generate a constructor for basic_symbol from given type. +m4_define([b4_basic_symbol_constructor_define], +[[#if 201103L <= YY_CPLUSPLUS + basic_symbol (]b4_join( + [typename Base::kind_type t], + b4_symbol_if([$1], [has_type], [b4_symbol([$1], [type])&& v]), + b4_locations_if([location_type&& l]))[) + : Base (t)]b4_symbol_if([$1], [has_type], [ + , value (std::move (v))])[]b4_locations_if([ + , location (std::move (l))])[ + {} +#else + basic_symbol (]b4_join( + [typename Base::kind_type t], + b4_symbol_if([$1], [has_type], [const b4_symbol([$1], [type])& v]), + b4_locations_if([const location_type& l]))[) + : Base (t)]b4_symbol_if([$1], [has_type], [ + , value (v)])[]b4_locations_if([ + , location (l)])[ + {} +#endif +]]) + + +# b4_token_constructor_define +# --------------------------- +# Define the overloaded versions of make_FOO for all the token kinds. +m4_define([b4_token_constructor_define], +[ // Implementation of make_symbol for each token kind. +b4_symbol_foreach([_b4_token_maker_define])]) diff --git a/Engine/bin/bison-flex/data/skeletons/yacc.c b/Engine/bin/bison-flex/data/skeletons/yacc.c new file mode 100644 index 000000000..64b9ac625 --- /dev/null +++ b/Engine/bin/bison-flex/data/skeletons/yacc.c @@ -0,0 +1,2209 @@ +# -*- C -*- +# Yacc compatible skeleton for Bison + +# Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software +# Foundation, Inc. + +m4_pushdef([b4_copyright_years], + [1984, 1989-1990, 2000-2015, 2018-2021]) + +# 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 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, see . + +m4_include(b4_skeletonsdir/[c.m4]) + + +## ---------- ## +## api.pure. ## +## ---------- ## + +b4_percent_define_default([[api.pure]], [[false]]) +b4_percent_define_check_values([[[[api.pure]], + [[false]], [[true]], [[]], [[full]]]]) + +m4_define([b4_pure_flag], [[0]]) +m4_case(b4_percent_define_get([[api.pure]]), + [false], [m4_define([b4_pure_flag], [[0]])], + [true], [m4_define([b4_pure_flag], [[1]])], + [], [m4_define([b4_pure_flag], [[1]])], + [full], [m4_define([b4_pure_flag], [[2]])]) + +m4_define([b4_pure_if], +[m4_case(b4_pure_flag, + [0], [$2], + [1], [$1], + [2], [$1])]) + [m4_fatal([invalid api.pure value: ]$1)])]) + +## --------------- ## +## api.push-pull. ## +## --------------- ## + +# b4_pull_if, b4_push_if +# ---------------------- +# Whether the pull/push APIs are needed. Both can be enabled. + +b4_percent_define_default([[api.push-pull]], [[pull]]) +b4_percent_define_check_values([[[[api.push-pull]], + [[pull]], [[push]], [[both]]]]) +b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) +b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) +m4_case(b4_percent_define_get([[api.push-pull]]), + [pull], [m4_define([b4_push_flag], [[0]])], + [push], [m4_define([b4_pull_flag], [[0]])]) + +# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing +# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the +# behavior of Bison at all when push parsing is already requested. +b4_define_flag_if([use_push_for_pull]) +b4_use_push_for_pull_if([ + b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], + [m4_define([b4_push_flag], [[1]])])]) + +## ----------- ## +## parse.lac. ## +## ----------- ## + +b4_percent_define_default([[parse.lac]], [[none]]) +b4_percent_define_default([[parse.lac.es-capacity-initial]], [[20]]) +b4_percent_define_default([[parse.lac.memory-trace]], [[failures]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]], + [[[[parse.lac.memory-trace]], + [[failures]], [[full]]]]) +b4_define_flag_if([lac]) +m4_define([b4_lac_flag], + [m4_if(b4_percent_define_get([[parse.lac]]), + [none], [[0]], [[1]])]) + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + + +# b4_yyerror_arg_loc_if(ARG) +# -------------------------- +# Expand ARG iff yyerror is to be given a location as argument. +m4_define([b4_yyerror_arg_loc_if], +[b4_locations_if([m4_case(b4_pure_flag, + [1], [m4_ifset([b4_parse_param], [$1])], + [2], [$1])])]) + +# b4_yyerror_formals +# ------------------ +m4_define([b4_yyerror_formals], +[b4_pure_if([b4_locations_if([, [[const ]b4_api_PREFIX[LTYPE *yyllocp], [&yylloc]]])[]dnl +m4_ifdef([b4_parse_param], [, b4_parse_param])[]dnl +,])dnl +[[const char *msg], [msg]]]) + + + +# b4_yyerror_args +# --------------- +# Arguments passed to yyerror: user args plus yylloc. +m4_define([b4_yyerror_args], +[b4_yyerror_arg_loc_if([&yylloc, ])dnl +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_accept([SYMBOL-NUM]) +# ----------------------- +# Used in actions of the rules of accept, the initial symbol, to call +# YYACCEPT. If SYMBOL-NUM is specified, run "yyvalue->SLOT = $2;" +# before, using the slot of SYMBOL-NUM. +m4_define([b4_accept], +[m4_ifval([$1], + [b4_symbol_value(yyimpl->yyvalue, [$1]) = b4_rhs_value(2, 1, [$1]); ]) YYACCEPT]) + + +# b4_lhs_value(SYMBOL-NUM, [TYPE]) +# -------------------------------- +# See README. +m4_define([b4_lhs_value], +[b4_symbol_value(yyval, [$1], [$2])]) + + +# b4_rhs_value(RULE-LENGTH, POS, [SYMBOL-NUM], [TYPE]) +# ---------------------------------------------------- +# See README. +m4_define([b4_rhs_value], +[b4_symbol_value([yyvsp@{b4_subtract([$2], [$1])@}], [$3], [$4])]) + + +## ----------- ## +## Locations. ## +## ----------- ## + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +# Overparenthetized to avoid obscure problems with "foo$$bar = foo$1bar". +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, POS) +# --------------------------------- +# Expansion of @POS, where the current rule has RULE-LENGTH symbols +# on RHS. +# Overparenthetized to avoid obscure problems with "foo$$bar = foo$1bar". +m4_define([b4_rhs_location], +[(yylsp@{b4_subtract([$2], [$1])@})]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + +# _b4_declare_sub_yyparse(START-SYMBOL-NUM, SWITCHING-TOKEN-SYMBOL-NUM) +# --------------------------------------------------------------------- +# Define the return type of the parsing function for SYMBOL-NUM, and +# declare its parsing function. +m4_define([_b4_declare_sub_yyparse], +[[ +// Return type when parsing one ]_b4_symbol($1, tag)[. +typedef struct +{]b4_symbol_if([$1], [has_type], [[ + ]_b4_symbol($1, type)[ yyvalue;]])[ + int yystatus; + int yynerrs; +} ]b4_prefix[parse_]_b4_symbol($1, id)[_t; + +// Parse one ]_b4_symbol($1, tag)[. +]b4_prefix[parse_]_b4_symbol($1, id)[_t ]b4_prefix[parse_]_b4_symbol($1, id)[ (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[); +]]) + + +# _b4_first_switching_token +# ------------------------- +m4_define([b4_first], [$1]) +m4_define([b4_second], [$2]) +m4_define([_b4_first_switching_token], +[b4_second(b4_first(b4_start_symbols))]) + + +# _b4_define_sub_yyparse(START-SYMBOL-NUM, SWITCHING-TOKEN-SYMBOL-NUM) +# -------------------------------------------------------------------- +# Define the parsing function for START-SYMBOL-NUM. +m4_define([_b4_define_sub_yyparse], +[[ +]b4_prefix[parse_]_b4_symbol($1, id)[_t +]b4_prefix[parse_]_b4_symbol($1, id)[ (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[) +{ + ]b4_prefix[parse_]_b4_symbol($1, id)[_t yyres; + yy_parse_impl_t yyimpl; + yyres.yystatus = yy_parse_impl (]b4_symbol($2, id)[, &yyimpl]m4_ifset([b4_parse_param], + [[, ]b4_args(b4_parse_param)])[);]b4_symbol_if([$1], [has_type], [[ + yyres.yyvalue = yyimpl.yyvalue.]b4_symbol($1, slot)[;]])[ + yyres.yynerrs = yyimpl.yynerrs; + return yyres; +} +]]) + + +# b4_declare_scanner_communication_variables +# ------------------------------------------ +# Declare the variables that are global, or local to YYPARSE if +# pure-parser. +m4_define([b4_declare_scanner_communication_variables], [[ +]m4_ifdef([b4_start_symbols], [], +[[/* Lookahead token kind. */ +int yychar; +]])[ +]b4_pure_if([[ +/* The semantic value of the lookahead symbol. */ +/* Default value used for initialization, for pacifying older GCCs + or non-GCC compilers. */ +YY_INITIAL_VALUE (static YYSTYPE yyval_default;) +YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);]b4_locations_if([[ + +/* Location data for the lookahead symbol. */ +static YYLTYPE yyloc_default]b4_yyloc_default[; +YYLTYPE yylloc = yyloc_default;]])], +[[/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval;]b4_locations_if([[ +/* Location data for the lookahead symbol. */ +YYLTYPE yylloc]b4_yyloc_default[;]])[ +/* Number of syntax errors so far. */ +int yynerrs;]])]) + + +# b4_declare_parser_state_variables([INIT]) +# ----------------------------------------- +# Declare all the variables that are needed to maintain the parser state +# between calls to yypush_parse. +# If INIT is non-null, initialize these variables. +m4_define([b4_declare_parser_state_variables], +[b4_pure_if([[ + /* Number of syntax errors so far. */ + int yynerrs]m4_ifval([$1], [ = 0])[; +]])[ + yy_state_fast_t yystate]m4_ifval([$1], [ = 0])[; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus]m4_ifval([$1], [ = 0])[; + + /* Refer to the stacks through separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* Their size. */ + YYPTRDIFF_T yystacksize]m4_ifval([$1], [ = YYINITDEPTH])[; + + /* The state stack: array, bottom, top. */ + yy_state_t yyssa[YYINITDEPTH]; + yy_state_t *yyss]m4_ifval([$1], [ = yyssa])[; + yy_state_t *yyssp]m4_ifval([$1], [ = yyss])[; + + /* The semantic value stack: array, bottom, top. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs]m4_ifval([$1], [ = yyvsa])[; + YYSTYPE *yyvsp]m4_ifval([$1], [ = yyvs])[;]b4_locations_if([[ + + /* The location stack: array, bottom, top. */ + YYLTYPE yylsa[YYINITDEPTH]; + YYLTYPE *yyls]m4_ifval([$1], [ = yylsa])[; + YYLTYPE *yylsp]m4_ifval([$1], [ = yyls])[;]])[]b4_lac_if([[ + + yy_state_t yyesa@{]b4_percent_define_get([[parse.lac.es-capacity-initial]])[@}; + yy_state_t *yyes]m4_ifval([$1], [ = yyesa])[; + YYPTRDIFF_T yyes_capacity][]m4_ifval([$1], + [m4_do([ = b4_percent_define_get([[parse.lac.es-capacity-initial]]) < YYMAXDEPTH], + [ ? b4_percent_define_get([[parse.lac.es-capacity-initial]])], + [ : YYMAXDEPTH])])[;]])]) + + +m4_define([b4_macro_define], +[[#]define $1 $2]) + +m4_define([b4_macro_undef], +[[#]undef $1]) + +m4_define([b4_pstate_macro_define], +[b4_macro_define([$1], [yyps->$1])]) + +# b4_parse_state_variable_macros(b4_macro_define|b4_macro_undef) +# -------------------------------------------------------------- +m4_define([b4_parse_state_variable_macros], +[b4_pure_if([$1([b4_prefix[]nerrs])]) +$1([yystate]) +$1([yyerrstatus]) +$1([yyssa]) +$1([yyss]) +$1([yyssp]) +$1([yyvsa]) +$1([yyvs]) +$1([yyvsp])[]b4_locations_if([ +$1([yylsa]) +$1([yyls]) +$1([yylsp])]) +$1([yystacksize])[]b4_lac_if([ +$1([yyesa]) +$1([yyes]) +$1([yyes_capacity])])]) + + + + +# _b4_declare_yyparse_push +# ------------------------ +# Declaration of yyparse (and dependencies) when using the push parser +# (including in pull mode). +m4_define([_b4_declare_yyparse_push], +[[#ifndef YYPUSH_MORE_DEFINED +# define YYPUSH_MORE_DEFINED +enum { YYPUSH_MORE = 4 }; +#endif + +typedef struct ]b4_prefix[pstate ]b4_prefix[pstate; + +]b4_pull_if([[ +int ]b4_prefix[parse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[);]])[ +int ]b4_prefix[push_parse (]b4_prefix[pstate *ps]b4_pure_if([[, + int pushed_char, ]b4_api_PREFIX[STYPE const *pushed_val]b4_locations_if([[, ]b4_api_PREFIX[LTYPE *pushed_loc]])])b4_user_formals[); +]b4_pull_if([[int ]b4_prefix[pull_parse (]b4_prefix[pstate *ps]b4_user_formals[);]])[ +]b4_prefix[pstate *]b4_prefix[pstate_new (void); +void ]b4_prefix[pstate_delete (]b4_prefix[pstate *ps); +]]) + + +# _b4_declare_yyparse +# ------------------- +# When not the push parser. +m4_define([_b4_declare_yyparse], +[[int ]b4_prefix[parse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[); +]m4_ifdef([b4_start_symbols], + [m4_map([_b4_declare_sub_yyparse], m4_defn([b4_start_symbols]))])]) + + +# b4_declare_yyparse +# ------------------ +m4_define([b4_declare_yyparse], +[b4_push_if([_b4_declare_yyparse_push], + [_b4_declare_yyparse])[]dnl +]) + + +# b4_declare_yyerror_and_yylex +# ---------------------------- +# Comply with POSIX Yacc. +# +m4_define([b4_declare_yyerror_and_yylex], +[b4_posix_if([[#if !defined ]b4_prefix[error && !defined ]b4_api_PREFIX[ERROR_IS_DECLARED +]b4_function_declare([b4_prefix[error]], void, b4_yyerror_formals)[ +#endif +#if !defined ]b4_prefix[lex && !defined ]b4_api_PREFIX[LEX_IS_DECLARED +]b4_function_declare([b4_prefix[lex]], int, b4_yylex_formals)[ +#endif +]])dnl +]) + + +# b4_shared_declarations +# ---------------------- +# Declarations that might either go into the header (if --header) +# or into the implementation file. +m4_define([b4_shared_declarations], +[b4_cpp_guard_open([b4_spec_mapped_header_file])[ +]b4_declare_yydebug[ +]b4_percent_code_get([[requires]])[ +]b4_token_enums_defines[ +]b4_declare_yylstype[ +]b4_declare_yyerror_and_yylex[ +]b4_declare_yyparse[ +]b4_percent_code_get([[provides]])[ +]b4_cpp_guard_close([b4_spec_mapped_header_file])[]dnl +]) + + +# b4_header_include_if(IF-TRUE, IF-FALSE) +# --------------------------------------- +# Run IF-TRUE if we generate an output file and api.header.include +# is defined. +m4_define([b4_header_include_if], +[m4_ifval(m4_quote(b4_spec_header_file), + [b4_percent_define_ifdef([[api.header.include]], + [$1], + [$2])], + [$2])]) + +m4_if(b4_spec_header_file, [y.tab.h], [], + [b4_percent_define_default([[api.header.include]], + [["@basename(]b4_spec_header_file[@)"]])]) + + + + +## -------------- ## +## Output files. ## +## -------------- ## + + +b4_header_if([[ +]b4_output_begin([b4_spec_header_file])[ +]b4_copyright([Bison interface for Yacc-like parsers in C])[ +]b4_disclaimer[ +]b4_shared_declarations[ +]b4_output_end[ +]])# b4_header_if + +b4_output_begin([b4_parser_file_name])[ +]b4_copyright([Bison implementation for Yacc-like parsers in C])[ +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +]b4_disclaimer[ +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +]b4_identification[ +]b4_percent_code_get([[top]])[]dnl +m4_if(b4_api_prefix, [yy], [], +[[/* Substitute the type names. */ +#define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[ +#define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[ +]m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */]b4_pull_if([[ +#define yyparse ]b4_prefix[parse]])b4_push_if([[ +#define yypush_parse ]b4_prefix[push_parse]b4_pull_if([[ +#define yypull_parse ]b4_prefix[pull_parse]])[ +#define yypstate_new ]b4_prefix[pstate_new +#define yypstate_clear ]b4_prefix[pstate_clear +#define yypstate_delete ]b4_prefix[pstate_delete +#define yypstate ]b4_prefix[pstate]])[ +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug +#define yynerrs ]b4_prefix[nerrs]]b4_pure_if([], [[ +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])]))[ + +]b4_user_pre_prologue[ +]b4_cast_define[ +]b4_null_define[ + +]b4_header_include_if([[#include ]b4_percent_define_get([[api.header.include]])], + [m4_ifval(m4_quote(b4_spec_header_file), + [/* Use api.header.include to #include this header + instead of duplicating it here. */ +])b4_shared_declarations])[ +]b4_declare_symbol_enum[ + +]b4_user_post_prologue[ +]b4_percent_code_get[ +]b4_c99_int_type_define[ + +]b4_sizes_types_define[ + +/* Stored state numbers (used for stacks). */ +typedef ]b4_int_type(0, m4_eval(b4_states_number - 1))[ yy_state_t; + +/* State numbers in computations. */ +typedef int yy_state_fast_t; + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif +]b4_has_translations_if([ +#ifndef N_ +# define N_(Msgid) Msgid +#endif +])[ + +]b4_attribute_define[ + +]b4_parse_assert_if([[#ifdef NDEBUG +# define YY_ASSERT(E) ((void) (0 && (E))) +#else +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_ASSERT(E) assert (E) +#endif +]], +[[#define YY_ASSERT(E) ((void) (0 && (E)))]])[ + +#if ]b4_lac_if([[1]], [b4_parse_error_case([simple], [[!defined yyoverflow]], [[1]])])[ + +/* The parser invokes alloca or malloc; define the necessary symbols. */]dnl +b4_push_if([], [b4_lac_if([], [[ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS +# include /* INFRINGES ON USER NAME SPACE */ + /* Use EXIT_SUCCESS as a witness for stdlib.h. */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif]])])[ + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's 'empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif]b4_lac_if([[ +# define YYCOPY_NEEDED 1]])[ +#endif /* ]b4_lac_if([[1]], [b4_parse_error_case([simple], [[!defined yyoverflow]], [[1]])])[ */ + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (]b4_locations_if([[defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL \ + && ]])[defined ]b4_api_PREFIX[STYPE_IS_TRIVIAL && ]b4_api_PREFIX[STYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yy_state_t yyss_alloc; + YYSTYPE yyvs_alloc;]b4_locations_if([ + YYLTYPE yyls_alloc;])[ +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +]b4_locations_if( +[# define YYSTACK_BYTES(N) \ + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \ + + YYSIZEOF (YYLTYPE)) \ + + 2 * YYSTACK_GAP_MAXIMUM)], +[# define YYSTACK_BYTES(N) \ + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM)])[ + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYPTRDIFF_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / YYSIZEOF (*yyptr); \ + } \ + while (0) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from SRC to DST. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(Dst, Src, Count) \ + __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) +# else +# define YYCOPY(Dst, Src, Count) \ + do \ + { \ + YYPTRDIFF_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (Dst)[yyi] = (Src)[yyi]; \ + } \ + while (0) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL ]b4_final_state_number[ +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST ]b4_last[ + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS ]b4_tokens_number[ +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS ]b4_nterms_number[ +/* YYNRULES -- Number of rules. */ +#define YYNRULES ]b4_rules_number[ +/* YYNSTATES -- Number of states. */ +#define YYNSTATES ]b4_states_number[ + +/* YYMAXUTOK -- Last valid token kind. */ +#define YYMAXUTOK ]b4_code_max[ + + +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ +]b4_api_token_raw_if(dnl +[[#define YYTRANSLATE(YYX) YY_CAST (yysymbol_kind_t, YYX)]], +[[#define YYTRANSLATE(YYX) \ + (0 <= (YYX) && (YYX) <= YYMAXUTOK \ + ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ + : ]b4_symbol_prefix[YYUNDEF) + +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex. */ +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = +{ + ]b4_translate[ +};]])[ + +#if ]b4_api_PREFIX[DEBUG +]b4_integral_parser_table_define([rline], [b4_rline], + [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ +#endif + +/** Accessing symbol of state STATE. */ +#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) + +#if ]b4_parse_error_case([simple], [b4_api_PREFIX[DEBUG || ]b4_token_table_flag], [[1]])[ +/* The user-facing name of the symbol whose (internal) number is + YYSYMBOL. No bounds checking. */ +static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; + +]b4_parse_error_bmatch([simple\|verbose], +[[/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + ]b4_tname[ +}; + +static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + return yytname[yysymbol]; +}]], +[[static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + static const char *const yy_sname[] = + { + ]b4_symbol_names[ + };]b4_has_translations_if([[ + /* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is + internationalizable. */ + static ]b4_int_type_for([b4_translatable])[ yytranslatable[] = + { + ]b4_translatable[ + }; + return (yysymbol < YYNTOKENS && yytranslatable[yysymbol] + ? _(yy_sname[yysymbol]) + : yy_sname[yysymbol]);]], [[ + return yy_sname[yysymbol];]])[ +}]])[ +#endif + +#define YYPACT_NINF (]b4_pact_ninf[) + +#define yypact_value_is_default(Yyn) \ + ]b4_table_value_equals([[pact]], [[Yyn]], [b4_pact_ninf], [YYPACT_NINF])[ + +#define YYTABLE_NINF (]b4_table_ninf[) + +#define yytable_value_is_error(Yyn) \ + ]b4_table_value_equals([[table]], [[Yyn]], [b4_table_ninf], [YYTABLE_NINF])[ + +]b4_parser_tables_define[ + +enum { YYENOMEM = -2 }; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = ]b4_symbol(empty, id)[) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYNOMEM goto yyexhaustedlab + + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == ]b4_symbol(empty, id)[) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \]b4_lac_if([[ + YY_LAC_DISCARD ("YYBACKUP"); \]])[ + goto yybackup; \ + } \ + else \ + { \ + yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) + +/* Backward compatibility with an undocumented macro. + Use ]b4_symbol(error, id)[ or ]b4_symbol(undef, id)[. */ +#define YYERRCODE ]b4_symbol(undef, id)[ +]b4_locations_if([[ +]b4_yylloc_default_define[ +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +]])[ + +/* Enable debugging if requested. */ +#if ]b4_api_PREFIX[DEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + +]b4_yylocation_print_define[ + +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Kind, Value]b4_locations_if([, Location])[]b4_user_args[); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +]b4_yy_symbol_print_define[ + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +static void +yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +static void +yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,]b4_locations_if([[ YYLTYPE *yylsp,]])[ + int yyrule]b4_user_formals[) +{ + int yylno = yyrline[yyrule]; + int yynrhs = yyr2[yyrule]; + int yyi; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, + YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), + &]b4_rhs_value(yynrhs, yyi + 1)[]b4_locations_if([, + &]b4_rhs_location(yynrhs, yyi + 1))[]b4_user_args[); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !]b4_api_PREFIX[DEBUG */ +# define YYDPRINTF(Args) ((void) 0) +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !]b4_api_PREFIX[DEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH ]b4_stack_depth_init[ +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH ]b4_stack_depth_max[ +#endif]b4_push_if([[ +/* Parser data structure. */ +struct yypstate + {]b4_declare_parser_state_variables[ + /* Whether this instance has not started parsing yet. + * If 2, it corresponds to a finished parsing. */ + int yynew; + };]b4_pure_if([], [[ + +/* Whether the only allowed instance of yypstate is allocated. */ +static char yypstate_allocated = 0;]])])[ +]b4_lac_if([[ + +/* Given a state stack such that *YYBOTTOM is its bottom, such that + *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty + stack, and such that *YYCAPACITY is the maximum number of elements it + can hold without a reallocation, make sure there is enough room to + store YYADD more elements. If not, allocate a new stack using + YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM, + *YYTOP, and *YYCAPACITY to reflect the new capacity and memory + location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack + using YYSTACK_FREE. Return 0 if successful or if no reallocation is + required. Return YYENOMEM if memory is exhausted. */ +static int +yy_lac_stack_realloc (YYPTRDIFF_T *yycapacity, YYPTRDIFF_T yyadd, +#if ]b4_api_PREFIX[DEBUG + char const *yydebug_prefix, + char const *yydebug_suffix, +#endif + yy_state_t **yybottom, + yy_state_t *yybottom_no_free, + yy_state_t **yytop, yy_state_t *yytop_empty) +{ + YYPTRDIFF_T yysize_old = + *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1; + YYPTRDIFF_T yysize_new = yysize_old + yyadd; + if (*yycapacity < yysize_new) + { + YYPTRDIFF_T yyalloc = 2 * yysize_new; + yy_state_t *yybottom_new; + /* Use YYMAXDEPTH for maximum stack size given that the stack + should never need to grow larger than the main state stack + needs to grow without LAC. */ + if (YYMAXDEPTH < yysize_new) + { + YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix, + yydebug_suffix)); + return YYENOMEM; + } + if (YYMAXDEPTH < yyalloc) + yyalloc = YYMAXDEPTH; + yybottom_new = + YY_CAST (yy_state_t *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, + yyalloc * YYSIZEOF (*yybottom_new)))); + if (!yybottom_new) + { + YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix, + yydebug_suffix)); + return YYENOMEM; + } + if (*yytop != yytop_empty) + { + YYCOPY (yybottom_new, *yybottom, yysize_old); + *yytop = yybottom_new + (yysize_old - 1); + } + if (*yybottom != yybottom_no_free) + YYSTACK_FREE (*yybottom); + *yybottom = yybottom_new; + *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]), + [full], [[ + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "%srealloc to %ld%s", yydebug_prefix, + YY_CAST (long, yyalloc), yydebug_suffix)); + YY_IGNORE_USELESS_CAST_END]])[ + } + return 0; +} + +/* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + YY_LAC_ESTABLISH should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). Iff there is a + lookahead token, it should also be invoked before reporting a syntax + error. This latter case is for the sake of the debugging output. + + For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. + Report a syntax error if it cannot. */ +#define YY_LAC_ESTABLISH \ +do { \ + if (!yy_lac_established) \ + { \ + YYDPRINTF ((stderr, \ + "LAC: initial context established for %s\n", \ + yysymbol_name (yytoken))); \ + yy_lac_established = 1; \ + switch (yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken)) \ + { \ + case YYENOMEM: \ + YYNOMEM; \ + case 1: \ + goto yyerrlab; \ + } \ + } \ +} while (0) + +/* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ +#if ]b4_api_PREFIX[DEBUG +# define YY_LAC_DISCARD(Event) \ +do { \ + if (yy_lac_established) \ + { \ + YYDPRINTF ((stderr, "LAC: initial context discarded due to " \ + Event "\n")); \ + yy_lac_established = 0; \ + } \ +} while (0) +#else +# define YY_LAC_DISCARD(Event) yy_lac_established = 0 +#endif + +/* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can + eventually (after perhaps some reductions) be shifted, return 1 if + not, or return YYENOMEM if memory is exhausted. As preconditions and + postconditions: *YYES_CAPACITY is the allocated size of the array to + which *YYES points, and either *YYES = YYESA or *YYES points to an + array allocated with YYSTACK_ALLOC. yy_lac may overwrite the + contents of either array, alter *YYES and *YYES_CAPACITY, and free + any old *YYES other than YYESA. */ +static int +yy_lac (yy_state_t *yyesa, yy_state_t **yyes, + YYPTRDIFF_T *yyes_capacity, yy_state_t *yyssp, yysymbol_kind_t yytoken) +{ + yy_state_t *yyes_prev = yyssp; + yy_state_t *yyesp = yyes_prev; + /* Reduce until we encounter a shift and thereby accept the token. */ + YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yysymbol_name (yytoken))); + if (yytoken == ]b4_symbol_prefix[YYUNDEF) + { + YYDPRINTF ((stderr, " Always Err\n")); + return 1; + } + while (1) + { + int yyrule = yypact[+*yyesp]; + if (yypact_value_is_default (yyrule) + || (yyrule += yytoken) < 0 || YYLAST < yyrule + || yycheck[yyrule] != yytoken) + { + /* Use the default action. */ + yyrule = yydefact[+*yyesp]; + if (yyrule == 0) + { + YYDPRINTF ((stderr, " Err\n")); + return 1; + } + } + else + { + /* Use the action from yytable. */ + yyrule = yytable[yyrule]; + if (yytable_value_is_error (yyrule)) + { + YYDPRINTF ((stderr, " Err\n")); + return 1; + } + if (0 < yyrule) + { + YYDPRINTF ((stderr, " S%d\n", yyrule)); + return 0; + } + yyrule = -yyrule; + } + /* By now we know we have to simulate a reduce. */ + YYDPRINTF ((stderr, " R%d", yyrule - 1)); + { + /* Pop the corresponding number of values from the stack. */ + YYPTRDIFF_T yylen = yyr2[yyrule]; + /* First pop from the LAC stack as many tokens as possible. */ + if (yyesp != yyes_prev) + { + YYPTRDIFF_T yysize = yyesp - *yyes + 1; + if (yylen < yysize) + { + yyesp -= yylen; + yylen = 0; + } + else + { + yyesp = yyes_prev; + yylen -= yysize; + } + } + /* Only afterwards look at the main stack. */ + if (yylen) + yyesp = yyes_prev -= yylen; + } + /* Push the resulting state of the reduction. */ + { + yy_state_fast_t yystate; + { + const int yylhs = yyr1[yyrule] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyesp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyesp + ? yytable[yyi] + : yydefgoto[yylhs]); + } + if (yyesp == yyes_prev) + { + yyesp = *yyes; + YY_IGNORE_USELESS_CAST_BEGIN + *yyesp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + } + else + { + if (yy_lac_stack_realloc (yyes_capacity, 1, +#if ]b4_api_PREFIX[DEBUG + " (", ")", +#endif + yyes, yyesa, &yyesp, yyes_prev)) + { + YYDPRINTF ((stderr, "\n")); + return YYENOMEM; + } + YY_IGNORE_USELESS_CAST_BEGIN + *++yyesp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + } + YYDPRINTF ((stderr, " G%d", yystate)); + } + } +}]])[ + +]b4_parse_error_case([simple], [], +[[/* Context of a parse error. */ +typedef struct +{]b4_push_if([[ + yypstate* yyps;]], [[ + yy_state_t *yyssp;]b4_lac_if([[ + yy_state_t *yyesa; + yy_state_t **yyes; + YYPTRDIFF_T *yyes_capacity;]])])[ + yysymbol_kind_t yytoken;]b4_locations_if([[ + YYLTYPE *yylloc;]])[ +} yypcontext_t; + +/* Put in YYARG at most YYARGN of the expected tokens given the + current YYCTX, and return the number of tokens stored in YYARG. If + YYARG is null, return the number of expected tokens (guaranteed to + be less than YYNTOKENS). Return YYENOMEM on memory exhaustion. + Return 0 if there are more than YYARGN expected tokens, yet fill + YYARG up to YYARGN. */]b4_push_if([[ +static int +yypstate_expected_tokens (yypstate *yyps, + yysymbol_kind_t yyarg[], int yyargn)]], [[ +static int +yypcontext_expected_tokens (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn)]])[ +{ + /* Actual size of YYARG. */ + int yycount = 0; +]b4_lac_if([[ + int yyx; + for (yyx = 0; yyx < YYNTOKENS; ++yyx) + { + yysymbol_kind_t yysym = YY_CAST (yysymbol_kind_t, yyx); + if (yysym != ]b4_symbol(error, kind)[ && yysym != ]b4_symbol_prefix[YYUNDEF) + switch (yy_lac (]b4_push_if([[yyps->yyesa, &yyps->yyes, &yyps->yyes_capacity, yyps->yyssp, yysym]], + [[yyctx->yyesa, yyctx->yyes, yyctx->yyes_capacity, yyctx->yyssp, yysym]])[)) + { + case YYENOMEM: + return YYENOMEM; + case 1: + continue; + default: + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = yysym; + } + }]], +[[ int yyn = yypact@{+*]b4_push_if([yyps], [yyctx])[->yyssp@}; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[ + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); + } + }]])[ + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = ]b4_symbol(empty, kind)[; + return yycount; +} + +]b4_push_if([[ +/* Similar to the previous function. */ +static int +yypcontext_expected_tokens (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn) +{ + return yypstate_expected_tokens (yyctx->yyps, yyarg, yyargn); +}]])[ +]])[ + +]b4_parse_error_bmatch( + [custom], +[[/* The kind of the lookahead of this context. */ +static yysymbol_kind_t +yypcontext_token (const yypcontext_t *yyctx) YY_ATTRIBUTE_UNUSED; + +static yysymbol_kind_t +yypcontext_token (const yypcontext_t *yyctx) +{ + return yyctx->yytoken; +} + +]b4_locations_if([[/* The location of the lookahead of this context. */ +static YYLTYPE * +yypcontext_location (const yypcontext_t *yyctx) YY_ATTRIBUTE_UNUSED; + +static YYLTYPE * +yypcontext_location (const yypcontext_t *yyctx) +{ + return yyctx->yylloc; +}]])[ + +/* User defined function to report a syntax error. */ +static int +yyreport_syntax_error (const yypcontext_t *yyctx]b4_user_formals[);]], + [detailed\|verbose], +[[#ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) +# else +/* Return the length of YYSTR. */ +static YYPTRDIFF_T +yystrlen (const char *yystr) +{ + YYPTRDIFF_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +#endif + +#ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +yystpcpy (char *yydest, const char *yysrc) +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +#endif + +]b4_parse_error_case( + [verbose], +[[#ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYPTRDIFF_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYPTRDIFF_T yyn = 0; + char const *yyp = yystr; + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + else + goto append; + + append: + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (yyres) + return yystpcpy (yyres, yystr) - yyres; + else + return yystrlen (yystr); +} +#endif +]])[ + +static int +yy_syntax_error_arguments (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn) +{ + /* Actual size of YYARG. */ + int yycount = 0; + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar.]b4_lac_if([[ + In the first two cases, it might appear that the current syntax + error should have been detected in the previous state when yy_lac + was invoked. However, at that time, there might have been a + different syntax error that discarded a different initial context + during error recovery, leaving behind the current lookahead.]], [[ + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state.]])[ + */ + if (yyctx->yytoken != ]b4_symbol(empty, kind)[) + { + int yyn;]b4_lac_if([[ + YYDPRINTF ((stderr, "Constructing syntax error message\n"));]])[ + if (yyarg) + yyarg[yycount] = yyctx->yytoken; + ++yycount; + yyn = yypcontext_expected_tokens (yyctx, + yyarg ? yyarg + 1 : yyarg, yyargn - 1); + if (yyn == YYENOMEM) + return YYENOMEM;]b4_lac_if([[ + else if (yyn == 0) + YYDPRINTF ((stderr, "No expected tokens.\n"));]])[ + else + yycount += yyn; + } + return yycount; +} + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP.]b4_lac_if([[ In order to see if a particular token T is a + valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[ + + Return 0 if *YYMSG was successfully written. Return -1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return YYENOMEM if the + required number of bytes is too large to store]b4_lac_if([[ or if + yy_lac returned YYENOMEM]])[. */ +static int +yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg, + const yypcontext_t *yyctx) +{ + enum { YYARGS_MAX = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULLPTR; + /* Arguments of yyformat: reported tokens (one for the "unexpected", + one per "expected"). */ + yysymbol_kind_t yyarg[YYARGS_MAX]; + /* Cumulated lengths of YYARG. */ + YYPTRDIFF_T yysize = 0; + + /* Actual size of YYARG. */ + int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); + if (yycount == YYENOMEM) + return YYENOMEM; + + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: /* Avoid compiler warnings. */ + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + /* Compute error message size. Don't count the "%s"s, but reserve + room for the terminator. */ + yysize = yystrlen (yyformat) - 2 * yycount + 1; + { + int yyi; + for (yyi = 0; yyi < yycount; ++yyi) + { + YYPTRDIFF_T yysize1 + = yysize + ]b4_parse_error_case( + [verbose], [[yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]])]], + [[yystrlen (yysymbol_name (yyarg[yyi]))]]);[ + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else + return YYENOMEM; + } + } + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return -1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + {]b4_parse_error_case([verbose], [[ + yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]);]], [[ + yyp = yystpcpy (yyp, yysymbol_name (yyarg[yyi++]));]])[ + yyformat += 2; + } + else + { + ++yyp; + ++yyformat; + } + } + return 0; +} +]])[ + +]b4_yydestruct_define[ + +]b4_pure_if([], [b4_declare_scanner_communication_variables])[ + +]b4_push_if([b4_pull_if([[ + +int +yyparse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[) +{ + yypstate *yyps = yypstate_new (); + if (!yyps) + {]b4_pure_if([b4_locations_if([[ + static YYLTYPE yyloc_default][]b4_yyloc_default[; + YYLTYPE yylloc = yyloc_default;]])[ + yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[ + if (!yypstate_allocated) + yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[ + return 2; + } + int yystatus = yypull_parse (yyps]b4_user_args[); + yypstate_delete (yyps); + return yystatus; +} + +int +yypull_parse (yypstate *yyps]b4_user_formals[) +{ + YY_ASSERT (yyps);]b4_pure_if([b4_locations_if([[ + static YYLTYPE yyloc_default][]b4_yyloc_default[; + YYLTYPE yylloc = yyloc_default;]])])[ + int yystatus; + do { +]b4_pure_if([[ YYSTYPE yylval; + int ]])[yychar = ]b4_yylex[; + yystatus = yypush_parse (yyps]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_args(b4_parse_param)])[); + } while (yystatus == YYPUSH_MORE); + return yystatus; +}]])[ + +]b4_parse_state_variable_macros([b4_pstate_macro_define])[ + +/* Initialize the parser data structure. */ +static void +yypstate_clear (yypstate *yyps) +{ + yynerrs = 0; + yystate = 0; + yyerrstatus = 0; + + yyssp = yyss; + yyvsp = yyvs;]b4_locations_if([[ + yylsp = yyls;]])[ + + /* Initialize the state stack, in case yypcontext_expected_tokens is + called before the first call to yyparse. */ + *yyssp = 0; + yyps->yynew = 1; +} + +/* Initialize the parser data structure. */ +yypstate * +yypstate_new (void) +{ + yypstate *yyps;]b4_pure_if([], [[ + if (yypstate_allocated) + return YY_NULLPTR;]])[ + yyps = YY_CAST (yypstate *, YYMALLOC (sizeof *yyps)); + if (!yyps) + return YY_NULLPTR;]b4_pure_if([], [[ + yypstate_allocated = 1;]])[ + yystacksize = YYINITDEPTH; + yyss = yyssa; + yyvs = yyvsa;]b4_locations_if([[ + yyls = yylsa;]])[]b4_lac_if([[ + yyes = yyesa; + yyes_capacity = ]b4_percent_define_get([[parse.lac.es-capacity-initial]])[; + if (YYMAXDEPTH < yyes_capacity) + yyes_capacity = YYMAXDEPTH;]])[ + yypstate_clear (yyps); + return yyps; +} + +void +yypstate_delete (yypstate *yyps) +{ + if (yyps) + { +#ifndef yyoverflow + /* If the stack was reallocated but the parse did not complete, then the + stack still needs to be freed. */ + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif]b4_lac_if([[ + if (yyes != yyesa) + YYSTACK_FREE (yyes);]])[ + YYFREE (yyps);]b4_pure_if([], [[ + yypstate_allocated = 0;]])[ + } +} +]])[ + +]b4_push_if([[ +/*---------------. +| yypush_parse. | +`---------------*/ + +int +yypush_parse (yypstate *yyps]b4_pure_if([[, + int yypushed_char, YYSTYPE const *yypushed_val]b4_locations_if([[, YYLTYPE *yypushed_loc]])])b4_user_formals[)]], +[[ +/*----------. +| yyparse. | +`----------*/ + +]m4_ifdef([b4_start_symbols], +[[// Extract data from the parser. +typedef struct +{ + YYSTYPE yyvalue; + int yynerrs; +} yy_parse_impl_t; + +// Run a full parse, using YYCHAR as switching token. +static int +yy_parse_impl (int yychar, yy_parse_impl_t *yyimpl]m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])[); + +]m4_map([_b4_define_sub_yyparse], m4_defn([b4_start_symbols]))[ + +int +yyparse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[) +{ + return yy_parse_impl (]b4_symbol(_b4_first_switching_token, id)[, YY_NULLPTR]m4_ifset([b4_parse_param], + [[, ]b4_args(b4_parse_param)])[); +} + +static int +yy_parse_impl (int yychar, yy_parse_impl_t *yyimpl]m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])[)]], +[[int +yyparse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[)]])])[ +{]b4_pure_if([b4_declare_scanner_communication_variables +])b4_push_if([b4_pure_if([], [[ + int yypushed_char = yychar; + YYSTYPE yypushed_val = yylval;]b4_locations_if([[ + YYLTYPE yypushed_loc = yylloc;]]) +])], + [b4_declare_parser_state_variables([init]) +])b4_lac_if([[ + /* Whether LAC context is established. A Boolean. */ + int yy_lac_established = 0;]])[ + int yyn; + /* The return value of yyparse. */ + int yyresult; + /* Lookahead symbol kind. */ + yysymbol_kind_t yytoken = ]b4_symbol(empty, kind)[; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc; + + /* The locations where the error started and ended. */ + YYLTYPE yyerror_range[3];]])[ + +]b4_parse_error_bmatch([detailed\|verbose], +[[ /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;]])[ + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0;]b4_push_if([[ + + switch (yyps->yynew) + { + case 0: + yyn = yypact[yystate]; + goto yyread_pushed_token; + + case 2: + yypstate_clear (yyps); + break; + + default: + break; + }]])[ + + YYDPRINTF ((stderr, "Starting parse\n")); + +]m4_ifdef([b4_start_symbols], [], +[[ yychar = ]b4_symbol(empty, id)[; /* Cause a token to be read. */ +]])[ +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([m4_define([b4_dollar_dollar_used])yylval], [], [], + [b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])])dnl +b4_user_initial_action +b4_dollar_popdef[]dnl +m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval; +]])])dnl +b4_locations_if([[ yylsp[0] = ]b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])[; +]])dnl +[ goto yysetstate; + + +/*------------------------------------------------------------. +| yynewstate -- push a new state, which is found in yystate. | +`------------------------------------------------------------*/ +yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + +/*--------------------------------------------------------------------. +| yysetstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + YY_ASSERT (0 <= yystate && yystate < YYNSTATES); + YY_IGNORE_USELESS_CAST_BEGIN + *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + YY_STACK_PRINT (yyss, yyssp); + + if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + YYNOMEM; +#else + { + /* Get the current used size of the three stacks, in elements. */ + YYPTRDIFF_T yysize = yyssp - yyss + 1; + +# if defined yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + yy_state_t *yyss1 = yyss; + YYSTYPE *yyvs1 = yyvs;]b4_locations_if([ + YYLTYPE *yyls1 = yyls;])[ + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * YYSIZEOF (*yyssp), + &yyvs1, yysize * YYSIZEOF (*yyvsp),]b4_locations_if([ + &yyls1, yysize * YYSIZEOF (*yylsp),])[ + &yystacksize); + yyss = yyss1; + yyvs = yyvs1;]b4_locations_if([ + yyls = yyls1;])[ + } +# else /* defined YYSTACK_RELOCATE */ + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + YYNOMEM; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yy_state_t *yyss1 = yyss; + union yyalloc *yyptr = + YY_CAST (union yyalloc *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); + if (! yyptr) + YYNOMEM; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([ + YYSTACK_RELOCATE (yyls_alloc, yyls);])[ +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1;]b4_locations_if([ + yylsp = yyls + yysize - 1;])[ + + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "Stack size increased to %ld\n", + YY_CAST (long, yystacksize))); + YY_IGNORE_USELESS_CAST_END + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ + +]m4_ifdef([b4_start_symbols], [], [[ + if (yystate == YYFINAL) + YYACCEPT;]])[ + + goto yybackup; + + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ + if (yychar == ]b4_symbol(empty, id)[) + {]b4_push_if([[ + if (!yyps->yynew) + {]b4_use_push_for_pull_if([], [[ + YYDPRINTF ((stderr, "Return for a new token:\n"));]])[ + yyresult = YYPUSH_MORE; + goto yypushreturn; + } + yyps->yynew = 0;]b4_pure_if([], [[ + /* Restoring the pushed token is only necessary for the first + yypush_parse invocation since subsequent invocations don't overwrite + it before jumping to yyread_pushed_token. */ + yychar = yypushed_char; + yylval = yypushed_val;]b4_locations_if([[ + yylloc = yypushed_loc;]])])[ +yyread_pushed_token:]])[ + YYDPRINTF ((stderr, "Reading a token\n"));]b4_push_if([b4_pure_if([[ + yychar = yypushed_char; + if (yypushed_val) + yylval = *yypushed_val;]b4_locations_if([[ + if (yypushed_loc) + yylloc = *yypushed_loc;]])])], [[ + yychar = ]b4_yylex[;]])[ + } + + if (yychar <= ]b4_symbol(eof, [id])[) + { + yychar = ]b4_symbol(eof, [id])[; + yytoken = ]b4_symbol(eof, [kind])[; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else if (yychar == ]b4_symbol(error, [id])[) + { + /* The scanner already issued an error message, process directly + to error recovery. But do not keep the error token as + lookahead, it is too special and may lead us to an endless + loop in error recovery. */ + yychar = ]b4_symbol(undef, [id])[; + yytoken = ]b4_symbol(error, [kind])[;]b4_locations_if([[ + yyerror_range[1] = yylloc;]])[ + goto yyerrlab1; + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)]b4_lac_if([[ + { + YY_LAC_ESTABLISH; + goto yydefault; + }]], [[ + goto yydefault;]])[ + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn;]b4_lac_if([[ + YY_LAC_ESTABLISH;]])[ + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END]b4_locations_if([ + *++yylsp = yylloc;])[ + + /* Discard the shifted token. */ + yychar = ]b4_symbol(empty, id)[;]b4_lac_if([[ + YY_LAC_DISCARD ("shift");]])[ + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + '$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + +]b4_locations_if( +[[ /* Default location. */ + YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); + yyerror_range[1] = yyloc;]])[ + YY_REDUCE_PRINT (yyn);]b4_lac_if([[ + { + int yychar_backup = yychar; + switch (yyn) + { +]b4_user_actions[ + default: break; + } + if (yychar_backup != yychar) + YY_LAC_DISCARD ("yychar change"); + }]], [[ + switch (yyn) + { +]b4_user_actions[ + default: break; + }]])[ + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + + *++yyvsp = yyval;]b4_locations_if([ + *++yylsp = yyloc;])[ + + /* Now 'shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } + + goto yynewstate; + + +/*--------------------------------------. +| yyerrlab -- here on detecting error. | +`--------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == ]b4_symbol(empty, id)[ ? ]b4_symbol(empty, kind)[ : YYTRANSLATE (yychar); + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +]b4_parse_error_case( + [custom], +[[ { + yypcontext_t yyctx + = {]b4_push_if([[yyps]], [[yyssp]b4_lac_if([[, yyesa, &yyes, &yyes_capacity]])])[, yytoken]b4_locations_if([[, &yylloc]])[};]b4_lac_if([[ + if (yychar != ]b4_symbol(empty, id)[) + YY_LAC_ESTABLISH;]])[ + if (yyreport_syntax_error (&yyctx]m4_ifset([b4_parse_param], + [[, ]b4_args(b4_parse_param)])[) == 2) + YYNOMEM; + }]], + [simple], +[[ yyerror (]b4_yyerror_args[YY_("syntax error"));]], +[[ { + yypcontext_t yyctx + = {]b4_push_if([[yyps]], [[yyssp]b4_lac_if([[, yyesa, &yyes, &yyes_capacity]])])[, yytoken]b4_locations_if([[, &yylloc]])[}; + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status;]b4_lac_if([[ + if (yychar != ]b4_symbol(empty, id)[) + YY_LAC_ESTABLISH;]])[ + yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == -1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = YY_CAST (char *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); + if (yymsg) + { + yysyntax_error_status + = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); + yymsgp = yymsg; + } + else + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = YYENOMEM; + } + } + yyerror (]b4_yyerror_args[yymsgp); + if (yysyntax_error_status == YYENOMEM) + YYNOMEM; + }]])[ + } +]b4_locations_if([[ + yyerror_range[1] = yylloc;]])[ + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= ]b4_symbol(eof, [id])[) + { + /* Return failure if at end of input. */ + if (yychar == ]b4_symbol(eof, [id])[) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); + yychar = ]b4_symbol(empty, id)[; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; + ++yynerrs; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + /* Pop stack until we find a state that shifts the error token. */ + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += ]b4_symbol(error, kind)[; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == ]b4_symbol(error, kind)[) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + +]b4_locations_if([[ yyerror_range[1] = *yylsp;]])[ + yydestruct ("Error: popping", + YY_ACCESSING_SYMBOL (yystate), yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + }]b4_lac_if([[ + + /* If the stack popping above didn't lose the initial context for the + current lookahead token, the shift below will for sure. */ + YY_LAC_DISCARD ("error recovery");]])[ + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END +]b4_locations_if([[ + yyerror_range[2] = yylloc; + ++yylsp; + YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);]])[ + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturnlab; + + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturnlab; + + +/*-----------------------------------------------------------. +| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | +`-----------------------------------------------------------*/ +yyexhaustedlab: + yyerror (]b4_yyerror_args[YY_("memory exhausted")); + yyresult = 2; + goto yyreturnlab; + + +/*----------------------------------------------------------. +| yyreturnlab -- parsing is finished, clean up and return. | +`----------------------------------------------------------*/ +yyreturnlab: + if (yychar != ]b4_symbol(empty, id)[) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); + } + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + YY_ACCESSING_SYMBOL (+*yyssp), yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); + YYPOPSTACK (1); + }]b4_push_if([[ + yyps->yynew = 2; + goto yypushreturn; + + +/*-------------------------. +| yypushreturn -- return. | +`-------------------------*/ +yypushreturn:]], [[ +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif]b4_lac_if([[ + if (yyes != yyesa) + YYSTACK_FREE (yyes);]])])[ +]b4_parse_error_bmatch([detailed\|verbose], +[[ if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg);]])[]m4_ifdef([b4_start_symbols], [[ + if (yyimpl) + yyimpl->yynerrs = yynerrs;]])[ + return yyresult; +} +]b4_push_if([b4_parse_state_variable_macros([b4_macro_undef])])[ +]b4_percent_code_get([[epilogue]])[]dnl +b4_epilogue[]dnl +b4_output_end diff --git a/Engine/bin/bison-flex/data/xslt/bison.xsl b/Engine/bin/bison-flex/data/xslt/bison.xsl new file mode 100644 index 000000000..989a3437f --- /dev/null +++ b/Engine/bin/bison-flex/data/xslt/bison.xsl @@ -0,0 +1,105 @@ + + + + + + + + + + + + + + + + + + + + + + + + + s + + + r + + + + + + , + + + + + 0 + + + + + + + + + + + diff --git a/Engine/bin/bison-flex/data/xslt/xml2dot.xsl b/Engine/bin/bison-flex/data/xslt/xml2dot.xsl new file mode 100644 index 000000000..7715d1ac3 --- /dev/null +++ b/Engine/bin/bison-flex/data/xslt/xml2dot.xsl @@ -0,0 +1,401 @@ + + + + + + + + + + + + + + + // Generated by GNU Bison + + . + // Report bugs to < + + >. + // Home page: < + + >. + + + + + + + + digraph " + + + + " { + node [fontname = courier, shape = box, colorscheme = paired6] + edge [fontname = courier] + + + + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + label="[ + + + + + + , + + + ]", + + + + style=solid] + + + + + + + + + 3 + + + 5 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + : + + + + . + + + + + + + . + + + + + + + + + + + %empty + + + + [ + + ] + + + + + + , + + + + + + + + + + + -> " + + R + + + d + + " [ + + + + + + + + " + + R + + + d + + " [label=" + + + Acc", fillcolor=1 + + + R + + ", fillcolor= + + + + , shape=diamond, style=filled] + + + + + + + + + + dotted + + + solid + + + dashed + + + + + + + + + + + + + + + + + [label=" + State + + \n + + + + \l"] + + + + + + + + + + -> + + [style= + + + label=" + + + + " + + ] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Engine/bin/bison-flex/data/xslt/xml2text.xsl b/Engine/bin/bison-flex/data/xslt/xml2text.xsl new file mode 100644 index 000000000..1fc5731a7 --- /dev/null +++ b/Engine/bin/bison-flex/data/xslt/xml2text.xsl @@ -0,0 +1,572 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Nonterminals useless in grammar + + + + + + + + + + + + Terminals unused in grammar + + + + + + + + + + + + + + Rules useless in grammar + + + + + + + + + + + Rules useless in parser due to conflicts + + + + + + + + + Grammar + + + + + + + + + + + + + + + + + + + + + + + + + Terminals, with rules where they appear + + + + + + Nonterminals, with rules where they appear + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + on@left: + + + + + + + + + on@right: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + State + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + : + + + + + + + • + + + + • + + + + + + + + + + + + + + + + %empty + + + + [ + + ] + + + + + + , + + + + + + + + + + + + + shift, and go to state + + + + go to state + + + + + + + + + + + + + + error + ( + + ) + + + + + + + + + + + + [ + + + + accept + + + reduce using rule + + ( + + ) + + + + ] + + + + + + + + + + + + + Conflict between rule + + and token + + resolved as + + an + + + ( + + ). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Engine/bin/bison-flex/data/xslt/xml2xhtml.xsl b/Engine/bin/bison-flex/data/xslt/xml2xhtml.xsl new file mode 100644 index 000000000..aaa5dbaa2 --- /dev/null +++ b/Engine/bin/bison-flex/data/xslt/xml2xhtml.xsl @@ -0,0 +1,765 @@ + + + + + + + + + + + + + + + + <xsl:value-of select="bison-xml-report/filename"/> + <xsl:text> - GNU Bison XML Automaton Report</xsl:text> + + + + + + +

+ + + + + +

GNU Bison XML Automaton Report

+

+ input grammar: +

+ + +

Table of Contents

+ + + + + + + + + +

+ + Reductions +

+ + + + + + +

+ + Nonterminals useless in grammar +

+ + +

+ + + + + + +

+ + + + +

+ + Terminals unused in grammar +

+ + +

+ + + + + + + +

+ + + + +

+ + Rules useless in grammar +

+ + + +

+ + + + +

+ + + + + + +

+ + Rules useless in parser due to conflicts +

+ +

+ + + +

+ + + + + +

+ + Grammar +

+ +

+ + + + +

+ + + + + + + + + + + + + + + + + + + + + + + +

+ + Conflicts +

+ + + + + +

+ + +

+ + + + + + + + + + + + + + + + + conflicts: + + + + + + + + + + + + + + +

+ + Terminals, with rules where they appear +

+ +
    + + +
+ + + + +

+ + Nonterminals, with rules where they appear +

+ +
    + + +
+ + + + +
  • + + + + + + + + +
    • + +     + + + +
  • + + + + + + +
      + + + +
    • + on left: + + + +
      • + +       + + +
    • + on right: + + + +
      • + +       + +
    + +
    • + +     + + + +     + + + + + + + + +

    + + Automaton +

    + + + +     + + + + +

    + + + + + + State + +

    + +

    + + + + + + + + + + + + +

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + → + + + + + + + + • + + + + + • + + + + + + + + + + + + + + + + + + + + + + + %empty + + + + [ + + ] + + + + + + , + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + error + ( + + ) + + + + + + + + + + + + [ + + + + accept + + + + + + + + + ( + + ) + + + + ] + + + + + + + + + + + + + Conflict between + + + + + + + and token + + resolved as + + an + + + ( + + ). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + diff --git a/Engine/bin/bison/bison.exe b/Engine/bin/bison/bison.exe deleted file mode 100644 index 4881bf604916b1331205bdd5f32624831e2a2331..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 196096 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

    Y%&V;-)+npYsq0 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 YcfY#-V)nRSdX^UC{nvVu+I#bV0CDn^H~;_u diff --git a/Engine/bin/bison/bison.html b/Engine/bin/bison/bison.html deleted file mode 100644 index a89eaa329..000000000 --- a/Engine/bin/bison/bison.html +++ /dev/null @@ -1,4501 +0,0 @@ - - - -Bison 1.24 - - - -

    Bison -

    -

    The YACC-compatible Parser Generator -

    -

    May 1995, Bison Version 1.24 -

    -
    by Charles Donnelly and Richard Stallman -
    -

    -

    -

    Table of Contents

    - -

    -