Added If, ternary, print (Refs #51)[13]

lucasnyc · lucasnyc · commit e391c4f341f0 · 2025-09-19T18:19:32.000+08:00
* added print() for testing on front end
* reworked interpreter to be more script runner and not repl like output

* changes 1
diff --git a/src/cse-machine/py_context.ts b/src/cse-machine/py_context.ts
@@ -10,6 +10,7 @@ import { StmtNS } from '../ast-types';
 export class PyContext {
   public control: PyControl;
   public stash: Stash;
+  public output: string = '';
   //public environment: Environment;
   public errors: CseError[] = [];
 
diff --git a/src/cse-machine/py_interpreter.ts b/src/cse-machine/py_interpreter.ts
@@ -11,11 +11,11 @@ import { PyClosure } from './py_closure';
 import { PyContext } from './py_context';
 import { PyControl, PyControlItem } from './py_control';
 import { createEnvironment, currentEnvironment, pushEnvironment, popEnvironment } from './py_environment';
-import { PyNode, Instr, InstrType, UnOpInstr, BinOpInstr, BoolOpInstr, AssmtInstr, AppInstr } from './py_types';
+import { PyNode, Instr, InstrType, UnOpInstr, BinOpInstr, BoolOpInstr, AssmtInstr, AppInstr, BranchInstr } from './py_types';
 import { Stash, Value, ErrorValue } from './stash';
 import { IOptions } from '..';
 import * as instrCreator from './py_instrCreator';
-import { evaluateUnaryExpression, evaluateBinaryExpression, evaluateBoolExpression } from './py_operators';
+import { evaluateUnaryExpression, evaluateBinaryExpression, evaluateBoolExpression, isFalsy } from './py_operators';
 import { TokenType } from '../tokens';
 import { Token } from '../tokenizer';
 import { Result, Finished, CSEBreak, Representation} from '../types';
@@ -66,9 +66,9 @@ export function PyCSEResultPromise(context: PyContext, value: Value): Promise<Re
  */
 export function PyEvaluate(code: string, program: StmtNS.Stmt, context: PyContext, options: IOptions): Value {
     try {
-        context.control = new PyControl(program);
         context.runtime.isRunning = true;
-
+        context.control = new PyControl(program);
+        
         const result = pyRunCSEMachine(
             code, 
             context, 
@@ -78,7 +78,7 @@ export function PyEvaluate(code: string, program: StmtNS.Stmt, context: PyContex
             options.stepLimit,
             options.isPrelude || false,
         );
-        return result;
+        return context.output ? { type: "string", value: context.output} : { type: 'undefined' };
     } catch(error: any) {
         return { type: 'error', message: error.message};
     } finally {
@@ -98,7 +98,7 @@ export function PyEvaluate(code: string, program: StmtNS.Stmt, context: PyContex
  * @param isPrelude Whether the program is the prelude.
  * @returns The top value of the stash after execution.
  */
-function pyRunCSEMachine(
+export function pyRunCSEMachine(
     code: string, 
     context: PyContext, 
     control: PyControl, 
@@ -397,6 +397,37 @@ const pyCmdEvaluators: { [type: string]: CmdEvaluator } = {
         }
     },
 
+    'If': (code, command, context, control, stash, isPrelude) => {
+        const ifNode = command as StmtNS.If;
+
+        // create branch instruction, wrap statement arrays in 'StatementSequence' objects
+        const branch = instrCreator.branchInstr(
+            { type: 'StatementSequence', body: ifNode.body },
+            ifNode.elseBlock
+                ? (Array.isArray(ifNode.elseBlock)
+                    // 'else' block
+                    ? {type: 'StatementSequence', body: ifNode.elseBlock }            
+                    // 'elif' block
+                    : ifNode.elseBlock)
+                // 'else' block dont exist
+                : null,
+            ifNode
+        );
+        control.push(branch);
+        control.push(ifNode.condition);
+    },
+
+    'Ternary': (code, command, context, control, stash, isPrelude) => {
+        const ternaryNode = command as ExprNS.Ternary;
+            const branch = instrCreator.branchInstr(
+                ternaryNode.consequent,
+                ternaryNode.alternative,
+                ternaryNode
+            );
+        control.push(branch);
+        control.push(ternaryNode.predicate);
+    },
+
     /**
      * Instruction Handlers
      */
@@ -471,31 +502,39 @@ const pyCmdEvaluators: { [type: string]: CmdEvaluator } = {
             args.unshift(stash.pop());
         }
 
-        // pop closure from stash
-        const closure = stash.pop() as PyClosure;
-
-        // push reset and implicit return for cleanup at end of function
-        control.push(instrCreator.resetInstr(instr.srcNode));
+        // pop callable from stash
+        const callable = stash.pop();
 
-        // Only push endOfFunctionBodyInstr for functionDef
-        if (closure.node.constructor.name === 'FunctionDef') {
-            control.push(instrCreator.endOfFunctionBodyInstr(instr.srcNode));
-        }
+        if (callable instanceof PyClosure) {
+            // User-defined function
+            const closure = callable as PyClosure;
+            // push reset and implicit return for cleanup at end of function
+            control.push(instrCreator.resetInstr(instr.srcNode));
 
-        // create new function environment
-        const newEnv = createEnvironment(context, closure, args, instr.srcNode as ExprNS.Call);
-        pushEnvironment(context, newEnv);
+            // Only push endOfFunctionBodyInstr for functionDef
+            if (closure.node.constructor.name === 'FunctionDef') {
+                control.push(instrCreator.endOfFunctionBodyInstr(instr.srcNode));
+            }
 
-        // push function body onto control stack
-        const closureNode = closure.node;
-        if (closureNode.constructor.name === 'FunctionDef') {
-           // 'def' has a body of statements (an array)
-            const bodyStmts = (closureNode as StmtNS.FunctionDef).body.slice().reverse();
-            control.push(...bodyStmts);
+            // create new function environment
+            const newEnv = createEnvironment(context, closure, args, instr.srcNode as ExprNS.Call);
+            pushEnvironment(context, newEnv);
+
+            // push function body onto control stack
+            const closureNode = closure.node;
+            if (closureNode.constructor.name === 'FunctionDef') {
+               // 'def' has a body of statements (an array)
+                const bodyStmts = (closureNode as StmtNS.FunctionDef).body.slice().reverse();
+                control.push(...bodyStmts);
+            } else {
+               // 'lambda' has a body with a single expression
+               const bodyExpr = (closureNode as ExprNS.Lambda).body;
+               control.push(bodyExpr);
+            }
         } else {
-           // 'lambda' has a body with a single expression
-           const bodyExpr = (closureNode as ExprNS.Lambda).body;
-           control.push(bodyExpr);
+            // Built-in function from stdlib / constants
+            const result = (callable as any)(context, ...args);
+            stash.push(result);
         }
     },
 
@@ -508,4 +547,35 @@ const pyCmdEvaluators: { [type: string]: CmdEvaluator } = {
         stash.push({ type: 'undefined' });
     },
 
+    [InstrType.BRANCH]: (code, command, context, control, stash, isPrelude) => {
+        const instr = command as BranchInstr;
+        const condition = stash.pop();
+
+        if (!isFalsy(condition)) {
+            // Condition is truthy, execute the consequent
+            const consequent = instr.consequent;
+            if (consequent && 'type' in consequent && consequent.type === 'StatementSequence') {
+                control.push(...(consequent as any).body.slice().reverse());
+            } else if (consequent) {
+                // consequent of ternary or single statement
+                control.push(consequent);
+            }
+        } else if (instr.alternate) {
+            // Condition is falsy, execute the alternate
+            const alternate = instr.alternate;
+            if (alternate && 'type' in alternate && alternate.type === 'StatementSequence') {
+                // 'else' block
+                control.push(...(alternate as any).body.slice().reverse());
+            } else if (alternate) {
+                // 'elif' or ternary alternative
+                control.push(alternate);
+            }
+        }
+        // If condition is falsy and there's no alternate, do nothing
+    },
+
+    [InstrType.POP]: (code, command, context, control, stash, isPrelude) => {
+        stash.pop();
+    },
+
 };
diff --git a/src/cse-machine/py_operators.ts b/src/cse-machine/py_operators.ts
@@ -1,7 +1,7 @@
 import { Value } from "./stash";
 import { PyContext } from "./py_context";
 import { PyComplexNumber} from "../types";
-import { UnsupportedOperandTypeError, ZeroDivisionError, TypeConcatenateError } from "../errors/py_errors";
+import { UnsupportedOperandTypeError, ZeroDivisionError } from "../errors/py_errors";
 import { ExprNS } from "../ast-types";
 import { TokenType } from "../tokens";
 import { pyHandleRuntimeError, operatorTranslator, pythonMod, typeTranslator } from "./py_utils";
@@ -33,7 +33,7 @@ export type BinaryOperator =
     | "instanceof";
 
 // Helper function for truthiness based on Python rules
-function isFalsy(value: Value): boolean {
+export function isFalsy(value: Value): boolean {
     switch (value.type) {
         case 'bigint':
             return value.value === 0n;
@@ -179,11 +179,12 @@ export function evaluateBinaryExpression(code: string, command: ExprNS.Expr, con
             if (left.type === 'string' && right.type === 'string') {
                 return { type: 'string', value: left.value + right.value };
             } else {
-                const wrongType = left.type === 'string' ? right.type : left.type;
-                pyHandleRuntimeError(context, new TypeConcatenateError(
+                pyHandleRuntimeError(context, new UnsupportedOperandTypeError(
                     code,
                     command,
-                    typeTranslator(wrongType)
+                    left.type,
+                    right.type,
+                    operatorTranslator(operator)
                 ));
             }
         }
@@ -257,7 +258,7 @@ export function evaluateBinaryExpression(code: string, command: ExprNS.Expr, con
                          }
                         return { type: 'number', value: pythonMod(l, r) };
                     case TokenType.DOUBLESTAR: 
-                         if (r === 0) {
+                         if (l === 0 && r < 0) {
                             pyHandleRuntimeError(context, new ZeroDivisionError(code, command, context));
                          }
                     return { type: 'number', value: l ** r };
diff --git a/src/cse-machine/py_types.ts b/src/cse-machine/py_types.ts
@@ -109,6 +109,10 @@ export interface BranchInstr extends BaseInstr {
   alternate: PyNode | null | undefined
 }
 
+export interface PopInstr extends BaseInstr {
+  instrType: InstrType.POP;
+}
+
 export interface EnvInstr extends BaseInstr {
   env: Environment
 }
@@ -126,6 +130,7 @@ export type Instr =
   | EndOfFunctionBodyInstr
   | ResetInstr
   | BranchInstr
+  | PopInstr
   | EnvInstr
   | ArrLitInstr
   | UnOpInstr
diff --git a/src/cse-machine/py_utils.ts b/src/cse-machine/py_utils.ts
@@ -4,6 +4,7 @@ import { PyNode } from "./py_types";
 import { TokenType } from "../tokens";
 import { PyRuntimeSourceError } from "../errors/py_runtimeSourceError";
 import { currentEnvironment, PyEnvironment } from "./py_environment";
+import { builtIns } from "../py_stdlib";
 
 
 export function pyHandleRuntimeError (context: PyContext, error: PyRuntimeSourceError) {
@@ -111,6 +112,9 @@ export function pyGetVariable(context: PyContext, name: string, node: PyNode): V
             environment = environment.tail;
         }
     }
+    if (builtIns.has(name)) {
+        return builtIns.get(name)!;
+    }
     // For now, we throw an error. We can change this to return undefined if needed.
     // handleRuntimeError(context, new TypeError(`name '${name} is not defined`, node as any, context as any, '', ''));
     return { type: 'error', message: `NameError: name '${name}' is not defined` };
diff --git a/src/errors/py_errors.ts b/src/errors/py_errors.ts
@@ -34,26 +34,24 @@ export function createErrorIndicator(snippet: string, errorPos: number): string
   return indicator;
 }
 
-export class TypeConcatenateError extends PyRuntimeSourceError {
-    constructor(source: string, node: ExprNS.Expr, wrongType: string) {
-        super(node);
-        this.type = ErrorType.TYPE;
-
-        const { line, fullLine } = getFullLine(source, node.startToken.indexInSource);
-
-        const snippet = source.substring(node.startToken.indexInSource, node.endToken.indexInSource + node.endToken.lexeme.length);
-        const offset = fullLine.indexOf(snippet);
-        const adjustedOffset = offset >= 0 ? offset : 0;
-
-        const errorPos = (node as any).operator.indexInSource - node.startToken.indexInSource;
-        const indicator = createErrorIndicator(snippet, errorPos);
-        const name = "TypeError";
-        let hint = 'TypeError: can only concatenate str (not "' + wrongType + '") to str.';
-        const suggestion = "You are trying to concatenate a string with an " + wrongType + ". To fix this, convert the " + wrongType + " to a string using str(), or ensure both operands are of the same type.";
-        const msg = `${name} at line ${line}\n\n    ${fullLine}\n    ${' '.repeat(adjustedOffset)}${indicator}\n${hint}\n${suggestion}`;
-        this.message = msg;
-    }
-}
+// export class TypeConcatenateError extends PyRuntimeSourceError {
+//     constructor(source: string, node: ExprNS.Expr, wrongType: string) {
+//         super(node);
+//         this.type = ErrorType.TYPE;
+
+//         let index = (node as any).symbol?.loc?.start?.index;
+//         const { line, fullLine } = getFullLine(source, index);
+//         const snippet = (node as any).symbol?.loc?.source ?? '<unknown source>';
+        
+//         let hint = 'TypeError: can only concatenate str (not "' + wrongType + '") to str.';
+//         const offset = fullLine.indexOf(snippet);
+//         const indicator = createErrorIndicator(snippet, '+');
+//         const name = "TypeError";
+//         const suggestion = "You are trying to concatenate a string with an " + wrongType + ". To fix this, convert the " + wrongType + " to a string using str(), or ensure both operands are of the same type.";
+//         const msg = name + " at line " + line + "\n\n    " + fullLine + "\n    " + " ".repeat(offset) + indicator + "\n" + hint + "\n" + suggestion;
+//         this.message = msg;
+//     }
+// }
 
 export class UnsupportedOperandTypeError extends PyRuntimeSourceError {
     constructor(source: string, node: ExprNS.Expr, wrongType1: string, wrongType2: string, operand: string) {
diff --git a/src/py_stdlib.ts b/src/py_stdlib.ts
@@ -1,6 +1,8 @@
-import { Closure } from "./cse-machine/closure";
+import { PyContext } from './cse-machine/py_context';
+import { PyClosure } from './cse-machine/py_closure';
 import { Value } from "./cse-machine/stash";
-
+import { pyHandleRuntimeError } from "./cse-machine/py_utils";
+import { UnsupportedOperandTypeError } from "./errors/py_errors";
 
 export function toPythonFloat(num: number): string {
     if (Object.is(num, -0)) {
@@ -32,6 +34,9 @@ export function toPythonFloat(num: number): string {
 
 export function toPythonString(obj: Value): string {
     let ret: any;
+    if (!obj) {
+        return 'None';
+    }
     if ((obj as Value).type === 'bigint' || (obj as Value).type === 'complex') {
         ret = (obj as Value).value.toString();
     } else if ((obj as Value).type === 'number') {
@@ -44,16 +49,46 @@ export function toPythonString(obj: Value): string {
         }
     } else if ((obj as Value).type === 'error') {
         return (obj as Value).message;
-    } else if ((obj as unknown as Closure).node) {
-        for (let name in (obj as unknown as Closure).environment!.head) {
-            if ((obj as unknown as Closure).environment!.head[name] === obj) {
-                return '<function ' + name + '>';
-            }
+    } else if (obj instanceof PyClosure) {
+        if (obj.node) {
+            const funcName = (obj.node as any).name?.lexeme || '(anonymous)';
+            return `<function ${funcName}>`;
         }
-    } else if ((obj as Value) === undefined || (obj as Value).value === undefined) {
+    } else if ((obj as Value).value === undefined) {
         ret = 'None';
     } else {
         ret = (obj as Value).value.toString();
     }
     return ret;
-  }
+}
+
+export class BuiltInFunctions {
+    static print(context: PyContext, ...args: Value[]): Value {
+        const output = args.map(arg => toPythonString(arg)).join(' ');
+        context.output += output + '\n';
+        return { type: 'undefined' }; 
+    }
+
+    static _int(context: PyContext, ...args: Value[]): Value {
+        if (args.length === 0) {
+            return { type: 'bigint', value: BigInt(0) };
+        }
+    
+        const arg = args[0];
+        if (arg.type === 'number') {
+            const truncated = Math.trunc(arg.value);
+            return { type: 'bigint', value: BigInt(truncated) };
+        }
+        if (arg.type === 'bigint') {
+            return { type: 'bigint', value: arg.value };
+        }
+    
+        // TODO: Use proper TypeError class once node is passed to built-ins
+        return { type: 'error', message: `TypeError: int() argument must be a string, a bytes-like object or a real number, not '${arg.type}'` };
+    }
+}
+
+// Load only the functions we have implemented
+export const builtIns = new Map<string, (...args: any[]) => any>();
+builtIns.set('print', BuiltInFunctions.print);
+builtIns.set('_int', BuiltInFunctions._int);
