CAMLE Compiler

CAMLE is based on the While language from "Semantics with Applications: A Formal Introduction" by Nielson and Nielson. CAMLE stands for Compiler to Abstract Machine for Language Engineering, imaginative? Yes, I know.

Language properties

Comments are started with { and finished with }, they can run over multiple lines.
Both comments and whitespace are ignored
Identifiers are 1 to 8 characters long, the first of which must be alphabetic then followed by 0 to 7 alphanumeric characters.
Constants are integer numbers, i.e. any sequence of decimal digits
Strings are enclosed in single quotes, two single quotes in a row escapes the quote. E.g. '''' is the string of a single quote.
Reserved words:
- do
- else
- false
- if
- read
- skip
- then
- true
- while
- write
- writeln

CAMLE Grammar

<program> ::= <statements>

<statements> ::= <statement> ( ';' <statement> )*
<statement> ::= <variable> ':=' <expression>
            |   'skip'
            |   'if' <booleanExpression>
                'then' <statement>
                'else' <statement>
            |   'while' <booleanExpression>
                'do' <statement>
            |   'read' '(' <variable> ')'
            |   <writeStatement>
<writeStatement> ::= 'write' '(' <expression> ')'
                 |   'write' '(' <booleanExpression> ')'
                 |   'write' '(' <string> ')'
                 |   'writeln'

<booleanExpression> ::= <booleanTerm> ( '&' <booleanTerm> )*
<booleanTerm> ::= '!' <boolean>
              |   <boolean>
<boolean> ::= 'true'
          |   'false'
          |   '(' <booleanExpression> ')'
          |   <relationalExpression>
<relationalExpression> ::= <expression> '=' <expression>
                       |   <expression> '<=' <expression>

<expression> ::= <term> ( ('+' | '-') <term> )*
<term> ::= <factor> ('*' <factor>)*
<factor> ::= <variable>
         |   <constant>
         | '(' <expression> ')'

Virtual Machine

A virtual machine has been provided which is based on the Jouette architecture as described in Chapter 9 of "Modern compiler implementation in Java" by Andrew Appel.

The machine has an infinite number of registers (actually 1000000000 of them, because of the limited operand length). It is quite possible to use registers R101, R123456789, etc., but probably more sensible to use R0, R1, etc.
R0 is not initialized to 0 as described in the book. You need to explicitly set
R0 to 0 if you want to use it this way, e.g., by XOR R0,R0,R0.
Real (floating point) versions of most instructions are included.
All integer and real numbers are 32-bit.
Memory addresses used by LOAD and STORE are byte addresses, which must be a multiple of 4. These instructions move 4 bytes at a time, regardless of type.
The new instruction WRS (to print a string) refers to the memory address of a string terminated by a 0 byte.
Memory addresses (used by LOAD, STORE, and WRS) start at 0. Memory to be accessed by these instructions must be allocated by the pseudo-instruction DATA.

Assembly code grammar

<line> ::= ( <label> ':' )? <instruction>? ( ';' <comment> )?
<instruction> ::= <opcode> ( <operand> ( ','? <operand> )? ( ','? <operand> )? )?
<operand> ::= <constant>
          | <register>
          | <label>

A <constant> is any (possibly signed) integer or real constant, as accepted by the "%d" or "%f" format of C. E.g., 1234 or -9.876.
A <register> is the letter 'R' or 'r' followed by one or more digits. E.g., R1 or R987654321.
A <label> is any alphanumeric string that is not a register or a constant.
Every label used as an operand must be defined, by appearing as a label on some line, and no label may be defined more than once.
A label refers to the instruction on the same line, or to the next instruction if there is no instruction on the same line as the label. This makes it possible for more than one label to refer to the same instruction.

Instructions