Added +=, -=, *=, etc. operators

diff --git a/include/onyxlex.h b/include/onyxlex.h
index ed65258e5e79f2ea775a14e4d98ebd629e17114d..6502862d4c039a2024b92ca9646009db41dfc7f9 100644 (file)
--- a/include/onyxlex.h
+++ b/include/onyxlex.h
@@ -53,6 +53,11 @@ typedef enum TokenType {
     TOKEN_TYPE_SYM_BANG,
     TOKEN_TYPE_SYM_CARET,
     TOKEN_TYPE_SYM_AMPERSAND,
+    TOKEN_TYPE_SYM_PLUS_EQUAL,
+    TOKEN_TYPE_SYM_MINUS_EQUAL,
+    TOKEN_TYPE_SYM_STAR_EQUAL,
+    TOKEN_TYPE_SYM_FSLASH_EQUAL,
+    TOKEN_TYPE_SYM_PERCENT_EQUAL,
 
     TOKEN_TYPE_SYMBOL,
     TOKEN_TYPE_LITERAL_STRING,

diff --git a/onyx b/onyx
index ead39f24013624edd5a41908db9705c84703eb31..abdad2c4ba9abd7c3ccf0dd5ed8f9802ae32b027 100755 (executable)
Binary files a/onyx and b/onyx differ

diff --git a/progs/other.onyx b/progs/other.onyx
index db004617d3e196b7debea66e7144f48f981d4693..7bab1efb8f7e8a05e23688299bac48777f04985d 100644 (file)
--- a/progs/other.onyx
+++ b/progs/other.onyx
@@ -14,7 +14,7 @@ export fib :: proc (n: i32) -> i32 {
     count := n;
 
     while count >= 0 {
-        count = count - 1;
+        count -= 1;
 
         c :: a + b;
         b = a;
@@ -31,8 +31,8 @@ export factorial :: proc (n: i32) -> i32 {
     i := 2;
 
     while i <= n {
-        f = f * i;
-        i = i + 1;
+        f *= i;
+        i += 1;
     }
 
     return f;

diff --git a/progs/test.onyx b/progs/test.onyx
index 6a227be43e50d05e29348f8dd1eecdb5bc599238..4f0c08ef43a63f15b103fd38bd3ee465bf4d9cd8 100644 (file)
--- a/progs/test.onyx
+++ b/progs/test.onyx
@@ -17,14 +17,14 @@ export main2 :: proc {
     while i < 10 {
         res :: fib(i);
         print_i32(res);
-        i = i + 1;
+        i += 1;
     }
 
     i = 0;
     while i < 10 {
         res :: factorial(i);
         print_i32(res);
-        i = i + 1;
+        i += 1;
     }
 
     x : i32;
@@ -34,17 +34,17 @@ export main2 :: proc {
         x = 0;
         while x < 5 {
             if x == 3 {
-                x = x + 1;
+                x += 1;
                 continue;
             }
 
             print_i32((x + y * 5) % 10);
-            x = x + 1;
+            x += 1;
         }
 
         if y > 2 { break; }
 
-        y = y + 1;
+        y += 1;
     }
 }
 

diff --git a/src/onyxlex.c b/src/onyxlex.c
index b16d9736995f3e9ffef4b1104ddccab8d08af79d..a280e6a420970264748df45a7f0ce05731f80776 100644 (file)
--- a/src/onyxlex.c
+++ b/src/onyxlex.c
@@ -51,6 +51,11 @@ static const char* token_type_names[] = {
     "!",  // "TOKEN_TYPE_SYM_BANG",
     "^",  // "TOKEN_TYPE_SYM_CARET",
     "&",  // "TOKEN_TYPE_SYM_AMPERSAND",
+    "+=", // "TOKEN_TYPE_SYM_PLUS_EQUAL",
+    "-=", // "TOKEN_TYPE_SYM_MINUS_EQUAL",
+    "*=", // "TOKEN_TYPE_SYM_STAR_EQUAL",
+    "/=", // "TOKEN_TYPE_SYM_FSLASH_EQUAL",
+    "%=", // "TOKEN_TYPE_SYM_PERCENT_EQUAL",
 
     "TOKEN_TYPE_SYMBOL",
     "TOKEN_TYPE_LITERAL_STRING",
@@ -160,6 +165,11 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) {
     LITERAL_TOKEN(">=",         0, TOKEN_TYPE_SYM_GREATER_EQUAL);
     LITERAL_TOKEN("==",         0, TOKEN_TYPE_SYM_EQUAL_EQUAL);
     LITERAL_TOKEN("!=",         0, TOKEN_TYPE_SYM_NOT_EQUAL);
+    LITERAL_TOKEN("+=",         0, TOKEN_TYPE_SYM_PLUS_EQUAL);
+    LITERAL_TOKEN("-=",         0, TOKEN_TYPE_SYM_MINUS_EQUAL);
+    LITERAL_TOKEN("*=",         0, TOKEN_TYPE_SYM_STAR_EQUAL);
+    LITERAL_TOKEN("/=",         0, TOKEN_TYPE_SYM_FSLASH_EQUAL);
+    LITERAL_TOKEN("%=",         0, TOKEN_TYPE_SYM_PERCENT_EQUAL);
     LITERAL_TOKEN("(",          0, TOKEN_TYPE_OPEN_PAREN);
     LITERAL_TOKEN(")",          0, TOKEN_TYPE_CLOSE_PAREN);
     LITERAL_TOKEN("{",          0, TOKEN_TYPE_OPEN_BRACE);

diff --git a/src/onyxparser.c b/src/onyxparser.c
index 3bc38e8d384aa973c12d31fd15c0eacddeadb10d..55d84acb1b5d0a3af1273c468e5559699aeb85cc 100644 (file)
--- a/src/onyxparser.c
+++ b/src/onyxparser.c
@@ -499,6 +499,43 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) {
                 return 1;
             }
 
+        case TOKEN_TYPE_SYM_PLUS_EQUAL:
+        case TOKEN_TYPE_SYM_MINUS_EQUAL:
+        case TOKEN_TYPE_SYM_STAR_EQUAL:
+        case TOKEN_TYPE_SYM_FSLASH_EQUAL:
+        case TOKEN_TYPE_SYM_PERCENT_EQUAL:
+            {
+                OnyxBinaryOp bin_op;
+                if      (parser->curr_token->type == TOKEN_TYPE_SYM_PLUS_EQUAL)    bin_op = ONYX_BINARY_OP_ADD;
+                else if (parser->curr_token->type == TOKEN_TYPE_SYM_MINUS_EQUAL)   bin_op = ONYX_BINARY_OP_MINUS;
+                else if (parser->curr_token->type == TOKEN_TYPE_SYM_STAR_EQUAL)    bin_op = ONYX_BINARY_OP_MULTIPLY;
+                else if (parser->curr_token->type == TOKEN_TYPE_SYM_FSLASH_EQUAL)  bin_op = ONYX_BINARY_OP_DIVIDE;
+                else if (parser->curr_token->type == TOKEN_TYPE_SYM_PERCENT_EQUAL) bin_op = ONYX_BINARY_OP_MODULUS;
+
+                parser_next_token(parser);
+
+                AstNodeTyped* expr = parse_expression(parser);
+
+                AstNodeBinOp* bin_op_node = make_node(AstNodeBinOp, AST_NODE_KIND_BIN_OP);
+                bin_op_node->operation = bin_op;
+
+                AstNode* bin_op_left = make_node(AstNode, AST_NODE_KIND_SYMBOL);
+                bin_op_left->token = symbol;
+                bin_op_node->left = (AstNodeTyped *) bin_op_left;
+                bin_op_node->right = expr;
+
+                AstNodeAssign* assign_node = make_node(AstNodeAssign, AST_NODE_KIND_ASSIGNMENT);
+
+                AstNode* lval = make_node(AstNode, AST_NODE_KIND_SYMBOL);
+                lval->token = symbol;
+                assign_node->lval = (AstNodeTyped *) lval;
+                assign_node->expr = (AstNodeTyped *) bin_op_node;
+
+                *ret = (AstNode *) assign_node;
+
+                return 1;
+            }
+
         default:
             parser_prev_token(parser);
     }