easycoder 260401.2__tar.gz → 260401.4__tar.gz

{easycoder-260401.2 → easycoder-260401.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easycoder
-Version: 260401.2
+Version: 260401.4
 Summary: Rapid scripting in English
 Keywords: compiler,scripting,prototyping,programming,coding,python,low code,hypertalk,computer language,learn to code
 Author-email: Graham Trott <gtanyware@gmail.com>

{easycoder-260401.2 → easycoder-260401.4}/easycoder/__init__.py

@@ -3,7 +3,7 @@
 import importlib
 import math
 
-__version__ = "260401.2"
+__version__ = "260401.4"
 
 from .ec_classes import *
 from .ec_compiler import *

{easycoder-260401.2 → easycoder-260401.4}/easycoder/ec_classes.py

@@ -59,6 +59,9 @@ class RuntimeError(BaseException):
 	def __init__(self, program, message):
 		if program == None:
 			sys.exit(f'Runtime Error: {message}')
+		elif program.onError:
+			program.errorMessage = message
+			program.run(program.onError)
 		else:
 			code = program.code[program.pc]
 			lino = code['lino']

{easycoder-260401.2 → easycoder-260401.4}/easycoder/ec_core.py

@@ -89,13 +89,15 @@ class Core(Handler):
                     record = self.getSymbolRecord()
                     self.checkObjectType(record, ECVariable)
                     command['target'] = record['name']
-                self.add(command)
+                orPC = self.getCodeSize()
+                self.processOr(command, orPC)
                 return True
             else:
                 # Here the variable is the target
                 command['target'] = record['name']
                 if self.getObject(record).isMutable():
-                    self.add(command)
+                    orPC = self.getCodeSize()
+                    self.processOr(command, orPC)
                     return True
         else:
             # Here we have 2 values so 'giving' must come next
@@ -105,26 +107,30 @@ class Core(Handler):
                     record = self.getSymbolRecord()
                     self.checkObjectType(record, ECVariable)
                     command['target'] = record['name']
-                self.add(command)
+                orPC = self.getCodeSize()
+                self.processOr(command, orPC)
                 return True
             # raise FatalError(self.compiler, 'Cannot add values: target variable expected')
         return False
 
     def r_add(self, command):
-        value1 = self.textify(command['value1'])
-        value2 = self.textify(command['value2']) if 'value2' in command else None
-        target = self.getVariable(command['target'])
-        # Check that the target variable is mutable. If not, it's not an arithmetic add
-        # If value2 exists, we are adding two values and storing the result in target
-        if value2 != None:
-            # add X to Y giving Z
-            targetValue = ECValue(type=int, content=int(value1) + int(value2))
-        else:
-            # add X to Y
-            targetValue = self.getSymbolValue(target)
-            targetValue.setContent(int(targetValue.getContent()) + int(value1))
-        self.putSymbolValue(target, targetValue)
-        return self.nextPC()
+        try:
+            value1 = self.textify(command['value1'])
+            value2 = self.textify(command['value2']) if 'value2' in command else None
+            target = self.getVariable(command['target'])
+            if value2 != None:
+                targetValue = ECValue(type=int, content=int(value1) + int(value2))
+            else:
+                targetValue = self.getSymbolValue(target)
+                targetValue.setContent(int(targetValue.getContent()) + int(value1))
+            self.putSymbolValue(target, targetValue)
+            return self.nextPC()
+        except Exception as e:
+            msg = f'Arithmetic error in add: {str(e)}'
+            self.program.errorMessage = msg
+            if command.get('or') != None:
+                return command['or']
+            RuntimeError(self.program, msg)
 
     # Append a value to a list or a queue
     # append {value} to {list/queue}
@@ -461,32 +467,37 @@ class Core(Handler):
                 self.checkObjectType(record, ECVariable)
                 command['target'] = record['name']
                 command['value1'] = value1
-                self.add(command)
+                orPC = self.getCodeSize()
+                self.processOr(command, orPC)
                 return True
         else:
             # Here the first variable is the target
             if variable1 != None:
                 command['target'] = variable1
-                self.add(command)
+                orPC = self.getCodeSize()
+                self.processOr(command, orPC)
                 return True
         return False
 
     def r_divide(self, command):
-        value1 = self.textify(command['value1']) if 'value1' in command else None
-        value2 = self.textify(command['value2'])
-        target = self.getVariable(command['target'])
-        # Check that the target variable can hold a value
-        self.checkObjectType(target, ECVariable)
-        # If value1 exists, we are adding two values and storing the result in target
-        if value1 != None:
-            # divide X by Y giving Z
-            targetValue = ECValue(type=int, content=int(value1) // int(value2))
-        else:
-            # divide X by Y
-            targetValue = self.getSymbolValue(target)
-            targetValue.setContent(int(targetValue.getContent()) // int(value2))
-        self.putSymbolValue(target, targetValue)
-        return self.nextPC()
+        try:
+            value1 = self.textify(command['value1']) if 'value1' in command else None
+            value2 = self.textify(command['value2'])
+            target = self.getVariable(command['target'])
+            self.checkObjectType(target, ECVariable)
+            if value1 != None:
+                targetValue = ECValue(type=int, content=int(value1) // int(value2))
+            else:
+                targetValue = self.getSymbolValue(target)
+                targetValue.setContent(int(targetValue.getContent()) // int(value2))
+            self.putSymbolValue(target, targetValue)
+            return self.nextPC()
+        except Exception as e:
+            msg = f'Arithmetic error in divide: {str(e)}'
+            self.program.errorMessage = msg
+            if command.get('or') != None:
+                return command['or']
+            RuntimeError(self.program, msg)
 
     # download [binary] {url} to {path}
     def k_download(self, command):
@@ -594,16 +605,18 @@ class Core(Handler):
             if response.status_code >= 400:
                 errorCode = response.status_code
                 errorReason = response.reason
+                self.program.errorMessage = f'Error code {errorCode}: {errorReason}'
                 if command['or'] != None:
                     return command['or']
                 else:
-                    RuntimeError(self.program, f'Error code {errorCode}: {errorReason}')
+                    RuntimeError(self.program, self.program.errorMessage)
         except Exception as e:
             errorReason = str(e)
+            self.program.errorMessage = f'Error: {errorReason}'
             if command['or'] != None:
                 return command['or']
             else:
-                RuntimeError(self.program, f'Error: {errorReason}')
+                RuntimeError(self.program, self.program.errorMessage)
         retval.setContent(response.text) # type: ignore
         self.program.putSymbolValue(target, retval)
         return self.nextPC()
@@ -757,15 +770,23 @@ class Core(Handler):
             if self.nextToken() == 'to':
                 # get the value
                 command['value'] = self.nextValue()
-                self.add(command)
+                orPC = self.getCodeSize()
+                self.processOr(command, orPC)
                 return True
         return False
 
     def r_index(self, command):
-        value = self.textify(command['value'])
-        record = self.getVariable(command['target'])
-        self.getObject(record).setIndex(value)
-        return self.nextPC()
+        try:
+            value = self.textify(command['value'])
+            record = self.getVariable(command['target'])
+            self.getObject(record).setIndex(value)
+            return self.nextPC()
+        except Exception as e:
+            msg = f'Index error: {str(e)}'
+            self.program.errorMessage = msg
+            if command.get('or') != None:
+                return command['or']
+            RuntimeError(self.program, msg)
 
     # Input a value from the terminal
     # input {variable} [with {prompt}]
@@ -841,6 +862,7 @@ class Core(Handler):
                 with sftp.open(path, 'r') as remote_file: content = remote_file.read().decode()
             except:
                 errorReason = f'Unable to read from {path}'
+                self.program.errorMessage = errorReason
                 if command['or'] != None:
                     print(f'Exception "{errorReason}": Running the "or" clause')
                     return command['or']
@@ -855,6 +877,7 @@ class Core(Handler):
                 errorReason = f'Unable to read from {filename}'
 
         if errorReason:
+            self.program.errorMessage = errorReason
             if command['or'] != None:
                 print(f'Exception "{errorReason}": Running the "or" clause')
                 return command['or']
@@ -922,32 +945,37 @@ class Core(Handler):
                 self.checkObjectType(record, ECVariable)
                 command['target'] = record['name']
                 command['value1'] = value1
-                self.add(command)
+                orPC = self.getCodeSize()
+                self.processOr(command, orPC)
                 return True
         else:
             # Here the first variable is the target
             if variable1 != None:
                 command['target'] = variable1
-                self.add(command)
+                orPC = self.getCodeSize()
+                self.processOr(command, orPC)
                 return True
         return False
 
     def r_multiply(self, command):
-        value1 = self.textify(command['value1']) if 'value1' in command else None
-        value2 = self.textify(command['value2'])
-        target = self.getVariable(command['target'])
-        # Check that the target variable can hold a value
-        self.checkObjectType(target, ECVariable)
-        # If value1 exists, we are adding two values and storing the result in target
-        if value1 != None:
-            # multiply X by Y giving Z
-            targetValue = ECValue(type=int, content=int(value1) * int(value2))
-        else:
-            # multiply X by Y
-            targetValue = self.getSymbolValue(target)
-            targetValue.setContent(int(targetValue.getContent()) * int(value2))
-        self.putSymbolValue(target, targetValue)
-        return self.nextPC()
+        try:
+            value1 = self.textify(command['value1']) if 'value1' in command else None
+            value2 = self.textify(command['value2'])
+            target = self.getVariable(command['target'])
+            self.checkObjectType(target, ECVariable)
+            if value1 != None:
+                targetValue = ECValue(type=int, content=int(value1) * int(value2))
+            else:
+                targetValue = self.getSymbolValue(target)
+                targetValue.setContent(int(targetValue.getContent()) * int(value2))
+            self.putSymbolValue(target, targetValue)
+            return self.nextPC()
+        except Exception as e:
+            msg = f'Arithmetic error in multiply: {str(e)}'
+            self.program.errorMessage = msg
+            if command.get('or') != None:
+                return command['or']
+            RuntimeError(self.program, msg)
 
     # Negate a variable
     def k_negate(self, command):
@@ -1029,7 +1057,8 @@ class Core(Handler):
                         command['mode'] = mode
                     else:
                         command['mode'] = 'r'
-                    self.add(command)
+                    orPC = self.getCodeSize()
+                    self.processOr(command, orPC)
                     return True
                 else:
                     FatalError(self.compiler, f'Variable "{record["name"]}" is not a file')
@@ -1041,10 +1070,17 @@ class Core(Handler):
         record = self.getVariable(command['target'])
         path = self.textify(command['path'])
         file_path = self.resolveLocalPath(path)
-        if command['mode'] == 'r' and os.path.exists(file_path) or command['mode'] != 'r':
+        try:
+            if command['mode'] == 'r' and not os.path.exists(file_path):
+                raise FileNotFoundError(f"File {path} does not exist")
             record['file'] = open(file_path, command['mode'])
             return self.nextPC()
-        RuntimeError(self.program, f"File {path} does not exist")
+        except Exception as e:
+            msg = str(e)
+            self.program.errorMessage = msg
+            if command.get('or') != None:
+                return command['or']
+            RuntimeError(self.program, msg)
 
     # Dummy command to hit a debugger breakpoint
     def k_pass(self, command):
@@ -1067,16 +1103,24 @@ class Core(Handler):
                     record = self.getSymbolRecord()
                     self.checkObjectType(record, (ECStack, ECQueue))
                     command['from'] = record['name']
-                    self.add(command)
+                    orPC = self.getCodeSize()
+                    self.processOr(command, orPC)
                     return True
         return False
 
     def r_pop(self, command):
-        record = self.getVariable(command['target'])
-        stackRecord = self.getVariable(command['from'])
-        value = stackRecord['object'].pop()
-        self.putSymbolValue(record, value)
-        return self.nextPC()
+        try:
+            record = self.getVariable(command['target'])
+            stackRecord = self.getVariable(command['from'])
+            value = stackRecord['object'].pop()
+            self.putSymbolValue(record, value)
+            return self.nextPC()
+        except Exception as e:
+            msg = f'Pop failed: {str(e)}'
+            self.program.errorMessage = msg
+            if command.get('or') != None:
+                return command['or']
+            RuntimeError(self.program, msg)
 
     # Perform an HTTP POST
     # post {value} to {url} [giving {variable}] [or {command}]
@@ -1109,18 +1153,20 @@ class Core(Handler):
             if response.status_code >= 400:
                 errorCode = response.status_code
                 errorReason = response.reason
+                self.program.errorMessage = f'Error code {errorCode}: {errorReason}'
                 if command['or'] != None:
                     print(f'Error {errorCode} {errorReason}: Running the "or" clause')
                     return command['or']
                 else:
-                    RuntimeError(self.program, f'Error code {errorCode}: {errorReason}')
+                    RuntimeError(self.program, self.program.errorMessage)
         except Exception as e:
             errorReason = str(e)
+            self.program.errorMessage = f'Error: {errorReason}'
             if command['or'] != None:
                 print(f'Exception "{errorReason}": Running the "or" clause')
                 return command['or']
             else:
-                RuntimeError(self.program, f'Error: {errorReason}')
+                RuntimeError(self.program, self.program.errorMessage)
         if command['result'] != None:
             result = self.getVariable(command['result'])
             self.program.putSymbolValue(result, retval)
@@ -1223,25 +1269,33 @@ class Core(Handler):
                     self.checkObjectType(fileRecord['object'], ECFile)
                     command['target'] = record['name']
                     command['file'] = fileRecord['name']
-                    self.add(command)
+                    orPC = self.getCodeSize()
+                    self.processOr(command, orPC)
                     return True
             return False
         FatalError(self.compiler, f'Symbol "{self.getToken()}" has not been declared')
         return False
 
     def r_read(self, command):
-        record = self.getVariable(command['target'])
-        fileRecord = self.getVariable(command['file'])
-        line = command['line']
-        file = fileRecord['file']
-        if file.mode == 'r':
-            if line:
-                content = file.readline().split('\n')[0]
-            else:
-                content = file.readline().rstrip('\n')
-            value = ECValue(type=str, content=content)
-            self.putSymbolValue(record, value)
-        return self.nextPC()
+        try:
+            record = self.getVariable(command['target'])
+            fileRecord = self.getVariable(command['file'])
+            line = command['line']
+            file = fileRecord['file']
+            if file.mode == 'r':
+                if line:
+                    content = file.readline().split('\n')[0]
+                else:
+                    content = file.readline().rstrip('\n')
+                value = ECValue(type=str, content=content)
+                self.putSymbolValue(record, value)
+            return self.nextPC()
+        except Exception as e:
+            msg = f'Read error: {str(e)}'
+            self.program.errorMessage = msg
+            if command.get('or') != None:
+                return command['or']
+            RuntimeError(self.program, msg)
 
     # Release the parent script
     def k_release(self, command):
@@ -1389,6 +1443,7 @@ class Core(Handler):
                 with sftp.open(path, 'w') as remote_file: remote_file.write(content)
             except:
                 errorReason = 'Unable to write to {path}'
+                self.program.errorMessage = errorReason
                 if command['or'] != None:
                     print(f'Exception "{errorReason}": Running the "or" clause')
                     return command['or']
@@ -1409,6 +1464,7 @@ class Core(Handler):
                 errorReason = f'Unable to write to {filename}: {str(e)}'
 
         if errorReason:
+            self.program.errorMessage = errorReason
             if command['or'] != None:
                 print(f'Exception "{errorReason}": Running the "or" clause')
                 return command['or']
@@ -2069,18 +2125,86 @@ class Core(Handler):
                 fileRecord = self.getSymbolRecord()
                 if fileRecord['keyword'] == 'file':
                     command['file'] = fileRecord['name']
-                    self.add(command)
+                    orPC = self.getCodeSize()
+                    self.processOr(command, orPC)
                     return True
         return False
 
     def r_write(self, command):
-        value = self.textify(command['value'])
-        fileRecord = self.getVariable(command['file'])
-        file = fileRecord['file']
-        if file.mode in ['w', 'w+', 'a', 'a+']:
-            file.write(f'{value}')
-            if command['line']:
-                file.write('\n')
+        try:
+            value = self.textify(command['value'])
+            fileRecord = self.getVariable(command['file'])
+            file = fileRecord['file']
+            if file.mode in ['w', 'w+', 'a', 'a+']:
+                file.write(f'{value}')
+                if command['line']:
+                    file.write('\n')
+            return self.nextPC()
+        except Exception as e:
+            msg = f'Write error: {str(e)}'
+            self.program.errorMessage = msg
+            if command.get('or') != None:
+                return command['or']
+            RuntimeError(self.program, msg)
+
+    # Try/or handle block
+    # try ... or handle ... end
+    def k_try(self, command):
+        # Add the try command (handlerPC will be fixed up)
+        tryPC = self.getCodeSize()
+        command['handlerPC'] = 0
+        self.add(command)
+        # Compile the try body up to 'or'
+        self.nextToken()
+        while self.getToken() != 'or':
+            self.compileOne()
+            self.nextToken()
+        # Expect 'handle' after 'or'
+        if self.peek() != 'handle':
+            FatalError(self.compiler, 'Expected "handle" after "or" in try block')
+        self.nextToken()
+        self.nextToken()
+        # Add a gotoPC to skip the handler on success
+        skipPC = self.getCodeSize()
+        cmd = {}
+        cmd['lino'] = command['lino']
+        cmd['domain'] = 'core'
+        cmd['keyword'] = 'gotoPC'
+        cmd['goto'] = 0
+        cmd['debug'] = False
+        self.add(cmd)
+        # Fix up the try command's handlerPC
+        self.getCommandAt(tryPC)['handlerPC'] = self.getCodeSize()
+        # Compile the handler body up to 'end'
+        while self.getToken() != 'end':
+            self.compileOne()
+            self.nextToken()
+        # Add the endTry command
+        endPC = self.getCodeSize()
+        cmd = {}
+        cmd['lino'] = command['lino']
+        cmd['domain'] = 'core'
+        cmd['keyword'] = 'endTry'
+        cmd['debug'] = False
+        self.add(cmd)
+        # Fix up the skip goto
+        self.getCommandAt(skipPC)['goto'] = endPC
+        return True
+
+    def r_try(self, command):
+        # Save current onError and set up the try handler
+        if not hasattr(self.program, 'onErrorStack'):
+            self.program.onErrorStack = []
+        self.program.onErrorStack.append(self.program.onError)
+        self.program.onError = command['handlerPC']
+        return self.nextPC()
+
+    def r_endTry(self, command):
+        # Restore onError from the stack
+        if hasattr(self.program, 'onErrorStack') and len(self.program.onErrorStack) > 0:
+            self.program.onError = self.program.onErrorStack.pop()
+        else:
+            self.program.onError = 0
         return self.nextPC()
 
     #############################################################################
@@ -2324,6 +2448,10 @@ class Core(Handler):
                 self.nextToken()
                 value.item = 'errorReason' # type: ignore
                 return value
+            elif token == 'message':
+                self.nextToken()
+                value.item = 'errorMessage' # type: ignore
+                return value
             elif token in ['in', 'of']:
                 self.nextToken()
                 if self.nextIsSymbol():
@@ -2332,7 +2460,9 @@ class Core(Handler):
                         value.item = 'sshError' # type: ignore
                         value.name = record['name'] # type: ignore
                         return value
-            return None
+            # Unqualified 'the error' returns errorMessage (same as JS)
+            value.item = 'errorMessage' # type: ignore
+            return value
 
         if token == 'type':
             if self.nextIs('of'):
@@ -2474,6 +2604,8 @@ class Core(Handler):
             value.setValue(type=int, content=errorCode)
         elif item == 'errorReason':
             value.setValue(type=str, content=errorReason)
+        elif item == 'errorMessage':
+            value.setValue(type=str, content=getattr(self.program, 'errorMessage', ''))
         elif item == 'sshError':
             record = self.getVariable(v.name)
             value.setValue(type=str, content=record['error'] if 'error' in record else '')

{easycoder-260401.2 → easycoder-260401.4}/easycoder/ec_program.py

@@ -75,6 +75,7 @@ class Program:
 		self.pc = 0
 		self.symbols = {}
 		self.onError = 0
+		self.errorMessage = ''
 		self.debugStep = False
 		self.debugSkip = False
 		self.stack = []

easycoder-260401.2/test.py

@@ -1,7 +0,0 @@
-#!/bin/python3
-
-import os
-from easycoder import Program
-
-os.chdir('/home/graham/dev/easycoder/easycoder-py/tests')
-Program('test.ecs').start()

easycoder-260401.2/testController.py

@@ -1,7 +0,0 @@
-#!/bin/python3
-
-import os
-from easycoder import Program
-
-os.chdir('/home/graham/dev/rbr/Controller/')
-Program('newController.ecs').start()

easycoder-260401.2/testDoclets.py

@@ -1,7 +0,0 @@
-#!/bin/python3
-
-import os
-from easycoder import Program
-
-os.chdir('/home/graham/dev/doclets')
-Program('doclets.ecs').start()

easycoder-260401.2/testServer.py

@@ -1,7 +0,0 @@
-#!/bin/python3
-
-import os
-from easycoder import Program
-
-os.chdir('/home/graham/dev/doclets')
-Program('docletServer.ecs').start()

easycoder-260401.2/test_debug_graphics.py

@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-import sys
-from easycoder import Program
-
-# Test with a graphics script
-test_script = """
-script TestDebugGraphics
-    use graphics
-    
-    window MainWindow
-    create MainWindow title `Debug Graphics Test` size 400 300
-    
-    show MainWindow
-    exit
-"""
-
-# Create temporary test script
-test_file = '/tmp/test_debug_graphics.ecs'
-with open(test_file, 'w') as f:
-    f.write(test_script)
-
-print("Testing debug mode with graphics...")
-try:
-    program = Program(f'debug {test_file}')
-    print(f"Debugging enabled: {program.debugging}")
-    print(f"Script: {program.scriptName}")
-    
-    # Note: This will hang waiting for user interaction with the GUI
-    # In a real test, we'd close the windows automatically
-    program.start()
-    
-    if program.debugger:
-        print("SUCCESS: Debugger was created for graphics!")
-    else:
-        print("FAILED: Debugger was not created for graphics")
-        
-except Exception as e:
-    print(f"Error: {e}")
-    import traceback
-    traceback.print_exc()

easycoder-260401.2/test_debug_launch.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-import sys
-from easycoder import Program
-
-# Test with a simple script
-test_script = """
-script TestDebug
-    print `Debug launch test`
-    exit
-"""
-
-# Create temporary test script
-test_file = '/tmp/test_debug.ecs'
-with open(test_file, 'w') as f:
-    f.write(test_script)
-
-print("Testing debug mode launch...")
-try:
-    program = Program(f'debug {test_file}')
-    print(f"Debugging enabled: {program.debugging}")
-    print(f"Script: {program.scriptName}")
-    
-    # Check that debugger is created
-    program.start()
-    
-    if program.debugger:
-        print("SUCCESS: Debugger was created!")
-    else:
-        print("FAILED: Debugger was not created")
-        
-except Exception as e:
-    print(f"Error: {e}")
-    import traceback
-    traceback.print_exc()