easycoder 251104.2__py2.py3-none-any.whl → 260108.1__py2.py3-none-any.whl

easycoder/ec_core.py

@@ -1,16 +1,31 @@
 import json, math, hashlib, threading, os, subprocess, time
-import numbers, base64, binascii, random, requests, paramiko
+import base64, binascii, random, requests, paramiko, uuid
 from copy import deepcopy
-from psutil import Process
 from datetime import datetime
-from .ec_classes import FatalError, RuntimeWarning, RuntimeError, AssertionError, NoValueError, NoValueRuntimeError, Object
+from .ec_classes import (
+    FatalError,
+    RuntimeWarning,
+    RuntimeError,
+    RuntimeAssertionError,
+    NoValueError,
+    NoValueRuntimeError,
+    ECObject,
+    ECVariable,
+    ECDictionary,
+    ECList,
+    ECFile,
+    ECStack,
+    ECSSH,
+    ECValue,
+    ECModule
+)
+
 from .ec_handler import Handler
-from .ec_timestamp import getTimestamp
 
 class Core(Handler):
 
     def __init__(self, compiler):
-        Handler.__init__(self, compiler)
+        super().__init__(compiler)
         self.encoding = 'utf-8'
 
     def getName(self):
@@ -43,91 +58,80 @@ class Core(Handler):
     # Keyword handlers
 
     # Arithmetic add
-    # add {value} to {variable}[ giving {variable}]}
+    # add {value} to {variable}
+    # add {value1} to {value2} 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['hasValue']:
-                    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')
+        if command['value1'] == None: return False
+        self.skip('to')
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if not isinstance(self.getObject(record), ECVariable): return False
+            # If 'giving' comes next, this variable is the second value
+            if self.peek() == 'giving':
+                v2 = ECValue(type='symbol', content=record['name'])
+                command['value2'] = v2
+                self.nextToken()
+                # Now get the target variable
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    self.checkObjectType(record, ECVariable)
+                    command['target'] = record['name']
+                self.add(command)
+                return True
             else:
-                # Here we have 2 values so 'giving' must come next
-                command['value2'] = self.getValue()
-                if self.nextToken() == 'giving':
-                    command['target'] = self.nextToken()
+                # Here the variable is the target
+                command['target'] = record['name']
+                if self.getObject(record).isMutable():
                     self.add(command)
                     return True
-                self.warning(f'Core.add: Expected "giving"')
+        else:
+            # Here we have 2 values so 'giving' must come next
+            command['value2'] = self.getValue()
+            if self.nextToken() == 'giving':
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    self.checkObjectType(record, ECVariable)
+                    command['target'] = record['name']
+                self.add(command)
+                return True
+            # raise FatalError(self.compiler, 'Cannot add values: target variable expected')
         return False
 
     def r_add(self, command):
-        value1 = command['value1']
-        try:
-            value2 = command['value2']
-        except:
-            value2 = None
+        value1 = self.textify(command['value1'])
+        value2 = self.textify(command['value2']) if 'value2' in command else None
         target = self.getVariable(command['target'])
-        if not target['hasValue']:
-            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
+        # Check that the target variable is mutable. If not, it's not an arithmetic add
+        # If value2 exists, we are adding two values and storing the result in target
+        if value2 != None:
+            # add X to Y giving Z
+            targetValue = ECValue(type=int, content=int(value1) + int(value2))
         else:
-#            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
+            # add X to Y
+            targetValue = self.getSymbolValue(target)
+            targetValue.setContent(int(targetValue.getContent()) + int(value1))
         self.putSymbolValue(target, targetValue)
         return self.nextPC()
 
-    # Append a value to an array
-    # append {value} to {array}
+    # Append a value to an list
+    # append {value} to {list}
     def k_append(self, command):
         command['value'] = self.nextValue()
         if self.nextIs('to'):
             if self.nextIsSymbol():
-                symbolRecord = self.getSymbolRecord()
-                if symbolRecord['hasValue']:
-                    command['target'] = symbolRecord['name']
-                    self.add(command)
-                    return True
-                self.warning(f'Core.append: Variable {symbolRecord["name"]} does not hold a value')
+                record = self.getSymbolRecord()
+                self.program.checkObjectType(self.getObject(record), ECList)
+                command['target'] = record['name']
+                self.add(command)
+                return True
         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)
+        value = self.textify(command['value'])
+        target = self.getObject(self.getVariable(command['target']))
+        target.append(value)
         return self.nextPC()
 
     #assert {condition} [with {message}]
@@ -145,7 +149,7 @@ class Core(Handler):
         test = self.program.condition.testCondition(command['test'])
         if test:
             return self.nextPC()
-        AssertionError(self.program, self.getRuntimeValue(command['with']))
+        RuntimeAssertionError(self.program, self.textify(command['with']))
 
     # Begin a block
     def k_begin(self, command):
@@ -162,23 +166,32 @@ class Core(Handler):
 
     # clear {variable}
     def k_clear(self, command):
-        if self.nextIsSymbol():
-            target = self.getSymbolRecord()
-            command['target'] = target['name']
-            if target['hasValue'] or target['keyword'] == 'ssh':
+        token = self.nextToken()
+        if token == 'breakpoint':
+            command['breakpoint'] = True
+            self.add(command)
+            return True
+        elif self.isSymbol():
+            record = self.getSymbolRecord()
+            command['target'] = record['name']
+            object = self.getObject(record)
+            if isinstance(object, ECSSH):
+                self.add(command)
+                return True
+            if isinstance(object, ECVariable):
                 self.add(command)
                 return True
         return False
 
     def r_clear(self, command):
-        target = self.getVariable(command['target'])
-        if target['keyword'] == 'ssh':
-            target['ssh'] = None
+        if 'breakpoint' in command:
+            self.program.breakpoint = False
         else:
-            val = {}
-            val['type'] = 'boolean'
-            val['content'] = False
-            self.putSymbolValue(target, val)
+            target = self.getVariable(command['target'])
+            if target['keyword'] == 'ssh':
+                target['ssh'] = None
+            else:
+                self.putSymbolValue(target, ECValue(type=bool, content=False))
         return self.nextPC()
 
     # Close a file
@@ -186,10 +199,10 @@ class Core(Handler):
     def k_close(self, command):
         if self.nextIsSymbol():
             fileRecord = self.getSymbolRecord()
-            if fileRecord['keyword'] == 'file':
-                command['file'] = fileRecord['name']
-                self.add(command)
-                return True
+            self.checkObjectType
+            command['file'] = fileRecord['name']
+            self.add(command)
+            return True
         return False
 
     def r_close(self, command):
@@ -197,7 +210,35 @@ class Core(Handler):
         fileRecord['file'].close()
         return self.nextPC()
 
-    #Create directory
+    # copy {variable} to {variable}
+    # copy {dictionary} to {dictionary}
+    # copy {list} to {list}
+    def k_copy(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            sourceObject = self.getObject(record)
+            if self.isObjectType(sourceObject, (ECVariable, ECDictionary, ECList)):
+                command['source'] = record['name']
+                self.skip('to')
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    targetObject = self.getObject(record)
+                    # Check that the types match
+                    if type(sourceObject) != type(targetObject):
+                        raise FatalError(self.compiler, 'Cannot copy - type mismatch')
+                    command['target'] = record['name']
+                    self.add(command)
+                    return True
+        return False
+
+    def r_copy(self, command):
+        sourceRecord = self.getVariable(command['source'])
+        targetRecord = self.getVariable(command['target'])
+        # Copy the value (type already checked at compile time)
+        self.putSymbolValue(targetRecord, self.textify(sourceRecord))
+        return self.nextPC()
+
+    # Create directory
     # create directory {name}
     def k_create(self, command):
         if self.nextIs('directory'):
@@ -209,7 +250,7 @@ class Core(Handler):
 
     def r_create(self, command):
         if command['item'] == 'directory':
-            path = self.getRuntimeValue(command['path'])
+            path = self.textify(command['path'])
             if not os.path.exists(path):
                 os.makedirs(path)
         return self.nextPC()
@@ -221,7 +262,7 @@ class Core(Handler):
             self.compiler.debugCompile = True
             self.nextToken()
             return True
-        elif token in ['step', 'stop', 'program', 'custom']:
+        elif token in ['step', 'stop', 'skip', 'breakpoint', 'program', 'custom']:
             command['mode'] = token
             self.nextToken()
         elif token == 'stack':
@@ -247,18 +288,22 @@ class Core(Handler):
             self.program.debugStep = True
         elif command['mode'] == 'stop':
             self.program.debugStep = False
+        elif command['mode'] == 'skip':
+            self.program.debugSkip = True
+        elif command['mode'] == 'breakpoint':
+            self.program.breakpoint = True
         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))
+            print(f'{self.textify(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)
+            value = self.textify(record)
             print('(Debug) Value:',value)
             pass
         return self.nextPC()
@@ -267,12 +312,11 @@ class Core(Handler):
     # decrement {variable}
     def k_decrement(self, command):
         if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['hasValue']:
-                command['target'] = self.getToken()
-                self.add(command)
-                return True
-            self.warning(f'Core.decrement: Variable {symbolRecord["name"]} does not hold a value')
+            record = self.getSymbolRecord()
+            self.checkObjectType(self.getObject(record), ECVariable)
+            command['target'] = record['name']
+            self.add(command)
+            return True
         return False
 
     def r_decrement(self, command):
@@ -280,8 +324,7 @@ class Core(Handler):
 
     # Delete a file or a property
     # delete file {filename}
-    # delete property {value} of {variable}
-    # delete element {name} of {variable}
+    # delete entry/item/property/element {name/number} of {variable}
     def k_delete(self, command):
         token = self.nextToken( )
         command['type'] = token
@@ -289,94 +332,119 @@ class Core(Handler):
             command['filename'] = self.nextValue()
             self.add(command)
             return True
-        elif token in ['property', 'element']:
+        elif token in ('entry', 'item', 'property', 'element'):
             command['key'] = self.nextValue()
             self.skip('of')
             if self.nextIsSymbol():
                 record = self.getSymbolRecord()
-                if record['hasValue']:
-                    command['var'] = record['name']
-                    self.add(command)
-                    return True
-                NoValueError(self.compiler, record)
+                command['variable'] = record['name']
+                if token == 'entry':
+                    self.checkObjectType(self.getObject(record), ECDictionary)
+                elif token == 'item':
+                    self.checkObjectType(self.getObject(record), ECList)
+                self.add(command)
+                return True
             self.warning(f'Core.delete: variable expected; got {self.getToken()}')
         else:
-            self.warning(f'Core.delete: "file", "property" or "element" expected; got {token}')
+            self.warning(f'Core.delete: "file", "entry", "item", "property" or "element" expected; got {token}')
         return False
 
     def r_delete(self, command):
         type = command['type']
         if type == 'file':
-            filename = self.getRuntimeValue(command['filename'])
+            filename = self.textify(command['filename'])
             if filename != None:
                 if os.path.isfile(filename): os.remove(filename)
+        elif type == 'entry':
+            key = self.textify(command['key'])
+            record = self.getVariable(command['variable'])
+            self.getObject(record).deleteEntry(key)
+        elif type == 'item':
+            key = self.textify(command['key'])
+            record = self.getVariable(command['variable'])
+            self.getObject(record).deleteItem(key)
         elif type == 'property':
-            key = self.getRuntimeValue(command['key'])
-            symbolRecord = self.getVariable(command['var'])
-            value = self.getSymbolValue(symbolRecord)
-            content = value['content']
+            raise NotImplementedError('Core.delete property not implemented yet')
+            key = self.textify(command['key'])
+            record = self.getVariable(command['var'])
+            value = self.getSymbolValue(record)
+            content = value.getContent()
             content.pop(key, None)
-            value['content'] = content
-            self.putSymbolValue(symbolRecord, value)
+            value.setContent(content)
+            self.putSymbolValue(record, value)
         elif type == 'element':
-            key = self.getRuntimeValue(command['key'])
-            symbolRecord = self.getVariable(command['var'])
-            value = self.getSymbolValue(symbolRecord)
-            content = value['content']
-            if key >= 0 and key < len(content): del(content[key])
+            key = self.textify(command['key'])
+            record = self.getVariable(command['variable'])
+            value = self.getSymbolValue(record)
+            content = value.getContent()
+            if isinstance(key, int):
+                if key >= 0 and key < len(content): del(content[key])
+            elif isinstance(key, str):
+                if key in content: content.remove(key)
             else: RuntimeError(self.program, f'Index {key} out of range')
-            value['content'] = content
-            self.putSymbolValue(symbolRecord, value)
+            value.setContent(content)
+            self.putSymbolValue(record, value)
+        return self.nextPC()
+
+    # Declare a dictionary variable
+    def k_dictionary(self, command):
+        self.compiler.addValueType()
+        return self.compileVariable(command, 'ECDictionary')
+
+    def r_dictionary(self, command):
         return self.nextPC()
 
-    # Arithmetic division
-    # divide {variable} by {value}[ giving {variable}]}
+
+    # Arithmetic divide
+    # divide {variable} by {value}
+    # divide {value1} by {value2} 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')
+        # Get the (first) item. If it's a symbol, it may be the target variable
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            self.checkObjectType(record, ECVariable)
+            # Hold onto the variable and its value
+            variable1 = record['name']
+            value1 = self.getValue()
+        else:
+            # Here we have a value
+            value1 = self.getValue()
+            variable1 = None
+        self.skip('by')
+        command['value2'] = self.nextValue()
+        # if 'giving' comes next, the target is the next value
+        if self.peek() == 'giving':
+            self.nextToken()
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                self.checkObjectType(record, ECVariable)
+                command['target'] = record['name']
+                command['value1'] = value1
+                self.add(command)
+                return True
+        else:
+            # Here the first variable is the target
+            if variable1 != None:
+                command['target'] = variable1
+                self.add(command)
+                return True
         return False
 
     def r_divide(self, command):
-        value1 = command['value1']
-        try:
-            value2 = command['value2']
-        except:
-            value2 = None
+        value1 = self.textify(command['value1']) if 'value1' in command else None
+        value2 = self.textify(command['value2'])
         target = self.getVariable(command['target'])
-        if not target['hasValue']:
-            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)
+        # Check that the target variable can hold a value
+        self.checkObjectType(target, ECVariable)
+        # If value1 exists, we are adding two values and storing the result in target
+        if value1 != None:
+            # divide X by Y giving Z
+            targetValue = ECValue(type=int, content=int(value1) // int(value2))
         else:
-            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)
+            # divide X by Y
+            targetValue = self.getSymbolValue(target)
+            targetValue.setContent(int(targetValue.getContent()) // int(value2))
+        self.putSymbolValue(target, targetValue)
         return self.nextPC()
 
     # download [binary] {url} to {path}
@@ -393,8 +461,8 @@ class Core(Handler):
     
     def r_download(self, command):
         binary = command['binary']
-        url = self.getRuntimeValue(command['url'])
-        path = self.getRuntimeValue(command['path'])
+        url = self.textify(command['url'])
+        path = self.textify(command['path'])
         mode = 'wb' if binary else 'w'
         response = requests.get(url, stream=True)
         with open(path, mode) as f:
@@ -402,14 +470,6 @@ class Core(Handler):
                 if chunk: f.write(chunk)
         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)
@@ -430,15 +490,16 @@ class Core(Handler):
 
     # Declare a file variable
     def k_file(self, command):
-        return self.compileVariable(command)
+        self.compiler.addValueType()
+        return self.compileVariable(command, 'ECFile')
 
     def r_file(self, command):
         return self.nextPC()
 
     # Fork to a label
+    # fork [to] {label}
     def k_fork(self, command):
-        if self.peek() == 'to':
-            self.nextToken()
+        self.skip('to')  # Optional 'to' (core-reserved keyword, plugin-safe)
         command['fork'] = self.nextToken()
         self.add(command)
         return True
@@ -457,11 +518,11 @@ class Core(Handler):
     # get {variable) from {url} [or {command}]
     def k_get(self, command):
         if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['hasValue']:
+            record = self.getSymbolRecord()
+            if isinstance(self.getObject(record), ECObject):
                 command['target'] = self.getToken()
             else:
-                NoValueError(self.compiler, symbolRecord)
+                NoValueError(self.compiler, record)
         if self.nextIs('from'):
             if self.nextIs('url'):
                 url = self.nextValue()
@@ -473,9 +534,7 @@ class Core(Handler):
                         self.nextToken()
                         command['timeout'] = self.nextValue()
                     else:
-                        timeout = {}
-                        timeout['type'] = 'int'
-                        timeout['content'] = 5
+                        timeout = ECValue(type = int, content = 5)
                         command['timeout'] = timeout
                     self.processOr(command, get)
                     return True
@@ -483,14 +542,12 @@ class Core(Handler):
 
     def r_get(self, command):
         global errorCode, errorReason
-        retval = {}
-        retval['type'] = 'text'
-        retval['numeric'] = False
-        url = self.getRuntimeValue(command['url'])
+        retval = ECValue(type=str)
+        url = self.textify(command['url'])
         target = self.getVariable(command['target'])
-        response = json.loads('{}')
+        response = {}
         try:
-            timeout = self.getRuntimeValue(command['timeout'])
+            timeout = self.textify(command['timeout'])
             response = requests.get(url, auth = ('user', 'pass'), timeout=timeout)
             if response.status_code >= 400:
                 errorCode = response.status_code
@@ -505,15 +562,15 @@ class Core(Handler):
                 return command['or']
             else:
                 RuntimeError(self.program, f'Error: {errorReason}')
-        retval['content'] = response.text
+        retval.setContent(response.text) # type: ignore
         self.program.putSymbolValue(target, retval)
         return self.nextPC()
 
     # Go to a label
+    # go [to] {label}
     def k_go(self, command):
-        if self.peek() == 'to':
-            self.nextToken()
-            return self.k_goto(command)
+        self.skip('to')  # Optional 'to' (core-reserved keyword, plugin-safe)
+        return self.k_goto(command)
 
     def k_goto(self, command):
         command['keyword'] = 'goto'
@@ -535,9 +592,9 @@ class Core(Handler):
         return command['goto']
 
     # Call a subroutine
+    # gosub [to] {label}
     def k_gosub(self, command):
-        if self.peek() == 'to':
-            self.nextToken()
+        self.skip('to')  # Optional 'to' (core-reserved keyword, plugin-safe)
         command['gosub'] = self.nextToken()
         self.add(command)
         return True
@@ -599,55 +656,51 @@ class Core(Handler):
 
     # Import one or more variables
     def k_import(self, command):
+        self.add(command)
         imports = []
         while True:
-            keyword = self.nextToken()
-            name = self.nextToken()
-            item = [keyword, name]
-            imports.append(item)
-            self.symbols[name] = self.getCodeSize()
-            variable = {}
-            variable['domain'] = None
-            variable['name'] = name
-            variable['keyword'] = keyword
-            variable['import'] = None
-            variable['used'] = False
-            variable['hasValue'] = True if keyword == 'variable' else False
-            self.add(variable)
+            vartype = self.nextToken()
+            for domain in self.program.getDomains():
+                handler = domain.keywordHandler(vartype)
+                if handler != None:
+                    variable = {}
+                    if not handler(variable):
+                        raise RuntimeError(self.program, f'Failed to handle variable type "{vartype}"')
+                    imports.append(variable)
             if self.peek() != 'and':
                 break
             self.nextToken()
-        command['imports'] = json.dumps(imports)
-        self.add(command)
+        command['imports'] = imports
         return True
 
     def r_import(self, command):
         exports = self.program.exports
-        imports = json.loads(command['imports'])
+        imports = 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
+            importRecord = imports[n]
+            if importRecord['classname'] != exportRecord['classname']:
+                raise RuntimeError(self.program, f'Import {n} does not match export (wrong type)')
+            name = importRecord['name']
+            importRecord.clear()
+            importRecord['name'] = name
+            importRecord['domain'] = exportRecord['domain']
+            importRecord['keyword'] = exportRecord['keyword']
+            importRecord['import'] = exportRecord
         return self.nextPC()
 
     # Increment a variable
     def k_increment(self, command):
         if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['hasValue']:
-                command['target'] = self.getToken()
-                self.add(command)
-                return True
-            self.warning(f'Core.increment: Variable {symbolRecord["name"]} does not hold a value')
+            record = self.getSymbolRecord()
+            self.checkObjectType(self.getObject(record), ECVariable)
+            command['target'] = record['name']
+            self.add(command)
+            return True
         return False
 
     def r_increment(self, command):
@@ -667,43 +720,18 @@ class Core(Handler):
         return False
 
     def r_index(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        symbolRecord['index'] = self.getRuntimeValue(command['value'])
+        value = self.textify(command['value'])
+        record = self.getVariable(command['target'])
+        self.getObject(record).setIndex(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 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'] = ': '
+            value = ECValue(type=str, content=': ')
             command['prompt'] = value
             if self.peek() == 'with':
                 self.nextToken()
@@ -713,13 +741,18 @@ class Core(Handler):
         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)
+        record = self.getVariable(command['target'])
+        prompt = command['prompt'].getValue()
+        value = ECValue(type=str, content=prompt+input(prompt))
+        self.putSymbolValue(record, value)
+        return self.nextPC()
+
+    # Declare a list variable
+    def k_list(self, command):
+        self.compiler.addValueType()
+        return self.compileVariable(command, 'ECList')
+
+    def r_list(self, command):
         return self.nextPC()
 
     # 1 Load a plugin. This is done at compile time.
@@ -733,9 +766,9 @@ class Core(Handler):
                 self.program.importPlugin(f'{source}:{clazz}')
                 return True
         elif self.isSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['hasValue']:
-                command['target'] = symbolRecord['name']
+            record = self.getSymbolRecord()
+            if isinstance(self.getObject(record), (ECVariable, ECDictionary, ECList)):
+                command['target'] = record['name']
                 if self.nextIs('from'):
                     if self.nextIsSymbol():
                         record = self.getSymbolRecord()
@@ -759,7 +792,7 @@ class Core(Handler):
         target = self.getVariable(command['target'])
         if 'ssh' in command:
             ssh = self.getVariable(command['ssh'])
-            path = self.getRuntimeValue(command['path'])
+            path = self.textify(command['path'])
             sftp = ssh['sftp']
             try:
                 with sftp.open(path, 'r') as remote_file: content = remote_file.read().decode()
@@ -771,13 +804,9 @@ class Core(Handler):
                 else:
                     RuntimeError(self.program, f'Error: {errorReason}')
         else:
-            filename = self.getRuntimeValue(command['file'])
+            filename = self.textify(command['file'])
             try:
                 with open(filename) as f: content = f.read()
-                try:
-                    if filename.endswith('.json'): content = json.loads(content)
-                except:
-                    errorReason = 'Bad or null JSON string'
             except:
                 errorReason = f'Unable to read from {filename}'
 
@@ -787,17 +816,20 @@ class Core(Handler):
                 return command['or']
             else:
                 RuntimeError(self.program, f'Error: {errorReason}')
-        value = {}
-        value['type'] = 'text'
-        value['content'] = content
-        self.putSymbolValue(target, value)
+
+        value = ECValue(type=str, content=content)
+        try:
+            self.putSymbolValue(target, value)
+        except Exception as e:
+            print(f'Exception "{e}": Running the "or" clause')
+            return command['or']
         return self.nextPC()
 
     # Lock a variable
     def k_lock(self, command):
         if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            command['target'] = symbolRecord['name']
+            record = self.getSymbolRecord()
+            command['target'] = record['name']
             self.add(command)
             return True
         return False
@@ -815,88 +847,91 @@ class Core(Handler):
 
     # Declare a module variable
     def k_module(self, command):
-        return self.compileVariable(command)
+        self.compiler.addValueType()
+        return self.compileVariable(command, 'ECModule')
 
     def r_module(self, command):
         return self.nextPC()
 
     # Arithmetic multiply
-    # multiply {variable} by {value}[ giving {variable}]}
+    # multiply {variable} by {value}
+    # multiply {value1} by {value2} 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')
+        # Get the (first) item. If it's a symbol, it may be the target variable
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            self.checkObjectType(record, ECVariable)
+            # Hold onto the variable and its value
+            variable1 = record['name']
+            value1 = self.getValue()
+        else:
+            # Here we have a value
+            value1 = self.getValue()
+            variable1 = None
+        self.skip('by')
+        command['value2'] = self.nextValue()
+        # if 'giving' comes next, the target is the next value
+        if self.peek() == 'giving':
+            self.nextToken()
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                self.checkObjectType(record, ECVariable)
+                command['target'] = record['name']
+                command['value1'] = value1
+                self.add(command)
+                return True
+        else:
+            # Here the first variable is the target
+            if variable1 != None:
+                command['target'] = variable1
+                self.add(command)
+                return True
         return False
 
     def r_multiply(self, command):
-        value1 = command['value1']
-        try:
-            value2 = command['value2']
-        except:
-            value2 = None
+        value1 = self.textify(command['value1']) if 'value1' in command else None
+        value2 = self.textify(command['value2'])
         target = self.getVariable(command['target'])
-        if not target['hasValue']:
-            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
+        # Check that the target variable can hold a value
+        self.checkObjectType(target, ECVariable)
+        # If value1 exists, we are adding two values and storing the result in target
+        if value1 != None:
+            # multiply X by Y giving Z
+            targetValue = ECValue(type=int, content=int(value1) * int(value2))
         else:
-            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)
+            # multiply X by Y
+            targetValue = self.getSymbolValue(target)
+            targetValue.setContent(int(targetValue.getContent()) * int(value2))
+        self.putSymbolValue(target, targetValue)
         return self.nextPC()
 
     # Negate a variable
     def k_negate(self, command):
         if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['hasValue']:
+            record = self.getSymbolRecord()
+            if record['hasValue']:
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'Core.negate: Variable {symbolRecord["name"]} does not hold a value')
+            self.warning(f'Core.negate: Variable {record["name"]} does not hold a value')
         return False
 
     def r_negate(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['hasValue']:
-            NoValueRuntimeError(self.program, symbolRecord)
+        record = self.getVariable(command['target'])
+        if not record['hasValue']:
+            NoValueRuntimeError(self.program, record)
             return None
-        value = self.getSymbolValue(symbolRecord)
+        value = self.getSymbolValue(record)
         if value == None:
-            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
-        value['content'] *= -1
-        self.putSymbolValue(symbolRecord, value)
+            RuntimeError(self.program, f'{record["name"]} has not been initialised')
+        value.setContent(value.getContent() * -1)
+        self.putSymbolValue(record, value)
         return self.nextPC()
 
     # on message {action}
     def k_on(self, command):
-        if self.nextIs('message'):
+        token = self.peek()
+        if token == 'message':
             self.nextToken()
             command['goto'] = 0
             self.add(command)
@@ -928,10 +963,10 @@ class Core(Handler):
     # open {file} for reading/writing/appending
     def k_open(self, command):
         if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            command['target'] = symbolRecord['name']
+            record = self.getSymbolRecord()
+            command['target'] = record['name']
             command['path'] = self.nextValue()
-            if symbolRecord['keyword'] == 'file':
+            if record['keyword'] == 'file':
                 if self.peek() == 'for':
                     self.nextToken()
                     token = self.nextToken()
@@ -956,39 +991,43 @@ class Core(Handler):
         return False
 
     def r_open(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        path = self.getRuntimeValue(command['path'])
+        record = self.getVariable(command['target'])
+        path = self.textify(command['path'])
         if command['mode'] == 'r' and os.path.exists(path) or command['mode'] != 'r':
-            symbolRecord['file'] = open(path, command['mode'])
+            record['file'] = open(path, command['mode'])
             return self.nextPC()
         RuntimeError(self.program, f"File {path} does not exist")
 
+    # Dummy command to hit a debugger breakpoint
+    def k_pass(self, command):
+        self.add(command)
+        return True
+
+    def r_pass(self, command):
+        return self.nextPC()
+
     # 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']
+            record = self.getSymbolRecord()
+            self.checkObjectType(record, ECObject)
+            command['target'] = record['name']
             if self.peek() == 'from':
                 self.nextToken()
                 if self.nextIsSymbol():
-                    command['from'] = self.getToken()
+                    record = self.getSymbolRecord()
+                    self.checkObjectType(record, ECStack)
+                    command['from'] = record['name']
                     self.add(command)
                     return True
         return False
 
     def r_pop(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['hasValue']:
-            NoValueRuntimeError(self.program, symbolRecord)
+        record = self.getVariable(command['target'])
         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)
+        value = stackRecord['object'].pop()
+        self.putSymbolValue(record, value)
         return self.nextPC()
 
     # Perform an HTTP POST
@@ -1013,14 +1052,12 @@ class Core(Handler):
 
     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'])
+        retval = ECValue(type=str, content = '')
+        value = self.textify(command['value'])
+        url = self.textify(command['url'])
         try:
             response = requests.post(url, value, timeout=5)
-            retval['content'] = response.text
+            retval.setContent(response.text) # type: ignore
             if response.status_code >= 400:
                 errorCode = response.status_code
                 errorReason = response.reason
@@ -1052,7 +1089,7 @@ class Core(Handler):
         return False
 
     def r_print(self, command):
-        value = self.getRuntimeValue(command['value'])
+        value = self.textify(command['value'])
         program = command['program']
         code = program.code[program.pc]
         lino = str(code['lino'] + 1)
@@ -1073,38 +1110,32 @@ class Core(Handler):
         if peekValue in ['onto', 'to']:
             self.nextToken()
             if self.nextIsSymbol():
-                symbolRecord = self.getSymbolRecord()
-                command['to'] = symbolRecord['name']
+                record = self.getSymbolRecord()
+                command['to'] = record['name']
                 self.add(command)
                 return True
         return False
 
     def r_push(self, command):
-        value = deepcopy(self.getRuntimeValue(command['value']))
+        value = deepcopy(self.evaluate(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)
+        stackRecord['object'].push(value)
         return self.nextPC()
 
-    # put {value} into {variable}
+    # put {value} into {variable/dictionary/list}
     def k_put(self, command):
         value = self.nextValue()
         if value != None:
             command['value'] = value
+            valueType = value.getType()
             if self.nextIs('into'):
                 if self.nextIsSymbol():
-                    symbolRecord = self.getSymbolRecord()
-                    command['target'] = symbolRecord['name']
-                    if 'hasValue' in symbolRecord and symbolRecord['hasValue'] == False:
-                        FatalError(self.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
-                    else:
+                    record = self.getSymbolRecord()
+                    command['target'] = record['name']
+                    object = self.getObject(record)
+                    self.checkObjectType(object, (ECVariable, ECDictionary, ECList))
+                    if (isinstance(object, ECVariable) and not valueType in ('dict', 'list', 'json') or
+                        isinstance(object, (ECDictionary, ECList))):
                         command['or'] = None
                         self.processOr(command, self.getCodeSize())
                         return True
@@ -1114,16 +1145,8 @@ class Core(Handler):
 
     def r_put(self, command):
         value = self.evaluate(command['value'])
-        if value == None:
-            if command['or'] != None:
-                return command['or']
-            else:
-                RuntimeError(self.program, f'Error: could not compute value')
-        symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['hasValue']:
-            NoValueRuntimeError(self.program, symbolRecord)
-            return -1
-        self.putSymbolValue(symbolRecord, value)
+        record = self.getVariable(command['target'])
+        self.putSymbolValue(record, value)
         return self.nextPC()
 
     # Read from a file
@@ -1135,41 +1158,38 @@ class Core(Handler):
         else:
             command['line'] = False
         if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['hasValue']:
-                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')
+            record = self.getSymbolRecord()
+            self.checkObjectType(self.getObject(record), ECVariable)
+            if self.peek() == 'from':
+                self.nextToken()
+                if self.nextIsSymbol():
+                    fileRecord = self.getSymbolRecord()
+                    self.checkObjectType(fileRecord['object'], ECFile)
+                    command['target'] = record['name']
+                    command['file'] = fileRecord['name']
+                    self.add(command)
+                    return True
             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'])
+        record = 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)
+            value = ECValue(type=str, content=content)
+            self.putSymbolValue(record, value)
         return self.nextPC()
 
     # Release the parent script
     def k_release(self, command):
         if self.nextIs('parent'):
             self.add(command)
-        return True
+            return True
+        return False
 
     def r_release(self, command):
         self.program.releaseParent()
@@ -1194,23 +1214,35 @@ class Core(Handler):
 
     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 = self.getSymbolValue(templateRecord).getContent()
+        original = self.textify(command['original'])
+        replacement = self.textify(command['replacement'])
         content = content.replace(original, str(replacement))
-        value = {}
-        value['type'] = 'text'
-        value['numeric'] = False
-        value['content'] = content
+        value = ECValue(type=str, content=content)
         self.putSymbolValue(templateRecord, value)
         return self.nextPC()
 
+    # Reset a variable
+    def k_reset(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            command['target'] = record['name']
+            self.add(command)
+            return True
+        return False
+
+    def r_reset(self, command):
+        record = self.getVariable(command['target'])
+        self.getObject(record).reset()
+        return self.nextPC()
+
     # Return from subroutine
     def k_return(self, command):
         self.add(command)
         return True
 
     def r_return(self, command):
+        self.program.debugSkip = False
         return self.stack.pop()
 
     # Compile and run a script
@@ -1246,15 +1278,15 @@ class Core(Handler):
 
     def r_run(self, command):
         module = self.getVariable(command['module'])
-        path = self.getRuntimeValue(command['path'])
+        path = self.textify(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
+        parent = ECValue()
+        parent.program = self.program # type: ignore
+        parent.pc = self.nextPC() # type: ignore
+        parent.waiting = True # type: ignore
         p = self.program.__class__
         p(path).start(parent, module, exports)
         return 0
@@ -1268,7 +1300,6 @@ class Core(Handler):
             if record['keyword'] == 'ssh':
                 command['ssh'] = record['name']
                 command['path'] = self.nextValue()
-                self.add(command)
             else:
                 command['file'] = self.getValue()
         else:
@@ -1280,10 +1311,10 @@ class Core(Handler):
 
     def r_save(self, command):
         errorReason = None
-        content = self.getRuntimeValue(command['content'])
+        content = self.textify(command['content'])
         if 'ssh' in command:
             ssh = self.getVariable(command['ssh'])
-            path = self.getRuntimeValue(command['path'])
+            path = self.textify(command['path'])
             sftp = ssh['sftp']
             if path.endswith('.json'): content = json.dumps(content)
             try:
@@ -1296,12 +1327,17 @@ class Core(Handler):
                 else:
                     RuntimeError(self.program, f'Error: {errorReason}')
         else:
-            filename = self.getRuntimeValue(command['file'])
-            if filename.endswith('.json'): content = json.dumps(content)
+            filename = self.textify(command['file'])
             try:
+                if content == None:
+                    content = ''
+                elif isinstance(content, dict) or isinstance(content, list):
+                    content = json.dumps(content)
+                elif not isinstance(content, str):
+                    content = self.textify(content)
                 with open(filename, 'w') as f: f.write(content)
-            except:
-                errorReason = f'Unable to write to {filename}'
+            except Exception as e:
+                errorReason = f'Unable to write to {filename}: {str(e)}'
 
         if errorReason:
             if command['or'] != None:
@@ -1322,32 +1358,30 @@ class Core(Handler):
         if self.nextIs('to'):
             if self.nextIsSymbol():
                 record = self.getSymbolRecord()
-                if record['keyword'] == 'module':
+                if self.isObjectType(record, ECModule):
                     command['module'] = record['name']
                     self.add(command)
                     return True
         return False
 
     def r_send(self, command):
-        message = self.getRuntimeValue(command['message'])
+        message = self.textify(command['message'])
         module = self.getVariable(command['module'])
         module['child'].handleMessage(message)
         return self.nextPC()
 
     # Set a value
     # set {variable}
+    # set {variable} to {value}
     # set {ssh} host {host} user {user} password {password}
-    # set the elements of {variable} to {value}
-    # set element/property of {variable} to {value}
+    # set the items/elements in/of {variable} to {value}
+    # set item/entry/property of {variable} to {value}
+    # set breakpoint
     def k_set(self, command):
         if self.nextIsSymbol():
             record = self.getSymbolRecord()
             command['target'] = record['name']
-            if record['hasValue']:
-                command['type'] = 'set'
-                self.add(command)
-                return True
-            elif record['keyword'] == 'ssh':
+            if record['keyword'] == 'ssh':
                 host = None
                 user = None
                 password = None
@@ -1369,7 +1403,18 @@ class Core(Handler):
                 command['type'] = 'ssh'
                 self.add(command)
                 return True
-
+            elif isinstance(self.getObject(record), ECVariable):
+                self.skip('to')
+                mark = self.compiler.getIndex()
+                value = self.nextValue()
+                if value != None:
+                    command['type'] = 'setValue'
+                    command['value'] = value
+                else:
+                    self.rewindTo(mark)
+                    command['type'] = 'set'
+                self.add(command)
+                return True
             return False
 
         token = self.getToken()
@@ -1379,7 +1424,7 @@ class Core(Handler):
 
         if token == 'elements':
             self.nextToken()
-            if self.peek() == 'of':
+            if self.peek() in ('in', 'of'):
                 self.nextToken()
             if self.nextIsSymbol():
                 command['name'] = self.getToken()
@@ -1395,11 +1440,14 @@ class Core(Handler):
                 self.add(command)
                 return True
 
-        elif token == 'property':
-            command['name'] = self.nextValue()
+        elif token in ('entry', 'property'):
+            command['key'] = self.nextValue()
             if self.nextIs('of'):
                 if self.nextIsSymbol():
-                    command['target'] = self.getSymbolRecord()['name']
+                    record = self.getSymbolRecord()
+                    if token == 'entry':
+                        self.checkObjectType(self.getObject(record), ECDictionary)
+                    command['target'] = record['name']
                     if self.nextIs('to'):
                         value = self.nextValue()
                         if value == None:
@@ -1408,7 +1456,7 @@ class Core(Handler):
                         self.add(command)
                         return True
 
-        elif token == 'element':
+        elif token == 'item':
             command['index'] = self.nextValue()
             if self.nextIs('of'):
                 if self.nextIsSymbol():
@@ -1422,6 +1470,11 @@ class Core(Handler):
             command['path'] = self.nextValue()
             self.add(command)
             return True
+        
+        elif token == 'breakpoint':
+            command['breakpoint'] = True
+            self.add(command)
+            return True
 
         return False
 
@@ -1429,81 +1482,70 @@ class Core(Handler):
         cmdType = command['type']
         if cmdType == 'set':
             target = self.getVariable(command['target'])
-            val = {}
-            val['type'] = 'boolean'
-            val['content'] = True
-            self.putSymbolValue(target, val)
+            self.putSymbolValue(target, ECValue(type=bool, content=True))
+            return self.nextPC()
+        
+        elif cmdType == 'setValue':
+            value = self.evaluate(command['value'])
+            target = self.getVariable(command['target'])
+            self.putSymbolValue(target, value)
             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
-            symbolRecord['index'] = 0
+            record = self.getVariable(command['name'])
+            elements = self.textify(command['elements'])
+            object = self.getObject(record)
+            self.checkObjectType(object, ECObject)
+            object.setElements(elements)
             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)
+        elif cmdType == 'item':
+            index = self.textify(command['index'])
+            value = self.textify(command['value'])
+            record = self.getVariable(command['target'])
+            self.checkObjectType(self.getObject(record), ECList)
+            variable = self.getObject(record)
+            variable.setItem(index, value)
             return self.nextPC()
 
         elif cmdType == 'encoding':
-            self.encoding = self.getRuntimeValue(command['encoding'])
+            self.encoding = self.textify(command['encoding'])
             return self.nextPC()
 
         elif cmdType == 'path':
-            path = self.getRuntimeValue(command['path'])
+            path = self.textify(command['path'])
             os.chdir(path)
             return self.nextPC()
 
+        elif cmdType == 'entry':
+            key = self.textify(command['key'])
+            value = self.textify(command['value'])
+            record = self.getVariable(command['target'])
+            self.checkObjectType(self.getObject(record), ECDictionary)
+            variable = self.getObject(record)
+            variable.setEntry(key, value)
+            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)
+            key = self.textify(command['key'])
+            value = self.evaluate(command['value'])
+            record = self.getVariable(command['target'])
+            variable = self.getObject(record)
+            variable.setProperty(key, value)
+            content = variable.getContent()
+            if content == None: content = {}
+            elif not isinstance(content, dict): 
+                raise RuntimeError(self.program, f'{record["name"]} is not a dictionary')
+            if isinstance(value, dict): content[key] = value
+            else: content[key] = self.textify(value)
+            variable.setContent(ECValue(type='dict', content=content))
             return self.nextPC()
         
         elif cmdType == 'ssh':
             target = self.getVariable(command['target'])
-            host = self.getRuntimeValue(command['host'])
-            user = self.getRuntimeValue(command['user'])
-            password = self.getRuntimeValue(command['password'])
+            host = self.textify(command['host'])
+            user = self.textify(command['user'])
+            password = self.textify(command['password'])
             ssh = paramiko.SSHClient()
             target['ssh'] = ssh
             ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
@@ -1513,50 +1555,51 @@ class Core(Handler):
             except:
                 target['error'] = f'Unable to connect to {host} (timeout)'
             return self.nextPC()
+        
+        elif cmdType == 'breakpoint':
+            self.program.breakpoint = True
+            return self.nextPC()
 
-    # Shuffle a list
+    # Shuffle a JSON list
     def k_shuffle(self, command):
         if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['hasValue']:
+            record = self.getSymbolRecord()
+            if record['hasValue']:
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'Core.negate: Variable {symbolRecord["name"]} does not hold a value')
+            self.warning(f'Core.negate: Variable {record["name"]} does not hold a value')
         return False
 
     def r_shuffle(self, command):
-        symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['hasValue']:
-            NoValueRuntimeError(self.program, symbolRecord)
+        record = self.getVariable(command['target'])
+        if not record['hasValue']:
+            NoValueRuntimeError(self.program, record)
             return None
-        value = self.getSymbolValue(symbolRecord)
+        value = self.getSymbolValue(record)
         if value == None:
-            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
-        content = value['content']
+            RuntimeError(self.program, f'{record["name"]} has not been initialised')
+        content = value.getContent()
         if isinstance(content, list):
             random.shuffle(content)
-            value['content'] = content
-            self.putSymbolValue(symbolRecord, value)
+            value.setContent(content)
+            self.putSymbolValue(record, value)
             return self.nextPC()
-        RuntimeError(self.program, f'{symbolRecord["name"]} is not a list')
+        RuntimeError(self.program, f'{record["name"]} is not a list')
 
     # Split a string into a variable with several elements
     # split {variable} on {value}
     def k_split(self, command):
         if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['hasValue']:
-                command['target'] = symbolRecord['name']
-                value = {}
-                value['type'] = 'text'
-                value['numeric'] = 'false'
-                value['content'] = '\n'
+            record = self.getSymbolRecord()
+            if isinstance(record['object'], ECObject):
+                command['target'] = record['name']
+                value = ECValue(type=str, content='\n')
                 command['on'] = value
                 if self.peek() == 'on':
                     self.nextToken()
                     if self.peek() == 'tab':
-                        value['content'] = '\t'
+                        value.setContent('\t')
                         self.nextToken()
                     else:
                         command['on'] = self.nextValue()
@@ -1568,30 +1611,31 @@ class Core(Handler):
     def r_split(self, command):
         target = self.getVariable(command['target'])
         value = self.getSymbolValue(target)
-        content = value['content'].split(self.getRuntimeValue(command['on']))
+        content = value.getContent().split(self.textify(command['on']))
         elements = len(content)
-        target['elements'] = elements
-        target['index'] = 0
-        target['value'] = [None] * elements
-
-        for index, item in enumerate(content):
-            element = {}
-            element['type'] = 'text'
-            element['numeric'] = 'false'
-            element['content'] = item
-            target['value'][index] = element
+        object = target['object']
+        object.setElements(elements)
+        
+        for n in range(0, elements):
+            val = ECValue(type=str, content=content[n])
+            object.setIndex(n)
+            object.setValue(val)
+        object.setIndex(0)
 
         return self.nextPC()
 
+    # Declare an SSH connection variable
     def k_ssh(self, command):
-        return self.compileVariable(command)
+        self.compiler.addValueType()
+        return self.compileVariable(command, 'ECSSH')
 
     def r_ssh(self, command):
         return self.nextPC()
 
     # Declare a stack variable
     def k_stack(self, command):
-        return self.compileVariable(command)
+        self.compiler.addValueType()
+        return self.compileVariable(command, 'ECStack')
 
     def r_stack(self, command):
         return self.nextPC()
@@ -1622,7 +1666,7 @@ class Core(Handler):
         return False
 
     def r_system(self, command):
-        value = self.getRuntimeValue(command['value'])
+        value = self.textify(command['value'])
         if value != None:
             if command['background']:
                 subprocess.Popen(["sh",value,"&"])
@@ -1631,82 +1675,77 @@ class Core(Handler):
             return self.nextPC()
 
     # Arithmetic subtraction
-    # take {value} from {variable}[ giving {variable}]}
+    # take {value} from {variable}
+    # take {value1} from {value2} 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['hasValue']:
-                    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')
+        self.skip('from')
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            self.checkObjectType(record, ECObject)
+            # If 'giving' comes next, this variable is the second value
+            if self.peek() == 'giving':
+                v2 = ECValue(type='symbol')
+                v2.setContent(record['name'])
+                command['value2'] = v2
+                self.nextToken()
+                # Now get the target variable
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    self.checkObjectType(record, ECVariable)
+                    command['target'] = record['name']
+                self.add(command)
+                return True
             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"')
+                # Here the variable is the target
+                command['target'] = record['name']
+                self.add(command)
+                return True
+        else:
+            # Here we have 2 values so 'giving' must come next
+            command['value2'] = self.getValue()
+            if self.nextToken() == 'giving':
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    self.checkObjectType(record, ECVariable)
+                    command['target'] = record['name']
+                self.add(command)
+                return True
+            raise FatalError(self.compiler, 'Cannot subtract values: target variable expected')
         return False
 
     def r_take(self, command):
-        value1 = command['value1']
-        try:
-            value2 = command['value2']
-        except:
-            value2 = None
+        value1 = self.textify(command['value1'])
+        value2 = self.textify(command['value2']) if 'value2' in command else None
         target = self.getVariable(command['target'])
-        if not target['hasValue']:
-            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
+        # Check that the target variable can hold a value
+        self.checkObjectType(target, ECVariable)
+        # If value2 exists, we are adding two values and storing the result in target
+        if value2 != None:
+            # take X from Y giving Z
+            targetValue = ECValue(type=int, content=int(value2) - int(value1))
         else:
-            v = int(self.getRuntimeValue(value))
-            v1 = int(self.getRuntimeValue(value1))
-            value['content'] = v-v1
-        self.putSymbolValue(target, value)
+            # take X from Y
+            targetValue = self.getSymbolValue(target)
+            targetValue.setContent(int(targetValue.getContent()) - int(value1))
+        self.putSymbolValue(target, targetValue)
         return self.nextPC()
 
     # Toggle a boolean value
     def k_toggle(self, command):
         if self.nextIsSymbol():
             target = self.getSymbolRecord()
-            if target['hasValue']:
-                command['target'] = target['name']
-                self.add(command)
-                return True
+            self.checkObjectType(target, ECVariable)
+            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']
+        val = ECValue(type=bool, content=not value.getContent())
         self.putSymbolValue(target, val)
         self.add(command)
         return self.nextPC()
@@ -1724,9 +1763,9 @@ class Core(Handler):
     def r_trim(self, command):
         record = self.getVariable(command['name'])
         value = record['value'][record['index']]
-        if value['type'] == 'text':
-            content = value['content']
-            value['content'] = content.strip()
+        if value.getType() == str:
+            content = value.getContent()
+            value.setContent(content.strip())
         return self.nextPC()
 
     # Truncate a file
@@ -1747,8 +1786,8 @@ class Core(Handler):
     # Unlock a variable
     def k_unlock(self, command):
         if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            command['target'] = symbolRecord['name']
+            record = self.getSymbolRecord()
+            command['target'] = record['name']
             self.add(command)
             return True
         return False
@@ -1758,7 +1797,10 @@ class Core(Handler):
         target['locked'] = False
         return self.nextPC()
 
-    # Use a plugin module
+    # use plugin {class} from {source}
+    # use graphics
+    # use mqtt
+    # use psutil
     def k_use(self, command):
         if self.peek() == 'plugin':
             # Import a plugin
@@ -1771,21 +1813,22 @@ class Core(Handler):
             return False
         else:
             token = self.nextToken()
-            if token in ['graphics', 'debugger']:
-                if not self.program.usingGraphics:
-                    print('Loading graphics module')
-                    from .ec_pyside import Graphics
-                    self.program.graphics = Graphics
-                    self.program.useClass(Graphics)
-                    self.program.usingGraphics = True
-                if token == 'debugger': self.program.debugging = True
-                return True
+            if token == 'graphics':
+                return self.program.useGraphics()
+            elif token == 'mqtt':
+                return self.program.useMQTT()
+            elif token == 'psutil':
+                return self.program.usePSUtil()
         return False
+    
+    # Unused
+    def r_use(self, command):
+        return self.nextPC()
 
     # Declare a general-purpose variable
     def k_variable(self, command):
         self.compiler.addValueType()
-        return self.compileVariable(command)
+        return self.compileVariable(command, 'ECVariable')
 
     def r_variable(self, command):
         return self.nextPC()
@@ -1811,7 +1854,7 @@ class Core(Handler):
         return True
 
     def r_wait(self, command):
-        value = self.getRuntimeValue(command['value']) * command['multiplier']
+        value = self.textify(command['value']) * command['multiplier']
         next = self.nextPC()
         threading.Timer(value/1000.0, lambda: (self.run(next))).start()
         return 0
@@ -1877,7 +1920,7 @@ class Core(Handler):
         return False
 
     def r_write(self, command):
-        value = self.getRuntimeValue(command['value'])
+        value = self.textify(command['value'])
         fileRecord = self.getVariable(command['file'])
         file = fileRecord['file']
         if file.mode in ['w', 'w+', 'a', 'a+']:
@@ -1890,158 +1933,147 @@ class Core(Handler):
     # Support functions
 
     def incdec(self, command, mode):
-        symbolRecord = self.getVariable(command['target'])
-        if not symbolRecord['hasValue']:
-            NoValueRuntimeError(self.program, symbolRecord)
-        value = self.getSymbolValue(symbolRecord)
-        if value == None:
-            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
-        if mode == '+':
-            value['content'] += 1
-        else:
-            value['content'] -= 1
-        self.putSymbolValue(symbolRecord, value)
+        record = self.getVariable(command['target'])
+        self.checkObjectType(record['object'], ECVariable)
+        value = self.getSymbolValue(record)
+        content = value.getContent()
+        if not isinstance(content, int):
+            RuntimeError(self.program, f'Variable {record["name"]} does not hold an integer')
+        if mode == '+': value.setContent(content + 1)
+        else: value.setContent(content - 1)
+        self.putSymbolValue(record, value)
         return self.nextPC()
 
     #############################################################################
     # Compile a value in this domain
     def compileValue(self):
-        value = {}
-        value['domain'] = self.getName()
+        value = ECValue()
         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 in ['ssh', 'variable']:
-                value['type'] = 'symbol'
-                return value
-
-            return None
+            value.setValue(type='symbol', content=token)
+            return value
 
-        value['type'] = token
+        value.setType(token)
 
         if token == 'arg':
             self.nextToken()
-            value['index'] = self.getValue()
+            value.index = self.getValue()
             return value
 
         if token in ['cos', 'sin', 'tan']:
-            value['angle'] = self.nextValue()
+            value.angle = self.nextValue()
             if self.nextToken() == 'radius':
-                value['radius'] = self.nextValue()
+                value.radius = self.nextValue()
                 return value
             return None
 
         if token in ['now', 'today', 'newline', 'tab', 'empty']:
             return value
 
-        if token in ['stringify', 'prettify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer', 'encode', 'decode']:
-            value['content'] = self.nextValue()
+        if token in ['stringify', 'prettify', 'json', 'lowercase', 'uppercase', 'hash', 'random', float, 'integer', 'encode', 'decode']:
+            value.setContent(self.nextValue())
             return value
 
         if (token in ['datime', 'datetime']):
-            value['type'] = 'datime'
-            value['timestamp'] = self.nextValue()
+            value.setType('datime')
+            value.timestamp = self.nextValue()
             if self.peek() == 'format':
                 self.nextToken()
-                value['format'] = self.nextValue()
+                value.format = self.nextValue()
             else:
-                value['format'] = None
+                value.format = None
             return value
 
-        if token == 'element':
-            value['index'] = self.nextValue()
+        if token == 'item':
+            value.index = self.nextValue()
             if self.nextToken() == 'of':
                 if self.nextIsSymbol():
-                    symbolRecord = self.getSymbolRecord()
-                    if symbolRecord['hasValue']:
-                        value['target'] = symbolRecord['name']
-                        return value
-                self.warning(f'Core.compileValue: Token {symbolRecord["name"]} does not hold a value')
+                    record = self.getSymbolRecord()
+                    self.checkObjectType(record['object'], ECList)
+                    value.target = ECValue(type='symbol', content=record['name'])
+                    return value
             return None
 
-        if token == 'property':
-            value['name'] = self.nextValue()
-            if self.nextToken() == 'of':
+        if token == 'entry':
+            value.key = self.nextValue() # type: ignore
+            if self.nextToken() in ('in', 'of'):
                 if self.nextIsSymbol():
-                    symbolRecord = self.getSymbolRecord()
-                    if symbolRecord['hasValue']:
-                        value['target'] = symbolRecord['name']
-                        return value
-                    NoValueError(self.compiler, symbolRecord)
+                    record = self.getSymbolRecord()
+                    object = record['object']
+                    self.checkObjectType(object, ECDictionary)
+                    value.target = object.name
+                    return value
             return None
 
         if token == 'arg':
-            value['content'] = self.nextValue()
+            value.setContent(self.nextValue())
             if self.getToken() == 'of':
                 if self.nextIsSymbol():
-                    symbolRecord = self.getSymbolRecord()
-                    if symbolRecord['keyword'] == 'variable':
-                        value['target'] = symbolRecord['name']
+                    record = self.getSymbolRecord()
+                    if record['keyword'] == 'variable':
+                        value.target = record['name'] # type: ignore
                         return value
             return None
 
         if token == 'trim':
             self.nextToken()
-            value['content'] = self.getValue()
+            value.setContent(self.getValue())
             return value
 
         if self.getToken() == 'the':
             self.nextToken()
 
         token = self.getToken()
-        value['type'] = token
+        value.setType(token)
 
-        if token == 'args':
-           return value
+        if token in ['args', 'message', 'uuid', 'weekday']:
+            return value
 
-        if token == 'elements':
-            if self.nextIs('of'):
+        if token in ('items', 'elements'):
+            if self.nextToken() in ('in', 'of'):
                 if self.nextIsSymbol():
-                    value['name'] = self.getToken()
+                    value.name = self.getToken() # type: ignore
                     return value
             return None
 
         if token == 'keys':
             if self.nextIs('of'):
-                value['name'] = self.nextValue()
-                return value
+                if self.nextIsSymbol():
+                    value.name = self.getToken() # type: ignore
+                    return value
             return None
 
         if token == 'count':
             if self.nextIs('of'):
                 if self.nextIsSymbol():
-                    if self.getSymbolRecord()['hasValue']:
-                        value['name'] = self.getToken()
+                    record = self.getSymbolRecord()
+                    object = record['object']
+                    if isinstance(object, ECList):
+                        value.setContent(record['name'])
                         return value
             return None
 
         if token == 'index':
             if self.nextIs('of'):
                 if self.nextIsSymbol():
-                    value['variable'] = self.getSymbolRecord()['name']
+                    value.variable = self.getSymbolRecord()['name'] # type: ignore
                     if self.peek() == 'in':
-                        value['value'] = None
-                        value['type'] = 'indexOf'
+                        value.value = None # type: ignore
+                        value.setType('indexOf')
+                        self.nextToken()
                         if self.nextIsSymbol():
-                            value['target'] = self.getSymbolRecord()['name']
+                            value.target = self.getSymbolRecord()['name'] # type: ignore
                             return value
                     else:
-                        value['name'] = self.getToken()
+                        value.name = self.getToken() # type: ignore
                         return value
                 else:
-                    value['value'] = self.getValue()
+                    value.value = self.getValue() # type: ignore
                     if self.nextIs('in'):
-                        value['variable'] = None
-                        value['type'] = 'indexOf'
+                        value.variable = None # type: ignore
+                        value.setType('indexOf')
                         if self.nextIsSymbol():
-                            value['target'] = self.getSymbolRecord()['name']
+                            value.target = self.getSymbolRecord()['name'] # type: ignore
                             return value
             return None
 
@@ -2049,111 +2081,101 @@ class Core(Handler):
             if self.nextIs('of'):
                 v = self.nextValue()
                 if v !=None:
-                    value['type'] = 'valueOf'
-                    value['content'] = v
+                    value.setValue(type='valueOf', content=v)
                     return value
             return None
 
         if token == 'length':
-            value['type'] = 'lengthOf'
+            value.setType('lengthOf')
             if self.nextIs('of'):
-                value['content'] = self.nextValue()
+                value.setContent(self.nextValue())
                 return value
             return None
 
         if token in ['left', 'right']:
-            value['count'] = self.nextValue()
+            value.count = self.nextValue() # type: ignore
             if self.nextToken() == 'of':
-                value['content'] = self.nextValue()
+                value.setContent(self.nextValue())
                 return value
             return None
 
+        # from {n} of {value}
+        # from {n} to {m} of {value}
         if token == 'from':
-            value['start'] = self.nextValue()
+            value.start = self.nextValue() # type: ignore
             if self.peek() == 'to':
                 self.nextToken()
-                value['to'] = self.nextValue()
+                value.to = self.nextValue() # type: ignore
             else:
-                value['to'] = None
+                value.to = None # type: ignore
             if self.nextToken() == 'of':
-                value['content'] = self.nextValue()
+                value.setContent(self.nextValue())
                 return value
 
+        # position of [the] [last] {needle} in {haystack}
         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':
+            self.skip('of')
+            self.skip('the')
+            if self.peek() == 'last':
+                value.last = True # type: ignore
+                self.nextToken()
+            value.needle = self.nextValue() # type: ignore
+            self.skip('in')
+            value.haystack = self.nextValue() # type: ignore
             return value
 
         if token == 'timestamp':
-            value['format'] = None
+            value.format = None # type: ignore
             if self.peek() == 'of':
                 self.nextToken()
-                value['datime'] = self.nextValue()
+                value.timestamp = self.nextValue() # type: ignore
                 if self.peek() == 'format':
                     self.nextToken()
-                    value['format'] = self.nextValue()
+                    value.format = self.nextValue() # type: ignore
             return value
 
         if token == 'files':
             token = self.nextToken()
             if token in ['in', 'of']:
-                value['target'] = self.nextValue()
+                value.target = self.nextValue() # type: ignore
                 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':
             token = self.peek()
             if token == 'code':
                 self.nextToken()
-                value['item'] = 'errorCode'
+                value.item = 'errorCode' # type: ignore
                 return value
             elif token == 'reason':
                 self.nextToken()
-                value['item'] = 'errorReason'
+                value.item = 'errorReason' # type: ignore
                 return value
             elif token in ['in', 'of']:
                 self.nextToken()
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
-                    if record['keyword'] == 'ssh':
-                        value['item'] = 'sshError'
-                        value['name'] = record['name']
+                    if isinstance(record['object'], ECSSH):
+                        value.item = 'sshError' # type: ignore
+                        value.name = record['name'] # type: ignore
                         return value
             return None
 
         if token == 'type':
             if self.nextIs('of'):
-                value['value'] = self.nextValue()
+                value.value = self.nextValue() # type: ignore
                 return value
             return None
 
         if token == 'modification':
             if self.nextIs('time'):
                 if self.nextIs('of'):
-                    value['fileName'] = self.nextValue()
+                    value.fileName = self.nextValue() # type: ignore
                     return value
             return None
 
         if token == 'system':
-            value['command'] = self.nextValue()
+            value.setContent(self.nextValue())
             return value
 
         if token == 'ticker':
@@ -2166,12 +2188,9 @@ class Core(Handler):
     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
+            mv = ECValue(type='modulo', content=value)
+            mv.modval = self.nextValue() # type: ignore
+            return mv
 
         return value
 
@@ -2179,472 +2198,368 @@ class Core(Handler):
     # Value handlers
 
     def v_args(self, v):
-        value = {}
-        value['type'] = 'text'
-        value['content'] = json.dumps(self.program.argv)
-        return value
+        return ECValue(type=str, content=json.dumps(self.program.argv))
 
     def v_arg(self, v):
-        value = {}
-        value['type'] = 'text'
-        index = self.getRuntimeValue(v['index'])
+        index = self.textify(v['index'])
         if index >= len(self.program.argv):
             RuntimeError(self.program, 'Index exceeds # of args')
-        value['content'] = self.program.argv[index]
-        return value
+        return ECValue(type=str, content=self.program.argv[index])
 
+    def v_bool(self, v):
+        value = ECValue(type=bool, content=v.getContent())
+    
     def v_boolean(self, v):
-        value = {}
-        value['type'] = 'boolean'
-        value['content'] = v['content']
-        return value
+        return self.v_bool(v)
 
     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
+        angle = self.textify(v['angle'])
+        radius = self.textify(v['radius'])
+        return ECValue(type=int, content=round(math.cos(angle * 0.01745329) * radius))
 
     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
+        variable = self.getObject(self.getVariable(v.getContent()))
+        return ECValue(type=int, content=variable.getItemCount())
 
     def v_datime(self, v):
-        ts = self.getRuntimeValue(v['timestamp'])
-        fmt = v['format']
+        ts = self.textify(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
+            fmt = self.textify(fmt)
+        return ECValue(type=str, content=datetime.fromtimestamp(ts/1000).strftime(fmt))
 
     def v_decode(self, v):
-        content = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
+        content = self.textify(v.getContent())
+        value = ECValue(type=str)
         if self.encoding == 'utf-8':
-            value['content'] = content.decode('utf-8')
+            value.setContent(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')
+            value.setContent(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')
+            value.setContent(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
+        var = self.getVariable(v.name)
+        object = var['object']
+        self.checkObjectType(object, ECVariable)
+        return ECValue(type=int, content=object.getElements())
 
     def v_empty(self, v):
-        value = {}
-        value['type'] = 'text'
-        value['content'] = ''
-        return value
+        return ECValue(type=str, content=''  )
 
     def v_encode(self, v):
-        content = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
+        content = self.textify(v.getContent())
+        value = ECValue(type=str)
         if self.encoding == 'utf-8':
-            value['content'] = content.encode('utf-8')
+            value.setContent(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')
+            value.setContent(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')
+            value.setContent(hex_bytes.decode('utf-8'))
         else:
             value = v
         return value
 
+    def v_entry(self, v):
+        record = self.getVariable(v.target)
+        dictionary = self.getObject(record)
+        return dictionary.getEntry(self.textify(v.key))
+
     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
-        elif v['item'] == 'sshError':
-            record = self.getVariable(v['name'])
-            value['type'] = 'text'
-            value['content'] = record['error'] if 'error' in record else ''
+        value = ECValue()
+        item = v.item
+        if item == 'errorCode':
+            value.setValue(type=int, content=errorCode)
+        elif item == 'errorReason':
+            value.setValue(type=str, content=errorReason)
+        elif item == 'sshError':
+            record = self.getVariable(v.name)
+            value.setValue(type=str, content=record['error'] if 'error' in record else '')
         return value
 
     def v_files(self, v):
-        v = self.getRuntimeValue(v['target'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = os.listdir(v)
-        return value
+        path = self.textify(v.target)
+        return ECValue(type=str, content=json.dumps(os.listdir(path)))
 
     def v_float(self, v):
-        val = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'float'
+        val = self.textify(v.getContent())
+        value = ECValue(type=float)
         try:
-            value['content'] = float(val)
+            value.setContent(float(val))
         except:
             RuntimeWarning(self.program, f'Value cannot be parsed as floating-point')
-            value['content'] = 0.0
+            value.setContent(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
+        content = self.textify(v.getContent())
+        start = self.textify(v.start)
+        to = self.textify(v.to)
+        if start is not None and type(start) != int:
+            RuntimeError(self.program, 'Invalid "from" value')
+        if to is not None and type(to) != int:
+            RuntimeError(self.program, 'Invalid "to" value')
+        return ECValue(type=str, content=content[start:] if to == None else content[start:to])
 
     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
+        hashval = self.textify(v.getContent())
+        return ECValue(type=str, content=hashlib.sha256(hashval.encode('utf-8')).hexdigest())
 
     def v_index(self, v):
-        value = {}
-        value['type'] = 'int'
-        value['content'] = self.getVariable(v['name'])['index']
-        return value
+        record = self.getVariable(v.name)
+        object = self.getObject(record)
+        return ECValue(type=int, content=object.getIndex())
 
     def v_indexOf(self, v):
-        value = v['value']
+        value = v.value
         if value == None:
-            value = self.getSymbolValue(v['variable'])['content']
+            var = self.getObject(self.getVariable(v.variable))
+            value = var.getContent()
         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
+            value = self.textify(value)
+        target = self.getObject(self.getVariable(v.target))
+        if hasattr(target, 'getIndexOf'):
+            index = target.getIndexOf(value)
+        else:
+            data = target.getContent()
+            try: index = data.index(value)
+            except: index = -1
+        return ECValue(type=int, content=index)
+    
+    def v_int(self, v):
+        content = self.textify(v.getContent())
+        if content in ('', None):
+            return ECValue(type=int, content=0)
+        return ECValue(type=int, content=int(content))
 
     def v_integer(self, v):
-        val = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'int'
-        value['content'] = int(val)
-        return value
+        return self.v_int(v)
+
+    def v_item(self, v):
+        index = self.textify(v.index)
+        targetName = v.target
+        target = self.getVariable(targetName.getContent())
+        variable = self.getObject(target)
+        self.checkObjectType(variable, ECList)
+        if index >= variable.getItemCount():
+            RuntimeError(self.program, f'Index out of range in {targetName}')
+        targetValue = variable.getItem(index)
+        return targetValue
+    
+    def v_items(self, v):
+        record = self.getVariable(v.name)
+        object = self.getObject(record)
+        self.checkObjectType(object, ECList)
+        return object.getItemCount()
 
     def v_json(self, v):
-        item = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'object'
+        item = self.textify(v.getContent())
+        value = ECValue()
         try:
-            value['content'] = json.loads(item)
+            v = json.loads(item)
+            if type(v) == list: value.setType('list')
+            elif type(v) == dict: value.setType('dict')
+            else: value.setType(str)  
+            value.setContent(v)
         except:
             value = None
         return value
 
     def v_keys(self, v):
-        value = {}
-        value['type'] = 'int'
-        value['content'] = list(self.getRuntimeValue(v['name']).keys())
-        return value
+        dictionary = self.getObject(self.getVariable(v.name))
+        return ECValue(type='list', content=list(dictionary.keys())) # type: ignore
 
     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
+        content = self.textify(v.getContent())
+        count = self.textify(v.count)
+        return ECValue(type=str, content=content[0:count])
 
     def v_lengthOf(self, v):
-        content = self.getRuntimeValue(v['content'])
+        content = self.textify(v.getContent())
         if type(content) == str:
-            value = {}
-            value['type'] = 'int'
-            value['content'] = len(content)
-            return value
+            return ECValue(type=int, content=len(content))
         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
+        content = self.textify(v.getValue())
+        return ECValue(type=str, content=content.lower())
 
     def v_message(self, v):
-        value = {}
-        value['type'] = 'text'
-        value['content'] = self.program.message
-        return value
+        return ECValue(type=str, content=self.program.message)
 
     def v_modification(self, v):
-        fileName = self.getRuntimeValue(v['fileName'])
+        fileName = self.textify(v['fileName'])
         ts = int(os.stat(fileName).st_mtime)
-        value = {}
-        value['type'] = 'int'
-        value['content'] = ts
-        return value
+        return ECValue(type=int, content=ts)
 
     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
+        val = self.textify(v.getContent())
+        modval = self.textify(v.modval)
+        return ECValue(type=int, content=val % modval)
 
     def v_newline(self, v):
-        value = {}
-        value['type'] = 'text'
-        value['content'] = '\n'
-        return value
+        return ECValue(type=str, content='\n')
 
     def v_now(self, v):
-        value = {}
-        value['type'] = 'int'
-        value['content'] = int(time.time())
-        return value
+        return ECValue(type=int, content=int(time.time()))
 
     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
+        needle = self.textify(v.needle)
+        haystack = self.textify(v.haystack)
+        last = v.last
+        return ECValue(type=int, content=haystack.rfind(needle) if last else haystack.find(needle))
 
     def v_prettify(self, v):
-        item = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = json.dumps(item, indent=4)
-        return value
+        item = self.textify(v.getContent())
+        if isinstance(item, str): item = json.loads(item)
+        return ECValue(type=str, content=json.dumps(item, indent=4))
 
     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
+        propertyName = v.name
+        propertyValue = self.textify(propertyName)
+        targetName = v.target
+        target = self.getVariable(targetName.getContent())
+        variable = self.getObject(target)
+        return variable.getProperty(propertyValue)
 
     def v_random(self, v):
-        limit = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'int'
-        value['content'] = random.randrange(0, limit)
-        return value
+        limit = self.textify(v.getValue())
+        return ECValue(type=int, content=random.randrange(0, limit))
 
     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
+        content = self.textify(v.getContent())
+        count = self.textify(v.count)
+        return ECValue(type=str, content=content[-count:])
 
     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
+        angle = self.textify(v.angle)
+        radius = self.textify(v.radius)
+        return ECValue(type=int, content=round(math.sin(angle * 0.01745329) * radius))
+    
+    def v_str(self, v):
+        content = self.textify(v.getContent())
+        return ECValue(type=str, content=str(content))
 
     def v_stringify(self, v):
-        item = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = json.dumps(item)
-        return value
+        item = self.textify(v.getContent())
+        item = json.loads(item)
+        return ECValue(type=str, content=json.dumps(item))
 
     # This is used by the expression evaluator to get the value of a symbol
-    def v_symbol(self, value):
-        name = value['name']
-        symbolRecord = self.program.getSymbolRecord(name)
-        keyword = symbolRecord['keyword']
-        if keyword == 'variable':
-            return self.getSymbolValue(symbolRecord)
+    def v_symbol(self, v):
+        name = v.name
+        record = self.program.getSymbolRecord(name)
+        keyword = record['keyword']
+        if keyword == 'object':
+            return record['object'].getValue()
+        elif keyword == 'variable':
+            return self.getSymbolValue(record)
         elif keyword == 'ssh':
-            v = {}
-            v['type'] = 'boolean'
-            v['content']  = True if 'ssh' in symbolRecord and symbolRecord['ssh'] != None else False
-            return v
+            return ECValue(type=bool, content=True if 'ssh' in record and record['ssh'] != None else False)
         else:
             return None
 
     def v_system(self, v):
-        command = self.getRuntimeValue(v['command'])
+        command = self.textify(v.getContent())
         result = os.popen(command).read()
-        value = {}
-        value['type'] = 'text'
-        value['content'] = result
-        return value
+        return ECValue(type=str, content=result)
 
     def v_tab(self, v):
-        value = {}
-        value['type'] = 'text'
-        value['content'] = '\t'
-        return value
+        return ECValue(type=str, content='\t')
 
     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
+        angle = self.textify(v['angle'])
+        radius = self.textify(v['radius'])
+        return ECValue(type=int, content=round(math.tan(angle * 0.01745329) * radius))
 
     def v_ticker(self, v):
-        value = {}
-        value['type'] = 'int'
-        value['content'] = self.program.ticker
-        return value
+        return ECValue(type=int, content=self.program.ticker)
 
     def v_timestamp(self, v):
-        value = {}
-        value['type'] = 'int'
-        fmt = v['format']
+        value = ECValue(type=int)
+        fmt = v.format
         if fmt == None:
-            value['content'] = int(time.time())
+            value.setContent(int(time.time()))
         else:
-            fmt = self.getRuntimeValue(fmt)
-            dt = self.getRuntimeValue(v['datime'])
+            fmt = self.textify(fmt)
+            dt = self.textify(v.timestamp)
             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())
+            value.setContent(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
+        return ECValue(type=int, content=int(datetime.combine(datetime.now().date(),datetime.min.time()).timestamp()) * 1000)
 
     def v_trim(self, v):
-        v = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = v.strip()
-        return value
+        content = v.getContent()
+        content = self.textify(content)
+        return ECValue(type=str, content=content.strip())
 
     def v_type(self, v):
-        value = {}
-        value['type'] = 'text'
-        val = self.getRuntimeValue(v['value'])
+        value = ECValue(type=str)
+        val = self.textify(v['value'])
         if val is None:
-            value['content'] = 'none'
+            value.setContent('none')
         elif type(val) is str:
-            value['content'] = 'text'
+            value.setContent(str)
         elif type(val) is int:
-            value['content'] = 'numeric'
+            value.setContent('numeric')
         elif type(val) is bool:
-            value['content'] = 'boolean'
+            value.setContent(bool)
         elif type(val) is list:
-            value['content'] = 'list'
+            value.setContent('list')
         elif type(val) is dict:
-            value['content'] = 'object'
+            value.setContent('dict')
         return value
 
     def v_uppercase(self, v):
-        content = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'text'
-        value['content'] = content.upper()
-        return value
+        content = self.textify(v.getContent())
+        return ECValue(type=str, content=content.upper())
+    
+    def v_uuid(self, v):
+        return ECValue(type=str, content=str(uuid.uuid4())[:8])
 
     def v_valueOf(self, v):
-        v = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'int'
-        value['content'] = int(v) if v != '' else 0
+        v = self.textify(v.getContent())
+        return ECValue(type=int, content=int(v) if v != '' else 0)
+    
+    def v_variable(self, v):
+        name = v.getContent()
+        record = self.program.getSymbolRecord(name)
+        variable = record['object']
+        self.checkObjectType(variable, ECVariable)
+        value = variable.getValue()
         return value
 
     def v_weekday(self, v):
-        value = {}
-        value['type'] = 'int'
-        value['content'] = datetime.today().weekday()
-        return value
+        return ECValue(type=int, content=datetime.today().weekday())
 
     #############################################################################
     # Compile a condition
     def compileCondition(self):
-        condition = Object()
-        condition.negate = False
+        condition = ECValue()
+        condition.negate = False # type: ignore
 
         token = self.getToken()
 
         if token == 'not':
-            condition.type = 'not'
-            condition.value = self.nextValue()
+            condition.type = 'not' # type: ignore
+            condition.value = self.nextValue() # type: ignore
             return condition
 
         elif token == 'error':
@@ -2653,21 +2568,21 @@ class Core(Handler):
             if self.nextIsSymbol():
                 record = self.getSymbolRecord()
                 if record['keyword'] == 'ssh':
-                    condition.type = 'sshError'
-                    condition.target = record['name']
+                    condition.type = 'sshError' # type: ignore
+                    condition.target = record['name'] # type: ignore
                     return condition
             return None
 
         elif token == 'file':
             path = self.nextValue()
-            condition.path = path
-            condition.type = 'exists'
+            condition.path = path # type: ignore
+            condition.type = 'exists' # type: ignore
             self.skip('on')
             if self.nextIsSymbol():
                 record = self.getSymbolRecord()
                 if record['keyword'] == 'ssh':
-                    condition.type = 'sshExists'
-                    condition.target = record['name']
+                    condition.type = 'sshExists' # type: ignore
+                    condition.target = record['name'] # type: ignore
                     token = self.nextToken()
             else: token = self.getToken()
             if token == 'exists':
@@ -2675,24 +2590,33 @@ class Core(Handler):
             elif token == 'does':
                 if self.nextIs('not'):
                     if self.nextIs('exist'):
-                        condition.negate = not condition.negate
+                        condition.negate = not condition.negate # type: ignore
                         return condition
             return None
+        
+        elif token == 'debugging':
+            condition.type = 'debugging' # type: ignore
+            return condition
 
         value = self.getValue()
         if value == None:
             return None
 
-        condition.value1 = value
+        condition.value1 = value # type: ignore
         token = self.peek()
-        condition.type = token
+        condition.type = token # type: ignore
 
         if token == 'has':
             self.nextToken()
-            if self.nextToken() == 'property':
-                prop = self.nextValue()
-                condition.type = 'hasProperty'
-                condition.property = prop
+            token = self.nextToken()
+            if token in ('entry', 'property'):
+                value = self.nextValue()
+                if token == 'entry':
+                    condition.type = 'hasEntry' # type: ignore
+                    condition.entry = value # type: ignore
+                elif token == 'property:':
+                    condition.type = 'hasProperty' # type: ignore
+                    condition.property = value # type: ignore
                 return condition
             return None
 
@@ -2701,50 +2625,55 @@ class Core(Handler):
             if self.nextIs('not'):
                 token = self.nextToken()
                 if token == 'have':
-                    if self.nextToken() == 'property':
-                        prop = self.nextValue()
-                        condition.type = 'hasProperty'
-                        condition.property = prop
-                        condition.negate = not condition.negate
+                    token = self.nextToken()
+                    if token in ('entry', 'property:'):
+                        value = self.nextValue()
+                        if token == 'entry':
+                            condition.type = 'hasEntry' # type: ignore
+                            condition.entry = value # type: ignore
+                        elif token == 'property':
+                            condition.type = 'hasProperty' # type: ignore
+                            condition.property = value # type: ignore
+                        condition.negate = not condition.negate # type: ignore
                         return condition
                 elif token == 'include':
                     value = self.nextValue()
-                    condition.type = 'includes'
-                    condition.value2 = value
-                    condition.negate = not condition.negate
+                    condition.type = 'includes' # type: ignore
+                    condition.value2 = value # type: ignore
+                    condition.negate = not condition.negate # type: ignore
                     return condition
             return None
 
         if token in ['starts', 'ends']:
             self.nextToken()
             if self.nextToken() == 'with':
-                condition.value2 = self.nextValue()
+                condition.value2 = self.nextValue() # type: ignore
                 return condition
 
         if token == 'includes':
-            condition.value2 = self.nextValue()
+            condition.value2 = self.nextValue() # type: ignore
             return condition
 
         if token == 'is':
             token = self.nextToken()
             if self.peek() == 'not':
                 self.nextToken()
-                condition.negate = True
+                condition.negate = True # type: ignore
             token = self.nextToken()
-            condition.type = token
-            if token in ['numeric', 'string', 'boolean', 'none', 'list', 'object', 'even', 'odd', 'empty']:
+            condition.type = token # type: ignore
+            if token in ['numeric', 'string', 'bool', 'boolean', 'none', 'list', 'object', 'even', 'odd', 'empty']:
                 return condition
             if token in ['greater', 'less']:
                 if self.nextToken() == 'than':
-                    condition.value2 = self.nextValue()
+                    condition.value2 = self.nextValue() # type: ignore
                     return condition
-            condition.type = 'is'
-            condition.value2 = self.getValue()
+            condition.type = 'is' # type: ignore
+            condition.value2 = self.getValue() # type: ignore
             return condition
  
-        if condition.value1:
+        if condition.value1: # type: ignore
             # It's a boolean if
-            condition.type = 'boolean'
+            condition.type = bool # type: ignore
             return condition
 
         self.warning(f'Core.compileCondition: I can\'t get a conditional:')
@@ -2760,8 +2689,8 @@ class Core(Handler):
     #############################################################################
     # Condition handlers
 
-    def c_boolean(self, condition):
-        value = self.getRuntimeValue(condition.value1)
+    def c_bool(self, condition):
+        value = self.textify(condition.value1)
         if type(value) == bool:
             return not value if condition.negate else value
         elif type(value) == int:
@@ -2774,77 +2703,102 @@ class Core(Handler):
             else:
                 return True if condition.negate else False
         return False
+    
+    def c_boolean(self, condition):
+        return self.c_bool(condition)
+
+    def c_debugging(self, condition):
+        return self.program.debugging
 
     def c_empty(self, condition):
-        value = self.getRuntimeValue(condition.value1)
+        if condition.value1.getType() == 'symbol':
+            record = self.getVariable(condition.value1.content)
+            variable = self.getObject(record)
+            if isinstance(variable, (ECList, ECDictionary)):
+                comparison = variable.isEmpty()
+                return not comparison if condition.negate else comparison
+        value = self.textify(condition.value1)
         if value == None:
             comparison = True
-        else:
+        elif isinstance(value, str):
             comparison = len(value) == 0
+        else:
+            domainName = condition.value1.domain
+            domain = self.program.domainIndex[domainName] # type: ignore
+            handler = domain.valueHandler('empty') # type: ignore
+            if handler: comparison = self.textify(handler(condition.value1))
         return not comparison if condition.negate else comparison
 
     def c_ends(self, condition):
-        value1 = self.getRuntimeValue(condition.value1)
-        value2 = self.getRuntimeValue(condition.value2)
+        value1 = self.textify(condition.value1)
+        value2 = self.textify(condition.value2)
         return value1.endswith(value2)
 
     def c_even(self, condition):
-        return self.getRuntimeValue(condition.value1) % 2 == 0
+        return self.textify(condition.value1) % 2 == 0
 
     def c_exists(self, condition):
-        path = self.getRuntimeValue(condition.path)
+        path = self.textify(condition.path)
         comparison = os.path.exists(path)
         return not comparison if condition.negate else comparison
 
     def c_greater(self, condition):
         comparison = self.program.compare(condition.value1, condition.value2)
+        if comparison == None:
+            raise RuntimeError(self.program, f'Cannot compare {self.textify(condition.value1)} and {self.textify(condition.value2)}')
         return comparison <= 0 if condition.negate else comparison > 0
 
+    def c_hasEntry(self, condition):
+        dictionary = self.getObject(self.getVariable(condition.value1.content))
+        entry = self.textify(condition.entry)
+        hasEntry = dictionary.hasEntry(entry) # type: ignore
+        return not hasEntry if condition.negate else hasEntry
+
     def c_hasProperty(self, condition):
-        value = self.getRuntimeValue(condition.value1)
-        prop = self.getRuntimeValue(condition.property)
-        try:
-            value[prop]
-            hasProp = True
-        except:
-            hasProp = False
+        record = self.getVariable(condition.value1)
+        variable = self.getObject(record)
+        prop = self.textify(condition.property)
+        hasProp = variable.hasProperty(prop)
         return not hasProp if condition.negate else hasProp
 
     def c_includes(self, condition):
-        value1 = self.getRuntimeValue(condition.value1)
-        value2 = self.getRuntimeValue(condition.value2)
+        value1 = self.textify(condition.value1)
+        value2 = self.textify(condition.value2)
         includes = value2 in value1
         return not includes if condition.negate else includes
 
     def c_is(self, condition):
         comparison = self.program.compare(condition.value1, condition.value2)
+        if comparison == None: comparison = 1
         return comparison != 0 if condition.negate else comparison == 0
 
     def c_less(self, condition):
         comparison = self.program.compare(condition.value1, condition.value2)
+        if comparison == None:
+            raise RuntimeError(self.program, f'Cannot compare {self.textify(condition.value1)} and {self.textify(condition.value2)}')
         return comparison >= 0 if condition.negate else comparison < 0
 
     def c_list(self, condition):
-        comparison = type(self.getRuntimeValue(condition.value1)) is list
+        comparison = type(self.textify(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
+        comparison = type(self.textify(condition.value1)) is int
         return not comparison if condition.negate else comparison
 
     def c_none(self, condition):
-        comparison = self.getRuntimeValue(condition.value1) is None
+        comparison = self.textify(condition.value1) is None
         return not comparison if condition.negate else comparison
 
     def c_not(self, condition):
-        return not self.getRuntimeValue(condition.value)
+        return not self.textify(condition.value)
 
     def c_object(self, condition):
-        comparison = type(self.getRuntimeValue(condition.value1)) is dict
+        comparison = type(self.textify(condition.value1)) is dict
         return not comparison if condition.negate else comparison
 
     def c_odd(self, condition):
-        return self.getRuntimeValue(condition.value1) % 2 == 1
+        return self.textify(condition.value1) % 2 == 1
     
     def c_sshError(self, condition):
         target = self.getVariable(condition.target)
@@ -2854,7 +2808,7 @@ class Core(Handler):
         return not test if condition.negate else test
 
     def c_sshExists(self, condition):
-        path = self.getRuntimeValue(condition.path)
+        path = self.textify(condition.path)
         ssh = self.getVariable(condition.target)
         sftp = ssh['sftp']
         try:
@@ -2865,10 +2819,10 @@ class Core(Handler):
         return not comparison if condition.negate else comparison
 
     def c_starts(self, condition):
-        value1 = self.getRuntimeValue(condition.value1)
-        value2 = self.getRuntimeValue(condition.value2)
+        value1 = self.textify(condition.value1)
+        value2 = self.textify(condition.value2)
         return value1.startswith(value2)
 
     def c_string(self, condition):
-        comparison = type(self.getRuntimeValue(condition.value1)) is str
+        comparison = type(self.textify(condition.value1)) is str
         return not comparison if condition.negate else comparison