From 9314157be58c7195bf8eacc762ba7ba83c7f50fc Mon Sep 17 00:00:00 2001
From: Wolfgang Bumiller <wolfgang.linux@bumiller.com>
Date: Fri, 20 Jul 2012 14:04:52 +0200
Subject: [PATCH] Adding ids to operators for SYA later

---
 lexer.h  | 81 ++++++++++++++++++++++++++++----------------------------
 parser.c | 23 ++++++++++++++--
 2 files changed, 62 insertions(+), 42 deletions(-)

diff --git a/lexer.h b/lexer.h
index f49b8ff..f23c1a6 100644
--- a/lexer.h
+++ b/lexer.h
@@ -117,66 +117,67 @@ enum {
 
 typedef struct {
     const char   *op;
+    unsigned int id;
     unsigned int assoc;
     unsigned int prec;
     unsigned int flags;
 } oper_info;
 
 static const oper_info operators[] = {
-    { "++",  ASSOC_LEFT,  16, OP_SUFFIX},
-    { "--",  ASSOC_LEFT,  16, OP_SUFFIX},
+    { "++",    1, ASSOC_LEFT,  16, OP_SUFFIX},
+    { "--",    2, ASSOC_LEFT,  16, OP_SUFFIX},
 
-    { ".",   ASSOC_LEFT,  15, 0 },
+    { ".",    10, ASSOC_LEFT,  15, 0 },
 
-    { "!",   ASSOC_RIGHT, 14, 0 },
-    { "~",   ASSOC_RIGHT, 14, 0 },
-    { "+",   ASSOC_RIGHT, 14, OP_PREFIX },
-    { "-",   ASSOC_RIGHT, 14, OP_PREFIX },
-    { "++",  ASSOC_RIGHT, 14, OP_PREFIX },
-    { "--",  ASSOC_RIGHT, 14, OP_PREFIX },
-/*  { "&",   ASSOC_RIGHT, 14, OP_PREFIX }, */
+    { "!",    21, ASSOC_RIGHT, 14, 0 },
+    { "~",    22, ASSOC_RIGHT, 14, 0 },
+    { "+",    23, ASSOC_RIGHT, 14, OP_PREFIX },
+    { "-",    24, ASSOC_RIGHT, 14, OP_PREFIX },
+    { "++",   25, ASSOC_RIGHT, 14, OP_PREFIX },
+    { "--",   26, ASSOC_RIGHT, 14, OP_PREFIX },
+/*  { "&",    27, ASSOC_RIGHT, 14, OP_PREFIX }, */
 
-    { "*",   ASSOC_LEFT,  13, 0 },
-    { "/",   ASSOC_LEFT,  13, 0 },
-    { "%",   ASSOC_LEFT,  13, 0 },
+    { "*",    30, ASSOC_LEFT,  13, 0 },
+    { "/",    31, ASSOC_LEFT,  13, 0 },
+    { "%",    32, ASSOC_LEFT,  13, 0 },
 
-    { "+",   ASSOC_LEFT,  12, 0 },
-    { "-",   ASSOC_LEFT,  12, 0 },
+    { "+",    40, ASSOC_LEFT,  12, 0 },
+    { "-",    41, ASSOC_LEFT,  12, 0 },
 
-    { "<<",  ASSOC_LEFT,  11, 0 },
-    { ">>",  ASSOC_LEFT,  11, 0 },
+    { "<<",   50, ASSOC_LEFT,  11, 0 },
+    { ">>",   51, ASSOC_LEFT,  11, 0 },
 
-    { "<",   ASSOC_LEFT,  10, 0 },
-    { ">",   ASSOC_LEFT,  10, 0 },
-    { "<=",  ASSOC_LEFT,  10, 0 },
-    { ">=",  ASSOC_LEFT,  10, 0 },
+    { "<",    60, ASSOC_LEFT,  10, 0 },
+    { ">",    61, ASSOC_LEFT,  10, 0 },
+    { "<=",   62, ASSOC_LEFT,  10, 0 },
+    { ">=",   63, ASSOC_LEFT,  10, 0 },
 
-    { "==",  ASSOC_LEFT,  9,  0 },
-    { "!=",  ASSOC_LEFT,  9,  0 },
+    { "==",   70, ASSOC_LEFT,  9,  0 },
+    { "!=",   71, ASSOC_LEFT,  9,  0 },
 
-    { "&",   ASSOC_LEFT,  8,  0 },
+    { "&",    80, ASSOC_LEFT,  8,  0 },
 
-    { "^",   ASSOC_LEFT,  7,  0 },
+    { "^",    90, ASSOC_LEFT,  7,  0 },
 
-    { "|",   ASSOC_LEFT,  6,  0 },
+    { "|",   100, ASSOC_LEFT,  6,  0 },
 
-    { "&&",  ASSOC_LEFT,  5,  0 },
+    { "&&",  110, ASSOC_LEFT,  5,  0 },
 
-    { "||",  ASSOC_LEFT,  4,  0 },
+    { "||",  120, ASSOC_LEFT,  4,  0 },
 
-    { "?",   ASSOC_RIGHT, 3,  0 },
+    { "?",   130, ASSOC_RIGHT, 3,  0 },
 
-    { "=",   ASSOC_RIGHT, 2,  0 },
-    { "+=",  ASSOC_RIGHT, 2,  0 },
-    { "-=",  ASSOC_RIGHT, 2,  0 },
-    { "*=",  ASSOC_RIGHT, 2,  0 },
-    { "/=",  ASSOC_RIGHT, 2,  0 },
-    { "%=",  ASSOC_RIGHT, 2,  0 },
-    { ">>=", ASSOC_RIGHT, 2,  0 },
-    { "<<=", ASSOC_RIGHT, 2,  0 },
-    { "&=",  ASSOC_RIGHT, 2,  0 },
-    { "^=",  ASSOC_RIGHT, 2,  0 },
-    { "|=",  ASSOC_RIGHT, 2,  0 },
+    { "=",   140, ASSOC_RIGHT, 2,  0 },
+    { "+=",  141, ASSOC_RIGHT, 2,  0 },
+    { "-=",  142, ASSOC_RIGHT, 2,  0 },
+    { "*=",  143, ASSOC_RIGHT, 2,  0 },
+    { "/=",  144, ASSOC_RIGHT, 2,  0 },
+    { "%=",  145, ASSOC_RIGHT, 2,  0 },
+    { ">>=", 146, ASSOC_RIGHT, 2,  0 },
+    { "<<=", 147, ASSOC_RIGHT, 2,  0 },
+    { "&=",  148, ASSOC_RIGHT, 2,  0 },
+    { "^=",  149, ASSOC_RIGHT, 2,  0 },
+    { "|=",  150, ASSOC_RIGHT, 2,  0 },
 };
 
 typedef struct
diff --git a/parser.c b/parser.c
index 036aca6..0b16a87 100644
--- a/parser.c
+++ b/parser.c
@@ -159,9 +159,26 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc
     return var;
 }
 
+typedef struct
+{
+    int etype; /* 0 = expression, others are operators */
+    ast_expression* out;
+} sy_elem;
+typedef struct
+{
+    MEM_VECTOR_MAKE(sy_elem, out);
+    MEM_VECTOR_MAKE(sy_elem, ops);
+} shyntingyard;
+
 static bool parser_expression(parser_t *parser, ast_block *block)
 {
-    parseerror(parser, "TODO: statements/expressions");
+    shyntingyard sy;
+
+    MEM_VECTOR_INIT(&sy, out);
+    MEM_VECTOR_INIT(&sy, ops);
+
+    MEM_VECTOR_CLEAR(&sy, out);
+    MEM_VECTOR_CLEAR(&sy, ops);
     return false;
 }
 
@@ -178,9 +195,11 @@ static bool parser_body_do(parser_t *parser, ast_block *block)
     else if (parser->tok == '{')
     {
         /* a block */
+        parseerror(parser, "TODO: inner blocks");
+        return false;
     }
     else
-        return parser_expression(parser_t *parser, ast_block *block);
+        return parser_expression(parser, block);
 }
 
 static ast_block* parser_parse_block(parser_t *parser)
-- 
2.39.2