easycoder 241211.2__py2.py3-none-any.whl → 250116.1__py2.py3-none-any.whl

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()
+

easycoder/ec_value.py

@@ -1,5 +1,12 @@
 from .ec_classes import FatalError
 
+# Create a constant
+def getConstant(str):
+	value = {}
+	value['type'] = 'text'
+	value['content'] = str
+	return value
+
 class Value:
 
 	def __init__(self, compiler):
@@ -15,7 +22,7 @@ class Value:
 			return None
 
 		value = {}
-			
+
 		if token == 'true':
 			value['type'] = 'boolean'
 			value['content'] = True
@@ -51,14 +58,14 @@ class Value:
 			if item != None:
 				return item
 			self.compiler.rewindTo(mark)
-		FatalError(self.compiler, f'I don\'t understand \'{token}\'')
+		# self.compiler.warning(f'I don\'t understand \'{token}\'')
 		return None
 
 	def compileValue(self):
 		token = self.getToken()
 		item = self.getItem()
 		if item == None:
-			FatalError(self.compiler, f'Cannot get the value of "{token}"')
+			self.compiler.warning(f'ec_value.compileValue: Cannot get the value of "{token}"')
 			return None
 
 		value = {}
@@ -80,19 +87,19 @@ class Value:
 			value = domain.modifyValue(value)
 
 		return value
-	
+
 	def compileConstant(self, token):
 		value = {}
-		if token.isnumeric():
-			val = eval(token)
-			if isinstance(val, int):
-				value['type'] = 'int'
-				value['content'] = val
-				return value
-			if isinstance(val, float):
-				value['type'] = 'float'
-				value['content'] = val
-				return value
+		if type(token) == 'str':
+			token = eval(token)
+		if isinstance(token, int):
+			value['type'] = 'int'
+			value['content'] = token
+			return value
+		if isinstance(token, float):
+			value['type'] = 'float'
+			value['content'] = token
+			return value
 		value['type'] = 'text'
 		value['content'] = token
 		return value

easycoder-250116.1.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.1
+Name: easycoder
+Version: 250116.1
+Summary: Rapid scripting in English
+Keywords: compiler,scripting,prototyping,programming,coding,python,low code,hypertalk,computer language,learn to code
+Author-email: Graham Trott <gtanyware@gmail.com>
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: pytz
+Project-URL: Home, https://github.com/easycoder/easycoder-py
+
+# Introduction
+**_EasyCoder_** is a high-level English-like scripting language suited for prototyping and rapid testing of ideas. It operates on the command line and a graphics module is under construction. This version of the language is written in Python and it acts as a fairly thin wrapper around Python functions, giving fast compilation and good runtime performance for general applications.
+<hr>
+
+There is also a JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser. For this, please visit
+
+Repository: [https://github.com/easycoder/easycoder.github.io](https://github.com/easycoder/easycoder.github.io)  
+Website: [https://easycoder.github.io](https://easycoder.github.io)
+<hr>
+
+## Quick Start
+Install **_EasyCoder_** in your Python environment:
+```
+pip install easycoder
+```
+You may also need to install `pytz`, as some commands need it.
+
+Write a test script, 'hello.ecs', containing the following:
+```
+print `Hello, world!`
+```
+This is traditionally the first program to be written in virtually any language. To run it, use `easycoder hello.ecs`.
+
+The output will look like this (the version number will differ):
+```
+EasyCoder version 250101.1
+Compiled <anon>: 1 lines (2 tokens) in 0 ms
+Run <anon>
+1-> Hello, world!
+```
+
+It's conventional to add a program title to a script:
+```
+!   Test script
+    script Test
+    print `Hello, world!`
+```
+The first line here is just a comment and has no effect on the running of the script.   The second line gives the script a name, which is useful in debugging as it says which script was running. When run, the output is now
+```
+EasyCoder version 250101.1
+Compiled Test: 3 lines (4 tokens) in 0 ms
+Run Test
+3-> Hello, world!
+```
+
+As you might guess from the above, the print command shows the line in the script it was called from. This is very useful in tracking down debugging print commands in large scripts.
+
+Here in the repository is a folder called `scripts` containing some sample scripts:
+
+`fizzbuzz.ecs` is a simple programming challenge often given at job interviews  
+`tests.ecs` is a test program containing many of the **_EasyCoder_** features  
+`benchmark.ecs` allows the performance of **_EasyCoder_** to be compared to other languages if a similar script is written for each one.
+
+## Graphical programmming
+**_EasyCoder_** includes a graphical programming environment that is in the early stages of development. A couple of demo scripts are included in the `scripts` directory. To run them, first install the Python `kivy` graphics library if it's not already present on your system. This is done with `pip install kivy`. Then run your **_EasyCoder_** script using `easycoder {scriptname}.ecg`.
+
+Graphical scripts look much like any other script but their file names must use the extension `.ecg` to signal to **_EasyCoder_** that it needs to load the graphics module. Non-graphical applications can use any extension but `.ecs` is recommended. This allows the **_EasyCoder_** application to be used wherever Python is installed, in either a command-line or a graphical environment, but graphics will of course not be available in the former.
+
+Some demo graphical scripts are included in the `scripts` directory:
+
+`graphics-demo.ecg` shows some of the elements that can be created, and demonstrates a variety of the graphical features of the language such as detecting when elements are clicked.
+
+`wave.ecg` is a "Mexican Wave" simulation.
+
+`keyboard.ecg` creates an on-screen keyboard (currently a 4-function calculator keypad) that responds to clicks on its keys. It uses a plugin module (see below) to add extra vocabulary and syntax to the language. This is currently under development so its features are likely to change. The intention is to support a wide range of keyboard styles with the minimum mount of coding. The plugin (`ec_keyword.py`) can be downloaded from the repository.
+
+**_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs. The renderer works with JSON-formatted specifications of the itens to be displayed.
+
+## Significant features
+
+ - English-like syntax based on vocabulary rather than structure. Scripts can be read as English
+ - Comprehensive feature set
+ - Runs directly from source scripts. A fast compiler creates efficient intermediate code that runs immediately after compilation
+ - Low memory requirements
+ - Minimim dependency on other 3rd-party packages
+ - Built-in co-operative multitasking
+ - Dynamic loading of scripts on demand
+ - The language can be extended seamlessly using plugin function modules
+ - Plays well with any Python code
+ - Fully Open Source
+
+## Programming reference
+
+**_EasyCoder_** comprises a set of modules to handle tokenisation, compilation and runtime control. Syntax and grammar are defined by [packages](doc/README.md), of which there are currently two; the [core](doc/core/README.md) package, which implements a comprehensive set of command-line programming features, and and the [graphics](doc/graphics/README.md) package, which adds graphical features in a windowing environment.
+
+## Extending the language
+
+**_EasyCoder_** can be extended to add new functionality with the use of 'plugins'. These contain compiler and runtime modules for the added language features. **_EasyCoder_** can use the added keywords, values and conditions freely; the effect is completely seamless. There is an outline example in the `plugins` directory called `example.py`, which comprises a module called `Points` with new language syntax to deal with two-valued items such as coordinates. In the `scripts` directory there is `points.ecs`, which exercises the new functionality.
+
+A plugin can act as a wrapper around any Python functionality that has a sensible API, thereby hiding its complexity. The only challenge is to devise an unambiguous syntax that doesn't clash with anything already existing in **_EasyCoder_**.
+

easycoder-250116.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+easycoder/README.md,sha256=PYqOc_SkIGiFbyCNs90y7JqoqWe4aO1xYIW-6bOnFKU,573
+easycoder/__init__.py,sha256=6tfI5jOPMiZDuD7BsvqLihJFFijWgyIr-EKAapPxT-s,262
+easycoder/ec_classes.py,sha256=xnWBNak8oKydkFoxHLlq9wo3lIsB3aMnTDrqbtCfoWo,1512
+easycoder/ec_compiler.py,sha256=f3zZRtbNsegBuRHTvTLK8BOdnuRq5p_p-1vtJYb-LiY,4800
+easycoder/ec_condition.py,sha256=WSbONo4zs2sX1icOVpscZDFSCAEFmTsquoc2RGcLx_k,763
+easycoder/ec_core.py,sha256=yO7d5OyEFHBDGKSaC1Fhf1uGjzsttAl6VCvR1W5X5YE,86279
+easycoder/ec_graphics.py,sha256=R1LVI-heohCM_uNwHas8VuTIOdxtT6-RMjhca_B5l4Q,11335
+easycoder/ec_gutils.py,sha256=fqh0VKfm2ry5yjHoOE1ufF7uu741lOU7EEwTUEabJ4k,1624
+easycoder/ec_handler.py,sha256=IJvxcrJJSR53d6DS_8H5qPHKhp9y5-GV4WXAjhZxu_o,2250
+easycoder/ec_program.py,sha256=wU-vWRWAYK2Ie4EFnp8HeSPUL0bxz-j9HLQSNplObcc,9919
+easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
+easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
+easycoder-250116.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-250116.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-250116.1.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+easycoder-250116.1.dist-info/METADATA,sha256=L9ZijU5ykpK7eHLHghThRQcJ_xqxM3BKQfsLn1kcDAo,6426
+easycoder-250116.1.dist-info/RECORD,,

{easycoder-241211.2.dist-info → easycoder-250116.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: flit 3.10.1
+Generator: flit 3.9.0
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

easycoder-241211.2.dist-info/METADATA

@@ -1,71 +0,0 @@
-Metadata-Version: 2.3
-Name: easycoder
-Version: 241211.2
-Summary: EasyCoder for Python
-Author-email: Graham Trott <gtanyware@gmail.com>
-Description-Content-Type: text/markdown
-Classifier: License :: OSI Approved :: MIT License
-Requires-Dist: pytz
-Project-URL: Home, https://github.com/easycoder
-
-# Introduction
-This is the Python version of **_EasyCoder_**, a high-level English-like scripting language suited for prototyping and rapid testing of ideas. It operates on the command line.
-
-The JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser, is at
-
-Repository: [https://github.com/easycoder/easycoder.github.io](https://github.com/easycoder/easycoder.github.io)
-Website: [https://easycoder.github.io](https://easycoder.github.io)
-
-## Quick Start
-Install **_EasyCoder_** in your Python environment:
-```
-pip install easycoder
-```
-Write a test script, 'hello.ecs', containing the following:
-```
-print `Hello, world!`
-```
-This is traditionally the first program to be written in virtually any language. To run it, use `easycoder hello.ecs`.
-
-The output will look like this:
-
-```
-EasyCoder version 5
-Compiled <anon>: 1 lines (2 tokens) in 0 ms
-Run <anon>
-1-> Hello, world!
-```
-It's conventional to add a program title to a script:
-
-```
-!   Test script
-    script Test
-    print `Hello, world!`
-```
-The first line here is just a comment and has no effect on the running of the script. The second line gives the script a name, which is useful in debugging as it says which script was running. When run, the output is now
-
-```
-EasyCoder version 5
-Compiled Test: 5 lines (4 tokens) in 0 ms
-Run Test
-5-> Hello, world!
-```
-As you can guess from the above, the print command gives the line in the script it was called from. This is very useful in tracking down debugging print commands in large scripts.
-
-Here in the repository is a folder called `scripts` containing some sample scripts:
-
-`benchmark.ecs` allows the performance of EasyCoder to be compared to other languages if a similar program is written for each one  
-`tests.ecs` is a test program containing many of the EasyCoder features  
-`fizzbuzz.ecs` is a simple programming challenge often given at job interviews
-
-## The EasyCoder programming language
-There are three primary components to the language:
-
- - Keywords
- - Values
- - Conditions
-
-The language comprises a general-purpose core package, which can be enhanced by plugins to provide special features on demand.
-
-[The core package](doc/core.md)
-

easycoder-241211.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-easycoder/__init__.py,sha256=LIhu5HcPlI3Zt29F96x0rEbK1NwA4gqMYpkKxtvK3aI,262
-easycoder/ec_classes.py,sha256=onBKF6Lj8BZKNuJKacx4HyhOrVLXsoHdzl6RnMf77uM,1413
-easycoder/ec_compiler.py,sha256=1z5U92uzUdCOO5-k0VXLnU581iAhwzQga04kfdTlpMY,4629
-easycoder/ec_condition.py,sha256=WSbONo4zs2sX1icOVpscZDFSCAEFmTsquoc2RGcLx_k,763
-easycoder/ec_core.py,sha256=AnPrSJ4oUIOFGV0iF6KxE3AmEb9NG77ae0KwoyvafYs,76175
-easycoder/ec_handler.py,sha256=WDDIz0awD3vSQZ149rgbUWsClt6zXqED8ByXQJ5p1Ds,2200
-easycoder/ec_program.py,sha256=U5QRxcyYycTugyu1ew8prk6NUEqnvcGuFJSY9stN8vY,7870
-easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
-easycoder/ec_value.py,sha256=aOvSF6bM1iKpcLLm0zyGerxHixBkyjE3iYl1Bx6jmzU,2381
-easycoder-241211.2.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-241211.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-241211.2.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
-easycoder-241211.2.dist-info/METADATA,sha256=nzof97vblfpCCdjDl9S0ZuOPHr5L2z58uBpTm61QjEs,2511
-easycoder-241211.2.dist-info/RECORD,,