3.1 Import and Export

Export    The export keyword indicates that a symbol bound at top level in a module should be visible to importing modules. When interpretation of the module is completed, and the top-level environment is fully defined, a selective copy of the elements of this environment is made to create a ``public'' environment containing only the exported symbols. This is the environment that is obtained by a subsequent import statement.

Import    The import statement has two effects. If the imported module has not yet been loaded and intepreted, this is done at the time of the first import. A given module will be imported at most once during an execution of mkimage.

The left-hand identifier specified in an import gives a local identifier to which the public environment of the imported module is bound. Thus, if a is defined to 1 and exported by module coyotos.SpaceBank, then the statements:

import sb = coyotos.SpaceBank;
print sb.a;

displays the value "1".

3.2 Defining Statements

The defining statments introduce variables, procedures, and enumerations:

def_stmt: def Ident '=' expr ';'
  | def Ident ({Ident {',' Ident}*}?')'
      block ';'
  | header? enum '{' enumDef+ '}'
  | header? enum Ident '{' enumDef+ '}'
  | header?capreg '{' enumDef+ '}'
  | header?capreg Ident '{' enumDef+ '}'
enumDef : Ident {'=' expr}*

The first def form associates an initial the value with an identifier and binds that identifier in the current scope.

The second def form introduces a procedure. When called, the body of the procedure will be executed in an environment consisting of its lexically preceding definitions within the module and the formal parameters of the procedure. Inner procedures are legal, and can be returned as values.

The enum form introduces enumerated constant values. The values of these identifiers cannot be modified. Enumerated constants are supported in the language because there are certain values that mkimage and it's constructed programs must agree on. In particular, enumerations are used to define slot numbers in the ``tools'' capability page of each process.

The capreg form introduces enumerated constant values that are to be used as capability register numbers. For purposes of use inside a mkimage file, there is no difference between a capreg enumeration and an enum.

When an enum or capreg definition is market by the header keyword, definitions for the enumerated constants will be emitted to the corresponding C header file when header files are generated. Constants defined in an enum enumeration will be emitted as integer literals, while constants defined in a capreg enumeration will be emitted as constant structure declarators of type capreg_t.

When an expression appears on the right hand side of an enumDef, it is subject to several constraints:

• The only functions that can be called are arithmetic functions and unary negation.

  The only identifiers that can be referenced are identifiers defined by earlier enumDef forms.

The combined effect of these constraints is that enumeration definitions may make reference to, and compute values based on, other enumeration definitions, but they do not require general interpretation to occur. This is necessary to support header file generation. At the time header files are generated the corresponding binary programs do not exist, so attempts to execute (e.g.) loadimage() would fail.

The value of a defining statement is unit.

3.3 Control Flow Statements

The statement:

if_stmt: if '(' expr ')' block { else block
  | if '(' expr ')' block { else if_stmt
stmt: if_stmt

provides conditional execution with the customary meaning. The value of this statement is the value of the executed block, or unit if the test expression produces false and no else clause is given. The expression in the test position should generate either an integer or a boolean result. If the result is an integer, the value zero is interpreted as a false condition result and non-zero is interpreted as a true condition result.

The statement:

return_stmt: return expr ';'

causes a value to be returned from the nearest enclosing procedure. This statement is not legal at module scope. Any statement following a return statement will not be executed.

The statement:

while_stmt: while '(' expr ')' block

Causes the sequence of statements within the block to be executed as long as the value of expr evaluates to true (see if statement, above). The return value of this statement is the value of the last iteration of executed block, or Unit if the loop is not executed at all.

The statement:

do_stmt: do block while '(' expr ')' ';'

Causes the sequence of statements within the block until the value of expr evaluates to true (see if statement, above). The return value of this statement is the value of the last iteration of executed block.

3.4 General Statements

The traditional syntax for assignment is accepted, and statements may be executed for side effects:

stmt: expr '=' expr ';'
stmt: expr ';'

The left hand side of an assignment must be an ``lvalue''. That is: an identifier bound in the current environment, a field of an object, or a slot of an array.

Sequences of statements may be surrounded by braces to form a statement block:

block: '{' block_stmt+ '}'
block_stmt: stmt
  | return_stmt
  | def_stmt

A block is not a legal statement. The value of a block is the value of the last executed statement within the block.

Diagnostics may be obtained during execution through two print statements:

stmt: print expr
  | print '*' expr

The first prints the value of the expression expr. If expr is a capability-valued expression denoting an object, the second prints the fields of the object in human-readable form.

The print statements may be dropped shortly in favor of comparable built-in procedures.

4.1 Basic Expressions

mkimage supports the traditional infix arithmetic, comparison, and boolean negation operators with the usual precedence:

expr: '-' expr
expr: expr arithop expr
expr: expr cmpop expr
expr: '!' expr
arithop: '-' | '+' | '/' | '*' | '%'
cmpop: '<' | '>' | '<=' | '>=' 
  | '==' | '!='

Arbitrary-precision integer literals, double-precision floating point values, and strings are valid expressions:

expr: Int | Float | String

The identifiers true and false are built-in literals:¹

expr: true | false

Procedure calls are expressions written in the usual way:

expr: expr '(' expr* ')'

4.2 Object Allocation Expressions

Processes, GPTs, Endpoints, Pages, CapPages, and Banks are primitive objects. Creating one entails reserving real storage in the output image file. In consequence, allocation of these is supported by syntax:

expr: new Bank '(' expr ')'
expr: new CapPage '(' expr ')'
expr: new GPT '(' expr ')'
expr: new Endpoint '(' expr ')'
expr: new Page '(' expr ')'
expr: new Process '(' expr ')'

The expr argument must be a bank capability.

4.3 Vector and Environment Expressions

If env is a environment-valued expression, and ident is a field of the corresponding object, then: env.ident is an lvalue expression denoting the location of that field. When this appears in a use-occurrence, it is automatically promoted to the value of the field.

expr: expr '.' Ident

For each of the objects defined in the Coyotos specification, if expr is a capability-valued expression naming one of these objects then expr is also an environment-valued expression whose identifiers are the fields of the object. For example:

;references the fault code slot:
processCap.faultCode
;references the GPT capability array:
gpt.cap

If evec is an expression denoting an array, and ndx is an integer-valued expression, then: evec[ndx] is an lvalue expression denoting a slot in that array (or raises an exception if bounds are violated). When this appears in a use-occurrence, it is automatically promoted to the value of the field.

expr: expr '[' expr ']'

For example:

;references to a capability register:
processCap.capReg[ndx]
;references to a GPT capability slot:
gpt.cap[2]

Environment-valued and vector-valued expressions are obtained by calling various built-in library procedures within the mkimage runtime. A capability page capability is a vector-valued expression. The cap field of a GPT is a vector-valued expression.

4.4 Block Expressions

A statement block is an expression whose value is the value of the last statement. Note that this subsumes the need for a local binding construct:

def a = { def i = 1; i + 3; };