easycoder 250103.2__tar.gz → 250104.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: easycoder
-Version: 250103.2
+Version: 250104.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-250103.2 → easycoder-250104.1}/README.md

@@ -1,10 +1,11 @@
 # 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:
@@ -17,7 +18,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
@@ -61,6 +62,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-250103.2 → easycoder-250104.1}/doc/core/README.md

@@ -10,7 +10,7 @@ There are three primary components to the language:
 
 The core keywords are:
 
-[add](keywords/add.md) [append](keywords/append.md) [assert](keywords/assert.md) [begin](keywords/begin.md) [clear](keywords/clear.md) [close](keywords/close.md) [create](keywords/create.md) [debug](keywords/debug.md) [decrement](keywords/decrement.md) [delete](keywords/delete.md) [divide](keywords/divide.md) [exit](keywords/exit.md) [file](keywords/file.md) [fork](keywords/fork.md) [get](keywords/get.md) [go](keywords/go.md) [gosub](keywords/gosub.md) [if](keywords/if.md) [import](keywords/import.md) [increment](keywords/increment.md) [index](keywords/index.md) [init](keywords/init.md) [input](keywords/input.md) [load](keywords/load.md) [multiply](keywords/multiply.md) [negate](keywords/negate.md) [open](keywords/open.md) [pop](keywords/pop.md) [post](keywords/post.md) [print](keywords/print.md) [push](keywords/push.md) [put](keywords/put.md) [read](keywords/read.md) [replace](keywords/replace.md) [return](keywords/return.md) [save](keywords/save.md) [script](keywords/script.md) [set](keywords/set.md) [split](keywords/split.md) [stack](keywords/stack.md) [stop](keywords/stop.md) [system](keywords/system.md) [take](keywords/take.md) [toggle](keywords/toggle.md) [truncate](keywords/truncate.md) [variable](keywords/variable.md) [wait](keywords/wait.md) [while](keywords/while.md) [write](keywords/write.md)
+[add](keywords/add.md) [append](keywords/append.md) [assert](keywords/assert.md) [begin](keywords/begin.md) [clear](keywords/clear.md) [close](keywords/close.md) [create](keywords/create.md) [debug](keywords/debug.md) [decrement](keywords/decrement.md) [delete](keywords/delete.md) [divide](keywords/divide.md) [exit](keywords/exit.md) [file](keywords/file.md) [fork](keywords/fork.md) [get](keywords/get.md) [go](keywords/go.md) [gosub](keywords/gosub.md) [if](keywords/if.md) [import](keywords/import.md) [increment](keywords/increment.md) [index](keywords/index.md) [init](keywords/init.md) [input](keywords/input.md) [load](keywords/load.md) [lock](keywords/lock.md) [module](keywords/module.md) [multiply](keywords/multiply.md) [negate](keywords/negate.md) [open](keywords/open.md) [pop](keywords/pop.md) [post](keywords/post.md) [print](keywords/print.md) [push](keywords/push.md) [put](keywords/put.md) [read](keywords/read.md) [replace](keywords/replace.md) [return](keywords/return.md) [run](keywords/run.md) [save](keywords/save.md) [script](keywords/script.md) [set](keywords/set.md) [split](keywords/split.md) [stack](keywords/stack.md) [stop](keywords/stop.md) [system](keywords/system.md) [take](keywords/take.md) [toggle](keywords/toggle.md) [truncate](keywords/truncate.md) [unlock](keywords/unlock.md) [variable](keywords/variable.md) [wait](keywords/wait.md) [while](keywords/while.md) [write](keywords/write.md)
 
 The core values are:
 

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

@@ -1,12 +1,18 @@
 # import
 
 ## Syntax:
+`import {type} {variable} [and {type} {variable} ...]]`  
 `import {classname} from {path}`
 
 ## Examples:
+`import variable Name and variable Surname`  
 `import Points from plugins/example.py`
 
 ## Description:
+First form:
+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.
 
 Next: [increment](increment.md)  

{easycoder-250103.2 → easycoder-250104.1}/doc/core/keywords/load.md

@@ -10,7 +10,7 @@
 ## Description:
 Loads the contents of a file into a variable. See also [save](save.md).
 
-Next: [multiply](multiply.md)  
+Next: [lock](lock.md)  
 Prev: [init](init.md)
 
 [Back](../../README.md)

easycoder-250104.1/doc/core/keywords/lock.md

@@ -0,0 +1,15 @@
+# lock
+
+## Syntax:
+`lock {variable}`
+
+## Examples:
+`lock Status`
+
+## Description:
+Locks a variable to prevent it being modified. See also [unlock](unlock.md).
+
+Next: [lock](lock.md)  
+Prev: [init](init.md)
+
+[Back](../../README.md)

easycoder-250104.1/doc/core/keywords/module.md

@@ -0,0 +1,17 @@
+# module
+
+## Syntax:
+`module {name}`
+
+## Example:
+`module Loader`
+
+## Description:
+Declare a module variable, which enables you to run another script as a child of the current one. You canarrange for both scripts to run concurrently or for one to wait for the other to complete.
+
+Module variables can be assigned any number of elements - see [set the elements](set.md).
+
+Next: [multiply](multiply.md)  
+Prev: [lock](lock.md)
+
+[Back](../../README.md)

{easycoder-250103.2 → easycoder-250104.1}/doc/core/keywords/multiply.md

@@ -11,6 +11,6 @@
 Multiplies a numeric variable by a numeric value or multiplies one value by another and puts the result into a variable. See elsewhere in this documentation for an explanation of what is meant by a value. If you multiply a variable it must already hold a numeric value, and if you assign a variable to hold the result of a multiplication it will lose whatever value it previously held. 
 
 Next: [negate](negate.md)  
-Prev: [load](load.md)
+Prev: [lock](lock.md)
 
 [Back](../../README.md)

{easycoder-250103.2 → easycoder-250104.1}/doc/core/keywords/read.md

@@ -8,7 +8,7 @@
 ## Description:
 Read a value from a [file](file.md). See [open](open.md), [write](write.md) and [close](close.md).
 
-Next: [replace](replace.md)  
+Next: [release](release.md)  
 Prev: [put](put.md)
 
 [Back](../../README.md)

easycoder-250104.1/doc/core/keywords/release.md

@@ -0,0 +1,15 @@
+# release
+
+## Syntax:
+`release parent`
+
+## Example:
+`release parent`
+
+## Description:
+Release the parent script. When a child module is run it blocks the parent from running until either it exits or it issues the `release parent` command. This allows it to do initialisation that cannot be interrupted but which may involve timed delays.
+
+Next: [multiply](multiply.md)  
+Prev: [lock](lock.md)
+
+[Back](../../README.md)

{easycoder-250103.2 → easycoder-250104.1}/doc/core/keywords/replace.md

@@ -10,6 +10,6 @@
 Replaces all occurrences of one string with another in a string [variable](variable.md).
 
 Next: [return](return.md)  
-Prev: [read](read.md)
+Prev: [release](release.md)
 
 [Back](../../README.md)

{easycoder-250103.2 → easycoder-250104.1}/doc/core/keywords/return.md

@@ -8,7 +8,7 @@
 ## Description:
 Return from a subroutine. See [gosub](gosub.md).
 
-Next: [save](save.md)  
+Next: [run](run.md)  
 Prev: [replace](replace.md)
 
 [Back](../../README.md)

easycoder-250104.1/doc/core/keywords/run.md

@@ -0,0 +1,15 @@
+# run
+
+## Syntax:
+`run {module} as {name} [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).
+
+Next: [multiply](multiply.md)  
+Prev: [lock](lock.md)
+
+[Back](../../README.md)

{easycoder-250103.2 → easycoder-250104.1}/doc/core/keywords/save.md

@@ -11,6 +11,6 @@
 Saves data to a file. See also [load](load.md).
 
 Next: [set](set.md)  
-Prev: [return](return.md)
+Prev: [run](run.md)
 
 [Back](../../README.md)

{easycoder-250103.2 → easycoder-250104.1}/doc/core/keywords/truncate.md

@@ -10,7 +10,7 @@
 ## Description:
 Truncate a file
 
-Next: [variable](variable.md)  
+Next: [unlock](variable.md)  
 Prev: [toggle](toggle.md)
 
 [Back](../../README.md)

easycoder-250104.1/doc/core/keywords/unlock.md

@@ -0,0 +1,15 @@
+# ulock
+
+## Syntax:
+`unlock {variable}`
+
+## Examples:
+`lock Status`
+
+## Description:
+Unlocks a locked variable to allow it to be modified. See also [lock](lock.md).
+
+Next: [lock](lock.md)  
+Prev: [init](init.md)
+
+[Back](../../README.md)

{easycoder-250103.2 → easycoder-250104.1}/doc/core/keywords/variable.md

@@ -12,6 +12,6 @@ Declare a variable - an arbitrary storage item. Variables may hold string, numer
 Variables can be assigned any number of elements - see [set the elements](set.md). Each element can hold a data value of any of the 3 types above.
 
 Next: [wait](wait.md)  
-Prev: [toggle](toggle.md)
+Prev: [unlock](toggle.md)
 
 [Back](../../README.md)

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

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

{easycoder-250103.2 → easycoder-250104.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-250103.2 → easycoder-250104.1}/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,45 @@ class Core(Handler):
             self.program.pc += 1
         return self.program.pc
 
-    # Import a plugin. This is done at compile time.
-    # import {class} from {source}
+    # Import one or more variables
     def k_import(self, command):
-        clazz = self.nextToken()
-        if self.nextIs('from'):
-            source = self.nextToken()
-            self.program.importPlugin(f'{source}:{clazz}')
-            return True
-        return False
+        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
+        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 +675,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()
@@ -657,8 +694,11 @@ 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()
@@ -668,6 +708,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):
@@ -1030,6 +1091,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 +1109,43 @@ class Core(Handler):
     def r_return(self, command):
         return self.stack.pop()
 
+    # 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()
+                    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):
+        target = self.getVariable(command['target'])
+        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
+        parent = Object()
+        parent.program = self.program
+        parent.pc = self.nextPC()
+        parent.waiting = True
+        p = self.program.__class__
+        p(path).start(parent, exports)
+        return 0
+
     # Provide a name for the script
     def k_script(self, command):
         self.program.name = self.nextToken()
@@ -1364,6 +1472,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)

{easycoder-250103.2 → easycoder-250104.1}/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,7 +175,7 @@ class Graphics(Handler):
             if type == 'window':
                 self.windowSpec = Object()
                 self.windowSpec.title = command['title']['content']
-                self.windowSpec.flush = self.program.flush
+                self.windowSpec.flush = flush
                 self.windowSpec.finish = self.program.finish
                 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]))
@@ -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']