Some general cleanup.

3 files changed, 41 insertions, 55 deletions

diff --git a/LuaSL/src/LuaSL_LSL_tree.c b/LuaSL/src/LuaSL_LSL_tree.c
index a0c07f0..beae756 100644
--- a/LuaSL/src/LuaSL_LSL_tree.c
+++ b/LuaSL/src/LuaSL_LSL_tree.c
@@ -11,13 +11,12 @@ static void evaluateStatementToken(LSL_Leaf *content, LSL_Leaf *left, LSL_Leaf *
 static void outputIntegerToken(LSL_Leaf *content);
 static void outputParenthesisToken(LSL_Leaf *content);
 static void outputStatementToken(LSL_Leaf *content);
-static void outputSpaceToken(LSL_Leaf *content);
 
 LSL_Token LSL_Tokens[] =
 {
     {LSL_COMMENT,                       "/*",           LSL_NONE,                       NULL, NULL, NULL},
     {LSL_COMMENT_LINE,                  "//",           LSL_NONE,                       NULL, NULL, NULL},
-    {LSL_SPACE,                 " ",            LSL_NONE,                       outputSpaceToken, NULL, NULL},
+    {LSL_SPACE,                         " ",            LSL_NONE,                       NULL, NULL, NULL},
 
     // Operators, in order of precedence, low to high
     // Left to right, unless oterwise stated.
@@ -96,7 +95,7 @@ LSL_Token LSL_Tokens[] =
 
     // Then the rest of the syntax tokens.
 
-    {LSL_IDENTIFIER,                    "identifier",           LSL_NONE,                       NULL, NULL, NULL},
+    {LSL_IDENTIFIER,                    "identifier",   LSL_NONE,                       NULL, NULL, NULL},
 
     {LSL_LABEL,                         "@",            LSL_NONE,                       NULL, NULL, NULL},
 
@@ -118,7 +117,7 @@ LSL_Token LSL_Tokens[] =
 //    {LSL_STATE,                               "state",                LSL_NONE,                       NULL, NULL, NULL},
     {LSL_SCRIPT,                        "",             LSL_NONE,                       NULL, NULL, NULL},
 
-    {LSL_UNKNOWN,                       "unknown",      LSL_NONE,                               NULL, NULL, NULL},
+    {LSL_UNKNOWN,                       "unknown",      LSL_NONE,                       NULL, NULL, NULL},
 
     // A sentinal.
 
@@ -129,6 +128,7 @@ LSL_Token **tokens = NULL;
 int lowestToken = 999999;
 
 
+/*  Not actually used, but it might be some day.
 static LSL_Leaf *newLeaf(LSL_Type type, LSL_Leaf *left, LSL_Leaf *right)
 {
     LSL_Leaf *leaf = calloc(1, sizeof(LSL_Leaf));
@@ -142,6 +142,7 @@ static LSL_Leaf *newLeaf(LSL_Type type, LSL_Leaf *left, LSL_Leaf *right)
 
     return leaf;
 }
+*/
 
 void burnLeaf(LSL_Leaf *leaf)
 {
@@ -155,22 +156,12 @@ void burnLeaf(LSL_Leaf *leaf)
     }
 }
 
-LSL_Leaf *addOperation(LSL_Leaf *lval, LSL_Type type, LSL_Leaf *left, LSL_Leaf *right)
+LSL_Leaf *addOperation(LSL_Leaf *left, LSL_Leaf *lval, LSL_Leaf *right)
 {
-printf("******************************addOperation(%s, %d, , )\n", lval->token->token, type);
     if (lval)
     {
         lval->left = left;
         lval->right = right;
-        if (LSL_EXPRESSION == type)
-        {
-            lval->value.expressionValue = right;
-            lval->left = NULL;
-        }
-        else
-        {
-            lval->value.operationValue = type;
-        }
     }
 
     return lval;
@@ -194,7 +185,6 @@ LSL_Leaf *addParenthesis(LSL_Leaf *lval, LSL_Leaf *expr, LSL_Leaf *rval)
 LSL_Leaf *addStatement(LSL_Leaf *lval, LSL_Type type, LSL_Leaf *expr)
 {
     LSL_Statement *stat = malloc(sizeof(LSL_Statement));
-printf("******************************addStatement(%s, %d, , )\n", lval->token->token, type);
 
     if (stat)
     {
@@ -270,13 +260,13 @@ static void evaluateNoToken(LSL_Leaf *content, LSL_Leaf *left, LSL_Leaf *right)
 
 static void evaluateOperationToken(LSL_Leaf *content, LSL_Leaf *left, LSL_Leaf *right)
 {
-    if ((content) && (content->value.operationValue))
+    if (content)
     {
 #ifdef LUASL_DEBUG
         printf(" [%s] ", content->token->token);
 #endif
 
-        switch (content->value.operationValue)
+        switch (content->token->type)
         {
             case LSL_COMMA                      :
             case LSL_INCREMENT_PRE              :
@@ -391,12 +381,6 @@ static void outputStatementToken(LSL_Leaf *content)
     }
 }
 
-static void outputSpaceToken(LSL_Leaf *content)
-{
-    if (content)
-        printf("%s", content->value.spaceValue);
-}
-
 static void convertLeaf2Lua(LSL_Leaf *leaf)
 {
     if (leaf)
diff --git a/LuaSL/src/LuaSL_LSL_tree.h b/LuaSL/src/LuaSL_LSL_tree.h
index 9db83d0..9493552 100644
--- a/LuaSL/src/LuaSL_LSL_tree.h
+++ b/LuaSL/src/LuaSL_LSL_tree.h
@@ -86,13 +86,11 @@ struct _LSL_Leaf
 {
     LSL_Leaf            *left;
     LSL_Leaf            *right;
+    LSL_Token           *token;
+    char                *ignorableText;
+    int                 line, column;
     union
     {
-        char            *commentValue;
-        char            *spaceValue;
-
-        LSL_Type        operationValue;
-        LSL_Leaf        *expressionValue;
         LSL_Parenthesis *parenthesis;
 
         float           floatValue;
@@ -126,9 +124,6 @@ struct _LSL_Leaf
 
         char            *unknownValue;
     } value;
-    char                *ignorableText;
-    LSL_Token           *token;
-    int                 line, column;
 };
 
 struct _LSL_Parenthesis
@@ -205,7 +200,7 @@ typedef struct
 
 void burnLeaf(LSL_Leaf *leaf);
 LSL_Leaf *addExpression(LSL_Leaf *exp);
-LSL_Leaf *addOperation(LSL_Leaf *lval, LSL_Type type, LSL_Leaf *left, LSL_Leaf *right);
+LSL_Leaf *addOperation(LSL_Leaf *left, LSL_Leaf *lval, LSL_Leaf *right);
 LSL_Leaf *addParenthesis(LSL_Leaf *lval, LSL_Leaf *expr, LSL_Leaf *rval);
 LSL_Leaf *addStatement(LSL_Leaf *lval, LSL_Type type, LSL_Leaf *expr);
 
diff --git a/LuaSL/src/LuaSL_lemon_yaccer.y b/LuaSL/src/LuaSL_lemon_yaccer.y
index 14942b7..2427456 100644
--- a/LuaSL/src/LuaSL_lemon_yaccer.y
+++ b/LuaSL/src/LuaSL_lemon_yaccer.y
@@ -15,39 +15,46 @@ program ::= script LSL_SCRIPT(A).					{ A->left = param->ast;  param->ast = A; }
 
 
 %left  LSL_BOOL_AND.
-expr(A) ::= expr(B) LSL_BOOL_AND(D) expr(C).                            { A = addOperation(D, D->token->type,           B, C); }
+expr(A) ::= expr(B) LSL_BOOL_AND(C)             expr(D).                        { A = addOperation(B, C, D); }
 %left  LSL_BOOL_OR.
-expr(A) ::= expr(B) LSL_BOOL_OR(D) expr(C).                             { A = addOperation(D, LSL_BOOL_OR,              B, C); }
+expr(A) ::= expr(B) LSL_BOOL_OR(C)              expr(D).                        { A = addOperation(B, C, D); }
+
 %left  LSL_BIT_AND LSL_BIT_XOR LSL_BIT_OR.
-expr(A) ::= expr(B) LSL_BIT_OR(D) expr(C).                              { A = addOperation(D, LSL_BIT_OR,               B, C); }
-expr(A) ::= expr(B) LSL_BIT_XOR(D) expr(C).                             { A = addOperation(D, LSL_BIT_XOR,              B, C); }
-expr(A) ::= expr(B) LSL_BIT_AND(D) expr(C).                             { A = addOperation(D, LSL_BIT_AND,              B, C); }
+expr(A) ::= expr(B) LSL_BIT_OR(C)               expr(D).                        { A = addOperation(B, C, D); }
+expr(A) ::= expr(B) LSL_BIT_XOR(C)              expr(D).                        { A = addOperation(B, C, D); }
+expr(A) ::= expr(B) LSL_BIT_AND(C)              expr(D).                        { A = addOperation(B, C, D); }
+
 %left  LSL_EQUAL LSL_NOT_EQUAL.
-expr(A) ::= expr(B) LSL_NOT_EQUAL(D) expr(C).                           { A = addOperation(D, LSL_NOT_EQUAL,            B, C); }
-expr(A) ::= expr(B) LSL_EQUAL(D) expr(C).                               { A = addOperation(D, LSL_EQUAL,                B, C); }
+expr(A) ::= expr(B) LSL_NOT_EQUAL(C)            expr(D).                        { A = addOperation(B, C, D); }
+expr(A) ::= expr(B) LSL_EQUAL(C)                expr(D).                        { A = addOperation(B, C, D); }
 %left  LSL_LESS_THAN LSL_GREATER_THAN LSL_LESS_EQUAL LSL_GREATER_EQUAL.
-expr(A) ::= expr(B) LSL_GREATER_EQUAL(D) expr(C).                       { A = addOperation(D, LSL_GREATER_EQUAL,        B, C); }
-expr(A) ::= expr(B) LSL_LESS_EQUAL(D) expr(C).                          { A = addOperation(D, LSL_LESS_EQUAL,           B, C); }
-expr(A) ::= expr(B) LSL_GREATER_THAN(D) expr(C).                        { A = addOperation(D, LSL_GREATER_THAN,         B, C); }
-expr(A) ::= expr(B) LSL_LESS_THAN(D) expr(C).                           { A = addOperation(D, LSL_LESS_THAN,            B, C); }
+expr(A) ::= expr(B) LSL_GREATER_EQUAL(C)        expr(D).                        { A = addOperation(B, C, D); }
+expr(A) ::= expr(B) LSL_LESS_EQUAL(C)           expr(D).                        { A = addOperation(B, C, D); }
+expr(A) ::= expr(B) LSL_GREATER_THAN(C)         expr(D).                        { A = addOperation(B, C, D); }
+expr(A) ::= expr(B) LSL_LESS_THAN(C)            expr(D).                        { A = addOperation(B, C, D); }
+
 %left  LSL_LEFT_SHIFT LSL_RIGHT_SHIFT.
-expr(A) ::= expr(B) LSL_RIGHT_SHIFT(D) expr(C).                         { A = addOperation(D, LSL_RIGHT_SHIFT,          B, C); }
-expr(A) ::= expr(B) LSL_LEFT_SHIFT(D) expr(C).                          { A = addOperation(D, LSL_LEFT_SHIFT,           B, C); }
+expr(A) ::= expr(B) LSL_RIGHT_SHIFT(C)          expr(D).                        { A = addOperation(B, C, D); }
+expr(A) ::= expr(B) LSL_LEFT_SHIFT(C)           expr(D).                        { A = addOperation(B, C, D); }
+
 %left  LSL_SUBTRACT LSL_ADD.
-expr(A) ::= expr(B) LSL_ADD(D) expr(C).                                 { A = addOperation(D, LSL_ADD,                  B, C); }
-expr(A) ::= expr(B) LSL_SUBTRACT(D) expr(C).                            { A = addOperation(D, LSL_SUBTRACT,             B, C); }
+expr(A) ::= expr(B) LSL_ADD(C)                  expr(D).                        { A = addOperation(B, C, D); }
+expr(A) ::= expr(B) LSL_SUBTRACT(C)             expr(D).                        { A = addOperation(B, C, D); }
 %left  LSL_DIVIDE LSL_MODULO LSL_MULTIPLY.
-expr(A) ::= expr(B) LSL_MULTIPLY(D) expr(C).                            { A = addOperation(D, LSL_MULTIPLY,             B, C); }
-expr(A) ::= expr(B) LSL_MODULO(D) expr(C).                              { A = addOperation(D, LSL_MODULO,               B, C); }
-expr(A) ::= expr(B) LSL_DIVIDE(D) expr(C).                              { A = addOperation(D, LSL_DIVIDE,               B, C); }
+expr(A) ::= expr(B) LSL_MULTIPLY(C)             expr(D).                        { A = addOperation(B, C, D); }
+expr(A) ::= expr(B) LSL_MODULO(C)               expr(D).                        { A = addOperation(B, C, D); }
+expr(A) ::= expr(B) LSL_DIVIDE(C)               expr(D).                        { A = addOperation(B, C, D); }
+
 %right LSL_BIT_NOT LSL_BOOL_NOT LSL_NEGATION.
-expr(A) ::= LSL_BIT_NOT(D) expr(B).                                     { A = addOperation(D, LSL_BIT_NOT,              NULL, B); }
-expr(A) ::= LSL_BOOL_NOT(D) expr(B).                                    { A = addOperation(D, LSL_BOOL_NOT,             NULL, B); }
-expr(A) ::= LSL_SUBTRACT(D) expr(B).            [LSL_NEGATION]          { A = addOperation(D, LSL_NEGATION,             NULL, B); }
+expr(A) ::= LSL_BIT_NOT(B)                      expr(C).                        { A = addOperation(NULL, B, C); }
+expr(A) ::= LSL_BOOL_NOT(B)                     expr(C).                        { A = addOperation(NULL, B, C); }
+expr(A) ::= LSL_SUBTRACT(B)                     expr(C).        [LSL_NEGATION]  { A = addOperation(NULL, B, C); }
+
 %left  LSL_ANGLE_OPEN LSL_ANGLE_CLOSE.
 %nonassoc LSL_BRACKET_OPEN LSL_BRACKET_CLOSE.
 %nonassoc LSL_PARENTHESIS_OPEN LSL_PARENTHESIS_CLOSE LSL_EXPRESSION.
-expr(A) ::= LSL_PARENTHESIS_OPEN(B) expr(C) LSL_PARENTHESIS_CLOSE(D).   { A = addParenthesis(B, C, D); }
+expr(A) ::= LSL_PARENTHESIS_OPEN(B)     expr(C) LSL_PARENTHESIS_CLOSE(D).       { A = addParenthesis(B, C, D); }
+
 %right LSL_ASSIGNMENT_ADD LSL_ASSIGNMENT_SUBTRACT LSL_ASSIGNMENT_MULTIPLY LSL_ASSIGNMENT_MODULO LSL_ASSIGNMENT_DIVIDE LSL_ASSIGNMENT_PLAIN.
 %right LSL_DOT.
 %right LSL_DECREMENT_PRE LSL_INCREMENT_PRE.