easycoder 250103.2__py2.py3-none-any.whl → 250105.1__py2.py3-none-any.whl

easycoder/__init__.py

@@ -10,4 +10,4 @@ from .ec_program import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "250103.2"
+__version__ = "250105.1"

easycoder/ec_compiler.py

@@ -128,6 +128,7 @@ class Compiler:
 			FatalError(self, f'Duplicate symbol name "{name}"')
 			return False
 		self.symbols[name] = self.getPC()
+		command['program'] = self.program
 		command['type'] = 'symbol'
 		command['valueHolder'] = valueHolder
 		command['name'] = name
@@ -136,6 +137,8 @@ class Compiler:
 		command['value'] = [None]
 		command['used'] = False
 		command['debug'] = False
+		command['import'] = None
+		command['locked'] = False
 		self.addCommand(command)
 		return True
 

easycoder/ec_core.py

@@ -367,8 +367,7 @@ class Core(Handler):
         return True
 
     def r_exit(self, command):
-        sys.exit()
-        return 0
+        return -1
 
     # Declare a file variable
     def k_file(self, command):
@@ -462,7 +461,7 @@ class Core(Handler):
             else:
                 RuntimeError(self.program, f'Error: {errorReason}')
         retval['content'] = response.text
-        self.program.putSymbolValue(target, retval);
+        self.program.putSymbolValue(target, retval)
         return self.nextPC()
 
     # Go to a label
@@ -553,15 +552,55 @@ class Core(Handler):
             self.program.pc += 1
         return self.program.pc
 
-    # Import a plugin. This is done at compile time.
-    # import {class} from {source}
     def k_import(self, command):
-        clazz = self.nextToken()
-        if self.nextIs('from'):
-            source = self.nextToken()
-            self.program.importPlugin(f'{source}:{clazz}')
+        if self.peek() == 'plugin':
+            # Import a plugin
+            self.nextToken()
+            clazz = self.nextToken()
+            if self.nextIs('from'):
+                source = self.nextToken()
+                self.program.importPlugin(f'{source}:{clazz}')
+                return True
+            return False
+        else:
+            # Import one or more variables
+            imports = []
+            while True:
+                keyword = self.nextToken()
+                name = self.nextToken()
+                item = [keyword, name]
+                imports.append(item)
+                self.symbols[name] = self.getPC()
+                variable = {}
+                variable['domain'] = None
+                variable['name'] = name
+                variable['keyword'] = keyword
+                variable['import'] = None
+                self.addCommand(variable)
+                if self.peek() != 'and':
+                    break
+                self.nextToken()
+            command['imports'] = json.dumps(imports)
+            self.add(command)
             return True
-        return False
+
+    def r_import(self, command):
+        exports = self.program.exports
+        imports = json.loads(command['imports'])
+        if len(imports) < len(exports):
+            RuntimeError(self.program, 'Too few imports')
+        elif len(imports) > len(exports):
+            RuntimeError(self.program, 'Too many imports')
+        for n in range(0, len(imports)):
+            exportRecord = exports[n]
+            exportKeyword = exportRecord['keyword']
+            name = imports[n][1]
+            symbolRecord = self.program.getSymbolRecord(name)
+            symbolKeyword = symbolRecord['keyword']
+            if symbolKeyword != exportKeyword:
+                RuntimeError(self.program, f'Import {n} ({symbolKeyword}) does not match export {n} ({exportKeyword})')
+            symbolRecord['import'] = exportRecord
+        return self.nextPC()
 
     # Increment a variable
     def k_increment(self, command):
@@ -646,9 +685,17 @@ class Core(Handler):
         self.putSymbolValue(symbolRecord, value)
         return self.nextPC()
 
-    # Load a variable from a file
+    # 1 Load a plugin. This is done at compile time.
+    # 2 Load text from a file
     def k_load(self, command):
-        if self.nextIsSymbol():
+        self.nextToken()
+        if self.tokenIs('plugin'):
+            clazz = self.nextToken()
+            if self.nextIs('from'):
+                source = self.nextToken()
+                self.program.importPlugin(f'{source}:{clazz}')
+                return True
+        elif self.isSymbol():
             command['target'] = self.getToken()
             if self.nextIs('from'):
                 command['file'] = self.nextValue()
@@ -668,6 +715,27 @@ class Core(Handler):
         self.putSymbolValue(target, value)
         return self.nextPC()
 
+    # Lock a variable
+    def k_lock(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            command['target'] = symbolRecord['name']
+            self.add(command)
+            return True
+        return False
+
+    def r_lock(self, command):
+        target = self.getVariable(command['target'])
+        target['locked'] = True
+        return self.nextPC()
+
+    # Declare a module variable
+    def k_module(self, command):
+        return self.compileVariable(command)
+
+    def r_module(self, command):
+        return self.nextPC()
+
     # Arithmetic multiply
     # multiply {variable} by {value}[ giving {variable}]}
     def k_multiply(self, command):
@@ -749,6 +817,36 @@ class Core(Handler):
     def r_object(self, command):
         return self.nextPC()
 
+    # on message {action}
+    def k_on(self, command):
+        if self.nextIs('message'):
+            self.nextToken()
+            command['goto'] = 0
+            self.add(command)
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'gotoPC'
+            cmd['goto'] = 0
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # Add the action and a 'stop'
+            self.compileOne()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'stop'
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # Fixup the link
+            command['goto'] = self.getPC()
+            return True
+        return False
+
+    def r_on(self, command):
+        self.program.onMessage(self.nextPC()+1)
+        return command['goto']
+
     # Open a file
     # open {file} for reading/writing/appending
     def k_open(self, command):
@@ -941,13 +1039,13 @@ class Core(Handler):
             if self.nextIsSymbol():
                 symbolRecord = self.getSymbolRecord()
                 command['target'] = symbolRecord['name']
-                if symbolRecord['valueHolder']:
+                if 'valueholder' in symbolRecord and symbolRecord['valueHolder'] == False:
+                    FatalError(self.program.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
+                else:
                     self.add(command)
                     return True
-                else:
-                    FatalError(self.program.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
             else:
-                FatalError(self.program.compiler, f'No such variable: "{self.getToken()}"')
+                FatalError(self.program.compiler, f'Symbol {self.getToken()} is not a variable')
         return False
 
     def r_put(self, command):
@@ -1030,6 +1128,16 @@ class Core(Handler):
         self.putSymbolValue(templateRecord, value)
         return self.nextPC()
 
+    # Release the parent script
+    def k_release(self, command):
+        if self.nextIs('parent'):
+            self.add(command)
+        return True
+
+    def r_release(self, command):
+        self.program.releaseParent()
+        return self.nextPC()
+
     # Return from subroutine
     def k_return(self, command):
         self.add(command)
@@ -1038,6 +1146,47 @@ class Core(Handler):
     def r_return(self, command):
         return self.stack.pop()
 
+    # Compile and run a script
+    def k_run(self, command):
+        try:
+            command['path'] = self.nextValue()
+        except Exception as e:
+            self.warning(f'Core.run: Path expected')
+            return False
+        if self.nextIs('as'):
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'module':
+                    command['module'] = record['name']
+                    exports = []
+                    if self.nextIs('with'):
+                        while True:
+                            name = self.nextToken()
+                            record = self.getSymbolRecord()
+                            exports.append(name)
+                            if self.peek() != 'and':
+                                break
+                            self.nextToken()
+                    command['exports'] = json.dumps(exports)
+                    self.add(command)
+                    return True
+        return False
+
+    def r_run(self, command):
+        module = self.getVariable(command['module'])
+        path = self.getRuntimeValue(command['path'])
+        exports = json.loads(command['exports'])
+        for n in range(0, len(exports)):
+            exports[n] = self.getVariable(exports[n])
+        module['path'] = path
+        parent = Object()
+        parent.program = self.program
+        parent.pc = self.nextPC()
+        parent.waiting = True
+        p = self.program.__class__
+        p(path).start(parent, module, exports)
+        return 0
+
     # Provide a name for the script
     def k_script(self, command):
         self.program.name = self.nextToken()
@@ -1060,6 +1209,24 @@ class Core(Handler):
         f.close()
         return self.nextPC()
 
+    # Send a message to a module
+    def k_send(self, command):
+        command['message'] = self.nextValue()
+        if self.nextIs('to'):
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'module':
+                    command['module'] = record['name']
+                    self.add(command)
+                    return True
+        return False
+
+    def r_send(self, command):
+        message = self.getRuntimeValue(command['message'])
+        module = self.getVariable(command['module'])
+        module['child'].handleMessage(message)
+        return self.nextPC()
+
     # Set a value
     # set {variable}
     # set the elements of {variable} to {value}
@@ -1364,6 +1531,20 @@ class Core(Handler):
         fileRecord['file'].truncate()
         return self.nextPC()
 
+    # Unlock a variable
+    def k_unlock(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            command['target'] = symbolRecord['name']
+            self.add(command)
+            return True
+        return False
+
+    def r_unlock(self, command):
+        target = self.getVariable(command['target'])
+        target['locked'] = False
+        return self.nextPC()
+
     # Declare a general-purpose variable
     def k_variable(self, command):
         return self.compileVariable(command, True)
@@ -1669,7 +1850,6 @@ class Core(Handler):
                     return value
 
         if token == 'message':
-            self.nextToken()
             return value
 
         if token == 'timestamp':
@@ -1975,6 +2155,12 @@ class Core(Handler):
         value['content'] = megabytes
         return value
 
+    def v_message(self, v):
+        value = {}
+        value['type'] = 'text'
+        value['content'] = self.program.message
+        return value
+
     def v_modification(self, v):
         fileName = self.getRuntimeValue(v['fileName'])
         ts = int(os.stat(fileName).st_mtime)

easycoder/ec_graphics.py

@@ -1,7 +1,9 @@
+import sys, threading, json
 from .ec_classes import FatalError, RuntimeError, Object
 from .ec_handler import Handler
 from .ec_screenspec import ScreenSpec
 from .ec_renderer import Renderer
+from .ec_program import flush
 
 class Graphics(Handler):
 
@@ -173,8 +175,8 @@ class Graphics(Handler):
             if type == 'window':
                 self.windowSpec = Object()
                 self.windowSpec.title = command['title']['content']
-                self.windowSpec.flush = self.program.flush
-                self.windowSpec.finish = self.program.finish
+                self.windowSpec.flush = flush
+                self.windowSpec.kill = self.program.kill
                 self.windowSpec.pos = (self.getRuntimeValue(command['pos'][0]), self.getRuntimeValue(command['pos'][1]))
                 self.windowSpec.size = (self.getRuntimeValue(command['size'][0]), self.getRuntimeValue(command['size'][1]))
                 self.windowSpec.fill = (self.getRuntimeValue(command['fill'][0])/255, self.getRuntimeValue(command['fill'][1])/255, self.getRuntimeValue(command['fill'][2])/255)
@@ -219,7 +221,7 @@ class Graphics(Handler):
         if self.nextIsSymbol():
             record = self.getSymbolRecord()
             type = record['keyword']
-            if type in ['ellipse', 'rectangle']:
+            if self.isGraphicType(type):
                 command['target'] = record['id']
                 token = self.nextToken()
                 if token == 'to':
@@ -283,7 +285,7 @@ class Graphics(Handler):
         if command['type'] == 'tap':
             record = self.getVariable(command['target'])
             keyword = record['keyword']
-            if keyword in ['ellipse', 'rectangle', 'text', 'image']:
+            if self.isGraphicType(keyword):
                 id = record['value'][record['index']]['content']
                 self.ui.setOnClick(id, lambda: self.run(pc))
             else:
@@ -296,12 +298,6 @@ class Graphics(Handler):
     def r_rectangle(self, command):
         return self.nextPC()
 
-    def k_text(self, command):
-        return self.compileVariable(command)
-
-    def r_text(self, command):
-        return self.nextPC()
-
     # render {spec}
     def k_render(self, command):
         command['spec'] = self.nextValue()
@@ -332,6 +328,7 @@ class Graphics(Handler):
     def r_run(self, command):
         self.renderer = Renderer()
         self.renderer.init(self.windowSpec)
+        self.ui = self.renderer.getUI()
         self.program.setExternalControl()
         self.program.run(self.nextPC())
         self.renderer.run()
@@ -343,7 +340,7 @@ class Graphics(Handler):
             if self.nextIs('of'):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
-                    if record['keyword'] in ['ellipse', 'rectangle', 'text', 'image']:
+                    if self.isGraphicType(record['keyword']):
                         command['target'] = record['name']
                         if self.nextIs('to'):
                             command['value'] = self.nextValue()
@@ -363,6 +360,12 @@ class Graphics(Handler):
         self.ui.setAttribute(id, attribute, value)
         return self.nextPC()
 
+    def k_text(self, command):
+        return self.compileVariable(command)
+
+    def r_text(self, command):
+        return self.nextPC()
+
     #############################################################################
     # Modify a value or leave it unchanged.
     def modifyValue(self, value):
@@ -373,6 +376,16 @@ class Graphics(Handler):
     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 == 'graphic':
+                value['type'] = 'symbol'
+                return value
+            return None
+        
         if self.tokenIs('the'):
             self.nextToken()
         kwd = self.getToken()
@@ -382,7 +395,7 @@ class Graphics(Handler):
             if self.nextIs('of'):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
-                    if record['keyword'] in ['ellipse', 'rectangle']:
+                    if self.isGraphicType(record['keyword']):
                         value['attribute'] = attribute
                         value['target'] = record['name']
                         return value
@@ -393,6 +406,12 @@ class Graphics(Handler):
                 return value
         return None
 
+    #############################################################################
+    # Test if a graphic type
+
+    def isGraphicType(self, type):
+        return type in ['ellipse', 'rectangle', 'text', 'image']
+
     #############################################################################
     # Value handlers
 
@@ -409,6 +428,15 @@ class Graphics(Handler):
         except Exception as e:
             RuntimeError(self.program, e)
 
+    # This is used by the expression evaluator to get the value of a symbol
+    def v_symbol(self, symbolRecord):
+        result = {}
+        if symbolRecord['keyword'] == 'graphic':
+            symbolValue = self.getSymbolValue(symbolRecord)
+            return symbolValue
+        else:
+            return None
+
     def v_window(self, v):
         try:
             attribute = v['attribute']

easycoder/ec_program.py

@@ -1,21 +1,29 @@
 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")}')
 		if len(argv) == 0:
 			print('No script supplied')
 			exit()
 		self.classes=[Core]
-		scriptName = argv[0]
+		scriptName = argv
 		if scriptName.endswith('.ecg'):
 			from .ec_graphics import Graphics
 			self.classes.append(Graphics)
@@ -23,6 +31,8 @@ class Program:
 		f = open(scriptName, 'r')
 		source = f.read()
 		f.close()
+		queue = deque()
+		self.argv = argv
 		self.domains = []
 		self.domainIndex = {}
 		self.name = '<anon>'
@@ -37,11 +47,14 @@ class Program:
 		self.value = self.compiler.value
 		self.condition = self.compiler.condition
 		self.processClasses()
-		self.queue = deque()
 		self.externalControl = False
-		self.quit = False
+		self.running = True
 
-	def start(self):
+	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, []):
@@ -59,7 +72,15 @@ 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):
@@ -98,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:
@@ -129,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)
@@ -184,6 +205,8 @@ class Program:
 		return copy
 
 	def putSymbolValue(self, symbolRecord, value):
+		if symbolRecord['locked']:
+			RuntimeError(self, f'Symbol \'{symbolRecord['name']}\' is locked')
 		if symbolRecord['value'] == None or symbolRecord['value'] == []:
 			symbolRecord['value'] = [value]
 		else:
@@ -192,11 +215,11 @@ class Program:
 				index = 0
 			symbolRecord['value'][index] = value
 
-	def encode(self, value, encoding='UTF-8'):
-		return value.encode(encoding)
+	def encode(self, value):
+		return value
 
-	def decode(self, value, encoding='UTF-8'):
-		return value.decode(encoding)
+	def decode(self, value):
+		return value
 
 	# Tokenise the script
 	def tokenise(self, script):
@@ -256,48 +279,56 @@ class Program:
 					token = ''
 		return
 	
-	def finish(self):
-		self.quit = True
+	def releaseParent(self):
+		if self.parent.waiting and self.parent.program.running:
+			self.parent.waiting = False
+			self.parent.program.run(self.parent.pc)
 
 	# Flush the queue
-	def flush(self):
-		while len(self.queue):
-			self.pc = self.queue.popleft()
-			while True:
-				if self.quit:
-					return
-				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):
-								break
-						except:
+	def flush(self, pc):
+		global queue
+		self.pc = pc
+		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)
+					# Deal with 'exit'
+					if self.pc == -1:
+						queue = deque()
+						if self.parent != None:
+							self.releaseParent()
+						else:
+							self.running = False
 							break
-
-	def setExternalControl(self):
-		self.externalControl = True
+					elif self.pc == None or self.pc == 0 or self.pc >= len(self.code):
+						break
 
 	# Run the script
 	def run(self, pc):
-		length = len(self.queue)
-		self.queue.append(pc)
-		if not self.externalControl:
-			if length == 0:
-				return self.flush()
+		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')
@@ -343,3 +374,19 @@ class Program:
 		if v1 < v2:
 			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]).start()
+	else:
+		print('Syntax: easycoder <scriptname> [plugins]')

easycoder/ec_renderer.py

@@ -225,6 +225,7 @@ class Renderer(App):
     
     def request_close(self):
         print('close window')
+        self.kill()
         Window.close()
     
     def flushQueue(self, dt):
@@ -232,12 +233,13 @@ class Renderer(App):
     
     def build(self):
         Clock.schedule_interval(self.flushQueue, 0.01)
-        self.ui = UI()
         return self.ui
 
     def init(self, spec):
+        self.ui = UI()
         self.title = spec.title
         self.flush = spec.flush
+        self.kill = spec.kill
         Window.size = spec.size
         Window.left = spec.pos[0]
         Window.top = spec.pos[1]

easycoder/ec_value.py

@@ -51,7 +51,7 @@ 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):

{easycoder-250103.2.dist-info → easycoder-250105.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: easycoder
-Version: 250103.2
+Version: 250105.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>
@@ -10,12 +10,13 @@ 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 its runtime acts as a fairly thin wrapper around Python functions, giving good performance for general applications.
-
-The JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser, is at
+**_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>
+For the JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser, 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:
@@ -28,7 +29,7 @@ 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 output will look like this (the version number will differ):
 
 ```
 EasyCoder version 250101.1
@@ -72,6 +73,19 @@ A couple of demo graphical scripts are included in the `scripts` directory:
 
 **_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs.
 
+## 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, using a fast compiler to create efficient intermediate runtime code that is run immediately
+ - 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.

easycoder-250105.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+easycoder/README.md,sha256=PYqOc_SkIGiFbyCNs90y7JqoqWe4aO1xYIW-6bOnFKU,573
+easycoder/__init__.py,sha256=owNA7S9z8wlR3KRxJytrzPU-s4ngA04Xq8_EUinKwK8,283
+easycoder/ec.py,sha256=Nj5PRl8GsKjfGJKq0FOM1a7FeK3cN68CoIFg8lswQEg,221
+easycoder/ec_classes.py,sha256=xnWBNak8oKydkFoxHLlq9wo3lIsB3aMnTDrqbtCfoWo,1512
+easycoder/ec_compiler.py,sha256=_xBh2L47mz_WOMYdruMYSHyyz2wfh7Hf28q559AWVSU,4781
+easycoder/ec_condition.py,sha256=WSbONo4zs2sX1icOVpscZDFSCAEFmTsquoc2RGcLx_k,763
+easycoder/ec_core.py,sha256=5woFkLx9divJomakFyeexmhqJeEPI1hUlzyB3MlAruI,86359
+easycoder/ec_graphics.py,sha256=ylkdEOo04g8aOeY9xB1V9mf3aZWkoIUt-caXivuVje4,16427
+easycoder/ec_handler.py,sha256=IJvxcrJJSR53d6DS_8H5qPHKhp9y5-GV4WXAjhZxu_o,2250
+easycoder/ec_program.py,sha256=sdVPc1c8urLn5icov-NVyNkc78UR930ipDDONlZTge8,9831
+easycoder/ec_renderer.py,sha256=oZ56OyJojQq-2ZPlVMFOrEyG_vj91D4yv9Nd5m92RQA,8031
+easycoder/ec_screenspec.py,sha256=TeXgccfYoE--r7Rf9t9drV1V3fU-p-iBnZwtjHzIh8M,2524
+easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
+easycoder/ec_value.py,sha256=KkSIxAum-bnb_qnaRgS1UiVUg_-khVPQrrEPiSXjQs4,2382
+easycoder-250105.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-250105.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-250105.1.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
+easycoder-250105.1.dist-info/METADATA,sha256=hm-vw2r4-nH5eaa8ouO0Qpdx9nyeNFK60iXwS41GDxg,5817
+easycoder-250105.1.dist-info/RECORD,,

easycoder-250103.2.dist-info/RECORD

@@ -1,19 +0,0 @@
-easycoder/README.md,sha256=PYqOc_SkIGiFbyCNs90y7JqoqWe4aO1xYIW-6bOnFKU,573
-easycoder/__init__.py,sha256=JT7KWbiZJzKjiWqUFbTt4PaWE-WxWQcMEBvq4al6KL0,283
-easycoder/ec.py,sha256=Nj5PRl8GsKjfGJKq0FOM1a7FeK3cN68CoIFg8lswQEg,221
-easycoder/ec_classes.py,sha256=xnWBNak8oKydkFoxHLlq9wo3lIsB3aMnTDrqbtCfoWo,1512
-easycoder/ec_compiler.py,sha256=2r6Nk7px9UMYqIpYc6dAbYOAFu-CoWPy-iqlsed49Lo,4690
-easycoder/ec_condition.py,sha256=WSbONo4zs2sX1icOVpscZDFSCAEFmTsquoc2RGcLx_k,763
-easycoder/ec_core.py,sha256=rglL7s3f1Ewzc0wjUPZxoY8__DJscxjZU7-Pd6OCIZQ,79904
-easycoder/ec_graphics.py,sha256=o70BdQ-Y3uIo5nheQYwJUmM3gYVerKD9_5arQ8JTP-Y,15556
-easycoder/ec_handler.py,sha256=IJvxcrJJSR53d6DS_8H5qPHKhp9y5-GV4WXAjhZxu_o,2250
-easycoder/ec_program.py,sha256=TUKQo56vURtx_UO7avIJZhz0EeOe2lNxQQz8EOOnCZ4,8685
-easycoder/ec_renderer.py,sha256=ejVFemHGuFBwGA__6VfZQZeZMnw4Ilvf_y9I34k04LM,7981
-easycoder/ec_screenspec.py,sha256=TeXgccfYoE--r7Rf9t9drV1V3fU-p-iBnZwtjHzIh8M,2524
-easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
-easycoder/ec_value.py,sha256=XIBtGhcCgh1abrzAn-Wy4l_xH_3cTWakMVIiSlBAZjM,2386
-easycoder-250103.2.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-250103.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-250103.2.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
-easycoder-250103.2.dist-info/METADATA,sha256=UyIqZzD6XVImMRxZloXqyE_bUKKJRGCMztjXaaIPBTc,5178
-easycoder-250103.2.dist-info/RECORD,,