Development of Python version

Author: graham-trott

py/README.md

@@ -31,7 +31,7 @@ This class contans compiler and runtime modules for core keywords, values and co
  - a `compileCondition()` function to compile 'conditions'
  - a `c_xxx()` function to evaluate each runtime 'condition'
 
-Each extension package has the same structure and deals with its own vocabulary and syntax.
+Each extension package has the same structure and deals with its own vocabulary and syntax. For example, `ec_graphics.py`, which is currently under development.
 
 The individual compiler functions make heavy use of the Compiler class to retrieve tokens and process them. When they successfully complete the compilation of any given language structure they return an 'intermediate code' object with some standard fields such as the name of the package (the 'domain'), the script line number, and other fields that relate to the specific keyword, value or condition. This object goes into the array that becomes the program to be run.
 

py/benchmark.ecs

@@ -14,49 +14,49 @@
 
 	!go to Skip
 
-	print `FOR loop counting to 10,000`
+	print `FOR loop counting to 100,000`
 	put now into Start
 	put 0 into N
-	while N is less than 10000 increment N
+	while N is less than 100000 increment N
 	put now into Finish
 	take Start from Finish giving N
-	print N cat ` milliseconds`
+	print N cat ` seconds`
 
 !	debug step
 
-	print `Compare 10,000 long integers for equality`
+	print `Compare 100,000 long integers for equality`
 	put now into Start
 	put 0 into N
-	while N is less than 10000
+	while N is less than 100000
 	begin
 		if N is 1234567890 begin end
 		increment N
 	end
 	put now into Finish
 	take Start from Finish giving N
-	print N cat ` milliseconds`
+	print N cat ` seconds`
 
-	print `Allocate and initialize a 10,000 element array`
+	print `Allocate and initialize a 100,000 element array`
 	put now into Start
-	set the elements of Array to 10000
+	set the elements of Array to 100000
 	put 0 into N
-	while N is less than 10000
+	while N is less than 100000
 	begin
 		index Array to N
 		put N into Array
 		increment N
 	end
 	put now into Finish
 	take Start from Finish giving N
-	print N cat ` milliseconds`
+	print N cat ` seconds`
 
-	print `Allocate and initialize a 50x50 dictionary`
+	print `Allocate and initialize a 200x5200 dictionary`
 	put now into Start
 	put 0 into N
-	while N is less than 50
+	while N is less than 200
 	begin
 		put 0 into M
-		while M is less than 50
+		while M is less than 200
 		begin
 			put M into Dictionary as N cat ` ` cat M
 			increment M
@@ -65,7 +65,7 @@
 	end
 	put now into Finish
 	take Start from Finish giving N
-	print N cat ` milliseconds`
+	print N cat ` seconds`
 
 	put 20 into Y
 	put 6 into X
@@ -112,7 +112,7 @@
 	put 51 into N
 	while N is less than 54
 	begin
-			if 52 is greater than N print `52 is greater than ` cat N else print `52 is not greater than  cat N
+			if 52 is greater than N print `52 is greater than ` cat N else print `52 is not greater than ` cat N
 			if 52 is less than N print `52 is less than ` cat N else print `52 is not less than ` cat N
 			if 52 is not greater than N print `52 is not greater than ` cat N else print `52 is greater than ` cat N
 			if 52 is not less than N print `52 is not less than ` cat N else print `52 is less than ` cat N
@@ -128,16 +128,16 @@ Loop1:
 	add 1 to N
 	if N is less than 10 go to Loop1
 
-	open File `/home/pi/test.txt` for writing
+	open File `test.txt` for writing
 	write line `Hello, world!` to File
 	close File
-	open File `/home/pi/test.txt` for appending
+	open File `test.txt` for appending
 	write `I'm back!` to File
 	close File
 
 Skip:
 	wait 2 seconds
-	open File `/home/pi/test.txt` for reading
+	open File `test.txt` for reading
 	read line X from File
 	print X
 	read X from File

py/config

@@ -9,17 +9,14 @@ class EasyCoder:
 	def __init__(self):
 		self.version = 1
 
-	domainMap = {}
-	domainMap['core'] = Core
-
 	if (len(sys.argv) > 1):
 		scriptName = sys.argv[1]
 
 		f = open(scriptName, 'r')
 		source = f.read()
 		f.close()
 
-		Program(source, domainMap)
+	Program(source, [Core])
 
 if __name__ == '__main__':
     EasyCoder()

py/dhcpcd.conf

@@ -6,6 +6,7 @@ def __init__(self, compiler, message):
 class RuntimeError:
 	def __init__(self, message):
 		print(f'Runtime Error: {message}')
+		quit()
 
 class Script:
 	def __init__(self, source):

py/easycoder.py

@@ -1,4 +1,4 @@
-from ec_classes import Token, FatalError
+from ec_classes import FatalError
 from ec_value import Value
 from ec_condition import Condition
 
@@ -56,7 +56,6 @@ def nextValue(self):
 
 	# Get a constant
 	def getConstant(self, token):
-		self.index += 1
 		return self.value.compileConstant(token)
 
 	# Get a condition
@@ -108,21 +107,26 @@ def showWarnings(self):
 			print(f'Line {self.getLino() + 1}: {warning}')
 
 	def getSymbolRecord(self):
-		symbolRecord = self.code[self.symbols[self.getToken()]]
-		symbolRecord['used'] = True
-		return symbolRecord
+		token = self.getToken()
+		symbol = self.symbols[token]
+		if symbol != None:
+			symbolRecord = self.code[symbol]
+			symbolRecord['used'] = True
+			return symbolRecord
+		return None
 
 	def compileLabel(self, command):
-		return self.compileSymbol(command, self.getToken(), False)
+		return self.compileSymbol(command, 'label', self.getToken(), False)
 
-	def compileVariable(self, command, valueHolder):
-		return self.compileSymbol(command, self.nextToken(), valueHolder)
+	def compileVariable(self, command, type, valueHolder):
+		return self.compileSymbol(command, type, self.nextToken(), valueHolder)
 
-	def compileSymbol(self, command, name, valueHolder):
+	def compileSymbol(self, command, type, name, valueHolder):
 		if hasattr(self.symbols, name):
 			FatalError(self, f'{self.code[self.pc].lino}: Duplicate symbol name "{name}"')
 			return False
 		self.symbols[name] = self.getPC()
+		command['type'] = type
 		command['isSymbol'] = True
 		command['used'] = False
 		command['valueHolder'] = valueHolder
@@ -150,8 +154,8 @@ def compileToken(self):
 				command['keyword'] = token
 				command['debug'] = True
 				result = handler(command)
-				return result
-			else:
+				if result:
+					return result
 				self.rewind()
 		FatalError(self, f'No handler found for "{token}"')
 		return False
@@ -161,7 +165,7 @@ def compileOne(self):
 		keyword = self.getToken()
 		if not keyword:
 			return False
-		#print(f'Compile keyword "{keyword}"')
+		# print(f'Compile keyword "{keyword}"')
 		if keyword.endswith(':'):
 			command = {}
 			command['domain'] = None
@@ -176,8 +180,6 @@ def compileFrom(self, index, stopOn):
 		while True:
 			token = self.tokens[self.index]
 			keyword = token.token
-#			line = self.script.lines[token.lino]
-#			print(f'{keyword} - {line}')
 			if keyword != 'else':
 				if self.compileOne() == True:
 					if self.index == len(self.tokens) - 1:

py/ec_autogui.py

@@ -21,6 +21,6 @@ def compileCondition(self):
 			return None
 
 	def testCondition(self, condition):
-		handler = self.program.domainList[condition['domain']]
+		handler = self.program.domainIndex[condition['domain']]
 		handler = handler.conditionHandler(condition['type'])
-		return handler(condition)
+		return handler(condition)

py/ec_classes.py

@@ -1,4 +1,4 @@
-import json, math, hashlib, threading, os, requests, time
+import json, math, hashlib, threading, os, requests, time, numbers
 from datetime import datetime, timezone
 from random import randrange
 from ec_classes import FatalError, RuntimeError
@@ -124,7 +124,7 @@ def r_clear(self, command):
         val['type'] = 'boolean'
         val['content'] = False
         self.putSymbolValue(target, val)
-        self.add(command)
+        # self.add(command)
         return self.nextPC()
 
     def k_close(self, command):
@@ -173,7 +173,7 @@ def r_decrement(self, command):
         return self.incdec(command, '-')
 
     def k_dictionary(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command, 'dictionary', False)
 
     def r_dictionary(self, command):
         return self.nextPC()
@@ -245,10 +245,10 @@ def k_exit(self, command):
         return True
 
     def r_exit(self, command):
-        return 0
+        return -1
 
     def k_file(self, command):
-        return self.compileVariable(command, False)
+        return self.compileVariable(command, 'file', False)
 
     def r_file(self, command):
         return self.nextPC()
@@ -561,6 +561,7 @@ def r_print(self, command):
         if value != None:
             print(f'-> {value}')
             return self.nextPC()
+        return False
 
     def k_put(self, command):
         command['value'] = self.nextValue()
@@ -621,17 +622,20 @@ def k_read(self, command):
         else:
             command['line'] = False
         if self.nextIsSymbol():
-                symbolRecord = self.getSymbolRecord()
-                if symbolRecord['valueHolder']:
-                    if self.peek() == 'from':
-                        self.nextToken()
-                        if self.nextIsSymbol():
-                            fileRecord = self.getSymbolRecord()
-                            if fileRecord['keyword'] == 'file':
-                                command['target'] = symbolRecord['name']
-                                command['file'] = fileRecord['name']
-                                self.add(command)
-                                return True
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['valueHolder']:
+                if self.peek() == 'from':
+                    self.nextToken()
+                    if self.nextIsSymbol():
+                        fileRecord = self.getSymbolRecord()
+                        if fileRecord['keyword'] == 'file':
+                            command['target'] = symbolRecord['name']
+                            command['file'] = fileRecord['name']
+                            self.add(command)
+                            return True
+            FatalError(self.program.compiler, f'Symbol "{symbolRecord["name"]}" is not a value holder')
+            return False
+        FatalError(self.program.compiler, f'Symbol "{self.getToken()}" has not been declared')
         return False
 
     def r_read(self, command):
@@ -781,13 +785,58 @@ def r_set(self, command):
             self.putSymbolValue(target, val)
             return self.nextPC()
 
+    def k_split(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['valueHolder']:
+                command['target'] = symbolRecord['name']
+                command['on'] = '\n'
+                if self.peek() == 'on':
+                    self.nextToken()
+                    command['on'] = self.getValue()
+                self.add(command)
+                return True
+        return False
+
+    def r_split(self, command):
+        target = self.getVariable(command['target'])
+        value = self.getSymbolValue(target)
+        content = value['content'].split(command['on'])
+        elements = len(content)
+        target['elements'] = elements
+        target['value'] = [None] * elements
+
+        for index, item in enumerate(content):
+            element = {}
+            element['type'] = 'text'
+            element['numeric'] = 'false'
+            element['content'] = item
+            target['value'][index] = element
+        
+        return self.nextPC()
+
     def k_stop(self, command):
         self.add(command)
         return True
 
     def r_stop(self, command):
         return 0
 
+    def k_system(self, command):
+        value = self.nextValue()
+        if value != None:
+            command['value'] = value
+            self.add(command)
+            return True
+        FatalError(self.program.compiler, 'I can\'t give this command')
+        return False
+
+    def r_system(self, command):
+        value = self.getRuntimeValue(command['value'])
+        if value != None:
+            os.system(value)
+            return self.nextPC()
+
     def k_take(self, command):
         # Get the (first) value
         command['value1'] = self.nextValue()
@@ -862,17 +911,19 @@ def r_toggle(self, command):
         val['type'] = 'boolean'
         val['content'] = not value['content']
         self.putSymbolValue(target, val)
-        self.add(command)
         return self.nextPC()
 
     def k_variable(self, command):
-        return self.compileVariable(command, True)
+        return self.compileVariable(command, 'variable', True)
 
     def r_variable(self, command):
         return self.nextPC()
 
     def k_wait(self, command):
-        command['value'] = self.nextValue()
+        value = self.nextValue()
+        if value is None:
+            return False
+        command['value'] = value
         multipliers = {}
         multipliers['milli'] = 1
         multipliers['millis'] = 1
@@ -881,7 +932,7 @@ def k_wait(self, command):
         multipliers['second'] = 1000
         multipliers['seconds'] = 1000
         multipliers['minute'] = 60000
-        multipliers['minutes7'] = 60000
+        multipliers['minutes'] = 60000
         command['multiplier'] = multipliers['second']
         token = self.peek()
         if token in multipliers:
@@ -1379,15 +1430,13 @@ def v_property(self, v):
         target = self.getVariable(v['target'])
         target = self.getSymbolValue(target)
         content = target['content']
-        if content == '':
-            content = ''
-            content['name'] = '(anon)'
+        val = content.get(name)
         value = {}
-        value['type'] = 'text'
-        if content.get(name):
-            value['content'] = content[name]
+        value['content'] = val
+        if isinstance(v, numbers.Number):
+            value['type'] = 'int'
         else:
-            value['content'] = ''
+            value['type'] = 'text'
         return value
 
     def v_random(self, v):
@@ -1572,7 +1621,10 @@ def c_includes(self, condition):
 
     def c_empty(self, condition):
         value = self.getRuntimeValue(condition['value1'])
-        comparison = len(value) == 0
+        if value == None:
+            comparison = True
+        else:
+            comparison = len(value) == 0
         return not comparison if condition['negate'] else comparison
 
     def c_exists(self, condition):

py/ec_compiler.py

@@ -0,0 +1,187 @@
+from ec_classes import FatalError, RuntimeError
+from ec_handler import Handler
+from graphson import createScreen, renderSpec, renderScreen, getElement, closeScreen, setOnClick
+
+class Graphics(Handler):
+
+    def __init__(self, compiler):
+        Handler.__init__(self, compiler)
+
+    def getName(self):
+        return 'graphics'
+
+    #############################################################################
+    # Keyword handlers
+
+    def k_attach(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            command['name'] = record['name']
+            if self.nextIs('to'):
+                value = self.nextValue()
+                command['id'] = value
+            self.add(command)
+        return True
+
+    def r_attach(self, command):
+        target = self.getVariable(command['name'])
+        id = self.getRuntimeValue(command['id'])
+        element = getElement(id)
+        if element == None:
+            FatalError(self.program.compiler, f'There is no screen element with id \'{self.getToken()}\'')
+        self.putSymbolValue(target, {'type': 'text', 'content': id})
+        return self.nextPC()
+
+    def k_close(self, command):
+        if self.nextToken() == 'screen':
+            self.add(command)
+        return True
+
+    def r_close(self, command):
+        closeScreen(self.screen)
+        self.screen = None
+        return self.nextPC()
+
+    def k_create(self, command):
+        if self.nextToken() == 'screen':
+            self.add(command)
+            return True
+        return False
+
+    def r_create(self, command):
+        self.screen = createScreen()
+        return self.nextPC()
+
+    def k_label(self, command):
+        return self.compileVariable(command, 'label', False)
+
+    def r_label(self, command):
+        return self.nextPC()
+
+    def k_on(self, command):
+        token = self.nextToken()
+        if token == 'click':
+            command['event'] = token
+            if self.peek() == 'in':
+                self.nextToken()
+            if self.nextIs('screen'):
+                command['target'] = None
+            elif self.isSymbol():
+                target = self.getSymbolRecord()
+                command['target'] = target['name']
+            else:
+                FatalError(self.program.compiler, f'{self.getToken()} is not a screen element')
+                return False
+            command['goto'] = self.getPC() + 2
+            self.add(command)
+            self.nextToken()
+            pcNext = self.getPC()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'gotoPC'
+            cmd['goto'] = 0
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            self.compileOne()
+            # Fixup the link
+            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            return True
+        return False
+
+    def r_on(self, command):
+        event = command['event']
+        if event == 'click':
+            target = command['target']
+            if target == None:
+                value = 'screen'
+            else:
+                widget = self.getVariable(target)
+                value = widget['value'][widget['index']]
+            pc = command['goto']
+            setOnClick(value['content'], lambda: self.run(pc))
+        return self.nextPC()
+
+    def k_rectangle(self, command):
+        return self.compileVariable(command, 'rectangle', False)
+
+    def r_rectangle(self, command):
+        return self.nextPC()
+
+    def k_render(self, command):
+        if self.nextIs('screen'):
+            command['name'] = None
+            self.add(command)
+            return True
+        elif self.isSymbol():
+            record = self.getSymbolRecord()
+            name = record['name']
+            type = record['type']
+            command['type'] = type
+            if type == 'variable':
+                command['name'] = name
+                if self.peek() == 'in':
+                    if self.nextIsSymbol():
+                        record = self.getSymbolRecord()
+                        type = record['type']
+                        name = record['name']
+                        if type in ['rectangle', 'ellipse']:
+                            command['parent'] = record['name']
+                            self.add(command)
+                            return True
+                        else:
+                            self.warning(f'{name} cannot be a parent of another element')
+                            return False
+                command['parent'] = 'screen'
+                self.add(command)
+                return True
+            FatalError(self.program.compiler, f'This variable type cannot be rendered')
+            return False
+        FatalError(self.program.compiler, 'Nothing specified to render')
+        return False
+
+    def r_render(self, command):
+        if command['name'] == None:
+            renderScreen(self.screen)
+        else:
+            variable = self.getVariable(command['name'])
+            spec = self.getRuntimeValue(variable)
+            offset = {'dx': 0, 'dy': 0}
+            result = renderSpec(self.screen, spec, offset)
+            if result != None:
+                RuntimeError(f'Rendering error: {result}')
+        return self.nextPC()
+    
+    #############################################################################
+    # Compile a value in this domain
+    def compileValue(self):
+        value = {}
+        value['domain'] = 'graphics'
+        if self.tokenIs('the'):
+            self.nextToken()
+        token = self.getToken()
+        if token == 'xxxxx':
+            return value
+
+        return None
+
+    #############################################################################
+    # Modify a value or leave it unchanged.
+    def modifyValue(self, value):
+        return value
+
+    #############################################################################
+    # Value handlers
+
+    def v_xxxxx(self, v):
+        value = {}
+        return value
+
+    #############################################################################
+    # Compile a condition
+    def compileCondition(self):
+        condition = {}
+        return condition
+
+    #############################################################################
+    # Condition handlers

py/ec_condition.py

@@ -49,12 +49,18 @@ def keywordHandler(self, name):
 
 	# Get a run handler
 	def runHandler(self, name):
-		return getattr(self, f'r_{name}')
+		if hasattr(self, f'r_{name}'):
+			return getattr(self, f'r_{name}')
+		return None
 
 	# Get a value handler
 	def valueHandler(self, name):
-		return getattr(self, f'v_{name}')
+		if hasattr(self, f'v_{name}'):
+			return getattr(self, f'v_{name}')
+		return None
 
 	# Get a condition handler
 	def conditionHandler(self, name):
-		return getattr(self, f'c_{name}')
+		if hasattr(self, f'c_{name}'):
+			return getattr(self, f'c_{name}')
+		return None

py/ec_core.py

@@ -6,11 +6,10 @@
 
 class Program:
 
-	def __init__(self, source, domainMap):
+	def __init__(self, source, domains):
 
-		self.domainMap = domainMap
-		self.domainList = {}
 		self.domains = []
+		self.domainIndex = {}
 		self.name = '<anon>'
 		self.code = []
 		self.symbols = {}
@@ -22,13 +21,10 @@ def __init__(self, source, domainMap):
 		self.compiler = Compiler(self)
 		self.value = self.compiler.value
 		self.condition = self.compiler.condition
-		for name in domainMap:
-			if name[0] != '_':
-				domain = domainMap[name](self.compiler)
-				self.domains.append(domain)
-		self.domainList = {}
-		for domain in self.domains:
-			self.domainList[domain.getName()] = domain
+		for domain in domains:
+			handler = domain(self.compiler)
+			self.domains.append(handler)
+			self.domainIndex[handler.getName()] = handler
 		self.queue = deque()
 
 		startCompile = time.time()
@@ -78,17 +74,24 @@ def doValue(self, value):
 				content += val
 			result['type'] = 'text'
 			result['content'] = content
-		elif valType == 'symbol':
-			name = value['name']
-			symbolRecord = self.getSymbolRecord(name)
-			if symbolRecord['value'] == [None]:
+		# elif valType == 'symbol':
+		# 	name = value['name']
+		# 	symbolRecord = self.getSymbolRecord(name)
+		# 	if symbolRecord['value'] == [None]:
+		# 		RuntimeError(f'Variable "{name}" has no value')
+		# 		return None
+		# 	handler = self.domainIndex[symbolRecord['domain']].valueHandler('symbol')
+		# 	result = handler(symbolRecord)
+		elif value['isSymbol']:
+			if value['value'] == [None]:
+				name = value['name']
 				RuntimeError(f'Variable "{name}" has no value')
 				return None
-			handler = self.domainList[symbolRecord['domain']].valueHandler('symbol')
-			result = handler(symbolRecord)
+			handler = self.domainIndex[value['domain']].valueHandler('symbol')
+			result = handler(value)
 		else:
 			# Call the given domain to handle a value
-			domain = self.domainList[value['domain']]
+			domain = self.domainIndex[value['domain']]
 			handler = domain.valueHandler(value['type'])
 			if handler:
 				result = handler(value)
@@ -203,7 +206,7 @@ def run(self, pc):
 						lino = command['lino'] + 1
 						line = self.script.lines[command['lino']].strip()
 						print(f'{self.name}: Line {lino}: PC: {self.pc} {domainName}:{keyword}:  {line}')
-					domain = self.domainList[domainName]
+					domain = self.domainIndex[domainName]
 					handler = domain.runHandler(keyword)
 					if handler:
 						self.pc = handler(self.code[self.pc])

py/ec_graphics.py

@@ -1,4 +1,4 @@
-import pytz, time
+import pytz
 from datetime import datetime
 
 def getTimestamp(t):

py/ec_handler.py

@@ -58,7 +58,7 @@ def compileValue(self):
 		token = self.getToken()
 		item = self.getItem()
 		if item == None:
-			FatalError(self.compiler, f'Cannot get the value of "{token}"')
+			self.warning(f'Cannot get the value of "{token}"')
 			return None
 
 		value = {}
@@ -75,16 +75,18 @@ def compileValue(self):
 		else:
 			value = item
 
-	# See if any domain has something to add to the value
+		# See if any domain has something to add to the value
 		for domain in self.domains:
 			value = domain.modifyValue(value)
 
 		return value
 
 	def compileConstant(self, token):
 		value = {}
-		if token.isnumeric():
+		if isinstance(token, str):
 			val = eval(token)
+		else:
+			val = token
 			if isinstance(val, int):
 				value['type'] = 'int'
 				value['content'] = val

py/ec_program.py

@@ -0,0 +1,204 @@
+import tkinter as tk
+import json
+
+elements = {}
+zlist = []
+
+def createScreen():
+    global dx, dy, running
+    running = True
+    screen = tk.Tk()
+    # screen.attributes('-fullscreen', True)
+
+    screen.overrideredirect(True)
+    w = 600
+    h = 800
+    # x = int((screen.winfo_screenwidth() / 2) - (w / 2))
+    dx = int(screen.winfo_screenwidth() - w)
+    dy = int((screen.winfo_screenheight() / 2) - (h / 2))
+    geometry = str(w) + 'x' + str(h) + '+' + str(dx) + '+' + str(dy) 
+    screen.geometry(geometry)
+
+    screen.bind('<Button-1>', onClick)
+    return screen
+
+def setOnClick(id, cb):
+    global elements
+    if id in elements:
+        elements[id]['cb'] = cb
+    else:
+        RuntimeError(f'Element \'{id}\' does not exist')
+    return
+
+def onClick(event):
+    global dx, dy, zlist
+    x = event.x_root
+    y = event.y_root
+    # print('Clicked at : '+ str(x) +","+ str(y))
+    for i in range(1, len(zlist) + 1):
+        element = zlist[-i]
+        id = list(element)[0]
+        values = element[id]
+        x1 = dx + values['left']
+        x2 = x1 + values['width']
+        y1 = dy + values['top']
+        y2 = y1 + values['height']
+        if x >= x1 and x < x2 and y >= y1 and y < y2:
+            if id in elements:
+               pc = elements[id]['cb']()
+            else:
+                RuntimeError(f'Element \'{id}\' does not exist')
+            return pc
+    return
+
+def closeScreen(screen):
+    global running
+    running = False
+
+def renderScreen(screen):
+    screen.after(1000, lambda: afterCB(screen))
+    screen.mainloop()
+    return
+
+def afterCB(screen):
+    global running
+    if not running:
+        screen.destroy()
+    else:
+        screen.after(1000, lambda: afterCB(screen))
+
+# Render a graphic specification expressed as JSON text
+def renderSpec(screen, text, offset):
+    global canvas, elements, zlist
+
+    def renderCanvas(values):
+        global canvas
+        left = values['left'] if 'left' in values else 0
+        top = values['top'] if 'top' in values else 0
+        width = values['width'] if 'width' in values else 600
+        height = values['height'] if 'height' in values else 800
+        fill = values['fill'] if 'fill' in values else 'white'
+        canvas = tk.Canvas(master=screen, width=width, height=height, bg=fill)
+        canvas.place(x=left, y=top)
+        if '#' in values:
+            children = values['#']
+            if type(children) == list:
+                for item in children:
+                    if item in values:
+                        child = values[item]
+                        result = renderWidget(child, {'dx': left, 'dy': top})
+                        if result != None:
+                            return result
+                    else:
+                        return f'Element \'{item}\' does not exist'
+            else:
+                child = values[children]
+                return renderWidget(child, offset)
+
+    def renderRect(values, offset):
+        global canvas
+        left = values['left'] if 'left' in values else 10
+        top = values['top'] if 'top' in values else 10
+        left = offset['dx'] + left
+        top = offset['dy'] + top
+        width = values['width'] if 'width' in values else 100
+        height = values['height'] if 'height' in values else 100
+        right = left + width
+        bottom = top + height
+        fill = values['fill'] if 'fill' in values else None
+        outline = values['outline'] if 'outline' in values else None
+        rectId = canvas.create_rectangle(left, top, right, bottom, fill=fill, outline=outline)
+        if 'id' in values:
+            id = values['id']
+            spec = {
+                "id": rectId,
+                "left": left,
+                "top": top,
+                "width": width,
+                "height": height
+            }
+            elements[id] = spec
+            zlist.append({id: spec})
+        if '#' in values:
+            children = values['#']
+            if type(children) == list:
+                for item in children:
+                    if item in values:
+                        child = values[item]
+                        result = renderWidget(child, {'dx': left, 'dy': top})
+                        if result != None:
+                            return result
+                    else:
+                        return f'Unable to render \'{item}\''
+            else:
+                child = values[children]
+                result = renderWidget(child, offset)
+                if result != None:
+                    return result
+        return None
+   
+    def renderLabel(values, offset):
+        global canvas
+        left = values['left'] if 'left' in values else 10
+        top = values['top'] if 'top' in values else 10
+        left = offset['dx'] + left
+        top = offset['dy'] + top
+        width = values['width'] if 'width' in values else 100
+        height = values['height'] if 'height' in values else 100
+        right = left + width
+        bottom = top + height
+        fill = values['fill'] if 'fill' in values else None
+        outline = values['outline'] if 'outline' in values else None
+        color = values['color'] if 'color' in values else None
+        text = values['text'] if 'text' in values else ''
+        rectId = canvas.create_rectangle(left, top, right, bottom, fill=fill, outline=outline)
+        if 'id' in values:
+            id = values['id']
+            spec = {
+                "id": rectId,
+                "left": left,
+                "top": top,
+                "width": width,
+                "height": height
+            }
+            elements[id] = spec
+            zlist.append({id: spec})
+        canvas.create_text(left + width/2, top + height/2 + 5, fill=color, font="Times 22  bold", text=text, anchor='center')
+        return None
+
+    # Create a canvas or render a widget
+    def renderWidget(widget, offset):
+        widgetType = widget['type']
+        if widgetType == 'canvas':
+            return renderCanvas(widget)
+        elif widgetType == 'rect':
+            return renderRect(widget, offset)
+        elif widgetType == 'label':
+            return renderLabel(widget, offset)
+    
+    # Render a block - an array of widgets
+    def renderBlock(block, offset):
+        for name in block.keys():
+            result = renderWidget(block[name], offset)
+            if result != None:
+                return result
+
+    # Render a complete specification
+    def renderSpec(spec, offset):
+        if type(spec) == dict:
+                return renderBlock(item, offset)
+        elif type(spec) == list:
+            for item in spec:
+                result = renderBlock(item, offset)
+                if result != None:
+                    return result
+
+    # Render a specification supplied as JSON text
+    return renderSpec(json.loads(text), offset)
+
+def getElement(name):
+    global elements
+    if name in elements:
+        return elements[name]
+    else:
+        RuntimeError(f'Element \'{name}\' does not exist')

py/ec_timestamp.py

@@ -0,0 +1,57 @@
+[
+    {
+        "Background": {
+            "type": "canvas",
+            "left": 0,
+            "top": 0,
+            "width": 600,
+            "height": 800,
+            "fill": "#ffc",
+            "#": ["Rect 1", "Rect 2", "Exit"],
+
+            "Rect 1": {
+                "type": "rect",
+                "left": 100,
+                "top": 100,
+                "width": 200,
+                "height": 100,
+                "fill": "red",
+                "outline": "black"
+            },
+
+            "Rect 2": {
+                "type": "rect",
+                "left": 500,
+                "top": 500,
+                "width": 100,
+                "height": 200,
+                "fill": "green",
+                "outline": "black",
+                "#":["Rect 2A"],
+
+                "Rect 2A": {
+                    "type": "rect",
+                    "left": 10,
+                    "top": 100,
+                    "width": 50,
+                    "height": 50,
+                    "fill": "blue",
+                    "outline": "white"
+                }
+            },
+
+            "Exit": {
+                "type": "label",
+                "id": "exit",
+                "left": 530,
+                "top": 760,
+                "width": 60,
+                "height": 30,
+                "fill": "black",
+                "outline": "red",
+                "color": "yellow",
+                "text": "Exit"
+            }
+        }
+    }
+]

py/ec_value.py

@@ -1,22 +1,19 @@
 #! /bin/python
 
-import sys
 from ec_program import Program
 from ec_core import Core
+from ec_graphics import Graphics
 
 class EasyCoder:
 
 	def __init__(self):
 		self.version = 1
 
-	domainMap = {}
-	domainMap['core'] = Core
-
-	f = open('py/getip.ecs', 'r')
+	f = open('/home/graham/Dropbox/Code/VisualStudio/EasyCoder/easycoder.github.io/py/test.ecs', 'r')
 	source = f.read()
 	f.close()
 
-	Program(source, domainMap)
+	Program(source, [Core, Graphics])
 
 if __name__ == '__main__':
     EasyCoder()