easycoder 241227.1__py2.py3-none-any.whl → 250102.1__py2.py3-none-any.whl

easycoder/README.md

@@ -0,0 +1,6 @@
+# EasyCode source code
+These are the Python files that comprise **_EasyCoder_**.
+
+**_EasyCoder_** has a small number of third-party dependencies. A minor one is `pytz`, which handles timezones. The biggest one by far is `kivy`, a comprehensive Python graphics library.
+
+If an **_EasyCoder_** script filename ends with `.ecs` it's a command-line script. If it ends with `.ecg` it's a script for a graphical application and will cause `kivy` to be imported. Obviously this will only work on a GUI-based system, whereas command-line scripts will run anywhere there is Python.

easycoder/__init__.py

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

easycoder/ec_core.py

@@ -1,4 +1,4 @@
-import json, math, hashlib, threading, os, subprocess, sys, requests, time, numbers
+import json, math, hashlib, threading, os, subprocess, sys, requests, time, numbers, base64
 from psutil import Process
 from datetime import datetime, timezone
 from random import randrange
@@ -10,6 +10,7 @@ class Core(Handler):
 
     def __init__(self, compiler):
         Handler.__init__(self, compiler)
+        self.encoding = 'utf-8'
 
     def getName(self):
         return 'core'
@@ -464,23 +465,6 @@ class Core(Handler):
         self.program.putSymbolValue(target, retval);
         return self.nextPC()
 
-    # Call a subroutine
-    def k_gosub(self, command):
-        if self.peek() == 'to':
-            self.nextToken()
-        command['gosub'] = self.nextToken()
-        self.add(command)
-        return True
-
-    def r_gosub(self, command):
-        label = command['gosub'] + ':'
-        address = self.symbols[label]
-        if address != None:
-            self.stack.append(self.nextPC())
-            return address
-        RuntimeError(self.program, f'There is no label "{label + ":"}"')
-        return None
-
     # Go to a label
     def k_go(self, command):
         if self.peek() == 'to':
@@ -506,6 +490,23 @@ class Core(Handler):
     def r_gotoPC(self, command):
         return command['goto']
 
+    # Call a subroutine
+    def k_gosub(self, command):
+        if self.peek() == 'to':
+            self.nextToken()
+        command['gosub'] = self.nextToken()
+        self.add(command)
+        return True
+
+    def r_gosub(self, command):
+        label = command['gosub'] + ':'
+        address = self.symbols[label]
+        if address != None:
+            self.stack.append(self.nextPC())
+            return address
+        RuntimeError(self.program, f'There is no label "{label + ":"}"')
+        return None
+
     # if <condition> <action> [else <action>]
     def k_if(self, command):
         command['condition'] = self.nextCondition()
@@ -696,6 +697,29 @@ class Core(Handler):
         self.putSymbolValue(target, value)
         return self.nextPC()
 
+    # Negate a variable
+    def k_negate(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['valueHolder']:
+                command['target'] = self.getToken()
+                self.add(command)
+                return True
+            self.warning(f'Core.negate: Variable "{symbolRecord["name"]}" does not hold a value')
+        return False
+
+    def r_negate(self, command):
+        symbolRecord = self.getVariable(command['target'])
+        if not symbolRecord['valueHolder']:
+            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
+            return None
+        value = self.getSymbolValue(symbolRecord)
+        if value == None:
+            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
+        value['content'] *= -1
+        self.putSymbolValue(symbolRecord, value)
+        return self.nextPC()
+
     # Define an object variable
     def k_object(self, command):
         return self.compileVariable(command)
@@ -976,7 +1000,7 @@ class Core(Handler):
         content = self.getSymbolValue(templateRecord)['content']
         original = self.getRuntimeValue(command['original'])
         replacement = self.getRuntimeValue(command['replacement'])
-        content = content.replace(original, replacement)
+        content = content.replace(original, str(replacement))
         value = {}
         value['type'] = 'text'
         value['numeric'] = False
@@ -1009,25 +1033,32 @@ class Core(Handler):
                 command['target'] = target['name']
                 self.add(command)
                 return True
+            return False
 
         token = self.getToken()
         if token == 'the':
             token = self.nextToken()
+        command['type'] = token
+
         if token == 'elements':
             self.nextToken()
             if self.peek() == 'of':
                 self.nextToken()
             if self.nextIsSymbol():
-                command['type'] = 'elements'
                 command['name'] = self.getToken()
                 if self.peek() == 'to':
                     self.nextToken()
                 command['elements'] = self.nextValue()
                 self.add(command)
                 return True
+            
+        elif token == 'encoding':
+            if self.nextIs('to'):
+                command['encoding'] = self.nextValue()
+                self.add(command)
+                return True
 
-        if token == 'property':
-            command['type'] = 'property'
+        elif token == 'property':
             command['name'] = self.nextValue()
             if self.nextIs('of'):
                 if self.nextIsSymbol():
@@ -1037,8 +1068,7 @@ class Core(Handler):
                         self.add(command)
                         return True
 
-        if token == 'element':
-            command['type'] = 'element'
+        elif token == 'element':
             command['index'] = self.nextValue()
             if self.nextIs('of'):
                 if self.nextIsSymbol():
@@ -1047,7 +1077,6 @@ class Core(Handler):
                         command['value'] = self.nextValue()
                         self.add(command)
                         return True
-
         return False
 
     def r_set(self, command):
@@ -1060,7 +1089,7 @@ class Core(Handler):
             self.putSymbolValue(target, val)
             return self.nextPC()
 
-        if cmdType == 'elements':
+        elif cmdType == 'elements':
             symbolRecord = self.getVariable(command['name'])
             elements = self.getRuntimeValue(command['elements'])
             currentElements = symbolRecord['elements']
@@ -1079,7 +1108,7 @@ class Core(Handler):
             symbolRecord['value'] = newValue
             return self.nextPC()
 
-        if cmdType == 'element':
+        elif cmdType == 'element':
             value = self.getRuntimeValue(command['value'])
             index = self.getRuntimeValue(command['index'])
             target = self.getVariable(command['target'])
@@ -1094,7 +1123,11 @@ class Core(Handler):
             self.putSymbolValue(target, val)
             return self.nextPC()
 
-        if cmdType == 'property':
+        elif cmdType == 'encoding':
+            self.encoding = self.getRuntimeValue(command['encoding'])
+            return self.nextPC()
+
+        elif cmdType == 'property':
             value = self.getRuntimeValue(command['value'])
             name = self.getRuntimeValue(command['name'])
             target = command['target']
@@ -1417,7 +1450,7 @@ class Core(Handler):
     # Compile a value in this domain
     def compileValue(self):
         value = {}
-        value['domain'] = 'core'
+        value['domain'] = self.getName()
         token = self.getToken()
         if self.isSymbol():
             value['name'] = token
@@ -1446,10 +1479,10 @@ class Core(Handler):
                 return value
             return None
 
-        if token in ['now', 'today', 'newline', 'break', 'empty']:
+        if token in ['now', 'today', 'newline', 'tab', 'empty']:
             return value
 
-        if token in ['date', 'encode', 'decode', 'stringify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer']:
+        if token in ['stringify', 'json', 'lowercase', 'uppercase', 'hash', 'random', 'float', 'integer', 'encode', 'decode']:
             value['content'] = self.nextValue()
             return value
 
@@ -1532,7 +1565,9 @@ class Core(Handler):
         if token == 'index':
             if self.nextIs('of'):
                 if self.nextIsSymbol():
+                    value['variable'] = self.getSymbolRecord()['name']
                     if self.peek() == 'in':
+                        value['value'] = None
                         value['type'] = 'indexOf'
                         if self.nextIsSymbol():
                             value['target'] = self.getSymbolRecord()['name']
@@ -1541,8 +1576,9 @@ class Core(Handler):
                         value['name'] = self.getToken()
                         return value
                 else:
-                    value['value1'] = self.getValue()
+                    value['value'] = self.getValue()
                     if self.nextIs('in'):
+                        value['variable'] = None
                         value['type'] = 'indexOf'
                         if self.nextIsSymbol():
                             value['target'] = self.getSymbolRecord()['name']
@@ -1608,7 +1644,8 @@ class Core(Handler):
             return value
 
         if token == 'files':
-            if self.nextIs('of'):
+            token = self.nextToken()
+            if token in ['in', 'of']:
                 value['target'] = self.nextValue()
                 return value
             return None
@@ -1693,6 +1730,14 @@ class Core(Handler):
         value['content'] = round(math.cos(angle * 0.01745329) * radius)
         return value
 
+    def v_count(self, v):
+        variable = self.getVariable(v['name'])
+        content = variable['value'][variable['index']]['content']
+        value = {}
+        value['type'] = 'int'
+        value['content'] = len(content)
+        return value
+
     def v_datime(self, v):
         ts = self.getRuntimeValue(v['timestamp'])
         fmt = v['format']
@@ -1706,9 +1751,17 @@ class Core(Handler):
         return value
 
     def v_decode(self, v):
+        content = self.getRuntimeValue(v['content'])
         value = {}
         value['type'] = 'text'
-        value['content'] = self.program.decode(v['content'])
+        if self.encoding == 'utf-8':
+            value['content'] = content.decode('utf-8')
+        elif self.encoding == 'base64':
+            base64_bytes = content.encode('ascii')
+            message_bytes = base64.b64decode(base64_bytes)
+            value['content'] = message_bytes.decode('ascii')
+        else:
+            value = v
         return value
 
     def v_element(self, v):
@@ -1731,18 +1784,9 @@ class Core(Handler):
         var = self.getVariable(v['name'])
         value = {}
         value['type'] = 'int'
-        # value['content'] = self.getVariable(v['name'])['elements']
         value['content'] = var['elements']
         return value
 
-    def v_count(self, v):
-        variable = self.getVariable(v['name'])
-        content = variable['value'][variable['index']]['content']
-        value = {}
-        value['type'] = 'int'
-        value['content'] = len(content)
-        return value
-
     def v_empty(self, v):
         value = {}
         value['type'] = 'text'
@@ -1750,9 +1794,17 @@ class Core(Handler):
         return value
 
     def v_encode(self, v):
+        content = self.getRuntimeValue(v['content'])
         value = {}
         value['type'] = 'text'
-        value['content'] = self.program.encode(v['content'])
+        if self.encoding == 'utf-8':
+            value['content'] = content.encode('utf-8')
+        elif self.encoding == 'base64':
+            data_bytes = content.encode('ascii')
+            base64_bytes = base64.b64encode(data_bytes)
+            value['content'] = base64_bytes.decode('ascii')
+        else:
+            value = v
         return value
 
     def v_error(self, v):
@@ -1766,21 +1818,22 @@ class Core(Handler):
             value['content'] = errorReason
         return value
 
-    def v_stringify(self, v):
-        item = self.getRuntimeValue(v['content'])
+    def v_files(self, v):
+        v = self.getRuntimeValue(v['target'])
         value = {}
         value['type'] = 'text'
-        value['content'] = json.dumps(item)
+        value['content'] = os.listdir(v)
         return value
 
-    def v_json(self, v):
-        item = self.getRuntimeValue(v['content'])
+    def v_float(self, v):
+        val = self.getRuntimeValue(v['content'])
         value = {}
-        value['type'] = 'object'
+        value['type'] = 'float'
         try:
-            value['content'] = json.loads(item)
+            value['content'] = float(val)
         except:
-            RuntimeError(self.program, 'Cannot encode value')
+            RuntimeWarning(self.program, f'Value cannot be parsed as floating-point')
+            value['content'] = 0.0
         return value
 
     def v_from(self, v):
@@ -1804,17 +1857,6 @@ class Core(Handler):
         value['content'] = hashlib.sha256(hashval.encode('utf-8')).hexdigest()
         return value
 
-    def v_float(self, v):
-        val = self.getRuntimeValue(v['content'])
-        value = {}
-        value['type'] = 'float'
-        try:
-            value['content'] = float(val)
-        except:
-            RuntimeWarning(self.program, f'Value cannot be parsed as floating-point')
-            value['content'] = 0.0
-        return value
-
     def v_index(self, v):
         value = {}
         value['type'] = 'int'
@@ -1822,16 +1864,22 @@ class Core(Handler):
         return value
 
     def v_indexOf(self, v):
-        value1 = v['value1']
+        value = v['value']
+        if value == None:
+            value = self.getSymbolValue(v['variable'])['content']
+        else:
+            value = self.getRuntimeValue(value)
         target = self.getVariable(v['target'])
-        try:
-            index = target['value'].index(value1)
-        except:
-            index = -1
-        value = {}
-        value['type'] = 'int'
-        value['content'] = index
-        return value
+        data = self.getSymbolValue(target)['content']
+        index = -1
+        for n in range(0, len(data)):
+            if data[n] == value:
+                index = n
+                break
+        retval = {}
+        retval['type'] = 'int'
+        retval['content'] = index
+        return retval
 
     def v_integer(self, v):
         val = self.getRuntimeValue(v['content'])
@@ -1840,6 +1888,16 @@ class Core(Handler):
         value['content'] = int(val)
         return value
 
+    def v_json(self, v):
+        item = self.getRuntimeValue(v['content'])
+        value = {}
+        value['type'] = 'object'
+        try:
+            value['content'] = json.loads(item)
+        except:
+            RuntimeError(self.program, 'Cannot encode value')
+        return value
+
     def v_keys(self, v):
         value = {}
         value['type'] = 'int'
@@ -1870,18 +1928,20 @@ class Core(Handler):
         value['content'] = content.lower()
         return value
 
-    def v_uppercase(self, v):
-        content = self.getRuntimeValue(v['content'])
+    def v_memory(self, v):
+        process: Process = Process(os.getpid())
+        megabytes: float = process.memory_info().rss / (1024 * 1024)
         value = {}
-        value['type'] = 'text'
-        value['content'] = content.upper()
+        value['type'] = 'float'
+        value['content'] = megabytes
         return value
 
-    def v_random(self, v):
-        limit = self.getRuntimeValue(v['content'])
+    def v_modification(self, v):
+        fileName = self.getRuntimeValue(v['fileName'])
+        ts = int(os.stat(fileName).st_mtime)
         value = {}
         value['type'] = 'int'
-        value['content'] = randrange(0, limit)
+        value['content'] = ts
         return value
 
     def v_modulo(self, v):
@@ -1931,6 +1991,13 @@ class Core(Handler):
             value['type'] = 'text'
         return value
 
+    def v_random(self, v):
+        limit = self.getRuntimeValue(v['content'])
+        value = {}
+        value['type'] = 'int'
+        value['content'] = randrange(0, limit)
+        return value
+
     def v_right(self, v):
         content = self.getRuntimeValue(v['content'])
         count = self.getRuntimeValue(v['count'])
@@ -1947,32 +2014,11 @@ class Core(Handler):
         value['content'] = round(math.sin(angle * 0.01745329) * radius)
         return value
 
-    def v_tan(self, v):
-        angle = self.getRuntimeValue(v['angle'])
-        radius = self.getRuntimeValue(v['radius'])
-        value = {}
-        value['type'] = 'int'
-        value['content'] = round(math.tan(angle * 0.01745329) * radius)
-        return value
-
-    def v_timestamp(self, v):
-        value = {}
-        value['type'] = 'int'
-        fmt = v['format']
-        if fmt == None:
-            value['content'] = int(time.time())
-        else:
-            fmt = self.getRuntimeValue(fmt)
-            dt = self.getRuntimeValue(v['datime'])
-            spec = datetime.strptime(dt, fmt)
-            t = datetime.now().replace(hour=spec.hour, minute=spec.minute, second=spec.second, microsecond=0)
-            value['content'] = int(t.timestamp())
-        return value
-
-    def v_today(self, v):
+    def v_stringify(self, v):
+        item = self.getRuntimeValue(v['content'])
         value = {}
-        value['type'] = 'int'
-        value['content'] = int(datetime.combine(datetime.now().date(),datetime.min.time()).timestamp())*1000
+        value['type'] = 'text'
+        value['content'] = json.dumps(item)
         return value
 
     def v_symbol(self, symbolRecord):
@@ -1991,39 +2037,45 @@ class Core(Handler):
         else:
             return None
 
-    def v_valueOf(self, v):
-        v = self.getRuntimeValue(v['content'])
+    def v_tab(self, v):
         value = {}
-        value['type'] = 'int'
-        value['content'] = int(v)
+        value['type'] = 'text'
+        value['content'] = '\t'
         return value
 
-    def v_files(self, v):
-        v = self.getRuntimeValue(v['target'])
+    def v_tan(self, v):
+        angle = self.getRuntimeValue(v['angle'])
+        radius = self.getRuntimeValue(v['radius'])
         value = {}
-        value['type'] = 'text'
-        value['content'] = os.listdir(v)
+        value['type'] = 'int'
+        value['content'] = round(math.tan(angle * 0.01745329) * radius)
         return value
 
-    def v_trim(self, v):
-        v = self.getRuntimeValue(v['content'])
+    def v_timestamp(self, v):
         value = {}
-        value['type'] = 'text'
-        value['content'] = v.strip()
+        value['type'] = 'int'
+        fmt = v['format']
+        if fmt == None:
+            value['content'] = int(time.time())
+        else:
+            fmt = self.getRuntimeValue(fmt)
+            dt = self.getRuntimeValue(v['datime'])
+            spec = datetime.strptime(dt, fmt)
+            t = datetime.now().replace(hour=spec.hour, minute=spec.minute, second=spec.second, microsecond=0)
+            value['content'] = int(t.timestamp())
         return value
 
-    def v_weekday(self, v):
+    def v_today(self, v):
         value = {}
         value['type'] = 'int'
-        value['content'] = datetime.today().weekday()
+        value['content'] = int(datetime.combine(datetime.now().date(),datetime.min.time()).timestamp())*1000
         return value
 
-    def v_memory(self, v):
-        process: Process = Process(os.getpid())
-        megabytes: float = process.memory_info().rss / (1024 * 1024)
+    def v_trim(self, v):
+        v = self.getRuntimeValue(v['content'])
         value = {}
-        value['type'] = 'float'
-        value['content'] = megabytes
+        value['type'] = 'text'
+        value['content'] = v.strip()
         return value
 
     def v_type(self, v):
@@ -2044,12 +2096,24 @@ class Core(Handler):
             value['content'] = 'object'
         return value
 
-    def v_modification(self, v):
-        fileName = self.getRuntimeValue(v['fileName'])
-        ts = int(os.stat(fileName).st_mtime)
+    def v_uppercase(self, v):
+        content = self.getRuntimeValue(v['content'])
+        value = {}
+        value['type'] = 'text'
+        value['content'] = content.upper()
+        return value
+
+    def v_valueOf(self, v):
+        v = self.getRuntimeValue(v['content'])
         value = {}
         value['type'] = 'int'
-        value['content'] = ts
+        value['content'] = int(v)
+        return value
+
+    def v_weekday(self, v):
+        value = {}
+        value['type'] = 'int'
+        value['content'] = datetime.today().weekday()
         return value
 
     #############################################################################

easycoder/ec_graphics.py

@@ -9,7 +9,7 @@ class Graphics(Handler):
         Handler.__init__(self, compiler)
 
     def getName(self):
-        return 'kivy'
+        return 'graphics'
 
     #############################################################################
     # Keyword handlers
@@ -204,12 +204,47 @@ class Graphics(Handler):
     def r_ellipse(self, command):
         return self.nextPC()
 
+    def r_getui(self, command):
+        self.ui = self.renderer.getUI()
+        return self.nextPC()
+
     def k_image(self, command):
         return self.compileVariable(command)
 
     def r_image(self, command):
         return self.nextPC()
 
+    # move an element
+    def k_move(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            type = record['keyword']
+            if type in ['ellipse', 'rectangle']:
+                command['target'] = record['id']
+                token = self.nextToken()
+                if token == 'to':
+                    command['x'] = self.nextValue()
+                    command['y'] = self.nextValue()
+                    self.add(command)
+                    return True
+                elif token == 'by':
+                    command['keyword'] = 'moveBy'
+                    command['dx'] = self.nextValue()
+                    command['dy'] = self.nextValue()
+                    self.add(command)
+                    return True
+        return False
+
+    def r_move(self, command):
+        pos = (self.getRuntimeValue(command['x']), self.getRuntimeValue(command['y']))
+        self.ui.moveElementTo(self.getRuntimeValue(command['target']), pos)
+        return self.nextPC()
+
+    def r_moveBy(self, command):
+        dist = (self.getRuntimeValue(command['dx']), self.getRuntimeValue(command['dy']))
+        self.ui.moveElementBy(self.getRuntimeValue(command['target']), dist)
+        return self.nextPC()
+
     def k_on(self, command):
         token = self.nextToken()
         if token in ['click', 'tap']:
@@ -255,37 +290,6 @@ class Graphics(Handler):
                 RuntimeError(self.program, f'{record['name']} is not a clickable object')
         return self.nextPC()
 
-    # move an element
-    def k_move(self, command):
-        if self.nextIsSymbol():
-            record = self.getSymbolRecord()
-            type = record['keyword']
-            if type in ['ellipse', 'rectangle']:
-                command['target'] = record['id']
-                token = self.nextToken()
-                if token == 'to':
-                    command['x'] = self.nextValue()
-                    command['y'] = self.nextValue()
-                    self.add(command)
-                    return True
-                elif token == 'by':
-                    command['keyword'] = 'moveBy'
-                    command['dx'] = self.nextValue()
-                    command['dy'] = self.nextValue()
-                    self.add(command)
-                    return True
-        return False
-
-    def r_move(self, command):
-        pos = (self.getRuntimeValue(command['x']), self.getRuntimeValue(command['y']))
-        self.ui.moveElementTo(self.getRuntimeValue(command['target']), pos)
-        return self.nextPC()
-
-    def r_moveBy(self, command):
-        dist = (self.getRuntimeValue(command['dx']), self.getRuntimeValue(command['dy']))
-        self.ui.moveElementBy(self.getRuntimeValue(command['target']), dist)
-        return self.nextPC()
-
     def k_rectangle(self, command):
         return self.compileVariable(command)
 
@@ -306,13 +310,22 @@ class Graphics(Handler):
 
     def r_render(self, command):
         self.ui = self.renderer.getUI()
-        ScreenSpec().render(self.getRuntimeValue(command['spec']), self.ui)
+        try:
+            ScreenSpec().render(self.getRuntimeValue(command['spec']), self.ui)
+        except Exception as e:
+            RuntimeError(self.program, e)
         return self.nextPC()
 
     # run graphics
     def k_run(self, command):
         if self.nextIs('graphics'):
             self.add(command)
+            cmd = {}
+            cmd['domain'] = 'graphics'
+            cmd['lino'] = command['lino'] + 1
+            cmd['keyword'] = 'getui'
+            cmd['debug'] = False
+            self.addCommand(cmd)
             return True
         return False
 
@@ -323,6 +336,33 @@ class Graphics(Handler):
         self.program.run(self.nextPC())
         self.renderer.run()
 
+    # Set something
+    def k_set(self, command):
+        if self.nextIs('attribute'):
+            command['attribute'] = self.nextValue()
+            if self.nextIs('of'):
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    if record['keyword'] in ['ellipse', 'rectangle', 'text', 'image']:
+                        command['target'] = record['name']
+                        if self.nextIs('to'):
+                            command['value'] = self.nextValue()
+                            self.addCommand(command)
+                            return True
+                    else:
+                        FatalError(self.program.compiler, f'Invalid type: {record['keyword']}')
+                else:
+                    FatalError(self.program.compiler, f'\'{self.getToken()}\' is not a variable')
+        return False
+
+    def r_set(self, command):
+        attribute = self.getRuntimeValue(command['attribute'])
+        target = self.getVariable(command['target'])
+        id = target['value'][target['index']]['content']
+        value = self.getRuntimeValue(command['value'])
+        self.ui.setAttribute(id, attribute, value)
+        return self.nextPC()
+
     #############################################################################
     # Modify a value or leave it unchanged.
     def modifyValue(self, value):
@@ -333,16 +373,24 @@ class Graphics(Handler):
     def compileValue(self):
         value = {}
         value['domain'] = self.getName()
-        if self.tokenIs('attribute'):
+        if self.tokenIs('the'):
+            self.nextToken()
+        kwd = self.getToken()
+        value['type'] = kwd
+        if kwd == 'attribute':
             attribute = self.nextValue()
             if self.nextIs('of'):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
                     if record['keyword'] in ['ellipse', 'rectangle']:
-                        value['type'] = 'attribute'
                         value['attribute'] = attribute
                         value['target'] = record['name']
                         return value
+        elif kwd == 'window':
+            attribute = self.nextToken()
+            if attribute in ['left', 'top', 'width', 'height']:
+                value['attribute'] = attribute
+                return value
         return None
 
     #############################################################################
@@ -361,6 +409,16 @@ class Graphics(Handler):
         except Exception as e:
             RuntimeError(self.program, e)
 
+    def v_window(self, v):
+        try:
+            attribute = v['attribute']
+            value = {}
+            value['type'] = 'int'
+            value['content'] = int(round(self.ui.getWindowAttribute(attribute)))
+            return value
+        except Exception as e:
+            RuntimeError(self.program, e)
+
     #############################################################################
     # Compile a condition
     def compileCondition(self):

easycoder/ec_program.py

@@ -192,52 +192,68 @@ class Program:
 				index = 0
 			symbolRecord['value'][index] = value
 
-	def encode(self, value):
-		return value
+	def encode(self, value, encoding='UTF-8'):
+		return value.encode(encoding)
 
-	def decode(self, value):
-		return value
+	def decode(self, value, encoding='UTF-8'):
+		return value.decode(encoding)
 
 	# 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 finish(self):

easycoder/ec_renderer.py

@@ -24,6 +24,13 @@ class Element():
     def getID(self):
         return self.spec.id
 
+    def getRealPos(self):
+        spec = self.spec
+        pos = spec.realpos
+        if spec.parent != None:
+            pos = Vector(pos) + spec.parent.realpos
+        return pos
+
     def getPos(self):
         spec = self.spec
         pos = spec.pos
@@ -32,13 +39,16 @@ class Element():
         return pos
 
     def setPos(self, pos):
-        self.spec.pos = pos
+        self.spec.realpos = pos
         self.spec.item.pos = pos
     
     # Called when the parent moves
     def repos(self):
         spec = self.spec
-        spec.item.pos = Vector(spec.pos) + spec.parent.pos
+        spec.item.pos = Vector(spec.realpos) + spec.parent.realpos
+            
+    def getRealSize(self):
+        return self.spec.realsize
             
     def getSize(self):
         return self.spec.size
@@ -68,6 +78,25 @@ class UI(Widget):
         self.zlist.append(element)
 
     def createElement(self, spec):
+        # Get a real position or size value
+        def getReal(val):
+            if isinstance(val, str):
+                c = val[-1]
+                if c in ['w', 'h']:
+                    val = int(val[0:len(val)-1])
+                    if spec.parent == None:
+                        if c == 'w':
+                            n = Window.width
+                        else:
+                            n = Window.height
+                    else:
+                        if c == 'w':
+                            n = spec.parent.realsize[0]
+                        else:
+                            n = spec.parent.realsize[1]
+                    return val * n / 100
+            return val
+
         with self.canvas:
             if hasattr(spec, 'fill'):
                 c = spec.fill
@@ -76,13 +105,16 @@ class UI(Widget):
                     Color(c[0], c[1], c[2])
                 else:
                     Color(c[0]/255, c[1]/255, c[2]/255)
-            pos = spec.pos
+            pos = (getReal(spec.pos[0]), getReal(spec.pos[1]))
+            spec.realpos = pos
+            size = (getReal(spec.size[0]), getReal(spec.size[1]))
+            spec.realsize = size
             if spec.parent != None:
-                pos = Vector(pos) + spec.parent.pos
+                pos = Vector(pos) + spec.parent.realpos
             if spec.type == 'ellipse':
-                item = Ellipse(pos=pos, size=spec.size)
+                item = Ellipse(pos=pos, size=size)
             elif spec.type == 'rectangle':
-                item = Rectangle(pos=pos, size=spec.size)
+                item = Rectangle(pos=pos, size=size)
             elif spec.type == 'text':
                 if hasattr(spec, 'color'):
                     c = spec.color
@@ -96,16 +128,16 @@ class UI(Widget):
                 label = CoreLabel(text=spec.text, font_size=1000, halign='center', valign='center')
                 label.refresh()
                 text = label.texture
-                item = Rectangle(pos=spec.pos, size=spec.size, texture=text)
+                item = Rectangle(pos=pos, size=size, texture=text)
             elif spec.type == 'image':
-                item = AsyncImage(pos=spec.pos, size=spec.size, source=spec.source)
+                item = AsyncImage(pos=pos, size=size, source=spec.source)
             spec.item = item
             self.addElement(spec.id, spec)
     
     def moveElementBy(self, id, dist):
         element = self.getElement(id)
         if element != None:
-            element.setPos(Vector(element.getPos()) + dist)
+            element.setPos(Vector(element.getRealPos()) + dist)
             for id in element.getChildren():
                 self.getElement(id).repos()
         return
@@ -113,7 +145,7 @@ class UI(Widget):
     def moveElementTo(self, id, pos):
         element = self.getElement(id)
         if element != None:
-            self.moveElementBy(id, Vector(pos) - element.getPos())
+            self.moveElementBy(id, Vector(pos) - element.getRealPos())
         return
 
     def on_touch_down(self, touch):
@@ -123,9 +155,9 @@ class UI(Widget):
         for element in reversed(self.zlist):
             if element.cb != None:
                 spec = element.spec
-                pos = spec.pos
+                pos = self.getRealPos()
                 if spec.parent != None:
-                    pos = Vector(pos) + spec.parent.pos
+                    pos = Vector(pos) + spec.parent.getRealPos()
                 size = spec.size
                 if spec.type == 'ellipse':
                     a = size[0]/2
@@ -144,19 +176,47 @@ class UI(Widget):
     def setOnClick(self, id, callback):
         self.getElement(id).cb = callback
 
+    def getWindowAttribute(self, attribute):
+        if attribute == 'left':
+            return Window.left
+        elif attribute == 'top':
+            return Window.top
+        elif attribute == 'width':
+            return Window.size[0]
+        elif attribute == 'height':
+            return Window.size[1]
+        else:
+            raise Exception(f'Unknown attribute: {attribute}')
+
     def getAttribute(self, id, attribute):
         spec = self.getElement(id).spec
         if attribute == 'left':
-            return spec.pos[0]
+            return spec.realpos[0]
         elif attribute == 'bottom':
-            return spec.pos[1]
+            return spec.realpos[1]
         elif attribute == 'width':
-            return spec.size[0]
+            return spec.realsize[0]
         elif attribute == 'height':
-            return spec.size[1]
+            return spec.realsize[1]
+        else:
+            raise Exception(f'Unknown attribute: {attribute}')
+        
+    def setAttribute(self, id, attribute, value):
+        spec = self.getElement(id).spec
+        if attribute == 'left':
+            spec.realpos = (value, spec.realsize[0])
+            spec.item.pos = (value, spec.realsize[0])
+        elif attribute == 'bottom':
+            spec.realpos = (spec.realsize[0], value)
+            spec.item.pos = (spec.realsize[0], value)
+        elif attribute == 'width':
+            spec.realsize = (value, spec.realsize[0])
+            spec.item.size = (value, spec.realsize[0])
+        elif attribute == 'height':
+            spec.realsize = (spec.realsize[0], value)
+            spec.item.size = (spec.realsize[0], value)
         else:
             raise Exception(f'Unknown attribute: {attribute}')
-
 
 class Renderer(App):
 
@@ -171,7 +231,7 @@ class Renderer(App):
         self.flush()
     
     def build(self):
-        Clock.schedule_interval(self.flushQueue, 0.05)
+        Clock.schedule_interval(self.flushQueue, 0.01)
         self.ui = UI()
         return self.ui
 

easycoder/ec_screenspec.py

@@ -75,4 +75,3 @@ class ScreenSpec():
 
         else:
             raise Exception('Spec is an unknown type')
-

easycoder-250102.1.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.3
+Name: easycoder
+Version: 250102.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 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
+
+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 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.
+
+A couple of 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.
+
+**_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs.
+
+## 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-250102.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+easycoder/README.md,sha256=PYqOc_SkIGiFbyCNs90y7JqoqWe4aO1xYIW-6bOnFKU,573
+easycoder/__init__.py,sha256=W4OVpn0u8D0l1986sfIOeYbyIh-u4cA3pN00Dd3iPTE,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=YGEEfnzPi8NQX-F7zWM-aic4FzDcAbuKalFQp0YIzKY,78939
+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-250102.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-250102.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-250102.1.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
+easycoder-250102.1.dist-info/METADATA,sha256=Sq25qn0s0MFnqadz35dmOedro1p235uwVXPxHO-hXJE,5178
+easycoder-250102.1.dist-info/RECORD,,

easycoder-241227.1.dist-info/METADATA

@@ -1,78 +0,0 @@
-Metadata-Version: 2.3
-Name: easycoder
-Version: 241227.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
-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
-
-## Graphical programmming
-**_EasyCoder_** is currently being extended to include a graphical programming environment. A single demo script `graphics-demo.ecs` is included in the `scripts` directory. To run it, first install the Python graphics library if it's not already present on your system. On Linux this is done with `sudo apt install python3-tk`. On Windows it's `pip install tk`. Then give the command `easycoder -g scripts/graphics-demo.ecs`.
-
-As development progresses this demo script will be extended to include new features as they are added. **_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs.
-
-## EasyCoder programming reference
-
-The language comprises a general-purpose core package, which can be enhanced by plugins to provide special features on demand.
-
-[The core package](doc/README.md)
-
-## 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-241227.1.dist-info/RECORD

@@ -1,18 +0,0 @@
-easycoder/__init__.py,sha256=l4J8ZzYaQ2L6tojyFFqc47eck2zDXoR8sUqlCyvanBs,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=Q-E2TX_yn9OhdV6HvUzYgiKX9fEQ_ro1-VxSQ5Xl-4Y,76508
-easycoder/ec_graphics.py,sha256=Sy1seMMEZ5KmkDKPhTKIkoGjXl5loYArvAS2YpdsFH8,13347
-easycoder/ec_handler.py,sha256=IJvxcrJJSR53d6DS_8H5qPHKhp9y5-GV4WXAjhZxu_o,2250
-easycoder/ec_program.py,sha256=j3eveYucPQX6E1flDwf1OpkPCh9OtDri88z8baXjvqI,8062
-easycoder/ec_renderer.py,sha256=UZk-VSyN4But0fRTs7wUnPwRGrCF6XA7LxhPxgZaYgU,5705
-easycoder/ec_screenspec.py,sha256=gmYYi0Q6S2qSQzCW0lMPB61EC7ZZ1mNQX8B1knxrTCg,2525
-easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
-easycoder/ec_value.py,sha256=XIBtGhcCgh1abrzAn-Wy4l_xH_3cTWakMVIiSlBAZjM,2386
-easycoder-241227.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-241227.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-241227.1.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
-easycoder-241227.1.dist-info/METADATA,sha256=-1vKmMw26mJSHmztn_O049rpIJqAgJ4OQWPC-lDO9ms,4098
-easycoder-241227.1.dist-info/RECORD,,