Mercurial > hg > index.cgi
changeset 314:a3e277c58df9 ccdev
Checkpoint parser development for lwcc
Beginning of lemon based parser for C including all the infrastructure for
calling the lemon generated parser. This requires a translation layer from
the preprocessor token numbers to the lemon parser token numbers due to the
fact that lemon wants to control the token numbers. Eventually when the
lemon parser gets replaced with a hand crafted recursive descent parser,
this translation will no longer be required. However, in the interest of
getting things working sooner rather than later, using something like lemon
is beneficial.
| author | William Astle <lost@l-w.ca> |
|---|---|
| date | Sun, 17 Nov 2013 11:59:36 -0700 |
| parents | 73b2bfa17ab0 |
| children | 836dc5371980 |
| files | Makefile lwcc/parse.c lwcc/parse.h lwcc/parse_c.c lwcc/parse_c.h lwcc/parse_c.y lwcc/token_names.c lwcc/tree.c lwcc/tree.h |
| diffstat | 9 files changed, 1680 insertions(+), 7 deletions(-) [+] |
line wrap: on
line diff
--- a/Makefile Tue Nov 12 20:41:14 2013 -0700 +++ b/Makefile Sun Nov 17 11:59:36 2013 -0700 @@ -108,7 +108,8 @@ lwcc_cpp_objs := $(lwcc_cpp_srcs:.c=.o) lwcc_cpp_deps := $(lwcc_cpp_srcs:.c=.d) -lwcc_cc_srcs := cc-main.c tree.c parse.c +# parse_c.c needs to be first here +lwcc_cc_srcs := parse_c.c cc-main.c tree.c parse.c token_names.c lwcc_cc_srcs := $(addprefix lwcc/,$(lwcc_cc_srcs)) lwcc_cc_objs := $(lwcc_cc_srcs:.c=.o) lwcc_cc_deps := $(lwcc_cc_srcs:.c=.d) @@ -179,9 +180,20 @@ extra_clean := $(extra_clean) *~ */*~ +lwcc/parse_c.c lwcc/parse_c.h: lwcc/parse_c.y + rm -f lwcc/parse_c.h lwcc/parse_c.c + lemon -q lwcc/parse_c.y + +lwcc/token_names.c: lwcc/parse_c.h + echo "char *ptoken_names[] = {" > $@ + echo '"TOKEN_NONE",' >> $@ + cat lwcc/parse_c.h | sed -e 's/#define \(.*\) .*$$/"\1",/g' -e 's/ //g' >> $@ + echo '"" };' >> $@ + + %.o: %.c @echo "Building dependencies for $@" - @$(CC) -MM $(CPPFLAGS) -o $*.d $< + @$(CC) -MM -MG $(CPPFLAGS) -o $*.d $< @mv -f $*.d $*.d.tmp @sed -e 's|.*:|$*.o $*.d:|' < $*.d.tmp > $*.d @sed -e 's/.*://' -e 's/\\$$//' < $*.d.tmp | fmt -1 | sed -e 's/^ *//' -e 's/$$/:/' >> $*.d
--- a/lwcc/parse.c Tue Nov 12 20:41:14 2013 -0700 +++ b/lwcc/parse.c Sun Nov 17 11:59:36 2013 -0700 @@ -19,10 +19,225 @@ this program. If not, see <http://www.gnu.org/licenses/>. */ +#include <stdio.h> +#include <string.h> +#include <lw_alloc.h> +#include <lw_string.h> + #include "cpp.h" #include "tree.h" +#include "parse.h" + +#include "parse_c.h" + + +void *Parse(void *parser, int tokid, struct tokendata *tdata, struct parserinfo *pi); +void *ParseAlloc(void *(*alloc)(size_t size)); +void ParseFree(void *parser, void (*free)(void *ptr)); + +void tokendata_free(struct tokendata *td) +{ + if (td) + { + if (td -> strval) + lw_free(td -> strval); + lw_free(td); + } +} + +extern char *ptoken_names[]; +char *tokendata_name(struct tokendata *td) +{ + if (td -> tokid < 0) + return "****UNKNOWN****"; + return ptoken_names[td -> tokid]; +} + +void tokendata_print(FILE *fp, struct tokendata *td) +{ + fprintf(fp, "TOKEN: %s", tokendata_name(td)); + if (td -> strval) + fprintf(fp, " \"%s\"", td -> strval); + fprintf(fp, "\n"); +} + +#define TOK_KW_IF -1 +#define TOK_KW_ELSE -2 +#define TOK_KW_WHILE -3 +#define TOK_KW_DO -4 +#define TOK_KW_FOR -5 +#define TOK_KW_VOID -6 +#define TOK_KW_INT -7 +#define TOK_KW_CHAR -8 +#define TOK_KW_SHORT -9 +#define TOK_KW_LONG -10 +#define TOK_KW_UNSIGNED -11 +#define TOK_KW_SIGNED -12 +#define TOK_KW_FLOAT -13 +#define TOK_KW_DOUBLE -14 +#define TOK_KW_STRUCT -15 +#define TOK_KW_UNION -16 +#define TOK_KW_TYPEDEF -17 +#define TOK_KW_STATIC -18 +#define TOK_KW_SWITCH -19 +#define TOK_KW_CASE -20 +#define TOK_KW_DEFAULT -21 +#define TOK_KW_BREAK -22 +#define TOK_KW_CONTINUE -23 +#define TOK_KW_CONST -24 +#define TOK_KW_AUTO -25 +#define TOK_KW_ENUM -26 +#define TOK_KW_REGISTER -27 +#define TOK_KW_SIZEOF -28 +#define TOK_KW_VOLATILE -29 +#define TOK_KW_RETURN -30 +#define TOK_KW_EXTERN -31 +#define TOK_KW_GOTO -32 +#define TOK_TYPENAME -100 + +static struct { int tok; char *word; } keyword_list[] = { + { TOK_KW_IF, "if" }, + { TOK_KW_ELSE, "else" }, + { TOK_KW_WHILE, "while" }, + { TOK_KW_DO, "do" }, + { TOK_KW_FOR, "for" }, + { TOK_KW_VOID, "void" }, + { TOK_KW_INT, "int" }, + { TOK_KW_CHAR, "char" }, + { TOK_KW_SHORT, "short" }, + { TOK_KW_LONG, "long" }, + { TOK_KW_UNSIGNED, "unsigned" }, + { TOK_KW_SIGNED, "signed" }, + { TOK_KW_FLOAT, "float" }, + { TOK_KW_DOUBLE, "double" }, + { TOK_KW_STRUCT, "struct" }, + { TOK_KW_UNION, "union" }, + { TOK_KW_TYPEDEF, "typedef" }, + { TOK_KW_STATIC, "static" }, + { TOK_KW_SWITCH, "switch" }, + { TOK_KW_CASE, "case" }, + { TOK_KW_DEFAULT, "default" }, + { TOK_KW_BREAK, "break" }, + { TOK_KW_CONTINUE, "continue" }, + { TOK_KW_CONST, "const" }, + { TOK_KW_AUTO, "auto" }, + { TOK_KW_ENUM, "enum" }, + { TOK_KW_REGISTER, "register" }, + { TOK_KW_SIZEOF, "sizeof" }, + { TOK_KW_VOLATILE, "volatile" }, + { TOK_KW_RETURN, "return" }, + { TOK_KW_EXTERN, "extern" }, + { TOK_KW_GOTO, "goto" }, + { 0, "" } +}; + +struct token *parse_next(struct preproc_info *pp) +{ + struct token *tok; + int i; + + for (;;) + { + tok = preproc_next(pp); + if (tok -> ttype == TOK_WSPACE) + continue; + if (tok -> ttype == TOK_EOL) + continue; + if (tok -> ttype == TOK_CHAR) + { + // random character + fprintf(stderr, "Random character %02x\n", tok -> strval[0]); + if (tok -> strval[0] < 32 || tok -> strval[0] > 126) + continue; + } + break; + } + if (tok -> ttype == TOK_IDENT) + { + /* convert identifier tokens to their respective meanings */ + for (i = 0; keyword_list[i].tok != TOK_NONE; i++) + { + if (strcmp(keyword_list[i].word, tok -> strval) == 0) + { + tok -> ttype = keyword_list[i].tok; + goto out; + } + } + /* check for a registered type here */ + } +out: + fprintf(stderr, "Lexed: "); + token_print(tok, stderr); + fprintf(stderr, " (%d)\n", tok -> ttype); + return tok; +} + +static struct { + int tokid; + int ttype; +} toktable[] = { + { PTOK_IDENTIFIER, TOK_IDENT }, + { PTOK_ENDS, TOK_EOS }, + { PTOK_KW_INT, TOK_KW_INT }, + { PTOK_KW_LONG, TOK_KW_LONG }, + { PTOK_KW_SHORT, TOK_KW_SHORT }, + { PTOK_KW_CHAR, TOK_KW_CHAR }, + { PTOK_KW_SIGNED, TOK_KW_SIGNED }, + { PTOK_KW_UNSIGNED, TOK_KW_UNSIGNED }, + { PTOK_STAR, TOK_STAR }, + { PTOK_KW_VOID, TOK_KW_VOID }, + { PTOK_KW_FLOAT, TOK_KW_FLOAT }, + { PTOK_KW_DOUBLE, TOK_KW_DOUBLE }, + { PTOK_OBRACE, TOK_OBRACE }, + { PTOK_CBRACE, TOK_CBRACE }, + { PTOK_OPAREN, TOK_OPAREN }, + { PTOK_CPAREN, TOK_CPAREN }, + { 0, 0 } +}; + +static int lookup_ptok(int ttype) +{ + int i; + for (i = 0; toktable[i].tokid != 0; i++) + if (toktable[i].ttype == ttype) + return toktable[i].tokid; + return -1; +} node_t *parse_program(struct preproc_info *pp) { - return node_create(NODE_NONE); + struct token *tok; + struct tokendata *td; + struct parserinfo pi = { NULL }; + void *parser; + + /* the cast below shuts up a warning */ + parser = ParseAlloc((void *)lw_alloc); + for (;;) + { + tok = parse_next(pp); + if (tok -> ttype == TOK_EOF) + break; + + td = lw_alloc(sizeof(struct tokendata)); + td -> strval = NULL; + td -> numval[0] = 0; + td -> numval[1] = 0; + td -> numval[2] = 0; + td -> numval[3] = 0; + td -> numval[4] = 0; + td -> numval[5] = 0; + td -> numval[6] = 0; + td -> numval[7] = 0; + td -> tokid = lookup_ptok(tok -> ttype); + if (tok -> strval) + td -> strval = lw_strdup(tok -> strval); + + tokendata_print(stderr, td); + + Parse(parser, td -> tokid, td, &pi); + } + Parse(parser, 0, NULL, &pi); + ParseFree(parser, lw_free); + return pi.parsetree; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lwcc/parse.h Sun Nov 17 11:59:36 2013 -0700 @@ -0,0 +1,46 @@ +/* +lwcc/parse.h + +Copyright © 2013 William Astle + +This file is part of LWTOOLS. + +LWTOOLS is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free Software +Foundation, either version 3 of the License, or (at your option) any later +version. + +This program is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +more details. + +You should have received a copy of the GNU General Public License along with +this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef parse_h_seen__ +#define parse_h_seen__ + +#include <stdio.h> +#include "tree.h" + +struct tokendata +{ + int tokid; + unsigned char numval[8]; + char *strval; +}; + + +extern void tokendata_free(struct tokendata *td); + +struct parserinfo +{ + node_t *parsetree; +}; + +extern char *tokendata_name(struct tokendata *td); +extern void tokendata_print(FILE *fp, struct tokendata *td); + +#endif // parse_h_seen__
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lwcc/parse_c.c Sun Nov 17 11:59:36 2013 -0700 @@ -0,0 +1,1199 @@ +/* Driver template for the LEMON parser generator. +** The author disclaims copyright to this source code. +*/ +/* First off, code is included that follows the "include" declaration +** in the input grammar file. */ +#include <stdio.h> +#line 1 "lwcc/parse_c.y" + +#include <assert.h> // only needed due to a bug in lemon +#include <stdio.h> +#include "parse.h" +#include "tree.h" +#line 14 "lwcc/parse_c.c" +/* Next is all token values, in a form suitable for use by makeheaders. +** This section will be null unless lemon is run with the -m switch. +*/ +/* +** These constants (all generated automatically by the parser generator) +** specify the various kinds of tokens (terminals) that the parser +** understands. +** +** Each symbol here is a terminal symbol in the grammar. +*/ +/* Make sure the INTERFACE macro is defined. +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/* The next thing included is series of defines which control +** various aspects of the generated parser. +** YYCODETYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 terminals +** and nonterminals. "int" is used otherwise. +** YYNOCODE is a number of type YYCODETYPE which corresponds +** to no legal terminal or nonterminal number. This +** number is used to fill in empty slots of the hash +** table. +** YYFALLBACK If defined, this indicates that one or more tokens +** have fall-back values which should be used if the +** original value of the token will not parse. +** YYACTIONTYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 rules and +** states combined. "int" is used otherwise. +** ParseTOKENTYPE is the data type used for minor tokens given +** directly to the parser from the tokenizer. +** YYMINORTYPE is the data type used for all minor tokens. +** This is typically a union of many types, one of +** which is ParseTOKENTYPE. The entry in the union +** for base tokens is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. If +** zero the stack is dynamically sized using realloc() +** ParseARG_SDECL A static variable declaration for the %extra_argument +** ParseARG_PDECL A parameter declaration for the %extra_argument +** ParseARG_STORE Code to store %extra_argument into yypParser +** ParseARG_FETCH Code to extract %extra_argument from yypParser +** YYNSTATE the combined number of states. +** YYNRULE the number of rules in the grammar +** YYERRORSYMBOL is the code number of the error symbol. If not +** defined, then do no error processing. +*/ +#define YYCODETYPE unsigned char +#define YYNOCODE 30 +#define YYACTIONTYPE unsigned char +#define ParseTOKENTYPE struct tokendata * +typedef union { + int yyinit; + ParseTOKENTYPE yy0; + node_t * yy18; +} YYMINORTYPE; +#ifndef YYSTACKDEPTH +#define YYSTACKDEPTH 100 +#endif +#define ParseARG_SDECL struct parserinfo *pinfo ; +#define ParseARG_PDECL , struct parserinfo *pinfo +#define ParseARG_FETCH struct parserinfo *pinfo = yypParser->pinfo +#define ParseARG_STORE yypParser->pinfo = pinfo +#define YYNSTATE 36 +#define YYNRULE 30 +#define YY_NO_ACTION (YYNSTATE+YYNRULE+2) +#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1) +#define YY_ERROR_ACTION (YYNSTATE+YYNRULE) + +/* The yyzerominor constant is used to initialize instances of +** YYMINORTYPE objects to zero. */ +static const YYMINORTYPE yyzerominor = { 0 }; + +/* Define the yytestcase() macro to be a no-op if is not already defined +** otherwise. +** +** Applications can choose to define yytestcase() in the %include section +** to a macro that can assist in verifying code coverage. For production +** code the yytestcase() macro should be turned off. But it is useful +** for testing. +*/ +#ifndef yytestcase +# define yytestcase(X) +#endif + + +/* Next are the tables used to determine what action to take based on the +** current state and lookahead token. These tables are used to implement +** functions that take a state number and lookahead value and return an +** action integer. +** +** Suppose the action integer is N. Then the action is determined as +** follows +** +** 0 <= N < YYNSTATE Shift N. That is, push the lookahead +** token onto the stack and goto state N. +** +** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE. +** +** N == YYNSTATE+YYNRULE A syntax error has occurred. +** +** N == YYNSTATE+YYNRULE+1 The parser accepts its input. +** +** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused +** slots in the yy_action[] table. +** +** The action table is constructed as a single large table named yy_action[]. +** Given state S and lookahead X, the action is computed as +** +** yy_action[ yy_shift_ofst[S] + X ] +** +** If the index value yy_shift_ofst[S]+X is out of range or if the value +** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S] +** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table +** and that yy_default[S] should be used instead. +** +** The formula above is for computing the action when the lookahead is +** a terminal symbol. If the lookahead is a non-terminal (as occurs after +** a reduce action) then the yy_reduce_ofst[] array is used in place of +** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of +** YY_SHIFT_USE_DFLT. +** +** The following are the tables generated in this section: +** +** yy_action[] A single table containing all actions. +** yy_lookahead[] A table containing the lookahead for each entry in +** yy_action. Used to detect hash collisions. +** yy_shift_ofst[] For each state, the offset into yy_action for +** shifting terminals. +** yy_reduce_ofst[] For each state, the offset into yy_action for +** shifting non-terminals after a reduce. +** yy_default[] Default action for each state. +*/ +#define YY_ACTTAB_COUNT (44) +static const YYACTIONTYPE yy_action[] = { + /* 0 */ 36, 27, 26, 29, 24, 23, 22, 7, 3, 2, + /* 10 */ 16, 9, 14, 35, 34, 33, 6, 8, 25, 18, + /* 20 */ 16, 9, 14, 21, 10, 10, 32, 20, 20, 30, + /* 30 */ 67, 1, 19, 28, 15, 5, 4, 68, 11, 68, + /* 40 */ 17, 31, 13, 12, +}; +static const YYCODETYPE yy_lookahead[] = { + /* 0 */ 0, 2, 3, 16, 4, 5, 6, 7, 8, 9, + /* 10 */ 10, 11, 12, 20, 21, 22, 23, 7, 25, 26, + /* 20 */ 10, 11, 12, 6, 7, 7, 1, 10, 10, 1, + /* 30 */ 18, 19, 10, 14, 10, 24, 27, 29, 13, 29, + /* 40 */ 26, 28, 26, 15, +}; +#define YY_SHIFT_USE_DFLT (-14) +#define YY_SHIFT_COUNT (12) +#define YY_SHIFT_MIN (-13) +#define YY_SHIFT_MAX (28) +static const signed char yy_shift_ofst[] = { + /* 0 */ -14, 0, 10, 10, 28, 25, -1, 17, 18, 24, + /* 10 */ 22, 19, -13, +}; +#define YY_REDUCE_USE_DFLT (-8) +#define YY_REDUCE_COUNT (6) +#define YY_REDUCE_MIN (-7) +#define YY_REDUCE_MAX (16) +static const signed char yy_reduce_ofst[] = { + /* 0 */ 12, -7, 16, 14, 13, 9, 11, +}; +static const YYACTIONTYPE yy_default[] = { + /* 0 */ 38, 66, 51, 50, 66, 66, 66, 55, 55, 58, + /* 10 */ 57, 66, 66, 52, 61, 60, 54, 53, 49, 59, + /* 20 */ 56, 48, 47, 46, 45, 43, 44, 42, 64, 65, + /* 30 */ 63, 62, 41, 40, 39, 37, +}; + +/* The next table maps tokens into fallback tokens. If a construct +** like the following: +** +** %fallback ID X Y Z. +** +** appears in the grammar, then ID becomes a fallback token for X, Y, +** and Z. Whenever one of the tokens X, Y, or Z is input to the parser +** but it does not parse, the type of the token is changed to ID and +** the parse is retried before an error is thrown. +*/ +#ifdef YYFALLBACK +static const YYCODETYPE yyFallback[] = { +}; +#endif /* YYFALLBACK */ + +/* The following structure represents a single element of the +** parser's stack. Information stored includes: +** +** + The state number for the parser at this level of the stack. +** +** + The value of the token stored at this level of the stack. +** (In other words, the "major" token.) +** +** + The semantic value stored at this level of the stack. This is +** the information used by the action routines in the grammar. +** It is sometimes called the "minor" token. +*/ +struct yyStackEntry { + YYACTIONTYPE stateno; /* The state-number */ + YYCODETYPE major; /* The major token value. This is the code + ** number for the token at this stack level */ + YYMINORTYPE minor; /* The user-supplied minor token value. This + ** is the value of the token */ +}; +typedef struct yyStackEntry yyStackEntry; + +/* The state of the parser is completely contained in an instance of +** the following structure */ +struct yyParser { + int yyidx; /* Index of top element in stack */ +#ifdef YYTRACKMAXSTACKDEPTH + int yyidxMax; /* Maximum value of yyidx */ +#endif + int yyerrcnt; /* Shifts left before out of the error */ + ParseARG_SDECL /* A place to hold %extra_argument */ +#if YYSTACKDEPTH<=0 + int yystksz; /* Current side of the stack */ + yyStackEntry *yystack; /* The parser's stack */ +#else + yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ +#endif +}; +typedef struct yyParser yyParser; + +#ifndef NDEBUG +#include <stdio.h> +static FILE *yyTraceFILE = 0; +static char *yyTracePrompt = 0; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Turn parser tracing on by giving a stream to which to write the trace +** and a prompt to preface each trace message. Tracing is turned off +** by making either argument NULL +** +** Inputs: +** <ul> +** <li> A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +** <li> A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +** </ul> +** +** Outputs: +** None. +*/ +void ParseTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *const yyTokenName[] = { + "$", "ENDS", "IDENTIFIER", "STAR", + "KW_VOID", "KW_FLOAT", "KW_DOUBLE", "KW_LONG", + "KW_UNSIGNED", "KW_SIGNED", "KW_INT", "KW_SHORT", + "KW_CHAR", "OPAREN", "CPAREN", "OBRACE", + "CBRACE", "error", "program", "rprogram", + "globaldecl", "vardecl", "fundecl", "datatype", + "ident", "typename", "baseint", "arglist", + "statementblock", +}; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *const yyRuleName[] = { + /* 0 */ "program ::= rprogram", + /* 1 */ "rprogram ::= rprogram globaldecl", + /* 2 */ "rprogram ::=", + /* 3 */ "globaldecl ::= vardecl", + /* 4 */ "globaldecl ::= fundecl", + /* 5 */ "vardecl ::= datatype ident ENDS", + /* 6 */ "ident ::= IDENTIFIER", + /* 7 */ "datatype ::= typename", + /* 8 */ "datatype ::= datatype STAR", + /* 9 */ "typename ::= KW_VOID", + /* 10 */ "typename ::= KW_FLOAT", + /* 11 */ "typename ::= KW_DOUBLE", + /* 12 */ "typename ::= KW_LONG KW_DOUBLE", + /* 13 */ "typename ::= baseint", + /* 14 */ "typename ::= KW_UNSIGNED", + /* 15 */ "typename ::= KW_SIGNED", + /* 16 */ "typename ::= KW_SIGNED baseint", + /* 17 */ "typename ::= KW_UNSIGNED baseint", + /* 18 */ "baseint ::= KW_INT", + /* 19 */ "baseint ::= KW_LONG", + /* 20 */ "baseint ::= KW_LONG KW_INT", + /* 21 */ "baseint ::= KW_LONG KW_LONG", + /* 22 */ "baseint ::= KW_SHORT", + /* 23 */ "baseint ::= KW_LONG KW_LONG KW_INT", + /* 24 */ "baseint ::= KW_SHORT KW_INT", + /* 25 */ "baseint ::= KW_CHAR", + /* 26 */ "fundecl ::= datatype ident arglist statementblock", + /* 27 */ "fundecl ::= datatype ident arglist ENDS", + /* 28 */ "arglist ::= OPAREN CPAREN", + /* 29 */ "statementblock ::= OBRACE CBRACE", +}; +#endif /* NDEBUG */ + + +#if YYSTACKDEPTH<=0 +/* +** Try to increase the size of the parser stack. +*/ +static void yyGrowStack(yyParser *p){ + int newSize; + yyStackEntry *pNew; + + newSize = p->yystksz*2 + 100; + pNew = realloc(p->yystack, newSize*sizeof(pNew[0])); + if( pNew ){ + p->yystack = pNew; + p->yystksz = newSize; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack grows to %d entries!\n", + yyTracePrompt, p->yystksz); + } +#endif + } +} +#endif + +/* +** This function allocates a new parser. +** The only argument is a pointer to a function which works like +** malloc. +** +** Inputs: +** A pointer to the function used to allocate memory. +** +** Outputs: +** A pointer to a parser. This pointer is used in subsequent calls +** to Parse and ParseFree. +*/ +void *ParseAlloc(void *(*mallocProc)(size_t)){ + yyParser *pParser; + pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) ); + if( pParser ){ + pParser->yyidx = -1; +#ifdef YYTRACKMAXSTACKDEPTH + pParser->yyidxMax = 0; +#endif +#if YYSTACKDEPTH<=0 + pParser->yystack = NULL; + pParser->yystksz = 0; + yyGrowStack(pParser); +#endif + } + return pParser; +} + +/* The following function deletes the value associated with a +** symbol. The symbol can be either a terminal or nonterminal. +** "yymajor" is the symbol code, and "yypminor" is a pointer to +** the value. +*/ +static void yy_destructor( + yyParser *yypParser, /* The parser */ + YYCODETYPE yymajor, /* Type code for object to destroy */ + YYMINORTYPE *yypminor /* The object to be destroyed */ +){ + ParseARG_FETCH; + switch( yymajor ){ + /* Here is inserted the actions which take place when a + ** terminal or non-terminal is destroyed. This can happen + ** when the symbol is popped from the stack during a + ** reduce or during error processing or when a parser is + ** being destroyed before it is finished parsing. + ** + ** Note: during a reduce, the only symbols destroyed are those + ** which appear on the RHS of the rule, but which are not used + ** inside the C code. + */ + /* TERMINAL Destructor */ + case 1: /* ENDS */ + case 2: /* IDENTIFIER */ + case 3: /* STAR */ + case 4: /* KW_VOID */ + case 5: /* KW_FLOAT */ + case 6: /* KW_DOUBLE */ + case 7: /* KW_LONG */ + case 8: /* KW_UNSIGNED */ + case 9: /* KW_SIGNED */ + case 10: /* KW_INT */ + case 11: /* KW_SHORT */ + case 12: /* KW_CHAR */ + case 13: /* OPAREN */ + case 14: /* CPAREN */ + case 15: /* OBRACE */ + case 16: /* CBRACE */ +{ +#line 10 "lwcc/parse_c.y" + tokendata_free((yypminor->yy0)); +#line 420 "lwcc/parse_c.c" +} + break; + default: break; /* If no destructor action specified: do nothing */ + } +} + +/* +** Pop the parser's stack once. +** +** If there is a destructor routine associated with the token which +** is popped from the stack, then call it. +** +** Return the major token number for the symbol popped. +*/ +static int yy_pop_parser_stack(yyParser *pParser){ + YYCODETYPE yymajor; + yyStackEntry *yytos = &pParser->yystack[pParser->yyidx]; + + if( pParser->yyidx<0 ) return 0; +#ifndef NDEBUG + if( yyTraceFILE && pParser->yyidx>=0 ){ + fprintf(yyTraceFILE,"%sPopping %s\n", + yyTracePrompt, + yyTokenName[yytos->major]); + } +#endif + yymajor = yytos->major; + yy_destructor(pParser, yymajor, &yytos->minor); + pParser->yyidx--; + return yymajor; +} + +/* +** Deallocate and destroy a parser. Destructors are all called for +** all stack elements before shutting the parser down. +** +** Inputs: +** <ul> +** <li> A pointer to the parser. This should be a pointer +** obtained from ParseAlloc. +** <li> A pointer to a function used to reclaim memory obtained +** from malloc. +** </ul> +*/ +void ParseFree( + void *p, /* The parser to be deleted */ + void (*freeProc)(void*) /* Function used to reclaim memory */ +){ + yyParser *pParser = (yyParser*)p; + if( pParser==0 ) return; + while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser); +#if YYSTACKDEPTH<=0 + free(pParser->yystack); +#endif + (*freeProc)((void*)pParser); +} + +/* +** Return the peak depth of the stack for a parser. +*/ +#ifdef YYTRACKMAXSTACKDEPTH +int ParseStackPeak(void *p){ + yyParser *pParser = (yyParser*)p; + return pParser->yyidxMax; +} +#endif + +/* +** Find the appropriate action for a parser given the terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_shift_action( + yyParser *pParser, /* The parser */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; + int stateno = pParser->yystack[pParser->yyidx].stateno; + + if( stateno>YY_SHIFT_COUNT + || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){ + return yy_default[stateno]; + } + assert( iLookAhead!=YYNOCODE ); + i += iLookAhead; + if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ + if( iLookAhead>0 ){ +#ifdef YYFALLBACK + YYCODETYPE iFallback; /* Fallback token */ + if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) + && (iFallback = yyFallback[iLookAhead])!=0 ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + return yy_find_shift_action(pParser, iFallback); + } +#endif +#ifdef YYWILDCARD + { + int j = i - iLookAhead + YYWILDCARD; + if( +#if YY_SHIFT_MIN+YYWILDCARD<0 + j>=0 && +#endif +#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT + j<YY_ACTTAB_COUNT && +#endif + yy_lookahead[j]==YYWILDCARD + ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]); + } +#endif /* NDEBUG */ + return yy_action[j]; + } + } +#endif /* YYWILDCARD */ + } + return yy_default[stateno]; + }else{ + return yy_action[i]; + } +} + +/* +** Find the appropriate action for a parser given the non-terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_reduce_action( + int stateno, /* Current state number */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; +#ifdef YYERRORSYMBOL + if( stateno>YY_REDUCE_COUNT ){ + return yy_default[stateno]; + } +#else + assert( stateno<=YY_REDUCE_COUNT ); +#endif + i = yy_reduce_ofst[stateno]; + assert( i!=YY_REDUCE_USE_DFLT ); + assert( iLookAhead!=YYNOCODE ); + i += iLookAhead; +#ifdef YYERRORSYMBOL + if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ + return yy_default[stateno]; + } +#else + assert( i>=0 && i<YY_ACTTAB_COUNT ); + assert( yy_lookahead[i]==iLookAhead ); +#endif + return yy_action[i]; +} + +/* +** The following routine is called if the stack overflows. +*/ +static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){ + ParseARG_FETCH; + yypParser->yyidx--; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will execute if the parser + ** stack every overflows */ +#line 90 "lwcc/parse_c.y" + + fprintf(stderr, "Parser stack overflow\n"); +#line 605 "lwcc/parse_c.c" + ParseARG_STORE; /* Suppress warning about unused %extra_argument var */ +} + +/* +** Perform a shift action. +*/ +static void yy_shift( + yyParser *yypParser, /* The parser to be shifted */ + int yyNewState, /* The new state to shift in */ + int yyMajor, /* The major token to shift in */ + YYMINORTYPE *yypMinor /* Pointer to the minor token to shift in */ +){ + yyStackEntry *yytos; + yypParser->yyidx++; +#ifdef YYTRACKMAXSTACKDEPTH + if( yypParser->yyidx>yypParser->yyidxMax ){ + yypParser->yyidxMax = yypParser->yyidx; + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yyidx>=YYSTACKDEPTH ){ + yyStackOverflow(yypParser, yypMinor); + return; + } +#else + if( yypParser->yyidx>=yypParser->yystksz ){ + yyGrowStack(yypParser); + if( yypParser->yyidx>=yypParser->yystksz ){ + yyStackOverflow(yypParser, yypMinor); + return; + } + } +#endif + yytos = &yypParser->yystack[yypParser->yyidx]; + yytos->stateno = (YYACTIONTYPE)yyNewState; + yytos->major = (YYCODETYPE)yyMajor; + yytos->minor = *yypMinor; +#ifndef NDEBUG + if( yyTraceFILE && yypParser->yyidx>0 ){ + int i; + fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState); + fprintf(yyTraceFILE,"%sStack:",yyTracePrompt); + for(i=1; i<=yypParser->yyidx; i++) + fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]); + fprintf(yyTraceFILE,"\n"); + } +#endif +} + +/* The following table contains information about every rule that +** is used during the reduce. +*/ +static const struct { + YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ + unsigned char nrhs; /* Number of right-hand side symbols in the rule */ +} yyRuleInfo[] = { + { 18, 1 }, + { 19, 2 }, + { 19, 0 }, + { 20, 1 }, + { 20, 1 }, + { 21, 3 }, + { 24, 1 }, + { 23, 1 }, + { 23, 2 }, + { 25, 1 }, + { 25, 1 }, + { 25, 1 }, + { 25, 2 }, + { 25, 1 }, + { 25, 1 }, + { 25, 1 }, + { 25, 2 }, + { 25, 2 }, + { 26, 1 }, + { 26, 1 }, + { 26, 2 }, + { 26, 2 }, + { 26, 1 }, + { 26, 3 }, + { 26, 2 }, + { 26, 1 }, + { 22, 4 }, + { 22, 4 }, + { 27, 2 }, + { 28, 2 }, +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +*/ +static void yy_reduce( + yyParser *yypParser, /* The parser */ + int yyruleno /* Number of the rule by which to reduce */ +){ + int yygoto; /* The next state */ + int yyact; /* The next action */ + YYMINORTYPE yygotominor; /* The LHS of the rule reduced */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + ParseARG_FETCH; + yymsp = &yypParser->yystack[yypParser->yyidx]; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno>=0 + && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ + fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt, + yyRuleName[yyruleno]); + } +#endif /* NDEBUG */ + + /* Silence complaints from purify about yygotominor being uninitialized + ** in some cases when it is copied into the stack after the following + ** switch. yygotominor is uninitialized when a rule reduces that does + ** not set the value of its left-hand side nonterminal. Leaving the + ** value of the nonterminal uninitialized is utterly harmless as long + ** as the value is never used. So really the only thing this code + ** accomplishes is to quieten purify. + ** + ** 2007-01-16: The wireshark project (www.wireshark.org) reports that + ** without this code, their parser segfaults. I'm not sure what there + ** parser is doing to make this happen. This is the second bug report + ** from wireshark this week. Clearly they are stressing Lemon in ways + ** that it has not been previously stressed... (SQLite ticket #2172) + */ + /*memset(&yygotominor, 0, sizeof(yygotominor));*/ + yygotominor = yyzerominor; + + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line <lineno> <grammarfile> + ** { ... } // User supplied code + ** #line <lineno> <thisfile> + ** break; + */ + case 0: /* program ::= rprogram */ +#line 14 "lwcc/parse_c.y" +{ yygotominor.yy18 = yymsp[0].minor.yy18; pinfo -> parsetree = yygotominor.yy18; } +#line 749 "lwcc/parse_c.c" + break; + case 1: /* rprogram ::= rprogram globaldecl */ +#line 16 "lwcc/parse_c.y" +{ + yygotominor.yy18 = yymsp[-1].minor.yy18; + node_addchild(yygotominor.yy18, yymsp[0].minor.yy18); +} +#line 757 "lwcc/parse_c.c" + break; + case 2: /* rprogram ::= */ +#line 20 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_PROGRAM); } +#line 762 "lwcc/parse_c.c" + break; + case 3: /* globaldecl ::= vardecl */ + case 4: /* globaldecl ::= fundecl */ yytestcase(yyruleno==4); + case 7: /* datatype ::= typename */ yytestcase(yyruleno==7); + case 13: /* typename ::= baseint */ yytestcase(yyruleno==13); +#line 22 "lwcc/parse_c.y" +{ yygotominor.yy18 = yymsp[0].minor.yy18; } +#line 770 "lwcc/parse_c.c" + break; + case 5: /* vardecl ::= datatype ident ENDS */ +#line 25 "lwcc/parse_c.y" +{ + yygotominor.yy18 = node_create(NODE_DECL, yymsp[-2].minor.yy18, yymsp[-1].minor.yy18); + yy_destructor(yypParser,1,&yymsp[0].minor); +} +#line 778 "lwcc/parse_c.c" + break; + case 6: /* ident ::= IDENTIFIER */ +#line 29 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_IDENT, yymsp[0].minor.yy0 -> strval); } +#line 783 "lwcc/parse_c.c" + break; + case 8: /* datatype ::= datatype STAR */ +#line 32 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_PTR, yymsp[-1].minor.yy18); yy_destructor(yypParser,3,&yymsp[0].minor); +} +#line 789 "lwcc/parse_c.c" + break; + case 9: /* typename ::= KW_VOID */ +#line 34 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_VOID); yy_destructor(yypParser,4,&yymsp[0].minor); +} +#line 795 "lwcc/parse_c.c" + break; + case 10: /* typename ::= KW_FLOAT */ +#line 35 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_FLOAT); yy_destructor(yypParser,5,&yymsp[0].minor); +} +#line 801 "lwcc/parse_c.c" + break; + case 11: /* typename ::= KW_DOUBLE */ +#line 36 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_DOUBLE); yy_destructor(yypParser,6,&yymsp[0].minor); +} +#line 807 "lwcc/parse_c.c" + break; + case 12: /* typename ::= KW_LONG KW_DOUBLE */ +#line 37 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_LDOUBLE); yy_destructor(yypParser,7,&yymsp[-1].minor); + yy_destructor(yypParser,6,&yymsp[0].minor); +} +#line 814 "lwcc/parse_c.c" + break; + case 14: /* typename ::= KW_UNSIGNED */ +#line 39 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_UINT); yy_destructor(yypParser,8,&yymsp[0].minor); +} +#line 820 "lwcc/parse_c.c" + break; + case 15: /* typename ::= KW_SIGNED */ +#line 40 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_INT); yy_destructor(yypParser,9,&yymsp[0].minor); +} +#line 826 "lwcc/parse_c.c" + break; + case 16: /* typename ::= KW_SIGNED baseint */ +#line 41 "lwcc/parse_c.y" +{ yygotominor.yy18 = yymsp[0].minor.yy18; if (yygotominor.yy18 -> type == NODE_TYPE_CHAR) yygotominor.yy18 -> type = NODE_TYPE_SCHAR; yy_destructor(yypParser,9,&yymsp[-1].minor); +} +#line 832 "lwcc/parse_c.c" + break; + case 17: /* typename ::= KW_UNSIGNED baseint */ +#line 42 "lwcc/parse_c.y" +{ + yygotominor.yy18 = yymsp[0].minor.yy18; + switch (yygotominor.yy18 -> type) + { + case NODE_TYPE_CHAR: + yygotominor.yy18 -> type = NODE_TYPE_UCHAR; + break; + case NODE_TYPE_SHORT: + yygotominor.yy18 -> type = NODE_TYPE_USHORT; + break; + case NODE_TYPE_INT: + yygotominor.yy18 -> type = NODE_TYPE_UINT; + break; + case NODE_TYPE_LONG: + yygotominor.yy18 -> type = NODE_TYPE_ULONG; + break; + case NODE_TYPE_LONGLONG: + yygotominor.yy18 -> type = NODE_TYPE_ULONGLONG; + break; + } + yy_destructor(yypParser,8,&yymsp[-1].minor); +} +#line 858 "lwcc/parse_c.c" + break; + case 18: /* baseint ::= KW_INT */ +#line 64 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_INT); yy_destructor(yypParser,10,&yymsp[0].minor); +} +#line 864 "lwcc/parse_c.c" + break; + case 19: /* baseint ::= KW_LONG */ +#line 65 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_LONG); yy_destructor(yypParser,7,&yymsp[0].minor); +} +#line 870 "lwcc/parse_c.c" + break; + case 20: /* baseint ::= KW_LONG KW_INT */ +#line 66 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_LONG); yy_destructor(yypParser,7,&yymsp[-1].minor); + yy_destructor(yypParser,10,&yymsp[0].minor); +} +#line 877 "lwcc/parse_c.c" + break; + case 21: /* baseint ::= KW_LONG KW_LONG */ +#line 67 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_LONGLONG); yy_destructor(yypParser,7,&yymsp[-1].minor); + yy_destructor(yypParser,7,&yymsp[0].minor); +} +#line 884 "lwcc/parse_c.c" + break; + case 22: /* baseint ::= KW_SHORT */ +#line 68 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_SHORT); yy_destructor(yypParser,11,&yymsp[0].minor); +} +#line 890 "lwcc/parse_c.c" + break; + case 23: /* baseint ::= KW_LONG KW_LONG KW_INT */ +#line 69 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_LONGLONG); yy_destructor(yypParser,7,&yymsp[-2].minor); + yy_destructor(yypParser,7,&yymsp[-1].minor); + yy_destructor(yypParser,10,&yymsp[0].minor); +} +#line 898 "lwcc/parse_c.c" + break; + case 24: /* baseint ::= KW_SHORT KW_INT */ +#line 70 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_SHORT); yy_destructor(yypParser,11,&yymsp[-1].minor); + yy_destructor(yypParser,10,&yymsp[0].minor); +} +#line 905 "lwcc/parse_c.c" + break; + case 25: /* baseint ::= KW_CHAR */ +#line 71 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_TYPE_CHAR); yy_destructor(yypParser,12,&yymsp[0].minor); +} +#line 911 "lwcc/parse_c.c" + break; + case 26: /* fundecl ::= datatype ident arglist statementblock */ +#line 74 "lwcc/parse_c.y" +{ + yygotominor.yy18 = node_create(NODE_FUNDEF, yymsp[-3].minor.yy18, yymsp[-2].minor.yy18, yymsp[-1].minor.yy18, yymsp[0].minor.yy18); +} +#line 918 "lwcc/parse_c.c" + break; + case 27: /* fundecl ::= datatype ident arglist ENDS */ +#line 78 "lwcc/parse_c.y" +{ + yygotominor.yy18 = node_create(NODE_FUNDECL, yymsp[-3].minor.yy18, yymsp[-2].minor.yy18, yymsp[-1].minor.yy18); + yy_destructor(yypParser,1,&yymsp[0].minor); +} +#line 926 "lwcc/parse_c.c" + break; + case 28: /* arglist ::= OPAREN CPAREN */ +#line 82 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_FUNARGS); yy_destructor(yypParser,13,&yymsp[-1].minor); + yy_destructor(yypParser,14,&yymsp[0].minor); +} +#line 933 "lwcc/parse_c.c" + break; + case 29: /* statementblock ::= OBRACE CBRACE */ +#line 84 "lwcc/parse_c.y" +{ yygotominor.yy18 = node_create(NODE_BLOCK); yy_destructor(yypParser,15,&yymsp[-1].minor); + yy_destructor(yypParser,16,&yymsp[0].minor); +} +#line 940 "lwcc/parse_c.c" + break; + default: + break; + }; + yygoto = yyRuleInfo[yyruleno].lhs; + yysize = yyRuleInfo[yyruleno].nrhs; + yypParser->yyidx -= yysize; + yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto); + if( yyact < YYNSTATE ){ +#ifdef NDEBUG + /* If we are not debugging and the reduce action popped at least + ** one element off the stack, then we can push the new element back + ** onto the stack here, and skip the stack overflow test in yy_shift(). + ** That gives a significant speed improvement. */ + if( yysize ){ + yypParser->yyidx++; + yymsp -= yysize-1; + yymsp->stateno = (YYACTIONTYPE)yyact; + yymsp->major = (YYCODETYPE)yygoto; + yymsp->minor = yygotominor; + }else +#endif + { + yy_shift(yypParser,yyact,yygoto,&yygotominor); + } + }else{ + assert( yyact == YYNSTATE + YYNRULE + 1 ); + yy_accept(yypParser); + } +} + +/* +** The following code executes when the parse fails +*/ +#ifndef YYNOERRORRECOVERY +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + ParseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ +#line 86 "lwcc/parse_c.y" + + fprintf(stderr, "Parse error\n"); +#line 991 "lwcc/parse_c.c" + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} +#endif /* YYNOERRORRECOVERY */ + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + YYMINORTYPE yyminor /* The minor type of the error token */ +){ + ParseARG_FETCH; +#define TOKEN (yyminor.yy0) +#line 94 "lwcc/parse_c.y" + + fprintf(stderr, "Undexpected token %d: ", TOKEN -> tokid); + tokendata_print(stderr, TOKEN); +#line 1010 "lwcc/parse_c.c" + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + ParseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "ParseAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +** <ul> +** <li> A pointer to the parser (an opaque structure.) +** <li> The major token number. +** <li> The minor token number. +** <li> An option argument of a grammar-specified type. +** </ul> +** +** Outputs: +** None. +*/ +void Parse( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + ParseTOKENTYPE yyminor /* The value for the token */ + ParseARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + int yyact; /* The parser action. */ + int yyendofinput; /* True if we are at the end of input */ +#ifdef YYERRORSYMBOL + int yyerrorhit = 0; /* True if yymajor has invoked an error */ +#endif + yyParser *yypParser; /* The parser */ + + /* (re)initialize the parser, if necessary */ + yypParser = (yyParser*)yyp; + if( yypParser->yyidx<0 ){ +#if YYSTACKDEPTH<=0 + if( yypParser->yystksz <=0 ){ + /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/ + yyminorunion = yyzerominor; + yyStackOverflow(yypParser, &yyminorunion); + return; + } +#endif + yypParser->yyidx = 0; + yypParser->yyerrcnt = -1; + yypParser->yystack[0].stateno = 0; + yypParser->yystack[0].major = 0; + } + yyminorunion.yy0 = yyminor; + yyendofinput = (yymajor==0); + ParseARG_STORE; + +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]); + } +#endif + + do{ + yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor); + if( yyact<YYNSTATE ){ + assert( !yyendofinput ); /* Impossible to shift the $ token */ + yy_shift(yypParser,yyact,yymajor,&yyminorunion); + yypParser->yyerrcnt--; + yymajor = YYNOCODE; + }else if( yyact < YYNSTATE + YYNRULE ){ + yy_reduce(yypParser,yyact-YYNSTATE); + }else{ + assert( yyact == YY_ERROR_ACTION ); +#ifdef YYERRORSYMBOL + int yymx; +#endif +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yymx = yypParser->yystack[yypParser->yyidx].major; + if( yymx==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion); + yymajor = YYNOCODE; + }else{ + while( + yypParser->yyidx >= 0 && + yymx != YYERRORSYMBOL && + (yyact = yy_find_reduce_action( + yypParser->yystack[yypParser->yyidx].stateno, + YYERRORSYMBOL)) >= YYNSTATE + ){ + yy_pop_parser_stack(yypParser); + } + if( yypParser->yyidx < 0 || yymajor==0 ){ + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + yy_parse_failed(yypParser); + yymajor = YYNOCODE; + }else if( yymx!=YYERRORSYMBOL ){ + YYMINORTYPE u2; + u2.YYERRSYMDT = 0; + yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; +#elif defined(YYNOERRORRECOVERY) + /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to + ** do any kind of error recovery. Instead, simply invoke the syntax + ** error routine and continue going as if nothing had happened. + ** + ** Applications can set this macro (for example inside %include) if + ** they intend to abandon the parse upon the first syntax error seen. + */ + yy_syntax_error(yypParser,yymajor,yyminorunion); + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + yymajor = YYNOCODE; + +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yypParser->yyerrcnt = 3; + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); + } + yymajor = YYNOCODE; +#endif + } + }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 ); + return; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lwcc/parse_c.h Sun Nov 17 11:59:36 2013 -0700 @@ -0,0 +1,16 @@ +#define PTOK_ENDS 1 +#define PTOK_IDENTIFIER 2 +#define PTOK_STAR 3 +#define PTOK_KW_VOID 4 +#define PTOK_KW_FLOAT 5 +#define PTOK_KW_DOUBLE 6 +#define PTOK_KW_LONG 7 +#define PTOK_KW_UNSIGNED 8 +#define PTOK_KW_SIGNED 9 +#define PTOK_KW_INT 10 +#define PTOK_KW_SHORT 11 +#define PTOK_KW_CHAR 12 +#define PTOK_OPAREN 13 +#define PTOK_CPAREN 14 +#define PTOK_OBRACE 15 +#define PTOK_CBRACE 16
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lwcc/parse_c.y Sun Nov 17 11:59:36 2013 -0700 @@ -0,0 +1,97 @@ +%include { +#include <assert.h> // only needed due to a bug in lemon +#include <stdio.h> +#include "parse.h" +#include "tree.h" +} + +%token_type { struct tokendata * } +%token_prefix PTOK_ +%token_destructor { tokendata_free($$); } +%default_type { node_t * } +%extra_argument { struct parserinfo *pinfo } + +program(A) ::= rprogram(B). { A = B; pinfo -> parsetree = A; } + +rprogram(A) ::= rprogram(C) globaldecl(B). { + A = C; + node_addchild(A, B); +} +rprogram(A) ::= . { A = node_create(NODE_PROGRAM); } + +globaldecl(A) ::= vardecl(B). { A = B; } +globaldecl(A) ::= fundecl(B). { A = B; } + +vardecl(A) ::= datatype(B) ident(C) ENDS. { + A = node_create(NODE_DECL, B, C); +} + +ident(A) ::= IDENTIFIER(B). { A = node_create(NODE_IDENT, B -> strval); } + +datatype(A) ::= typename(B). { A = B; } +datatype(A) ::= datatype(B) STAR. { A = node_create(NODE_TYPE_PTR, B); } + +typename(A) ::= KW_VOID. { A = node_create(NODE_TYPE_VOID); } +typename(A) ::= KW_FLOAT. { A = node_create(NODE_TYPE_FLOAT); } +typename(A) ::= KW_DOUBLE. { A = node_create(NODE_TYPE_DOUBLE); } +typename(A) ::= KW_LONG KW_DOUBLE. { A = node_create(NODE_TYPE_LDOUBLE); } +typename(A) ::= baseint(B). { A = B; } +typename(A) ::= KW_UNSIGNED. { A = node_create(NODE_TYPE_UINT); } +typename(A) ::= KW_SIGNED. { A = node_create(NODE_TYPE_INT); } +typename(A) ::= KW_SIGNED baseint(B). { A = B; if (A -> type == NODE_TYPE_CHAR) A -> type = NODE_TYPE_SCHAR; } +typename(A) ::= KW_UNSIGNED baseint(B). { + A = B; + switch (A -> type) + { + case NODE_TYPE_CHAR: + A -> type = NODE_TYPE_UCHAR; + break; + case NODE_TYPE_SHORT: + A -> type = NODE_TYPE_USHORT; + break; + case NODE_TYPE_INT: + A -> type = NODE_TYPE_UINT; + break; + case NODE_TYPE_LONG: + A -> type = NODE_TYPE_ULONG; + break; + case NODE_TYPE_LONGLONG: + A -> type = NODE_TYPE_ULONGLONG; + break; + } +} + +baseint(A) ::= KW_INT. { A = node_create(NODE_TYPE_INT); } +baseint(A) ::= KW_LONG. { A = node_create(NODE_TYPE_LONG); } +baseint(A) ::= KW_LONG KW_INT. { A = node_create(NODE_TYPE_LONG); } +baseint(A) ::= KW_LONG KW_LONG. { A = node_create(NODE_TYPE_LONGLONG); } +baseint(A) ::= KW_SHORT. { A = node_create(NODE_TYPE_SHORT); } +baseint(A) ::= KW_LONG KW_LONG KW_INT. { A = node_create(NODE_TYPE_LONGLONG); } +baseint(A) ::= KW_SHORT KW_INT. { A = node_create(NODE_TYPE_SHORT); } +baseint(A) ::= KW_CHAR. { A = node_create(NODE_TYPE_CHAR); } + + +fundecl(A) ::= datatype(B) ident(C) arglist(D) statementblock(E). { + A = node_create(NODE_FUNDEF, B, C, D, E); +} + +fundecl(A) ::= datatype(B) ident(C) arglist(D) ENDS. { + A = node_create(NODE_FUNDECL, B, C, D); +} + +arglist(A) ::= OPAREN CPAREN. { A = node_create(NODE_FUNARGS); } + +statementblock(A) ::= OBRACE CBRACE. { A = node_create(NODE_BLOCK); } + +%parse_failure { + fprintf(stderr, "Parse error\n"); +} + +%stack_overflow { + fprintf(stderr, "Parser stack overflow\n"); +} + +%syntax_error { + fprintf(stderr, "Undexpected token %d: ", TOKEN -> tokid); + tokendata_print(stderr, TOKEN); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lwcc/token_names.c Sun Nov 17 11:59:36 2013 -0700 @@ -0,0 +1,19 @@ +char *ptoken_names[] = { +"TOKEN_NONE", +"PTOK_ENDS", +"PTOK_IDENTIFIER", +"PTOK_STAR", +"PTOK_KW_VOID", +"PTOK_KW_FLOAT", +"PTOK_KW_DOUBLE", +"PTOK_KW_LONG", +"PTOK_KW_UNSIGNED", +"PTOK_KW_SIGNED", +"PTOK_KW_INT", +"PTOK_KW_SHORT", +"PTOK_KW_CHAR", +"PTOK_OPAREN", +"PTOK_CPAREN", +"PTOK_OBRACE", +"PTOK_CBRACE", +"" };
--- a/lwcc/tree.c Tue Nov 12 20:41:14 2013 -0700 +++ b/lwcc/tree.c Sun Nov 17 11:59:36 2013 -0700 @@ -22,12 +22,35 @@ #include <stdarg.h> #include <string.h> #include <lw_alloc.h> +#include <lw_string.h> #include "tree.h" static char *node_names[] = { "NONE", "PROGRAM", + "DECL", + "TYPE_CHAR", + "TYPE_SHORT", + "TYPE_INT", + "TYPE_LONG", + "TYPE_LONGLONG", + "IDENT", + "TYPE_PTR", + "TYPE_SCHAR", + "TYPE_UCHAR", + "TYPE_USHORT", + "TYPE_UINT", + "TYPE_ULONG", + "TYPE_ULONGLONG", + "TYPE_VOID", + "TYPE_FLOAT", + "TYPE_DOUBLE", + "TYPE_LDOUBLE", + "FUNDEF", + "FUNDECL", + "FUNARGS", + "BLOCK", }; @@ -40,11 +63,30 @@ va_start(args, type); r = lw_alloc(sizeof(node_t)); - memset(r, sizeof(node_t), 0); + memset(r, 0, sizeof(node_t)); r -> type = type; switch (type) { + case NODE_DECL: + nargs = 2; + break; + + case NODE_TYPE_PTR: + nargs = 1; + break; + + case NODE_IDENT: + r -> strval = lw_strdup(va_arg(args, char *)); + break; + + case NODE_FUNDEF: + nargs = 4; + break; + + case NODE_FUNDECL: + nargs = 3; + break; } while (nargs--) @@ -73,6 +115,9 @@ { node_t *tmp; + if (!nn) + return; + nn -> parent = node; nn -> next_child = NULL; if (node -> children) @@ -124,6 +169,8 @@ for (i = 0; i < level * 4; i++) fputc(' ', f); fprintf(f, "(%s ", node_names[node -> type]); + if (node -> strval) + fprintf(f, "\"%s\" ", node -> strval); fputc('\n', f); for (nn = node -> children; nn; nn = nn -> next_child) node_display_aux(nn, f, level + 1);
--- a/lwcc/tree.h Tue Nov 12 20:41:14 2013 -0700 +++ b/lwcc/tree.h Sun Nov 17 11:59:36 2013 -0700 @@ -25,9 +25,31 @@ #include <stdio.h> /* the various node types */ -#define NODE_NONE 0 // a node with no type -#define NODE_PROGRAM 1 // the whole program -#define NODE_NUMTYPES 2 // the number of node types +#define NODE_NONE 0 // a node with no type +#define NODE_PROGRAM 1 // the whole program +#define NODE_DECL 2 // a declaration +#define NODE_TYPE_CHAR 3 // a character type +#define NODE_TYPE_SHORT 4 // short int +#define NODE_TYPE_INT 5 // integer +#define NODE_TYPE_LONG 6 // long int +#define NODE_TYPE_LONGLONG 7 // long long +#define NODE_IDENT 8 // an identifier of some kind +#define NODE_TYPE_PTR 9 // a pointer +#define NODE_TYPE_SCHAR 10 // signed char +#define NODE_TYPE_UCHAR 11 // unsigned char +#define NODE_TYPE_USHORT 12 // unsigned short +#define NODE_TYPE_UINT 13 // unsigned int +#define NODE_TYPE_ULONG 14 // unsigned long +#define NODE_TYPE_ULONGLONG 15 // unsigned long long +#define NODE_TYPE_VOID 16 // void +#define NODE_TYPE_FLOAT 17 // float +#define NODE_TYPE_DOUBLE 18 // double +#define NODE_TYPE_LDOUBLE 19 // long double +#define NODE_FUNDEF 20 // function definition +#define NODE_FUNDECL 21 // function declaration +#define NODE_FUNARGS 22 // list of function args +#define NODE_BLOCK 23 // statement block +#define NODE_NUMTYPES 24 // the number of node types typedef struct node_s node_t;