prev.p0

:fun(main){
	d = 1 # debug
	:if(d){
		:raw("/*\n")
	}
	a = 20000 # stack pointer
	:call(readFile)
	b = m
	:call(tokenize)
	# c = condition, d = debug, so next var is e
	e = m
	:call(syntax)
	# f = flag
	g = m
	:if(d){
		:call(debug_printExpressions)
		:call(debug_printTypes)
	}
	:call(semantics)
	h = m
	:call(memory)
	j = m
	:if(d){
		:raw("\nPhase 5 - Code generation\n*/\n")
	}
	:call(codegen)
}
#
# Utility functions
#
# breakpoint
:fun(break){
}
:fun(push){
	:store(s,a)
	a = a 1 -
}
:fun(pop){
	a = a 1 +
	:load(s,a)
}
:fun(putint){
	s = y
	:call(push) # save y
	s = w
	:call(push) # save w
	s = x
	:call(push) # save x
	:if(x 0 <){
		:raw("-")
		w = x 0 1 - *
	} else {
		w = x
	}
	y = 10
	:while(w y / 0 >){
		y = y 10 *
	}
	y = y 10 /
	:while(y){
		x = w y / 10 % 48 +
		:putchar(x)
		y = y 10 /
	}
	:call(pop) # restore x
	x = s
	:call(pop) # restore w
	w = s
	:call(pop) # restore y
	y = s
}
:fun(errint){
	s = y
	:call(push) # save y
	s = w
	:call(push) # save w
	s = x
	:call(push) # save x
	y = x 0 <
	:if(y){
		:raw("-")
		w = x 0 1 - *
	} else {
		w = x
	}
	y = 10
	:while(w y / 0 >){
		y = y 10 *
	}
	y = y 10 /
	:while(y){
		x = w y / 10 % 48 +
		:uchar(x)
		y = y 10 /
	}
	:call(pop) # restore x
	x = s
	:call(pop) # restore w
	w = s
	:call(pop) # restore y
	y = s
}
# input: x
# writes: y
:fun(convertEscapableChar){
	:if(x 110 ==){ # n
		y = 10 # newline
	} elif(x 116 ==){ # t
		y = 9 # tab
	} elif(x 39 == x 34 == | x 92 == |){ # ' " \
		y = x
	} else {
		:throw("Invalid escape sequence. Line ")
		x = l
		:call(errint)
		:throw("\n")
		:exit(1)
	}
}
:fun(isValidChar){
	y = x 32 => x 126 =< & # x >= ' ' & x <= '~'
}
:fun(debug_printType){
	:load(u,x)
	:if(u 1 =!){
		x = u
		:call(putint)
		x = 0 30 -
		:call(errorPrintLine)
	}
	:load(u,x 1 +)
	:if(u 0 ==){ # int
		:raw("int")
	} elif(u 1 ==){ # char
		:raw("char")
	} elif(u 2 ==){ # bool
		:raw("bool")
	} elif(u 3 ==){ # void
		:raw("void")
	} elif(u 4 ==){ # array
		:raw("arr(")
		:load(u,x 3 +) # load token addr
		:load(u,u 2 +) # load const value
		v = x
		x = u
		:call(putint)
		:raw(", ")
		x = v
		:load(x,x 2 +) # basetype
		:call(debug_printType)
		:raw(")")
	} elif(u 5 ==){ # pointer
		:raw("ptr(")
		:load(x,x 2 +) # basetype
		:call(debug_printType)
		:raw(")")
	} elif(u 6 ==){ # nametype
		:load(u,x 2 +) # basetype
		:load(v,u 2 +) # length
		:load(u,u 1 +) # start
		v = u v +
		:while(u v <){
			:load(x,u)
			:putchar(x)
			u = u 1 +
		}
	}
}
:fun(debug_printTypes){
	:raw("\nTypes:\n")
	i = e
	:while(i g <){
		:load(x,i)
		y = 0
		:if(x 0 ==){ # declaration
			:raw("DECL [ ")
			:load(x,i 1 +)
			y = 1
		} elif(x 3 ==){ # function
			:load(v,i 3 +)
			:if(v 1 =!){ # end
				:raw("FUN [ ")
				:load(x,i 1 +)
				y = 1
			}
		} elif(x 4 ==){ # parameter
			:raw("PAR [ ")
			:load(x,i 1 +)
			y = 1
		} elif(x 2 ==){ # expression
			:load(z,i 1 +)
			:if(z 30 ==){ # cast expression
				:raw("CAST [ ")
				:load(x,i 3 +)
				y = 1
			}
		}
		:if(y){
			:call(debug_printType)
			:raw(" ] ")
		}
		i = i 5 +
	}
}
:fun(debug_printExpressions){
	:raw("\nExpressions:\n")
	i = e
	:while(i g <){
		:load(x,i)
		:if(x 0 ==){ # declaration
			:load(x,i 2 +)
			:if(x 0 1 - =!){
				:raw("INIT[ ")
				:call(debug_printExpression)
				:raw(" ] ")
			}
		} elif(x 5 ==){ # return
			:load(x,i 1 +)
			:raw("RET[ ")
			:if(x 0 1 - =!){
				:call(debug_printExpression)
			}
			:raw(" ] ")
		} elif(x 6 ==){ # expression stmt
			:load(x,i 1 +)
			:raw("EXP[ ")
			:call(debug_printExpression)
			:raw(" ] ")
		} elif(x 7 ==){ # assign
			:load(x,i 2 +)
			:raw("ASS[ ")
			:call(debug_printExpression)
			:raw(" ]=[ ")
			:load(x,i 3 +)
			:call(debug_printExpression)
			:raw(" ] ")
		} elif(x 8 ==){
			:load(x,i 1 +)
			:if(x 0 ==){ # if
				:load(x,i 2 +)
				:raw("IF[ ")
				:call(debug_printExpression)
				:raw(" ] ")
			}
		} elif(x 9 ==){
			:load(x,i 1 +)
			:if(x 0 ==){ # start
				:load(x,i 2 +)
				:raw("WHILE[ ")
				:call(debug_printExpression)
				:raw(" ] ")
			}
		}
		i = i 5 +
	}
}
:fun(debug_printExpressionExtra){
	:if(u 10 ==){ # call expression
		u = 1
		:while(u){
			x = x 5 -
			:load(y,x)
			:if(y 10 ==){
				:load(y,x 1 +)
				:if(y){ # y : 0start, 1end
					u = u 1 +
				} else {
					u = u 1 -
				}
			}
		}
		:raw("CALL(")
		:load(u,x 2 +) # ident
		:load(y,u) # check if its an ident
		:if(y 2 =!){
			x = 0 44 -
			:call(errorPrintLine)
		}
		v = x
		x = u
		:call(printIdent)
		x = v
		:raw(")[ ")
		u = 1
		v = 0
		:while(u){
			x = x 5 +
			:load(z,x)
			:if(z 10 ==){
				:load(y,x 1 +)
				:if(y){ # y : 0start, 1end
					:if(v){
						v = v 1 -
					} else {
						u = 0
					}
				} else {
					v = v 1 +
				}
			} elif(z 11 == v 0 == &){ # argument of current call
				s = x
				:call(push)
				:load(x,x 1 +)
				:call(debug_printExpression)
				:call(pop)
				x = s
				:raw(", ")
			}
		}
		:raw(" ]")
	}
}
:fun(debug_printExpression){
	:load(u,x)
	:if(u 2 =!){ # check if its an expression
		:call(debug_printExpressionExtra)
	} else {
		:load(u,x 1 +)
		:if(u 0 ==){ # postfix ++
			:raw("(")
			:load(x,x 2 +) # expr1
			:call(debug_printExpression)
			:raw("++")
			:raw(")")
		} elif(u 1 ==){ # postfix --
			:raw("(")
			:load(x,x 2 +) # expr1
			:call(debug_printExpression)
			:raw("--")
			:raw(")")
		} elif(u 2 => u 6 =< & u 27 => u 30 =< & |){ # prefix
			:raw("(")
			:load(x,x 2 +) # expr1
			:if(u 2 ==){
				:raw("++")
			} elif(u 3 ==){
				:raw("--")
			} elif(u 4 ==){
				:raw("+")
			} elif(u 5 ==){
				:raw("-")
			} elif(u 27 ==){
				:raw("~")
			} elif(u 28 ==){
				:raw("&")
			} elif(u 29 ==){
				:raw("*")
			} elif(u 30 ==){
				:raw("cast")
			} else {
				:raw("!")
			}
			:call(debug_printExpression)
			:raw(")")
		} else {
			:if(u 7 => u 21 =< & u 26 == |){ # binop
				:raw("(")
				x = x 2 + # expr1
				s = x 1 + # expr2
				:call(push) # push expr2
				s = u # op
				:call(push) # push op
				:load(x,x)
				:call(debug_printExpression)
				:call(pop) # pop op
				:if(s 7 ==){
					:raw("*")
				} elif(s 8 ==){
					:raw("/")
				} elif(s 9 ==){
					:raw("%")
				} elif(s 10 ==){
					:raw("+")
				} elif(s 11 ==){
					:raw("-")
				} elif(s 12 ==){
					:raw("<")
				} elif(s 13 ==){
					:raw(">")
				} elif(s 14 ==){
					:raw("<=")
				} elif(s 15 ==){
					:raw(">=")
				} elif(s 16 ==){
					:raw("==")
				} elif(s 17 ==){
					:raw("!=")
				} elif(s 18 ==){
					:raw("&")
				} elif(s 19 ==){
					:raw("|")
				} elif(s 20 ==){
					:raw("&&")
				} elif(s 26 ==){
					:raw("^")
				} else {
					:raw("||")
				}
				:call(pop) # pop expr2
				:load(x,s)
				:call(debug_printExpression)
				:raw(")")
			} elif(u 22 ==){ # ident
				:load(x,x 2 +) # expr1 (identifier token)
				:load(u,x)
				:if(u 2 =!){ # Sanity check
					x = 0 42 -
					:call(errorPrintLine)
				}
				:call(printIdent)
			} elif(u 23 ==){ # const
				:load(x,x 2 +) # expr1 (const token)
				:load(u,x)
				:if(u 3 =!){ # Sanity check
					x = 0 43 -
					:call(errorPrintLine)
				}
				:load(u,x 1 +) # constant id
				:load(x,x 2 +)
				:if(u 3 ==) {
					:raw("\"")
					z = x 1 +
					y = 1
					:while(y){
						:load(x,z)
						z = z 1 +
						:putchar(x)
						:if(x 92 ==){ # \
							:load(x,z)
							z = z 1 +
							:putchar(x)
						} else {
							y = x 34 =! # "
						}
					}
				} else {
					:call(putint)
				}
			} elif(u 24 ==){ # array
				:raw("(")
				x = x 2 + # expr1
				s = x 1 + # expr2
				:call(push)
				:load(x,x)
				:call(debug_printExpression)
				:raw("[")
				:call(pop)
				:load(x,s)
				:call(debug_printExpression)
				:raw("])")
			} elif(u 25 ==){ # component
				:raw("(")
				x = x 2 + # expr1
				s = x 1 + # expr2
				:call(push)
				:load(x,x)
				:call(debug_printExpression)
				:raw(".")
				:call(pop)
				:load(x,s)
				:call(printIdent)
				:raw(")")
			} elif(u 31 ==){ # pointer component
				:raw("(")
				x = x 2 + # expr1
				s = x 1 + # expr2
				:call(push)
				:load(x,x)
				:call(debug_printExpression)
				:raw("->")
				:call(pop)
				:load(x,s)
				:call(printIdent)
				:raw(")")
			}
		}
	}
}
:fun(printIdent){
	s = x
	:call(push)
	s = u
	:call(push)
	s = v
	:call(push)
	:load(u,x 1 +) # start
	:load(v,x 2 +) # length
	v = u v +
	:while(u v <){
		:load(x,u)
		:putchar(x)
		u = u 1 +
	}
	:call(pop)
	v = s
	:call(pop)
	u = s
	:call(pop)
	x = s
}
:fun(errorIdent){
	s = x
	:call(push)
	s = u
	:call(push)
	s = v
	:call(push)
	:load(u,x 1 +) # start
	:load(v,x 2 +) # length
	v = u v +
	:while(u v <){
		:load(x,u)
		:uchar(x)
		u = u 1 +
	}
	:call(pop)
	v = s
	:call(pop)
	u = s
	:call(pop)
	x = s
}
# input: x,y
# output: y
:fun(identEquals){
	s = t
	:call(push)
	s = u
	:call(push)
	s = v
	:call(push)
	s = z
	:call(push)
	:load(u,x 2 +) # ident1 length
	:load(v,y 2 +) # ident2 length
	:load(x,x 1 +) # ident1 start
	:load(y,y 1 +) # ident2 start
	t = 0 1 - # counter
	z = u # length
	:while(u v == t z < &){
		t = t 1 +
		:load(u,x t +)
		:load(v,y t +)
	}
	y = t z ==
	:call(pop)
	z = s
	:call(pop)
	v = s
	:call(pop)
	u = s
	:call(pop)
	t = s
}
#
# Errors
#
:fun(errorInternal){
	:throw("Internal error\n")
	:exit(1)
}
:fun(errorExpectedX){
	:throw("Expected ")
	:putchar(x)
	:throw(", found token type ")
	:load(x,i)
	:call(errint)
	:throw(". ")
	:load(x,i 3 +)
	:call(errorPrintLine)
}
:fun(errorUnmatchedToken){
	:throw("Unmatched token (type ")
	:load(x,i)
	:call(errint)
	:throw("). ")
	:load(x,i 3 +)
	:call(errorPrintLine)
}
:fun(errorEOFcomment){
	:throw("EOF reached while parsing comment.")
	:exit(1)
}
:fun(errorInvalidCharConstant){
	:throw("Invalid char constant. ")
	x = l
	:call(errorPrintLine)
}
:fun(errorLeadingZero){
	:throw("Invalid int constant (leading zeros). ")
	x = l
	:call(errorPrintLine)
}
:fun(errorConstantTooBig){
	:throw("Invalid int constant (too big). ")
	x = l
	:call(errorPrintLine)
}
:fun(errorInvalidCharInString){
	:throw("Invalid char encountered in string literal. ")
	x = l
	:call(errorPrintLine)
}
:fun(errorUnmatchedChar){
	:throw("Unmatched char '")
	:load(x,i)
	:uchar(x)
	:throw("'. ")
	x = l
	:call(errorPrintLine)
}
:fun(errorPrintLine){
	:throw("Line ")
	:call(errint)
	:throw("\n")
	:exit(1)
}