fixed errors and added CHEATSHEET.md

Author: ProgrammerKR

CHEATSHEET.md

@@ -0,0 +1,160 @@
+# ProXPL Cheatsheet
+
+A quick reference guide for the ProX Programming Language (ProXPL).
+
+## 1. Basics
+
+### Comments
+```javascript
+// Single-line comment
+/* Multi-line
+   comment */
+```
+
+### Variables
+ProXPL uses `let` for mutable variables and `const` for constants.
+```javascript
+let x = 10;
+x = 20;
+
+const PI = 3.14;
+// PI = 3.14159; // Error: Assignment to constant
+```
+
+### Data Types
+- **Primitive**: `int`, `float`, `bool`, `string`, `null`.
+- **Composite**: `List`, `Dictionary` (Map).
+
+```javascript
+let isDone = true;
+let count = 42;
+let price = 19.99;
+let name = "ProX";
+let empty = null;
+let list = [1, 2, 3];
+// let map = {"key": "value"}; // (Syntax supported in some contexts)
+```
+
+## 2. Control Flow
+
+### If-Else
+```javascript
+if (score > 90) {
+    print("Excellent");
+} else if (score > 50) {
+    print("Pass");
+} else {
+    print("Fail");
+}
+```
+
+### Loops
+```javascript
+// While Loop
+let i = 0;
+while (i < 5) {
+    print(i);
+    i = i + 1;
+}
+
+// For Loop
+for (let j = 0; j < 5; j = j + 1) {
+    print(j);
+}
+```
+
+## 3. Functions
+
+### Declaration
+```javascript
+func add(a, b) {
+    return a + b;
+}
+
+let sum = add(5, 3);
+```
+
+### Arrow Functions (Short syntax)
+```javascript
+func square(x) => x * x;
+```
+
+## 4. Object-Oriented Programming
+
+### Classes
+```javascript
+class Animal {
+    func speak() {
+        print("Generic sound");
+    }
+}
+
+class Dog extends Animal {
+    func speak() {
+        print("Woof!");
+    }
+}
+```
+
+### Instantiation
+```javascript
+let d = new Dog();
+d.speak(); // Output: Woof!
+```
+
+### Usage of `this`
+```javascript
+class Person {
+    func setAge(a) {
+        this.age = a;
+    }
+}
+```
+
+## 5. Standard Library
+
+### IO (`std.io`)
+```javascript
+print("Hello World");       // Native print
+// or
+use std.io;
+IO.println("Hello World");
+let name = IO.readLine();
+```
+
+### Math (`std.math`)
+```javascript
+use std.math;
+
+let maxVal = Math.max(10, 20);
+let rand = Math.random(); 
+let root = Math.sqrt(16);
+```
+
+### Native Functions
+Built-in global functions available without imports:
+- `print(msg)`
+- `input(prompt)`
+- `to_string(value)`
+- `clock()` - Returns current time
+- `random(min, max)` (If available in specific implementations)
+
+## 6. Operators
+- **Arithmetic**: `+`, `-`, `*`, `/`, `%`
+- **Comparison**: `==`, `!=`, `<`, `>`, `<=`, `>=`
+- **Logical**: `&&`, `||`, `!`
+
+## 7. Example Program
+```javascript
+// fib.prox
+func fib(n) {
+    if (n <= 1) return n;
+    return fib(n - 1) + fib(n - 2);
+}
+
+func main() {
+    print(fib(10));
+}
+
+main();
+```

benchmarks/macro/json_bench.prox

@@ -112,7 +112,7 @@ func main() {
     let parser = JsonParser(json_str);
     let res = parser.parse();
 
-    let elapsed = time() - start;
+    let elapsed = clock() - start;
 
     // Check result
     let users = res["users"];

src/compiler/type_checker.c

@@ -127,7 +127,7 @@ static TypeInfo checkBinary(TypeChecker* checker, Expr* expr) {
     // Let's be safe: if unknown, we can't guarantee safety, but usually in static analysis we warn.
     // Here we will allow it to proceed as Unknown to avoid cascading errors.
     // DEBUG:
-    printf("Binary '%s' L:%d R:%d at line %d\n", op, l.kind, r.kind, expr->line);
+    // printf("Binary '%s' L:%d R:%d at line %d\n", op, l.kind, r.kind, expr->line);
 
     if (l.kind == TYPE_UNKNOWN || r.kind == TYPE_UNKNOWN) {
         return createType(TYPE_UNKNOWN);

src/runtime/vm.c

@@ -467,18 +467,30 @@ static InterpretResult run(VM* vm) {
       DISPATCH();
   }
   DO_OP_SUBTRACT: {
+      if (!IS_NUMBER(peek(vm, 0)) || !IS_NUMBER(peek(vm, 1))) {
+          runtimeError(vm, "Operands must be numbers.");
+          return INTERPRET_RUNTIME_ERROR;
+      }
       double b = AS_NUMBER(pop(vm));
       double a = AS_NUMBER(pop(vm));
       push(vm, NUMBER_VAL(a - b));
       DISPATCH();
   }
   DO_OP_MULTIPLY: {
+      if (!IS_NUMBER(peek(vm, 0)) || !IS_NUMBER(peek(vm, 1))) {
+          runtimeError(vm, "Operands must be numbers.");
+          return INTERPRET_RUNTIME_ERROR;
+      }
       double b = AS_NUMBER(pop(vm));
       double a = AS_NUMBER(pop(vm));
       push(vm, NUMBER_VAL(a * b));
       DISPATCH();
   }
   DO_OP_DIVIDE: {
+      if (!IS_NUMBER(peek(vm, 0)) || !IS_NUMBER(peek(vm, 1))) {
+          runtimeError(vm, "Operands must be numbers.");
+          return INTERPRET_RUNTIME_ERROR;
+      }
       double b = AS_NUMBER(pop(vm));
       double a = AS_NUMBER(pop(vm));
       push(vm, NUMBER_VAL(a / b));

src/stdlib/stdlib_core.c

@@ -33,10 +33,8 @@ extern Value native_clock(int argCount, Value* args);
 static Value native_len(int argCount, Value* args) {
     if (argCount < 1) return NUMBER_VAL(0);
     if (IS_STRING(args[0])) return NUMBER_VAL((double)AS_STRING(args[0])->length);
-    printf("native_len: Type=%d, IS_LIST=%d, IS_STRING=%d\n", AS_OBJ(args[0])->type, IS_LIST(args[0]), IS_STRING(args[0]));
     if (IS_STRING(args[0])) return NUMBER_VAL((double)AS_STRING(args[0])->length);
     if (IS_LIST(args[0])) {
-         printf("It is a list! Count: %d\n", AS_LIST(args[0])->count);
          return NUMBER_VAL((double)AS_LIST(args[0])->count);
     }
     if (IS_DICTIONARY(args[0])) return NUMBER_VAL((double)AS_DICTIONARY(args[0])->items.count);