easycoder 250103.2__tar.gz → 250105.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: easycoder
-Version: 250103.2
+Version: 250105.1
 Summary: Rapid scripting in English
 Keywords: compiler,scripting,prototyping,programming,coding,python,low code,hypertalk,computer language,learn to code
 Author-email: Graham Trott <gtanyware@gmail.com>
@@ -10,12 +10,13 @@ Requires-Dist: pytz
 Project-URL: Home, https://github.com/easycoder/easycoder-py
 
 # Introduction
-**_EasyCoder_** is a high-level English-like scripting language suited for prototyping and rapid testing of ideas. It operates on the command line and a graphics module is under construction. This version of the language is written in Python and its runtime acts as a fairly thin wrapper around Python functions, giving good performance for general applications.
-
-The JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser, is at
+**_EasyCoder_** is a high-level English-like scripting language suited for prototyping and rapid testing of ideas. It operates on the command line and a graphics module is under construction. This version of the language is written in Python and it acts as a fairly thin wrapper around Python functions, giving fast compilation and good runtime performance for general applications.
+<hr>
+For the JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser, please visit
 
 Repository: [https://github.com/easycoder/easycoder.github.io](https://github.com/easycoder/easycoder.github.io)  
 Website: [https://easycoder.github.io](https://easycoder.github.io)
+<hr>
 
 ## Quick Start
 Install **_EasyCoder_** in your Python environment:
@@ -28,7 +29,7 @@ print `Hello, world!`
 ```
 This is traditionally the first program to be written in virtually any language. To run it, use `easycoder hello.ecs`.
 
-The output will look like this:
+The output will look like this (the version number will differ):
 
 ```
 EasyCoder version 250101.1
@@ -72,6 +73,19 @@ A couple of demo graphical scripts are included in the `scripts` directory:
 
 **_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs.
 
+## Significant features
+
+ - English-like syntax based on vocabulary rather than structure. Scripts can be read as English
+ - Comprehensive feature set
+ - Runs directly from source scripts, using a fast compiler to create efficient intermediate runtime code that is run immediately
+ - Low memory requirements
+ - Minimim dependency on other 3rd-party packages
+ - Built-in co-operative multitasking
+ - Dynamic loading of scripts on demand
+ - The language can be extended seamlessly using plugin function modules
+ - Plays well with any Python code
+ - Fully Open Source
+
 ## Programming reference
 
 **_EasyCoder_** comprises a set of modules to handle tokenisation, compilation and runtime control. Syntax and grammar are defined by [packages](doc/README.md), of which there are currently two; the [core](doc/core/README.md) package, which implements a comprehensive set of command-line programming features, and and the [graphics](doc/graphics/README.md) package, which adds graphical features in a windowing environment.

{easycoder-250103.2 → easycoder-250105.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-250105.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-250105.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-250105.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-250105.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-250105.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-250105.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-250105.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-250105.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-250105.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-250105.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-250105.1/doc/core/keywords/run.md

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

{easycoder-250103.2 → easycoder-250105.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-250105.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-250105.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-250105.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-250105.1}/easycoder/__init__.py

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

{easycoder-250103.2 → easycoder-250105.1}/easycoder/ec_compiler.py

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

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