# HG changeset patch
# User William Astle <lost@l-w.ca>
# Date 1565328743 21600
# Node ID 1bd2d590d734c26d965b9bcd540c52236aab418e
# Parent  4b865c9d437176cadda005b54d3c4c6768ed55f0
Rejig parser to eliminate lemon

No longer use lemon for building the parser. It adds too much complexity,
really, and a hand written recursive descent parser is far more flexible.

The current iteration can handle exactly one statement: "return <int>".

diff -r 4b865c9d4371 -r 1bd2d590d734 Makefile
--- a/Makefile	Mon Aug 05 21:38:23 2019 -0600
+++ b/Makefile	Thu Aug 08 23:32:23 2019 -0600
@@ -108,8 +108,7 @@
 lwcc_cpp_objs := $(lwcc_cpp_srcs:.c=.o)
 lwcc_cpp_deps := $(lwcc_cpp_srcs:.c=.d)
 
-# 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 := cc-main.c tree.c cc-parse.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)
@@ -180,17 +179,6 @@
 
 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 -MG $(CPPFLAGS) -o $*.d $<
diff -r 4b865c9d4371 -r 1bd2d590d734 lwcc/cc-parse.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lwcc/cc-parse.c	Thu Aug 08 23:32:23 2019 -0600
@@ -0,0 +1,278 @@
+/*
+lwcc/cc-parse.c
+
+Copyright © 2019 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/>.
+*/
+
+#include <string.h>
+
+#include <lw_alloc.h>
+#include <lw_string.h>
+
+#include "cpp.h"
+#include "tree.h"
+
+#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
+#define TOK_CONST_INT   -150
+
+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" },
+    { TOK_NONE, "" }
+};
+
+
+struct parser_state
+{
+    struct preproc_info *pp;                // preprocessor data
+    struct token *curtok;                   // the current token
+};
+
+
+struct token *parse_next(struct parser_state *ps)
+{
+    struct token *tok;
+    int i;
+    
+    for (;;)
+    {
+        tok = preproc_next(ps -> 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 registered types here
+    }
+    else if (tok -> ttype == TOK_NUMBER)
+    {
+        // look for anything that isn't 0-9
+        for (i = 0; tok -> strval[i]; i++)
+        {
+            if (tok -> strval[i] < '0' || tok -> strval[i] > '9')
+                break;
+        }
+        if (tok -> strval[i] == 0)
+            tok -> ttype = TOK_CONST_INT;
+    }
+out:
+    fprintf(stderr, "Lexed: ");
+    token_print(tok, stderr);
+    fprintf(stderr, " (%d)\n", tok -> ttype);
+    if (ps -> curtok)
+        token_free(ps -> curtok);
+    ps -> curtok = tok;
+    return tok;
+}
+
+void parse_generr(struct parser_state *ps, char *tag)
+{
+    fprintf(stderr, "(%s) Unexpected token (%d): ", tag, ps -> curtok -> ttype);
+    token_print(ps -> curtok, stderr);
+    fprintf(stderr, "\n");
+
+}
+
+node_t *parse_expr(struct parser_state *ps)
+{
+    node_t *rv;
+    if (ps -> curtok -> ttype == TOK_CONST_INT)
+    {
+        rv = node_create(NODE_CONST_INT, ps -> curtok -> strval);
+        parse_next(ps);
+        return rv;
+    }
+    parse_generr(ps, "expr");
+    return NULL;
+}
+
+node_t *parse_statement(struct parser_state *ps)
+{
+    node_t *rv;
+    node_t *n;
+
+    switch (ps -> curtok -> ttype)
+    {
+    case TOK_KW_RETURN:
+        parse_next(ps);
+        n = parse_expr(ps);
+        if (!n)
+        {
+            parse_generr(ps, "statement");
+            return NULL;
+        }
+        rv = node_create(NODE_STMT_RETURN);
+        node_addchild(rv, n);
+        break;
+
+    default:
+        return NULL;
+    }
+    
+    if (ps -> curtok -> ttype != TOK_EOS)
+        parse_generr(ps, "statement");
+    else
+        parse_next(ps);
+    return rv;
+}
+
+node_t *parse_globaldecl(struct parser_state *ps)
+{
+    node_t *rv = NULL;
+    node_t *stmt;
+    char *fnname = NULL;
+    if (ps -> curtok -> ttype == TOK_KW_INT)
+    {
+        // variable name
+        parse_next(ps);
+        if (ps -> curtok -> ttype != TOK_IDENT)
+            goto error;
+        fnname = lw_strdup(ps -> curtok -> strval);
+        parse_next(ps);
+        if (ps -> curtok -> ttype != TOK_OPAREN)
+            goto error;
+        parse_next(ps);
+        if (ps -> curtok -> ttype != TOK_CPAREN)
+            goto error;
+        parse_next(ps);
+        if (ps -> curtok -> ttype != TOK_OBRACE)
+            goto error;
+        parse_next(ps);
+        stmt = parse_statement(ps);
+        if (!stmt)
+            goto error;
+        rv = node_create(NODE_FUNDEF, node_create(NODE_TYPE_INT), node_create(NODE_IDENT, fnname), node_create(NODE_FUNARGS), stmt);
+        if (ps -> curtok -> ttype != TOK_CBRACE)
+            goto error;
+        parse_next(ps);
+        lw_free(fnname);        
+        return rv;
+    }        
+        
+
+error:
+    if (fnname)
+        lw_free(fnname);
+    parse_generr(ps, "globaldecl");
+    return rv;
+}
+
+node_t *parse_program(struct preproc_info *pp)
+{
+    node_t *rv;
+    node_t *node;
+    struct parser_state ps;
+    
+    ps.pp = pp;
+    ps.curtok = NULL;
+
+    rv = node_create(NODE_PROGRAM);
+
+    // prime the parser
+    parse_next(&ps);
+    while (ps.curtok -> ttype != TOK_EOF)
+    {
+        node = parse_globaldecl(&ps);
+        if (!node)
+            break;
+        node_addchild(rv, node);
+    }
+
+    return rv;
+}
diff -r 4b865c9d4371 -r 1bd2d590d734 lwcc/tree.c
--- a/lwcc/tree.c	Mon Aug 05 21:38:23 2019 -0600
+++ b/lwcc/tree.c	Thu Aug 08 23:32:23 2019 -0600
@@ -51,6 +51,8 @@
 	"FUNDECL",
 	"FUNARGS",
 	"BLOCK",
+	"STMT_RETURN",
+	"CONST_INT",
 };
 
 
@@ -77,6 +79,7 @@
 		break;
 		
 	case NODE_IDENT:
+	case NODE_CONST_INT:
 		r -> strval = lw_strdup(va_arg(args, char *));
 		break;
 	
diff -r 4b865c9d4371 -r 1bd2d590d734 lwcc/tree.h
--- a/lwcc/tree.h	Mon Aug 05 21:38:23 2019 -0600
+++ b/lwcc/tree.h	Thu Aug 08 23:32:23 2019 -0600
@@ -49,7 +49,9 @@
 #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
+#define NODE_STMT_RETURN    24  // return statement
+#define NODE_CONST_INT      25  // constant integer
+#define NODE_NUMTYPES		26	// the number of node types
 
 typedef struct node_s node_t;