easycoder 251215.2__py2.py3-none-any.whl → 260111.1__py2.py3-none-any.whl

easycoder/ec_core.py

@@ -1,5 +1,5 @@
 import json, math, hashlib, threading, os, subprocess, time
-import base64, binascii, random, requests, paramiko
+import base64, binascii, random, requests, paramiko, uuid
 from copy import deepcopy
 from datetime import datetime
 from .ec_classes import (
@@ -11,10 +11,13 @@ from .ec_classes import (
     NoValueRuntimeError,
     ECObject,
     ECVariable,
+    ECDictionary,
+    ECList,
     ECFile,
     ECStack,
     ECSSH,
-    ECValue
+    ECValue,
+    ECModule
 )
 
 from .ec_handler import Handler
@@ -67,7 +70,7 @@ class Core(Handler):
             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(domain=self.getName(), type='symbol', content=record['name'])
+                v2 = ECValue(type='symbol', content=record['name'])
                 command['value2'] = v2
                 self.nextToken()
                 # Now get the target variable
@@ -104,7 +107,7 @@ class Core(Handler):
         # 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(domain=self.getName(), type='int', content=int(value1) + int(value2))
+            targetValue = ECValue(type=int, content=int(value1) + int(value2))
         else:
             # add X to Y
             targetValue = self.getSymbolValue(target)
@@ -112,14 +115,14 @@ class Core(Handler):
         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():
                 record = self.getSymbolRecord()
-                self.program.checkObjectType(self.getObject(record), ECVariable)
+                self.program.checkObjectType(self.getObject(record), ECList)
                 command['target'] = record['name']
                 self.add(command)
                 return True
@@ -127,13 +130,8 @@ class Core(Handler):
 
     def r_append(self, command):
         value = self.textify(command['value'])
-        target = self.getVariable(command['target'])
-        content = target['object'].getContent()
-        items = [] if content == None else content
-        if not type(items) == list:
-            RuntimeError(self.program, f'{command["target"]} is not a JSON list')
-        items.append(value)
-        self.putSymbolValue(target, items)
+        target = self.getObject(self.getVariable(command['target']))
+        target.append(value)
         return self.nextPC()
 
     #assert {condition} [with {message}]
@@ -193,7 +191,7 @@ class Core(Handler):
             if target['keyword'] == 'ssh':
                 target['ssh'] = None
             else:
-                self.putSymbolValue(target, ECValue(domain=self.getName(), type='boolean', content=False))
+                self.putSymbolValue(target, ECValue(type=bool, content=False))
         return self.nextPC()
 
     # Close a file
@@ -201,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):
@@ -212,6 +210,34 @@ class Core(Handler):
         fileRecord['file'].close()
         return self.nextPC()
 
+    # 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):
@@ -236,7 +262,7 @@ class Core(Handler):
             self.compiler.debugCompile = True
             self.nextToken()
             return True
-        elif token in ['step', 'stop', 'breakpoint', 'program', 'custom']:
+        elif token in ['step', 'stop', 'skip', 'breakpoint', 'program', 'custom']:
             command['mode'] = token
             self.nextToken()
         elif token == 'stack':
@@ -262,6 +288,8 @@ 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':
@@ -296,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
@@ -305,19 +332,21 @@ 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 isinstance(self.getObject(record), ECObject):
-                    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):
@@ -326,7 +355,16 @@ class Core(Handler):
             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':
+            raise NotImplementedError('Core.delete property not implemented yet')
             key = self.textify(command['key'])
             record = self.getVariable(command['var'])
             value = self.getSymbolValue(record)
@@ -336,7 +374,7 @@ class Core(Handler):
             self.putSymbolValue(record, value)
         elif type == 'element':
             key = self.textify(command['key'])
-            record = self.getVariable(command['var'])
+            record = self.getVariable(command['variable'])
             value = self.getSymbolValue(record)
             content = value.getContent()
             if isinstance(key, int):
@@ -348,6 +386,15 @@ class Core(Handler):
             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 divide
     # divide {variable} by {value}
     # divide {value1} by {value2} giving {variable}
@@ -392,7 +439,7 @@ class Core(Handler):
         # 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(domain=self.getName(), type='int', content=int(value1) // int(value2))
+            targetValue = ECValue(type=int, content=int(value1) // int(value2))
         else:
             # divide X by Y
             targetValue = self.getSymbolValue(target)
@@ -450,9 +497,9 @@ class Core(Handler):
         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
@@ -468,7 +515,7 @@ class Core(Handler):
         self.run(label)
         return next
 
-    # get {variable) from {url} [or {command}]
+    # get {variable) from url {url} [or {command}]
     def k_get(self, command):
         if self.nextIsSymbol():
             record = self.getSymbolRecord()
@@ -487,7 +534,7 @@ class Core(Handler):
                         self.nextToken()
                         command['timeout'] = self.nextValue()
                     else:
-                        timeout = ECValue(type = 'int', content = 5)
+                        timeout = ECValue(type = int, content = 5)
                         command['timeout'] = timeout
                     self.processOr(command, get)
                     return True
@@ -495,10 +542,10 @@ class Core(Handler):
 
     def r_get(self, command):
         global errorCode, errorReason
-        retval = ECValue(type='str')
+        retval = ECValue(type=str)
         url = self.textify(command['url'])
         target = self.getVariable(command['target'])
-        response = json.loads('{}')
+        response = {}
         try:
             timeout = self.textify(command['timeout'])
             response = requests.get(url, auth = ('user', 'pass'), timeout=timeout)
@@ -515,15 +562,15 @@ class Core(Handler):
                 return command['or']
             else:
                 RuntimeError(self.program, f'Error: {errorReason}')
-        retval.setContent(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'
@@ -545,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
@@ -684,7 +731,7 @@ class Core(Handler):
         # get the variable
         if self.nextIsSymbol():
             command['target'] = self.getToken()
-            value = ECValue(domain=self.getName(), type='str', content=': ')
+            value = ECValue(type=str, content=': ')
             command['prompt'] = value
             if self.peek() == 'with':
                 self.nextToken()
@@ -696,10 +743,18 @@ class Core(Handler):
     def r_input(self, command):
         record = self.getVariable(command['target'])
         prompt = command['prompt'].getValue()
-        value = ECValue(domain=self.getName(), type='str', content=prompt+input(prompt))
+        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.
     # 2 Load text from a file or ssh
     def k_load(self, command):
@@ -712,7 +767,7 @@ class Core(Handler):
                 return True
         elif self.isSymbol():
             record = self.getSymbolRecord()
-            if isinstance(self.getObject(record), ECVariable):
+            if isinstance(self.getObject(record), (ECVariable, ECDictionary, ECList)):
                 command['target'] = record['name']
                 if self.nextIs('from'):
                     if self.nextIsSymbol():
@@ -761,8 +816,13 @@ class Core(Handler):
                 return command['or']
             else:
                 RuntimeError(self.program, f'Error: {errorReason}')
-        value = ECValue(domain=self.getName(), type='str', 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
@@ -788,7 +848,7 @@ class Core(Handler):
     # Declare a module variable
     def k_module(self, command):
         self.compiler.addValueType()
-        return self.compileVariable(command, 'ECObject')
+        return self.compileVariable(command, 'ECModule')
 
     def r_module(self, command):
         return self.nextPC()
@@ -837,7 +897,7 @@ class Core(Handler):
         # 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(domain=self.getName(), type='int', content=int(value1) * int(value2))
+            targetValue = ECValue(type=int, content=int(value1) * int(value2))
         else:
             # multiply X by Y
             targetValue = self.getSymbolValue(target)
@@ -870,7 +930,8 @@ class Core(Handler):
 
     # 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)
@@ -937,7 +998,7 @@ class Core(Handler):
             return self.nextPC()
         RuntimeError(self.program, f"File {path} does not exist")
 
-    # Dummy command for testing
+    # Dummy command to hit a debugger breakpoint
     def k_pass(self, command):
         self.add(command)
         return True
@@ -991,7 +1052,7 @@ class Core(Handler):
 
     def r_post(self, command):
         global errorCode, errorReason
-        retval = ECValue(domain=self.getName(), type='str', content = '')
+        retval = ECValue(type=str, content = '')
         value = self.textify(command['value'])
         url = self.textify(command['url'])
         try:
@@ -1061,30 +1122,29 @@ class Core(Handler):
         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():
                     record = self.getSymbolRecord()
                     command['target'] = record['name']
-                    self.checkObjectType(self.getObject(record), ECVariable)
-                    command['or'] = None
-                    self.processOr(command, self.getCodeSize())
-                    return True
+                    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
                 else:
                     FatalError(self.compiler, f'Symbol {self.getToken()} is not a variable')
         return False
 
     def r_put(self, command):
         value = self.evaluate(command['value'])
-#        if value == None:
-#            if command['or'] != None:
-#                return command['or']
-#            else:
-#                RuntimeError(self.program, f'Error: could not compute value')
         record = self.getVariable(command['target'])
         self.putSymbolValue(record, value)
         return self.nextPC()
@@ -1120,7 +1180,7 @@ class Core(Handler):
         file = fileRecord['file']
         if file.mode == 'r':
             content = file.readline().split('\n')[0] if line else file.read()
-            value = ECValue(domain=self.getName(), type='str', content=content)
+            value = ECValue(type=str, content=content)
             self.putSymbolValue(record, value)
         return self.nextPC()
 
@@ -1128,7 +1188,8 @@ class Core(Handler):
     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()
@@ -1157,7 +1218,7 @@ class Core(Handler):
         original = self.textify(command['original'])
         replacement = self.textify(command['replacement'])
         content = content.replace(original, str(replacement))
-        value = ECValue(domain=self.getName(), type='str', content=content)
+        value = ECValue(type=str, content=content)
         self.putSymbolValue(templateRecord, value)
         return self.nextPC()
 
@@ -1181,6 +1242,7 @@ class Core(Handler):
         return True
 
     def r_return(self, command):
+        self.program.debugSkip = False
         return self.stack.pop()
 
     # Compile and run a script
@@ -1296,7 +1358,7 @@ 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
@@ -1310,9 +1372,10 @@ class Core(Handler):
 
     # 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():
@@ -1341,7 +1404,15 @@ class Core(Handler):
                 self.add(command)
                 return True
             elif isinstance(self.getObject(record), ECVariable):
-                command['type'] = 'set'
+                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
@@ -1353,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()
@@ -1369,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:
@@ -1382,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():
@@ -1408,7 +1482,13 @@ class Core(Handler):
         cmdType = command['type']
         if cmdType == 'set':
             target = self.getVariable(command['target'])
-            self.putSymbolValue(target, ECValue(domain=self.getName(), type='boolean', content=True))
+            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':
@@ -1419,19 +1499,13 @@ class Core(Handler):
             object.setElements(elements)
             return self.nextPC()
 
-        elif cmdType == 'element':
-            value = self.textify(command['value'])
+        elif cmdType == 'item':
             index = self.textify(command['index'])
-            target = self.getVariable(command['target'])
-            val = self.getSymbolValue(target)
-            content = val.getContent()
-            if content == '':
-                content = []
-            # else:
-            # 	content = json.loads(content)
-            content[index] = value
-            val.setContent(content)
-            self.putSymbolValue(target, val)
+            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':
@@ -1443,18 +1517,28 @@ class Core(Handler):
             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':
-            name = self.textify(command['name'])
+            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[name] = value
-            else: content[name] = self.textify(value)
-            variable.setContent(ECValue(domain=self.getName(), type='dict', content=content))
+            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':
@@ -1510,7 +1594,7 @@ class Core(Handler):
             record = self.getSymbolRecord()
             if isinstance(record['object'], ECObject):
                 command['target'] = record['name']
-                value = ECValue(domain=self.getName(), type='str', content='\n')
+                value = ECValue(type=str, content='\n')
                 command['on'] = value
                 if self.peek() == 'on':
                     self.nextToken()
@@ -1533,7 +1617,7 @@ class Core(Handler):
         object.setElements(elements)
         
         for n in range(0, elements):
-            val = ECValue(domain=self.getName(), type='str', content=content[n])
+            val = ECValue(type=str, content=content[n])
             object.setIndex(n)
             object.setValue(val)
         object.setIndex(0)
@@ -1602,7 +1686,7 @@ class Core(Handler):
             self.checkObjectType(record, ECObject)
             # If 'giving' comes next, this variable is the second value
             if self.peek() == 'giving':
-                v2 = ECValue(domain=self.getName(), type='symbol')
+                v2 = ECValue(type='symbol')
                 v2.setContent(record['name'])
                 command['value2'] = v2
                 self.nextToken()
@@ -1640,7 +1724,7 @@ class Core(Handler):
         # 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(domain=self.getName(), type='int', content=int(value2) - int(value1))
+            targetValue = ECValue(type=int, content=int(value2) - int(value1))
         else:
             # take X from Y
             targetValue = self.getSymbolValue(target)
@@ -1661,7 +1745,7 @@ class Core(Handler):
     def r_toggle(self, command):
         target = self.getVariable(command['target'])
         value = self.getSymbolValue(target)
-        val = ECValue(domain=self.getName(), type='boolean', content=not value.getContent())
+        val = ECValue(type=bool, content=not value.getContent())
         self.putSymbolValue(target, val)
         self.add(command)
         return self.nextPC()
@@ -1679,7 +1763,7 @@ class Core(Handler):
     def r_trim(self, command):
         record = self.getVariable(command['name'])
         value = record['value'][record['index']]
-        if value.getType() == 'str':
+        if value.getType() == str:
             content = value.getContent()
             value.setContent(content.strip())
         return self.nextPC()
@@ -1715,7 +1799,8 @@ class Core(Handler):
 
     # use plugin {class} from {source}
     # use graphics
-    # use psutil.
+    # use mqtt
+    # use psutil
     def k_use(self, command):
         if self.peek() == 'plugin':
             # Import a plugin
@@ -1730,9 +1815,15 @@ class Core(Handler):
             token = self.nextToken()
             if token == 'graphics':
                 return self.program.useGraphics()
+            if 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):
@@ -1856,7 +1947,7 @@ class Core(Handler):
     #############################################################################
     # Compile a value in this domain
     def compileValue(self):
-        value = ECValue(domain=self.getName())
+        value = ECValue()
         token = self.getToken()
         if self.isSymbol():
             value.setValue(type='symbol', content=token)
@@ -1879,7 +1970,7 @@ class Core(Handler):
         if token in ['now', 'today', 'newline', 'tab', 'empty']:
             return value
 
-        if token in ['stringify', 'prettify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer', 'encode', 'decode']:
+        if token in ['stringify', 'prettify', 'json', 'lowercase', 'uppercase', 'hash', 'random', float, 'integer', 'encode', 'decode']:
             value.setContent(self.nextValue())
             return value
 
@@ -1893,27 +1984,25 @@ class Core(Handler):
                 value.format = None
             return value
 
-        if token == 'element':
+        if token == 'item':
             value.index = self.nextValue()
             if self.nextToken() == 'of':
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
-                    self.checkObjectType(record['object'], ECVariable)
-                    value.target = ECValue(domain=self.getName(), type='symbol', content=record['name'])
+                    self.checkObjectType(record['object'], ECList)
+                    value.target = ECValue(type='symbol', content=record['name'])
                     return value
             return None
 
-        if token == 'property':
-            value.name = self.nextValue() # type: ignore
-            if self.nextToken() == 'of':
+        if token == 'entry':
+            value.key = self.nextValue() # type: ignore
+            if self.nextToken() in ('in', 'of'):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
                     object = record['object']
-                    self.checkObjectType(object, ECObject)
-                    if hasattr(object, 'name'):
-                        value.target = ECValue(domain=self.getName(), type='symbol', content=object.name) # type: ignore
-                        return value
-                    raise RuntimeError(self.program, f'Object {record["name"]} has no attribute "name"')
+                    self.checkObjectType(object, ECDictionary)
+                    value.target = object.name
+                    return value
             return None
 
         if token == 'arg':
@@ -1937,11 +2026,11 @@ class Core(Handler):
         token = self.getToken()
         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() # type: ignore
                     return value
@@ -1949,8 +2038,9 @@ class Core(Handler):
 
         if token == 'keys':
             if self.nextIs('of'):
-                value.name = self.nextValue() # type: ignore
-                return value
+                if self.nextIsSymbol():
+                    value.name = self.getToken() # type: ignore
+                    return value
             return None
 
         if token == 'count':
@@ -1958,7 +2048,7 @@ class Core(Handler):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
                     object = record['object']
-                    if isinstance(object, ECVariable):
+                    if isinstance(object, ECList):
                         value.setContent(record['name'])
                         return value
             return None
@@ -1970,6 +2060,7 @@ class Core(Handler):
                     if self.peek() == 'in':
                         value.value = None # type: ignore
                         value.setType('indexOf')
+                        self.nextToken()
                         if self.nextIsSymbol():
                             value.target = self.getSymbolRecord()['name'] # type: ignore
                             return value
@@ -2033,9 +2124,6 @@ class Core(Handler):
             value.haystack = self.nextValue() # type: ignore
             return value
 
-        if token == 'message':
-            return value
-
         if token == 'timestamp':
             value.format = None # type: ignore
             if self.peek() == 'of':
@@ -2053,10 +2141,6 @@ class Core(Handler):
                 return value
             return None
 
-        if token == 'weekday':
-            value.setType('weekday')
-            return value
-
         if token == 'error':
             token = self.peek()
             if token == 'code':
@@ -2104,7 +2188,7 @@ class Core(Handler):
     def modifyValue(self, value):
         if self.peek() == 'modulo':
             self.nextToken()
-            mv = ECValue(domain=self.getName(), type='modulo', content=value)
+            mv = ECValue(type='modulo', content=value)
             mv.modval = self.nextValue() # type: ignore
             return mv
 
@@ -2114,26 +2198,28 @@ class Core(Handler):
     # Value handlers
 
     def v_args(self, v):
-        return ECValue(domain=self.getName(), type='str', content=json.dumps(self.program.argv))
+        return ECValue(type=str, content=json.dumps(self.program.argv))
 
     def v_arg(self, v):
         index = self.textify(v['index'])
         if index >= len(self.program.argv):
             RuntimeError(self.program, 'Index exceeds # of args')
-        return ECValue(domain=self.getName(), type='str', content=self.program.argv[index])
+        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 = ECValue(domain=self.getName(), type='boolean', content=v.getContent())
+        return self.v_bool(v)
 
     def v_cos(self, v):
         angle = self.textify(v['angle'])
         radius = self.textify(v['radius'])
-        return ECValue(domain=self.getName(), type='int', content=round(math.cos(angle * 0.01745329) * radius))
+        return ECValue(type=int, content=round(math.cos(angle * 0.01745329) * radius))
 
     def v_count(self, v):
-        content = self.textify(self.getVariable(v.getContent()))
-        if content == None: raise RuntimeError(self.program, 'Count: No value provided')
-        return ECValue(domain=self.getName(), type='int', content=len(content))
+        variable = self.getObject(self.getVariable(v.getContent()))
+        return ECValue(type=int, content=variable.getItemCount())
 
     def v_datime(self, v):
         ts = self.textify(v.timestamp)
@@ -2142,11 +2228,11 @@ class Core(Handler):
             fmt = '%b %d %Y %H:%M:%S'
         else:
             fmt = self.textify(fmt)
-        return ECValue(domain=self.getName(), type='str', content=datetime.fromtimestamp(ts/1000).strftime(fmt))
+        return ECValue(type=str, content=datetime.fromtimestamp(ts/1000).strftime(fmt))
 
     def v_decode(self, v):
         content = self.textify(v.getContent())
-        value = ECValue(domain=self.getName(), type='str')
+        value = ECValue(type=str)
         if self.encoding == 'utf-8':
             value.setContent(content.decode('utf-8'))
         elif self.encoding == 'base64':
@@ -2161,34 +2247,18 @@ class Core(Handler):
             value = v
         return value
 
-    def v_element(self, v):
-        index = self.textify(v.index)
-        targetName = v.target
-        target = self.getVariable(targetName.getContent())
-        variable = target['object']
-        self.checkObjectType(variable, ECObject)
-        content = variable.getContent()
-        if not type(content) == list:
-            RuntimeError(self.program, f'{targetName} is not a list')
-        if index >= len(content):
-            RuntimeError(self.program, f'Index out of range in {targetName}')
-        targetValue = content[index]
-        if isinstance(targetValue, ECValue):
-            targetValue = self.textify(targetValue)
-        return targetValue
-
     def v_elements(self, v):
         var = self.getVariable(v.name)
         object = var['object']
         self.checkObjectType(object, ECVariable)
-        return ECValue(domain=self.getName(), type='int', content=object.getElements())
+        return ECValue(type=int, content=object.getElements())
 
     def v_empty(self, v):
-        return ECValue(domain=self.getName(), type='str', content=''  )
+        return ECValue(type=str, content=''  )
 
     def v_encode(self, v):
         content = self.textify(v.getContent())
-        value = ECValue(domain=self.getName(), type='str')
+        value = ECValue(type=str)
         if self.encoding == 'utf-8':
             value.setContent(content.encode('utf-8'))
         elif self.encoding == 'base64':
@@ -2203,26 +2273,31 @@ class Core(Handler):
             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 = ECValue(domain=self.getName())
+        value = ECValue()
         item = v.item
         if item == 'errorCode':
-            value.setValue(type='int', content=errorCode)
+            value.setValue(type=int, content=errorCode)
         elif item == 'errorReason':
-            value.setValue(type='str', content=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 '')
+            value.setValue(type=str, content=record['error'] if 'error' in record else '')
         return value
 
     def v_files(self, v):
         path = self.textify(v.target)
-        return ECValue(domain=self.getName(), type='str', content=json.dumps(os.listdir(path)))
+        return ECValue(type=str, content=json.dumps(os.listdir(path)))
 
     def v_float(self, v):
         val = self.textify(v.getContent())
-        value = ECValue(domain=self.getName(), type='float')
+        value = ECValue(type=float)
         try:
             value.setContent(float(val))
         except:
@@ -2238,130 +2313,151 @@ class Core(Handler):
             RuntimeError(self.program, 'Invalid "from" value')
         if to is not None and type(to) != int:
             RuntimeError(self.program, 'Invalid "to" value')
-        return ECValue(domain=self.getName(), type='str', content=content[start:] if to == None else content[start:to])
+        return ECValue(type=str, content=content[start:] if to == None else content[start:to])
 
     def v_hash(self, v):
         hashval = self.textify(v.getContent())
-        return ECValue(domain=self.getName(), type='str', content=hashlib.sha256(hashval.encode('utf-8')).hexdigest())
+        return ECValue(type=str, content=hashlib.sha256(hashval.encode('utf-8')).hexdigest())
 
     def v_index(self, v):
         record = self.getVariable(v.name)
         object = self.getObject(record)
-        return ECValue(domain=self.getName(), type='int', content=object.getIndex())
+        return ECValue(type=int, content=object.getIndex())
 
     def v_indexOf(self, v):
         value = v.value
         if value == None:
-            value = self.getSymbolValue(v.variable).getContent()
+            var = self.getObject(self.getVariable(v.variable))
+            value = var.getContent()
         else:
             value = self.textify(value)
-        target = self.getVariable(v.target)
-        data = self.getSymbolValue(target).getContent()
-        try: index = data.index(value)
-        except: index = -1
-        return ECValue(domain=self.getName(), type='int', content=index)
+        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.textify(v.getValue())
-        return ECValue(domain=self.getName(), type='int', content=int(val))
+        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.textify(v.getContent())
-        value = ECValue(domain=self.getName())
+        value = ECValue()
         try:
             v = json.loads(item)
             if type(v) == list: value.setType('list')
             elif type(v) == dict: value.setType('dict')
-            else: value.setType('str')  
+            else: value.setType(str)  
             value.setContent(v)
         except:
             value = None
         return value
 
     def v_keys(self, v):
-        value = self.textify(v.name)
-        return ECValue(domain=self.getName(), type='list', content=list(value.keys())) # type: ignore
+        dictionary = self.getObject(self.getVariable(v.name))
+        return ECValue(type='list', content=list(dictionary.keys())) # type: ignore
 
     def v_left(self, v):
         content = self.textify(v.getContent())
         count = self.textify(v.count)
-        return ECValue(domain=self.getName(), type='str', content=content[0:count])
+        return ECValue(type=str, content=content[0:count])
 
     def v_lengthOf(self, v):
         content = self.textify(v.getContent())
         if type(content) == str:
-            return ECValue(domain=self.getName(), type='int', content=len(content))
+            return ECValue(type=int, content=len(content))
         RuntimeError(self.program, 'Value is not a string')
 
     def v_lowercase(self, v):
         content = self.textify(v.getValue())
-        return ECValue(domain=self.getName(), type='str', content=content.lower())
+        return ECValue(type=str, content=content.lower())
 
     def v_message(self, v):
-        return ECValue(domain=self.getName(), type='str', content=self.program.message)
+        return ECValue(type=str, content=self.program.message)
 
     def v_modification(self, v):
         fileName = self.textify(v['fileName'])
         ts = int(os.stat(fileName).st_mtime)
-        return ECValue(domain=self.getName(), type='int', content=ts)
+        return ECValue(type=int, content=ts)
 
     def v_modulo(self, v):
         val = self.textify(v.getContent())
         modval = self.textify(v.modval)
-        return ECValue(domain=self.getName(), type='int', content=val % modval)
+        return ECValue(type=int, content=val % modval)
 
     def v_newline(self, v):
-        return ECValue(domain=self.getName(), type='str', content='\n')
+        return ECValue(type=str, content='\n')
 
     def v_now(self, v):
-        return ECValue(domain=self.getName(), type='int', content=int(time.time()))
+        return ECValue(type=int, content=int(time.time()))
 
     def v_position(self, v):
         needle = self.textify(v.needle)
         haystack = self.textify(v.haystack)
         last = v.last
-        return ECValue(domain=self.getName(), type='int', content=haystack.rfind(needle) if last else haystack.find(needle))
+        return ECValue(type=int, content=haystack.rfind(needle) if last else haystack.find(needle))
 
     def v_prettify(self, v):
         item = self.textify(v.getContent())
-        return ECValue(domain=self.getName(), type='str', content=json.dumps(item, indent=4))
+        if isinstance(item, str): item = json.loads(item)
+        return ECValue(type=str, content=json.dumps(item, indent=4))
 
     def v_property(self, v):
         propertyName = v.name
         propertyValue = self.textify(propertyName)
         targetName = v.target
-        targetValue = self.textify(targetName)
-        try:
-            targetObject = json.loads(targetValue)
-        except:
-            targetObject = targetValue
-        if type(targetObject) != dict:
-            RuntimeError(self.program, f'{targetName} is not a dictionary')
-        if not propertyValue in targetObject:
-            RuntimeError(self.program, f'This value does not have the property \'{propertyValue}\'')
-        value = targetObject[propertyValue]
-        if isinstance(value, ECValue):
-            value = self.textify(value)
-        return value
+        target = self.getVariable(targetName.getContent())
+        variable = self.getObject(target)
+        return variable.getProperty(propertyValue)
 
     def v_random(self, v):
         limit = self.textify(v.getValue())
-        return ECValue(domain=self.getName(), type='int', content=random.randrange(0, limit))
+        return ECValue(type=int, content=random.randrange(0, limit))
 
     def v_right(self, v):
         content = self.textify(v.getContent())
         count = self.textify(v.count)
-        return ECValue(domain=self.getName(), type='str', content=content[-count:])
+        return ECValue(type=str, content=content[-count:])
 
     def v_sin(self, v):
         angle = self.textify(v.angle)
         radius = self.textify(v.radius)
-        return ECValue(domain=self.getName(), type='int', content=round(math.sin(angle * 0.01745329) * 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.textify(v.getContent())
-        self.checkObjectType(item, (dict, list))
-        return ECValue(domain=self.getName(), type='str', content=json.dumps(item))
+        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, v):
@@ -2373,28 +2469,28 @@ class Core(Handler):
         elif keyword == 'variable':
             return self.getSymbolValue(record)
         elif keyword == 'ssh':
-            return ECValue(domain=self.getName(), type='boolean', content=True if 'ssh' in record and record['ssh'] != None else False)
+            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.textify(v.getContent())
         result = os.popen(command).read()
-        return ECValue(domain=self.getName(), type='str', content=result)
+        return ECValue(type=str, content=result)
 
     def v_tab(self, v):
-        return ECValue(domain=self.getName(), type='str', content='\t')
+        return ECValue(type=str, content='\t')
 
     def v_tan(self, v):
         angle = self.textify(v['angle'])
         radius = self.textify(v['radius'])
-        return ECValue(domain=self.getName(), type='int', content=round(math.tan(angle * 0.01745329) * radius))
+        return ECValue(type=int, content=round(math.tan(angle * 0.01745329) * radius))
 
     def v_ticker(self, v):
-        return ECValue(domain=self.getName(), type='int', content=self.program.ticker)
+        return ECValue(type=int, content=self.program.ticker)
 
     def v_timestamp(self, v):
-        value = ECValue(domain=self.getName(), type='int')
+        value = ECValue(type=int)
         fmt = v.format
         if fmt == None:
             value.setContent(int(time.time()))
@@ -2407,24 +2503,24 @@ class Core(Handler):
         return value
 
     def v_today(self, v):
-        return ECValue(domain=self.getName(), type='int', content=int(datetime.combine(datetime.now().date(),datetime.min.time()).timestamp()) * 1000)
+        return ECValue(type=int, content=int(datetime.combine(datetime.now().date(),datetime.min.time()).timestamp()) * 1000)
 
     def v_trim(self, v):
         content = v.getContent()
         content = self.textify(content)
-        return ECValue(domain=self.getName(), type='str', content=content.strip())
+        return ECValue(type=str, content=content.strip())
 
     def v_type(self, v):
-        value = ECValue(domain=self.getName(), type='str')
+        value = ECValue(type=str)
         val = self.textify(v['value'])
         if val is None:
             value.setContent('none')
         elif type(val) is str:
-            value.setContent('str')
+            value.setContent(str)
         elif type(val) is int:
             value.setContent('numeric')
         elif type(val) is bool:
-            value.setContent('boolean')
+            value.setContent(bool)
         elif type(val) is list:
             value.setContent('list')
         elif type(val) is dict:
@@ -2433,11 +2529,14 @@ class Core(Handler):
 
     def v_uppercase(self, v):
         content = self.textify(v.getContent())
-        return ECValue(domain=self.getName(), type='str', content=content.upper())
+        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.textify(v.getContent())
-        return ECValue(domain=self.getName(), type='int', content=int(v) if v != '' else 0)
+        return ECValue(type=int, content=int(v) if v != '' else 0)
     
     def v_variable(self, v):
         name = v.getContent()
@@ -2448,7 +2547,7 @@ class Core(Handler):
         return value
 
     def v_weekday(self, v):
-        return ECValue(domain=self.getName(), type='int', content=datetime.today().weekday())
+        return ECValue(type=int, content=datetime.today().weekday())
 
     #############################################################################
     # Compile a condition
@@ -2494,6 +2593,10 @@ class Core(Handler):
                         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:
@@ -2505,10 +2608,15 @@ class Core(Handler):
 
         if token == 'has':
             self.nextToken()
-            if self.nextToken() == 'property':
-                prop = self.nextValue()
-                condition.type = 'hasProperty' # type: ignore
-                condition.property = prop # type: ignore
+            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
 
@@ -2517,10 +2625,15 @@ class Core(Handler):
             if self.nextIs('not'):
                 token = self.nextToken()
                 if token == 'have':
-                    if self.nextToken() == 'property':
-                        prop = self.nextValue()
-                        condition.type = 'hasProperty' # type: ignore
-                        condition.property = prop # type: ignore
+                    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':
@@ -2548,7 +2661,7 @@ class Core(Handler):
                 condition.negate = True # type: ignore
             token = self.nextToken()
             condition.type = token # type: ignore
-            if token in ['numeric', 'string', 'boolean', 'none', 'list', 'object', 'even', 'odd', 'empty']:
+            if token in ['numeric', 'string', 'bool', 'boolean', 'none', 'list', 'object', 'even', 'odd', 'empty']:
                 return condition
             if token in ['greater', 'less']:
                 if self.nextToken() == 'than':
@@ -2560,7 +2673,7 @@ class Core(Handler):
  
         if condition.value1: # type: ignore
             # It's a boolean if
-            condition.type = 'boolean' # type: ignore
+            condition.type = bool # type: ignore
             return condition
 
         self.warning(f'Core.compileCondition: I can\'t get a conditional:')
@@ -2576,7 +2689,7 @@ class Core(Handler):
     #############################################################################
     # Condition handlers
 
-    def c_boolean(self, condition):
+    def c_bool(self, condition):
         value = self.textify(condition.value1)
         if type(value) == bool:
             return not value if condition.negate else value
@@ -2590,12 +2703,24 @@ 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):
+        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
-        elif type(value) == str or type(value) == list or type(value) == dict:
+        elif isinstance(value, str):
             comparison = len(value) == 0
         else:
             domainName = condition.value1.domain
@@ -2623,20 +2748,17 @@ class Core(Handler):
             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.textify(condition.value1)
+        record = self.getVariable(condition.value1)
+        variable = self.getObject(record)
         prop = self.textify(condition.property)
-        if isinstance(value, str):
-            try:
-                jsonValue = json.loads(value)
-                value = jsonValue
-            except:
-                pass
-        try:
-            value[prop]
-            hasProp = True
-        except:
-            hasProp = False
+        hasProp = variable.hasProperty(prop)
         return not hasProp if condition.negate else hasProp
 
     def c_includes(self, condition):