Merge pull request #38 from SahilK-027/main

shashankbhosagi · web-flow · commit e53dd8d55a43 · 2023-10-04T16:55:54.000+05:30
Adding Template Literals in AssemblyScript
diff --git a/BackEnd/Interpreter/interpreter.ts b/BackEnd/Interpreter/interpreter.ts
@@ -24,6 +24,7 @@ import {
   Stmt,
   StringLiteral,
   SwitchStatement,
+  TemplateLiteralNode,
   UnaryExpr,
   VariableDeclaration,
   WakandaForStatement,
@@ -34,6 +35,7 @@ import Environment from "../Scope/environment.ts";
 import {
   BooleanVal,
   MAKE_NUll,
+  MAKE_STRING,
   NumberVal,
   RuntimeVal,
   StringVal,
@@ -100,6 +102,27 @@ const evaluate_identifier = (
   return val;
 };
 
+const evaluate_template_literals = (
+  node: TemplateLiteralNode,
+  env: Environment,
+): RuntimeVal => {
+  let ans = "";
+  node.body.forEach((element) => {
+    switch (typeof element) {
+      case "string":
+        ans += element;
+        break;
+      case "object":
+        const templateLiteralValue = evaluate(element.value, env).value;
+        ans += templateLiteralValue.toString();
+        break;
+      default:
+        throw `RunTimeError: Error while interpreting TemplateLiteralNode`;
+    }
+  });
+  return MAKE_STRING(ans);
+};
+
 /**
  * Evaluates an AST node by handling different node kinds and calling the corresponding evaluation functions.
  * @param astNode - The AST node to evaluate.
@@ -208,6 +231,11 @@ export function evaluate(astNode: Stmt, env: Environment): RuntimeVal {
         astNode as CompoundAssignmentExpr,
         env,
       );
+    case "TemplateLiteral":
+      return evaluate_template_literals(
+        astNode as TemplateLiteralNode,
+        env,
+      );
     default:
       // If the AST node has an unknown or unsupported kind, we log an error and exit the program.
       console.log(astNode);
diff --git a/FrontEnd/AST.ts b/FrontEnd/AST.ts
@@ -33,6 +33,7 @@ export type NodeType =
   | "StringLiteral"
   | "NullLiteral"
   | "BooleanLiteral"
+  | "TemplateLiteral"
   // Function-related nodes
   | "FunctionParam"
   | "FunctionDefinition"
@@ -268,6 +269,14 @@ export interface StringLiteral extends Expr {
   value: string;
 }
 
+/**
+ * Represents an AST node for template literals.
+ */
+export interface TemplateLiteralNode extends Expr {
+  kind: "TemplateLiteral";
+  body: (string | Expr)[];
+}
+
 /**
  * Represents a while statement.
  * The WhileStatement interface represents a while statement. It has the following properties:
diff --git a/FrontEnd/Parser.ts b/FrontEnd/Parser.ts
@@ -27,6 +27,7 @@ import {
   StringLiteral,
   SwitchCase,
   SwitchStatement,
+  TemplateLiteralNode,
   UnaryExpr,
   VariableDeclaration,
   WakandaForStatement,
@@ -1019,6 +1020,56 @@ export default class Parser {
     } as MinusExpr;
   }
 
+  /**
+   * Parses a template literal.
+   *
+   * @returns An Expr object representing the parsed template literal.
+   * @throws {Error} If there are syntax errors or missing tokens in the expression.
+   */
+  private parse_template_literal(): Expr {
+    const parts: (string | TemplateLiteralInterpolation)[] = [];
+    this.expect(
+      TokenType.BackTicks,
+      "Expected template literal to start with a backtick (`)",
+    );
+
+    while (this.at().type !== TokenType.BackTicks) {
+      if (this.at().type === TokenType.Interpolation) {
+        this.eat();
+        this.expect(
+          TokenType.OpenBrace,
+          "Expected template literal to start with a backtick '{'",
+        );
+        if (this.at().type === TokenType.CloseBrace) {
+          this.eat();
+          continue;
+        } else {
+          const interpolation = this.parse_expr();
+          parts.push({
+            value: interpolation,
+            kind: interpolation.kind,
+          });
+          this.expect(
+            TokenType.CloseBrace,
+            "Expected '}'",
+          );
+        }
+      } else if (this.at().type === TokenType.String) {
+        parts.push(this.at().value);
+        this.eat();
+      } else {
+        // Handle other tokens inside template literals
+        throw `SyntaxError:line:${this.at().curr_line}: Unexpected token found inside template literal`;
+      }
+    }
+
+    this.expect(
+      TokenType.BackTicks,
+      "Expected template literal to end with a backtick (`)",
+    );
+
+    return { kind: "TemplateLiteral", body: parts } as TemplateLiteralNode;
+  }
   /**
    * Parses a primary expression.
    *
@@ -1075,6 +1126,10 @@ export default class Parser {
       case TokenType.NotOperator:
         return this.parse_not_expr();
 
+        // Handle template literals
+      case TokenType.BackTicks:
+        return this.parse_template_literal();
+
       default:
         throw `SyntaxError:line:${this.at().curr_line}: Unexpected token found while parsing scanned ${this.at().value}`;
     }
diff --git a/FrontEnd/lexer.ts b/FrontEnd/lexer.ts
@@ -7,6 +7,7 @@ export enum TokenType {
   Number,
   Identifier,
   String,
+  TemplateLiteral, // @{}
   // Keywords
   NewAvenger,
   NewEternal,
@@ -44,6 +45,8 @@ export enum TokenType {
   CloseBrace, // }
   OpenBracket, // [
   CloseBracket, // ]
+  BackTicks, //]
+  Interpolation, //@
   //Easter eggs
   If,
   Else,
@@ -297,8 +300,7 @@ export function tokenize(sourceCode: string): Token[] {
       const token = getMultiCharacterToken(src);
       if (token) {
         tokens.push(token);
-      } // Check for identifiers
-      else if (isAlphabet(src[0])) {
+      } else if (isAlphabet(src[0])) {
         let id = "";
         while (src.length > 0 && isAlphabet(src[0])) {
           id += src.shift();
@@ -323,8 +325,114 @@ export function tokenize(sourceCode: string): Token[] {
       else if (isSkippable(src[0])) {
         // Skip the current character
         src.shift();
-      } // Handle unrecognized characters
-      else {
+      } else if (src[0] === "`") {
+        tokens.push(getToken(src.shift(), TokenType.BackTicks, line_cnt));
+        while (src.length > 0 && src[0] !== "`") {
+          if (src[0] === "@") {
+            tokens.push(
+              getToken(src.shift(), TokenType.Interpolation, line_cnt),
+            );
+            if (src[0] === "{") {
+              tokens.push(getToken(src.shift(), TokenType.OpenBrace, line_cnt));
+              while (src.length > 0 && src[0] !== "}") {
+                if (src[0] === "@") {
+                  break;
+                } else if (src[0] === "{") {
+                  throw `SyntaxError:line:${line_cnt}: nesting within template literal is not allowed.`;
+                } else if (src[0] === "`") {
+                  throw `SyntaxError:line:${line_cnt}: Missing closing '}`;
+                } else if (src[0] === "(") {
+                  tokens.push(
+                    getToken(src.shift(), TokenType.OpenParen, line_cnt),
+                  );
+                } else if (src[0] === ")") {
+                  tokens.push(
+                    getToken(src.shift(), TokenType.CloseParen, line_cnt),
+                  );
+                } else if (src[0] === "[") {
+                  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] === ";") {
+                  tokens.push(
+                    getToken(src.shift(), TokenType.Semicolon, line_cnt),
+                  );
+                } else if (src[0] === "!") {
+                  tokens.push(
+                    getToken(src.shift(), TokenType.NotOperator, line_cnt),
+                  );
+                } else if (src[0] === ":") {
+                  tokens.push(getToken(src.shift(), TokenType.Colon, line_cnt));
+                } else if (src[0] === ",") {
+                  tokens.push(getToken(src.shift(), TokenType.Comma, line_cnt));
+                } else if (src[0] === ".") {
+                  tokens.push(getToken(src.shift(), TokenType.Dot, line_cnt));
+                } else {
+                  const token = getMultiCharacterToken(src);
+                  if (token) {
+                    tokens.push(token);
+                  } else if (isAlphabet(src[0])) {
+                    let id = "";
+                    while (src.length > 0 && isAlphabet(src[0])) {
+                      id += src.shift();
+                    }
+                    // Check for keywords
+                    const reserved: TokenType = KEYWORDS[id];
+                    if (typeof reserved === "number") {
+                      tokens.push(getToken(id, reserved, line_cnt));
+                    } else {
+                      // unreserved means user defined identifier
+                      tokens.push(getToken(id, TokenType.Identifier, line_cnt));
+                    }
+                  } // Build number token
+                  else if (isNum(src[0])) {
+                    let num = "";
+                    while (src.length > 0 && isNum(src[0])) {
+                      num += src.shift();
+                    }
+
+                    tokens.push(getToken(num, TokenType.Number, line_cnt));
+                  } // Skip the skippable character
+                  else if (isSkippable(src[0])) {
+                    // Skip the current character
+                    src.shift();
+                  }
+                }
+              }
+              if (src[0] === "}") {
+                tokens.push(
+                  getToken(src.shift(), TokenType.CloseBrace, line_cnt),
+                );
+              } else {
+                throw `SyntaxError:line:${line_cnt}: missing terminating '}' character.`;
+              }
+            } else {
+              throw `SyntaxError:line:${line_cnt}: missing opening '{' character for template interpolation.`;
+            }
+          } else {
+            let templateString: string = "";
+            while (src.length > 0 && src[0] !== "@" && src[0] !== "`") {
+              templateString += src.shift();
+            }
+            if (src[0] === "@") {
+              tokens.push(getToken(templateString, TokenType.String, line_cnt));
+            } else if (src[0] === "`") {
+              tokens.push(getToken(templateString, TokenType.String, line_cnt));
+              break;
+            }
+          }
+        }
+        if (src[0] === "`") {
+          tokens.push(getToken(src.shift(), TokenType.BackTicks, line_cnt));
+        } else {
+          let backtick = "`";
+          throw `SyntaxError:line:${line_cnt}: missing closing ${backtick} character for template interpolation.`;
+        }
+      } else {
         throw `SyntaxError:line:${line_cnt}: Unrecognised character ${
           src[0]
         } found.`;
@@ -334,6 +442,5 @@ export function tokenize(sourceCode: string): Token[] {
 
   // Push EOF token
   tokens.push({ type: TokenType.EOF, value: "EndOfFile", curr_line: line_cnt });
-
   return tokens;
 }
diff --git a/feat.avenger b/feat.avenger
@@ -1,20 +1,6 @@
 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);
+newEternal PI = 3.142;
+newAvenger template = `The value of i is: @{i} and the value of PI is @{PI}`;
+vision(template);
+vision(`Hello how are you. @{ }`);
+vision(`The value of 22/7 is @{22/7}`);
diff --git a/main.ts b/main.ts
@@ -13,7 +13,7 @@ async function __run(inputFile: string) {
   const program = parser.produceAST(input);
   evaluate(program, env);
 }
-__run("./test.avenger");
+__run("./feat.avenger");
 /**
  * Initializes the script execution.
  */

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ async function __run(inputFile: string) {`
`13`	`13`	`const program = parser.produceAST(input);`
`14`	`14`	`evaluate(program, env);`
`15`	`15`	`}`
`16`		`-__run("./test.avenger");`
	`16`	`+__run("./feat.avenger");`
`17`	`17`	`/**`
`18`	`18`	`* Initializes the script execution.`
`19`	`19`	`*/`