Updated the parser to handle treating variables as expressions. Updated the symbols table to handle computing the values of variables.

.gitignore

@@ -1,3 +1,6 @@
 assm
 obj/
 bin/
+*.bin
+docs/*
+!docs/*.tex

Makefile

@@ -1,5 +1,5 @@
 CC = gcc
-CFLAGS=-g -Wall -DDEBUG -Wpedantic
+CFLAGS=-g -Wall -DDEBUG -Wpedantic -Wextra -Wunused-result -std=c99 -pedantic-errors
 SRCDIR=src
 OBJDIR=obj
 SRCS=$(wildcard $(SRCDIR)/*.c)
@@ -11,7 +11,7 @@ BIN=$(BINDIR)/assm
 
 all: $(BIN)
 
-release: CFLAGS=-Wall -Wpedantic -O2
+release: CFLAGS=-Wall -Wpedantic -std=c99 -pedantic-errors -O2
 release: clean
 release: $(BIN)
 
@@ -35,7 +35,7 @@ clean:
 	rm -rf $(BINDIR)/* $(OBJDIR)/*
 
 test:
-	$(BIN) misc/test.asm
+	$(BIN) misc/another_test.asm
 
 disass:
 	objdump -S --disassemble $(OBJDIR)/$(FILE).o > $(OBJDIR)/$(FILE).s

docs/document.tex

@@ -0,0 +1,187 @@
+\documentclass[a4paper,12pt]{book}
+\usepackage{tikz}
+\usepackage{hyperref}
+\hypersetup{
+	linktoc=all
+}
+
+\title{Unnamed Machine}
+\author{A Very Terrible 16-bit Machine}
+
+\newcommand{\OpcodeTable}[5] {
+	\begin{tabular}{ c c c c c }
+		\hline
+		Opcode & Bit Pattern & Mnemonic & Operand 1 & Operand 2 \\
+		\hline\hline
+		#1 & #2 & #3 & #4 & #5 \\
+		\hline
+	\end{tabular}
+}
+
+\begin{document}
+	\maketitle
+	\tableofcontents
+	\chapter{Overview}
+	\section{Introduction}
+	This is a very poorly thought out 16-bit machine, but you've got to start somewhere. Currently debating between a CPU status register, 80x86 style, or just placing arithmetic results into a predetermined register. This is more of a load–store architecture to try and keep the instruction set simple. The machine will be big-endian.
+	\section{Registers}
+	The following are the general purpose registers that can be used.
+	\begin{itemize}
+		\item[] R1
+		\item[] ...
+		\item[] R8
+	\end{itemize}
+	Additionally, there will be a special status register that will be a signed 16 bit register that the compare and jump instructions will read or write to when determining what action, if any, they'll take.
+	\section{Memory Model}
+	Memory will be implicitly mapped I/O. The bottom 3201 bytes of memory will be reserved for the keyboard input and graphics.
+	A single byte is reserved for the keyboard's input. The current key will be stored in byte 0xF37E, with the most significant bit being a flag indicating that the keyboard 
+	is ready to be read from. This means that the character encoding is actually 7 bits.
+	Video memory starts at 0xF37F (62335 decimal), and every byte represents an ASCII character in monochrome.
+	\begin{figure}[!htb]
+		\centering
+		\begin{tikzpicture}
+			\fill[gray!5] (0,0)rectangle(5,10);
+			%\draw (0,10) .. controls (-2,6) and (-2,4) .. (0,1);
+			%\draw (0,10) arc (0:180:3cm);
+			\draw (0,10) -- (5,10);
+			\draw (0,1) --  node[above] {Video 0xF37F} (5,1);
+			\draw (0,0) -- (5,0);
+			\node[label=right:Top 0x0000] at (5,10) {};
+			\node[label=right:Bottom 0xFFFF] at (5,0) {};
+		\end{tikzpicture}
+		\caption{Memory Layout}
+	\end{figure}
+	\chapter{Instruction Set Architecture}
+	\section{Instruction Encoding}
+	The instruction encoding is fixed width to exactly 8 bites wide.
+	The encoding for the instructions will differ depending on if the opcode requires a register as its first operand.
+	For instructions that require, as their first argument, a register the encoding format will be as shown in Figure \ref{fig:WithRegister}.
+	The lower 3 bits may be any bit pattern as long as at least one bit is set in the upper 5 bits.
+	%https://tex.stackexchange.com/questions/32598/force-latex-image-to-appear-in-the-section-in-which-its-declared	
+	\begin{figure}[!htb]
+		\centering
+		\begin{tabular}{ c c }
+			Instruction & Register \\
+			\hline
+			XXXX X & 000 \\
+			\hline
+		\end{tabular}
+		\caption{Encoding Layout, Register Required}
+		\label{fig:WithRegister}
+	\end{figure}
+
+	Figure \ref{fig:NoRegisterEncoding} shows how encoding will look for instructions that lack arguments or do not require a register.
+	In contrast with the previous encoding scheme the upper 5 bits MUST be zero, allowing 7 possible instructions to use this format.
+	All zeroes is not considered a legal instruction.
+
+	\begin{figure}[!htb]
+	\centering
+	\begin{tabular}{ c c }
+		Must Be Zero & Instruction \\
+		\hline
+		0000 0 & XXX \\
+		\hline
+	\end{tabular}
+	\caption{Encoding Layout, No Register Required}
+	\label{fig:NoRegisterEncoding}
+\end{figure}
+	
+	\section{Notes}
+	For the opcodes that load or store data at the assembly language level we could have the mnemonics
+	"store" and "load" and have the assembler pick the opcode based on the inclusion of the word "byte" 
+	or "word" for two bytes. That would make the assembly easier to read but put a bit more work on the
+	assembler. The Stack Pointer will start 2 bytes above the video memory start.
+	\section{COPY (Copy Word from Address)}
+		\OpcodeTable{0x08}{0000 1000}{copya}{Register}{Address}\\[6pt]
+		Copy a machine word from Operand 2 into Operand 1.
+	\section{COPY BYTE (Copy Byte from Address)}
+		\OpcodeTable{0x10}{0001 0000}{copyab}{Register}{Address}\\[6pt]
+		Copy a byte (8 bits) from Operand 2 into Operand 1, clearing the setting the most significant bits to zero.
+	\section{COPY (Copy Word Indirect Address)}
+		\OpcodeTable{0x18}{0001 1000}{copyra}{Register}{[Register]}\\[6pt]
+		Copy a machine word from the address stored in Operand 2 into Operand 1.
+	\section{COPY BYTE (Copy Byte Indirect Address)}
+		\OpcodeTable{0x20}{0010 0000}{copyrab}{Register}{[Register]}\\[6pt]
+		Copy a byte (8 bits) from the address stored in Operand 2 into Operand 1.
+	\section{COPY (Copy)}
+		\OpcodeTable{0x28}{0010 1000}{copyrara}{[Register]}{[Register]}\\[6pt]
+		Copy a machine word from the address stored in Operand 2 into the address stored in Operand 1.
+	\section{COPY BYTE (Copy Byte)}
+		\OpcodeTable{0x30}{0011 0000}{copyrarab}{[Register]}{[Register]}\\[6pt]
+		Copy a byte (8 bits) from the address stored in Operand 2 into  the address stored in Operand 1.
+	\section{COPY (Copy)}
+		\OpcodeTable{0x38}{0011 1000}{copy}{Register}{Register}\\[6pt]
+		Copy a machine word from Operand 2 into Operand 1.
+	\section{COPY (Copy Immediate)}
+		\OpcodeTable{0xC0}{1100 0000}{copyi}{Register}{Constant}\\[6pt]
+		Copy a machine word from Operand 2 into Operand 1.
+	\section{COPY BYTE (Copy Byte)}
+		\OpcodeTable{0x40}{0100 0000}{copyb}{Register}{Constant}\\[6pt]
+		Copy a byte (8 bits) from Operand 2 into Operand 1.
+	\section{CMP (Compare)}
+		\OpcodeTable{0x48}{0100 1000}{cmp}{Register}{Register}\\[6pt]
+		Compares two registers and somewhere sets a result in the status register.
+	\section{CMPI (Compare Immediate)}
+		\OpcodeTable{0x50}{0101 0000}{cmpi}{Register}{Constant}\\[6pt]
+		Compares an immediate 2 byte value to the contents of a register setting the status register accordingly.
+	\section{ADD (Add)}
+		\OpcodeTable{0x58}{0101 1000}{add}{Register}{Register}\\[6pt]
+		Performs addition on a register with a value from another (or the same) register.
+	\section{SUB (Subtract)}
+		\OpcodeTable{0x60}{0110 0000}{sub}{Register}{Register}\\[6pt]
+		Performs subtraction on a register with a value from another (or the same) register.
+	\section{AND (Logical AND)}
+		\OpcodeTable{0x68}{0110 1000}{and}{Register}{Register}\\[6pt]
+		Logical ANDs the two registers together storing the result in operand 1.
+	\section{XOR (Logical Exclusive OR)}
+		\OpcodeTable{0x70}{0111 0000}{xor}{Register}{Register}\\[6pt]
+		Logical XORs the two registers together storing the result in operand 1.
+	\section{OR (Logical OR)}
+		\OpcodeTable{0x78}{0111 1000}{or}{Register}{Register}\\[6pt]
+		Logical ORs the two registers together storing the result in operand 1.
+	\section{NOT (Logical Negation)}
+		\OpcodeTable{0x80}{1000 0000}{not}{Register}{None}\\[6pt]
+		Inverts the bits of the target register.
+	\section{SHR (Shift Right)}
+		\OpcodeTable{0x88}{1000 1000}{shr}{Register}{Constant}\\[6pt]
+		Bit-wise shifts the contents of the register right Constant number of times.
+	\section{SHL (Shift Left)}
+		\OpcodeTable{0x90}{1001 0000}{shl}{Register}{Constant}\\[6pt]
+		Bit-wise shifts the contents of the register left Constant number of times.
+	\section{INC (Increment)}
+		\OpcodeTable{0x98}{1001 1000}{inc}{Register}{None}\\[6pt]
+		Increments the contents of the register by one. Over-flows will not be reported.
+	\section{DEC (Decrement)}
+		\OpcodeTable{0xA0}{1010 0000}{dec}{Register}{None}\\[6pt]
+		Decrements the contents of the register by one. Under-flows will not be reported.
+	\section{Push}
+		\OpcodeTable{0xA8}{1010 1000}{push}{Register}{None}
+		Pushes the value of Register onto the stack, decrementing the Stack Pointer by 2.
+	\section{Pop}
+		\OpcodeTable{0xB0}{1011 0000}{pop}{Register}{None}
+		Pops the top of the stack into Register, incrementing the Stack Pointer by 2.
+	\section{JMPI (Jump Indirect)}
+		\OpcodeTable{0xB8}{1011 1000}{jmpi}{Register}{None}\\[6pt]
+		Jumps unconditionally to a memory address stored in Operand 1. Sets the Program Counter to Operand 1.
+	\section{JMP (Jump)}
+		\OpcodeTable{0x02}{0000 0010}{jmp}{Address}{None}\\[6pt]
+		Jumps unconditionally to a memory address. Sets the Program Counter to Address.
+	\section{JZ (Jump if Zero)}
+		\OpcodeTable{0x03}{0000 0011}{jz}{Address}{None}\\[6pt]
+		Jumps to a memory address if the status flag is zero. Sets the Program Counter to Address.
+	\section{JG (Jump if Greater Than)}
+		\OpcodeTable{0x04}{0000 0100}{jg}{Address}{None}\\[6pt]
+		Jump to the Address if the status flag is greater than zero. Sets the Program Counter to Address.
+	\section{JL (Jump if Less Than)}
+		\OpcodeTable{0x05}{0000 0101}{jl}{Address}{None}\\[6pt]
+		Jumps to the address if the status flag is less than zero. Sets the Program Counter to Address.		
+	\section{NOP (No Operation)}
+		\OpcodeTable{0x01}{0000 0001}{nop}{None}{None}\\[6pt]
+		Skips a clock cycle, incrementing the program counter.
+	\section{CALL (Call Subroutine)}
+		\OpcodeTable{0x06}{0000 0110}{call}{Address}{None}\\[6pt]
+		Pushes the base address to the stack and sets the Program Counter to Address.
+	\section{RET (Return from Subroutine)}
+		\OpcodeTable{0x07}{0000 0111}{ret}{None}{None}\\[6pt]
+		Pops the stack and sets the Program Counter to that value.
+\end{document}

includes/disass.h

@@ -0,0 +1,9 @@
+#ifndef DIASSEMBLER_H
+#define DIASSEMBLER_H
+
+#include "parser.h"
+
+//void Disassemble(unsigned char image[HIGHMEMORY]);
+
+#endif
+

includes/list.h

@@ -1,21 +0,0 @@
-#ifndef LIST_H
-#define LIST_H
-
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define LISTDEFAULTSIZE 4
-
-typedef struct {
-    void** content;
-    int size;
-    int capacity;
-} List;
-
-List* CreateList(void);
-int AddListItem(const void *, size_t, List *);
-void DestroyList(List*);
-
-#endif

includes/opcodes.h

@@ -2,34 +2,23 @@
 #define OPCODES_H
 
 #include <string.h>
-#include "token.h"
+#include <errno.h>
-
+#include <stdio.h>
-#define OPCODECOUNT 10
-#define REGISTERCOUNT 8
 
 typedef enum {
-    None = 0,
+    R1 = 0, R2, R3, R4, R5, R6, R7, R8 = 7
-    Reg,
+} Registers;
-    Imm8,
-    Imm16
-} ParameterType;
 
-typedef struct {
+typedef enum {
-    char* lexeme;
+    COPYA = 0x08, COPYAB = 0x10, COPYRA = 0x18, COPYRAB = 0x20, COPYRARA = 0x28, COPYRARAB = 0x30, COPY = 0x38, COPYB = 0x40, COPYI = 0xC0,
-    TokenType op;
+    CMP = 0x48, CMPI = 0x50, ADD = 0x58, SUB = 0x60, AND = 0x68, XOR = 0x70, OR = 0x78, NOT = 0x80, SHR = 0x88, SHL = 0x90,
-    ParameterType parameter_one;
+    INC = 0x98, DEC = 0xA0, PUSH = 0xA8, POP = 0xB0, 
-    ParameterType parameter_two;
+    JMPI = 0xB8, JMP = 0x02, JZ = 0x03, JG = 0x04, JL = 0x05, NOP = 0x01, CALL = 0x06, RET = 0x07
-} OpCode;
+} Mnemonic;
 
-typedef struct {
+int IsOpcode(const char*, Mnemonic*);
-    char* lexeme;
+int IsRegister(const char*, Registers*);
-    TokenType type;
+void GetMnemonicText(Mnemonic mnemonic, char buffer[12]);
-} Register;
+void GetRegisterText(Registers reg, char buffer[3]);
-
-extern OpCode opcodes[OPCODECOUNT];
-extern Register registers[REGISTERCOUNT];
-
-int IsOpcode(const char*, TokenType*);
-int IsRegister(const char*, TokenType*);
 
 #endif

includes/parser.h

@@ -1,11 +1,15 @@
 #ifndef PARSER_H
 #define PARSER_H
 
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "list.h"
+#include <string.h>
+#include <stdarg.h>
 #include "token.h"
+#include "opcodes.h"
+#include "symbols_table.h"
 
-void ParseTokens(List*);
+void ParseTokens(TokenList* tokens, SymbolTable** symbolsTable);
 
 #endif

includes/scanner.h

@@ -7,9 +7,8 @@
 #include <errno.h>
 #include "stdlib.h"
 #include "token.h"
-#include "list.h"
 #include "opcodes.h"
 
-List* GenerateTokenList(const char*);
+TokenList* GenerateTokenList(const char*);
 
 #endif

includes/symbols_table.h

@@ -0,0 +1,44 @@
+#ifndef SYMBOLSTABLE_H
+#define SYMBOLSTABLE_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include "opcodes.h"
+#include "token.h"
+
+#define SYMBOLSTABLE_DEFAULT_CAPACITY 128
+
+typedef struct __token_node {
+    const Token* Token;
+    struct __token_node* Left;
+    struct __token_node* Right;
+} TokenNode;
+
+typedef struct _symbol {
+    const char* Name;
+    int Address;
+    int Length;
+    const Token* Token;
+    TokenNode* ValueExpression;
+} Symbol;
+
+typedef struct {
+    Symbol** Symbols;
+    int Size;
+    int Capacity;
+} SymbolTable;
+
+SymbolTable* CreateSymbolTable(void);
+TokenNode* CreateTokenNode(const Token* token);
+int TryGetSymbol(const char* name, const SymbolTable* table, Symbol** outSymbol);
+Symbol* AddSymbolToTable(const char* name, int address, SymbolTable* table);
+void FreeSymbolTable(SymbolTable* table);
+void FreeSymbol(Symbol* symbol);
+int SymbolResolved(const Symbol* symbol, const SymbolTable* table);
+int TryGetSymbolValue(const Symbol* symbol, const SymbolTable* table, unsigned short* value);
+
+#endif

includes/token.h

@@ -5,40 +5,68 @@
 #include <string.h>
 #include <errno.h>
 #include <stdio.h>
+#include "opcodes.h"
 
 typedef enum {
-    PLUS,
+    Plus = '+',
-    MINUS,
+    Minus = '-',
-    STAR,
+    Star = '*',
-    SLASH,
+    Slash = '/',
-    POWER,
+    Power = '^',
-    LPARAM,
+    LParan = '(',
-    RPARAM,
+    RParan = ')',
-    LBRACKET,
+    LBracket = '[',
-    RBracket,
+    RBracket = ']',
-    COMMA,
+    Comma = ',',
-    STRING,
+    NewLine = '\n'
-    IDENTIFIER,
+} TokenPunctuation;
-    LABEL,
-    NUMBER,
-    HEX,
-    //Keywords
-    DB, ORG,    
-    //Opcodes
-    COPY, ADD, SUB, JZ, INT, YLD, RET,
-    CMP, IN, OUT,
-    //Registers
-    R1, R2, R3, R4, R5, R6, R7, R8
-} TokenType;
 
-typedef struct {
+typedef enum {
-    TokenType type;
+    DB,
-    char* lexeme;
+    Include,
-    void* value;
+    Byte
-    int line;
+} Directive;
+
+typedef enum {
+    RegisterClass = 0,
+    NumberClass = 1,
+    CharacterClass = 2,
+    MnemonicClass = 4,
+    DirectiveClass = 8,
+    PunctuationClass = 16,
+    IdentifierClass = 32,
+    LabelClass = 64,
+    AddressClass = LabelClass | IdentifierClass
+} TokenClass;
+
+typedef struct __token {
+    char* Lemexe;
+    TokenClass Class;
+    int LineNumber;
+    int EndOfFile;
+
+    union {
+        TokenPunctuation Punctuation;
+        Registers Register;
+        Mnemonic Mnemonic;
+        Directive Directive;
+        unsigned short Number;
+    } Value;
+
+    struct __token* Prev;
+    struct __token* Next;
 } Token;
 
-Token* CreateToken(char*, void*, int, TokenType);
+typedef struct {
-void FreeToken(Token*);
+    Token** content;
+    int size;
+    int capacity;
+} TokenList;
+
+Token* CreateToken(int lineNumber, TokenClass tokenClass);
+TokenList* CreateTokenList(void);
+int AddToken(Token* token, TokenList* list);
+void RemoveToken(int index, TokenList* list);
+void FreeToken(Token* token);
 
 #endif

misc/another_test.asm

@@ -0,0 +1,44 @@
+.db MAX_MEM 0xFFFF
+.db VIDEO_MEM 0xF37F
+.db MAX_LENGTH MAX_MEM; - MAX_LENGTH
+.db MSG "Hello, World!", 0
+
+__start:
+    copy r1, MSG ; Pointer into r1
+    copy r8, VIDEO_MEM
+    call strlen
+    copy r1, MSG
+    cmp r2, 0
+    jz _end
+    cmp r2, MAX_LENGTH
+    jg _end
+draw_loop:
+    copy byte [r8], [r1]
+    inc r1
+    inc r8
+    dec r2
+    cmp r2, 0
+    jz _end
+    jmp draw_loop
+_end:
+    jmp _end
+
+.db NewMsg "My message", 0
+
+; Returns the length of a NULL terminated string
+; Arguments: R1 - Pointer to the string
+; Returns: R2 - Contains the length of the string
+strlen:
+    copy r2, 0 ; length
+    copy byte r3, [r1]
+    cmp r3, 0
+    jz end ;The string is zero length
+loop:
+    inc r1
+    copy byte r3, [r1]
+    cmp r3, 0
+    jz end
+    inc r2
+    jmp loop
+end:
+    ret

misc/test.asm

@@ -1,45 +1,27 @@
-.org 0x100
+;.include "./another_test.asm"
+.db labelsz reference
+.db video_start 0xF37F
 .db msg "Hello, world!", 0
-.db more_stuff "And yet another string!", 0
+.db NOTERM "No terminating byte here"
-
+.db null_byte 0
-copy r1, msg
+jmp [r4]
-copy r2, 0
+;load r2, label
-loop:
+something_insance:
-    cmp r1, 0
+load r1, unknown_symbol
-    jz loop
+load r1, 5
-    add r1, 1
+.db fun_alright 0x70;does this break?
-mov r1, 5   ; move the immediate value 5 into r1
+load r3, r4
-add r1,5   ; add 5 into r1
+store byte r3, r5
-int 21      ; maybe that will call some string drawing BIOS-like routine
+store r5, r7
-ret
+unknown_symbol:;Does this work?
-; form  YYYY YYXX - Y opcode, X modifier
+cmp r1, 5;or one after the register?
-; nop:  0000 0000
+cmp r1, r2;This might work
-; copy: 0000 01XX
+and r1, r2
-; add:  0000 10XX - | Perhaps running these will clear any overflow
+add r4, r7
-; addc: 0000 11XX - | or under flow flags if no errors occur.
+inc r1 ;increment r1
-; sub:  0001 00XX - | jz should clear the zero flag.
+xor r1, r1 ;clear self
-; subb: 0001 01XX - |
+pop r3
-; call: 0001 1100 - Always call [imm16]
+jmp unknown_symbol
-; jmp:  0010 0000 - Always jmp [imm16] (No short jumps)
+jmp [r4]
-; jz:   0010 0100 - Always jz [imm16] (no short jumps)
+jz [r6]
-; cmp:  0010 11XX
+;And a comment at the end
-; push: 0011 11XX -| pop / push imm16/imm8 | reg
-; pop:  0100 00XX -|
-
-; 
-; imm8 imm16 reg
-; mov reg, imm16|reg
-; add reg, imm16|reg
-; int imm16
-; db [label] 'String data here' (Null byte is added implicatly by the assemblier)
-; 
-; enum Type {
-;   Op,
-;   Reg,
-;   Imm16,
-;   Imm8
-; }
-; struct Token {
-;   enum Type type;
-;   char *value;
-; }

src/disass.c

@@ -0,0 +1,161 @@
+#include "../includes/disass.h"
+#include <stdlib.h>
+
+const unsigned char* Image;
+const unsigned char COPYMASKREG = 0x20;
+const unsigned char COPYMASKADD = 0xA0;
+const unsigned char ADDMASK     = 0x40;
+const unsigned char SUBMASK     = 0x60;
+const unsigned char CMPMASK     = 0x80;
+
+const unsigned char REGMASK     = 0x00;//0x18; //0001 1000
+const unsigned char CONSTMASK   = 0x08; //0000 1000
+const unsigned char ADDRESSMASK = 0x10; //0001 0000
+
+int IsRegisterPattern(unsigned char pattern, char* lexeme);
+void GetParameter(unsigned char instruction, char* text);
+/*
+void Disassemble(unsigned char image[HIGHMEMORY]) {
+    Image = image;
+    int position = image[0] + image[1];
+    int end = image[2] + image[3];
+
+    char* parameter1 = calloc(32, sizeof(char));
+    char* parameter2 = calloc(32, sizeof(char));
+
+    unsigned char instruction = image[position];
+
+    while(end > position) {
+        unsigned char masked = instruction & 0xE0;
+
+        if (masked) {
+            IsRegisterPattern(instruction & 0x07, parameter1);
+            unsigned char parameterType = instruction & 0x18;
+
+            if (parameterType == REGMASK) {
+                IsRegisterPattern(Image[position + 1], parameter2);
+                position += 2;
+            } else if (parameterType == CONSTMASK) {
+                snprintf(parameter2, sizeof(char) * 31, "%d", Image[position + 1] + Image[position + 2]);
+                position += 3;
+            }
+            else if (parameterType == ADDRESSMASK) {
+                snprintf(parameter2, sizeof(char) * 31, "[%#04X]", Image[position + 1] + Image[position + 2]);
+                position += 3;
+            }
+
+            //If the top bits are set
+            if (masked == COPYMASKREG) {
+                printf("COPY %s, %s\n", parameter1, parameter2);
+            }
+            else if (masked == COPYMASKADD) {
+                printf("COPY %s, %s\n", parameter2, parameter1);
+            }
+            else if (masked == ADDMASK) {
+                printf("ADD %s, %s\n", parameter1, parameter2);
+            }
+            else if (masked == SUBMASK) {
+                printf("SUB %s, %s\n", parameter1, parameter2);
+            }
+            else if (masked == CMPMASK) {
+                printf("CMP %s, %s\n", parameter1, parameter2);
+            }
+            else {
+                fprintf(stderr, "[Error] Unknown opcode %#02X\n", masked);
+                exit(1);
+            }
+        }
+        else {
+            int parameter = Image[position + 1] + Image[position + 2];
+
+            switch(instruction) {
+                case 0:
+                    printf("NOP\n");
+                    position++;
+                    break;
+                case 1:
+                    printf("JZ [%#04X]\n", parameter);
+                    position += 3;
+                    break;
+                case 2:
+                    printf("INT %d\n", parameter);
+                    position += 3;
+                    break;
+                case 3:
+                    printf("YLD\n");
+                    position++;
+                    break;
+                case 4:
+                    printf("RET\n");
+                    position++;
+                    break;
+                case 5:
+                    printf("CALL [%#04X]\n", parameter);
+                    position += 3;
+                    break;
+                case 6:
+                    printf("JMP [%#04X]\n", parameter);
+                    position += 3;
+                    break;
+                case 7:
+                    printf("IN %d\n", parameter);
+                    position += 3;
+                    break;
+                case 8:
+                    printf("OUT %d\n", parameter);
+                    position += 3;
+                    break;
+                default:
+                    position++;
+                    break;
+            }
+        }
+
+        instruction = Image[position];
+
+        memset(parameter1, '\0', sizeof(char) * 32);
+        memset(parameter2, '\0', sizeof(char) * 32);
+    }
+}
+*/
+int IsRegisterPattern(unsigned char pattern, char* lexeme) {
+    if (pattern > 8) {
+        lexeme[0] = '\0';
+        return 0;
+    }
+    //The registers' bit patterns are zero indexed, so 'r1' is '000'
+    //but 'r8' is '111' and so forth.
+    pattern++;
+
+    lexeme[0] = 'r';
+    lexeme[1] = pattern | 0x30;
+    lexeme[2] = '\0';
+
+    return 1;
+}
+/*
+//REG       XXX0 0XXX
+//Constant  XXX0 1XXX
+//Address   XXX1 0XXX
+    NOP  - 0000 0000 NOP
+    JZ   - 0000 0001 JZ Address
+    INT  - 0000 0010 INT Constant
+    YLD  - 0000 0011 YLD
+    RET  - 0000 0100 RET
+    CALL - 0000 0101 CALL Address
+    JMP  - 0000 0110 JMP Address
+    IN   - 0000 0111 IN Constant
+    OUT  - 0000 1000 OUT Constant
+    COPY - 0010 0XXX COPY REG, REG
+         - 0010 1XXX COPY REG, Constant
+         - 0011 0XXX COPY REG, Address
+         - 1010 0XXX COPY Address, REG
+         - 1010 1XXX COPY Address, Constant
+         - 1011 0XXX COPY Address, Address
+    ADD  - 0100 0XXX ADD REG, REG
+         - 0100 1XXX ADD REG, Constant
+    SUB  - 0110 0XXX SUB REG, REG
+         - 0110 1XXX SUB REG, Constant
+    CMP  - 1000 0XXX CMP REG, REG
+         - 1000 1XXX CMP REG, Constant
+         - 1001 0XXX CMP REG, Address */

src/list.c

@@ -1,66 +0,0 @@
-#include "../includes/list.h"
-
-List* CreateList() {
-    List *new = malloc(sizeof(List));
-
-    if (!new) {
-        fprintf(stderr, "Failed to malloc() for new new List.\n");
-        return NULL;
-    }
-
-    new->content = malloc(sizeof(void*) * LISTDEFAULTSIZE);
-
-    if (!new->content) {
-        fprintf(stderr, "Failed to malloc() memory for List contents.\n");
-        free(new);
-        return NULL;
-    }
-
-    new->size = 0;
-    new->capacity = LISTDEFAULTSIZE;
-
-    return new;
-}
-
-int AddListItem(const void *value, size_t size, List* list) {
-    if (!list) return -1;
-    if (!value) return -1;
-    if (size == 0) return -1;
-
-    if (list->capacity < list->size + 1) {
-        void* ptr = realloc(list->content, sizeof(void*) * list->capacity * 2);
-        //Note: realloc will free list->root if it succeeds.
-        if (!ptr) {
-            fprintf(stderr, "Failed to resize array with realloc() (%d bytes).\n", list->capacity * 2);
-            return -1;
-        }
-
-        list->content = ptr;
-        list->capacity = list->capacity * 2;
-    }
-
-    void* item = calloc(1, size);
-
-    if (!item) {
-        fprintf(stderr, "Failed to calloc() new memory (%lu bytes).\n", size);
-        return -1;
-    }
-
-    memcpy(item, value, size);
-
-    list->content[list->size] = item;
-    list->size++;
-
-    return 0;
-}
-
-void DestroyList(List* list) {
-    if (!list) return;
-
-    for(int i = 0; i < list->size; i++) {
-        free(list->content[i]);
-    }
-
-    free(list->content);
-    free(list);
-}

src/main.c

@@ -1,11 +1,20 @@
+#include <bits/types/FILE.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
-#include "../includes/list.h"
+#include "../includes/token.h"
-#include "../includes/parser.h"
 #include "../includes/futil.h"
 #include "../includes/scanner.h"
+#include "../includes/parser.h"
+
+const char* MagicStartName = "__start";
+TokenList* LIST;
+SymbolTable* Symbols = NULL;
+
+unsigned char mem[128] = {0};
+void print(void);
+void assemble(void);
 
 int main(int argc, char* args[]) {
     if (argc == 1) {
@@ -13,22 +22,227 @@ int main(int argc, char* args[]) {
         return EX_USAGE;
     }
 
+    atexit(print);
+
     char* source_code;
     size_t bytes_read;
 
     if (!ReadAllString(args[1], &source_code, &bytes_read)) return EX_IOERR;
 
-    List* list = GenerateTokenList(source_code);
+    LIST = GenerateTokenList(source_code);
     
-    // for(int i = 0; i < list->size; i++) {
+    ParseTokens(LIST, &Symbols);
-    //     Token* t = (Token*) list->content[i];
-
-    //     printf("[%i] '%s'", t->type, t->lexeme);
-    //     if (t->type == LABEL) printf("*");
-    //     printf("\n");
-    // }
-
-    ParseTokens(list);
 
     free(source_code);
+
+    assemble();
+
+    printf("\nBytes:\n");
+    for(unsigned long i = 0; i < sizeof(mem); i++) { 
+        if (i != 0 && i % 8 == 0) printf("\n");
+        printf("%02X ", mem[i] & 0xFF);
+    }
+    printf("\n");
 }
+
+void print(void) {
+    char mnemonic[12];
+    printf("printing tokens...\n");
+
+
+    for(int i = 0; i < LIST->size; i++) {
+        Token* t = (Token*) LIST->content[i];
+
+        if (t->EndOfFile) {
+            printf("EOF\n");
+            break;
+        }
+
+        if (t->Class == PunctuationClass){
+            if(t->Value.Punctuation == NewLine) {
+                printf("<%d>\n", t->LineNumber);
+                continue;
+            }
+
+            printf("[P]%c", t->Value.Punctuation);
+            continue;
+        }
+
+        if (t->Class == LabelClass) {
+            printf("[L]%s*", t->Lemexe);
+            continue;
+        }
+
+        if (t->Class == IdentifierClass) {
+            printf("[I]%s ", t->Lemexe);
+            continue;
+        }
+        
+        if (t->Class == RegisterClass) {
+            printf("[R]%d", t->Value.Register);
+            continue;
+        }
+
+        if (t->Class == NumberClass) {
+            printf("[N]%d ", t->Value.Number);
+            continue;
+        }
+
+        if (t->Class == MnemonicClass) {
+            GetMnemonicText(t->Value.Mnemonic, mnemonic);
+            printf("[M]%s ", mnemonic);
+            continue;
+        }
+
+        if (t->Class == DirectiveClass) {
+            printf("[D]%d ", t->Value.Directive);
+
+        }
+
+        if (t->Class == CharacterClass) {
+            printf("[C]'%s'", t->Lemexe);
+        }
+    } 
+}
+
+int CurrentIndex = 0;
+int PC2 = 0;
+
+void WriteByte(unsigned char byte) {
+    mem[PC2] = byte;
+    PC2++;
+}
+
+void WriteWord(unsigned short word) {
+    mem[PC2] = (word >> 8) & 0xFF;
+    mem[PC2 + 1] = word & 0xFF;
+    PC2 += 2;
+}
+
+unsigned short GetValueFromToken(Token* token) {
+    if (token->Class & IdentifierClass) {
+        Symbol* symbol;
+
+        if (TryGetSymbol(token->Lemexe, Symbols, &symbol)) {
+            return symbol->Address;
+        } 
+        else {
+            fprintf(stderr, "Failed to find symbol %s while assembling.\n", token->Lemexe);
+
+            exit(1);
+        }
+    }
+    else if (token->Class == NumberClass) return token->Value.Number;
+
+    fprintf(stderr, "Failed to find token '%d' while assmbling.\n", token->Class);
+
+    exit(1);
+}
+
+int IsAtEnd(void){
+    return CurrentIndex >= LIST->size;
+}
+
+void assemble() {
+    while(!IsAtEnd()) {
+        Token* current = LIST->content[CurrentIndex];
+        switch(current->Value.Mnemonic) {
+            case COPYA:
+            case COPYAB:
+                CurrentIndex++;
+
+                WriteByte(current->Value.Mnemonic | ((Token*) LIST->content[CurrentIndex])->Value.Register);
+                CurrentIndex++;
+                WriteWord(GetValueFromToken(LIST->content[CurrentIndex]));
+                break;
+            case COPYRA:
+            case COPYRAB:
+            case COPYRARA:
+            case COPYRARAB:
+            case COPY:
+                CurrentIndex++;
+
+                WriteByte(current->Value.Mnemonic | ((Token*) LIST->content[CurrentIndex])->Value.Register);
+                CurrentIndex++;
+                WriteByte(((Token*) LIST->content[CurrentIndex])->Value.Register);
+                break;
+            case COPYI: //TODO: should explicitly get number from value I feel
+                CurrentIndex++;
+
+                WriteByte(current->Value.Mnemonic | ((Token*) LIST->content[CurrentIndex])->Value.Register);
+                CurrentIndex++;
+                WriteWord(GetValueFromToken(LIST->content[CurrentIndex]));
+                break;
+            case COPYB:
+                CurrentIndex++;
+
+                WriteByte(current->Value.Mnemonic | ((Token*) LIST->content[CurrentIndex])->Value.Register);
+                CurrentIndex++;
+                WriteByte((unsigned char)GetValueFromToken(LIST->content[CurrentIndex]));
+                break;
+            case CMP:
+                CurrentIndex++;
+
+                WriteByte(current->Value.Mnemonic | ((Token*) LIST->content[CurrentIndex])->Value.Register);
+                CurrentIndex++;
+                WriteByte(((Token*) LIST->content[CurrentIndex])->Value.Register);
+                break;
+            case CMPI:
+                CurrentIndex++;
+
+                WriteByte(current->Value.Mnemonic | ((Token*) LIST->content[CurrentIndex])->Value.Register);
+                CurrentIndex++;
+                WriteWord(GetValueFromToken(LIST->content[CurrentIndex]));
+                break;
+            case ADD:
+            case SUB:
+            case AND:
+            case OR:
+            case XOR:
+                CurrentIndex++;
+
+                WriteByte(current->Value.Mnemonic | ((Token*) LIST->content[CurrentIndex])->Value.Register);
+                CurrentIndex++;
+                WriteByte(((Token*) LIST->content[CurrentIndex])->Value.Register);
+                break;
+            case SHL:
+            case SHR:
+                CurrentIndex++;
+
+                WriteByte(current->Value.Mnemonic | ((Token*) LIST->content[CurrentIndex])->Value.Register);
+                CurrentIndex++;
+                WriteWord(GetValueFromToken(LIST->content[CurrentIndex]));
+                break;
+            case INC:
+            case DEC:
+            case PUSH:
+            case POP:
+            case JMPI:
+                CurrentIndex++;
+
+                WriteByte(current->Value.Mnemonic | ((Token*) LIST->content[CurrentIndex])->Value.Register);
+                break;
+            case JMP:
+            case JZ:
+            case JG:
+            case JL:
+                WriteByte(current->Value.Mnemonic);
+                CurrentIndex++;
+                WriteWord(GetValueFromToken(LIST->content[CurrentIndex]));
+                break;
+            case NOP:
+            case RET:
+                WriteByte(current->Value.Mnemonic);
+                break;
+            case CALL:
+                WriteByte(current->Value.Mnemonic);
+                CurrentIndex++;
+                WriteWord(GetValueFromToken(LIST->content[CurrentIndex]));
+            default:
+                break;
+        }
+
+        CurrentIndex++;
+    }
+}
+

src/opcodes.c

@@ -1,53 +1,97 @@
 #include "../includes/opcodes.h"
+#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 
-OpCode opcodes[OPCODECOUNT] = {
+#define OPCODECOUNT 34
-    { "copy", COPY, Reg, Reg | Imm8 | Imm16 },
+
-    { "add", ADD, Reg, Reg | Imm8 | Imm16 },
+struct _instruction {
-    { "sub", SUB, Reg, Reg | Imm8 | Imm16 },
+    char* Name;
-    { "jz", JZ, Imm8 | Imm16, None },
+    Mnemonic Mnemonic;
-    { "int", INT, Imm8, None },
-    { "yld", YLD, None, None },
-    { "ret", RET, None, None },
-    { "cmp", CMP, Reg | Imm8 | Imm16, Reg | Imm8 | Imm16 },
-    { "in", IN, None, None},
-    { "out", OUT, None, None}
 };
 
-Register registers[REGISTERCOUNT] = {
+struct _instruction instructions[31] = {
-    { "r1", R1 },
+    { "copya", COPYA },
-    { "r2", R2 },
+    { "copyab", COPYAB },
-    { "r3", R3 },
+    { "copyra", COPYRA },
-    { "r4", R4 },
+    { "copyrab", COPYRAB },
-    { "r5", R5 },
+    { "copyrara", COPYRARA },
-    { "r6", R6 },
+    { "copyrarab", COPYRARAB },
-    { "r7", R7 },
+    { "copy", COPY },
-    { "r8", R8 }
+    { "copyi", COPYI },
+    { "copyb", COPYB },
+    { "cmp", CMP },
+    { "cmpi", CMPI },
+    { "add", ADD },
+    { "sub", SUB },
+    { "and", AND },
+    { "xor", XOR },
+    { "or", OR },
+    { "not", NOT },
+    { "shr", SHR },
+    { "shl", SHL },
+    { "inc", INC },
+    { "dec", DEC },
+    { "push", PUSH },
+    { "pop", POP },
+    { "jmpi", JMPI },
+    { "jmp", JMP },
+    { "jz", JZ },
+    { "jg", JG },
+    { "jl", JL },
+    { "nop", NOP },
+    { "call", CALL },
+    { "ret", RET }
+    //yld
 };
 
-int IsOpcode(const char* text, TokenType* opcode) {
+void GetMnemonicText(Mnemonic mnemonic, char buffer[12]) {
-    if (!text) return 0;
+    memset(buffer, '\0', 12);
 
     for(int i = 0; i < OPCODECOUNT; i++) {
-        if (strcmp(opcodes[i].lexeme, text) == 0) {
+        if (instructions[i].Mnemonic == mnemonic) { 
-            *opcode = opcodes[i].op;
+            strncpy(buffer, instructions[i].Name, 11);
-            return 1;
+            break;
         }
     }
-
-    return 0;
 }
 
-int IsRegister(const char* text, TokenType* reg) {
+void GetRegisterText(Registers reg, char buffer[3]) {
+    memset(buffer, '\0', 3);
+
+    if (reg < R1 || reg > R8) return;
+
+    buffer[0] = 'r';
+    buffer[1] = reg + 49;
+}
+
+int IsOpcode(const char* text, Mnemonic* opcode) {
     if (!text) return 0;
 
-    for(int i = 0; i < REGISTERCOUNT; i++) {
+    for(unsigned long i = 0; i < sizeof(instructions) / sizeof(struct _instruction); i++) {
-        if (strcmp(registers[i].lexeme, text) == 0)  {
+        if (strcmp(instructions[i].Name, text) == 0) {
-            *reg = registers[i].type;
+            if (opcode) *opcode = instructions[i].Mnemonic;
             return 1;
         }
     }
 
     return 0;
 }
+
+int IsRegister(const char* text, Registers* reg) {
+    if (!text) return 0;
+
+    int length = strlen(text);
+    Registers r = R8;
+
+    if (length != 2) return 0;
+    if (text[0] != 'r') return 0;
+
+    if (!isdigit(text[1])) return 0;
+
+    r = text[1] - 0x31;
+
+    if (reg) *reg = r;
+
+    return 1;
+}

src/parser.c

@@ -3,87 +3,606 @@
 #include <stdlib.h>
 #include <string.h>
 
-typedef struct {
+typedef enum {
-    Token* token;
+    NoOptions = 0, ForwardParser = 1, RemoveExpected = 2
-    int address;
+} ExpectOptions;
-} Symbol;
+
+TokenList* TokensList;
+int CurrentToken = 0;
 
-Symbol* CreateSymbol(Token*, int);
-void AddSymbol(Token*);
 void PrintSymbols(void);
-Token* GetSymbol(char*);
+void RemoveCurrentToken(void);
-List* SymbolsTable;
+void HandleAssemblerDirective(void);
-unsigned int ProgramCounter = 0;
+Token* ExpectMnemonic(void);
+void AdvanceParser(void);
+void IgnoreParserLine(void);
+Token* PeekToken(void);
+int ParserAtEnd(void);
 
-void ParseTokens(List* tokens) {
+void ExpectPuncuation(TokenPunctuation punctuation, ExpectOptions options);
-    SymbolsTable = CreateList();
+void ExpectRegister(void);
+Symbol* ExpectIdentifier(ExpectOptions options, int expectUnresolved);
+void ExpectCharacterClass(Symbol* symbol);
+Token* ExpectLineEndOrFileEnd(ExpectOptions options);
+Token* ExpectMathOperator(ExpectOptions options);
+Token* ExpectMathOperand(ExpectOptions options);
 
-    for(int i = 0; i < tokens->size; i++){
+SymbolTable* SymbolsTable;
-        Token* t = tokens->content[i];
+TokenNode* ParseSymbolExpression(void);
 
-        switch(t->type) {
+//int HeapSize = 0;
-            case IDENTIFIER:
+int PC = 0;
-            case LABEL:
+
-                AddSymbol(t);
+void ParseTokens(TokenList* tokens, SymbolTable** symbols) {
+    if (!tokens) return;
+    if (!symbols) return;
+
+    TokensList = tokens;
+
+    if (!*symbols) *symbols = CreateSymbolTable();
+
+    SymbolsTable = *symbols;
+
+    while(!ParserAtEnd()) {
+        Token* t = PeekToken();
+        if (!t || t->EndOfFile) break;
+
+        switch(t->Class) {
+            case DirectiveClass:
+                HandleAssemblerDirective();
                 break;
-            case STRING:
+            case MnemonicClass:
-                ProgramCounter += strlen(t->lexeme);
+                ExpectMnemonic();
                 break;
-            case NUMBER:
+            case LabelClass:
-            case HEX:
+                {
-                if ((long) t->value < 256) ProgramCounter += 1;
+                    Symbol* symbol;
-                else ProgramCounter += 2;
+                    int found = TryGetSymbol(t->Lemexe, SymbolsTable, &symbol);
+
+                    if (found && SymbolResolved(symbol, SymbolsTable)) {
+                        fprintf(stderr, "[Error] Line %d: Redefinition of symbol '%s'\n", t->LineNumber, t->Lemexe);
+                        exit(1);
+                    }
+
+                    if (!found) symbol = AddSymbolToTable(t->Lemexe, PC, SymbolsTable);
+                    
+                    symbol->Address = PC;
+
+                    RemoveCurrentToken(); //label
+                    
+                    ExpectLineEndOrFileEnd(RemoveExpected);
+                    
+                    symbol->Token = ExpectMnemonic();
+                }
                 break;
             default:
-                if (t->type > ORG) ProgramCounter += 1;
+                fprintf(stderr, "[Warning] Line %d: Syntax error, expected start of expression, got '%c' [%d].\n", t->LineNumber, t->Value.Punctuation, t->Class);
+                exit(1);
                 break;
         }
     }
 
     PrintSymbols();
-    DestroyList(SymbolsTable);
-    printf("Program Counter: %d\n", ProgramCounter);
 }
 
-void PrintSymbols(void) {
+void HandleAssemblerDirective() {
-    printf("-----SYMBOLS-----\n");
+    Token* directive = PeekToken();
-    for(int i = 0; i < SymbolsTable->size; i++) {
+
-        Symbol* symbol = SymbolsTable->content[i];
+    switch(directive->Value.Directive){
-        printf("[%#08X] %s\n", symbol->address, symbol->token->lexeme);
+        case DB:
+            {
+                RemoveCurrentToken();
+
+                Symbol* symbol = ExpectIdentifier(RemoveExpected, 1);
+
+                if (PeekToken()->Class == CharacterClass) {
+                    ExpectCharacterClass(symbol);
+                }
+                else if (PeekToken()->Class == NumberClass || PeekToken()->Class == IdentifierClass) {
+                    symbol->Length = 2;
+                    
+                    symbol->ValueExpression = ParseSymbolExpression();
+                }
+            }
+            break;
+        default:
+            fprintf(stderr, "Synatx error on line %d, %s.\n", directive->LineNumber, directive->Lemexe);
+            exit(1);
     }
-    printf("-----SYMBOLS-----\n");
 }
 
-void AddSymbol(Token* token) {
+Token* ExpectMnemonic(void) {
-    if (!token) return;
+    Token* opcode = PeekToken();
-    if (token->type != IDENTIFIER && token->type != LABEL) return;
 
-    for(int i = 0; i < SymbolsTable->size; i++) {
+    if (opcode->Class != MnemonicClass) {
-        Symbol* s = SymbolsTable->content[i];
+        fprintf(stderr, "Syntax error on line %d: expected mnemonic.\n", opcode->LineNumber);
 
-        if (strcmp(s->token->lexeme, token->lexeme) == 0) return;
+        exit(1);
     }
 
-    Symbol* symbol = CreateSymbol(token, ProgramCounter);
+    AdvanceParser();
 
-    AddListItem(symbol, sizeof(Symbol), SymbolsTable);
+    switch(opcode->Value.Mnemonic) {
-}
+        case COPY:
+            {
+                Token* arg = PeekToken();
+                int isByte = 0;
 
-Token* GetSymbol(char* name) {
+                if (arg->Class == DirectiveClass) {
-    if (!name) return NULL;
+                    if (arg->Value.Directive != Byte) {
+                        fprintf(stderr, "Syntax error on line %d: expected keyword 'byte'.\n", opcode->LineNumber);
 
-    return NULL;
+                        exit(1);
-}
+                    }
+                    RemoveCurrentToken(); //byte  
                     
-Symbol* CreateSymbol(Token* token, int offset) {
+                    isByte = 1;
-    Symbol* symbol = calloc(1, sizeof(Symbol));
 
-    if (!symbol) {
+                    arg = PeekToken();
-        return NULL;
                 }
 
-    symbol->token = token;
+                PC++;
-    symbol->address = offset;
+
+                if (arg->Class == RegisterClass) {
+                    ExpectRegister();
+
+                    ExpectPuncuation(Comma, RemoveExpected);
+
+                    arg = PeekToken();
+
+                    if (arg->Class == NumberClass) {
+                        opcode->Value.Mnemonic = isByte ? COPYB : COPYI;
+                        opcode->Lemexe = isByte ? "copyb" : "copyi";
+
+                        isByte ? PC++ : (PC += 2);
+
+                        AdvanceParser();
+                    }
+                    else if (arg->Class == RegisterClass) {
+                        if (isByte) {
+                            fprintf(stderr, "Syntax error on line %d: unexpected modifier 'Byte' for Register to Register copy.\n", opcode->LineNumber);
+
+                            exit(1);
+                        }
+
+                        ExpectRegister();
+
+                        opcode->Value.Mnemonic = COPY;
+                        opcode->Lemexe = "copy";
+
+                        PC++;
+                    }
+                    else if (arg->Class & IdentifierClass) {
+                        opcode->Value.Mnemonic = isByte ? COPYAB : COPYA;
+                        opcode->Lemexe = isByte ? "copyab" : "copya";
+                        PC += 2;
+
+                        ExpectIdentifier(ForwardParser, 0);
+                    }
+                    else {
+                        ExpectPuncuation(LBracket, RemoveExpected);
+
+                        ExpectRegister();
+
+                        ExpectPuncuation(RBracket, RemoveExpected);
+
+                        opcode->Value.Mnemonic = isByte ? COPYRAB : COPYRA;
+                        opcode->Lemexe = isByte ? "copyrab" : "copyra";
+                        PC++;
+                    }
+                }
+                else {
+                    ExpectPuncuation(LBracket, RemoveExpected);
+
+                    ExpectRegister();
+
+                    ExpectPuncuation(RBracket, RemoveExpected);
+
+                    ExpectPuncuation(Comma, RemoveExpected);
+
+                    ExpectPuncuation(LBracket, RemoveExpected);
+
+                    ExpectRegister();
+
+                    ExpectPuncuation(RBracket, RemoveExpected);
+
+                    opcode->Value.Mnemonic = isByte ? COPYRARAB : COPYRARA;
+                    opcode->Lemexe = isByte ? "copyrarab" : "copyrara"; 
+
+                    PC++;
+                }
+            }
+            break;
+        case CMP:
+            {
+                ExpectRegister();
+
+                ExpectPuncuation(Comma, RemoveExpected);
+
+                TokenClass class = PeekToken()->Class;
+
+                PC++;
+
+                if (class == NumberClass) {
+                    opcode->Value.Mnemonic = CMPI;
+                    opcode->Lemexe = "CMPI";
+
+                    AdvanceParser();
+
+                    PC += 2;
+                }
+                else if (class & IdentifierClass) {
+                    opcode->Value.Mnemonic = CMPI;
+                    opcode->Lemexe = "CMPI";
+
+                    ExpectIdentifier(ForwardParser, 0);
+
+                    PC += 2;
+                }
+                else {
+                    ExpectRegister();
+
+                    PC++;
+                }
+            }
+            break;
+        case ADD:
+        case SUB:
+        case AND:
+        case OR:
+        case XOR:
+            PC++;
+
+            ExpectRegister();
+
+            ExpectPuncuation(Comma, RemoveExpected);
+
+            ExpectRegister();
+
+            PC++;
+            break;
+        case SHL:
+        case SHR:
+            PC++;
+            ExpectRegister();
+
+            ExpectPuncuation(Comma, RemoveExpected);
+
+            if (PeekToken()->Class != NumberClass) {
+                fprintf(stderr, "[Line %d] Syntax error, expected numeric literal.\n", PeekToken()->LineNumber);
+
+                exit(12);
+            }
+
+            AdvanceParser();
+
+            PC += 2;
+            break;
+        case INC:
+        case DEC:
+        case PUSH:
+        case POP:
+            PC++;
+            ExpectRegister();
+            break;
+        case JMP:
+            {
+                PC++;
+
+                Token* arg = PeekToken();
+
+                if (arg->Class & IdentifierClass) {
+                    ExpectIdentifier(ForwardParser, 0);
+
+                    opcode->Value.Mnemonic = JMP;
+                    opcode->Lemexe = "jmp";
+
+                    PC += 2;
+                }
+                else 
+                {
+                    ExpectPuncuation(LBracket, RemoveExpected);
+
+                    ExpectRegister();
+
+                    ExpectPuncuation(RBracket, RemoveExpected);
+
+                    opcode->Value.Mnemonic = JMPI;
+                    opcode->Lemexe = "jmpi";                    
+                }
+            }
+            break;
+        case JZ:
+            {
+                PC++;
+
+                ExpectIdentifier(ForwardParser, 0);
+
+                PC += 2;
+
+                opcode->Value.Mnemonic = JZ;
+                opcode->Lemexe = "jz";
+            }        
+            break;
+        case JG:
+            {
+                PC++;
+
+                ExpectIdentifier(ForwardParser, 0);
+
+                PC += 2;
+
+                opcode->Value.Mnemonic = JG;
+                opcode->Lemexe = "jg";
+            }
+            break;
+        case JL:
+            {
+                PC++;
+
+                ExpectIdentifier(ForwardParser, 0);
+
+                PC += 2;
+
+                opcode->Value.Mnemonic = JL;
+                opcode->Lemexe = "jl";
+            }
+            break;
+        case CALL:
+            {
+                PC++;
+
+                Token* arg = PeekToken();
+
+                if ((arg->Class & IdentifierClass) == 0) {
+                    fprintf(stderr, "Syntax error on line %d: expected subroutine call target.\n", opcode->LineNumber);
+
+                    exit(1);
+                }
+
+                ExpectIdentifier(ForwardParser, 0);
+
+                PC += 2;
+            }
+            break;
+        default:
+            break;
+    }
+
+    ExpectLineEndOrFileEnd(ForwardParser);
+    
+    return opcode;
+}
+
+void ExpectPuncuation(TokenPunctuation punctuation, ExpectOptions options) {
+    Token* token = PeekToken();
+
+    if (token->Class != PunctuationClass || token->Value.Punctuation != punctuation) {
+        fprintf(stderr, "[Line %d] Syntac error, expected %c.\n", token->LineNumber, punctuation);
+        exit(1);
+    }
+
+    if (options & RemoveExpected) RemoveCurrentToken();
+    if (options & ForwardParser) AdvanceParser();
+}
+
+void ExpectRegister() {
+    Token* token = PeekToken();
+
+    if (token->Class != RegisterClass) {
+        fprintf(stderr, "[Line %d] Syntax error, expected Register.\n", token->LineNumber);
+        exit(2);
+    }
+
+    AdvanceParser();
+}
+
+Symbol* ExpectIdentifier(ExpectOptions options, int expectUnresolved) {
+    Token* token = PeekToken();
+
+    if (token->Class != IdentifierClass) {
+        fprintf(stderr, "[Line %d] Expected Identifier.\n", token->LineNumber);
+        exit(3);
+    }
+
+    Symbol* symbol;
+
+    int found = TryGetSymbol(token->Lemexe, SymbolsTable, &symbol);
+
+    if (found && TryGetSymbolValue(symbol, SymbolsTable, NULL) && expectUnresolved) {
+        fprintf(stderr, "[Line %d] Redefinition of symbol '%s'.\n", token->LineNumber, token->Lemexe);
+        exit(4);
+    }
+
+    if (!found) symbol = AddSymbolToTable(token->Lemexe, PC, SymbolsTable);
+    if (expectUnresolved) symbol->Token = token;
+
+    if (options & RemoveExpected) RemoveCurrentToken();
+    if (options & ForwardParser) AdvanceParser();
 
     return symbol;
 }
+
+void ExpectCharacterClass(Symbol* symbol) {
+    Token* token = PeekToken();
+
+    if (token->Class != CharacterClass) {
+        fprintf(stderr, "[Line %d] Syntax error, expected character string.\n", token->LineNumber);
+        exit(5);
+    }
+
+    symbol->Length = strlen(token->Lemexe);
+    symbol->Token = token;
+
+    RemoveCurrentToken(); //Remove the string declared by this DB command.
+
+    token = PeekToken();
+
+    if (token->EndOfFile) return;
+
+    if (token->Class == PunctuationClass && token->Value.Punctuation == NewLine) {
+        RemoveCurrentToken();
+        return;
+    }
+    
+    ExpectPuncuation(Comma, RemoveExpected);
+
+    token = PeekToken();
+
+    if (token->Class != NumberClass) {
+        fprintf(stderr, "[Line %d] Syntax error, expected terminating byte.\n", token->LineNumber);
+        exit(7);
+    }
+
+    RemoveCurrentToken(); //Remove terminating byte.
+    //TODO: add the raw value of the byte to the end of the string, but for now just pretend all numbers are zero.
+    symbol->Length++;
+
+    ExpectLineEndOrFileEnd(RemoveExpected);
+}
+
+Token* ExpectLineEndOrFileEnd(ExpectOptions options) {
+    Token* token = PeekToken();
+
+    if (token->EndOfFile) return token;
+
+    if (token->Class != PunctuationClass || token->Value.Punctuation != NewLine) {
+        fprintf(stderr, "[Line %d] Syntax error, expected line break.\n", token->LineNumber);
+        exit(9);
+    }
+
+    if (options & RemoveExpected) RemoveCurrentToken();
+    if (options & ForwardParser) AdvanceParser();
+
+    return token;
+}
+
+void PrintSymbols(void) {
+    char mn[12];
+    printf("-----SYMBOLS-----\n");
+    for(int i = 0; i < SymbolsTable->Size; i++) {
+        Symbol* symbol = SymbolsTable->Symbols[i];
+        unsigned short value = 0;
+        int resolved = SymbolResolved(symbol, SymbolsTable);
+
+        if (resolved) TryGetSymbolValue(symbol, SymbolsTable, &value);
+
+        printf("[%s] %s [Value: %d]", resolved == 0 ? "Unresolved" : "Resolved", symbol->Name, value);
+
+        if (symbol->Token && symbol->Token->Class == MnemonicClass) 
+        {
+            GetMnemonicText(symbol->Token->Value.Mnemonic, mn);
+            printf(" -> [%s]", mn);
+        }
+
+        if (symbol->Token) printf(" Line %d", symbol->Token->LineNumber);
+
+        printf("\n");
+    }
+    printf("-----SYMBOLS-----\n");
+}
+
+void AdvanceParser(void) {
+    if (ParserAtEnd()) return;
+
+    CurrentToken++;
+}
+
+int ParserAtEnd(void) {
+    if (CurrentToken >= TokensList->size) return 1;
+
+    return 0;
+}
+
+Token* PeekToken(void) {
+    return TokensList->content[CurrentToken];
+}
+
+void IgnoreParserLine(void) {
+    while(!ParserAtEnd()) {
+        if (PeekToken()->Class == PunctuationClass && PeekToken()->Value.Punctuation == NewLine) {
+            AdvanceParser();
+            break;
+        }
+
+        if (PeekToken()->EndOfFile) break;
+
+        AdvanceParser();
+    }
+}
+
+void RemoveCurrentToken(void) {
+    RemoveToken(CurrentToken, TokensList);
+}
+
+TokenNode* ParseSymbolExpression(void) {
+    TokenNode* root = CreateTokenNode(ExpectMathOperand(RemoveExpected));
+    
+    while(!ParserAtEnd()) {
+        if (PeekToken()->Class == PunctuationClass && PeekToken()->Value.Punctuation == NewLine) {
+
+            ExpectPuncuation(NewLine, RemoveExpected);
+
+            break;
+        }
+
+        TokenNode* value = CreateTokenNode(ExpectMathOperand(RemoveExpected));
+        TokenNode* operation = CreateTokenNode(ExpectMathOperator(RemoveExpected));
+        
+        operation->Left = root;
+        operation->Right = value;
+        root = operation;
+    }
+    
+    return root;
+}
+
+Token* ExpectMathOperator(ExpectOptions options) {
+    if (ParserAtEnd()) {
+        fprintf(stderr, "Syntax error, expected math operator but found unexpected end of file.\n");
+        exit (1);
+    }
+
+    Token* current = PeekToken();
+
+    if (current->Class != PunctuationClass) {
+        fprintf(stderr, "[Line %d] Syntax error, expected math operator.\n", current->LineNumber);
+        exit (1);
+    }
+
+    switch (current->Value.Punctuation) {
+        case Plus:
+        case Minus:
+        case Star:
+        case Slash:
+        case Power:
+            break;
+        default:
+            fprintf(stderr, "[Line %d] Syntax error, expected math operator 2.\n", current->LineNumber);
+            exit(1);
+    }
+
+    if (options & RemoveExpected) RemoveCurrentToken();
+    if (options & ForwardParser) AdvanceParser();
+
+    return current;
+}
+
+Token* ExpectMathOperand(ExpectOptions options) {
+    if (ParserAtEnd()) {
+        fprintf(stderr, "Syntax error, expected math operand but found unexpected end of file.\n");
+        exit (1);
+    }
+
+    Token* token = PeekToken();
+
+    if (token->Class != NumberClass && token->Class != IdentifierClass) {
+        fprintf(stderr, "[Line %d] Syntax error, expected a number or identifier.\n", token->LineNumber);
+        exit (1);
+    }
+    
+    if (options & RemoveExpected) RemoveCurrentToken();
+    if (options & ForwardParser) AdvanceParser();
+
+    return token;
+}

src/scanner.c

@@ -1,13 +1,16 @@
 #include "../includes/scanner.h"
+#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
+#include <limits.h>
 
 const char* SourceCode;
-int Line = 0;
+int Line = 1;
 int Position = 0;
 int SourceLength = 0;
 int ScannerAtEnd(void);
 int IsPunctuation(char);
+int IsWhiteSpace(char);
 char PeekScanner(void);
 char PeekAheadScanner(void);
 void AdvanceScanner(void);
@@ -18,8 +21,8 @@ Token* ParseNumber(void);
 Token* ParsePunctuation(char);
 void IgnoreLine(void);
 
-List* GenerateTokenList(const char* source) {
+TokenList* GenerateTokenList(const char* source) {
-    List* tokens = CreateList();
+    TokenList* tokens = CreateTokenList();
     Token* token = NULL;
 
     if (!tokens) return NULL;
@@ -34,39 +37,60 @@ List* GenerateTokenList(const char* source) {
             case ' ':
             case '\r':
             case '\t':
+            case '\v':
+            case '\f':
                 AdvanceScanner();
                 break; //Ignore whitespace
             case '\n':
+                if (tokens->size > 0) {
+                    token = tokens->content[tokens->size - 1];
+
+                    if (token->Class == PunctuationClass && token->Value.Punctuation == NewLine) {
+                        AdvanceScanner();
+                        Line++;
+                        continue;
+                    }
+                }
+
+                token = CreateToken(Line, PunctuationClass);
+                token->Value.Punctuation = NewLine;
+                AddToken(token, tokens);
                 AdvanceScanner();
                 Line++;
                 break;
             case ';':
                 IgnoreLine();
+
+                if (tokens->size == 0) {
+                    //There's nothing here so that means this is some comments block at the start of the file.
+                    AdvanceScanner(); //Consume the actual new line char.
+                    Line++;
+                }
                 break;
-            case '.': //directive like ".org" or ".db"
+            case '.': //directive like ".include" or ".db"
                 token = ParseDirective();
-                if (token) AddListItem(token, sizeof(Token), tokens);
+                if (token) AddToken(token, tokens);
                 break;
             case '"':
                 token = ParseString();
-                if (token) AddListItem(token, sizeof(Token), tokens);
+                if (token) AddToken(token, tokens);
                 break;
             default:
                 if (isdigit(c)) {
-                    AddListItem(ParseNumber(), sizeof(Token), tokens);
+                    AddToken(ParseNumber(), tokens);
 
                     break;
                 }
 
                 if (IsPunctuation(c)) {
                     AdvanceScanner();
-                    AddListItem(ParsePunctuation(c), sizeof(Token), tokens);
+                    AddToken(ParsePunctuation(c), tokens);
                     break;
                 }
 
                 token = ParseIdentifier();
 
-                if (token) AddListItem(token, sizeof(Token), tokens);
+                if (token) AddToken(token, tokens);
 
                 break;
         }
@@ -74,20 +98,45 @@ List* GenerateTokenList(const char* source) {
         token = NULL;
     }
 
+    if (tokens->size > 0) {
+        token = tokens->content[tokens->size - 1];
+
+        if (token->Class == PunctuationClass && token->Value.Punctuation == NewLine) {
+            //If the last token is a line break, remove it as its not too meaningful.
+            tokens->size--;
+        }
+    }
+
+    token = CreateToken(Line, PunctuationClass);
+
+    token->EndOfFile = 1;
+
+    AddToken(token, tokens);
+
     return tokens;
 }
 
 Token* ParseNumber(void) {
     int start = Position;
-    int base = 10;
 
     while(!ScannerAtEnd() && isdigit(PeekScanner()))
         AdvanceScanner();
 
-    if (PeekScanner() == 'x' && isdigit(PeekAheadScanner())) {
+    if (tolower(PeekScanner()) == 'x') {
-        base = 16;
+        char ahead = tolower(PeekAheadScanner());
+
+        if ((ahead >= 'a' && ahead <= 'f') || isdigit(ahead)) {
             AdvanceScanner(); //Consume the 'x'
-        while(!ScannerAtEnd() && isdigit(PeekScanner())) AdvanceScanner();
+
+            while(!ScannerAtEnd() && PeekScanner() != '\n' && !IsWhiteSpace(PeekScanner()) && PeekScanner() != ';') {
+                if (isdigit(PeekScanner())) { 
+                    AdvanceScanner();
+                    continue;
+                }
+
+                if (tolower(PeekScanner()) >= 'a' && tolower(PeekScanner()) <= 'f') AdvanceScanner();
+            }
+        }
     }
 
     int length = Position - start;
@@ -95,26 +144,26 @@ Token* ParseNumber(void) {
     if (length == 0) return NULL;
 
     char* lexeme = calloc(sizeof(char), length + 1);
-    long* value = calloc(1, sizeof(long));
 
     if (!lexeme) {
         fprintf(stderr, "Failed to calloc space for number. %s.\n", strerror(errno));
         return NULL;
     }
 
-    if (!value) {
-        free(lexeme);
-        fprintf(stderr, "Failed to calloc space for the raw numeric value of a token. %s.\n", strerror(errno));
-        return NULL;
-    }
-
     memcpy(lexeme, &SourceCode[start], length);
     
-    *value = strtol(lexeme, NULL, base);
+    Token* token = CreateToken(Line, NumberClass);
 
-    if (base == 10) return CreateToken(lexeme, value, Line, NUMBER);
+    token->Value.Number = strtol(lexeme, NULL, 0);
 
-    return CreateToken(lexeme, value, Line, HEX);
+    if (errno != 0) {
+        fprintf(stderr, "[Error] Line %d: Invalid number detected. %s.\n", Line, strerror(errno));
+        exit(1);
+    }
+
+    token->Lemexe = lexeme;
+
+    return token;
 }
 
 Token* ParseDirective(void) {
@@ -135,19 +184,23 @@ Token* ParseDirective(void) {
 
     memcpy(directive, &SourceCode[start], length);
 
+    Token* token = CreateToken(Line, DirectiveClass);
+
     if (strcmp(directive, ".db") == 0) {
-        return CreateToken(directive, directive, Line, DB);
+        token->Value.Directive = DB;
+
+        return token;
     }
-    else if (strcmp(directive, ".org") == 0) {
+    else if (strcmp(directive, ".include") == 0) {
-        fprintf(stderr, "[Warning] Org is not a supported directive.\n");
+        token->Value.Directive = Include;
-        free(directive);
+
-        IgnoreLine();
+        return token;
-        return NULL;
     }
 
     fprintf(stderr, "[Error] Unknown assembler directive '%s'\n", directive);
 
     free(directive);
+    free(token);
     
     IgnoreLine();
     
@@ -180,7 +233,9 @@ Token* ParseString(void) {
 
     AdvanceScanner(); //Consume the trailing double quote.
 
-    Token* token = CreateToken(lexeme, lexeme, Line, STRING);
+    Token* token = CreateToken(Line, CharacterClass);
+    
+    token->Lemexe = lexeme;
 
     return token;
 }
@@ -188,7 +243,7 @@ Token* ParseString(void) {
 Token* ParseIdentifier(void) {
     int start = Position;
 
-    while(!ScannerAtEnd() && !IsPunctuation(PeekScanner()) && PeekScanner() != ' ' && PeekScanner() != '\n') {
+    while(!ScannerAtEnd() && !IsPunctuation(PeekScanner()) && PeekScanner() != ' ' && PeekScanner() != '\n' && PeekScanner() != ';') {
         AdvanceScanner();
     }
 
@@ -196,7 +251,8 @@ Token* ParseIdentifier(void) {
 
     if (length == 0) return NULL;
     
-    TokenType type;
+    Mnemonic mnemonics;
+    Registers reg;
     char* lexeme = calloc(sizeof(char), length + 1);
 
     if (!lexeme) {
@@ -206,14 +262,41 @@ Token* ParseIdentifier(void) {
 
     memcpy(lexeme, &SourceCode[start], length);
 
-    if (IsOpcode(lexeme, &type)) return CreateToken(lexeme, lexeme, Line, type);
+    if (IsOpcode(lexeme, &mnemonics)) {
-    if (IsRegister(lexeme, &type)) return CreateToken(lexeme, lexeme, Line, type);
+        Token* token = CreateToken(Line, MnemonicClass);
+
+        token->Value.Mnemonic = mnemonics;
+
+        return token;
+    }
+    if (IsRegister(lexeme, &reg)) {
+        Token* token = CreateToken(Line, RegisterClass);
+        token->Value.Register = reg;
+
+        return token;
+    }
     if (lexeme[length - 1] == ':') {
         lexeme[length - 1] = '\0'; //Bit hacky, but this makes the parser's job a bit easier.
-        return CreateToken(lexeme, lexeme, Line, LABEL);
+        Token* token = CreateToken(Line, LabelClass);
+        
+        token->Lemexe = lexeme;
+
+        return token;
+    }
+    if (strcmp(lexeme, "byte") == 0) {
+        Token* token = CreateToken(Line, DirectiveClass);
+
+        token->Lemexe = lexeme;
+        token->Value.Directive = Byte;
+
+        return token;
     }
 
-    return CreateToken(lexeme, lexeme, Line, IDENTIFIER);
+    Token* token = CreateToken(Line, IdentifierClass);
+    
+    token->Lemexe = lexeme;
+
+    return token;
 }
 
 char PeekScanner(void) {
@@ -245,6 +328,23 @@ int IsPunctuation(char c) {
         case '(':
         case ')':
         case ',':
+        case '-':
+        case '+':
+        case '*':
+        case '/':
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+int IsWhiteSpace(char c) {
+    switch(c) {
+        case ' ':
+        case '\t':
+        case '\v':
+        case '\f':
+        case '\r':
             return 1;
         default:
             return 0;
@@ -252,18 +352,42 @@ int IsPunctuation(char c) {
 }
 
 Token* ParsePunctuation(char c) {
+    TokenPunctuation punctuation;
+
     switch(c) {
         case '[':
-            return CreateToken("[", NULL, Line, LBRACKET);
+            punctuation = LBracket;
+            break;
         case ']':
-            return CreateToken("]", NULL, Line, RBracket);
+            punctuation = RBracket;
+            break;
         case '(':
-            return CreateToken("(", NULL, Line, LPARAM);
+            punctuation = LParan;
+            break;
         case ')':
-            return CreateToken(")", NULL, Line, RPARAM);
+            punctuation = RParan;
+            break;
         case ',':
-            return CreateToken(",", NULL, Line, COMMA);
+            punctuation = Comma;
+            break;
+        case '-':
+            punctuation = Minus;
+            break;
+        case '+':
+            punctuation = Plus;
+            break;
+        case '*':
+            punctuation = Star;
+            break;
+        case '/':
+            punctuation = Slash;
+            break;
         default:
             return NULL;
     }
+
+    Token* token = CreateToken(Line, PunctuationClass);
+    token->Value.Punctuation = punctuation;
+
+    return token;
 }

src/symbols_table.c

@@ -0,0 +1,202 @@
+#include "../includes/symbols_table.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int SymbolResolved(const Symbol* symbol, const SymbolTable* table) {
+    if (!symbol) return 0;
+
+    const Token* token = symbol->Token;
+
+    if (!token) return 0;
+
+    if (token->Class == LabelClass || token->Class == CharacterClass || token->Class == MnemonicClass) return 1;
+
+    return TryGetSymbolValue(symbol, table, NULL);
+}
+
+SymbolTable* CreateSymbolTable(void){
+    SymbolTable* table = calloc(1, sizeof(SymbolTable));
+
+    if (!table) {
+        fprintf(stderr, "Failed to calloc memory for a SymbolTable. %s.\n", strerror(errno));
+        return NULL;
+    }
+
+    table->Symbols = calloc(SYMBOLSTABLE_DEFAULT_CAPACITY, sizeof(Symbol*));
+
+    if (!table->Symbols) {
+        fprintf(stderr, "Failed to calloc Symbol list. %s.\n", strerror(errno));
+        free(table);
+        return NULL;
+    }
+
+    table->Capacity = SYMBOLSTABLE_DEFAULT_CAPACITY;
+    table->Size = 0;
+
+    return table;
+}
+
+Symbol* CreateSymbol(const char* name, int address) {
+    Symbol* symbol = calloc(1, sizeof(Symbol));
+
+    if (!symbol) {
+        fprintf(stderr, "Failed to create Symbol '%s'. %s.\n", name, strerror(errno));
+
+        return NULL;
+    }
+
+    symbol->Address = address;
+    symbol->Name = name;
+    //symbol->Type = RefUnknown;
+
+    return symbol;
+}
+
+int TryGetSymbol(const char* name, const SymbolTable* table, Symbol** outSymbol) {
+    *outSymbol = NULL;
+
+    if (!name || !table) return 0;
+
+    for(int i = 0; i < table->Size; i++) {
+        if (strcmp(table->Symbols[i]->Name, name) == 0) {
+            *outSymbol = table->Symbols[i];
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+Symbol* AddSymbolToTable(const char* name, int address, SymbolTable* table) {
+    //if (!name || !value || !table || length == 0) return NULL;
+
+    for(int i = 0; i < table->Size; i++) {
+        if (strcmp(table->Symbols[i]->Name, name) == 0) {
+            //TODO: Do we update or throw some kind of an error?
+
+            return table->Symbols[i];
+        }
+    }
+
+    if (table->Capacity < table->Size + 1) {
+        Symbol** newBlock = realloc(table->Symbols, sizeof(Symbol*) * table->Capacity * 2);
+
+        if (!newBlock) {
+            fprintf(stderr, "Failed to realloc space for a new symbol '%s'. %s.\n", name, strerror(errno));
+
+            return NULL;
+        }
+
+        table->Capacity *= 2;
+        table->Symbols = newBlock;
+    }
+
+    Symbol* symbol = CreateSymbol(name, address);
+
+    table->Symbols[table->Size] = symbol;
+    table->Size++;
+
+    return symbol;
+}
+
+void FreeSymbolTable(SymbolTable* table) {
+    if (!table) return;
+
+    for(int i = 0; i < table->Size; i++) FreeSymbol(table->Symbols[i]);
+
+    free(table);
+}
+
+void FreeSymbol(Symbol* symbol) {
+    if (!symbol) return;
+
+    free(symbol);
+}
+
+int TryGetTokenNodeValue(const TokenNode* node, const SymbolTable* table, unsigned short* value);
+unsigned short DoOp(unsigned short left, unsigned short right, TokenPunctuation op);
+
+int TryGetSymbolValue(const Symbol* symbol, const SymbolTable* table, unsigned short* value) {
+    if (!symbol || !symbol->Token || !table) return 0;
+
+    TokenNode* root = symbol->ValueExpression;
+    Symbol* s = NULL;
+    if (value) *value = 0;
+
+    if (!root || !root->Token) return 0;
+
+    switch (root->Token->Class) {
+        case NumberClass:
+            if (value) *value = root->Token->Value.Number;
+
+            return 1;
+        case IdentifierClass:
+            if (!TryGetSymbol(root->Token->Lemexe, table, &s)) return 0;
+
+            return TryGetTokenNodeValue(s->ValueExpression, table, value);
+        case PunctuationClass:
+            return TryGetTokenNodeValue(root, table, value);
+        default:
+            return 0;
+    }
+}
+
+int TryGetTokenNodeValue(const TokenNode* node, const SymbolTable* table, unsigned short* value) {
+	const Token* token = node->Token;
+    Symbol* symbol = { 0 };
+
+	if (token->Class == NumberClass) {
+		if (value) *value = token->Value.Number;
+		return 1;
+	}
+
+    if (token->Class == IdentifierClass) {
+        if (!TryGetSymbol(token->Lemexe, table, &symbol)) return 0;
+
+        return TryGetTokenNodeValue(symbol->ValueExpression, table, value);
+    }
+
+    if (token->Class != PunctuationClass) return 0;
+
+    unsigned short left = 0;
+    unsigned short right = 0;
+
+    if (!TryGetTokenNodeValue(node->Left, table, &left)) return 0;
+    if (!TryGetTokenNodeValue(node->Right, table, &right)) return 0;
+
+    if (value) *value = DoOp(left, right, token->Value.Punctuation);
+
+    return 1;
+}
+
+TokenNode* CreateTokenNode(const Token* token){
+    TokenNode* node = calloc(1, sizeof(TokenNode));
+
+    if (!node) {
+        fprintf(stderr, "Failed to calloc memory for a TokenNode. %s.\n", strerror(errno));
+        return NULL;
+    }
+
+    node->Token = token;
+
+    return node;
+}
+
+
+unsigned short DoOp(unsigned short left, unsigned short right, TokenPunctuation op) {
+    switch (op) {
+        case Plus:
+            return left + right;
+        case Minus:
+            return left - right;
+        case Star:
+            return left * right;
+        case Slash:
+            return left / right;
+        default:
+            break;
+    }
+
+    return 0;
+}

src/token.c

@@ -1,6 +1,8 @@
 #include "../includes/token.h"
 
-Token* CreateToken(char* lexeme, void* value, int lineNumber, TokenType type) {
+#define LISTDEFAULTSIZE 32
+
+Token* CreateToken(int lineNumber, TokenClass tokenClass) {
     Token* token = calloc(1, sizeof(Token));
 
     if (!token) { 
@@ -8,10 +10,8 @@ Token* CreateToken(char* lexeme, void* value, int lineNumber, TokenType type) {
         return NULL;
     }
 
-    token->type = type;
+    token->Class = tokenClass;
-    token->line = lineNumber;
+    token->LineNumber = lineNumber;
-    token->lexeme = lexeme;
-    token->value = value;
 
     return token;
 }
@@ -19,7 +19,68 @@ Token* CreateToken(char* lexeme, void* value, int lineNumber, TokenType type) {
 void FreeToken(Token* token) {
     if (!token) return;
 
-    if (token->value && token->type >= STRING) free(token->value);
-
     free(token);
 }
+
+TokenList* CreateTokenList(void) {
+    TokenList *new = malloc(sizeof(TokenList));
+
+    if (!new) {
+        fprintf(stderr, "Failed to malloc() for new new List.\n");
+        return NULL;
+    }
+
+    new->content = calloc(LISTDEFAULTSIZE, sizeof(void*));
+
+    if (!new->content) {
+        fprintf(stderr, "Failed to malloc() memory for List contents.\n");
+        free(new);
+        return NULL;
+    }
+
+    new->size = 0;
+    new->capacity = LISTDEFAULTSIZE;
+
+    return new;
+}
+
+int AddToken(Token* token, TokenList* list) {
+    if (!list || !token) return 0;
+
+    if (list->capacity < list->size + 1) {
+        void* ptr = realloc(list->content, sizeof(void*) * list->capacity * 2);
+        //Note: realloc will free list->root if it succeeds.
+        if (!ptr) {
+            fprintf(stderr, "Failed to resize array with realloc() (%d bytes).\n", list->capacity * 2);
+            return 0;
+        }
+
+        list->content = ptr;
+        list->capacity *= 2;
+    }
+
+    if (list->size > 0) 
+    {
+        Token* prev = list->content[list->size - 1];
+
+        token->Prev = prev;
+        prev->Next = token;
+    }    
+
+    list->content[list->size] = token;
+    list->size++;
+
+    return 1;
+}
+
+void RemoveToken(int index, TokenList* list) {
+    Token* token = list->content[index];
+
+    if (token->Prev) token->Prev->Next = token->Next;
+
+    memmove(&list->content[index], &list->content[index + 1], (list->size - index) * sizeof(Token*));
+
+    list->size--;
+
+    list->content[list->size] = NULL;
+}