A command selector consists of a name and a finite sequence of commands which are alternatives for replacement.

A command name which is the name of a selector shall behave as if its command name is rewritten as a_matching alternative_ before any parameter checking takes place.

A command name which is the name of a selector shall behave as if its command name is rewritten as amatching alternative before any parameter checking takes place.

A _matching alternative_ is the first command in the alternative sequence to have the same amount of parameters as arguments in the actual command, and to obey the following rules for every argument and its corresponding parameter:

You may use custom characters (c > 127), but you may clash with the characters DMA used to tokenize string literals.

BLA BLA The in-house compiler recognizes all of the octets in the range 01 through FF almost indiscriminately. Some of these codes produce unexpected results, while others are used internally during translation (for e.g. escaping string literals). In practice, only the printable characters were used by designers. For simplicity we restrict source code to these characters. BLA BLA

*A string literal is the same as four tokens*

*Side-effects*

*Sideeffects*

Yields control to another script. The current script is not resumed for at least the specified number of milliseconds.

This command is useful due to the cooperative multitasking nature of the execution environment.

[[command-def-goto]]

=== GOTO

*Side-effects*

*Sideeffects*

Performs a jump to the specified location.

*Side-effects*

*Sideeffects*

Calls the subroutine in the specified location.

*Side-effects*

*Sideeffects*

Returns from the last called subroutine.

*Side-effects*

*Sideeffects*

Returns true (as in any command updating the compare flag to true).

*Side-effects*

*Sideeffects*

Returns false (as in any command updating the compare flag to false).

*Side-effects*

*Sideeffects*

Associates a name to the executing script.

The name of a script must be unique across the multi-file.

It is unspecified whether a name given by a text label variable is accepted.

It is unspecified whether a name given by a text label variable is accepted.footnote:[The in-house compiler does not handle the case of text label variables in `SCRIPT_NAME`, but this does not tell much because it barely supports any text label variable feature. No compiled multi-file contains script names assigned by a variable. Thus, we refrain from defining any semantics for this case.]

[[command-def-terminate-this-script]]

=== TERMINATE_THIS_SCRIPT

*Side-effects*

*Sideeffects*

Terminates the executing script.

*Side-effects*

*Sideeffects*

Creates a script and sets its program counter to the specified label location.

The translation environment must enforce the following constraints.

The specified label location must be within a scope. Such scope may begin at the next non-empty embedded statement relative to the label location.

The specified label location must be within a scope. Such scope may begin at the next non-empty embedded statement relative to the label location.footnote:[For GTA III 10th Anniversary multi-files, all target scopes are a line after its target label, which would emit an error in the in-house compiler (for GTA Vice City).]

The type of a local variable and its respective input argument must match. For instance, if an input argument is an integer literal or variable of integer type, its corresponding local variable in the target scope must be of integer type.

If there are not enough local variables in the target scope to accomodate the input arguments the program is ill-formed.

If an input argument is a variable, the value assignment to the variable in the target scope shall obey the same constraints as specifiedin theSETalternator.

If an input argument is a variable, the value assignment to the variable in the target scope shall obey the same constraints as specifiedfor `SET` (<<alternator-def-set>>).

A _subscript file_ is a script file required by the means of a LAUNCH_MISSION statement. A _subscript_ is a script started by the same statement.

A _mission script file_ is a script file required by the means of a LOAD_AND_LAUNCH_MISSION statement. A _mission script_ is a script started by the same statement. Only a single mission script can be running at once.

A _mission script file_ is a script file required by the means of a LOAD_AND_LAUNCH_MISSION statement. A _mission script_ is a script started by the same statement.

An implementation may contain special features regarding the way subscripts and mission scripts are executed.

The lexical grammar of the language is context-sensitive. As such, the lexical elements and the syntactic elements are presented together.

The lexical grammar of the language is context-sensitive. As such, the lexical elements and the syntactic elements are presented together.footnote:[The in-house compiler is an ad-hoc parser, introducing a lot of contextual problems to the language.]

[[element-source-code]]

=== Source Code

_Source code_ is a stream of printable ASCII characters plus the control codes line feed (`\n`), horizontal tab (`\t`) and carriage return (`\r`).

_Source code_ is a stream of printable ASCII characters plus the control codes line feed (`\n`), horizontal tab (`\t`) and carriage return (`\r`).footnoteref:[miss2]

Carriage returns should appear only before a line feed.

Carriage returns should appear only before a line feed.footnote:[The in-house compiler does not have such a restriction. We introduce it for simplicity.]

Lowercase letters in the stream shall be interpreted as its uppercase equivalent.

Space, horizontal tab, parentheses and comma are defined aswhitespace characters.

Space, horizontal tab, parentheses and comma are defined as_whitespace_ characters.

Each line should be interpreted as if there is no whitespaces in either ends of the line.

Each line should be interpreted as if there is no whitespaces in either ends of the line.footnoteref:[simplify-whitespace,This simplifies the syntactic specification.]

A _token character_ is any character capable of forming a single token.

* _Line comments_ starts with the character sequence `//` and stop at the end of the line.

* _Block comments_ starts with the character sequence `/\*` and stop with its matching `*/`. Block comments can be nested inside each other.

The contents of a comment shall be interpreted as if it is whitespaces in the source code. More specifically:

The contents of a comment shall be interpreted as if it is whitespaces in the source code.footnoteref:[simplify-whitespace] More specifically:

* A line comment should be interpreted as an `eol`.

* A single, nested, block comment should be interpreted as an `eol` on each line boundary it crosses. On its last line (i.e. the one it does not cross), it should be interpreted as one or more whitespace characters.

Comments cannot start inside string literals.

Comments cannot start inside string literals.footnote:[i.e. `"This // is a string"` is a string literal, not an incomplete string.]

[[element-command]]

=== Commands

An _integer literal_ is a sequence of digits optionally preceded by a minus sign.

An _integer literal_ is a sequence of digits optionally preceded by a minus sign.footnoteref:[miss2]

If the literal begins with a minus, the number following it shall be negated.

A _floating-point literal_ is a sequence of digits which must contain at least one occurrence of the characters `.` or `F`.

Once the `F` characters is found, all characters including and following it shall be ignored. The same shall happen when the character `.` is found a second time.

Once the `F` characters is found, all characters including and following it shall be ignored. The same shall happen when the character `.` is found a second time.footnote:[We have not simplified this misfeature because it is used in one of the GTA III 10th Anniversary scripts.]

The literal can be preceded by a minus sign, which shall negate the floating-point number.

A _variable reference_ is a variable name optionally followed by an array subscript.

A _variable reference_ is a variable name optionally followed by an array subscript.footnoteref:[miss2]

The type of a variable reference is the type of the variable name being referenced.

The subscript uses an integer literal or another variable name of integer type for zero-based indexing.

The subscript uses an integer literal or another variable name of integer type for zero-based indexing.footnote:[The in-house compiler uses one-based indexing. Its array feature is incomplete and produces problematic bytecode when subscripting variables. Additionally, the GTA Vice City runtime (the target of the in-house compiler) does not support arrays. Thus it's believed this feature is still incomplete in V413 and was never used. Not until GTA San Andreas, which introduces arrays in the execution environment. Its runtime performs zero-based indexing on variable subscripts, but for literal subscripts we can only guess. The compiled multifile contains debug strings that suggests zero-based indexing for literals.]

The program is ill-formed if the array subscript uses a negative or out of bounds value for indexing.

The program is ill-formed if a variable name is followed by a subscript but the variable is not an array.

The program is ill-formed if a variable name is followed by a subscript but the variable is not an array.footnoteref:[miss2]

An array variable name which is not followed by a subscript behaves as if its zero-indexed element is referenced.

An argument in an expression cannot be a string literal.

The name of commands used to require script files (e.g. `GOSUB_FILE`) and its directive commands (i.e. `MISSION_START` and `MISSION_END`) cannot be on the left hand side ofa expression.

The name of commands used to require script files (e.g. `GOSUB_FILE`) and its directive commands (i.e. `MISSION_START` and `MISSION_END`) cannot be on the left hand side ofan expression.

[[assignment-expressions]]

=== Assignment Expressions

The ternary assignment `a = b - c` behaves as if the following is executed:

* `SUB_THING_FROM_THING a c` if the name `a` is the same as the name `b`.

* Implementation-defined if `a` is the same name as `c`.

* Implementation-defined if `a` is the same name as `c`.footnote:[The in-house compiler uses unsupported command selectors (`NEGATE` for substraction and `ONEOVER` for division) to perform this operation.]

* `SET a b` followed by `SUB_THING_BY_THING a c` otherwise.

The ternary assignment `a = b * c` behaves as if `a = b + c`, except by using `MULT_THING_BY_THING` instead of `ADD_THING_TO_THING`.

A _parameter definition_ is a set of definitions regarding a single parameter for a specific command.

A command must have the same amount of arguments as its amount of parameter definitions, unless the missing arguments correspond to_optional parameters_ (defined below).

A command must have the same amount of arguments as its amount of parameter definitions, unless the missing arguments correspond tooptional parameters.

If a variable is used in the same command both as an input and as an output, the input shall be evaluated before any output is assigned to the variable.

An entity can be assigned to a variable. In such case, the variable is said to be of that specific entity type from that line of code on. Previous lines of code are not affected.

If an entity type is associated with an parameter and a variable is used as argument, the variable must have the same entity type as the parameter.

Further semantics for entities are defined along this document.

If an entity type is associated with an parameter and a variable is used as argument, the variable must have the same entity type as the formal parameter.

[[parameter-types]]

=== Parameter Types