initial commit

tronScript/assemblyTest.tron

@@ -0,0 +1,6 @@
+:INP b#00000000
+:STA v#A
+:INP b#00000000
+:ADD v#A
+:OUT -
+:HLT ~

tronScript/forTest.tron

@@ -0,0 +1,7 @@
+read A
+read B
+
+setVar STEP 1
+
+for A CLOCK STEP write B
+

tronScript/henrik.tron

@@ -0,0 +1,4 @@
+setVar A 5
+setVar B 7
+add A B C
+write C

tronScript/powCompiled.tron

@@ -0,0 +1,33 @@
+#inputs
+read BASE
+read EXPONENT
+
+setVar ONE 1
+setVar ZERO 0
+
+#newVar mulCOUNTER
+#newVar mulOUT
+
+copyVar BASE powOUT
+jumpMark powLoop
+
+copyVar powOUT IN_A
+copyVar BASE IN_B
+copyVar ZERO mulOUT
+copyVar ZERO mulCOUNTER
+jump mulLoop
+jumpMark next
+add powCOUNTER ONE powCOUNTER
+if powCOUNTER != EXPONENT jump powLoop
+
+write mulOUT
+
+halt
+
+jumpMark mulLoop
+add mulOUT IN_A mulOUT
+add mulCOUNTER ONE mulCOUNTER
+if IN_B != mulCOUNTER jump mulLoop
+jump next
+
+halt

tronScript/stack_test.tron

@@ -0,0 +1,14 @@
+setVar STEP 1
+setVar A 5
+push A
+setVar A 3
+push A
+setVar A 7
+push A
+
+pop A
+write A
+pop A
+write A
+pop A
+write A

tronScript/tronScript_README.txt

@@ -0,0 +1,45 @@
+tronScript is a stupid pretty assembly-like low level language for my asmTron emulator
+
+
+Available Commands:
+
+newVar [var]                            - Initializes new var; not needed most of the time:
+                                          Compiler automatically initializes new vars when used
+jumpMark [jumpMark name]                - Sets an JumpMark to jump to using the "jump" command
+jump [jumpMark name]                    - Jumps to an JumpMark
+getVarAddress [var A] [var B]           - Saves [var A]'s memory-address into [var B]
+getArrayAddress [array] [index] [var]   - Saves [array][[index]]'s memory-adress into [var]
+exec [func name]                        - Executes function with name [func name]
+setVar [var] [value]                    - Sets var [var] to [value] (decimal)
+setVar [var] b[value]                   - Sets var [var] to [value] (binary)
+setArrayIndex [array] [index] [value]   - Sets [array][[index]] to [value] (decimal)
+setArrayIndex [array] [index] b[value]  - Sets [array][[index]] to [value] (binary)
+getArrayIndex [array] [index] [var]     - Stores the content of [array][[index]] into var [var]
+copyVar [var A] [var B]                 - Copies to value of [var A] to [var B] (B=A)
+write [var]                             - Writes value of [var] to console
+read [var]                              - Reads input from console into [var]
+add [var A] [var B] [var OUT]           - Adds [var A] + [var B] = [var OUT]
+subtract [var A] [var B] [var OUT]      - Subtracts [var A] - [var B] = [var OUT]
+if [var A] [??] [var B] [cmd] [pars]    - ?? = [==,!=,>,<,>=,<=] if clause is true,
+                                          executes [cmd] with [pars]
+for [goal] [counter] [step] [cmd] [pars]- Sets [counter] = 0; Executes [cmd] with [pars] and
+                                          adds [step] to [counter], until [goal]==[counter]
+:[asm] v#[var]                          - Executes [asm]-assembler command with par [var]
+:[asm] d#[par]                          - Executes [asm]-assembler command with par [par] (decimal)
+:[asm] b#[par]                          - Executes [asm]-assembler command with par [par] (binary)
+:[asm] -                                - Executes [asm]-assembler command with par b#00000000 / d#0
+:[asm] ~                                - Executes [asm]-assembler command with par b#11111111 / d#255
+shellcode [code]                        - Executes binary code [code]
+nop                                     - Nothing; sleep one cycle
+halt                                    - Stops execution of program; automatically added to the end of
+                                          your program if not present
+
+function [funcName] {                   - Defines function [funcName] with code [funcCode]
+    [funcCode line 1]                     ! Every function can only have one instance at a time:
+    [funcCode line 2]                     ! A function shall not call itself and a sub function shall
+    [funcCode line 3]                     ! not call any of its root functions !!!
+     .                                    ! If you need this functionality, implement it in assembly...
+     .
+     .                                    Why is that so? This is a stupid compiler, which does not use
+    [funcCode line n]                     a stack to return from functions, but a function-specific variable
+}                                         to store the jump-back-address... :P