gdded variable assignment and compare (Refs #51)[8]

* tsconfig.json: added ignoreDeprecations to for backward compatibility
  with moduleresolution
* new files: py_environment
* Introduced for simple handling of variable declarations
TODO: undeclared variable error

Author: lucasnyc

src/cse-machine/py_context.ts

@@ -1,6 +1,6 @@
 import { Stash, Value } from './stash';
 import { PyControl, PyControlItem } from './py_control';
-import { createSimpleEnvironment, createProgramEnvironment, Environment } from './environment';
+import { createSimpleEnvironment, createProgramEnvironment, Environment } from './py_environment';
 import { CseError } from './error';
 import { Heap } from './heap';
 import { PyNode } from './py_types';

src/cse-machine/py_environment.ts

@@ -0,0 +1,119 @@
+import { Value } from './stash';
+import { Heap } from './heap';
+// import { Closure } from './closure';
+import { PyContext } from './py_context';
+import { PyNode } from './py_types';
+import { ExprNS } from '../ast-types';
+
+
+export interface Frame {
+  [name: string]: any
+}
+
+export interface Environment {
+  readonly id: string
+  name: string
+  tail: Environment | null
+  callExpression?: ExprNS.Call;
+  head: Frame
+  heap: Heap
+  thisContext?: Value
+}
+
+export const uniqueId = (context: PyContext): string => {
+  return `${context.runtime.objectCount++}`
+}
+
+// export const createEnvironment = (
+//   context: PyContext,
+//   closure: Closure,
+//   args: Value[],
+//   callExpression: ExprNS.Call
+// ): Environment => {
+//   const environment: Environment = {
+//     // TODO: name
+//     name: '',
+//     tail: closure.environment,
+//     head: {},
+//     heap: new Heap(),
+//     id: uniqueId(context),
+//     callExpression: {
+//       ...callExpression,
+//       //arguments: args.map(ast.primitive)
+//     }
+//   }
+  
+//   // console.info('closure.node.params:', closure.node.params);
+//   // console.info('Number of params:', closure.node.params.length);
+
+//   closure.node.params.forEach((param, index) => {
+//     if (isRestElement(param)) {
+//       const array = args.slice(index)
+//       handleArrayCreation(context, array, environment)
+//       environment.head[(param.argument as es.Identifier).name] = array
+//     } else {
+//       environment.head[(param as es.Identifier).name] = args[index]
+//     }
+//   })
+//   return environment
+// }
+
+export const createSimpleEnvironment = (
+  context: PyContext,
+  name: string,
+  tail: Environment | null = null
+): Environment => {
+  return {
+    id: uniqueId(context),
+    name,
+    tail,
+    head: {},
+    heap: new Heap(),
+    // TODO: callExpression and thisContext are optional and can be provided as needed.
+  };
+};
+
+export const createProgramEnvironment = (context: PyContext, isPrelude: boolean): Environment => {
+  return createSimpleEnvironment(context, isPrelude ? 'prelude' : 'programEnvironment');
+};
+
+export const createBlockEnvironment = (
+  context: PyContext,
+  name = 'blockEnvironment'
+): Environment => {
+  return {
+    name,
+    tail: currentEnvironment(context),
+    head: {},
+    heap: new Heap(),
+    id: uniqueId(context)
+  }
+}
+
+// export const isRestElement = (node: Node): node is es.RestElement => {
+//   return (node as es.RestElement).type === 'RestElement';
+// };
+
+// export const handleArrayCreation = (
+//   context: PyContext,
+//   array: any[],
+//   envOverride?: Environment
+// ): void => {
+//   const environment = envOverride ?? currentEnvironment(context);
+//   Object.defineProperties(array, {
+//     id: { value: uniqueId(context) },
+//     environment: { value: environment, writable: true }
+//   });
+//   environment.heap.add(array as any);
+// };
+
+export const currentEnvironment = (context: PyContext): Environment => {
+  return context.runtime.environments[0];
+};
+
+export const popEnvironment = (context: PyContext) => context.runtime.environments.shift()
+
+export const pushEnvironment = (context: PyContext, environment: Environment) => {
+  context.runtime.environments.unshift(environment)
+  context.runtime.environmentTree.insert(environment)
+}

src/cse-machine/py_interpreter.ts

@@ -1,7 +1,7 @@
 import { StmtNS, ExprNS } from '../ast-types';
 import { PyContext } from './py_context';
 import { PyControl, PyControlItem } from './py_control';
-import { PyNode, Instr, InstrType, UnOpInstr, BinOpInstr, BoolOpInstr } from './py_types';
+import { PyNode, Instr, InstrType, UnOpInstr, BinOpInstr, BoolOpInstr, AssmtInstr } from './py_types';
 import { Stash, Value, ErrorValue } from './stash';
 import { IOptions } from '..';
 import * as instr from './py_instrCreator';
@@ -10,6 +10,7 @@ import { TokenType } from '../tokens';
 import { Token } from '../tokenizer';
 import { Result, Finished, CSEBreak, Representation} from '../types';
 import { toPythonString } from '../stdlib'
+import { pyGetVariable, pyDefineVariable } from './py_utils';
 
 type CmdEvaluator = (
   command: PyControlItem,
@@ -149,20 +150,44 @@ const pyCmdEvaluators: { [type: string]: CmdEvaluator } = {
     },
 
     'Variable': (command, context, control, stash, isPrelude) => {
-        const variable = command as ExprNS.Variable;
-        const name = variable.name.lexeme;
-        // For now, we only handle built in constants.
-        // In a future commit, we will look up variables in the environment.
+        const variableNode = command as ExprNS.Variable;
+        const name = variableNode.name.lexeme;
+        
         if (name === 'True') {
             stash.push({ type: 'bool', value: true });
         } else if (name === 'False') {
             stash.push({ type: 'bool', value: false });
         } else {
-            // Throw an error for undefined variables for now
-            throw new Error(`NameError: name '${name}' is not defined`);
+            // if not built in, look up in environment
+            const value = pyGetVariable(context, name, variableNode)
+            stash.push(value);
         }
     },
 
+    'Compare': (command, context, control, stash, isPrelude) => {
+        const compareNode = command as ExprNS.Compare;
+        // For now, we only handle simple, single comparisons.
+        const opStr = mapOperatorToPyOperator(compareNode.operator);
+        const op_instr = instr.binOpInstr(opStr, compareNode);
+        control.push(op_instr);
+        control.push(compareNode.right);
+        control.push(compareNode.left);
+    },
+    
+    'Assign': (command, context, control, stash, isPrelude) => {
+        const assignNode = command as StmtNS.Assign;
+
+        const assmtInstr = instr.assmtInstr(
+            assignNode.name.lexeme, 
+            false,
+            true,
+            assignNode
+        );
+
+        control.push(assmtInstr);
+        control.push(assignNode.value);
+    },
+
     /**
      * Instruction Handlers
      */
@@ -242,4 +267,13 @@ const pyCmdEvaluators: { [type: string]: CmdEvaluator } = {
             throw new Error(`Unsupported boolean operator: ${instr.symbol}`);
         }
     },
+
+    [InstrType.ASSIGNMENT]: (command, context, control, stash, isPrelude) => {
+        const instr = command as AssmtInstr;
+        const value = stash.pop(); // Get the evaluated value from the stash
+
+        if (value) {
+            pyDefineVariable(context, instr.symbol, value);
+        }
+    },
 };

src/cse-machine/py_operators.ts

@@ -433,7 +433,7 @@ export function evaluateBinaryExpression(code: string, command: ExprNS.Expr, con
             }
     } 
     // Same type Integer Operations
-    else if (left.type === 'bigint' && right.type ==='bigint') {    
+    else {    
         const leftBigInt = left.value as bigint;
         const rightBigInt = right.value as bigint;
         let result: bigint | boolean;

src/cse-machine/py_utils.ts

@@ -1,9 +1,15 @@
-import { Context } from "./context";
-import { ExprNS } from "../ast-types";
+import { PyContext } from "./py_context";
+import { Value } from "./stash";
+import { PyNode } from "./py_types";
 import { TokenType } from "../tokens";
-import { UnsupportedOperandTypeError } from "../errors/errors";
+import { RuntimeSourceError } from "../errors/runtimeSourceError";
+import { currentEnvironment, Environment } from "./py_environment";
+import { TypeError } from "../errors/errors";
 
-export function handleRuntimeError (context: Context, error: any) {
+
+
+export function handleRuntimeError (context: PyContext, error: RuntimeSourceError) {
+  context.errors.push(error);
   throw error;
 }
 
@@ -29,23 +35,21 @@ export function typeTranslator(type: string): string {
 // TODO: properly adapt for the rest, string is passed in to cater for __py_adder etc...
 export function operandTranslator(operand: TokenType | string) {
   if (typeof operand === 'string') {
-    return operand;
+    switch (operand) {
+      case "__py_adder": return "+";
+      case "__py_minuser": return "-";
+      case "__py_multiplier": return "*";
+      case "__py_divider": return "/";
+      case "__py_modder": return "%";
+      case "__py_powerer": return "**";
+      default: return operand;
+    }
   }
   switch (operand) {
-    case TokenType.PLUS:
-      return '+';
-    case TokenType.MINUS:
-      return '-';
-    case TokenType.STAR:
-      return '*';
-    case TokenType.SLASH:
-      return '/';
     case TokenType.LESS:
       return '<';
     case TokenType.GREATER:
       return '>';
-    case TokenType.PERCENT:
-      return '%';
     case TokenType.DOUBLEEQUAL:
       return '==';
     case TokenType.NOTEQUAL:
@@ -54,12 +58,8 @@ export function operandTranslator(operand: TokenType | string) {
       return '<=';
     case TokenType.GREATEREQUAL:
       return '>=';
-    case TokenType.DOUBLESTAR:
-      return '**';
     case TokenType.NOT:
       return 'not';
-    case TokenType.DOUBLESLASH:
-      return '//';
     default:
         return String(operand);
   }
@@ -73,3 +73,26 @@ export function pythonMod(a: any, b: any): any {
     return mod + b;
   }
 }
+
+export function pyDefineVariable(context: PyContext, name: string, value: Value) {
+    const environment = currentEnvironment(context);
+    Object.defineProperty(environment.head, name, {
+        value: value,
+        writable: true,
+        enumerable: true
+    });
+}
+
+export function pyGetVariable(context: PyContext, name: string, node: PyNode): Value {
+    let environment: Environment | null = currentEnvironment(context);
+    while (environment) {
+        if (Object.prototype.hasOwnProperty.call(environment.head, name)) {
+            return environment.head[name];
+        } else {
+            environment = environment.tail;
+        }
+    }
+    // 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: 'unreachable' }; 
+}

src/errors/errors.ts

@@ -261,10 +261,11 @@ export class TypeError extends RuntimeSourceError {
                   ?? '<unknown source>';
     let hint = "TypeError: '" + originalType + "' cannot be interpreted as an '" + targetType + "'.";
     const offset = fullLine.indexOf(snippet);
+    const adjustedOffset = offset >= 0 ? offset : 0;
     const indicator = createErrorIndicator(snippet, '@');
     const name = "TypeError";
     const suggestion = ' Make sure the value you are passing is compatible with the expected type.';
-    const msg = name + " at line " + line + "\n\n    " + fullLine + "\n    " + " ".repeat(offset) + indicator + "\n" + hint + suggestion;
+    const msg = name + " at line " + line + "\n\n    " + fullLine + "\n    " + " ".repeat(adjustedOffset) + indicator + "\n" + hint + suggestion;
     this.message = msg;
   }
 }

tsconfig.json

@@ -36,6 +36,7 @@
     "module": "commonjs",//"ESNext",//                                /* Specify what module code is generated. */
     "rootDir": "src",                                    /* Specify the root folder within your source files. */
     "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    "ignoreDeprecations": "6.0",
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
     // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */