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

easycoder/ec_graphics.py

@@ -0,0 +1,274 @@
+from .ec_classes import FatalError, RuntimeError, Object
+from .ec_handler import Handler
+from .ec_gutils import GUtils
+import PySimpleGUI as psg
+import json
+
+class Graphics(Handler):
+
+    def __init__(self, compiler):
+        Handler.__init__(self, compiler)
+        self.utils = GUtils()
+        self.eventHandlers = {}
+
+    def getName(self):
+        return 'graphics'
+
+    #############################################################################
+    # Keyword handlers
+
+    def k_add(self, command):
+        elements = []
+        token = self.nextToken()
+        if self.isSymbol():
+            symbolRecord = self.getSymbolRecord()
+            name = symbolRecord['name']
+            if symbolRecord['keyword'] == 'layout':
+                elements.append(name)
+                command['args'] = name
+            else: FatalError(self.compiler.program, f'\'{name}\' is not a layout')
+        elif token[0:2] == 'g_':
+            command['type'] = token
+            command['args'] = self.utils.getArgs(self)
+        else: return False
+        if self.nextIs('to'):
+            if self.nextIsSymbol():
+                symbolRecord = self.getSymbolRecord()
+                if symbolRecord['keyword'] == 'layout':
+                    command['target'] = symbolRecord['name']
+                    self.addCommand(command)
+                    return True
+        return False
+
+    def r_add(self, command):
+        target = self.getVariable(command['target'])
+        type = command['type']
+        args = command['args']
+        if not 'layout' in target:
+            target['layout'] = []
+        if args[0] == '{':
+            layout = json.loads(self.getRuntimeValue(json.loads(args)))
+            default = self.utils.getDefaultArgs(type)
+            for n in range(0, len(layout)):
+                args = self.utils.decode(default, layout[n])
+            target['layout'].append(self.utils.createElement(type, args))
+        else:
+            v = self.getVariable(args)
+            target['layout'].append(v['layout'])
+        return self.nextPC()
+
+    def k_capture(self, command):
+        if self.nextIs('event'):
+            if self.nextIs('as'):
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    command['target'] = record['name']
+                    self.addCommand(command)
+                    return True
+        return False
+
+    def r_capture(self, command):
+        target = self.getVariable(command['target'])
+        self.putSymbolValue(target, self.getConstant(self.eventValues))
+        return self.nextPC()
+
+    def k_close(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['keyword'] == 'window':
+                command['target'] = symbolRecord['name']
+                self.add(command)
+                return True
+        return False
+
+    def r_close(self, command):
+        target = self.getVariable(command['target'])
+        target['window'].close()
+        return self.nextPC()
+
+    # create {window} layout {layout}
+    # create {element} {args...}
+    def k_create(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            type = symbolRecord['keyword']
+            command['type'] = type
+            command['name'] = symbolRecord['name']
+            if type == 'window':
+                command['title'] = self.nextValue()
+                if self.nextIs('layout'):
+                    if self.nextIsSymbol():
+                        symbolRecord = self.getSymbolRecord()
+                        if symbolRecord['keyword'] == 'layout':
+                            command['layout'] = symbolRecord['name']
+                            self.addCommand(command)
+                            return True
+        return False
+
+    def r_create(self, command):
+        type = command['type']
+        record = self.getVariable(command['name'])
+        if type == 'window':
+            layout = self.getVariable(command['layout'])
+            title = self.getRuntimeValue(command['title'])
+            self.program.window = psg.Window(title, layout['layout'], finalize=True)
+            self.program.run(self.nextPC())
+            self.mainLoop()
+            self.program.kill()
+            return 0
+        else:
+            RuntimeError(self.program, 'Variable is not a window or an element')
+
+    def k_layout(self, command):
+        return self.compileVariable(command)
+
+    def r_layout(self, command):
+        return self.nextPC()
+
+    def k_on(self, command):
+        token = self.nextToken()
+        if token == 'event':
+            command['key'] = self.nextValue()
+            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()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'stop'
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # Fixup the link
+            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            return True
+        return False
+
+    def r_on(self, command):
+        key = self.getRuntimeValue(command['key'])
+        pc = command['goto']
+        self.eventHandlers[key] = lambda: self.run(pc)
+        return self.nextPC()
+
+    def k_popup(self, command):
+        command['message'] = self.nextValue()
+        self.addCommand(command)
+        return True
+
+    def r_popup(self, command):
+        psg.popup(self.getRuntimeValue(command['message']))
+        return self.nextPC()
+
+    def k_set(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            keyword = record['keyword']
+            if keyword == 'layout':
+                command['target'] = record['name']
+                if self.peek() == 'to':
+                    self.nextToken()
+                    command['type'] = self.nextToken()
+                    command['args'] = self.utils.getArgs(self)
+                else: command['args'] = None
+                self.addCommand(command)
+                return True
+            elif keyword == 'event':
+                pass
+            return False
+
+    def r_set(self, command):
+        target = self.getVariable(command['target'])
+        target['layout'] = []
+        type = command['type']
+        args = command['args']
+        if args != None:
+            if args[0] == '{':
+                layout = json.loads(self.getRuntimeValue(json.loads(args)))
+                default = self.utils.getDefaultArgs(type)
+                for n in range(0, len(layout)):
+                    args = self.utils.decode(default, layout[n])
+                target['layout'].append(self.utils.createElement(type, args))
+            else:
+                v = self.getVariable(args)
+                target['layout'].append(v['layout'])
+        return self.nextPC()
+
+    def k_window(self, command):
+        return self.compileVariable(command)
+
+    def r_window(self, command):
+        return self.nextPC()
+
+    #############################################################################
+    # Compile a value in this domain
+    def compileValue(self):
+        value = {}
+        value['domain'] = self.getName()
+        token = self.getToken()
+        if self.isSymbol():
+            value['name'] = token
+            symbolRecord = self.getSymbolRecord()
+            keyword = symbolRecord['keyword']
+            if keyword == 'event':
+                value['type'] = 'symbol'
+                return value
+            return None
+
+        value['type'] = token
+
+        if token == 'test':
+            value = {}
+            value['type'] = 'text'
+            value['content'] = 'test'
+            return value
+
+        return None
+
+    #############################################################################
+    # Modify a value or leave it unchanged.
+    def modifyValue(self, value):
+        return value
+
+    #############################################################################
+    # Value handlers
+
+    # This is used by the expression evaluator to get the value of a symbol
+    def v_symbol(self, symbolRecord):
+        if symbolRecord['keyword'] == 'event':
+            return self.getSymbolValue(symbolRecord)
+        else:
+            return None
+
+    def v_test(self, v):
+        return v
+
+    #############################################################################
+    # Compile a condition
+    def compileCondition(self):
+        condition = {}
+        return condition
+
+    #############################################################################
+    # Condition handlers
+
+    #############################################################################
+    # The main loop
+    def mainLoop(self):
+        while True:
+            event, values = self.program.window.Read(timeout=100)
+            if event == psg.WINDOW_CLOSED or event == "EXIT":
+                break
+            if event == '__TIMEOUT__': self.program.flushCB()
+            else:
+                if event in self.eventHandlers:
+                    self.eventValues = values
+                    self.eventHandlers[event]()
+

easycoder/ec_gutils.py

@@ -0,0 +1,52 @@
+import PySimpleGUI as psg
+import json
+
+class GUtils:
+
+    # Parse a set of compile-time arguments
+    def getArgs(self, handler):
+        args = []
+        while True:
+            key = handler.nextToken()
+            value = json.dumps(handler.nextValue())
+            args.append(f'{key}={value}')
+            if handler.peek() == 'and':
+                handler.nextToken()
+            else: break
+        v = {}
+        v['type'] = 'text'
+        v['content'] = json.dumps(args)
+        return json.dumps(v)
+
+    # Get the default args for a graphic element
+    def getDefaultArgs(self, type):
+        args = {}
+        if type == 'g_text':
+            args['text'] = '(empty)'
+            args['expand_x'] = False
+        elif type == 'g_input':
+            args['key'] = None
+            args['size'] = (None, None)
+        elif type == 'g_button':
+            args['button_text'] = '(empty)'
+        return args
+
+    # Decode an argument at runtime
+    def decode(self, args, text):
+        p = text.find('=')
+        if p > 0:
+            key = text[0:p]
+            value = json.loads(text[p+1:])['content']
+            args[key] = value
+            return args
+        return None
+
+    # Create an element
+    def createElement(self, type, args):
+        if type == 'g_text': return psg.Text(text=args['text'], expand_x=args['expand_x'])
+        elif type == 'g_input':
+            size = args['size'].split()
+            size = (size[0], size[1])
+            return psg.Input(key=args['key'], size=size)
+        elif type == 'g_button': return psg.Button(button_text=args['button_text'])
+        else: return None

easycoder/ec_handler.py

@@ -25,6 +25,7 @@ class Handler:
 		self.getCommandAt = compiler.getCommandAt
 		self.compileOne = compiler.compileOne
 		self.compileFromHere = compiler.compileFromHere
+		self.compileConstant = compiler.compileConstant
 
 		self.code = self.program.code
 		self.add = self.program.add

easycoder/ec_program.py

@@ -1,29 +1,38 @@
 import time, json, sys
 from copy import deepcopy
 from collections import deque
-from .ec_classes import Script, Token, FatalError, RuntimeError
+from .ec_classes import Script, Token, FatalError, RuntimeError, Object
 from .ec_compiler import Compiler
 from .ec_core import Core
 import importlib
 from importlib.metadata import version
 
+# Flush the queue
+def flush():
+	global queue
+	while len(queue):
+		item = queue.popleft()
+		item.program.flush(item.pc)
+
 class Program:
 
 	def __init__(self, argv):
+		global queue
 		print(f'EasyCoder version {version("easycoder")}')
-		scriptName = None
-		if len(argv)>0:
-			scriptName = argv[0]
-		else:
+		if len(argv) == 0:
 			print('No script supplied')
-			exit();
+			exit()
+		self.classes=[Core]
+		scriptName = argv
+		if scriptName.endswith('.ecg'):
+			from .ec_graphics import Graphics
+			self.classes.append(Graphics)
 
-#		print('Domains:',domains)
 		f = open(scriptName, 'r')
 		source = f.read()
 		f.close()
+		queue = deque()
 		self.argv = argv
-		self.classes=[Core]
 		self.domains = []
 		self.domainIndex = {}
 		self.name = '<anon>'
@@ -38,8 +47,14 @@ class Program:
 		self.value = self.compiler.value
 		self.condition = self.compiler.condition
 		self.processClasses()
-		self.queue = deque()
+		self.externalControl = False
+		self.running = True
 
+	def start(self, parent=None, module = None, exports=[]):
+		self.parent = parent
+		self.exports = exports
+		if module != None:
+			module['child'] = self
 		startCompile = time.time()
 		self.tokenise(self.script)
 		if self.compiler.compileFrom(0, []):
@@ -57,13 +72,24 @@ class Program:
 				self.run(0)
 		else:
 			self.compiler.showWarnings()
-			return
+
+		# If this is the main script and there's no graphics, run a main loop
+		if parent == None and self.externalControl == False:
+			while True:
+				if self.running == True:
+					flush()
+					time.sleep(0.1)
+				else:
+					break
 
 	# Import a plugin
 	def importPlugin(self, source):
 		args=source.split(':')
+		if len(args)<2:
+			RuntimeError(None, f'Invalid plugin spec "{source}"')
 		idx=args[0].rfind('/')
 		if idx<0:
+			sys.path.append('.')
 			module=args[0]
 		else:
 			sys.path.append(args[0][0:idx])
@@ -81,7 +107,7 @@ class Program:
 			handler = clazz(self.compiler)
 			self.domains.append(handler)
 			self.domainIndex[handler.getName()] = handler
-	
+
 	# Get the domain list
 	def getDomains(self):
 		return self.domains
@@ -93,11 +119,11 @@ class Program:
 	def getSymbolRecord(self, name):
 		try:
 			target = self.code[self.symbols[name]]
+			if target['import'] != None:
+				target = target['import']
+			return target
 		except:
-			RuntimeError(self.compiler.program, f'Unknown symbol \'{name}\'')
-			return None
-
-		return target
+			RuntimeError(self, f'Unknown symbol \'{name}\'')
 
 	def doValue(self, value):
 		if value == None:
@@ -124,7 +150,7 @@ class Program:
 			name = value['name']
 			symbolRecord = self.getSymbolRecord(name)
 			if symbolRecord['value'] == [None]:
-				RuntimeWarning(self.compiler.program, f'Variable "{name}" has no value')
+				RuntimeWarning(self.program, f'Variable "{name}" has no value')
 				return None
 			handler = self.domainIndex[symbolRecord['domain']].valueHandler('symbol')
 			result = handler(symbolRecord)
@@ -179,6 +205,9 @@ class Program:
 		return copy
 
 	def putSymbolValue(self, symbolRecord, value):
+		if symbolRecord['locked']:
+			name = symbolRecord['name']
+			RuntimeError(self, f'Symbol "{name}" is locked')
 		if symbolRecord['value'] == None or symbolRecord['value'] == []:
 			symbolRecord['value'] = [value]
 		else:
@@ -195,80 +224,115 @@ class Program:
 
 	# Tokenise the script
 	def tokenise(self, script):
-		index = 0
-		lino = 0
-		for line in script.lines:
+		token = ''
+		literal = False
+		for lino in range(0, len(script.lines)):
+			line = script.lines[lino]
 			length = len(line)
-			token = ''
-			inSpace = True
+			if length == 0:
+				continue
+			# Look for the first non-space
 			n = 0
-			while n < length:
+			while n < length and line[n].isspace():
+				n += 1
+			# The whole line may be empty
+			if n == length:
+				if literal:
+					token += '\n'
+				continue
+			# If in an unfinished literal, the first char must be a backtick to continue adding to it
+			if literal:
+				if line[n] != '`':
+					# Close the current token
+					if len(token) > 0:
+						script.tokens.append(Token(lino, token))
+						token = ''
+						literal = False
+				n += 1
+			for n in range(n, length):
 				c = line[n]
-				if len(c.strip()) == 0:
-					if (inSpace):
-						n += 1
+				# Test if we are in a literal
+				if not literal:
+					if c.isspace():
+						if len(token) > 0:
+							script.tokens.append(Token(lino, token))
+							token = ''
 						continue
-					script.tokens.append(Token(lino, token))
-					index += 1
-					token = ''
-					inSpace = True
-					n += 1
-					continue
-				inSpace = False
+					elif c == '!':
+						break
+				# Test for the start or end of a literal
 				if c == '`':
-					m = n
-					n += 1
-					while n < len(line) - 1:
-						if line[n] == '`':
-							break
-						n += 1
-					# n += 1
-					token = line[m:n+1]
-				elif c == '!':
-					break
+					if literal:
+						token += c
+						literal = False
+					else:
+						token += c
+						literal = True
+						m = n
+						continue
 				else:
 					token += c
-				n += 1
 			if len(token) > 0:
-				script.tokens.append(Token(lino, token))
-				index += 1
-			lino += 1
+				if literal:
+					token += '\n'
+				else:
+					script.tokens.append(Token(lino, token))
+					token = ''
 		return
 
+	def releaseParent(self):
+		if self.parent.waiting and self.parent.program.running:
+			self.parent.waiting = False
+			self.parent.program.run(self.parent.pc)
+
+	def flushCB(self):
+		flush()
+
+	# Flush the queue
+	def flush(self, pc):
+		global queue
+		self.pc = pc
+		while self.running:
+			command = self.code[self.pc]
+			domainName = command['domain']
+			if domainName == None:
+				self.pc += 1
+			else:
+				keyword = command['keyword']
+				if self.debugStep and command['debug']:
+					lino = command['lino'] + 1
+					line = self.script.lines[command['lino']].strip()
+					print(f'{self.name}: Line {lino}: {domainName}:{keyword}:  {line}')
+				domain = self.domainIndex[domainName]
+				handler = domain.runHandler(keyword)
+				if handler:
+					command = self.code[self.pc]
+					command['program'] = self
+					self.pc = handler(command)
+					# Deal with 'exit'
+					if self.pc == -1:
+						queue = deque()
+						if self.parent != None:
+							self.releaseParent()
+						else:
+							self.running = False
+							break
+					elif self.pc == None or self.pc == 0 or self.pc >= len(self.code):
+						break
+
 	# Run the script
 	def run(self, pc):
-		# print(f'Run from {pc}')
-		length = len(self.queue)
-		self.queue.append(pc)
-		if length > 0:
-			return
-
-		while len(self.queue):
-			self.pc = self.queue.popleft()
-			while True:
-				command = self.code[self.pc]
-				domainName = command['domain']
-				if domainName == None:
-					self.pc += 1
-				else:
-					keyword = command['keyword']
-					if self.debugStep and command['debug']:
-						lino = command['lino'] + 1
-						line = self.script.lines[command['lino']].strip()
-						print(f'{self.name}: Line {lino}: {domainName}:{keyword}:  {line}')
-					domain = self.domainIndex[domainName]
-					handler = domain.runHandler(keyword)
-					if handler:
-						command = self.code[self.pc]
-						command['program'] = self
-						self.pc = handler(command)
-						try:
-							if self.pc == 0 or self.pc >= len(self.code):
-								return 0
-						except:
-							return 0
-				if self.pc < 0:
-					return -1
+		global queue
+		item = Object()
+		item.program = self
+		item.pc = pc
+		queue.append(item)
+
+	def kill(self):
+		self.running = False
+
+	def setExternalControl(self):
+		self.externalControl = True
 
 	def nonNumericValueError(self):
 		FatalError(self.compiler, 'Non-numeric value')
@@ -315,9 +379,22 @@ class Program:
 			return -1
 		return 0
 
+	# Set up a message handler
+	def onMessage(self, pc):
+		self.onMessagePC = pc
+
+	# Handle a message from our parent program
+	def handleMessage(self, message):
+		self.message = message
+		self.run(self.onMessagePC)
+
 # This is the program launcher
 def Main():
 	if (len(sys.argv) > 1):
-		Program(sys.argv[1:])
+		Program(sys.argv[1]).start()
 	else:
 		print('Syntax: easycoder <scriptname> [plugins]')
+
+if __name__ == '__main__':
+    Main()
+