easycoder 250104.1__tar.gz → 250106.1__tar.gz

{easycoder-250104.1 → easycoder-250106.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: easycoder
-Version: 250104.1
+Version: 250106.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>
@@ -77,7 +77,7 @@ A couple of demo graphical scripts are included in the `scripts` directory:
 
  - 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
+ - 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

{easycoder-250104.1 → easycoder-250106.1}/README.md

@@ -66,7 +66,7 @@ A couple of demo graphical scripts are included in the `scripts` directory:
 
  - 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
+ - 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

{easycoder-250104.1 → easycoder-250106.1}/doc/core/keywords/import.md

@@ -2,15 +2,15 @@
 
 ## Syntax:
 `import {type} {variable} [and {type} {variable} ...]]`  
-`import {classname} from {path}`
+`import plugin {classname} from {path}`
 
 ## Examples:
 `import variable Name and variable Surname`  
-`import Points from plugins/example.py`
+`import plugin Points from plugins/example.py`
 
 ## Description:
 First form:
-This specifies which variable should be provided by a calling script
+This specifies which variable should be provided by a calling script.
 
 Second form:
 As with [script](script.md), `import` is a compiler directive that should be placed at the top of the script, under the [script](script.md) directive. It's used to call in a plugin language extension where needed. The example above is provided in the repository, to be used as a starting point for your own extra functionality.

{easycoder-250104.1 → easycoder-250106.1}/doc/core/keywords/run.md

@@ -1,13 +1,13 @@
 # run
 
 ## Syntax:
-`run {module} as {name} [with {export} [and {export}...]]`
+`run {name} {module} as [with {export} [and {export}...]]`
 
 ## Example:
 ``run Hello as `hello.ecs` with Name and Surname` ``
 
 ## Description:
-Run a second script, optionally passing it variables it can use. Changes to these variables will be seen by the parent script (but see [lock](lock.md)). See also [release](release.md).
+Run a second script, optionally passing it variables it can use. Changes to these variables will be seen by the parent script (but see [lock](lock.md)). See also [module](module.md), [release](release.md), [send](send.md)and [on](on.md).
 
 Next: [multiply](multiply.md)  
 Prev: [lock](lock.md)

{easycoder-250104.1 → easycoder-250106.1}/doc/graphics/README.md

@@ -10,10 +10,11 @@ There are three primary components to the language:
 
 The core keywords are:
 
-
+[attach](attach.md) [close](close.md) [create](create.md) [ellipse](ellipse.md) [image](image.md) [move](move.md) [on](on.md) [rectangle](rectangle.md) [render](render.md) [run](run.md) [set](set.md) [text](text.md)
 
 The core values are:
 
+[attribute](attribute.md) [window](window.md) 
 
 The core conditions are:
 

easycoder-250106.1/doc/graphics/keywords/attach.md

@@ -0,0 +1,18 @@
+## attach
+
+## Syntax:
+`attach {id} to {graphic element}`
+
+## Examples:
+``attach `big-circle` to Ellipse1` ``  
+``attach `container` to Container` ``
+
+## Description:
+Attaches an **_EasyCoder_** graphic variable ([ellipse](ellipse.md), [rectangle](rectangle.md), [text](text.md), [image](image.md) etc.) to the rendered graphic item with the given id.
+
+When a graphic specification is rendered, every item in the structure is added to 1) a list of items in the order they were rendered (the z-order) and 2) a dictionary of items indexed by their ids.
+
+Next: [close](close.md)  
+Prev: [text](text.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/close.md

@@ -0,0 +1,15 @@
+## close
+
+## Syntax:
+`close window`
+
+## Examples:
+`close window`
+
+## Description:
+Close the window. This will also terminate the **_EasyCoder_** script.
+
+Next: [create](create.md)  
+Prev: [attach](attach.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/create.md

@@ -0,0 +1,15 @@
+## create
+
+## Syntax:
+`create window {parameters}`
+
+## Examples:
+``create window title `Demo` at 300 300 size 640 480 fill color 255 255 200` ``
+
+## Description:
+Creates a window with the given parameters. There can only be one of these in a program.
+
+Next: [ellipse](ellipse.md)  
+Prev: [close](close.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/ellipse.md

@@ -0,0 +1,15 @@
+## ellipse
+
+## Syntax:
+`ellipse {name}`
+
+## Examples:
+`ellipse Circle`
+
+## Description:
+Declares an ellipse variable. This will be attached to a rendered ellipse and used to pass commands to it. See also [image](image.md), [rectangle](rectangle.md) and [text](text.md).
+
+Next: [image](image.md)  
+Prev: [create](create.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/image.md

@@ -0,0 +1,15 @@
+## image
+
+## Syntax:
+`image {name}`
+
+## Examples:
+`image House`
+
+## Description:
+Declares an image variable. This will be attached to a rendered image and used to pass commands to it. See also [ellipse](ellipse.md), [rectangle](rectangle.md) and [text](text.md).
+
+Next: [move](move.md)  
+Prev: [ellipse](ellipse.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/move.md

@@ -0,0 +1,17 @@
+## move
+
+## Syntax:
+`move {name} by {dx} {dy}`  
+`move {name} to {x} {y}`
+
+## Examples:
+`move Blob by 5 10`  
+`move Button to X Y`
+
+## Description:
+Moves a graphic element in its parent container, either by a relative amount or to a specified location.
+
+Next: [on](on.md)  
+Prev: [image](image.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/on.md

@@ -0,0 +1,16 @@
+## on
+
+## Syntax:
+`on click/tap {element} {action}`
+
+## Examples:
+`on click Button stop`  
+`on tap Plus increment Count`
+
+## Description:
+Handle a graphic event. When the user clicks/taps the specified element, perform the requested action, which can be a single command or a `begin...end` block.
+
+Next: [rectangle](rectangle.md)  
+Prev: [move](move.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/rectangle.md

@@ -0,0 +1,15 @@
+## rectangle
+
+## Syntax:
+`rectangle {name}`
+
+## Examples:
+`rectangle BigBox`
+
+## Description:
+Declares a rectangle variable. This will be attached to a rendered rectangle and used to pass commands to it. See also [ellipse](ellipse.md), [image](image.md) and [text](text.md).
+
+Next: [render](render.md)  
+Prev: [on](on.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/render.md

@@ -0,0 +1,18 @@
+## render
+
+## Syntax:
+`render {specification} [in {parent}]`
+
+## Examples:
+`render Spec`  
+`render Spec in BigBox`
+
+## Description:
+Render a graphic specification, optionally giving the parent container.
+
+Specifications are JSON structures that describe the layout and the element(s) comprising the graphic. See [specification](../specification.md).
+
+Next: [run](run.md)  
+Prev: [rectangle](rectangle.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/run.md

@@ -0,0 +1,18 @@
+## run
+
+## Syntax:
+`render {specification} [in {parent}]`
+
+## Examples:
+`render Spec`  
+`render Spec in BigBox`
+
+## Description:
+Render a graphic specification, optionally giving the parent container.
+
+Specifications are JSON structures that describe the layout and the element(s) comprising the graphic. See [specification](../specification.md).
+
+Next: [run](run.md)  
+Prev: [rectangle](rectangle.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/set.md

@@ -0,0 +1,15 @@
+## set
+
+## Syntax:
+`set attribute {name} of {element} to {value}`
+
+## Examples:
+``set attribute `left` of Button to Left`
+
+## Description:
+Set an attribute of a graphic element. Valid attributes depend on the element but include such as `left`, `bottom`, `width` and `height`.
+
+Next: [text](text.md)  
+Prev: [run](run.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/keywords/text.md

@@ -0,0 +1,15 @@
+## text
+
+## Syntax:
+`text {name}`
+
+## Examples:
+`text BigBox`
+
+## Description:
+Declares a text variable. This will be attached to a rendered text object and used to pass commands to it. See also [ellipse](ellipse.md), [image](image.md) and [rectangle](rectangle.md).
+
+Next: [attach](attach.md)  
+Prev: [set](set.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/values/attribute.md

@@ -0,0 +1,15 @@
+# attribute
+
+## Syntax:
+`attribute {key} of {element}`
+
+## Examples:
+``attribute `width` of BigBox` ``
+
+## Description:
+Gets the named attribute of a graphic element. 
+
+Next: [window](window.md)  
+Prev: [window](window.md)
+
+[Back](../../README.md)

easycoder-250106.1/doc/graphics/values/window.md

@@ -0,0 +1,15 @@
+# window
+
+## Syntax:
+`[the] window left/top/width/height`
+
+## Examples:
+`the window height`
+
+## Description:
+Gets the specified attribute of the window. 
+
+Next: [attribute](attribute.md)  
+Prev: [attribute](attribute.md)
+
+[Back](../../README.md)

{easycoder-250104.1 → easycoder-250106.1}/easycoder/__init__.py

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

{easycoder-250104.1 → easycoder-250106.1}/easycoder/ec_compiler.py

@@ -102,7 +102,7 @@ class Compiler:
 
 	def showWarnings(self):
 		for warning in self.warnings:
-			print(f'Warning at line {self.getLino() + 1} from {warning}')
+			print(f'Warning at line {self.getLino() + 1} of {self.program.name}: {warning}')
 
 	def getSymbolRecord(self):
 		token = self.getToken()

{easycoder-250104.1 → easycoder-250106.1}/easycoder/ec_core.py

@@ -552,27 +552,37 @@ class Core(Handler):
             self.program.pc += 1
         return self.program.pc
 
-    # Import one or more variables
     def k_import(self, command):
-        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
+        if self.peek() == 'plugin':
+            # Import a plugin
             self.nextToken()
-        command['imports'] = json.dumps(imports)
-        self.add(command)
-        return True
+            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
 
     def r_import(self, command):
         exports = self.program.exports
@@ -694,11 +704,8 @@ class Core(Handler):
         return False
 
     def r_load(self, command):
-        print(command)
         target = self.getVariable(command['target'])
-        print(target)
         file = self.getRuntimeValue(command['file'])
-        print(file)
         f = open(file, 'r')
         content = f.read()
         f.close()
@@ -810,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):
@@ -1002,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):
@@ -1111,12 +1148,16 @@ class Core(Handler):
 
     # Compile and run a script
     def k_run(self, command):
-        if self.nextIsSymbol():
-            record = self.getSymbolRecord()
-            if record['keyword'] == 'module':
-                command['target'] = record['name']
-                if self.nextIs('as'):
-                    command['path'] = self.nextValue()
+        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:
@@ -1132,18 +1173,18 @@ class Core(Handler):
         return False
 
     def r_run(self, command):
-        target = self.getVariable(command['target'])
+        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])
-        target['path'] = path
+        module['path'] = path
         parent = Object()
         parent.program = self.program
         parent.pc = self.nextPC()
         parent.waiting = True
         p = self.program.__class__
-        p(path).start(parent, exports)
+        p(path).start(parent, module, exports)
         return 0
 
     # Provide a name for the script
@@ -1168,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}
@@ -1791,7 +1850,6 @@ class Core(Handler):
                     return value
 
         if token == 'message':
-            self.nextToken()
             return value
 
         if token == 'timestamp':
@@ -1842,7 +1900,6 @@ class Core(Handler):
                     return value
             return None
 
-        self.warning(f'Core.compileValue: Unknown token "{token}"')
         return None
 
     #############################################################################
@@ -2097,6 +2154,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-250104.1 → easycoder-250106.1}/easycoder/ec_graphics.py

@@ -36,7 +36,7 @@ class Graphics(Handler):
             FatalError(self.program.compiler, f'There is no screen element with id \'{id}\'')
             return -1
         if element.getType() != keyword:
-            FatalError(self.program.compiler, f'Mismatched element type ({element['type']} and {keyword})')
+            FatalError(self.program.compiler, f'Mismatched element type: \'{element['type']}\' and \'{keyword}\'')
         self.putSymbolValue(targetRecord, {'type': 'text', 'content': id})
         return self.nextPC()
 
@@ -176,7 +176,7 @@ class Graphics(Handler):
                 self.windowSpec = Object()
                 self.windowSpec.title = command['title']['content']
                 self.windowSpec.flush = flush
-                self.windowSpec.finish = self.program.finish
+                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)
@@ -301,13 +301,22 @@ class Graphics(Handler):
     # render {spec}
     def k_render(self, command):
         command['spec'] = self.nextValue()
+        command['parent'] = None
+        if self.peek() == 'in':
+            self.nextToken()
+            if self.nextIsSymbol():
+                command['parent'] = self.getSymbolRecord()['name']
         self.add(command)
         return True
 
     def r_render(self, command):
+        spec = self.getRuntimeValue(command['spec'])
+        parent = command['parent']
+        if parent !=None:
+            parent = self.getVariable(command['parent'])
         self.ui = self.renderer.getUI()
         try:
-            ScreenSpec().render(self.getRuntimeValue(command['spec']), self.ui)
+            ScreenSpec().render(spec, parent, self.ui)
         except Exception as e:
             RuntimeError(self.program, e)
         return self.nextPC()
@@ -316,12 +325,6 @@ class Graphics(Handler):
     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