diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
new file mode 100644
index 0000000..873615d
--- /dev/null
+++ b/.vscode/c_cpp_properties.json
@@ -0,0 +1,21 @@
+{
+ "configurations": [
+ {
+ "name": "Win32",
+ "includePath": [
+ "${workspaceFolder}/**",
+ "../util"
+ ],
+ "defines": [
+ "_DEBUG",
+ "UNICODE",
+ "_UNICODE"
+ ],
+ "compilerPath": "C:/SysGCC/risc-v/bin/riscv64-unknown-elf-gcc.exe",
+ "cStandard": "c17",
+ "cppStandard": "gnu++17",
+ "intelliSenseMode": "windows-gcc-x64"
+ }
+ ],
+ "version": 4
+}
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..08f6034
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,5 @@
+{
+ "files.associations": {
+ "vartype.h": "c"
+ }
+}
\ No newline at end of file
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..585f7f7
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,32 @@
+INCLUDE_DIRS = util/
+COMPILER_DIR = C:/SysGCC/risc-v/bin
+CC = $(COMPILER_DIR)/riscv64-unknown-elf-gcc
+RV_CFG = -march=rv32im -mabi=ilp32
+CFLAGS = -c $(RV_CFG) -I $(INCLUDE_DIRS) -O3
+LDFLAGS = -nostartfiles -specs=nano.specs -ffunction-sections $(RV_CFG) -T linker.ld
+
+OBJS = *.o
+SRC_FILES = *.c util/*.c
+
+all: $(OBJS) final.elf
+ $(COMPILER_DIR)/riscv64-unknown-elf-objcopy -O binary final.elf final.bin
+ rm -rf *.o
+
+final.elf: $(OBJS)
+ $(CC) $(LDFLAGS) $^ -o $@
+
+$(OBJS): $(SRC_FILES)
+ $(CC) $(CFLAGS) $^
+
+.PHONY: clean dump size bin
+
+clean:
+ rm -f *.o *.bin *.elf
+
+dump:
+ $(COMPILER_DIR)/riscv64-unknown-elf-objdump -D final.elf
+
+size:
+ $(COMPILER_DIR)/riscv64-unknown-elf-size -A final.elf
+
+
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..e0d79ab
--- /dev/null
+++ b/README.md
@@ -0,0 +1,287 @@
+# Veecom uBASIC
+
+#### A Simple Interactive BASIC Interpreter for Veecom.
+
+## Table of Contents
+* [Introduction](#intro)
+* [Variables](#variables)
+* [Mathematical Operators](#math_operators)
+* [Logical Operators](#logical_operators)
+* [Control Flow](#control_flow)
+* [PEEK-POKE](#peek_poke)
+* [Additional Commands](#additional_commands)
+* [Examples](#examples)
+* [Configuring uBASIC](#config)
+* [Compiling and Building uBASIC](#compile_build)
+
+### Introduction
+
+Veecom uBASIC is a derivative of the [uBASIC](https://dunkels.com/adam/ubasic/) interpreter originally authored by Adam Dunkels. This version of uBASIC has been improved to be made fully interactive, with the incorporation of additional commands and performance optimizations.
+
+
+
+
+
+The interpreter provides flexibility in input methods, allowing users to either write commands directly or use line numbers.
+
+#### Direct Command Input:
+
+ PRINT "HELLO, WORLD!"
+
+#### Line-Numbered Programming:
+
+ 10 PRINT "HELLO, WORLD!"
+ 20 END
+
+Direct commands are executed right away, whereas Line-Numbered commands require the execution of the `RUN` command afterward.
+
+
+
+### Variables
+
+There is only support for integer variables and the variables can only have single character names (A-Z).
+
+#### Valid Assignment
+ 10 LET A = 10
+ 20 LET B = 2 * A
+ 30 LET C = B - A
+
+#### Invalid Assignment
+ 10 LET CE = 9
+ 20 LET A = 2.4
+
+
+
+### Mathematical Operators
+
+#### Addition ( + ):
+ LET N = 10 + 6
+
+#### Subtraction ( - ):
+ LET N = 10 - 6
+
+#### Multiplication ( * ):
+ LET N = 10 * 6
+
+#### Division ( / ):
+ LET N = 10 / 6
+
+#### Modulus ( % ):
+ LET N = 10 % 6
+
+
+
+### Logical Operators
+
+#### Logical And ( & ):
+ LET N = 10 & 6
+
+#### Logical Or ( | ):
+ LET N = 10 | 6
+
+#### Less Than ( < ):
+ IF A < B THEN ...
+
+#### Greater Than ( > ):
+ IF A > B THEN ...
+
+#### Equal ( = ):
+ IF A = B THEN ...
+
+
+
+### Control Flow
+
+#### IF-THEN Statement
+
+ IF A < B THEN PRINT "A IS LESS"
+
+#### FOR-NEXT Statement
+
+ 10 FOR I = 1 TO 3
+ 20 PRINT I * I
+ 30 NEXT I
+ 40 END
+
+ 1
+ 4
+ 9
+
+#### GOTO Statement
+
+ 10 PRINT "HELLO, WORLD!"
+ 20 GOTO 10
+
+ HELLO, WORLD!
+ HELLO, WORLD!
+ HELLO, WORLD!
+ HELLO, WORLD!
+ HELLO, WORLD!
+ ...
+
+#### GOSUB-RETURN
+
+ 10 GOSUB 100
+ 20 PRINT "RETURNED FROM SUBROUTINE"
+ 30 END
+ 100 PRINT "SUBROUTINE"
+ 110 RETURN
+
+ SUBROUTINE
+ RETURNED FROM SUBROUTINE
+
+### PEEK-POKE
+
+#### PEEK
+`A` is assigned to the value held at address `65535`
+
+ PEEK 65535, A
+
+Variables can be used to hold addresses
+
+ 10 LET A = 65532
+ 20 PEEK A, B
+
+#### POKE
+
+The memory address is assigned to the value held by `A`
+
+ 10 LET A = 72
+ 20 POKE 65534, A
+
+
+
+### Additional Commands
+
+#### RUN
+
+The `RUN` is used to start the execution of Line-Numbered programs
+
+ 10 PRINT "HELLO, WORLD!"
+ 20 GOTO 10
+
+ RUN
+ HELLO, WORLD!
+ HELLO, WORLD!
+ HELLO, WORLD!
+ ...
+
+#### LIST
+ The `LIST` command is used to view the lines of uBASIC code that you have entered into the computer.
+
+ 10 PRINT "HELLO, WORLD!"
+ 20 FOR I = 1 TO 10
+ 30 PRINT I
+ 40 NEXT I
+
+#### LIST 20
+ 20 FOR I = 1 TO 10
+
+#### LIST -30
+
+ 10 PRINT "HELLO, WORLD!"
+ 20 FOR I = 1 TO 10
+ 30 PRINT I
+
+#### LIST 30-40
+ 30 PRINT I
+ 40 NEXT I
+
+#### LIST 20-
+ 20 FOR I = 1 TO 10
+ 30 PRINT I
+ 40 NEXT I
+
+#### NEW
+
+The `NEW` command erases the content of uBASIC program memory
+
+ LIST
+ 10 PRINT "HELLO, WORLD!"
+ READY.
+
+ NEW
+ READY.
+
+ LIST
+
+ READY.
+
+#### FRE
+The `FRE` command displays the remaining bytes available for the uBASIC program
+
+ FRE
+ 2100 uBASIC BYTES FREE
+
+
+
+### Examples
+
+#### Printing the alphabet to the terminal
+
+ REM SET VARIABLE A TO THE ADDRESS OF PORT A OUTPUT (PAO)
+ 10 LET A = 65528
+ 20 FOR I = 65 TO 90
+ 30 POKE A, I | 128
+ 40 POKE A, 0
+ 50 NEXT I
+ 60 POKE A, 10
+ 70 POKE A, 0
+ 80 END
+
+
+
+
+
+#### Reading the timer value
+
+ REM CONFIGURE AND START THE TIMER IN ONE-SHOT MODE
+ 10 LET C = 1
+ 20 POKE 65535, C
+ 30 PEEK 65534, T
+ 40 PRINT T
+ 50 GOTO 30
+
+
+
+
+
+#### Odd-Even
+
+When `A` equal to 6
+
+ 10 LET A = 6
+ 20 IF A % 2 = 0 THEN GOTO 50
+ 30 PRINT "A IS ODD"
+ 40 END
+ 50 PRINT "A IS EVEN"
+ 60 END
+
+
+
+
+
+
+
+When `A` equal to 9
+
+ 10 LET A = 9
+ ...
+
+
+
+
+
+
+
+### Configuring uBASIC
+
+Veecom uBASIC can be customized from the `ubasic_config.h` file.
+
+### Compiling and Building uBASIC
+
+You'll need a RISC-V C/C++ compiler, I personally use this one for my windows machine.
+Download and install `risc-v-gcc10.1.0.exe` and leave things to defaults.
+Open the terminal, navigate to `Veecom-uBASIC` folder and type `make`.
+
+From logisim load the `final.bin` file into Veecoms' main memory module.
diff --git a/interperter.c b/interperter.c
new file mode 100644
index 0000000..30745cc
--- /dev/null
+++ b/interperter.c
@@ -0,0 +1,682 @@
+/*
+ * Copyright (c) 2006, Adam Dunkels
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the author nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#include "interperter.h"
+#include "tokenizer.h"
+#include "utility.h"
+#include
+#include
+
+VariableType_t expr(void);
+
+static struct interperter self;
+
+void interperter_init(peek_func peek, poke_func poke)
+{
+ interperter_reset();
+
+ for (int i = 0; i < UBASIC_MAX_PROGRAM_LINES; ++i)
+ {
+ self.program_lines[i].idx = -1;
+ }
+
+ self.peek_function = peek;
+ self.poke_function = poke;
+
+ self.bytes_used = 0;
+ self.cur_free_lidx = 0;
+}
+
+void interperter_reset(void)
+{
+ self.for_stack_ptr = 0;
+ self.gosub_stack_ptr = 0;
+ self.program_counter = 0;
+ self.finished = 0;
+}
+
+int interperter_get_line_num(char *text)
+{
+ tokenizer_init(text);
+
+ if (tokenizer_token() == TOKENIZER_NUMBER)
+ {
+ return tokenizer_num();
+ }
+
+ return -1;
+}
+
+int interperter_indexed_line_empty()
+{
+ tokenizer_next();
+ return tokenizer_token() == TOKENIZER_CR;
+}
+
+void set_variable(int varnum, VariableType_t value)
+{
+ if (varnum >= 0 && varnum <= MAX_VARNUM)
+ {
+ self.variables[varnum] = value;
+ }
+}
+
+VariableType_t get_variable(int varnum)
+{
+ if (varnum >= 0 && varnum <= MAX_VARNUM)
+ {
+ return self.variables[varnum];
+ }
+
+ return 0;
+}
+
+void accept(int token)
+{
+ if (token != tokenizer_token())
+ {
+ // tokenizer_error_dma_write();
+ return;
+ }
+
+ tokenizer_next();
+}
+
+int varfactor(void)
+{
+ int r = get_variable(tokenizer_variable_num());
+ accept(TOKENIZER_VARIABLE);
+ return r;
+}
+
+int factor(void)
+{
+ int r;
+
+ switch (tokenizer_token())
+ {
+ case TOKENIZER_NUMBER:
+ r = tokenizer_num();
+ accept(TOKENIZER_NUMBER);
+ break;
+ case TOKENIZER_LEFTPAREN:
+ accept(TOKENIZER_LEFTPAREN);
+ r = expr();
+ accept(TOKENIZER_RIGHTPAREN);
+ break;
+ default:
+ r = varfactor();
+ break;
+ }
+
+ return r;
+}
+
+int term(void)
+{
+ int f1 = factor();
+ int op = tokenizer_token();
+
+ while (op == TOKENIZER_ASTR ||
+ op == TOKENIZER_SLASH ||
+ op == TOKENIZER_MOD)
+ {
+ tokenizer_next();
+ int f2 = factor();
+
+ switch (op)
+ {
+ case TOKENIZER_ASTR:
+ f1 = f1 * f2;
+ break;
+ case TOKENIZER_SLASH:
+ f1 = f1 / f2;
+ break;
+ case TOKENIZER_MOD:
+ f1 = f1 % f2;
+ break;
+ }
+ op = tokenizer_token();
+ }
+
+ return f1;
+}
+
+VariableType_t expr(void)
+{
+ int t1 = term();
+ int op = tokenizer_token();
+
+ while (op == TOKENIZER_PLUS ||
+ op == TOKENIZER_MINUS ||
+ op == TOKENIZER_AND ||
+ op == TOKENIZER_OR)
+ {
+ tokenizer_next();
+ int t2 = term();
+
+ switch (op)
+ {
+ case TOKENIZER_PLUS:
+ t1 = t1 + t2;
+ break;
+ case TOKENIZER_MINUS:
+ t1 = t1 - t2;
+ break;
+ case TOKENIZER_AND:
+ t1 = t1 & t2;
+ break;
+ case TOKENIZER_OR:
+ t1 = t1 | t2;
+ break;
+ }
+ op = tokenizer_token();
+ }
+
+ return t1;
+}
+
+int relation(void)
+{
+ int r1 = expr();
+ int op = tokenizer_token();
+
+ while (op == TOKENIZER_LT ||
+ op == TOKENIZER_GT ||
+ op == TOKENIZER_EQ)
+ {
+ tokenizer_next();
+ int r2 = expr();
+
+ switch (op)
+ {
+ case TOKENIZER_LT:
+ r1 = r1 < r2;
+ break;
+ case TOKENIZER_GT:
+ r1 = r1 > r2;
+ break;
+ case TOKENIZER_EQ:
+ r1 = r1 == r2;
+ break;
+ }
+ op = tokenizer_token();
+ }
+
+ return r1;
+}
+
+struct line_index index_find(int linenum)
+{
+ struct line_index find = {.idx = -1};
+
+ for (int i = 0; i < self.cur_free_lidx + 1; ++i)
+ {
+ if (self.program_lines[i].line_number == linenum)
+ {
+ find = self.program_lines[i];
+ break;
+ }
+ }
+
+ return find;
+}
+
+void index_insert(struct line_index lidx)
+{
+ for (int i = 0; i < self.cur_free_lidx + 1; ++i)
+ {
+ if (self.program_lines[i].idx == -1)
+ {
+ self.program_lines[i] = lidx;
+ return;
+ }
+
+ if (self.program_lines[i].line_number > lidx.line_number)
+ {
+ struct line_index temp = self.program_lines[i];
+ temp.idx = lidx.idx;
+ self.program_lines[i] = lidx;
+ self.program_lines[i].idx = i;
+ lidx = temp;
+ }
+ }
+}
+
+void interperter_add_line(int linenum, char *text, int len)
+{
+ if (self.cur_free_lidx >= UBASIC_MAX_PROGRAM_LINES)
+ {
+ return;
+ }
+
+ int idx = index_find(linenum).idx;
+
+ if (idx != -1)
+ {
+ memcpy(self.program_lines[idx].text, text, len);
+ return;
+ }
+
+ struct line_index new_lidx = {
+ .line_number = linenum,
+ .idx = self.cur_free_lidx++,
+ .len = len,
+ };
+
+ memcpy(new_lidx.text, text, len);
+ index_insert(new_lidx);
+ self.bytes_used += len;
+}
+
+void goto_statement(void)
+{
+ accept(TOKENIZER_GOTO);
+ self.program_counter = index_find(tokenizer_num()).idx;
+}
+
+void print_statement(void)
+{
+ accept(TOKENIZER_PRINT);
+
+ do
+ {
+ if (tokenizer_token() == TOKENIZER_STRING)
+ {
+ int strlen = tokenizer_string(self.string, UBASIC_MAX_STRINGLEN);
+ dma_nwrite(self.string, strlen);
+ tokenizer_next();
+ }
+ else if (tokenizer_token() == TOKENIZER_COMMA)
+ {
+ put_char(' ');
+ tokenizer_next();
+ }
+ else if (tokenizer_token() == TOKENIZER_SEMICOLON)
+ {
+ tokenizer_next();
+ }
+ else
+ {
+ VariableType_t e = expr();
+ itoa(e, self.numstr, 10);
+ dma_nwrite(self.numstr, UBASIC_MAX_NUMLEN);
+ }
+ } while (tokenizer_token() != TOKENIZER_CR &&
+ tokenizer_token() != TOKENIZER_ENDOFINPUT);
+
+ put_char('\n');
+ tokenizer_next();
+}
+
+void if_statement(void)
+{
+ int r;
+
+ accept(TOKENIZER_IF);
+
+ r = relation();
+
+ accept(TOKENIZER_THEN);
+
+ if (r)
+ {
+ interperter_execute();
+ }
+
+ accept(TOKENIZER_CR);
+}
+
+void let_statement(void)
+{
+ int var = tokenizer_variable_num();
+
+ accept(TOKENIZER_VARIABLE);
+ accept(TOKENIZER_EQ);
+ set_variable(var, expr());
+ accept(TOKENIZER_CR);
+}
+
+void gosub_statement(void)
+{
+ int linenum;
+
+ accept(TOKENIZER_GOSUB);
+ linenum = tokenizer_num();
+
+ accept(TOKENIZER_NUMBER);
+ accept(TOKENIZER_CR);
+
+ if (self.gosub_stack_ptr < UBASIC_MAX_GOSUB_STACK_DEPTH)
+ {
+ self.gosub_stack[self.gosub_stack_ptr] = self.program_counter;
+ self.gosub_stack_ptr++;
+ self.program_counter = index_find(linenum).idx;
+ }
+}
+
+void return_statement(void)
+{
+ accept(TOKENIZER_RETURN);
+
+ if (self.gosub_stack_ptr > 0)
+ {
+ self.gosub_stack_ptr--;
+ self.program_counter = self.gosub_stack[self.gosub_stack_ptr];
+ }
+}
+
+void next_statement(void)
+{
+ int var;
+
+ accept(TOKENIZER_NEXT);
+ var = tokenizer_variable_num();
+ accept(TOKENIZER_VARIABLE);
+
+ if (self.for_stack_ptr > 0 && var == self.for_stack[self.for_stack_ptr - 1].for_variable)
+ {
+ set_variable(var, get_variable(var) + 1);
+
+ if (get_variable(var) <= self.for_stack[self.for_stack_ptr - 1].to)
+ {
+ self.program_counter = self.for_stack[self.for_stack_ptr - 1].line_after_for;
+ }
+ else
+ {
+ self.for_stack_ptr--;
+ accept(TOKENIZER_CR);
+ }
+ }
+ else
+ {
+ accept(TOKENIZER_CR);
+ }
+}
+
+void for_statement(void)
+{
+ int for_variable, to;
+
+ accept(TOKENIZER_FOR);
+ for_variable = tokenizer_variable_num();
+
+ accept(TOKENIZER_VARIABLE);
+ accept(TOKENIZER_EQ);
+
+ set_variable(for_variable, expr());
+ accept(TOKENIZER_TO);
+
+ to = expr();
+ accept(TOKENIZER_CR);
+
+ if (self.for_stack_ptr < UBASIC_MAX_FOR_STACK_DEPTH)
+ {
+ self.for_stack[self.for_stack_ptr].line_after_for = self.program_counter;
+ self.for_stack[self.for_stack_ptr].for_variable = for_variable;
+ self.for_stack[self.for_stack_ptr].to = to;
+ self.for_stack_ptr++;
+ }
+}
+
+void peek_statement(void)
+{
+ VariableType_t peek_addr;
+ VariableType_t var;
+
+ accept(TOKENIZER_PEEK);
+ peek_addr = expr();
+
+ accept(TOKENIZER_COMMA);
+ var = tokenizer_variable_num();
+
+ accept(TOKENIZER_VARIABLE);
+ accept(TOKENIZER_CR);
+
+ set_variable(var, self.peek_function(peek_addr));
+}
+
+void poke_statement(void)
+{
+ VariableType_t poke_addr;
+ VariableType_t value;
+
+ accept(TOKENIZER_POKE);
+ poke_addr = expr();
+
+ accept(TOKENIZER_COMMA);
+ value = expr();
+
+ accept(TOKENIZER_CR);
+
+ self.poke_function(poke_addr, value);
+}
+
+void end_statement(void)
+{
+ accept(TOKENIZER_END);
+ self.finished = 1;
+}
+
+void new_statement(void)
+{
+ accept(TOKENIZER_NEW);
+ accept(TOKENIZER_CR);
+
+ for (int i = 0; i < self.cur_free_lidx; ++i)
+ {
+ self.program_lines[i].idx = -1;
+ }
+
+ self.cur_free_lidx = 0;
+ self.bytes_used = 0;
+}
+
+void run_statement(void)
+{
+ accept(TOKENIZER_RUN);
+ accept(TOKENIZER_CR);
+
+ if (self.bytes_used == 0)
+ {
+ return;
+ }
+
+ interperter_reset();
+
+ while (self.program_counter < self.cur_free_lidx)
+ {
+ if (self.finished)
+ {
+ return;
+ }
+
+ struct line_index lidx = self.program_lines[self.program_counter++];
+
+ if (lidx.idx == -1)
+ {
+ continue;
+ }
+
+ tokenizer_init(lidx.text);
+ accept(TOKENIZER_NUMBER);
+ interperter_execute();
+ }
+}
+
+void list_statement(void)
+{
+ if (self.bytes_used == 0)
+ {
+ put_char('\n');
+ return;
+ }
+
+ accept(TOKENIZER_LIST);
+
+ int start = 0;
+ int end = self.cur_free_lidx - 1;
+
+ switch (tokenizer_token())
+ {
+ case TOKENIZER_NUMBER:
+ start = index_find(tokenizer_num()).idx;
+ tokenizer_next();
+
+ if (tokenizer_token() == TOKENIZER_CR)
+ {
+ end = start;
+ }
+ else if (tokenizer_token() == TOKENIZER_MINUS)
+ {
+ tokenizer_next();
+
+ if (tokenizer_token() == TOKENIZER_NUMBER)
+ {
+ end = index_find(tokenizer_num()).idx;
+ }
+ }
+ break;
+ case TOKENIZER_MINUS:
+ tokenizer_next();
+ if (tokenizer_token() == TOKENIZER_NUMBER)
+ {
+ end = index_find(tokenizer_num()).idx;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (start == -1 || end == -1)
+ {
+ put_char('\n');
+ return;
+ }
+
+ for (int i = start; i <= end; ++i)
+ {
+ if (self.program_lines[i].idx == -1)
+ {
+ continue;
+ }
+
+ dma_nwrite(self.program_lines[i].text, self.program_lines[i].len);
+ }
+}
+
+void fre_statement(void)
+{
+ accept(TOKENIZER_FRE);
+ accept(TOKENIZER_CR);
+
+ sprintf(self.string, "%d uBASIC BYTES FREE\n");
+ dma_write(self.string);
+}
+
+void interperter_remove_line(int linenum)
+{
+ int idx = index_find(linenum).idx;
+
+ if (idx == -1)
+ {
+ return;
+ }
+
+ self.program_lines[idx].idx = -1;
+ self.bytes_used -= self.program_lines[idx].len;
+}
+
+uint16_t interperter_bytes_free(void)
+{
+ return UBASIC_FREE_BYTES - self.bytes_used;
+}
+
+void interperter_execute(void)
+{
+ int token;
+
+ token = tokenizer_token();
+
+ switch (token)
+ {
+ case TOKENIZER_PRINT:
+ print_statement();
+ break;
+ case TOKENIZER_IF:
+ if_statement();
+ break;
+ case TOKENIZER_GOTO:
+ goto_statement();
+ break;
+ case TOKENIZER_GOSUB:
+ gosub_statement();
+ break;
+ case TOKENIZER_RETURN:
+ return_statement();
+ break;
+ case TOKENIZER_FOR:
+ for_statement();
+ break;
+ case TOKENIZER_PEEK:
+ peek_statement();
+ break;
+ case TOKENIZER_POKE:
+ poke_statement();
+ break;
+ case TOKENIZER_NEXT:
+ next_statement();
+ break;
+ case TOKENIZER_END:
+ end_statement();
+ break;
+ case TOKENIZER_LET:
+ accept(TOKENIZER_LET);
+ /* Fall through. */
+ case TOKENIZER_VARIABLE:
+ let_statement();
+ break;
+ case TOKENIZER_NEW:
+ new_statement();
+ break;
+ case TOKENIZER_RUN:
+ run_statement();
+ break;
+ case TOKENIZER_LIST:
+ list_statement();
+ break;
+ case TOKENIZER_FRE:
+ fre_statement();
+ break;
+ default:
+ self.finished = 1;
+ break;
+ }
+}
\ No newline at end of file
diff --git a/interperter.h b/interperter.h
new file mode 100644
index 0000000..ac3b775
--- /dev/null
+++ b/interperter.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2006, Adam Dunkels
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the author nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#ifndef __INTERPERTER_H__
+#define __INTERPERTER_H__
+
+#include
+#include "ubasic_version.h"
+
+#define MAX_VARNUM 26
+
+struct for_state
+{
+ int line_after_for;
+ int for_variable;
+ int to;
+};
+
+struct line_index
+{
+ char text[UBASIC_PROGRAM_LINE_WIDTH];
+ int line_number;
+ int idx;
+ int len;
+};
+
+typedef VariableType_t (*peek_func)(VariableType_t);
+typedef void (*poke_func)(VariableType_t, VariableType_t);
+
+struct interperter
+{
+ struct line_index program_lines[UBASIC_MAX_PROGRAM_LINES];
+ struct for_state for_stack[UBASIC_MAX_FOR_STACK_DEPTH];
+ VariableType_t variables[MAX_VARNUM];
+ char string[UBASIC_MAX_STRINGLEN];
+ char numstr[UBASIC_MAX_NUMLEN];
+ int for_stack_ptr;
+ int gosub_stack[UBASIC_MAX_GOSUB_STACK_DEPTH];
+ int gosub_stack_ptr;
+ int cur_free_lidx;
+ int program_counter;
+ int finished;
+ int bytes_used;
+ peek_func peek_function;
+ poke_func poke_function;
+};
+
+void interperter_init(peek_func peek, poke_func poke);
+void interperter_reset(void);
+void interperter_execute(void);
+int interperter_get_line_num(char *text);
+int interperter_indexed_line_empty(void);
+void interperter_add_line(int linenum, char *text, int len);
+void interperter_remove_line(int linenum);
+uint16_t interperter_bytes_free(void);
+
+#endif
\ No newline at end of file
diff --git a/linker.ld b/linker.ld
new file mode 100644
index 0000000..91df063
--- /dev/null
+++ b/linker.ld
@@ -0,0 +1,43 @@
+OUTPUT(riscv)
+ENTRY(_start)
+
+MEMORY
+{
+ RAM (rwx): ORIGIN = 0x00000, LENGTH = 0xFFFF - 0x0B
+}
+
+SECTIONS
+{
+ __stack_size = 4K;
+
+ .init :
+ {
+ *(.init)
+ } > RAM
+
+ .text :
+ {
+ *(.text*)
+ *(.rodata*)
+ PROVIDE( _text_end = .);
+
+ } > RAM
+
+ .data :
+ {
+ *(.data*)
+ PROVIDE( _global_pointer = . + 0x800);
+ *(.sdata*)
+ } > RAM
+
+ .bss :
+ {
+ *(.bss*)
+ }
+
+ .stack ORIGIN(RAM) + LENGTH(RAM) - __stack_size :
+ {
+ PROVIDE( _sp = .);
+ } >RAM
+}
+
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..e5be473
--- /dev/null
+++ b/main.c
@@ -0,0 +1,11 @@
+#include "ubasic.h"
+
+int main(void)
+{
+ ubasic_init();
+
+ for (;;)
+ {
+ ubasic_run();
+ }
+}
\ No newline at end of file
diff --git a/screenshots/alphabet.svg b/screenshots/alphabet.svg
new file mode 100644
index 0000000..fc34685
--- /dev/null
+++ b/screenshots/alphabet.svg
@@ -0,0 +1,524 @@
+
+
diff --git a/screenshots/even.svg b/screenshots/even.svg
new file mode 100644
index 0000000..8173705
--- /dev/null
+++ b/screenshots/even.svg
@@ -0,0 +1,523 @@
+
+
diff --git a/screenshots/hello_world.svg b/screenshots/hello_world.svg
new file mode 100644
index 0000000..3cb6504
--- /dev/null
+++ b/screenshots/hello_world.svg
@@ -0,0 +1,520 @@
+
+
diff --git a/screenshots/odd.svg b/screenshots/odd.svg
new file mode 100644
index 0000000..ae54897
--- /dev/null
+++ b/screenshots/odd.svg
@@ -0,0 +1,523 @@
+
+
diff --git a/screenshots/timer_example.svg b/screenshots/timer_example.svg
new file mode 100644
index 0000000..05fb927
--- /dev/null
+++ b/screenshots/timer_example.svg
@@ -0,0 +1,523 @@
+
+
diff --git a/tokenizer.c b/tokenizer.c
new file mode 100644
index 0000000..e41fa9e
--- /dev/null
+++ b/tokenizer.c
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) 2006, Adam Dunkels
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the author nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#include "tokenizer.h"
+#include "ubasic_config.h"
+#include
+#include
+#include
+
+static char const *ptr, *nextptr;
+
+struct keyword_token
+{
+ char *keyword;
+ int token;
+};
+
+static int current_token = TOKENIZER_ERROR;
+
+static const struct keyword_token keywords[] = {
+ {"LET", TOKENIZER_LET},
+ {"PRINT", TOKENIZER_PRINT},
+ {"IF", TOKENIZER_IF},
+ {"THEN", TOKENIZER_THEN},
+ {"FOR", TOKENIZER_FOR},
+ {"TO", TOKENIZER_TO},
+ {"NEXT", TOKENIZER_NEXT},
+ {"GOTO", TOKENIZER_GOTO},
+ {"GOSUB", TOKENIZER_GOSUB},
+ {"RETURN", TOKENIZER_RETURN},
+ {"REM", TOKENIZER_REM},
+ {"PEEK", TOKENIZER_PEEK},
+ {"POKE", TOKENIZER_POKE},
+ {"END", TOKENIZER_END},
+ {"NEW", TOKENIZER_NEW},
+ {"RUN", TOKENIZER_RUN},
+ {"LIST", TOKENIZER_LIST},
+ {"FRE", TOKENIZER_FRE},
+ {NULL, TOKENIZER_ERROR},
+};
+
+static int singlechar(void)
+{
+ switch (*ptr)
+ {
+ case '\n':
+ return TOKENIZER_CR;
+ case ',':
+ return TOKENIZER_COMMA;
+ case ';':
+ return TOKENIZER_SEMICOLON;
+ case '+':
+ return TOKENIZER_PLUS;
+ case '-':
+ return TOKENIZER_MINUS;
+ case '&':
+ return TOKENIZER_AND;
+ case '|':
+ return TOKENIZER_OR;
+ case '*':
+ return TOKENIZER_ASTR;
+ case '/':
+ return TOKENIZER_SLASH;
+ case '%':
+ return TOKENIZER_MOD;
+ case '(':
+ return TOKENIZER_LEFTPAREN;
+ case ')':
+ return TOKENIZER_RIGHTPAREN;
+ case '<':
+ return TOKENIZER_LT;
+ case '>':
+ return TOKENIZER_GT;
+ case '=':
+ return TOKENIZER_EQ;
+ }
+
+ return 0;
+}
+
+static int get_next_token(void)
+{
+ struct keyword_token const *kt;
+ int i = 0;
+
+ if (*ptr == 0)
+ {
+ return TOKENIZER_ENDOFINPUT;
+ }
+
+ if (isdigit(ptr[i++]))
+ {
+ for (; i < UBASIC_MAX_NUMLEN; ++i)
+ {
+ if (!isdigit(ptr[i]))
+ {
+ nextptr = ptr + i;
+ return TOKENIZER_NUMBER;
+ }
+ }
+
+ // Number is too long
+ return TOKENIZER_ERROR;
+ }
+
+ if (singlechar())
+ {
+ nextptr = ptr + 1;
+ return singlechar();
+ }
+
+ if (*ptr == '"')
+ {
+ nextptr = ptr;
+ do
+ {
+ ++nextptr;
+ } while (*nextptr != '"');
+
+ ++nextptr;
+ return TOKENIZER_STRING;
+ }
+
+ for (kt = keywords; kt->keyword != NULL; ++kt)
+ {
+ if (strncmp(ptr, kt->keyword, strlen(kt->keyword)) == 0)
+ {
+ nextptr = ptr + strlen(kt->keyword);
+ return kt->token;
+ }
+ }
+
+ if (*ptr >= 'A' && *ptr <= 'Z')
+ {
+ nextptr = ptr + 1;
+ return TOKENIZER_VARIABLE;
+ }
+
+ return TOKENIZER_ERROR;
+}
+
+void tokenizer_goto(const char *program)
+{
+ ptr = program;
+ current_token = get_next_token();
+}
+
+void tokenizer_init(const char *program)
+{
+ tokenizer_goto(program);
+ current_token = get_next_token();
+}
+
+int tokenizer_token(void)
+{
+ return current_token;
+}
+
+void tokenizer_next(void)
+{
+
+ if (tokenizer_finished())
+ {
+ return;
+ }
+
+ ptr = nextptr;
+
+ while (*ptr == ' ')
+ {
+ ++ptr;
+ }
+
+ current_token = get_next_token();
+
+ if (current_token == TOKENIZER_REM)
+ {
+ while (!(*nextptr == '\n' || tokenizer_finished()))
+ {
+ ++nextptr;
+ }
+
+ if (*nextptr == '\n')
+ {
+ ++nextptr;
+ }
+ tokenizer_next();
+ }
+}
+
+VariableType_t tokenizer_num(void)
+{
+ return atoi(ptr);
+}
+
+int tokenizer_string(char *dest, int len)
+{
+ char *string_end;
+ int string_len;
+
+ string_end = strchr(ptr + 1, '"');
+
+ if (string_end == NULL)
+ {
+ return 0;
+ }
+
+ string_len = string_end - ptr - 1;
+
+ if (len < string_len)
+ {
+ string_len = len;
+ }
+
+ memcpy(dest, ptr + 1, string_len);
+
+ dest[string_len] = '\0';
+
+ return string_len;
+}
+
+void tokenizer_error_print(void)
+{
+ // DEBUG_PRINTF("tokenizer_error_print: '%s'\n", ptr);
+}
+
+int tokenizer_finished(void)
+{
+ return *ptr == 0 || current_token == TOKENIZER_ENDOFINPUT;
+}
+
+int tokenizer_variable_num(void)
+{
+ return *ptr - 'A';
+}
+
+char const *tokenizer_pos(void)
+{
+ return ptr;
+}
diff --git a/tokenizer.h b/tokenizer.h
new file mode 100644
index 0000000..902b89c
--- /dev/null
+++ b/tokenizer.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2006, Adam Dunkels
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the author nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#ifndef __TOKENIZER_H__
+#define __TOKENIZER_H__
+
+#include "vartype.h"
+
+enum
+{
+ TOKENIZER_ERROR,
+ TOKENIZER_ENDOFINPUT,
+ TOKENIZER_NUMBER,
+ TOKENIZER_STRING,
+ TOKENIZER_VARIABLE,
+ TOKENIZER_LET,
+ TOKENIZER_PRINT,
+ TOKENIZER_IF,
+ TOKENIZER_THEN,
+ TOKENIZER_FOR,
+ TOKENIZER_TO,
+ TOKENIZER_NEXT,
+ TOKENIZER_GOTO,
+ TOKENIZER_GOSUB,
+ TOKENIZER_RETURN,
+ TOKENIZER_REM,
+ TOKENIZER_PEEK,
+ TOKENIZER_POKE,
+ TOKENIZER_END,
+ TOKENIZER_NEW,
+ TOKENIZER_RUN,
+ TOKENIZER_LIST,
+ TOKENIZER_INPUT,
+ TOKENIZER_FRE,
+ TOKENIZER_COMMA,
+ TOKENIZER_SEMICOLON,
+ TOKENIZER_PLUS,
+ TOKENIZER_MINUS,
+ TOKENIZER_AND,
+ TOKENIZER_OR,
+ TOKENIZER_ASTR,
+ TOKENIZER_SLASH,
+ TOKENIZER_MOD,
+ TOKENIZER_LEFTPAREN,
+ TOKENIZER_RIGHTPAREN,
+ TOKENIZER_LT,
+ TOKENIZER_GT,
+ TOKENIZER_EQ,
+ TOKENIZER_CR,
+};
+
+void tokenizer_goto(const char *program);
+void tokenizer_init(const char *program);
+void tokenizer_next(void);
+int tokenizer_token(void);
+VariableType_t tokenizer_num(void);
+VariableType_t tokenizer_variable_num(void);
+int tokenizer_string(char *dest, int len);
+
+int tokenizer_finished(void);
+void tokenizer_error_print(void);
+
+char const *tokenizer_pos(void);
+
+#endif /* __TOKENIZER_H__ */
diff --git a/ubasic.c b/ubasic.c
new file mode 100644
index 0000000..b6675bc
--- /dev/null
+++ b/ubasic.c
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2006, Adam Dunkels
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the author nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#include "ubasic.h"
+#include "interperter.h"
+#include "utility.h"
+#include
+#include
+#include
+
+VariableType_t peek(VariableType_t addr);
+void poke(VariableType_t addr, VariableType_t val);
+
+static char input_buff[UBASIC_PROGRAM_LINE_WIDTH];
+static int char_count;
+
+extern char _text_end;
+#define FORBIDDEN_MEM_AREA (uintptr_t)(&_text_end)
+
+void ubasic_init(void)
+{
+ interperter_init(peek, poke);
+ memset(input_buff, 0, sizeof(input_buff));
+ char_count = 0;
+ dma_nwrite(UBASIC_STARTUP_MESSAGE, sizeof(UBASIC_STARTUP_MESSAGE));
+}
+
+void ubasic_run(void)
+{
+ char key = toupper(read_key());
+ put_char(key);
+
+ if (key == 12)
+ {
+ return;
+ }
+
+ if (key == 8 && char_count > 0)
+ {
+ input_buff[--char_count] = '\0';
+ return;
+ }
+
+ if (char_count < UBASIC_PROGRAM_LINE_WIDTH)
+ {
+ input_buff[char_count++] = key;
+ }
+
+ if (key == 10)
+ {
+ int linenum = interperter_get_line_num(input_buff);
+
+ if (linenum == -1)
+ {
+ interperter_reset();
+ interperter_execute();
+ dma_write("READY.\n");
+ }
+ else if (interperter_indexed_line_empty())
+ {
+ interperter_remove_line(linenum);
+ }
+ else
+ {
+ interperter_add_line(linenum, input_buff, char_count);
+ }
+
+ char_count = 0;
+ }
+}
+
+VariableType_t peek(VariableType_t addr)
+{
+ return *(volatile VariableType_t *)(addr);
+}
+
+void poke(VariableType_t addr, VariableType_t val)
+{
+ if (addr <= FORBIDDEN_MEM_AREA)
+ {
+ return;
+ }
+
+ *(volatile VariableType_t *)(addr) = val;
+}
\ No newline at end of file
diff --git a/ubasic.h b/ubasic.h
new file mode 100644
index 0000000..10915d2
--- /dev/null
+++ b/ubasic.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2006, Adam Dunkels
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the author nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#ifndef __UBASIC_H__
+#define __UBASIC_H__
+
+#include "vartype.h"
+
+void ubasic_init(void);
+void ubasic_run(void);
+
+#endif /* __UBASIC_H__ */
diff --git a/ubasic_config.h b/ubasic_config.h
new file mode 100644
index 0000000..2e0f8c4
--- /dev/null
+++ b/ubasic_config.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2006, Adam Dunkels
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the author nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#ifndef UBASIC_CFG_H
+#define UBASIC_CFG_H
+
+#include "vartype.h"
+
+#define UBASIC_MAX_STRINGLEN 40 // Maximum number of character per string variable
+#define UBASIC_MAX_NUMLEN 6 // Maximum number of digits for integer variables
+#define UBASIC_MAX_GOSUB_STACK_DEPTH 10 // Maximum number of subroutine/function calls
+#define UBASIC_MAX_FOR_STACK_DEPTH 4 // Maximum number of nested for
+#define UBASIC_FREE_BYTES 2560 // uBASIC program memory size
+#define UBASIC_PROGRAM_LINE_WIDTH 40 // Maximum number of character per program line
+
+// PLEASE DO NOT EDIT!
+#define UBASIC_MAX_PROGRAM_LINES (UBASIC_FREE_BYTES / UBASIC_PROGRAM_LINE_WIDTH)
+
+#endif
diff --git a/ubasic_version.h b/ubasic_version.h
new file mode 100644
index 0000000..212a95d
--- /dev/null
+++ b/ubasic_version.h
@@ -0,0 +1,15 @@
+#ifndef UBASIC_VERSION_H
+#define UBASIC_VERSION_H
+
+#include "ubasic_config.h"
+
+#define UBASIC_VERSION "1.0"
+
+
+#define STR(s) #s
+#define STRINGIFY(s) STR(s)
+
+#define UBASIC_STARTUP_MESSAGE "VEECOM uBASIC "UBASIC_VERSION"\n"\
+STRINGIFY(UBASIC_FREE_BYTES)" uBASIC BYTES FREE\nREADY.\n"
+
+#endif
\ No newline at end of file
diff --git a/util/iom.h b/util/iom.h
new file mode 100644
index 0000000..bce981e
--- /dev/null
+++ b/util/iom.h
@@ -0,0 +1,22 @@
+// Veecom I/O Map
+
+#ifndef IOM_H
+#define IOM_H
+
+#include
+
+#define DAL *(volatile uint8_t*)(0xfff4) // DMA Block Address Lo (W)
+#define DAH *(volatile uint8_t*)(0xfff5) // DMA Block Address Hi (W)
+#define DSL *(volatile uint8_t*)(0xfff6) // DMA Block Size Lo (W)
+#define DSH *(volatile uint8_t*)(0xfff7) // DMA Block Size Hi (W)
+#define PAO *(volatile uint8_t*)(0xfff8) // Port A Output (R/W)
+#define PAI *(volatile uint8_t*)(0xfff9) // Port A Input (R)
+#define PBO *(volatile uint8_t*)(0xfffa) // Port B Output (R/W)
+#define PBI *(volatile uint8_t*)(0xfffb) // Port B Input (R)
+#define PCO *(volatile uint8_t*)(0xfffc) // Port C Output (R/W)
+#define PCI *(volatile uint8_t*)(0xfffd) // Port C Input (R)
+#define TVR *(volatile uint8_t*)(0xfffe) // Timer Value (R/W)
+#define TCR *(volatile uint8_t*)(0xffff) // Timer Control (W)
+#define TXP *(volatile uint8_t*)(0xffff) // Timer Expired Flag (R)
+
+#endif
diff --git a/util/printf.c b/util/printf.c
new file mode 100644
index 0000000..d34279a
--- /dev/null
+++ b/util/printf.c
@@ -0,0 +1,914 @@
+///////////////////////////////////////////////////////////////////////////////
+// \author (c) Marco Paland (info@paland.com)
+// 2014-2019, PALANDesign Hannover, Germany
+//
+// \license The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// \brief Tiny printf, sprintf and (v)snprintf implementation, optimized for speed on
+// embedded systems with a very limited resources. These routines are thread
+// safe and reentrant!
+// Use this instead of the bloated standard/newlib printf cause these use
+// malloc for printf (and may not be thread safe).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include
+#include
+
+#include "printf.h"
+
+
+// define this globally (e.g. gcc -DPRINTF_INCLUDE_CONFIG_H ...) to include the
+// printf_config.h header file
+// default: undefined
+#ifdef PRINTF_INCLUDE_CONFIG_H
+#include "printf_config.h"
+#endif
+
+
+// 'ntoa' conversion buffer size, this must be big enough to hold one converted
+// numeric number including padded zeros (dynamically created on stack)
+// default: 32 byte
+#ifndef PRINTF_NTOA_BUFFER_SIZE
+#define PRINTF_NTOA_BUFFER_SIZE 32U
+#endif
+
+// 'ftoa' conversion buffer size, this must be big enough to hold one converted
+// float number including padded zeros (dynamically created on stack)
+// default: 32 byte
+#ifndef PRINTF_FTOA_BUFFER_SIZE
+#define PRINTF_FTOA_BUFFER_SIZE 32U
+#endif
+
+// support for the floating point type (%f)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_FLOAT
+#define PRINTF_SUPPORT_FLOAT
+#endif
+
+// support for exponential floating point notation (%e/%g)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_EXPONENTIAL
+#define PRINTF_SUPPORT_EXPONENTIAL
+#endif
+
+// define the default floating point precision
+// default: 6 digits
+#ifndef PRINTF_DEFAULT_FLOAT_PRECISION
+#define PRINTF_DEFAULT_FLOAT_PRECISION 6U
+#endif
+
+// define the largest float suitable to print with %f
+// default: 1e9
+#ifndef PRINTF_MAX_FLOAT
+#define PRINTF_MAX_FLOAT 1e9
+#endif
+
+// support for the long long types (%llu or %p)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_LONG_LONG
+#define PRINTF_SUPPORT_LONG_LONG
+#endif
+
+// support for the ptrdiff_t type (%t)
+// ptrdiff_t is normally defined in as long or long long type
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_PTRDIFF_T
+#define PRINTF_SUPPORT_PTRDIFF_T
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+// internal flag definitions
+#define FLAGS_ZEROPAD (1U << 0U)
+#define FLAGS_LEFT (1U << 1U)
+#define FLAGS_PLUS (1U << 2U)
+#define FLAGS_SPACE (1U << 3U)
+#define FLAGS_HASH (1U << 4U)
+#define FLAGS_UPPERCASE (1U << 5U)
+#define FLAGS_CHAR (1U << 6U)
+#define FLAGS_SHORT (1U << 7U)
+#define FLAGS_LONG (1U << 8U)
+#define FLAGS_LONG_LONG (1U << 9U)
+#define FLAGS_PRECISION (1U << 10U)
+#define FLAGS_ADAPT_EXP (1U << 11U)
+
+
+// import float.h for DBL_MAX
+#if defined(PRINTF_SUPPORT_FLOAT)
+#include
+#endif
+
+
+// output function type
+typedef void (*out_fct_type)(char character, void* buffer, size_t idx, size_t maxlen);
+
+
+// wrapper (used as buffer) for output function type
+typedef struct {
+ void (*fct)(char character, void* arg);
+ void* arg;
+} out_fct_wrap_type;
+
+
+// internal buffer output
+static inline void _out_buffer(char character, void* buffer, size_t idx, size_t maxlen)
+{
+ if (idx < maxlen) {
+ ((char*)buffer)[idx] = character;
+ }
+}
+
+
+// internal null output
+static inline void _out_null(char character, void* buffer, size_t idx, size_t maxlen)
+{
+ (void)character; (void)buffer; (void)idx; (void)maxlen;
+}
+
+
+// internal _putchar wrapper
+static inline void _out_char(char character, void* buffer, size_t idx, size_t maxlen)
+{
+ (void)buffer; (void)idx; (void)maxlen;
+ if (character) {
+ _putchar(character);
+ }
+}
+
+
+// internal output function wrapper
+static inline void _out_fct(char character, void* buffer, size_t idx, size_t maxlen)
+{
+ (void)idx; (void)maxlen;
+ if (character) {
+ // buffer is the output fct pointer
+ ((out_fct_wrap_type*)buffer)->fct(character, ((out_fct_wrap_type*)buffer)->arg);
+ }
+}
+
+
+// internal secure strlen
+// \return The length of the string (excluding the terminating 0) limited by 'maxsize'
+static inline unsigned int _strnlen_s(const char* str, size_t maxsize)
+{
+ const char* s;
+ for (s = str; *s && maxsize--; ++s);
+ return (unsigned int)(s - str);
+}
+
+
+// internal test if char is a digit (0-9)
+// \return true if char is a digit
+static inline bool _is_digit(char ch)
+{
+ return (ch >= '0') && (ch <= '9');
+}
+
+
+// internal ASCII string to unsigned int conversion
+static unsigned int _atoi(const char** str)
+{
+ unsigned int i = 0U;
+ while (_is_digit(**str)) {
+ i = i * 10U + (unsigned int)(*((*str)++) - '0');
+ }
+ return i;
+}
+
+
+// output the specified string in reverse, taking care of any zero-padding
+static size_t _out_rev(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags)
+{
+ const size_t start_idx = idx;
+
+ // pad spaces up to given width
+ if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
+ for (size_t i = len; i < width; i++) {
+ out(' ', buffer, idx++, maxlen);
+ }
+ }
+
+ // reverse string
+ while (len) {
+ out(buf[--len], buffer, idx++, maxlen);
+ }
+
+ // append pad spaces up to given width
+ if (flags & FLAGS_LEFT) {
+ while (idx - start_idx < width) {
+ out(' ', buffer, idx++, maxlen);
+ }
+ }
+
+ return idx;
+}
+
+
+// internal itoa format
+static size_t _ntoa_format(out_fct_type out, char* buffer, size_t idx, size_t maxlen, char* buf, size_t len, bool negative, unsigned int base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+ // pad leading zeros
+ if (!(flags & FLAGS_LEFT)) {
+ if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
+ width--;
+ }
+ while ((len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+ buf[len++] = '0';
+ }
+ while ((flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+ buf[len++] = '0';
+ }
+ }
+
+ // handle hash
+ if (flags & FLAGS_HASH) {
+ if (!(flags & FLAGS_PRECISION) && len && ((len == prec) || (len == width))) {
+ len--;
+ if (len && (base == 16U)) {
+ len--;
+ }
+ }
+ if ((base == 16U) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+ buf[len++] = 'x';
+ }
+ else if ((base == 16U) && (flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+ buf[len++] = 'X';
+ }
+ else if ((base == 2U) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+ buf[len++] = 'b';
+ }
+ if (len < PRINTF_NTOA_BUFFER_SIZE) {
+ buf[len++] = '0';
+ }
+ }
+
+ if (len < PRINTF_NTOA_BUFFER_SIZE) {
+ if (negative) {
+ buf[len++] = '-';
+ }
+ else if (flags & FLAGS_PLUS) {
+ buf[len++] = '+'; // ignore the space if the '+' exists
+ }
+ else if (flags & FLAGS_SPACE) {
+ buf[len++] = ' ';
+ }
+ }
+
+ return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+
+// internal itoa for 'long' type
+static size_t _ntoa_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long value, bool negative, unsigned long base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+ char buf[PRINTF_NTOA_BUFFER_SIZE];
+ size_t len = 0U;
+
+ // no hash for 0 values
+ if (!value) {
+ flags &= ~FLAGS_HASH;
+ }
+
+ // write if precision != 0 and value is != 0
+ if (!(flags & FLAGS_PRECISION) || value) {
+ do {
+ const char digit = (char)(value % base);
+ buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
+ value /= base;
+ } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
+ }
+
+ return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
+}
+
+
+// internal itoa for 'long long' type
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+static size_t _ntoa_long_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long long value, bool negative, unsigned long long base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+ char buf[PRINTF_NTOA_BUFFER_SIZE];
+ size_t len = 0U;
+
+ // no hash for 0 values
+ if (!value) {
+ flags &= ~FLAGS_HASH;
+ }
+
+ // write if precision != 0 and value is != 0
+ if (!(flags & FLAGS_PRECISION) || value) {
+ do {
+ const char digit = (char)(value % base);
+ buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
+ value /= base;
+ } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
+ }
+
+ return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
+}
+#endif // PRINTF_SUPPORT_LONG_LONG
+
+
+#if defined(PRINTF_SUPPORT_FLOAT)
+
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+// forward declaration so that _ftoa can switch to exp notation for values > PRINTF_MAX_FLOAT
+static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags);
+#endif
+
+
+// internal ftoa for fixed decimal floating point
+static size_t _ftoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
+{
+ char buf[PRINTF_FTOA_BUFFER_SIZE];
+ size_t len = 0U;
+ double diff = 0.0;
+
+ // powers of 10
+ static const double pow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
+
+ // test for special values
+ if (value != value)
+ return _out_rev(out, buffer, idx, maxlen, "nan", 3, width, flags);
+ if (value < -DBL_MAX)
+ return _out_rev(out, buffer, idx, maxlen, "fni-", 4, width, flags);
+ if (value > DBL_MAX)
+ return _out_rev(out, buffer, idx, maxlen, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width, flags);
+
+ // test for very large values
+ // standard printf behavior is to print EVERY whole number digit -- which could be 100s of characters overflowing your buffers == bad
+ if ((value > PRINTF_MAX_FLOAT) || (value < -PRINTF_MAX_FLOAT)) {
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+ return _etoa(out, buffer, idx, maxlen, value, prec, width, flags);
+#else
+ return 0U;
+#endif
+ }
+
+ // test for negative
+ bool negative = false;
+ if (value < 0) {
+ negative = true;
+ value = 0 - value;
+ }
+
+ // set default precision, if not set explicitly
+ if (!(flags & FLAGS_PRECISION)) {
+ prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+ }
+ // limit precision to 9, cause a prec >= 10 can lead to overflow errors
+ while ((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U)) {
+ buf[len++] = '0';
+ prec--;
+ }
+
+ int whole = (int)value;
+ double tmp = (value - whole) * pow10[prec];
+ unsigned long frac = (unsigned long)tmp;
+ diff = tmp - frac;
+
+ if (diff > 0.5) {
+ ++frac;
+ // handle rollover, e.g. case 0.99 with prec 1 is 1.0
+ if (frac >= pow10[prec]) {
+ frac = 0;
+ ++whole;
+ }
+ }
+ else if (diff < 0.5) {
+ }
+ else if ((frac == 0U) || (frac & 1U)) {
+ // if halfway, round up if odd OR if last digit is 0
+ ++frac;
+ }
+
+ if (prec == 0U) {
+ diff = value - (double)whole;
+ if ((!(diff < 0.5) || (diff > 0.5)) && (whole & 1)) {
+ // exactly 0.5 and ODD, then round up
+ // 1.5 -> 2, but 2.5 -> 2
+ ++whole;
+ }
+ }
+ else {
+ unsigned int count = prec;
+ // now do fractional part, as an unsigned number
+ while (len < PRINTF_FTOA_BUFFER_SIZE) {
+ --count;
+ buf[len++] = (char)(48U + (frac % 10U));
+ if (!(frac /= 10U)) {
+ break;
+ }
+ }
+ // add extra 0s
+ while ((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U)) {
+ buf[len++] = '0';
+ }
+ if (len < PRINTF_FTOA_BUFFER_SIZE) {
+ // add decimal
+ buf[len++] = '.';
+ }
+ }
+
+ // do whole part, number is reversed
+ while (len < PRINTF_FTOA_BUFFER_SIZE) {
+ buf[len++] = (char)(48 + (whole % 10));
+ if (!(whole /= 10)) {
+ break;
+ }
+ }
+
+ // pad leading zeros
+ if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) {
+ if (width && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
+ width--;
+ }
+ while ((len < width) && (len < PRINTF_FTOA_BUFFER_SIZE)) {
+ buf[len++] = '0';
+ }
+ }
+
+ if (len < PRINTF_FTOA_BUFFER_SIZE) {
+ if (negative) {
+ buf[len++] = '-';
+ }
+ else if (flags & FLAGS_PLUS) {
+ buf[len++] = '+'; // ignore the space if the '+' exists
+ }
+ else if (flags & FLAGS_SPACE) {
+ buf[len++] = ' ';
+ }
+ }
+
+ return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+// internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse
+static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
+{
+ // check for NaN and special values
+ if ((value != value) || (value > DBL_MAX) || (value < -DBL_MAX)) {
+ return _ftoa(out, buffer, idx, maxlen, value, prec, width, flags);
+ }
+
+ // determine the sign
+ const bool negative = value < 0;
+ if (negative) {
+ value = -value;
+ }
+
+ // default precision
+ if (!(flags & FLAGS_PRECISION)) {
+ prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+ }
+
+ // determine the decimal exponent
+ // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c)
+ union {
+ uint64_t U;
+ double F;
+ } conv;
+
+ conv.F = value;
+ int exp2 = (int)((conv.U >> 52U) & 0x07FFU) - 1023; // effectively log2
+ conv.U = (conv.U & ((1ULL << 52U) - 1U)) | (1023ULL << 52U); // drop the exponent so conv.F is now in [1,2)
+ // now approximate log10 from the log2 integer part and an expansion of ln around 1.5
+ int expval = (int)(0.1760912590558 + exp2 * 0.301029995663981 + (conv.F - 1.5) * 0.289529654602168);
+ // now we want to compute 10^expval but we want to be sure it won't overflow
+ exp2 = (int)(expval * 3.321928094887362 + 0.5);
+ const double z = expval * 2.302585092994046 - exp2 * 0.6931471805599453;
+ const double z2 = z * z;
+ conv.U = (uint64_t)(exp2 + 1023) << 52U;
+ // compute exp(z) using continued fractions, see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex
+ conv.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14)))));
+ // correct for rounding errors
+ if (value < conv.F) {
+ expval--;
+ conv.F /= 10;
+ }
+
+ // the exponent format is "%+03d" and largest value is "307", so set aside 4-5 characters
+ unsigned int minwidth = ((expval < 100) && (expval > -100)) ? 4U : 5U;
+
+ // in "%g" mode, "prec" is the number of *significant figures* not decimals
+ if (flags & FLAGS_ADAPT_EXP) {
+ // do we want to fall-back to "%f" mode?
+ if ((value >= 1e-4) && (value < 1e6)) {
+ if ((int)prec > expval) {
+ prec = (unsigned)((int)prec - expval - 1);
+ }
+ else {
+ prec = 0;
+ }
+ flags |= FLAGS_PRECISION; // make sure _ftoa respects precision
+ // no characters in exponent
+ minwidth = 0U;
+ expval = 0;
+ }
+ else {
+ // we use one sigfig for the whole part
+ if ((prec > 0) && (flags & FLAGS_PRECISION)) {
+ --prec;
+ }
+ }
+ }
+
+ // will everything fit?
+ unsigned int fwidth = width;
+ if (width > minwidth) {
+ // we didn't fall-back so subtract the characters required for the exponent
+ fwidth -= minwidth;
+ } else {
+ // not enough characters, so go back to default sizing
+ fwidth = 0U;
+ }
+ if ((flags & FLAGS_LEFT) && minwidth) {
+ // if we're padding on the right, DON'T pad the floating part
+ fwidth = 0U;
+ }
+
+ // rescale the float value
+ if (expval) {
+ value /= conv.F;
+ }
+
+ // output the floating part
+ const size_t start_idx = idx;
+ idx = _ftoa(out, buffer, idx, maxlen, negative ? -value : value, prec, fwidth, flags & ~FLAGS_ADAPT_EXP);
+
+ // output the exponent part
+ if (minwidth) {
+ // output the exponential symbol
+ out((flags & FLAGS_UPPERCASE) ? 'E' : 'e', buffer, idx++, maxlen);
+ // output the exponent value
+ idx = _ntoa_long(out, buffer, idx, maxlen, (expval < 0) ? -expval : expval, expval < 0, 10, 0, minwidth-1, FLAGS_ZEROPAD | FLAGS_PLUS);
+ // might need to right-pad spaces
+ if (flags & FLAGS_LEFT) {
+ while (idx - start_idx < width) out(' ', buffer, idx++, maxlen);
+ }
+ }
+ return idx;
+}
+#endif // PRINTF_SUPPORT_EXPONENTIAL
+#endif // PRINTF_SUPPORT_FLOAT
+
+
+// internal vsnprintf
+static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const char* format, va_list va)
+{
+ unsigned int flags, width, precision, n;
+ size_t idx = 0U;
+
+ if (!buffer) {
+ // use null output function
+ out = _out_null;
+ }
+
+ while (*format)
+ {
+ // format specifier? %[flags][width][.precision][length]
+ if (*format != '%') {
+ // no
+ out(*format, buffer, idx++, maxlen);
+ format++;
+ continue;
+ }
+ else {
+ // yes, evaluate it
+ format++;
+ }
+
+ // evaluate flags
+ flags = 0U;
+ do {
+ switch (*format) {
+ case '0': flags |= FLAGS_ZEROPAD; format++; n = 1U; break;
+ case '-': flags |= FLAGS_LEFT; format++; n = 1U; break;
+ case '+': flags |= FLAGS_PLUS; format++; n = 1U; break;
+ case ' ': flags |= FLAGS_SPACE; format++; n = 1U; break;
+ case '#': flags |= FLAGS_HASH; format++; n = 1U; break;
+ default : n = 0U; break;
+ }
+ } while (n);
+
+ // evaluate width field
+ width = 0U;
+ if (_is_digit(*format)) {
+ width = _atoi(&format);
+ }
+ else if (*format == '*') {
+ const int w = va_arg(va, int);
+ if (w < 0) {
+ flags |= FLAGS_LEFT; // reverse padding
+ width = (unsigned int)-w;
+ }
+ else {
+ width = (unsigned int)w;
+ }
+ format++;
+ }
+
+ // evaluate precision field
+ precision = 0U;
+ if (*format == '.') {
+ flags |= FLAGS_PRECISION;
+ format++;
+ if (_is_digit(*format)) {
+ precision = _atoi(&format);
+ }
+ else if (*format == '*') {
+ const int prec = (int)va_arg(va, int);
+ precision = prec > 0 ? (unsigned int)prec : 0U;
+ format++;
+ }
+ }
+
+ // evaluate length field
+ switch (*format) {
+ case 'l' :
+ flags |= FLAGS_LONG;
+ format++;
+ if (*format == 'l') {
+ flags |= FLAGS_LONG_LONG;
+ format++;
+ }
+ break;
+ case 'h' :
+ flags |= FLAGS_SHORT;
+ format++;
+ if (*format == 'h') {
+ flags |= FLAGS_CHAR;
+ format++;
+ }
+ break;
+#if defined(PRINTF_SUPPORT_PTRDIFF_T)
+ case 't' :
+ flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+ format++;
+ break;
+#endif
+ case 'j' :
+ flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+ format++;
+ break;
+ case 'z' :
+ flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+ format++;
+ break;
+ default :
+ break;
+ }
+
+ // evaluate specifier
+ switch (*format) {
+ case 'd' :
+ case 'i' :
+ case 'u' :
+ case 'x' :
+ case 'X' :
+ case 'o' :
+ case 'b' : {
+ // set the base
+ unsigned int base;
+ if (*format == 'x' || *format == 'X') {
+ base = 16U;
+ }
+ else if (*format == 'o') {
+ base = 8U;
+ }
+ else if (*format == 'b') {
+ base = 2U;
+ }
+ else {
+ base = 10U;
+ flags &= ~FLAGS_HASH; // no hash for dec format
+ }
+ // uppercase
+ if (*format == 'X') {
+ flags |= FLAGS_UPPERCASE;
+ }
+
+ // no plus or space flag for u, x, X, o, b
+ if ((*format != 'i') && (*format != 'd')) {
+ flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
+ }
+
+ // ignore '0' flag when precision is given
+ if (flags & FLAGS_PRECISION) {
+ flags &= ~FLAGS_ZEROPAD;
+ }
+
+ // convert the integer
+ if ((*format == 'i') || (*format == 'd')) {
+ // signed
+ if (flags & FLAGS_LONG_LONG) {
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+ const long long value = va_arg(va, long long);
+ idx = _ntoa_long_long(out, buffer, idx, maxlen, (unsigned long long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
+#endif
+ }
+ else if (flags & FLAGS_LONG) {
+ const long value = va_arg(va, long);
+ idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
+ }
+ else {
+ const int value = (flags & FLAGS_CHAR) ? (char)va_arg(va, int) : (flags & FLAGS_SHORT) ? (short int)va_arg(va, int) : va_arg(va, int);
+ idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned int)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
+ }
+ }
+ else {
+ // unsigned
+ if (flags & FLAGS_LONG_LONG) {
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+ idx = _ntoa_long_long(out, buffer, idx, maxlen, va_arg(va, unsigned long long), false, base, precision, width, flags);
+#endif
+ }
+ else if (flags & FLAGS_LONG) {
+ idx = _ntoa_long(out, buffer, idx, maxlen, va_arg(va, unsigned long), false, base, precision, width, flags);
+ }
+ else {
+ const unsigned int value = (flags & FLAGS_CHAR) ? (unsigned char)va_arg(va, unsigned int) : (flags & FLAGS_SHORT) ? (unsigned short int)va_arg(va, unsigned int) : va_arg(va, unsigned int);
+ idx = _ntoa_long(out, buffer, idx, maxlen, value, false, base, precision, width, flags);
+ }
+ }
+ format++;
+ break;
+ }
+#if defined(PRINTF_SUPPORT_FLOAT)
+ case 'f' :
+ case 'F' :
+ if (*format == 'F') flags |= FLAGS_UPPERCASE;
+ idx = _ftoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
+ format++;
+ break;
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+ case 'e':
+ case 'E':
+ case 'g':
+ case 'G':
+ if ((*format == 'g')||(*format == 'G')) flags |= FLAGS_ADAPT_EXP;
+ if ((*format == 'E')||(*format == 'G')) flags |= FLAGS_UPPERCASE;
+ idx = _etoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
+ format++;
+ break;
+#endif // PRINTF_SUPPORT_EXPONENTIAL
+#endif // PRINTF_SUPPORT_FLOAT
+ case 'c' : {
+ unsigned int l = 1U;
+ // pre padding
+ if (!(flags & FLAGS_LEFT)) {
+ while (l++ < width) {
+ out(' ', buffer, idx++, maxlen);
+ }
+ }
+ // char output
+ out((char)va_arg(va, int), buffer, idx++, maxlen);
+ // post padding
+ if (flags & FLAGS_LEFT) {
+ while (l++ < width) {
+ out(' ', buffer, idx++, maxlen);
+ }
+ }
+ format++;
+ break;
+ }
+
+ case 's' : {
+ const char* p = va_arg(va, char*);
+ unsigned int l = _strnlen_s(p, precision ? precision : (size_t)-1);
+ // pre padding
+ if (flags & FLAGS_PRECISION) {
+ l = (l < precision ? l : precision);
+ }
+ if (!(flags & FLAGS_LEFT)) {
+ while (l++ < width) {
+ out(' ', buffer, idx++, maxlen);
+ }
+ }
+ // string output
+ while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) {
+ out(*(p++), buffer, idx++, maxlen);
+ }
+ // post padding
+ if (flags & FLAGS_LEFT) {
+ while (l++ < width) {
+ out(' ', buffer, idx++, maxlen);
+ }
+ }
+ format++;
+ break;
+ }
+
+ case 'p' : {
+ width = sizeof(void*) * 2U;
+ flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE;
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+ const bool is_ll = sizeof(uintptr_t) == sizeof(long long);
+ if (is_ll) {
+ idx = _ntoa_long_long(out, buffer, idx, maxlen, (uintptr_t)va_arg(va, void*), false, 16U, precision, width, flags);
+ }
+ else {
+#endif
+ idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)((uintptr_t)va_arg(va, void*)), false, 16U, precision, width, flags);
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+ }
+#endif
+ format++;
+ break;
+ }
+
+ case '%' :
+ out('%', buffer, idx++, maxlen);
+ format++;
+ break;
+
+ default :
+ out(*format, buffer, idx++, maxlen);
+ format++;
+ break;
+ }
+ }
+
+ // termination
+ out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
+
+ // return written chars without terminating \0
+ return (int)idx;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+int printf_(const char* format, ...)
+{
+ va_list va;
+ va_start(va, format);
+ char buffer[1];
+ const int ret = _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
+ va_end(va);
+ return ret;
+}
+
+
+int sprintf_(char* buffer, const char* format, ...)
+{
+ va_list va;
+ va_start(va, format);
+ const int ret = _vsnprintf(_out_buffer, buffer, (size_t)-1, format, va);
+ va_end(va);
+ return ret;
+}
+
+
+int snprintf_(char* buffer, size_t count, const char* format, ...)
+{
+ va_list va;
+ va_start(va, format);
+ const int ret = _vsnprintf(_out_buffer, buffer, count, format, va);
+ va_end(va);
+ return ret;
+}
+
+
+int vprintf_(const char* format, va_list va)
+{
+ char buffer[1];
+ return _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
+}
+
+
+int vsnprintf_(char* buffer, size_t count, const char* format, va_list va)
+{
+ return _vsnprintf(_out_buffer, buffer, count, format, va);
+}
+
+
+int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...)
+{
+ va_list va;
+ va_start(va, format);
+ const out_fct_wrap_type out_fct_wrap = { out, arg };
+ const int ret = _vsnprintf(_out_fct, (char*)(uintptr_t)&out_fct_wrap, (size_t)-1, format, va);
+ va_end(va);
+ return ret;
+}
\ No newline at end of file
diff --git a/util/printf.h b/util/printf.h
new file mode 100644
index 0000000..3856ae5
--- /dev/null
+++ b/util/printf.h
@@ -0,0 +1,116 @@
+///////////////////////////////////////////////////////////////////////////////
+// \author (c) Marco Paland (info@paland.com)
+// 2014-2019, PALANDesign Hannover, Germany
+//
+// \license The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// \brief Tiny printf, sprintf and snprintf implementation, optimized for speed on
+// embedded systems with a very limited resources.
+// Use this instead of bloated standard/newlib printf.
+// These routines are thread safe and reentrant.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _PRINTF_H_
+#define _PRINTF_H_
+
+#include
+#include
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * Output a character to a custom device like UART, used by the printf() function
+ * This function is declared here only. You have to write your custom implementation somewhere
+ * \param character Character to output
+ */
+void _putchar(char character);
+
+/**
+ * Tiny printf implementation
+ * You have to implement _putchar if you use printf()
+ * To avoid conflicts with the regular printf() API it is overridden by macro defines
+ * and internal underscore-appended functions like printf_() are used
+ * \param format A string that specifies the format of the output
+ * \return The number of characters that are written into the array, not counting the terminating null character
+ */
+#define printf printf_
+int printf_(const char* format, ...);
+
+
+/**
+ * Tiny sprintf implementation
+ * Due to security reasons (buffer overflow) YOU SHOULD CONSIDER USING (V)SNPRINTF INSTEAD!
+ * \param buffer A pointer to the buffer where to store the formatted string. MUST be big enough to store the output!
+ * \param format A string that specifies the format of the output
+ * \return The number of characters that are WRITTEN into the buffer, not counting the terminating null character
+ */
+#define sprintf sprintf_
+int sprintf_(char* buffer, const char* format, ...);
+
+
+/**
+ * Tiny snprintf/vsnprintf implementation
+ * \param buffer A pointer to the buffer where to store the formatted string
+ * \param count The maximum number of characters to store in the buffer, including a terminating null character
+ * \param format A string that specifies the format of the output
+ * \param va A value identifying a variable arguments list
+ * \return The number of characters that COULD have been written into the buffer, not counting the terminating
+ * null character. A value equal or larger than count indicates truncation. Only when the returned value
+ * is non-negative and less than count, the string has been completely written.
+ */
+#define snprintf snprintf_
+#define vsnprintf vsnprintf_
+int snprintf_(char* buffer, size_t count, const char* format, ...);
+int vsnprintf_(char* buffer, size_t count, const char* format, va_list va);
+
+
+/**
+ * Tiny vprintf implementation
+ * \param format A string that specifies the format of the output
+ * \param va A value identifying a variable arguments list
+ * \return The number of characters that are WRITTEN into the buffer, not counting the terminating null character
+ */
+#define vprintf vprintf_
+int vprintf_(const char* format, va_list va);
+
+
+/**
+ * printf with output function
+ * You may use this as dynamic alternative to printf() with its fixed _putchar() output
+ * \param out An output function which takes one character and an argument pointer
+ * \param arg An argument pointer for user data passed to output function
+ * \param format A string that specifies the format of the output
+ * \return The number of characters that are sent to the output function, not counting the terminating null character
+ */
+int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif // _PRINTF_H_
\ No newline at end of file
diff --git a/util/startup.c b/util/startup.c
new file mode 100644
index 0000000..4794ace
--- /dev/null
+++ b/util/startup.c
@@ -0,0 +1,15 @@
+
+int main(void);
+
+void _start(void) __attribute__((naked, section(".init")));
+
+void _start(void)
+{
+ __asm__ volatile(
+ "la gp, _global_pointer;"
+ "la sp, _sp;"
+ "call main;");
+
+ for (;;)
+ ;
+}
\ No newline at end of file
diff --git a/util/utility.c b/util/utility.c
new file mode 100644
index 0000000..4d1588a
--- /dev/null
+++ b/util/utility.c
@@ -0,0 +1,42 @@
+#include "utility.h"
+#include "printf.h"
+
+#include
+
+void _putchar(char character)
+{
+ PAO = character | 0x80;
+ PAO = 0x00;
+}
+
+void dma_nwrite(char *str, uint16_t len)
+{
+ PCO |= 0x2;
+ DSL = (uint8_t)(len & 0xff);
+ DSH = (uint8_t)((len >> 8) & 0xff);
+ DAL = (uint8_t)(((uintptr_t)str) & 0xff);
+ DAH = (uint8_t)(((uintptr_t)(str) >> 8) & 0xff);
+ PCO &= ~(0x2);
+}
+
+void dma_write(char *str)
+{
+ dma_nwrite(str, strlen(str));
+}
+
+// Blocking key read
+
+char read_key(void)
+{
+ char k = 0;
+
+ while ((k & 0x80) == 0)
+ {
+ k = PBI;
+ }
+
+ PCO |= 0x01;
+ PCO &= ~(0x01);
+
+ return k & 0x7f;
+}
diff --git a/util/utility.h b/util/utility.h
new file mode 100644
index 0000000..94a7416
--- /dev/null
+++ b/util/utility.h
@@ -0,0 +1,14 @@
+#ifndef UTILITY_H
+#define UTILITY_H
+
+#include "iom.h"
+#include "printf.h"
+
+#define put_char _putchar
+
+void dma_write(char *str);
+void dma_nwrite(char *str, uint16_t len);
+
+char read_key(void);
+
+#endif
diff --git a/vartype.h b/vartype.h
new file mode 100644
index 0000000..b25baf1
--- /dev/null
+++ b/vartype.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2006, Adam Dunkels
+ * Copyright (c) 2013, Danyil Bohdan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the author nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#ifndef __VARTYPE_H__
+#define __VARTYPE_H__
+
+typedef int VariableType_t;
+
+#endif /* __VARTYPE_H__ */
+
+
+
+
+