easycoder 241211.3__py2.py3-none-any.whl → 250116.1__py2.py3-none-any.whl

easycoder/ec_core.py

@@ -1,4 +1,4 @@
-import json, math, hashlib, threading, os, subprocess, sys, requests, time, numbers
+import json, math, hashlib, threading, os, subprocess, sys, requests, time, numbers, base64
 from psutil import Process
 from datetime import datetime, timezone
 from random import randrange
@@ -10,6 +10,7 @@ class Core(Handler):
 
     def __init__(self, compiler):
         Handler.__init__(self, compiler)
+        self.encoding = 'utf-8'
 
     def getName(self):
         return 'core'
@@ -38,7 +39,7 @@ class Core(Handler):
                         command['target'] = self.getToken()
                         self.add(command)
                         return True
-                self.warning(f'core.add: Expected value holder')
+                self.warning(f'Core.add: Expected value holder')
             else:
                 # Here we have 2 values so 'giving' must come next
                 command['value2'] = self.getValue()
@@ -46,7 +47,7 @@ class Core(Handler):
                     command['target'] = self.nextToken()
                     self.add(command)
                     return True
-                self.warning(f'core.add: Expected "giving"')
+                self.warning(f'Core.add: Expected "giving"')
         return False
 
     def r_add(self, command):
@@ -90,7 +91,7 @@ class Core(Handler):
                     command['target'] = symbolRecord['name']
                     self.add(command)
                     return True
-                self.warning(f'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):
@@ -248,7 +249,7 @@ class Core(Handler):
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'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):
@@ -272,9 +273,9 @@ class Core(Handler):
                 self.add(command)
                 return True
             else:
-                self.warning(f'"of" expected; got {self.getToken()}')
+                self.warning(f'Core.delete: "of" expected; got {self.getToken()}')
         else:
-            self.warning(f'"file" or "property" expected; got {token}')
+            self.warning(f'Core.delete: "file" or "property" expected; got {token}')
         return False
 
     def r_delete(self, command):
@@ -366,8 +367,7 @@ class Core(Handler):
         return True
 
     def r_exit(self, command):
-        sys.exit()
-        return 0
+        return -1
 
     # Declare a file variable
     def k_file(self, command):
@@ -461,26 +461,9 @@ class Core(Handler):
             else:
                 RuntimeError(self.program, f'Error: {errorReason}')
         retval['content'] = response.text
-        self.program.putSymbolValue(target, retval);
+        self.program.putSymbolValue(target, retval)
         return self.nextPC()
 
-    # Call a subroutine
-    def k_gosub(self, command):
-        if self.peek() == 'to':
-            self.nextToken()
-        command['gosub'] = self.nextToken()
-        self.add(command)
-        return True
-
-    def r_gosub(self, command):
-        label = command['gosub'] + ':'
-        address = self.symbols[label]
-        if address != None:
-            self.stack.append(self.nextPC())
-            return address
-        RuntimeError(self.program, f'There is no label "{label + ":"}"')
-        return None
-
     # Go to a label
     def k_go(self, command):
         if self.peek() == 'to':
@@ -506,6 +489,23 @@ class Core(Handler):
     def r_gotoPC(self, command):
         return command['goto']
 
+    # Call a subroutine
+    def k_gosub(self, command):
+        if self.peek() == 'to':
+            self.nextToken()
+        command['gosub'] = self.nextToken()
+        self.add(command)
+        return True
+
+    def r_gosub(self, command):
+        label = command['gosub'] + ':'
+        address = self.symbols[label]
+        if address != None:
+            self.stack.append(self.nextPC())
+            return address
+        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()
@@ -552,15 +552,55 @@ class Core(Handler):
             self.program.pc += 1
         return self.program.pc
 
-    # Import a plugin. This is done at compile time.
-    # import {class} from {source}
     def k_import(self, command):
-        clazz = self.nextToken()
-        if self.nextIs('from'):
-            source = self.nextToken()
-            self.program.importPlugin(f'{source}:{clazz}')
+        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:
+            # 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
-        return False
+
+    def r_import(self, command):
+        exports = self.program.exports
+        imports = json.loads(command['imports'])
+        if len(imports) < len(exports):
+            RuntimeError(self.program, 'Too few imports')
+        elif len(imports) > len(exports):
+            RuntimeError(self.program, 'Too many imports')
+        for n in range(0, len(imports)):
+            exportRecord = exports[n]
+            exportKeyword = exportRecord['keyword']
+            name = imports[n][1]
+            symbolRecord = self.program.getSymbolRecord(name)
+            symbolKeyword = symbolRecord['keyword']
+            if symbolKeyword != exportKeyword:
+                RuntimeError(self.program, f'Import {n} ({symbolKeyword}) does not match export {n} ({exportKeyword})')
+            symbolRecord['import'] = exportRecord
+        return self.nextPC()
 
     # Increment a variable
     def k_increment(self, command):
@@ -570,7 +610,7 @@ class Core(Handler):
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'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):
@@ -645,6 +685,57 @@ class Core(Handler):
         self.putSymbolValue(symbolRecord, value)
         return self.nextPC()
 
+    # 1 Load a plugin. This is done at compile time.
+    # 2 Load text from a file
+    def k_load(self, command):
+        self.nextToken()
+        if self.tokenIs('plugin'):
+            clazz = self.nextToken()
+            if self.nextIs('from'):
+                source = self.nextToken()
+                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
+        return False
+
+    def r_load(self, command):
+        target = self.getVariable(command['target'])
+        file = self.getRuntimeValue(command['file'])
+        f = open(file, 'r')
+        content = f.read()
+        f.close()
+        value = {}
+        value['type'] = 'text'
+        value['content'] = content
+        self.putSymbolValue(target, value)
+        return self.nextPC()
+
+    # Lock a variable
+    def k_lock(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            command['target'] = symbolRecord['name']
+            self.add(command)
+            return True
+        return False
+
+    def r_lock(self, command):
+        target = self.getVariable(command['target'])
+        target['locked'] = True
+        return self.nextPC()
+
+    # Declare a module variable
+    def k_module(self, command):
+        return self.compileVariable(command)
+
+    def r_module(self, command):
+        return self.nextPC()
+
     # Arithmetic multiply
     # multiply {variable} by {value}[ giving {variable}]}
     def k_multiply(self, command):
@@ -696,6 +787,29 @@ class Core(Handler):
         self.putSymbolValue(target, value)
         return self.nextPC()
 
+    # Negate a variable
+    def k_negate(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['valueHolder']:
+                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_negate(self, command):
+        symbolRecord = self.getVariable(command['target'])
+        if not symbolRecord['valueHolder']:
+            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
+            return None
+        value = self.getSymbolValue(symbolRecord)
+        if value == None:
+            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
+        value['content'] *= -1
+        self.putSymbolValue(symbolRecord, value)
+        return self.nextPC()
+
     # Define an object variable
     def k_object(self, command):
         return self.compileVariable(command)
@@ -703,6 +817,36 @@ class Core(Handler):
     def r_object(self, command):
         return self.nextPC()
 
+    # on message {action}
+    def k_on(self, command):
+        if self.nextIs('message'):
+            self.nextToken()
+            command['goto'] = 0
+            self.add(command)
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'gotoPC'
+            cmd['goto'] = 0
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # Add the action and a 'stop'
+            self.compileOne()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'stop'
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # Fixup the link
+            command['goto'] = self.getPC()
+            return True
+        return False
+
+    def r_on(self, command):
+        self.program.onMessage(self.nextPC()+1)
+        return command['goto']
+
     # Open a file
     # open {file} for reading/writing/appending
     def k_open(self, command):
@@ -724,12 +868,14 @@ class Core(Handler):
                         FatalError(self.program.compiler, 'Unknown file open mode {self.getToken()}')
                         return False
                     command['mode'] = mode
-                    self.add(command)
-                    return True
+                else:
+                    command['mode'] = 'r'
+                self.add(command)
+                return True
             else:
                 FatalError(self.compiler, f'Variable "{self.getToken()}" is not a file')
         else:
-            self.warning(f'core.open: Variable "{self.getToken()}" not declared')
+            self.warning(f'Core.open: Variable "{self.getToken()}" not declared')
         return False
 
     def r_open(self, command):
@@ -893,13 +1039,13 @@ class Core(Handler):
             if self.nextIsSymbol():
                 symbolRecord = self.getSymbolRecord()
                 command['target'] = symbolRecord['name']
-                if symbolRecord['valueHolder']:
+                if 'valueholder' in symbolRecord and symbolRecord['valueHolder'] == False:
+                    FatalError(self.program.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
+                else:
                     self.add(command)
                     return True
-                else:
-                    FatalError(self.program.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
             else:
-                FatalError(self.program.compiler, f'No such variable: "{self.getToken()}"')
+                FatalError(self.program.compiler, f'Symbol {self.getToken()} is not a variable')
         return False
 
     def r_put(self, command):
@@ -974,7 +1120,7 @@ class Core(Handler):
         content = self.getSymbolValue(templateRecord)['content']
         original = self.getRuntimeValue(command['original'])
         replacement = self.getRuntimeValue(command['replacement'])
-        content = content.replace(original, replacement)
+        content = content.replace(original, str(replacement))
         value = {}
         value['type'] = 'text'
         value['numeric'] = False
@@ -982,6 +1128,16 @@ 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)
@@ -990,11 +1146,87 @@ class Core(Handler):
     def r_return(self, command):
         return self.stack.pop()
 
+    # Compile and run a script
+    def k_run(self, command):
+        try:
+            command['path'] = self.nextValue()
+        except Exception as e:
+            self.warning(f'Core.run: Path expected')
+            return False
+        if self.nextIs('as'):
+            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
+
+    def r_run(self, command):
+        module = self.getVariable(command['module'])
+        path = self.getRuntimeValue(command['path'])
+        exports = json.loads(command['exports'])
+        for n in range(0, len(exports)):
+            exports[n] = self.getVariable(exports[n])
+        module['path'] = path
+        parent = Object()
+        parent.program = self.program
+        parent.pc = self.nextPC()
+        parent.waiting = True
+        p = self.program.__class__
+        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
+
+    def r_save(self, command):
+        content = self.getRuntimeValue(command['content'])
+        file = self.getRuntimeValue(command['file'])
+        f = open(file, 'w')
+        f.write(content)
+        f.close()
+        return self.nextPC()
+
+    # Send a message to a module
+    def k_send(self, command):
+        command['message'] = self.nextValue()
+        if self.nextIs('to'):
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'module':
+                    command['module'] = record['name']
+                    self.add(command)
+                    return True
+        return False
+
+    def r_send(self, command):
+        message = self.getRuntimeValue(command['message'])
+        module = self.getVariable(command['module'])
+        module['child'].handleMessage(message)
+        return self.nextPC()
+
     # Set a value
     # set {variable}
     # set the elements of {variable} to {value}
@@ -1007,16 +1239,18 @@ class Core(Handler):
                 command['target'] = target['name']
                 self.add(command)
                 return True
+            return False
 
         token = self.getToken()
         if token == 'the':
             token = self.nextToken()
+        command['type'] = token
+
         if token == 'elements':
             self.nextToken()
             if self.peek() == 'of':
                 self.nextToken()
             if self.nextIsSymbol():
-                command['type'] = 'elements'
                 command['name'] = self.getToken()
                 if self.peek() == 'to':
                     self.nextToken()
@@ -1024,8 +1258,13 @@ class Core(Handler):
                 self.add(command)
                 return True
 
-        if token == 'property':
-            command['type'] = 'property'
+        elif token == 'encoding':
+            if self.nextIs('to'):
+                command['encoding'] = self.nextValue()
+                self.add(command)
+                return True
+
+        elif token == 'property':
             command['name'] = self.nextValue()
             if self.nextIs('of'):
                 if self.nextIsSymbol():
@@ -1035,8 +1274,7 @@ class Core(Handler):
                         self.add(command)
                         return True
 
-        if token == 'element':
-            command['type'] = 'element'
+        elif token == 'element':
             command['index'] = self.nextValue()
             if self.nextIs('of'):
                 if self.nextIsSymbol():
@@ -1045,7 +1283,6 @@ class Core(Handler):
                         command['value'] = self.nextValue()
                         self.add(command)
                         return True
-
         return False
 
     def r_set(self, command):
@@ -1058,7 +1295,7 @@ class Core(Handler):
             self.putSymbolValue(target, val)
             return self.nextPC()
 
-        if cmdType == 'elements':
+        elif cmdType == 'elements':
             symbolRecord = self.getVariable(command['name'])
             elements = self.getRuntimeValue(command['elements'])
             currentElements = symbolRecord['elements']
@@ -1077,7 +1314,7 @@ class Core(Handler):
             symbolRecord['value'] = newValue
             return self.nextPC()
 
-        if cmdType == 'element':
+        elif cmdType == 'element':
             value = self.getRuntimeValue(command['value'])
             index = self.getRuntimeValue(command['index'])
             target = self.getVariable(command['target'])
@@ -1092,7 +1329,11 @@ class Core(Handler):
             self.putSymbolValue(target, val)
             return self.nextPC()
 
-        if cmdType == 'property':
+        elif cmdType == 'encoding':
+            self.encoding = self.getRuntimeValue(command['encoding'])
+            return self.nextPC()
+
+        elif cmdType == 'property':
             value = self.getRuntimeValue(command['value'])
             name = self.getRuntimeValue(command['name'])
             target = command['target']
@@ -1215,7 +1456,7 @@ class Core(Handler):
                         command['target'] = self.getToken()
                         self.add(command)
                         return True
-                self.warning(f'core.take: Expected value holder')
+                self.warning(f'Core.take: Expected value holder')
             else:
                 # Here we have 2 values so 'giving' must come next
                 command['value2'] = self.getValue()
@@ -1227,7 +1468,7 @@ class Core(Handler):
                     else:
                         FatalError(self.program.compiler, f'\'{self.getToken()}\' is not a symbol')
                 else:
-                    self.warning(f'core.take: Expected "giving"')
+                    self.warning(f'Core.take: Expected "giving"')
         return False
 
     def r_take(self, command):
@@ -1290,6 +1531,20 @@ class Core(Handler):
         fileRecord['file'].truncate()
         return self.nextPC()
 
+    # Unlock a variable
+    def k_unlock(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            command['target'] = symbolRecord['name']
+            self.add(command)
+            return True
+        return False
+
+    def r_unlock(self, command):
+        target = self.getVariable(command['target'])
+        target['locked'] = False
+        return self.nextPC()
+
     # Declare a general-purpose variable
     def k_variable(self, command):
         return self.compileVariable(command, True)
@@ -1402,6 +1657,8 @@ class Core(Handler):
             RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
             return None
         value = self.getSymbolValue(symbolRecord)
+        if value == None:
+            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
         if mode == '+':
             value['content'] += 1
         else:
@@ -1413,7 +1670,7 @@ class Core(Handler):
     # Compile a value in this domain
     def compileValue(self):
         value = {}
-        value['domain'] = 'core'
+        value['domain'] = self.getName()
         token = self.getToken()
         if self.isSymbol():
             value['name'] = token
@@ -1442,10 +1699,10 @@ class Core(Handler):
                 return value
             return None
 
-        if token in ['now', 'today', 'newline', 'break', 'empty']:
+        if token in ['now', 'today', 'newline', 'tab', 'empty']:
             return value
 
-        if token in ['date', 'encode', 'decode', 'stringify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer']:
+        if token in ['stringify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer', 'encode', 'decode']:
             value['content'] = self.nextValue()
             return value
 
@@ -1467,7 +1724,7 @@ class Core(Handler):
                     if symbolRecord['valueHolder']:
                         value['target'] = symbolRecord['name']
                         return value
-                self.warning(f'Token \'{self.getToken()}\' does not hold a value')
+                self.warning(f'Core.compileValue: Token \'{self.getToken()}\' does not hold a value')
             return None
 
         if token == 'property':
@@ -1478,7 +1735,7 @@ class Core(Handler):
                     if symbolRecord['valueHolder']:
                         value['target'] = symbolRecord['name']
                         return value
-                self.warning(f'Token \'{self.getToken()}\' does not hold a value')
+                self.warning(f'Core.compileValue: Token \'{self.getToken()}\' does not hold a value')
             return None
 
         if token == 'arg':
@@ -1528,7 +1785,9 @@ class Core(Handler):
         if token == 'index':
             if self.nextIs('of'):
                 if self.nextIsSymbol():
+                    value['variable'] = self.getSymbolRecord()['name']
                     if self.peek() == 'in':
+                        value['value'] = None
                         value['type'] = 'indexOf'
                         if self.nextIsSymbol():
                             value['target'] = self.getSymbolRecord()['name']
@@ -1537,8 +1796,9 @@ class Core(Handler):
                         value['name'] = self.getToken()
                         return value
                 else:
-                    value['value1'] = self.getValue()
+                    value['value'] = self.getValue()
                     if self.nextIs('in'):
+                        value['variable'] = None
                         value['type'] = 'indexOf'
                         if self.nextIsSymbol():
                             value['target'] = self.getSymbolRecord()['name']
@@ -1590,7 +1850,6 @@ class Core(Handler):
                     return value
 
         if token == 'message':
-            self.nextToken()
             return value
 
         if token == 'timestamp':
@@ -1604,7 +1863,8 @@ class Core(Handler):
             return value
 
         if token == 'files':
-            if self.nextIs('of'):
+            token = self.nextToken()
+            if token in ['in', 'of']:
                 value['target'] = self.nextValue()
                 return value
             return None
@@ -1640,7 +1900,6 @@ class Core(Handler):
                     return value
             return None
 
-        self.warning(f'Core: Unknown token {token}')
         return None
 
     #############################################################################
@@ -1689,6 +1948,14 @@ class Core(Handler):
         value['content'] = round(math.cos(angle * 0.01745329) * radius)
         return value
 
+    def v_count(self, v):
+        variable = self.getVariable(v['name'])
+        content = variable['value'][variable['index']]['content']
+        value = {}
+        value['type'] = 'int'
+        value['content'] = len(content)
+        return value
+
     def v_datime(self, v):
         ts = self.getRuntimeValue(v['timestamp'])
         fmt = v['format']
@@ -1702,9 +1969,17 @@ class Core(Handler):
         return value
 
     def v_decode(self, v):
+        content = self.getRuntimeValue(v['content'])
         value = {}
         value['type'] = 'text'
-        value['content'] = self.program.decode(v['content'])
+        if self.encoding == 'utf-8':
+            value['content'] = content.decode('utf-8')
+        elif self.encoding == 'base64':
+            base64_bytes = content.encode('ascii')
+            message_bytes = base64.b64decode(base64_bytes)
+            value['content'] = message_bytes.decode('ascii')
+        else:
+            value = v
         return value
 
     def v_element(self, v):
@@ -1727,18 +2002,9 @@ class Core(Handler):
         var = self.getVariable(v['name'])
         value = {}
         value['type'] = 'int'
-        # value['content'] = self.getVariable(v['name'])['elements']
         value['content'] = var['elements']
         return value
 
-    def v_count(self, v):
-        variable = self.getVariable(v['name'])
-        content = variable['value'][variable['index']]['content']
-        value = {}
-        value['type'] = 'int'
-        value['content'] = len(content)
-        return value
-
     def v_empty(self, v):
         value = {}
         value['type'] = 'text'
@@ -1746,9 +2012,17 @@ class Core(Handler):
         return value
 
     def v_encode(self, v):
+        content = self.getRuntimeValue(v['content'])
         value = {}
         value['type'] = 'text'
-        value['content'] = self.program.encode(v['content'])
+        if self.encoding == 'utf-8':
+            value['content'] = content.encode('utf-8')
+        elif self.encoding == 'base64':
+            data_bytes = content.encode('ascii')
+            base64_bytes = base64.b64encode(data_bytes)
+            value['content'] = base64_bytes.decode('ascii')
+        else:
+            value = v
         return value
 
     def v_error(self, v):
@@ -1762,21 +2036,22 @@ class Core(Handler):
             value['content'] = errorReason
         return value
 
-    def v_stringify(self, v):
-        item = self.getRuntimeValue(v['content'])
+    def v_files(self, v):
+        v = self.getRuntimeValue(v['target'])
         value = {}
         value['type'] = 'text'
-        value['content'] = json.dumps(item)
+        value['content'] = os.listdir(v)
         return value
 
-    def v_json(self, v):
-        item = self.getRuntimeValue(v['content'])
+    def v_float(self, v):
+        val = self.getRuntimeValue(v['content'])
         value = {}
-        value['type'] = 'object'
+        value['type'] = 'float'
         try:
-            value['content'] = json.loads(item)
+            value['content'] = float(val)
         except:
-            RuntimeError(self.program, 'Cannot encode value')
+            RuntimeWarning(self.program, f'Value cannot be parsed as floating-point')
+            value['content'] = 0.0
         return value
 
     def v_from(self, v):
@@ -1800,17 +2075,6 @@ class Core(Handler):
         value['content'] = hashlib.sha256(hashval.encode('utf-8')).hexdigest()
         return value
 
-    def v_float(self, v):
-        val = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'float'
-        try:
-            value['content'] = float(val)
-        except:
-            RuntimeWarning(self.program, f'Value cannot be parsed as floating-point')
-            value['content'] = 0.0
-        return value
-
     def v_index(self, v):
         value = {}
         value['type'] = 'int'
@@ -1818,16 +2082,22 @@ class Core(Handler):
         return value
 
     def v_indexOf(self, v):
-        value1 = v['value1']
+        value = v['value']
+        if value == None:
+            value = self.getSymbolValue(v['variable'])['content']
+        else:
+            value = self.getRuntimeValue(value)
         target = self.getVariable(v['target'])
-        try:
-            index = target['value'].index(value1)
-        except:
-            index = -1
-        value = {}
-        value['type'] = 'int'
-        value['content'] = index
-        return value
+        data = self.getSymbolValue(target)['content']
+        index = -1
+        for n in range(0, len(data)):
+            if data[n] == value:
+                index = n
+                break
+        retval = {}
+        retval['type'] = 'int'
+        retval['content'] = index
+        return retval
 
     def v_integer(self, v):
         val = self.getRuntimeValue(v['content'])
@@ -1836,6 +2106,16 @@ class Core(Handler):
         value['content'] = int(val)
         return value
 
+    def v_json(self, v):
+        item = self.getRuntimeValue(v['content'])
+        value = {}
+        value['type'] = 'object'
+        try:
+            value['content'] = json.loads(item)
+        except:
+            RuntimeError(self.program, 'Cannot encode value')
+        return value
+
     def v_keys(self, v):
         value = {}
         value['type'] = 'int'
@@ -1866,18 +2146,26 @@ class Core(Handler):
         value['content'] = content.lower()
         return value
 
-    def v_uppercase(self, v):
-        content = self.getRuntimeValue(v['content'])
+    def v_memory(self, v):
+        process: Process = Process(os.getpid())
+        megabytes: float = process.memory_info().rss / (1024 * 1024)
+        value = {}
+        value['type'] = 'float'
+        value['content'] = megabytes
+        return value
+
+    def v_message(self, v):
         value = {}
         value['type'] = 'text'
-        value['content'] = content.upper()
+        value['content'] = self.program.message
         return value
 
-    def v_random(self, v):
-        limit = self.getRuntimeValue(v['content'])
+    def v_modification(self, v):
+        fileName = self.getRuntimeValue(v['fileName'])
+        ts = int(os.stat(fileName).st_mtime)
         value = {}
         value['type'] = 'int'
-        value['content'] = randrange(0, limit)
+        value['content'] = ts
         return value
 
     def v_modulo(self, v):
@@ -1927,6 +2215,13 @@ class Core(Handler):
             value['type'] = 'text'
         return value
 
+    def v_random(self, v):
+        limit = self.getRuntimeValue(v['content'])
+        value = {}
+        value['type'] = 'int'
+        value['content'] = randrange(0, limit)
+        return value
+
     def v_right(self, v):
         content = self.getRuntimeValue(v['content'])
         count = self.getRuntimeValue(v['count'])
@@ -1943,6 +2238,28 @@ class Core(Handler):
         value['content'] = round(math.sin(angle * 0.01745329) * radius)
         return value
 
+    def v_stringify(self, v):
+        item = self.getRuntimeValue(v['content'])
+        value = {}
+        value['type'] = 'text'
+        value['content'] = json.dumps(item)
+        return value
+
+    # This is used by the expression evaluator to get the value of a symbol
+    def v_symbol(self, symbolRecord):
+        result = {}
+        if symbolRecord['keyword'] == 'variable':
+            symbolValue = self.getSymbolValue(symbolRecord)
+            return symbolValue
+        else:
+            return None
+
+    def v_tab(self, v):
+        value = {}
+        value['type'] = 'text'
+        value['content'] = '\t'
+        return value
+
     def v_tan(self, v):
         angle = self.getRuntimeValue(v['angle'])
         radius = self.getRuntimeValue(v['radius'])
@@ -1971,36 +2288,6 @@ class Core(Handler):
         value['content'] = int(datetime.combine(datetime.now().date(),datetime.min.time()).timestamp())*1000
         return value
 
-    def v_symbol(self, symbolRecord):
-        result = {}
-        if symbolRecord['keyword'] == 'variable':
-            symbolValue = self.getSymbolValue(symbolRecord)
-            return symbolValue
-            # if symbolValue == None:
-            #     return None
-            # result['type'] = symbolValue['type']
-            # content = symbolValue['content']
-            # if content == None:
-            #     return ''
-            # result['content'] = content
-            # return result
-        else:
-            return None
-
-    def v_valueOf(self, v):
-        v = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'int'
-        value['content'] = int(v)
-        return value
-
-    def v_files(self, v):
-        v = self.getRuntimeValue(v['target'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = os.listdir(v)
-        return value
-
     def v_trim(self, v):
         v = self.getRuntimeValue(v['content'])
         value = {}
@@ -2008,20 +2295,6 @@ class Core(Handler):
         value['content'] = v.strip()
         return value
 
-    def v_weekday(self, v):
-        value = {}
-        value['type'] = 'int'
-        value['content'] = datetime.today().weekday()
-        return value
-
-    def v_memory(self, v):
-        process: Process = Process(os.getpid())
-        megabytes: float = process.memory_info().rss / (1024 * 1024)
-        value = {}
-        value['type'] = 'float'
-        value['content'] = megabytes
-        return value
-
     def v_type(self, v):
         value = {}
         value['type'] = 'text'
@@ -2040,12 +2313,24 @@ class Core(Handler):
             value['content'] = 'object'
         return value
 
-    def v_modification(self, v):
-        fileName = self.getRuntimeValue(v['fileName'])
-        ts = int(os.stat(fileName).st_mtime)
+    def v_uppercase(self, v):
+        content = self.getRuntimeValue(v['content'])
+        value = {}
+        value['type'] = 'text'
+        value['content'] = content.upper()
+        return value
+
+    def v_valueOf(self, v):
+        v = self.getRuntimeValue(v['content'])
         value = {}
         value['type'] = 'int'
-        value['content'] = ts
+        value['content'] = int(v)
+        return value
+
+    def v_weekday(self, v):
+        value = {}
+        value['type'] = 'int'
+        value['content'] = datetime.today().weekday()
         return value
 
     #############################################################################
@@ -2115,7 +2400,7 @@ class Core(Handler):
             condition.type = 'boolean'
             return condition
 
-        self.warning(f'I can\'t get a conditional:')
+        self.warning(f'Core.compileCondition: I can\'t get a conditional:')
         return None
 
     def isNegate(self):
@@ -2143,20 +2428,59 @@ class Core(Handler):
                 return True if condition.negate else False
         return False
 
-    def c_numeric(self, condition):
-        comparison = type(self.getRuntimeValue(condition.value1)) is int
+    def c_empty(self, condition):
+        value = self.getRuntimeValue(condition.value1)
+        if value == None:
+            comparison = True
+        else:
+            comparison = len(value) == 0
         return not comparison if condition.negate else comparison
 
-    def c_string(self, condition):
-        comparison = type(self.getRuntimeValue(condition.value1)) is str
-        return not comparison if condition.negate else comparison
+    def c_ends(self, condition):
+        value1 = self.getRuntimeValue(condition.value1)
+        value2 = self.getRuntimeValue(condition.value2)
+        return value1.endswith(value2)
+
+    def c_even(self, condition):
+        return self.getRuntimeValue(condition.value1) % 2 == 0
+
+    def c_exists(self, condition):
+        path = self.getRuntimeValue(condition.path)
+        return os.path.exists(path)
+
+    def c_greater(self, condition):
+        comparison = self.program.compare(condition.value1, condition.value2)
+        return comparison <= 0 if condition.negate else comparison > 0
+
+    def c_hasProperty(self, condition):
+        value = self.getRuntimeValue(condition.value1)
+        prop = self.getRuntimeValue(condition.property)
+        try:
+            value[prop]
+            hasProp = True
+        except:
+            hasProp = False
+        return hasProp
+
+    def c_includes(self, condition):
+        value1 = self.getRuntimeValue(condition.value1)
+        value2 = self.getRuntimeValue(condition.value2)
+        return value2 in value1
+
+    def c_is(self, condition):
+        comparison = self.program.compare(condition.value1, condition.value2)
+        return comparison != 0 if condition.negate else comparison == 0
+
+    def c_less(self, condition):
+        comparison = self.program.compare(condition.value1, condition.value2)
+        return comparison >= 0 if condition.negate else comparison < 0
 
     def c_list(self, condition):
         comparison = type(self.getRuntimeValue(condition.value1)) is list
         return not comparison if condition.negate else comparison
 
-    def c_object(self, condition):
-        comparison = type(self.getRuntimeValue(condition.value1)) is dict
+    def c_numeric(self, condition):
+        comparison = type(self.getRuntimeValue(condition.value1)) is int
         return not comparison if condition.negate else comparison
 
     def c_none(self, condition):
@@ -2166,58 +2490,19 @@ class Core(Handler):
     def c_not(self, condition):
         return not self.getRuntimeValue(condition.value1)
 
-    def c_even(self, condition):
-        return self.getRuntimeValue(condition.value1) % 2 == 0
+    def c_object(self, condition):
+        comparison = type(self.getRuntimeValue(condition.value1)) is dict
+        return not comparison if condition.negate else comparison
 
     def c_odd(self, condition):
         return self.getRuntimeValue(condition.value1) % 2 == 1
 
-    def c_is(self, condition):
-        comparison = self.program.compare(condition.value1, condition.value2)
-        return comparison != 0 if condition.negate else comparison == 0
-
-    def c_greater(self, condition):
-        comparison = self.program.compare(condition.value1, condition.value2)
-        return comparison <= 0 if condition.negate else comparison > 0
-
-    def c_less(self, condition):
-        comparison = self.program.compare(condition.value1, condition.value2)
-        return comparison >= 0 if condition.negate else comparison < 0
-
     def c_starts(self, condition):
         value1 = self.getRuntimeValue(condition.value1)
         value2 = self.getRuntimeValue(condition.value2)
         return value1.startswith(value2)
 
-    def c_ends(self, condition):
-        value1 = self.getRuntimeValue(condition.value1)
-        value2 = self.getRuntimeValue(condition.value2)
-        return value1.endswith(value2)
-
-    def c_includes(self, condition):
-        value1 = self.getRuntimeValue(condition.value1)
-        value2 = self.getRuntimeValue(condition.value2)
-        return value2 in value1
-
-    def c_empty(self, condition):
-        value = self.getRuntimeValue(condition.value1)
-        if value == None:
-            comparison = True
-        else:
-            comparison = len(value) == 0
+    def c_string(self, condition):
+        comparison = type(self.getRuntimeValue(condition.value1)) is str
         return not comparison if condition.negate else comparison
-
-    def c_exists(self, condition):
-        path = self.getRuntimeValue(condition.path)
-        return os.path.exists(path)
-
-    def c_hasProperty(self, condition):
-        value = self.getRuntimeValue(condition.value1)
-        prop = self.getRuntimeValue(condition.property)
-        try:
-            value[prop]
-            hasProp = True
-        except:
-            hasProp = False
-        return hasProp
 # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx