easycoder 241211.3__tar.gz → 241215.1__tar.gz

easycoder-241211.3/README.md → easycoder-241215.1/PKG-INFO

@@ -1,9 +1,20 @@
+Metadata-Version: 2.3
+Name: easycoder
+Version: 241215.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)
+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
@@ -48,6 +59,11 @@ Here in the repository is a folder called `scripts` containing some sample scrip
 `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.
@@ -59,3 +75,4 @@ The language comprises a general-purpose core package, which can be enhanced by
 **_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-241211.3/PKG-INFO → easycoder-241215.1/README.md

@@ -1,19 +1,9 @@
-Metadata-Version: 2.3
-Name: easycoder
-Version: 241211.3
-Summary: EasyCoder for Python
-Author-email: Graham Trott <gtanyware@gmail.com>
-Description-Content-Type: text/markdown
-Classifier: License :: OSI Approved :: MIT License
-Requires-Dist: pytz
-Project-URL: Home, https://github.com/easycoder
-
 # Introduction
 This is the Python version of **_EasyCoder_**, a high-level English-like scripting language suited for prototyping and rapid testing of ideas. It operates on the command line.
 
 The JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser, is at
 
-Repository: [https://github.com/easycoder/easycoder.github.io](https://github.com/easycoder/easycoder.github.io)
+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
@@ -58,6 +48,11 @@ Here in the repository is a folder called `scripts` containing some sample scrip
 `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.
@@ -69,4 +64,3 @@ The language comprises a general-purpose core package, which can be enhanced by
 **_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-241211.3 → easycoder-241215.1}/doc/README.md

@@ -10,7 +10,7 @@ The core package contains all the keywords values and conditionals needed for ge
 
 The core keywords are:
 
-[add](core/add.md) [append](core/append.md) [assert](core/assert.md) [begin](core/begin.md) [clear](core/clear.md) [close](core/close.md) [create](core/create.md) [debug](core/debug.md) [decrement](core/decrement.md) [delete](core/delete.md) [divide](core/divide.md) [exit](core/exit.md) [file](core/file.md) [fork](core/fork.md) [get](core/get.md) [go](core/go.md) [gosub](core/gosub.md) [if](core/if.md) [increment](core/increment.md) [index](core/index.md) [init](core/init.md) [input](core/input.md) [multiply](core/multiply.md) [open](core/open.md) [pop](core/pop.md) [post](core/post.md) [print](core/print.md) [push](core/push.md) [put](core/put.md) [read](core/read.md) [replace](core/replace.md) [return](core/return.md) [script](core/script.md) [set](core/set.md) [split](core/split.md) [stack](core/stack.md) [stop](core/stop.md) [system](core/system.md) [take](core/take.md) [toggle](core/toggle.md) [truncate](core/truncate.md) [variable](core/variable.md) [wait](core/wait.md) [while](core/while.md) [write](core/write.md)
+[add](core/add.md) [append](core/append.md) [assert](core/assert.md) [begin](core/begin.md) [clear](core/clear.md) [close](core/close.md) [create](core/create.md) [debug](core/debug.md) [decrement](core/decrement.md) [delete](core/delete.md) [divide](core/divide.md) [exit](core/exit.md) [file](core/file.md) [fork](core/fork.md) [get](core/get.md) [go](core/go.md) [gosub](core/gosub.md) [if](core/if.md) [import](core/import.md) [increment](core/increment.md) [index](core/index.md) [init](core/init.md) [input](core/input.md) [multiply](core/multiply.md) [open](core/open.md) [pop](core/pop.md) [post](core/post.md) [print](core/print.md) [push](core/push.md) [put](core/put.md) [read](core/read.md) [replace](core/replace.md) [return](core/return.md) [script](core/script.md) [set](core/set.md) [split](core/split.md) [stack](core/stack.md) [stop](core/stop.md) [system](core/system.md) [take](core/take.md) [toggle](core/toggle.md) [truncate](core/truncate.md) [variable](core/variable.md) [wait](core/wait.md) [while](core/while.md) [write](core/write.md)
 
 The core values are:
 

{easycoder-241211.3 → easycoder-241215.1}/doc/core/if.md

@@ -8,7 +8,7 @@
 ## Description:
 `if` tests the condition that follows. If the result is `true` then control resumes at the named label; otherwise if there's an `else` section this is executed, then the program resumes at the next instruction after the `if`. See also [while](while.md).
 
-Next: [increment](increment.md)  
+Next: [import](import.md)  
 Prev: [gosub](gosub.md)
 
 [Back](../README.md)

easycoder-241215.1/doc/core/import.md

@@ -0,0 +1,13 @@
+## Syntax:
+`import {classname} from {path}`
+
+## Examples:
+`import Points from plugins/example.py`
+
+## Description:
+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)  
+Prev: [if](if.md)
+
+[Back](../README.md)

{easycoder-241211.3 → easycoder-241215.1}/doc/core/increment.md

@@ -8,6 +8,6 @@
 Add 1 to the value of the variable. See also [decrement](decrement.md).
 
 Next: [index](index.md)  
-Prev: [if](if.md)
+Prev: [import](import.md)
 
 [Back](../README.md)

{easycoder-241211.3 → easycoder-241215.1}/easycoder/__init__.py

@@ -8,5 +8,6 @@ from .ec_handler import *
 from .ec_program import *
 from .ec_timestamp import *
 from .ec_value import *
+from .ec_graphics import *
 
-__version__ = "241211.3"
+__version__ = "241215.1"

{easycoder-241211.3 → easycoder-241215.1}/easycoder/ec_compiler.py

@@ -101,7 +101,7 @@ class Compiler:
 
 	def showWarnings(self):
 		for warning in self.warnings:
-			print(f'Line {self.getLino() + 1}: {warning}')
+			print(f'Warning: Line {self.getLino() + 1}: {warning}')
 
 	def getSymbolRecord(self):
 		token = self.getToken()

{easycoder-241211.3 → easycoder-241215.1}/easycoder/ec_core.py

@@ -38,7 +38,7 @@ class Core(Handler):
                         command['target'] = self.getToken()
                         self.add(command)
                         return True
-                self.warning(f'core.add: Expected value holder')
+                self.warning(f'Core.add: Expected value holder')
             else:
                 # Here we have 2 values so 'giving' must come next
                 command['value2'] = self.getValue()
@@ -46,7 +46,7 @@ class Core(Handler):
                     command['target'] = self.nextToken()
                     self.add(command)
                     return True
-                self.warning(f'core.add: Expected "giving"')
+                self.warning(f'Core.add: Expected "giving"')
         return False
 
     def r_add(self, command):
@@ -90,7 +90,7 @@ class Core(Handler):
                     command['target'] = symbolRecord['name']
                     self.add(command)
                     return True
-                self.warning(f'Variable "{symbolRecord["name"]}" does not hold a value')
+                self.warning(f'Core.append: Variable "{symbolRecord["name"]}" does not hold a value')
         return False
 
     def r_append(self, command):
@@ -248,7 +248,7 @@ class Core(Handler):
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'Variable "{symbolRecord["name"]}" does not hold a value')
+            self.warning(f'Core.decrement: Variable "{symbolRecord["name"]}" does not hold a value')
         return False
 
     def r_decrement(self, command):
@@ -272,9 +272,9 @@ class Core(Handler):
                 self.add(command)
                 return True
             else:
-                self.warning(f'"of" expected; got {self.getToken()}')
+                self.warning(f'Core.delete: "of" expected; got {self.getToken()}')
         else:
-            self.warning(f'"file" or "property" expected; got {token}')
+            self.warning(f'Core.delete: "file" or "property" expected; got {token}')
         return False
 
     def r_delete(self, command):
@@ -570,7 +570,7 @@ class Core(Handler):
                 command['target'] = self.getToken()
                 self.add(command)
                 return True
-            self.warning(f'Variable "{symbolRecord["name"]}" does not hold a value')
+            self.warning(f'Core.increment: Variable "{symbolRecord["name"]}" does not hold a value')
         return False
 
     def r_increment(self, command):
@@ -729,7 +729,7 @@ class Core(Handler):
             else:
                 FatalError(self.compiler, f'Variable "{self.getToken()}" is not a file')
         else:
-            self.warning(f'core.open: Variable "{self.getToken()}" not declared')
+            self.warning(f'Core.open: Variable "{self.getToken()}" not declared')
         return False
 
     def r_open(self, command):
@@ -1215,7 +1215,7 @@ class Core(Handler):
                         command['target'] = self.getToken()
                         self.add(command)
                         return True
-                self.warning(f'core.take: Expected value holder')
+                self.warning(f'Core.take: Expected value holder')
             else:
                 # Here we have 2 values so 'giving' must come next
                 command['value2'] = self.getValue()
@@ -1227,7 +1227,7 @@ class Core(Handler):
                     else:
                         FatalError(self.program.compiler, f'\'{self.getToken()}\' is not a symbol')
                 else:
-                    self.warning(f'core.take: Expected "giving"')
+                    self.warning(f'Core.take: Expected "giving"')
         return False
 
     def r_take(self, command):
@@ -1402,6 +1402,8 @@ class Core(Handler):
             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')
         if mode == '+':
             value['content'] += 1
         else:
@@ -1467,7 +1469,7 @@ class Core(Handler):
                     if symbolRecord['valueHolder']:
                         value['target'] = symbolRecord['name']
                         return value
-                self.warning(f'Token \'{self.getToken()}\' does not hold a value')
+                self.warning(f'Core.compileValue: Token \'{self.getToken()}\' does not hold a value')
             return None
 
         if token == 'property':
@@ -1478,7 +1480,7 @@ class Core(Handler):
                     if symbolRecord['valueHolder']:
                         value['target'] = symbolRecord['name']
                         return value
-                self.warning(f'Token \'{self.getToken()}\' does not hold a value')
+                self.warning(f'Core.compileValue: Token \'{self.getToken()}\' does not hold a value')
             return None
 
         if token == 'arg':
@@ -1640,7 +1642,7 @@ class Core(Handler):
                     return value
             return None
 
-        self.warning(f'Core: Unknown token {token}')
+        self.warning(f'Core.compileValue: Unknown token "{token}"')
         return None
 
     #############################################################################
@@ -2115,7 +2117,7 @@ class Core(Handler):
             condition.type = 'boolean'
             return condition
 
-        self.warning(f'I can\'t get a conditional:')
+        self.warning(f'Core.compileCondition: I can\'t get a conditional:')
         return None
 
     def isNegate(self):

easycoder-241215.1/easycoder/ec_graphics.py

@@ -0,0 +1,376 @@
+from .ec_classes import FatalError, RuntimeError
+from .ec_handler import Handler
+from .ec_renderer import *
+
+class Graphics(Handler):
+
+    def __init__(self, compiler):
+        Handler.__init__(self, compiler)
+
+    def getName(self):
+        return 'graphics'
+
+    #############################################################################
+    # Keyword handlers
+
+    def k_attach(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            command['name'] = record['name']
+            if self.nextIs('to'):
+                value = self.nextValue()
+                command['id'] = value
+            self.add(command)
+        return True
+
+    def r_attach(self, command):
+        target = self.getVariable(command['name'])
+        id = self.getRuntimeValue(command['id'])
+        element = getElement(id)
+        if element == None:
+            FatalError(self.program.compiler, f'There is no screen element with id \'{id}\'')
+            return -1
+        if element['type'] != target['keyword']:
+            FatalError(self.program.compiler, f'Mismatched element type ({element['type']} and {target['keyword']})')
+        self.putSymbolValue(target, {'type': 'text', 'content': id})
+        return self.nextPC()
+
+    def k_close(self, command):
+        if self.nextIs('screen'):
+            self.add(command)
+            return True
+        return False
+
+    def r_close(self, command):
+        closeScreen()
+        return self.nextPC()
+
+    def k_create(self, command):
+        if self.nextIs('screen'):
+            while True:
+                token = self.peek()
+                if token == 'at':
+                    self.nextToken()
+                    command['left'] = self.nextValue()
+                    command['top'] = self.nextValue()
+                elif token == 'size':
+                    self.nextToken()
+                    command['width'] = self.nextValue()
+                    command['height'] = self.nextValue()
+                elif token == 'fill':
+                    self.nextToken()
+                    command['fill'] = self.nextValue()
+                else:
+                    break
+            self.add(command)
+            return True
+        return False
+
+    def r_create(self, command):
+        createScreen(command)
+        return self.nextPC()
+
+    def k_ellipse(self, command):
+        return self.compileVariable(command)
+
+    def r_ellipse(self, command):
+        return self.nextPC()
+
+    def k_image(self, command):
+        return self.compileVariable(command)
+
+    def r_image(self, command):
+        return self.nextPC()
+
+    def k_move(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['keyword'] in ['rectangle', 'ellipse', 'text', 'image']:
+                command['name'] = record['name']
+                if self.nextToken() in ['by', 'to']:
+                    command['type'] = self.getToken()
+                    command['x'] = self.nextValue()
+                    command['y'] = self.nextValue()
+                    self.add(command)
+                    return True
+        return False
+
+    def r_move(self, command):
+        target = self.getVariable(command['name'])
+        id = self.getSymbolValue(target)['content']
+        type = command['type']
+        x = self.getRuntimeValue(command['x'])
+        y = self.getRuntimeValue(command['y'])
+        if type == 'by':
+            moveElement(id, x, y)
+        elif type == 'to':
+            moveElementTo(id, x, y)
+        return self.nextPC()
+
+    def k_on(self, command):
+        token = self.nextToken()
+        command['type'] = token
+        if token == 'click':
+            command['event'] = token
+            if self.peek() == 'in':
+                self.nextToken()
+            if self.nextIs('screen'):
+                command['target'] = None
+            elif self.isSymbol():
+                target = self.getSymbolRecord()
+                command['target'] = target['name']
+            else:
+                FatalError(self.program.compiler, f'{self.getToken()} is not a screen element')
+                return False
+            command['goto'] = self.getPC() + 2
+            self.add(command)
+            self.nextToken()
+            pcNext = self.getPC()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'gotoPC'
+            cmd['goto'] = 0
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            self.compileOne()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'stop'
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # Fixup the link
+            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            return True
+        elif token == 'tick':
+            command['event'] = token
+            command['goto'] = self.getPC() + 2
+            self.add(command)
+            self.nextToken()
+            pcNext = self.getPC()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'gotoPC'
+            cmd['goto'] = 0
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            self.compileOne()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'stop'
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # Fixup the link
+            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            return True
+        return False
+
+    def r_on(self, command):
+        pc = command['goto']
+        if command['type'] == 'click':
+            event = command['event']
+            if event == 'click':
+                target = command['target']
+                if target == None:
+                    value = 'screen'
+                else:
+                    widget = self.getVariable(target)
+                value = widget['value'][widget['index']]
+                setOnClick(value['content'], lambda: self.run(pc))
+        elif command['type'] == 'tick':
+            setOnTick(lambda: self.run(pc))
+        return self.nextPC()
+
+    def k_rectangle(self, command):
+        return self.compileVariable(command)
+
+    def r_rectangle(self, command):
+        return self.nextPC()
+
+    def k_render(self, command):
+        command['value'] = self.nextValue()
+        command['parent'] = 'screen'
+        if self.peek() == 'in':
+            self.nextToken()
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                type = record['type']
+                name = record['name']
+                if type in ['rectangle', 'ellipse']:
+                    command['parent'] = record['name']
+                    self.add(command)
+                    return True
+                else:
+                    self.warning(f'Graphics.render: {name} cannot be a parent of another element')
+                    return False
+        self.add(command)
+        return True
+        FatalError(self.program.compiler, 'Nothing specified to render')
+        return False
+
+    def r_render(self, command):
+        parent = command['parent']
+        value = self.getRuntimeValue(command['value'])
+        render(value, parent)
+        return self.nextPC()
+
+    def k_set(self, command):
+        if self.peek() == 'the':
+            self.nextToken()
+        token = self.peek()
+        if token == 'text':
+            self.nextToken()
+            command['variant'] = 'setText'
+            if self.peek() == 'of':
+                self.nextToken()
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                command['name'] = record['name']
+                if record['keyword'] != 'text':
+                    RuntimeError(command['program'], f'Symbol type is not \'text\'')
+                if self.peek() == 'to':
+                    self.nextToken()
+                    command['value'] = self.nextValue()
+                    self.add(command)
+                    return True
+            return False
+        elif token == 'background':
+            self.nextToken()
+            command['variant'] = 'setBackground'
+            if self.peek() == 'color':
+                self.nextToken()
+            if self.peek() == 'of':
+                self.nextToken()
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                command['name'] = record['name']
+                if not record['keyword'] in ['rectangle', 'ellipse']:
+                    RuntimeError(command['program'], f'Symbol type is not \'rectangle\' or \'ellipse\'')
+                if self.peek() == 'to':
+                    self.nextToken()
+                    command['value'] = self.nextValue()
+                    self.add(command)
+                return True
+            return False
+        return False
+
+    def r_set(self, command):
+        variant = command['variant']
+        if variant == 'setText':
+            variable = self.getVariable(command['name'])
+            element = self.getSymbolValue(variable)
+            value = self.getRuntimeValue(command['value'])
+            setText(element['content'], value)
+        elif variant == 'setBackground':
+            variable = self.getVariable(command['name'])
+            element = self.getSymbolValue(variable)
+            value = self.getRuntimeValue(command['value'])
+            setBackground(element['content'], value)
+        return self.nextPC()
+
+    def k_show(self, command):
+        if self.nextIs('screen'):
+            command['name'] = None
+            self.add(command)
+            return True
+        return False
+
+    def r_show(self, command):
+        showScreen()
+        return self.nextPC()
+
+    def k_spec(self, command):
+        return self.compileVariable(command, True)
+
+    def r_spec(self, command):
+        return self.nextPC()
+
+    def k_text(self, command):
+        return self.compileVariable(command)
+
+    def r_text(self, command):
+        return self.nextPC()
+    
+    #############################################################################
+    # Compile a value in this domain
+    def compileValue(self):
+        value = {}
+        value['domain'] = 'graphics'
+        token = self.getToken()
+        if self.isSymbol():
+            value['name'] = token
+            symbolRecord = self.getSymbolRecord()
+            keyword = symbolRecord['keyword']
+            if keyword == 'module':
+                value['type'] = 'module'
+                return value
+
+            if symbolRecord['valueHolder'] == True or keyword == 'dictionary':
+                value['type'] = 'symbol'
+                return value
+            return None
+
+        if self.tokenIs('the'):
+            self.nextToken()
+        token = self.getToken()
+
+        value['type'] = token
+
+        if token == 'color':
+            name = self.nextToken()
+            value = {}
+            value['type'] = 'string'
+            value['content'] = name
+            return value
+        
+        elif token == 'attribute':
+            value['attribute'] = self.nextValue()
+            if (self.nextIs('of')):
+                if (self.nextIsSymbol()):
+                    value['name'] = self.getToken()
+                    return value
+        return None
+
+    #############################################################################
+    # Modify a value or leave it unchanged.
+    def modifyValue(self, value):
+        return value
+
+    #############################################################################
+    # Value handlers
+
+    def v_symbol(self, symbolRecord):
+        result = {}
+        if symbolRecord['valueHolder']:
+            symbolValue = self.getSymbolValue(symbolRecord)
+            if symbolValue == None:
+                return None
+            result['type'] = symbolValue['type']
+            content = symbolValue['content']
+            if content == None:
+                return ''
+            result['content'] = content
+            return result
+        else:
+            return ''
+    
+    def v_attribute(self, v):
+        target = self.getVariable(v['name'])
+        attribute = self.getRuntimeValue(v['attribute'])
+        name = target['value'][target['index']]['content']
+        value = {}
+        value['type'] = 'int'
+        value['content'] = getAttribute(name, attribute)
+        return value
+
+    #############################################################################
+    # Compile a condition
+    def compileCondition(self):
+        condition = {}
+        return condition
+
+    #############################################################################
+    # Condition handlers