mknbi-mgl(8)

Comments

Since the standard Pascal comment character is already used in a different context with MGL, comments can be delimited with (* and *). In addition everything following a hash character # is treated as a comment until the end of the line. This can be used in conjunction with the C preprocessor.

Reserved words

The following words are reserved and can not be used as identifiers: array, begin, break, const, default, do, else, end, function, if, item, of, procedure, record, repeat, restart, return, screen, select, then, type, until, var, while, with. Unlike Pascal MGL is case sensitive.

General layout of a program

A MGL program consists of declaration blocks like Pascal. Those declaration blocks are constant declarations, type declarations, variable declarations, function declarations and procedure declarations. In addition to Pascal, MGL also knows about screen declarations. A screen is basically the same as a procedure without any arguments. A program has to have at least one screen declaration at the end, which gets run when the program starts. All declaration blocks can be mixed and don't have to follow in any specific order with the exception of the start screen which has to always come last. Each block has to be terminated by a semicolon, again with the exception of the last screen, which has a dot for termination. Each declaration block is introduced by a keyword:

const

Define symbols with constant values. Each such definition has to look like:

type

Define a new type identifier. Assigning a type to an identifier looks like:

var

Define a new variable. The syntax is:

function

A function is defined the same way as in Pascal. Following the keyword function the function's name has to be given, followed by the arguments in round brackets, a colon and the return type of the function:

procedure

A procedure is very similar to a function which does not return a value. Therefore, defining a procedure is also very similar:

screen

As described above a screen is the same as a procedure without arguments. It gets defined by:

Data types

There are two general types: scalar and non-scalar. Scalar types are those which can be internally represented by a number. All others including records, arrays and strings are non-scalar. Each possible value of a scalar type has an ordinal number, so scalar types are defined by their range of ordinal numbers.

The following basic types are already predefined:

integer

The integer type is a scalar type with an internal data width of two bytes. It's range of values is from -maxint to +maxint, where maxint is a predefined constant with a value of 32767.

string

The string type is different from Pascal, which only knows about strings of a constant length. However, strings in MGL can have a variable length. Usually, the maximum length for a string is 255 characters. This can be reduced by appending a maximum length in square brackets to the type identifier: string[16] therefore limits the maximum length of a string to 16 characters.

char

The character type is a scalar type with an internal data width of one byte. It's ordinal numbers range from 0 to 255.

boolean

The boolean type is a scalar type with an internal data width of one byte. It's only possible ordinal numbers are 0 and 1.

Note that there is no floating point type in MGL. Like Pascal and unlike C, MGL is very strict regarding types. For example it is not possible to assign an integer value to a character variable.

In addition to these basic types, it is also possible to define additional scalar and non-scalar types. User defined scalar types can be enumerations or subrange types:

Enumeration

The enumeration type consists of named elements, which have to be specified in round brackets. All named elements are seperated by commas from each other, and get assigned an ordinal number starting at zero. The following declaration defines an enumeration type with five elements:

Subrange

A subrange type is based upon one of the basic scalar types integer, char and boolean. It is specified by giving two constant values, seperated by three dots. For example, the following declaration defines a subrange type with 26 elements:

User defined non-scalar types can be records and arrays:

Record

A record is a collection of elements with possibly different types. It is defined with the keyword record. Following this keyword can appear all elements of the record, with the same syntax as with variable declarations. The record definition is terminated by the end keyword. Unlike Pascal, MGL does not implement variant record elements (which are similar to unions in C).

Array

An array is a collection of elements with the same type. It is defined with the keyword array followed by a scalar type in square brackets, the keyword of and the type specifier of the elements. The following are examples of array definitions:

Expressions

An expression is a set of operations applied to variables and constants. The operations allowed differ for the types involved in the expression. There is no possible operation for array and record types (which is in contrast to Pascal, where it is possible to compare variables with these types). The following operations are available:

Numerical operations

These include addition ( + ), subtraction ( - ), multiplication ( * ), division ( / or div ) and the modulo operation ( % or mod ). All these operations can only be applied to numerical values (i.e. values of integer type and integer subrange types), and the result has the same type as the types involved in the operation. Also there are two predefined functions which operate on integer values: abs returns the absolute value of it's argument, and sqr returns the square value of it's argument. In addition to these operations it is also possible to apply boolean operations to numerical values: and, or, xor and not. These apply bitwise on the numerical values, and the result is numerical again.

String operations

The only valid string operation is the addition ( + ). This will append the string on the right side of the plus sign at the end of the string on the left side. The result is always a string. If the result gets assigned to a variable, it will be automatically truncated if it exceeds the maximum length allowed for the variable.

Character operations

As with strings, characters can be added together. However, the result will always be a string. Similarily, a character can also be added to a string. Another operation with a character is the multiplication. On the left side of the multiplication sign has to be a character value, and on the right side has to be a numerical value. The character gets repeated as often as indicated by this numerical value. Therefore, the result is always a string.

Boolean operations

The normal boolean operations and, or, xor and not can be applied to boolean values. The result is boolean again. Also, comparisons (e.g. =, <>, >, <, >=, <=) always give a boolean result regardless of the types involved in the comparison. It is only possible to compare two values which are assignable to each other. In contrast to Pascal, a comparison of arrays and records is not possible.

General scalar operations

For all scalar values the ord function returns their ordinal values. The result of this function is always numerical. The functions succ and pred increase resp. decrease the corresponding scalar value to the next ordinal value. It will result in a runtime error to increase or decrease out of the range of the corresponding scalar type.

When the result of an expression turns out to be constant, it will be collapsed by the compiler and treated as one single constant value. This is also true for most of the builtin functions like chr or ord. Whenever it is required to use a constant value, for example for defining an integer subrange type or for specifying a maximum length for a string, it is possible to use an expression which consists only of constant values. These can also be named constants like maxint or user defined constants.

Commands

MGL knows of some commands in addition to Pascal to ease the generation of menus. Also some Pascal commands are not implemented, especially for and case. The following commands are implemented in MGL:

while <boolean expression> do

Repeat the following command or block of commands, delimited with begin and end as long as the boolean expression returns true.

repeat <commands> until <boolean expression>

Repeat the commands until the boolean expression returns true. In contrast to while this command does not allow the <commands> block to be delimited by begin and end.

if <boolean expression> then <command 1> else <command 2>

Execute the command 1 if the boolean expression returns true. Otherwise execute the command 2. Both commands can also be command blocks delimited by begin and end. The keyword then is optional and can be left out. With all these commands affecting program flow, the keywords begin and end can be replaced with the characters { and } respectively.

print <expression> at [ <x> , <y> ]

This will print the result of the expression onto the screen at the position pointed to by the two numerical expressions x and y. The position specification is optional. If it's not given, the expression will be printed at the current cursor position. The expression to be printed has to result in a numerical, string or character type.

get <variable> at [ <x>, <y> ] with timeout <expression>

Read a value into the variable using the timeout in seconds given by the numerical expression. If no coordinates are given the current cursor position will be used. The variable has to have a numerical, character or string type. It will be echoed to the console while reading. Note that you will get a runtime error when the user enters a numerical value which is larger than the range for the numerical variable. However, entering values larger than +/- maxint is not possible, so a runtime error will not occur with an integer variable. When no timeout is given the get function will wait forever for proper user input. If a timeout is given, the variable receives the value entered so far when the timeout occurs.

select at [ <x>, <y> ] with timeout <expression> of <items> end

This is a complex command which operates similar to the get command. However, it does only allow entering a numerical character from x and y coordinates and with a timeout given by the numerical expression. Depending on what key the user pressed a specific item is selected. When no key is pressed, the default item is executed. If the user pressed a key for which no item is defined, no action is taken and another key press is waited for. select operates in an endless loop, which can only be left by using the keywords break, return and restart.

load <string expression> from <IP address> gateway <IP address>

This command lets the program return to the bootrom and tell the bootrom to load the file named by the string expression from the system given by the first IP address and using a gateway given by the second IP address. The string expression does not have to be constant, but the IP addresses must be constant, because the runtime module presently lacks a hostname resolver. However, the IP addresses can either be specified in dotted format like 111.222.111.222 or as a string constant expression. If it's a string constant, the compiler treats it as a host name and resolves the name into an IP address at compile time.

menu <menu id>

Call another screen with the given name. This is like a procedure call but for screens.

gotoxy at [ <x> , <y> ]

Move the cursor to the position on the screen given by the two numerical expressions x and y.

restart

Continue operation at the beginning of the current screen, procedure or function.

break

Leave the innermost while, repeat or select command and continue execution at the end of the loop.

return

Terminate the current screen, function or procedure and return to the caller.

<variable> := <value>

This will assign a value to a variable. The value has to be assignable to the variable regarding types.

Scope of symbols

All symbols which are not keywords can be redefined in a different nesting level. While it's not possible to have two symbols with the same name within one procedure or function, the same symbol names can be used again in a different procedure, or in a procedure which is local to the current procedure. This also applies to internally defined symbols, which have an implicit nesting level of -1, which is lower than any other level. Therefore you can redefine internal procedures or functions like print or get.

BOOTP values

When the MGL program gets loaded and run by a boot rom, it gets passed the BOOTP record. It is possible to access the BOOTP tags in this record from within the program by using the special variable construct $[ <expression> ] The expression has to be numerical, and defines the number of the tag in the BOOTP RFC vendor data area. The type of this special BOOTP variable is always a string. You can use this kind of variable within string expressions, or assign a value to it like with any other variable. When the MGL program terminates, the so modified BOOTP record gets passed back to the boot rom. Using this method it is possible to pass special BOOTP tags to the operating system loaded next by the boot rom. But note that the boot rom only allows a maximum size of 2048 bytes for the BOOTP record. When this space gets exceeded, the resulting tags are truncated.

To make accessing the BOOTP tags easier, some constants are predefined:

BOOTP_HOSTNAME

Tag 12: The hostname of the client. This tag is only present in the BOOTP record if you specified the hn flag in /etc/bootptab on the server.

BOOTP_DOMAIN

Tag 15: The domain name of the client. This tag is only present if you specified the dn tag in /etc/bootptab on the server.

BOOTP_ROOTPATH

Tag 17: The path to the root directory of the client. This tag is only present if you specified the rp tag in /etc/bootptab on the server.

So, for example to access the client's root directory on the server, you can use $[BOOTP_ROOTPATH] in your MGL program. In addition to this there are also two read-only variables predefined:

hostname

This string variable gives the client's host name. It has the same value as $[BOOTP_HOSTNAME].

servername

This string variable contains the name of the BOOTP server which answered the request of the boot rom. Since this name is not encoded as a tag in the BOOTP record, using this variable is the only way of accessing the server name.