easycoder 250403.1__py2.py3-none-any.whl → 250404.1__py2.py3-none-any.whl

easycoder/ec_core.sync-conflict-20250331-210238-M3XB3VD.py

@@ -1,2564 +0,0 @@
-import json, math, hashlib, threading, os, subprocess, sys, requests, time, numbers, base64, binascii
-from psutil import Process
-from datetime import datetime, timezone
-from random import randrange
-from .ec_classes import FatalError, RuntimeWarning, RuntimeError, AssertionError, Condition, Object
-from .ec_handler import Handler
-from .ec_timestamp import getTimestamp
-
-class Core(Handler):
-
-    def __init__(self, compiler):
-        Handler.__init__(self, compiler)
-        self.encoding = 'utf-8'
-
-    def getName(self):
-        return 'core'
-
-    #############################################################################
-    # Keyword handlers
-
-    # Arithmetic add
-    # add {value} to {variable}[ giving {variable}]}
-    def k_add(self, command):
-        # Get the (first) value
-        command['value1'] = self.nextValue()
-        if self.nextToken() == 'to':
-            if self.nextIsSymbol():
-                symbolRecord = self.getSymbolRecord()
-                if symbolRecord['valueHolder']:
-                    if self.peek() == 'giving':
-                        # This variable must be treated as a second value
-                        command['value2'] = self.getValue()
-                        self.nextToken()
-                        command['target'] = self.nextToken()
-                        self.add(command)
-                        return True
-                    else:
-                        # Here the variable is the target
-                        command['target'] = self.getToken()
-                        self.add(command)
-                        return True
-                self.warning(f'Core.add: Expected value holder')
-            else:
-                # Here we have 2 values so 'giving' must come next
-                command['value2'] = self.getValue()
-                if self.nextToken() == 'giving':
-                    command['target'] = self.nextToken()
-                    self.add(command)
-                    return True
-                self.warning(f'Core.add: Expected "giving"')
-        return False
-
-    def r_add(self, command):
-        value1 = command['value1']
-        try:
-            value2 = command['value2']
-        except:
-            value2 = None
-        target = self.getVariable(command['target'])
-        if not target['valueHolder']:
-            self.variableDoesNotHoldAValueError(target['name'])
-        targetValue = self.getSymbolValue(target)
-        if targetValue == None:
-            targetValue = {}
-            targetValue['content'] = 0
-        targetValue['type'] = 'int'
-        if value2:
-            v1 = int(self.getRuntimeValue(value1))
-            v2 = int(self.getRuntimeValue(value2))
-            targetValue['content'] = v1 + v2
-        else:
-#            if targetValue['type'] != 'int' and targetValue['content'] != None:
-#                self.nonNumericValueError()
-            v = self.getRuntimeValue(targetValue)
-            v = int(v)
-            v1 = int(self.getRuntimeValue(value1))
-            if v1 == None:
-                v1 = 0
-            targetValue['content'] = v + v1
-        self.putSymbolValue(target, targetValue)
-        return self.nextPC()
-
-    # Append a value to an array
-    # append {value} to {array}
-    def k_append(self, command):
-        command['value'] = self.nextValue()
-        if self.nextIs('to'):
-            if self.nextIsSymbol():
-                symbolRecord = self.getSymbolRecord()
-                if symbolRecord['valueHolder']:
-                    command['target'] = symbolRecord['name']
-                    self.add(command)
-                    return True
-                self.warning(f'Core.append: Variable "{symbolRecord["name"]}" does not hold a value')
-        return False
-
-    def r_append(self, command):
-        value = self.getRuntimeValue(command['value'])
-        target = self.getVariable(command['target'])
-        val = self.getSymbolValue(target)
-        content = val['content']
-        if content == '':
-            content = []
-        content.append(value)
-        val['content'] = content
-        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()
-        if self.peek() == 'with':
-            self.nextToken()
-            command['with'] = self.nextValue()
-        else:
-            command['with'] = None
-        self.addCommand(command)
-        return True
-
-    def r_assert(self, command):
-        test = self.program.condition.testCondition(command['test'])
-        if test:
-            return self.nextPC()
-        AssertionError(self.program, self.getRuntimeValue(command['with']))
-
-    # Begin a block
-    def k_begin(self, command):
-        if self.nextToken() == 'end':
-            cmd = {}
-            cmd['domain'] = 'core'
-            cmd['keyword'] = 'end'
-            cmd['debug'] = True
-            cmd['lino'] = command['lino']
-            self.addCommand(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']
-                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)
-        return self.nextPC()
-
-    # Close a file
-    # close {file}
-    def k_close(self, command):
-        if self.nextIsSymbol():
-            fileRecord = self.getSymbolRecord()
-            if fileRecord['keyword'] == 'file':
-                command['file'] = fileRecord['name']
-                self.add(command)
-                return True
-        return False
-
-    def r_close(self, command):
-        fileRecord = self.getVariable(command['file'])
-        fileRecord['file'].close()
-        return self.nextPC()
-
-    #Create directory
-    # create directory {name}
-    def k_create(self, command):
-        if self.nextIs('directory'):
-            command['item'] = 'directory'
-            command['path'] = self.nextValue()
-            self.add(command)
-            return True
-        return False
-
-    def r_create(self, command):
-        if command['item'] == 'directory':
-            path = self.getRuntimeValue(command['path'])
-            if not os.path.exists(path):
-                os.makedirs(path)
-        return self.nextPC()
-
-    # Debug the script
-    def k_debug(self, command):
-        token = self.peek()
-        if token in ['step', 'stop', 'program', 'custom']:
-            command['mode'] = token
-            self.nextToken()
-        elif token == 'stack':
-            command['mode'] = self.nextToken()
-            if (self.nextIsSymbol()):
-                command['stack'] = self.getToken()
-                if self.peek() == 'as':
-                    self.nextToken()
-                    command['as'] = self.nextValue()
-                else:
-                    command['as'] = 'Stack'
-            else:
-                return False
-        else:
-            command['mode'] = None
-        self.add(command)
-        return True
-
-    def r_debug(self, command):
-        if command['mode'] == 'step':
-            self.program.debugStep = True
-        elif command['mode'] == 'stop':
-            self.program.debugStep = False
-        elif command['mode'] == 'program':
-            for item in self.code:
-                print(json.dumps(item, indent = 2))
-        elif command['mode'] == 'stack':
-            stackRecord = self.getVariable(command['stack'])
-            value = self.getSymbolValue(stackRecord)
-            print(f'{self.getRuntimeValue(command["as"])}:',json.dumps(self.getSymbolValue(stackRecord), indent = 2))
-        elif command['mode'] == 'custom':
-            # Custom debugging code goes in here
-            record = self.getVariable('Script')
-            print('(Debug) Script:',record)
-            value = self.getRuntimeValue(record)
-            print('(Debug) Value:',value)
-            pass
-        return self.nextPC()
-
-    # Decrement a variable
-    # decrement {variable}
-    def k_decrement(self, command):
-        if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['valueHolder']:
-                command['target'] = self.getToken()
-                self.add(command)
-                return True
-            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 property {value} of {variable}
-    def k_delete(self, command):
-        token = self.nextToken( )
-        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()}')
-        else:
-            self.warning(f'Core.delete: "file" or "property" 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)
-        elif type == 'property':
-            key = self.getRuntimeValue(command['key'])
-            symbolRecord = self.getVariable(command['var'])
-            value = self.getSymbolValue(symbolRecord)
-            content = value['content']
-            content.pop(key, None)
-            value['content'] = content
-            self.putSymbolValue(symbolRecord, value)
-        return self.nextPC()
-
-    # Arithmetic division
-    # divide {variable} by {value}[ giving {variable}]}
-    def k_divide(self, command):
-        # Get the (first) value
-        command['value1'] = self.nextValue()
-        if self.nextToken() == 'by':
-            command['value2'] = self.nextValue()
-            if self.peek() == 'giving':
-                self.nextToken()
-                if (self.nextIsSymbol()):
-                    command['target'] = self.getToken()
-                    self.add(command)
-                    return True
-                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.compiler, 'First value must be a variable')
-        return False
-
-    def r_divide(self, command):
-        value1 = command['value1']
-        try:
-            value2 = command['value2']
-        except:
-            value2 = None
-        target = self.getVariable(command['target'])
-        if not target['valueHolder']:
-            self.variableDoesNotHoldAValueError(target['name'])
-            return None
-        value = self.getSymbolValue(target)
-        if value == None:
-            value = {}
-        value['type'] = 'int'
-        if value2:
-            v1 = int(self.getRuntimeValue(value1))
-            v2 = int(self.getRuntimeValue(value2))
-            value['content'] = int(v1/v2)
-        else:
-            if value['type'] != 'int' and value['content'] != None:
-                self.nonNumericValueError(self.compiler, command['lino'])
-            v = int(self.getRuntimeValue(value))
-            v1 = int(self.getRuntimeValue(value1))
-            value['content'] = int(v/v1)
-        self.putSymbolValue(target, value)
-        return self.nextPC()
-
-    # Dummy command for testing
-    def k_dummy(self, command):
-        self.add(command)
-        return True
-
-    def r_dummy(self, command):
-        return self.nextPC()
-
-    # Match a begin
-    def k_end(self, command):
-        self.add(command)
-        return True
-
-    def r_end(self, command):
-        return self.nextPC()
-
-    # Exit the script
-    def k_exit(self, command):
-        self.add(command)
-        return True
-
-    def r_exit(self, command):
-        return -1
-
-    # Declare a file variable
-    def k_file(self, command):
-        return self.compileVariable(command, False)
-
-    def r_file(self, command):
-        return self.nextPC()
-
-    # Fork to a label
-    def k_fork(self, command):
-        if self.peek() == 'to':
-            self.nextToken()
-        command['fork'] = self.nextToken()
-        self.add(command)
-        return True
-
-    def r_fork(self, command):
-        next = self.nextPC()
-        label = command['fork']
-        try:
-            label = self.symbols[label + ':']
-        except:
-            RuntimeError(self.program, f'There is no label "{label + ":"}"')
-            return None
-        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']:
-                command['target'] = self.getToken()
-            else:
-                FatalError(self.compiler, f'Variable "{symbolRecord["name"]}" does not hold a value')
-        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
-
-    def r_get(self, command):
-        global errorCode, errorReason
-        retval = {}
-        retval['type'] = 'text'
-        retval['numeric'] = False
-        url = self.getRuntimeValue(command['url'])
-        target = self.getVariable(command['target'])
-        response = json.loads('{}')
-        try:
-            timeout = self.getRuntimeValue(command['timeout'])
-            response = requests.get(url, auth = ('user', 'pass'), timeout=timeout)
-            if response.status_code >= 400:
-                errorCode = response.status_code
-                errorReason = response.reason
-                if command['or'] != None:
-                    return command['or']
-                else:
-                    RuntimeError(self.program, f'Error code {errorCode}: {errorReason}')
-        except Exception as e:
-            errorReason = str(e)
-            if command['or'] != None:
-                return command['or']
-            else:
-                RuntimeError(self.program, f'Error: {errorReason}')
-        retval['content'] = response.text
-        self.program.putSymbolValue(target, retval)
-        return self.nextPC()
-
-    # Go to a label
-    def k_go(self, command):
-        if self.peek() == 'to':
-            self.nextToken()
-            return self.k_goto(command)
-
-    def k_goto(self, command):
-        command['keyword'] = 'goto'
-        command['goto'] = self.nextToken()
-        self.add(command)
-        return True
-
-    def r_goto(self, command):
-        label = f'{command["goto"]}:'
-        try:
-            if self.symbols[label]:
-                return self.symbols[label]
-        except:
-            pass
-        RuntimeError(self.program, f'There is no label "{label}"')
-        return None
-
-    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()
-        self.addCommand(command)
-        self.nextToken()
-        pcElse = self.getPC()
-        cmd = {}
-        cmd['lino'] = command['lino']
-        cmd['domain'] = 'core'
-        cmd['keyword'] = 'gotoPC'
-        cmd['goto'] = 0
-        cmd['debug'] = False
-        self.addCommand(cmd)
-        # Get the 'then' code
-        self.compileOne()
-        if self.peek() == 'else':
-            self.nextToken()
-            # Add a 'goto' to skip the 'else'
-            pcNext = self.getPC()
-            cmd = {}
-            cmd['lino'] = command['lino']
-            cmd['domain'] = 'core'
-            cmd['keyword'] = 'gotoPC'
-            cmd['goto'] = 0
-            cmd['debug'] = False
-            self.addCommand(cmd)
-            # Fixup the link to the 'else' branch
-            self.getCommandAt(pcElse)['goto'] = self.getPC()
-            # Process the 'else' branch
-            self.nextToken()
-            self.compileOne()
-            # Fixup the pcNext 'goto'
-            self.getCommandAt(pcNext)['goto'] = self.getPC()
-        else:
-            # We're already at the next command
-            self.getCommandAt(pcElse)['goto'] = self.getPC()
-        return True
-
-    def r_if(self, command):
-        test = self.program.condition.testCondition(command['condition'])
-        if test:
-            self.program.pc += 2
-        else:
-            self.program.pc += 1
-        return self.program.pc
-
-    def k_import(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:
-            # 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
-
-    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):
-        if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['valueHolder']:
-                command['target'] = self.getToken()
-                self.add(command)
-                return True
-            self.warning(f'Core.increment: Variable "{symbolRecord["name"]}" does not hold a value')
-        return False
-
-    def r_increment(self, command):
-        return self.incdec(command, '+')
-
-    # Index to a specified element in a variable
-    # index {variable} to {value}
-    def k_index(self, command):
-        # get the variable
-        if self.nextIsSymbol():
-            command['target'] = self.getToken()
-            if self.nextToken() == 'to':
-                # get the value
-                command['value'] = self.nextValue()
-                self.add(command)
-                return True
-        return False
-
-    def r_index(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        symbolRecord['index'] = self.getRuntimeValue(command['value'])
-        return self.nextPC()
-
-    # Initialise a stack, array or object
-    def k_init(self, command):
-        # get the variable
-        if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            keyword = symbolRecord['keyword']
-            if keyword in ['stack','array', 'object']:
-                command['keyword'] = keyword
-                command['target'] = symbolRecord['name']
-                return True
-        return False
-
-    def r_init(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        keyword = command['keyword']
-        if keyword in ['stack', 'array']:
-            self.putSymbolValue(symbolRecord, json.loads('[]'))
-        elif keyword == 'object':
-            self.putSymbolValue(symbolRecord, json.loads('{}'))
-        else:
-            RuntimeError(self.program, f"Inappropriate variable type '{keyword}'")
-        return self.nextPC()
-
-    # Inout a value from the terminal
-    # input {variable} [with {prompt}]
-    def k_input(self, command):
-        # get the variable
-        if self.nextIsSymbol():
-            command['target'] = self.getToken()
-            value = {}
-            value['type'] = 'text'
-            value['numeric'] = 'false'
-            value['content'] = ': '
-            command['prompt'] = value
-            if self.peek() == 'with':
-                self.nextToken()
-                command['prompt'] = self.nextValue()
-            self.add(command)
-            return True
-        return False
-
-    def r_input(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        prompt = command['prompt']['content']
-        value = {}
-        value['type'] = 'text'
-        value['numeric'] = False
-        value['content'] = prompt+input(prompt)
-        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():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['valueHolder']:
-                command['target'] = symbolRecord['name']
-                if self.nextIs('from'):
-                    command['file'] = self.nextValue()
-                    self.add(command)
-                    return True
-        else:
-            FatalError(self.compiler, f'I don\'t understand \'{self.getToken()}\'')
-        return False
-
-    def r_load(self, command):
-        target = self.getVariable(command['target'])
-        filename = self.getRuntimeValue(command['file'])
-        try:
-            with open(filename) as f: content = f.read()
-        except:
-            RuntimeError(self.program, f'File \'{filename}\' not found')
-        try:
-            if filename.endswith('.json'): content = json.loads(content)
-        except:
-            RuntimeError(self.program, 'Bad or null JSON string')
-        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()
-
-    # 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)
-
-    def r_module(self, command):
-        return self.nextPC()
-
-    # Arithmetic multiply
-    # multiply {variable} by {value}[ giving {variable}]}
-    def k_multiply(self, command):
-        # Get the (first) value
-        command['value1'] = self.nextValue()
-        if self.nextToken() == 'by':
-            command['value2'] = self.nextValue()
-            if self.peek() == 'giving':
-                self.nextToken()
-                if (self.nextIsSymbol()):
-                    command['target'] = self.getToken()
-                    self.add(command)
-                    return True
-                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.compiler, 'First value must be a variable')
-        return False
-
-    def r_multiply(self, command):
-        value1 = command['value1']
-        try:
-            value2 = command['value2']
-        except:
-            value2 = None
-        target = self.getVariable(command['target'])
-        if not target['valueHolder']:
-            self.variableDoesNotHoldAValueError(target['name'])
-            return None
-        value = self.getSymbolValue(target)
-        if value == None:
-            value = {}
-        value['type'] = 'int'
-        if value2:
-            v1 = int(self.getRuntimeValue(value1))
-            v2 = int(self.getRuntimeValue(value2))
-            value['content'] = v1*v2
-        else:
-            if value['type'] != 'int' and value['content'] != None:
-                self.nonNumericValueError()
-                return None
-            v = int(self.getRuntimeValue(value))
-            v1 = int(self.getRuntimeValue(value1))
-            value['content'] = v*v1
-        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)
-
-    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):
-        if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            command['target'] = symbolRecord['name']
-            command['path'] = self.nextValue()
-            if symbolRecord['keyword'] == 'file':
-                if self.peek() == 'for':
-                    self.nextToken()
-                    token = self.nextToken()
-                    if token == 'appending':
-                        mode = 'a'
-                    elif token == 'reading':
-                        mode = 'r'
-                    elif token == 'writing':
-                        mode = 'w'
-                    else:
-                        FatalError(self.compiler, 'Unknown file open mode {self.getToken()}')
-                        return False
-                    command['mode'] = mode
-                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')
-        return False
-
-    def r_open(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        path = self.getRuntimeValue(command['path'])
-        if command['mode'] == 'r' and os.path.exists(path) or command['mode'] != 'r':
-            symbolRecord['file'] = open(path, command['mode'])
-            return self.nextPC()
-        RuntimeError(self.program, f"File {path} does not exist")
-
-    # Pop a value from a stack
-    # pop {variable} from {stack}
-    def k_pop(self, command):
-        if (self.nextIsSymbol()):
-            symbolRecord = self.getSymbolRecord()
-            command['target'] = symbolRecord['name']
-            if self.peek() == 'from':
-                self.nextToken()
-                if self.nextIsSymbol():
-                    command['from'] = self.getToken()
-                    self.add(command)
-                    return True
-        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')
-        stackRecord = self.getVariable(command['from'])
-        stack = self.getSymbolValue(stackRecord)
-        v = stack.pop();
-        self.putSymbolValue(stackRecord, stack)
-        value = {}
-        value['type'] = 'int' if type(v) == int else 'text'
-        value['content'] = v
-        self.putSymbolValue(symbolRecord, value)
-        return self.nextPC()
-
-    # Perform an HTTP POST
-    # post {value} to {url} [giving {variable}] [or {command}]
-    def k_post(self, command):
-        if self.nextIs('to'):
-            command['value'] = self.getConstant('')
-            command['url'] = self.getValue()
-        else:
-            command['value'] = self.getValue()
-            if self.nextIs('to'):
-                command['url'] = self.nextValue()
-        if self.peek() == 'giving':
-            self.nextToken()
-            command['result'] = self.nextToken()
-        else:
-            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()
-        return True
-
-    def r_post(self, command):
-        global errorCode, errorReason
-        retval = {}
-        retval['type'] = 'text'
-        retval['numeric'] = False
-        value = self.getRuntimeValue(command['value'])
-        url = self.getRuntimeValue(command['url'])
-        try:
-            response = requests.post(url, value, timeout=5)
-            retval['content'] = response.text
-            if response.status_code >= 400:
-                errorCode = response.status_code
-                errorReason = response.reason
-                if command['or'] != None:
-                    print(f'Error {errorCode} {errorReason}: Running the "or" clause')
-                    return command['or']
-                else:
-                    RuntimeError(self.program, f'Error code {errorCode}: {errorReason}')
-        except Exception as e:
-            errorReason = str(e)
-            if command['or'] != None:
-                print(f'Exception "{errorReason}": Running the "or" clause')
-                return command['or']
-            else:
-                RuntimeError(self.program, f'Error: {errorReason}')
-        if command['result'] != None:
-            result = self.getVariable(command['result'])
-            self.program.putSymbolValue(result, retval)
-        return self.nextPC()
-
-    # Print a value
-    def k_print(self, command):
-        value = self.nextValue()
-        if value != None:
-            command['value'] = value
-            self.add(command)
-            return True
-        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 = 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()}:{lino}-> {value}')
-        else:
-            print(value)
-        return self.nextPC()
-
-    # Push a value onto a stack
-    # push {value} to/onto {stack}
-    def k_push(self, command):
-        value = self.nextValue()
-        command['value'] = value
-        peekValue = self.peek()
-        if peekValue in ['onto', 'to']:
-            self.nextToken()
-            if self.nextIsSymbol():
-                symbolRecord = self.getSymbolRecord()
-                command['to'] = symbolRecord['name']
-                self.add(command)
-                return True
-        return False
-
-    def r_push(self, command):
-        value = self.getRuntimeValue(command['value'])
-        stackRecord = self.getVariable(command['to'])
-        if stackRecord['keyword'] != 'stack':
-            RuntimeError(self.program, f'{stackRecord["name"]} is not a stack')
-            return -1
-        stack = stackRecord['value'][stackRecord['index']]
-        if stack == None:
-            stack = [value]
-        else:
-            stack.append(value)
-        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.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
-                else:
-                    self.add(command)
-                    return True
-            else:
-                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
-        symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['valueHolder']:
-            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
-            return -1
-        self.putSymbolValue(symbolRecord, value)
-        return self.nextPC()
-
-    # Read from a file
-    # read {variable} from {file}
-    def k_read(self, command):
-        if self.peek() == 'line':
-            self.nextToken()
-            command['line'] = True
-        else:
-            command['line'] = False
-        if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['valueHolder']:
-                if self.peek() == 'from':
-                    self.nextToken()
-                    if self.nextIsSymbol():
-                        fileRecord = self.getSymbolRecord()
-                        if fileRecord['keyword'] == 'file':
-                            command['target'] = symbolRecord['name']
-                            command['file'] = fileRecord['name']
-                            self.add(command)
-                            return True
-            FatalError(self.compiler, f'Symbol "{symbolRecord["name"]}" is not a value holder')
-            return False
-        FatalError(self.compiler, f'Symbol "{self.getToken()}" has not been declared')
-        return False
-
-    def r_read(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        fileRecord = self.getVariable(command['file'])
-        line = command['line']
-        file = fileRecord['file']
-        if file.mode == 'r':
-            value = {}
-            content = file.readline().split('\n')[0] if line else file.read()
-            value['type'] = 'text'
-            value['numeric'] = False
-            value['content'] = content
-            self.putSymbolValue(symbolRecord, value)
-        return self.nextPC()
-
-    # Replace a substring
-    #replace {value} with {value} in {variable}
-    def k_replace(self, command):
-        original = self.nextValue()
-        if self.peek() == 'with':
-            self.nextToken()
-            replacement = self.nextValue()
-            if self.nextIs('in'):
-                if self.nextIsSymbol():
-                    templateRecord = self.getSymbolRecord()
-                    command['original'] = original
-                    command['replacement'] = replacement
-                    command['target'] = templateRecord['name']
-                    self.add(command)
-                    return True
-        return False
-
-    def r_replace(self, command):
-        templateRecord = self.getVariable(command['target'])
-        content = self.getSymbolValue(templateRecord)['content']
-        original = self.getRuntimeValue(command['original'])
-        replacement = self.getRuntimeValue(command['replacement'])
-        content = content.replace(original, str(replacement))
-        value = {}
-        value['type'] = 'text'
-        value['numeric'] = False
-        value['content'] = content
-        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)
-        return True
-
-    def r_return(self, command):
-        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()
-        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':
-                    name = record['name']
-                    command['module'] = name
-                else: RuntimeError(self.program, f'Symbol \'name\' is not a module')
-            else: RuntimeError(self.program, 'Module name expected after \'as\'')
-        else: RuntimeError(self.program, '\'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'])
-        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'])
-        filename = self.getRuntimeValue(command['file'])
-        if filename.endswith('.json'): content = json.dumps(content)
-        with open(filename, 'w') as f: f.write(content)
-        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}
-    # set element/property of {variable} to {value}
-    def k_set(self, command):
-        if self.nextIsSymbol():
-            target = self.getSymbolRecord()
-            if target['valueHolder']:
-                command['type'] = 'set'
-                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['name'] = self.getToken()
-                if self.peek() == 'to':
-                    self.nextToken()
-                command['elements'] = self.nextValue()
-                self.add(command)
-                return True
-
-        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():
-                    command['target'] = self.getSymbolRecord()['name']
-                    if self.nextIs('to'):
-                        command['value'] = self.nextValue()
-                        self.add(command)
-                        return True
-
-        elif token == 'element':
-            command['index'] = self.nextValue()
-            if self.nextIs('of'):
-                if self.nextIsSymbol():
-                    command['target'] = self.getSymbolRecord()['name']
-                    if self.nextIs('to'):
-                        command['value'] = self.nextValue()
-                        self.add(command)
-                        return True
-        return False
-
-    def r_set(self, command):
-        cmdType = command['type']
-        if cmdType == 'set':
-            target = self.getVariable(command['target'])
-            val = {}
-            val['type'] = 'boolean'
-            val['content'] = True
-            self.putSymbolValue(target, val)
-            return self.nextPC()
-
-        elif cmdType == 'elements':
-            symbolRecord = self.getVariable(command['name'])
-            elements = self.getRuntimeValue(command['elements'])
-            currentElements = symbolRecord['elements']
-            currentValue = symbolRecord['value']
-            if currentValue == None:
-                currentValue = [None]
-            newValue = [None] * elements
-            if elements > currentElements:
-                for index, value in enumerate(currentValue):
-                    newValue[index] = value
-            elif elements < currentElements:
-                for index, value in enumerate(currentValue):
-                    if index < elements:
-                        newValue[index] = value
-            symbolRecord['elements'] = elements
-            symbolRecord['value'] = newValue
-            return self.nextPC()
-
-        elif cmdType == 'element':
-            value = self.getRuntimeValue(command['value'])
-            index = self.getRuntimeValue(command['index'])
-            target = self.getVariable(command['target'])
-            val = self.getSymbolValue(target)
-            content = val['content']
-            if content == '':
-                content = []
-            # else:
-            # 	content = json.loads(content)
-            content[index] = value
-            val['content'] = content
-            self.putSymbolValue(target, val)
-            return self.nextPC()
-
-        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']
-            targetVariable = self.getVariable(target)
-            val = self.getSymbolValue(targetVariable)
-            try:
-                content = val['content']
-            except:
-                RuntimeError(self.program, f'{target} is not an object')
-            if content == '':
-                content = {}
-            try:
-                content[name] = value
-            except:
-                RuntimeError(self.program, f'{target} is not an object')
-            val['content'] = content
-            self.putSymbolValue(targetVariable, val)
-            return self.nextPC()
-
-    # 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']:
-                command['target'] = symbolRecord['name']
-                value = {}
-                value['type'] = 'text'
-                value['numeric'] = 'false'
-                value['content'] = '\n'
-                command['on'] = value
-                if self.peek() == 'on':
-                    self.nextToken()
-                    if self.peek() == 'tab':
-                        value['content'] = '\t'
-                        self.nextToken()
-                    else:
-                        command['on'] = self.nextValue()
-                self.add(command)
-                return True
-        return False
-
-    def r_split(self, command):
-        target = self.getVariable(command['target'])
-        value = self.getSymbolValue(target)
-        content = value['content'].split(self.getRuntimeValue(command['on']))
-        elements = len(content)
-        target['elements'] = elements
-        target['value'] = [None] * elements
-
-        for index, item in enumerate(content):
-            element = {}
-            element['type'] = 'text'
-            element['numeric'] = 'false'
-            element['content'] = item
-            target['value'][index] = element
-
-        return self.nextPC()
-
-    # Declare a stack variable
-    def k_stack(self, command):
-        return self.compileVariable(command)
-
-    def r_stack(self, command):
-        return self.nextPC()
-
-    # Stop the current execution thread
-    def k_stop(self, command):
-        self.add(command)
-        return True
-
-    def r_stop(self, command):
-        return 0
-
-    # Issue a system call
-    # system {command}
-    def k_system(self, command):
-        background = False
-        token = self.nextToken()
-        if token == 'background':
-            self.nextToken()
-            background = True
-        value = self.getValue()
-        if value != None:
-            command['value'] = value
-            command['background'] = background
-            self.add(command)
-            return True
-        FatalError(self.compiler, 'I can\'t give this command')
-        return False
-
-    def r_system(self, command):
-        value = self.getRuntimeValue(command['value'])
-        if value != None:
-            if command['background']:
-                subprocess.Popen(["sh",value,"&"])
-            else:
-                os.system(value)
-            return self.nextPC()
-
-    # Arithmetic subtraction
-    # take {value} from {variable}[ giving {variable}]}
-    def k_take(self, command):
-        # Get the (first) value
-        command['value1'] = self.nextValue()
-        if self.nextToken() == 'from':
-            if self.nextIsSymbol():
-                symbolRecord = self.getSymbolRecord()
-                if symbolRecord['valueHolder']:
-                    if self.peek() == 'giving':
-                        # This variable must be treated as a second value
-                        command['value2'] = self.getValue()
-                        self.nextToken()
-                        command['target'] = self.nextToken()
-                        self.add(command)
-                        return True
-                    else:
-                        # Here the variable is the target
-                        command['target'] = self.getToken()
-                        self.add(command)
-                        return True
-                self.warning(f'Core.take: Expected value holder')
-            else:
-                # Here we have 2 values so 'giving' must come next
-                command['value2'] = self.getValue()
-                if self.nextToken() == 'giving':
-                    if (self.nextIsSymbol()):
-                        command['target'] = self.getToken()
-                        self.add(command)
-                        return True
-                    else:
-                        FatalError(self.compiler, f'\'{self.getToken()}\' is not a symbol')
-                else:
-                    self.warning(f'Core.take: Expected "giving"')
-        return False
-
-    def r_take(self, command):
-        value1 = command['value1']
-        try:
-            value2 = command['value2']
-        except:
-            value2 = None
-        target = self.getVariable(command['target'])
-        if not target['valueHolder']:
-            self.variableDoesNotHoldAValueError(target['name'])
-            return None
-        value = self.getSymbolValue(target)
-        if value == None:
-            value = {}
-        value['type'] = 'int'
-        if value2:
-            v1 = int(self.getRuntimeValue(value1))
-            v2 = int(self.getRuntimeValue(value2))
-            value['content'] = v2-v1
-        else:
-            v = int(self.getRuntimeValue(value))
-            v1 = int(self.getRuntimeValue(value1))
-            value['content'] = v-v1
-        self.putSymbolValue(target, value)
-        return self.nextPC()
-
-    # Toggle a boolean value
-    def k_toggle(self, command):
-        if self.nextIsSymbol():
-            target = self.getSymbolRecord()
-            if target['valueHolder']:
-                command['target'] = target['name']
-                self.add(command)
-                return True
-        return False
-
-    def r_toggle(self, command):
-        target = self.getVariable(command['target'])
-        value = self.getSymbolValue(target)
-        val = {}
-        val['type'] = 'boolean'
-        val['content'] = not value['content']
-        self.putSymbolValue(target, val)
-        self.add(command)
-        return self.nextPC()
-
-    # Truncate a file
-    def k_truncate(self, command):
-        if self.nextIsSymbol():
-            fileRecord = self.getSymbolRecord()
-            if fileRecord['keyword'] == 'file':
-                command['file'] = fileRecord['name']
-                self.add(command)
-                return True
-        return False
-
-    def r_truncate(self, command):
-        fileRecord = self.getVariable(command['file'])
-        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)
-
-    def r_variable(self, command):
-        return self.nextPC()
-
-    # Pause for a specified time
-    def k_wait(self, command):
-        command['value'] = self.nextValue()
-        multipliers = {}
-        multipliers['milli'] = 1
-        multipliers['millis'] = 1
-        multipliers['tick'] = 10
-        multipliers['ticks'] = 10
-        multipliers['second'] = 1000
-        multipliers['seconds'] = 1000
-        multipliers['minute'] = 60000
-        multipliers['minutes'] = 60000
-        command['multiplier'] = multipliers['second']
-        token = self.peek()
-        if token in multipliers:
-            self.nextToken()
-            command['multiplier'] = multipliers[token]
-        self.add(command)
-        return True
-
-    def r_wait(self, command):
-        value = self.getRuntimeValue(command['value']) * command['multiplier']
-        next = self.nextPC()
-        threading.Timer(value/1000.0, lambda: (self.run(next))).start()
-        return 0
-
-    # while <condition> <action>
-    def k_while(self, command):
-        code = self.nextCondition()
-        if code == None:
-            return None
-        # token = self.getToken()
-        command['condition'] = code
-        test = self.getPC()
-        self.addCommand(command)
-        # Set up a goto for when the test fails
-        fail = self.getPC()
-        cmd = {}
-        cmd['lino'] = command['lino']
-        cmd['domain'] = 'core'
-        cmd['keyword'] = 'gotoPC'
-        cmd['goto'] = 0
-        cmd['debug'] = False
-        self.addCommand(cmd)
-        # Do the body of the while
-        self.nextToken()
-        if self.compileOne() == False:
-            return False
-        # Repeat the test
-        cmd = {}
-        cmd['lino'] = command['lino']
-        cmd['domain'] = 'core'
-        cmd['keyword'] = 'gotoPC'
-        cmd['goto'] = test
-        cmd['debug'] = False
-        self.addCommand(cmd)
-        # Fixup the 'goto' on completion
-        self.getCommandAt(fail)['goto'] = self.getPC()
-        return True
-
-    def r_while(self, command):
-        test = self.program.condition.testCondition(command['condition'])
-        if test:
-            self.program.pc += 2
-        else:
-            self.program.pc += 1
-        return self.program.pc
-
-    # Write to a file
-    def k_write(self, command):
-        if self.peek() == 'line':
-            self.nextToken()
-            command['line'] = True
-        else:
-            command['line'] = False
-        command['value'] = self.nextValue()
-        if self.peek() == 'to':
-            self.nextToken()
-            if self.nextIsSymbol():
-                fileRecord = self.getSymbolRecord()
-                if fileRecord['keyword'] == 'file':
-                    command['file'] = fileRecord['name']
-                    self.add(command)
-                    return True
-        return False
-
-    def r_write(self, command):
-        value = self.getRuntimeValue(command['value'])
-        fileRecord = self.getVariable(command['file'])
-        file = fileRecord['file']
-        if file.mode in ['w', 'w+', 'a', 'a+']:
-            file.write(f'{value}')
-            if command['line']:
-                file.write('\n')
-        return self.nextPC()
-
-    #############################################################################
-    # Support functions
-
-    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
-        value = self.getSymbolValue(symbolRecord)
-        if value == None:
-            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
-        if mode == '+':
-            value['content'] += 1
-        else:
-            value['content'] -= 1
-        self.putSymbolValue(symbolRecord, value)
-        return self.nextPC()
-
-    #############################################################################
-    # Compile a value in this domain
-    def compileValue(self):
-        value = {}
-        value['domain'] = self.getName()
-        token = self.getToken()
-        if self.isSymbol():
-            value['name'] = token
-            symbolRecord = self.getSymbolRecord()
-            keyword = symbolRecord['keyword']
-
-            if keyword == 'module':
-                value['type'] = 'module'
-                return value
-
-            if keyword == 'variable':
-                value['type'] = 'symbol'
-                return value
-            return None
-
-        value['type'] = token
-
-        if token == 'arg':
-            self.nextToken()
-            value['index'] = self.getValue()
-            return value
-
-        if token in ['cos', 'sin', 'tan']:
-            value['angle'] = self.nextValue()
-            if self.nextToken() == 'radius':
-                value['radius'] = self.nextValue()
-                return value
-            return None
-
-        if token in ['now', 'today', 'newline', 'tab', 'empty']:
-            return value
-
-        if token in ['stringify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer', 'encode', 'decode']:
-            value['content'] = self.nextValue()
-            return value
-
-        if (token in ['datime', 'datetime']):
-            value['type'] = 'datime'
-            value['timestamp'] = self.nextValue()
-            if self.peek() == 'format':
-                self.nextToken()
-                value['format'] = self.nextValue()
-            else:
-                value['format'] = None
-            return value
-
-        if token == 'element':
-            value['index'] = self.nextValue()
-            if self.nextToken() == 'of':
-                if self.nextIsSymbol():
-                    symbolRecord = self.getSymbolRecord()
-                    if symbolRecord['valueHolder']:
-                        value['target'] = symbolRecord['name']
-                        return value
-                self.warning(f'Core.compileValue: Token \'{self.getToken()}\' does not hold a value')
-            return None
-
-        if token == 'property':
-            value['name'] = self.nextValue()
-            if self.nextToken() == 'of':
-                if self.nextIsSymbol():
-                    symbolRecord = self.getSymbolRecord()
-                    if symbolRecord['valueHolder']:
-                        value['target'] = symbolRecord['name']
-                        return value
-                    FatalError(self.compiler, 'Variable does not hold a value')
-            return None
-
-        if token == 'arg':
-            value['content'] = self.nextValue()
-            if self.getToken() == 'of':
-                if self.nextIsSymbol():
-                    symbolRecord = self.getSymbolRecord()
-                    if symbolRecord['keyword'] == 'variable':
-                        value['target'] = symbolRecord['name']
-                        return value
-            return None
-
-        if token == 'trim':
-            self.nextToken()
-            value['content'] = self.getValue()
-            return value
-
-        if self.getToken() == 'the':
-            self.nextToken()
-
-        token = self.getToken()
-        value['type'] = token
-
-        if token == 'args':
-           return value
-
-        if token == 'elements':
-            if self.nextIs('of'):
-                if self.nextIsSymbol():
-                    value['name'] = self.getToken()
-                    return value
-            return None
-
-        if token == 'keys':
-            if self.nextIs('of'):
-                value['name'] = self.nextValue()
-                return value
-            return None
-
-        if token == 'count':
-            if self.nextIs('of'):
-                if self.nextIsSymbol():
-                    value['name'] = self.getToken()
-                    return value
-            return None
-
-        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']
-                            return value
-                    else:
-                        value['name'] = self.getToken()
-                        return value
-                else:
-                    value['value'] = self.getValue()
-                    if self.nextIs('in'):
-                        value['variable'] = None
-                        value['type'] = 'indexOf'
-                        if self.nextIsSymbol():
-                            value['target'] = self.getSymbolRecord()['name']
-                            return value
-            return None
-
-        if token == 'value':
-            if self.nextIs('of'):
-                v = self.nextValue()
-                if v !=None:
-                    value['type'] = 'valueOf'
-                    value['content'] = v
-                    return value
-            return None
-
-        if token == 'length':
-            value['type'] = 'lengthOf'
-            if self.nextIs('of'):
-                value['content'] = self.nextValue()
-                return value
-            return None
-
-        if token in ['left', 'right']:
-            value['count'] = self.nextValue()
-            if self.nextToken() == 'of':
-                value['content'] = self.nextValue()
-                return value
-            return None
-
-        if token == 'from':
-            value['start'] = self.nextValue()
-            if self.peek() == 'to':
-                self.nextToken()
-                value['to'] = self.nextValue()
-            else:
-                value['to'] = None
-            if self.nextToken() == 'of':
-                value['content'] = self.nextValue()
-                return value
-
-        if token == 'position':
-            if self.nextIs('of'):
-                value['last'] = False
-                if self.nextIs('the'):
-                    if self.nextIs('last'):
-                        self.nextToken()
-                        value['last'] = True
-                value['needle'] = self.getValue()
-                if self.nextToken() == 'in':
-                    value['haystack'] = self.nextValue()
-                    return value
-
-        if token == 'message':
-            return value
-
-        if token == 'timestamp':
-            value['format'] = None
-            if self.peek() == 'of':
-                self.nextToken()
-                value['datime'] = self.nextValue()
-                if self.peek() == 'format':
-                    self.nextToken()
-                    value['format'] = self.nextValue()
-            return value
-
-        if token == 'files':
-            token = self.nextToken()
-            if token in ['in', 'of']:
-                value['target'] = self.nextValue()
-                return value
-            return None
-
-        if token == 'weekday':
-            value['type'] = 'weekday'
-            return value
-
-        if token == 'mem' or token == 'memory':
-            value['type'] = 'memory'
-            return value
-
-        if token == 'error':
-            if self.peek() == 'code':
-                self.nextToken()
-                value['item'] = 'errorCode'
-                return value
-            if self.peek() == 'reason':
-                self.nextToken()
-                value['item'] = 'errorReason'
-                return value
-
-        if token == 'type':
-            if self.nextIs('of'):
-                value['value'] = self.nextValue()
-                return value
-            return None
-
-        if token == 'modification':
-            if self.nextIs('time'):
-                if self.nextIs('of'):
-                    value['fileName'] = self.nextValue()
-                    return value
-            return None
-
-        if token == 'system':
-            value['command'] = self.nextValue()
-            return value
-
-        return None
-
-    #############################################################################
-    # Modify a value or leave it unchanged.
-    def modifyValue(self, value):
-        if self.peek() == 'modulo':
-            self.nextToken()
-            mv = {}
-            mv['domain'] = 'core'
-            mv['type'] = 'modulo'
-            mv['content'] = value
-            mv['modval'] = self.nextValue()
-            value = mv
-
-        return value
-
-    #############################################################################
-    # Value handlers
-
-    def v_args(self, v):
-        value = {}
-        value['type'] = 'text'
-        value['content'] = json.dumps(self.program.argv)
-        return value
-
-    def v_arg(self, v):
-        value = {}
-        value['type'] = 'text'
-        index = self.getRuntimeValue(v['index'])
-        if index >= len(self.program.argv):
-            RuntimeError(self.program, 'Index exceeds # of args')
-        value['content'] = self.program.argv[index]
-        return value
-
-    def v_boolean(self, v):
-        value = {}
-        value['type'] = 'boolean'
-        value['content'] = v['content']
-        return value
-
-    def v_cos(self, v):
-        angle = self.getRuntimeValue(v['angle'])
-        radius = self.getRuntimeValue(v['radius'])
-        value = {}
-        value['type'] = 'int'
-        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']
-        if fmt == None:
-            fmt = '%b %d %Y %H:%M:%S'
-        else:
-            fmt = self.getRuntimeValue(fmt)
-        value = {}
-        value['type'] = 'text'
-        value['content'] = datetime.fromtimestamp(ts/1000).strftime(fmt)
-        return value
-
-    def v_decode(self, v):
-        content = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
-        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')
-        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
-
-    def v_element(self, v):
-        index = self.getRuntimeValue(v['index'])
-        target = self.getVariable(v['target'])
-        val = self.getSymbolValue(target)
-        content = val['content']
-        value = {}
-        value['type'] = 'int' if isinstance(content, int) else 'text'
-        if type(content) == list:
-            try:
-                value['content'] = content[index]
-                return value
-            except:
-                RuntimeError(self.program, 'Index out of range')
-        # lino = self.program.code[self.program.pc]['lino']
-        RuntimeError(self.program, 'Item is not a list')
-
-    def v_elements(self, v):
-        var = self.getVariable(v['name'])
-        value = {}
-        value['type'] = 'int'
-        value['content'] = var['elements']
-        return value
-
-    def v_empty(self, v):
-        value = {}
-        value['type'] = 'text'
-        value['content'] = ''
-        return value
-
-    def v_encode(self, v):
-        content = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
-        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')
-        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
-
-    def v_error(self, v):
-        global errorCode, errorReason
-        value = {}
-        if v['item'] == 'errorCode':
-            value['type'] = 'int'
-            value['content'] = errorCode
-        elif v['item'] == 'errorReason':
-            value['type'] = 'text'
-            value['content'] = errorReason
-        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_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_from(self, v):
-        content = self.getRuntimeValue(v['content'])
-        start = self.getRuntimeValue(v['start'])
-        to = v['to']
-        if not to == None:
-            to = self.getRuntimeValue(to)
-        value = {}
-        value['type'] = 'text'
-        if to == None:
-            value['content'] = content[start:]
-        else:
-            value['content'] = content[start:to]
-        return value
-
-    def v_hash(self, v):
-        hashval = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = hashlib.sha256(hashval.encode('utf-8')).hexdigest()
-        return value
-
-    def v_index(self, v):
-        value = {}
-        value['type'] = 'int'
-        value['content'] = self.getVariable(v['name'])['index']
-        return value
-
-    def v_indexOf(self, v):
-        value = v['value']
-        if value == None:
-            value = self.getSymbolValue(v['variable'])['content']
-        else:
-            value = self.getRuntimeValue(value)
-        target = self.getVariable(v['target'])
-        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'])
-        value = {}
-        value['type'] = 'int'
-        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'
-        value['content'] = list(self.getRuntimeValue(v['name']).keys())
-        return value
-
-    def v_left(self, v):
-        content = self.getRuntimeValue(v['content'])
-        count = self.getRuntimeValue(v['count'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = content[0:count]
-        return value
-
-    def v_lengthOf(self, v):
-        content = self.getRuntimeValue(v['content'])
-        if type(content) == str:
-            value = {}
-            value['type'] = 'int'
-            value['content'] = len(content)
-            return value
-        RuntimeError(self.program, 'Value is not a string')
-
-    def v_lowercase(self, v):
-        content = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = content.lower()
-        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_message(self, v):
-        value = {}
-        value['type'] = 'text'
-        value['content'] = self.program.message
-        return value
-
-    def v_modification(self, v):
-        fileName = self.getRuntimeValue(v['fileName'])
-        ts = int(os.stat(fileName).st_mtime)
-        value = {}
-        value['type'] = 'int'
-        value['content'] = ts
-        return value
-
-    def v_modulo(self, v):
-        val = self.getRuntimeValue(v['content'])
-        modval = self.getRuntimeValue(v['modval'])
-        value = {}
-        value['type'] = 'int'
-        value['content'] = val % modval
-        return value
-
-    def v_newline(self, v):
-        value = {}
-        value['type'] = 'text'
-        value['content'] = '\n'
-        return value
-
-    def v_now(self, v):
-        value = {}
-        value['type'] = 'int'
-        value['content'] = getTimestamp(time.time())
-        return value
-
-    def v_position(self, v):
-        needle = self.getRuntimeValue(v['needle'])
-        haystack = self.getRuntimeValue(v['haystack'])
-        last = v['last']
-        value = {}
-        value['type'] = 'int'
-        value['content'] = haystack.rfind(needle) if last else haystack.find(needle)
-        return value
-
-    def v_property(self, v):
-        propertyValue = self.getRuntimeValue(v['name'])
-        if 'target' in v:
-            targetName = v['target']
-            target = self.getVariable(targetName)
-            targetValue = self.getRuntimeValue(target)
-        else:
-            targetValue = self.getRuntimeValue(v['value'])
-        try:
-            val = targetValue[propertyValue]
-        except:
-            RuntimeError(self.program, f'This value does not have the property \'{propertyValue}\'')
-            return None
-        value = {}
-        value['content'] = val
-        if isinstance(v, numbers.Number):
-            value['type'] = 'int'
-        else:
-            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'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = content[-count:]
-        return value
-
-    def v_sin(self, v):
-        angle = self.getRuntimeValue(v['angle'])
-        radius = self.getRuntimeValue(v['radius'])
-        value = {}
-        value['type'] = 'int'
-        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):
-        if symbolRecord['keyword'] == 'variable':
-            return self.getSymbolValue(symbolRecord)
-        else:
-            return None
-
-    def v_system(self, v):
-        command = self.getRuntimeValue(v['command'])
-        result = os.popen(command).read()
-        value = {}
-        value['type'] = 'text'
-        value['content'] = result
-        return value
-
-    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'])
-        value = {}
-        value['type'] = 'int'
-        value['content'] = round(math.tan(angle * 0.01745329) * radius)
-        return value
-
-    def v_timestamp(self, v):
-        value = {}
-        value['type'] = 'int'
-        fmt = v['format']
-        if fmt == None:
-            value['content'] = int(time.time())
-        else:
-            fmt = self.getRuntimeValue(fmt)
-            dt = self.getRuntimeValue(v['datime'])
-            spec = datetime.strptime(dt, fmt)
-            t = datetime.now().replace(hour=spec.hour, minute=spec.minute, second=spec.second, microsecond=0)
-            value['content'] = int(t.timestamp())
-        return value
-
-    def v_today(self, v):
-        value = {}
-        value['type'] = 'int'
-        value['content'] = int(datetime.combine(datetime.now().date(),datetime.min.time()).timestamp())*1000
-        return value
-
-    def v_trim(self, v):
-        v = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = v.strip()
-        return value
-
-    def v_type(self, v):
-        value = {}
-        value['type'] = 'text'
-        val = self.getRuntimeValue(v['value'])
-        if val is None:
-            value['content'] = 'none'
-        elif type(val) is str:
-            value['content'] = 'text'
-        elif type(val) is int:
-            value['content'] = 'numeric'
-        elif type(val) is bool:
-            value['content'] = 'boolean'
-        elif type(val) is list:
-            value['content'] = 'list'
-        elif type(val) is dict:
-            value['content'] = 'object'
-        return value
-
-    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'] = int(v)
-        return value
-
-    def v_weekday(self, v):
-        value = {}
-        value['type'] = 'int'
-        value['content'] = datetime.today().weekday()
-        return value
-
-    #############################################################################
-    # Compile a condition
-    def compileCondition(self):
-        condition = Condition()
-
-        if self.getToken() == 'not':
-            condition.type = 'not'
-            condition.value = self.nextValue()
-            return condition
-
-        if self.getToken() == 'file':
-            path = self.nextValue()
-            if self.peek() == 'exists':
-                condition.type = 'exists'
-                condition.path = path
-                self.nextToken()
-                return condition
-            return None
-
-        value = self.getValue()
-        if value == None:
-            return None
-
-        condition.value1 = value
-        token = self.peek()
-        condition.type = token
-
-        if token == 'has':
-            self.nextToken()
-            if self.nextToken() == 'property':
-                prop = self.nextValue()
-                condition.type = 'hasProperty'
-                condition.property = prop
-                return condition
-            return None
-
-        if token == 'does':
-            self.nextToken()
-            if self.nextIs('not'):
-                if self.nextIs('have'):
-                    if self.nextToken() == 'property':
-                        prop = self.nextValue()
-                        condition.type = 'hasProperty'
-                        condition.property = prop
-                        condition.negate = not condition.negate
-                        return condition
-            return None
-
-        if token in ['starts', 'ends']:
-            self.nextToken()
-            if self.nextToken() == 'with':
-                condition.value2 = self.nextValue()
-                return condition
-
-        if token == 'includes':
-            condition.value2 = self.nextValue()
-            return condition
-
-        if token == 'is':
-            token = self.nextToken()
-            if self.peek() == 'not':
-                self.nextToken()
-                condition.negate = True
-            token = self.nextToken()
-            condition.type = token
-            if token in ['numeric', 'string', 'boolean', 'none', 'list', 'object', 'even', 'odd', 'empty']:
-                return condition
-            if token in ['greater', 'less']:
-                if self.nextToken() == 'than':
-                    condition.value2 = self.nextValue()
-                    return condition
-            condition.type = 'is'
-            condition.value2 = self.getValue()
-            return condition
-
-        if condition.value1:
-            # It's a boolean if
-            condition.type = 'boolean'
-            return condition
-
-        self.warning(f'Core.compileCondition: I can\'t get a conditional:')
-        return None
-
-    def isNegate(self):
-        token = self.getToken()
-        if token == 'not':
-            self.nextToken()
-            return True
-        return False
-
-    #############################################################################
-    # Condition handlers
-
-    def c_boolean(self, condition):
-        value = self.getRuntimeValue(condition.value1)
-        if type(value) == bool:
-            return not value if condition.negate else value
-        elif type(value) == int:
-            return True if condition.negate else False
-        elif type(value) == str:
-            if value.lower() == 'true':
-                return False if condition.negate else True
-            elif value.lower() == 'false':
-                return True if condition.negate else False
-            else:
-                return True if condition.negate else False
-        return False
-
-    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_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 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
-
-    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_numeric(self, condition):
-        comparison = type(self.getRuntimeValue(condition.value1)) is int
-        return not comparison if condition.negate else comparison
-
-    def c_none(self, condition):
-        comparison = self.getRuntimeValue(condition.value1) is None
-        return not comparison if condition.negate else comparison
-
-    def c_not(self, condition):
-        return not self.getRuntimeValue(condition.value)
-
-    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_starts(self, condition):
-        value1 = self.getRuntimeValue(condition.value1)
-        value2 = self.getRuntimeValue(condition.value2)
-        return value1.startswith(value2)
-
-    def c_string(self, condition):
-        comparison = type(self.getRuntimeValue(condition.value1)) is str
-        return not comparison if condition.negate else comparison