interpreter.icn

#
global vars, expressionQueue
#TODO: Add a record for type checking
procedure main(args)
	vars := table("NOOB")
	filename := args[1]
	if / filename
		then write("Usage: interpreter file-name") & return
	file := open(filename)
	text := ""
	while text := text || read(file) || "\n"
	executeBlock(text)
end

#Executes a block of code
procedure executeBlock(block)
	block ?
	{
		every loc := upto('\n') do
		{
			if loc < &pos
				then next
			line := fullTrim(tab(loc), ' \t\n')
			if match("O RLY", line)
				then
				{
					searchSpace := line || block[&pos:*block]
					startBlockLocation := &pos - *line
					ifCounter := 0
					every wordLoc := upto(' \t\n') do
					{
						word := fullTrim(tab(wordLoc), ' \t\n')
						if word == "O"
							then ifCounter := ifCounter + 1
						if word == "OIC"
							then
							{
							if ifCounter = 0
								then 
								{
									ifStmt(block[startBlockLocation:&pos]||"\n")
									moveUpto := &pos
									break
								}
							if ifCounter > 0
								then ifCounter := ifCounter - 1
						}
					}
					&pos := moveUpto
				}
				else 
				{
					parseLine(line)
				}
		}
	}
end

#Parses and executes an individual line
procedure parseLine(line)
	line ?
	{
		if ="I HAS A"
			then addVar(line) & return	
	    if ="O RLY"
			then ifStmt(line) & return
		if ="VISIBLE"
			then visibleStmt(line) & return
	
	
	}
end

procedure visibleStmt(line)
	line ?
	{
		move(match("VISIBLE"))
			
		expression := fullTrim(tab(0), ' \t\n')
		if match('\"', expression)
			then writes(fullTrim(expression, '\"'))
			else writes(parseExpression(expression || "\n"))
	}
end

procedure ifStmt(line)
	line ?
	{
		move(match("O RLY"))
	
		boolExpr := tab(upto('?'))
		move(1) #Get rid of '?'
		result := parseExpression(boolExpr || "\n")
		tab(find("YA RLY"))
		move(*"YA RLY")
		
		startBlockLocation := &pos
		winBlock := ""
		ifCounter := 0
		every wordLoc := upto(' \t\n') do
		{
			word := fullTrim(tab(wordLoc), ' \t\n')
			if word == "O"
				then ifCounter := ifCounter + 1
			if word == "NO" & ifCounter = 0
				then 
				{	
					winBlock := line[startBlockLocation:(&pos-2)]
					move(4) #move past " WAI"
					elseBlockLoc := &pos
				}
			if word == "OIC"
				then
				{
					if ifCounter = 0
						then 
						{
							if \elseBlockLoc
								then
								{
									elseBlock := line[elseBlockLoc:&pos-3]
								}
								else
								{
									winBlock := line[startBlockLocation:&pos-3]
								}
							break
						}
					if ifCounter > 0
						then ifCounter := ifCounter - 1
				}
		}

		if ifCounter ~= 0
			then 
			{
				write("ERROR O RLY? MISSING MATCHING OIC:\n" || line)
				return
			}
		
		if result = 1
			then
			{
				executeBlock(winBlock)
			}
			else
			{
				if \elseBlock
					then 
					{
						executeBlock(elseBlock)
					}
			}
	}
end

procedure parseExpression(expr)
	whitespace := ' \t\n'
	expressionQueue := []
	expr ?
	{
		every loc := upto(whitespace) do
		{
			term := fullTrim(tab(loc), whitespace)
			if term ~== "OF" & term ~== "AN" 
				then 
				{
					put(expressionQueue, term)
				}
		}
	}
	return execExpression()
end

procedure execExpression()
	if *expressionQueue = 0
		then write("empty") & return

	node := pop(expressionQueue)
	if node[1] ? any(&digits)
		then return node
	
	if node == "SUM"
		then return execExpression() + execExpression()
	if node == "DIF"
		then return execExpression() - execExpression()
	if node == "PRODUKT"
		then return execExpression() * execExpression()
	if node == "QUOSHUNT"
		then return execExpression() / execExpression()
	if node == "MOD"
		then return execExpression() % execExpression()
	if node == "BIGGR"
		then
		{
			first := execExpression()
			second := execExpression()
			if first > second
				then return first
				else return second
		}
	if node == "SMALLR"
		then
		{
			first := execExpression()
			second := execExpression()
			if first > second
				then return second
				else return first
		}
	if node == "SAEM"
		then
		{
			if execExpression() = execExpression()
				then return 1
				else return 0
		}
	if node == "DIFFRINT"
		then
		{
			if execExpression() = execExpression()
				then return 0
				else return 1
		}
	# Check if variable is defined / exists
	value := vars[node]
	if value ~== "NOOB"
		then return value
		else write("Error: " || node || " is undefined")
end

procedure addVar(line)
	whitespace := ' \t\n' 
	line ?
	{
		move(match("I HAS A"))
		varName := tab(upto(whitespace)) | tab(0)
		vars[varName] := "NOOB" #TODO: implement types
		if findLoc := find("ITZ")
			then 
			{
				move(5)
				vars[varName] := line[&pos:*line+1] 
			}
	}
end

procedure fullTrim(str, chars)
	return reverse(trim(reverse(trim(str, chars)), chars))
end