Fixed Multiplication in Strings, Fixed Interables when Dynamically Co…

…nverting to Strings
Tidal-Lang · Oct 12, 2024 · 69456a7 · 69456a7
1 parent 210f874
commit 69456a7
Show file tree

Hide file tree

Showing 7 changed files with 41 additions and 14 deletions.
diff --git a/code/Normal/file-1.td b/code/Normal/file-1.td
@@ -3,5 +3,4 @@ var b;
 
 
 print(a);
-print(b);
-print(c);
+print(b);
diff --git a/code/Normal/file-11.td b/code/Normal/file-11.td
@@ -3,7 +3,7 @@ var i = 0;
 while (true) {
      print(i);
      i = i + 1;
-     if (i == 1000) {
+     if (i == 10) {
           break;
      }
 }
diff --git a/code/Normal/file-13.td b/code/Normal/file-13.td
@@ -12,8 +12,8 @@ if (3 != 2) {
      print("Yay");
 } 
 
-var a = 7 // 2;  
-var b = 7 / 2;   
+a = 7 // 2;  
+b = 7 / 2;   
 
 print(a);
 print(b);

diff --git a/code/Normal/file-15.td b/code/Normal/file-15.td
@@ -1,6 +1,7 @@
 var a = [12, 23, "hi", "hello", "hi", "hi"];
 a[0] = 10;
-novar b = [12, 34123, ["hi", [[["hi"]], "lol", [[[[[[[0, 1, 2 ,3]]]]]], 4, 5, 6]]]];
+print(str(a[0])[0]);
+novar b = [12, 34123, ["1283", [[["hi"]], "lol", [[[[[[[0, 1, 2 ,3]]]]]], 4, 5, 6]]]];
 var c = [];
 
 /* Try Uncommenting This Line: */
@@ -27,6 +28,6 @@ print(type(b));
 print("");
 
 print(type(a[0]));
-print(type(a[0]));
-print(type(b[2][0]));
+print(type(str(a[0])));
+print(type(int(b[2][0])));
 print(type(b[2][1]));
diff --git a/scripts/run-all.sh b/scripts/run-all.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+
+for file in ./code/Normal/*.td; 
+do
+    ./td "$file"
+done
diff --git a/src/interpreter.rs b/src/interpreter.rs
@@ -155,11 +155,30 @@ fn interpret_node(node: &ASTNode, symbol_table: &mut HashMap<String, (Value, boo
                         (Value::String(s), Value::String(t)) => {
                             match op {
                                 Token::Plus => Value::String(s + &t),
+                                Token::Multiply => {
+                                    if let Value::Number(n) = interpret_node(right, symbol_table, is_verbose, in_loop) {
+                                        Value::String(s.repeat(n as usize))
+                                    } else {
+                                        panic!("String can only be multiplied by an integer")
+                                    }
+                                }
                                 Token::Equal => Value::Boolean(s == t),
                                 Token::NotEqual => Value::Boolean(s != t),
                                 _ => panic!("Unsupported operator for strings"),
                             }
                         }
+                        (Value::String(s), Value::Number(n)) => {
+                            match op {
+                                Token::Multiply => Value::String(s.repeat(n as usize)),
+                                _ => panic!("Unsupported operation between string and number"),
+                            }
+                        }
+                        (Value::Number(n), Value::String(s)) => {
+                            match op {
+                                Token::Multiply => Value::String(s.repeat(n as usize)),
+                                _ => panic!("Unsupported operation between number and string"),
+                            }
+                        }
                         (Value::Boolean(b1), Value::Boolean(b2)) => {
                             match op {
                                 Token::Equal => Value::Boolean(b1 == b2),

diff --git a/src/parser.rs b/src/parser.rs
@@ -336,7 +336,7 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_primary(&mut self) -> ASTNode {
-        match &self.current_token {
+        let mut node = match &self.current_token {
             Token::Number(val) => {
                 let num = *val;
                 self.eat(Token::Number(num));
@@ -360,11 +360,7 @@ impl<'a> Parser<'a> {
             Token::Identifier(var_name) => {
                 let name = var_name.clone();
                 self.eat(Token::Identifier(name.clone()));
-                let mut node = ASTNode::Identifier(name);
-                while self.current_token == Token::LBracket {
-                    node = self.parse_index(node);
-                }
-                node
+                ASTNode::Identifier(name)
             }
             Token::TypeLiteral(type_name) => {
                 let name = type_name.clone();
@@ -392,7 +388,12 @@ impl<'a> Parser<'a> {
                 ASTNode::Type(Box::new(expr))
             }
             _ => panic!("Unexpected token in primary: {:?}", self.current_token),
+        };
+        while self.current_token == Token::LBracket {
+            node = self.parse_index(node);
         }
+
+        node
     }
 
     fn parse_array_literal(&mut self) -> ASTNode {