Blueprint Registers
{
	Names
	Can Data
	Can Pointer
	Available?
	Need Save
	Max Size
}

Set Yes[in:out]
{
	out <- Yes
}

_Flip[dest,val,index:out]
{
	out <- [dest]Set[val,index]
}
Flip[list,dest:out]
{
	out <- Fold["_Flip", dest, list]
}

Registers[names, data, pointer, need save, max size:out]
{
	out <- [[[[[[Build["Registers"]
	]Names << [names]
	]Can Data << [data]
	]Can Pointer << [pointer]
	]Available? << [ Map[names, "Set Yes"] ]
	]Need Save << [ Flip[need save, ()] ]
	]Max Size <<[max size]
}

Name@Registers[regs,num:out]
{
	out <- [[regs]Names >>]Index[num]
}

Allocate Helper@Registers[regs, try, current:found, not found]
{
	reg <- [try]Index[current]
	If[[[regs]Available? >>]Index[reg]]
	{
		found <- Val[reg]
	}{
		[try]Next[current]
		{
			found, not found <- [regs]Allocate Helper[try, ~]
		}{
			not found <- Yes
		}
	}
}

Allocate Reg@Registers[regs,try:next regs,found,need save?,not found]
{
	[try]First
	{
		found, not found <- [regs]Allocate Helper[try, ~]
		{
			next regs <- [regs]Available? << [ [[regs]Available? >>]Set[~, No] ]
			[[regs]Need Save >>]Index[~]
			{
				need save? <- Yes
			}{
				need save? <- No
			}
		}
	}{
		not found <- Yes
	}
}

Free Reg@Registers[regs,num:out]
{
	out <- [regs]Available? <<[ [[regs]Available? >>]Set[num, Yes] ]
}

Processor Reg[func,type:next func,num,not found]
{
	regs <- [func]Registers >>
	If[[type] = ["pointer"]]
	{
		source <- [regs]Can Pointer >>
	}{
		source <- [regs]Can Data >>
	}
	next regs, reg num, need save?, not found <- [regs]Allocate Reg[source] {}
	{
		If[need save?]
		{
			next func <- [[func]Need Save << [ [[func]Need Save >>]Set[reg num, Yes] ]
			]Registers << [next regs]
		}{
			next func <- [func]Registers << [next regs]
		}
		num <- Val[reg num]
	}
}

Processor Free Reg[func,num:out func]
{
	out func <- [func]Registers <<[  [[func]Registers >>]Free Reg[num] ]
}

Processor Allocate[func,name,size,type:out func,out]
{
	regs <- [func]Registers >>
	If[[type] = ["pointer"]]
	{
		alloc size <- [func]Pointer Size
	}{
		alloc size <- size
	}
	If[[alloc size] > [[regs]Max Size >>]] {
			stack alloc <- Val[alloc size]
	}{
		next func <- [func]Processor Reg[type] {}
		{
			location <- Register[~, alloc size]
		}{
			stack alloc <- Val[alloc size]
		}
	}
	Val[stack alloc]
	{
		next func, location <- [func]Allocate Stack[alloc size]
	}
	out func <- [next func]Variables <<[ [[next func]Variables >>]Set[name, location] ]
	out <- Val[location]
}

Blueprint Register
{
	Number
	Value Size
}
Register[num,size:out]
{
	If[[size] = [3]]
	{
		value size <- 4
	}{
		value size <- size
	}
	out <- [[Build["Register"]]Number <<[num]]Value Size <<[value size]
}

In Memory?@Register[reg:out]
{
	out <- No
}

=@Register[reg,other:out]
{
	,out <- If[[Type Of[reg]] = [Type Of[other]]]
	{
		out <- [[reg]Number >>] = [[other]Number >>]
	}
}

Op ASM@Register[reg,func,regs,extra offset:out]
{
	out <- [regs]Index[ [reg]Number >> ]
}

Size@Register[reg:out]
{
	out <- [reg]Value Size >>
}

Blueprint Immediate
{
	Value
}

Immediate[val:out]
{
	out <- [Build["Immediate"]]Value <<[val]
}

In Memory?@Immediate[val:out]
{
	out <- No
}

=@Immediate[val,other:out]
{
	,out <- If[[Type Of[val]] = [Type Of[other]]]
	{
		out <- [[val]Value >>] = [[other]Value >>]
	}
}

Op ASM@Immediate[val,func,regs,extra offset:out]
{
	out <- [val]Value >>
}

Size@Immediate[val:out]
{
	out <- 4
}

Blueprint None
{
	Dummy
}

None[:out]
{
	out <- Build["None"]
}

In Memory?@None[none:out]
{
	out <- No
}

Op ASM@None[none,func,regs,extra offset:out]
{
	out <- ""
}

Size@None[none:out]
{
	out <- 0
}

Blueprint Stack Location
{
	Offset
	Size
}

Stack Location[offset,size:out]
{
	out <- [[Build["Stack Location"]]Offset <<[offset]]Size <<[size]
}

In Memory?@Stack Location[location:out]
{
	out <- Yes
}

=@Stack Location[loc,other:out]
{
	,out <- If[[Type Of[loc]] = [Type Of[other]]]
	{
		out <- [[loc]Offset >>] = [[other]Offset >>]
	}
}

Op ASM@Stack Location[loc,func,regs,extra offset:out]
{
	offset <- [[[func]Stack Size >>] - [[loc]Offset >>]] - [[loc]Size >>]
	If[[offset] > [0]]
	{
		toffset <- ["+"]Append[offset]
	}{
		toffset <- ""
	}
	out <- [["[esp"]Append[toffset]]Append["]"]
}

Size@Stack Location[loc:out]
{
	out <- [loc]Size >>
}

Blueprint Pointer
{
	Base
	Offset
	Target Size
}

Pointer[base,offset,size:out]
{
	out <- [[[Build["Pointer"]]Base <<[base]]Offset <<[offset]]Target Size <<[size]
}

In Memory?@Pointer[location:out]
{
	out <- Yes
}

=@Pointer[pointer,other:out]
{
	,out <- If[[Type Of[loc]] = [Type Of[other]]]
	{
		out <- [[loc]Storage >>] = [[other]Storage >>]
	}
}

Op ASM@Pointer[pointer,func,regs,extra offset:out]
{
	If[[Type Of[ [pointer]Offset >> ]] = ["None"]]
	{
		out <- [["["]Append[ [[pointer]Base >>]Op ASM[func,regs,extra offset] ]]Append["]"]
	}{
		out <- [[[["["
			]Append[ [[pointer]Base >>]Op ASM[func,regs,extra offset] ]
			]Append["+"]
			]Append[ [[pointer]Offset >>]Op ASM[func,regs,extra offset] ]
			]Append["]"]
	}
}

Size@Pointer[pointer:out]
{
	out <- [pointer]Target Size >>
}

CAppend[left,right:out]
{
	If[[right] = [""]]
	{
		out <- ""
	}{
		out <- [left]Append[right]
	}
}