Skip to end of metadata
Go to start of metadata

The macros control of openBEB

Macros are called from the graphical user interface or by the application server. openBEB Macros are simple batches executing commands step by step. However, there is a simple variable and flow control system. The openBEB Core program is also controlled by macros stored in the application support folder.

The Macros are loaded during startup and are parsed. Basically, all comments and empty lines are removed. Macros can be called by passing parameters to them. Variables can be stored under a name.

The macro panel

Macros can be read, edited and created via the macro panel. Select Macro Panel... from the Help and Preferences menu.

Macro interpreter control

The macros are loaded during start-up of the openBEB. However, they can be loaded at any time later by the command:

The stack also has to be initialized by the command:

The server can be started and stopped using following commands:

Note, that these commands are commands send by the core queue. However, to control macro-interpretetion during runtime, you must use “!” primitives.

Parsing options

Parsing and parameter look-up during runtime is time-consuming. Flags can be set to speed up the interpretation using the command !parsing::X:

X

Description

0

Full parsing is performed (standard). This flag can be set at any time in a macro.

1

Only Pre-parsing is performed. This flag can be set at any time in a macro.

2

No parsing is perfomed. No flow control, no parameter look-up. This option cannot be changed during macro-execution. To block pre-parsing, this option must be set on the first line of the macro. Otherwise, this flag has the same effect as option 1.

Executing a macro from the CORE command queue

A  macro (Macros which are stored in Application support) are executed by calling them with macro::macroname. You can pass parameters to the macro by providing key=(value parameters). See example below:

The parameters in the macro are called by name, see following example:

It is important to note, if you do not provide the parameters, the parser tries to find the corresponding names in the stack (runtime look-up).

Macro command structure

The language is case insensitive and consists of a list with “::" separated items and parameters. Parts of the list can be directed further, there is no obvious discrimination between commands and arguments. Special characters:

character

description

#

Indicates comments. Must be the first character of a line.

!

Commands for the Macro-interpreter and macro-primitives. These commands are used during runtime.

{parameter}

The {} indicate the name of the parameters.

.

Intention of blocks. E.g., after an !if statement.

@Commands starting with an “@“ will not be written to the log file.
  • No labels
Write a comment…