Rz language version 3.6
(This compiler is still a work in progress. )
Rz is a descendant of R1, a concurrent language for small control
applications. (Have a look at full report and implementation from my research work web
page). Rz is aimed to be a teaching language for system
programming and computer architecture subjects, which emphasises a small
language that can be used to illustrate all the "inner" working parts of a
computer system (compilation, code generation, ISA simulation), in other
words it allows students to "play" with the system. R1 is a
concurrent language. Rz simplifies that by eliminating all the real-time
concurrency language features and retains only the most basic language
constructs. In a way, Rz "looks like" C (without type).
Short description
The language is a small subset of C look-alike language. It has no type (or
having only one type which is "int"). Global variables must be
declared but local variables are automatic. A variable can be either a
scalar or an array. There is no user defined data type. An array
is one dimension. RZ language can be summarised as follows:
- It has only integer as primitive data. (natural size depends on
implementation)
- Global variables must be declared before their use. Local
variables are automatic (not required to be declared).
- Global variables can be array. The size of array must be known
at compile time. An array has only one dimension. Local
variables can be only scalar.
- Reserved words are: if, else, while, return, print.
- Operators are: +, -, *,
/, ==, !=, <, <=, >, >=, !, &&, ||, *
(dereference), & (address).
For C programmer, please note, no: for, break, do, missing many operators
especially ++, -- . The syntax looks clean because it uses
indentation instead of {} and using a newline to terminate a statement
instead of ';'.
Examples
It is easier just to look at an example to know most of the syntax.
Here is an example of Rz
// find max
in an array
a[10], N
init()
i = 0
while (
i < N )
a[i] = i
i = i + 1
main()
N = 10
init()
max =
a[0]
i = 1
while(
i < N )
if( max < a[i] ) max = a[i]
i = i + 1
print(max)
The variables a[], N are globals, max, i are locals. For an array, the
size must be known at compile time. (A note of C user, there is no ++,
--, and no "break", "print" is not "printf"). "print" knows only integer and
string. The size of basic unit (integer) depends on the target
machine.
// sum array
ax[10]
sum()
i = 0
s = 0
while( ax[i] != 0 )
s = s + ax[i]
i = i + 1
return s
main()
ax[0] = 11
ax[1] = 22
ax[2] = 33
ax[3] = 44
ax[4] = 0
print(sum())
The call by reference can be achieved using the * and & operators just
like in C. In short, you can think of Rz syntax as C without type
declaration.
increment(x)
*x = *x + 1
main()
a = 1
increment(&a)
print(a)
With version 3.6, the compiler generates machine code for S2 version 3
(s23). A special syntax is introduced to enable a low level code
generation.
asm("...x ")
where x is an assembly statement. The compiler will output this
statement to the output file. To use this feature, understanding of S2.3
assembler is necessary.
s23 assembly language
Current state of implementation
Recursive call is not working. (I still got code generation for
recursive call incorrectly passing parameters). * and & operators have
not been implemented yet. The output of the compiler is the s2.3 assembly
language. It can be assemble and run under s2.3 simulator.
Session example
Here is hand-on how to use the compiler. Compile the "sum array"
program above. The screen will show:
c:> rz36 sum.txt
.symbol
fp 30
sp 29
retval 28
rads 27
ax 2000
.code 0
mov fp #4000
mov sp #3000
jal rads main
trap r0 #0
:sum
st r1 @1 fp
st r2 @2 fp
st r3 @3 fp
st r4 @4 fp
add fp fp #5
st rads @0 fp
mov r1 #0
mov r2 #0
jmp L102
:L103
ld r3 @ax r1
add r4 r2 r3
mov r2 r4
add r1 r1 #1
...
:main
...
ld r1 @1 fp
ret rads
.data 200
.end
Download
rz36.zip compiler source that generates
s2 assembly code
last update 13 Jan 2013