blob: dca3ec67204155337d4d056a15a22adcd14254f2 [file] [log] [blame]
drh75897232000-05-29 14:26:00 +00001/*
drh75897232000-05-29 14:26:00 +00002** This file contains all sources (including headers) to the LEMON
3** LALR(1) parser generator. The sources have been combined into a
drh960e8c62001-04-03 16:53:21 +00004** single file to make it easy to include LEMON in the source tree
5** and Makefile of another program.
drh75897232000-05-29 14:26:00 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** The author of this program disclaims copyright.
drh75897232000-05-29 14:26:00 +00008*/
9#include <stdio.h>
drhf9a2e7b2003-04-15 01:49:48 +000010#include <stdarg.h>
drh75897232000-05-29 14:26:00 +000011#include <string.h>
12#include <ctype.h>
drh8b582012003-10-21 13:16:03 +000013#include <stdlib.h>
drhe9278182007-07-18 18:16:29 +000014#include <assert.h>
drh75897232000-05-29 14:26:00 +000015
drhc56fac72015-10-29 13:48:15 +000016#define ISSPACE(X) isspace((unsigned char)(X))
17#define ISDIGIT(X) isdigit((unsigned char)(X))
18#define ISALNUM(X) isalnum((unsigned char)(X))
19#define ISALPHA(X) isalpha((unsigned char)(X))
20#define ISUPPER(X) isupper((unsigned char)(X))
21#define ISLOWER(X) islower((unsigned char)(X))
22
23
drh75897232000-05-29 14:26:00 +000024#ifndef __WIN32__
25# if defined(_WIN32) || defined(WIN32)
drhf2f105d2012-08-20 15:53:54 +000026# define __WIN32__
drh75897232000-05-29 14:26:00 +000027# endif
28#endif
29
rse8f304482007-07-30 18:31:53 +000030#ifdef __WIN32__
drhdf609712010-11-23 20:55:27 +000031#ifdef __cplusplus
32extern "C" {
33#endif
34extern int access(const char *path, int mode);
35#ifdef __cplusplus
36}
37#endif
rse8f304482007-07-30 18:31:53 +000038#else
39#include <unistd.h>
40#endif
41
drh75897232000-05-29 14:26:00 +000042/* #define PRIVATE static */
43#define PRIVATE
44
45#ifdef TEST
46#define MAXRHS 5 /* Set low to exercise exception code */
47#else
48#define MAXRHS 1000
49#endif
50
mistachkin17df7612019-06-03 15:09:25 +000051extern void memory_error();
drhf5c4e0f2010-07-18 11:35:53 +000052static int showPrecedenceConflict = 0;
drhe9278182007-07-18 18:16:29 +000053static char *msort(char*,char**,int(*)(const char*,const char*));
drh75897232000-05-29 14:26:00 +000054
drh87cf1372008-08-13 20:09:06 +000055/*
56** Compilers are getting increasingly pedantic about type conversions
57** as C evolves ever closer to Ada.... To work around the latest problems
58** we have to define the following variant of strlen().
59*/
60#define lemonStrlen(X) ((int)strlen(X))
61
drh898799f2014-01-10 23:21:00 +000062/*
63** Compilers are starting to complain about the use of sprintf() and strcpy(),
64** saying they are unsafe. So we define our own versions of those routines too.
65**
66** There are three routines here: lemon_sprintf(), lemon_vsprintf(), and
drh25473362015-09-04 18:03:45 +000067** lemon_addtext(). The first two are replacements for sprintf() and vsprintf().
drh898799f2014-01-10 23:21:00 +000068** The third is a helper routine for vsnprintf() that adds texts to the end of a
69** buffer, making sure the buffer is always zero-terminated.
70**
71** The string formatter is a minimal subset of stdlib sprintf() supporting only
72** a few simply conversions:
73**
74** %d
75** %s
76** %.*s
77**
78*/
79static void lemon_addtext(
80 char *zBuf, /* The buffer to which text is added */
81 int *pnUsed, /* Slots of the buffer used so far */
82 const char *zIn, /* Text to add */
drh61f92cd2014-01-11 03:06:18 +000083 int nIn, /* Bytes of text to add. -1 to use strlen() */
84 int iWidth /* Field width. Negative to left justify */
drh898799f2014-01-10 23:21:00 +000085){
86 if( nIn<0 ) for(nIn=0; zIn[nIn]; nIn++){}
drhecaa9d32014-01-11 03:27:37 +000087 while( iWidth>nIn ){ zBuf[(*pnUsed)++] = ' '; iWidth--; }
drh898799f2014-01-10 23:21:00 +000088 if( nIn==0 ) return;
89 memcpy(&zBuf[*pnUsed], zIn, nIn);
90 *pnUsed += nIn;
drhecaa9d32014-01-11 03:27:37 +000091 while( (-iWidth)>nIn ){ zBuf[(*pnUsed)++] = ' '; iWidth++; }
drh898799f2014-01-10 23:21:00 +000092 zBuf[*pnUsed] = 0;
93}
94static int lemon_vsprintf(char *str, const char *zFormat, va_list ap){
mistachkin7a429652014-01-14 10:17:21 +000095 int i, j, k, c;
drh898799f2014-01-10 23:21:00 +000096 int nUsed = 0;
97 const char *z;
98 char zTemp[50];
99 str[0] = 0;
100 for(i=j=0; (c = zFormat[i])!=0; i++){
101 if( c=='%' ){
drh61f92cd2014-01-11 03:06:18 +0000102 int iWidth = 0;
103 lemon_addtext(str, &nUsed, &zFormat[j], i-j, 0);
drh898799f2014-01-10 23:21:00 +0000104 c = zFormat[++i];
drhc56fac72015-10-29 13:48:15 +0000105 if( ISDIGIT(c) || (c=='-' && ISDIGIT(zFormat[i+1])) ){
drh61f92cd2014-01-11 03:06:18 +0000106 if( c=='-' ) i++;
drhc56fac72015-10-29 13:48:15 +0000107 while( ISDIGIT(zFormat[i]) ) iWidth = iWidth*10 + zFormat[i++] - '0';
drh61f92cd2014-01-11 03:06:18 +0000108 if( c=='-' ) iWidth = -iWidth;
109 c = zFormat[i];
110 }
drh898799f2014-01-10 23:21:00 +0000111 if( c=='d' ){
112 int v = va_arg(ap, int);
113 if( v<0 ){
drh61f92cd2014-01-11 03:06:18 +0000114 lemon_addtext(str, &nUsed, "-", 1, iWidth);
drh898799f2014-01-10 23:21:00 +0000115 v = -v;
116 }else if( v==0 ){
drh61f92cd2014-01-11 03:06:18 +0000117 lemon_addtext(str, &nUsed, "0", 1, iWidth);
drh898799f2014-01-10 23:21:00 +0000118 }
119 k = 0;
120 while( v>0 ){
121 k++;
122 zTemp[sizeof(zTemp)-k] = (v%10) + '0';
123 v /= 10;
124 }
drh61f92cd2014-01-11 03:06:18 +0000125 lemon_addtext(str, &nUsed, &zTemp[sizeof(zTemp)-k], k, iWidth);
drh898799f2014-01-10 23:21:00 +0000126 }else if( c=='s' ){
127 z = va_arg(ap, const char*);
drh61f92cd2014-01-11 03:06:18 +0000128 lemon_addtext(str, &nUsed, z, -1, iWidth);
drh898799f2014-01-10 23:21:00 +0000129 }else if( c=='.' && memcmp(&zFormat[i], ".*s", 3)==0 ){
130 i += 2;
131 k = va_arg(ap, int);
132 z = va_arg(ap, const char*);
drh61f92cd2014-01-11 03:06:18 +0000133 lemon_addtext(str, &nUsed, z, k, iWidth);
drh898799f2014-01-10 23:21:00 +0000134 }else if( c=='%' ){
drh61f92cd2014-01-11 03:06:18 +0000135 lemon_addtext(str, &nUsed, "%", 1, 0);
drh898799f2014-01-10 23:21:00 +0000136 }else{
137 fprintf(stderr, "illegal format\n");
138 exit(1);
139 }
140 j = i+1;
141 }
142 }
drh61f92cd2014-01-11 03:06:18 +0000143 lemon_addtext(str, &nUsed, &zFormat[j], i-j, 0);
drh898799f2014-01-10 23:21:00 +0000144 return nUsed;
145}
146static int lemon_sprintf(char *str, const char *format, ...){
147 va_list ap;
148 int rc;
149 va_start(ap, format);
150 rc = lemon_vsprintf(str, format, ap);
151 va_end(ap);
152 return rc;
153}
154static void lemon_strcpy(char *dest, const char *src){
155 while( (*(dest++) = *(src++))!=0 ){}
156}
157static void lemon_strcat(char *dest, const char *src){
158 while( *dest ) dest++;
159 lemon_strcpy(dest, src);
160}
161
162
icculus9e44cf12010-02-14 17:14:22 +0000163/* a few forward declarations... */
164struct rule;
165struct lemon;
166struct action;
167
drhe9278182007-07-18 18:16:29 +0000168static struct action *Action_new(void);
169static struct action *Action_sort(struct action *);
drh75897232000-05-29 14:26:00 +0000170
171/********** From the file "build.h" ************************************/
drh14d88552017-04-14 19:44:15 +0000172void FindRulePrecedences(struct lemon*);
173void FindFirstSets(struct lemon*);
174void FindStates(struct lemon*);
175void FindLinks(struct lemon*);
176void FindFollowSets(struct lemon*);
177void FindActions(struct lemon*);
drh75897232000-05-29 14:26:00 +0000178
179/********* From the file "configlist.h" *********************************/
icculus9e44cf12010-02-14 17:14:22 +0000180void Configlist_init(void);
181struct config *Configlist_add(struct rule *, int);
182struct config *Configlist_addbasis(struct rule *, int);
183void Configlist_closure(struct lemon *);
184void Configlist_sort(void);
185void Configlist_sortbasis(void);
186struct config *Configlist_return(void);
187struct config *Configlist_basis(void);
188void Configlist_eat(struct config *);
189void Configlist_reset(void);
drh75897232000-05-29 14:26:00 +0000190
191/********* From the file "error.h" ***************************************/
drhf9a2e7b2003-04-15 01:49:48 +0000192void ErrorMsg(const char *, int,const char *, ...);
drh75897232000-05-29 14:26:00 +0000193
194/****** From the file "option.h" ******************************************/
icculus9e44cf12010-02-14 17:14:22 +0000195enum option_type { OPT_FLAG=1, OPT_INT, OPT_DBL, OPT_STR,
196 OPT_FFLAG, OPT_FINT, OPT_FDBL, OPT_FSTR};
drh75897232000-05-29 14:26:00 +0000197struct s_options {
icculus9e44cf12010-02-14 17:14:22 +0000198 enum option_type type;
199 const char *label;
drh75897232000-05-29 14:26:00 +0000200 char *arg;
icculus9e44cf12010-02-14 17:14:22 +0000201 const char *message;
drh75897232000-05-29 14:26:00 +0000202};
icculus9e44cf12010-02-14 17:14:22 +0000203int OptInit(char**,struct s_options*,FILE*);
204int OptNArgs(void);
205char *OptArg(int);
206void OptErr(int);
207void OptPrint(void);
drh75897232000-05-29 14:26:00 +0000208
209/******** From the file "parse.h" *****************************************/
icculus9e44cf12010-02-14 17:14:22 +0000210void Parse(struct lemon *lemp);
drh75897232000-05-29 14:26:00 +0000211
212/********* From the file "plink.h" ***************************************/
icculus9e44cf12010-02-14 17:14:22 +0000213struct plink *Plink_new(void);
214void Plink_add(struct plink **, struct config *);
215void Plink_copy(struct plink **, struct plink *);
216void Plink_delete(struct plink *);
drh75897232000-05-29 14:26:00 +0000217
218/********** From the file "report.h" *************************************/
icculus9e44cf12010-02-14 17:14:22 +0000219void Reprint(struct lemon *);
220void ReportOutput(struct lemon *);
drhfe03dac2019-11-26 02:22:39 +0000221void ReportTable(struct lemon *, int, int);
icculus9e44cf12010-02-14 17:14:22 +0000222void ReportHeader(struct lemon *);
223void CompressTables(struct lemon *);
224void ResortStates(struct lemon *);
drh75897232000-05-29 14:26:00 +0000225
226/********** From the file "set.h" ****************************************/
icculus9e44cf12010-02-14 17:14:22 +0000227void SetSize(int); /* All sets will be of size N */
228char *SetNew(void); /* A new set for element 0..N */
229void SetFree(char*); /* Deallocate a set */
icculus9e44cf12010-02-14 17:14:22 +0000230int SetAdd(char*,int); /* Add element to a set */
231int SetUnion(char *,char *); /* A <- A U B, thru element N */
drh75897232000-05-29 14:26:00 +0000232#define SetFind(X,Y) (X[Y]) /* True if Y is in set X */
233
234/********** From the file "struct.h" *************************************/
235/*
236** Principal data structures for the LEMON parser generator.
237*/
238
drhaa9f1122007-08-23 02:50:56 +0000239typedef enum {LEMON_FALSE=0, LEMON_TRUE} Boolean;
drh75897232000-05-29 14:26:00 +0000240
241/* Symbols (terminals and nonterminals) of the grammar are stored
242** in the following: */
icculus9e44cf12010-02-14 17:14:22 +0000243enum symbol_type {
244 TERMINAL,
245 NONTERMINAL,
246 MULTITERMINAL
247};
248enum e_assoc {
drh75897232000-05-29 14:26:00 +0000249 LEFT,
250 RIGHT,
251 NONE,
252 UNK
icculus9e44cf12010-02-14 17:14:22 +0000253};
254struct symbol {
255 const char *name; /* Name of the symbol */
256 int index; /* Index number for this symbol */
257 enum symbol_type type; /* Symbols are all either TERMINALS or NTs */
258 struct rule *rule; /* Linked list of rules of this (if an NT) */
259 struct symbol *fallback; /* fallback token in case this token doesn't parse */
260 int prec; /* Precedence if defined (-1 otherwise) */
261 enum e_assoc assoc; /* Associativity if precedence is defined */
drh75897232000-05-29 14:26:00 +0000262 char *firstset; /* First-set for all rules of this symbol */
263 Boolean lambda; /* True if NT and can generate an empty string */
drhc4dd3fd2008-01-22 01:48:05 +0000264 int useCnt; /* Number of times used */
drh75897232000-05-29 14:26:00 +0000265 char *destructor; /* Code which executes whenever this symbol is
266 ** popped from the stack during error processing */
drh0f832dd2016-08-16 16:46:40 +0000267 int destLineno; /* Line number for start of destructor. Set to
268 ** -1 for duplicate destructors. */
drh75897232000-05-29 14:26:00 +0000269 char *datatype; /* The data type of information held by this
270 ** object. Only used if type==NONTERMINAL */
271 int dtnum; /* The data type number. In the parser, the value
272 ** stack is a union. The .yy%d element of this
273 ** union is the correct data type for this object */
drh539e7412018-04-21 20:24:19 +0000274 int bContent; /* True if this symbol ever carries content - if
275 ** it is ever more than just syntax */
drhfd405312005-11-06 04:06:59 +0000276 /* The following fields are used by MULTITERMINALs only */
277 int nsubsym; /* Number of constituent symbols in the MULTI */
278 struct symbol **subsym; /* Array of constituent symbols */
drh75897232000-05-29 14:26:00 +0000279};
280
281/* Each production rule in the grammar is stored in the following
282** structure. */
283struct rule {
284 struct symbol *lhs; /* Left-hand side of the rule */
icculus9e44cf12010-02-14 17:14:22 +0000285 const char *lhsalias; /* Alias for the LHS (NULL if none) */
drhb4960992007-10-05 16:16:36 +0000286 int lhsStart; /* True if left-hand side is the start symbol */
drh75897232000-05-29 14:26:00 +0000287 int ruleline; /* Line number for the rule */
288 int nrhs; /* Number of RHS symbols */
289 struct symbol **rhs; /* The RHS symbols */
icculus9e44cf12010-02-14 17:14:22 +0000290 const char **rhsalias; /* An alias for each RHS symbol (NULL if none) */
drh75897232000-05-29 14:26:00 +0000291 int line; /* Line number at which code begins */
icculus9e44cf12010-02-14 17:14:22 +0000292 const char *code; /* The code executed when this rule is reduced */
drh4dd0d3f2016-02-17 01:18:33 +0000293 const char *codePrefix; /* Setup code before code[] above */
294 const char *codeSuffix; /* Breakdown code after code[] above */
drh711c9812016-05-23 14:24:31 +0000295 int noCode; /* True if this rule has no associated C code */
296 int codeEmitted; /* True if the code has been emitted already */
drh75897232000-05-29 14:26:00 +0000297 struct symbol *precsym; /* Precedence symbol for this rule */
298 int index; /* An index number for this rule */
drh4ef07702016-03-16 19:45:54 +0000299 int iRule; /* Rule number as used in the generated tables */
drh75897232000-05-29 14:26:00 +0000300 Boolean canReduce; /* True if this rule is ever reduced */
drh756b41e2016-05-24 18:55:08 +0000301 Boolean doesReduce; /* Reduce actions occur after optimization */
drh75897232000-05-29 14:26:00 +0000302 struct rule *nextlhs; /* Next rule with the same LHS */
303 struct rule *next; /* Next rule in the global list */
304};
305
306/* A configuration is a production rule of the grammar together with
307** a mark (dot) showing how much of that rule has been processed so far.
308** Configurations also contain a follow-set which is a list of terminal
309** symbols which are allowed to immediately follow the end of the rule.
310** Every configuration is recorded as an instance of the following: */
icculus9e44cf12010-02-14 17:14:22 +0000311enum cfgstatus {
312 COMPLETE,
313 INCOMPLETE
314};
drh75897232000-05-29 14:26:00 +0000315struct config {
316 struct rule *rp; /* The rule upon which the configuration is based */
317 int dot; /* The parse point */
318 char *fws; /* Follow-set for this configuration only */
319 struct plink *fplp; /* Follow-set forward propagation links */
320 struct plink *bplp; /* Follow-set backwards propagation links */
321 struct state *stp; /* Pointer to state which contains this */
icculus9e44cf12010-02-14 17:14:22 +0000322 enum cfgstatus status; /* used during followset and shift computations */
drh75897232000-05-29 14:26:00 +0000323 struct config *next; /* Next configuration in the state */
324 struct config *bp; /* The next basis configuration */
325};
326
icculus9e44cf12010-02-14 17:14:22 +0000327enum e_action {
328 SHIFT,
329 ACCEPT,
330 REDUCE,
331 ERROR,
332 SSCONFLICT, /* A shift/shift conflict */
333 SRCONFLICT, /* Was a reduce, but part of a conflict */
334 RRCONFLICT, /* Was a reduce, but part of a conflict */
335 SH_RESOLVED, /* Was a shift. Precedence resolved conflict */
336 RD_RESOLVED, /* Was reduce. Precedence resolved conflict */
drh3bd48ab2015-09-07 18:23:37 +0000337 NOT_USED, /* Deleted by compression */
338 SHIFTREDUCE /* Shift first, then reduce */
icculus9e44cf12010-02-14 17:14:22 +0000339};
340
drh75897232000-05-29 14:26:00 +0000341/* Every shift or reduce operation is stored as one of the following */
342struct action {
343 struct symbol *sp; /* The look-ahead symbol */
icculus9e44cf12010-02-14 17:14:22 +0000344 enum e_action type;
drh75897232000-05-29 14:26:00 +0000345 union {
346 struct state *stp; /* The new state, if a shift */
347 struct rule *rp; /* The rule, if a reduce */
348 } x;
drhc173ad82016-05-23 16:15:02 +0000349 struct symbol *spOpt; /* SHIFTREDUCE optimization to this symbol */
drh75897232000-05-29 14:26:00 +0000350 struct action *next; /* Next action for this state */
351 struct action *collide; /* Next action with the same hash */
352};
353
354/* Each state of the generated parser's finite state machine
355** is encoded as an instance of the following structure. */
356struct state {
357 struct config *bp; /* The basis configurations for this state */
358 struct config *cfp; /* All configurations in this set */
drh34ff57b2008-07-14 12:27:51 +0000359 int statenum; /* Sequential number for this state */
drh711c9812016-05-23 14:24:31 +0000360 struct action *ap; /* List of actions for this state */
drh8b582012003-10-21 13:16:03 +0000361 int nTknAct, nNtAct; /* Number of actions on terminals and nonterminals */
362 int iTknOfst, iNtOfst; /* yy_action[] offset for terminals and nonterms */
drh3bd48ab2015-09-07 18:23:37 +0000363 int iDfltReduce; /* Default action is to REDUCE by this rule */
364 struct rule *pDfltReduce;/* The default REDUCE rule. */
365 int autoReduce; /* True if this is an auto-reduce state */
drh75897232000-05-29 14:26:00 +0000366};
drh8b582012003-10-21 13:16:03 +0000367#define NO_OFFSET (-2147483647)
drh75897232000-05-29 14:26:00 +0000368
369/* A followset propagation link indicates that the contents of one
370** configuration followset should be propagated to another whenever
371** the first changes. */
372struct plink {
373 struct config *cfp; /* The configuration to which linked */
374 struct plink *next; /* The next propagate link */
375};
376
377/* The state vector for the entire parser generator is recorded as
378** follows. (LEMON uses no global variables and makes little use of
379** static variables. Fields in the following structure can be thought
380** of as begin global variables in the program.) */
381struct lemon {
382 struct state **sorted; /* Table of states sorted by state number */
383 struct rule *rule; /* List of all rules */
drh4ef07702016-03-16 19:45:54 +0000384 struct rule *startRule; /* First rule */
drh75897232000-05-29 14:26:00 +0000385 int nstate; /* Number of states */
drh3bd48ab2015-09-07 18:23:37 +0000386 int nxstate; /* nstate with tail degenerate states removed */
drh75897232000-05-29 14:26:00 +0000387 int nrule; /* Number of rules */
388 int nsymbol; /* Number of terminal and nonterminal symbols */
389 int nterminal; /* Number of terminal symbols */
drh5c8241b2017-12-24 23:38:10 +0000390 int minShiftReduce; /* Minimum shift-reduce action value */
391 int errAction; /* Error action value */
392 int accAction; /* Accept action value */
393 int noAction; /* No-op action value */
394 int minReduce; /* Minimum reduce action */
395 int maxAction; /* Maximum action value of any kind */
drh75897232000-05-29 14:26:00 +0000396 struct symbol **symbols; /* Sorted array of pointers to symbols */
397 int errorcnt; /* Number of errors */
398 struct symbol *errsym; /* The error symbol */
drhe09daa92006-06-10 13:29:31 +0000399 struct symbol *wildcard; /* Token that matches anything */
drh75897232000-05-29 14:26:00 +0000400 char *name; /* Name of the generated parser */
401 char *arg; /* Declaration of the 3th argument to parser */
drhfb32c442018-04-21 13:51:42 +0000402 char *ctx; /* Declaration of 2nd argument to constructor */
drh75897232000-05-29 14:26:00 +0000403 char *tokentype; /* Type of terminal symbols in the parser stack */
drh960e8c62001-04-03 16:53:21 +0000404 char *vartype; /* The default type of non-terminal symbols */
drh75897232000-05-29 14:26:00 +0000405 char *start; /* Name of the start symbol for the grammar */
406 char *stacksize; /* Size of the parser stack */
407 char *include; /* Code to put at the start of the C file */
drh75897232000-05-29 14:26:00 +0000408 char *error; /* Code to execute when an error is seen */
drh75897232000-05-29 14:26:00 +0000409 char *overflow; /* Code to execute on a stack overflow */
drh75897232000-05-29 14:26:00 +0000410 char *failure; /* Code to execute on parser failure */
drh75897232000-05-29 14:26:00 +0000411 char *accept; /* Code to execute when the parser excepts */
drh75897232000-05-29 14:26:00 +0000412 char *extracode; /* Code appended to the generated file */
drh75897232000-05-29 14:26:00 +0000413 char *tokendest; /* Code to execute to destroy token data */
drh960e8c62001-04-03 16:53:21 +0000414 char *vardest; /* Code for the default non-terminal destructor */
drh75897232000-05-29 14:26:00 +0000415 char *filename; /* Name of the input file */
416 char *outname; /* Name of the current output file */
417 char *tokenprefix; /* A prefix added to token names in the .h file */
418 int nconflict; /* Number of parsing conflicts */
drhc75e0162015-09-07 02:23:02 +0000419 int nactiontab; /* Number of entries in the yy_action[] table */
drh3a9d6c72017-12-25 04:15:38 +0000420 int nlookaheadtab; /* Number of entries in yy_lookahead[] */
drhc75e0162015-09-07 02:23:02 +0000421 int tablesize; /* Total table size of all tables in bytes */
drh75897232000-05-29 14:26:00 +0000422 int basisflag; /* Print only basis configurations */
drh34ff57b2008-07-14 12:27:51 +0000423 int has_fallback; /* True if any %fallback is seen in the grammar */
shane58543932008-12-10 20:10:04 +0000424 int nolinenosflag; /* True if #line statements should not be printed */
drh75897232000-05-29 14:26:00 +0000425 char *argv0; /* Name of the program */
426};
427
428#define MemoryCheck(X) if((X)==0){ \
429 extern void memory_error(); \
430 memory_error(); \
431}
432
433/**************** From the file "table.h" *********************************/
434/*
435** All code in this file has been automatically generated
436** from a specification in the file
437** "table.q"
438** by the associative array code building program "aagen".
439** Do not edit this file! Instead, edit the specification
440** file, then rerun aagen.
441*/
442/*
443** Code for processing tables in the LEMON parser generator.
444*/
drh75897232000-05-29 14:26:00 +0000445/* Routines for handling a strings */
446
icculus9e44cf12010-02-14 17:14:22 +0000447const char *Strsafe(const char *);
drh75897232000-05-29 14:26:00 +0000448
icculus9e44cf12010-02-14 17:14:22 +0000449void Strsafe_init(void);
450int Strsafe_insert(const char *);
451const char *Strsafe_find(const char *);
drh75897232000-05-29 14:26:00 +0000452
453/* Routines for handling symbols of the grammar */
454
icculus9e44cf12010-02-14 17:14:22 +0000455struct symbol *Symbol_new(const char *);
456int Symbolcmpp(const void *, const void *);
457void Symbol_init(void);
458int Symbol_insert(struct symbol *, const char *);
459struct symbol *Symbol_find(const char *);
460struct symbol *Symbol_Nth(int);
461int Symbol_count(void);
462struct symbol **Symbol_arrayof(void);
drh75897232000-05-29 14:26:00 +0000463
464/* Routines to manage the state table */
465
icculus9e44cf12010-02-14 17:14:22 +0000466int Configcmp(const char *, const char *);
467struct state *State_new(void);
468void State_init(void);
469int State_insert(struct state *, struct config *);
470struct state *State_find(struct config *);
drh14d88552017-04-14 19:44:15 +0000471struct state **State_arrayof(void);
drh75897232000-05-29 14:26:00 +0000472
473/* Routines used for efficiency in Configlist_add */
474
icculus9e44cf12010-02-14 17:14:22 +0000475void Configtable_init(void);
476int Configtable_insert(struct config *);
477struct config *Configtable_find(struct config *);
478void Configtable_clear(int(*)(struct config *));
479
drh75897232000-05-29 14:26:00 +0000480/****************** From the file "action.c" *******************************/
481/*
482** Routines processing parser actions in the LEMON parser generator.
483*/
484
485/* Allocate a new parser action */
drhe9278182007-07-18 18:16:29 +0000486static struct action *Action_new(void){
mistachkind9bc6e82019-05-10 16:16:19 +0000487 static struct action *actionfreelist = 0;
icculus9e44cf12010-02-14 17:14:22 +0000488 struct action *newaction;
drh75897232000-05-29 14:26:00 +0000489
mistachkind9bc6e82019-05-10 16:16:19 +0000490 if( actionfreelist==0 ){
drh75897232000-05-29 14:26:00 +0000491 int i;
492 int amt = 100;
mistachkind9bc6e82019-05-10 16:16:19 +0000493 actionfreelist = (struct action *)calloc(amt, sizeof(struct action));
494 if( actionfreelist==0 ){
drh75897232000-05-29 14:26:00 +0000495 fprintf(stderr,"Unable to allocate memory for a new parser action.");
496 exit(1);
497 }
mistachkind9bc6e82019-05-10 16:16:19 +0000498 for(i=0; i<amt-1; i++) actionfreelist[i].next = &actionfreelist[i+1];
499 actionfreelist[amt-1].next = 0;
drh75897232000-05-29 14:26:00 +0000500 }
mistachkind9bc6e82019-05-10 16:16:19 +0000501 newaction = actionfreelist;
502 actionfreelist = actionfreelist->next;
icculus9e44cf12010-02-14 17:14:22 +0000503 return newaction;
drh75897232000-05-29 14:26:00 +0000504}
505
drhe9278182007-07-18 18:16:29 +0000506/* Compare two actions for sorting purposes. Return negative, zero, or
507** positive if the first action is less than, equal to, or greater than
508** the first
509*/
510static int actioncmp(
511 struct action *ap1,
512 struct action *ap2
513){
drh75897232000-05-29 14:26:00 +0000514 int rc;
515 rc = ap1->sp->index - ap2->sp->index;
drh75897232000-05-29 14:26:00 +0000516 if( rc==0 ){
drh9892c5d2007-12-21 00:02:11 +0000517 rc = (int)ap1->type - (int)ap2->type;
518 }
drh3bd48ab2015-09-07 18:23:37 +0000519 if( rc==0 && (ap1->type==REDUCE || ap1->type==SHIFTREDUCE) ){
drh75897232000-05-29 14:26:00 +0000520 rc = ap1->x.rp->index - ap2->x.rp->index;
521 }
drhe594bc32009-11-03 13:02:25 +0000522 if( rc==0 ){
icculus7b429aa2010-03-03 17:09:01 +0000523 rc = (int) (ap2 - ap1);
drhe594bc32009-11-03 13:02:25 +0000524 }
drh75897232000-05-29 14:26:00 +0000525 return rc;
526}
527
528/* Sort parser actions */
drhe9278182007-07-18 18:16:29 +0000529static struct action *Action_sort(
530 struct action *ap
531){
532 ap = (struct action *)msort((char *)ap,(char **)&ap->next,
533 (int(*)(const char*,const char*))actioncmp);
drh75897232000-05-29 14:26:00 +0000534 return ap;
535}
536
icculus9e44cf12010-02-14 17:14:22 +0000537void Action_add(
538 struct action **app,
539 enum e_action type,
540 struct symbol *sp,
541 char *arg
542){
543 struct action *newaction;
544 newaction = Action_new();
545 newaction->next = *app;
546 *app = newaction;
547 newaction->type = type;
548 newaction->sp = sp;
drhc173ad82016-05-23 16:15:02 +0000549 newaction->spOpt = 0;
drh75897232000-05-29 14:26:00 +0000550 if( type==SHIFT ){
icculus9e44cf12010-02-14 17:14:22 +0000551 newaction->x.stp = (struct state *)arg;
drh75897232000-05-29 14:26:00 +0000552 }else{
icculus9e44cf12010-02-14 17:14:22 +0000553 newaction->x.rp = (struct rule *)arg;
drh75897232000-05-29 14:26:00 +0000554 }
555}
drh8b582012003-10-21 13:16:03 +0000556/********************** New code to implement the "acttab" module ***********/
557/*
558** This module implements routines use to construct the yy_action[] table.
559*/
560
561/*
562** The state of the yy_action table under construction is an instance of
drh8dc3e8f2010-01-07 03:53:03 +0000563** the following structure.
564**
565** The yy_action table maps the pair (state_number, lookahead) into an
566** action_number. The table is an array of integers pairs. The state_number
567** determines an initial offset into the yy_action array. The lookahead
568** value is then added to this initial offset to get an index X into the
569** yy_action array. If the aAction[X].lookahead equals the value of the
570** of the lookahead input, then the value of the action_number output is
571** aAction[X].action. If the lookaheads do not match then the
572** default action for the state_number is returned.
573**
574** All actions associated with a single state_number are first entered
drh06f60d82017-04-14 19:46:12 +0000575** into aLookahead[] using multiple calls to acttab_action(). Then the
576** actions for that single state_number are placed into the aAction[]
drh8dc3e8f2010-01-07 03:53:03 +0000577** array with a single call to acttab_insert(). The acttab_insert() call
578** also resets the aLookahead[] array in preparation for the next
579** state number.
drh8b582012003-10-21 13:16:03 +0000580*/
icculus9e44cf12010-02-14 17:14:22 +0000581struct lookahead_action {
582 int lookahead; /* Value of the lookahead token */
583 int action; /* Action to take on the given lookahead */
584};
drh8b582012003-10-21 13:16:03 +0000585typedef struct acttab acttab;
586struct acttab {
587 int nAction; /* Number of used slots in aAction[] */
588 int nActionAlloc; /* Slots allocated for aAction[] */
icculus9e44cf12010-02-14 17:14:22 +0000589 struct lookahead_action
590 *aAction, /* The yy_action[] table under construction */
drh8b582012003-10-21 13:16:03 +0000591 *aLookahead; /* A single new transaction set */
592 int mnLookahead; /* Minimum aLookahead[].lookahead */
593 int mnAction; /* Action associated with mnLookahead */
594 int mxLookahead; /* Maximum aLookahead[].lookahead */
595 int nLookahead; /* Used slots in aLookahead[] */
596 int nLookaheadAlloc; /* Slots allocated in aLookahead[] */
drh3a9d6c72017-12-25 04:15:38 +0000597 int nterminal; /* Number of terminal symbols */
598 int nsymbol; /* total number of symbols */
drh8b582012003-10-21 13:16:03 +0000599};
600
601/* Return the number of entries in the yy_action table */
drh3a9d6c72017-12-25 04:15:38 +0000602#define acttab_lookahead_size(X) ((X)->nAction)
drh8b582012003-10-21 13:16:03 +0000603
604/* The value for the N-th entry in yy_action */
605#define acttab_yyaction(X,N) ((X)->aAction[N].action)
606
607/* The value for the N-th entry in yy_lookahead */
608#define acttab_yylookahead(X,N) ((X)->aAction[N].lookahead)
609
610/* Free all memory associated with the given acttab */
611void acttab_free(acttab *p){
612 free( p->aAction );
613 free( p->aLookahead );
614 free( p );
615}
616
617/* Allocate a new acttab structure */
drh3a9d6c72017-12-25 04:15:38 +0000618acttab *acttab_alloc(int nsymbol, int nterminal){
icculus9e44cf12010-02-14 17:14:22 +0000619 acttab *p = (acttab *) calloc( 1, sizeof(*p) );
drh8b582012003-10-21 13:16:03 +0000620 if( p==0 ){
621 fprintf(stderr,"Unable to allocate memory for a new acttab.");
622 exit(1);
623 }
624 memset(p, 0, sizeof(*p));
drh3a9d6c72017-12-25 04:15:38 +0000625 p->nsymbol = nsymbol;
626 p->nterminal = nterminal;
drh8b582012003-10-21 13:16:03 +0000627 return p;
628}
629
drh06f60d82017-04-14 19:46:12 +0000630/* Add a new action to the current transaction set.
drh8dc3e8f2010-01-07 03:53:03 +0000631**
632** This routine is called once for each lookahead for a particular
633** state.
drh8b582012003-10-21 13:16:03 +0000634*/
635void acttab_action(acttab *p, int lookahead, int action){
636 if( p->nLookahead>=p->nLookaheadAlloc ){
637 p->nLookaheadAlloc += 25;
icculus9e44cf12010-02-14 17:14:22 +0000638 p->aLookahead = (struct lookahead_action *) realloc( p->aLookahead,
drh8b582012003-10-21 13:16:03 +0000639 sizeof(p->aLookahead[0])*p->nLookaheadAlloc );
640 if( p->aLookahead==0 ){
641 fprintf(stderr,"malloc failed\n");
642 exit(1);
643 }
644 }
645 if( p->nLookahead==0 ){
646 p->mxLookahead = lookahead;
647 p->mnLookahead = lookahead;
648 p->mnAction = action;
649 }else{
650 if( p->mxLookahead<lookahead ) p->mxLookahead = lookahead;
651 if( p->mnLookahead>lookahead ){
652 p->mnLookahead = lookahead;
653 p->mnAction = action;
654 }
655 }
656 p->aLookahead[p->nLookahead].lookahead = lookahead;
657 p->aLookahead[p->nLookahead].action = action;
658 p->nLookahead++;
659}
660
661/*
662** Add the transaction set built up with prior calls to acttab_action()
663** into the current action table. Then reset the transaction set back
664** to an empty set in preparation for a new round of acttab_action() calls.
665**
666** Return the offset into the action table of the new transaction.
drh3a9d6c72017-12-25 04:15:38 +0000667**
668** If the makeItSafe parameter is true, then the offset is chosen so that
669** it is impossible to overread the yy_lookaside[] table regardless of
670** the lookaside token. This is done for the terminal symbols, as they
671** come from external inputs and can contain syntax errors. When makeItSafe
672** is false, there is more flexibility in selecting offsets, resulting in
673** a smaller table. For non-terminal symbols, which are never syntax errors,
674** makeItSafe can be false.
drh8b582012003-10-21 13:16:03 +0000675*/
drh3a9d6c72017-12-25 04:15:38 +0000676int acttab_insert(acttab *p, int makeItSafe){
677 int i, j, k, n, end;
drh8b582012003-10-21 13:16:03 +0000678 assert( p->nLookahead>0 );
679
680 /* Make sure we have enough space to hold the expanded action table
681 ** in the worst case. The worst case occurs if the transaction set
682 ** must be appended to the current action table
683 */
drh3a9d6c72017-12-25 04:15:38 +0000684 n = p->nsymbol + 1;
drh8dc3e8f2010-01-07 03:53:03 +0000685 if( p->nAction + n >= p->nActionAlloc ){
drhfdbf9282003-10-21 16:34:41 +0000686 int oldAlloc = p->nActionAlloc;
drh8b582012003-10-21 13:16:03 +0000687 p->nActionAlloc = p->nAction + n + p->nActionAlloc + 20;
icculus9e44cf12010-02-14 17:14:22 +0000688 p->aAction = (struct lookahead_action *) realloc( p->aAction,
drh8b582012003-10-21 13:16:03 +0000689 sizeof(p->aAction[0])*p->nActionAlloc);
690 if( p->aAction==0 ){
691 fprintf(stderr,"malloc failed\n");
692 exit(1);
693 }
drhfdbf9282003-10-21 16:34:41 +0000694 for(i=oldAlloc; i<p->nActionAlloc; i++){
drh8b582012003-10-21 13:16:03 +0000695 p->aAction[i].lookahead = -1;
696 p->aAction[i].action = -1;
697 }
698 }
699
drh06f60d82017-04-14 19:46:12 +0000700 /* Scan the existing action table looking for an offset that is a
drh8dc3e8f2010-01-07 03:53:03 +0000701 ** duplicate of the current transaction set. Fall out of the loop
702 ** if and when the duplicate is found.
drh8b582012003-10-21 13:16:03 +0000703 **
704 ** i is the index in p->aAction[] where p->mnLookahead is inserted.
705 */
drh3a9d6c72017-12-25 04:15:38 +0000706 end = makeItSafe ? p->mnLookahead : 0;
707 for(i=p->nAction-1; i>=end; i--){
drhf16371d2009-11-03 19:18:31 +0000708 if( p->aAction[i].lookahead==p->mnLookahead ){
drh8dc3e8f2010-01-07 03:53:03 +0000709 /* All lookaheads and actions in the aLookahead[] transaction
710 ** must match against the candidate aAction[i] entry. */
drh8b582012003-10-21 13:16:03 +0000711 if( p->aAction[i].action!=p->mnAction ) continue;
712 for(j=0; j<p->nLookahead; j++){
713 k = p->aLookahead[j].lookahead - p->mnLookahead + i;
714 if( k<0 || k>=p->nAction ) break;
715 if( p->aLookahead[j].lookahead!=p->aAction[k].lookahead ) break;
716 if( p->aLookahead[j].action!=p->aAction[k].action ) break;
717 }
718 if( j<p->nLookahead ) continue;
drh8dc3e8f2010-01-07 03:53:03 +0000719
720 /* No possible lookahead value that is not in the aLookahead[]
721 ** transaction is allowed to match aAction[i] */
drh8b582012003-10-21 13:16:03 +0000722 n = 0;
723 for(j=0; j<p->nAction; j++){
drhfdbf9282003-10-21 16:34:41 +0000724 if( p->aAction[j].lookahead<0 ) continue;
725 if( p->aAction[j].lookahead==j+p->mnLookahead-i ) n++;
drh8b582012003-10-21 13:16:03 +0000726 }
drhfdbf9282003-10-21 16:34:41 +0000727 if( n==p->nLookahead ){
drh8dc3e8f2010-01-07 03:53:03 +0000728 break; /* An exact match is found at offset i */
drhfdbf9282003-10-21 16:34:41 +0000729 }
drh8b582012003-10-21 13:16:03 +0000730 }
731 }
drh8dc3e8f2010-01-07 03:53:03 +0000732
733 /* If no existing offsets exactly match the current transaction, find an
734 ** an empty offset in the aAction[] table in which we can add the
735 ** aLookahead[] transaction.
736 */
drh3a9d6c72017-12-25 04:15:38 +0000737 if( i<end ){
drh8dc3e8f2010-01-07 03:53:03 +0000738 /* Look for holes in the aAction[] table that fit the current
739 ** aLookahead[] transaction. Leave i set to the offset of the hole.
740 ** If no holes are found, i is left at p->nAction, which means the
741 ** transaction will be appended. */
drh3a9d6c72017-12-25 04:15:38 +0000742 i = makeItSafe ? p->mnLookahead : 0;
743 for(; i<p->nActionAlloc - p->mxLookahead; i++){
drhf16371d2009-11-03 19:18:31 +0000744 if( p->aAction[i].lookahead<0 ){
745 for(j=0; j<p->nLookahead; j++){
746 k = p->aLookahead[j].lookahead - p->mnLookahead + i;
747 if( k<0 ) break;
748 if( p->aAction[k].lookahead>=0 ) break;
749 }
750 if( j<p->nLookahead ) continue;
751 for(j=0; j<p->nAction; j++){
752 if( p->aAction[j].lookahead==j+p->mnLookahead-i ) break;
753 }
754 if( j==p->nAction ){
755 break; /* Fits in empty slots */
756 }
757 }
758 }
759 }
drh8b582012003-10-21 13:16:03 +0000760 /* Insert transaction set at index i. */
drh3a9d6c72017-12-25 04:15:38 +0000761#if 0
762 printf("Acttab:");
763 for(j=0; j<p->nLookahead; j++){
764 printf(" %d", p->aLookahead[j].lookahead);
765 }
766 printf(" inserted at %d\n", i);
767#endif
drh8b582012003-10-21 13:16:03 +0000768 for(j=0; j<p->nLookahead; j++){
769 k = p->aLookahead[j].lookahead - p->mnLookahead + i;
770 p->aAction[k] = p->aLookahead[j];
771 if( k>=p->nAction ) p->nAction = k+1;
772 }
drh4396c612017-12-27 15:21:16 +0000773 if( makeItSafe && i+p->nterminal>=p->nAction ) p->nAction = i+p->nterminal+1;
drh8b582012003-10-21 13:16:03 +0000774 p->nLookahead = 0;
775
776 /* Return the offset that is added to the lookahead in order to get the
777 ** index into yy_action of the action */
778 return i - p->mnLookahead;
779}
780
drh3a9d6c72017-12-25 04:15:38 +0000781/*
782** Return the size of the action table without the trailing syntax error
783** entries.
784*/
785int acttab_action_size(acttab *p){
786 int n = p->nAction;
787 while( n>0 && p->aAction[n-1].lookahead<0 ){ n--; }
788 return n;
789}
790
drh75897232000-05-29 14:26:00 +0000791/********************** From the file "build.c" *****************************/
792/*
793** Routines to construction the finite state machine for the LEMON
794** parser generator.
795*/
796
797/* Find a precedence symbol of every rule in the grammar.
drh06f60d82017-04-14 19:46:12 +0000798**
drh75897232000-05-29 14:26:00 +0000799** Those rules which have a precedence symbol coded in the input
800** grammar using the "[symbol]" construct will already have the
801** rp->precsym field filled. Other rules take as their precedence
802** symbol the first RHS symbol with a defined precedence. If there
803** are not RHS symbols with a defined precedence, the precedence
804** symbol field is left blank.
805*/
icculus9e44cf12010-02-14 17:14:22 +0000806void FindRulePrecedences(struct lemon *xp)
drh75897232000-05-29 14:26:00 +0000807{
808 struct rule *rp;
809 for(rp=xp->rule; rp; rp=rp->next){
810 if( rp->precsym==0 ){
drhfd405312005-11-06 04:06:59 +0000811 int i, j;
812 for(i=0; i<rp->nrhs && rp->precsym==0; i++){
813 struct symbol *sp = rp->rhs[i];
814 if( sp->type==MULTITERMINAL ){
815 for(j=0; j<sp->nsubsym; j++){
816 if( sp->subsym[j]->prec>=0 ){
817 rp->precsym = sp->subsym[j];
818 break;
819 }
820 }
821 }else if( sp->prec>=0 ){
drh75897232000-05-29 14:26:00 +0000822 rp->precsym = rp->rhs[i];
drhf2f105d2012-08-20 15:53:54 +0000823 }
drh75897232000-05-29 14:26:00 +0000824 }
825 }
826 }
827 return;
828}
829
830/* Find all nonterminals which will generate the empty string.
831** Then go back and compute the first sets of every nonterminal.
832** The first set is the set of all terminal symbols which can begin
833** a string generated by that nonterminal.
834*/
icculus9e44cf12010-02-14 17:14:22 +0000835void FindFirstSets(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +0000836{
drhfd405312005-11-06 04:06:59 +0000837 int i, j;
drh75897232000-05-29 14:26:00 +0000838 struct rule *rp;
839 int progress;
840
841 for(i=0; i<lemp->nsymbol; i++){
drhaa9f1122007-08-23 02:50:56 +0000842 lemp->symbols[i]->lambda = LEMON_FALSE;
drh75897232000-05-29 14:26:00 +0000843 }
844 for(i=lemp->nterminal; i<lemp->nsymbol; i++){
845 lemp->symbols[i]->firstset = SetNew();
846 }
847
848 /* First compute all lambdas */
849 do{
850 progress = 0;
851 for(rp=lemp->rule; rp; rp=rp->next){
852 if( rp->lhs->lambda ) continue;
853 for(i=0; i<rp->nrhs; i++){
drh7dd1ac62012-01-07 15:17:18 +0000854 struct symbol *sp = rp->rhs[i];
855 assert( sp->type==NONTERMINAL || sp->lambda==LEMON_FALSE );
856 if( sp->lambda==LEMON_FALSE ) break;
drh75897232000-05-29 14:26:00 +0000857 }
858 if( i==rp->nrhs ){
drhaa9f1122007-08-23 02:50:56 +0000859 rp->lhs->lambda = LEMON_TRUE;
drh75897232000-05-29 14:26:00 +0000860 progress = 1;
861 }
862 }
863 }while( progress );
864
865 /* Now compute all first sets */
866 do{
867 struct symbol *s1, *s2;
868 progress = 0;
869 for(rp=lemp->rule; rp; rp=rp->next){
870 s1 = rp->lhs;
871 for(i=0; i<rp->nrhs; i++){
872 s2 = rp->rhs[i];
873 if( s2->type==TERMINAL ){
874 progress += SetAdd(s1->firstset,s2->index);
875 break;
drhfd405312005-11-06 04:06:59 +0000876 }else if( s2->type==MULTITERMINAL ){
877 for(j=0; j<s2->nsubsym; j++){
878 progress += SetAdd(s1->firstset,s2->subsym[j]->index);
879 }
880 break;
drhf2f105d2012-08-20 15:53:54 +0000881 }else if( s1==s2 ){
drhaa9f1122007-08-23 02:50:56 +0000882 if( s1->lambda==LEMON_FALSE ) break;
drhf2f105d2012-08-20 15:53:54 +0000883 }else{
drh75897232000-05-29 14:26:00 +0000884 progress += SetUnion(s1->firstset,s2->firstset);
drhaa9f1122007-08-23 02:50:56 +0000885 if( s2->lambda==LEMON_FALSE ) break;
drhf2f105d2012-08-20 15:53:54 +0000886 }
drh75897232000-05-29 14:26:00 +0000887 }
888 }
889 }while( progress );
890 return;
891}
892
893/* Compute all LR(0) states for the grammar. Links
894** are added to between some states so that the LR(1) follow sets
895** can be computed later.
896*/
icculus9e44cf12010-02-14 17:14:22 +0000897PRIVATE struct state *getstate(struct lemon *); /* forward reference */
898void FindStates(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +0000899{
900 struct symbol *sp;
901 struct rule *rp;
902
903 Configlist_init();
904
905 /* Find the start symbol */
906 if( lemp->start ){
907 sp = Symbol_find(lemp->start);
908 if( sp==0 ){
909 ErrorMsg(lemp->filename,0,
910"The specified start symbol \"%s\" is not \
911in a nonterminal of the grammar. \"%s\" will be used as the start \
drh4ef07702016-03-16 19:45:54 +0000912symbol instead.",lemp->start,lemp->startRule->lhs->name);
drh75897232000-05-29 14:26:00 +0000913 lemp->errorcnt++;
drh4ef07702016-03-16 19:45:54 +0000914 sp = lemp->startRule->lhs;
drh75897232000-05-29 14:26:00 +0000915 }
916 }else{
drh4ef07702016-03-16 19:45:54 +0000917 sp = lemp->startRule->lhs;
drh75897232000-05-29 14:26:00 +0000918 }
919
920 /* Make sure the start symbol doesn't occur on the right-hand side of
921 ** any rule. Report an error if it does. (YACC would generate a new
922 ** start symbol in this case.) */
923 for(rp=lemp->rule; rp; rp=rp->next){
924 int i;
925 for(i=0; i<rp->nrhs; i++){
drhfd405312005-11-06 04:06:59 +0000926 if( rp->rhs[i]==sp ){ /* FIX ME: Deal with multiterminals */
drh75897232000-05-29 14:26:00 +0000927 ErrorMsg(lemp->filename,0,
928"The start symbol \"%s\" occurs on the \
929right-hand side of a rule. This will result in a parser which \
930does not work properly.",sp->name);
931 lemp->errorcnt++;
932 }
933 }
934 }
935
936 /* The basis configuration set for the first state
937 ** is all rules which have the start symbol as their
938 ** left-hand side */
939 for(rp=sp->rule; rp; rp=rp->nextlhs){
940 struct config *newcfp;
drhb4960992007-10-05 16:16:36 +0000941 rp->lhsStart = 1;
drh75897232000-05-29 14:26:00 +0000942 newcfp = Configlist_addbasis(rp,0);
943 SetAdd(newcfp->fws,0);
944 }
945
946 /* Compute the first state. All other states will be
947 ** computed automatically during the computation of the first one.
948 ** The returned pointer to the first state is not used. */
949 (void)getstate(lemp);
950 return;
951}
952
953/* Return a pointer to a state which is described by the configuration
954** list which has been built from calls to Configlist_add.
955*/
icculus9e44cf12010-02-14 17:14:22 +0000956PRIVATE void buildshifts(struct lemon *, struct state *); /* Forwd ref */
957PRIVATE struct state *getstate(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +0000958{
959 struct config *cfp, *bp;
960 struct state *stp;
961
962 /* Extract the sorted basis of the new state. The basis was constructed
963 ** by prior calls to "Configlist_addbasis()". */
964 Configlist_sortbasis();
965 bp = Configlist_basis();
966
967 /* Get a state with the same basis */
968 stp = State_find(bp);
969 if( stp ){
970 /* A state with the same basis already exists! Copy all the follow-set
971 ** propagation links from the state under construction into the
972 ** preexisting state, then return a pointer to the preexisting state */
973 struct config *x, *y;
974 for(x=bp, y=stp->bp; x && y; x=x->bp, y=y->bp){
975 Plink_copy(&y->bplp,x->bplp);
976 Plink_delete(x->fplp);
977 x->fplp = x->bplp = 0;
978 }
979 cfp = Configlist_return();
980 Configlist_eat(cfp);
981 }else{
982 /* This really is a new state. Construct all the details */
983 Configlist_closure(lemp); /* Compute the configuration closure */
984 Configlist_sort(); /* Sort the configuration closure */
985 cfp = Configlist_return(); /* Get a pointer to the config list */
986 stp = State_new(); /* A new state structure */
987 MemoryCheck(stp);
988 stp->bp = bp; /* Remember the configuration basis */
989 stp->cfp = cfp; /* Remember the configuration closure */
drhada354d2005-11-05 15:03:59 +0000990 stp->statenum = lemp->nstate++; /* Every state gets a sequence number */
drh75897232000-05-29 14:26:00 +0000991 stp->ap = 0; /* No actions, yet. */
992 State_insert(stp,stp->bp); /* Add to the state table */
993 buildshifts(lemp,stp); /* Recursively compute successor states */
994 }
995 return stp;
996}
997
drhfd405312005-11-06 04:06:59 +0000998/*
999** Return true if two symbols are the same.
1000*/
icculus9e44cf12010-02-14 17:14:22 +00001001int same_symbol(struct symbol *a, struct symbol *b)
drhfd405312005-11-06 04:06:59 +00001002{
1003 int i;
1004 if( a==b ) return 1;
1005 if( a->type!=MULTITERMINAL ) return 0;
1006 if( b->type!=MULTITERMINAL ) return 0;
1007 if( a->nsubsym!=b->nsubsym ) return 0;
1008 for(i=0; i<a->nsubsym; i++){
1009 if( a->subsym[i]!=b->subsym[i] ) return 0;
1010 }
1011 return 1;
1012}
1013
drh75897232000-05-29 14:26:00 +00001014/* Construct all successor states to the given state. A "successor"
1015** state is any state which can be reached by a shift action.
1016*/
icculus9e44cf12010-02-14 17:14:22 +00001017PRIVATE void buildshifts(struct lemon *lemp, struct state *stp)
drh75897232000-05-29 14:26:00 +00001018{
1019 struct config *cfp; /* For looping thru the config closure of "stp" */
1020 struct config *bcfp; /* For the inner loop on config closure of "stp" */
icculus9e44cf12010-02-14 17:14:22 +00001021 struct config *newcfg; /* */
drh75897232000-05-29 14:26:00 +00001022 struct symbol *sp; /* Symbol following the dot in configuration "cfp" */
1023 struct symbol *bsp; /* Symbol following the dot in configuration "bcfp" */
1024 struct state *newstp; /* A pointer to a successor state */
1025
1026 /* Each configuration becomes complete after it contibutes to a successor
1027 ** state. Initially, all configurations are incomplete */
1028 for(cfp=stp->cfp; cfp; cfp=cfp->next) cfp->status = INCOMPLETE;
1029
1030 /* Loop through all configurations of the state "stp" */
1031 for(cfp=stp->cfp; cfp; cfp=cfp->next){
1032 if( cfp->status==COMPLETE ) continue; /* Already used by inner loop */
1033 if( cfp->dot>=cfp->rp->nrhs ) continue; /* Can't shift this config */
1034 Configlist_reset(); /* Reset the new config set */
1035 sp = cfp->rp->rhs[cfp->dot]; /* Symbol after the dot */
1036
1037 /* For every configuration in the state "stp" which has the symbol "sp"
1038 ** following its dot, add the same configuration to the basis set under
1039 ** construction but with the dot shifted one symbol to the right. */
1040 for(bcfp=cfp; bcfp; bcfp=bcfp->next){
1041 if( bcfp->status==COMPLETE ) continue; /* Already used */
1042 if( bcfp->dot>=bcfp->rp->nrhs ) continue; /* Can't shift this one */
1043 bsp = bcfp->rp->rhs[bcfp->dot]; /* Get symbol after dot */
drhfd405312005-11-06 04:06:59 +00001044 if( !same_symbol(bsp,sp) ) continue; /* Must be same as for "cfp" */
drh75897232000-05-29 14:26:00 +00001045 bcfp->status = COMPLETE; /* Mark this config as used */
icculus9e44cf12010-02-14 17:14:22 +00001046 newcfg = Configlist_addbasis(bcfp->rp,bcfp->dot+1);
1047 Plink_add(&newcfg->bplp,bcfp);
drh75897232000-05-29 14:26:00 +00001048 }
1049
1050 /* Get a pointer to the state described by the basis configuration set
1051 ** constructed in the preceding loop */
1052 newstp = getstate(lemp);
1053
1054 /* The state "newstp" is reached from the state "stp" by a shift action
1055 ** on the symbol "sp" */
drhfd405312005-11-06 04:06:59 +00001056 if( sp->type==MULTITERMINAL ){
1057 int i;
1058 for(i=0; i<sp->nsubsym; i++){
1059 Action_add(&stp->ap,SHIFT,sp->subsym[i],(char*)newstp);
1060 }
1061 }else{
1062 Action_add(&stp->ap,SHIFT,sp,(char *)newstp);
1063 }
drh75897232000-05-29 14:26:00 +00001064 }
1065}
1066
1067/*
1068** Construct the propagation links
1069*/
icculus9e44cf12010-02-14 17:14:22 +00001070void FindLinks(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +00001071{
1072 int i;
1073 struct config *cfp, *other;
1074 struct state *stp;
1075 struct plink *plp;
1076
1077 /* Housekeeping detail:
1078 ** Add to every propagate link a pointer back to the state to
1079 ** which the link is attached. */
1080 for(i=0; i<lemp->nstate; i++){
1081 stp = lemp->sorted[i];
1082 for(cfp=stp->cfp; cfp; cfp=cfp->next){
1083 cfp->stp = stp;
1084 }
1085 }
1086
1087 /* Convert all backlinks into forward links. Only the forward
1088 ** links are used in the follow-set computation. */
1089 for(i=0; i<lemp->nstate; i++){
1090 stp = lemp->sorted[i];
1091 for(cfp=stp->cfp; cfp; cfp=cfp->next){
1092 for(plp=cfp->bplp; plp; plp=plp->next){
1093 other = plp->cfp;
1094 Plink_add(&other->fplp,cfp);
1095 }
1096 }
1097 }
1098}
1099
1100/* Compute all followsets.
1101**
1102** A followset is the set of all symbols which can come immediately
1103** after a configuration.
1104*/
icculus9e44cf12010-02-14 17:14:22 +00001105void FindFollowSets(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +00001106{
1107 int i;
1108 struct config *cfp;
1109 struct plink *plp;
1110 int progress;
1111 int change;
1112
1113 for(i=0; i<lemp->nstate; i++){
1114 for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){
1115 cfp->status = INCOMPLETE;
1116 }
1117 }
drh06f60d82017-04-14 19:46:12 +00001118
drh75897232000-05-29 14:26:00 +00001119 do{
1120 progress = 0;
1121 for(i=0; i<lemp->nstate; i++){
1122 for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){
1123 if( cfp->status==COMPLETE ) continue;
1124 for(plp=cfp->fplp; plp; plp=plp->next){
1125 change = SetUnion(plp->cfp->fws,cfp->fws);
1126 if( change ){
1127 plp->cfp->status = INCOMPLETE;
1128 progress = 1;
drhf2f105d2012-08-20 15:53:54 +00001129 }
1130 }
drh75897232000-05-29 14:26:00 +00001131 cfp->status = COMPLETE;
1132 }
1133 }
1134 }while( progress );
1135}
1136
drh3cb2f6e2012-01-09 14:19:05 +00001137static int resolve_conflict(struct action *,struct action *);
drh75897232000-05-29 14:26:00 +00001138
1139/* Compute the reduce actions, and resolve conflicts.
1140*/
icculus9e44cf12010-02-14 17:14:22 +00001141void FindActions(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +00001142{
1143 int i,j;
1144 struct config *cfp;
1145 struct state *stp;
1146 struct symbol *sp;
1147 struct rule *rp;
1148
drh06f60d82017-04-14 19:46:12 +00001149 /* Add all of the reduce actions
drh75897232000-05-29 14:26:00 +00001150 ** A reduce action is added for each element of the followset of
1151 ** a configuration which has its dot at the extreme right.
1152 */
1153 for(i=0; i<lemp->nstate; i++){ /* Loop over all states */
1154 stp = lemp->sorted[i];
1155 for(cfp=stp->cfp; cfp; cfp=cfp->next){ /* Loop over all configurations */
1156 if( cfp->rp->nrhs==cfp->dot ){ /* Is dot at extreme right? */
1157 for(j=0; j<lemp->nterminal; j++){
1158 if( SetFind(cfp->fws,j) ){
1159 /* Add a reduce action to the state "stp" which will reduce by the
1160 ** rule "cfp->rp" if the lookahead symbol is "lemp->symbols[j]" */
drh218dc692004-05-31 23:13:45 +00001161 Action_add(&stp->ap,REDUCE,lemp->symbols[j],(char *)cfp->rp);
drh75897232000-05-29 14:26:00 +00001162 }
drhf2f105d2012-08-20 15:53:54 +00001163 }
drh75897232000-05-29 14:26:00 +00001164 }
1165 }
1166 }
1167
1168 /* Add the accepting token */
1169 if( lemp->start ){
1170 sp = Symbol_find(lemp->start);
drh4ef07702016-03-16 19:45:54 +00001171 if( sp==0 ) sp = lemp->startRule->lhs;
drh75897232000-05-29 14:26:00 +00001172 }else{
drh4ef07702016-03-16 19:45:54 +00001173 sp = lemp->startRule->lhs;
drh75897232000-05-29 14:26:00 +00001174 }
1175 /* Add to the first state (which is always the starting state of the
1176 ** finite state machine) an action to ACCEPT if the lookahead is the
1177 ** start nonterminal. */
1178 Action_add(&lemp->sorted[0]->ap,ACCEPT,sp,0);
1179
1180 /* Resolve conflicts */
1181 for(i=0; i<lemp->nstate; i++){
1182 struct action *ap, *nap;
drh75897232000-05-29 14:26:00 +00001183 stp = lemp->sorted[i];
drhe9278182007-07-18 18:16:29 +00001184 /* assert( stp->ap ); */
drh75897232000-05-29 14:26:00 +00001185 stp->ap = Action_sort(stp->ap);
drhb59499c2002-02-23 18:45:13 +00001186 for(ap=stp->ap; ap && ap->next; ap=ap->next){
drh75897232000-05-29 14:26:00 +00001187 for(nap=ap->next; nap && nap->sp==ap->sp; nap=nap->next){
1188 /* The two actions "ap" and "nap" have the same lookahead.
1189 ** Figure out which one should be used */
drh3cb2f6e2012-01-09 14:19:05 +00001190 lemp->nconflict += resolve_conflict(ap,nap);
drh75897232000-05-29 14:26:00 +00001191 }
1192 }
1193 }
1194
1195 /* Report an error for each rule that can never be reduced. */
drhaa9f1122007-08-23 02:50:56 +00001196 for(rp=lemp->rule; rp; rp=rp->next) rp->canReduce = LEMON_FALSE;
drh75897232000-05-29 14:26:00 +00001197 for(i=0; i<lemp->nstate; i++){
1198 struct action *ap;
1199 for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){
drhaa9f1122007-08-23 02:50:56 +00001200 if( ap->type==REDUCE ) ap->x.rp->canReduce = LEMON_TRUE;
drh75897232000-05-29 14:26:00 +00001201 }
1202 }
1203 for(rp=lemp->rule; rp; rp=rp->next){
1204 if( rp->canReduce ) continue;
1205 ErrorMsg(lemp->filename,rp->ruleline,"This rule can not be reduced.\n");
1206 lemp->errorcnt++;
1207 }
1208}
1209
1210/* Resolve a conflict between the two given actions. If the
drh34ff57b2008-07-14 12:27:51 +00001211** conflict can't be resolved, return non-zero.
drh75897232000-05-29 14:26:00 +00001212**
1213** NO LONGER TRUE:
1214** To resolve a conflict, first look to see if either action
1215** is on an error rule. In that case, take the action which
1216** is not associated with the error rule. If neither or both
1217** actions are associated with an error rule, then try to
1218** use precedence to resolve the conflict.
1219**
1220** If either action is a SHIFT, then it must be apx. This
1221** function won't work if apx->type==REDUCE and apy->type==SHIFT.
1222*/
icculus9e44cf12010-02-14 17:14:22 +00001223static int resolve_conflict(
1224 struct action *apx,
drh3cb2f6e2012-01-09 14:19:05 +00001225 struct action *apy
icculus9e44cf12010-02-14 17:14:22 +00001226){
drh75897232000-05-29 14:26:00 +00001227 struct symbol *spx, *spy;
1228 int errcnt = 0;
1229 assert( apx->sp==apy->sp ); /* Otherwise there would be no conflict */
drhf0fa1c12006-12-14 01:06:22 +00001230 if( apx->type==SHIFT && apy->type==SHIFT ){
drh9892c5d2007-12-21 00:02:11 +00001231 apy->type = SSCONFLICT;
drhf0fa1c12006-12-14 01:06:22 +00001232 errcnt++;
1233 }
drh75897232000-05-29 14:26:00 +00001234 if( apx->type==SHIFT && apy->type==REDUCE ){
1235 spx = apx->sp;
1236 spy = apy->x.rp->precsym;
1237 if( spy==0 || spx->prec<0 || spy->prec<0 ){
1238 /* Not enough precedence information. */
drh9892c5d2007-12-21 00:02:11 +00001239 apy->type = SRCONFLICT;
drh75897232000-05-29 14:26:00 +00001240 errcnt++;
drhdd7e9db2010-07-19 01:52:07 +00001241 }else if( spx->prec>spy->prec ){ /* higher precedence wins */
drh75897232000-05-29 14:26:00 +00001242 apy->type = RD_RESOLVED;
1243 }else if( spx->prec<spy->prec ){
1244 apx->type = SH_RESOLVED;
1245 }else if( spx->prec==spy->prec && spx->assoc==RIGHT ){ /* Use operator */
1246 apy->type = RD_RESOLVED; /* associativity */
1247 }else if( spx->prec==spy->prec && spx->assoc==LEFT ){ /* to break tie */
1248 apx->type = SH_RESOLVED;
1249 }else{
1250 assert( spx->prec==spy->prec && spx->assoc==NONE );
drh62a223e2014-06-09 13:11:40 +00001251 apx->type = ERROR;
drh75897232000-05-29 14:26:00 +00001252 }
1253 }else if( apx->type==REDUCE && apy->type==REDUCE ){
1254 spx = apx->x.rp->precsym;
1255 spy = apy->x.rp->precsym;
1256 if( spx==0 || spy==0 || spx->prec<0 ||
1257 spy->prec<0 || spx->prec==spy->prec ){
drh9892c5d2007-12-21 00:02:11 +00001258 apy->type = RRCONFLICT;
drh75897232000-05-29 14:26:00 +00001259 errcnt++;
1260 }else if( spx->prec>spy->prec ){
1261 apy->type = RD_RESOLVED;
1262 }else if( spx->prec<spy->prec ){
1263 apx->type = RD_RESOLVED;
1264 }
1265 }else{
drh06f60d82017-04-14 19:46:12 +00001266 assert(
drhb59499c2002-02-23 18:45:13 +00001267 apx->type==SH_RESOLVED ||
1268 apx->type==RD_RESOLVED ||
drh9892c5d2007-12-21 00:02:11 +00001269 apx->type==SSCONFLICT ||
1270 apx->type==SRCONFLICT ||
1271 apx->type==RRCONFLICT ||
drhb59499c2002-02-23 18:45:13 +00001272 apy->type==SH_RESOLVED ||
1273 apy->type==RD_RESOLVED ||
drh9892c5d2007-12-21 00:02:11 +00001274 apy->type==SSCONFLICT ||
1275 apy->type==SRCONFLICT ||
1276 apy->type==RRCONFLICT
drhb59499c2002-02-23 18:45:13 +00001277 );
1278 /* The REDUCE/SHIFT case cannot happen because SHIFTs come before
1279 ** REDUCEs on the list. If we reach this point it must be because
1280 ** the parser conflict had already been resolved. */
drh75897232000-05-29 14:26:00 +00001281 }
1282 return errcnt;
1283}
1284/********************* From the file "configlist.c" *************************/
1285/*
1286** Routines to processing a configuration list and building a state
1287** in the LEMON parser generator.
1288*/
1289
1290static struct config *freelist = 0; /* List of free configurations */
1291static struct config *current = 0; /* Top of list of configurations */
1292static struct config **currentend = 0; /* Last on list of configs */
1293static struct config *basis = 0; /* Top of list of basis configs */
1294static struct config **basisend = 0; /* End of list of basis configs */
1295
1296/* Return a pointer to a new configuration */
drh14d88552017-04-14 19:44:15 +00001297PRIVATE struct config *newconfig(void){
icculus9e44cf12010-02-14 17:14:22 +00001298 struct config *newcfg;
drh75897232000-05-29 14:26:00 +00001299 if( freelist==0 ){
1300 int i;
1301 int amt = 3;
drh9892c5d2007-12-21 00:02:11 +00001302 freelist = (struct config *)calloc( amt, sizeof(struct config) );
drh75897232000-05-29 14:26:00 +00001303 if( freelist==0 ){
1304 fprintf(stderr,"Unable to allocate memory for a new configuration.");
1305 exit(1);
1306 }
1307 for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1];
1308 freelist[amt-1].next = 0;
1309 }
icculus9e44cf12010-02-14 17:14:22 +00001310 newcfg = freelist;
drh75897232000-05-29 14:26:00 +00001311 freelist = freelist->next;
icculus9e44cf12010-02-14 17:14:22 +00001312 return newcfg;
drh75897232000-05-29 14:26:00 +00001313}
1314
1315/* The configuration "old" is no longer used */
icculus9e44cf12010-02-14 17:14:22 +00001316PRIVATE void deleteconfig(struct config *old)
drh75897232000-05-29 14:26:00 +00001317{
1318 old->next = freelist;
1319 freelist = old;
1320}
1321
1322/* Initialized the configuration list builder */
drh14d88552017-04-14 19:44:15 +00001323void Configlist_init(void){
drh75897232000-05-29 14:26:00 +00001324 current = 0;
1325 currentend = &current;
1326 basis = 0;
1327 basisend = &basis;
1328 Configtable_init();
1329 return;
1330}
1331
1332/* Initialized the configuration list builder */
drh14d88552017-04-14 19:44:15 +00001333void Configlist_reset(void){
drh75897232000-05-29 14:26:00 +00001334 current = 0;
1335 currentend = &current;
1336 basis = 0;
1337 basisend = &basis;
1338 Configtable_clear(0);
1339 return;
1340}
1341
1342/* Add another configuration to the configuration list */
icculus9e44cf12010-02-14 17:14:22 +00001343struct config *Configlist_add(
1344 struct rule *rp, /* The rule */
1345 int dot /* Index into the RHS of the rule where the dot goes */
1346){
drh75897232000-05-29 14:26:00 +00001347 struct config *cfp, model;
1348
1349 assert( currentend!=0 );
1350 model.rp = rp;
1351 model.dot = dot;
1352 cfp = Configtable_find(&model);
1353 if( cfp==0 ){
1354 cfp = newconfig();
1355 cfp->rp = rp;
1356 cfp->dot = dot;
1357 cfp->fws = SetNew();
1358 cfp->stp = 0;
1359 cfp->fplp = cfp->bplp = 0;
1360 cfp->next = 0;
1361 cfp->bp = 0;
1362 *currentend = cfp;
1363 currentend = &cfp->next;
1364 Configtable_insert(cfp);
1365 }
1366 return cfp;
1367}
1368
1369/* Add a basis configuration to the configuration list */
icculus9e44cf12010-02-14 17:14:22 +00001370struct config *Configlist_addbasis(struct rule *rp, int dot)
drh75897232000-05-29 14:26:00 +00001371{
1372 struct config *cfp, model;
1373
1374 assert( basisend!=0 );
1375 assert( currentend!=0 );
1376 model.rp = rp;
1377 model.dot = dot;
1378 cfp = Configtable_find(&model);
1379 if( cfp==0 ){
1380 cfp = newconfig();
1381 cfp->rp = rp;
1382 cfp->dot = dot;
1383 cfp->fws = SetNew();
1384 cfp->stp = 0;
1385 cfp->fplp = cfp->bplp = 0;
1386 cfp->next = 0;
1387 cfp->bp = 0;
1388 *currentend = cfp;
1389 currentend = &cfp->next;
1390 *basisend = cfp;
1391 basisend = &cfp->bp;
1392 Configtable_insert(cfp);
1393 }
1394 return cfp;
1395}
1396
1397/* Compute the closure of the configuration list */
icculus9e44cf12010-02-14 17:14:22 +00001398void Configlist_closure(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +00001399{
1400 struct config *cfp, *newcfp;
1401 struct rule *rp, *newrp;
1402 struct symbol *sp, *xsp;
1403 int i, dot;
1404
1405 assert( currentend!=0 );
1406 for(cfp=current; cfp; cfp=cfp->next){
1407 rp = cfp->rp;
1408 dot = cfp->dot;
1409 if( dot>=rp->nrhs ) continue;
1410 sp = rp->rhs[dot];
1411 if( sp->type==NONTERMINAL ){
1412 if( sp->rule==0 && sp!=lemp->errsym ){
1413 ErrorMsg(lemp->filename,rp->line,"Nonterminal \"%s\" has no rules.",
1414 sp->name);
1415 lemp->errorcnt++;
1416 }
1417 for(newrp=sp->rule; newrp; newrp=newrp->nextlhs){
1418 newcfp = Configlist_add(newrp,0);
1419 for(i=dot+1; i<rp->nrhs; i++){
1420 xsp = rp->rhs[i];
1421 if( xsp->type==TERMINAL ){
1422 SetAdd(newcfp->fws,xsp->index);
1423 break;
drhfd405312005-11-06 04:06:59 +00001424 }else if( xsp->type==MULTITERMINAL ){
1425 int k;
1426 for(k=0; k<xsp->nsubsym; k++){
1427 SetAdd(newcfp->fws, xsp->subsym[k]->index);
1428 }
1429 break;
drhf2f105d2012-08-20 15:53:54 +00001430 }else{
drh75897232000-05-29 14:26:00 +00001431 SetUnion(newcfp->fws,xsp->firstset);
drhaa9f1122007-08-23 02:50:56 +00001432 if( xsp->lambda==LEMON_FALSE ) break;
drhf2f105d2012-08-20 15:53:54 +00001433 }
1434 }
drh75897232000-05-29 14:26:00 +00001435 if( i==rp->nrhs ) Plink_add(&cfp->fplp,newcfp);
1436 }
1437 }
1438 }
1439 return;
1440}
1441
1442/* Sort the configuration list */
drh14d88552017-04-14 19:44:15 +00001443void Configlist_sort(void){
drh25473362015-09-04 18:03:45 +00001444 current = (struct config*)msort((char*)current,(char**)&(current->next),
1445 Configcmp);
drh75897232000-05-29 14:26:00 +00001446 currentend = 0;
1447 return;
1448}
1449
1450/* Sort the basis configuration list */
drh14d88552017-04-14 19:44:15 +00001451void Configlist_sortbasis(void){
drh25473362015-09-04 18:03:45 +00001452 basis = (struct config*)msort((char*)current,(char**)&(current->bp),
1453 Configcmp);
drh75897232000-05-29 14:26:00 +00001454 basisend = 0;
1455 return;
1456}
1457
1458/* Return a pointer to the head of the configuration list and
1459** reset the list */
drh14d88552017-04-14 19:44:15 +00001460struct config *Configlist_return(void){
drh75897232000-05-29 14:26:00 +00001461 struct config *old;
1462 old = current;
1463 current = 0;
1464 currentend = 0;
1465 return old;
1466}
1467
1468/* Return a pointer to the head of the configuration list and
1469** reset the list */
drh14d88552017-04-14 19:44:15 +00001470struct config *Configlist_basis(void){
drh75897232000-05-29 14:26:00 +00001471 struct config *old;
1472 old = basis;
1473 basis = 0;
1474 basisend = 0;
1475 return old;
1476}
1477
1478/* Free all elements of the given configuration list */
icculus9e44cf12010-02-14 17:14:22 +00001479void Configlist_eat(struct config *cfp)
drh75897232000-05-29 14:26:00 +00001480{
1481 struct config *nextcfp;
1482 for(; cfp; cfp=nextcfp){
1483 nextcfp = cfp->next;
1484 assert( cfp->fplp==0 );
1485 assert( cfp->bplp==0 );
1486 if( cfp->fws ) SetFree(cfp->fws);
1487 deleteconfig(cfp);
1488 }
1489 return;
1490}
1491/***************** From the file "error.c" *********************************/
1492/*
1493** Code for printing error message.
1494*/
1495
drhf9a2e7b2003-04-15 01:49:48 +00001496void ErrorMsg(const char *filename, int lineno, const char *format, ...){
icculus15a2cec2010-02-16 16:07:28 +00001497 va_list ap;
icculus1c11f742010-02-15 00:01:04 +00001498 fprintf(stderr, "%s:%d: ", filename, lineno);
1499 va_start(ap, format);
1500 vfprintf(stderr,format,ap);
1501 va_end(ap);
1502 fprintf(stderr, "\n");
drh75897232000-05-29 14:26:00 +00001503}
1504/**************** From the file "main.c" ************************************/
1505/*
1506** Main program file for the LEMON parser generator.
1507*/
1508
1509/* Report an out-of-memory condition and abort. This function
1510** is used mostly by the "MemoryCheck" macro in struct.h
1511*/
drh14d88552017-04-14 19:44:15 +00001512void memory_error(void){
drh75897232000-05-29 14:26:00 +00001513 fprintf(stderr,"Out of memory. Aborting...\n");
1514 exit(1);
1515}
1516
drh6d08b4d2004-07-20 12:45:22 +00001517static int nDefine = 0; /* Number of -D options on the command line */
1518static char **azDefine = 0; /* Name of the -D macros */
1519
1520/* This routine is called with the argument to each -D command-line option.
1521** Add the macro defined to the azDefine array.
1522*/
1523static void handle_D_option(char *z){
1524 char **paz;
1525 nDefine++;
icculus9e44cf12010-02-14 17:14:22 +00001526 azDefine = (char **) realloc(azDefine, sizeof(azDefine[0])*nDefine);
drh6d08b4d2004-07-20 12:45:22 +00001527 if( azDefine==0 ){
1528 fprintf(stderr,"out of memory\n");
1529 exit(1);
1530 }
1531 paz = &azDefine[nDefine-1];
icculus9e44cf12010-02-14 17:14:22 +00001532 *paz = (char *) malloc( lemonStrlen(z)+1 );
drh6d08b4d2004-07-20 12:45:22 +00001533 if( *paz==0 ){
1534 fprintf(stderr,"out of memory\n");
1535 exit(1);
1536 }
drh898799f2014-01-10 23:21:00 +00001537 lemon_strcpy(*paz, z);
drh6d08b4d2004-07-20 12:45:22 +00001538 for(z=*paz; *z && *z!='='; z++){}
1539 *z = 0;
1540}
1541
drh9f88e6d2018-04-20 20:47:49 +00001542/* Rember the name of the output directory
1543*/
1544static char *outputDir = NULL;
1545static void handle_d_option(char *z){
1546 outputDir = (char *) malloc( lemonStrlen(z)+1 );
1547 if( outputDir==0 ){
1548 fprintf(stderr,"out of memory\n");
1549 exit(1);
1550 }
1551 lemon_strcpy(outputDir, z);
1552}
1553
icculus3e143bd2010-02-14 00:48:49 +00001554static char *user_templatename = NULL;
1555static void handle_T_option(char *z){
icculus9e44cf12010-02-14 17:14:22 +00001556 user_templatename = (char *) malloc( lemonStrlen(z)+1 );
icculus3e143bd2010-02-14 00:48:49 +00001557 if( user_templatename==0 ){
1558 memory_error();
1559 }
drh898799f2014-01-10 23:21:00 +00001560 lemon_strcpy(user_templatename, z);
icculus3e143bd2010-02-14 00:48:49 +00001561}
drh75897232000-05-29 14:26:00 +00001562
drh711c9812016-05-23 14:24:31 +00001563/* Merge together to lists of rules ordered by rule.iRule */
drh4ef07702016-03-16 19:45:54 +00001564static struct rule *Rule_merge(struct rule *pA, struct rule *pB){
1565 struct rule *pFirst = 0;
1566 struct rule **ppPrev = &pFirst;
1567 while( pA && pB ){
1568 if( pA->iRule<pB->iRule ){
1569 *ppPrev = pA;
1570 ppPrev = &pA->next;
1571 pA = pA->next;
1572 }else{
1573 *ppPrev = pB;
1574 ppPrev = &pB->next;
1575 pB = pB->next;
1576 }
1577 }
1578 if( pA ){
1579 *ppPrev = pA;
1580 }else{
1581 *ppPrev = pB;
1582 }
1583 return pFirst;
1584}
1585
1586/*
1587** Sort a list of rules in order of increasing iRule value
1588*/
1589static struct rule *Rule_sort(struct rule *rp){
1590 int i;
1591 struct rule *pNext;
1592 struct rule *x[32];
1593 memset(x, 0, sizeof(x));
1594 while( rp ){
1595 pNext = rp->next;
1596 rp->next = 0;
1597 for(i=0; i<sizeof(x)/sizeof(x[0]) && x[i]; i++){
1598 rp = Rule_merge(x[i], rp);
1599 x[i] = 0;
1600 }
1601 x[i] = rp;
1602 rp = pNext;
1603 }
1604 rp = 0;
1605 for(i=0; i<sizeof(x)/sizeof(x[0]); i++){
1606 rp = Rule_merge(x[i], rp);
1607 }
1608 return rp;
1609}
1610
drhc75e0162015-09-07 02:23:02 +00001611/* forward reference */
1612static const char *minimum_size_type(int lwr, int upr, int *pnByte);
1613
1614/* Print a single line of the "Parser Stats" output
1615*/
1616static void stats_line(const char *zLabel, int iValue){
1617 int nLabel = lemonStrlen(zLabel);
1618 printf(" %s%.*s %5d\n", zLabel,
1619 35-nLabel, "................................",
1620 iValue);
1621}
1622
drh75897232000-05-29 14:26:00 +00001623/* The main program. Parse the command line and do it... */
icculus9e44cf12010-02-14 17:14:22 +00001624int main(int argc, char **argv)
drh75897232000-05-29 14:26:00 +00001625{
1626 static int version = 0;
1627 static int rpflag = 0;
1628 static int basisflag = 0;
1629 static int compress = 0;
1630 static int quiet = 0;
1631 static int statistics = 0;
1632 static int mhflag = 0;
shane58543932008-12-10 20:10:04 +00001633 static int nolinenosflag = 0;
drhdd7e9db2010-07-19 01:52:07 +00001634 static int noResort = 0;
drhfe03dac2019-11-26 02:22:39 +00001635 static int sqlFlag = 0;
drh9f88e6d2018-04-20 20:47:49 +00001636
drh75897232000-05-29 14:26:00 +00001637 static struct s_options options[] = {
1638 {OPT_FLAG, "b", (char*)&basisflag, "Print only the basis in report."},
1639 {OPT_FLAG, "c", (char*)&compress, "Don't compress the action table."},
drh9f88e6d2018-04-20 20:47:49 +00001640 {OPT_FSTR, "d", (char*)&handle_d_option, "Output directory. Default '.'"},
drh6d08b4d2004-07-20 12:45:22 +00001641 {OPT_FSTR, "D", (char*)handle_D_option, "Define an %ifdef macro."},
drh0325d392015-01-01 19:11:22 +00001642 {OPT_FSTR, "f", 0, "Ignored. (Placeholder for -f compiler options.)"},
drh75897232000-05-29 14:26:00 +00001643 {OPT_FLAG, "g", (char*)&rpflag, "Print grammar without actions."},
drh0325d392015-01-01 19:11:22 +00001644 {OPT_FSTR, "I", 0, "Ignored. (Placeholder for '-I' compiler options.)"},
shane58543932008-12-10 20:10:04 +00001645 {OPT_FLAG, "m", (char*)&mhflag, "Output a makeheaders compatible file."},
1646 {OPT_FLAG, "l", (char*)&nolinenosflag, "Do not print #line statements."},
drh0325d392015-01-01 19:11:22 +00001647 {OPT_FSTR, "O", 0, "Ignored. (Placeholder for '-O' compiler options.)"},
drhf5c4e0f2010-07-18 11:35:53 +00001648 {OPT_FLAG, "p", (char*)&showPrecedenceConflict,
1649 "Show conflicts resolved by precedence rules"},
drh75897232000-05-29 14:26:00 +00001650 {OPT_FLAG, "q", (char*)&quiet, "(Quiet) Don't print the report file."},
drhdd7e9db2010-07-19 01:52:07 +00001651 {OPT_FLAG, "r", (char*)&noResort, "Do not sort or renumber states"},
drh6d08b4d2004-07-20 12:45:22 +00001652 {OPT_FLAG, "s", (char*)&statistics,
1653 "Print parser stats to standard output."},
drhfe03dac2019-11-26 02:22:39 +00001654 {OPT_FLAG, "S", (char*)&sqlFlag,
1655 "Generate the *.sql file describing the parser tables."},
drh75897232000-05-29 14:26:00 +00001656 {OPT_FLAG, "x", (char*)&version, "Print the version number."},
drh0325d392015-01-01 19:11:22 +00001657 {OPT_FSTR, "T", (char*)handle_T_option, "Specify a template file."},
1658 {OPT_FSTR, "W", 0, "Ignored. (Placeholder for '-W' compiler options.)"},
drh75897232000-05-29 14:26:00 +00001659 {OPT_FLAG,0,0,0}
1660 };
1661 int i;
icculus42585cf2010-02-14 05:19:56 +00001662 int exitcode;
drh75897232000-05-29 14:26:00 +00001663 struct lemon lem;
drh4ef07702016-03-16 19:45:54 +00001664 struct rule *rp;
drh75897232000-05-29 14:26:00 +00001665
drhb0c86772000-06-02 23:21:26 +00001666 OptInit(argv,options,stderr);
drh75897232000-05-29 14:26:00 +00001667 if( version ){
drhb19a2bc2001-09-16 00:13:26 +00001668 printf("Lemon version 1.0\n");
drh06f60d82017-04-14 19:46:12 +00001669 exit(0);
drh75897232000-05-29 14:26:00 +00001670 }
drhb0c86772000-06-02 23:21:26 +00001671 if( OptNArgs()!=1 ){
drh75897232000-05-29 14:26:00 +00001672 fprintf(stderr,"Exactly one filename argument is required.\n");
1673 exit(1);
1674 }
drh954f6b42006-06-13 13:27:46 +00001675 memset(&lem, 0, sizeof(lem));
drh75897232000-05-29 14:26:00 +00001676 lem.errorcnt = 0;
1677
1678 /* Initialize the machine */
1679 Strsafe_init();
1680 Symbol_init();
1681 State_init();
1682 lem.argv0 = argv[0];
drhb0c86772000-06-02 23:21:26 +00001683 lem.filename = OptArg(0);
drh75897232000-05-29 14:26:00 +00001684 lem.basisflag = basisflag;
shane58543932008-12-10 20:10:04 +00001685 lem.nolinenosflag = nolinenosflag;
drh75897232000-05-29 14:26:00 +00001686 Symbol_new("$");
drh75897232000-05-29 14:26:00 +00001687
1688 /* Parse the input file */
1689 Parse(&lem);
1690 if( lem.errorcnt ) exit(lem.errorcnt);
drh954f6b42006-06-13 13:27:46 +00001691 if( lem.nrule==0 ){
drh75897232000-05-29 14:26:00 +00001692 fprintf(stderr,"Empty grammar.\n");
1693 exit(1);
1694 }
drhed0c15b2018-04-16 14:31:34 +00001695 lem.errsym = Symbol_find("error");
drh75897232000-05-29 14:26:00 +00001696
1697 /* Count and index the symbols of the grammar */
drh75897232000-05-29 14:26:00 +00001698 Symbol_new("{default}");
drh61f92cd2014-01-11 03:06:18 +00001699 lem.nsymbol = Symbol_count();
drh75897232000-05-29 14:26:00 +00001700 lem.symbols = Symbol_arrayof();
drh61f92cd2014-01-11 03:06:18 +00001701 for(i=0; i<lem.nsymbol; i++) lem.symbols[i]->index = i;
1702 qsort(lem.symbols,lem.nsymbol,sizeof(struct symbol*), Symbolcmpp);
1703 for(i=0; i<lem.nsymbol; i++) lem.symbols[i]->index = i;
1704 while( lem.symbols[i-1]->type==MULTITERMINAL ){ i--; }
1705 assert( strcmp(lem.symbols[i-1]->name,"{default}")==0 );
1706 lem.nsymbol = i - 1;
drhc56fac72015-10-29 13:48:15 +00001707 for(i=1; ISUPPER(lem.symbols[i]->name[0]); i++);
drh75897232000-05-29 14:26:00 +00001708 lem.nterminal = i;
1709
drh711c9812016-05-23 14:24:31 +00001710 /* Assign sequential rule numbers. Start with 0. Put rules that have no
1711 ** reduce action C-code associated with them last, so that the switch()
1712 ** statement that selects reduction actions will have a smaller jump table.
1713 */
drh4ef07702016-03-16 19:45:54 +00001714 for(i=0, rp=lem.rule; rp; rp=rp->next){
1715 rp->iRule = rp->code ? i++ : -1;
1716 }
1717 for(rp=lem.rule; rp; rp=rp->next){
1718 if( rp->iRule<0 ) rp->iRule = i++;
1719 }
1720 lem.startRule = lem.rule;
1721 lem.rule = Rule_sort(lem.rule);
1722
drh75897232000-05-29 14:26:00 +00001723 /* Generate a reprint of the grammar, if requested on the command line */
1724 if( rpflag ){
1725 Reprint(&lem);
1726 }else{
1727 /* Initialize the size for all follow and first sets */
drh9892c5d2007-12-21 00:02:11 +00001728 SetSize(lem.nterminal+1);
drh75897232000-05-29 14:26:00 +00001729
1730 /* Find the precedence for every production rule (that has one) */
1731 FindRulePrecedences(&lem);
1732
1733 /* Compute the lambda-nonterminals and the first-sets for every
1734 ** nonterminal */
1735 FindFirstSets(&lem);
1736
1737 /* Compute all LR(0) states. Also record follow-set propagation
1738 ** links so that the follow-set can be computed later */
1739 lem.nstate = 0;
1740 FindStates(&lem);
1741 lem.sorted = State_arrayof();
1742
1743 /* Tie up loose ends on the propagation links */
1744 FindLinks(&lem);
1745
1746 /* Compute the follow set of every reducible configuration */
1747 FindFollowSets(&lem);
1748
1749 /* Compute the action tables */
1750 FindActions(&lem);
1751
1752 /* Compress the action tables */
1753 if( compress==0 ) CompressTables(&lem);
1754
drhada354d2005-11-05 15:03:59 +00001755 /* Reorder and renumber the states so that states with fewer choices
drhdd7e9db2010-07-19 01:52:07 +00001756 ** occur at the end. This is an optimization that helps make the
1757 ** generated parser tables smaller. */
1758 if( noResort==0 ) ResortStates(&lem);
drhada354d2005-11-05 15:03:59 +00001759
drh75897232000-05-29 14:26:00 +00001760 /* Generate a report of the parser generated. (the "y.output" file) */
1761 if( !quiet ) ReportOutput(&lem);
1762
1763 /* Generate the source code for the parser */
drhfe03dac2019-11-26 02:22:39 +00001764 ReportTable(&lem, mhflag, sqlFlag);
drh75897232000-05-29 14:26:00 +00001765
1766 /* Produce a header file for use by the scanner. (This step is
1767 ** omitted if the "-m" option is used because makeheaders will
1768 ** generate the file for us.) */
1769 if( !mhflag ) ReportHeader(&lem);
1770 }
1771 if( statistics ){
drhc75e0162015-09-07 02:23:02 +00001772 printf("Parser statistics:\n");
1773 stats_line("terminal symbols", lem.nterminal);
1774 stats_line("non-terminal symbols", lem.nsymbol - lem.nterminal);
1775 stats_line("total symbols", lem.nsymbol);
1776 stats_line("rules", lem.nrule);
drh3bd48ab2015-09-07 18:23:37 +00001777 stats_line("states", lem.nxstate);
drhc75e0162015-09-07 02:23:02 +00001778 stats_line("conflicts", lem.nconflict);
1779 stats_line("action table entries", lem.nactiontab);
drh3a9d6c72017-12-25 04:15:38 +00001780 stats_line("lookahead table entries", lem.nlookaheadtab);
drhc75e0162015-09-07 02:23:02 +00001781 stats_line("total table size (bytes)", lem.tablesize);
drh75897232000-05-29 14:26:00 +00001782 }
icculus8e158022010-02-16 16:09:03 +00001783 if( lem.nconflict > 0 ){
1784 fprintf(stderr,"%d parsing conflicts.\n",lem.nconflict);
icculus42585cf2010-02-14 05:19:56 +00001785 }
1786
1787 /* return 0 on success, 1 on failure. */
icculus8e158022010-02-16 16:09:03 +00001788 exitcode = ((lem.errorcnt > 0) || (lem.nconflict > 0)) ? 1 : 0;
icculus42585cf2010-02-14 05:19:56 +00001789 exit(exitcode);
1790 return (exitcode);
drh75897232000-05-29 14:26:00 +00001791}
1792/******************** From the file "msort.c" *******************************/
1793/*
1794** A generic merge-sort program.
1795**
1796** USAGE:
1797** Let "ptr" be a pointer to some structure which is at the head of
1798** a null-terminated list. Then to sort the list call:
1799**
1800** ptr = msort(ptr,&(ptr->next),cmpfnc);
1801**
1802** In the above, "cmpfnc" is a pointer to a function which compares
1803** two instances of the structure and returns an integer, as in
1804** strcmp. The second argument is a pointer to the pointer to the
1805** second element of the linked list. This address is used to compute
1806** the offset to the "next" field within the structure. The offset to
1807** the "next" field must be constant for all structures in the list.
1808**
1809** The function returns a new pointer which is the head of the list
1810** after sorting.
1811**
1812** ALGORITHM:
1813** Merge-sort.
1814*/
1815
1816/*
1817** Return a pointer to the next structure in the linked list.
1818*/
drhd25d6922012-04-18 09:59:56 +00001819#define NEXT(A) (*(char**)(((char*)A)+offset))
drh75897232000-05-29 14:26:00 +00001820
1821/*
1822** Inputs:
1823** a: A sorted, null-terminated linked list. (May be null).
1824** b: A sorted, null-terminated linked list. (May be null).
1825** cmp: A pointer to the comparison function.
1826** offset: Offset in the structure to the "next" field.
1827**
1828** Return Value:
1829** A pointer to the head of a sorted list containing the elements
1830** of both a and b.
1831**
1832** Side effects:
1833** The "next" pointers for elements in the lists a and b are
1834** changed.
1835*/
drhe9278182007-07-18 18:16:29 +00001836static char *merge(
1837 char *a,
1838 char *b,
1839 int (*cmp)(const char*,const char*),
1840 int offset
1841){
drh75897232000-05-29 14:26:00 +00001842 char *ptr, *head;
1843
1844 if( a==0 ){
1845 head = b;
1846 }else if( b==0 ){
1847 head = a;
1848 }else{
drhe594bc32009-11-03 13:02:25 +00001849 if( (*cmp)(a,b)<=0 ){
drh75897232000-05-29 14:26:00 +00001850 ptr = a;
1851 a = NEXT(a);
1852 }else{
1853 ptr = b;
1854 b = NEXT(b);
1855 }
1856 head = ptr;
1857 while( a && b ){
drhe594bc32009-11-03 13:02:25 +00001858 if( (*cmp)(a,b)<=0 ){
drh75897232000-05-29 14:26:00 +00001859 NEXT(ptr) = a;
1860 ptr = a;
1861 a = NEXT(a);
1862 }else{
1863 NEXT(ptr) = b;
1864 ptr = b;
1865 b = NEXT(b);
1866 }
1867 }
1868 if( a ) NEXT(ptr) = a;
1869 else NEXT(ptr) = b;
1870 }
1871 return head;
1872}
1873
1874/*
1875** Inputs:
1876** list: Pointer to a singly-linked list of structures.
1877** next: Pointer to pointer to the second element of the list.
1878** cmp: A comparison function.
1879**
1880** Return Value:
1881** A pointer to the head of a sorted list containing the elements
1882** orginally in list.
1883**
1884** Side effects:
1885** The "next" pointers for elements in list are changed.
1886*/
1887#define LISTSIZE 30
drhe9278182007-07-18 18:16:29 +00001888static char *msort(
1889 char *list,
1890 char **next,
1891 int (*cmp)(const char*,const char*)
1892){
drhba99af52001-10-25 20:37:16 +00001893 unsigned long offset;
drh75897232000-05-29 14:26:00 +00001894 char *ep;
1895 char *set[LISTSIZE];
1896 int i;
drh1cc0d112015-03-31 15:15:48 +00001897 offset = (unsigned long)((char*)next - (char*)list);
drh75897232000-05-29 14:26:00 +00001898 for(i=0; i<LISTSIZE; i++) set[i] = 0;
1899 while( list ){
1900 ep = list;
1901 list = NEXT(list);
1902 NEXT(ep) = 0;
1903 for(i=0; i<LISTSIZE-1 && set[i]!=0; i++){
1904 ep = merge(ep,set[i],cmp,offset);
1905 set[i] = 0;
1906 }
1907 set[i] = ep;
1908 }
1909 ep = 0;
drhe594bc32009-11-03 13:02:25 +00001910 for(i=0; i<LISTSIZE; i++) if( set[i] ) ep = merge(set[i],ep,cmp,offset);
drh75897232000-05-29 14:26:00 +00001911 return ep;
1912}
1913/************************ From the file "option.c" **************************/
mistachkind9bc6e82019-05-10 16:16:19 +00001914static char **g_argv;
drh75897232000-05-29 14:26:00 +00001915static struct s_options *op;
1916static FILE *errstream;
1917
1918#define ISOPT(X) ((X)[0]=='-'||(X)[0]=='+'||strchr((X),'=')!=0)
1919
1920/*
1921** Print the command line with a carrot pointing to the k-th character
1922** of the n-th field.
1923*/
icculus9e44cf12010-02-14 17:14:22 +00001924static void errline(int n, int k, FILE *err)
drh75897232000-05-29 14:26:00 +00001925{
1926 int spcnt, i;
mistachkind9bc6e82019-05-10 16:16:19 +00001927 if( g_argv[0] ) fprintf(err,"%s",g_argv[0]);
1928 spcnt = lemonStrlen(g_argv[0]) + 1;
1929 for(i=1; i<n && g_argv[i]; i++){
1930 fprintf(err," %s",g_argv[i]);
1931 spcnt += lemonStrlen(g_argv[i])+1;
drh75897232000-05-29 14:26:00 +00001932 }
1933 spcnt += k;
mistachkind9bc6e82019-05-10 16:16:19 +00001934 for(; g_argv[i]; i++) fprintf(err," %s",g_argv[i]);
drh75897232000-05-29 14:26:00 +00001935 if( spcnt<20 ){
1936 fprintf(err,"\n%*s^-- here\n",spcnt,"");
1937 }else{
1938 fprintf(err,"\n%*shere --^\n",spcnt-7,"");
1939 }
1940}
1941
1942/*
1943** Return the index of the N-th non-switch argument. Return -1
1944** if N is out of range.
1945*/
icculus9e44cf12010-02-14 17:14:22 +00001946static int argindex(int n)
drh75897232000-05-29 14:26:00 +00001947{
1948 int i;
1949 int dashdash = 0;
mistachkind9bc6e82019-05-10 16:16:19 +00001950 if( g_argv!=0 && *g_argv!=0 ){
1951 for(i=1; g_argv[i]; i++){
1952 if( dashdash || !ISOPT(g_argv[i]) ){
drh75897232000-05-29 14:26:00 +00001953 if( n==0 ) return i;
1954 n--;
1955 }
mistachkind9bc6e82019-05-10 16:16:19 +00001956 if( strcmp(g_argv[i],"--")==0 ) dashdash = 1;
drh75897232000-05-29 14:26:00 +00001957 }
1958 }
1959 return -1;
1960}
1961
1962static char emsg[] = "Command line syntax error: ";
1963
1964/*
1965** Process a flag command line argument.
1966*/
icculus9e44cf12010-02-14 17:14:22 +00001967static int handleflags(int i, FILE *err)
drh75897232000-05-29 14:26:00 +00001968{
1969 int v;
1970 int errcnt = 0;
1971 int j;
1972 for(j=0; op[j].label; j++){
mistachkind9bc6e82019-05-10 16:16:19 +00001973 if( strncmp(&g_argv[i][1],op[j].label,lemonStrlen(op[j].label))==0 ) break;
drh75897232000-05-29 14:26:00 +00001974 }
mistachkind9bc6e82019-05-10 16:16:19 +00001975 v = g_argv[i][0]=='-' ? 1 : 0;
drh75897232000-05-29 14:26:00 +00001976 if( op[j].label==0 ){
1977 if( err ){
1978 fprintf(err,"%sundefined option.\n",emsg);
1979 errline(i,1,err);
1980 }
1981 errcnt++;
drh0325d392015-01-01 19:11:22 +00001982 }else if( op[j].arg==0 ){
1983 /* Ignore this option */
drh75897232000-05-29 14:26:00 +00001984 }else if( op[j].type==OPT_FLAG ){
1985 *((int*)op[j].arg) = v;
1986 }else if( op[j].type==OPT_FFLAG ){
icculus9e44cf12010-02-14 17:14:22 +00001987 (*(void(*)(int))(op[j].arg))(v);
drh6d08b4d2004-07-20 12:45:22 +00001988 }else if( op[j].type==OPT_FSTR ){
mistachkind9bc6e82019-05-10 16:16:19 +00001989 (*(void(*)(char *))(op[j].arg))(&g_argv[i][2]);
drh75897232000-05-29 14:26:00 +00001990 }else{
1991 if( err ){
1992 fprintf(err,"%smissing argument on switch.\n",emsg);
1993 errline(i,1,err);
1994 }
1995 errcnt++;
1996 }
1997 return errcnt;
1998}
1999
2000/*
2001** Process a command line switch which has an argument.
2002*/
icculus9e44cf12010-02-14 17:14:22 +00002003static int handleswitch(int i, FILE *err)
drh75897232000-05-29 14:26:00 +00002004{
2005 int lv = 0;
2006 double dv = 0.0;
2007 char *sv = 0, *end;
2008 char *cp;
2009 int j;
2010 int errcnt = 0;
mistachkind9bc6e82019-05-10 16:16:19 +00002011 cp = strchr(g_argv[i],'=');
drh43617e92006-03-06 20:55:46 +00002012 assert( cp!=0 );
drh75897232000-05-29 14:26:00 +00002013 *cp = 0;
2014 for(j=0; op[j].label; j++){
mistachkind9bc6e82019-05-10 16:16:19 +00002015 if( strcmp(g_argv[i],op[j].label)==0 ) break;
drh75897232000-05-29 14:26:00 +00002016 }
2017 *cp = '=';
2018 if( op[j].label==0 ){
2019 if( err ){
2020 fprintf(err,"%sundefined option.\n",emsg);
2021 errline(i,0,err);
2022 }
2023 errcnt++;
2024 }else{
2025 cp++;
2026 switch( op[j].type ){
2027 case OPT_FLAG:
2028 case OPT_FFLAG:
2029 if( err ){
2030 fprintf(err,"%soption requires an argument.\n",emsg);
2031 errline(i,0,err);
2032 }
2033 errcnt++;
2034 break;
2035 case OPT_DBL:
2036 case OPT_FDBL:
2037 dv = strtod(cp,&end);
2038 if( *end ){
2039 if( err ){
drh25473362015-09-04 18:03:45 +00002040 fprintf(err,
2041 "%sillegal character in floating-point argument.\n",emsg);
mistachkind9bc6e82019-05-10 16:16:19 +00002042 errline(i,(int)((char*)end-(char*)g_argv[i]),err);
drh75897232000-05-29 14:26:00 +00002043 }
2044 errcnt++;
2045 }
2046 break;
2047 case OPT_INT:
2048 case OPT_FINT:
2049 lv = strtol(cp,&end,0);
2050 if( *end ){
2051 if( err ){
2052 fprintf(err,"%sillegal character in integer argument.\n",emsg);
mistachkind9bc6e82019-05-10 16:16:19 +00002053 errline(i,(int)((char*)end-(char*)g_argv[i]),err);
drh75897232000-05-29 14:26:00 +00002054 }
2055 errcnt++;
2056 }
2057 break;
2058 case OPT_STR:
2059 case OPT_FSTR:
2060 sv = cp;
2061 break;
2062 }
2063 switch( op[j].type ){
2064 case OPT_FLAG:
2065 case OPT_FFLAG:
2066 break;
2067 case OPT_DBL:
2068 *(double*)(op[j].arg) = dv;
2069 break;
2070 case OPT_FDBL:
icculus9e44cf12010-02-14 17:14:22 +00002071 (*(void(*)(double))(op[j].arg))(dv);
drh75897232000-05-29 14:26:00 +00002072 break;
2073 case OPT_INT:
2074 *(int*)(op[j].arg) = lv;
2075 break;
2076 case OPT_FINT:
icculus9e44cf12010-02-14 17:14:22 +00002077 (*(void(*)(int))(op[j].arg))((int)lv);
drh75897232000-05-29 14:26:00 +00002078 break;
2079 case OPT_STR:
2080 *(char**)(op[j].arg) = sv;
2081 break;
2082 case OPT_FSTR:
icculus9e44cf12010-02-14 17:14:22 +00002083 (*(void(*)(char *))(op[j].arg))(sv);
drh75897232000-05-29 14:26:00 +00002084 break;
2085 }
2086 }
2087 return errcnt;
2088}
2089
icculus9e44cf12010-02-14 17:14:22 +00002090int OptInit(char **a, struct s_options *o, FILE *err)
drh75897232000-05-29 14:26:00 +00002091{
2092 int errcnt = 0;
mistachkind9bc6e82019-05-10 16:16:19 +00002093 g_argv = a;
drh75897232000-05-29 14:26:00 +00002094 op = o;
2095 errstream = err;
mistachkind9bc6e82019-05-10 16:16:19 +00002096 if( g_argv && *g_argv && op ){
drh75897232000-05-29 14:26:00 +00002097 int i;
mistachkind9bc6e82019-05-10 16:16:19 +00002098 for(i=1; g_argv[i]; i++){
2099 if( g_argv[i][0]=='+' || g_argv[i][0]=='-' ){
drh75897232000-05-29 14:26:00 +00002100 errcnt += handleflags(i,err);
mistachkind9bc6e82019-05-10 16:16:19 +00002101 }else if( strchr(g_argv[i],'=') ){
drh75897232000-05-29 14:26:00 +00002102 errcnt += handleswitch(i,err);
2103 }
2104 }
2105 }
2106 if( errcnt>0 ){
2107 fprintf(err,"Valid command line options for \"%s\" are:\n",*a);
drhb0c86772000-06-02 23:21:26 +00002108 OptPrint();
drh75897232000-05-29 14:26:00 +00002109 exit(1);
2110 }
2111 return 0;
2112}
2113
drh14d88552017-04-14 19:44:15 +00002114int OptNArgs(void){
drh75897232000-05-29 14:26:00 +00002115 int cnt = 0;
2116 int dashdash = 0;
2117 int i;
mistachkind9bc6e82019-05-10 16:16:19 +00002118 if( g_argv!=0 && g_argv[0]!=0 ){
2119 for(i=1; g_argv[i]; i++){
2120 if( dashdash || !ISOPT(g_argv[i]) ) cnt++;
2121 if( strcmp(g_argv[i],"--")==0 ) dashdash = 1;
drh75897232000-05-29 14:26:00 +00002122 }
2123 }
2124 return cnt;
2125}
2126
icculus9e44cf12010-02-14 17:14:22 +00002127char *OptArg(int n)
drh75897232000-05-29 14:26:00 +00002128{
2129 int i;
2130 i = argindex(n);
mistachkind9bc6e82019-05-10 16:16:19 +00002131 return i>=0 ? g_argv[i] : 0;
drh75897232000-05-29 14:26:00 +00002132}
2133
icculus9e44cf12010-02-14 17:14:22 +00002134void OptErr(int n)
drh75897232000-05-29 14:26:00 +00002135{
2136 int i;
2137 i = argindex(n);
2138 if( i>=0 ) errline(i,0,errstream);
2139}
2140
drh14d88552017-04-14 19:44:15 +00002141void OptPrint(void){
drh75897232000-05-29 14:26:00 +00002142 int i;
2143 int max, len;
2144 max = 0;
2145 for(i=0; op[i].label; i++){
drh87cf1372008-08-13 20:09:06 +00002146 len = lemonStrlen(op[i].label) + 1;
drh75897232000-05-29 14:26:00 +00002147 switch( op[i].type ){
2148 case OPT_FLAG:
2149 case OPT_FFLAG:
2150 break;
2151 case OPT_INT:
2152 case OPT_FINT:
2153 len += 9; /* length of "<integer>" */
2154 break;
2155 case OPT_DBL:
2156 case OPT_FDBL:
2157 len += 6; /* length of "<real>" */
2158 break;
2159 case OPT_STR:
2160 case OPT_FSTR:
2161 len += 8; /* length of "<string>" */
2162 break;
2163 }
2164 if( len>max ) max = len;
2165 }
2166 for(i=0; op[i].label; i++){
2167 switch( op[i].type ){
2168 case OPT_FLAG:
2169 case OPT_FFLAG:
2170 fprintf(errstream," -%-*s %s\n",max,op[i].label,op[i].message);
2171 break;
2172 case OPT_INT:
2173 case OPT_FINT:
drh0325d392015-01-01 19:11:22 +00002174 fprintf(errstream," -%s<integer>%*s %s\n",op[i].label,
drh87cf1372008-08-13 20:09:06 +00002175 (int)(max-lemonStrlen(op[i].label)-9),"",op[i].message);
drh75897232000-05-29 14:26:00 +00002176 break;
2177 case OPT_DBL:
2178 case OPT_FDBL:
drh0325d392015-01-01 19:11:22 +00002179 fprintf(errstream," -%s<real>%*s %s\n",op[i].label,
drh87cf1372008-08-13 20:09:06 +00002180 (int)(max-lemonStrlen(op[i].label)-6),"",op[i].message);
drh75897232000-05-29 14:26:00 +00002181 break;
2182 case OPT_STR:
2183 case OPT_FSTR:
drh0325d392015-01-01 19:11:22 +00002184 fprintf(errstream," -%s<string>%*s %s\n",op[i].label,
drh87cf1372008-08-13 20:09:06 +00002185 (int)(max-lemonStrlen(op[i].label)-8),"",op[i].message);
drh75897232000-05-29 14:26:00 +00002186 break;
2187 }
2188 }
2189}
2190/*********************** From the file "parse.c" ****************************/
2191/*
2192** Input file parser for the LEMON parser generator.
2193*/
2194
2195/* The state of the parser */
icculus9e44cf12010-02-14 17:14:22 +00002196enum e_state {
2197 INITIALIZE,
2198 WAITING_FOR_DECL_OR_RULE,
2199 WAITING_FOR_DECL_KEYWORD,
2200 WAITING_FOR_DECL_ARG,
2201 WAITING_FOR_PRECEDENCE_SYMBOL,
2202 WAITING_FOR_ARROW,
2203 IN_RHS,
2204 LHS_ALIAS_1,
2205 LHS_ALIAS_2,
2206 LHS_ALIAS_3,
2207 RHS_ALIAS_1,
2208 RHS_ALIAS_2,
2209 PRECEDENCE_MARK_1,
2210 PRECEDENCE_MARK_2,
2211 RESYNC_AFTER_RULE_ERROR,
2212 RESYNC_AFTER_DECL_ERROR,
2213 WAITING_FOR_DESTRUCTOR_SYMBOL,
2214 WAITING_FOR_DATATYPE_SYMBOL,
2215 WAITING_FOR_FALLBACK_ID,
drh61f92cd2014-01-11 03:06:18 +00002216 WAITING_FOR_WILDCARD_ID,
2217 WAITING_FOR_CLASS_ID,
drh59c435a2017-08-02 03:21:11 +00002218 WAITING_FOR_CLASS_TOKEN,
2219 WAITING_FOR_TOKEN_NAME
icculus9e44cf12010-02-14 17:14:22 +00002220};
drh75897232000-05-29 14:26:00 +00002221struct pstate {
2222 char *filename; /* Name of the input file */
2223 int tokenlineno; /* Linenumber at which current token starts */
2224 int errorcnt; /* Number of errors so far */
2225 char *tokenstart; /* Text of current token */
2226 struct lemon *gp; /* Global state vector */
icculus9e44cf12010-02-14 17:14:22 +00002227 enum e_state state; /* The state of the parser */
drh0bd1f4e2002-06-06 18:54:39 +00002228 struct symbol *fallback; /* The fallback token */
drh61f92cd2014-01-11 03:06:18 +00002229 struct symbol *tkclass; /* Token class symbol */
drh75897232000-05-29 14:26:00 +00002230 struct symbol *lhs; /* Left-hand side of current rule */
icculus9e44cf12010-02-14 17:14:22 +00002231 const char *lhsalias; /* Alias for the LHS */
drh75897232000-05-29 14:26:00 +00002232 int nrhs; /* Number of right-hand side symbols seen */
2233 struct symbol *rhs[MAXRHS]; /* RHS symbols */
icculus9e44cf12010-02-14 17:14:22 +00002234 const char *alias[MAXRHS]; /* Aliases for each RHS symbol (or NULL) */
drh75897232000-05-29 14:26:00 +00002235 struct rule *prevrule; /* Previous rule parsed */
icculus9e44cf12010-02-14 17:14:22 +00002236 const char *declkeyword; /* Keyword of a declaration */
drh75897232000-05-29 14:26:00 +00002237 char **declargslot; /* Where the declaration argument should be put */
drha5808f32008-04-27 22:19:44 +00002238 int insertLineMacro; /* Add #line before declaration insert */
drh4dc8ef52008-07-01 17:13:57 +00002239 int *decllinenoslot; /* Where to write declaration line number */
drh75897232000-05-29 14:26:00 +00002240 enum e_assoc declassoc; /* Assign this association to decl arguments */
2241 int preccounter; /* Assign this precedence to decl arguments */
2242 struct rule *firstrule; /* Pointer to first rule in the grammar */
2243 struct rule *lastrule; /* Pointer to the most recently parsed rule */
2244};
2245
2246/* Parse a single token */
icculus9e44cf12010-02-14 17:14:22 +00002247static void parseonetoken(struct pstate *psp)
drh75897232000-05-29 14:26:00 +00002248{
icculus9e44cf12010-02-14 17:14:22 +00002249 const char *x;
drh75897232000-05-29 14:26:00 +00002250 x = Strsafe(psp->tokenstart); /* Save the token permanently */
2251#if 0
2252 printf("%s:%d: Token=[%s] state=%d\n",psp->filename,psp->tokenlineno,
2253 x,psp->state);
2254#endif
2255 switch( psp->state ){
2256 case INITIALIZE:
2257 psp->prevrule = 0;
2258 psp->preccounter = 0;
2259 psp->firstrule = psp->lastrule = 0;
2260 psp->gp->nrule = 0;
2261 /* Fall thru to next case */
2262 case WAITING_FOR_DECL_OR_RULE:
2263 if( x[0]=='%' ){
2264 psp->state = WAITING_FOR_DECL_KEYWORD;
drhc56fac72015-10-29 13:48:15 +00002265 }else if( ISLOWER(x[0]) ){
drh75897232000-05-29 14:26:00 +00002266 psp->lhs = Symbol_new(x);
2267 psp->nrhs = 0;
2268 psp->lhsalias = 0;
2269 psp->state = WAITING_FOR_ARROW;
2270 }else if( x[0]=='{' ){
2271 if( psp->prevrule==0 ){
2272 ErrorMsg(psp->filename,psp->tokenlineno,
drh3cb2f6e2012-01-09 14:19:05 +00002273"There is no prior rule upon which to attach the code \
drh75897232000-05-29 14:26:00 +00002274fragment which begins on this line.");
2275 psp->errorcnt++;
drhf2f105d2012-08-20 15:53:54 +00002276 }else if( psp->prevrule->code!=0 ){
drh75897232000-05-29 14:26:00 +00002277 ErrorMsg(psp->filename,psp->tokenlineno,
2278"Code fragment beginning on this line is not the first \
2279to follow the previous rule.");
2280 psp->errorcnt++;
2281 }else{
2282 psp->prevrule->line = psp->tokenlineno;
2283 psp->prevrule->code = &x[1];
drh711c9812016-05-23 14:24:31 +00002284 psp->prevrule->noCode = 0;
drhf2f105d2012-08-20 15:53:54 +00002285 }
drh75897232000-05-29 14:26:00 +00002286 }else if( x[0]=='[' ){
2287 psp->state = PRECEDENCE_MARK_1;
2288 }else{
2289 ErrorMsg(psp->filename,psp->tokenlineno,
2290 "Token \"%s\" should be either \"%%\" or a nonterminal name.",
2291 x);
2292 psp->errorcnt++;
2293 }
2294 break;
2295 case PRECEDENCE_MARK_1:
drhc56fac72015-10-29 13:48:15 +00002296 if( !ISUPPER(x[0]) ){
drh75897232000-05-29 14:26:00 +00002297 ErrorMsg(psp->filename,psp->tokenlineno,
2298 "The precedence symbol must be a terminal.");
2299 psp->errorcnt++;
2300 }else if( psp->prevrule==0 ){
2301 ErrorMsg(psp->filename,psp->tokenlineno,
2302 "There is no prior rule to assign precedence \"[%s]\".",x);
2303 psp->errorcnt++;
2304 }else if( psp->prevrule->precsym!=0 ){
2305 ErrorMsg(psp->filename,psp->tokenlineno,
2306"Precedence mark on this line is not the first \
2307to follow the previous rule.");
2308 psp->errorcnt++;
2309 }else{
2310 psp->prevrule->precsym = Symbol_new(x);
2311 }
2312 psp->state = PRECEDENCE_MARK_2;
2313 break;
2314 case PRECEDENCE_MARK_2:
2315 if( x[0]!=']' ){
2316 ErrorMsg(psp->filename,psp->tokenlineno,
2317 "Missing \"]\" on precedence mark.");
2318 psp->errorcnt++;
2319 }
2320 psp->state = WAITING_FOR_DECL_OR_RULE;
2321 break;
2322 case WAITING_FOR_ARROW:
2323 if( x[0]==':' && x[1]==':' && x[2]=='=' ){
2324 psp->state = IN_RHS;
2325 }else if( x[0]=='(' ){
2326 psp->state = LHS_ALIAS_1;
2327 }else{
2328 ErrorMsg(psp->filename,psp->tokenlineno,
2329 "Expected to see a \":\" following the LHS symbol \"%s\".",
2330 psp->lhs->name);
2331 psp->errorcnt++;
2332 psp->state = RESYNC_AFTER_RULE_ERROR;
2333 }
2334 break;
2335 case LHS_ALIAS_1:
drhc56fac72015-10-29 13:48:15 +00002336 if( ISALPHA(x[0]) ){
drh75897232000-05-29 14:26:00 +00002337 psp->lhsalias = x;
2338 psp->state = LHS_ALIAS_2;
2339 }else{
2340 ErrorMsg(psp->filename,psp->tokenlineno,
2341 "\"%s\" is not a valid alias for the LHS \"%s\"\n",
2342 x,psp->lhs->name);
2343 psp->errorcnt++;
2344 psp->state = RESYNC_AFTER_RULE_ERROR;
2345 }
2346 break;
2347 case LHS_ALIAS_2:
2348 if( x[0]==')' ){
2349 psp->state = LHS_ALIAS_3;
2350 }else{
2351 ErrorMsg(psp->filename,psp->tokenlineno,
2352 "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
2353 psp->errorcnt++;
2354 psp->state = RESYNC_AFTER_RULE_ERROR;
2355 }
2356 break;
2357 case LHS_ALIAS_3:
2358 if( x[0]==':' && x[1]==':' && x[2]=='=' ){
2359 psp->state = IN_RHS;
2360 }else{
2361 ErrorMsg(psp->filename,psp->tokenlineno,
2362 "Missing \"->\" following: \"%s(%s)\".",
2363 psp->lhs->name,psp->lhsalias);
2364 psp->errorcnt++;
2365 psp->state = RESYNC_AFTER_RULE_ERROR;
2366 }
2367 break;
2368 case IN_RHS:
2369 if( x[0]=='.' ){
2370 struct rule *rp;
drh06f60d82017-04-14 19:46:12 +00002371 rp = (struct rule *)calloc( sizeof(struct rule) +
drh9892c5d2007-12-21 00:02:11 +00002372 sizeof(struct symbol*)*psp->nrhs + sizeof(char*)*psp->nrhs, 1);
drh75897232000-05-29 14:26:00 +00002373 if( rp==0 ){
2374 ErrorMsg(psp->filename,psp->tokenlineno,
2375 "Can't allocate enough memory for this rule.");
2376 psp->errorcnt++;
2377 psp->prevrule = 0;
drhf2f105d2012-08-20 15:53:54 +00002378 }else{
drh75897232000-05-29 14:26:00 +00002379 int i;
2380 rp->ruleline = psp->tokenlineno;
2381 rp->rhs = (struct symbol**)&rp[1];
icculus9e44cf12010-02-14 17:14:22 +00002382 rp->rhsalias = (const char**)&(rp->rhs[psp->nrhs]);
drh75897232000-05-29 14:26:00 +00002383 for(i=0; i<psp->nrhs; i++){
2384 rp->rhs[i] = psp->rhs[i];
2385 rp->rhsalias[i] = psp->alias[i];
drh539e7412018-04-21 20:24:19 +00002386 if( rp->rhsalias[i]!=0 ){ rp->rhs[i]->bContent = 1; }
drhf2f105d2012-08-20 15:53:54 +00002387 }
drh75897232000-05-29 14:26:00 +00002388 rp->lhs = psp->lhs;
2389 rp->lhsalias = psp->lhsalias;
2390 rp->nrhs = psp->nrhs;
2391 rp->code = 0;
drh711c9812016-05-23 14:24:31 +00002392 rp->noCode = 1;
drh75897232000-05-29 14:26:00 +00002393 rp->precsym = 0;
2394 rp->index = psp->gp->nrule++;
2395 rp->nextlhs = rp->lhs->rule;
2396 rp->lhs->rule = rp;
2397 rp->next = 0;
2398 if( psp->firstrule==0 ){
2399 psp->firstrule = psp->lastrule = rp;
drhf2f105d2012-08-20 15:53:54 +00002400 }else{
drh75897232000-05-29 14:26:00 +00002401 psp->lastrule->next = rp;
2402 psp->lastrule = rp;
drhf2f105d2012-08-20 15:53:54 +00002403 }
drh75897232000-05-29 14:26:00 +00002404 psp->prevrule = rp;
drhf2f105d2012-08-20 15:53:54 +00002405 }
drh75897232000-05-29 14:26:00 +00002406 psp->state = WAITING_FOR_DECL_OR_RULE;
drhc56fac72015-10-29 13:48:15 +00002407 }else if( ISALPHA(x[0]) ){
drh75897232000-05-29 14:26:00 +00002408 if( psp->nrhs>=MAXRHS ){
2409 ErrorMsg(psp->filename,psp->tokenlineno,
drhc4dd3fd2008-01-22 01:48:05 +00002410 "Too many symbols on RHS of rule beginning at \"%s\".",
drh75897232000-05-29 14:26:00 +00002411 x);
2412 psp->errorcnt++;
2413 psp->state = RESYNC_AFTER_RULE_ERROR;
drhf2f105d2012-08-20 15:53:54 +00002414 }else{
drh75897232000-05-29 14:26:00 +00002415 psp->rhs[psp->nrhs] = Symbol_new(x);
2416 psp->alias[psp->nrhs] = 0;
2417 psp->nrhs++;
drhf2f105d2012-08-20 15:53:54 +00002418 }
drhfd405312005-11-06 04:06:59 +00002419 }else if( (x[0]=='|' || x[0]=='/') && psp->nrhs>0 ){
2420 struct symbol *msp = psp->rhs[psp->nrhs-1];
2421 if( msp->type!=MULTITERMINAL ){
2422 struct symbol *origsp = msp;
icculus9e44cf12010-02-14 17:14:22 +00002423 msp = (struct symbol *) calloc(1,sizeof(*msp));
drhfd405312005-11-06 04:06:59 +00002424 memset(msp, 0, sizeof(*msp));
2425 msp->type = MULTITERMINAL;
2426 msp->nsubsym = 1;
icculus9e44cf12010-02-14 17:14:22 +00002427 msp->subsym = (struct symbol **) calloc(1,sizeof(struct symbol*));
drhfd405312005-11-06 04:06:59 +00002428 msp->subsym[0] = origsp;
2429 msp->name = origsp->name;
2430 psp->rhs[psp->nrhs-1] = msp;
2431 }
2432 msp->nsubsym++;
icculus9e44cf12010-02-14 17:14:22 +00002433 msp->subsym = (struct symbol **) realloc(msp->subsym,
2434 sizeof(struct symbol*)*msp->nsubsym);
drhfd405312005-11-06 04:06:59 +00002435 msp->subsym[msp->nsubsym-1] = Symbol_new(&x[1]);
drhc56fac72015-10-29 13:48:15 +00002436 if( ISLOWER(x[1]) || ISLOWER(msp->subsym[0]->name[0]) ){
drhfd405312005-11-06 04:06:59 +00002437 ErrorMsg(psp->filename,psp->tokenlineno,
2438 "Cannot form a compound containing a non-terminal");
2439 psp->errorcnt++;
2440 }
drh75897232000-05-29 14:26:00 +00002441 }else if( x[0]=='(' && psp->nrhs>0 ){
2442 psp->state = RHS_ALIAS_1;
2443 }else{
2444 ErrorMsg(psp->filename,psp->tokenlineno,
2445 "Illegal character on RHS of rule: \"%s\".",x);
2446 psp->errorcnt++;
2447 psp->state = RESYNC_AFTER_RULE_ERROR;
2448 }
2449 break;
2450 case RHS_ALIAS_1:
drhc56fac72015-10-29 13:48:15 +00002451 if( ISALPHA(x[0]) ){
drh75897232000-05-29 14:26:00 +00002452 psp->alias[psp->nrhs-1] = x;
2453 psp->state = RHS_ALIAS_2;
2454 }else{
2455 ErrorMsg(psp->filename,psp->tokenlineno,
2456 "\"%s\" is not a valid alias for the RHS symbol \"%s\"\n",
2457 x,psp->rhs[psp->nrhs-1]->name);
2458 psp->errorcnt++;
2459 psp->state = RESYNC_AFTER_RULE_ERROR;
2460 }
2461 break;
2462 case RHS_ALIAS_2:
2463 if( x[0]==')' ){
2464 psp->state = IN_RHS;
2465 }else{
2466 ErrorMsg(psp->filename,psp->tokenlineno,
2467 "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
2468 psp->errorcnt++;
2469 psp->state = RESYNC_AFTER_RULE_ERROR;
2470 }
2471 break;
2472 case WAITING_FOR_DECL_KEYWORD:
drhc56fac72015-10-29 13:48:15 +00002473 if( ISALPHA(x[0]) ){
drh75897232000-05-29 14:26:00 +00002474 psp->declkeyword = x;
2475 psp->declargslot = 0;
drh4dc8ef52008-07-01 17:13:57 +00002476 psp->decllinenoslot = 0;
drha5808f32008-04-27 22:19:44 +00002477 psp->insertLineMacro = 1;
drh75897232000-05-29 14:26:00 +00002478 psp->state = WAITING_FOR_DECL_ARG;
2479 if( strcmp(x,"name")==0 ){
2480 psp->declargslot = &(psp->gp->name);
drha5808f32008-04-27 22:19:44 +00002481 psp->insertLineMacro = 0;
drhf2f105d2012-08-20 15:53:54 +00002482 }else if( strcmp(x,"include")==0 ){
drh75897232000-05-29 14:26:00 +00002483 psp->declargslot = &(psp->gp->include);
drhf2f105d2012-08-20 15:53:54 +00002484 }else if( strcmp(x,"code")==0 ){
drh75897232000-05-29 14:26:00 +00002485 psp->declargslot = &(psp->gp->extracode);
drhf2f105d2012-08-20 15:53:54 +00002486 }else if( strcmp(x,"token_destructor")==0 ){
drh75897232000-05-29 14:26:00 +00002487 psp->declargslot = &psp->gp->tokendest;
drhf2f105d2012-08-20 15:53:54 +00002488 }else if( strcmp(x,"default_destructor")==0 ){
drh960e8c62001-04-03 16:53:21 +00002489 psp->declargslot = &psp->gp->vardest;
drhf2f105d2012-08-20 15:53:54 +00002490 }else if( strcmp(x,"token_prefix")==0 ){
drh75897232000-05-29 14:26:00 +00002491 psp->declargslot = &psp->gp->tokenprefix;
drha5808f32008-04-27 22:19:44 +00002492 psp->insertLineMacro = 0;
drhf2f105d2012-08-20 15:53:54 +00002493 }else if( strcmp(x,"syntax_error")==0 ){
drh75897232000-05-29 14:26:00 +00002494 psp->declargslot = &(psp->gp->error);
drhf2f105d2012-08-20 15:53:54 +00002495 }else if( strcmp(x,"parse_accept")==0 ){
drh75897232000-05-29 14:26:00 +00002496 psp->declargslot = &(psp->gp->accept);
drhf2f105d2012-08-20 15:53:54 +00002497 }else if( strcmp(x,"parse_failure")==0 ){
drh75897232000-05-29 14:26:00 +00002498 psp->declargslot = &(psp->gp->failure);
drhf2f105d2012-08-20 15:53:54 +00002499 }else if( strcmp(x,"stack_overflow")==0 ){
drh75897232000-05-29 14:26:00 +00002500 psp->declargslot = &(psp->gp->overflow);
drh75897232000-05-29 14:26:00 +00002501 }else if( strcmp(x,"extra_argument")==0 ){
2502 psp->declargslot = &(psp->gp->arg);
drha5808f32008-04-27 22:19:44 +00002503 psp->insertLineMacro = 0;
drhfb32c442018-04-21 13:51:42 +00002504 }else if( strcmp(x,"extra_context")==0 ){
2505 psp->declargslot = &(psp->gp->ctx);
2506 psp->insertLineMacro = 0;
drh75897232000-05-29 14:26:00 +00002507 }else if( strcmp(x,"token_type")==0 ){
2508 psp->declargslot = &(psp->gp->tokentype);
drha5808f32008-04-27 22:19:44 +00002509 psp->insertLineMacro = 0;
drh960e8c62001-04-03 16:53:21 +00002510 }else if( strcmp(x,"default_type")==0 ){
2511 psp->declargslot = &(psp->gp->vartype);
drha5808f32008-04-27 22:19:44 +00002512 psp->insertLineMacro = 0;
drh75897232000-05-29 14:26:00 +00002513 }else if( strcmp(x,"stack_size")==0 ){
2514 psp->declargslot = &(psp->gp->stacksize);
drha5808f32008-04-27 22:19:44 +00002515 psp->insertLineMacro = 0;
drh75897232000-05-29 14:26:00 +00002516 }else if( strcmp(x,"start_symbol")==0 ){
2517 psp->declargslot = &(psp->gp->start);
drha5808f32008-04-27 22:19:44 +00002518 psp->insertLineMacro = 0;
drh75897232000-05-29 14:26:00 +00002519 }else if( strcmp(x,"left")==0 ){
2520 psp->preccounter++;
2521 psp->declassoc = LEFT;
2522 psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
2523 }else if( strcmp(x,"right")==0 ){
2524 psp->preccounter++;
2525 psp->declassoc = RIGHT;
2526 psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
2527 }else if( strcmp(x,"nonassoc")==0 ){
2528 psp->preccounter++;
2529 psp->declassoc = NONE;
2530 psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
drhf2f105d2012-08-20 15:53:54 +00002531 }else if( strcmp(x,"destructor")==0 ){
drh75897232000-05-29 14:26:00 +00002532 psp->state = WAITING_FOR_DESTRUCTOR_SYMBOL;
drhf2f105d2012-08-20 15:53:54 +00002533 }else if( strcmp(x,"type")==0 ){
drh75897232000-05-29 14:26:00 +00002534 psp->state = WAITING_FOR_DATATYPE_SYMBOL;
drh0bd1f4e2002-06-06 18:54:39 +00002535 }else if( strcmp(x,"fallback")==0 ){
2536 psp->fallback = 0;
2537 psp->state = WAITING_FOR_FALLBACK_ID;
drh59c435a2017-08-02 03:21:11 +00002538 }else if( strcmp(x,"token")==0 ){
2539 psp->state = WAITING_FOR_TOKEN_NAME;
drhe09daa92006-06-10 13:29:31 +00002540 }else if( strcmp(x,"wildcard")==0 ){
2541 psp->state = WAITING_FOR_WILDCARD_ID;
drh61f92cd2014-01-11 03:06:18 +00002542 }else if( strcmp(x,"token_class")==0 ){
2543 psp->state = WAITING_FOR_CLASS_ID;
drh75897232000-05-29 14:26:00 +00002544 }else{
2545 ErrorMsg(psp->filename,psp->tokenlineno,
2546 "Unknown declaration keyword: \"%%%s\".",x);
2547 psp->errorcnt++;
2548 psp->state = RESYNC_AFTER_DECL_ERROR;
drhf2f105d2012-08-20 15:53:54 +00002549 }
drh75897232000-05-29 14:26:00 +00002550 }else{
2551 ErrorMsg(psp->filename,psp->tokenlineno,
2552 "Illegal declaration keyword: \"%s\".",x);
2553 psp->errorcnt++;
2554 psp->state = RESYNC_AFTER_DECL_ERROR;
2555 }
2556 break;
2557 case WAITING_FOR_DESTRUCTOR_SYMBOL:
drhc56fac72015-10-29 13:48:15 +00002558 if( !ISALPHA(x[0]) ){
drh75897232000-05-29 14:26:00 +00002559 ErrorMsg(psp->filename,psp->tokenlineno,
icculusd0d97b02010-02-17 20:22:10 +00002560 "Symbol name missing after %%destructor keyword");
drh75897232000-05-29 14:26:00 +00002561 psp->errorcnt++;
2562 psp->state = RESYNC_AFTER_DECL_ERROR;
2563 }else{
icculusd286fa62010-03-03 17:06:32 +00002564 struct symbol *sp = Symbol_new(x);
2565 psp->declargslot = &sp->destructor;
2566 psp->decllinenoslot = &sp->destLineno;
2567 psp->insertLineMacro = 1;
2568 psp->state = WAITING_FOR_DECL_ARG;
drh75897232000-05-29 14:26:00 +00002569 }
2570 break;
2571 case WAITING_FOR_DATATYPE_SYMBOL:
drhc56fac72015-10-29 13:48:15 +00002572 if( !ISALPHA(x[0]) ){
drh75897232000-05-29 14:26:00 +00002573 ErrorMsg(psp->filename,psp->tokenlineno,
icculusd0d97b02010-02-17 20:22:10 +00002574 "Symbol name missing after %%type keyword");
drh75897232000-05-29 14:26:00 +00002575 psp->errorcnt++;
2576 psp->state = RESYNC_AFTER_DECL_ERROR;
2577 }else{
icculus866bf1e2010-02-17 20:31:32 +00002578 struct symbol *sp = Symbol_find(x);
2579 if((sp) && (sp->datatype)){
2580 ErrorMsg(psp->filename,psp->tokenlineno,
2581 "Symbol %%type \"%s\" already defined", x);
2582 psp->errorcnt++;
2583 psp->state = RESYNC_AFTER_DECL_ERROR;
2584 }else{
2585 if (!sp){
2586 sp = Symbol_new(x);
2587 }
2588 psp->declargslot = &sp->datatype;
2589 psp->insertLineMacro = 0;
2590 psp->state = WAITING_FOR_DECL_ARG;
2591 }
drh75897232000-05-29 14:26:00 +00002592 }
2593 break;
2594 case WAITING_FOR_PRECEDENCE_SYMBOL:
2595 if( x[0]=='.' ){
2596 psp->state = WAITING_FOR_DECL_OR_RULE;
drhc56fac72015-10-29 13:48:15 +00002597 }else if( ISUPPER(x[0]) ){
drh75897232000-05-29 14:26:00 +00002598 struct symbol *sp;
2599 sp = Symbol_new(x);
2600 if( sp->prec>=0 ){
2601 ErrorMsg(psp->filename,psp->tokenlineno,
2602 "Symbol \"%s\" has already be given a precedence.",x);
2603 psp->errorcnt++;
drhf2f105d2012-08-20 15:53:54 +00002604 }else{
drh75897232000-05-29 14:26:00 +00002605 sp->prec = psp->preccounter;
2606 sp->assoc = psp->declassoc;
drhf2f105d2012-08-20 15:53:54 +00002607 }
drh75897232000-05-29 14:26:00 +00002608 }else{
2609 ErrorMsg(psp->filename,psp->tokenlineno,
2610 "Can't assign a precedence to \"%s\".",x);
2611 psp->errorcnt++;
2612 }
2613 break;
2614 case WAITING_FOR_DECL_ARG:
drhc56fac72015-10-29 13:48:15 +00002615 if( x[0]=='{' || x[0]=='\"' || ISALNUM(x[0]) ){
icculus9e44cf12010-02-14 17:14:22 +00002616 const char *zOld, *zNew;
2617 char *zBuf, *z;
mistachkin2318d332015-01-12 18:02:52 +00002618 int nOld, n, nLine = 0, nNew, nBack;
drhb5bd49e2008-07-14 12:21:08 +00002619 int addLineMacro;
drha5808f32008-04-27 22:19:44 +00002620 char zLine[50];
2621 zNew = x;
2622 if( zNew[0]=='"' || zNew[0]=='{' ) zNew++;
drh87cf1372008-08-13 20:09:06 +00002623 nNew = lemonStrlen(zNew);
drha5808f32008-04-27 22:19:44 +00002624 if( *psp->declargslot ){
2625 zOld = *psp->declargslot;
2626 }else{
2627 zOld = "";
2628 }
drh87cf1372008-08-13 20:09:06 +00002629 nOld = lemonStrlen(zOld);
drha5808f32008-04-27 22:19:44 +00002630 n = nOld + nNew + 20;
shane58543932008-12-10 20:10:04 +00002631 addLineMacro = !psp->gp->nolinenosflag && psp->insertLineMacro &&
drhb5bd49e2008-07-14 12:21:08 +00002632 (psp->decllinenoslot==0 || psp->decllinenoslot[0]!=0);
2633 if( addLineMacro ){
drha5808f32008-04-27 22:19:44 +00002634 for(z=psp->filename, nBack=0; *z; z++){
2635 if( *z=='\\' ) nBack++;
2636 }
drh898799f2014-01-10 23:21:00 +00002637 lemon_sprintf(zLine, "#line %d ", psp->tokenlineno);
drh87cf1372008-08-13 20:09:06 +00002638 nLine = lemonStrlen(zLine);
2639 n += nLine + lemonStrlen(psp->filename) + nBack;
drha5808f32008-04-27 22:19:44 +00002640 }
icculus9e44cf12010-02-14 17:14:22 +00002641 *psp->declargslot = (char *) realloc(*psp->declargslot, n);
2642 zBuf = *psp->declargslot + nOld;
drhb5bd49e2008-07-14 12:21:08 +00002643 if( addLineMacro ){
drha5808f32008-04-27 22:19:44 +00002644 if( nOld && zBuf[-1]!='\n' ){
2645 *(zBuf++) = '\n';
2646 }
2647 memcpy(zBuf, zLine, nLine);
2648 zBuf += nLine;
2649 *(zBuf++) = '"';
2650 for(z=psp->filename; *z; z++){
2651 if( *z=='\\' ){
2652 *(zBuf++) = '\\';
2653 }
2654 *(zBuf++) = *z;
2655 }
2656 *(zBuf++) = '"';
2657 *(zBuf++) = '\n';
2658 }
drh4dc8ef52008-07-01 17:13:57 +00002659 if( psp->decllinenoslot && psp->decllinenoslot[0]==0 ){
2660 psp->decllinenoslot[0] = psp->tokenlineno;
2661 }
drha5808f32008-04-27 22:19:44 +00002662 memcpy(zBuf, zNew, nNew);
2663 zBuf += nNew;
2664 *zBuf = 0;
2665 psp->state = WAITING_FOR_DECL_OR_RULE;
drh75897232000-05-29 14:26:00 +00002666 }else{
2667 ErrorMsg(psp->filename,psp->tokenlineno,
2668 "Illegal argument to %%%s: %s",psp->declkeyword,x);
2669 psp->errorcnt++;
2670 psp->state = RESYNC_AFTER_DECL_ERROR;
2671 }
2672 break;
drh0bd1f4e2002-06-06 18:54:39 +00002673 case WAITING_FOR_FALLBACK_ID:
2674 if( x[0]=='.' ){
2675 psp->state = WAITING_FOR_DECL_OR_RULE;
drhc56fac72015-10-29 13:48:15 +00002676 }else if( !ISUPPER(x[0]) ){
drh0bd1f4e2002-06-06 18:54:39 +00002677 ErrorMsg(psp->filename, psp->tokenlineno,
2678 "%%fallback argument \"%s\" should be a token", x);
2679 psp->errorcnt++;
2680 }else{
2681 struct symbol *sp = Symbol_new(x);
2682 if( psp->fallback==0 ){
2683 psp->fallback = sp;
2684 }else if( sp->fallback ){
2685 ErrorMsg(psp->filename, psp->tokenlineno,
2686 "More than one fallback assigned to token %s", x);
2687 psp->errorcnt++;
2688 }else{
2689 sp->fallback = psp->fallback;
2690 psp->gp->has_fallback = 1;
2691 }
2692 }
2693 break;
drh59c435a2017-08-02 03:21:11 +00002694 case WAITING_FOR_TOKEN_NAME:
2695 /* Tokens do not have to be declared before use. But they can be
2696 ** in order to control their assigned integer number. The number for
2697 ** each token is assigned when it is first seen. So by including
2698 **
2699 ** %token ONE TWO THREE
2700 **
2701 ** early in the grammar file, that assigns small consecutive values
2702 ** to each of the tokens ONE TWO and THREE.
2703 */
2704 if( x[0]=='.' ){
2705 psp->state = WAITING_FOR_DECL_OR_RULE;
2706 }else if( !ISUPPER(x[0]) ){
2707 ErrorMsg(psp->filename, psp->tokenlineno,
2708 "%%token argument \"%s\" should be a token", x);
2709 psp->errorcnt++;
2710 }else{
2711 (void)Symbol_new(x);
2712 }
2713 break;
drhe09daa92006-06-10 13:29:31 +00002714 case WAITING_FOR_WILDCARD_ID:
2715 if( x[0]=='.' ){
2716 psp->state = WAITING_FOR_DECL_OR_RULE;
drhc56fac72015-10-29 13:48:15 +00002717 }else if( !ISUPPER(x[0]) ){
drhe09daa92006-06-10 13:29:31 +00002718 ErrorMsg(psp->filename, psp->tokenlineno,
2719 "%%wildcard argument \"%s\" should be a token", x);
2720 psp->errorcnt++;
2721 }else{
2722 struct symbol *sp = Symbol_new(x);
2723 if( psp->gp->wildcard==0 ){
2724 psp->gp->wildcard = sp;
2725 }else{
2726 ErrorMsg(psp->filename, psp->tokenlineno,
2727 "Extra wildcard to token: %s", x);
2728 psp->errorcnt++;
2729 }
2730 }
2731 break;
drh61f92cd2014-01-11 03:06:18 +00002732 case WAITING_FOR_CLASS_ID:
drhc56fac72015-10-29 13:48:15 +00002733 if( !ISLOWER(x[0]) ){
drh61f92cd2014-01-11 03:06:18 +00002734 ErrorMsg(psp->filename, psp->tokenlineno,
mistachkind9bc6e82019-05-10 16:16:19 +00002735 "%%token_class must be followed by an identifier: %s", x);
drh61f92cd2014-01-11 03:06:18 +00002736 psp->errorcnt++;
2737 psp->state = RESYNC_AFTER_DECL_ERROR;
2738 }else if( Symbol_find(x) ){
2739 ErrorMsg(psp->filename, psp->tokenlineno,
2740 "Symbol \"%s\" already used", x);
2741 psp->errorcnt++;
2742 psp->state = RESYNC_AFTER_DECL_ERROR;
2743 }else{
2744 psp->tkclass = Symbol_new(x);
2745 psp->tkclass->type = MULTITERMINAL;
2746 psp->state = WAITING_FOR_CLASS_TOKEN;
2747 }
2748 break;
2749 case WAITING_FOR_CLASS_TOKEN:
2750 if( x[0]=='.' ){
2751 psp->state = WAITING_FOR_DECL_OR_RULE;
drhc56fac72015-10-29 13:48:15 +00002752 }else if( ISUPPER(x[0]) || ((x[0]=='|' || x[0]=='/') && ISUPPER(x[1])) ){
drh61f92cd2014-01-11 03:06:18 +00002753 struct symbol *msp = psp->tkclass;
2754 msp->nsubsym++;
2755 msp->subsym = (struct symbol **) realloc(msp->subsym,
2756 sizeof(struct symbol*)*msp->nsubsym);
drhc56fac72015-10-29 13:48:15 +00002757 if( !ISUPPER(x[0]) ) x++;
drh61f92cd2014-01-11 03:06:18 +00002758 msp->subsym[msp->nsubsym-1] = Symbol_new(x);
2759 }else{
2760 ErrorMsg(psp->filename, psp->tokenlineno,
2761 "%%token_class argument \"%s\" should be a token", x);
2762 psp->errorcnt++;
2763 psp->state = RESYNC_AFTER_DECL_ERROR;
2764 }
2765 break;
drh75897232000-05-29 14:26:00 +00002766 case RESYNC_AFTER_RULE_ERROR:
2767/* if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE;
2768** break; */
2769 case RESYNC_AFTER_DECL_ERROR:
2770 if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE;
2771 if( x[0]=='%' ) psp->state = WAITING_FOR_DECL_KEYWORD;
2772 break;
2773 }
2774}
2775
drh34ff57b2008-07-14 12:27:51 +00002776/* Run the preprocessor over the input file text. The global variables
drh6d08b4d2004-07-20 12:45:22 +00002777** azDefine[0] through azDefine[nDefine-1] contains the names of all defined
2778** macros. This routine looks for "%ifdef" and "%ifndef" and "%endif" and
2779** comments them out. Text in between is also commented out as appropriate.
2780*/
danielk1977940fac92005-01-23 22:41:37 +00002781static void preprocess_input(char *z){
drh6d08b4d2004-07-20 12:45:22 +00002782 int i, j, k, n;
2783 int exclude = 0;
rse38514a92007-09-20 11:34:17 +00002784 int start = 0;
drh6d08b4d2004-07-20 12:45:22 +00002785 int lineno = 1;
rse38514a92007-09-20 11:34:17 +00002786 int start_lineno = 1;
drh6d08b4d2004-07-20 12:45:22 +00002787 for(i=0; z[i]; i++){
2788 if( z[i]=='\n' ) lineno++;
2789 if( z[i]!='%' || (i>0 && z[i-1]!='\n') ) continue;
drhc56fac72015-10-29 13:48:15 +00002790 if( strncmp(&z[i],"%endif",6)==0 && ISSPACE(z[i+6]) ){
drh6d08b4d2004-07-20 12:45:22 +00002791 if( exclude ){
2792 exclude--;
2793 if( exclude==0 ){
2794 for(j=start; j<i; j++) if( z[j]!='\n' ) z[j] = ' ';
2795 }
2796 }
2797 for(j=i; z[j] && z[j]!='\n'; j++) z[j] = ' ';
drhc56fac72015-10-29 13:48:15 +00002798 }else if( (strncmp(&z[i],"%ifdef",6)==0 && ISSPACE(z[i+6]))
2799 || (strncmp(&z[i],"%ifndef",7)==0 && ISSPACE(z[i+7])) ){
drh6d08b4d2004-07-20 12:45:22 +00002800 if( exclude ){
2801 exclude++;
2802 }else{
drhc56fac72015-10-29 13:48:15 +00002803 for(j=i+7; ISSPACE(z[j]); j++){}
2804 for(n=0; z[j+n] && !ISSPACE(z[j+n]); n++){}
drh6d08b4d2004-07-20 12:45:22 +00002805 exclude = 1;
2806 for(k=0; k<nDefine; k++){
drh87cf1372008-08-13 20:09:06 +00002807 if( strncmp(azDefine[k],&z[j],n)==0 && lemonStrlen(azDefine[k])==n ){
drh6d08b4d2004-07-20 12:45:22 +00002808 exclude = 0;
2809 break;
2810 }
2811 }
2812 if( z[i+3]=='n' ) exclude = !exclude;
2813 if( exclude ){
2814 start = i;
2815 start_lineno = lineno;
2816 }
2817 }
2818 for(j=i; z[j] && z[j]!='\n'; j++) z[j] = ' ';
2819 }
2820 }
2821 if( exclude ){
2822 fprintf(stderr,"unterminated %%ifdef starting on line %d\n", start_lineno);
2823 exit(1);
2824 }
2825}
2826
drh75897232000-05-29 14:26:00 +00002827/* In spite of its name, this function is really a scanner. It read
2828** in the entire input file (all at once) then tokenizes it. Each
2829** token is passed to the function "parseonetoken" which builds all
2830** the appropriate data structures in the global state vector "gp".
2831*/
icculus9e44cf12010-02-14 17:14:22 +00002832void Parse(struct lemon *gp)
drh75897232000-05-29 14:26:00 +00002833{
2834 struct pstate ps;
2835 FILE *fp;
2836 char *filebuf;
mistachkin2318d332015-01-12 18:02:52 +00002837 unsigned int filesize;
drh75897232000-05-29 14:26:00 +00002838 int lineno;
2839 int c;
2840 char *cp, *nextcp;
2841 int startline = 0;
2842
rse38514a92007-09-20 11:34:17 +00002843 memset(&ps, '\0', sizeof(ps));
drh75897232000-05-29 14:26:00 +00002844 ps.gp = gp;
2845 ps.filename = gp->filename;
2846 ps.errorcnt = 0;
2847 ps.state = INITIALIZE;
2848
2849 /* Begin by reading the input file */
2850 fp = fopen(ps.filename,"rb");
2851 if( fp==0 ){
2852 ErrorMsg(ps.filename,0,"Can't open this file for reading.");
2853 gp->errorcnt++;
2854 return;
2855 }
2856 fseek(fp,0,2);
2857 filesize = ftell(fp);
2858 rewind(fp);
2859 filebuf = (char *)malloc( filesize+1 );
drh03e1b1f2014-01-11 12:52:25 +00002860 if( filesize>100000000 || filebuf==0 ){
2861 ErrorMsg(ps.filename,0,"Input file too large.");
mistachkinc93c6142018-09-08 16:55:18 +00002862 free(filebuf);
drh75897232000-05-29 14:26:00 +00002863 gp->errorcnt++;
drhe0a59cf2011-08-30 00:58:58 +00002864 fclose(fp);
drh75897232000-05-29 14:26:00 +00002865 return;
2866 }
2867 if( fread(filebuf,1,filesize,fp)!=filesize ){
2868 ErrorMsg(ps.filename,0,"Can't read in all %d bytes of this file.",
2869 filesize);
2870 free(filebuf);
2871 gp->errorcnt++;
drhe0a59cf2011-08-30 00:58:58 +00002872 fclose(fp);
drh75897232000-05-29 14:26:00 +00002873 return;
2874 }
2875 fclose(fp);
2876 filebuf[filesize] = 0;
2877
drh6d08b4d2004-07-20 12:45:22 +00002878 /* Make an initial pass through the file to handle %ifdef and %ifndef */
2879 preprocess_input(filebuf);
2880
drh75897232000-05-29 14:26:00 +00002881 /* Now scan the text of the input file */
2882 lineno = 1;
2883 for(cp=filebuf; (c= *cp)!=0; ){
2884 if( c=='\n' ) lineno++; /* Keep track of the line number */
drhc56fac72015-10-29 13:48:15 +00002885 if( ISSPACE(c) ){ cp++; continue; } /* Skip all white space */
drh75897232000-05-29 14:26:00 +00002886 if( c=='/' && cp[1]=='/' ){ /* Skip C++ style comments */
2887 cp+=2;
2888 while( (c= *cp)!=0 && c!='\n' ) cp++;
2889 continue;
2890 }
2891 if( c=='/' && cp[1]=='*' ){ /* Skip C style comments */
2892 cp+=2;
2893 while( (c= *cp)!=0 && (c!='/' || cp[-1]!='*') ){
2894 if( c=='\n' ) lineno++;
2895 cp++;
2896 }
2897 if( c ) cp++;
2898 continue;
2899 }
2900 ps.tokenstart = cp; /* Mark the beginning of the token */
2901 ps.tokenlineno = lineno; /* Linenumber on which token begins */
2902 if( c=='\"' ){ /* String literals */
2903 cp++;
2904 while( (c= *cp)!=0 && c!='\"' ){
2905 if( c=='\n' ) lineno++;
2906 cp++;
2907 }
2908 if( c==0 ){
2909 ErrorMsg(ps.filename,startline,
2910"String starting on this line is not terminated before the end of the file.");
2911 ps.errorcnt++;
2912 nextcp = cp;
2913 }else{
2914 nextcp = cp+1;
2915 }
2916 }else if( c=='{' ){ /* A block of C code */
2917 int level;
2918 cp++;
2919 for(level=1; (c= *cp)!=0 && (level>1 || c!='}'); cp++){
2920 if( c=='\n' ) lineno++;
2921 else if( c=='{' ) level++;
2922 else if( c=='}' ) level--;
2923 else if( c=='/' && cp[1]=='*' ){ /* Skip comments */
2924 int prevc;
2925 cp = &cp[2];
2926 prevc = 0;
2927 while( (c= *cp)!=0 && (c!='/' || prevc!='*') ){
2928 if( c=='\n' ) lineno++;
2929 prevc = c;
2930 cp++;
drhf2f105d2012-08-20 15:53:54 +00002931 }
2932 }else if( c=='/' && cp[1]=='/' ){ /* Skip C++ style comments too */
drh75897232000-05-29 14:26:00 +00002933 cp = &cp[2];
2934 while( (c= *cp)!=0 && c!='\n' ) cp++;
2935 if( c ) lineno++;
drhf2f105d2012-08-20 15:53:54 +00002936 }else if( c=='\'' || c=='\"' ){ /* String a character literals */
drh75897232000-05-29 14:26:00 +00002937 int startchar, prevc;
2938 startchar = c;
2939 prevc = 0;
2940 for(cp++; (c= *cp)!=0 && (c!=startchar || prevc=='\\'); cp++){
2941 if( c=='\n' ) lineno++;
2942 if( prevc=='\\' ) prevc = 0;
2943 else prevc = c;
drhf2f105d2012-08-20 15:53:54 +00002944 }
2945 }
drh75897232000-05-29 14:26:00 +00002946 }
2947 if( c==0 ){
drh960e8c62001-04-03 16:53:21 +00002948 ErrorMsg(ps.filename,ps.tokenlineno,
drh75897232000-05-29 14:26:00 +00002949"C code starting on this line is not terminated before the end of the file.");
2950 ps.errorcnt++;
2951 nextcp = cp;
2952 }else{
2953 nextcp = cp+1;
2954 }
drhc56fac72015-10-29 13:48:15 +00002955 }else if( ISALNUM(c) ){ /* Identifiers */
2956 while( (c= *cp)!=0 && (ISALNUM(c) || c=='_') ) cp++;
drh75897232000-05-29 14:26:00 +00002957 nextcp = cp;
2958 }else if( c==':' && cp[1]==':' && cp[2]=='=' ){ /* The operator "::=" */
2959 cp += 3;
2960 nextcp = cp;
drhc56fac72015-10-29 13:48:15 +00002961 }else if( (c=='/' || c=='|') && ISALPHA(cp[1]) ){
drhfd405312005-11-06 04:06:59 +00002962 cp += 2;
drhc56fac72015-10-29 13:48:15 +00002963 while( (c = *cp)!=0 && (ISALNUM(c) || c=='_') ) cp++;
drhfd405312005-11-06 04:06:59 +00002964 nextcp = cp;
drh75897232000-05-29 14:26:00 +00002965 }else{ /* All other (one character) operators */
2966 cp++;
2967 nextcp = cp;
2968 }
2969 c = *cp;
2970 *cp = 0; /* Null terminate the token */
2971 parseonetoken(&ps); /* Parse the token */
mistachkin2318d332015-01-12 18:02:52 +00002972 *cp = (char)c; /* Restore the buffer */
drh75897232000-05-29 14:26:00 +00002973 cp = nextcp;
2974 }
2975 free(filebuf); /* Release the buffer after parsing */
2976 gp->rule = ps.firstrule;
2977 gp->errorcnt = ps.errorcnt;
2978}
2979/*************************** From the file "plink.c" *********************/
2980/*
2981** Routines processing configuration follow-set propagation links
2982** in the LEMON parser generator.
2983*/
2984static struct plink *plink_freelist = 0;
2985
2986/* Allocate a new plink */
drh14d88552017-04-14 19:44:15 +00002987struct plink *Plink_new(void){
icculus9e44cf12010-02-14 17:14:22 +00002988 struct plink *newlink;
drh75897232000-05-29 14:26:00 +00002989
2990 if( plink_freelist==0 ){
2991 int i;
2992 int amt = 100;
drh9892c5d2007-12-21 00:02:11 +00002993 plink_freelist = (struct plink *)calloc( amt, sizeof(struct plink) );
drh75897232000-05-29 14:26:00 +00002994 if( plink_freelist==0 ){
2995 fprintf(stderr,
2996 "Unable to allocate memory for a new follow-set propagation link.\n");
2997 exit(1);
2998 }
2999 for(i=0; i<amt-1; i++) plink_freelist[i].next = &plink_freelist[i+1];
3000 plink_freelist[amt-1].next = 0;
3001 }
icculus9e44cf12010-02-14 17:14:22 +00003002 newlink = plink_freelist;
drh75897232000-05-29 14:26:00 +00003003 plink_freelist = plink_freelist->next;
icculus9e44cf12010-02-14 17:14:22 +00003004 return newlink;
drh75897232000-05-29 14:26:00 +00003005}
3006
3007/* Add a plink to a plink list */
icculus9e44cf12010-02-14 17:14:22 +00003008void Plink_add(struct plink **plpp, struct config *cfp)
drh75897232000-05-29 14:26:00 +00003009{
icculus9e44cf12010-02-14 17:14:22 +00003010 struct plink *newlink;
3011 newlink = Plink_new();
3012 newlink->next = *plpp;
3013 *plpp = newlink;
3014 newlink->cfp = cfp;
drh75897232000-05-29 14:26:00 +00003015}
3016
3017/* Transfer every plink on the list "from" to the list "to" */
icculus9e44cf12010-02-14 17:14:22 +00003018void Plink_copy(struct plink **to, struct plink *from)
drh75897232000-05-29 14:26:00 +00003019{
3020 struct plink *nextpl;
3021 while( from ){
3022 nextpl = from->next;
3023 from->next = *to;
3024 *to = from;
3025 from = nextpl;
3026 }
3027}
3028
3029/* Delete every plink on the list */
icculus9e44cf12010-02-14 17:14:22 +00003030void Plink_delete(struct plink *plp)
drh75897232000-05-29 14:26:00 +00003031{
3032 struct plink *nextpl;
3033
3034 while( plp ){
3035 nextpl = plp->next;
3036 plp->next = plink_freelist;
3037 plink_freelist = plp;
3038 plp = nextpl;
3039 }
3040}
3041/*********************** From the file "report.c" **************************/
3042/*
3043** Procedures for generating reports and tables in the LEMON parser generator.
3044*/
3045
3046/* Generate a filename with the given suffix. Space to hold the
3047** name comes from malloc() and must be freed by the calling
3048** function.
3049*/
icculus9e44cf12010-02-14 17:14:22 +00003050PRIVATE char *file_makename(struct lemon *lemp, const char *suffix)
drh75897232000-05-29 14:26:00 +00003051{
3052 char *name;
3053 char *cp;
drh9f88e6d2018-04-20 20:47:49 +00003054 char *filename = lemp->filename;
3055 int sz;
drh75897232000-05-29 14:26:00 +00003056
drh9f88e6d2018-04-20 20:47:49 +00003057 if( outputDir ){
3058 cp = strrchr(filename, '/');
3059 if( cp ) filename = cp + 1;
3060 }
3061 sz = lemonStrlen(filename);
3062 sz += lemonStrlen(suffix);
3063 if( outputDir ) sz += lemonStrlen(outputDir) + 1;
3064 sz += 5;
3065 name = (char*)malloc( sz );
drh75897232000-05-29 14:26:00 +00003066 if( name==0 ){
3067 fprintf(stderr,"Can't allocate space for a filename.\n");
3068 exit(1);
3069 }
drh9f88e6d2018-04-20 20:47:49 +00003070 name[0] = 0;
3071 if( outputDir ){
3072 lemon_strcpy(name, outputDir);
3073 lemon_strcat(name, "/");
3074 }
3075 lemon_strcat(name,filename);
drh75897232000-05-29 14:26:00 +00003076 cp = strrchr(name,'.');
3077 if( cp ) *cp = 0;
drh898799f2014-01-10 23:21:00 +00003078 lemon_strcat(name,suffix);
drh75897232000-05-29 14:26:00 +00003079 return name;
3080}
3081
3082/* Open a file with a name based on the name of the input file,
3083** but with a different (specified) suffix, and return a pointer
3084** to the stream */
icculus9e44cf12010-02-14 17:14:22 +00003085PRIVATE FILE *file_open(
3086 struct lemon *lemp,
3087 const char *suffix,
3088 const char *mode
3089){
drh75897232000-05-29 14:26:00 +00003090 FILE *fp;
3091
3092 if( lemp->outname ) free(lemp->outname);
3093 lemp->outname = file_makename(lemp, suffix);
3094 fp = fopen(lemp->outname,mode);
3095 if( fp==0 && *mode=='w' ){
3096 fprintf(stderr,"Can't open file \"%s\".\n",lemp->outname);
3097 lemp->errorcnt++;
3098 return 0;
3099 }
3100 return fp;
3101}
3102
drh5c8241b2017-12-24 23:38:10 +00003103/* Print the text of a rule
3104*/
3105void rule_print(FILE *out, struct rule *rp){
3106 int i, j;
3107 fprintf(out, "%s",rp->lhs->name);
3108 /* if( rp->lhsalias ) fprintf(out,"(%s)",rp->lhsalias); */
3109 fprintf(out," ::=");
3110 for(i=0; i<rp->nrhs; i++){
3111 struct symbol *sp = rp->rhs[i];
3112 if( sp->type==MULTITERMINAL ){
3113 fprintf(out," %s", sp->subsym[0]->name);
3114 for(j=1; j<sp->nsubsym; j++){
3115 fprintf(out,"|%s", sp->subsym[j]->name);
3116 }
3117 }else{
3118 fprintf(out," %s", sp->name);
3119 }
3120 /* if( rp->rhsalias[i] ) fprintf(out,"(%s)",rp->rhsalias[i]); */
3121 }
3122}
3123
drh06f60d82017-04-14 19:46:12 +00003124/* Duplicate the input file without comments and without actions
drh75897232000-05-29 14:26:00 +00003125** on rules */
icculus9e44cf12010-02-14 17:14:22 +00003126void Reprint(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +00003127{
3128 struct rule *rp;
3129 struct symbol *sp;
3130 int i, j, maxlen, len, ncolumns, skip;
3131 printf("// Reprint of input file \"%s\".\n// Symbols:\n",lemp->filename);
3132 maxlen = 10;
3133 for(i=0; i<lemp->nsymbol; i++){
3134 sp = lemp->symbols[i];
drh87cf1372008-08-13 20:09:06 +00003135 len = lemonStrlen(sp->name);
drh75897232000-05-29 14:26:00 +00003136 if( len>maxlen ) maxlen = len;
3137 }
3138 ncolumns = 76/(maxlen+5);
3139 if( ncolumns<1 ) ncolumns = 1;
3140 skip = (lemp->nsymbol + ncolumns - 1)/ncolumns;
3141 for(i=0; i<skip; i++){
3142 printf("//");
3143 for(j=i; j<lemp->nsymbol; j+=skip){
3144 sp = lemp->symbols[j];
3145 assert( sp->index==j );
3146 printf(" %3d %-*.*s",j,maxlen,maxlen,sp->name);
3147 }
3148 printf("\n");
3149 }
3150 for(rp=lemp->rule; rp; rp=rp->next){
drh5c8241b2017-12-24 23:38:10 +00003151 rule_print(stdout, rp);
drh75897232000-05-29 14:26:00 +00003152 printf(".");
3153 if( rp->precsym ) printf(" [%s]",rp->precsym->name);
drhfd405312005-11-06 04:06:59 +00003154 /* if( rp->code ) printf("\n %s",rp->code); */
drh75897232000-05-29 14:26:00 +00003155 printf("\n");
3156 }
3157}
3158
drh7e698e92015-09-07 14:22:24 +00003159/* Print a single rule.
3160*/
3161void RulePrint(FILE *fp, struct rule *rp, int iCursor){
drhfd405312005-11-06 04:06:59 +00003162 struct symbol *sp;
3163 int i, j;
drh75897232000-05-29 14:26:00 +00003164 fprintf(fp,"%s ::=",rp->lhs->name);
3165 for(i=0; i<=rp->nrhs; i++){
drh7e698e92015-09-07 14:22:24 +00003166 if( i==iCursor ) fprintf(fp," *");
drh75897232000-05-29 14:26:00 +00003167 if( i==rp->nrhs ) break;
drhfd405312005-11-06 04:06:59 +00003168 sp = rp->rhs[i];
drhfd405312005-11-06 04:06:59 +00003169 if( sp->type==MULTITERMINAL ){
drh61f92cd2014-01-11 03:06:18 +00003170 fprintf(fp," %s", sp->subsym[0]->name);
drhfd405312005-11-06 04:06:59 +00003171 for(j=1; j<sp->nsubsym; j++){
3172 fprintf(fp,"|%s",sp->subsym[j]->name);
3173 }
drh61f92cd2014-01-11 03:06:18 +00003174 }else{
3175 fprintf(fp," %s", sp->name);
drhfd405312005-11-06 04:06:59 +00003176 }
drh75897232000-05-29 14:26:00 +00003177 }
3178}
3179
drh7e698e92015-09-07 14:22:24 +00003180/* Print the rule for a configuration.
3181*/
3182void ConfigPrint(FILE *fp, struct config *cfp){
3183 RulePrint(fp, cfp->rp, cfp->dot);
3184}
3185
drh75897232000-05-29 14:26:00 +00003186/* #define TEST */
drhfd405312005-11-06 04:06:59 +00003187#if 0
drh75897232000-05-29 14:26:00 +00003188/* Print a set */
3189PRIVATE void SetPrint(out,set,lemp)
3190FILE *out;
3191char *set;
3192struct lemon *lemp;
3193{
3194 int i;
3195 char *spacer;
3196 spacer = "";
3197 fprintf(out,"%12s[","");
3198 for(i=0; i<lemp->nterminal; i++){
3199 if( SetFind(set,i) ){
3200 fprintf(out,"%s%s",spacer,lemp->symbols[i]->name);
3201 spacer = " ";
3202 }
3203 }
3204 fprintf(out,"]\n");
3205}
3206
3207/* Print a plink chain */
3208PRIVATE void PlinkPrint(out,plp,tag)
3209FILE *out;
3210struct plink *plp;
3211char *tag;
3212{
3213 while( plp ){
drhada354d2005-11-05 15:03:59 +00003214 fprintf(out,"%12s%s (state %2d) ","",tag,plp->cfp->stp->statenum);
drh75897232000-05-29 14:26:00 +00003215 ConfigPrint(out,plp->cfp);
3216 fprintf(out,"\n");
3217 plp = plp->next;
3218 }
3219}
3220#endif
3221
3222/* Print an action to the given file descriptor. Return FALSE if
3223** nothing was actually printed.
3224*/
drh7e698e92015-09-07 14:22:24 +00003225int PrintAction(
3226 struct action *ap, /* The action to print */
3227 FILE *fp, /* Print the action here */
drh3bd48ab2015-09-07 18:23:37 +00003228 int indent /* Indent by this amount */
drh7e698e92015-09-07 14:22:24 +00003229){
drh75897232000-05-29 14:26:00 +00003230 int result = 1;
3231 switch( ap->type ){
drh7e698e92015-09-07 14:22:24 +00003232 case SHIFT: {
3233 struct state *stp = ap->x.stp;
drh3bd48ab2015-09-07 18:23:37 +00003234 fprintf(fp,"%*s shift %-7d",indent,ap->sp->name,stp->statenum);
drh75897232000-05-29 14:26:00 +00003235 break;
drh7e698e92015-09-07 14:22:24 +00003236 }
3237 case REDUCE: {
3238 struct rule *rp = ap->x.rp;
drh4ef07702016-03-16 19:45:54 +00003239 fprintf(fp,"%*s reduce %-7d",indent,ap->sp->name,rp->iRule);
drh3bd48ab2015-09-07 18:23:37 +00003240 RulePrint(fp, rp, -1);
3241 break;
3242 }
3243 case SHIFTREDUCE: {
3244 struct rule *rp = ap->x.rp;
drh4ef07702016-03-16 19:45:54 +00003245 fprintf(fp,"%*s shift-reduce %-7d",indent,ap->sp->name,rp->iRule);
drh3bd48ab2015-09-07 18:23:37 +00003246 RulePrint(fp, rp, -1);
drh75897232000-05-29 14:26:00 +00003247 break;
drh7e698e92015-09-07 14:22:24 +00003248 }
drh75897232000-05-29 14:26:00 +00003249 case ACCEPT:
3250 fprintf(fp,"%*s accept",indent,ap->sp->name);
3251 break;
3252 case ERROR:
3253 fprintf(fp,"%*s error",indent,ap->sp->name);
3254 break;
drh9892c5d2007-12-21 00:02:11 +00003255 case SRCONFLICT:
3256 case RRCONFLICT:
drh3bd48ab2015-09-07 18:23:37 +00003257 fprintf(fp,"%*s reduce %-7d ** Parsing conflict **",
drh4ef07702016-03-16 19:45:54 +00003258 indent,ap->sp->name,ap->x.rp->iRule);
drh75897232000-05-29 14:26:00 +00003259 break;
drh9892c5d2007-12-21 00:02:11 +00003260 case SSCONFLICT:
drh06f60d82017-04-14 19:46:12 +00003261 fprintf(fp,"%*s shift %-7d ** Parsing conflict **",
drh9892c5d2007-12-21 00:02:11 +00003262 indent,ap->sp->name,ap->x.stp->statenum);
3263 break;
drh75897232000-05-29 14:26:00 +00003264 case SH_RESOLVED:
drhf5c4e0f2010-07-18 11:35:53 +00003265 if( showPrecedenceConflict ){
drh3bd48ab2015-09-07 18:23:37 +00003266 fprintf(fp,"%*s shift %-7d -- dropped by precedence",
drhf5c4e0f2010-07-18 11:35:53 +00003267 indent,ap->sp->name,ap->x.stp->statenum);
3268 }else{
3269 result = 0;
3270 }
3271 break;
drh75897232000-05-29 14:26:00 +00003272 case RD_RESOLVED:
drhf5c4e0f2010-07-18 11:35:53 +00003273 if( showPrecedenceConflict ){
drh7e698e92015-09-07 14:22:24 +00003274 fprintf(fp,"%*s reduce %-7d -- dropped by precedence",
drh4ef07702016-03-16 19:45:54 +00003275 indent,ap->sp->name,ap->x.rp->iRule);
drhf5c4e0f2010-07-18 11:35:53 +00003276 }else{
3277 result = 0;
3278 }
3279 break;
drh75897232000-05-29 14:26:00 +00003280 case NOT_USED:
3281 result = 0;
3282 break;
3283 }
drhc173ad82016-05-23 16:15:02 +00003284 if( result && ap->spOpt ){
3285 fprintf(fp," /* because %s==%s */", ap->sp->name, ap->spOpt->name);
3286 }
drh75897232000-05-29 14:26:00 +00003287 return result;
3288}
3289
drh3bd48ab2015-09-07 18:23:37 +00003290/* Generate the "*.out" log file */
icculus9e44cf12010-02-14 17:14:22 +00003291void ReportOutput(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +00003292{
drh539e7412018-04-21 20:24:19 +00003293 int i, n;
drh75897232000-05-29 14:26:00 +00003294 struct state *stp;
3295 struct config *cfp;
3296 struct action *ap;
drh12f68392018-04-06 19:12:55 +00003297 struct rule *rp;
drh75897232000-05-29 14:26:00 +00003298 FILE *fp;
3299
drh2aa6ca42004-09-10 00:14:04 +00003300 fp = file_open(lemp,".out","wb");
drh75897232000-05-29 14:26:00 +00003301 if( fp==0 ) return;
drh3bd48ab2015-09-07 18:23:37 +00003302 for(i=0; i<lemp->nxstate; i++){
drh75897232000-05-29 14:26:00 +00003303 stp = lemp->sorted[i];
drhada354d2005-11-05 15:03:59 +00003304 fprintf(fp,"State %d:\n",stp->statenum);
drh75897232000-05-29 14:26:00 +00003305 if( lemp->basisflag ) cfp=stp->bp;
3306 else cfp=stp->cfp;
3307 while( cfp ){
3308 char buf[20];
3309 if( cfp->dot==cfp->rp->nrhs ){
drh4ef07702016-03-16 19:45:54 +00003310 lemon_sprintf(buf,"(%d)",cfp->rp->iRule);
drh75897232000-05-29 14:26:00 +00003311 fprintf(fp," %5s ",buf);
3312 }else{
3313 fprintf(fp," ");
3314 }
3315 ConfigPrint(fp,cfp);
3316 fprintf(fp,"\n");
drhfd405312005-11-06 04:06:59 +00003317#if 0
drh75897232000-05-29 14:26:00 +00003318 SetPrint(fp,cfp->fws,lemp);
3319 PlinkPrint(fp,cfp->fplp,"To ");
3320 PlinkPrint(fp,cfp->bplp,"From");
3321#endif
3322 if( lemp->basisflag ) cfp=cfp->bp;
3323 else cfp=cfp->next;
3324 }
3325 fprintf(fp,"\n");
3326 for(ap=stp->ap; ap; ap=ap->next){
drh3bd48ab2015-09-07 18:23:37 +00003327 if( PrintAction(ap,fp,30) ) fprintf(fp,"\n");
drh75897232000-05-29 14:26:00 +00003328 }
3329 fprintf(fp,"\n");
3330 }
drhe9278182007-07-18 18:16:29 +00003331 fprintf(fp, "----------------------------------------------------\n");
3332 fprintf(fp, "Symbols:\n");
drh539e7412018-04-21 20:24:19 +00003333 fprintf(fp, "The first-set of non-terminals is shown after the name.\n\n");
drhe9278182007-07-18 18:16:29 +00003334 for(i=0; i<lemp->nsymbol; i++){
3335 int j;
3336 struct symbol *sp;
3337
3338 sp = lemp->symbols[i];
3339 fprintf(fp, " %3d: %s", i, sp->name);
3340 if( sp->type==NONTERMINAL ){
3341 fprintf(fp, ":");
3342 if( sp->lambda ){
3343 fprintf(fp, " <lambda>");
3344 }
3345 for(j=0; j<lemp->nterminal; j++){
3346 if( sp->firstset && SetFind(sp->firstset, j) ){
3347 fprintf(fp, " %s", lemp->symbols[j]->name);
3348 }
3349 }
3350 }
drh12f68392018-04-06 19:12:55 +00003351 if( sp->prec>=0 ) fprintf(fp," (precedence=%d)", sp->prec);
drhe9278182007-07-18 18:16:29 +00003352 fprintf(fp, "\n");
3353 }
drh12f68392018-04-06 19:12:55 +00003354 fprintf(fp, "----------------------------------------------------\n");
drh539e7412018-04-21 20:24:19 +00003355 fprintf(fp, "Syntax-only Symbols:\n");
3356 fprintf(fp, "The following symbols never carry semantic content.\n\n");
3357 for(i=n=0; i<lemp->nsymbol; i++){
3358 int w;
3359 struct symbol *sp = lemp->symbols[i];
3360 if( sp->bContent ) continue;
3361 w = (int)strlen(sp->name);
3362 if( n>0 && n+w>75 ){
3363 fprintf(fp,"\n");
3364 n = 0;
3365 }
3366 if( n>0 ){
3367 fprintf(fp, " ");
3368 n++;
3369 }
3370 fprintf(fp, "%s", sp->name);
3371 n += w;
3372 }
3373 if( n>0 ) fprintf(fp, "\n");
3374 fprintf(fp, "----------------------------------------------------\n");
drh12f68392018-04-06 19:12:55 +00003375 fprintf(fp, "Rules:\n");
3376 for(rp=lemp->rule; rp; rp=rp->next){
3377 fprintf(fp, "%4d: ", rp->iRule);
3378 rule_print(fp, rp);
3379 fprintf(fp,".");
3380 if( rp->precsym ){
3381 fprintf(fp," [%s precedence=%d]",
3382 rp->precsym->name, rp->precsym->prec);
3383 }
3384 fprintf(fp,"\n");
3385 }
drh75897232000-05-29 14:26:00 +00003386 fclose(fp);
3387 return;
3388}
3389
3390/* Search for the file "name" which is in the same directory as
3391** the exacutable */
icculus9e44cf12010-02-14 17:14:22 +00003392PRIVATE char *pathsearch(char *argv0, char *name, int modemask)
drh75897232000-05-29 14:26:00 +00003393{
icculus9e44cf12010-02-14 17:14:22 +00003394 const char *pathlist;
3395 char *pathbufptr;
3396 char *pathbuf;
drh75897232000-05-29 14:26:00 +00003397 char *path,*cp;
3398 char c;
drh75897232000-05-29 14:26:00 +00003399
3400#ifdef __WIN32__
3401 cp = strrchr(argv0,'\\');
3402#else
3403 cp = strrchr(argv0,'/');
3404#endif
3405 if( cp ){
3406 c = *cp;
3407 *cp = 0;
drh87cf1372008-08-13 20:09:06 +00003408 path = (char *)malloc( lemonStrlen(argv0) + lemonStrlen(name) + 2 );
drh898799f2014-01-10 23:21:00 +00003409 if( path ) lemon_sprintf(path,"%s/%s",argv0,name);
drh75897232000-05-29 14:26:00 +00003410 *cp = c;
3411 }else{
drh75897232000-05-29 14:26:00 +00003412 pathlist = getenv("PATH");
3413 if( pathlist==0 ) pathlist = ".:/bin:/usr/bin";
icculus9e44cf12010-02-14 17:14:22 +00003414 pathbuf = (char *) malloc( lemonStrlen(pathlist) + 1 );
drh87cf1372008-08-13 20:09:06 +00003415 path = (char *)malloc( lemonStrlen(pathlist)+lemonStrlen(name)+2 );
icculus9e44cf12010-02-14 17:14:22 +00003416 if( (pathbuf != 0) && (path!=0) ){
3417 pathbufptr = pathbuf;
drh898799f2014-01-10 23:21:00 +00003418 lemon_strcpy(pathbuf, pathlist);
icculus9e44cf12010-02-14 17:14:22 +00003419 while( *pathbuf ){
3420 cp = strchr(pathbuf,':');
3421 if( cp==0 ) cp = &pathbuf[lemonStrlen(pathbuf)];
drh75897232000-05-29 14:26:00 +00003422 c = *cp;
3423 *cp = 0;
drh898799f2014-01-10 23:21:00 +00003424 lemon_sprintf(path,"%s/%s",pathbuf,name);
drh75897232000-05-29 14:26:00 +00003425 *cp = c;
icculus9e44cf12010-02-14 17:14:22 +00003426 if( c==0 ) pathbuf[0] = 0;
3427 else pathbuf = &cp[1];
drh75897232000-05-29 14:26:00 +00003428 if( access(path,modemask)==0 ) break;
3429 }
icculus9e44cf12010-02-14 17:14:22 +00003430 free(pathbufptr);
drh75897232000-05-29 14:26:00 +00003431 }
3432 }
3433 return path;
3434}
3435
3436/* Given an action, compute the integer value for that action
3437** which is to be put in the action table of the generated machine.
3438** Return negative if no action should be generated.
3439*/
icculus9e44cf12010-02-14 17:14:22 +00003440PRIVATE int compute_action(struct lemon *lemp, struct action *ap)
drh75897232000-05-29 14:26:00 +00003441{
3442 int act;
3443 switch( ap->type ){
drh3bd48ab2015-09-07 18:23:37 +00003444 case SHIFT: act = ap->x.stp->statenum; break;
drhbd8fcc12017-06-28 11:56:18 +00003445 case SHIFTREDUCE: {
drhbd8fcc12017-06-28 11:56:18 +00003446 /* Since a SHIFT is inherient after a prior REDUCE, convert any
3447 ** SHIFTREDUCE action with a nonterminal on the LHS into a simple
3448 ** REDUCE action: */
drh5c8241b2017-12-24 23:38:10 +00003449 if( ap->sp->index>=lemp->nterminal ){
3450 act = lemp->minReduce + ap->x.rp->iRule;
3451 }else{
3452 act = lemp->minShiftReduce + ap->x.rp->iRule;
3453 }
drhbd8fcc12017-06-28 11:56:18 +00003454 break;
3455 }
drh5c8241b2017-12-24 23:38:10 +00003456 case REDUCE: act = lemp->minReduce + ap->x.rp->iRule; break;
3457 case ERROR: act = lemp->errAction; break;
3458 case ACCEPT: act = lemp->accAction; break;
drh75897232000-05-29 14:26:00 +00003459 default: act = -1; break;
3460 }
3461 return act;
3462}
3463
3464#define LINESIZE 1000
3465/* The next cluster of routines are for reading the template file
3466** and writing the results to the generated parser */
3467/* The first function transfers data from "in" to "out" until
3468** a line is seen which begins with "%%". The line number is
3469** tracked.
3470**
3471** if name!=0, then any word that begin with "Parse" is changed to
3472** begin with *name instead.
3473*/
icculus9e44cf12010-02-14 17:14:22 +00003474PRIVATE void tplt_xfer(char *name, FILE *in, FILE *out, int *lineno)
drh75897232000-05-29 14:26:00 +00003475{
3476 int i, iStart;
3477 char line[LINESIZE];
3478 while( fgets(line,LINESIZE,in) && (line[0]!='%' || line[1]!='%') ){
3479 (*lineno)++;
3480 iStart = 0;
3481 if( name ){
3482 for(i=0; line[i]; i++){
3483 if( line[i]=='P' && strncmp(&line[i],"Parse",5)==0
drhc56fac72015-10-29 13:48:15 +00003484 && (i==0 || !ISALPHA(line[i-1]))
drh75897232000-05-29 14:26:00 +00003485 ){
3486 if( i>iStart ) fprintf(out,"%.*s",i-iStart,&line[iStart]);
3487 fprintf(out,"%s",name);
3488 i += 4;
3489 iStart = i+1;
3490 }
3491 }
3492 }
3493 fprintf(out,"%s",&line[iStart]);
3494 }
3495}
3496
3497/* The next function finds the template file and opens it, returning
3498** a pointer to the opened file. */
icculus9e44cf12010-02-14 17:14:22 +00003499PRIVATE FILE *tplt_open(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +00003500{
3501 static char templatename[] = "lempar.c";
3502 char buf[1000];
3503 FILE *in;
3504 char *tpltname;
3505 char *cp;
3506
icculus3e143bd2010-02-14 00:48:49 +00003507 /* first, see if user specified a template filename on the command line. */
3508 if (user_templatename != 0) {
3509 if( access(user_templatename,004)==-1 ){
3510 fprintf(stderr,"Can't find the parser driver template file \"%s\".\n",
3511 user_templatename);
3512 lemp->errorcnt++;
3513 return 0;
3514 }
3515 in = fopen(user_templatename,"rb");
3516 if( in==0 ){
drh25473362015-09-04 18:03:45 +00003517 fprintf(stderr,"Can't open the template file \"%s\".\n",
3518 user_templatename);
icculus3e143bd2010-02-14 00:48:49 +00003519 lemp->errorcnt++;
3520 return 0;
3521 }
3522 return in;
3523 }
3524
drh75897232000-05-29 14:26:00 +00003525 cp = strrchr(lemp->filename,'.');
3526 if( cp ){
drh898799f2014-01-10 23:21:00 +00003527 lemon_sprintf(buf,"%.*s.lt",(int)(cp-lemp->filename),lemp->filename);
drh75897232000-05-29 14:26:00 +00003528 }else{
drh898799f2014-01-10 23:21:00 +00003529 lemon_sprintf(buf,"%s.lt",lemp->filename);
drh75897232000-05-29 14:26:00 +00003530 }
3531 if( access(buf,004)==0 ){
3532 tpltname = buf;
drh960e8c62001-04-03 16:53:21 +00003533 }else if( access(templatename,004)==0 ){
3534 tpltname = templatename;
drh75897232000-05-29 14:26:00 +00003535 }else{
3536 tpltname = pathsearch(lemp->argv0,templatename,0);
3537 }
3538 if( tpltname==0 ){
3539 fprintf(stderr,"Can't find the parser driver template file \"%s\".\n",
3540 templatename);
3541 lemp->errorcnt++;
3542 return 0;
3543 }
drh2aa6ca42004-09-10 00:14:04 +00003544 in = fopen(tpltname,"rb");
drh75897232000-05-29 14:26:00 +00003545 if( in==0 ){
3546 fprintf(stderr,"Can't open the template file \"%s\".\n",templatename);
3547 lemp->errorcnt++;
3548 return 0;
3549 }
3550 return in;
3551}
3552
drhaf805ca2004-09-07 11:28:25 +00003553/* Print a #line directive line to the output file. */
icculus9e44cf12010-02-14 17:14:22 +00003554PRIVATE void tplt_linedir(FILE *out, int lineno, char *filename)
drhaf805ca2004-09-07 11:28:25 +00003555{
3556 fprintf(out,"#line %d \"",lineno);
3557 while( *filename ){
3558 if( *filename == '\\' ) putc('\\',out);
3559 putc(*filename,out);
3560 filename++;
3561 }
3562 fprintf(out,"\"\n");
3563}
3564
drh75897232000-05-29 14:26:00 +00003565/* Print a string to the file and keep the linenumber up to date */
icculus9e44cf12010-02-14 17:14:22 +00003566PRIVATE void tplt_print(FILE *out, struct lemon *lemp, char *str, int *lineno)
drh75897232000-05-29 14:26:00 +00003567{
3568 if( str==0 ) return;
drh75897232000-05-29 14:26:00 +00003569 while( *str ){
drh75897232000-05-29 14:26:00 +00003570 putc(*str,out);
shane58543932008-12-10 20:10:04 +00003571 if( *str=='\n' ) (*lineno)++;
drh75897232000-05-29 14:26:00 +00003572 str++;
3573 }
drh9db55df2004-09-09 14:01:21 +00003574 if( str[-1]!='\n' ){
3575 putc('\n',out);
3576 (*lineno)++;
3577 }
shane58543932008-12-10 20:10:04 +00003578 if (!lemp->nolinenosflag) {
drh06f60d82017-04-14 19:46:12 +00003579 (*lineno)++; tplt_linedir(out,*lineno,lemp->outname);
shane58543932008-12-10 20:10:04 +00003580 }
drh75897232000-05-29 14:26:00 +00003581 return;
3582}
3583
3584/*
3585** The following routine emits code for the destructor for the
3586** symbol sp
3587*/
icculus9e44cf12010-02-14 17:14:22 +00003588void emit_destructor_code(
3589 FILE *out,
3590 struct symbol *sp,
3591 struct lemon *lemp,
3592 int *lineno
3593){
drhcc83b6e2004-04-23 23:38:42 +00003594 char *cp = 0;
drh75897232000-05-29 14:26:00 +00003595
drh75897232000-05-29 14:26:00 +00003596 if( sp->type==TERMINAL ){
3597 cp = lemp->tokendest;
3598 if( cp==0 ) return;
drha5808f32008-04-27 22:19:44 +00003599 fprintf(out,"{\n"); (*lineno)++;
drh960e8c62001-04-03 16:53:21 +00003600 }else if( sp->destructor ){
drh75897232000-05-29 14:26:00 +00003601 cp = sp->destructor;
drha5808f32008-04-27 22:19:44 +00003602 fprintf(out,"{\n"); (*lineno)++;
drh25473362015-09-04 18:03:45 +00003603 if( !lemp->nolinenosflag ){
3604 (*lineno)++;
3605 tplt_linedir(out,sp->destLineno,lemp->filename);
3606 }
drh960e8c62001-04-03 16:53:21 +00003607 }else if( lemp->vardest ){
3608 cp = lemp->vardest;
3609 if( cp==0 ) return;
drha5808f32008-04-27 22:19:44 +00003610 fprintf(out,"{\n"); (*lineno)++;
drhcc83b6e2004-04-23 23:38:42 +00003611 }else{
3612 assert( 0 ); /* Cannot happen */
drh75897232000-05-29 14:26:00 +00003613 }
3614 for(; *cp; cp++){
3615 if( *cp=='$' && cp[1]=='$' ){
3616 fprintf(out,"(yypminor->yy%d)",sp->dtnum);
3617 cp++;
3618 continue;
3619 }
shane58543932008-12-10 20:10:04 +00003620 if( *cp=='\n' ) (*lineno)++;
drh75897232000-05-29 14:26:00 +00003621 fputc(*cp,out);
3622 }
shane58543932008-12-10 20:10:04 +00003623 fprintf(out,"\n"); (*lineno)++;
drh06f60d82017-04-14 19:46:12 +00003624 if (!lemp->nolinenosflag) {
3625 (*lineno)++; tplt_linedir(out,*lineno,lemp->outname);
shane58543932008-12-10 20:10:04 +00003626 }
3627 fprintf(out,"}\n"); (*lineno)++;
drh75897232000-05-29 14:26:00 +00003628 return;
3629}
3630
3631/*
drh960e8c62001-04-03 16:53:21 +00003632** Return TRUE (non-zero) if the given symbol has a destructor.
drh75897232000-05-29 14:26:00 +00003633*/
icculus9e44cf12010-02-14 17:14:22 +00003634int has_destructor(struct symbol *sp, struct lemon *lemp)
drh75897232000-05-29 14:26:00 +00003635{
3636 int ret;
3637 if( sp->type==TERMINAL ){
3638 ret = lemp->tokendest!=0;
3639 }else{
drh960e8c62001-04-03 16:53:21 +00003640 ret = lemp->vardest!=0 || sp->destructor!=0;
drh75897232000-05-29 14:26:00 +00003641 }
3642 return ret;
3643}
3644
drh0bb132b2004-07-20 14:06:51 +00003645/*
3646** Append text to a dynamically allocated string. If zText is 0 then
3647** reset the string to be empty again. Always return the complete text
3648** of the string (which is overwritten with each call).
drh7ac25c72004-08-19 15:12:26 +00003649**
3650** n bytes of zText are stored. If n==0 then all of zText up to the first
3651** \000 terminator is stored. zText can contain up to two instances of
3652** %d. The values of p1 and p2 are written into the first and second
3653** %d.
3654**
3655** If n==-1, then the previous character is overwritten.
drh0bb132b2004-07-20 14:06:51 +00003656*/
icculus9e44cf12010-02-14 17:14:22 +00003657PRIVATE char *append_str(const char *zText, int n, int p1, int p2){
3658 static char empty[1] = { 0 };
drh0bb132b2004-07-20 14:06:51 +00003659 static char *z = 0;
3660 static int alloced = 0;
3661 static int used = 0;
drhaf805ca2004-09-07 11:28:25 +00003662 int c;
drh0bb132b2004-07-20 14:06:51 +00003663 char zInt[40];
drh0bb132b2004-07-20 14:06:51 +00003664 if( zText==0 ){
drh4dd0d3f2016-02-17 01:18:33 +00003665 if( used==0 && z!=0 ) z[0] = 0;
drh0bb132b2004-07-20 14:06:51 +00003666 used = 0;
3667 return z;
3668 }
drh7ac25c72004-08-19 15:12:26 +00003669 if( n<=0 ){
3670 if( n<0 ){
3671 used += n;
3672 assert( used>=0 );
3673 }
drh87cf1372008-08-13 20:09:06 +00003674 n = lemonStrlen(zText);
drh7ac25c72004-08-19 15:12:26 +00003675 }
drhdf609712010-11-23 20:55:27 +00003676 if( (int) (n+sizeof(zInt)*2+used) >= alloced ){
drh0bb132b2004-07-20 14:06:51 +00003677 alloced = n + sizeof(zInt)*2 + used + 200;
icculus9e44cf12010-02-14 17:14:22 +00003678 z = (char *) realloc(z, alloced);
drh0bb132b2004-07-20 14:06:51 +00003679 }
icculus9e44cf12010-02-14 17:14:22 +00003680 if( z==0 ) return empty;
drh0bb132b2004-07-20 14:06:51 +00003681 while( n-- > 0 ){
3682 c = *(zText++);
drh50489622006-10-13 12:25:29 +00003683 if( c=='%' && n>0 && zText[0]=='d' ){
drh898799f2014-01-10 23:21:00 +00003684 lemon_sprintf(zInt, "%d", p1);
drh0bb132b2004-07-20 14:06:51 +00003685 p1 = p2;
drh898799f2014-01-10 23:21:00 +00003686 lemon_strcpy(&z[used], zInt);
drh87cf1372008-08-13 20:09:06 +00003687 used += lemonStrlen(&z[used]);
drh0bb132b2004-07-20 14:06:51 +00003688 zText++;
3689 n--;
3690 }else{
mistachkin2318d332015-01-12 18:02:52 +00003691 z[used++] = (char)c;
drh0bb132b2004-07-20 14:06:51 +00003692 }
3693 }
3694 z[used] = 0;
3695 return z;
3696}
3697
3698/*
drh711c9812016-05-23 14:24:31 +00003699** Write and transform the rp->code string so that symbols are expanded.
3700** Populate the rp->codePrefix and rp->codeSuffix strings, as appropriate.
drhdabd04c2016-02-17 01:46:19 +00003701**
3702** Return 1 if the expanded code requires that "yylhsminor" local variable
3703** to be defined.
drh0bb132b2004-07-20 14:06:51 +00003704*/
drhdabd04c2016-02-17 01:46:19 +00003705PRIVATE int translate_code(struct lemon *lemp, struct rule *rp){
drh0bb132b2004-07-20 14:06:51 +00003706 char *cp, *xp;
3707 int i;
drhcf82f0d2016-02-17 04:33:10 +00003708 int rc = 0; /* True if yylhsminor is used */
drh43303de2016-02-17 12:34:03 +00003709 int dontUseRhs0 = 0; /* If true, use of left-most RHS label is illegal */
drhcf82f0d2016-02-17 04:33:10 +00003710 const char *zSkip = 0; /* The zOvwrt comment within rp->code, or NULL */
3711 char lhsused = 0; /* True if the LHS element has been used */
3712 char lhsdirect; /* True if LHS writes directly into stack */
3713 char used[MAXRHS]; /* True for each RHS element which is used */
3714 char zLhs[50]; /* Convert the LHS symbol into this string */
3715 char zOvwrt[900]; /* Comment that to allow LHS to overwrite RHS */
drh0bb132b2004-07-20 14:06:51 +00003716
3717 for(i=0; i<rp->nrhs; i++) used[i] = 0;
3718 lhsused = 0;
3719
drh19c9e562007-03-29 20:13:53 +00003720 if( rp->code==0 ){
icculus9e44cf12010-02-14 17:14:22 +00003721 static char newlinestr[2] = { '\n', '\0' };
3722 rp->code = newlinestr;
drh19c9e562007-03-29 20:13:53 +00003723 rp->line = rp->ruleline;
drh711c9812016-05-23 14:24:31 +00003724 rp->noCode = 1;
3725 }else{
3726 rp->noCode = 0;
drh19c9e562007-03-29 20:13:53 +00003727 }
3728
drh4dd0d3f2016-02-17 01:18:33 +00003729
drh2e55b042016-04-30 17:19:30 +00003730 if( rp->nrhs==0 ){
drh4dd0d3f2016-02-17 01:18:33 +00003731 /* If there are no RHS symbols, then writing directly to the LHS is ok */
3732 lhsdirect = 1;
3733 }else if( rp->rhsalias[0]==0 ){
drh2e55b042016-04-30 17:19:30 +00003734 /* The left-most RHS symbol has no value. LHS direct is ok. But
drh4dd0d3f2016-02-17 01:18:33 +00003735 ** we have to call the distructor on the RHS symbol first. */
3736 lhsdirect = 1;
3737 if( has_destructor(rp->rhs[0],lemp) ){
3738 append_str(0,0,0,0);
3739 append_str(" yy_destructor(yypParser,%d,&yymsp[%d].minor);\n", 0,
3740 rp->rhs[0]->index,1-rp->nrhs);
3741 rp->codePrefix = Strsafe(append_str(0,0,0,0));
drh711c9812016-05-23 14:24:31 +00003742 rp->noCode = 0;
drh4dd0d3f2016-02-17 01:18:33 +00003743 }
drh2e55b042016-04-30 17:19:30 +00003744 }else if( rp->lhsalias==0 ){
3745 /* There is no LHS value symbol. */
3746 lhsdirect = 1;
drh4dd0d3f2016-02-17 01:18:33 +00003747 }else if( strcmp(rp->lhsalias,rp->rhsalias[0])==0 ){
drh06f60d82017-04-14 19:46:12 +00003748 /* The LHS symbol and the left-most RHS symbol are the same, so
drh4dd0d3f2016-02-17 01:18:33 +00003749 ** direct writing is allowed */
3750 lhsdirect = 1;
3751 lhsused = 1;
3752 used[0] = 1;
3753 if( rp->lhs->dtnum!=rp->rhs[0]->dtnum ){
3754 ErrorMsg(lemp->filename,rp->ruleline,
3755 "%s(%s) and %s(%s) share the same label but have "
3756 "different datatypes.",
3757 rp->lhs->name, rp->lhsalias, rp->rhs[0]->name, rp->rhsalias[0]);
3758 lemp->errorcnt++;
drh06f60d82017-04-14 19:46:12 +00003759 }
drh4dd0d3f2016-02-17 01:18:33 +00003760 }else{
drhcf82f0d2016-02-17 04:33:10 +00003761 lemon_sprintf(zOvwrt, "/*%s-overwrites-%s*/",
3762 rp->lhsalias, rp->rhsalias[0]);
3763 zSkip = strstr(rp->code, zOvwrt);
3764 if( zSkip!=0 ){
3765 /* The code contains a special comment that indicates that it is safe
3766 ** for the LHS label to overwrite left-most RHS label. */
3767 lhsdirect = 1;
3768 }else{
3769 lhsdirect = 0;
3770 }
drh4dd0d3f2016-02-17 01:18:33 +00003771 }
3772 if( lhsdirect ){
3773 sprintf(zLhs, "yymsp[%d].minor.yy%d",1-rp->nrhs,rp->lhs->dtnum);
3774 }else{
drhdabd04c2016-02-17 01:46:19 +00003775 rc = 1;
drh4dd0d3f2016-02-17 01:18:33 +00003776 sprintf(zLhs, "yylhsminor.yy%d",rp->lhs->dtnum);
3777 }
3778
drh0bb132b2004-07-20 14:06:51 +00003779 append_str(0,0,0,0);
icculus9e44cf12010-02-14 17:14:22 +00003780
3781 /* This const cast is wrong but harmless, if we're careful. */
3782 for(cp=(char *)rp->code; *cp; cp++){
drhcf82f0d2016-02-17 04:33:10 +00003783 if( cp==zSkip ){
3784 append_str(zOvwrt,0,0,0);
3785 cp += lemonStrlen(zOvwrt)-1;
drh43303de2016-02-17 12:34:03 +00003786 dontUseRhs0 = 1;
drhcf82f0d2016-02-17 04:33:10 +00003787 continue;
3788 }
drhc56fac72015-10-29 13:48:15 +00003789 if( ISALPHA(*cp) && (cp==rp->code || (!ISALNUM(cp[-1]) && cp[-1]!='_')) ){
drh0bb132b2004-07-20 14:06:51 +00003790 char saved;
drhc56fac72015-10-29 13:48:15 +00003791 for(xp= &cp[1]; ISALNUM(*xp) || *xp=='_'; xp++);
drh0bb132b2004-07-20 14:06:51 +00003792 saved = *xp;
3793 *xp = 0;
3794 if( rp->lhsalias && strcmp(cp,rp->lhsalias)==0 ){
drh4dd0d3f2016-02-17 01:18:33 +00003795 append_str(zLhs,0,0,0);
drh0bb132b2004-07-20 14:06:51 +00003796 cp = xp;
3797 lhsused = 1;
3798 }else{
3799 for(i=0; i<rp->nrhs; i++){
3800 if( rp->rhsalias[i] && strcmp(cp,rp->rhsalias[i])==0 ){
drh43303de2016-02-17 12:34:03 +00003801 if( i==0 && dontUseRhs0 ){
3802 ErrorMsg(lemp->filename,rp->ruleline,
3803 "Label %s used after '%s'.",
3804 rp->rhsalias[0], zOvwrt);
3805 lemp->errorcnt++;
3806 }else if( cp!=rp->code && cp[-1]=='@' ){
drh7ac25c72004-08-19 15:12:26 +00003807 /* If the argument is of the form @X then substituted
3808 ** the token number of X, not the value of X */
3809 append_str("yymsp[%d].major",-1,i-rp->nrhs+1,0);
3810 }else{
drhfd405312005-11-06 04:06:59 +00003811 struct symbol *sp = rp->rhs[i];
3812 int dtnum;
3813 if( sp->type==MULTITERMINAL ){
3814 dtnum = sp->subsym[0]->dtnum;
3815 }else{
3816 dtnum = sp->dtnum;
3817 }
3818 append_str("yymsp[%d].minor.yy%d",0,i-rp->nrhs+1, dtnum);
drh7ac25c72004-08-19 15:12:26 +00003819 }
drh0bb132b2004-07-20 14:06:51 +00003820 cp = xp;
3821 used[i] = 1;
3822 break;
3823 }
3824 }
3825 }
3826 *xp = saved;
3827 }
3828 append_str(cp, 1, 0, 0);
3829 } /* End loop */
3830
drh4dd0d3f2016-02-17 01:18:33 +00003831 /* Main code generation completed */
3832 cp = append_str(0,0,0,0);
3833 if( cp && cp[0] ) rp->code = Strsafe(cp);
3834 append_str(0,0,0,0);
3835
drh0bb132b2004-07-20 14:06:51 +00003836 /* Check to make sure the LHS has been used */
3837 if( rp->lhsalias && !lhsused ){
3838 ErrorMsg(lemp->filename,rp->ruleline,
3839 "Label \"%s\" for \"%s(%s)\" is never used.",
3840 rp->lhsalias,rp->lhs->name,rp->lhsalias);
3841 lemp->errorcnt++;
3842 }
3843
drh4dd0d3f2016-02-17 01:18:33 +00003844 /* Generate destructor code for RHS minor values which are not referenced.
3845 ** Generate error messages for unused labels and duplicate labels.
3846 */
drh0bb132b2004-07-20 14:06:51 +00003847 for(i=0; i<rp->nrhs; i++){
drh4dd0d3f2016-02-17 01:18:33 +00003848 if( rp->rhsalias[i] ){
3849 if( i>0 ){
3850 int j;
3851 if( rp->lhsalias && strcmp(rp->lhsalias,rp->rhsalias[i])==0 ){
3852 ErrorMsg(lemp->filename,rp->ruleline,
3853 "%s(%s) has the same label as the LHS but is not the left-most "
3854 "symbol on the RHS.",
drhf135cb72019-04-30 14:26:31 +00003855 rp->rhs[i]->name, rp->rhsalias[i]);
drh4dd0d3f2016-02-17 01:18:33 +00003856 lemp->errorcnt++;
3857 }
3858 for(j=0; j<i; j++){
3859 if( rp->rhsalias[j] && strcmp(rp->rhsalias[j],rp->rhsalias[i])==0 ){
3860 ErrorMsg(lemp->filename,rp->ruleline,
3861 "Label %s used for multiple symbols on the RHS of a rule.",
3862 rp->rhsalias[i]);
3863 lemp->errorcnt++;
3864 break;
3865 }
3866 }
drh0bb132b2004-07-20 14:06:51 +00003867 }
drh4dd0d3f2016-02-17 01:18:33 +00003868 if( !used[i] ){
3869 ErrorMsg(lemp->filename,rp->ruleline,
3870 "Label %s for \"%s(%s)\" is never used.",
3871 rp->rhsalias[i],rp->rhs[i]->name,rp->rhsalias[i]);
3872 lemp->errorcnt++;
3873 }
3874 }else if( i>0 && has_destructor(rp->rhs[i],lemp) ){
3875 append_str(" yy_destructor(yypParser,%d,&yymsp[%d].minor);\n", 0,
3876 rp->rhs[i]->index,i-rp->nrhs+1);
drh0bb132b2004-07-20 14:06:51 +00003877 }
3878 }
drh4dd0d3f2016-02-17 01:18:33 +00003879
3880 /* If unable to write LHS values directly into the stack, write the
3881 ** saved LHS value now. */
3882 if( lhsdirect==0 ){
3883 append_str(" yymsp[%d].minor.yy%d = ", 0, 1-rp->nrhs, rp->lhs->dtnum);
3884 append_str(zLhs, 0, 0, 0);
3885 append_str(";\n", 0, 0, 0);
drh61e339a2007-01-16 03:09:02 +00003886 }
drh4dd0d3f2016-02-17 01:18:33 +00003887
3888 /* Suffix code generation complete */
3889 cp = append_str(0,0,0,0);
drh711c9812016-05-23 14:24:31 +00003890 if( cp && cp[0] ){
3891 rp->codeSuffix = Strsafe(cp);
3892 rp->noCode = 0;
3893 }
drhdabd04c2016-02-17 01:46:19 +00003894
3895 return rc;
drh0bb132b2004-07-20 14:06:51 +00003896}
3897
drh06f60d82017-04-14 19:46:12 +00003898/*
drh75897232000-05-29 14:26:00 +00003899** Generate code which executes when the rule "rp" is reduced. Write
3900** the code to "out". Make sure lineno stays up-to-date.
3901*/
icculus9e44cf12010-02-14 17:14:22 +00003902PRIVATE void emit_code(
3903 FILE *out,
3904 struct rule *rp,
3905 struct lemon *lemp,
3906 int *lineno
3907){
3908 const char *cp;
drh75897232000-05-29 14:26:00 +00003909
drh4dd0d3f2016-02-17 01:18:33 +00003910 /* Setup code prior to the #line directive */
3911 if( rp->codePrefix && rp->codePrefix[0] ){
3912 fprintf(out, "{%s", rp->codePrefix);
3913 for(cp=rp->codePrefix; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
3914 }
3915
drh75897232000-05-29 14:26:00 +00003916 /* Generate code to do the reduce action */
3917 if( rp->code ){
drh25473362015-09-04 18:03:45 +00003918 if( !lemp->nolinenosflag ){
3919 (*lineno)++;
3920 tplt_linedir(out,rp->line,lemp->filename);
3921 }
drhaf805ca2004-09-07 11:28:25 +00003922 fprintf(out,"{%s",rp->code);
drh4dd0d3f2016-02-17 01:18:33 +00003923 for(cp=rp->code; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
shane58543932008-12-10 20:10:04 +00003924 fprintf(out,"}\n"); (*lineno)++;
drh25473362015-09-04 18:03:45 +00003925 if( !lemp->nolinenosflag ){
3926 (*lineno)++;
3927 tplt_linedir(out,*lineno,lemp->outname);
3928 }
drh4dd0d3f2016-02-17 01:18:33 +00003929 }
3930
3931 /* Generate breakdown code that occurs after the #line directive */
3932 if( rp->codeSuffix && rp->codeSuffix[0] ){
3933 fprintf(out, "%s", rp->codeSuffix);
3934 for(cp=rp->codeSuffix; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
3935 }
3936
3937 if( rp->codePrefix ){
3938 fprintf(out, "}\n"); (*lineno)++;
3939 }
drh75897232000-05-29 14:26:00 +00003940
drh75897232000-05-29 14:26:00 +00003941 return;
3942}
3943
3944/*
3945** Print the definition of the union used for the parser's data stack.
3946** This union contains fields for every possible data type for tokens
3947** and nonterminals. In the process of computing and printing this
3948** union, also set the ".dtnum" field of every terminal and nonterminal
3949** symbol.
3950*/
icculus9e44cf12010-02-14 17:14:22 +00003951void print_stack_union(
3952 FILE *out, /* The output stream */
3953 struct lemon *lemp, /* The main info structure for this parser */
3954 int *plineno, /* Pointer to the line number */
3955 int mhflag /* True if generating makeheaders output */
3956){
drh75897232000-05-29 14:26:00 +00003957 int lineno = *plineno; /* The line number of the output */
3958 char **types; /* A hash table of datatypes */
3959 int arraysize; /* Size of the "types" array */
3960 int maxdtlength; /* Maximum length of any ".datatype" field. */
3961 char *stddt; /* Standardized name for a datatype */
3962 int i,j; /* Loop counters */
drh01f75f22013-10-02 20:46:30 +00003963 unsigned hash; /* For hashing the name of a type */
icculus9e44cf12010-02-14 17:14:22 +00003964 const char *name; /* Name of the parser */
drh75897232000-05-29 14:26:00 +00003965
3966 /* Allocate and initialize types[] and allocate stddt[] */
3967 arraysize = lemp->nsymbol * 2;
drh9892c5d2007-12-21 00:02:11 +00003968 types = (char**)calloc( arraysize, sizeof(char*) );
drh070d4222011-06-02 15:48:51 +00003969 if( types==0 ){
3970 fprintf(stderr,"Out of memory.\n");
3971 exit(1);
3972 }
drh75897232000-05-29 14:26:00 +00003973 for(i=0; i<arraysize; i++) types[i] = 0;
3974 maxdtlength = 0;
drh960e8c62001-04-03 16:53:21 +00003975 if( lemp->vartype ){
drh87cf1372008-08-13 20:09:06 +00003976 maxdtlength = lemonStrlen(lemp->vartype);
drh960e8c62001-04-03 16:53:21 +00003977 }
drh75897232000-05-29 14:26:00 +00003978 for(i=0; i<lemp->nsymbol; i++){
3979 int len;
3980 struct symbol *sp = lemp->symbols[i];
3981 if( sp->datatype==0 ) continue;
drh87cf1372008-08-13 20:09:06 +00003982 len = lemonStrlen(sp->datatype);
drh75897232000-05-29 14:26:00 +00003983 if( len>maxdtlength ) maxdtlength = len;
3984 }
3985 stddt = (char*)malloc( maxdtlength*2 + 1 );
drh070d4222011-06-02 15:48:51 +00003986 if( stddt==0 ){
drh75897232000-05-29 14:26:00 +00003987 fprintf(stderr,"Out of memory.\n");
3988 exit(1);
3989 }
3990
3991 /* Build a hash table of datatypes. The ".dtnum" field of each symbol
3992 ** is filled in with the hash index plus 1. A ".dtnum" value of 0 is
drh960e8c62001-04-03 16:53:21 +00003993 ** used for terminal symbols. If there is no %default_type defined then
3994 ** 0 is also used as the .dtnum value for nonterminals which do not specify
3995 ** a datatype using the %type directive.
3996 */
drh75897232000-05-29 14:26:00 +00003997 for(i=0; i<lemp->nsymbol; i++){
3998 struct symbol *sp = lemp->symbols[i];
3999 char *cp;
4000 if( sp==lemp->errsym ){
4001 sp->dtnum = arraysize+1;
4002 continue;
4003 }
drh960e8c62001-04-03 16:53:21 +00004004 if( sp->type!=NONTERMINAL || (sp->datatype==0 && lemp->vartype==0) ){
drh75897232000-05-29 14:26:00 +00004005 sp->dtnum = 0;
4006 continue;
4007 }
4008 cp = sp->datatype;
drh960e8c62001-04-03 16:53:21 +00004009 if( cp==0 ) cp = lemp->vartype;
drh75897232000-05-29 14:26:00 +00004010 j = 0;
drhc56fac72015-10-29 13:48:15 +00004011 while( ISSPACE(*cp) ) cp++;
drh75897232000-05-29 14:26:00 +00004012 while( *cp ) stddt[j++] = *cp++;
drhc56fac72015-10-29 13:48:15 +00004013 while( j>0 && ISSPACE(stddt[j-1]) ) j--;
drh75897232000-05-29 14:26:00 +00004014 stddt[j] = 0;
drh02368c92009-04-05 15:18:02 +00004015 if( lemp->tokentype && strcmp(stddt, lemp->tokentype)==0 ){
drh32c4d742008-07-01 16:34:49 +00004016 sp->dtnum = 0;
4017 continue;
4018 }
drh75897232000-05-29 14:26:00 +00004019 hash = 0;
4020 for(j=0; stddt[j]; j++){
4021 hash = hash*53 + stddt[j];
4022 }
drh3b2129c2003-05-13 00:34:21 +00004023 hash = (hash & 0x7fffffff)%arraysize;
drh75897232000-05-29 14:26:00 +00004024 while( types[hash] ){
4025 if( strcmp(types[hash],stddt)==0 ){
4026 sp->dtnum = hash + 1;
4027 break;
4028 }
4029 hash++;
drh2b51f212013-10-11 23:01:02 +00004030 if( hash>=(unsigned)arraysize ) hash = 0;
drh75897232000-05-29 14:26:00 +00004031 }
4032 if( types[hash]==0 ){
4033 sp->dtnum = hash + 1;
drh87cf1372008-08-13 20:09:06 +00004034 types[hash] = (char*)malloc( lemonStrlen(stddt)+1 );
drh75897232000-05-29 14:26:00 +00004035 if( types[hash]==0 ){
4036 fprintf(stderr,"Out of memory.\n");
4037 exit(1);
4038 }
drh898799f2014-01-10 23:21:00 +00004039 lemon_strcpy(types[hash],stddt);
drh75897232000-05-29 14:26:00 +00004040 }
4041 }
4042
4043 /* Print out the definition of YYTOKENTYPE and YYMINORTYPE */
4044 name = lemp->name ? lemp->name : "Parse";
4045 lineno = *plineno;
4046 if( mhflag ){ fprintf(out,"#if INTERFACE\n"); lineno++; }
4047 fprintf(out,"#define %sTOKENTYPE %s\n",name,
4048 lemp->tokentype?lemp->tokentype:"void*"); lineno++;
4049 if( mhflag ){ fprintf(out,"#endif\n"); lineno++; }
4050 fprintf(out,"typedef union {\n"); lineno++;
drh15b024c2008-12-11 02:20:43 +00004051 fprintf(out," int yyinit;\n"); lineno++;
drh75897232000-05-29 14:26:00 +00004052 fprintf(out," %sTOKENTYPE yy0;\n",name); lineno++;
4053 for(i=0; i<arraysize; i++){
4054 if( types[i]==0 ) continue;
4055 fprintf(out," %s yy%d;\n",types[i],i+1); lineno++;
4056 free(types[i]);
4057 }
drhed0c15b2018-04-16 14:31:34 +00004058 if( lemp->errsym && lemp->errsym->useCnt ){
drhc4dd3fd2008-01-22 01:48:05 +00004059 fprintf(out," int yy%d;\n",lemp->errsym->dtnum); lineno++;
4060 }
drh75897232000-05-29 14:26:00 +00004061 free(stddt);
4062 free(types);
4063 fprintf(out,"} YYMINORTYPE;\n"); lineno++;
4064 *plineno = lineno;
4065}
4066
drhb29b0a52002-02-23 19:39:46 +00004067/*
4068** Return the name of a C datatype able to represent values between
drhc75e0162015-09-07 02:23:02 +00004069** lwr and upr, inclusive. If pnByte!=NULL then also write the sizeof
4070** for that type (1, 2, or 4) into *pnByte.
drhb29b0a52002-02-23 19:39:46 +00004071*/
drhc75e0162015-09-07 02:23:02 +00004072static const char *minimum_size_type(int lwr, int upr, int *pnByte){
4073 const char *zType = "int";
4074 int nByte = 4;
drh8b582012003-10-21 13:16:03 +00004075 if( lwr>=0 ){
4076 if( upr<=255 ){
drhc75e0162015-09-07 02:23:02 +00004077 zType = "unsigned char";
4078 nByte = 1;
drh8b582012003-10-21 13:16:03 +00004079 }else if( upr<65535 ){
drhc75e0162015-09-07 02:23:02 +00004080 zType = "unsigned short int";
4081 nByte = 2;
drh8b582012003-10-21 13:16:03 +00004082 }else{
drhc75e0162015-09-07 02:23:02 +00004083 zType = "unsigned int";
4084 nByte = 4;
drh8b582012003-10-21 13:16:03 +00004085 }
4086 }else if( lwr>=-127 && upr<=127 ){
drhc75e0162015-09-07 02:23:02 +00004087 zType = "signed char";
4088 nByte = 1;
drh8b582012003-10-21 13:16:03 +00004089 }else if( lwr>=-32767 && upr<32767 ){
drhc75e0162015-09-07 02:23:02 +00004090 zType = "short";
4091 nByte = 2;
drhb29b0a52002-02-23 19:39:46 +00004092 }
drhc75e0162015-09-07 02:23:02 +00004093 if( pnByte ) *pnByte = nByte;
4094 return zType;
drhb29b0a52002-02-23 19:39:46 +00004095}
4096
drhfdbf9282003-10-21 16:34:41 +00004097/*
4098** Each state contains a set of token transaction and a set of
4099** nonterminal transactions. Each of these sets makes an instance
4100** of the following structure. An array of these structures is used
4101** to order the creation of entries in the yy_action[] table.
4102*/
4103struct axset {
4104 struct state *stp; /* A pointer to a state */
4105 int isTkn; /* True to use tokens. False for non-terminals */
4106 int nAction; /* Number of actions */
drhe594bc32009-11-03 13:02:25 +00004107 int iOrder; /* Original order of action sets */
drhfdbf9282003-10-21 16:34:41 +00004108};
4109
4110/*
4111** Compare to axset structures for sorting purposes
4112*/
4113static int axset_compare(const void *a, const void *b){
4114 struct axset *p1 = (struct axset*)a;
4115 struct axset *p2 = (struct axset*)b;
drhe594bc32009-11-03 13:02:25 +00004116 int c;
4117 c = p2->nAction - p1->nAction;
4118 if( c==0 ){
drh337cd0d2015-09-07 23:40:42 +00004119 c = p1->iOrder - p2->iOrder;
drhe594bc32009-11-03 13:02:25 +00004120 }
4121 assert( c!=0 || p1==p2 );
4122 return c;
drhfdbf9282003-10-21 16:34:41 +00004123}
4124
drhc4dd3fd2008-01-22 01:48:05 +00004125/*
4126** Write text on "out" that describes the rule "rp".
4127*/
4128static void writeRuleText(FILE *out, struct rule *rp){
4129 int j;
4130 fprintf(out,"%s ::=", rp->lhs->name);
4131 for(j=0; j<rp->nrhs; j++){
4132 struct symbol *sp = rp->rhs[j];
drh61f92cd2014-01-11 03:06:18 +00004133 if( sp->type!=MULTITERMINAL ){
4134 fprintf(out," %s", sp->name);
4135 }else{
drhc4dd3fd2008-01-22 01:48:05 +00004136 int k;
drh61f92cd2014-01-11 03:06:18 +00004137 fprintf(out," %s", sp->subsym[0]->name);
drhc4dd3fd2008-01-22 01:48:05 +00004138 for(k=1; k<sp->nsubsym; k++){
4139 fprintf(out,"|%s",sp->subsym[k]->name);
4140 }
4141 }
4142 }
4143}
4144
4145
drh75897232000-05-29 14:26:00 +00004146/* Generate C source code for the parser */
icculus9e44cf12010-02-14 17:14:22 +00004147void ReportTable(
4148 struct lemon *lemp,
drhfe03dac2019-11-26 02:22:39 +00004149 int mhflag, /* Output in makeheaders format if true */
4150 int sqlFlag /* Generate the *.sql file too */
icculus9e44cf12010-02-14 17:14:22 +00004151){
drhfe03dac2019-11-26 02:22:39 +00004152 FILE *out, *in, *sql;
drh75897232000-05-29 14:26:00 +00004153 char line[LINESIZE];
4154 int lineno;
4155 struct state *stp;
4156 struct action *ap;
4157 struct rule *rp;
drh8b582012003-10-21 13:16:03 +00004158 struct acttab *pActtab;
drhc75e0162015-09-07 02:23:02 +00004159 int i, j, n, sz;
drh2e517162019-08-28 02:09:47 +00004160 int nLookAhead;
drhc75e0162015-09-07 02:23:02 +00004161 int szActionType; /* sizeof(YYACTIONTYPE) */
4162 int szCodeType; /* sizeof(YYCODETYPE) */
icculus9e44cf12010-02-14 17:14:22 +00004163 const char *name;
drh8b582012003-10-21 13:16:03 +00004164 int mnTknOfst, mxTknOfst;
4165 int mnNtOfst, mxNtOfst;
drhfdbf9282003-10-21 16:34:41 +00004166 struct axset *ax;
drh75897232000-05-29 14:26:00 +00004167
drh5c8241b2017-12-24 23:38:10 +00004168 lemp->minShiftReduce = lemp->nstate;
4169 lemp->errAction = lemp->minShiftReduce + lemp->nrule;
4170 lemp->accAction = lemp->errAction + 1;
4171 lemp->noAction = lemp->accAction + 1;
4172 lemp->minReduce = lemp->noAction + 1;
4173 lemp->maxAction = lemp->minReduce + lemp->nrule;
4174
drh75897232000-05-29 14:26:00 +00004175 in = tplt_open(lemp);
4176 if( in==0 ) return;
drh2aa6ca42004-09-10 00:14:04 +00004177 out = file_open(lemp,".c","wb");
drh75897232000-05-29 14:26:00 +00004178 if( out==0 ){
4179 fclose(in);
4180 return;
4181 }
drhfe03dac2019-11-26 02:22:39 +00004182 if( sqlFlag==0 ){
4183 sql = 0;
4184 }else{
4185 sql = file_open(lemp, ".sql", "wb");
4186 if( sql==0 ){
4187 fclose(in);
4188 fclose(out);
4189 return;
4190 }
4191 fprintf(sql,
drh1417c2f2019-11-29 12:51:00 +00004192 "BEGIN;\n"
drhfe03dac2019-11-26 02:22:39 +00004193 "CREATE TABLE symbol(\n"
4194 " id INTEGER PRIMARY KEY,\n"
4195 " name TEXT NOT NULL,\n"
4196 " isTerminal BOOLEAN NOT NULL,\n"
drh1417c2f2019-11-29 12:51:00 +00004197 " fallback INTEGER REFERENCES symbol"
4198 " DEFERRABLE INITIALLY DEFERRED\n"
drhfe03dac2019-11-26 02:22:39 +00004199 ");\n"
4200 );
4201 for(i=0; i<lemp->nsymbol; i++){
4202 fprintf(sql,
4203 "INSERT INTO symbol(id,name,isTerminal,fallback)"
4204 "VALUES(%d,'%s',%s",
4205 i, lemp->symbols[i]->name,
4206 i<lemp->nterminal ? "TRUE" : "FALSE"
4207 );
4208 if( lemp->symbols[i]->fallback ){
4209 fprintf(sql, ",%d);\n", lemp->symbols[i]->fallback->index);
4210 }else{
4211 fprintf(sql, ",NULL);\n");
4212 }
4213 }
4214 fprintf(sql,
4215 "CREATE TABLE rule(\n"
4216 " ruleid INTEGER PRIMARY KEY,\n"
4217 " lhs INTEGER REFERENCES symbol(id)\n"
4218 ");\n"
4219 "CREATE TABLE rulerhs(\n"
4220 " ruleid INTEGER REFERENCES rule(ruleid),\n"
4221 " pos INTEGER,\n"
4222 " sym INTEGER REFERENCES symbol(id)\n"
4223 ");\n"
4224 );
4225 for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){
4226 assert( i==rp->iRule );
drh61cb4ed2019-11-29 13:01:57 +00004227 fprintf(sql, "-- ");
4228 writeRuleText(sql, rp);
4229 fprintf(sql, "\n");
drhfe03dac2019-11-26 02:22:39 +00004230 fprintf(sql,
4231 "INSERT INTO rule(ruleid,lhs)VALUES(%d,%d);\n",
4232 rp->iRule, rp->lhs->index
4233 );
4234 for(j=0; j<rp->nrhs; j++){
4235 struct symbol *sp = rp->rhs[j];
4236 if( sp->type!=MULTITERMINAL ){
4237 fprintf(sql,
4238 "INSERT INTO rulerhs(ruleid,pos,sym)VALUES(%d,%d,%d);\n",
4239 i,j,sp->index
4240 );
4241 }else{
4242 int k;
4243 for(k=0; k<sp->nsubsym; k++){
4244 fprintf(sql,
4245 "INSERT INTO rulerhs(ruleid,pos,sym)VALUES(%d,%d,%d);\n",
4246 i,j,sp->subsym[k]->index
4247 );
4248 }
4249 }
4250 }
4251 }
drh1417c2f2019-11-29 12:51:00 +00004252 fprintf(sql, "COMMIT;\n");
drhfe03dac2019-11-26 02:22:39 +00004253 }
drh75897232000-05-29 14:26:00 +00004254 lineno = 1;
4255 tplt_xfer(lemp->name,in,out,&lineno);
4256
4257 /* Generate the include code, if any */
drha5808f32008-04-27 22:19:44 +00004258 tplt_print(out,lemp,lemp->include,&lineno);
drh75897232000-05-29 14:26:00 +00004259 if( mhflag ){
mistachkin8e189222015-04-19 21:43:16 +00004260 char *incName = file_makename(lemp, ".h");
4261 fprintf(out,"#include \"%s\"\n", incName); lineno++;
4262 free(incName);
drh75897232000-05-29 14:26:00 +00004263 }
4264 tplt_xfer(lemp->name,in,out,&lineno);
4265
4266 /* Generate #defines for all tokens */
4267 if( mhflag ){
icculus9e44cf12010-02-14 17:14:22 +00004268 const char *prefix;
drh75897232000-05-29 14:26:00 +00004269 fprintf(out,"#if INTERFACE\n"); lineno++;
4270 if( lemp->tokenprefix ) prefix = lemp->tokenprefix;
4271 else prefix = "";
4272 for(i=1; i<lemp->nterminal; i++){
4273 fprintf(out,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i);
4274 lineno++;
4275 }
4276 fprintf(out,"#endif\n"); lineno++;
4277 }
4278 tplt_xfer(lemp->name,in,out,&lineno);
4279
4280 /* Generate the defines */
drh75897232000-05-29 14:26:00 +00004281 fprintf(out,"#define YYCODETYPE %s\n",
drhed0c15b2018-04-16 14:31:34 +00004282 minimum_size_type(0, lemp->nsymbol, &szCodeType)); lineno++;
4283 fprintf(out,"#define YYNOCODE %d\n",lemp->nsymbol); lineno++;
drh75897232000-05-29 14:26:00 +00004284 fprintf(out,"#define YYACTIONTYPE %s\n",
drh5c8241b2017-12-24 23:38:10 +00004285 minimum_size_type(0,lemp->maxAction,&szActionType)); lineno++;
drhe09daa92006-06-10 13:29:31 +00004286 if( lemp->wildcard ){
4287 fprintf(out,"#define YYWILDCARD %d\n",
4288 lemp->wildcard->index); lineno++;
4289 }
drh75897232000-05-29 14:26:00 +00004290 print_stack_union(out,lemp,&lineno,mhflag);
drhca44b5a2007-02-22 23:06:58 +00004291 fprintf(out, "#ifndef YYSTACKDEPTH\n"); lineno++;
drh75897232000-05-29 14:26:00 +00004292 if( lemp->stacksize ){
drh75897232000-05-29 14:26:00 +00004293 fprintf(out,"#define YYSTACKDEPTH %s\n",lemp->stacksize); lineno++;
4294 }else{
4295 fprintf(out,"#define YYSTACKDEPTH 100\n"); lineno++;
4296 }
drhca44b5a2007-02-22 23:06:58 +00004297 fprintf(out, "#endif\n"); lineno++;
drh75897232000-05-29 14:26:00 +00004298 if( mhflag ){
4299 fprintf(out,"#if INTERFACE\n"); lineno++;
4300 }
4301 name = lemp->name ? lemp->name : "Parse";
4302 if( lemp->arg && lemp->arg[0] ){
drh87cf1372008-08-13 20:09:06 +00004303 i = lemonStrlen(lemp->arg);
drhc56fac72015-10-29 13:48:15 +00004304 while( i>=1 && ISSPACE(lemp->arg[i-1]) ) i--;
4305 while( i>=1 && (ISALNUM(lemp->arg[i-1]) || lemp->arg[i-1]=='_') ) i--;
drh1f245e42002-03-11 13:55:50 +00004306 fprintf(out,"#define %sARG_SDECL %s;\n",name,lemp->arg); lineno++;
4307 fprintf(out,"#define %sARG_PDECL ,%s\n",name,lemp->arg); lineno++;
drhfb32c442018-04-21 13:51:42 +00004308 fprintf(out,"#define %sARG_PARAM ,%s\n",name,&lemp->arg[i]); lineno++;
4309 fprintf(out,"#define %sARG_FETCH %s=yypParser->%s;\n",
drh1f245e42002-03-11 13:55:50 +00004310 name,lemp->arg,&lemp->arg[i]); lineno++;
drhfb32c442018-04-21 13:51:42 +00004311 fprintf(out,"#define %sARG_STORE yypParser->%s=%s;\n",
drh1f245e42002-03-11 13:55:50 +00004312 name,&lemp->arg[i],&lemp->arg[i]); lineno++;
drh75897232000-05-29 14:26:00 +00004313 }else{
drhfb32c442018-04-21 13:51:42 +00004314 fprintf(out,"#define %sARG_SDECL\n",name); lineno++;
4315 fprintf(out,"#define %sARG_PDECL\n",name); lineno++;
4316 fprintf(out,"#define %sARG_PARAM\n",name); lineno++;
drh1f245e42002-03-11 13:55:50 +00004317 fprintf(out,"#define %sARG_FETCH\n",name); lineno++;
4318 fprintf(out,"#define %sARG_STORE\n",name); lineno++;
drh75897232000-05-29 14:26:00 +00004319 }
drhfb32c442018-04-21 13:51:42 +00004320 if( lemp->ctx && lemp->ctx[0] ){
4321 i = lemonStrlen(lemp->ctx);
4322 while( i>=1 && ISSPACE(lemp->ctx[i-1]) ) i--;
4323 while( i>=1 && (ISALNUM(lemp->ctx[i-1]) || lemp->ctx[i-1]=='_') ) i--;
4324 fprintf(out,"#define %sCTX_SDECL %s;\n",name,lemp->ctx); lineno++;
4325 fprintf(out,"#define %sCTX_PDECL ,%s\n",name,lemp->ctx); lineno++;
4326 fprintf(out,"#define %sCTX_PARAM ,%s\n",name,&lemp->ctx[i]); lineno++;
4327 fprintf(out,"#define %sCTX_FETCH %s=yypParser->%s;\n",
4328 name,lemp->ctx,&lemp->ctx[i]); lineno++;
4329 fprintf(out,"#define %sCTX_STORE yypParser->%s=%s;\n",
4330 name,&lemp->ctx[i],&lemp->ctx[i]); lineno++;
4331 }else{
4332 fprintf(out,"#define %sCTX_SDECL\n",name); lineno++;
4333 fprintf(out,"#define %sCTX_PDECL\n",name); lineno++;
4334 fprintf(out,"#define %sCTX_PARAM\n",name); lineno++;
4335 fprintf(out,"#define %sCTX_FETCH\n",name); lineno++;
4336 fprintf(out,"#define %sCTX_STORE\n",name); lineno++;
4337 }
drh75897232000-05-29 14:26:00 +00004338 if( mhflag ){
4339 fprintf(out,"#endif\n"); lineno++;
4340 }
drhed0c15b2018-04-16 14:31:34 +00004341 if( lemp->errsym && lemp->errsym->useCnt ){
drh3bd48ab2015-09-07 18:23:37 +00004342 fprintf(out,"#define YYERRORSYMBOL %d\n",lemp->errsym->index); lineno++;
4343 fprintf(out,"#define YYERRSYMDT yy%d\n",lemp->errsym->dtnum); lineno++;
drhc4dd3fd2008-01-22 01:48:05 +00004344 }
drh0bd1f4e2002-06-06 18:54:39 +00004345 if( lemp->has_fallback ){
4346 fprintf(out,"#define YYFALLBACK 1\n"); lineno++;
4347 }
drh75897232000-05-29 14:26:00 +00004348
drh3bd48ab2015-09-07 18:23:37 +00004349 /* Compute the action table, but do not output it yet. The action
4350 ** table must be computed before generating the YYNSTATE macro because
4351 ** we need to know how many states can be eliminated.
drh75897232000-05-29 14:26:00 +00004352 */
drh3bd48ab2015-09-07 18:23:37 +00004353 ax = (struct axset *) calloc(lemp->nxstate*2, sizeof(ax[0]));
drhfdbf9282003-10-21 16:34:41 +00004354 if( ax==0 ){
4355 fprintf(stderr,"malloc failed\n");
4356 exit(1);
4357 }
drh3bd48ab2015-09-07 18:23:37 +00004358 for(i=0; i<lemp->nxstate; i++){
drh75897232000-05-29 14:26:00 +00004359 stp = lemp->sorted[i];
drhfdbf9282003-10-21 16:34:41 +00004360 ax[i*2].stp = stp;
4361 ax[i*2].isTkn = 1;
4362 ax[i*2].nAction = stp->nTknAct;
4363 ax[i*2+1].stp = stp;
4364 ax[i*2+1].isTkn = 0;
4365 ax[i*2+1].nAction = stp->nNtAct;
drh75897232000-05-29 14:26:00 +00004366 }
drh8b582012003-10-21 13:16:03 +00004367 mxTknOfst = mnTknOfst = 0;
4368 mxNtOfst = mnNtOfst = 0;
drh3bd48ab2015-09-07 18:23:37 +00004369 /* In an effort to minimize the action table size, use the heuristic
4370 ** of placing the largest action sets first */
4371 for(i=0; i<lemp->nxstate*2; i++) ax[i].iOrder = i;
4372 qsort(ax, lemp->nxstate*2, sizeof(ax[0]), axset_compare);
drh3a9d6c72017-12-25 04:15:38 +00004373 pActtab = acttab_alloc(lemp->nsymbol, lemp->nterminal);
drh3bd48ab2015-09-07 18:23:37 +00004374 for(i=0; i<lemp->nxstate*2 && ax[i].nAction>0; i++){
drhfdbf9282003-10-21 16:34:41 +00004375 stp = ax[i].stp;
4376 if( ax[i].isTkn ){
4377 for(ap=stp->ap; ap; ap=ap->next){
4378 int action;
4379 if( ap->sp->index>=lemp->nterminal ) continue;
4380 action = compute_action(lemp, ap);
4381 if( action<0 ) continue;
4382 acttab_action(pActtab, ap->sp->index, action);
drh8b582012003-10-21 13:16:03 +00004383 }
drh3a9d6c72017-12-25 04:15:38 +00004384 stp->iTknOfst = acttab_insert(pActtab, 1);
drhfdbf9282003-10-21 16:34:41 +00004385 if( stp->iTknOfst<mnTknOfst ) mnTknOfst = stp->iTknOfst;
4386 if( stp->iTknOfst>mxTknOfst ) mxTknOfst = stp->iTknOfst;
4387 }else{
4388 for(ap=stp->ap; ap; ap=ap->next){
4389 int action;
4390 if( ap->sp->index<lemp->nterminal ) continue;
4391 if( ap->sp->index==lemp->nsymbol ) continue;
4392 action = compute_action(lemp, ap);
4393 if( action<0 ) continue;
4394 acttab_action(pActtab, ap->sp->index, action);
drh8b582012003-10-21 13:16:03 +00004395 }
drh3a9d6c72017-12-25 04:15:38 +00004396 stp->iNtOfst = acttab_insert(pActtab, 0);
drhfdbf9282003-10-21 16:34:41 +00004397 if( stp->iNtOfst<mnNtOfst ) mnNtOfst = stp->iNtOfst;
4398 if( stp->iNtOfst>mxNtOfst ) mxNtOfst = stp->iNtOfst;
drh8b582012003-10-21 13:16:03 +00004399 }
drh337cd0d2015-09-07 23:40:42 +00004400#if 0 /* Uncomment for a trace of how the yy_action[] table fills out */
4401 { int jj, nn;
4402 for(jj=nn=0; jj<pActtab->nAction; jj++){
4403 if( pActtab->aAction[jj].action<0 ) nn++;
4404 }
4405 printf("%4d: State %3d %s n: %2d size: %5d freespace: %d\n",
4406 i, stp->statenum, ax[i].isTkn ? "Token" : "Var ",
4407 ax[i].nAction, pActtab->nAction, nn);
4408 }
4409#endif
drh8b582012003-10-21 13:16:03 +00004410 }
drhfdbf9282003-10-21 16:34:41 +00004411 free(ax);
drh8b582012003-10-21 13:16:03 +00004412
drh756b41e2016-05-24 18:55:08 +00004413 /* Mark rules that are actually used for reduce actions after all
4414 ** optimizations have been applied
4415 */
4416 for(rp=lemp->rule; rp; rp=rp->next) rp->doesReduce = LEMON_FALSE;
4417 for(i=0; i<lemp->nxstate; i++){
drh756b41e2016-05-24 18:55:08 +00004418 for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){
4419 if( ap->type==REDUCE || ap->type==SHIFTREDUCE ){
drh69bfa552017-04-26 04:32:17 +00004420 ap->x.rp->doesReduce = 1;
drh756b41e2016-05-24 18:55:08 +00004421 }
4422 }
4423 }
4424
drh3bd48ab2015-09-07 18:23:37 +00004425 /* Finish rendering the constants now that the action table has
4426 ** been computed */
4427 fprintf(out,"#define YYNSTATE %d\n",lemp->nxstate); lineno++;
4428 fprintf(out,"#define YYNRULE %d\n",lemp->nrule); lineno++;
drh0d9de992017-12-26 18:04:23 +00004429 fprintf(out,"#define YYNTOKEN %d\n",lemp->nterminal); lineno++;
drh337cd0d2015-09-07 23:40:42 +00004430 fprintf(out,"#define YY_MAX_SHIFT %d\n",lemp->nxstate-1); lineno++;
drh5c8241b2017-12-24 23:38:10 +00004431 i = lemp->minShiftReduce;
4432 fprintf(out,"#define YY_MIN_SHIFTREDUCE %d\n",i); lineno++;
4433 i += lemp->nrule;
drh3bd48ab2015-09-07 18:23:37 +00004434 fprintf(out,"#define YY_MAX_SHIFTREDUCE %d\n", i-1); lineno++;
drh5c8241b2017-12-24 23:38:10 +00004435 fprintf(out,"#define YY_ERROR_ACTION %d\n", lemp->errAction); lineno++;
4436 fprintf(out,"#define YY_ACCEPT_ACTION %d\n", lemp->accAction); lineno++;
4437 fprintf(out,"#define YY_NO_ACTION %d\n", lemp->noAction); lineno++;
4438 fprintf(out,"#define YY_MIN_REDUCE %d\n", lemp->minReduce); lineno++;
4439 i = lemp->minReduce + lemp->nrule;
drh3bd48ab2015-09-07 18:23:37 +00004440 fprintf(out,"#define YY_MAX_REDUCE %d\n", i-1); lineno++;
drh3bd48ab2015-09-07 18:23:37 +00004441 tplt_xfer(lemp->name,in,out,&lineno);
4442
4443 /* Now output the action table and its associates:
4444 **
4445 ** yy_action[] A single table containing all actions.
4446 ** yy_lookahead[] A table containing the lookahead for each entry in
4447 ** yy_action. Used to detect hash collisions.
4448 ** yy_shift_ofst[] For each state, the offset into yy_action for
4449 ** shifting terminals.
4450 ** yy_reduce_ofst[] For each state, the offset into yy_action for
4451 ** shifting non-terminals after a reduce.
4452 ** yy_default[] Default action for each state.
4453 */
4454
drh8b582012003-10-21 13:16:03 +00004455 /* Output the yy_action table */
drh3a9d6c72017-12-25 04:15:38 +00004456 lemp->nactiontab = n = acttab_action_size(pActtab);
drhc75e0162015-09-07 02:23:02 +00004457 lemp->tablesize += n*szActionType;
drhf16371d2009-11-03 19:18:31 +00004458 fprintf(out,"#define YY_ACTTAB_COUNT (%d)\n", n); lineno++;
4459 fprintf(out,"static const YYACTIONTYPE yy_action[] = {\n"); lineno++;
drh8b582012003-10-21 13:16:03 +00004460 for(i=j=0; i<n; i++){
4461 int action = acttab_yyaction(pActtab, i);
drh5c8241b2017-12-24 23:38:10 +00004462 if( action<0 ) action = lemp->noAction;
drhfdbf9282003-10-21 16:34:41 +00004463 if( j==0 ) fprintf(out," /* %5d */ ", i);
drh8b582012003-10-21 13:16:03 +00004464 fprintf(out, " %4d,", action);
4465 if( j==9 || i==n-1 ){
4466 fprintf(out, "\n"); lineno++;
4467 j = 0;
4468 }else{
4469 j++;
4470 }
4471 }
4472 fprintf(out, "};\n"); lineno++;
4473
4474 /* Output the yy_lookahead table */
drh3a9d6c72017-12-25 04:15:38 +00004475 lemp->nlookaheadtab = n = acttab_lookahead_size(pActtab);
drhc75e0162015-09-07 02:23:02 +00004476 lemp->tablesize += n*szCodeType;
drh57196282004-10-06 15:41:16 +00004477 fprintf(out,"static const YYCODETYPE yy_lookahead[] = {\n"); lineno++;
drh8b582012003-10-21 13:16:03 +00004478 for(i=j=0; i<n; i++){
4479 int la = acttab_yylookahead(pActtab, i);
4480 if( la<0 ) la = lemp->nsymbol;
drhfdbf9282003-10-21 16:34:41 +00004481 if( j==0 ) fprintf(out," /* %5d */ ", i);
drh8b582012003-10-21 13:16:03 +00004482 fprintf(out, " %4d,", la);
drh2e517162019-08-28 02:09:47 +00004483 if( j==9 ){
drh8b582012003-10-21 13:16:03 +00004484 fprintf(out, "\n"); lineno++;
4485 j = 0;
4486 }else{
4487 j++;
4488 }
4489 }
drh2e517162019-08-28 02:09:47 +00004490 /* Add extra entries to the end of the yy_lookahead[] table so that
4491 ** yy_shift_ofst[]+iToken will always be a valid index into the array,
4492 ** even for the largest possible value of yy_shift_ofst[] and iToken. */
4493 nLookAhead = lemp->nterminal + lemp->nactiontab;
4494 while( i<nLookAhead ){
4495 if( j==0 ) fprintf(out," /* %5d */ ", i);
4496 fprintf(out, " %4d,", lemp->nterminal);
4497 if( j==9 ){
4498 fprintf(out, "\n"); lineno++;
4499 j = 0;
4500 }else{
4501 j++;
4502 }
4503 i++;
4504 }
mistachkinacf6e082019-09-11 15:25:26 +00004505 if( j>0 ){ fprintf(out, "\n"); lineno++; }
drh8b582012003-10-21 13:16:03 +00004506 fprintf(out, "};\n"); lineno++;
4507
4508 /* Output the yy_shift_ofst[] table */
drh3bd48ab2015-09-07 18:23:37 +00004509 n = lemp->nxstate;
drhada354d2005-11-05 15:03:59 +00004510 while( n>0 && lemp->sorted[n-1]->iTknOfst==NO_OFFSET ) n--;
drh701b6882016-08-10 13:30:43 +00004511 fprintf(out, "#define YY_SHIFT_COUNT (%d)\n", n-1); lineno++;
4512 fprintf(out, "#define YY_SHIFT_MIN (%d)\n", mnTknOfst); lineno++;
4513 fprintf(out, "#define YY_SHIFT_MAX (%d)\n", mxTknOfst); lineno++;
drh06f60d82017-04-14 19:46:12 +00004514 fprintf(out, "static const %s yy_shift_ofst[] = {\n",
drh701b6882016-08-10 13:30:43 +00004515 minimum_size_type(mnTknOfst, lemp->nterminal+lemp->nactiontab, &sz));
4516 lineno++;
drhc75e0162015-09-07 02:23:02 +00004517 lemp->tablesize += n*sz;
drh8b582012003-10-21 13:16:03 +00004518 for(i=j=0; i<n; i++){
4519 int ofst;
4520 stp = lemp->sorted[i];
4521 ofst = stp->iTknOfst;
drh701b6882016-08-10 13:30:43 +00004522 if( ofst==NO_OFFSET ) ofst = lemp->nactiontab;
drhfdbf9282003-10-21 16:34:41 +00004523 if( j==0 ) fprintf(out," /* %5d */ ", i);
drh8b582012003-10-21 13:16:03 +00004524 fprintf(out, " %4d,", ofst);
4525 if( j==9 || i==n-1 ){
4526 fprintf(out, "\n"); lineno++;
4527 j = 0;
4528 }else{
4529 j++;
4530 }
4531 }
4532 fprintf(out, "};\n"); lineno++;
4533
4534 /* Output the yy_reduce_ofst[] table */
drh3bd48ab2015-09-07 18:23:37 +00004535 n = lemp->nxstate;
drhada354d2005-11-05 15:03:59 +00004536 while( n>0 && lemp->sorted[n-1]->iNtOfst==NO_OFFSET ) n--;
drhf16371d2009-11-03 19:18:31 +00004537 fprintf(out, "#define YY_REDUCE_COUNT (%d)\n", n-1); lineno++;
4538 fprintf(out, "#define YY_REDUCE_MIN (%d)\n", mnNtOfst); lineno++;
4539 fprintf(out, "#define YY_REDUCE_MAX (%d)\n", mxNtOfst); lineno++;
drh06f60d82017-04-14 19:46:12 +00004540 fprintf(out, "static const %s yy_reduce_ofst[] = {\n",
drhc75e0162015-09-07 02:23:02 +00004541 minimum_size_type(mnNtOfst-1, mxNtOfst, &sz)); lineno++;
4542 lemp->tablesize += n*sz;
drh8b582012003-10-21 13:16:03 +00004543 for(i=j=0; i<n; i++){
4544 int ofst;
4545 stp = lemp->sorted[i];
4546 ofst = stp->iNtOfst;
4547 if( ofst==NO_OFFSET ) ofst = mnNtOfst - 1;
drhfdbf9282003-10-21 16:34:41 +00004548 if( j==0 ) fprintf(out," /* %5d */ ", i);
drh8b582012003-10-21 13:16:03 +00004549 fprintf(out, " %4d,", ofst);
4550 if( j==9 || i==n-1 ){
4551 fprintf(out, "\n"); lineno++;
4552 j = 0;
4553 }else{
4554 j++;
4555 }
4556 }
4557 fprintf(out, "};\n"); lineno++;
4558
4559 /* Output the default action table */
drh57196282004-10-06 15:41:16 +00004560 fprintf(out, "static const YYACTIONTYPE yy_default[] = {\n"); lineno++;
drh3bd48ab2015-09-07 18:23:37 +00004561 n = lemp->nxstate;
drhc75e0162015-09-07 02:23:02 +00004562 lemp->tablesize += n*szActionType;
drh8b582012003-10-21 13:16:03 +00004563 for(i=j=0; i<n; i++){
4564 stp = lemp->sorted[i];
drhfdbf9282003-10-21 16:34:41 +00004565 if( j==0 ) fprintf(out," /* %5d */ ", i);
drh5c8241b2017-12-24 23:38:10 +00004566 if( stp->iDfltReduce<0 ){
4567 fprintf(out, " %4d,", lemp->errAction);
4568 }else{
4569 fprintf(out, " %4d,", stp->iDfltReduce + lemp->minReduce);
4570 }
drh8b582012003-10-21 13:16:03 +00004571 if( j==9 || i==n-1 ){
4572 fprintf(out, "\n"); lineno++;
4573 j = 0;
4574 }else{
4575 j++;
4576 }
4577 }
4578 fprintf(out, "};\n"); lineno++;
drh75897232000-05-29 14:26:00 +00004579 tplt_xfer(lemp->name,in,out,&lineno);
4580
drh0bd1f4e2002-06-06 18:54:39 +00004581 /* Generate the table of fallback tokens.
4582 */
4583 if( lemp->has_fallback ){
drh1441f3e2009-06-12 12:50:50 +00004584 int mx = lemp->nterminal - 1;
drh010bdb42019-08-28 11:31:11 +00004585 /* 2019-08-28: Generate fallback entries for every token to avoid
4586 ** having to do a range check on the index */
4587 /* while( mx>0 && lemp->symbols[mx]->fallback==0 ){ mx--; } */
drhc75e0162015-09-07 02:23:02 +00004588 lemp->tablesize += (mx+1)*szCodeType;
drh1441f3e2009-06-12 12:50:50 +00004589 for(i=0; i<=mx; i++){
drh0bd1f4e2002-06-06 18:54:39 +00004590 struct symbol *p = lemp->symbols[i];
4591 if( p->fallback==0 ){
4592 fprintf(out, " 0, /* %10s => nothing */\n", p->name);
4593 }else{
4594 fprintf(out, " %3d, /* %10s => %s */\n", p->fallback->index,
4595 p->name, p->fallback->name);
4596 }
4597 lineno++;
4598 }
4599 }
4600 tplt_xfer(lemp->name, in, out, &lineno);
4601
4602 /* Generate a table containing the symbolic name of every symbol
4603 */
drh75897232000-05-29 14:26:00 +00004604 for(i=0; i<lemp->nsymbol; i++){
drh898799f2014-01-10 23:21:00 +00004605 lemon_sprintf(line,"\"%s\",",lemp->symbols[i]->name);
drh3a9d6c72017-12-25 04:15:38 +00004606 fprintf(out," /* %4d */ \"%s\",\n",i, lemp->symbols[i]->name); lineno++;
drh75897232000-05-29 14:26:00 +00004607 }
drh75897232000-05-29 14:26:00 +00004608 tplt_xfer(lemp->name,in,out,&lineno);
4609
drh0bd1f4e2002-06-06 18:54:39 +00004610 /* Generate a table containing a text string that describes every
drh34ff57b2008-07-14 12:27:51 +00004611 ** rule in the rule set of the grammar. This information is used
drh0bd1f4e2002-06-06 18:54:39 +00004612 ** when tracing REDUCE actions.
4613 */
4614 for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){
drh4ef07702016-03-16 19:45:54 +00004615 assert( rp->iRule==i );
drhc4dd3fd2008-01-22 01:48:05 +00004616 fprintf(out," /* %3d */ \"", i);
4617 writeRuleText(out, rp);
drh0bd1f4e2002-06-06 18:54:39 +00004618 fprintf(out,"\",\n"); lineno++;
4619 }
4620 tplt_xfer(lemp->name,in,out,&lineno);
4621
drh75897232000-05-29 14:26:00 +00004622 /* Generate code which executes every time a symbol is popped from
drh06f60d82017-04-14 19:46:12 +00004623 ** the stack while processing errors or while destroying the parser.
drh0bd1f4e2002-06-06 18:54:39 +00004624 ** (In other words, generate the %destructor actions)
4625 */
drh75897232000-05-29 14:26:00 +00004626 if( lemp->tokendest ){
drh4dc8ef52008-07-01 17:13:57 +00004627 int once = 1;
drh75897232000-05-29 14:26:00 +00004628 for(i=0; i<lemp->nsymbol; i++){
4629 struct symbol *sp = lemp->symbols[i];
4630 if( sp==0 || sp->type!=TERMINAL ) continue;
drh4dc8ef52008-07-01 17:13:57 +00004631 if( once ){
4632 fprintf(out, " /* TERMINAL Destructor */\n"); lineno++;
4633 once = 0;
4634 }
drhc53eed12009-06-12 17:46:19 +00004635 fprintf(out," case %d: /* %s */\n", sp->index, sp->name); lineno++;
drh75897232000-05-29 14:26:00 +00004636 }
4637 for(i=0; i<lemp->nsymbol && lemp->symbols[i]->type!=TERMINAL; i++);
4638 if( i<lemp->nsymbol ){
4639 emit_destructor_code(out,lemp->symbols[i],lemp,&lineno);
4640 fprintf(out," break;\n"); lineno++;
4641 }
4642 }
drh8d659732005-01-13 23:54:06 +00004643 if( lemp->vardest ){
4644 struct symbol *dflt_sp = 0;
drh4dc8ef52008-07-01 17:13:57 +00004645 int once = 1;
drh8d659732005-01-13 23:54:06 +00004646 for(i=0; i<lemp->nsymbol; i++){
4647 struct symbol *sp = lemp->symbols[i];
4648 if( sp==0 || sp->type==TERMINAL ||
4649 sp->index<=0 || sp->destructor!=0 ) continue;
drh4dc8ef52008-07-01 17:13:57 +00004650 if( once ){
drh5c8241b2017-12-24 23:38:10 +00004651 fprintf(out, " /* Default NON-TERMINAL Destructor */\n");lineno++;
drh4dc8ef52008-07-01 17:13:57 +00004652 once = 0;
4653 }
drhc53eed12009-06-12 17:46:19 +00004654 fprintf(out," case %d: /* %s */\n", sp->index, sp->name); lineno++;
drh8d659732005-01-13 23:54:06 +00004655 dflt_sp = sp;
4656 }
4657 if( dflt_sp!=0 ){
4658 emit_destructor_code(out,dflt_sp,lemp,&lineno);
drh8d659732005-01-13 23:54:06 +00004659 }
drh4dc8ef52008-07-01 17:13:57 +00004660 fprintf(out," break;\n"); lineno++;
drh8d659732005-01-13 23:54:06 +00004661 }
drh75897232000-05-29 14:26:00 +00004662 for(i=0; i<lemp->nsymbol; i++){
4663 struct symbol *sp = lemp->symbols[i];
4664 if( sp==0 || sp->type==TERMINAL || sp->destructor==0 ) continue;
drh0f832dd2016-08-16 16:46:40 +00004665 if( sp->destLineno<0 ) continue; /* Already emitted */
drh75013012009-06-12 15:47:34 +00004666 fprintf(out," case %d: /* %s */\n", sp->index, sp->name); lineno++;
drh0bb132b2004-07-20 14:06:51 +00004667
4668 /* Combine duplicate destructors into a single case */
4669 for(j=i+1; j<lemp->nsymbol; j++){
4670 struct symbol *sp2 = lemp->symbols[j];
4671 if( sp2 && sp2->type!=TERMINAL && sp2->destructor
4672 && sp2->dtnum==sp->dtnum
4673 && strcmp(sp->destructor,sp2->destructor)==0 ){
drhc53eed12009-06-12 17:46:19 +00004674 fprintf(out," case %d: /* %s */\n",
4675 sp2->index, sp2->name); lineno++;
drh0f832dd2016-08-16 16:46:40 +00004676 sp2->destLineno = -1; /* Avoid emitting this destructor again */
drh0bb132b2004-07-20 14:06:51 +00004677 }
4678 }
4679
drh75897232000-05-29 14:26:00 +00004680 emit_destructor_code(out,lemp->symbols[i],lemp,&lineno);
4681 fprintf(out," break;\n"); lineno++;
4682 }
drh75897232000-05-29 14:26:00 +00004683 tplt_xfer(lemp->name,in,out,&lineno);
4684
4685 /* Generate code which executes whenever the parser stack overflows */
drha5808f32008-04-27 22:19:44 +00004686 tplt_print(out,lemp,lemp->overflow,&lineno);
drh75897232000-05-29 14:26:00 +00004687 tplt_xfer(lemp->name,in,out,&lineno);
4688
drhcfc45b12018-12-03 23:57:27 +00004689 /* Generate the tables of rule information. yyRuleInfoLhs[] and
4690 ** yyRuleInfoNRhs[].
drh75897232000-05-29 14:26:00 +00004691 **
4692 ** Note: This code depends on the fact that rules are number
4693 ** sequentually beginning with 0.
4694 */
drh5c8241b2017-12-24 23:38:10 +00004695 for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){
drhcfc45b12018-12-03 23:57:27 +00004696 fprintf(out," %4d, /* (%d) ", rp->lhs->index, i);
4697 rule_print(out, rp);
4698 fprintf(out," */\n"); lineno++;
4699 }
4700 tplt_xfer(lemp->name,in,out,&lineno);
4701 for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){
4702 fprintf(out," %3d, /* (%d) ", -rp->nrhs, i);
drh5c8241b2017-12-24 23:38:10 +00004703 rule_print(out, rp);
4704 fprintf(out," */\n"); lineno++;
drh75897232000-05-29 14:26:00 +00004705 }
4706 tplt_xfer(lemp->name,in,out,&lineno);
4707
4708 /* Generate code which execution during each REDUCE action */
drhdabd04c2016-02-17 01:46:19 +00004709 i = 0;
drh75897232000-05-29 14:26:00 +00004710 for(rp=lemp->rule; rp; rp=rp->next){
drhdabd04c2016-02-17 01:46:19 +00004711 i += translate_code(lemp, rp);
4712 }
4713 if( i ){
4714 fprintf(out," YYMINORTYPE yylhsminor;\n"); lineno++;
drh0bb132b2004-07-20 14:06:51 +00004715 }
drhc53eed12009-06-12 17:46:19 +00004716 /* First output rules other than the default: rule */
drh0bb132b2004-07-20 14:06:51 +00004717 for(rp=lemp->rule; rp; rp=rp->next){
drhc53eed12009-06-12 17:46:19 +00004718 struct rule *rp2; /* Other rules with the same action */
drh711c9812016-05-23 14:24:31 +00004719 if( rp->codeEmitted ) continue;
4720 if( rp->noCode ){
4721 /* No C code actions, so this will be part of the "default:" rule */
drh2e55b042016-04-30 17:19:30 +00004722 continue;
4723 }
drh4ef07702016-03-16 19:45:54 +00004724 fprintf(out," case %d: /* ", rp->iRule);
drhc4dd3fd2008-01-22 01:48:05 +00004725 writeRuleText(out, rp);
4726 fprintf(out, " */\n"); lineno++;
drh0bb132b2004-07-20 14:06:51 +00004727 for(rp2=rp->next; rp2; rp2=rp2->next){
drhafb8cd92016-04-29 11:28:35 +00004728 if( rp2->code==rp->code && rp2->codePrefix==rp->codePrefix
4729 && rp2->codeSuffix==rp->codeSuffix ){
drh4ef07702016-03-16 19:45:54 +00004730 fprintf(out," case %d: /* ", rp2->iRule);
drhc4dd3fd2008-01-22 01:48:05 +00004731 writeRuleText(out, rp2);
drh4ef07702016-03-16 19:45:54 +00004732 fprintf(out," */ yytestcase(yyruleno==%d);\n", rp2->iRule); lineno++;
drh711c9812016-05-23 14:24:31 +00004733 rp2->codeEmitted = 1;
drh0bb132b2004-07-20 14:06:51 +00004734 }
4735 }
drh75897232000-05-29 14:26:00 +00004736 emit_code(out,rp,lemp,&lineno);
4737 fprintf(out," break;\n"); lineno++;
drh711c9812016-05-23 14:24:31 +00004738 rp->codeEmitted = 1;
drh75897232000-05-29 14:26:00 +00004739 }
drhc53eed12009-06-12 17:46:19 +00004740 /* Finally, output the default: rule. We choose as the default: all
4741 ** empty actions. */
4742 fprintf(out," default:\n"); lineno++;
4743 for(rp=lemp->rule; rp; rp=rp->next){
drh711c9812016-05-23 14:24:31 +00004744 if( rp->codeEmitted ) continue;
4745 assert( rp->noCode );
drh4ef07702016-03-16 19:45:54 +00004746 fprintf(out," /* (%d) ", rp->iRule);
drhc53eed12009-06-12 17:46:19 +00004747 writeRuleText(out, rp);
drh756b41e2016-05-24 18:55:08 +00004748 if( rp->doesReduce ){
4749 fprintf(out, " */ yytestcase(yyruleno==%d);\n", rp->iRule); lineno++;
4750 }else{
4751 fprintf(out, " (OPTIMIZED OUT) */ assert(yyruleno!=%d);\n",
4752 rp->iRule); lineno++;
4753 }
drhc53eed12009-06-12 17:46:19 +00004754 }
4755 fprintf(out," break;\n"); lineno++;
drh75897232000-05-29 14:26:00 +00004756 tplt_xfer(lemp->name,in,out,&lineno);
4757
4758 /* Generate code which executes if a parse fails */
drha5808f32008-04-27 22:19:44 +00004759 tplt_print(out,lemp,lemp->failure,&lineno);
drh75897232000-05-29 14:26:00 +00004760 tplt_xfer(lemp->name,in,out,&lineno);
4761
4762 /* Generate code which executes when a syntax error occurs */
drha5808f32008-04-27 22:19:44 +00004763 tplt_print(out,lemp,lemp->error,&lineno);
drh75897232000-05-29 14:26:00 +00004764 tplt_xfer(lemp->name,in,out,&lineno);
4765
4766 /* Generate code which executes when the parser accepts its input */
drha5808f32008-04-27 22:19:44 +00004767 tplt_print(out,lemp,lemp->accept,&lineno);
drh75897232000-05-29 14:26:00 +00004768 tplt_xfer(lemp->name,in,out,&lineno);
4769
4770 /* Append any addition code the user desires */
drha5808f32008-04-27 22:19:44 +00004771 tplt_print(out,lemp,lemp->extracode,&lineno);
drh75897232000-05-29 14:26:00 +00004772
drhe2dcc422019-01-15 14:44:23 +00004773 acttab_free(pActtab);
drh75897232000-05-29 14:26:00 +00004774 fclose(in);
4775 fclose(out);
drhfe03dac2019-11-26 02:22:39 +00004776 if( sql ) fclose(sql);
drh75897232000-05-29 14:26:00 +00004777 return;
4778}
4779
4780/* Generate a header file for the parser */
icculus9e44cf12010-02-14 17:14:22 +00004781void ReportHeader(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +00004782{
4783 FILE *out, *in;
icculus9e44cf12010-02-14 17:14:22 +00004784 const char *prefix;
drh75897232000-05-29 14:26:00 +00004785 char line[LINESIZE];
4786 char pattern[LINESIZE];
4787 int i;
4788
4789 if( lemp->tokenprefix ) prefix = lemp->tokenprefix;
4790 else prefix = "";
drh2aa6ca42004-09-10 00:14:04 +00004791 in = file_open(lemp,".h","rb");
drh75897232000-05-29 14:26:00 +00004792 if( in ){
drh8ba0d1c2012-06-16 15:26:31 +00004793 int nextChar;
drh75897232000-05-29 14:26:00 +00004794 for(i=1; i<lemp->nterminal && fgets(line,LINESIZE,in); i++){
drh61f92cd2014-01-11 03:06:18 +00004795 lemon_sprintf(pattern,"#define %s%-30s %3d\n",
4796 prefix,lemp->symbols[i]->name,i);
drh75897232000-05-29 14:26:00 +00004797 if( strcmp(line,pattern) ) break;
4798 }
drh8ba0d1c2012-06-16 15:26:31 +00004799 nextChar = fgetc(in);
drh75897232000-05-29 14:26:00 +00004800 fclose(in);
drh8ba0d1c2012-06-16 15:26:31 +00004801 if( i==lemp->nterminal && nextChar==EOF ){
drh75897232000-05-29 14:26:00 +00004802 /* No change in the file. Don't rewrite it. */
4803 return;
4804 }
4805 }
drh2aa6ca42004-09-10 00:14:04 +00004806 out = file_open(lemp,".h","wb");
drh75897232000-05-29 14:26:00 +00004807 if( out ){
4808 for(i=1; i<lemp->nterminal; i++){
drh61f92cd2014-01-11 03:06:18 +00004809 fprintf(out,"#define %s%-30s %3d\n",prefix,lemp->symbols[i]->name,i);
drh75897232000-05-29 14:26:00 +00004810 }
drh06f60d82017-04-14 19:46:12 +00004811 fclose(out);
drh75897232000-05-29 14:26:00 +00004812 }
4813 return;
4814}
4815
4816/* Reduce the size of the action tables, if possible, by making use
4817** of defaults.
4818**
drhb59499c2002-02-23 18:45:13 +00004819** In this version, we take the most frequent REDUCE action and make
drhe09daa92006-06-10 13:29:31 +00004820** it the default. Except, there is no default if the wildcard token
4821** is a possible look-ahead.
drh75897232000-05-29 14:26:00 +00004822*/
icculus9e44cf12010-02-14 17:14:22 +00004823void CompressTables(struct lemon *lemp)
drh75897232000-05-29 14:26:00 +00004824{
4825 struct state *stp;
drhc173ad82016-05-23 16:15:02 +00004826 struct action *ap, *ap2, *nextap;
drhb59499c2002-02-23 18:45:13 +00004827 struct rule *rp, *rp2, *rbest;
drh0c6dfaa2015-09-08 21:16:46 +00004828 int nbest, n;
drh75897232000-05-29 14:26:00 +00004829 int i;
drhe09daa92006-06-10 13:29:31 +00004830 int usesWildcard;
drh75897232000-05-29 14:26:00 +00004831
4832 for(i=0; i<lemp->nstate; i++){
4833 stp = lemp->sorted[i];
drhb59499c2002-02-23 18:45:13 +00004834 nbest = 0;
4835 rbest = 0;
drhe09daa92006-06-10 13:29:31 +00004836 usesWildcard = 0;
drh75897232000-05-29 14:26:00 +00004837
drhb59499c2002-02-23 18:45:13 +00004838 for(ap=stp->ap; ap; ap=ap->next){
drhe09daa92006-06-10 13:29:31 +00004839 if( ap->type==SHIFT && ap->sp==lemp->wildcard ){
4840 usesWildcard = 1;
4841 }
drhb59499c2002-02-23 18:45:13 +00004842 if( ap->type!=REDUCE ) continue;
4843 rp = ap->x.rp;
drhb4960992007-10-05 16:16:36 +00004844 if( rp->lhsStart ) continue;
drhb59499c2002-02-23 18:45:13 +00004845 if( rp==rbest ) continue;
4846 n = 1;
4847 for(ap2=ap->next; ap2; ap2=ap2->next){
4848 if( ap2->type!=REDUCE ) continue;
4849 rp2 = ap2->x.rp;
4850 if( rp2==rbest ) continue;
4851 if( rp2==rp ) n++;
4852 }
4853 if( n>nbest ){
4854 nbest = n;
4855 rbest = rp;
drh75897232000-05-29 14:26:00 +00004856 }
4857 }
drh06f60d82017-04-14 19:46:12 +00004858
drhb59499c2002-02-23 18:45:13 +00004859 /* Do not make a default if the number of rules to default
drhe09daa92006-06-10 13:29:31 +00004860 ** is not at least 1 or if the wildcard token is a possible
4861 ** lookahead.
4862 */
4863 if( nbest<1 || usesWildcard ) continue;
drh75897232000-05-29 14:26:00 +00004864
drhb59499c2002-02-23 18:45:13 +00004865
4866 /* Combine matching REDUCE actions into a single default */
4867 for(ap=stp->ap; ap; ap=ap->next){
4868 if( ap->type==REDUCE && ap->x.rp==rbest ) break;
4869 }
drh75897232000-05-29 14:26:00 +00004870 assert( ap );
4871 ap->sp = Symbol_new("{default}");
4872 for(ap=ap->next; ap; ap=ap->next){
drhb59499c2002-02-23 18:45:13 +00004873 if( ap->type==REDUCE && ap->x.rp==rbest ) ap->type = NOT_USED;
drh75897232000-05-29 14:26:00 +00004874 }
4875 stp->ap = Action_sort(stp->ap);
drh3bd48ab2015-09-07 18:23:37 +00004876
4877 for(ap=stp->ap; ap; ap=ap->next){
4878 if( ap->type==SHIFT ) break;
4879 if( ap->type==REDUCE && ap->x.rp!=rbest ) break;
4880 }
4881 if( ap==0 ){
4882 stp->autoReduce = 1;
4883 stp->pDfltReduce = rbest;
4884 }
4885 }
4886
4887 /* Make a second pass over all states and actions. Convert
4888 ** every action that is a SHIFT to an autoReduce state into
4889 ** a SHIFTREDUCE action.
4890 */
4891 for(i=0; i<lemp->nstate; i++){
4892 stp = lemp->sorted[i];
4893 for(ap=stp->ap; ap; ap=ap->next){
4894 struct state *pNextState;
4895 if( ap->type!=SHIFT ) continue;
4896 pNextState = ap->x.stp;
4897 if( pNextState->autoReduce && pNextState->pDfltReduce!=0 ){
4898 ap->type = SHIFTREDUCE;
4899 ap->x.rp = pNextState->pDfltReduce;
4900 }
4901 }
drh75897232000-05-29 14:26:00 +00004902 }
drhc173ad82016-05-23 16:15:02 +00004903
4904 /* If a SHIFTREDUCE action specifies a rule that has a single RHS term
4905 ** (meaning that the SHIFTREDUCE will land back in the state where it
4906 ** started) and if there is no C-code associated with the reduce action,
4907 ** then we can go ahead and convert the action to be the same as the
4908 ** action for the RHS of the rule.
4909 */
4910 for(i=0; i<lemp->nstate; i++){
4911 stp = lemp->sorted[i];
4912 for(ap=stp->ap; ap; ap=nextap){
4913 nextap = ap->next;
4914 if( ap->type!=SHIFTREDUCE ) continue;
4915 rp = ap->x.rp;
4916 if( rp->noCode==0 ) continue;
4917 if( rp->nrhs!=1 ) continue;
4918#if 1
4919 /* Only apply this optimization to non-terminals. It would be OK to
4920 ** apply it to terminal symbols too, but that makes the parser tables
4921 ** larger. */
4922 if( ap->sp->index<lemp->nterminal ) continue;
4923#endif
4924 /* If we reach this point, it means the optimization can be applied */
4925 nextap = ap;
4926 for(ap2=stp->ap; ap2 && (ap2==ap || ap2->sp!=rp->lhs); ap2=ap2->next){}
4927 assert( ap2!=0 );
4928 ap->spOpt = ap2->sp;
4929 ap->type = ap2->type;
4930 ap->x = ap2->x;
4931 }
4932 }
drh75897232000-05-29 14:26:00 +00004933}
drhb59499c2002-02-23 18:45:13 +00004934
drhada354d2005-11-05 15:03:59 +00004935
4936/*
4937** Compare two states for sorting purposes. The smaller state is the
4938** one with the most non-terminal actions. If they have the same number
4939** of non-terminal actions, then the smaller is the one with the most
4940** token actions.
4941*/
4942static int stateResortCompare(const void *a, const void *b){
4943 const struct state *pA = *(const struct state**)a;
4944 const struct state *pB = *(const struct state**)b;
4945 int n;
4946
4947 n = pB->nNtAct - pA->nNtAct;
4948 if( n==0 ){
4949 n = pB->nTknAct - pA->nTknAct;
drhe594bc32009-11-03 13:02:25 +00004950 if( n==0 ){
4951 n = pB->statenum - pA->statenum;
4952 }
drhada354d2005-11-05 15:03:59 +00004953 }
drhe594bc32009-11-03 13:02:25 +00004954 assert( n!=0 );
drhada354d2005-11-05 15:03:59 +00004955 return n;
4956}
4957
4958
4959/*
4960** Renumber and resort states so that states with fewer choices
4961** occur at the end. Except, keep state 0 as the first state.
4962*/
icculus9e44cf12010-02-14 17:14:22 +00004963void ResortStates(struct lemon *lemp)
drhada354d2005-11-05 15:03:59 +00004964{
4965 int i;
4966 struct state *stp;
4967 struct action *ap;
4968
4969 for(i=0; i<lemp->nstate; i++){
4970 stp = lemp->sorted[i];
4971 stp->nTknAct = stp->nNtAct = 0;
drh5c8241b2017-12-24 23:38:10 +00004972 stp->iDfltReduce = -1; /* Init dflt action to "syntax error" */
drhada354d2005-11-05 15:03:59 +00004973 stp->iTknOfst = NO_OFFSET;
4974 stp->iNtOfst = NO_OFFSET;
4975 for(ap=stp->ap; ap; ap=ap->next){
drh3bd48ab2015-09-07 18:23:37 +00004976 int iAction = compute_action(lemp,ap);
4977 if( iAction>=0 ){
drhada354d2005-11-05 15:03:59 +00004978 if( ap->sp->index<lemp->nterminal ){
4979 stp->nTknAct++;
4980 }else if( ap->sp->index<lemp->nsymbol ){
4981 stp->nNtAct++;
4982 }else{
drh3bd48ab2015-09-07 18:23:37 +00004983 assert( stp->autoReduce==0 || stp->pDfltReduce==ap->x.rp );
drh5c8241b2017-12-24 23:38:10 +00004984 stp->iDfltReduce = iAction;
drhada354d2005-11-05 15:03:59 +00004985 }
4986 }
4987 }
4988 }
4989 qsort(&lemp->sorted[1], lemp->nstate-1, sizeof(lemp->sorted[0]),
4990 stateResortCompare);
4991 for(i=0; i<lemp->nstate; i++){
4992 lemp->sorted[i]->statenum = i;
4993 }
drh3bd48ab2015-09-07 18:23:37 +00004994 lemp->nxstate = lemp->nstate;
4995 while( lemp->nxstate>1 && lemp->sorted[lemp->nxstate-1]->autoReduce ){
4996 lemp->nxstate--;
4997 }
drhada354d2005-11-05 15:03:59 +00004998}
4999
5000
drh75897232000-05-29 14:26:00 +00005001/***************** From the file "set.c" ************************************/
5002/*
5003** Set manipulation routines for the LEMON parser generator.
5004*/
5005
5006static int size = 0;
5007
5008/* Set the set size */
icculus9e44cf12010-02-14 17:14:22 +00005009void SetSize(int n)
drh75897232000-05-29 14:26:00 +00005010{
5011 size = n+1;
5012}
5013
5014/* Allocate a new set */
drh14d88552017-04-14 19:44:15 +00005015char *SetNew(void){
drh75897232000-05-29 14:26:00 +00005016 char *s;
drh9892c5d2007-12-21 00:02:11 +00005017 s = (char*)calloc( size, 1);
drh75897232000-05-29 14:26:00 +00005018 if( s==0 ){
drh75897232000-05-29 14:26:00 +00005019 memory_error();
5020 }
drh75897232000-05-29 14:26:00 +00005021 return s;
5022}
5023
5024/* Deallocate a set */
icculus9e44cf12010-02-14 17:14:22 +00005025void SetFree(char *s)
drh75897232000-05-29 14:26:00 +00005026{
5027 free(s);
5028}
5029
5030/* Add a new element to the set. Return TRUE if the element was added
5031** and FALSE if it was already there. */
icculus9e44cf12010-02-14 17:14:22 +00005032int SetAdd(char *s, int e)
drh75897232000-05-29 14:26:00 +00005033{
5034 int rv;
drh9892c5d2007-12-21 00:02:11 +00005035 assert( e>=0 && e<size );
drh75897232000-05-29 14:26:00 +00005036 rv = s[e];
5037 s[e] = 1;
5038 return !rv;
5039}
5040
5041/* Add every element of s2 to s1. Return TRUE if s1 changes. */
icculus9e44cf12010-02-14 17:14:22 +00005042int SetUnion(char *s1, char *s2)
drh75897232000-05-29 14:26:00 +00005043{
5044 int i, progress;
5045 progress = 0;
5046 for(i=0; i<size; i++){
5047 if( s2[i]==0 ) continue;
5048 if( s1[i]==0 ){
5049 progress = 1;
5050 s1[i] = 1;
5051 }
5052 }
5053 return progress;
5054}
5055/********************** From the file "table.c" ****************************/
5056/*
5057** All code in this file has been automatically generated
5058** from a specification in the file
5059** "table.q"
5060** by the associative array code building program "aagen".
5061** Do not edit this file! Instead, edit the specification
5062** file, then rerun aagen.
5063*/
5064/*
5065** Code for processing tables in the LEMON parser generator.
5066*/
5067
drh01f75f22013-10-02 20:46:30 +00005068PRIVATE unsigned strhash(const char *x)
drh75897232000-05-29 14:26:00 +00005069{
drh01f75f22013-10-02 20:46:30 +00005070 unsigned h = 0;
5071 while( *x ) h = h*13 + *(x++);
drh75897232000-05-29 14:26:00 +00005072 return h;
5073}
5074
5075/* Works like strdup, sort of. Save a string in malloced memory, but
5076** keep strings in a table so that the same string is not in more
5077** than one place.
5078*/
icculus9e44cf12010-02-14 17:14:22 +00005079const char *Strsafe(const char *y)
drh75897232000-05-29 14:26:00 +00005080{
icculus9e44cf12010-02-14 17:14:22 +00005081 const char *z;
5082 char *cpy;
drh75897232000-05-29 14:26:00 +00005083
drh916f75f2006-07-17 00:19:39 +00005084 if( y==0 ) return 0;
drh75897232000-05-29 14:26:00 +00005085 z = Strsafe_find(y);
icculus9e44cf12010-02-14 17:14:22 +00005086 if( z==0 && (cpy=(char *)malloc( lemonStrlen(y)+1 ))!=0 ){
drh898799f2014-01-10 23:21:00 +00005087 lemon_strcpy(cpy,y);
icculus9e44cf12010-02-14 17:14:22 +00005088 z = cpy;
drh75897232000-05-29 14:26:00 +00005089 Strsafe_insert(z);
5090 }
5091 MemoryCheck(z);
5092 return z;
5093}
5094
5095/* There is one instance of the following structure for each
5096** associative array of type "x1".
5097*/
5098struct s_x1 {
5099 int size; /* The number of available slots. */
5100 /* Must be a power of 2 greater than or */
5101 /* equal to 1 */
5102 int count; /* Number of currently slots filled */
5103 struct s_x1node *tbl; /* The data stored here */
5104 struct s_x1node **ht; /* Hash table for lookups */
5105};
5106
5107/* There is one instance of this structure for every data element
5108** in an associative array of type "x1".
5109*/
5110typedef struct s_x1node {
icculus9e44cf12010-02-14 17:14:22 +00005111 const char *data; /* The data */
drh75897232000-05-29 14:26:00 +00005112 struct s_x1node *next; /* Next entry with the same hash */
5113 struct s_x1node **from; /* Previous link */
5114} x1node;
5115
5116/* There is only one instance of the array, which is the following */
5117static struct s_x1 *x1a;
5118
5119/* Allocate a new associative array */
drh14d88552017-04-14 19:44:15 +00005120void Strsafe_init(void){
drh75897232000-05-29 14:26:00 +00005121 if( x1a ) return;
5122 x1a = (struct s_x1*)malloc( sizeof(struct s_x1) );
5123 if( x1a ){
5124 x1a->size = 1024;
5125 x1a->count = 0;
drh03e1b1f2014-01-11 12:52:25 +00005126 x1a->tbl = (x1node*)calloc(1024, sizeof(x1node) + sizeof(x1node*));
drh75897232000-05-29 14:26:00 +00005127 if( x1a->tbl==0 ){
5128 free(x1a);
5129 x1a = 0;
5130 }else{
5131 int i;
5132 x1a->ht = (x1node**)&(x1a->tbl[1024]);
5133 for(i=0; i<1024; i++) x1a->ht[i] = 0;
5134 }
5135 }
5136}
5137/* Insert a new record into the array. Return TRUE if successful.
5138** Prior data with the same key is NOT overwritten */
icculus9e44cf12010-02-14 17:14:22 +00005139int Strsafe_insert(const char *data)
drh75897232000-05-29 14:26:00 +00005140{
5141 x1node *np;
drh01f75f22013-10-02 20:46:30 +00005142 unsigned h;
5143 unsigned ph;
drh75897232000-05-29 14:26:00 +00005144
5145 if( x1a==0 ) return 0;
5146 ph = strhash(data);
5147 h = ph & (x1a->size-1);
5148 np = x1a->ht[h];
5149 while( np ){
5150 if( strcmp(np->data,data)==0 ){
5151 /* An existing entry with the same key is found. */
5152 /* Fail because overwrite is not allows. */
5153 return 0;
5154 }
5155 np = np->next;
5156 }
5157 if( x1a->count>=x1a->size ){
5158 /* Need to make the hash table bigger */
mistachkin8e189222015-04-19 21:43:16 +00005159 int i,arrSize;
drh75897232000-05-29 14:26:00 +00005160 struct s_x1 array;
mistachkin8e189222015-04-19 21:43:16 +00005161 array.size = arrSize = x1a->size*2;
drh75897232000-05-29 14:26:00 +00005162 array.count = x1a->count;
mistachkin8e189222015-04-19 21:43:16 +00005163 array.tbl = (x1node*)calloc(arrSize, sizeof(x1node) + sizeof(x1node*));
drh75897232000-05-29 14:26:00 +00005164 if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
mistachkin8e189222015-04-19 21:43:16 +00005165 array.ht = (x1node**)&(array.tbl[arrSize]);
5166 for(i=0; i<arrSize; i++) array.ht[i] = 0;
drh75897232000-05-29 14:26:00 +00005167 for(i=0; i<x1a->count; i++){
5168 x1node *oldnp, *newnp;
5169 oldnp = &(x1a->tbl[i]);
mistachkin8e189222015-04-19 21:43:16 +00005170 h = strhash(oldnp->data) & (arrSize-1);
drh75897232000-05-29 14:26:00 +00005171 newnp = &(array.tbl[i]);
5172 if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
5173 newnp->next = array.ht[h];
5174 newnp->data = oldnp->data;
5175 newnp->from = &(array.ht[h]);
5176 array.ht[h] = newnp;
5177 }
5178 free(x1a->tbl);
5179 *x1a = array;
5180 }
5181 /* Insert the new data */
5182 h = ph & (x1a->size-1);
5183 np = &(x1a->tbl[x1a->count++]);
5184 np->data = data;
5185 if( x1a->ht[h] ) x1a->ht[h]->from = &(np->next);
5186 np->next = x1a->ht[h];
5187 x1a->ht[h] = np;
5188 np->from = &(x1a->ht[h]);
5189 return 1;
5190}
5191
5192/* Return a pointer to data assigned to the given key. Return NULL
5193** if no such key. */
icculus9e44cf12010-02-14 17:14:22 +00005194const char *Strsafe_find(const char *key)
drh75897232000-05-29 14:26:00 +00005195{
drh01f75f22013-10-02 20:46:30 +00005196 unsigned h;
drh75897232000-05-29 14:26:00 +00005197 x1node *np;
5198
5199 if( x1a==0 ) return 0;
5200 h = strhash(key) & (x1a->size-1);
5201 np = x1a->ht[h];
5202 while( np ){
5203 if( strcmp(np->data,key)==0 ) break;
5204 np = np->next;
5205 }
5206 return np ? np->data : 0;
5207}
5208
5209/* Return a pointer to the (terminal or nonterminal) symbol "x".
5210** Create a new symbol if this is the first time "x" has been seen.
5211*/
icculus9e44cf12010-02-14 17:14:22 +00005212struct symbol *Symbol_new(const char *x)
drh75897232000-05-29 14:26:00 +00005213{
5214 struct symbol *sp;
5215
5216 sp = Symbol_find(x);
5217 if( sp==0 ){
drh9892c5d2007-12-21 00:02:11 +00005218 sp = (struct symbol *)calloc(1, sizeof(struct symbol) );
drh75897232000-05-29 14:26:00 +00005219 MemoryCheck(sp);
5220 sp->name = Strsafe(x);
drhc56fac72015-10-29 13:48:15 +00005221 sp->type = ISUPPER(*x) ? TERMINAL : NONTERMINAL;
drh75897232000-05-29 14:26:00 +00005222 sp->rule = 0;
drh0bd1f4e2002-06-06 18:54:39 +00005223 sp->fallback = 0;
drh75897232000-05-29 14:26:00 +00005224 sp->prec = -1;
5225 sp->assoc = UNK;
5226 sp->firstset = 0;
drhaa9f1122007-08-23 02:50:56 +00005227 sp->lambda = LEMON_FALSE;
drh75897232000-05-29 14:26:00 +00005228 sp->destructor = 0;
drh4dc8ef52008-07-01 17:13:57 +00005229 sp->destLineno = 0;
drh75897232000-05-29 14:26:00 +00005230 sp->datatype = 0;
drhc4dd3fd2008-01-22 01:48:05 +00005231 sp->useCnt = 0;
drh75897232000-05-29 14:26:00 +00005232 Symbol_insert(sp,sp->name);
5233 }
drhc4dd3fd2008-01-22 01:48:05 +00005234 sp->useCnt++;
drh75897232000-05-29 14:26:00 +00005235 return sp;
5236}
5237
drh61f92cd2014-01-11 03:06:18 +00005238/* Compare two symbols for sorting purposes. Return negative,
5239** zero, or positive if a is less then, equal to, or greater
5240** than b.
drh60d31652004-02-22 00:08:04 +00005241**
5242** Symbols that begin with upper case letters (terminals or tokens)
5243** must sort before symbols that begin with lower case letters
drh61f92cd2014-01-11 03:06:18 +00005244** (non-terminals). And MULTITERMINAL symbols (created using the
5245** %token_class directive) must sort at the very end. Other than
5246** that, the order does not matter.
drh60d31652004-02-22 00:08:04 +00005247**
5248** We find experimentally that leaving the symbols in their original
5249** order (the order they appeared in the grammar file) gives the
5250** smallest parser tables in SQLite.
5251*/
icculus9e44cf12010-02-14 17:14:22 +00005252int Symbolcmpp(const void *_a, const void *_b)
5253{
drh61f92cd2014-01-11 03:06:18 +00005254 const struct symbol *a = *(const struct symbol **) _a;
5255 const struct symbol *b = *(const struct symbol **) _b;
5256 int i1 = a->type==MULTITERMINAL ? 3 : a->name[0]>'Z' ? 2 : 1;
5257 int i2 = b->type==MULTITERMINAL ? 3 : b->name[0]>'Z' ? 2 : 1;
5258 return i1==i2 ? a->index - b->index : i1 - i2;
drh75897232000-05-29 14:26:00 +00005259}
5260
5261/* There is one instance of the following structure for each
5262** associative array of type "x2".
5263*/
5264struct s_x2 {
5265 int size; /* The number of available slots. */
5266 /* Must be a power of 2 greater than or */
5267 /* equal to 1 */
5268 int count; /* Number of currently slots filled */
5269 struct s_x2node *tbl; /* The data stored here */
5270 struct s_x2node **ht; /* Hash table for lookups */
5271};
5272
5273/* There is one instance of this structure for every data element
5274** in an associative array of type "x2".
5275*/
5276typedef struct s_x2node {
icculus9e44cf12010-02-14 17:14:22 +00005277 struct symbol *data; /* The data */
5278 const char *key; /* The key */
drh75897232000-05-29 14:26:00 +00005279 struct s_x2node *next; /* Next entry with the same hash */
5280 struct s_x2node **from; /* Previous link */
5281} x2node;
5282
5283/* There is only one instance of the array, which is the following */
5284static struct s_x2 *x2a;
5285
5286/* Allocate a new associative array */
drh14d88552017-04-14 19:44:15 +00005287void Symbol_init(void){
drh75897232000-05-29 14:26:00 +00005288 if( x2a ) return;
5289 x2a = (struct s_x2*)malloc( sizeof(struct s_x2) );
5290 if( x2a ){
5291 x2a->size = 128;
5292 x2a->count = 0;
drh03e1b1f2014-01-11 12:52:25 +00005293 x2a->tbl = (x2node*)calloc(128, sizeof(x2node) + sizeof(x2node*));
drh75897232000-05-29 14:26:00 +00005294 if( x2a->tbl==0 ){
5295 free(x2a);
5296 x2a = 0;
5297 }else{
5298 int i;
5299 x2a->ht = (x2node**)&(x2a->tbl[128]);
5300 for(i=0; i<128; i++) x2a->ht[i] = 0;
5301 }
5302 }
5303}
5304/* Insert a new record into the array. Return TRUE if successful.
5305** Prior data with the same key is NOT overwritten */
icculus9e44cf12010-02-14 17:14:22 +00005306int Symbol_insert(struct symbol *data, const char *key)
drh75897232000-05-29 14:26:00 +00005307{
5308 x2node *np;
drh01f75f22013-10-02 20:46:30 +00005309 unsigned h;
5310 unsigned ph;
drh75897232000-05-29 14:26:00 +00005311
5312 if( x2a==0 ) return 0;
5313 ph = strhash(key);
5314 h = ph & (x2a->size-1);
5315 np = x2a->ht[h];
5316 while( np ){
5317 if( strcmp(np->key,key)==0 ){
5318 /* An existing entry with the same key is found. */
5319 /* Fail because overwrite is not allows. */
5320 return 0;
5321 }
5322 np = np->next;
5323 }
5324 if( x2a->count>=x2a->size ){
5325 /* Need to make the hash table bigger */
mistachkin8e189222015-04-19 21:43:16 +00005326 int i,arrSize;
drh75897232000-05-29 14:26:00 +00005327 struct s_x2 array;
mistachkin8e189222015-04-19 21:43:16 +00005328 array.size = arrSize = x2a->size*2;
drh75897232000-05-29 14:26:00 +00005329 array.count = x2a->count;
mistachkin8e189222015-04-19 21:43:16 +00005330 array.tbl = (x2node*)calloc(arrSize, sizeof(x2node) + sizeof(x2node*));
drh75897232000-05-29 14:26:00 +00005331 if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
mistachkin8e189222015-04-19 21:43:16 +00005332 array.ht = (x2node**)&(array.tbl[arrSize]);
5333 for(i=0; i<arrSize; i++) array.ht[i] = 0;
drh75897232000-05-29 14:26:00 +00005334 for(i=0; i<x2a->count; i++){
5335 x2node *oldnp, *newnp;
5336 oldnp = &(x2a->tbl[i]);
mistachkin8e189222015-04-19 21:43:16 +00005337 h = strhash(oldnp->key) & (arrSize-1);
drh75897232000-05-29 14:26:00 +00005338 newnp = &(array.tbl[i]);
5339 if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
5340 newnp->next = array.ht[h];
5341 newnp->key = oldnp->key;
5342 newnp->data = oldnp->data;
5343 newnp->from = &(array.ht[h]);
5344 array.ht[h] = newnp;
5345 }
5346 free(x2a->tbl);
5347 *x2a = array;
5348 }
5349 /* Insert the new data */
5350 h = ph & (x2a->size-1);
5351 np = &(x2a->tbl[x2a->count++]);
5352 np->key = key;
5353 np->data = data;
5354 if( x2a->ht[h] ) x2a->ht[h]->from = &(np->next);
5355 np->next = x2a->ht[h];
5356 x2a->ht[h] = np;
5357 np->from = &(x2a->ht[h]);
5358 return 1;
5359}
5360
5361/* Return a pointer to data assigned to the given key. Return NULL
5362** if no such key. */
icculus9e44cf12010-02-14 17:14:22 +00005363struct symbol *Symbol_find(const char *key)
drh75897232000-05-29 14:26:00 +00005364{
drh01f75f22013-10-02 20:46:30 +00005365 unsigned h;
drh75897232000-05-29 14:26:00 +00005366 x2node *np;
5367
5368 if( x2a==0 ) return 0;
5369 h = strhash(key) & (x2a->size-1);
5370 np = x2a->ht[h];
5371 while( np ){
5372 if( strcmp(np->key,key)==0 ) break;
5373 np = np->next;
5374 }
5375 return np ? np->data : 0;
5376}
5377
5378/* Return the n-th data. Return NULL if n is out of range. */
icculus9e44cf12010-02-14 17:14:22 +00005379struct symbol *Symbol_Nth(int n)
drh75897232000-05-29 14:26:00 +00005380{
5381 struct symbol *data;
5382 if( x2a && n>0 && n<=x2a->count ){
5383 data = x2a->tbl[n-1].data;
5384 }else{
5385 data = 0;
5386 }
5387 return data;
5388}
5389
5390/* Return the size of the array */
5391int Symbol_count()
5392{
5393 return x2a ? x2a->count : 0;
5394}
5395
5396/* Return an array of pointers to all data in the table.
5397** The array is obtained from malloc. Return NULL if memory allocation
5398** problems, or if the array is empty. */
5399struct symbol **Symbol_arrayof()
5400{
5401 struct symbol **array;
mistachkin8e189222015-04-19 21:43:16 +00005402 int i,arrSize;
drh75897232000-05-29 14:26:00 +00005403 if( x2a==0 ) return 0;
mistachkin8e189222015-04-19 21:43:16 +00005404 arrSize = x2a->count;
5405 array = (struct symbol **)calloc(arrSize, sizeof(struct symbol *));
drh75897232000-05-29 14:26:00 +00005406 if( array ){
mistachkin8e189222015-04-19 21:43:16 +00005407 for(i=0; i<arrSize; i++) array[i] = x2a->tbl[i].data;
drh75897232000-05-29 14:26:00 +00005408 }
5409 return array;
5410}
5411
5412/* Compare two configurations */
icculus9e44cf12010-02-14 17:14:22 +00005413int Configcmp(const char *_a,const char *_b)
drh75897232000-05-29 14:26:00 +00005414{
icculus9e44cf12010-02-14 17:14:22 +00005415 const struct config *a = (struct config *) _a;
5416 const struct config *b = (struct config *) _b;
drh75897232000-05-29 14:26:00 +00005417 int x;
5418 x = a->rp->index - b->rp->index;
5419 if( x==0 ) x = a->dot - b->dot;
5420 return x;
5421}
5422
5423/* Compare two states */
icculus9e44cf12010-02-14 17:14:22 +00005424PRIVATE int statecmp(struct config *a, struct config *b)
drh75897232000-05-29 14:26:00 +00005425{
5426 int rc;
5427 for(rc=0; rc==0 && a && b; a=a->bp, b=b->bp){
5428 rc = a->rp->index - b->rp->index;
5429 if( rc==0 ) rc = a->dot - b->dot;
5430 }
5431 if( rc==0 ){
5432 if( a ) rc = 1;
5433 if( b ) rc = -1;
5434 }
5435 return rc;
5436}
5437
5438/* Hash a state */
drh01f75f22013-10-02 20:46:30 +00005439PRIVATE unsigned statehash(struct config *a)
drh75897232000-05-29 14:26:00 +00005440{
drh01f75f22013-10-02 20:46:30 +00005441 unsigned h=0;
drh75897232000-05-29 14:26:00 +00005442 while( a ){
5443 h = h*571 + a->rp->index*37 + a->dot;
5444 a = a->bp;
5445 }
5446 return h;
5447}
5448
5449/* Allocate a new state structure */
5450struct state *State_new()
5451{
icculus9e44cf12010-02-14 17:14:22 +00005452 struct state *newstate;
5453 newstate = (struct state *)calloc(1, sizeof(struct state) );
5454 MemoryCheck(newstate);
5455 return newstate;
drh75897232000-05-29 14:26:00 +00005456}
5457
5458/* There is one instance of the following structure for each
5459** associative array of type "x3".
5460*/
5461struct s_x3 {
5462 int size; /* The number of available slots. */
5463 /* Must be a power of 2 greater than or */
5464 /* equal to 1 */
5465 int count; /* Number of currently slots filled */
5466 struct s_x3node *tbl; /* The data stored here */
5467 struct s_x3node **ht; /* Hash table for lookups */
5468};
5469
5470/* There is one instance of this structure for every data element
5471** in an associative array of type "x3".
5472*/
5473typedef struct s_x3node {
5474 struct state *data; /* The data */
5475 struct config *key; /* The key */
5476 struct s_x3node *next; /* Next entry with the same hash */
5477 struct s_x3node **from; /* Previous link */
5478} x3node;
5479
5480/* There is only one instance of the array, which is the following */
5481static struct s_x3 *x3a;
5482
5483/* Allocate a new associative array */
drh14d88552017-04-14 19:44:15 +00005484void State_init(void){
drh75897232000-05-29 14:26:00 +00005485 if( x3a ) return;
5486 x3a = (struct s_x3*)malloc( sizeof(struct s_x3) );
5487 if( x3a ){
5488 x3a->size = 128;
5489 x3a->count = 0;
drh03e1b1f2014-01-11 12:52:25 +00005490 x3a->tbl = (x3node*)calloc(128, sizeof(x3node) + sizeof(x3node*));
drh75897232000-05-29 14:26:00 +00005491 if( x3a->tbl==0 ){
5492 free(x3a);
5493 x3a = 0;
5494 }else{
5495 int i;
5496 x3a->ht = (x3node**)&(x3a->tbl[128]);
5497 for(i=0; i<128; i++) x3a->ht[i] = 0;
5498 }
5499 }
5500}
5501/* Insert a new record into the array. Return TRUE if successful.
5502** Prior data with the same key is NOT overwritten */
icculus9e44cf12010-02-14 17:14:22 +00005503int State_insert(struct state *data, struct config *key)
drh75897232000-05-29 14:26:00 +00005504{
5505 x3node *np;
drh01f75f22013-10-02 20:46:30 +00005506 unsigned h;
5507 unsigned ph;
drh75897232000-05-29 14:26:00 +00005508
5509 if( x3a==0 ) return 0;
5510 ph = statehash(key);
5511 h = ph & (x3a->size-1);
5512 np = x3a->ht[h];
5513 while( np ){
5514 if( statecmp(np->key,key)==0 ){
5515 /* An existing entry with the same key is found. */
5516 /* Fail because overwrite is not allows. */
5517 return 0;
5518 }
5519 np = np->next;
5520 }
5521 if( x3a->count>=x3a->size ){
5522 /* Need to make the hash table bigger */
mistachkin8e189222015-04-19 21:43:16 +00005523 int i,arrSize;
drh75897232000-05-29 14:26:00 +00005524 struct s_x3 array;
mistachkin8e189222015-04-19 21:43:16 +00005525 array.size = arrSize = x3a->size*2;
drh75897232000-05-29 14:26:00 +00005526 array.count = x3a->count;
mistachkin8e189222015-04-19 21:43:16 +00005527 array.tbl = (x3node*)calloc(arrSize, sizeof(x3node) + sizeof(x3node*));
drh75897232000-05-29 14:26:00 +00005528 if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
mistachkin8e189222015-04-19 21:43:16 +00005529 array.ht = (x3node**)&(array.tbl[arrSize]);
5530 for(i=0; i<arrSize; i++) array.ht[i] = 0;
drh75897232000-05-29 14:26:00 +00005531 for(i=0; i<x3a->count; i++){
5532 x3node *oldnp, *newnp;
5533 oldnp = &(x3a->tbl[i]);
mistachkin8e189222015-04-19 21:43:16 +00005534 h = statehash(oldnp->key) & (arrSize-1);
drh75897232000-05-29 14:26:00 +00005535 newnp = &(array.tbl[i]);
5536 if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
5537 newnp->next = array.ht[h];
5538 newnp->key = oldnp->key;
5539 newnp->data = oldnp->data;
5540 newnp->from = &(array.ht[h]);
5541 array.ht[h] = newnp;
5542 }
5543 free(x3a->tbl);
5544 *x3a = array;
5545 }
5546 /* Insert the new data */
5547 h = ph & (x3a->size-1);
5548 np = &(x3a->tbl[x3a->count++]);
5549 np->key = key;
5550 np->data = data;
5551 if( x3a->ht[h] ) x3a->ht[h]->from = &(np->next);
5552 np->next = x3a->ht[h];
5553 x3a->ht[h] = np;
5554 np->from = &(x3a->ht[h]);
5555 return 1;
5556}
5557
5558/* Return a pointer to data assigned to the given key. Return NULL
5559** if no such key. */
icculus9e44cf12010-02-14 17:14:22 +00005560struct state *State_find(struct config *key)
drh75897232000-05-29 14:26:00 +00005561{
drh01f75f22013-10-02 20:46:30 +00005562 unsigned h;
drh75897232000-05-29 14:26:00 +00005563 x3node *np;
5564
5565 if( x3a==0 ) return 0;
5566 h = statehash(key) & (x3a->size-1);
5567 np = x3a->ht[h];
5568 while( np ){
5569 if( statecmp(np->key,key)==0 ) break;
5570 np = np->next;
5571 }
5572 return np ? np->data : 0;
5573}
5574
5575/* Return an array of pointers to all data in the table.
5576** The array is obtained from malloc. Return NULL if memory allocation
5577** problems, or if the array is empty. */
drh14d88552017-04-14 19:44:15 +00005578struct state **State_arrayof(void)
drh75897232000-05-29 14:26:00 +00005579{
5580 struct state **array;
mistachkin8e189222015-04-19 21:43:16 +00005581 int i,arrSize;
drh75897232000-05-29 14:26:00 +00005582 if( x3a==0 ) return 0;
mistachkin8e189222015-04-19 21:43:16 +00005583 arrSize = x3a->count;
5584 array = (struct state **)calloc(arrSize, sizeof(struct state *));
drh75897232000-05-29 14:26:00 +00005585 if( array ){
mistachkin8e189222015-04-19 21:43:16 +00005586 for(i=0; i<arrSize; i++) array[i] = x3a->tbl[i].data;
drh75897232000-05-29 14:26:00 +00005587 }
5588 return array;
5589}
5590
5591/* Hash a configuration */
drh01f75f22013-10-02 20:46:30 +00005592PRIVATE unsigned confighash(struct config *a)
drh75897232000-05-29 14:26:00 +00005593{
drh01f75f22013-10-02 20:46:30 +00005594 unsigned h=0;
drh75897232000-05-29 14:26:00 +00005595 h = h*571 + a->rp->index*37 + a->dot;
5596 return h;
5597}
5598
5599/* There is one instance of the following structure for each
5600** associative array of type "x4".
5601*/
5602struct s_x4 {
5603 int size; /* The number of available slots. */
5604 /* Must be a power of 2 greater than or */
5605 /* equal to 1 */
5606 int count; /* Number of currently slots filled */
5607 struct s_x4node *tbl; /* The data stored here */
5608 struct s_x4node **ht; /* Hash table for lookups */
5609};
5610
5611/* There is one instance of this structure for every data element
5612** in an associative array of type "x4".
5613*/
5614typedef struct s_x4node {
5615 struct config *data; /* The data */
5616 struct s_x4node *next; /* Next entry with the same hash */
5617 struct s_x4node **from; /* Previous link */
5618} x4node;
5619
5620/* There is only one instance of the array, which is the following */
5621static struct s_x4 *x4a;
5622
5623/* Allocate a new associative array */
drh14d88552017-04-14 19:44:15 +00005624void Configtable_init(void){
drh75897232000-05-29 14:26:00 +00005625 if( x4a ) return;
5626 x4a = (struct s_x4*)malloc( sizeof(struct s_x4) );
5627 if( x4a ){
5628 x4a->size = 64;
5629 x4a->count = 0;
drh03e1b1f2014-01-11 12:52:25 +00005630 x4a->tbl = (x4node*)calloc(64, sizeof(x4node) + sizeof(x4node*));
drh75897232000-05-29 14:26:00 +00005631 if( x4a->tbl==0 ){
5632 free(x4a);
5633 x4a = 0;
5634 }else{
5635 int i;
5636 x4a->ht = (x4node**)&(x4a->tbl[64]);
5637 for(i=0; i<64; i++) x4a->ht[i] = 0;
5638 }
5639 }
5640}
5641/* Insert a new record into the array. Return TRUE if successful.
5642** Prior data with the same key is NOT overwritten */
icculus9e44cf12010-02-14 17:14:22 +00005643int Configtable_insert(struct config *data)
drh75897232000-05-29 14:26:00 +00005644{
5645 x4node *np;
drh01f75f22013-10-02 20:46:30 +00005646 unsigned h;
5647 unsigned ph;
drh75897232000-05-29 14:26:00 +00005648
5649 if( x4a==0 ) return 0;
5650 ph = confighash(data);
5651 h = ph & (x4a->size-1);
5652 np = x4a->ht[h];
5653 while( np ){
icculus9e44cf12010-02-14 17:14:22 +00005654 if( Configcmp((const char *) np->data,(const char *) data)==0 ){
drh75897232000-05-29 14:26:00 +00005655 /* An existing entry with the same key is found. */
5656 /* Fail because overwrite is not allows. */
5657 return 0;
5658 }
5659 np = np->next;
5660 }
5661 if( x4a->count>=x4a->size ){
5662 /* Need to make the hash table bigger */
mistachkin8e189222015-04-19 21:43:16 +00005663 int i,arrSize;
drh75897232000-05-29 14:26:00 +00005664 struct s_x4 array;
mistachkin8e189222015-04-19 21:43:16 +00005665 array.size = arrSize = x4a->size*2;
drh75897232000-05-29 14:26:00 +00005666 array.count = x4a->count;
mistachkin8e189222015-04-19 21:43:16 +00005667 array.tbl = (x4node*)calloc(arrSize, sizeof(x4node) + sizeof(x4node*));
drh75897232000-05-29 14:26:00 +00005668 if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
mistachkin8e189222015-04-19 21:43:16 +00005669 array.ht = (x4node**)&(array.tbl[arrSize]);
5670 for(i=0; i<arrSize; i++) array.ht[i] = 0;
drh75897232000-05-29 14:26:00 +00005671 for(i=0; i<x4a->count; i++){
5672 x4node *oldnp, *newnp;
5673 oldnp = &(x4a->tbl[i]);
mistachkin8e189222015-04-19 21:43:16 +00005674 h = confighash(oldnp->data) & (arrSize-1);
drh75897232000-05-29 14:26:00 +00005675 newnp = &(array.tbl[i]);
5676 if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
5677 newnp->next = array.ht[h];
5678 newnp->data = oldnp->data;
5679 newnp->from = &(array.ht[h]);
5680 array.ht[h] = newnp;
5681 }
5682 free(x4a->tbl);
5683 *x4a = array;
5684 }
5685 /* Insert the new data */
5686 h = ph & (x4a->size-1);
5687 np = &(x4a->tbl[x4a->count++]);
5688 np->data = data;
5689 if( x4a->ht[h] ) x4a->ht[h]->from = &(np->next);
5690 np->next = x4a->ht[h];
5691 x4a->ht[h] = np;
5692 np->from = &(x4a->ht[h]);
5693 return 1;
5694}
5695
5696/* Return a pointer to data assigned to the given key. Return NULL
5697** if no such key. */
icculus9e44cf12010-02-14 17:14:22 +00005698struct config *Configtable_find(struct config *key)
drh75897232000-05-29 14:26:00 +00005699{
5700 int h;
5701 x4node *np;
5702
5703 if( x4a==0 ) return 0;
5704 h = confighash(key) & (x4a->size-1);
5705 np = x4a->ht[h];
5706 while( np ){
icculus9e44cf12010-02-14 17:14:22 +00005707 if( Configcmp((const char *) np->data,(const char *) key)==0 ) break;
drh75897232000-05-29 14:26:00 +00005708 np = np->next;
5709 }
5710 return np ? np->data : 0;
5711}
5712
5713/* Remove all data from the table. Pass each data to the function "f"
5714** as it is removed. ("f" may be null to avoid this step.) */
icculus9e44cf12010-02-14 17:14:22 +00005715void Configtable_clear(int(*f)(struct config *))
drh75897232000-05-29 14:26:00 +00005716{
5717 int i;
5718 if( x4a==0 || x4a->count==0 ) return;
5719 if( f ) for(i=0; i<x4a->count; i++) (*f)(x4a->tbl[i].data);
5720 for(i=0; i<x4a->size; i++) x4a->ht[i] = 0;
5721 x4a->count = 0;
5722 return;
5723}