easycoder 250118.1__py2.py3-none-any.whl → 251103.4__py2.py3-none-any.whl

easycoder/ec_core.py

@@ -1,8 +1,9 @@
-import json, math, hashlib, threading, os, subprocess, sys, requests, time, numbers, base64
+import json, math, hashlib, threading, os, subprocess, time
+import numbers, base64, binascii, random, requests, paramiko
+from copy import deepcopy
 from psutil import Process
-from datetime import datetime, timezone
-from random import randrange
-from .ec_classes import FatalError, RuntimeWarning, RuntimeError, AssertionError, Condition
+from datetime import datetime
+from .ec_classes import FatalError, RuntimeWarning, RuntimeError, AssertionError, NoValueError, NoValueRuntimeError, Object
 from .ec_handler import Handler
 from .ec_timestamp import getTimestamp
 
@@ -14,6 +15,29 @@ class Core(Handler):
 
     def getName(self):
         return 'core'
+    
+    def noSymbolWarning(self):
+        self.warning(f'Symbol "{self.getToken()}" not found')
+    
+    def processOr(self, command, orHere):
+        self.add(command)
+        if self.peek() == 'or':
+            self.nextToken()
+            self.nextToken()
+            # Add a 'goto' to skip the 'or'
+            cmd = {}
+            cmd['lino'] = command['lino']
+            cmd['domain'] = 'core'
+            cmd['keyword'] = 'gotoPC'
+            cmd['goto'] = 0
+            cmd['debug'] = False
+            skip = self.getPC()
+            self.add(cmd)
+            # Process the 'or'
+            self.getCommandAt(orHere)['or'] = self.getPC()
+            self.compileOne()
+            # Fixup the skip
+            self.getCommandAt(skip)['goto'] = self.getPC()
 
     #############################################################################
     # Keyword handlers
@@ -26,7 +50,7 @@ class Core(Handler):
         if self.nextToken() == 'to':
             if self.nextIsSymbol():
                 symbolRecord = self.getSymbolRecord()
-                if symbolRecord['valueHolder']:
+                if symbolRecord['hasValue']:
                     if self.peek() == 'giving':
                         # This variable must be treated as a second value
                         command['value2'] = self.getValue()
@@ -57,7 +81,7 @@ class Core(Handler):
         except:
             value2 = None
         target = self.getVariable(command['target'])
-        if not target['valueHolder']:
+        if not target['hasValue']:
             self.variableDoesNotHoldAValueError(target['name'])
         targetValue = self.getSymbolValue(target)
         if targetValue == None:
@@ -87,11 +111,11 @@ class Core(Handler):
         if self.nextIs('to'):
             if self.nextIsSymbol():
                 symbolRecord = self.getSymbolRecord()
-                if symbolRecord['valueHolder']:
+                if symbolRecord['hasValue']:
                     command['target'] = symbolRecord['name']
                     self.add(command)
                     return True
-                self.warning(f'Core.append: Variable "{symbolRecord["name"]}" does not hold a value')
+                self.warning(f'Core.append: Variable {symbolRecord["name"]} does not hold a value')
         return False
 
     def r_append(self, command):
@@ -106,14 +130,6 @@ class Core(Handler):
         self.putSymbolValue(target, val)
         return self.nextPC()
 
-    # Define an array
-    def k_array(self, command):
-        return self.compileVariable(command)
-
-    def r_array(self, command):
-        return self.nextPC()
-
-    # Assertion
     #assert {condition} [with {message}]
     def k_assert(self, command):
         command['test'] = self.nextCondition()
@@ -122,7 +138,7 @@ class Core(Handler):
             command['with'] = self.nextValue()
         else:
             command['with'] = None
-        self.addCommand(command)
+        self.add(command)
         return True
 
     def r_assert(self, command):
@@ -139,29 +155,30 @@ class Core(Handler):
             cmd['keyword'] = 'end'
             cmd['debug'] = True
             cmd['lino'] = command['lino']
-            self.addCommand(cmd)
+            self.add(cmd)
             return self.nextPC()
         else:
             return self.compileFromHere(['end'])
 
-    # Clear (set False)
     # clear {variable}
     def k_clear(self, command):
         if self.nextIsSymbol():
             target = self.getSymbolRecord()
-            if target['valueHolder']:
-                command['target'] = target['name']
+            command['target'] = target['name']
+            if target['hasValue'] or target['keyword'] == 'ssh':
                 self.add(command)
                 return True
         return False
 
     def r_clear(self, command):
         target = self.getVariable(command['target'])
-        val = {}
-        val['type'] = 'boolean'
-        val['content'] = False
-        self.putSymbolValue(target, val)
-        # self.add(command)
+        if target['keyword'] == 'ssh':
+            target['ssh'] = None
+        else:
+            val = {}
+            val['type'] = 'boolean'
+            val['content'] = False
+            self.putSymbolValue(target, val)
         return self.nextPC()
 
     # Close a file
@@ -200,7 +217,11 @@ class Core(Handler):
     # Debug the script
     def k_debug(self, command):
         token = self.peek()
-        if token in ['step', 'stop', 'program', 'custom']:
+        if token == 'compile':
+            self.compiler.debugCompile = True
+            self.nextToken()
+            return True
+        elif token in ['step', 'stop', 'program', 'custom']:
             command['mode'] = token
             self.nextToken()
         elif token == 'stack':
@@ -220,7 +241,9 @@ class Core(Handler):
         return True
 
     def r_debug(self, command):
-        if command['mode'] == 'step':
+        if command['mode'] == 'compile':
+            self.program.debugStep = True
+        elif command['mode'] == 'step':
             self.program.debugStep = True
         elif command['mode'] == 'stop':
             self.program.debugStep = False
@@ -245,46 +268,48 @@ class Core(Handler):
     def k_decrement(self, command):
         if self.nextIsSymbol():
             symbolRecord = self.getSymbolRecord()
-            if symbolRecord['valueHolder']:
+            if symbolRecord['hasValue']:
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'Core.decrement: Variable "{symbolRecord["name"]}" does not hold a value')
+            self.warning(f'Core.decrement: Variable {symbolRecord["name"]} does not hold a value')
         return False
 
     def r_decrement(self, command):
         return self.incdec(command, '-')
 
     # Delete a file or a property
-    # delete {filename}
+    # delete file {filename}
     # delete property {value} of {variable}
+    # delete element {name} of {variable}
     def k_delete(self, command):
         token = self.nextToken( )
+        command['type'] = token
         if token == 'file':
-            command['type'] = 'file'
             command['filename'] = self.nextValue()
             self.add(command)
             return True
-        elif token == 'property':
-            command['key'] = self.nextValue();
-            if self.nextIs('of'):
-                command['type'] = 'property'
-                command['var'] = self.nextToken()
-                self.add(command)
-                return True
-            else:
-                self.warning(f'Core.delete: "of" expected; got {self.getToken()}')
+        elif token in ['property', 'element']:
+            command['key'] = self.nextValue()
+            self.skip('of')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['hasValue']:
+                    command['var'] = record['name']
+                    self.add(command)
+                    return True
+                NoValueError(self.compiler, record)
+            self.warning(f'Core.delete: variable expected; got {self.getToken()}')
         else:
-            self.warning(f'Core.delete: "file" or "property" expected; got {token}')
+            self.warning(f'Core.delete: "file", "property" or "element" expected; got {token}')
         return False
 
     def r_delete(self, command):
         type = command['type']
         if type == 'file':
             filename = self.getRuntimeValue(command['filename'])
-            if os.path.isfile(filename):
-                print('Deleting',filename)
-                os.remove(filename)
+            if filename != None:
+                if os.path.isfile(filename): os.remove(filename)
         elif type == 'property':
             key = self.getRuntimeValue(command['key'])
             symbolRecord = self.getVariable(command['var'])
@@ -293,6 +318,15 @@ class Core(Handler):
             content.pop(key, None)
             value['content'] = content
             self.putSymbolValue(symbolRecord, value)
+        elif type == 'element':
+            key = self.getRuntimeValue(command['key'])
+            symbolRecord = self.getVariable(command['var'])
+            value = self.getSymbolValue(symbolRecord)
+            content = value['content']
+            if key >= 0 and key < len(content): del(content[key])
+            else: RuntimeError(self.program, f'Index {key} out of range')
+            value['content'] = content
+            self.putSymbolValue(symbolRecord, value)
         return self.nextPC()
 
     # Arithmetic division
@@ -308,7 +342,7 @@ class Core(Handler):
                     command['target'] = self.getToken()
                     self.add(command)
                     return True
-                FatalError(self.program.compiler, 'Symbol expected')
+                FatalError(self.compiler, 'Symbol expected')
             else:
                 # First value must be a variable
                 if command['value1']['type'] == 'symbol':
@@ -325,7 +359,7 @@ class Core(Handler):
         except:
             value2 = None
         target = self.getVariable(command['target'])
-        if not target['valueHolder']:
+        if not target['hasValue']:
             self.variableDoesNotHoldAValueError(target['name'])
             return None
         value = self.getSymbolValue(target)
@@ -345,6 +379,29 @@ class Core(Handler):
         self.putSymbolValue(target, value)
         return self.nextPC()
 
+    # download [binary] {url} to {path}
+    def k_download(self, command):
+        if self.nextIs('binary'):
+            command['binary'] = True
+            self.nextToken()
+        else: command['binary'] = False
+        command['url'] = self.getValue()
+        self.skip('to')
+        command['path'] = self.nextValue()
+        self.add(command)
+        return True
+    
+    def r_download(self, command):
+        binary = command['binary']
+        url = self.getRuntimeValue(command['url'])
+        path = self.getRuntimeValue(command['path'])
+        mode = 'wb' if binary else 'w'
+        response = requests.get(url, stream=True)
+        with open(path, mode) as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk: f.write(chunk)
+        return self.nextPC()
+
     # Dummy command for testing
     def k_dummy(self, command):
         self.add(command)
@@ -367,11 +424,13 @@ class Core(Handler):
         return True
 
     def r_exit(self, command):
+        if self.program.parent == None and self.program.graphics != None:
+            self.program.graphics.force_exit(None)
         return -1
 
     # Declare a file variable
     def k_file(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command)
 
     def r_file(self, command):
         return self.nextPC()
@@ -395,46 +454,32 @@ class Core(Handler):
         self.run(label)
         return next
 
-    # Issue a REST GET request
     # get {variable) from {url} [or {command}]
     def k_get(self, command):
         if self.nextIsSymbol():
             symbolRecord = self.getSymbolRecord()
-            if symbolRecord['valueHolder']:
+            if symbolRecord['hasValue']:
                 command['target'] = self.getToken()
             else:
-                FatalError(self.compiler, f'Variable "{symbolRecord["name"]}" does not hold a value')
+                NoValueError(self.compiler, symbolRecord)
         if self.nextIs('from'):
-            command['url'] = self.nextValue()
-        command['or'] = None
-        get = self.getPC()
-        if self.peek() == 'timeout':
-            self.nextToken()
-            command['timeout'] = self.nextValue()
-        else:
-            timeout = {}
-            timeout['type'] = 'int'
-            timeout['content'] = 5
-            command['timeout'] = timeout
-        self.addCommand(command)
-        if self.peek() == 'or':
-            self.nextToken()
-            self.nextToken()
-            # Add a 'goto' to skip the 'or'
-            cmd = {}
-            cmd['lino'] = command['lino']
-            cmd['domain'] = 'core'
-            cmd['keyword'] = 'gotoPC'
-            cmd['goto'] = 0
-            cmd['debug'] = False
-            skip = self.getPC()
-            self.addCommand(cmd)
-            # Process the 'or'
-            self.getCommandAt(get)['or'] = self.getPC()
-            self.compileOne()
-            # Fixup the skip
-            self.getCommandAt(skip)['goto'] = self.getPC()
-        return True
+            if self.nextIs('url'):
+                url = self.nextValue()
+                if url != None:
+                    command['url'] = url
+                    command['or'] = None
+                    get = self.getPC()
+                    if self.peek() == 'timeout':
+                        self.nextToken()
+                        command['timeout'] = self.nextValue()
+                    else:
+                        timeout = {}
+                        timeout['type'] = 'int'
+                        timeout['content'] = 5
+                        command['timeout'] = timeout
+                    self.processOr(command, get)
+                    return True
+        return False
 
     def r_get(self, command):
         global errorCode, errorReason
@@ -499,17 +544,17 @@ class Core(Handler):
 
     def r_gosub(self, command):
         label = command['gosub'] + ':'
-        address = self.symbols[label]
-        if address != None:
+        if label in self.symbols:
+            address = self.symbols[label]
             self.stack.append(self.nextPC())
             return address
-        RuntimeError(self.program, f'There is no label "{label + ":"}"')
+        RuntimeError(self.program, f'There is no label "{label}"')
         return None
 
     # if <condition> <action> [else <action>]
     def k_if(self, command):
         command['condition'] = self.nextCondition()
-        self.addCommand(command)
+        self.add(command)
         self.nextToken()
         pcElse = self.getPC()
         cmd = {}
@@ -518,7 +563,7 @@ class Core(Handler):
         cmd['keyword'] = 'gotoPC'
         cmd['goto'] = 0
         cmd['debug'] = False
-        self.addCommand(cmd)
+        self.add(cmd)
         # Get the 'then' code
         self.compileOne()
         if self.peek() == 'else':
@@ -531,7 +576,7 @@ class Core(Handler):
             cmd['keyword'] = 'gotoPC'
             cmd['goto'] = 0
             cmd['debug'] = False
-            self.addCommand(cmd)
+            self.add(cmd)
             # Fixup the link to the 'else' branch
             self.getCommandAt(pcElse)['goto'] = self.getPC()
             # Process the 'else' branch
@@ -552,37 +597,29 @@ class Core(Handler):
             self.program.pc += 1
         return self.program.pc
 
+    # Import one or more variables
     def k_import(self, command):
-        if self.peek() == 'plugin':
-            # Import a plugin
+        imports = []
+        while True:
+            keyword = self.nextToken()
+            name = self.nextToken()
+            item = [keyword, name]
+            imports.append(item)
+            self.symbols[name] = self.getPC()
+            variable = {}
+            variable['domain'] = None
+            variable['name'] = name
+            variable['keyword'] = keyword
+            variable['import'] = None
+            variable['used'] = False
+            variable['hasValue'] = True if keyword == 'variable' else False
+            self.add(variable)
+            if self.peek() != 'and':
+                break
             self.nextToken()
-            clazz = self.nextToken()
-            if self.nextIs('from'):
-                source = self.nextToken()
-                self.program.importPlugin(f'{source}:{clazz}')
-                return True
-            return False
-        else:
-            # Import one or more variables
-            imports = []
-            while True:
-                keyword = self.nextToken()
-                name = self.nextToken()
-                item = [keyword, name]
-                imports.append(item)
-                self.symbols[name] = self.getPC()
-                variable = {}
-                variable['domain'] = None
-                variable['name'] = name
-                variable['keyword'] = keyword
-                variable['import'] = None
-                self.addCommand(variable)
-                if self.peek() != 'and':
-                    break
-                self.nextToken()
-            command['imports'] = json.dumps(imports)
-            self.add(command)
-            return True
+        command['imports'] = json.dumps(imports)
+        self.add(command)
+        return True
 
     def r_import(self, command):
         exports = self.program.exports
@@ -606,11 +643,11 @@ class Core(Handler):
     def k_increment(self, command):
         if self.nextIsSymbol():
             symbolRecord = self.getSymbolRecord()
-            if symbolRecord['valueHolder']:
+            if symbolRecord['hasValue']:
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'Core.increment: Variable "{symbolRecord["name"]}" does not hold a value')
+            self.warning(f'Core.increment: Variable {symbolRecord["name"]} does not hold a value')
         return False
 
     def r_increment(self, command):
@@ -686,7 +723,7 @@ class Core(Handler):
         return self.nextPC()
 
     # 1 Load a plugin. This is done at compile time.
-    # 2 Load text from a file
+    # 2 Load text from a file or ssh
     def k_load(self, command):
         self.nextToken()
         if self.tokenIs('plugin'):
@@ -696,19 +733,60 @@ class Core(Handler):
                 self.program.importPlugin(f'{source}:{clazz}')
                 return True
         elif self.isSymbol():
-            command['target'] = self.getToken()
-            if self.nextIs('from'):
-                command['file'] = self.nextValue()
-                self.add(command)
-                return True
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['hasValue']:
+                command['target'] = symbolRecord['name']
+                if self.nextIs('from'):
+                    if self.nextIsSymbol():
+                        record = self.getSymbolRecord()
+                        if record['keyword'] == 'ssh':
+                            command['ssh'] = record['name']
+                            command['path'] = self.nextValue()
+                        else:
+                            command['file'] = self.getValue()
+                    else:
+                        command['file'] = self.getValue()
+                    command['or'] = None
+                    load = self.getPC()
+                    self.processOr(command, load)
+                    return True
+        else:
+            FatalError(self.compiler, f'I don\'t understand \'{self.getToken()}\'')
         return False
 
     def r_load(self, command):
+        errorReason = None
         target = self.getVariable(command['target'])
-        file = self.getRuntimeValue(command['file'])
-        f = open(file, 'r')
-        content = f.read()
-        f.close()
+        if 'ssh' in command:
+            ssh = self.getVariable(command['ssh'])
+            path = self.getRuntimeValue(command['path'])
+            sftp = ssh['sftp']
+            try:
+                with sftp.open(path, 'r') as remote_file: content = remote_file.read().decode()
+            except:
+                errorReason = f'Unable to read from {path}'
+                if command['or'] != None:
+                    print(f'Exception "{errorReason}": Running the "or" clause')
+                    return command['or']
+                else:
+                    RuntimeError(self.program, f'Error: {errorReason}')
+        else:
+            filename = self.getRuntimeValue(command['file'])
+            try:
+                with open(filename) as f: content = f.read()
+                try:
+                    if filename.endswith('.json'): content = json.loads(content)
+                except:
+                    errorReason = 'Bad or null JSON string'
+            except:
+                errorReason = f'Unable to read from {filename}'
+
+        if errorReason:
+            if command['or'] != None:
+                print(f'Exception "{errorReason}": Running the "or" clause')
+                return command['or']
+            else:
+                RuntimeError(self.program, f'Error: {errorReason}')
         value = {}
         value['type'] = 'text'
         value['content'] = content
@@ -729,6 +807,12 @@ class Core(Handler):
         target['locked'] = True
         return self.nextPC()
 
+    # Log a message
+    def k_log(self, command):
+        command['log'] = True
+        command['keyword'] = 'print'
+        return self.k_print(command)
+
     # Declare a module variable
     def k_module(self, command):
         return self.compileVariable(command)
@@ -749,14 +833,14 @@ class Core(Handler):
                     command['target'] = self.getToken()
                     self.add(command)
                     return True
-                FatalError(self.program.compiler, 'Symbol expected')
+                FatalError(self.compiler, 'Symbol expected')
             else:
                 # First value must be a variable
                 if command['value1']['type'] == 'symbol':
                     command['target'] = command['value1']['name']
                     self.add(command)
                     return True
-                FatalError(self.program.compiler, 'First value must be a variable')
+                FatalError(self.compiler, 'First value must be a variable')
         return False
 
     def r_multiply(self, command):
@@ -766,7 +850,7 @@ class Core(Handler):
         except:
             value2 = None
         target = self.getVariable(command['target'])
-        if not target['valueHolder']:
+        if not target['hasValue']:
             self.variableDoesNotHoldAValueError(target['name'])
             return None
         value = self.getSymbolValue(target)
@@ -791,17 +875,17 @@ class Core(Handler):
     def k_negate(self, command):
         if self.nextIsSymbol():
             symbolRecord = self.getSymbolRecord()
-            if symbolRecord['valueHolder']:
+            if symbolRecord['hasValue']:
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'Core.negate: Variable "{symbolRecord["name"]}" does not hold a value')
+            self.warning(f'Core.negate: Variable {symbolRecord["name"]} does not hold a value')
         return False
 
     def r_negate(self, command):
         symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['valueHolder']:
-            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
+        if not symbolRecord['hasValue']:
+            NoValueRuntimeError(self.program, symbolRecord)
             return None
         value = self.getSymbolValue(symbolRecord)
         if value == None:
@@ -810,13 +894,6 @@ class Core(Handler):
         self.putSymbolValue(symbolRecord, value)
         return self.nextPC()
 
-    # Define an object variable
-    def k_object(self, command):
-        return self.compileVariable(command)
-
-    def r_object(self, command):
-        return self.nextPC()
-
     # on message {action}
     def k_on(self, command):
         if self.nextIs('message'):
@@ -829,7 +906,7 @@ class Core(Handler):
             cmd['keyword'] = 'gotoPC'
             cmd['goto'] = 0
             cmd['debug'] = False
-            self.addCommand(cmd)
+            self.add(cmd)
             # Add the action and a 'stop'
             self.compileOne()
             cmd = {}
@@ -837,7 +914,7 @@ class Core(Handler):
             cmd['lino'] = command['lino']
             cmd['keyword'] = 'stop'
             cmd['debug'] = False
-            self.addCommand(cmd)
+            self.add(cmd)
             # Fixup the link
             command['goto'] = self.getPC()
             return True
@@ -865,7 +942,7 @@ class Core(Handler):
                     elif token == 'writing':
                         mode = 'w'
                     else:
-                        FatalError(self.program.compiler, 'Unknown file open mode {self.getToken()}')
+                        FatalError(self.compiler, 'Unknown file open mode {self.getToken()}')
                         return False
                     command['mode'] = mode
                 else:
@@ -898,15 +975,15 @@ class Core(Handler):
                     command['from'] = self.getToken()
                     self.add(command)
                     return True
-        return False;
+        return False
 
     def r_pop(self, command):
         symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['valueHolder']:
-            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
+        if not symbolRecord['hasValue']:
+            NoValueRuntimeError(self.program, symbolRecord)
         stackRecord = self.getVariable(command['from'])
         stack = self.getSymbolValue(stackRecord)
-        v = stack.pop();
+        v = stack.pop()
         self.putSymbolValue(stackRecord, stack)
         value = {}
         value['type'] = 'int' if type(v) == int else 'text'
@@ -931,24 +1008,7 @@ class Core(Handler):
             command['result'] = None
         command['or'] = None
         post = self.getPC()
-        self.addCommand(command)
-        if self.peek() == 'or':
-            self.nextToken()
-            self.nextToken()
-            # Add a 'goto' to skip the 'or'
-            cmd = {}
-            cmd['lino'] = command['lino']
-            cmd['domain'] = 'core'
-            cmd['keyword'] = 'gotoPC'
-            cmd['goto'] = 0
-            cmd['debug'] = False
-            skip = self.getPC()
-            self.addCommand(cmd)
-            # Process the 'or'
-            self.getCommandAt(post)['or'] = self.getPC()
-            self.compileOne()
-            # Fixup the skip
-            self.getCommandAt(skip)['goto'] = self.getPC()
+        self.processOr(command, post)
         return True
 
     def r_post(self, command):
@@ -988,18 +1048,20 @@ class Core(Handler):
             command['value'] = value
             self.add(command)
             return True
-        FatalError(self.program.compiler, 'I can\'t print this value')
+        FatalError(self.compiler, 'I can\'t print this value')
         return False
 
     def r_print(self, command):
         value = self.getRuntimeValue(command['value'])
         program = command['program']
         code = program.code[program.pc]
-        lino = code['lino'] + 1
-        if value == None:
-            print(f'{lino}-> <empty>')
+        lino = str(code['lino'] + 1)
+#        while len(lino) < 5: lino = f' {lino}'
+        if value == None: value = '<empty>'
+        if 'log' in command:
+            print(f'{datetime.now().time()}:{self.program.name}:{lino}->{value}')
         else:
-            print(f'{lino}-> {value}')
+            print(value)
         return self.nextPC()
 
     # Push a value onto a stack
@@ -1018,7 +1080,7 @@ class Core(Handler):
         return False
 
     def r_push(self, command):
-        value = self.getRuntimeValue(command['value'])
+        value = deepcopy(self.getRuntimeValue(command['value']))
         stackRecord = self.getVariable(command['to'])
         if stackRecord['keyword'] != 'stack':
             RuntimeError(self.program, f'{stackRecord["name"]} is not a stack')
@@ -1031,30 +1093,35 @@ class Core(Handler):
         self.putSymbolValue(stackRecord, stack)
         return self.nextPC()
 
-    # Put a value into a variable
     # put {value} into {variable}
     def k_put(self, command):
-        command['value'] = self.nextValue()
-        if self.nextIs('into'):
-            if self.nextIsSymbol():
-                symbolRecord = self.getSymbolRecord()
-                command['target'] = symbolRecord['name']
-                if 'valueholder' in symbolRecord and symbolRecord['valueHolder'] == False:
-                    FatalError(self.program.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
+        value = self.nextValue()
+        if value != None:
+            command['value'] = value
+            if self.nextIs('into'):
+                if self.nextIsSymbol():
+                    symbolRecord = self.getSymbolRecord()
+                    command['target'] = symbolRecord['name']
+                    if 'hasValue' in symbolRecord and symbolRecord['hasValue'] == False:
+                        FatalError(self.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
+                    else:
+                        command['or'] = None
+                        self.processOr(command, self.getPC())
+                        return True
                 else:
-                    self.add(command)
-                    return True
-            else:
-                FatalError(self.program.compiler, f'Symbol {self.getToken()} is not a variable')
+                    FatalError(self.compiler, f'Symbol {self.getToken()} is not a variable')
         return False
 
     def r_put(self, command):
         value = self.evaluate(command['value'])
         if value == None:
-            return -1
+            if command['or'] != None:
+                return command['or']
+            else:
+                RuntimeError(self.program, f'Error: could not compute value')
         symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['valueHolder']:
-            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
+        if not symbolRecord['hasValue']:
+            NoValueRuntimeError(self.program, symbolRecord)
             return -1
         self.putSymbolValue(symbolRecord, value)
         return self.nextPC()
@@ -1069,7 +1136,7 @@ class Core(Handler):
             command['line'] = False
         if self.nextIsSymbol():
             symbolRecord = self.getSymbolRecord()
-            if symbolRecord['valueHolder']:
+            if symbolRecord['hasValue']:
                 if self.peek() == 'from':
                     self.nextToken()
                     if self.nextIsSymbol():
@@ -1079,9 +1146,9 @@ class Core(Handler):
                             command['file'] = fileRecord['name']
                             self.add(command)
                             return True
-            FatalError(self.program.compiler, f'Symbol "{symbolRecord["name"]}" is not a value holder')
+            FatalError(self.compiler, f'Symbol "{symbolRecord["name"]}" is not a value holder')
             return False
-        FatalError(self.program.compiler, f'Symbol "{self.getToken()}" has not been declared')
+        FatalError(self.compiler, f'Symbol "{self.getToken()}" has not been declared')
         return False
 
     def r_read(self, command):
@@ -1098,6 +1165,16 @@ class Core(Handler):
             self.putSymbolValue(symbolRecord, value)
         return self.nextPC()
 
+    # Release the parent script
+    def k_release(self, command):
+        if self.nextIs('parent'):
+            self.add(command)
+        return True
+
+    def r_release(self, command):
+        self.program.releaseParent()
+        return self.nextPC()
+
     # Replace a substring
     #replace {value} with {value} in {variable}
     def k_replace(self, command):
@@ -1128,16 +1205,6 @@ class Core(Handler):
         self.putSymbolValue(templateRecord, value)
         return self.nextPC()
 
-    # Release the parent script
-    def k_release(self, command):
-        if self.nextIs('parent'):
-            self.add(command)
-        return True
-
-    def r_release(self, command):
-        self.program.releaseParent()
-        return self.nextPC()
-
     # Return from subroutine
     def k_return(self, command):
         self.add(command)
@@ -1147,6 +1214,7 @@ class Core(Handler):
         return self.stack.pop()
 
     # Compile and run a script
+    # run {path} [as {module}] [with {variable} [and {variable}...]]
     def k_run(self, command):
         try:
             command['path'] = self.nextValue()
@@ -1157,20 +1225,24 @@ class Core(Handler):
             if self.nextIsSymbol():
                 record = self.getSymbolRecord()
                 if record['keyword'] == 'module':
-                    command['module'] = record['name']
-                    exports = []
-                    if self.nextIs('with'):
-                        while True:
-                            name = self.nextToken()
-                            record = self.getSymbolRecord()
-                            exports.append(name)
-                            if self.peek() != 'and':
-                                break
-                            self.nextToken()
-                    command['exports'] = json.dumps(exports)
-                    self.add(command)
-                    return True
-        return False
+                    name = record['name']
+                    command['module'] = name
+                else: FatalError(self.compiler, f'Symbol \'name\' is not a module')
+            else: FatalError(self.compiler, 'Module name expected after \'as\'')
+        else: FatalError(self.compiler, '\'as {module name}\' expected')
+        exports = []
+        if self.peek() == 'with':
+            self.nextToken()
+            while True:
+                name = self.nextToken()
+                record = self.getSymbolRecord()
+                exports.append(name)
+                if self.peek() != 'and':
+                    break
+                self.nextToken()
+        command['exports'] = json.dumps(exports)
+        self.add(command)
+        return True
 
     def r_run(self, command):
         module = self.getVariable(command['module'])
@@ -1187,28 +1259,63 @@ class Core(Handler):
         p(path).start(parent, module, exports)
         return 0
 
-    # Provide a name for the script
-    def k_script(self, command):
-        self.program.name = self.nextToken()
-        return True
-
     # Save a value to a file
     def k_save(self, command):
         command['content'] = self.nextValue()
-        if self.nextIs('to'):
-            command['file'] = self.nextValue()
-            self.add(command)
-            return True
-        return False
+        self.skip('to')
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['keyword'] == 'ssh':
+                command['ssh'] = record['name']
+                command['path'] = self.nextValue()
+                self.add(command)
+            else:
+                command['file'] = self.getValue()
+        else:
+            command['file'] = self.getValue()
+        command['or'] = None
+        save = self.getPC()
+        self.processOr(command, save)
+        return True
 
     def r_save(self, command):
+        errorReason = None
         content = self.getRuntimeValue(command['content'])
-        file = self.getRuntimeValue(command['file'])
-        f = open(file, 'w')
-        f.write(content)
-        f.close()
+        if 'ssh' in command:
+            ssh = self.getVariable(command['ssh'])
+            path = self.getRuntimeValue(command['path'])
+            sftp = ssh['sftp']
+            if path.endswith('.json'): content = json.dumps(content)
+            try:
+                with sftp.open(path, 'w') as remote_file: remote_file.write(content)
+            except:
+                errorReason = 'Unable to write to {path}'
+                if command['or'] != None:
+                    print(f'Exception "{errorReason}": Running the "or" clause')
+                    return command['or']
+                else:
+                    RuntimeError(self.program, f'Error: {errorReason}')
+        else:
+            filename = self.getRuntimeValue(command['file'])
+            if filename.endswith('.json'): content = json.dumps(content)
+            try:
+                with open(filename, 'w') as f: f.write(content)
+            except:
+                errorReason = f'Unable to write to {filename}'
+
+        if errorReason:
+            if command['or'] != None:
+                print(f'Exception "{errorReason}": Running the "or" clause')
+                return command['or']
+            else:
+                RuntimeError(self.program, f'Error: {errorReason}')
         return self.nextPC()
 
+    # Provide a name for the script
+    def k_script(self, command):
+        self.program.name = self.nextToken()
+        return True
+
     # Send a message to a module
     def k_send(self, command):
         command['message'] = self.nextValue()
@@ -1229,16 +1336,40 @@ class Core(Handler):
 
     # Set a value
     # set {variable}
+    # set {ssh} host {host} user {user} password {password}
     # set the elements of {variable} to {value}
     # set element/property of {variable} to {value}
     def k_set(self, command):
         if self.nextIsSymbol():
-            target = self.getSymbolRecord()
-            if target['valueHolder']:
+            record = self.getSymbolRecord()
+            command['target'] = record['name']
+            if record['hasValue']:
                 command['type'] = 'set'
-                command['target'] = target['name']
                 self.add(command)
                 return True
+            elif record['keyword'] == 'ssh':
+                host = None
+                user = None
+                password = None
+                while True:
+                    token = self.peek()
+                    if token == 'host':
+                        self.nextToken()
+                        host = self.nextValue()
+                    elif token == 'user':
+                        self.nextToken()
+                        user = self.nextValue()
+                    elif token == 'password':
+                        self.nextToken()
+                        password = self.nextValue()
+                    else: break
+                command['host'] = host
+                command['user'] = user
+                command['password'] = password
+                command['type'] = 'ssh'
+                self.add(command)
+                return True
+
             return False
 
         token = self.getToken()
@@ -1270,7 +1401,10 @@ class Core(Handler):
                 if self.nextIsSymbol():
                     command['target'] = self.getSymbolRecord()['name']
                     if self.nextIs('to'):
-                        command['value'] = self.nextValue()
+                        value = self.nextValue()
+                        if value == None:
+                            FatalError(self.compiler, 'Unable to get a value')
+                        command['value'] = value
                         self.add(command)
                         return True
 
@@ -1283,6 +1417,12 @@ class Core(Handler):
                         command['value'] = self.nextValue()
                         self.add(command)
                         return True
+        
+        elif token == 'path':
+            command['path'] = self.nextValue()
+            self.add(command)
+            return True
+
         return False
 
     def r_set(self, command):
@@ -1312,6 +1452,7 @@ class Core(Handler):
                         newValue[index] = value
             symbolRecord['elements'] = elements
             symbolRecord['value'] = newValue
+            symbolRecord['index'] = 0
             return self.nextPC()
 
         elif cmdType == 'element':
@@ -1333,6 +1474,11 @@ class Core(Handler):
             self.encoding = self.getRuntimeValue(command['encoding'])
             return self.nextPC()
 
+        elif cmdType == 'path':
+            path = self.getRuntimeValue(command['path'])
+            os.chdir(path)
+            return self.nextPC()
+
         elif cmdType == 'property':
             value = self.getRuntimeValue(command['value'])
             name = self.getRuntimeValue(command['name'])
@@ -1352,13 +1498,55 @@ class Core(Handler):
             val['content'] = content
             self.putSymbolValue(targetVariable, val)
             return self.nextPC()
+        
+        elif cmdType == 'ssh':
+            target = self.getVariable(command['target'])
+            host = self.getRuntimeValue(command['host'])
+            user = self.getRuntimeValue(command['user'])
+            password = self.getRuntimeValue(command['password'])
+            ssh = paramiko.SSHClient()
+            target['ssh'] = ssh
+            ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+            try:
+                ssh.connect(host, username=user, password=password, timeout=10)
+                target['sftp'] = ssh.open_sftp()
+            except:
+                target['error'] = f'Unable to connect to {host} (timeout)'
+            return self.nextPC()
+
+    # Shuffle a list
+    def k_shuffle(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['hasValue']:
+                command['target'] = self.getToken()
+                self.add(command)
+                return True
+            self.warning(f'Core.negate: Variable {symbolRecord["name"]} does not hold a value')
+        return False
+
+    def r_shuffle(self, command):
+        symbolRecord = self.getVariable(command['target'])
+        if not symbolRecord['hasValue']:
+            NoValueRuntimeError(self.program, symbolRecord)
+            return None
+        value = self.getSymbolValue(symbolRecord)
+        if value == None:
+            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
+        content = value['content']
+        if isinstance(content, list):
+            random.shuffle(content)
+            value['content'] = content
+            self.putSymbolValue(symbolRecord, value)
+            return self.nextPC()
+        RuntimeError(self.program, f'{symbolRecord["name"]} is not a list')
 
     # Split a string into a variable with several elements
     # split {variable} on {value}
     def k_split(self, command):
         if self.nextIsSymbol():
             symbolRecord = self.getSymbolRecord()
-            if symbolRecord['valueHolder']:
+            if symbolRecord['hasValue']:
                 command['target'] = symbolRecord['name']
                 value = {}
                 value['type'] = 'text'
@@ -1374,6 +1562,7 @@ class Core(Handler):
                         command['on'] = self.nextValue()
                 self.add(command)
                 return True
+        else: self.noSymbolWarning()
         return False
 
     def r_split(self, command):
@@ -1382,6 +1571,7 @@ class Core(Handler):
         content = value['content'].split(self.getRuntimeValue(command['on']))
         elements = len(content)
         target['elements'] = elements
+        target['index'] = 0
         target['value'] = [None] * elements
 
         for index, item in enumerate(content):
@@ -1393,6 +1583,12 @@ class Core(Handler):
 
         return self.nextPC()
 
+    def k_ssh(self, command):
+        return self.compileVariable(command)
+
+    def r_ssh(self, command):
+        return self.nextPC()
+
     # Declare a stack variable
     def k_stack(self, command):
         return self.compileVariable(command)
@@ -1422,7 +1618,7 @@ class Core(Handler):
             command['background'] = background
             self.add(command)
             return True
-        FatalError(self.program.compiler, 'I can\'t give this command')
+        FatalError(self.compiler, 'I can\'t give this command')
         return False
 
     def r_system(self, command):
@@ -1442,7 +1638,7 @@ class Core(Handler):
         if self.nextToken() == 'from':
             if self.nextIsSymbol():
                 symbolRecord = self.getSymbolRecord()
-                if symbolRecord['valueHolder']:
+                if symbolRecord['hasValue']:
                     if self.peek() == 'giving':
                         # This variable must be treated as a second value
                         command['value2'] = self.getValue()
@@ -1465,7 +1661,7 @@ class Core(Handler):
                         self.add(command)
                         return True
                     else:
-                        FatalError(self.program.compiler, f'\'{self.getToken()}\' is not a symbol')
+                        FatalError(self.compiler, f'\'{self.getToken()}\' is not a symbol')
                 else:
                     self.warning(f'Core.take: Expected "giving"')
         return False
@@ -1477,7 +1673,7 @@ class Core(Handler):
         except:
             value2 = None
         target = self.getVariable(command['target'])
-        if not target['valueHolder']:
+        if not target['hasValue']:
             self.variableDoesNotHoldAValueError(target['name'])
             return None
         value = self.getSymbolValue(target)
@@ -1499,7 +1695,7 @@ class Core(Handler):
     def k_toggle(self, command):
         if self.nextIsSymbol():
             target = self.getSymbolRecord()
-            if target['valueHolder']:
+            if target['hasValue']:
                 command['target'] = target['name']
                 self.add(command)
                 return True
@@ -1515,6 +1711,24 @@ class Core(Handler):
         self.add(command)
         return self.nextPC()
 
+    # Trim whitespace from a variable
+    def k_trim(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['hasValue']:
+                command['name'] = record['name']
+                self.add(command)
+                return True
+        return False
+
+    def r_trim(self, command):
+        record = self.getVariable(command['name'])
+        value = record['value'][record['index']]
+        if value['type'] == 'text':
+            content = value['content']
+            value['content'] = content.strip()
+        return self.nextPC()
+
     # Truncate a file
     def k_truncate(self, command):
         if self.nextIsSymbol():
@@ -1544,9 +1758,34 @@ class Core(Handler):
         target['locked'] = False
         return self.nextPC()
 
+    # Use a plugin module
+    def k_use(self, command):
+        if self.peek() == 'plugin':
+            # Import a plugin
+            self.nextToken()
+            clazz = self.nextToken()
+            if self.nextIs('from'):
+                source = self.nextToken()
+                self.program.importPlugin(f'{source}:{clazz}')
+                return True
+            return False
+        else:
+            token = self.nextToken()
+            if token in ['graphics', 'debugger']:
+                if not hasattr(self.program, 'usingGraphics'):
+                    print('Loading graphics module')
+                    from .ec_pyside import Graphics
+                    self.program.graphics = Graphics
+                    self.program.useClass(Graphics)
+                    self.program.usingGraphics = True
+                if token == 'debugger': self.program.debugging = True
+                return True
+        return False
+
     # Declare a general-purpose variable
     def k_variable(self, command):
-        return self.compileVariable(command, True)
+        self.compiler.addValueType()
+        return self.compileVariable(command)
 
     def r_variable(self, command):
         return self.nextPC()
@@ -1585,7 +1824,7 @@ class Core(Handler):
         # token = self.getToken()
         command['condition'] = code
         test = self.getPC()
-        self.addCommand(command)
+        self.add(command)
         # Set up a goto for when the test fails
         fail = self.getPC()
         cmd = {}
@@ -1594,7 +1833,7 @@ class Core(Handler):
         cmd['keyword'] = 'gotoPC'
         cmd['goto'] = 0
         cmd['debug'] = False
-        self.addCommand(cmd)
+        self.add(cmd)
         # Do the body of the while
         self.nextToken()
         if self.compileOne() == False:
@@ -1606,7 +1845,7 @@ class Core(Handler):
         cmd['keyword'] = 'gotoPC'
         cmd['goto'] = test
         cmd['debug'] = False
-        self.addCommand(cmd)
+        self.add(cmd)
         # Fixup the 'goto' on completion
         self.getCommandAt(fail)['goto'] = self.getPC()
         return True
@@ -1652,9 +1891,8 @@ class Core(Handler):
 
     def incdec(self, command, mode):
         symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['valueHolder']:
-            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
-            return None
+        if not symbolRecord['hasValue']:
+            NoValueRuntimeError(self.program, symbolRecord)
         value = self.getSymbolValue(symbolRecord)
         if value == None:
             RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
@@ -1675,13 +1913,15 @@ class Core(Handler):
             value['name'] = token
             symbolRecord = self.getSymbolRecord()
             keyword = symbolRecord['keyword']
+
             if keyword == 'module':
                 value['type'] = 'module'
                 return value
 
-            if keyword == 'variable':
+            if keyword in ['ssh', 'variable']:
                 value['type'] = 'symbol'
                 return value
+
             return None
 
         value['type'] = token
@@ -1701,7 +1941,7 @@ class Core(Handler):
         if token in ['now', 'today', 'newline', 'tab', 'empty']:
             return value
 
-        if token in ['stringify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer', 'encode', 'decode']:
+        if token in ['stringify', 'prettify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer', 'encode', 'decode']:
             value['content'] = self.nextValue()
             return value
 
@@ -1720,10 +1960,10 @@ class Core(Handler):
             if self.nextToken() == 'of':
                 if self.nextIsSymbol():
                     symbolRecord = self.getSymbolRecord()
-                    if symbolRecord['valueHolder']:
+                    if symbolRecord['hasValue']:
                         value['target'] = symbolRecord['name']
                         return value
-                self.warning(f'Core.compileValue: Token \'{self.getToken()}\' does not hold a value')
+                self.warning(f'Core.compileValue: Token {symbolRecord["name"]} does not hold a value')
             return None
 
         if token == 'property':
@@ -1731,13 +1971,10 @@ class Core(Handler):
             if self.nextToken() == 'of':
                 if self.nextIsSymbol():
                     symbolRecord = self.getSymbolRecord()
-                    if symbolRecord['valueHolder']:
+                    if symbolRecord['hasValue']:
                         value['target'] = symbolRecord['name']
                         return value
-                else:
-                    value['value'] = self.getValue()
-                    return value
-                self.warning(f'Core.compileValue: Token \'{self.getToken()}\' does not hold a value')
+                    NoValueError(self.compiler, symbolRecord)
             return None
 
         if token == 'arg':
@@ -1780,8 +2017,9 @@ class Core(Handler):
         if token == 'count':
             if self.nextIs('of'):
                 if self.nextIsSymbol():
-                    value['name'] = self.getToken()
-                    return value
+                    if self.getSymbolRecord()['hasValue']:
+                        value['name'] = self.getToken()
+                        return value
             return None
 
         if token == 'index':
@@ -1808,10 +2046,12 @@ class Core(Handler):
             return None
 
         if token == 'value':
-            value['type'] = 'valueOf'
             if self.nextIs('of'):
-                value['content'] = self.nextValue()
-                return value
+                v = self.nextValue()
+                if v !=None:
+                    value['type'] = 'valueOf'
+                    value['content'] = v
+                    return value
             return None
 
         if token == 'length':
@@ -1880,14 +2120,24 @@ class Core(Handler):
             return value
 
         if token == 'error':
-            if self.peek() == 'code':
+            token = self.peek()
+            if token == 'code':
                 self.nextToken()
                 value['item'] = 'errorCode'
                 return value
-            if self.peek() == 'reason':
+            elif token == 'reason':
                 self.nextToken()
                 value['item'] = 'errorReason'
                 return value
+            elif token in ['in', 'of']:
+                self.nextToken()
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    if record['keyword'] == 'ssh':
+                        value['item'] = 'sshError'
+                        value['name'] = record['name']
+                        return value
+            return None
 
         if token == 'type':
             if self.nextIs('of'):
@@ -1906,6 +2156,9 @@ class Core(Handler):
             value['command'] = self.nextValue()
             return value
 
+        if token == 'ticker':
+            return value
+
         return None
 
     #############################################################################
@@ -1984,6 +2237,10 @@ class Core(Handler):
             base64_bytes = content.encode('ascii')
             message_bytes = base64.b64decode(base64_bytes)
             value['content'] = message_bytes.decode('ascii')
+        elif self.encoding == 'hex':
+            hex_bytes = content.encode('utf-8')
+            message_bytes = binascii.unhexlify(hex_bytes)
+            value['content'] = message_bytes.decode('utf-8')
         else:
             value = v
         return value
@@ -2027,6 +2284,10 @@ class Core(Handler):
             data_bytes = content.encode('ascii')
             base64_bytes = base64.b64encode(data_bytes)
             value['content'] = base64_bytes.decode('ascii')
+        elif self.encoding == 'hex':
+            data_bytes = content.encode('utf-8')
+            hex_bytes = binascii.hexlify(data_bytes)
+            value['content'] = hex_bytes.decode('utf-8')
         else:
             value = v
         return value
@@ -2040,6 +2301,10 @@ class Core(Handler):
         elif v['item'] == 'errorReason':
             value['type'] = 'text'
             value['content'] = errorReason
+        elif v['item'] == 'sshError':
+            record = self.getVariable(v['name'])
+            value['type'] = 'text'
+            value['content'] = record['error'] if 'error' in record else ''
         return value
 
     def v_files(self, v):
@@ -2119,7 +2384,7 @@ class Core(Handler):
         try:
             value['content'] = json.loads(item)
         except:
-            RuntimeError(self.program, 'Cannot encode value')
+            value = None
         return value
 
     def v_keys(self, v):
@@ -2191,7 +2456,7 @@ class Core(Handler):
     def v_now(self, v):
         value = {}
         value['type'] = 'int'
-        value['content'] = getTimestamp(time.time())
+        value['content'] = int(time.time())
         return value
 
     def v_position(self, v):
@@ -2203,6 +2468,13 @@ class Core(Handler):
         value['content'] = haystack.rfind(needle) if last else haystack.find(needle)
         return value
 
+    def v_prettify(self, v):
+        item = self.getRuntimeValue(v['content'])
+        value = {}
+        value['type'] = 'text'
+        value['content'] = json.dumps(item, indent=4)
+        return value
+
     def v_property(self, v):
         propertyValue = self.getRuntimeValue(v['name'])
         if 'target' in v:
@@ -2228,7 +2500,7 @@ class Core(Handler):
         limit = self.getRuntimeValue(v['content'])
         value = {}
         value['type'] = 'int'
-        value['content'] = randrange(0, limit)
+        value['content'] = random.randrange(0, limit)
         return value
 
     def v_right(self, v):
@@ -2255,9 +2527,17 @@ class Core(Handler):
         return value
 
     # This is used by the expression evaluator to get the value of a symbol
-    def v_symbol(self, symbolRecord):
-        if symbolRecord['keyword'] == 'variable':
+    def v_symbol(self, value):
+        name = value['name']
+        symbolRecord = self.program.getSymbolRecord(name)
+        keyword = symbolRecord['keyword']
+        if keyword == 'variable':
             return self.getSymbolValue(symbolRecord)
+        elif keyword == 'ssh':
+            v = {}
+            v['type'] = 'boolean'
+            v['content']  = True if 'ssh' in symbolRecord and symbolRecord['ssh'] != None else False
+            return v
         else:
             return None
 
@@ -2283,6 +2563,12 @@ class Core(Handler):
         value['content'] = round(math.tan(angle * 0.01745329) * radius)
         return value
 
+    def v_ticker(self, v):
+        value = {}
+        value['type'] = 'int'
+        value['content'] = self.program.ticker
+        return value
+
     def v_timestamp(self, v):
         value = {}
         value['type'] = 'int'
@@ -2339,7 +2625,7 @@ class Core(Handler):
         v = self.getRuntimeValue(v['content'])
         value = {}
         value['type'] = 'int'
-        value['content'] = int(v)
+        value['content'] = int(v) if v != '' else 0
         return value
 
     def v_weekday(self, v):
@@ -2351,19 +2637,46 @@ class Core(Handler):
     #############################################################################
     # Compile a condition
     def compileCondition(self):
-        condition = Condition()
-        if self.getToken() == 'not':
+        condition = Object()
+        condition.negate = False
+
+        token = self.getToken()
+
+        if token == 'not':
             condition.type = 'not'
             condition.value = self.nextValue()
             return condition
 
-        if self.getToken() == 'file':
+        elif token == 'error':
+            self.nextToken()
+            self.skip('in')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'ssh':
+                    condition.type = 'sshError'
+                    condition.target = record['name']
+                    return condition
+            return None
+
+        elif token == 'file':
             path = self.nextValue()
-            if self.peek() == 'exists':
-                condition.type = 'exists'
-                condition.path = path
-                self.nextToken()
+            condition.path = path
+            condition.type = 'exists'
+            self.skip('on')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'ssh':
+                    condition.type = 'sshExists'
+                    condition.target = record['name']
+                    token = self.nextToken()
+            else: token = self.getToken()
+            if token == 'exists':
                 return condition
+            elif token == 'does':
+                if self.nextIs('not'):
+                    if self.nextIs('exist'):
+                        condition.negate = not condition.negate
+                        return condition
             return None
 
         value = self.getValue()
@@ -2383,6 +2696,25 @@ class Core(Handler):
                 return condition
             return None
 
+        if token == 'does':
+            self.nextToken()
+            if self.nextIs('not'):
+                token = self.nextToken()
+                if token == 'have':
+                    if self.nextToken() == 'property':
+                        prop = self.nextValue()
+                        condition.type = 'hasProperty'
+                        condition.property = prop
+                        condition.negate = not condition.negate
+                        return condition
+                elif token == 'include':
+                    value = self.nextValue()
+                    condition.type = 'includes'
+                    condition.value2 = value
+                    condition.negate = not condition.negate
+                    return condition
+            return None
+
         if token in ['starts', 'ends']:
             self.nextToken()
             if self.nextToken() == 'with':
@@ -2409,7 +2741,7 @@ class Core(Handler):
             condition.type = 'is'
             condition.value2 = self.getValue()
             return condition
-
+ 
         if condition.value1:
             # It's a boolean if
             condition.type = 'boolean'
@@ -2461,7 +2793,8 @@ class Core(Handler):
 
     def c_exists(self, condition):
         path = self.getRuntimeValue(condition.path)
-        return os.path.exists(path)
+        comparison = os.path.exists(path)
+        return not comparison if condition.negate else comparison
 
     def c_greater(self, condition):
         comparison = self.program.compare(condition.value1, condition.value2)
@@ -2475,12 +2808,13 @@ class Core(Handler):
             hasProp = True
         except:
             hasProp = False
-        return hasProp
+        return not hasProp if condition.negate else hasProp
 
     def c_includes(self, condition):
         value1 = self.getRuntimeValue(condition.value1)
         value2 = self.getRuntimeValue(condition.value2)
-        return value2 in value1
+        includes = value2 in value1
+        return not includes if condition.negate else includes
 
     def c_is(self, condition):
         comparison = self.program.compare(condition.value1, condition.value2)
@@ -2503,7 +2837,7 @@ class Core(Handler):
         return not comparison if condition.negate else comparison
 
     def c_not(self, condition):
-        return not self.getRuntimeValue(condition.value1)
+        return not self.getRuntimeValue(condition.value)
 
     def c_object(self, condition):
         comparison = type(self.getRuntimeValue(condition.value1)) is dict
@@ -2511,6 +2845,24 @@ class Core(Handler):
 
     def c_odd(self, condition):
         return self.getRuntimeValue(condition.value1) % 2 == 1
+    
+    def c_sshError(self, condition):
+        target = self.getVariable(condition.target)
+        errormsg = target['error'] if 'error' in target else None
+        condition.errormsg = errormsg
+        test = errormsg != None
+        return not test if condition.negate else test
+
+    def c_sshExists(self, condition):
+        path = self.getRuntimeValue(condition.path)
+        ssh = self.getVariable(condition.target)
+        sftp = ssh['sftp']
+        try:
+            with sftp.open(path, 'r') as remote_file: remote_file.read().decode()
+            comparison = True
+        except:
+            comparison = False
+        return not comparison if condition.negate else comparison
 
     def c_starts(self, condition):
         value1 = self.getRuntimeValue(condition.value1)
@@ -2520,4 +2872,3 @@ class Core(Handler):
     def c_string(self, condition):
         comparison = type(self.getRuntimeValue(condition.value1)) is str
         return not comparison if condition.negate else comparison
-# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx