;; Copyright (C) 2017 Jeremiah Orians
;; This file is part of stage0.
;;
;; stage0 is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;;
;; stage0 is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with stage0.  If not, see <http://www.gnu.org/licenses/>.

	section .text
	global _start

	;; Register usage:
	;; EAX => Temps

	;; Struct TYPE format: (size 28)
	;; NEXT => 0
	;; SIZE => 4
	;; OFFSET => 8
	;; INDIRECT => 12
	;; MEMBERS => 16
	;; TYPE => 20
	;; NAME => 24

	;; Struct TOKEN_LIST format: (size 20)
	;; NEXT => 0
	;; LOCALS/PREV => 4
	;; S => 8
	;; TYPE => 12
	;; ARGS/DEPTH => 16

; Where the ELF Header is going to hit
; Simply jump to _start
; Our main function
_start:
	pop eax                     ; Get the number of arguments
	pop ebx                     ; Get the program name
	pop ebx                     ; Get the actual input name
	mov ecx, 0                  ; prepare read_only
	mov eax, 5                  ; the syscall number for open()
	int 0x80                    ; Now open that damn file
	mov [Input_file], eax       ; Preserve the file pointer we were given

	pop ebx                     ; Get the actual output name
	mov ecx, 577                ; Prepare file as O_WRONLY|O_CREAT|O_TRUNC
	mov edx, 384                ; Prepare file as RW for owner only (600 in octal)
	mov eax, 5                  ; the syscall number for open()
	int 0x80                    ; Now open that damn file
	cmp eax, 0                  ; Check for missing output
	jg _start_out               ; Have real input
	mov eax, 1                  ; Use stdout

_start_out:
	mov [Output_file], eax      ; Preserve the file pointer we were given

	mov eax, 45                 ; the Syscall # for SYS_BRK
	mov ebx, 0                  ; Get current brk
	int 0x80                    ; Let the kernel do the work
	mov [MALLOC], eax           ; Set our malloc pointer
	mov eax, 0                  ; HEAD = NULL
	call read_all_tokens        ; Read all tokens
	call Reverse_List           ; Reverse order
;	call debug_list             ; Try to figure out what is wrong
	mov [global_token], eax     ; Set global_token
	call program                ; Convert into program
	mov eax, header_string1     ; Our header string
	call File_Print             ; Print it
	mov eax, [output_list]      ; Our output_list
	call recursive_output       ; Print core program
;	mov eax, header_string2     ; Our Enable debug
;	call File_Print             ; Print it
	mov eax, header_string3     ; Our second label
	call File_Print             ; Print it
	mov eax, [globals_list]     ; Our globals
	call recursive_output       ; Get them
	mov eax, header_string4     ; Our final header
	call File_Print             ; Print it
	mov eax, [strings_list]     ; Our strings
	call recursive_output       ; Get them
	mov eax, header_string5     ; Make this a bare assembly
	call File_Print             ; Print it

Done:
	; program completed Successfully
	mov ebx, 0                  ; All is well
	mov eax, 1                  ; put the exit syscall number in eax
	int 0x80                    ; Call it a good day

header_string1: db 10, "# Core program", 10, 0
header_string2: db 10, ":ELF_data", 10, 0
header_string3: db 10, "# Program global variables", 10, 0
header_string4: db 10, "# Program strings", 10, 0
header_string5: db 10, ":ELF_end", 10, 0


;; read_all_tokens function
;; Receives Token_List* in EAX
;; Tokenizes all input and returns updated list in EAX
;; Returns TOKEN in EAX
;; Uses EAX for C
read_all_tokens:
	mov [Token], eax
	call fgetc
read_all_tokens_loop:
	cmp eax, -4                 ; Check for EOF
	je read_all_tokens_done     ; Stop if found
	call get_token              ; Read all tokens
	jmp read_all_tokens_loop    ; Loop
read_all_tokens_done:
	mov eax, [Token]
	ret


;; get_token function
;; Receives INT in EAX
;; Makes a list of TOKEN_LIST
;; C and STRING_INDEX are stored in memory, ECX is used for S and EDX is used for current
;; Returns C in EAX
get_token:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX

	mov [C], eax                ; Set C

	mov eax, 20                 ; Malloc CURRENT
	call malloc                 ; Get Pointer
	mov edx, eax                ; Set CURRENT

	mov eax, 256                ; Malloc the string
	call malloc                 ; Get pointer to S
	mov ecx, eax                ; Set S
	mov [edx+8], ecx            ; CURRENT->S = S
reset:
	mov [string_index], ecx     ; S[0]
	mov eax, [C]                ; Using C

	call clear_white_space      ; Clear WhiteSpace
	mov [C], eax                ; Set C

	cmp eax, -4                 ; Check for EOF
	je get_token_abort          ; if EOF abort

	cmp eax, 35                 ; Check for '#'
	jne get_token_alpha         ; Nope

	;; Deal with # line comments
	call purge_macro            ; Let it handle it
	mov [C], eax                ; Set C
	jmp reset                   ; Try again

get_token_alpha:
	mov eax, [C]                ; Send C
	mov ebx, alphas             ; Get alphanumerics
	call In_Set                 ; See if in set
	cmp eax, 1                  ; IF TRUE
	jne get_token_symbol        ; Otherwise

	;; Store keywords
	mov eax, [C]                ; Send C
	call preserve_keyword       ; Store
	mov [C], eax                ; Set C
	jmp get_token_done          ; Be done with this token

get_token_symbol:
	mov eax, [C]                ; Send C
	mov ebx, symbols            ; Get symbols
	call In_Set                 ; See if in set
	cmp eax, 1                  ; IF TRUE
	jne get_token_strings       ; Otherwise

	;; Store symbols
	mov eax, [C]                ; Send C
	call preserve_symbol        ; Store
	mov [C], eax                ; Set C
	jmp get_token_done          ; Be done with this token

get_token_strings:
	mov eax, [C]                ; Send C
	mov ebx, strings            ; Get strings
	call In_Set                 ; See if in set
	cmp eax, 1                  ; IF TRUE
	jne get_token_comment       ; Otherwise

	;; Store String
	mov eax, [C]                ; Send C
	call consume_word           ; Store
	mov [C], eax                ; Set C
	jmp get_token_done          ; Be done with this token

get_token_comment:
	mov eax, [C]                ; Send C
	cmp eax, 47                 ; IF '/' == C
	jne get_token_else          ; Otherwise

	call consume_byte           ; Hope it just is '/'
	mov [C], eax                ; Set C

	cmp eax, 42                 ; IF '*' we have '/*'
	jne get_token_comment_line  ; Check for '//'

	;; Deal with /* block comments */
	call fgetc                  ; get next C
	mov [C], eax                ; Set C
get_token_comment_block_outer:
	mov eax, [C]                ; Using C
	cmp eax, 47                 ; IF '/' != C
	je get_token_comment_block_done ; be done

get_token_comment_block_inner:
	mov eax, [C]                ; Using C
	cmp eax, 42                 ; IF '*' != C
	je get_token_comment_block_iter ; jump over

	;; Deal with inner loop
	call fgetc                  ; get next C
	mov [C], eax                ; Set C
	jmp get_token_comment_block_inner ; keep going

get_token_comment_block_iter:
	call fgetc                  ; get next C
	mov [C], eax                ; Set C
	jmp get_token_comment_block_outer

get_token_comment_block_done:
	call fgetc                  ; get next C
	mov [C], eax                ; Set C
	jmp reset                   ; throw away, try again

get_token_comment_line:
	cmp eax, 47                 ; IF '/' we have //
	jne get_token_done          ; keep if just '/'

	;; Deal with // line comment
	call fgetc                  ; drop to match
	mov [C], eax                ; Set C
	jmp reset                   ; throw away, try again

get_token_else:
	mov eax, [C]                ; Send C
	call consume_byte
	mov [C], eax                ; Set C

get_token_done:
	mov eax, [Token]            ; TOKEN
	mov [edx+4], eax            ; CURRENT->PREV = TOKEN
	mov [edx], eax              ; CURRENT->NEXT = TOKEN
	mov [Token], edx            ; TOKEN = CURRENT

get_token_abort:
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	mov eax, [C]                ; Return C
	ret


;; Malloc isn't actually required if the program being built fits in the initial memory
;; However, it doesn't take much to add it.
;; Requires [MALLOC] to be initialized and EAX to have the number of desired bytes
malloc:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	mov ebx, [MALLOC]           ; Using the current pointer
	add ebx, eax                ; Request the number of desired bytes
	mov eax, 45                 ; the Syscall # for SYS_BRK
	int 0x80                    ; call the Kernel
	mov eax, [MALLOC]           ; Return pointer
	mov [MALLOC], ebx           ; Update pointer
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; clear_white_space function
;; Receives INT C in EAX
;; Returns first non-whitespace char in EAX
clear_white_space:
	cmp eax, 32                 ; Check for ' '
	je clear_white_space_wipe   ; wipe it out

	cmp eax, 10                 ; Check for '\n'
	je clear_white_space_wipe   ; wipe it output

	cmp eax, 9                  ; Check for '\t'
	jne clear_white_space_done  ; looks like non-whitespace

clear_white_space_wipe:
	call fgetc                  ; Read a new byte
	cmp eax, -4                 ; Check for EOF
	je clear_white_space_done   ; Short circuit
	jmp clear_white_space       ; iterate

clear_white_space_done:
	ret


;; In_Set function
;; Receives Char C in EAX and CHAR* in EBX
;; Returns 1 if true, zero if false in EAX
In_Set:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
In_Set_loop:
	mov cl, [ebx]               ; Read char
	movzx ecx, cl               ; Zero extend it

	cmp eax, ecx                ; See if they match
	je In_Set_True              ; return true

	cmp ecx, 0                  ; Check for NULL
	je In_Set_False             ; return false

	add ebx, 1                  ; s = s + 1
	jmp In_Set_loop             ; Keep looping

In_Set_True:
	mov eax, 1                  ; Set True
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

In_Set_False:
	mov eax, 0                  ; Set FALSE
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

alphas: db "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz", 0
symbols: db "<=>|&!-", 0
strings: db 34, 39, 0


;; purge_macro function
;; Receives CH in EAX
;; Reads chars until Line feed is read
;; returns line feed
purge_macro:
	call fgetc                  ; read next char
	cmp eax, 10                 ; Check for '\n'
	jne purge_macro             ; Keep going
	ret


;; preserve_keyword function
;; Receives INT C in EAX
;; collects all chars in keyword
;; Returns C in EAX
;; Uses ECX for INT C
preserve_keyword:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ecx, eax                ; Setup C
	mov ebx, alphas             ; Concerning ourselves with "abc.."
preserve_keyword_loop:
	call In_Set                 ; Check if alphanumerics
	cmp eax, 1                  ; IF TRUE
	jne preserve_keyword_label  ; Otherwise check for label

	mov eax, ecx                ; Pass C
	call consume_byte           ; consume that byte
	mov ecx, eax                ; Update C
	jmp preserve_keyword_loop   ; keep looping

preserve_keyword_label:
	mov eax, ecx                ; Fix return
	cmp eax, 58                 ; Check for ':'
	jne preserve_keyword_done   ; be done

	;; Fix our goto label
	call fixup_label            ; Fix the label
	mov eax, 32                 ; Return Whitespace

preserve_keyword_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; preserve_symbol function
;; Receives INT C in EAX
;; collects all chars in symbol
;; Returns C in EAX
;; Uses ECX for INT C
preserve_symbol:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ecx, eax                ; Setup C
	mov ebx, symbols            ; Concerning ourselves with "<=>.."
preserve_symbol_loop:
	call In_Set                 ; Check if symbol
	cmp eax, 1                  ; IF TRUE
	jne preserve_symbol_done    ; Otherwise be done

	mov eax, ecx                ; Pass C
	call consume_byte           ; consume that byte
	mov ecx, eax                ; Update C
	jmp preserve_symbol_loop    ; keep looping

preserve_symbol_done:
	mov eax, ecx                ; Fix return
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; consume_word function
;; receives INT C in EAX
;; returns INT C in EAX
;; Uses EAX for C, EBX for FREQ and ECX for ESCAPE
consume_word:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ebx, eax                ; FREQ = C
	mov ecx, 0                  ; ESCAPE = FALSE
consume_word_loop:
	cmp ecx, 0                  ; IF !ESCAPE
	jne consume_word_escape     ; Enable escape

	cmp eax, 92                 ; if '\\'
	jne consume_word_iter       ; keep state

	mov ecx, 1                  ; ESCAPE = TRUE
	jmp consume_word_iter       ; keep going

consume_word_escape:
	mov ecx, 0                  ; ESCAPE = FALSE

consume_word_iter:
	call consume_byte           ; read next char

	cmp ecx, 0                  ; IF ESCAPE
	jne consume_word_loop       ; keep looping

	cmp eax, ebx                ; IF C != FREQ
	jne consume_word_loop       ; keep going

	call fgetc                  ; return next char
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; consume_byte function
;; Receives INT C in EAX
;; Inserts C into string S, updates String S
;; Returns Next char in EAX
consume_byte:
	push ebx                    ; Protect EBX
	mov ebx, [string_index]     ; S[0]
	mov [ebx], al               ; S[0] = C
	add ebx, 1                  ; S = S + 1
	mov [string_index], ebx     ; Update S
	call fgetc
	pop ebx                     ; Restore EBX
	ret


;; fixup_label function
;; Receives S in ECX
;; prepends ':' to string and returns registers unchanged
;; Uses EAX for HOLD, EBX for PREV and ECX for S[0]
fixup_label:
	push eax                    ; Protect EAX
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, 58                 ; HOLD = ':'
	mov ecx, [edx+8]            ; HOLD_STRING[0]
fixup_label_loop:
	mov ebx, eax                ; PREV = HOLD
	mov al, [ecx]               ; HOLD = HOLD_STRING[I]
	movzx eax, al               ; make useful
	mov [ecx], bl               ; HOLD_STRING[I] = PREV
	add ecx, 1                  ; I = I + 1
	cmp eax, 0                  ; IF NULL == HOLD
	jne fixup_label_loop        ; Keep looping

	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	pop eax                     ; Restore EAX
	ret


;; fgetc function
;; Loads FILE* from [INPUT_FILE]
;; Returns -4 (EOF) or char in EAX
fgetc:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	mov eax, -4                 ; Put EOF in eax
	push eax                    ; Assume bad (If nothing read, value will remain EOF)
	lea ecx, [esp]              ; Get stack address
	mov ebx, [Input_file]       ; Where are we reading from
	mov eax, 3                  ; the syscall number for read
	mov edx, 1                  ; set the size of chars we want
	int 0x80                    ; call the Kernel
	pop eax                     ; Get either char or EOF
	cmp eax, -4                 ; Check for EOF
	je fgetc_done               ; Return as is
	movzx eax, al               ; Make it useful
fgetc_done:
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; Reverse_List function
;; Receives List in EAX
;; Returns the list reversed in EAX
Reverse_List:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ebx, eax                ; Set HEAD
	mov eax, 0                  ; ROOT = NULL
Reverse_List_Loop:
	cmp ebx, 0                  ; WHILE HEAD != NULL
	je Reverse_List_Done        ; Stop otherwise

	mov ecx, [ebx]              ; NEXT = HEAD->NEXT
	mov [ebx], eax              ; HEAD->NEXT = ROOT
	mov eax, ebx                ; ROOT = HEAD
	mov ebx, ecx                ; HEAD = NEXT
	jmp Reverse_List_Loop       ; Keep Going

Reverse_List_Done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; recursive_output function
;; Receives list in EAX
;; walks the list and prints the I->S for all nodes backwards
;; Uses EBX for I
recursive_output:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	cmp eax, 0                  ; Check for NULL
	je recursive_output_done    ; Skip the work
	mov ebx, eax                ; I = Head

	mov eax, [ebx]              ; Iterate to next Token
	call recursive_output       ; Recurse

	mov eax, [ebx+8]            ; Using S
	call File_Print             ; Print it

recursive_output_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; File_Print function
;; Receives CHAR* in EAX
;; calls fputc for every non-null char
File_Print:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ebx, eax                ; Protect S
	cmp eax, 0                  ; Protect against nulls
	je File_Print_Done          ; Simply don't try to print them
File_Print_Loop:
	mov al, [ebx]               ; Read byte
	movzx eax, al               ; zero extend
	cmp eax, 0                  ; Check for NULL
	je File_Print_Done          ; Stop at NULL

	call fputc                  ; write it
	add ebx, 1                  ; S = S + 1
	jmp File_Print_Loop         ; Keep going

File_Print_Done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; fputc function
;; receives CHAR in EAX and load FILE* from [OUTPUT_FILE]
;; writes char and returns
fputc:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	push eax                    ; We are writing eax
	lea ecx, [esp]              ; Get stack address
	mov ebx, [Output_file]      ; Write to target file
	mov eax, 4                  ; the syscall number for write
	mov edx, 1                  ; set the size of chars we want
	int 0x80                    ; call the Kernel
	pop eax                     ; Restore stack
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; program function
;; receives nothing, returns nothing
;; Uses EAX for type_size
program:
	;; The binary initialized the globals to null, so we can skip those steps
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX

new_type:
	mov eax, [global_token]     ; Using global_token
	cmp eax, 0                  ; Check if NULL
	je program_done             ; Be done if null

	mov ebx, [eax+8]            ; GLOBAL_TOKEN->S
	mov eax, constant           ; "CONSTANT"
	call match                  ; IF GLOBAL_TOKEN->S == "CONSTANT"
	cmp eax, 0                  ; If true
	jne program_else            ; Looks like not a constant

	;; Deal with minimal constant case
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next

	mov eax, [eax+8]            ; global_token->S
	mov ebx, 0                  ; NULL
	mov ecx, [global_constant_list] ; global_constant_list
	call sym_declare            ; Declare that constant
	mov [global_constant_list], eax ; global_constant_list = sym_declare(global_token->s, NULL, global_constant_list);

	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx]              ; global_token->next
	mov [eax+16], ebx           ; global_constant_list->arguments = global_token->next

	mov ebx, [ebx]              ; global_token->next->next
	mov [global_token], ebx     ; global_token = global_token->next->next;
	jmp new_type                ; go around again

program_else:
	call type_name              ; Figure out the type_size
	cmp eax, 0                  ; IF NULL == type_size
	je new_type                 ; it was a new type

	;; Add to global symbol table
	mov ebx, eax                ; put type_size in the right spot
	mov eax, [global_token]     ; Using global token
	mov eax, [eax+8]            ; global_token->S
	mov ecx, [global_symbol_list] ; Using global_symbol_list
	call sym_declare            ; Declare symbol
	mov [global_symbol_list], eax ; global_symbol_list = sym_declare(global_token->s, type_size, global_symbol_list);
	mov ebx, [global_token]     ; Using global token
	mov ebx, [ebx]              ; global_token->next
	mov [global_token], ebx     ; global_token = global_token->next

	mov ebx, [global_token]     ; Using global token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, semicolon          ; ";"
	call match                  ; if(match(";", global_token->s))
	cmp eax, 0                  ; If true
	jne program_function        ; looks like not a match

	;; Deal with the global variable
	mov ebx, [globals_list]     ; Using globals_list
	mov eax, program_string_0   ; ":GLOBAL_"
	call emit                   ; Emit it
	mov ebx, eax                ; update globals_list

	mov eax, [global_token]     ; Using global token
	mov eax, [eax+4]            ; global token->prev
	mov eax, [eax+8]            ; global token->prev->s
	call emit                   ; Emit it

	mov ebx, eax                ; update globals_list
	mov eax, program_string_1   ; "\nNULL\n"
	call emit                   ; Emit it
	mov [globals_list], eax     ; update globals_list

	mov eax, [global_token]     ; Using global token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next
	jmp new_type                ; go around again

program_function:
	mov ebx, [global_token]     ; Using global token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, open_paren         ; "("
	call match                  ; if(match(";", global_token->s))
	cmp eax, 0                  ; If true
	jne program_error           ; Otherwise deal with error case

	;; Deal with function definition
	call declare_function       ; Lets get the parsing rolling
	jmp new_type                ; Keep looping through functions

program_error:
	;; Deal with the case of something we don't support
	;; NOT IMPLEMENTED

program_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

;; Strings needed by the program function
program_string_0: db ":GLOBAL_", 0
program_string_1: db 10, "NULL", 10, 0


;; declare_function function
;; Receives nothing and returns nothing
;; Sets current function and adds it to the global function list
declare_function:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, 0                  ; Using NULL
	mov [current_count], eax    ; current_count = 0

	mov eax, [global_token]     ; Using global token
	mov eax, [eax+4]            ; global token->prev
	mov eax, [eax+8]            ; global token->prev->s
	mov ebx, 0                  ; NULL
	mov ecx, [global_function_list] ; global_function_list
	call sym_declare            ; sym_declare(global_token->prev->s, NULL, global_function_list);
	mov [function], eax         ; function = sym_declare(global_token->prev->s, NULL, global_function_list);
	mov [global_function_list], eax ; global_function_list = function

	call collect_arguments      ; collect all of the function arguments

	mov eax, [global_token]     ; Using global token
	mov eax, [eax+8]            ; global token->s
	mov ebx, semicolon          ; ";"
	call match                  ; IF global token->s == ";"
	cmp eax, 0                  ; If true
	jne declare_function_full   ; It was a prototype

	;; Deal with prototypes
	mov eax, [global_token]     ; Using global token
	mov eax, [eax]              ; global token->next
	mov [global_token], eax     ; global token = global token->next
	jmp declare_function_done   ; Move on

declare_function_full:
	;; Deal with full function definitions
	mov eax, declare_function_string_0 ; "# Defining function "
	call emit_out               ; emit it

	mov eax, [function]         ; function
	mov eax, [eax+8]            ; function->s
	call emit_out               ; emit it

	mov eax, declare_function_string_1 ; "\n:FUNCTION_"
	call emit_out               ; emit it

	mov eax, [function]         ; function
	mov eax, [eax+8]            ; function->s
	call emit_out               ; emit it

	mov eax, declare_function_string_3 ; "\n"
	call emit_out               ; emit it

	call statement              ; Recursively get the function pieces

	mov eax, [output_list]      ; output
	mov eax, [eax+8]            ; output->s
	mov ebx, declare_function_string_2 ; "RETURN\n"
	call match                  ; IF output->s == "RETURN\n"
	cmp eax, 0                  ; If true we can skip adding it
	je declare_function_done    ; otherwise we need to add it

	;; Add the return to the end of a function lacking a return;
	mov eax, declare_function_string_2 ; "RETURN\n"
	call emit_out               ; emit it

declare_function_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

declare_function_string_0: db 35, " Defining function ", 0
declare_function_string_1: db 10, ":FUNCTION_", 0
declare_function_string_2: db "RETURN", 10, 0
declare_function_string_3: db 10, 0


;; collect_arguments function
;; Receives nothing
;; Returns Nothing
;; Adds arguments to the function definition
;; holds struct type* type_size in ECX, then replace with struct token_list* a in ECX when type_size is used
collect_arguments:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next
collect_arguments_loop:
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, close_paren        ; ")"
	call match                  ; IF global_token->S == ")"
	cmp eax, 0                  ; we reached the end
	je collect_arguments_done   ; be done

	;; deal with the case of there are arguments
	call type_name              ; Get the type
	mov ecx, eax                ; put type_size safely out of the way

	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, close_paren        ; ")"
	call match                  ; IF global_token->S == ")"
	cmp eax, 0                  ; is a foo(int, char,void) case
	je collect_arguments_common ; deal with commas

	;; Trying second else
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, comma              ; ","
	call match                  ; IF global_token->S == ","
	cmp eax, 0                  ; then deal with the common
	je collect_arguments_common ; case of commas between arguments

	;; deal with foo(int a, char b)
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov ebx, ecx                ; put type_size in the right place
	mov ecx, [function]         ; Using function
	mov ecx, [ecx+16]           ; function->args
	call sym_declare            ; sym_declare(global_token->s, type_size, function->arguments);
	mov ecx, eax                ; put a in a safe place

	mov eax, [function]         ; Using function
	mov eax, [eax+16]           ; function->args
	cmp eax, 0                  ; IF function->args == NULL
	jne collect_arguments_another ; otherwise it isn't the first

	;; Deal with the case of first argument in the function
	mov eax, -4                 ; -4
	mov [ecx+16], eax           ; a->depth = -4
	jmp collect_arguments_next  ; get to next

collect_arguments_another:
	;; deal with the case of non-first arguments
	mov eax, [function]         ; Using function
	mov eax, [eax+16]           ; function->args
	mov eax, [eax+16]           ; function->args->depth
	sub eax, 4                  ; function->args->depth - 4
	mov [ecx+16], eax           ; a->depth = function->args->depth - 4

collect_arguments_next:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next

	mov eax, [function]         ; Using function
	mov [eax+16], ecx           ; function->args = a

collect_arguments_common:
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, comma              ; ","
	call match                  ; IF global_token->S == ","
	cmp eax, 0                  ; then deal with the comma
	jne collect_arguments_loop  ; otherwise loop

	;; keep foo(bar(), 1) expressions working
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next
	jmp collect_arguments_loop  ; keep going

collect_arguments_done:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; statement function
;; Receives nothing
;; Returns nothing
;; Walks down global_token recursively to collect the contents of the function
statement:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX

	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, open_curly_brace   ; "{"
	call match                  ; IF global_token->S == "{"
	jne statement_label         ; otherwise try label

	;; deal with { statement }
	call recursive_statement    ; Statements inside of statements for days
	jmp statement_done          ; Be done

statement_label:
	mov al, [ebx]               ; global_token->S[0]
	movzx eax, al               ; make it useful
	cmp eax, 58                 ; IF global_token->S == ':'
	jne statement_local         ; otherwise try locals

	;; deal with labels
	mov eax, ebx                ; put global_token->S in the right spot
	call emit_out               ; emit it

	mov eax, statement_string_0 ; Using "\t#C goto label\n"
	call emit_out               ; emit it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next
	jmp statement_done          ; be done

statement_local:
	mov eax, ebx                ; put global_token->S in the right place
	mov ebx, prim_types         ; pointer to primative types
	call lookup_type            ; See if found
	cmp eax, 0                  ; IF NULL == lookup_type(global_token->S, prim_types)
	jne statement_local_success ; Sweet a new local

	;; Second chance
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, struct             ; "struct"
	call match                  ; IF global_token->S == "struct"
	cmp eax, 0                  ; then we are a local
	jne statement_if            ; otherwise try IF

statement_local_success:
	call collect_local          ; Grab those locals
	jmp statement_done          ; be done

statement_if:
	mov eax, if_string          ; Using "if"
	call match                  ; IF global_token->S == "if"
	cmp eax, 0                  ; then we have an if statement
	jne statement_do            ; otherwise try DO

	;; Deal with IF statement
	call process_if             ; DO IT
	jmp statement_done          ; be done

statement_do:
	mov eax, do_string          ; Using "do"
	call match                  ; IF global_token->S == "do"
	cmp eax, 0                  ; then we have a do statement
	jne statement_while         ; otherwise try WHILE

	;; Deal with DO statement
	call process_do             ; DO IT
	jmp statement_done          ; be done

statement_while:
	mov eax, while_string       ; Using "while"
	call match                  ; IF global_token->S == "while"
	cmp eax, 0                  ; then we have a while statement
	jne statement_for           ; otherwise try FOR

	;; Deal with WHILE statement
	call process_while          ; DO IT
	jmp statement_done          ; be done

statement_for:
	mov eax, for_string         ; Using "for"
	call match                  ; IF global_token->S == "for"
	cmp eax, 0                  ; then we have a for statement
	jne statement_asm           ; otherwise try ASM

	;; Deal with FOR statement
	call process_for            ; DO IT
	jmp statement_done          ; be done

statement_asm:
	mov eax, asm_string         ; Using "asm"
	call match                  ; IF global_token->S == "asm"
	cmp eax, 0                  ; then we have an asm statement
	jne statement_goto          ; otherwise try GOTO

	;; Deal with ASM statement
	call process_asm            ; Hit it
	jmp statement_done          ; be done

statement_goto:
	mov eax, goto_string        ; Using "goto"
	call match                  ; IF global_token->S == "goto"
	cmp eax, 0                  ; then we have a goto statement
	jne statement_return        ; Otherwise try RETURN

	;; Deal with GOTO statement
	mov eax, statement_string_1 ; Using "JUMP %"
	call emit_out               ; emit it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next

	mov eax, [eax+8]            ; global_token->S
	call emit_out               ; emit it

	mov eax, statement_string_2 ; Using "\n"
	call emit_out               ; emit it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next

	mov eax, statement_string_4 ; Using "ERROR in statement\nMissing ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure it has the required
	jmp statement_done          ; Be done

statement_return:
	mov eax, return_string      ; Using "return"
	call match                  ; IF global_token->S == "return"
	cmp eax, 0                  ; then we have a return statement
	jne statement_break         ; Otherwise try BREAK

	;; Deal with RETURN Statement
	call return_result          ; Return anything they want
	jmp statement_done          ; be done

statement_break:
	mov eax, break_string       ; Using "break"
	call match                  ; IF global_token->S == "break"
	cmp eax, 0                  ; then we have a break statement
	jne statement_continue      ; Otherwise try CONTINUE

	;; Deal with BREAK statement
	call process_break          ; Lets do some damage
	jmp statement_done          ; be done

statement_continue:
	mov eax, continue_string    ; Using "continue"
	call match                  ; IF global_token->S == "continue"
	cmp eax, 0                  ; then we have a continue statement
	jne statement_else          ; Otherwise we are punting to an expression

	;; Deal with CONTINUE statement
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next

	mov eax, statement_string_3 ; Using "\n#continue statement\n"
	call emit_out               ; emit it

	mov eax, statement_string_4 ; Using "ERROR in statement\nMissing ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Don't forget the ";"
	jmp statement_done          ; Be done

statement_else:
	call expression             ; Collect expression
	mov eax, statement_string_4 ; Using "ERROR in statement\nMissing ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; make sure we have it

statement_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

statement_string_0: db 9, "#C goto label", 10, 0
statement_string_1: db "JUMP %", 0
statement_string_2: db 10, 0
statement_string_3: db 10, "#continue statement", 10, 0
statement_string_4: db "ERROR in statement", 10, "Missing ;", 10, 0


;; recursive_statement function
;; Receives nothing
;; Returns nothing
;; Walks the global_token list to build the contents of statements
;; Uses struct token_list* frame in ECX
recursive_statement:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next

	mov ecx, [function]         ; Using function
	mov ecx, [ecx+4]            ; frame = function->locals

recursive_statement_loop:
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, close_curly_brace  ; Using "}"
	call match                  ; IF global_token->S == "}"
	cmp eax, 0                  ; Then we are done recursing
	je recursive_statement_cleanup ; and then we clean up

	;; Deal with the recursive calls
	call statement              ; Deal with another statement
	jmp recursive_statement_loop ; loop some more

recursive_statement_cleanup:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next

	mov eax, recursive_statement_string_0 ; Using "RETURN\n"
	mov ebx, [output_list]      ; Using output
	mov ebx, [ebx+8]            ; output->S
	call match                  ; IF output->S == "RETURN\n"
	cmp eax, 0                  ; Then we can skip the clean up
	je recursive_statement_done ; and be done

	;; Deal with cleanup
	mov ebx, [function]         ; Using function
	mov ebx, [ebx+4]            ; i = function->locals
	mov eax, recursive_statement_string_1 ; Using "POP_ebx\t# _recursive_statement_locals\n"

recursive_statement_locals:
	cmp ebx, ecx                ; IF frame != i
	je recursive_statement_done ; Otherwise be done

	;; Lets emit
	call emit_out               ; emit it
	mov ebx, [ebx]              ; i = i->next
	jmp recursive_statement_locals ; keep going

recursive_statement_done:
	mov eax, [function]         ; Using function
	mov [eax+4], ecx            ; function->locals = frame
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

recursive_statement_string_0: db "RETURN", 10, 0
recursive_statement_string_1: db "POP_ebx", 9, "# _recursive_statement_locals", 10, 0


;; return_result function
;; Receives nothing
;; Returns nothing
;; Cleans up function and generates return
;; Also handles returning expressions
return_result:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next

	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; make it useful
	cmp eax, 59                 ; If global_token->S[0] == ';'
	je return_result_cleanup    ; Go straight to cleanup

	call expression             ; get the expression we are returning

return_result_cleanup:
	mov eax, return_result_string_0 ; Using "ERROR in return_result\nMISSING ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it

	mov ebx, [function]         ; Using function
	mov ebx, [ebx+4]            ; function->locals
	mov eax, return_result_string_1 ; Using "POP_ebx\t# _return_result_locals\n"
return_result_locals:
	cmp ebx, 0                  ; IF NULL == i
	je return_result_done       ; Be done

	call emit_out               ; Emit out pop
	mov ebx, [ebx]              ; i = i->NEXT
	jmp return_result_locals    ; Keep going

return_result_done:
	mov eax, return_result_string_2 ; Using "RETURN\n"
	call emit_out               ; Emit it
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

return_result_string_0: db "ERROR in return_result", 10, "MISSING ;", 10, 0
return_result_string_1: db "POP_ebx", 9, "# _return_result_locals", 10, 0
return_result_string_2: db "RETURN", 10, 0


;; collect_local function
;; Receives nothing
;; Returns nothing
;; Walks global_token list to create function locals
;; Uses ECX for struct token_list* A
collect_local:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	call type_name              ; Get the local's type

	mov ebx, eax                ; Put struct type* type_size in the right place
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov ecx, [function]         ; Using function
	mov ecx, [ecx+4]            ; function->locals
	call sym_declare            ; Declare it
	mov ecx, eax                ; put it away safely

	;; Try for main
	mov eax, main_string        ; Using "main"
	mov ebx, [function]         ; Using function
	mov ebx, [ebx+8]            ; function->S
	call match                  ; IF match("main", function->s)
	cmp eax, 0                  ; possible
	jne collect_local_fresh     ; try to see if fresh function

	;; Ok we are in main, now to see if main is fresh
	mov eax, [function]         ; Using function
	mov eax, [eax+4]            ; function->locals
	cmp eax, 0                  ; IF NULL == function->locals
	jne collect_local_fresh     ; try to see if fresh function

	;; Sweet we are in a fresh main
	mov eax, -20                ; We start at -20
	mov [ecx+16], eax           ; a->DEPTH = -20
	jmp collect_local_common    ; Go to the commons

collect_local_fresh:
	mov eax, [function]         ; Using function
	mov eax, [eax+16]           ; function->args
	cmp eax, 0                  ; IF NULL == function->args
	jne collect_local_first     ; Otherwise see if first

	mov eax, [function]         ; Using function
	mov eax, [eax+4]            ; function->locals
	cmp eax, 0                  ; IF NULL == function->locals
	jne collect_local_first     ; Otherwise try first

	;; Sweet we are in a fresh function
	mov eax, -8                 ; We start at -8
	mov [ecx+16], eax           ; a->DEPTH = -8
	jmp collect_local_common    ; Go to the commons

collect_local_first:
	mov eax, [function]         ; Using function
	mov eax, [eax+4]            ; function->locals
	cmp eax, 0                  ; IF NULL == function->locals
	jne collect_local_else      ; Looks like we are just another local

	;; Ok we are the first local
	mov eax, [function]         ; Using function
	mov eax, [eax+16]           ; function->args
	mov eax, [eax+16]           ; function->args->depth
	sub eax, 8                  ; function->arguments->depth - 8
	mov [ecx+16], eax           ; a->DEPTH = function->arguments->depth - 8
	jmp collect_local_common    ; Go to the commons

collect_local_else:
	;; Always the last to know
	mov eax, [function]         ; Using function
	mov eax, [eax+4]            ; function->locals
	mov eax, [eax+16]           ; function->locals->depth
	sub eax, 4                  ; function->locals->depth - 4
	mov [ecx+16], eax           ; a->DEPTH = function->locals->depth - 4

collect_local_common:
	mov eax, [function]         ; Using function

	mov [eax+4], ecx            ; function->locals = a
	mov ecx, [ecx+8]            ; a->S

	mov eax, collect_local_string_0 ; Using "# Defining local "
	call emit_out               ; emit it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	call emit_out               ; emit it

	mov eax, collect_local_string_1 ; Using "\n"
	call emit_out               ; emit it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov ebx, [eax+8]            ; global_token->S
	mov eax, equal              ; Using "="
	call match                  ; IF match("=", global_token->s)
	cmp eax, 0                  ; Deal with assignment
	jne collect_local_done      ; Otherwise finish it

	;; Deal with assignment
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	call expression             ; Recurse

collect_local_done:
	mov eax, collect_local_string_2 ; Using "ERROR in collect_local\nMissing ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it

	mov eax, collect_local_string_3 ; Using "PUSH_eax\t#"
	call emit_out               ; emit it

	mov eax, ecx                ; put A->S where it belongs
	call emit_out               ; emit it

	mov eax, collect_local_string_1 ; Using "\n"
	call emit_out               ; emit it

	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

collect_local_string_0: db "# Defining local ", 0
collect_local_string_1: db 10, 0
collect_local_string_2: db "ERROR in collect_local", 10, "Missing ;", 10, 0
collect_local_string_3: db "PUSH_eax", 9, "#", 0


;; process_asm function
;; Receives nothing
;; Returns nothing
;; Simply inlines the asm statements
;; Uses EBX for global_token temp storage
process_asm:
	push ebx                    ; Protect EBX
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, process_asm_string_0 ; Using "ERROR in process_asm\nMISSING (\n"
	mov ebx, open_paren         ; Using "("
	call require_match          ; Make sure we have it

	mov ebx, [global_token]     ; Using global_token
process_asm_iter:
	mov eax, [ebx+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	cmp eax, 34                 ; IF global_token->S[0] == '\"'
	jne process_asm_done        ; Otherwise be done

	mov eax, [ebx+8]            ; global_token->S
	add eax, 1                  ; global_token->S + 1
	call emit_out               ; Emit it

	mov eax, process_asm_string_1 ; Using "\n"
	call emit_out               ; Emit it

	mov ebx, [ebx]              ; global_token->NEXT
	mov [global_token], ebx     ; global_token = global_token->NEXT
	jmp process_asm_iter        ; keep going

process_asm_done:
	mov eax, process_asm_string_2 ; Using "ERROR in process_asm\nMISSING )\n"
	mov ebx, close_paren        ; Using ")"
	call require_match          ; Make sure we have it

	mov eax, process_asm_string_3 ; Using "ERROR in process_asm\nMISSING ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it

	pop ebx                     ; Restore EBX
	ret

process_asm_string_0: db "ERROR in process_asm", 10, "MISSING (", 10, 0
process_asm_string_1: db 10, 0
process_asm_string_2: db "ERROR in process_asm", 10, "MISSING )", 10, 0
process_asm_string_3: db "ERROR in process_asm", 10, "MISSING ;", 10, 0


;; process_if function
;; Receives nothing
;; Returns Nothing
;; Increments current_count recurses into expression + statement
;; Uses ECX for char* NUMBER_STRING
process_if:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, [current_count]    ; Using current count
	mov ebx, eax                ; Preparing for update
	add ebx, 1                  ; current_count + 1
	mov [current_count], ebx    ; current_count = current_count + 1
	call numerate_number        ; convert to string
	mov ecx, eax                ; put NUMBER_STRING in place

	mov eax, process_if_string_0 ; Using "# IF_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, process_if_string_1 ; Using "ERROR in process_if\nMISSING (\n"
	mov ebx, open_paren         ; Using "("
	call require_match          ; Make sure we have it

	call expression             ; Recurse to get the IF(...) part

	mov eax, process_if_string_2 ; Using "TEST\nJUMP_EQ %ELSE_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_if_string_3 ; Using "ERROR in process_if\nMISSING )\n"
	mov ebx, close_paren        ; Using ")"
	call require_match          ; Make sure we have it

	call statement              ; Recursive to get the IF(){...} part

	mov eax, process_if_string_4 ; Using "JUMP %_END_IF_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_if_string_5 ; Using ":ELSE_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, else_string        ; Using "else"
	call match                  ; IF global_token->S == "else"
	cmp eax, 0                  ; Then we need to collect the else too
	jne process_if_done         ; Otherwise finish up

	;; deal with else statement
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	call statement              ; Recurse to get the ELSE {...} part

process_if_done:
	mov eax, process_if_string_6 ; Using ":_END_IF_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

process_if_string_0: db "# IF_",0
process_if_string_1: db "ERROR in process_if", 10, "MISSING (", 10, 0
process_if_string_2: db "TEST", 10, "JUMP_EQ %ELSE_", 0
process_if_string_3: db "ERROR in process_if", 10, "MISSING )", 10, 0
process_if_string_4: db "JUMP %_END_IF_", 0
process_if_string_5: db ":ELSE_", 0
process_if_string_6: db ":_END_IF_", 0


;; save_break_frame microfunction
;; Overwrites EAX and EBX
;; Saves break frame on stack
;; Returns to caller
save_break_frame:
	pop ebx                     ; Save return Address
	mov eax, [break_frame]      ; Get break_frame
	push eax                    ; Store as nested_locals
	mov eax, [break_target_head] ; Get break_target_head
	push eax                    ; Store as nested_break_head
	mov eax, [break_target_func] ; Get break_target_func
	push eax                    ; Store as nested_break_func
	mov eax, [break_target_num] ; Get break_target_num
	push eax                    ; Store as nested_break_num
	push ebx                    ; Put return back in place
	ret                         ; Return to caller


;; restore_break_frame microfunction
;; Overwrites EAX and EBX
;; Restores break frame from stack
;; Returns to caller
restore_break_frame:
	pop ebx                     ; Save return Address
	pop eax                     ; Get nested_break_num
	mov [break_target_num], eax ; Restore break_target_num
	pop eax                     ; Get nested_break_func
	mov [break_target_func], eax ; Restore break_target_func
	pop eax                     ; Get nested_break_head
	mov [break_target_head], eax ; Restore break_target_head
	pop eax                     ; Get nested_locals
	mov [break_frame], eax      ; Restore break_frame
	push ebx                    ; Put return back in place
	ret                         ; Return to caller


;; set_break_frame microfunction
;; Receives char* head in EAX and char* num in EBX
;; Overwrites EAX and EBX
;; Returns to calling function
set_break_frame:
	mov [break_target_head], eax ; update break_target_head
	mov [break_target_num], ebx ; update break_target_num
	mov ebx, [function]         ; Using function
	mov eax, [ebx+4]            ; function->LOCALS
	mov [break_frame], eax      ; break_frame = function->LOCALS
	mov eax, [ebx+8]            ; function->S
	mov [break_target_func], eax ; break_target_func = function->S
	ret                         ; Return to sender


;; process_do function
;; Receives Nothing
;; Returns Nothing
;; Increments current_count and leverages save/restore_break_frame pieces
;; Uses ECX for char* NUMBER_STRING
process_do:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	call save_break_frame       ; Save the frame

	mov eax, [current_count]    ; Using current count
	mov ebx, eax                ; Preparing for update
	add ebx, 1                  ; current_count + 1
	mov [current_count], ebx    ; current_count = current_count + 1
	call numerate_number        ; convert to string
	mov ecx, eax                ; put NUMBER_STRING in place

	mov eax, process_do_string_0 ; Using "DO_END_"
	mov ebx, ecx                ; Passing NUMBER_STRING
	call set_break_frame        ; Set the frame

	mov eax, process_do_string_1 ; Using ":DO_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	call statement              ; Do the DO {...} part

	mov eax, process_do_string_2 ; Using "ERROR in process_do\nMISSING while\n"
	mov ebx, while_string       ; Using "while"
	call require_match          ; Make sure we have it

	mov eax, process_do_string_3 ; Using "ERROR in process_do\nMISSING (\n"
	mov ebx, open_paren         ; Using "("
	call require_match          ; Make sure we have it

	call expression             ; Do the WHILE (...) part

	mov eax, process_do_string_4 ; Using "ERROR in process_do\nMISSING )\n"
	mov ebx, close_paren        ; Using ")"
	call require_match          ; Make sure we have it

	mov eax, process_do_string_5 ; Using "ERROR in process_do\nMISSING ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it

	mov eax, process_do_string_6 ; Using "TEST\nJUMP_NE %DO_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_do_string_7 ; Using ":DO_END_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	call restore_break_frame    ; Restore the old break frame

	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

process_do_string_0: db "DO_END_", 0
process_do_string_1: db ":DO_", 0
process_do_string_2: db "ERROR in process_do", 10, "MISSING while", 10, 0
process_do_string_3: db "ERROR in process_do", 10, "MISSING (", 10, 0
process_do_string_4: db "ERROR in process_do", 10, "MISSING )", 10, 0
process_do_string_5: db "ERROR in process_do", 10, "MISSING ;", 10, 0
process_do_string_6: db "TEST", 10, "JUMP_NE %DO_", 0
process_do_string_7: db ":DO_END_", 0


;; process_while function
;; Receives nothing
;; Returns nothing
;; Increments current_count and leverages save/restore_break_frame pieces
;; Uses ECX for char* NUMBER_STRING
process_while:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	call save_break_frame       ; Save break_frame

	mov eax, [current_count]    ; Using current count
	mov ebx, eax                ; Preparing for update
	add ebx, 1                  ; current_count + 1
	mov [current_count], ebx    ; current_count = current_count + 1
	call numerate_number        ; convert to string
	mov ecx, eax                ; put NUMBER_STRING in place

	mov eax, process_while_string_0 ; Using "END_WHILE_"
	mov ebx, ecx                ; Passing NUMBER_STRING
	call set_break_frame        ; Set it and forget it

	mov eax, process_while_string_1 ; Using ":WHILE_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, process_while_string_2 ; Using "ERROR in process_while\nMISSING (\n"
	mov ebx, open_paren         ; Using "("
	call require_match          ; Make sure we have it

	call expression             ; Deal with the WHILE (...) part

	mov eax, process_while_string_3 ; Using "TEST\nJUMP_EQ %END_WHILE_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_while_string_4 ; Using "# THEN_while_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_while_string_5 ; Using "ERROR in process_while\nMISSING )\n"
	mov ebx, close_paren        ; Using ")"
	call require_match          ; Make sure we have it

	call statement              ; Deal with the {....} part

	mov eax, process_while_string_6 ; Using "JUMP %WHILE_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_while_string_7 ; Using ":END_WHILE_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	call restore_break_frame    ; Restore the old break frame

	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

process_while_string_0: db "END_WHILE_", 0
process_while_string_1: db ":WHILE_", 0
process_while_string_2: db "ERROR in process_while", 10, "MISSING (", 10, 0
process_while_string_3: db "TEST", 10, "JUMP_EQ %END_WHILE_", 0
process_while_string_4: db "# THEN_while_", 0
process_while_string_5: db "ERROR in process_while", 10, "MISSING )", 10, 0
process_while_string_6: db "JUMP %WHILE_", 0
process_while_string_7: db ":END_WHILE_", 0


;; process_for function
;; Receives Nothing
;; Returns Nothing
;; Increments current_count and leverages save/restore_break_frame pieces
;; Uses ECX for char* NUMBER_STRING
process_for:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	call save_break_frame       ; Save the frame

	mov eax, [current_count]    ; Using current count
	mov ebx, eax                ; Preparing for update
	add ebx, 1                  ; current_count + 1
	mov [current_count], ebx    ; current_count = current_count + 1
	call numerate_number        ; convert to string
	mov ecx, eax                ; put NUMBER_STRING in place

	mov eax, process_for_string_0 ; Using "FOR_END_"
	mov ebx, ecx                ; Passing NUMBER_STRING
	call set_break_frame        ; Set it and forget it

	mov eax, process_for_string_1 ; Using "# FOR_initialization_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, process_for_string_2 ; Using "ERROR in process_for\nMISSING (\n"
	mov ebx, open_paren         ; Using "("
	call require_match          ; Make Sure we have it

	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, semicolon          ; Using ";"
	call match                  ; IF global_token->S == ";"
	cmp eax, 0                  ; Then no initializer
	je process_for_terminator   ; And skip getting the expression

	;; Deal with FOR (...; case
	call expression             ; Get the FOR ( ... ; part

process_for_terminator:
	mov eax, process_for_string_3 ; Using ":FOR_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_for_string_4 ; Using "ERROR in process_for\nMISSING ;1\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it

	call expression             ; Get the FOR ( ; ... ; Part

	mov eax, process_for_string_5 ; Using "TEST\nJUMP_EQ %FOR_END_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_for_string_6 ; Using "JUMP %FOR_THEN_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_for_string_7 ; Using ":FOR_ITER_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_for_string_8 ; Using "ERROR in process_for\nMISSING ;2\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it

	call expression             ; Get the FOR (;;...) part

	mov eax, process_for_string_9 ; Using "JUMP %FOR_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_for_string_10 ; Using ":FOR_THEN_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_for_string_11 ; Using "ERROR in process_for\nMISSING )\n"
	mov ebx, close_paren        ; Using ")"
	call require_match          ; Make sure we have it

	call statement              ; Get FOR (;;) {...} part

	mov eax, process_for_string_12 ; Using "JUMP %FOR_ITER_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Passing NUMBER_STRING
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	mov eax, process_for_string_13 ; Using ":FOR_END_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	call uniqueID_out           ; uniqueID_out(function->s, number_string)

	call restore_break_frame    ; Restore the old break frame

	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

process_for_string_0: db "FOR_END_", 0
process_for_string_1: db "# FOR_initialization_", 0
process_for_string_2: db "ERROR in process_for", 10, "MISSING (", 10, 0
process_for_string_3: db ":FOR_", 0
process_for_string_4: db "ERROR in process_for", 10, "MISSING ;1", 10, 0
process_for_string_5: db "TEST", 10, "JUMP_EQ %FOR_END_", 0
process_for_string_6: db "JUMP %FOR_THEN_", 0
process_for_string_7: db ":FOR_ITER_", 0
process_for_string_8: db "ERROR in process_for", 10, "MISSING ;2", 10, 0
process_for_string_9: db "JUMP %FOR_", 0
process_for_string_10: db ":FOR_THEN_", 0
process_for_string_11: db "ERROR in process_for",10, "MISSING )", 10, 0
process_for_string_12: db "JUMP %FOR_ITER_", 0
process_for_string_13: db ":FOR_END_", 0


;; process_break function
;; Receives nothing
;; Returns nothing
;; Handles the break out of loops case
;; Uses EBX for struct token_list* break_frame and ECX for struct token_list* I
process_break:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, [break_target_head] ; Catch big error
	cmp eax, 0                  ; IF(NULL == break_target_head)
	je process_break_bad        ; I'm sorry Mr White but you have stage-3 lung cancer

	mov eax, [function]         ; Using function
	mov ecx, [eax+4]            ; I = function->LOCALS
	mov ebx, [break_frame]      ; Put break_frame in the right spot
	mov eax, process_break_string_1 ; Using "POP_ebx\t# break_cleanup_locals\n"

process_break_iter:
	cmp ecx, 0                  ; IF (NULL == I)
	je process_break_cleaned    ; We are done

	cmp ecx, ebx                ; IF I != break_frame
	je process_break_cleaned    ; We are done

	call emit_out               ; Emit it
	mov ecx, [ecx]              ; I = I->NEXT
	jmp process_break_iter      ; Keep looping

process_break_cleaned:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, process_break_string_2 ; Using "JUMP %"
	call emit_out               ; Emit it

	mov eax, [break_target_head] ; Get what we are in
	call emit_out               ; Emit it

	mov eax, [break_target_func] ; Get what function we are in
	call emit_out               ; Emit it

	mov eax, underline          ; Using "_"
	call emit_out               ; Emit it

	mov eax, [break_target_num] ; Get dem digits
	call emit_out               ; Emit it

	mov eax, process_break_string_3 ; Using "\n"
	call emit_out               ; Emit it

	mov eax, process_break_string_4 ; Using "ERROR in break statement\nMissing ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it

	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

process_break_bad:
	;; Breaking badly
	mov eax, 2                  ; Using standard error
	mov [Output_file], eax      ; write to standard error
;	call line_error             ; Write useful debug info
	mov eax, ecx                ; put S in the right place
	call File_Print             ; print it

	mov eax, process_break_string_0 ; Ending string
	call File_Print             ; print it
	jmp Exit_Failure            ; Abort Hard

process_break_string_0: db "Not inside of a loop or case statement", 0
process_break_string_1: db "POP_ebx", 9, "# break_cleanup_locals", 10, 0
process_break_string_2: db "JUMP %", 0
process_break_string_3: db 10, 0
process_break_string_4: db "ERROR in break statement",10, "Missing ;", 10, 0


;; expression function
;; Receives Nothing
;; Returns Nothing
;; Walks global_token and updates output_list
;; Uses EAX and EBX for match and ECX for char* store
expression:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	call bitwise_expr           ; Collect bitwise expressions

	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, equal              ; "="
	call match                  ; IF global_token->S == "="
	cmp eax, 0                  ; We have to deal with assignment
	jne expression_done         ; Looks like nope

	;; Deal with possible assignment
	mov ecx, expression_string_1 ; Assume "STORE_CHAR\n" by default
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+4]            ; global_token->PREV
	mov ebx, [ebx+8]            ; global_token->PREV->S
	mov eax, close_bracket      ; Using "]"
	call match                  ; IF global_token->S == "]"
	cmp eax, 0                  ; Then we might have a char
	jne expression_int          ; Otherwise INT

	mov ebx, [current_target]   ; Using current_target
	mov ebx, [ebx+24]           ; current_target->NAME
	mov eax, type_char_indirect_name ; Using "char*"
	call match                  ; Intentional inefficiency because I feel like it
	cmp eax, 0                  ; IF current_target->NAME == "char*"
	jne expression_int          ; Do char anyway

	jmp expression_common       ; Looks like we have to use "STORE_CHAR\n"

expression_int:
	mov ecx, expression_string_0 ; Use "STORE_INTEGER\n"

expression_common:
	mov eax, expression         ; Passing expression
	call common_recursion       ; Recurse
	mov eax, ecx                ; Using Store
	call emit_out               ; Emit it
	mov eax, 0                  ; Using NULL
	mov [current_target], eax   ; current_target = NULL

expression_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

expression_string_0: db "STORE_INTEGER", 10, 0
expression_string_1: db "STORE_CHAR", 10, 0


;; bitwise_expr function
;; Receives nothing
;; Returns nothing
;; Walks global_token list and updates output list
;; Just calls other functions
bitwise_expr:
	call relational_expr        ; Walk up the tree
	call bitwise_expr_stub      ; Let general recursion do the work
	ret


;; bitwise_expr_stub function
;; Receives nothing
;; Returns Nothing
;; Just calls general_recursion a bunch
;; Uses EAX, EBX, ECX and EDX for passing constants to general recursion
bitwise_expr_stub:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX

	mov eax, relational_expr    ; Using relational_expr
	mov ebx, bitwise_expr_stub_string_0 ; Using "AND_eax_ebx\n"
	mov ecx, bitwise_and        ; Using "&"
	mov edx, bitwise_expr_stub  ; And recurse
	call general_recursion      ; Hit it

	mov eax, relational_expr    ; Using relational_expr
	mov ebx, bitwise_expr_stub_string_0 ; Using "AND_eax_ebx\n"
	mov ecx, logical_and        ; Using "&&"
	mov edx, bitwise_expr_stub  ; And recurse
	call general_recursion      ; Hit it

	mov eax, relational_expr    ; Using relational_expr
	mov ebx, bitwise_expr_stub_string_1 ; Using "OR_eax_ebx\n"
	mov ecx, bitwise_or         ; Using "|"
	mov edx, bitwise_expr_stub  ; And recurse
	call general_recursion      ; Hit it

	mov eax, relational_expr    ; Using relational_expr
	mov ebx, bitwise_expr_stub_string_1 ; Using "OR_eax_ebx\n"
	mov ecx, logical_or         ; Using "||"
	mov edx, bitwise_expr_stub  ; And recurse
	call general_recursion      ; Hit it

	mov eax, relational_expr    ; Using relational_expr
	mov ebx, bitwise_expr_stub_string_2 ; Using "XOR_ebx_eax_into_eax\n"
	mov ecx, bitwise_xor        ; Using "^"
	mov edx, bitwise_expr_stub  ; And recurse
	call general_recursion      ; Hit it

	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

bitwise_expr_stub_string_0: db "AND_eax_ebx", 10, 0
bitwise_expr_stub_string_1: db "OR_eax_ebx", 10, 0
bitwise_expr_stub_string_2: db "XOR_ebx_eax_into_eax", 10, 0


;; relational_expr function
;; Receives nothing
;; Returns Nothing
;; Walks global_token list and updates output list
;; just calls other function
relational_expr:
	call additive_expr          ; Walk up the tree
	call relational_expr_stub   ; Recurse
	ret


;; relational_expr_stub function
;; Receives nothing
;; Returns Nothing
;; Just calls general_recursion a bunch
;; Uses EAX, EBX, ECX and EDX for passing constants to general recursion
relational_expr_stub:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX

	mov eax, additive_expr      ; Using additive_expr
	mov ebx, relational_expr_stub_string_0 ; Using "CMP\nSETL\nMOVEZBL\n"
	mov ecx, less_than_string   ; Using "<"
	mov edx, relational_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, additive_expr      ; Using additive_expr
	mov ebx, relational_expr_stub_string_1 ; Using "CMP\nSETLE\nMOVEZBL\n"
	mov ecx, less_than_equal_string ; Using "<="
	mov edx, relational_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, additive_expr      ; Using additive_expr
	mov ebx, relational_expr_stub_string_2 ; Using "CMP\nSETGE\nMOVEZBL\n"
	mov ecx, greater_than_equal_string ; Using ">="
	mov edx, relational_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, additive_expr      ; Using additive_expr
	mov ebx, relational_expr_stub_string_3 ; Using "CMP\nSETG\nMOVEZBL\n"
	mov ecx, greater_than_string ; Using ">"
	mov edx, relational_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, additive_expr      ; Using additive_expr
	mov ebx, relational_expr_stub_string_4 ; Using "CMP\nSETE\nMOVEZBL\n"
	mov ecx, equal_to_string    ; Using "=="
	mov edx, relational_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, additive_expr      ; Using additive_expr
	mov ebx, relational_expr_stub_string_5 ; Using "CMP\nSETNE\nMOVEZBL\n"
	mov ecx, not_equal_string   ; Using "!="
	mov edx, relational_expr_stub ; And recurse
	call general_recursion      ; Hit it

	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

relational_expr_stub_string_0: db "CMP", 10, "SETL", 10, "MOVEZBL", 10,  0
relational_expr_stub_string_1: db "CMP", 10, "SETLE", 10, "MOVEZBL", 10, 0
relational_expr_stub_string_2: db "CMP", 10, "SETGE", 10, "MOVEZBL", 10, 0
relational_expr_stub_string_3: db "CMP", 10, "SETG", 10, "MOVEZBL", 10, 0
relational_expr_stub_string_4: db "CMP", 10, "SETE", 10, "MOVEZBL", 10, 0
relational_expr_stub_string_5: db "CMP", 10, "SETNE", 10, "MOVEZBL", 10, 0


;; additive_expr function
;; Receives nothing
;; Returns Nothing
;; Walks global_token list and updates output list
;; just calls other function
additive_expr:
	call postfix_expr           ; Walk up the tree
	call additive_expr_stub     ; Recurse
	ret


;; additive_expr_stub function
;; Receives nothing
;; Returns Nothing
;; Just calls general_recursion a bunch
;; Uses EAX, EBX, ECX and EDX for passing constants to general recursion
additive_expr_stub:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX

	mov eax, postfix_expr       ; Using postfix_expr
	mov ebx, additive_expr_stub_string_0 ; Using "ADD_ebx_to_eax\n"
	mov ecx, plus_string        ; Using "+"
	mov edx, additive_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, postfix_expr       ; Using postfix_expr
	mov ebx, additive_expr_stub_string_1 ; Using "SUBTRACT_eax_from_ebx_into_ebx\nMOVE_ebx_to_eax\n"
	mov ecx, minus_string       ; Using "-"
	mov edx, additive_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, postfix_expr       ; Using postfix_expr
	mov ebx, additive_expr_stub_string_2 ; Using "MULTIPLY_eax_by_ebx_into_eax\n"
	mov ecx, multiply_string    ; Using "*"
	mov edx, additive_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, postfix_expr       ; Using postfix_expr
	mov ebx, additive_expr_stub_string_3 ; Using "XCHG_eax_ebx\nLOAD_IMMEDIATE_edx %0\nDIVIDE_eax_by_ebx_into_eax\n"
	mov ecx, divide_string      ; Using "/"
	mov edx, additive_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, postfix_expr       ; Using postfix_expr
	mov ebx, additive_expr_stub_string_4 ; Using "XCHG_eax_ebx\nLOAD_IMMEDIATE_edx %0\nMODULUS_eax_from_ebx_into_ebx\nMOVE_edx_to_eax\n"
	mov ecx, modulus_string     ; Using "%"
	mov edx, additive_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, postfix_expr       ; Using postfix_expr
	mov ebx, additive_expr_stub_string_5 ; Using "COPY_eax_to_ecx\nCOPY_ebx_to_eax\nSAL_eax_cl\n"
	mov ecx, left_shift_string  ; Using "<<"
	mov edx, additive_expr_stub ; And recurse
	call general_recursion      ; Hit it

	mov eax, postfix_expr       ; Using postfix_expr
	mov ebx, additive_expr_stub_string_6 ; Using "COPY_eax_to_ecx\nCOPY_ebx_to_eax\nSAR_eax_cl\n"
	mov ecx, right_shift_string ; Using ">>"
	mov edx, additive_expr_stub ; And recurse
	call general_recursion      ; Hit it

	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

additive_expr_stub_string_0: db "ADD_ebx_to_eax", 10, 0
additive_expr_stub_string_1: db "SUBTRACT_eax_from_ebx_into_ebx", 10, "MOVE_ebx_to_eax", 10, 0
additive_expr_stub_string_2: db "MULTIPLY_eax_by_ebx_into_eax", 10, 0
additive_expr_stub_string_3: db "XCHG_eax_ebx", 10, "LOAD_IMMEDIATE_edx %0", 10, "DIVIDE_eax_by_ebx_into_eax", 10, 0
additive_expr_stub_string_4: db "XCHG_eax_ebx", 10, "LOAD_IMMEDIATE_edx %0", 10, "MODULUS_eax_from_ebx_into_ebx", 10, "MOVE_edx_to_eax", 10, 0
additive_expr_stub_string_5: db "COPY_eax_to_ecx", 10, "COPY_ebx_to_eax", 10, "SAL_eax_cl", 10, 0
additive_expr_stub_string_6: db "COPY_eax_to_ecx", 10, "COPY_ebx_to_eax", 10, "SAR_eax_cl", 10, 0


;; postfix_expr function
;; Receives nothing
;; Returns Nothing
;; Walks global_token list and updates output list
;; just calls other function
postfix_expr:
	call primary_expr           ; Walk up the tree
	call postfix_expr_stub      ; Recurse
	ret


;; postfix_expr_stub function
;; Receives nothing
;; Returns Nothing
;; Checks for "[" and "->" and deals with them otherwise does nothing
;; Uses EAX, EBX, ECX and EDX for passing constants to general recursion
postfix_expr_stub:
	push ebx                    ; Protect EBX
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, open_bracket       ; Using "["
	call match                  ; IF global_token->S == "["
	cmp eax, 0                  ; then we have an array
	jne postfix_expr_stub_arrow ; Otherwise try arrow

	;; Deal with array
	call postfix_expr_array     ; Get it
	call postfix_expr_stub      ; Recurse

postfix_expr_stub_arrow:
	mov eax, arrow_string       ; Using "->"
	call match                  ; IF global_token->S == "->"
	cmp eax, 0                  ; Then we need to deal with struct offsets
	jne postfix_expr_stub_done  ; Otherwise be done

	;; Deal with arrow
	call postfix_expr_arrow     ; Get it
	call postfix_expr_stub      ; Recurse

postfix_expr_stub_done:
	pop ebx                     ; Restore EBX
	ret


;; unary_expr_sizeof function
;; Receives nothing
;; Returns nothing
;; Uses ECX for A->SIZE
unary_expr_sizeof:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, unary_expr_sizeof_string_0 ; Using "ERROR in unary_expr\nMissing (\n"
	mov ebx, open_paren         ; Using "("
	call require_match          ; Make sure we have it

	call type_name              ; Get the type
	mov ecx, [eax+4]            ; Set A->TYPE

	mov eax, unary_expr_sizeof_string_1 ; Using "ERROR in unary_expr\nMissing )\n"
	mov ebx, close_paren        ; Using ")"
	call require_match          ; Make sure we have it

	mov eax, unary_expr_sizeof_string_2 ; Using "LOAD_IMMEDIATE_eax %"
	call emit_out               ; Emit it

	mov eax, ecx                ; Put A->SIZE in the right place
	call numerate_number        ; Turn into string
	call emit_out               ; Emit it

	mov eax, unary_expr_sizeof_string_3 ; Using "\n"
	call emit_out               ; Emit it

	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

unary_expr_sizeof_string_0: db "ERROR in unary_expr", 10, "Missing (", 10, 0
unary_expr_sizeof_string_1: db "ERROR in unary_expr", 10, "Missing )", 10, 0
unary_expr_sizeof_string_2: db "LOAD_IMMEDIATE_eax %", 0
unary_expr_sizeof_string_3: db 10, 0


;; postfix_expr_array function
;; Receives Nothing
;; Returns Nothing
;; Uses EBX for struct type* ARRAY and ECX for char* ASSIGN
postfix_expr_array:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, [current_target]   ; ARRAY = current_target
	push eax                    ; Protect it

	mov eax, expression         ; Using expression
	call common_recursion       ; Recurse

	pop ebx                     ; Restore array
	mov [current_target], ebx   ; current_target = ARRAY

	mov ecx, postfix_expr_array_string_0 ; ASSIGN = "LOAD_INTEGER\n"

	mov eax, type_char_indirect_name ; Using "char*"
	mov ebx, [ebx+24]           ; current_target->NAME
	call match                  ; IF current_target->NAME == "char*"
	cmp eax, 0                  ; load a byte
	jne postfix_expr_array_large ; Otherwise adjust

	;; Deal with loading byte
	mov ecx, postfix_expr_array_string_1 ; ASSIGN = "LOAD_BYTE\n"
	jmp postfix_expr_array_common ; Do the next bit

postfix_expr_array_large:
	;; deal with arrays made of things other than chars
	mov eax, postfix_expr_array_string_2 ; Using "SAL_eax_Immediate8 !"
	call emit_out               ; Emit it

	mov eax, [current_target]   ; Using current_target
	mov eax, [eax+12]           ; current_target->INDIRECT
	mov eax, [eax+4]            ; current_target->INDIRECT->SIZE
	call ceil_log2              ; ceil_log2(current_target->indirect->size)
	call numerate_number        ; numerate_number(ceil_log2(current_target->indirect->size))
	call emit_out               ; Emit it

	mov eax, postfix_expr_array_string_3 ; Using "\n"
	call emit_out               ; Emit it

postfix_expr_array_common:
	mov eax, postfix_expr_array_string_4 ; Using "ADD_ebx_to_eax\n"
	call emit_out               ; Emit it

	mov eax, postfix_expr_array_string_5 ; Using "ERROR in postfix_expr\nMissing ]\n"
	mov ebx, close_bracket      ; Using "]"
	call require_match          ; Make sure we have it

	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, equal              ; Using "="
	call match                  ; IF global_token->S == "="
	cmp eax, 0                  ; We need to preserve address
	jne postfix_expr_array_done ; Otherwise be done

	;; Clearing out assign
	mov ecx, postfix_expr_array_string_6 ; ASSIGN = ""

postfix_expr_array_done:
	mov eax, ecx                ; Using ASSIGN
	call emit_out               ; Emit it

	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

postfix_expr_array_string_0: db "LOAD_INTEGER", 10, 0
postfix_expr_array_string_1: db "LOAD_BYTE", 10, 0
postfix_expr_array_string_2: db "SAL_eax_Immediate8 !", 0
postfix_expr_array_string_3: db 10, 0
postfix_expr_array_string_4: db "ADD_ebx_to_eax", 10, 0
postfix_expr_array_string_5: db "ERROR in postfix_expr", 10, "Missing ]", 10, 0
postfix_expr_array_string_6: db 0


;; ceil_log2 function
;; Receives int a in EAX
;; Performs log2 on A and
;; Returns result in EAX
;; Uses EBX for INT A and ECX for INT RESULT
ceil_log2:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ecx, 0                  ; RESULT = 0

	mov ebx, eax                ; put A in right place
	sub eax, 1                  ; (A - 1)
	and eax, ebx                ; A & (A - 1)
	cmp eax, 0                  ; IF 0 == (A & (A - 1))
	jne ceil_log2_iter          ; Starting from -1

	mov ecx, -1                 ; RESULT = -1

ceil_log2_iter:
	cmp ebx, 0                  ; IF A > 0
	jle ceil_log2_done          ; Otherwise be done

	add ecx, 1                  ; RESULT = RESULT + 1
	shr ebx, 1                  ; A = A >> 1
	jmp ceil_log2_iter          ; Keep looping

ceil_log2_done:
	mov eax, ecx                ; Return RESULT
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; postfix_expr_arrow function
;; Receives nothing
;; Returns nothing
;; Emits a bunch and updates current_target
;; Uses EBX for struct type* I
postfix_expr_arrow:
	push ebx                    ; Protect EBX
	mov eax, postfix_expr_arrow_string_0 ; Using "# looking up offset\n"
	call emit_out               ; Emit it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov ebx, [eax+8]            ; Using global_token->S
	mov eax, [current_target]   ; Using current_target
	call lookup_member          ; lookup_member(current_target, global_token->s)
	mov ebx, eax                ; struct type* I = lookup_member(current_target, global_token->s)

	mov eax, [eax+20]           ; I->TYPE
	mov [current_target], eax   ; current_target = I->TYPE

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, [ebx+8]            ; I->OFFSET
	cmp eax, 0                  ; IF 0 != I->OFFSET
	je postfix_expr_arrow_first ; Then we don't need to do an offset

	;; Deal with needing an offset
	mov eax, postfix_expr_arrow_string_1 ; Using "# -> offset calculation\nLOAD_IMMEDIATE_ebx %"
	call emit_out               ; Emit it

	mov eax, [ebx+8]            ; I->OFFSET
	call numerate_number        ; Convert to string
	call emit_out               ; Emit it

	mov eax, postfix_expr_arrow_string_2 ; Using "\nADD_ebx_to_eax\n"
	call emit_out               ; Emit it

postfix_expr_arrow_first:
	mov eax, [ebx+4]            ; I->SIZE
	cmp eax, 4                  ; IF I->SIZE >= 4
	jl postfix_expr_arrow_done  ; Otherwise be done

	;; Last chance for load
	mov eax, [global_token]     ; Using global_token
	mov ebx, [eax+8]            ; global_token->S
	mov eax, equal              ; Using "="
	call match                  ; IF global_token->S == "="
	cmp eax, 0                  ; Then we have assignment and should not load
	je postfix_expr_arrow_done  ; Be done

	;; Deal with load case
	mov eax, postfix_expr_arrow_string_3 ; Using "LOAD_INTEGER\n"
	call emit_out               ; Emit it

postfix_expr_arrow_done:
	pop ebx                     ; Restore EBX
	ret

postfix_expr_arrow_string_0: db "# looking up offset", 10, 0
postfix_expr_arrow_string_1: db "# -> offset calculation", 10, "LOAD_IMMEDIATE_ebx %", 0
postfix_expr_arrow_string_2: db 10, "ADD_ebx_to_eax", 10, 0
postfix_expr_arrow_string_3: db "LOAD_INTEGER", 10, 0


;; primary_expr function
;; Receives nothing
;; Returns nothing
primary_expr:
	push ebx                    ; Protect EBX

	mov eax, [global_token]     ; Using global_token
	mov ebx, [eax+8]            ; global_token->S
	mov eax, sizeof_string      ; Using "sizeof"
	call match                  ; See if match
	cmp eax, 0                  ; IF match
	jne primary_expr_neg        ; Otherwise try negatives

	;; Deal with sizeof
	call unary_expr_sizeof      ; Lets do this
	jmp primary_expr_done       ; Be done

primary_expr_neg:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	cmp eax, 45                 ; IF global_token->S[0] == "-"
	jne primary_expr_not        ; Otherwise try logical NOT

	;; Deal with negative numbers
	mov eax, primary_expr_string_0 ; Using "LOAD_IMMEDIATE_eax %0\n"
	call emit_out               ; Emit it

	mov eax, postfix_expr       ; Passing postfix_expr
	call common_recursion       ; Get what it is notting

	mov eax, primary_expr_string_1 ; Using "SUBTRACT_eax_from_ebx_into_ebx\nMOVE_ebx_to_eax\n"
	call emit_out               ; Emit it
	jmp primary_expr_done       ; Be done

primary_expr_not:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	cmp eax, 33                 ; IF global_token->S[0] == "!"
	jne primary_expr_bin        ; Otherwise try '~'

	;; Deal with logical not
	mov eax, primary_expr_string_2 ; Using "LOAD_IMMEDIATE_eax %1\n"
	call emit_out               ; Emit it

	mov eax, postfix_expr       ; Passing postfix_expr
	call common_recursion       ; Get what it is notting

	mov eax, primary_expr_string_3 ; Using "XOR_ebx_eax_into_eax\n"
	call emit_out               ; Emit it
	jmp primary_expr_done       ; Be done

primary_expr_bin:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	cmp eax, 126                ; IF global_token->S[0] == "~"
	jne primary_expr_paren      ; Otherwise try paren

	;; Deal with binary NOT
	mov eax, postfix_expr       ; Passing postfix_expr
	call common_recursion       ; Get what it is notting
	mov eax, primary_expr_string_4 ; Using "NOT_eax\n"
	call emit_out               ; Emit it
	jmp primary_expr_done       ; Be done

primary_expr_paren:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	cmp eax, 40                 ; IF global_token->S[0] == "("
	jne primary_expr_ch         ; Otherwise try char

	;; deal with nesting
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT
	call expression             ; Lets recurse
	mov eax, primary_expr_string_5 ; Using "Error in Primary expression\nDidn't get )\n"
	mov ebx, close_paren        ; Using ")"
	call require_match          ; Make sure we have it
	jmp primary_expr_done       ; Be done

primary_expr_ch:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	cmp eax, 39                 ; Using "'"
	jne primary_expr_str        ; Otherwise try string

	;; Deal with chars
	call primary_expr_char      ; Handle that char
	jmp primary_expr_done       ; Be done

primary_expr_str:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	cmp eax, 34                 ; Using '\"'
	jne primary_expr_var        ; Otherwise try a variable

	;; Deal with strings
	call primary_expr_string    ; Handle that string
	jmp primary_expr_done       ; Be done

primary_expr_var:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	mov ebx, primary_expr_string_6 ; Using "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"
	call In_Set                 ; See if we have a match
	cmp eax, 1                  ; IF match
	jne primary_expr_num        ; otherwise try number

	;; Deal with variables
	call primary_expr_variable  ; Deal with variable
	jmp primary_expr_done       ; Be done

primary_expr_num:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	mov ebx, primary_expr_string_7 ; Using "0123456789"
	call In_Set                 ; See if we have a match
	cmp eax, 1                  ; IF match
	jne primary_expr_fail       ; otherwise we failed hard

	;; Deal with numbers
	call primary_expr_number    ; Collect the number
	jmp primary_expr_done       ; Be done

primary_expr_fail:
	;; looks like we hit bad input
	;; abort before it gets bad
	call primary_expr_failure   ; No match means failure
primary_expr_done:
	pop ebx                     ; Restore EBX
	ret

primary_expr_string_0: db "LOAD_IMMEDIATE_eax %0", 10, 0
primary_expr_string_1: db "SUBTRACT_eax_from_ebx_into_ebx", 10, "MOVE_ebx_to_eax", 10, 0
primary_expr_string_2: db "LOAD_IMMEDIATE_eax %1", 10, 0
primary_expr_string_3: db "XOR_ebx_eax_into_eax", 10, 0
primary_expr_string_4: db "NOT_eax", 10, 0
primary_expr_string_5: db "Error in Primary expression", 10, "Didn't get )", 10, 0
primary_expr_string_6: db "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_", 0
primary_expr_string_7:db "0123456789", 0


;; primary_expr_variable function
;; Receives nothing
;; Returns nothing
;; Walks global and updates output
;; Uses EAX for struct token_list* a and ECX for char* S
primary_expr_variable:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, [global_token]     ; Using global_token
	mov ecx, [eax+8]            ; S = global_token->S
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, ecx                ; Using S
	mov ebx, [global_constant_list] ; Using global_constant_list
	call sym_lookup             ; sym_lookup(s, global_constant_list)
	cmp eax, 0                  ; IF NULL == sym_lookup(s, global_constant_list)
	je primary_expr_variable_local ; Try locals next

	;; Deal with constant load
	mov ebx, [eax+16]              ; a->ARGS
	mov eax, primary_expr_variable_string_2 ; Using "LOAD_IMMEDIATE_eax %"
	call emit_out               ; Emit it

	mov eax, [ebx+8]            ; a->ARGS->S
	call emit_out               ; Emit it

	mov eax, primary_expr_variable_string_1 ; Using "\n"
	call emit_out               ; Emit it
	jmp primary_expr_variable_done ; Be done

primary_expr_variable_local:
	mov eax, ecx                ; Using S
	mov ebx, [function]         ; Using function
	mov ebx, [ebx+4]            ; function->locals
	call sym_lookup             ; sym_lookup(s, function->locals)
	cmp eax, 0                  ; IF NULL == sym_lookup(s, function->locals)
	je primary_expr_variable_arguments ; try arguments next

	;; Deal with local load
	call variable_load          ; Collect it
	jmp primary_expr_variable_done ; Be done

primary_expr_variable_arguments:
	mov eax, ecx                ; Using S
	mov ebx, [function]         ; Using function
	mov ebx, [ebx+16]           ; function->args
	call sym_lookup             ; sym_lookup(s, function->args)
	cmp eax, 0                  ; IF NULL == sym_lookup(s, function->args)
	je primary_expr_variable_function ; try functions next

	;; Deal with argument load
	call variable_load          ; Collect it
	jmp primary_expr_variable_done ; Be done

primary_expr_variable_function:
	mov eax, ecx                ; Using S
	mov ebx, [global_function_list] ; Using global_function_list
	call sym_lookup             ; sym_lookup(s, global_function_list)
	cmp eax, 0                  ; IF NULL == sym_lookup(s, global_function_list)
	je primary_expr_variable_global ; try globals next

	;; Deal with functions
	call function_load          ; Deal with the function
	jmp primary_expr_variable_done ; Be done

primary_expr_variable_global:
	mov eax, ecx                ; Using S
	mov ebx, [global_symbol_list] ; Using global_symbol_list
	call sym_lookup             ; sym_lookup(s, global_symbol_list)
	cmp eax, 0                  ; IF NULL == sym_lookup(s, global_symbol_list)
	je primary_expr_variable_error ; Give up

	;; Deal with globals
	call global_load               ; Collect that global
	jmp primary_expr_variable_done ; Be done

primary_expr_variable_error:
	mov eax, 2                  ; Using standard error
	mov [Output_file], eax      ; write to standard error
;	call line_error             ; Write useful debug info
	mov eax, ecx                ; put S in the right place
	call File_Print             ; print it

	mov eax, primary_expr_variable_string_0 ; Ending string
	call File_Print             ; print it
	jmp Exit_Failure            ; Abort Hard

primary_expr_variable_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

primary_expr_variable_string_0: db " is not a defined symbol", 10, 0
primary_expr_variable_string_1: db 10, 0
primary_expr_variable_string_2: db "LOAD_IMMEDIATE_eax %", 0


;; function_call function
;; Receives char* S in EAX and int BOOL in EBX
;; Builds stack frames before and tears them down after function calls
;; Uses ECX for char* S, EDX for int BOOL, ESI for PASSED
function_call:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	push esi                    ; Protect ESI
	mov ecx, eax                ; Put S in place
	mov edx, ebx                ; Put BOOL in place
	mov esi, 0                  ; PASSED = 0

	mov eax, function_call_string_0 ; Using "ERROR in process_expression_list\nNo ( was found\n"
	mov ebx, open_paren         ; Using "("
	call require_match          ; Make sure we have it

	mov eax, function_call_string_1 ; Using "PUSH_edi\t# Prevent overwriting in recursion\n"
	call emit_out               ; Emit it

	mov eax, function_call_string_2 ; Using "PUSH_ebp\t# Protect the old base pointer\n"
	call emit_out               ; Emit it

	mov eax, function_call_string_3 ; Using "COPY_esp_to_edi\t# Copy new base pointer\n"
	call emit_out               ; Emit it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	cmp eax, 41                 ; IF global_token->S[0] == ")"
	je function_call_gen_done   ; Then no arguments to send

	;; looks like we have arguments to collect
	call expression             ; Collect the argument

	mov eax, function_call_string_4 ; Using "PUSH_eax\t#_process_expression1\n"
	call emit_out               ; Emit it
	mov esi, 1                  ; PASSED = 1

function_call_gen_iter:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	cmp eax, 44                 ; IF global_token->S[0] == ","
	jne function_call_gen_done  ; Otherwise we are done

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	call expression             ; Collect the argument

	mov eax, function_call_string_5 ; Using "PUSH_eax\t#_process_expression2\n"
	call emit_out               ; Emit it
	add esi, 1                  ; PASSED = PASSED + 1
	jmp function_call_gen_iter  ; Keep trying

function_call_gen_done:
	;; All is collected
	mov eax, function_call_string_6 ; Using "ERROR in process_expression_list\nNo ) was found\n"
	mov ebx, close_paren         ; Using ")"
	call require_match          ; Make sure we have it

	cmp edx, 0                  ; IF(BOOL == TRUE)
	jne function_call_static    ; Otherwise it is a static call

	;; Deal with a passed function pointer
	mov eax, function_call_string_7 ; Using "LOAD_BASE_ADDRESS_eax %"
	call emit_out               ; Emit it

	mov eax, ecx                ; Using S
	call emit_out               ; Emit it

	mov eax, function_call_string_8 ; Using "\nLOAD_INTEGER\n"
	call emit_out               ; Emit it

	mov eax, function_call_string_9 ; Using "COPY_edi_to_ebp\n"
	call emit_out               ; Emit it

	mov eax, function_call_string_10 ; Using "CALL_eax\n"
	call emit_out               ; Emit it

	mov eax, function_call_string_13 ; Using "POP_ebx\t# _process_expression_locals\n"
	jmp function_call_cleanup   ; Clean up

function_call_static:
	;; Deal with fixed function name
	mov eax, function_call_string_9 ; Using "COPY_edi_to_ebp\n"
	call emit_out               ; Emit it

	mov eax, function_call_string_11 ; Using "CALL_IMMEDIATE %FUNCTION_"
	call emit_out               ; Emit it

	mov eax, ecx                ; Using S
	call emit_out               ; Emit it

	mov eax, function_call_string_12 ; Using "\n"
	call emit_out               ; Emit it

	mov eax, function_call_string_13 ; Using "POP_ebx\t# _process_expression_locals\n"

function_call_cleanup:
	cmp esi, 0                  ; IF PASSED > 0
	jle function_call_done      ; Otherwise be done

	;; The desired string is already in EAX
	call emit_out               ; Emit it

	sub esi, 1                  ; PASSED = PASSED - 1
	jmp function_call_cleanup   ; Keep going

function_call_done:
	mov eax, function_call_string_14 ; Using "POP_ebp\t# Restore old base pointer\n"
	call emit_out               ; Emit it

	mov eax, function_call_string_15 ; Using "POP_edi\t# Prevent overwrite\n"
	call emit_out               ; Emit it

	pop esi                     ; Restore ESI
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

function_call_string_0: db "ERROR in process_expression_list", 10, "No ( was found", 10, 0
function_call_string_1: db "PUSH_edi", 9, "# Prevent overwriting in recursion", 10, 0
function_call_string_2: db "PUSH_ebp", 9, "# Protect the old base pointer", 10, 0
function_call_string_3: db "COPY_esp_to_edi", 9, "# Copy new base pointer", 10, 0
function_call_string_4: db "PUSH_eax", 9, "#_process_expression1", 10, 0
function_call_string_5: db "PUSH_eax", 9, "#_process_expression2", 10, 0
function_call_string_6: db "ERROR in process_expression_list", 10, "No ) was found", 10, 0
function_call_string_7: db "LOAD_BASE_ADDRESS_eax %", 0
function_call_string_8: db 10, "LOAD_INTEGER", 10, 0
function_call_string_9: db "COPY_edi_to_ebp", 10, 0
function_call_string_10: db "CALL_eax", 10, 0
function_call_string_11: db "CALL_IMMEDIATE %FUNCTION_", 0
function_call_string_12: db 10, 0
function_call_string_13: db "POP_ebx", 9, "# _process_expression_locals", 10, 0
function_call_string_14: db "POP_ebp", 9, "# Restore old base pointer", 10, 0
function_call_string_15: db "POP_edi", 9, "# Prevent overwrite", 10, 0


;; variable_load function
;; Receives struct token_list* A in EAX
;; Returns nothing
;; Updates output and current_target
;; Uses ECX for A
variable_load:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ecx, eax                ; Protect A

	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, open_paren         ; Using "("
	call match                  ; IF global_token->S == "("
	cmp eax, 0                  ; Then it might be a function
	jne variable_load_regular   ; Otherwise it is regular

	mov ebx, [ecx+12]           ; A->TYPE
	mov ebx, [ebx+24]           ; A->TYPE->NAME
	mov eax, type_function_name ; Using "FUNCTION"
	call match                  ; IF A->TYPE->NAME == "FUNCTION"
	cmp eax, 0                  ; Then it must be a function
	jne variable_load_regular   ; otherwise just another regular

	;; deal with function
	mov eax, [ecx+16]           ; A->DEPTH
	call numerate_number        ; Convert to string
	mov ebx, 0                  ; pass 0 for true
	call function_call          ; Create the function call
	jmp variable_load_done      ; Be done

variable_load_regular:
	mov eax, [ecx+12]           ; A->TYPE
	mov [current_target], eax   ; current_target = A->TYPE

	mov eax, variable_load_string_0 ; Using "LOAD_BASE_ADDRESS_eax %"
	call emit_out               ; Emit it

	mov eax, [ecx+16]           ; A->DEPTH
	call numerate_number        ; Convert to string
	call emit_out               ; Emit it

	mov eax, variable_load_string_1 ; Using "\n"
	call emit_out               ; Emit it

	;; Check for special case of assignment
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, equal              ; Using "="
	call match                  ; IF global_token->S == "="
	cmp eax, 0                  ; Then we skip loading
	je variable_load_done       ; And be done

	;; Deal with common case
	mov eax, variable_load_string_2 ; Using "LOAD_INTEGER\n"
	call emit_out               ; Emit it

variable_load_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

variable_load_string_0: db "LOAD_BASE_ADDRESS_eax %", 0
variable_load_string_1: db 10, 0
variable_load_string_2: db "LOAD_INTEGER", 10, 0


;; function_load function
;; Receives struct token_list* a in EAX
;; Returns nothing
;; Uses ECX to hold A->S
function_load:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, [eax+8]            ; A->S
	mov ecx, eax                ; Protect A->S
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, open_paren         ; Using "("
	call match                  ; IF global_token->S == "("
	cmp eax, 0                  ; The we need to do a function call
	jne function_load_regular   ; Otherwise just load it's address

	;; Deal with function call
	mov eax, ecx                ; Using A->S
	mov ebx, 1                  ; Using FALSE
	call function_call          ; Deal with it
	jmp function_load_done      ; Be done

function_load_regular:
	mov eax, function_load_string_0 ; Using "LOAD_IMMEDIATE_eax &FUNCTION_"
	call emit_out               ; Emit it

	mov eax, ecx                ; Using A->S
	call emit_out               ; Emit it

	mov eax, function_load_string_1 ; Using "\n"
	call emit_out               ; Emit it

function_load_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

function_load_string_0: db "LOAD_IMMEDIATE_eax &FUNCTION_", 0
function_load_string_1: db 10, 0


;; global_load function
;; Receives struct token_list* A in EAX
;; Returns nothing
;; Uses EBX to hold A->S
global_load:
	push ebx                    ; Protect EBX
	mov ebx, eax                ; Set as A
	mov ebx, [ebx+8]            ; Set as A->S

	mov eax, [eax+12]           ; A->TYPE
	mov [current_target], eax   ; current_target = A->TYPE

	mov eax, global_load_string_0 ; Using "LOAD_IMMEDIATE_eax &GLOBAL_"
	call emit_out               ; Emit it

	mov eax, ebx                ; Using A->S
	call emit_out               ; Emit it

	mov eax, global_load_string_1 ; Using "\n"
	call emit_out               ; Emit it

	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, equal              ; "="
	call match                  ; IF global_token->S == "="
	cmp eax, 0                  ; We need to skip for assignment
	je global_load_done         ; and be done

	;; Otherwise we are loading the contents
	mov eax, global_load_string_2 ; Using "LOAD_INTEGER\n"
	call emit_out               ; Emit it

global_load_done:
	pop ebx                     ; Restore EBX
	ret

global_load_string_0: db "LOAD_IMMEDIATE_eax &GLOBAL_", 0
global_load_string_1: db 10, 0
global_load_string_2: db "LOAD_INTEGER", 10, 0


;; sym_lookup function
;; Receives char* S in EAX and struct token_list* symbol_list in EBX
;; Uses I->S in EAX, S in EBX and I in ECX
;; Returns match or NULL
sym_lookup:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ecx, ebx                ; I = symbol_list
	mov ebx, eax                ; Put S in the right place
sym_lookup_iter:
	cmp ecx, 0                  ; IF NULL == I
	je sym_lookup_done          ; We failed to find match

	mov eax, [ecx+8]            ; Using I->S
	call match                  ; IF I->S == S
	cmp eax, 0                  ; then be done
	je sym_lookup_done          ; Failed

	mov ecx, [ecx]              ; I = I->NEXT
	jmp sym_lookup_iter         ; otherwise keep looping

sym_lookup_done:
	mov eax, ecx                ; Return I
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; primary_expr_number function
;; Receives nothing
;; Returns nothing
;; Simply uses current global token to update output and then steps to next global_token
primary_expr_number:
	mov eax, primary_expr_number_string_0 ; Using "LOAD_IMMEDIATE_eax %"
	call emit_out               ; Emit it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	call emit_out               ; Emit it

	mov eax, primary_expr_number_string_1 ; Using "\n"
	call emit_out               ; Emit it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT
	ret

primary_expr_number_string_0: db "LOAD_IMMEDIATE_eax %", 0
primary_expr_number_string_1: db 10, 0


;; primary_expr_string function
;; receives nothing
;; Returns nothing
;; creates entries for string and calls to generate string output
;; uses ECX for char* number_string
primary_expr_string:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ebx, [current_count]    ; Using current_count
	mov eax, ebx                ; And putting it in the right place
	call numerate_number        ; Get the string
	mov ecx, eax                ; protect number_string

	add ebx, 1                  ; current_count + 1
	mov [current_count], ebx    ; current_count = current_count + 1

	mov eax, primary_expr_string_string_0 ; Using "LOAD_IMMEDIATE_eax &STRING_"
	call emit_out               ; Emit it

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	mov ebx, ecx                ; Put number_string in the right place
	call uniqueID_out           ; Make it unique

	;; Generate the target
	mov eax, primary_expr_string_string_1 ; Using ":STRING_"
	mov ebx, [strings_list]     ; Using strings_list
	call emit                   ; Emit it
	mov ebx, eax                ; put new strings_list in place

	mov eax, [function]         ; Using function
	mov eax, [eax+8]            ; function->S
	call uniqueID               ; Make it unique
	mov ebx, eax                ; put new strings_list in place

	;; Parse the string
	mov eax, [global_token]     ; Using global token
	mov eax, [eax+8]            ; global_token->S
	call parse_string           ; convert to useful form
	call emit                   ; Emit it
	mov [strings_list], eax     ; Update Strings _list

	mov eax, [global_token]     ; Using global token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

primary_expr_string_string_0: db "LOAD_IMMEDIATE_eax &STRING_", 0
primary_expr_string_string_1: db ":STRING_", 0


;; primary_expr_char function
;; Receives nothing
;; Returns nothing
;; Updates output_list using global_token
primary_expr_char:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov eax, primary_expr_char_string_0 ; Using "LOAD_IMMEDIATE_eax %"
	call emit_out               ; Emit it

	mov eax, [global_token]     ; Using global token
	mov eax, [eax+8]            ; global_token->S
	add eax, 1                  ; global_token->S + 1
	call escape_lookup          ; Get the char
	call numerate_number        ; Convert to string
	call emit_out               ; emit it

	mov eax, primary_expr_char_string_1 ; Using "\n"
	call emit_out               ; Emit it

	mov eax, [global_token]     ; Using global token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

primary_expr_char_string_0: db "LOAD_IMMEDIATE_eax %", 0
primary_expr_char_string_1: db 10, 0


;; primary_expr_failure function
;; Receives nothing
;; Does not return but aborts hard
;; Complains about the bad input
primary_expr_failure:
;	call line_error             ; Get line of issue
	mov eax, 2                  ; Using Standard error
	mov [Output_file], eax      ; write to standard error
	mov eax, primary_expr_failure_string_0 ; Using "Received "
	call File_Print             ; Print it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	call File_Print             ; Print it

	mov eax, primary_expr_failure_string_1 ; Using " in primary_expr\n"
	call File_Print             ; Print it
	jmp Exit_Failure            ; Abort Hard

primary_expr_failure_string_0: db "Received ", 0
primary_expr_failure_string_1: db " in primary_expr", 10, 0


;; general_recursion function
;; Receives FUNCTION F in EAX, char* S in EBX, char* name in ECX and FUNCTION iterate in EDX
;; Returns nothing
;; Uses ECX for char* S, EDX for FUNCTION iterate and EBP for FUNCTION F
;; But generally recurses a shitload
general_recursion:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	push ebp                    ; Protect EBP
	mov ebp, eax                ; Protect F
	mov eax, ecx                ; Put name in the right place
	mov ecx, ebx                ; Protect S

	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	call match                  ; IF match(name, global_token->s)
	cmp eax, 0                  ; If true we do
	jne general_recursion_done  ; Otherwise skip it

	;; Deal with the recursion
	mov eax, ebp                ; Put F in the right place
	call common_recursion       ; Recurse

	mov eax, ecx                ; Put S in the right place
	call emit_out               ; Emit it

	mov eax, edx                ; Put iterate in the right place
	call eax                    ; Down the rabbit hole

general_recursion_done:
	pop ebp                     ; Restore EBP
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; promote_type function
;; Receives struct type* a in EAX and struct type* b in EBX
;; Returns the most recent type in EAX
;; Uses EAX for struct type* I, ECX for struct type* A and EDX for struct type* B
promote_type:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	cmp ebx, 0                  ; IF NULL == B
	je promote_type_done        ; Just return A

	mov ecx, eax                ; Put A in place
	mov edx, ebx                ; Put B in place
	mov eax, ebx                ; IF NULL == A
	cmp ecx, 0                  ; Then we just return B
	je promote_type_done        ; Be done

	;; Looks like we need to walk the list
	mov ecx, [ecx+24]           ; A->NAME
	mov edx, [edx+24]           ; B->NAME
	mov eax, [global_types]     ; I = global_types
promote_type_iter:
	cmp eax, 0                  ; IF NULL == I
	je promote_type_done        ; Just be done

	mov ebx, [eax+24]           ; I->NAME
	cmp ebx, ecx                ; IF(A->NAME == I->NAME)
	je promote_type_done        ; Be done

	cmp ebx, edx                ; IF(B->NAME == I->NAME)
	je promote_type_done        ; Be done

	mov ebx, [eax+12]           ; I->INDIRECT
	mov ebx, [ebx+24]           ; I->INDIRECT->NAME

	cmp ebx, ecx                ; IF(A->NAME == I->INDIRECT->NAME)
	je promote_type_done        ; Be done

	cmp ebx, edx                ; IF(B->NAME == I->INDIRECT->NAME)
	je promote_type_done        ; Be done

	mov eax, [eax]              ; I = I->NEXT
	jmp promote_type_iter       ; Keep going

promote_type_done:
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; common_recursion function
;; Receives FUNCTION F in EAX
;; Returns Nothing
;; Walks global_token list and update output_list
;; Updates current_target
;; Uses EBX to hold FUNCTION F and struct type* last_type
common_recursion:
	push ebx                    ; Protect EBX
	mov ebx, eax                ; Put FUNCTION F safely out of the way
	mov eax, common_recursion_string_0 ; Using "PUSH_eax\t#_common_recursion\n"
	call emit_out               ; Emit it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, ebx                ; Prepare for function call
	mov ebx, [current_target]   ; Get last type
	call eax                    ; F();
	mov eax, [current_target]   ; Get current_target
	call promote_type           ; get the right type
	mov [current_target], eax   ; Set new current_target

	mov eax, common_recursion_string_1 ; Using "POP_ebx\t# _common_recursion\n"
	call emit_out               ; Emit it
	pop ebx                     ; Restore EBX
	ret

common_recursion_string_0: db "PUSH_eax", 9, "#_common_recursion", 10, 0
common_recursion_string_1: db "POP_ebx", 9, "# _common_recursion", 10, 0


;; require_match function
;; Receives char* message in EAX and char* required in EBX
;; Returns nothing
;; Uses ECX to hold message and updates global_token
require_match:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ecx, eax                ; put the message somewhere safe
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	call match                  ; IF required == global_token->S
	cmp eax, 0                  ; we are fine
	je require_match_good       ; otherwise pain

	;; Deal with bad times
;	call line_error             ; Tell user what went wrong
	mov eax, 2                  ; Using standard error
	mov [Output_file], eax      ; write to standard error
	mov eax, ecx                ; using our message
	call File_Print             ; Print it
	jmp Exit_Failure            ; Abort HARD

require_match_good:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->next
	mov [global_token], eax     ; global_token = global_token->next
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; uniqueID Function
;; Receives char *S in EAX, struct token_list* l in EBX and char* num in ECX
;; Returns updated struct token_list* L in EAX
uniqueID:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	call emit                   ; emit(s, l)
	mov ebx, eax                ; Put L in correct place
	mov eax, underline          ; Using "_"
	call emit                   ; emit("_", l)
	mov ebx, eax                ; Put L in correct place
	mov eax, ecx                ; Put num in correct place
	call emit                   ; emit(num, l)
	mov ebx, eax                ; Put L in correct place
	mov eax, uniqueID_string_0  ; Using "\n"
	call emit                   ; emit("\n", l)
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

uniqueID_string_0: db 10, 0


;; uniqueID_out function
;; Receives char* S in EAX and char* num in EBX
;; Returns nothing
uniqueID_out:
	push eax                    ; Protect EAX
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ecx, ebx                ; Put num in right spot
	mov ebx, [output_list]      ; Using output_list
	call uniqueID               ; Get updated list
	mov [output_list], eax      ; output_list = uniqueID(s, output_list, num)
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	pop eax                     ; Restore EAX
	ret


;; emit_out function
;; Receives char* S in EAX
;; Returns nothing
;; Updates output_list
;; MUST NOT ALTER REGISTERS
emit_out:
	push eax                    ; Protect EAX
	push ebx                    ; Protect EBX
	mov ebx, [output_list]      ; Using output_list
	call emit                   ; emit it
	mov [output_list], eax      ; update it
	pop ebx                     ; Restore EBX
	pop eax                     ; Restore EAX
	ret


;; emit function
;; Receives char *s in EAX and struct token_list* head in EBX
;; Returns struct token_list* T in EAX
emit:
	push ecx                    ; Protect ECX
	mov ecx, eax                ; put S out of the way
	mov eax, 20                 ; sizeof(struct token_list)
	call malloc                 ; get T
	mov [eax], ebx              ; t->next = head;
	mov [eax+8], ecx            ; t->s = s;
	pop ecx                     ; Restore ECX
	ret


;; escape_lookup function
;; Receives char* c in EAX
;; Returns integer value of char in EAX
;; Aborts hard if unknown escape is received
;; Uses ECX to hold char* C
escape_lookup:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ecx, eax                ; Put char* C in safe place
	mov al, [ecx]               ; Load c[0]
	movzx eax, al               ; make it useful
	cmp eax, 92                 ; If '\\' != c[0]
	jne escape_lookup_done      ; Be done

	mov ebx, ecx                ; Prepare for walk
	add ebx, 1                  ; increment
	mov bl, [ebx]               ; load c[1]
	movzx ebx, bl               ; make it useful

	cmp ebx, 120                ; Check if \x??
	je escape_lookup_hex        ; Deal with hex

	;; Deal with \? escapes
	mov eax, 10                 ; Guess "\n"
	cmp ebx, 110                ; If n
	je escape_lookup_done       ; Be done

	mov eax, 9                  ; Guess "\t"
	cmp ebx, 116                ; If t
	je escape_lookup_done       ; Be done

	mov eax, ebx                ; "\\", "'" and '\"' all encode as themselves
	cmp ebx, 92                 ; If "\\"
	je escape_lookup_done       ; Be done
	cmp ebx, 39                 ; IF "'"
	je escape_lookup_done       ; Be done
	cmp ebx, 34                 ; IF '\"'
	je escape_lookup_done       ; Be done

	mov eax, 13                 ; Guess "\r"
	cmp ebx, 114                ; IF r
	je escape_lookup_done       ; Be done

	;; Looks like we have no clue what we are doing
	;; Aborting hard
	mov eax, 2                  ; Using Standard error
	mov [Output_file], eax      ; write to standard error
	mov eax, escape_lookup_string_0 ; Using "Unknown escape received: "
	call File_Print             ; Print it
	mov eax, ecx                ; Using C
	call File_Print             ; Print it
	mov eax, escape_lookup_string_1 ; Using " Unable to process\n"
	call File_Print             ; Print it
	jmp Exit_Failure            ; Abort Hard

escape_lookup_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

escape_lookup_hex:
	;; Give up on C and just assume they know what they are doing
	add ecx, 2                  ; increment
	mov al, [ecx]               ; c[2]
	movzx eax, al               ; make it useful
	add ecx, 1                  ; increment
	call char2hex               ; Get the hex value
	sal eax, 4                  ; c << 4
	mov bl, [ecx]               ; c[3]
	movzx ebx, bl               ; make it useful
	xchg eax, ebx               ; protect c << 4
	call char2hex               ; Get the hex value
	add eax, ebx                ; hex(c[2]) << 4 + hex(c[3])
	jmp escape_lookup_done      ; Be done

escape_lookup_string_0: db "Unknown escape received: ", 0
escape_lookup_string_1: db " Unable to process", 10, 0


;; char2hex function
;; Receives char in EAX
;; Returns hex or aborts hard
char2hex:
	sub eax, 48                 ; Try 0-9
	cmp eax, 10                 ; Otherwise fun times
	jl char2hex_done            ; Be done

	;; Deal with A-F
	and eax, 0xDF               ; Unset High bit turning a-f into A-F
	sub eax, 7                  ; Shift down into position
	cmp eax, 10                 ; Everything below A is bad
	jl char2hex_fail            ; And should fail
	cmp eax, 16                 ; Make sure we are below F
	jl char2hex_done            ; If so be done

char2hex_fail:
	;; Time to fail hard
	mov eax, 2                  ; Using Standard error
	mov [Output_file], eax      ; write to standard error
	mov eax, char2hex_string_0  ; Using "Tried to print non-hex number\n"
	call File_Print             ; Print it
	jmp Exit_Failure            ; Abort Hard

char2hex_done:
	ret

char2hex_string_0: db "Tried to print non-hex number", 10, 0


;; parse_string function
;; Receives char* string in EAX
;; Returns cleaned up string
;; Protects char* string in EBX
parse_string:
	push ebx                    ; Protect EBX
	mov ebx, eax                ; Protect char* string
	call weird                  ; Determine if we have a weird string
	cmp eax, 0                  ; If weird
	je parse_string_weird       ; Deal with it

	;; Dealing with regular string
	mov eax, ebx                ; Passing Char* string
	call collect_regular_string ; Collect it
	jmp parse_string_done       ; Be done

parse_string_weird:
	mov eax, ebx                ; Passing Char* string
	call collect_weird_string   ; Collect it

parse_string_done:
	pop ebx                     ; Restore EBX
	ret


;; weird function
;; Receives char* string in EAX
;; Returns true(0) or false(1) in EAX
;; Uses ECX to hold char* string
weird:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ecx, eax                ; Place string in safe place
	add ecx, 1                  ; increment past the '\"'
weird_reset:
	mov al, [ecx]               ; Load a char
	movzx eax, al               ; Make it useful
	cmp eax, 0                  ; IF NULL == C
	je weird_false              ; Nothing weird found

	cmp eax, 92                 ; IF '\\'
	jne weird_escaped           ; Deal with escaping

	;; Deal with escape
	mov eax, ecx                ; We are passing the string
	call escape_lookup          ; to look it up

	add ecx, 1                  ; string = string + 1
	mov bl, [ecx]               ; get string[1]
	movzx ebx, bl               ; make it useful
	cmp ebx, 120                ; IF 'x' == string[1]
	jne weird_escaped           ; otherwise skip the gap

	add ecx, 2                  ; string = string + 2

weird_escaped:
	push eax                    ; Protect C in case we need it
	mov ebx, weird_string_0     ; Use "\t\n !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
	call In_Set                 ; To find if weird
	cmp eax, 1                  ; IF TRUE
	pop eax                     ; Restore C
	jne weird_true              ; Then not weird

	add ecx, 1                  ; string = string + 1

	;; Last chance for weird
	mov ebx, weird_string_1     ; Use "\t\n\r "
	call In_Set                 ; Check for special case
	cmp eax, 1                  ; IF TRUE
	jne weird_reset             ; Otherwise not in the special case

	;; Deal with possible special case
	mov al, [ecx]               ; Load string[1]
	movzx eax, al               ; Make it useful
	cmp eax, 58                 ; IF string[1] == ":"
	je weird_true               ; Then we hit the special case
	jmp weird_reset             ; Keep trying

weird_done:
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

weird_true:
	mov eax, 0                  ; Return true
	jmp weird_done              ; Be done

weird_false:
	mov eax, 1                  ; Return false
	jmp weird_done              ; Be done

weird_string_0: db 9, 10, " !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~", 0
weird_string_1: db 9, 10, 13, 32, 0


;; collect_regular_string function
;; Receives char* string in EAX
;; Malloc and creates new string to return in EAX
;; Uses ECX for return string and EDX for passed string
collect_regular_string:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	mov edx, eax                ; Protect our passed string
	mov eax, 256                ; We need 256bytes of storage
	call malloc                 ; Get our new pointer
	mov ecx, eax                ; put it in place
	push eax                    ; protect until done
collect_regular_string_reset:
	mov al, [edx]               ; string[0]
	movzx eax, al               ; Make it useful
	cmp eax, 0                  ; See if we hit the end
	je collect_regular_string_done ; And be done

	cmp eax, 92                 ; IF string[0] == '\\'
	je collect_regular_string_escaped ; Deal with that mess

	;; deal with boring char
	mov [ecx], al               ; hold_string[index] = string[0]
	add ecx, 1                  ; Increment it
	add edx, 1                  ; Increment it
	jmp collect_regular_string_reset ; And keep going

collect_regular_string_escaped:
	mov eax, edx                ; Using string
	call escape_lookup          ; Get the char
	mov [ecx], al               ; hold_string[index] = escape_lookup(string)
	add edx, 1                  ; Increment it
	add ecx, 1                  ; Increment it
	mov al, [edx]               ; string[0]
	movzx eax, al               ; Make it useful
	add edx, 1                  ; Increment it
	cmp eax, 120                ; IF 'x' == string[1]
	jne collect_regular_string_reset ; Otherwise keep going

	add edx, 2                  ; Increment it
	jmp collect_regular_string_reset ; Keep going

collect_regular_string_done:
	mov eax, 34                 ; Using '\"'
	mov [ecx], al               ; hold_string[index] = '\"'
	add ecx, 1                  ; Increment it
	mov eax, 10                 ; Using "\n"
	mov [ecx], al               ; hold_string[index] = '\n'
	pop eax                     ; Return our new string
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; collect_weird_string function
;; Receives char* string in EAX
;; Mallocs and returns char* hold in EAX
;; Uses ECX for char* hold and EDX for char* string
collect_weird_string:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	mov edx, eax                ; Protect our passed string
	mov eax, 512                ; We need 512bytes of storage
	call malloc                 ; Get our new pointer
	mov ecx, eax                ; put it in place
	push eax                    ; protect until done

	mov eax, 39                 ; Using "'"
	mov [ecx], al               ; hold_string[index] = "'"
	add ecx, 1                  ; Increment it
	add edx, 1                  ; Increment it
collect_weird_string_reset:
	mov al, [edx]               ; Read a byte
	movzx eax, al               ; Make it useful
	cmp eax, 0                  ; IF NULL == string[0]
	je collect_weird_string_done ; Be done

	mov eax, 32                 ; Using ' '
	mov [ecx], al               ; hold_string[index] = ' '
	add ecx, 1                  ; Increment it

	mov eax, edx                ; Using string
	call escape_lookup          ; Get the char
	call hex8                   ; Update ECX

	mov al, [edx]               ; Read a byte
	movzx eax, al               ; Make it useful
	add edx, 1                  ; Increment it
	cmp eax, 92                 ; IF string[0] == '\\'
	jne collect_weird_string_reset ; Otherwise keep going

	mov al, [edx]               ; Read a byte
	movzx eax, al               ; Make it useful
	add edx, 1                  ; Increment it
	cmp eax, 120                ; IF 'x' == string[1]
	jne collect_weird_string_reset ; Otherwise keep going

	add edx, 2                  ; Increment it
	jmp collect_weird_string_reset ; Keep going

collect_weird_string_done:
	mov eax, 32                 ; Using ' '
	mov [ecx], al               ; hold_string[index] = ' '
	add ecx, 1                  ; Increment it
	mov eax, 48                 ; Using '0'
	mov [ecx], al               ; hold_string[index] = '0'
	add ecx, 1                  ; Increment it
	mov [ecx], al               ; hold_string[index] = '0'
	add ecx, 1                  ; Increment it
	mov eax, 39                 ; Using "'"
	mov [ecx], al               ; hold_string[index] = "'"
	add ecx, 1                  ; Increment it
	mov eax, 10                 ; Using "\n"
	mov [ecx], al               ; hold_string[index] = '\n'
	pop eax                     ; Return our new string
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; HEX to ascii routine
;; Receives INT in EAX and CHAR* in ECX
;; Stores ascii of INT in CHAR*
;; Returns only modifying EAX and ECX
hex8:
	push eax                    ; Protect bottom nibble
	shr eax, 4                  ; do high nibble first
	call hex4                   ; Store it
	pop eax                     ; do low nibble
hex4:
	and eax, 0xf                ; isolate nibble
	add al,'0'                  ; convert to ascii
	cmp al,'9'                  ; valid digit?
	jbe hex1                    ; yes
	add al,7                    ; use alpha range
hex1:
	mov [ecx], al               ; store result
	add ecx, 1                  ; next position
	ret


;; type_name function
;; Receives nothing
;; Returns type_size in EAX
;; Uses ECX for STRUCT TYPE* RET
type_name:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx+8]            ; global_token->S
	mov eax, struct             ; Using "struct"
	call match                  ; IF global_token->S == "struct"
	mov ecx, eax                ; Protect structure
	cmp eax, 0                  ; need to skip over "struct"
	jne type_name_native        ; otherwise keep going

	;; Deal with possible STRUCTs
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx]              ; global_token->next
	mov [global_token], ebx     ; global_token = global_token->next
	mov eax, [ebx+8]            ; global_token->S
	mov ebx, [global_types]     ; get all known types
	call lookup_type            ; Find type if possible
	mov ecx, eax                ; Set ret

	cmp eax, 0                  ; IF NULL == ret
	jne type_name_common        ; We have to create struct

	;; Create a struct
	call create_struct          ; Create a new struct
	mov ecx, 0                  ; We wish to return NULL
	jmp type_name_done          ; be done

type_name_native:
	;; Deal only with native types
	mov eax, ebx                ; Put global_token->S in the right place
	mov ebx, [global_types]     ; get all known types
	call lookup_type            ; Find the type if possible
	mov ecx, eax                ; Set ret

	cmp eax, 0                  ; IF NULL == ret
	jne type_name_common        ; We need to abort hard

	;; Aborting hard
	mov eax, 2                  ; Using Standard error
	mov [Output_file], eax      ; write to standard error
	mov eax, type_name_string_0 ; Print header
	call File_Print             ; Print it

	mov eax, [global_token]     ; Using global token
	mov eax, [eax+8]            ; global_token->S
	call File_Print             ; Print it

	mov eax, type_name_string_1 ; Print footer
	call File_Print             ; Print it

;	call line_error             ; Give details
	jmp Exit_Failure           ; Abort

type_name_common:
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx]              ; global_token->next
	mov [global_token], ebx     ; global_token = global_token->next

type_name_iter:
	mov eax, [ebx+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; make it useful
	cmp eax, 42                 ; IF global_token->S[0] == '*'
	jne type_name_done          ; recurse

	;; Deal with char**
	mov ecx, [ecx+12]           ; ret = ret->indirect
	mov ebx, [global_token]     ; Using global_token
	mov ebx, [ebx]              ; global_token->next
	mov [global_token], ebx     ; global_token = global_token->next
	jmp type_name_iter          ; keep looping

type_name_done:
	mov eax, ecx                ; put ret in the right place
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

type_name_string_0: db "Unknown type ", 0
type_name_string_1: db 10, 0


;; lookup_type function
;; Receives char* s in EAX and struct type* start in EBX
;; Returns struct type* in EAX
;; Uses EBX for S and ECX for I
lookup_type:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	mov ecx, ebx                ; I = Start
	mov ebx, eax                ; Put S in place
lookup_type_iter:
	cmp ecx, 0                  ; Check if I == NULL
	je lookup_type_done         ; return NULL

	mov eax, [ecx+24]           ; I->NAME
	call match                  ; Check if matching
	cmp eax, 0                  ; IF I->NAME == S
	je lookup_type_done         ; return it

	mov ecx, [ecx]              ; Otherwise I = I->NEXT
	jmp lookup_type_iter        ; And keep looping

lookup_type_done:
	mov eax, ecx                ; return either I or NULL
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; create_struct function
;; Receives nothing
;; Returns nothing
;; Uses global_token to malloc a struct's definition
;; Uses ECX for int OFFSET, EDX for struct type* head, EBP for struct type* I,
;; EDI for member_size (Which is passed) and ESI for LAST
;; EAX and EBX are used for scratch
create_struct:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	push ebp                    ; Protect EBP
	push edi                    ; Protect EDI
	push esi                    ; Protect ESI
	mov ecx, 0                  ; OFFSET = 0
	mov edi, 0                  ; member_size = 0

	mov eax, 28                 ; sizeof(struct type)
	call malloc                 ; malloc(sizeof(struct type))
	mov edx, eax                ; Set HEAD

	mov eax, 28                 ; sizeof(struct type)
	call malloc                 ; malloc(sizeof(struct type))
	mov ebp, eax                ; Set I

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov [edx+24], eax           ; HEAD->NAME = global_token->S
	mov [ebp+24], eax           ; I->NAME = global_token->S

	mov [edx+12], ebp           ; HEAD->INDIRECT = I
	mov [ebp+12], edx           ; I->INDIRECT = HEAD

	mov eax, [global_types]     ; Using global_types
	mov [edx], eax              ; HEAD->NEXT = global_types
	mov [global_types], edx     ; global_types = HEAD

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, 4                  ; Using register size
	mov [ebp+4], eax            ; I->SIZE = register size

	mov eax, create_struct_string_0 ; Using "ERROR in create_struct\n Missing {\n"
	mov ebx, open_curly_brace   ; Using "{"
	call require_match          ; Make sure we have it

	mov esi, 0                  ; LAST = NULL

create_struct_iter:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; Make it useful
	cmp eax, 125                ; IF global_token->S[0] == "}"
	je create_struct_done       ; be done

	;; Looks like we are adding members
	;; Lets see if it is a union
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov ebx, union              ; Using "union"
	call match                  ; IF match(global_token->s, "union")
	cmp eax, 0                  ; Deal with union
	jne create_struct_single    ; Otherwise deal with singles

	;; Deal with union
	mov eax, esi                ; Put last in right place
	mov ebx, ecx                ; put offset in right place
	call build_union            ; ASSEMBLE
	mov esi, eax                ; last = build_union(last, offset)
	add ecx, edi                ; offset = offset + member_size

	mov eax, create_struct_string_1 ; Using "ERROR in create_struct\n Missing ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it
	jmp create_struct_iter      ; keep going

create_struct_single:
	;; deal with singles
	mov eax, esi                ; Put last in right place
	mov ebx, ecx                ; put offset in right place
	call build_member           ; ASSEMBLE
	mov esi, eax                ; last = build_union(last, offset)
	add ecx, edi                ; offset = offset + member_size

	mov eax, create_struct_string_1 ; Using "ERROR in create_struct\n Missing ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it
	jmp create_struct_iter      ; keep going

create_struct_done:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, create_struct_string_1 ; Using "ERROR in create_struct\n Missing ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it

	mov [edx+4], ecx            ; HEAD->SIZE = OFFSET
	mov [edx+16], esi           ; HEAD->MEMBERS = LAST
	mov [ebp+16], esi           ; I->MEMBERS = LAST

	pop esi                     ; Restore ESI
	pop edi                     ; Restore EDI
	pop ebp                     ; Restore EBP
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

create_struct_string_0: db "ERROR in create_struct", 10, " Missing {", 10, 0
create_struct_string_1: db "ERROR in create_struct", 10, " Missing ;", 10, 0


;; lookup_member function
;; Receives struct type* parent in EAX and char* name in EBX
;; Returns struct type* I in EAX
;; Uses char* NAME in EBX, ECX for struct type* I and EDX to hold parent for errors
;; Aborts hard if not found
lookup_member:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	mov edx, eax                ; Protect Parent
	mov ecx, [eax+16]           ; struct type* I = parent->MEMBERS
lookup_member_iter:
	cmp ecx, 0                  ; IF I == NULL
	je lookup_member_fail       ; Abort HARD

	mov eax, [ecx+24]           ; Using I->NAME
	call match                  ; IF I->NAME == NAME
	cmp eax, 0                  ; Then we have found the member
	mov eax, ecx                ; Prepare for return
	mov ecx, [ecx+16]           ; Prepare for loop I = I->MEMBERS
	jne lookup_member_iter      ; Looks like we are looping

	;; I is already in EAX
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

lookup_member_fail:
	mov eax, 2                  ; Using Standard error
	mov [Output_file], eax      ; write to standard error
	mov eax, lookup_member_string_0 ; Using "ERROR in lookup_member "
	call File_Print             ; print it

	mov eax, [edx+24]           ; PARENT->NAME
	call File_Print             ; print it

	mov eax, arrow_string       ; Using "->"
	call File_Print             ; print it

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	call File_Print             ; print it

	mov eax, lookup_member_string_1 ; Using " does not exist\n"
	call File_Print             ; print it

;	call line_error             ; Write useful debug info

	mov eax, lookup_member_string_2 ; Using "\n"
	call File_Print             ; print it
	jmp Exit_Failure            ; Abort Hard

lookup_member_string_0: db "ERROR in lookup_member ", 0
lookup_member_string_1: db " does not exist", 10, 0
lookup_member_string_2: db 10, 0


;; build_member function
;; Receives struct type* last in EAX, int offset in EBX and global member_size in EDI
;; Updates member_size in EDI and returns struct type* I in EAX
;; Uses ECX for struct type* member_type and EDX for struct type* I
build_member:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	mov edx, eax                ; Put last out of the way
	mov eax, 28                 ; Allocate type
	call malloc                 ; Get I
	mov [eax+16], edx           ; I->MEMBERS = LAST
	mov [eax+8], ebx            ; I->OFFSET = OFFSET
	mov edx, eax                ; Put I in place

	call type_name              ; Get member_type
	mov ecx, eax                ; Put in place
	mov [edx+20], ecx           ; I->TYPE = MEMBER_TYPE
	mov eax, [global_token]     ; Using global_token
	mov ebx, [eax+8]            ; global_token->S
	mov [edx+24], ebx           ; I->NAME = global_token->S
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	;; Check if we have an array
	mov ebx, [eax+8]            ; global_token->S
	mov eax, open_bracket       ; Using "["
	call match                  ; IF global_token->S == "["
	cmp eax, 0                  ; Then we have to deal with arrays in our structs
	je build_member_array       ; So deal with that pain

	;; Deal with non-array case
	mov eax, [ecx+4]            ; member_type->SIZE
	mov [edx+4], eax            ; I->SIZE = member_type->SIZE
	jmp build_member_done       ; Be done

build_member_array:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, [eax+8]            ; global_token->S
	call numerate_string        ; convert number
	mov ebx, [ecx+20]           ; member_type->TYPE
	mov ebx, [ebx+4]            ; member_type->TYPE->SIZE
	imul eax, ebx               ; member_type->type->size * numerate_string(global_token->s)
	mov [edx+4], eax            ; I->SIZE = member_type->type->size * numerate_string(global_token->s)

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, build_member_string_0 ; Using "Struct only supports [num] form\n"
	mov ebx, close_bracket      ; Using "]"
	call require_match          ; Make sure we have it

build_member_done:
	mov edi, [edx+4]            ; MEMBER_SIZE = I->SIZE
	mov [edx+20], ecx           ; I->TYPE = MEMBER_TYPE
	mov eax, edx                ; Return I

	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

build_member_string_0: db "Struct only supports [num] form", 10, 0


;; build_union function
;; Receives struct type* last in EAX, int offset in EBX and global member_size in EDI
;; Updates member_size in EDI and returns struct type* LAST in EAX
;; Uses ECX for struct type* last, EDX for int offset, ESI for int size and EDI for int member_size
build_union:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	push esi                    ; Protect ESI
	mov ecx, eax                ; Put LAST in right spot
	mov edx, ebx                ; Put OFFSET in right spot
	mov esi, 0                  ; SIZE = 0

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, build_union_string_0 ; Using "ERROR in build_union\nMissing {\n"
	mov ebx, open_curly_brace   ; Using "{"
	call require_match          ; Make sure we have it

build_union_iter:
	mov eax, [global_token]     ; Using global_token
	mov eax, [eax+8]            ; global_token->S
	mov al, [eax]               ; global_token->S[0]
	movzx eax, al               ; make it useful
	cmp eax, 125                ; IF global_token->S[0] == "}"
	je build_union_done         ; Be done

	;; Collect union member
	mov eax, ecx                ; Passing LAST
	mov ebx, edx                ; Passing offset
	call build_member           ; build_member(last, offset)
	mov ecx, eax                ; last = build_member(last, offset)

	cmp esi, edi                ; IF member_size > size
	jg build_union_size         ; Then update size

	;; deal with member_size > size
	mov esi, edi                ; SIZE = MEMBER_SIZE

build_union_size:
	mov eax, build_union_string_1 ; Using "ERROR in build_union\nMissing ;\n"
	mov ebx, semicolon          ; Using ";"
	call require_match          ; Make sure we have it
	jmp build_union_iter        ; Keep going

build_union_done:
	mov edi, esi                ; MEMBER_SIZE = SIZE

	mov eax, [global_token]     ; Using global_token
	mov eax, [eax]              ; global_token->NEXT
	mov [global_token], eax     ; global_token = global_token->NEXT

	mov eax, ecx                ; Return last

	pop esi                     ; Restore ESI
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

build_union_string_0: db "ERROR in build_union", 10, "Missing {", 10, 0
build_union_string_1: db "ERROR in build_union", 10, "Missing ;", 10, 0


;; sym_declare function
;; Receives char *s in EAX, struct type* t in EBX, and struct token_list* list in ECX
;; Returns struct token_list* in EAX
;; Uses EAX for A
sym_declare:
	push edx                    ; Protect EDX
	mov edx, eax                ; Get char *S safely out of the way
	mov eax, 20                 ; Using sizeof(struct token_list)
	call malloc                 ; Get pointer to A
	mov [eax], ecx              ; A->NEXT = LIST
	mov [eax+8], edx            ; A->S = S
	mov [eax+12], ebx           ; A->TYPE = T
	pop edx                     ; Restore EDX
	ret


;; match function
;; Receives CHAR* in EAX and CHAR* in EBX
;; Returns 0 (TRUE) or 1 (FALSE) in EAX
match:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	mov ecx, eax                ; S1 in place
	mov edx, ebx                ; S2 in place
match_Loop:
	mov al, [ecx]               ; S1[0]
	movzx eax, al               ; Make it useful
	mov bl, [edx]               ; S2[0]
	movzx ebx, bl               ; Make it useful
	cmp eax, ebx                ; See if they match
	jne match_False             ; If not

	add ecx, 1                  ; S1 = S1 + 1
	add edx, 1                  ; S2 = S2 + 1
	cmp eax, 0                  ; If reached end of string
	je match_Done               ; Perfect match
	jmp match_Loop              ; Otherwise keep looping

match_False:
	mov eax, 1                  ; Return false
match_Done:
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; numerate_number function
;; Receives an INT A in EAX
;; Returns char* result in EAX
;; Allocates 16 bytes of memory
;; Behaves badly when given a negative number too large
;; Uses EAX for temp, EBX for DIVISOR, EDX for mod/0, ESI for result[i] and EBP for A
numerate_number:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	push esi                    ; Protect ESI
	push ebp                    ; Protect EBP
	mov ebp, eax                ; Protect A

	mov eax, 16                 ; 16bytes
	call malloc                 ; Get our pointer
	push eax                    ; Protect our pointer
	mov esi, eax                ; put pointer in right place
	mov ebx, 0x3B9ACA00         ; Set divisor to largest positive number that fits in 32bits

	cmp ebp, 0                  ; Deal with 0 case
	je numerate_number_ZERO     ; If it is
	jg numerate_number_positive ; If it is positive

	;; Deal with negative case
	mov eax, 45                 ; Using "-"
	mov [esi], al               ; Write it
	add esi, 1                  ; increment
	imul ebp, -1                ; A = A * -1

numerate_number_positive:
	mov edx, 0                  ; Set top to 0
	mov eax, ebp                ; Using A as bottom
	idiv ebx                    ; edx:eax % ebx -> edx + edx:eax / ebx -> eax [Even if we don't want it]
	cmp eax, 0                  ; IF 0 == (a / divisor)
	jne numerate_number_iter    ; Clean up those leading Zeros

	mov edx, 0                  ; Set top to 0
	mov eax, ebx                ; Using Divisor for bottom
	mov ebx, 10                 ; Make this shit work because idiv 10 doesn't work
	idiv ebx                    ; edx:eax % 10 -> edx + edx:eax / 10 -> eax [Even if we don't want it]
	mov ebx, eax                ; Update divisor
	jmp numerate_number_positive ; Keep collecting

numerate_number_iter:
	cmp ebx, 0                  ; IF DIVISOR < 0
	jle numerate_number_done    ; Be done

	mov edx, 0                  ; Set top to 0
	mov eax, ebp                ; Using A as bottom
	idiv ebx                    ; edx:eax % ebx -> edx + edx:eax / ebx -> eax [Even if we don't want it]
	add eax, 48                 ; ((a / divisor) + 48)
	mov [esi], al               ; Write it
	mov ebp, edx                ; a = a % divisor

	mov edx, 0                  ; Set top to 0
	mov eax, ebx                ; Using Divisor for bottom
	mov ebx, 10                 ; Make this shit work because idiv 10 doesn't work
	idiv ebx                    ; edx:eax % 10 -> edx + edx:eax / 10 -> eax [Even if we don't want it]
	mov ebx, eax                ; Update divisor

	add esi, 1                  ; increment
	jmp numerate_number_iter    ; Keep going

numerate_number_done:
	pop eax                     ; Restore our result
	pop ebp                     ; Restore EBP
	pop esi                     ; Restore ESI
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret

numerate_number_ZERO:
	mov eax, 48                 ; Using '0'
	mov [esi], al               ; Write it
	add esi, 1                  ; increment
	jmp numerate_number_done    ; Be done


;; numerate_string function
;; Receives CHAR* in EAX
;; Returns value of CHAR* in EAX
;; Uses EAX for VALUE, EBX for S, ECX for CH and ESI for NEGATIVE?
numerate_string:
	push ebx                    ; Protect EBX
	push ecx                    ; Protect ECX
	push edx                    ; Protect EDX
	push esi                    ; Protect ESI
	mov ebx, eax                ; put S in correct place
	mov eax, 0                  ; Initialize to Zero
numerate_string_loop:
	mov cl, [ebx+1]             ; S[1]
	movzx ecx, cl               ; make it useful
	cmp ecx, 120                ; IF 'x' == S[1]
	je numerate_hex             ; Deal with hex input

	;; Assume decimal input
	mov esi, 0                  ; Assume no negation
	mov cl, [ebx]               ; S[0]
	movzx ecx, cl               ; make it useful
	cmp ecx, 45                 ; IF '-' == S[0]
	jne numerate_decimal        ; Skip negation

	mov esi, 1                  ; Set FLAG
	add ebx, 1                  ; S = S + 1

numerate_decimal:
	mov cl, [ebx]               ; S[0]
	movzx ecx, cl               ; make it useful
	cmp ecx, 0                  ; IF NULL == S[0]
	je numerate_decimal_done    ; We are done

	imul eax, 10                ; VALUE = VALUE * 10
	sub ecx, 48                 ; CH = CH - '0'
	cmp ecx, 9                  ; Check for illegal
	jg numerate_string_fail     ; If CH > '9'
	cmp ecx, 0                  ; Check for illegal
	jl numerate_string_fail     ; IF CH < 0
	add eax, ecx                ; VALUE = VALUE + CH
	add ebx, 1                  ; S = S + 1
	jmp numerate_decimal        ; Keep looping

numerate_decimal_done:
	cmp esi, 1                  ; Check if need to negate
	jne numerate_string_done    ; Nope

	imul eax, -1                ; VALUE = VALUE * -1
	jmp numerate_string_done    ; Done

numerate_hex:
	add ebx, 2                  ; S = S + 2
numerate_hex_loop:
	mov cl, [ebx]               ; S[0]
	movzx ecx, cl               ; make it useful
	cmp ecx, 0                  ; IF NULL == S[0]
	je numerate_string_done     ; We are done

	shl eax, 4                  ; VALUE = VALUE << 4
	sub ecx, 48                 ; CH = CH - '0'
	cmp ecx, 10                 ; IF 10 >= CH
	jl numerate_hex_digit       ; NO
	sub ecx, 7                  ; Push A-F into range
numerate_hex_digit:
	cmp ecx, 15                 ; Check for illegal
	jg numerate_string_fail     ; If CH > 'F'
	cmp ecx, 0                  ; Check for illegal
	jl numerate_string_fail     ; IF CH < 0
	add eax, ecx                ; VALUE = VALUE + CH
	add ebx, 1                  ; S = S + 1
	jmp numerate_hex_loop       ; Keep looping

numerate_string_fail:
	mov eax, 0                  ; return ZERO

numerate_string_done:
	pop esi                     ; Restore ESI
	pop edx                     ; Restore EDX
	pop ecx                     ; Restore ECX
	pop ebx                     ; Restore EBX
	ret


;; Exit_Failure function
;; Receives nothing
;; And aborts hard
;; Does NOT return
Exit_Failure:
	mov ebx, 1                  ; All is wrong
	mov eax, 1                  ; put the exit syscall number in eax
	int 0x80                    ; Call it a bad day


;; Keywords
union: db "union", 0
struct: db "struct", 0
constant: db "CONSTANT", 0
main_string: db "main", 0
argc_string: db "argc", 0
argv_string: db "argv", 0
if_string: db "if", 0
else_string: db "else", 0
do_string: db "do", 0
while_string: db "while", 0
for_string: db "for", 0
asm_string: db "asm", 0
goto_string: db "goto", 0
return_string: db "return", 0
break_string: db "break", 0
continue_string: db "continue", 0
sizeof_string: db "sizeof", 0
plus_string: db "+", 0
minus_string: db "-", 0
multiply_string: db "*", 0
divide_string: db "/", 0
modulus_string: db "%", 0
left_shift_string: db "<<", 0
right_shift_string: db ">>", 0
less_than_string: db "<", 0
less_than_equal_string: db "<=", 0
greater_than_equal_string: db ">=", 0
greater_than_string: db ">", 0
equal_to_string: db "==", 0
not_equal_string: db "!=", 0
bitwise_and: db "&", 0
logical_and: db "&&", 0
bitwise_or: db "|", 0
logical_or: db "||", 0
bitwise_xor: db "^", 0
arrow_string: db "->", 0


;; Frequently Used strings
;; Generally used by require_match
open_curly_brace: db "{", 0
close_curly_brace: db "}", 0
open_paren: db "(", 0
close_paren: db ")", 0
open_bracket: db "[", 0
close_bracket: db "]", 0
comma: db ",", 0
semicolon: db ";", 0
equal: db "=", 0
percent: db "%", 0
newline: db "\n", 0
underline: db "_", 0


prim_types:
type_void:
	dd type_int                 ; NEXT
	dd 4                        ; SIZE
	dd 0                        ; OFFSET
	dd type_void                ; INDIRECT
	dd 0                        ; MEMBERS
	dd type_void                ; TYPE
	dd type_void_name           ; NAME
type_void_name: db "void", 0

type_int:
	dd type_char                ; NEXT
	dd 4                        ; SIZE
	dd 0                        ; OFFSET
	dd type_int                 ; INDIRECT
	dd 0                        ; MEMBERS
	dd type_int                 ; TYPE
	dd type_int_name            ; NAME
type_int_name: db "int", 0

type_char:
	dd type_file                ; NEXT
	dd 1                        ; SIZE
	dd 0                        ; OFFSET
	dd type_char_indirect       ; INDIRECT
	dd 0                        ; MEMBERS
	dd type_char                ; TYPE
	dd type_char_name           ; NAME
type_char_name: db "char", 0

type_char_indirect:
	dd type_file                ; NEXT
	dd 4                        ; SIZE
	dd 0                        ; OFFSET
	dd type_char_double_indirect ; INDIRECT
	dd 0                        ; MEMBERS
	dd type_char_indirect       ; TYPE
	dd type_char_indirect_name  ; NAME
type_char_indirect_name: db "char*", 0

type_char_double_indirect:
	dd type_file                ; NEXT
	dd 4                        ; SIZE
	dd 0                        ; OFFSET
	dd type_char_double_indirect ; INDIRECT
	dd 0                        ; MEMBERS
	dd type_char_indirect       ; TYPE
	dd type_char_double_indirect_name ; NAME
type_char_double_indirect_name: db "char**", 0

type_file:
	dd type_function            ; NEXT
	dd 4                        ; SIZE
	dd 0                        ; OFFSET
	dd type_file                ; INDIRECT
	dd 0                        ; MEMBERS
	dd type_file                ; TYPE
	dd type_file_name           ; NAME
type_file_name: db "FILE", 0

type_function:
	dd type_unsigned            ; NEXT
	dd 4                        ; SIZE
	dd 0                        ; OFFSET
	dd type_function            ; INDIRECT
	dd 0                        ; MEMBERS
	dd type_function            ; TYPE
	dd type_function_name       ; NAME
type_function_name: db "FUNCTION", 0

type_unsigned:
	dd type_long                ; NEXT
	dd 4                        ; SIZE
	dd 0                        ; OFFSET
	dd type_unsigned            ; INDIRECT
	dd 0                        ; MEMBERS
	dd type_unsigned            ; TYPE
	dd type_unsigned_name       ; NAME
type_unsigned_name: db "unsigned", 0

type_long:
	dd 0                        ; NEXT
	dd 4                        ; SIZE
	dd 0                        ; OFFSET
	dd type_long                ; INDIRECT
	dd 0                        ; MEMBERS
	dd type_long                ; TYPE
	dd type_long_name           ; NAME
type_long_name: db "long", 0


;; debug_list function
;; Receives struct token_list* in EAX
;; Prints contents of list and exits
;; Does NOT return
debug_list:
	mov ebp, eax                ; Protect the list pointer
	mov eax, 2                  ; Using Standard error
	mov [Output_file], eax      ; write to standard error

debug_list_iter:
	;; Header
	mov eax, debug_list_string0 ; Using our first string
	call File_Print             ; Print it
	mov eax, ebp                ; Use address of pointer
	call numerate_number        ; Convert it into string
	call File_Print             ; Print it

	;; NEXT
	mov eax, debug_list_string1 ; Using our second string
	call File_Print             ; Print it
	mov eax, [ebp]              ; Use address of pointer
	call numerate_number        ; Convert it into string
	call File_Print             ; Print it

	;; PREV
	mov eax, debug_list_string2 ; Using our third string
	call File_Print             ; Print it
	mov eax, [ebp+4]            ; Use address of pointer
	call numerate_number        ; Convert it into string
	call File_Print             ; Print it

	;; S
	mov eax, debug_list_string3 ; Using our fourth string
	call File_Print             ; Print it
	mov eax, [ebp+8]               ; Use address of pointer
	call numerate_number        ; Convert it into string
	call File_Print             ; Print it

	;; S Contents
	mov eax, debug_list_string4 ; Using our fifth string
	call File_Print             ; Print it
	mov eax, [ebp+8]            ; Use address of string
	cmp eax, 0                  ; IF NULL Pointer
	jne debug_list_null         ; otherwise display
	mov eax, debug_list_string_null ; Give meaningful message instead
debug_list_null:
	call File_Print             ; Print it

	;; TYPE
	mov eax, debug_list_string5 ; Using our sixth string
	call File_Print             ; Print it
	mov eax, [ebp+12]           ; Use address of pointer
	call numerate_number        ; Convert it into string
	call File_Print             ; Print it

	;; ARGS/DEPTH
	mov eax, debug_list_string6 ; Using our seventh string
	call File_Print             ; Print it
	mov eax, [ebp+16]           ; Use address of pointer
	call numerate_number        ; Convert it into string
	call File_Print             ; Print it

	mov eax, 10                 ; Add "\n"
	call fputc                  ; print it
	call fputc                  ; print it

	mov ebp, [ebp]              ; TOKEN = TOKEN->NEXT
	cmp ebp, 0                  ; Check if NULL
	jne debug_list_iter         ; iterate otherwise

	mov ebx, 666                ; All is HELL
	mov eax, 1                  ; put the exit syscall number in eax
	int 0x80                    ; Call it a bad day

debug_list_string0: db "Token_list node at address: ", 0
debug_list_string1: db 10, "NEXT address: ", 0
debug_list_string2: db 10, "PREV address: ", 0
debug_list_string3: db 10, "S address: ", 0
debug_list_string4: db 10, "The contents of S are: ", 0
debug_list_string5: db 10, "TYPE address: ", 0
debug_list_string6: db 10, "ARGUMENTS address: ", 0
debug_list_string_null: db ">::<NULL>::<", 0


section .data
Address_of: dd 0
C: dd 0
Input_file: dd 0
MALLOC: dd 0
Output_file: dd 0
Token: dd 0
break_frame: dd 0
break_target_func: dd 0
break_target_head: dd 0
break_target_num: dd 0
current_count: dd 0
current_target: dd 0
function: dd 0
global_constant_list: dd 0
global_function_list: dd 0
global_symbol_list: dd 0
global_token: dd 0
global_types: dd prim_types
globals_list: dd 0
output_list: dd 0
string_index: dd 0
strings_list: dd 0
