luxferre/n808
1
0
Fork 0
Code Actions Activity

initial upload

Browse Source
This commit is contained in:
Luxferre
2025-05-04 11:46:54 +03:00
commit 5810c2f985
22 changed files with 2146 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+538
View File
@@ -0,0 +1,538 @@
n808 VM specification
=====================
n808 (always lowercase, pronounced _nano-bob_) is a Harvard-type numeric-only
virtual machine based on an elaborate effort of further simplification of the
[mu808 VM](https://codeberg.org/luxferre/mu808) specification. The n808 VM comes
with its own assembly language, N8A, and strict plaintext and binary machine
code format definitions.
Features
--------
* Data memory: 128 cells (125 of which are mutable, see below)
* Program memory: 128 steps
* Data cell type: floating point (or fixed point where floats are unsupported)
The n808 data memory contains several special addresses that cannot be used
for writing custom data into them:
* 0: read-only, always returns 0 when accessed;
* 125: read-write but gets overwritten by `jmp 14` instructions to store the
return instruction address;
* 126: read-only, always returns -1 when accessed;
* 127: read-only, always returns 1 when accessed.
Instruction format
------------------
Every n808 instruction `[opcode] [p1] [p2] [p3]` is 24 bits (3 bytes) long:
* 3 bits for opcode;
* 7 bits for parameter 1;
* 7 bits for parameter 2;
* 7 bits for parameter 3.
Implementations may accept both text and binary representations, but every
instruction can only be entered as a single non-negative integer number.
The value of this number is: `opcode * 2097152 + p1 * 16384 + p2 * 128 + p3`.
In case an implementation is only expecting the binary format, the byte order
of the number must be big-endian, from the most to the least significant byte.
In case of plain text representation, instructions can be separated with any
non-digit characters, but only the support for whitespaces and newlines as the
delimiters is absolutely required.
If an implementation supports the host filesystem, it is recommended to store
the plain text machine code with the `.n8` file suffix, and the binary machine
code with the `.n8b` file suffix. Since a program can at most contain 128 n808
instructions that are 24 bits each, the maximum `.n8b` file size is 384 bytes.
Note: contrary to 1V0, 808UL and mu808, instruction numbers are no longer part
of the instructions. Every instruction is numbered sequentially, starting from
the step 0 (unlike 808UL and mu808, step number 0 is not reserved for immediate
execution).
Instruction set
---------------
This description assumes that every instruction accepts address parameters
`p1`, `p2` and `p3`, and `v1`, `v2` and `v3` refer to the actual contents
of data memory cells at those addresses.
Some instruction descriptions also contain shortcut mnemonics. These mnemonics
are just for convenience, as they, just like the main mnemonics, are converted
into real numeric instructions by the N8A assembler. Shortcuts always take less
parameters than real instructions. Some shortcuts, like `nnn` or `ret`, do not
take any parameters at all.
Note that mnemonics and shortcuts are a feature of the N8A assembly language and
not n808 per se. The VM itself only operates on numbers in both program and data
memory areas.
### 0 NOP: no operation
Ignore all parameters and do nothing.
Shortcut: `nnn` = `nop 0 0 0`
### 1 JMP: jump
The logic depends on the value of `p1`:
* 0: jump to the address `p3` if `v2` equals to zero;
* 1: jump to the address `p3` if `v2` is above zero;
* 2: jump to the address `p3` if `v2` is below zero;
* 3: jump to the address `p3` if `v2` is above or equals to zero;
* 4: jump to the address `p3` if `v2` is below or equals to zero;
* 5: jump to the address `p3` if `v2` does not equal to zero;
* 6: jump to the address `p3` unconditionally;
* 7: jump to the address `v3` if `v2` equals to zero;
* 8: jump to the address `v3` if `v2` is above zero;
* 9: jump to the address `v3` if `v2` is below zero;
* 10: jump to the address `v3` if `v2` is above or equals to zero;
* 11: jump to the address `v3` if `v2` is below or equals to zero;
* 12: jump to the address `v3` if `v2` does not equal to zero;
* 13: jump to the address `v3` unconditionally;
* 14: save the next instruction pointer to the cell 125 and jump to
the address `p3` unconditionally.
In case of jumping to the address `v3`, it is converted to an integer first.
Shortcuts:
* `jeq` = `jmp 0` (direct jump if equals to zero)
* `jgt` = `jmp 1` (direct jump if greater than zero)
* `jlt` = `jmp 2` (direct jump if less than zero)
* `jge` = `jmp 3` (direct jump if greater than or equals to zero)
* `jle` = `jmp 4` (direct jump if less than or equals to zero)
* `jne` = `jmp 5` (direct jump if not equals to zero)
* `juc` = `jmp 6 0` (direct unconditional jump)
* `ieq` = `jmp 7` (indirect jump if equals to zero)
* `igt` = `jmp 8` (indirect jump if greater than zero)
* `ilt` = `jmp 9` (indirect jump if less than zero)
* `ige` = `jmp 10` (indirect jump if greater than or equals to zero)
* `ile` = `jmp 11` (indirect jump if less than or equals to zero)
* `ine` = `jmp 12` (indirect jump if not equals to zero)
* `iuc` = `jmp 13 0` (indirect unconditional jump)
* `jpr` = `jmp 14 0` (jump to a procedure)
* `ret` = `jmp 13 0 125` (return from a procedure)
### 2 IAT: indirect addressing toggle
Overrides the next instruction by providing `v1`, `v2` and `v3` as the parameters
for the next instruction's command. The actual command parameters provided with
the next instruction will be ignored.
Shortcuts: none
### 3 INO: port input/output
This instruction combines input and output depending on the port number in `p1`.
Generally, even ports are related to output and odd ports are related to input:
* 0: standard (numeric) output;
* 1: standard (numeric) input;
* 2: character output (if supported);
* 3: character input (if supported).
The `p2` and `p3` parameters define the range of addresses to output the data from
or input the data into.
Shortcuts:
* `out` = `ino 0` (numeric output)
* `inp` = `ino 1` (numeric input)
* `ouc` = `ino 2` (character output)
* `ipc` = `ino 3` (character input)
### 4 CPY: copying/assignment
The logic depends on the value of `p1`:
* 0: set the memory cell `p3` to `p2`;
* 1: set the memory cell `p3` to `v2`;
* 2: set the memory cell `v3` (converted to integer) to `p2`;
* 3: set the memory cell `v3` (converted to integer) to `v2`;
* 4: set the memory cell `v3` (converted to integer) to the value at address
`v2` (converted to integer).
Shortcuts:
* `dca` = `cpy 0` (direct constant assignment)
* `dva` = `cpy 1` (direct value assignment)
* `ica` = `cpy 2` (indirect constant assignment)
* `iva` = `cpy 3` (indirect value assignment)
* `ivc` = `cpy 4` (indirect value copy)
### 5 SET: large value assignment
Set the memory cell `p3` to the value of `p1 * 100 + p2 + v3 / 100`.
Shortcuts: none
### 6 MAT: mathematical operations
The logic depends on the value of `p1`:
* 0: set the memory cell `p3` to `v2 + v3`;
* 1: set the memory cell `p3` to `v2 - v3`;
* 2: set the memory cell `p3` to `v2 * v3`;
* 3: set the memory cell `p3` to `v2 / v3` if `v3` is not zero,
otherwise set it to zero;
* 4: set the memory cell `p3` to `v2 mod v3` if `v3` is not zero,
otherwise set it to the integer part of `v2`.
* 5: set the memory cell `p3` to `|v2|` (absolute value of `v2`);
* 6: set the memory cell `p3` to the square root of `|v2|`;
* 7: set the memory cell `p3` to the natural exponent of `v2` (`e ** v2`);
* 8: set the memory cell `p3` to `ln |v2|`;
* 9: set the memory cell `p3` to `sin v2` (`v2` given in radians);
* 10: set the memory cell `p3` to `cos v2` (`v2` given in radians);
* 11: set the memory cell `p3` to `arctg v2`.
Shortcuts:
* `add` = `mat 0` (addition)
* `sub` = `mat 1` (subtraction)
* `mul` = `mat 2` (multiplication)
* `div` = `mat 3` (division)
* `mdf` = `mat 4` (modulo/floor)
* `inc` = `mat 0 127` (increment)
* `dec` = `mat 0 126` (decrement)
* `neg` = `mat 1 0` (negation)
* `inv` = `mat 3 127` (inverse/reciprocal)
* `abs` = `mat 5` (absolute value)
* `sqr` = `mat 6` (square root)
* `exp` = `mat 7` (natural exponent)
* `log` = `mat 8` (natural logarithm)
* `sin` = `mat 9` (sine)
* `cos` = `mat 10` (cosine)
* `atn` = `mat 11` (arctangent)
### 7 RND: random number generator
Set the memory cell `p3` to a random integer number between `v1` and `v2`
(inclusively).
Shortcuts: none
Interactive mode
----------------
Unlike 1V0/808UL/mu808, n808 only accepts the following command parameters
in the interactive mode:
* `0 [step no] 0`: run the currently loaded program starting at a particular step;
* `1 [step no] [instr]`: enter an instruction into the program
memory (the previous instruction at that step will be overwritten);
* `2 [p1] [p2]`: clear a range of instructions from address `p1` to `p2` (incl.);
* `3 [p1] [p2]`: clear a range of data from address `p1` to `p2` (incl.);
* `4 0 0`: exit to the OS or reset the VM if the exit is not supported.
Assembly source code file format (N8A)
--------------------------------------
In addition to direct machine code in the plain text or N8B formats, the n808
VM also allows using an assembly-like language to write programs using labels
and the above mnemonics (case-insensitive). The recommended file suffix is
.n8a.
An assembly line looks like this (the optional parts are enclosed in square
brackets): `[:lbl] MNEMONIC p1 p2 p3 [;comment]`. Labels are optional but must
start with a colon (`:`) and be on the same line before the instruction they
label. The mnemonics are specified above in the core opcode list and the
shortcut list for each opcode. In the second case, shortcuts accept less
instruction parameters than the opcode they refer to.
Besides normal assembly lines, N8A also supports alias definition lines that
start with `#` and have the following format: `#number alias`. In the rest of
your code, you can recall any alias with the `@alias` form. For instance, if you
have defined `#21 counter` (use the cell 21 as counter), you can then write
`inc @counter` as opposed to `inc 21`. The alias feature allows you to replace
any constant numbers with easily remembered words within your N8A assembly.
Every alias must be defined on a separate line of code.
Here, the exact assembly algorithm is specified step-by-step for each line in
the N8A assembly file to convert it into a plain text based machine code
representation:
1. Remove all comments (starting with `;` until the end of the line).
2. Replace all jump/function shortcuts according to the above mnemonics.
3. Record the current line number N (not counting completely empty lines),
starting with 0.
4. Split the line into space-delimited fields (1-based numbering as well).
5. Check if the first field starts with `:`. If so, mark the mapping between
the field text and the number N, then remove the field from the set
(so that the field 2 becomes field 1 and so on).
6. Check if the first field starts with `#`. If so, mark the mapping between
the text of the field 2 and the rest of the field 1 into the label mapping,
prepending `@` to the text of the field 2.
7. If the field 1 is not already a number, replace the field 1 mnemonic text
with the numeric opcode if it can be found. If it's not a number and the
mnemonic cannot be found, report an error and halt the process.
8. Write the result as a new line into the intermediate text file.
9. After the steps 1 to 8 are complete for every line, replace every label
occurrence in the mapping with the corresponding number in the intermediate
text file.
10. For every line in the intermediate text file, convert the four numbers on
that line (`opcode`, `p1`, `p2`, `p3`) into a single number according to this
formula: `instruction = opcode * 2097152 + p1 * 16384 + p2 * 128 + p3`.
Write the result as a (space-delimited) field into the target code file.
Examples
--------
The [examples](examples/) subdirectory contains several N8A source code file
examples for n808 (some of which are ports of the same mu808 example programs),
namely:
* [Compound interest calculator](examples/compound.n8a),
* [Linear regression calculator](examples/linreg.n8a),
* [Hellorld!](examples/hellorld.n8a) (a tribute to @UsagiElectric)
(requires I/O port 2 support),
* [FizzBuzz classic program](examples/fizzbuzz.n8a)
(requires I/O port 2 support),
* [A simple 10-character echo test](examples/echo.n8a) (requires both I/O
port 2 and port 3 support),
* [Bulls and Cows game](examples/moo.n8a),
* [Lunar Lander game](examples/lunar.n8a),
* [NumberJack](examples/numjack.n8a) port of a Blackjack game, utilizing some
advanced techniques (see the comments in the beginning on how to play it).
You can assemble them using any of the reference assemblers provided within the
repository, or even by hand (by numbering lines, resolving the labels/shortcuts
and replacing mnemonics with corresponding opcodes).
If you just want to test an implementation, assembled N8 machine code files
(in the plaintext format) are stored in the `examples/assembled` subdirectory.
After loading into the REPL, you can run each of them with the `0 0 0` sequence.
Reference implementations
-------------------------
### n808 VM implementations
* [ANSI C implementation](n808.c) (C89 standard): the primary version where all
development is being done. Supports the entire specification but only preloads
the `.n8` (text-based format) machine code files.
Compile the source with: `cc -std=c89 -O2 -s -lm -o n808 n808.c`
* [Python 3/MicroPython implementation](n808.py): supports the entire n808 spec
and runs in any Python 3 environment. Only preloads the `.n8`-type code files.
* [POSIX AWK implementation](n808.awk): supports the entire specification except
the I/O port 3 (character input). Otherwise, it is a line-to-line port of the
C89 and Python 3 versions. Only preloads the `.n8`-type code files, can be run
as follows: `LC_ALL=C awk -f n808.awk [- input_program.n8]`
### N8A assembler implementations
* [n8asm.py](n8asm.py): the reference assembler/disassembler for the N8A
language. Supports all real and shortcut mnemonics mentioned in this README.
Besides assembling and disassembling `.n8` and `.n8b` files, also supports
in-place conversion between these two formats and exporting N8 text-based
machine code into the N74 format for usage in the TI-74 and other similar
BASIC-based n808 VM implementations.
Other implementations (VMs, assemblers, helper tools)
-----------------------------------------------------
### Texas Instruments TI-74 portable computer
The [n808.b74](n808.b74) file contains a BASIC port of n808 for the Texas
Instruments TI-74 portable computer (tested on the TI-74S variant). Due to the
resource constraints, the following limitations apply:
* no interactive mode (the RUN command directly executes the predefined program
in the VM),
* the program itself is entered into the DATA statements in the so-called N74
format (see below),
* no boundary checks for the addresses inside the program.
Also, since the VM runs on top of a BASIC interpreter, program execution is
extremely slow most of the time. Keep in mind, this is more of a proof of
concept than a viable solution, and using the "native" TI BASIC is preferred for
any serious computing on that machine.
In order to store your programs for execution, you must store the N8 instruction
values in the DATA statements, starting from the BASIC line number 1000. The
last data entry of the program must be -1. You can fit as many data entries on
a line as the machine allows (usually up to 7, given the instruction number
length in the decimal form). To ease the program entry process, you can start it
with the `NUM 1000,1` command, and use `FN N` key combo to enter the `DATA `
keyword.
For instance, the compound interest calculator example looks like this in N74:
```
1000 DATA 8401409,6308099,12632321,12599169,12714113,12616065,12697729
1001 DATA 6291585,-1
```
To make the conversion easier, the official n808 assembler, n8asm.py, supports
the `t74` mode that accepts a plain N8 machine code file and outputs the same
program in the N74 format.
### Casio fx-3400P programmable scientific calculator
Unfortunately, the fx-3400P's program memory is too small to be able to fit in
any full-featured n808 VM or assembler, but here's a couple of helper keystroke
programs for converting the four numeric instruction parts into a machine code
instruction and vice versa. The encoding and decoding process is done according
to the formula `ins = opcode * 2097152 + p1 * 16384 + p2 * 128 + p3`.
These programs will help you with hand-assembling n808 code in case you don't
have a PC or any modern Web-enabled device to do it on.
The complete encoding/decoding suite consisting of both routines to be saved in
the P1 and P2 areas is presented here along with the sequences to enter them
(the `ENT` key is the same as the `RUN` key in the program entry mode):
```
128 Kin 6
MODE EXP SHIFT PCL MODE 1 DEC P1
x Kout 6 + ENT = x Kout 6 + ENT = x Kout 6 + ENT =
SHIFT P2
Kin 1 / Kout 6 = Kin 2 * Kout 6 - Kout 1 = +/- SHIFT HLT Kout 2 SHIFT x>0
MODE .
```
Note that you need to keep the value 128 in the register 6 at all times for both
routines to work correctly.
To encode an instruction, first enter the opcode and press the `P1` key, then
enter parameter 1 and press `RUN`, then enter parameter 2 and press `RUN`, then
enter parameter 3 and press `RUN` The program will output the resulting machine
instruction as a single decimal number. In case you're directly hand-assembling
a binary machine code file (N8B) file, you can view the hexadecimal
representation of the number by pressing the `MODE 1 HEX` sequence (press
`MODE 0` to return to the normal mode).
Example: suppose the instruction is `out 16 18`, which translates to
`ino 0 16 18`, meaning `3 0 16 18`. As expected, after entering each parameter
and pressing the `RUN` key, the program will output the final result 6293522
to be entered into the VM as the machine code.
To decode an instruction, enter the instruction value and press `SHIFT P2`. The
program will output the instruction parameters in the reverse order: parameter
3, parameter 2, parameter 1 and then the opcode. Continue pressing the `RUN` key
until you get all four parameters, press it once more to finish the program.
E.g. if we enter the instruction value 6293522 and press `SHIFT P2`, the program
will first output 18, then 16, then 0, then 3.
Note that the whole suite takes exactly 29 steps (the entire program memory in
the Casio fx-3400P calculator), so it doesn't clear the mode after finishing.
Once you don't want to stay in the integer calculation mode, press `MODE 0` to
return to the normal mode.
### Citizen SRP-145 and other programmable calculators using Sharp LI3301A chip
One of the first cheap programmable calculator architectures of the past was the
Sharp LI3301A chip that never made it into Sharp's own calculators. I happen to
have a Citizen SRP-145T-II based on the same hardware.
Similarly to Casio fx-3400P, this calculator only has enough (40-step) program
memory for instruction encoding/decoding helper routines. However, they must be
entered separately as the SRP-145T only has a single program storage area. It
also has much less register memory, no flow control or integer calculation mode.
Here's what an n808 instruction encoding routine looks like in SRP-145:
```
SHIFT PGM
x 128 + SHIFT [x] = x 128 + SHIFT [x] = x 128 + SHIFT [x] =
SHIFT PGM
```
To encode an instruction, first enter the opcode and press the `RUN` key, then
enter parameter 1 and press `RUN`, then enter parameter 2 and press `RUN`, then
enter parameter 3 and press `RUN` The program will output the resulting machine
instruction as a single decimal number.
Since there's no integer conversion in LI3301A, the instruction decoding routine
relies on a DMS precision exhaustion hack (the DMS is the `SHIFT /` key to
convert decimal degrees into degrees/minutes/seconds, where the minutes and the
seconds are shown after the decimal point):
```
SHIFT PGM
MR SHIFT Ka 128 SHIFT 1/x Ka
SHIFT / (23 times)
X->M x 128 - 1 Ka = +/-
SHIFT PGM
```
To run the routine, enter the instruction value and then press `X->M RUN`.
The program will output the parameters in the reverse order (first parameter 3,
then parameter 2, then parameter 1, then the opcode). Continue pressing `RUN`
until you get all four parameters. Clear the memory register(s) when finished.
Note: due to the hackiness of the method, you may get non-integer outputs. Just
round the results to the nearest integer if you get a fractional part.
### Sharp EL-506P scientific calculator and its clones
These calculators are non-programmable but are the cheapest scientific calcs in
the world, and can help you with n808 instruction encoding and decoding.
Since this architecture has algebraic input, encoding is straightforward and
based on the initial formula:
```
[opcode] x 2097152 + [p1] x 16384 + [p2] x 128 + [p3] =
```
Decoding can be done based on the fact that conversion to hexadecimal and back
only leaves the integer part. One of the most optimal sequences is mostly using
hexadecimal flow:
```
[instruction] X->M 2ndf HEX / 80 * 80 - RM = +/- 2ndf DEC # display parameter 3
RM 2ndf HEX / 80 = X->M / 80 * 80 - RM = +/- 2ndf DEC # display parameter 2
RM 2ndf HEX / 80 = X->M / 80 * 80 - RM = +/- 2ndf DEC # display parameter 1
RM 2ndf HEX / 80 = 2ndf DEC # display the opcode
```
### Generic 8-digit four-function calculators
Four-function calculators mostly have their architecture stemming from early
Sharp LCD models such as EL-211 and EL-330. They are famous for their extremely
low prices, limited precision and non-algebraic input. Because of this, an
optimal keystroke sequence for n808 instruction encoding using them would be:
```
[opcode] x 128 + [p1] x 128 + [p2] x 128 + [p3] =
```
On the other hand, instruction decoding on such calculators is generally not
possible in a fully automated fashion, so the following algorithm is suggested
instead:
```
[instruction] / 2097152 - # note the integer part as the [opcode] value
[opcode] x 128 - # note the integer part as the [p1] value
[p1] x 128 - # note the integer part as the [p2] value
[p2] x 128 = # round to the nearest integer as the [p3] value
```
FAQ
---
### Why another ultralight VM? Isn't mu808 enough?
While mu808 already is compact enough, it still has some room for optimization
when it comes to the instruction format and port-based I/O. n808 aims to be an
architecture that can run on the devices where even mu808 would struggle.
Besides, n808 can also serve as a demo platform for the enthusiasts to try and
fit as much useful code as possible into the space as tight as 128 program steps
and 124 data cells (not counting cells 0, 125, 126 and 127). For instance, the
"Examples" section of this document contains several games that could be rather
difficult to fit into such space.
### Does n808 deprecate mu808 in the same way that mu808 deprecated 808UL?
**No**. These two VMs are being actively maintained in parallel. Moreover, there
are some plans to upgrade mu808's assembly language (MU8A) based on the
innovations introduced in the N8A language.
The author is currently more focused on the n808 implementations because it is a
more interesting challenge both to port the n808 VM itself and to write useful
software for it given the space constraints.
### When to choose mu808 and when to choose n808?
Choose mu808 when:
* resource constraints are not a significant factor;
* you need to retain the ability to compose programs in a human-readable
machine language (seeing every instruction component as opposed to a
single number) in addition to assembly;
* you rely on the interactive mode more than on preloaded programs.
Choose n808 when:
* your target environment is really tight on memory and CPU performance;
* you need or just want to have the machine code as compact as possible;
* you primarily run programs by preloading them and not entering via console.
Credits
-------
Created by Luxferre in 2025, released into public domain with no warranties.
examples/assembled/compound.n8
+8
View File
@@ -0,0 +1,8 @@
8401409
6308099
12632321
12599169
12714113
12616065
12697729
6291585
examples/assembled/echo.n8
+3
View File
@@ -0,0 +1,3 @@
8389899
6340746
6324363
examples/assembled/fizzbuzz.n8
+30
View File
@@ -0,0 +1,30 @@
8397628
8402109
8397118
8403647
8404288
8389953
8388609
12599169
8388994
12648578
8389251
12648579
8388741
2179346
6331965
6332480
6332480
8388613
2179479
6332223
6332480
6332480
8388613
2097818
6291585
2195483
6332609
8401412
12599428
2130439
examples/assembled/hellorld.n8
+11
View File
@@ -0,0 +1,11 @@
8397825
8401538
8402435
8402436
8402821
8403206
8402439
8401416
8392841
8389898
6324362
examples/assembled/linreg.n8
+49
View File
@@ -0,0 +1,49 @@
8388618
8388619
8388620
8388621
8388622
8388623
6307970
8405123
12616067
8405252
12616196
8405253
12615813
12583050
12583179
12583308
12583437
12583566
12599183
12583427
2113926
12599055
8406918
12617478
8406407
12616967
12600071
8406918
12617222
8406280
12616712
12600072
8406033
12632977
8406278
12617862
12600710
8406928
12632848
8406406
12617094
8406913
12617345
12599430
8406017
12616449
12681362
12632978
6293522
examples/assembled/lunar.n8
+79
View File
@@ -0,0 +1,79 @@
8395905
8421377
12599041
2113665
8389940
8391861
10487861
11708470
8394423
10486199
10960952
10800936
8401465
12623016
10749097
11673130
11212318
11393951
11575584
11757217
11938850
8397220
10489124
8397989
10486949
8394406
10486310
8394407
10485799
6296618
8388610
2168098
6308098
12622722
8410371
12589827
8405252
12599684
12632452
12714497
12622849
12604545
12589697
8405161
12622337
12604417
8405160
12604674
8405290
2118963
8388650
2118709
8388648
8411649
12604417
2113693
6296618
8409985
12604545
2113726
6295842
2195534
8409857
12604545
2113731
6295713
2195534
8409729
12604545
2113736
6295584
2195534
8409601
12604545
2113741
6295455
2195534
6295326
0
examples/assembled/moo.n8
+66
View File
@@ -0,0 +1,66 @@
8389898
8388668
8388797
8388926
8389055
8389184
8389313
8389442
8389571
8389700
8389829
8396358
8398919
8389902
10485774
8389131
8389761
14680193
12591873
8388866
8454274
8389891
12599555
2097552
8422657
8406401
12592001
8388867
8454529
12599051
2114960
8389515
6319582
8400198
8388628
8389132
8389133
8406529
8414082
12583042
8406657
8413955
12583043
8388737
8454401
8389124
8454532
12599809
2179255
8406658
12600834
2179382
12599188
2195511
12584724
12599053
2115237
12599052
2115108
6294036
8389121
12601857
2097345
12599051
2114976
6301908
examples/assembled/numjack.n8
+117
View File
@@ -0,0 +1,117 @@
8389299
8390324
8393270
8401461
8388668
10649660
2195491
16767489
8389890
12632194
8388611
12648707
12615555
12615811
2113937
8389891
2310269
12599043
2179476
12589699
12599171
2310269
8402946
12599426
8405251
12589571
12616066
12665091
12632450
12599042
12622210
12599426
8411779
12648707
2310269
6331190
6299196
2170484
6315709
8412801
12606977
2130164
8405180
2326535
8405438
8405380
2326535
12583358
8412929
2326550
8391297
12599681
2097315
2326535
8405439
2326535
12583359
8402817
12607361
2097390
6291972
8388672
8388673
6299583
6308485
2097873
12599045
2097869
12599045
2097863
2195539
2187347
8412801
12606977
8405180
12590781
8388801
2326535
12583359
12599232
2195539
8388801
12599232
8413057
2326550
8391297
12599681
2162906
6299583
2195491
2105535
8405383
8412929
2326550
8405382
8390657
12599681
2113765
2326535
12583358
2195548
6299455
8405889
12600065
2097394
2130161
8391297
12600065
2113777
2195491
8388865
12639873
12583100
12590780
12590780
2195491
0
examples/compound.n8a
+12
View File
@@ -0,0 +1,12 @@
; A simple compound interest calculator in N8A for n808 VM
; Prompts for the percentage and then for the period, outputs the resulting multiplier
; Created by Luxferre in 2025, released into public domain
dca 100 1 ; store the constant 100 at loc 1
inp 2 3 ; prompt for the percentage into loc 2 and the period into loc 3
div 2 1 ; divide the percentage value at loc 2 by the constant at loc 1 into loc 1
inc 1 ; increment loc 1
log 1 1 ; replace loc 1 with its ln
mul 3 1 ; replace loc 1 with loc 3 * ln loc 1
exp 1 1 ; replace loc 1 with its nexp
out 1 1 ; output the resulting value
examples/echo.n8a
+5
View File
@@ -0,0 +1,5 @@
; Simple 10-character echo test for n808 VM
dca 10 11 ; set the newline character to loc 11
ipc 1 10 ; input characters from loc 1 to loc 10
ouc 1 11 ; output them right away along with the newline
examples/fizzbuzz.n8a
+39
View File
@@ -0,0 +1,39 @@
; FizzBuzz classical challenge in N8A for n808 VM
; Outputs first 100 FizzBuzz numbers
; Created by Luxferre in 2025, released into public domain
dca 70 60 ; store Fi into loc 60-61
dca 105 61
dca 66 62 ; store Buz + LF into loc 62-65
dca 117 63
dca 122 64
dca 10 65
#1 cntr ; counter in loc 1
#2 cmod3 ; variable for counter mod 3
#3 cmod5 ; variable for counter mod 5
#4 chk ; variable for loop checks
#5 oflag ; normal output flag variable
dca 0 @cntr ; set counter to 0
:lp inc @cntr ; loop start, increment the counter
dca 3 @cmod3 ; store constant 3
mdf @cntr @cmod3 ; store counter mod 3
dca 5 @cmod5 ; store constant 5
mdf @cntr @cmod5 ; store counter mod 5
dca 1 @oflag ; set normal output flag
jne @cmod3 :bu ; jump next if not divisible by 3
ouc 60 61 ; output Fizz sequence
ouc 64 64
ouc 64 64
dca 0 @oflag ; unset normal output flag
:bu jne @cmod5 :no ; jump next if not divisible by 5
ouc 62 63 ; output Buzz sequence
ouc 64 64
ouc 64 64
dca 0 @oflag ; unset normal output flag
:no jeq @oflag :nl ; jump next if normal output flag is off
out @cntr @cntr ; normal counter output
juc :le ; jump to the end of the loop
:nl ouc 65 65 ; output a newline
:le dca 100 @chk ; store the constant 100 into checkvar
sub @cntr @chk ; save the difference into checkvar
jlt @chk :lp ; go back in the loop if not every number is displayed yet
examples/hellorld.n8a
+11
View File
@@ -0,0 +1,11 @@
dca 72 1 ; fill in the data bytes from 1 to 10
dca 101 2
dca 108 3
dca 108 4
dca 111 5
dca 114 6
dca 108 7
dca 100 8
dca 33 9
dca 10 10 ; end the string with an LF character for newline
ouc 1 10 ; output the range as ASCII to port 2
examples/linreg.n8a
+77
View File
@@ -0,0 +1,77 @@
; Linear regression calculator in N8A for n808 VM
; Enter the pairs number by number, end with 0,0 pair
; The program will then output A and B parameters of A + Bx
; linear function and then the correlation coefficient r
; Created by Luxferre in 2025, released into public domain
; variable/constant definitions
#1 xi ; data x component
#2 yi ; data y component
#3 xs ; xi squared
#4 ys ; yi squared
#5 xy ; xy
#6 buf ; buffer
#7 r1 ; r-coefficient buffer 1
#8 r2 ; r-coefficient buffer 2
#10 Sxi ; x sum
#11 Syi ; y sum
#12 Sxx ; x squared sum
#13 Syy ; y squared sum
#14 Sxy ; xy sum
#15 n ; data element counter
#16 A ; coefficient A
#17 B ; coefficient B
#18 RC ; coefficient R
; zero out all sums
dca 0 @Sxi
dca 0 @Syi
dca 0 @Sxx
dca 0 @Syy
dca 0 @Sxy
dca 0 @n
; data input loop
:lp inp @xi @yi ; loop start, input xi and yi pair
dva @xi @xs ; prepare x
mul @xs @xs ; square x
dva @yi @ys ; prepare y
mul @ys @ys ; square y
dva @yi @xy ; prepare y
mul @xi @xy ; save xy
add @xi @Sxi ; update x sum
add @yi @Syi ; update y sum
add @xs @Sxx ; update x squared sum
add @ys @Syy ; update y squared sum
add @xy @Sxy ; update xy sum
inc @n ; increment element count
add @ys @xs ; add y-squared to x-squared
jgt @xs :lp ; loop back if the square sum is over zero
dec @n ; decrement last n to omit the (0,0) input
; processing and output part
dva @n @buf ; n => buffer
mul @Sxy @buf ; n * Sxy => buffer
dva @Syi @r1 ; Syi => r-buffer 1
mul @Sxi @r1 ; Sxi * Syi => r-buffer 1
sub @buf @r1 ; n * Sxy - Sxi * Syi => r-buffer 1 (to be stored)
dva @n @buf ; n => buffer
mul @Sxx @buf ; n * Sxx => buffer
dva @Sxi @r2 ; Sxi => r-buffer 2
mul @r2 @r2 ; Sxi squared => r-buffer 2
sub @buf @r2 ; n * Sxx - Sx^2 => r-buffer 2 (to be stored)
dva @r2 @B ; prepare coefficient B
div @r1 @B ; store coefficient B
dva @Sxi @buf ; copy Sxi to buffer
mul @B @buf ; B * Sxi => buffer
sub @Syi @buf ; Syi - B * Sxi => buffer
dva @n @A ; prepare coefficient A
div @buf @A ; calculate coefficient A
dva @Syi @buf ; Syi => buffer
mul @Syi @buf ; Syi squared => buffer
dva @n @xi ; reuse xi for the second buffer
mul @Syy @xi ; n * Syy => second buffer
sub @xi @buf ; n * Syy - Sy^2 => buffer
dva @r2 @xi ; r-buffer 2 to xi
mul @buf @xi ; buffer * xi => xi
sqr @xi @RC ; sqrt(xi) => prepare RC
div @r1 @RC ; calculate correlation coefficient
out @A @RC ; output all three resulting numbers
examples/lunar.n8a
+131
View File
@@ -0,0 +1,131 @@
; Lunar Lander game in N8A for n808 VM
; On each turn, the following parameters are displayed in this order:
; altitude (meters), speed (m/s) and remaining fuel (kg)
; Your goal is to apply (or not apply) thrust
; (values that make any sense are 0 to 2000) every 10 seconds of flight
; and get the lunar module to land safely without running out of fuel.
; At the end, the game shows one of the following statuses:
; 4444 is a disaster landing with no survivors,
; 5555 is a crash landing with the crew surviving the impact,
; 6666 is a hard landing with some damage to the pod,
; 7777 is a good landing,
; 8888 is a perfect landing.
; Created by Luxferre in 2025, released into public domain
; constant/variable area
#30 code_dis ; disaster code
#31 code_crsh ; crash landing code
#32 code_dmg ; damage landing code
#33 code_good ; good landing code
#34 code_perf ; perfect landing code
#36 crit_crsh ; criterion for crash landing
#37 crit_dmg ; criterion for damage landing
#38 crit_good ; criterion for good landing
#39 crit_perf ; criterion for perfect landing
#40 alt ; module altitude
#41 speed ; module fall speed (m/s)
#42 fuel ; fuel (in kg)
#52 athr ; altitude threshold AND time period
#53 ffsd ; freefall speed delta
#54 capw ; capsule weight (in kg)
#55 burnrate ; fuel burn rate
#56 exvel ; exhaust velocity
#57 c100 ; constant 100
#1 buf ; buffer variable
#2 floss ; fuel loss value
#3 m0 ; m0 variable in the equation
#4 m1 ; m1 variable in the equation
; memory initialization part
; zero out the memory (first 57 cells)
dca 57 1 ; set the counter to 57
:clp ica 0 1 ; assign 0 to the cell from the counter
dec 1
jgt 1 :clp
; set constants and initial variable values
dca 10 @athr ; altitude threshold / time period
dca 25 @ffsd ; set 16.25 as freefall speed delta
set 0 16 @ffsd
set 74 80 @capw ; set 7480 as capsule weight
dca 45 @burnrate ; set 3.45 as fuel burn rate
set 0 3 @burnrate
set 29 0 @exvel ; set 2900 as exhaust velocity
set 19 30 @alt ; set 1930 as starting altitude
dca 100 @c100 ; set constant 100
mul @c100 @alt ; multiply this altitude value by 100
set 16 9 @speed ; set 1609 as starting speed
set 72 60 @fuel ; set 7260 as fuel
set 44 44 @code_dis ; set 4444 as disaster code
set 55 55 @code_crsh ; set 5555 as crash landing code
set 66 66 @code_dmg ; set 6666 as damage landing code
set 77 77 @code_good ; set 7777 as good landing code
set 88 88 @code_perf ; set 8888 as perfect landing code
dca 67 @crit_crsh ; set 26.67 as the criterion for crash landing
set 0 26 @crit_crsh
dca 73 @crit_dmg ; set 9.73 as the criterion for damage landing
set 0 9 @crit_dmg
dca 45 @crit_good ; set 4.45 as the criterion for good landing
set 0 4 @crit_good
dca 45 @crit_perf ; set 0.45 as the criterion for perfect landing
set 0 0 @crit_perf
; main action/logic part
:lp out @alt @fuel ; loop start; print altitude, speed and fuel
dca 0 @floss ; set fuel loss to 0
jle @fuel :cnt ; skip prompting for thrust if already out of fuel
inp @floss @floss ; prompt for thrust into the fuel loss location
mul @burnrate @floss ; multiply thrust by fuel burn rate to get fuel loss
:cnt dva @fuel @m0 ; copy fuel weight into m0
add @capw @m0 ; add capsule weight and fuel weight to get m0
dva @floss @m1 ; prepare m1
sub @m0 @m1 ; m0 - floss => m1
div @m0 @m1 ; m0 / m1 => m1
log @m1 @buf ; ln (m0 / (m0 - floss)) => buf
mul @exvel @buf ; multiply the result by the exhaust velocity to get thrust speed delta
sub @speed @buf ; subtract the thrust speed delta from the current speed
add @ffsd @buf ; add the freefall speed delta to the current speed
dva @buf @speed ; copy the resulting speed value back to the holding variable
mul @athr @buf ; multiply speed by time period into the buffer variable
sub @alt @buf ; decrease the altitude by the result of this operation
dva @buf @alt ; restore the altitude variable
sub @fuel @floss ; decrease the amount of fuel by the fuel loss value
dva @floss @fuel ; restore the fuel variable
jgt @fuel :flc ; skip the next instruction if the amount of fuel is positive
dca 0 @fuel ; just set the amount of fuel to zero if it's negative
:flc jgt @alt :al ; do the same for altitude
dca 0 @alt ; set it to zero if negative
:al dva @athr @buf ; copy altitude threshold to the buffer
sub @alt @buf ; subtract the threshold from the altitude
jgt @buf :lp ; go to the loop start if the altitude is above the threshold
; game finalization/scoring part
out @alt @fuel ; print the final altitude/speed/fuel
dva @crit_perf @buf ; buffer the perfect speed
sub @speed @buf ; subtract the perfect speed
jgt @buf :good ; skip if > 0
out @code_perf @code_perf ; output the perfect score
juc :end ; go to end
:good dva @crit_good @buf ; buffer the good speed
sub @speed @buf ; subtract the good speed
jgt @buf :dmg ; skip if > 0
out @code_good @code_good ; output the good score
juc :end ; go to end
:dmg dva @crit_dmg @buf ; buffer the damage speed
sub @speed @buf ; subtract the damage speed
jgt @buf :crsh ; skip if > 0
out @code_dmg @code_dmg ; output the damage score
juc :end ; go to end
:crsh dva @crit_crsh @buf ; buffer the crash speed
sub @speed @buf ; subtract the crash speed
jgt @buf :disa ; skip if > 0
out @code_crsh @code_crsh ; output the crash score
juc :end ; go to end
:disa out @code_dis @code_dis ; output the disaster score
:end nnn ; program end label
examples/moo.n8a
+108
View File
@@ -0,0 +1,108 @@
; Bulls and Cows game in N8A for n808 VM
; Enter your guesses digit by digit, you have 7 attempts
; After each guess, the game replies with bulls.cows
; (if you have 4.0, you win)
; On victory or after running out of attempts, the game
; displays the target digits and halts
; Created by Luxferre in 2025, released into public domain
; constants/variables section
#1 va
#2 vb
#3 vc
#4 vd
#10 c10
#11 counter
#12 octr
#13 ictr
#14 frac
#20 bcctr
#60 dig_0
#61 dig_1
#62 dig_2
#63 dig_3
#64 dig_4
#65 dig_5
#66 dig_6
#67 dig_7
#68 dig_8
#69 dig_9
#70 src_base ; source base address
#71 trg_base ; target base address
; constant/variable assignments
dca 10 @c10 ; constant 10
dca 0 @dig_0 ; assign digits from 0 to 9
dca 1 @dig_1
dca 2 @dig_2
dca 3 @dig_3
dca 4 @dig_4
dca 5 @dig_5
dca 6 @dig_6
dca 7 @dig_7
dca 8 @dig_8
dca 9 @dig_9
dca 60 @src_base ; set the source base address (60)
dca 80 @trg_base ; set the target base address (80)
dca 10 @frac ; prepare the @frac variable
set 0 0 @frac ; set 0.1 to @frac
; main logic
; random unique 4-digit generator (into the addresses 81..84)
dca 4 @counter ; set the counter to 4
:dsl dca 9 @va ; digit selection loop start, set the upper boundary to @va
rnd 0 @va @va ; select a random digit from 0 to 9 inclusively into @va
add @src_base @va ; add the source base address to @va
dca @vb @vb ; init @vb with its own address
ivc @va @vb ; copy the value at address in @va into @vb
dca 10 @vc ; init @vc with the constant 10
sub @vb @vc ; @vb - 10 => @vc
jeq @vc :dsl ; jump back to the digit selection if the value at @vc is 0
ica 10 @va ; set the value at the address in @va to 10
dva @counter @va ; copy the counter to @va
add @trg_base @va ; add the target base address to the counter in @va
dca @vb @vc ; copy the address of @vb into @vc
ivc @vc @va ; copy the value from @vb (address stored at @vc) to the cell address at @va
dec @counter ; decrement the counter
jgt @counter :dsl ; jump back to digit selection if it still is above zero
; player guess loop
dca 7 @counter ; set the attempt count to 7
:prm inp 91 94 ; input the guess digit by digit into loc 91..94
dca 90 @src_base ; set 90 as the new source base address
dca 0 @bcctr ; init bull/cow counter
dca 4 @octr ; init outer loop counter
:olp dca 4 @ictr ; start of the outer loop, init inner loop counter
:ilp dva @octr @va ; start of the inner loop, copy the outer counter
dva @trg_base @vb ; fetch the target base address
add @va @vb ; get the address of the target digit in @vb
dva @ictr @va ; copy the inner counter
dva @src_base @vc ; fetch the source base address
add @va @vc ; get the address of the entered digit in @vc
dca @va @va ; init @va with its own address
ivc @vb @va ; copy the target digit into @va
dca @vd @vd ; init @vd with its own address
ivc @vc @vd ; copy the entered digit into @vd
sub @vd @va ; save the digits difference into @va
jne @va :ei ; jump to the next comparator if the digits don't match
dva @ictr @vb ; load the inner counter into @vb
sub @octr @vb ; save the _counters_ difference into @vb
jne @vb :cc ; jump to the cow counter if the indices don't match
inc @bcctr ; increment the bull counter if they do
juc :ei ; skip the next instruction
:cc add @frac @bcctr ; increase the cow counter if they don't
:ei dec @ictr ; decrement the inner loop counter
jgt @ictr :ilp ; jump to the start of the inner loop if still > 0
dec @octr ; decrement the outer loop counter
jgt @octr :olp ; jump to the start of the outer loop if still > 0
out @bcctr @bcctr ; output the match result
dca 4 @va ; store the constant 4 into @va
sub @bcctr @va ; get the difference between bull/cow counter and 4
jeq @va :end ; jump to the last instruction if they match
dec @counter ; decrement the attempt counter
jgt @counter :prm ; jump to guess prompt if the counter is above 0
:end out 81 84 ; output the target number before halting
examples/numjack.n8a
+166
View File
@@ -0,0 +1,166 @@
; A Blackjack port in N8A assembly for n808 VM
; How to play:
; * you start with a $1000 balance
; * on each round, enter your bet
; (the game will quit if the bet is above your balance)
; * if you hit a blackjack, your balance will increase immediately
; * if the dealer hits a blackjack, your balance will decrease immediately
; * the first card of the dealer's hand will be shown
; (card values are: ace is 101, 2 to 9 are "as is", 10 is 10 to K)
; * on the first turn, select 0 (stand), 1 (hit) or 2 (double)
; * on each next turn, select 0 (stand) or 1 (hit)
; * as a result of the round, the dealer's final hand will be shown
; first and then yours
; * the dealer must draw on 16 and stand on any 17
; * player's blackjack pays 3 to 2
; Created by Luxferre in 2025, released into public domain
; constant/variable space
#1 va
#2 vb
#3 vc
#4 vd
#5 action
#6 dscore
#7 pscore
#127 c1
#51 c5
#52 c_13
#53 c_hund
#54 c_ds
#60 balance
#61 bet
#62 dhand
#63 phand
#64 round
#65 stand
; constant assignments
dca 5 @c5
dca 13 @c_13
dca 36 @c_ds
dca 100 @c_hund
dca 0 @balance
set 10 0 @balance
juc :main ; jump to the main code after initialization
; card retrieval procedure
; the resulting card is in the @vc cell
:gcard rnd @c1 @c_13 @va ; get a random number from 1 to 13 incl
dca 10 @vb ; assign 10 to the second buffer
div @va @vb ; va / 10 => vb
dca 0 @vc ; 0 => vc
mdf @vb @vc ; floor(va/10) => vc
sub @c1 @vc ; subtract it from 1
mul @va @vc ; multiply it by the random choice itself
jgt @vc :gnext ; skip the next part if > 0
dca 10 @vc ; return 10
ret
:gnext dec @vc ; decrement
jne @vc :gnr ; skip the next part if == 0
add @c_hund @vc ; add 100
:gnr inc @vc ; increment back
ret
; scoring procedure, parameter is in the @va cell
; the result is in the @vc cell
:score dca 112 @vb ; set vb to 112
sub @va @vb ; set vb to va - 112
dva @vb @vc ; copy vb value into vc
add @c_13 @vc ; add 13 to vc
mul @vc @vb ; vb * vc => vb
abs @vb @vc ; abs(vb) => vc
div @vc @vb ; abs(vb) / vb => vb
dec @vb ; vb - 1 => vb
mul @c5 @vb ; vb * 5 => vb
sub @va @vb ; va - vb => vb
dva @c_hund @vc ; store 100 into vc
mdf @vb @vc ; store vb mod 100 into vc
ret
; main code part
:main ouc @c_ds @c_ds ; output a dollar sign if supported
out @balance @balance ; output the current balance
jle @balance :end ; game over if zero or less
inp @bet @bet ; input your bet
dva @bet @va ; buffer the bet
sub @balance @va ; va = balance - bet
jlt @va :end ; game over if the bet is invalid
dva @va @balance ; restore the balance value from va
jpr :gcard ; call the card generation procedure
dva @vc @dhand ; copy the result as the dealer's hand value
dva @vc @vd ; copy the first dealer hand card into vd
jpr :gcard ; call the card generation procedure again
add @vc @dhand ; complete the dealer's hand
dva @dhand @va ; copy the dealer's hand as the va param
jpr :score ; run the scoring procedure (result in @vc)
dca 21 @va ; set the constant 21 to @va
sub @vc @va ; compare the procedure result with 21
jeq @va :main ; loop back if we have the dealer's blackjack
jpr :gcard ; call the card generation procedure
dva @vc @phand ; save the first card into the player's hand
jpr :gcard ; call the card generation procedure
add @vc @phand ; add the second card into the player's hand
dca 111 @va ; prepare constant 111
sub @phand @va ; compare player's hand to 111
jeq @va :bjk ; jump to blackjack condition on player's blackjack
out @vd @vd ; display the start of the dealer's hand
dca 0 @round ; set the round index to 0
dca 0 @stand ; set the stand flag to 0
:rnl out @phand @phand ; start of the inner player loop, display the player's hand
inp @action @action ; input the action value
jeq @action :std ; jump to stand action if 0
dec @action ; check if 1
jeq @action :hit ; jump to hit action if 1
dec @action ; check if 2
jeq @action :dbl ; jump to double action if 2
juc :skp ; skip otherwise
:dbl jne @round :skp ; skip double if not the first round
dva @bet @va ; buffer the bet
sub @balance @va ; subtract more balance
dva @va @balance ; restore the variable
add @bet @bet ; double the bet
dca 1 @stand ; set the stand flag, proceed to the hit section
:hit jpr :gcard ; generate a new card in @vc
add @vc @phand ; add it to the player's hand
inc @round ; increment the round index
juc :skp ; jump to skip the rest
:std dca 1 @stand ; just set the stand flag
inc @round ; increment the round index
:skp dva @phand @va ; set the player's hand as a parameter to @va
jpr :score ; call the scoring procedure (result in @vc)
dca 21 @va ; set 21 to va
sub @vc @va ; subtract 21 from the result
jle @va :nob ; reloop to beginning if the player is bust
out @phand @phand ; output the player's hand
juc :main ; reloop
:nob jeq @stand :rnl ; repeat the inner loop if the stand flag is 0
dva @vc @pscore ; at this point, player score is now in @vc
:rdl dva @dhand @va ; start the inner dealer loop, set the dealer hand param
jpr :score ; call the scoring procedure (result in @vc)
dva @vc @dscore ; save the dealer's score
dca 16 @va ; compare @vc with 16
sub @vc @va ; the difference is in @va
jgt @va :dbrk ; go to stand if the difference is over 16
jpr :gcard ; call the card generation procedure
add @vc @dhand ; add the result to dealer's hand
juc :rdl ; repeat the inner dealer loop
:dbrk out @dhand @phand ; output both hands (dealer's first)
dva @pscore @va ; buffer the player's score
sub @dscore @va ; subtract it from the dealer's score
jeq @va :push ; push condition
jlt @va :win ; player win condition
dca 21 @va ; prepare constant 21
sub @dscore @va ; compare dealer's score with 21
jgt @va :win ; player win condition
juc :main ; reloop to beginning
:bjk dca 2 @va ; set 2 to @va
div @bet @va ; halve the bet
add @va @balance ; add half the bet to the balance
:win add @bet @balance ; add the bet the first time
:push add @bet @balance ; add the bet the second time
juc :main ; reloop to beginning
:end nnn ; program end label
n808.awk
+113
View File
@@ -0,0 +1,113 @@
#!/usr/bin/env awk -f
# n808 VM reference implementation in POSIX AWK
# Run with: LC_ALL=C awk -f n808.awk [- input_program.n8]
# Supports the entire n808 spec except the I/O port 3
# See the README.md file for all documentation
# Created by Luxferre in 2025, released into public domain
# absolute value function
function fabs(v) {return (v < 0) ? -v : v}
# port I/O function (all ports supported except 3)
function portio(port, data) {
if(port == 0) printf("%f\n", data) # standard numeric output
else if(port == 1) getline data # standard numeric input
else if(port == 2) printf("%c", int(data) % 256) # character output
return +data
}
# main instruction execution logic
function iexec(lno, halt, data_override, cmd, p1, p2, p3, i, v1, v2, v3) {
halt = data_override = 0
while(halt == 0) { # decode and execute the current instruction
cmd = int(PMEM[lno] / 2097152) % 8 # command opcode
p1 = (data_override ? int(v1) : int(PMEM[lno] / 16384)) % 128 # parameter 1
p2 = (data_override ? int(v2) : int(PMEM[lno] / 128)) % 128 # parameter 2
p3 = (data_override ? int(v3) : PMEM[lno]) % 128 # parameter 3
DMEM[0] = data_override = 0 # enforce the 0 at the location 0
DMEM[127] = 1 # enforce the 1 at the location 127
DMEM[126] = -1 # enforce the -1 at the location 126
v1 = DMEM[p1]; v2 = DMEM[p2]; v3 = DMEM[p3] # prefetch the values
if(cmd == 1) { # JMP
if(p1 == 14) DMEM[125] = lno + 1
if((v2 == 0 && p1 == 0) || (v2 > 0 && p1 == 1) || (v2 < 0 && p1 == 2) \
|| (v2 >= 0 && p1 == 3) || (v2 <= 0 && p1 == 4) || (v2 != 0 && p1 == 5) \
|| p1 == 6 || p1 == 14) lno = p3 - 1
else if((v2 == 0 && p1 == 7) || (v2 > 0 && p1 == 8) || (v2 < 0 && p1 == 9) \
|| (v2 >= 0 && p1 == 10) || (v2 <= 0 && p1 == 11) || (v2 != 0 && p1 == 12) \
|| p1 == 13) lno = int(v3) - 1
} else if(cmd == 2) data_override = 1 # IAT
else if(cmd == 3) for(i=p2;i<=p3;i++) DMEM[i] = portio(p1, DMEM[i]) # INO
else if(cmd == 4) { # CPY
if(p1 == 0) DMEM[p3] = p2
else if(p1 == 1) DMEM[p3] = v2
else if(p1 == 2) DMEM[int(v3)] = p2
else if(p1 == 3) DMEM[int(v3)] = v2
else if(p1 == 4) DMEM[int(v3)] = DMEM[int(v2)]
} else if(cmd == 5) DMEM[p3] = p1 * 100 + p2 + v3 / 100.0 # SET
else if(cmd == 6) { # MAT
if(p1 == 0) DMEM[p3] = v2 + v3
else if(p1 == 1) DMEM[p3] = v2 - v3
else if(p1 == 2) DMEM[p3] = v2 * v3
else if(p1 == 3) DMEM[p3] = (v3 == 0) ? 0 : (v2 / v3)
else if(p1 == 4) DMEM[p3] = (v3 == 0) ? int(v2) : (v2 % v3)
else if(p1 == 5) DMEM[p3] = fabs(v2)
else if(p1 == 6) DMEM[p3] = sqrt(fabs(v2))
else if(p1 == 7) DMEM[p3] = exp(v2)
else if(p1 == 8) DMEM[p3] = (v2 == 0) ? 0 : log(fabs(v2))
else if(p1 == 9) DMEM[p3] = sin(v2)
else if(p1 == 10) DMEM[p3] = cos(v2)
else if(p1 == 11) DMEM[p3] = atan(v2)
} else if(cmd == 7) # RND
DMEM[p3] = int(v1) + int(rand() * (int(v2) - int(v1) + 1))
lno++ # increment the program counter
if(lno >= MEMLIMIT) halt = 1
}
}
# interactive mode entry function
function intermode(cmd, p1, p2) {
if(cmd == 0 && p1 < MEMLIMIT) iexec(p1) # run from the step
else if(cmd == 1) PMEM[p1] = p2 # enter the instruction into PMEM
else if(cmd == 2 && p1 < MEMLIMIT && p2 < MEMLIMIT) # clear instructions
for(cmd=p1;cmd<=p2;cmd++) PMEM[cmd] = 0
else if(cmd == 3 && p1 < MEMLIMIT && p2 < MEMLIMIT) # clear data
for(cmd=p1;cmd<=p2;cmd++) DMEM[cmd] = 0.0
else if(cmd == 4) {print("Bye!"); exit(0)}
}
BEGIN { # VM entry point
MEMLIMIT = 128
for(i=0;i<MEMLIMIT;i++) DMEM[i] = PMEM[i] = 0 # initialize both areas
srand()
if(ARGC > 1) { # preload the input program
fname = ARGV[ARGC-1]
iindex = 0
while(getline < fname) { # iterate over the file lines
csize = split($0, icache)
for(i=0;i<csize;i++) {
a = int(icache[i+1])
intermode(1, iindex, a) # enter nth instruction
iindex++
}
}
close(fname)
}
printf("> ")
iindex = cmd = p1 = p2 = 0
while(getline) { # main REPL
csize = split($0, icache)
for(i=0;i<csize;i++) {
a = int(icache[i+1])
if(iindex == 0) cmd = a
else if(iindex == 1) p1 = a
else if(iindex == 2) p2 = a
iindex++
if(iindex == 3) { # pefrorm the entry
intermode(cmd, p1, p2)
iindex = 0
}
}
printf("> ")
}
}
n808.b74
+69
View File
@@ -0,0 +1,69 @@
100 RANDOMIZE:RAD
110 DIM PMEM(129),DMEM(128)
120 RESTORE 1000
130 I=0
140 READ PMEM(I)
150 I=I+1
160 IF PMEM(I-1)>-1 THEN 140
170 L,IAT,V1,V2,V3=0
180 A=PMEM(L):L=L+1
190 IF A<0 THEN 770
200 CMD=INT(A/2097152)
210 IF IAT=1 THEN 220 ELSE 230
220 P1=INT(V1):P2=INT(V2):P3=INT(V3):IAT=0:GOTO 250
230 A=A-CMD*2097152:P1=INT(A/16384):A=A-P1*16384
240 P2=INT(A/128):P3=A-P2*128
250 DMEM(0)=0:DMEM(127)=1:DMEM(126)=-1
260 V1=DMEM(P1):V2=DMEM(P2):V3=DMEM(P3)
270 IF CMD=1 THEN 280 ELSE 430
280 IF P1=0 AND V2=0 THEN L=P3:GOTO 180
290 IF P1=1 AND V2>0 THEN L=P3:GOTO 180
300 IF P1=2 AND V2<0 THEN L=P3:GOTO 180
310 IF P1=3 AND V2>=0 THEN L=P3:GOTO 180
320 IF P1=4 AND V2<=0 THEN L=P3:GOTO 180
330 IF P1=5 AND V2<>0 THEN L=P3:GOTO 180
340 IF P1=6 THEN L=P3:GOTO 180
350 IF P1=7 AND V2=0 THEN L=INT(V3):GOTO 180
360 IF P1=8 AND V2>0 THEN L=INT(V3):GOTO 180
370 IF P1=9 AND V2<0 THEN L=INT(V3):GOTO 180
380 IF P1=10 AND V2>=0 THEN L=INT(V3):GOTO 180
390 IF P1=11 AND V2<=0 THEN L=INT(V3):GOTO 180
400 IF P1=12 AND V2<>0 THEN L=INT(V3):GOTO 180
410 IF P1=13 THEN L=INT(V3):GOTO 180
420 IF P1=14 THEN DMEM(125)=L:L=P3:GOTO 180
430 IF CMD=2 THEN IAT=1:GOTO 180
440 IF CMD=3 THEN 450 ELSE 520
450 FOR I=P2 TO P3
460 IF P1=0 THEN PRINT(DMEM(I)):PAUSE
470 IF P1=1 THEN INPUT DMEM(I)
480 IF P1=2 THEN 490 ELSE 500
490 IF DMEM(I)=10 THEN PAUSE ELSE PRINT(CHR$(INT(DMEM(I))));
500 IF P1=3 THEN DMEM(I)=ASC(KEY$)
510 NEXT I:GOTO 180
520 IF CMD=4 THEN 530 ELSE 580
530 IF P1=0 THEN DMEM(P3)=P2:GOTO 180
540 IF P1=1 THEN DMEM(P3)=V2:GOTO 180
550 IF P1=2 THEN DMEM(INT(V3))=P2:GOTO 180
560 IF P1=3 THEN DMEM(INT(V3))=V2:GOTO 180
570 IF P1=4 THEN DMEM(INT(V3))=DMEM(INT(V2)):GOTO 180
580 IF CMD=5 THEN DMEM(P3)=P1*100+P2+V3/100:GOTO 180
590 IF CMD=6 THEN 600 ELSE 720
600 IF P1=0 THEN DMEM(P3)=V2+V3:GOTO 180
610 IF P1=1 THEN DMEM(P3)=V2-V3:GOTO 180
620 IF P1=2 THEN DMEM(P3)=V2*V3:GOTO 180
630 IF P1=3 THEN 640 ELSE 650
640 IF V3=0 THEN DMEM(P3)=0:GOTO 180 ELSE DMEM(P3)=V2/V3:GOTO 180
650 IF P1=4 THEN 660 ELSE 680
660 IF V3=0 THEN DMEM(P3)=INT(V2):GOTO 180 ELSE 670
670 DMEM(P3)=V2-V3*INT(V2/V3):GOTO 180
680 IF P1=5 THEN DMEM(P3)=ABS(V2):GOTO 180
690 IF P1=6 THEN DMEM(P3)=SQR(ABS(V2)):GOTO 180
700 IF P1=7 THEN DMEM(P3)=EXP(V2):GOTO 180
710 IF P1=8 THEN DMEM(P3)=LN(ABS(V2)):GOTO 180
720 IF P1=9 THEN DMEM(P3)=SIN(V2):GOTO 180
730 IF P1=10 THEN DMEM(P3)=COS(V2):GOTO 180
740 IF P1=11 THEN DMEM(P3)=ATN(V2):GOTO 180
750 IF CMD=7 THEN DMEM(P3)=INT(V1)+INT(RND*(INT(V2)-INT(V1)+1))
760 GOTO 180
770 END
n808.c
+144
View File
@@ -0,0 +1,144 @@
/**
* n808: an ultralight numeric-only VM
* ANSI C89 reference implementation
* Compile with: cc -std=c89 -O2 -s -lm -o n808 n808.c
* See the README.md file for all documentation
* Created by Luxferre in 2025, released into public domain
*/
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
/* POSIX-specific terminal stuff for unbuffered input for I/O port 2 */
#if defined (__unix__) || (defined (__APPLE__) && defined (__MACH__))
#define NLC "\n"
#include <unistd.h>
#include <termios.h>
struct termios orig_termios;
void disable_raw_mode() {
tcsetattr(STDIN_FILENO, TCSAFLUSH, &orig_termios);
}
void enable_raw_mode() {
tcgetattr(STDIN_FILENO, &orig_termios);
atexit(disable_raw_mode);
struct termios raw = orig_termios;
raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
raw.c_oflag &= ~(OPOST);
raw.c_cflag |= (CS8);
raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
}
#else
#define NLC "\r\n"
void disable_raw_mode() {}
void enable_raw_mode() {}
#endif
/* core memory */
#define MEMLIMIT 128
static unsigned int PMEM[MEMLIMIT] = {0};
static double DMEM[MEMLIMIT] = {0.0};
#define uchar unsigned char
/* port input/output function */
void portio(uchar port, double *data) {
if(port == 0) printf("%f" NLC, *data); /* standard numeric output */
else if(port == 1) scanf("%lf", data); /* standard numeric input */
else if(port == 2) fputc(((int)floor(*data)) & 255, stdout); /* char output */
else if(port == 3) { /* character input */
enable_raw_mode();
*data = (double) (fgetc(stdin) & 255);
disable_raw_mode();
}
}
/* main instruction execution logic */
void iexec(unsigned short lno) {
uchar halt = 0, data_override = 0, cmd, p1, p2, p3, i;
double v1, v2, v3;
while(halt == 0) { /* decode and execute the current instruction */
cmd = (PMEM[lno] >> 21) & 7; /* command opcode */
p1 = (data_override ? ((int)floor(v1)) : (PMEM[lno] >> 14)) & 127; /* parameter 1 */
p2 = (data_override ? ((int)floor(v2)) : (PMEM[lno] >> 7)) & 127; /* parameter 2 */
p3 = (data_override ? ((int)floor(v3)) : PMEM[lno]) & 127; /* parameter 3 */
DMEM[0] = data_override = 0; /* enforce the 0 at the location 0 */
DMEM[127] = 1; /* enforce the 1 at the location 127 */
DMEM[126] = -1; /* enforce the -1 at the location 126 */
v1 = DMEM[p1]; v2 = DMEM[p2]; v3 = DMEM[p3]; /* prefetch the values */
if(cmd == 1) { /* JMP */
if(p1 == 14) DMEM[125] = lno + 1;
if((v2 == 0 && p1 == 0) || (v2 > 0 && p1 == 1) || (v2 < 0 && p1 == 2) \
|| (v2 >= 0 && p1 == 3) || (v2 <= 0 && p1 == 4) || (v2 != 0 && p1 == 5) \
|| p1 == 6 || p1 == 14) lno = p3 - 1;
else if((v2 == 0 && p1 == 7) || (v2 > 0 && p1 == 8) || (v2 < 0 && p1 == 9) \
|| (v2 >= 0 && p1 == 10) || (v2 <= 0 && p1 == 11) || (v2 != 0 && p1 == 12) \
|| p1 == 13) lno = (int)floor(v3) - 1;
} else if(cmd == 2) data_override = 1; /* IAT */
else if(cmd == 3) for(i=p2;i<=p3;i++) portio(p1, &DMEM[i]); /* INO */
else if(cmd == 4) { /* CPY */
if(p1 == 0) DMEM[p3] = p2;
else if(p1 == 1) DMEM[p3] = v2;
else if(p1 == 2) DMEM[(int)v3] = p2;
else if(p1 == 3) DMEM[(int)v3] = v2;
else if(p1 == 4) DMEM[(int)v3] = DMEM[(int)v2];
} else if(cmd == 5) DMEM[p3] = p1 * 100 + p2 + v3 / 100.0; /* SET */
else if(cmd == 6) { /* MAT */
if(p1 == 0) DMEM[p3] = v2 + v3;
else if(p1 == 1) DMEM[p3] = v2 - v3;
else if(p1 == 2) DMEM[p3] = v2 * v3;
else if(p1 == 3) DMEM[p3] = (v3 == 0) ? 0 : (v2 / v3);
else if(p1 == 4) DMEM[p3] = (v3 == 0) ? floor(v2) : fmod(v2, v3);
else if(p1 == 5) DMEM[p3] = fabs(v2);
else if(p1 == 6) DMEM[p3] = sqrt(fabs(v2));
else if(p1 == 7) DMEM[p3] = exp(v2);
else if(p1 == 8) DMEM[p3] = (v2 == 0) ? 0 : log(fabs(v2));
else if(p1 == 9) DMEM[p3] = sin(v2);
else if(p1 == 10) DMEM[p3] = cos(v2);
else if(p1 == 11) DMEM[p3] = atan(v2);
} else if(cmd == 7) { /* RND */
v1 = floor(v1);
DMEM[p3] = v1 + (rand() % (int)(floor(v2) + 1 - v1));
}
lno++; /* increment the program counter */
if(lno >= MEMLIMIT) halt = 1;
}
}
/* interactive mode entry function */
void intermode(unsigned int cmd, unsigned int p1, unsigned int p2) {
unsigned int i;
if(cmd == 0 && p1 < MEMLIMIT) iexec(p1); /* run from the step */
else if(cmd == 1) PMEM[p1] = p2; /* enter the instruction into PMEM */
else if(cmd == 2 && p1 < MEMLIMIT && p2 < MEMLIMIT) /* clear instructions */
for(i=p1;i<=p2;i++) PMEM[i] = 0;
else if(cmd == 3 && p1 < MEMLIMIT && p2 < MEMLIMIT) /* clear data */
for(i=p1;i<=p2;i++) DMEM[i] = 0.0;
else if(cmd == 4) {puts("Bye!"); exit(0);}
}
/* entry point to the VM REPL */
void main(int argc, char* argv[]) {
srand(time(NULL));
unsigned int cmd, p1, p2, instr, lno = 0; /* commands and their parameters */
if(argc > 1) { /* preload the file from a command line parameter */
FILE *fd = fopen(argv[1], "r");
if(fd != NULL) { /* opened successfully */
while(!feof(fd)) {
if(fscanf(fd, "%u", &instr) == 1) { /* read the instruction number */
intermode(1, lno, instr); /* run the entry routine */
lno++;
}
}
fclose(fd);
} else puts("Warning: no file could be preloaded!");
}
while(1) { /* main interactive loop */
printf("> ");
cmd = p1 = p2 = 0;
scanf("%u %u %u", &cmd, &p1, &p2); /* read the three numbers */
while(getchar() != '\n'); /* ignore the rest of the line */
intermode(cmd, p1, p2); /* run the entry routine */
}
}
n808.py
Executable
+132
View File
@@ -0,0 +1,132 @@
#!/usr/bin/env python3
# n808 VM reference implementation in Python 3/MicroPython
# Supports the entire n808 spec
# See README.md for all documentation
# Created by Luxferre in 2025, released into public domain
import sys, math, random, re
advterm = False
try:
import tty, termios # for the character input port
advterm = True
except:
pass
MEMLIMIT:int = 128
PMEM = [0 for i in range(0, MEMLIMIT)] # program memory
DMEM = [0.0 for i in range(0, MEMLIMIT)] # data memory
# port I/O function
def portio(port:int, data:float):
if port == 0: print(data) # standard numeric output
elif port == 1: # standard numeric input
try: data = float(input())
except ValueError: data = 0
elif port == 2: # character output
sys.stdout.write(chr(int(data)&255))
sys.stdout.flush()
elif port == 3: # character input
ch = '\0'
if advterm: # normal OS with termios
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(fd)
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
else: # crippled OS without termios
ch = sys.stdin.read(1)
data = float(ord(ch))
return data
# main instruction execution logic
def iexec(lno:int):
global PMEM, DMEM
data_override = 0
while True: # decode and execute the current instruction
cmd = (PMEM[lno] >> 21) & 7 # command opcode
p1 = (int(v1) if data_override else (PMEM[lno] >> 14)) & 127 # parameter 1
p2 = (int(v2) if data_override else (PMEM[lno] >> 7)) & 127 # parameter 2
p3 = (int(v3) if data_override else PMEM[lno]) & 127 # parameter 3
DMEM[0] = data_override = 0 # enforce the 0 at the location 0
DMEM[127] = 1 # enforce the 1 at the location 127
DMEM[126] = -1 # enforce the -1 at the location 126
v1 = DMEM[p1]; v2 = DMEM[p2]; v3 = DMEM[p3] # prefetch the values
if cmd == 1: # JMP
if p1 == 14: DMEM[125] = lno + 1
if (v2 == 0 and p1 == 0) or (v2 > 0 and p1 == 1) or (v2 < 0 and p1 == 2) \
or (v2 >= 0 and p1 == 3) or (v2 <= 0 and p1 == 4) or (v2 != 0 and p1 == 5) \
or p1 == 6 or p1 == 14: lno = p3 - 1
elif (v2 == 0 and p1 == 7) or (v2 > 0 and p1 == 8) or (v2 < 0 and p1 == 9) \
or (v2 >= 0 and p1 == 10) or (v2 <= 0 and p1 == 11) or (v2 != 0 and p1 == 12) \
or p1 == 13: lno = int(v3) - 1
elif cmd == 2: data_override = 1 # IAT
elif cmd == 3: # INO
for i in range(p2,p3+1): DMEM[i] = portio(p1, DMEM[i])
elif cmd == 4: # CPY
if p1 == 0: DMEM[p3] = p2
elif p1 == 1: DMEM[p3] = v2
elif p1 == 2: DMEM[int(v3)] = p2
elif p1 == 3: DMEM[int(v3)] = v2
elif p1 == 4: DMEM[int(v3)] = DMEM[int(v2)]
elif cmd == 5: DMEM[p3] = p1 * 100 + p2 + v3 / 100.0 # SET
elif cmd == 6: # MAT
if p1 == 0: DMEM[p3] = v2 + v3
elif p1 == 1: DMEM[p3] = v2 - v3
elif p1 == 2: DMEM[p3] = v2 * v3
elif p1 == 3: DMEM[p3] = 0 if v3 == 0 else (v2 / v3)
elif p1 == 4: DMEM[p3] = math.floor(v2) if v3 == 0 else (v2 % v3)
elif p1 == 5: DMEM[p3] = math.fabs(v2)
elif p1 == 6: DMEM[p3] = math.sqrt(math.fabs(v2))
elif p1 == 7: DMEM[p3] = math.exp(v2)
elif p1 == 8: DMEM[p3] = 0 if v2 == 0 else math.log(math.fabs(v2))
elif p1 == 9: DMEM[p3] = math.sin(v2)
elif p1 == 10: DMEM[p3] = math.cos(v2)
elif p1 == 11: DMEM[p3] = math.atan(v2)
elif cmd == 7: DMEM[p3] = float(random.randint(int(v1), int(v2))) # RND
lno += 1 # increment the program counter
if lno >= MEMLIMIT: break
# interactive mode entry function
def intermode(cmd:int, p1:int, p2:int):
if cmd == 0 and p1 < MEMLIMIT: iexec(p1) # run from the step
elif cmd == 1 and p1 < MEMLIMIT: PMEM[p1] = p2 # enter the instruction into PMEM
elif cmd == 2 and p1 < MEMLIMIT and p2 < MEMLIMIT: # clear instructions
for cmd in range(p1, p2+1): PMEM[cmd] = 0
elif cmd == 3 and p1 < MEMLIMIT and p2 < MEMLIMIT: # clear data
for cmd in range(p1, p2+1): DMEM[cmd] = 0.0
elif cmd == 4:
print("Bye!")
sys.exit(0)
# main REPL environment
if __name__ == '__main__':
vreg = re.compile(r'[^-\d]+')
if len(sys.argv) > 1: # preload the file contents
fc = ''
try:
fd = open(sys.argv[1], 'r')
fc = fd.read()
close(fd)
except:
pass
instr = [] # current instruction cache
iindex = 0
for instrpart in vreg.split(fc):
if len(instrpart) > 0:
intermode(1, iindex, int(instrpart))
instr.append(int(instrpart))
iindex += 1
instr = [] # current instruction cache
while True: # main interactive loop
rinput = input('> ')
if len(rinput) > 0:
for v in vreg.split(rinput): # loop over the current input
if len(v) > 0:
instr.append(v)
if len(instr) == 3: # full instruction registered
intermode(int(instr[0]), int(instr[1]), int(instr[2]))
instr = []
n8asm.py
Executable
+238
View File
@@ -0,0 +1,238 @@
#!/usr/bin/env python3
# a simple assembler/disassembler for the n808 VM
# supports both text and binary program formats
# usage: n8asm [at|ab|dt|db|t2b|b2t|t74] file outfile
# modes:
# at: assemble to plaintext (N8) machine code
# ab: assemble to binary (N8B) machine code
# dt: disassemble plaintext (N8) machine code
# db: disassemble binary (N8B) machine code
# t2b: convert from plaintext N8 to binary N8B
# b2t: convert from binary N8B to plaintext N8
# t74: convert from plaintext N8 to the TI-74 representation
# Created by Luxferre in 2025, released into public domain
import sys, re, struct
# n808 mnemonics for assembly and disasssembly
mnemos = ['nop', 'jmp', 'iat', 'ino', 'cpy', 'set', 'mat', 'rnd']
# n808 jump/function shortcuts (arranged from longest to shortest)
jmpfunc_shorts = {
'ret': 'jmp 13 0 125', # return from a procedure
'nnn': 'nop 0 0 0', # alias for nop
'inc': 'mat 0 127', # increment
'dec': 'mat 0 126', # decrement
'inv': 'mat 3 127', # inverse/reciprocal
'iuc': 'jmp 13 0', # indirect unconditional jump
'jpr': 'jmp 14 0', # jump to a procedure
'neg': 'mat 1 0', # negation
'juc': 'jmp 6 0', # direct unconditional jump
'ige': 'jmp 10', # indirect jump if greater than or equals to zero
'ile': 'jmp 11', # indirect jump if less than or equals to zero
'ine': 'jmp 12', # indirect jump if not equals to zero
'cos': 'mat 10', # cosine
'atn': 'mat 11', # arctangent
'jeq': 'jmp 0', # direct jump if equals to zero
'jgt': 'jmp 1', # direct jump if greater than zero
'jlt': 'jmp 2', # direct jump if less than zero
'jge': 'jmp 3', # direct jump if greater than or equals to zero
'jle': 'jmp 4', # direct jump if less than or equals to zero
'jne': 'jmp 5', # direct jump if not equals to zero
'ieq': 'jmp 7', # indirect jump if equals to zero
'igt': 'jmp 8', # indirect jump if greater than zero
'ilt': 'jmp 9', # indirect jump if less than zero
'out': 'ino 0', # normal numeric output
'inp': 'ino 1', # normal numeric input
'ouc': 'ino 2', # character output
'ipc': 'ino 3', # character input
'dca': 'cpy 0', # direct constant assignment
'dva': 'cpy 1', # direct value assignment
'ica': 'cpy 2', # indirect constant assignment
'iva': 'cpy 3', # indirect value assignment
'ivc': 'cpy 4', # indirect value copy
'add': 'mat 0', # addition
'sub': 'mat 1', # subtraction
'mul': 'mat 2', # multiplication
'div': 'mat 3', # division
'mdf': 'mat 4', # modulo/floor
'abs': 'mat 5', # absolute value
'sqr': 'mat 6', # square root
'exp': 'mat 7', # natural exponent
'log': 'mat 8', # natural logarithm
'sin': 'mat 9' # sine
}
# converts the N8A source code to the plaintext machine code representation
def assemble(source):
labels = {}
out = ''
lno = 0
vreg = re.compile(r'\s+')
for shrt, meaning in jmpfunc_shorts.items(): # replace the shortcuts
source = source.replace(shrt, meaning)
for line in source.split('\n'): # parse the main code
fields = []
line = line.split(';')[0].strip()
if len(line) > 0: # actual line to be counted on
fields = vreg.split(line)[:5] # split it into fields
if fields[0].startswith(':'): # this is a label
labels[fields[0]] = lno # remember the label
fields = fields[1:] # remove the label from fields
elif fields[0].startswith('#'): # this is an alias
labels['@' + fields[1].strip()] = int(fields[0][1:])
continue # do not update the instruction number
try:
cmd = mnemos.index(fields[0].lower())
except ValueError:
try:
cmd = int(cmd)
except:
print('Assembly error - unknown mnemonic at line', lno)
sys.exit(1)
try:
out += ' '.join([str(cmd), fields[1], fields[2], fields[3]]) + '\n'
except IndexError:
print('Assembly error - not enough operands at line', lno)
sys.exit(1)
lno += 1 # update the instruction number
for lbl, lineno in labels.items():
out = out.replace(lbl, str(lineno))
final = '' # prepare the final text
for line in out.split('\n'):
if len(line) > 0:
fields = vreg.split(line)[:4] # split it into fields
instr = int(fields[0]) * 2097152 + int(fields[1]) * 16384
instr += int(fields[2]) * 128 + int(fields[3])
final += str(instr) + '\n'
return final
# converts the plaintext machine code representation to N8A source code
def disassemble(machcode):
vreg = re.compile(r'\s+')
iindex = 0
instrs = []
for instrnum in vreg.split(machcode):
if len(instrnum) > 0:
instrnum = int(instrnum)
opcode = (instrnum >> 21) & 7
p1 = (instrnum >> 14) & 127
p2 = (instrnum >> 7) & 127
p3 = instrnum & 127
instrs.append([iindex, opcode, p1, p2, p3])
iindex += 1
# now, instrs contains 5-number groups
assembly = [None for i in range(0, 128)]
labels = {}
for instr in instrs: # iterate over each instruction
lno, cmd, x, y, z = instr
try:
mnemo = mnemos[cmd]
except IndexError:
print('Disassembly error - unknown opcode at line', lno)
sys.exit(1)
if cmd == 1: # save the label for jump instructions
labels[z] = ':lbl_' + str(z)
assembly[lno] = [mnemo, str(x), str(y), labels[z]]
else:
assembly[lno] = [mnemo, str(x), str(y), str(z)]
out = ''
lno = 0
for asline in assembly:
if lno in labels:
out += labels[lno] + ' '
if asline is not None:
out += ' '.join(asline) + '\n'
lno += 1
for shrt, meaning in jmpfunc_shorts.items(): # replace the shortcuts
out = out.replace(meaning, shrt)
return out
# converts the plaintext machine code representation to binary representation
def tobinary(txtrep):
instrs = [] # instruction list to store here
vreg = re.compile(r'\s+')
out = b''
for instr in vreg.split(txtrep):
if len(instr) > 0:
instr = int(instr)
out += struct.pack('BBB', (instr >> 16) & 255, (instr >> 8) & 255, instr & 255)
return out
# converts the binary machine code representation to plaintext representation
def totext(binrep):
out = ''
while len(binrep) > 0:
chunk = binrep[0:3]
binrep = binrep[3:]
b1, b2, b3 = struct.unpack('BBB', chunk)
instr = (b1 << 16) | (b2 << 8) | b3
out += str(instr) + '\n'
return out
# converts the N8 plaintext machine code to the TI-74 DATA statements (N74)
def ti74data(txtrep:str, baseaddr:int=1000):
instrs = [] # instruction list to store here
vreg = re.compile(r'\s+')
out = ''
iindex = 0
for instr in vreg.split(txtrep):
if len(instr) > 0:
instrs.append(str(int(instr)))
instrs.append(str(-1)) # add the terminating instruction
while len(instrs) > 0:
dchunk = instrs[:7]
instrs = instrs[7:]
out += f'{baseaddr + iindex} DATA {','.join(dchunk)}\n'
iindex += 1
return out
def main():
if len(sys.argv) < 4:
print("Usage: n8asm [at|ab|dt|db|t2b|b2t|t74] file outfile")
return
mode = sys.argv[1]
srcfile = sys.argv[2]
targetfile = sys.argv[3]
srctext = ''
inpmode = 'r'
if mode == 'b2t' or mode == 'db':
inpmode = 'rb'
try:
fd = open(srcfile, inpmode)
srctext = fd.read()
close(fd)
except:
pass
if len(srctext) > 0:
outmode = 'w'
output = ''
if mode == 'b2t': # binary-to-text
output = totext(srctext)
elif mode == 't2b': # text-to-binary
output = tobinary(srctext)
outmode = 'wb'
elif mode == 'dt': # disassemble text
output = disassemble(srctext)
elif mode == 'db': # disassemble binary
srctext = totext(srctext)
output = disassemble(srctext)
elif mode == 't74': # convert to TI-74 DATA statements
output = ti74data(srctext)
else: # assemble
output = assemble(srctext) # default mode
if mode == 'ab':
output = tobinary(output)
outmode = 'wb'
# write the output file
try:
fd = open(targetfile, outmode)
fd.write(output)
close(fd)
except:
pass
else:
print('Nothing to process!')
if __name__ == '__main__':
main()