Whitespace Assembler
#! /usr/bin/env python
"""Assembler.py
Compiles a program from "Assembly" folder into "Program" folder.
Can be executed directly by double-click or on the command line.
Give name of *.WSA file without extension (example: stack_calc)."""
################################################################################
__author__ = 'Stephen "Zero" Chappell <
[email protected]>'
__date__ = '14 March 2010'
__version__ = '$Revision: 3 $'
################################################################################
import string
from Interpreter import INS, MNEMONIC
################################################################################
def parse(code):
program = []
process_virtual(program, code)
process_control(program)
return tuple(program)
def process_virtual(program, code):
for line, text in enumerate(code.split('\n')):
if not text or text[0] == '#':
continue
if text.startswith('part '):
parse_part(program, line, text[5:])
elif text.startswith(' '):
parse_code(program, line, text[5:])
else:
syntax_error(line)
def syntax_error(line):
raise SyntaxError('Line ' + str(line + 1))
################################################################################
def process_control(program):
parts = get_parts(program)
names = dict(pair for pair in zip(parts, generate_index()))
correct_control(program, names)
def get_parts(program):
parts = []
for ins in program:
if isinstance(ins, tuple):
ins, arg = ins
if ins == INS.PART:
if arg in parts:
raise NameError('Part definition was found twice: ' + arg)
parts.append(arg)
return parts
def generate_index():
index = 1
while True:
yield index
index *= -1
if index > 0:
index += 1
def correct_control(program, names):
for index, ins in enumerate(program):
if isinstance(ins, tuple):
ins, arg = ins
if ins in HAS_LABEL:
if arg not in names:
raise NameError('Part definition was never found: ' + arg)
program[index] = (ins, names[arg])
################################################################################
def parse_part(program, line, text):
if not valid_label(text):
syntax_error(line)
program.append((INS.PART, text))
def valid_label(text):
if not between_quotes(text):
return False
label = text[1:-1]
if not valid_name(label):
return False
return True
def between_quotes(text):
if len(text) < 3:
return False
if text.count('"') != 2:
return False
if text[0] != '"' or text[-1] != '"':
return False
return True
def valid_name(label):
valid_characters = string.ascii_letters + string.digits + '_'
valid_set = frozenset(valid_characters)
label_set = frozenset(label)
if len(label_set - valid_set) != 0:
return False
return True
################################################################################
from Interpreter import HAS_LABEL, Program
NO_ARGS = Program.NO_ARGS
HAS_ARG = Program.HAS_ARG
TWO_WAY = tuple(set(NO_ARGS) & set(HAS_ARG))
################################################################################
def parse_code(program, line, text):
for ins, word in enumerate(MNEMONIC):
if text.startswith(word):
check_code(program, line, text[len(word):], ins)
break
else:
syntax_error(line)
def check_code(program, line, text, ins):
if ins in TWO_WAY:
if text:
number = parse_number(line, text)
program.append((ins, number))
else:
program.append(ins)
elif ins in HAS_LABEL:
text = parse_label(line, text)
program.append((ins, text))
elif ins in HAS_ARG:
number = parse_number(line, text)
program.append((ins, number))
elif ins in NO_ARGS:
if text:
syntax_error(line)
program.append(ins)
else:
syntax_error(line)
def parse_label(line, text):
if not text or text[0] != ' ':
syntax_error(line)
text = text[1:]
if not valid_label(text):
syntax_error(line)
return text
################################################################################
def parse_number(line, text):
if not valid_number(text):
syntax_error(line)
return int(text)
def valid_number(text):
if len(text) < 2:
return False
if text[0] != ' ':
return False
text = text[1:]
if '+' in text and '-' in text:
return False
if '+' in text:
if text.count('+') != 1:
return False
if text[0] != '+':
return False
text = text[1:]
if not text:
return False
if '-' in text:
if text.count('-') != 1:
return False
if text[0] != '-':
return False
text = text[1:]
if not text:
return False
valid_set = frozenset(string.digits)
value_set = frozenset(text)
if len(value_set - valid_set) != 0:
return False
return True
################################################################################
################################################################################
from Interpreter import partition_number
VMC_2_TRI = {
(INS.PUSH, True): (0, 0),
(INS.COPY, False): (0, 2, 0),
(INS.COPY, True): (0, 1, 0),
(INS.SWAP, False): (0, 2, 1),
(INS.AWAY, False): (0, 2, 2),
(INS.AWAY, True): (0, 1, 2),
(INS.ADD, False): (1, 0, 0, 0),
(INS.SUB, False): (1, 0, 0, 1),
(INS.MUL, False): (1, 0, 0, 2),
(INS.DIV, False): (1, 0, 1, 0),
(INS.MOD, False): (1, 0, 1, 1),
(INS.SET, False): (1, 1, 0),
(INS.GET, False): (1, 1, 1),
(INS.PART, True): (2, 0, 0),
(INS.CALL, True): (2, 0, 1),
(INS.GOTO, True): (2, 0, 2),
(INS.ZERO, True): (2, 1, 0),
(INS.LESS, True): (2, 1, 1),
(INS.BACK, False): (2, 1, 2),
(INS.EXIT, False): (2, 2, 2),
(INS.OCHR, False): (1, 2, 0, 0),
(INS.OINT, False): (1, 2, 0, 1),
(INS.ICHR, False): (1, 2, 1, 0),
(INS.IINT, False): (1, 2, 1, 1)
}
################################################################################
def to_trinary(program):
trinary_code = []
for ins in program:
if isinstance(ins, tuple):
ins, arg = ins
trinary_code.extend(VMC_2_TRI[(ins, True)])
trinary_code.extend(from_number(arg))
else:
trinary_code.extend(VMC_2_TRI[(ins, False)])
return tuple(trinary_code)
def from_number(arg):
code = [int(arg < 0)]
if arg:
for bit in reversed(list(partition_number(abs(arg), 2))):
code.append(bit)
return
code + [2]
return
code + [0, 2]
to_ws = lambda trinary: ''.join(' \t\n'[index] for index in trinary)
def compile_wsa(source):
program = parse(source)
trinary = to_trinary(program)
ws_code = to_ws(trinary)
return ws_code
################################################################################
################################################################################
import os
import sys
import time
import traceback
def main():
name,
source, command_line, error = get_source()
if not error:
start = time.clock()
try:
ws_code = compile_wsa(source)
except:
print('ERROR: File could not be compiled.\n')
traceback.print_exc()
error = True
else:
path = os.path.join('Programs', name + '.ws')
try:
open(path, 'w').write(ws_code)
except IOError as err:
print(err)
error = True
else:
div, mod = divmod((time.clock() - start) * 1000, 1)
args = int(div), '{:.3}'.format(mod)[1:]
print('DONE: Comipled in {}{} ms'.format(*args))
handle_close(error, command_line)
def get_source():
if len(sys.argv) > 1:
command_line = True
name = sys.argv[1]
else:
command_line = False
try:
name = input('
Source File: ')
except:
return None, None, False, True
print()
path = os.path.join('Assembly', name + '.wsa')
try:
return name, open(path).read(), command_line, False
except IOError as err:
print(err)
return None, None, command_line, True
def handle_close(error, command_line):
if error:
usage = 'Usage: {} <assembly>'.format(os.path.basename(sys.argv[0]))
print('\n{}\n{}'.format('-' * len(usage), usage))
if not command_line:
time.sleep(10)
################################################################################
if __name__ == '__main__':
main()
Whitespace Helpers
#! /usr/bin/env python
"""Helpers.py
Includes a function to encode Python strings into my WSA format.
Has a "PRINT_LINE" function that can be copied to a WSA program.
Contains a "PRINT" function and documentation as an explanation."""
################################################################################
__author__ = 'Stephen "Zero" Chappell <
[email protected]>'
__date__ = '14 March 2010'
__version__ = '$Revision: 1 $'
################################################################################
def encode_string(string, addr):
print(' push', addr)
print(' push', len(string))
print(' set')
addr += 1
for offset, character in enumerate(string):
print(' push', addr + offset)
print(' push', ord(character))
print(' set')
################################################################################
# Prints a string with newline.
# push addr
# call "PRINT_LINE"
"""
part "PRINT_LINE"
call "PRINT"
push 10
ochr
back
"""
################################################################################
# def print(array):
# if len(array) <= 0:
# return
# offset = 1
# while len(array) - offset >= 0:
# ptr = array.ptr + offset
# putch(array[ptr])
# offset += 1
"""
part "PRINT"
# Line 1-2
copy
get
less "__PRINT_RET_1"
copy
get
zero "__PRINT_RET_1"
# Line 3
push 1
# Line 4
part "__PRINT_LOOP"
copy
copy 2
get
swap
sub
less "__PRINT_RET_2"
# Line 5
copy 1
copy 1
add
# Line 6
get
ochr
# Line 7
push 1
add
goto "__PRINT_LOOP"
part "__PRINT_RET_2"
away
part "__PRINT_RET_1"
away
back
"""
Whitespace Interpreter
#! /usr/bin/env python
"""Interpreter.py
Runs programs in "Programs" and creates *.WSO files when needed.
Can be executed directly by double-click or on the command line.
If run on command line, add "ASM" flag to dump program assembly."""
################################################################################
__author__ = 'Stephen "Zero" Chappell <
[email protected]>'
__date__ = '14 March 2010'
__version__ = '$Revision: 4 $'
################################################################################
def test_file(path):
disassemble(parse(trinary(load(path))), True)
################################################################################
load = lambda ws: ''.join(c for r in open(ws) for c in r if c in ' \t\n')
trinary = lambda ws: tuple(' \t\n'.index(c) for c in ws)
################################################################################
def enum(names):
names = names.replace(',', ' ').split()
space = dict((reversed(pair) for pair in enumerate(names)), __slots__=())
return type('enum', (object,), space)()
INS = enum('''\
PUSH, COPY, SWAP, AWAY, \
ADD, SUB, MUL, DIV, MOD, \
SET, GET, \
PART, CALL, GOTO, ZERO, LESS, BACK, EXIT, \
OCHR, OINT, ICHR, IINT''')
################################################################################
def parse(code):
ins = iter(code).__next__
program = []
while True:
try:
imp = ins()
except StopIteration:
return tuple(program)
if imp == 0:
# [Space]
parse_stack(ins, program)
elif imp == 1:
# [Tab]
imp = ins()
if imp == 0:
# [Tab][Space]
parse_math(ins, program)
elif imp == 1:
# [Tab][Tab]
parse_heap(ins, program)
else:
# [Tab][Line]
parse_io(ins, program)
else:
# [Line]
parse_flow(ins, program)
def parse_number(ins):
sign = ins()
if sign == 2:
raise StopIteration()
buffer = ''
code = ins()
if
code == 2:
raise StopIteration()
while
code != 2:
buffer += str(code)
code = ins()
if sign == 1:
return int(buffer, 2) * -1
return int(buffer, 2)
################################################################################
def parse_stack(ins, program):
code = ins()
if
code == 0:
# [Space]
number = parse_number(ins)
program.append((INS.PUSH, number))
elif
code == 1:
# [Tab]
code = ins()
number = parse_number(ins)
if
code == 0:
# [Tab][Space]
program.append((INS.COPY, number))
elif
code == 1:
# [Tab][Tab]
raise StopIteration()
else:
# [Tab][Line]
program.append((INS.AWAY, number))
else:
# [Line]
code = ins()
if
code == 0:
# [Line][Space]
program.append(INS.COPY)
elif
code == 1:
# [Line][Tab]
program.append(INS.SWAP)
else:
# [Line][Line]
program.append(INS.AWAY)
def parse_math(ins, program):
code = ins()
if
code == 0:
# [Space]
code = ins()
if
code == 0:
# [Space][Space]
program.append(INS.ADD)
elif
code == 1:
# [Space][Tab]
program.append(INS.SUB)
else:
# [Space][Line]
program.append(INS.MUL)
elif
code == 1:
# [Tab]
code = ins()
if
code == 0:
# [Tab][Space]
program.append(INS.DIV)
elif
code == 1:
# [Tab][Tab]
program.append(INS.MOD)
else:
# [Tab][Line]
raise StopIteration()
else:
# [Line]
raise StopIteration()
def parse_heap(ins, program):
code = ins()
if
code == 0:
# [Space]
program.append(INS.SET)
elif
code == 1:
# [Tab]
program.append(INS.GET)
else:
# [Line]
raise StopIteration()
def parse_io(ins, program):
code = ins()
if
code == 0:
# [Space]
code = ins()
if
code == 0:
# [Space][Space]
program.append(INS.OCHR)
elif
code == 1:
# [Space][Tab]
program.append(INS.OINT)
else:
# [Space][Line]
raise StopIteration()
elif
code == 1:
# [Tab]
code = ins()
if
code == 0:
# [Tab][Space]
program.append(INS.ICHR)
elif
code == 1:
# [Tab][Tab]
program.append(INS.IINT)
else:
# [Tab][Line]
raise StopIteration()
else:
# [Line]
raise StopIteration()
def parse_flow(ins, program):
code = ins()
if
code == 0:
# [Space]
code = ins()
label = parse_number(ins)
if
code == 0:
# [Space][Space]
program.append((INS.PART, label))
elif
code == 1:
# [Space][Tab]
program.append((INS.CALL, label))
else:
# [Space][Line]
program.append((INS.GOTO, label))
elif
code == 1:
# [Tab]
code = ins()
if
code == 0:
# [Tab][Space]
label = parse_number(ins)
program.append((INS.ZERO, label))
elif
code == 1:
# [Tab][Tab]
label = parse_number(ins)
program.append((INS.LESS, label))
else:
# [Tab][Line]
program.append(INS.BACK)
else:
# [Line]
code = ins()
if
code == 2:
# [Line][Line]
program.append(INS.EXIT)
else:
# [Line][Space] or [Line][Tab]
raise StopIteration()
################################################################################
MNEMONIC = '\
push copy swap away add sub mul div mod set get part \
call goto zero less back exit ochr oint ichr iint'.split()
HAS_ARG = [getattr(INS, name) for name in
'PUSH COPY AWAY PART CALL GOTO ZERO LESS'.split()]
HAS_LABEL = [getattr(INS, name) for name in
'PART CALL GOTO ZERO LESS'.split()]
def disassemble(program, names=False):
if names:
names = create_names(program)
for ins in program:
if isinstance(ins, tuple):
ins, arg = ins
assert ins in HAS_ARG
has_arg = True
else:
assert INS.PUSH <= ins <= INS.IINT
has_arg = False
if ins == INS.PART:
if names:
print(MNEMONIC[ins], '"' + names[arg] + '"')
else:
print(MNEMONIC[ins], arg)
elif has_arg and ins in HAS_ARG:
if ins in HAS_LABEL and names:
assert arg in names
print(' ' + MNEMONIC[ins], '"' + names[arg] + '"')
else:
print(' ' + MNEMONIC[ins], arg)
else:
print(' ' + MNEMONIC[ins])
################################################################################
def create_names(program):
names = {}
number = 1
for ins in program:
if isinstance(ins, tuple) and ins[0] == INS.PART:
label = ins[1]
assert label not in names
names[label] = number_to_name(number)
number += 1
return names
def number_to_name(number):
name = ''
for offset in reversed(list(partition_number(number, 27))):
if offset:
name += chr(ord('A') + offset - 1)
else:
name += '_'
return name
def partition_number(number, base):
div, mod = divmod(number, base)
yield mod
while div:
div, mod = divmod(div, base)
yield mod
################################################################################
CODE = (' \t\n',
' \n ',
' \t \t\n',
' \n\t',
' \n\n',
' \t\n \t\n',
'\t ',
'\t \t',
'\t \n',
'\t \t ',
'\t \t\t',
'\t\t ',
'\t\t\t',
'\n \t\n',
'\n \t \t\n',
'\n \n \t\n',
'\n\t \t\n',
'\n\t\t \t\n',
'\n\t\n',
'\n\n\n',
'\t\n ',
'\t\n \t',
'\t\n\t ',
'\t\n\t\t')
EXAMPLE = ''.join(CODE)
################################################################################
NOTES = '''\
STACK
=====
push number
copy
copy number
swap
away
away number
MATH
====
add
sub
mul
div
mod
HEAP
====
set
get
FLOW
====
part label
call label
goto label
zero label
less label
back
exit
I/O
===
ochr
oint
ichr
iint'''
################################################################################
################################################################################
class Stack:
def __init__(self):
self.__data = []
# Stack Operators
def push(self, number):
self.__data.append(number)
def copy(self, number=None):
if number is None:
self.__data.append(self.__data[-1])
else:
size = len(self.__data)
index = size - number - 1
assert 0 <= index < size
self.__data.append(self.__data[index])
def swap(self):
self.__data[-2], self.__data[-1] = self.__data[-1], self.__data[-2]
def away(self, number=None):
if number is None:
self.__data.pop()
else:
size = len(self.__data)
index = size - number - 1
assert 0 <= index < size
del self.__data[index:-1]
# Math Operators
def add(self):
suffix = self.__data.pop()
prefix = self.__data.pop()
self.__data.append(prefix + suffix)
def sub(self):
suffix = self.__data.pop()
prefix = self.__data.pop()
self.__data.append(prefix - suffix)
def mul(self):
suffix = self.__data.pop()
prefix = self.__data.pop()
self.__data.append(prefix * suffix)
def div(self):
suffix = self.__data.pop()
prefix = self.__data.pop()
self.__data.append(prefix // suffix)
def mod(self):
suffix = self.__data.pop()
prefix = self.__data.pop()
self.__data.append(prefix % suffix)
# Program Operator
def pop(self):
return self.__data.pop()
################################################################################
class Heap:
def __init__(self):
self.__data = {}
def set_(self, addr, item):
if item:
self.__data[addr] = item
elif addr in self.__data:
del self.__data[addr]
def get_(self, addr):
return self.__data.get(addr, 0)
################################################################################
import os
import zlib
import msvcrt
import pickle
import string
class CleanExit(Exception): pass
NOP = lambda arg: None
DEBUG_WHITESPACE = False
################################################################################
class Program:
NO_ARGS = INS.COPY, INS.SWAP, INS.AWAY, INS.ADD, \
INS.SUB, INS.MUL, INS.DIV, INS.MOD, \
INS.SET, INS.GET, INS.BACK, INS.EXIT, \
INS.OCHR, INS.OINT, INS.ICHR, INS.IINT
HAS_ARG = INS.PUSH, INS.COPY, INS.AWAY, INS.PART, \
INS.CALL, INS.GOTO, INS.ZERO, INS.LESS
def __init__(self, code):
self.__data =
code
self.__validate()
self.__build_jump()
self.__check_jump()
self.__setup_exec()
def __setup_exec(self):
self.__iptr = 0
self.__stck = stack = Stack()
self.__heap = Heap()
self.__cast = []
self.__meth = (stack.push, stack.copy, stack.swap, stack.away,
stack.add, stack.sub, stack.mul, stack.div, stack.mod,
self.__set, self.__get,
NOP, self.__call, self.__goto, self.__zero,
self.__less, self.__back, self.__exit,
self.__ochr, self.__oint, self.__ichr, self.__iint)
def step(self):
ins = self.__data[self.__iptr]
self.__iptr += 1
if isinstance(ins, tuple):
self.__meth[ins[0]](ins[1])
else:
self.__meth[ins]()
def run(self):
while True:
ins = self.__data[self.__iptr]
self.__iptr += 1
if isinstance(ins, tuple):
self.__meth[ins[0]](ins[1])
else:
self.__meth[ins]()
def __oint(self):
for digit in str(self.__stck.pop()):
msvcrt.putwch(digit)
def __ichr(self):
addr = self.__stck.pop()
# Input Routine
while msvcrt.kbhit():
msvcrt.getwch()
while True:
char = msvcrt.getwch()
if char in '\x00\xE0':
msvcrt.getwch()
elif char in string.printable:
char = char.replace('\r', '\n')
msvcrt.putwch(char)
break
item = ord(char)
# Storing Number
self.__heap.set_(addr, item)
def __iint(self):
addr = self.__stck.pop()
# Input Routine
while msvcrt.kbhit():
msvcrt.getwch()
buff = ''
char = msvcrt.getwch()
while char != '\r' or not buff:
if char in '\x00\xE0':
msvcrt.getwch()
elif char in '+-' and not buff:
msvcrt.putwch(char)
buff += char
elif '0' <= char <= '9':
msvcrt.putwch(char)
buff += char
elif char == '\b':
if buff:
buff = buff[:-1]
msvcrt.putwch(char)
msvcrt.putwch(' ')
msvcrt.putwch(char)
char = msvcrt.getwch()
msvcrt.putwch(char)
msvcrt.putwch('\n')
item = int(buff)
# Storing Number
self.__heap.set_(addr, item)
def __goto(self, label):
self.__iptr = self.__jump[label]
def __zero(self, label):
if self.__stck.pop() == 0:
self.__iptr = self.__jump[label]
def __less(self, label):
if self.__stck.pop() < 0:
self.__iptr = self.__jump[label]
def __exit(self):
self.__setup_exec()
raise CleanExit()
def __set(self):
item = self.__stck.pop()
addr = self.__stck.po
