Merge pull request #36 from SahilK-027/main

Feature: Add Compound Assignment Operators (+=, -=, =, /=, %=, ^= etc.)

Author: SahilK-027

BackEnd/Interpreter/Expressions/Compound_assignment.ts

@@ -0,0 +1,75 @@
+import { CompoundAssignmentExpr, Identifier } from "../../../FrontEnd/AST.ts";
+import Environment from "../../Scope/environment.ts";
+import { MAKE_NUll, RuntimeVal } from "../../values.ts";
+import { evaluate } from "../interpreter.ts";
+
+export const evaluate_compound_assignment_expression = (
+  node: CompoundAssignmentExpr,
+  env: Environment,
+): RuntimeVal => {
+  if (node.assignee.kind === "Identifier") {
+    const varname = (node.assignee as Identifier).symbol;
+    const varValue = env.lookupVar(varname);
+    const operator = node.operator;
+
+    // Evaluate the right-hand side expression once
+    const rightValue = evaluate(node.val, env);
+
+    if (varValue.type === rightValue.type) {
+      switch (operator) {
+        case "+=":
+          if (varValue.type === "number") {
+            const value = varValue.value + rightValue.value;
+            console.log(value);
+            return env.assignVar(varname, value);
+          }
+          break;
+        case "-=":
+          if (varValue.type === "number") {
+            const value = varValue.value - rightValue.value;
+            console.log(value);
+            return env.assignVar(varname, value);
+          }
+          break;
+        case "*=":
+          if (varValue.type === "number") {
+            const value = varValue.value * rightValue.value;
+            console.log(value);
+            return env.assignVar(varname, value);
+          }
+          break;
+        case "/=":
+          if (varValue.type === "number") {
+            const value = varValue.value / rightValue.value;
+            console.log(value);
+            return env.assignVar(varname, value);
+          }
+          break;
+        case "%=":
+          if (varValue.type === "number") {
+            const value = varValue.value % rightValue.value;
+            console.log(value);
+            return env.assignVar(varname, value);
+          }
+          break;
+        case "^=":
+          if (varValue.type === "number") {
+            const value = Math.pow(varValue.value, rightValue.value);
+            console.log(value);
+            return env.assignVar(varname, value);
+          }
+          break;
+        default:
+          throw new Error(
+            `Operator '${operator}' is not supported for type '${varValue.type}'`,
+          );
+      }
+    } else {
+      throw new Error(
+        `Type Mismatch: Cannot use operator '${operator}' with different types`,
+      );
+    }
+  }
+
+  return MAKE_NUll();
+};

BackEnd/Interpreter/interpreter.ts

@@ -9,6 +9,7 @@ import {
   BooleanLiteral,
   CallExpr,
   ComparisonExpression,
+  CompoundAssignmentExpr,
   ElseStatement,
   ForEachLoopStatement,
   FunctionDefinition,
@@ -43,6 +44,7 @@ import {
   evaluate_unary_expr,
 } from "./Expressions/Boolean_expression.ts";
 import { evaluate_comparison_expression } from "./Expressions/Comparison_expression.ts";
+import { evaluate_compound_assignment_expression } from "./Expressions/Compound_assignment.ts";
 import {
   evaluate_assignment_expression,
   evaluate_member_expression,
@@ -200,6 +202,12 @@ export function evaluate(astNode: Stmt, env: Environment): RuntimeVal {
 
     case "ReturnStatement":
       return evaluate_return_statement(astNode as ReturnStatement, env);
+
+    case "CompoundAssignmentExpr":
+      return evaluate_compound_assignment_expression(
+        astNode as CompoundAssignmentExpr,
+        env,
+      );
     default:
       // If the AST node has an unknown or unsupported kind, we log an error and exit the program.
       console.log(astNode);

FrontEnd/AST.ts

@@ -25,6 +25,7 @@ export type NodeType =
   | "LogicalExpression"
   | "UnaryExpr"
   | "MinusExpr"
+  | "CompoundAssignmentExpr"
   // Literals
   | "Identifier"
   | "NumericLiteral"
@@ -379,6 +380,22 @@ export interface MinusExpr extends Expr {
   argument: Expr;
 }
 
+/**
+ * Represents a compound assignment expression.
+ * The CompoundAssignmentExpr interface represents a compound assignment expression.
+ * It has the following properties:
+ * - kind: The type of the node ("CompoundAssignmentExpression").
+ * - assignee: The expression being assigned.
+ * - operator: The compound assignment operator used in the expression.
+ * - val: The value being assigned.
+ */
+export interface CompoundAssignmentExpr extends Expr {
+  kind: "CompoundAssignmentExpr";
+  assignee: Expr;
+  operator: string; // This can be "+=", "-=", "/=", etc.
+  val: Expr;
+}
+
 /**
  * ===========================================================================================
  *                        User Defined Functions

FrontEnd/Parser.ts

@@ -8,6 +8,7 @@ import {
   BreakStatement,
   CallExpr,
   ComparisonExpression,
+  CompoundAssignmentExpr,
   ElseStatement,
   Expr,
   ForEachLoopStatement,
@@ -754,6 +755,16 @@ export default class Parser {
         assignee: left,
         kind: "AssignmentExpression",
       } as AssignmentExpression;
+    } else if (this.at().type === TokenType.CompoundAssignmentOperator) {
+      const operator = this.at().value;
+      this.eat();
+      const value = this.parse_assignment_expr();
+      return {
+        assignee: left,
+        val: value,
+        kind: "CompoundAssignmentExpr",
+        operator: operator,
+      } as CompoundAssignmentExpr;
     }
     return left;
   }

FrontEnd/lexer.ts

@@ -36,6 +36,7 @@ export enum TokenType {
   BinaryOperator,
   LogicalOperator,
   ComparisonOperator,
+  CompoundAssignmentOperator,
   NotOperator,
   OpenParen, // (
   CloseParen, // )
@@ -173,6 +174,12 @@ export function tokenize(sourceCode: string): Token[] {
       ">": TokenType.ComparisonOperator,
       "&&": TokenType.LogicalOperator,
       "||": TokenType.LogicalOperator,
+      "+=": TokenType.CompoundAssignmentOperator,
+      "*=": TokenType.CompoundAssignmentOperator,
+      "/=": TokenType.CompoundAssignmentOperator,
+      "-=": TokenType.CompoundAssignmentOperator,
+      "%=": TokenType.CompoundAssignmentOperator,
+      "^=": TokenType.CompoundAssignmentOperator,
     };
 
     for (const operator in operators) {
@@ -199,9 +206,8 @@ export function tokenize(sourceCode: string): Token[] {
       if (src[0] === '"') {
         src.shift(); // Consume the closing double quote
         return getToken(string, TokenType.String, line_cnt);
-      } else {
-        throw `SyntaxError:line:${line_cnt}: missing terminating '"' character.`;
       }
+      throw `SyntaxError:line:${line_cnt}: missing terminating '"' character.`;
     }
 
     if (src[0] === "'") {
@@ -215,11 +221,20 @@ export function tokenize(sourceCode: string): Token[] {
       if (src[0] === "'") {
         src.shift(); // Consume the closing double quote
         return getToken(string, TokenType.String, line_cnt);
-      } else {
-        throw `SyntaxError:line:${line_cnt}: missing terminating ''' character.`;
       }
+      throw `SyntaxError:line:${line_cnt}: missing terminating ''' character.`;
     }
 
+    if (
+      src[0] === "+" ||
+      src[0] === "-" ||
+      src[0] === "*" ||
+      src[0] === "/" ||
+      src[0] === "%" ||
+      src[0] === "^"
+    ) {
+      return getToken(src.shift(), TokenType.BinaryOperator, line_cnt);
+    }
     return null;
   }
 
@@ -268,15 +283,6 @@ export function tokenize(sourceCode: string): Token[] {
       tokens.push(getToken(src.shift(), TokenType.OpenBracket, line_cnt));
     } else if (src[0] === "]") {
       tokens.push(getToken(src.shift(), TokenType.CloseBracket, line_cnt));
-    } else if (
-      src[0] === "+" ||
-      src[0] === "-" ||
-      src[0] === "*" ||
-      src[0] === "/" ||
-      src[0] === "%" ||
-      src[0] === "^"
-    ) {
-      tokens.push(getToken(src.shift(), TokenType.BinaryOperator, line_cnt));
     } else if (src[0] === ";") {
       tokens.push(getToken(src.shift(), TokenType.Semicolon, line_cnt));
     } else if (src[0] === "!") {
@@ -328,5 +334,6 @@ export function tokenize(sourceCode: string): Token[] {
 
   // Push EOF token
   tokens.push({ type: TokenType.EOF, value: "EndOfFile", curr_line: line_cnt });
+
   return tokens;
 }

TODO.md

@@ -18,14 +18,14 @@
 - [x] Implement user defined functions
 - [x] Write test cases
 - [x] Documentation
+- [x] For loop new syntax
 
 ## Increment
 
-- [x] For loop new syntax
+- [x] Add support for `+=` `-=` `*=` `/=` `%=` `^=` operator
 
 ## Backlog
 
 - [ ] Implement objects
 - [ ] Implement error handling
 - [ ] Optimize performance
-- [ ] Add support for `+=` `-=` `*=` `/=` `%=` `^=` operator

feat.avenger

@@ -1,6 +1,20 @@
-newAvenger i;
-wakandaFor( i = 0 ; 10 ;i = i + 1){
-    newAvenger temp = 10;
-    vision(i);
-    vision(temp);
-}
+newAvenger i = 27;
+newAvenger j = 27;
+newAvenger k = 27;
+newAvenger l = 27;
+newAvenger m = 27;
+newAvenger n = 27;
+
+i += 3;
+j -= 3;
+k *= 3;
+l /= 3;
+m %= 10;
+n ^= 2;
+
+vision(i);
+vision(j);
+vision(k);
+vision(l);
+vision(m);
+vision(n);