IF=auto()

ELIF=auto()

ELSE=auto()

END=auto()

WHILE=auto()

DO=auto()

MACRO=auto()

PLUS=auto()

MINUS=auto()

MUL=auto()

DIVMOD=auto()

EQ=auto()

GT=auto()

LT=auto()

GE=auto()

LE=auto()

NE=auto()

SHR=auto()

SHL=auto()

OR=auto()

AND=auto()

NOT=auto()

PRINT=auto()

DUP=auto()

SWAP=auto()

DROP=auto()

OVER=auto()

ROT=auto()

MEM=auto()

LOAD=auto()

STORE=auto()

FORTH_LOAD=auto()

FORTH_STORE=auto()

LOAD64=auto()

STORE64=auto()

FORTH_LOAD64=auto()

FORTH_STORE64=auto()

CAST_PTR=auto()

ARGC=auto()

ARGV=auto()

HERE=auto()

SYSCALL0=auto()

SYSCALL1=auto()

SYSCALL2=auto()

SYSCALL3=auto()

SYSCALL4=auto()

SYSCALL5=auto()

PUSH_INT=auto()

PUSH_STR=auto()

PUSH_CSTR=auto()

INTRINSIC=auto()

IF=auto()

ELIF=auto()

ELSE=auto()

END=auto()

WHILE=auto()

WORD=auto()

INT=auto()

STR=auto()

CSTR=auto()

CHAR=auto()

typ: TokenType

text: str

loc: Loc

value: Union[int, str, Keyword]

# https://www.python.org/dev/peps/pep-0484/#forward-references

expanded_from: Optional['Token'] = None

end = ptr

while mem[end] != 0:

end += 1

AT_FDCWD=-100

O_RDONLY=0

ENOENT=2

CLOCK_MONOTONIC=1

stack: List[int] = []

mem = bytearray(SIM_NULL_POINTER_PADDING + SIM_STR_CAPACITY + SIM_ARGV_CAPACITY + MEM_CAPACITY)

str_buf_ptr = SIM_NULL_POINTER_PADDING

str_ptrs: Dict[int, int] = {}

str_size = 0

argv_buf_ptr = SIM_NULL_POINTER_PADDING + SIM_STR_CAPACITY

argc = 0

mem_buf_ptr = SIM_NULL_POINTER_PADDING + SIM_STR_CAPACITY + SIM_ARGV_CAPACITY

fds: List[BinaryIO] = [sys.stdin.buffer, sys.stdout.buffer, sys.stderr.buffer]

for arg in argv:

value = arg.encode('utf-8')

n = len(value)

arg_ptr = str_buf_ptr + str_size

mem[arg_ptr:arg_ptr+n] = value

mem[arg_ptr+n] = 0

str_size += n + 1

assert str_size <= SIM_STR_CAPACITY, "String buffer overflow"

argv_ptr = argv_buf_ptr+argc*8

mem[argv_ptr:argv_ptr+8] = arg_ptr.to_bytes(8, byteorder='little')

argc += 1

assert argc*8 <= SIM_ARGV_CAPACITY, "Argv buffer, overflow"

ip = 0

while ip < len(program):

assert len(OpType) == 10, "Exhaustive op handling in simulate_little_endian_linux"

op = program[ip]

try:

if op.typ == OpType.PUSH_INT:

assert isinstance(op.operand, int), "This could be a bug in the parsing step"

stack.append(op.operand)

ip += 1

elif op.typ == OpType.PUSH_STR:

assert isinstance(op.operand, str), "This could be a bug in the parsing step"

value = op.operand.encode('utf-8')

n = len(value)

stack.append(n)

if ip not in str_ptrs:

str_ptr = str_buf_ptr+str_size

str_ptrs[ip] = str_ptr

mem[str_ptr:str_ptr+n] = value

str_size += n

assert str_size <= SIM_STR_CAPACITY, "String buffer overflow"

stack.append(str_ptrs[ip])

ip += 1

elif op.typ == OpType.PUSH_CSTR:

assert isinstance(op.operand, str), "This could be a bug in the parsing step"

value = op.operand.encode('utf-8') + b'\0'

n = len(value)

if ip not in str_ptrs:

str_ptr = str_buf_ptr+str_size

str_ptrs[ip] = str_ptr

mem[str_ptr:str_ptr+n] = value

str_size += n

assert str_size <= SIM_STR_CAPACITY, "String buffer overflow"

stack.append(str_ptrs[ip])

ip += 1

elif op.typ == OpType.IF:

ip += 1

elif op.typ == OpType.WHILE:

ip += 1

elif op.typ == OpType.ELSE:

assert isinstance(op.operand, OpAddr), "This could be a bug in the parsing step"

ip = op.operand

elif op.typ == OpType.ELIF:

assert isinstance(op.operand, OpAddr), "This could be a bug in the parsing step"

ip = op.operand

elif op.typ == OpType.END:

assert isinstance(op.operand, OpAddr), "This could be a bug in the parsing step"

ip = op.operand

elif op.typ == OpType.DO:

a = stack.pop()

if a == 0:

assert isinstance(op.operand, OpAddr), "This could be a bug in the parsing step"

ip = op.operand

else:

ip += 1

elif op.typ == OpType.INTRINSIC:

assert len(Intrinsic) == 41, "Exhaustive handling of intrinsic in simulate_little_endian_linux()"

if op.operand == Intrinsic.PLUS:

a = stack.pop()

b = stack.pop()

stack.append(a + b)

ip += 1

elif op.operand == Intrinsic.MINUS:

a = stack.pop()

b = stack.pop()

stack.append(b - a)

ip += 1

elif op.operand == Intrinsic.MUL:

a = stack.pop()

b = stack.pop()

stack.append(b * a)

ip += 1

elif op.operand == Intrinsic.DIVMOD:

a = stack.pop()

b = stack.pop()

stack.append(b // a)

stack.append(b % a)

ip += 1

elif op.operand == Intrinsic.EQ:

a = stack.pop()

b = stack.pop()

stack.append(int(a == b))

ip += 1

elif op.operand == Intrinsic.GT:

a = stack.pop()

b = stack.pop()

stack.append(int(b > a))

ip += 1

elif op.operand == Intrinsic.LT:

a = stack.pop()

b = stack.pop()

stack.append(int(b < a))

ip += 1

elif op.operand == Intrinsic.GE:

a = stack.pop()

b = stack.pop()

stack.append(int(b >= a))

ip += 1

elif op.operand == Intrinsic.LE:

a = stack.pop()

b = stack.pop()

stack.append(int(b <= a))

ip += 1

elif op.operand == Intrinsic.NE:

a = stack.pop()

b = stack.pop()

stack.append(int(b != a))

ip += 1

elif op.operand == Intrinsic.SHR:

a = stack.pop()

b = stack.pop()

stack.append(int(b >> a))

ip += 1

elif op.operand == Intrinsic.SHL:

a = stack.pop()

b = stack.pop()

stack.append(int(b << a))

ip += 1

elif op.operand == Intrinsic.OR:

a = stack.pop()

b = stack.pop()

stack.append(int(a | b))

ip += 1

elif op.operand == Intrinsic.AND:

a = stack.pop()

b = stack.pop()

stack.append(int(a & b))

ip += 1

elif op.operand == Intrinsic.NOT:

a = stack.pop()

stack.append(int(~a))

ip += 1

elif op.operand == Intrinsic.PRINT:

a = stack.pop()

fds[1].write(b"%d\n" % a)

fds[1].flush()

ip += 1

elif op.operand == Intrinsic.DUP:

a = stack.pop()

stack.append(a)

stack.append(a)

ip += 1

elif op.operand == Intrinsic.SWAP:

a = stack.pop()

b = stack.pop()

stack.append(a)

stack.append(b)

ip += 1

elif op.operand == Intrinsic.DROP:

stack.pop()

ip += 1

elif op.operand == Intrinsic.OVER:

a = stack.pop()

b = stack.pop()

stack.append(b)

stack.append(a)

stack.append(b)

ip += 1

elif op.operand == Intrinsic.ROT:

a = stack.pop()

b = stack.pop()

c = stack.pop()

stack.append(b)

stack.append(a)

stack.append(c)

ip += 1

elif op.operand == Intrinsic.MEM:

stack.append(mem_buf_ptr)

ip += 1

elif op.operand == Intrinsic.LOAD:

addr = stack.pop()

byte = mem[addr]

stack.append(byte)

ip += 1

elif op.operand == Intrinsic.STORE:

store_value = stack.pop()

store_addr = stack.pop()

mem[store_addr] = store_value & 0xFF

ip += 1

elif op.operand == Intrinsic.FORTH_LOAD:

addr = stack.pop()

byte = mem[addr]

stack.append(byte)

ip += 1

elif op.operand == Intrinsic.FORTH_STORE:

store_addr = stack.pop()

store_value = stack.pop()

mem[store_addr] = store_value & 0xFF

ip += 1

elif op.operand == Intrinsic.LOAD64:

addr = stack.pop()

_bytes = bytearray(8)

for offset in range(0,8):

_bytes[offset] = mem[addr + offset]

stack.append(int.from_bytes(_bytes, byteorder="little"))

ip += 1

elif op.operand == Intrinsic.STORE64:

store_value = stack.pop()

store_value64 = store_value.to_bytes(length=8, byteorder="little", signed=(store_value < 0));

store_addr64 = stack.pop();

for byte in store_value64:

mem[store_addr64] = byte;

store_addr64 += 1;

ip += 1

elif op.operand == Intrinsic.FORTH_LOAD64:

addr = stack.pop()

_bytes = bytearray(8)

for offset in range(0,8):

_bytes[offset] = mem[addr + offset]

stack.append(int.from_bytes(_bytes, byteorder="little"))

ip += 1

elif op.operand == Intrinsic.FORTH_STORE64:

store_addr64 = stack.pop();

store_value = stack.pop()

store_value64 = store_value.to_bytes(length=8, byteorder="little", signed=(store_value < 0));

for byte in store_value64:

mem[store_addr64] = byte;

store_addr64 += 1;

ip += 1

elif op.operand == Intrinsic.ARGC:

stack.append(argc)

ip += 1

elif op.operand == Intrinsic.ARGV:

stack.append(argv_buf_ptr)

ip += 1

elif op.operand == Intrinsic.HERE:

value = ("%s:%d:%d" % op.token.loc).encode('utf-8')

n = len(value)

stack.append(n)

if ip not in str_ptrs:

str_ptr = str_buf_ptr+str_size

str_ptrs[ip] = str_ptr

mem[str_ptr:str_ptr+n] = value

str_size += n

assert str_size <= SIM_STR_CAPACITY, "String buffer overflow"

stack.append(str_ptrs[ip])

ip += 1

elif op.operand == Intrinsic.CAST_PTR:

# Ignore the type casting. It's only useful for type_check_program() phase

ip += 1

elif op.operand == Intrinsic.SYSCALL0:

syscall_number = stack.pop();

if syscall_number == 39: # SYS_getpid

stack.append(os.getpid());

else:

assert False, "unknown syscall number %d" % syscall_number

ip += 1

elif op.operand == Intrinsic.SYSCALL1:

syscall_number = stack.pop()

arg1 = stack.pop()

if syscall_number == 60: # SYS_exit

exit(arg1)

elif syscall_number == 3: # SYS_close

fds[arg1].close()

stack.append(0)

else:

assert False, "unknown syscall number %d" % syscall_number

ip += 1

elif op.operand == Intrinsic.SYSCALL2:

assert False, "not implemented"

elif op.operand == Intrinsic.SYSCALL3:

syscall_number = stack.pop()

arg1 = stack.pop()

arg2 = stack.pop()

arg3 = stack.pop()

if syscall_number == 0: # SYS_read

fd = arg1

buf = arg2

count = arg3

# NOTE: trying to behave like a POSIX tty in canonical mode by making the data available

# on each newline

# https://en.wikipedia.org/wiki/POSIX_terminal_interface#Canonical_mode_processing

# TODO: maybe this behavior should be customizable

data = fds[fd].readline(count)

mem[buf:buf+len(data)] = data

stack.append(len(data))

elif syscall_number == 1: # SYS_write

fd = arg1

buf = arg2

count = arg3

fds[fd].write(mem[buf:buf+count])

fds[fd].flush()

stack.append(count)

elif syscall_number == 257: # SYS_openat

dirfd = arg1

pathname_ptr = arg2

flags = arg3

if dirfd != AT_FDCWD:

assert False, "openat: unsupported dirfd"

if flags != O_RDONLY:

assert False, "openat: unsupported flags"

pathname = get_cstr_from_mem(mem, pathname_ptr).decode('utf-8')

fd = len(fds)

try:

fds.append(open(pathname, 'rb'))

stack.append(fd)

except FileNotFoundError:

stack.append(-ENOENT)

else:

assert False, "unknown syscall number %d" % syscall_number

ip += 1

elif op.operand == Intrinsic.SYSCALL4:

syscall_number = stack.pop()

arg1 = stack.pop()

arg2 = stack.pop()

arg3 = stack.pop()

arg4 = stack.pop()

if syscall_number == 230: # clock_nanosleep

clock_id = arg1

flags = arg2

request_ptr = arg3

remain_ptr = arg4

assert clock_id == CLOCK_MONOTONIC, "Only CLOCK_MONOTONIC is implemented for SYS_clock_nanosleep"

assert flags == 0, "Only relative time is supported for SYS_clock_nanosleep"

assert request_ptr != 0, "request cannot be NULL for SYS_clock_nanosleep. We should probably return -1 in that case..."

assert remain_ptr == 0, "remain is not supported for SYS_clock_nanosleep"

seconds = int.from_bytes(mem[request_ptr:request_ptr+8], byteorder='little')

nano_seconds = int.from_bytes(mem[request_ptr+8:request_ptr+8+8], byteorder='little')

sleep(float(seconds)+float(nano_seconds)*1e-09)

stack.append(0)

else:

assert False, "unknown syscall number %d" % syscall_number

ip += 1

elif op.operand == Intrinsic.SYSCALL5:

assert False, "not implemented"

elif op.operand == Intrinsic.SYSCALL6:

assert False, "not implemented"

else:

assert False, "unreachable"

else:

assert False, "unreachable"

except Exception as e:

compiler_error_with_expansion_stack(op.token, "Python Exception during simulation")

traceback.print_exception(type(e), e, e.__traceback__)

exit(1)

if debug:

print("[INFO] Memory dump")

compiler_diagnostic(token.loc, tag, message)

stack = token.expanded_from

limit = 0

while stack is not None and limit <= EXPANSION_DIAGNOSTIC_LIMIT:

compiler_note(stack.loc, "expanded from `%s`" % stack.text)

stack = stack.expanded_from

limit += 1

if limit > EXPANSION_DIAGNOSTIC_LIMIT:

print('...', file=sys.stderr)

print('... too many expansions ...', file=sys.stderr)

if op.typ == OpType.INTRINSIC:

assert isinstance(op.operand, Intrinsic)

compiler_error_with_expansion_stack(op.token, "not enough arguments for the `%s` intrinsic" % INTRINSIC_NAMES[op.operand])

# TODO: why don't we add while-do here too?

elif op.typ == OpType.IF:

compiler_error_with_expansion_stack(op.token, "not enough arguments for the if-block")

else:

stack: DataStack = []

block_stack: List[Tuple[DataStack, OpType]] = []

for ip in range(len(program)):

op = program[ip]

assert len(OpType) == 10, "Exhaustive ops handling in type_check_program()"

if op.typ == OpType.PUSH_INT:

stack.append((DataType.INT, op.token))

elif op.typ == OpType.PUSH_STR:

stack.append((DataType.INT, op.token))

stack.append((DataType.PTR, op.token))

elif op.typ == OpType.PUSH_CSTR:

stack.append((DataType.PTR, op.token))

elif op.typ == OpType.INTRINSIC:

assert len(Intrinsic) == 41, "Exhaustive intrinsic handling in type_check_program()"

assert isinstance(op.operand, Intrinsic), "This could be a bug in compilation step"

if op.operand == Intrinsic.PLUS:

assert len(DataType) == 3, "Exhaustive type handling in PLUS intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == DataType.INT and b_type == DataType.INT:

stack.append((DataType.INT, op.token))

elif a_type == DataType.INT and b_type == DataType.PTR:

stack.append((DataType.PTR, op.token))

elif a_type == DataType.PTR and b_type == DataType.INT:

stack.append((DataType.PTR, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument types for PLUS intrinsic. Expected INT or PTR")

exit(1)

elif op.operand == Intrinsic.MINUS:

assert len(DataType) == 3, "Exhaustive type handling in MINUS intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and (a_type == DataType.INT or a_type == DataType.PTR):

stack.append((DataType.INT, op.token))

elif b_type == DataType.PTR and a_type == DataType.INT:

stack.append((DataType.PTR, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument types fo MINUS intrinsic: %s" % [b_type, a_type])

exit(1)

elif op.operand == Intrinsic.MUL:

assert len(DataType) == 3, "Exhaustive type handling in MUL intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.INT, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument types fo MUL intrinsic. Expected INT.")

exit(1)

elif op.operand == Intrinsic.DIVMOD:

assert len(DataType) == 3, "Exhaustive type handling in DIVMOD intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.INT, op.token))

stack.append((DataType.INT, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument types fo DIVMOD intrinsic. Expected INT.")

exit(1)

elif op.operand == Intrinsic.EQ:

assert len(DataType) == 3, "Exhaustive type handling in EQ intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.BOOL, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument types fo EQ intrinsic. Expected INT.")

exit(1)

elif op.operand == Intrinsic.GT:

assert len(DataType) == 3, "Exhaustive type handling in GT intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.BOOL, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for GT intrinsic")

exit(1)

elif op.operand == Intrinsic.LT:

assert len(DataType) == 3, "Exhaustive type handling in LT intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.BOOL, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for LT intrinsic")

exit(1)

elif op.operand == Intrinsic.GE:

assert len(DataType) == 3, "Exhaustive type handling in GE intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.BOOL, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for GE intrinsic")

exit(1)

elif op.operand == Intrinsic.LE:

assert len(DataType) == 3, "Exhaustive type handling in LE intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.BOOL, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for LE intrinsic")

exit(1)

elif op.operand == Intrinsic.NE:

assert len(DataType) == 3, "Exhaustive type handling in NE intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.BOOL, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for NE intrinsic")

exit(1)

elif op.operand == Intrinsic.SHR:

assert len(DataType) == 3, "Exhaustive type handling in SHR intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.INT, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for SHR intrinsic")

exit(1)

elif op.operand == Intrinsic.SHL:

assert len(DataType) == 3, "Exhaustive type handling in SHL intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.INT, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for SHL intrinsic")

exit(1)

elif op.operand == Intrinsic.OR:

assert len(DataType) == 3, "Exhaustive type handling in OR intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.INT, op.token))

elif a_type == b_type and a_type == DataType.BOOL:

stack.append((DataType.BOOL, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for OR intrinsic")

exit(1)

elif op.operand == Intrinsic.AND:

assert len(DataType) == 3, "Exhaustive type handling in AND intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == b_type and a_type == DataType.INT:

stack.append((DataType.INT, op.token))

elif a_type == b_type and a_type == DataType.BOOL:

stack.append((DataType.BOOL, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for AND intrinsic")

exit(1)

elif op.operand == Intrinsic.NOT:

assert len(DataType) == 3, "Exhaustive type handling in NOT intrinsic"

if len(stack) < 1:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

if a_type == DataType.INT:

stack.append((DataType.INT, op.token))

elif a_type == DataType.BOOL:

stack.append((DataType.BOOL, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for NOT intrinsic")

exit(1)

elif op.operand == Intrinsic.PRINT:

if len(stack) < 1:

not_enough_arguments(op)

exit(1)

stack.pop()

elif op.operand == Intrinsic.DUP:

if len(stack) < 1:

not_enough_arguments(op)

exit(1)

a = stack.pop()

stack.append(a)

stack.append(a)

elif op.operand == Intrinsic.SWAP:

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a = stack.pop()

b = stack.pop()

stack.append(a)

stack.append(b)

elif op.operand == Intrinsic.DROP:

if len(stack) < 1:

not_enough_arguments(op)

exit(1)

stack.pop()

elif op.operand == Intrinsic.OVER:

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a = stack.pop()

b = stack.pop()

stack.append(b)

stack.append(a)

stack.append(b)

elif op.operand == Intrinsic.ROT:

if len(stack) < 3:

not_enough_arguments(op)

exit(1)

a = stack.pop()

b = stack.pop()

c = stack.pop()

stack.append(b)

stack.append(a)

stack.append(c)

elif op.operand == Intrinsic.MEM:

stack.append((DataType.PTR, op.token))

elif op.operand == Intrinsic.LOAD:

assert len(DataType) == 3, "Exhaustive type handling in LOAD intrinsic"

if len(stack) < 1:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

if a_type == DataType.PTR:

stack.append((DataType.INT, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for LOAD intrinsic: %s" % a_type)

exit(1)

elif op.operand == Intrinsic.STORE:

assert len(DataType) == 3, "Exhaustive type handling in STORE intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == DataType.INT and b_type == DataType.PTR:

pass

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for STORE intrinsic")

exit(1)

elif op.operand == Intrinsic.FORTH_LOAD:

assert len(DataType) == 3, "Exhaustive type handling in LOAD intrinsic"

if len(stack) < 1:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

if a_type == DataType.PTR:

stack.append((DataType.INT, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for LOAD intrinsic: %s" % a_type)

exit(1)

elif op.operand == Intrinsic.FORTH_STORE:

assert len(DataType) == 3, "Exhaustive type handling in STORE intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if a_type == DataType.PTR and b_type == DataType.INT:

pass

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for STORE intrinsic")

exit(1)

elif op.operand == Intrinsic.LOAD64:

assert len(DataType) == 3, "Exhaustive type handling in LOAD64 intrinsic"

if len(stack) < 1:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

if a_type == DataType.PTR:

stack.append((DataType.INT, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for LOAD64 intrinsic")

exit(1)

elif op.operand == Intrinsic.STORE64:

assert len(DataType) == 3, "Exhaustive type handling in STORE64 intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if (a_type == DataType.INT or a_type == DataType.PTR) and b_type == DataType.PTR:

pass

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for STORE64 intrinsic: %s" % [b_type, a_type])

exit(1)

elif op.operand == Intrinsic.FORTH_LOAD64:

assert len(DataType) == 3, "Exhaustive type handling in LOAD64 intrinsic"

if len(stack) < 1:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

if a_type == DataType.PTR:

stack.append((DataType.INT, op.token))

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for LOAD64 intrinsic")

exit(1)

elif op.operand == Intrinsic.FORTH_STORE64:

assert len(DataType) == 3, "Exhaustive type handling in STORE64 intrinsic"

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

a_type, a_loc = stack.pop()

b_type, b_loc = stack.pop()

if (b_type == DataType.INT or b_type == DataType.PTR) and a_type == DataType.PTR:

pass

else:

compiler_error_with_expansion_stack(op.token, "invalid argument type for STORE64 intrinsic: %s" % [b_type, a_type])

exit(1)

elif op.operand == Intrinsic.CAST_PTR:

if len(stack) < 1:

not_enough_arguments(op)

exit(1)

a_type, a_token = stack.pop()

stack.append((DataType.PTR, a_token))

elif op.operand == Intrinsic.ARGC:

stack.append((DataType.INT, op.token))

elif op.operand == Intrinsic.ARGV:

stack.append((DataType.PTR, op.token))

elif op.operand == Intrinsic.HERE:

stack.append((DataType.INT, op.token))

stack.append((DataType.PTR, op.token))

# TODO: figure out how to type check syscall arguments and return types

elif op.operand == Intrinsic.SYSCALL0:

if len(stack) < 1:

not_enough_arguments(op)

exit(1)

for i in range(1):

stack.pop()

stack.append((DataType.INT, op.token))

elif op.operand == Intrinsic.SYSCALL1:

if len(stack) < 2:

not_enough_arguments(op)

exit(1)

for i in range(2):

stack.pop()

stack.append((DataType.INT, op.token))

elif op.operand == Intrinsic.SYSCALL2:

if len(stack) < 3:

not_enough_arguments(op)

exit(1)

for i in range(3):

stack.pop()

stack.append((DataType.INT, op.token))

elif op.operand == Intrinsic.SYSCALL3:

if len(stack) < 4:

not_enough_arguments(op)

exit(1)

for i in range(4):

stack.pop()

stack.append((DataType.INT, op.token))

elif op.operand == Intrinsic.SYSCALL4:

if len(stack) < 5:

not_enough_arguments(op)

exit(1)

for i in range(5):

stack.pop()

stack.append((DataType.INT, op.token))

elif op.operand == Intrinsic.SYSCALL5:

if len(stack) < 6:

not_enough_arguments(op)

exit(1)

for i in range(6):

stack.pop()

stack.append((DataType.INT, op.token))

elif op.operand == Intrinsic.SYSCALL6:

if len(stack) < 7:

not_enough_arguments(op)

exit(1)

for i in range(7):

stack.pop()

stack.append((DataType.INT, op.token))

else:

assert False, "unreachable"

elif op.typ == OpType.IF:

block_stack.append((copy(stack), op.typ))

elif op.typ == OpType.WHILE:

block_stack.append((copy(stack), op.typ))

elif op.typ == OpType.END:

block_snapshot, block_type = block_stack.pop()

assert len(OpType) == 10, "Exhaustive handling of op types"