# Plain Assembly examples

I used a bit of space on If, so I will just quickly draft the rest of the instructions in High Level Assembly syntax and Low Level Assembly syntax assuing I need both – we can discuss the draft and possible changes later.

# For loop

```for A=1 to 10 step 1
nop
end```

Low Level Assembly:

```start     for A=1 to 10 step 1, next end1
nop
goto start
end1```

The for statement is 6 x 16 bit entries + 2 for the goto – 8 entries.

# Assign statement

Assign is will parse an expression and create an executable table that compute that expression and store the result in a register run-time. This is expected to bloat a bit.

`Assign A = B + C / D`

The parser will convert this into an instruction consisting of op-code and an array of math intructions as follows:

```op-code
R1=C/D
A=B+R1```

Each table entry will take between 3-4 16 bit entries, meaning that the Assign is 7-9 entries in binary code. I will be more exact on this as I dig up some old code on this.

Low level assembly would be as follows:

`             Assign R1=C/D, A=B+R1`

# While loop

A while loop contains an Expression that need an assign statement

```While A+B/C > 1
NOP
End```

Low level Assemby example:

``` while   Assign R1 = A+B/C
ifgt R1, 1 next end
nop
goto while
end```

# Loop statement

Not sure this adds any value, but it is a way to avoid writing goto. We can always remove it later.

High level assembly example

```loop
nop
end```

Low Level assembly example

```loop1   nop

goto loop1```

# Exit

Exit is a single 16 bit instruction that terminate the module execution.

# Raise & Call statements

These are identical in syntax, but with a different op-code since Raise do not create a return and Call does. Using Raise on a module is the same as exit with parameters.

High level assembly example

```Raise Error(A1, A+B, C)
or
Call MyFunc(A1, A+B, C)```

Low Level assembly example

The assembly need to use assign to compute expressions into a list of registers that can be used as parameters.

```Assign R1=A+B
Raise Error (A1, R1, C)

or

Assign R1=A+B
Call Myfunc (A1, R1, C)```

Assign will in this case use 1 + 4 =5 entries. The Call/Raise will use 1 op-code + one for instruction to call and 3 for parameters = 5, so they do in effect use 10 x 16 bit entries.

# Switch

Looking at the assembly I ditched switch for now!

# Return

Single entry instruction.

# Encode/Decode

Encode/Decode is intended for bit manipulation. Decode will read a bit and convert it into a 32 bit register, encode will read the register and write the bit Field.

```Encode A:4:2 = B
Decode B = A:4:2```

These are low level instructions using 4 entries each.