from __future__ import print_function
import sys
import inspect
import contextlib
@contextlib.contextmanager
def redir_stdout(new):
old = sys.stdout
sys.stdout = new
yield
sys.stdout = old
SPACE = None
class _RUN: pass
def read_word(fil):
char = ' '
buffer = []
delim = SPACE
spaces = {' ', '\n', '\t'}
while char != '':
char = fil.read(1)
if char == '':
yield ''.join(buffer).strip()
break
buffer.append(char)
if delim != SPACE and buffer[-len(delim):] == delim:
delim = yield ''.join(buffer[:-len(delim)])
buffer = []
elif char in spaces:
delim = yield ''.join(buffer[:-1]).strip()
if char == '\n':
yield _RUN
buffer = []
def skip_run(reader):
skipped = False
r = reader.next()
while r == _RUN:
skipped = skipped or r == _RUN
#print(r, end=':')
r = reader.next()
#print(r, end=' ')
#print('out')
return r, skipped
import collections
import traceback
class SymbolDict(collections.MutableMapping):
def __init__(self, *args, **kwargs):
self.ctr = 0
self.items_ = set()
self.dct = dict(*args, **kwargs)
def __getitem__(self, key):
if self.dct[key] != []:
return self.dct[key][-1][1]
else:
raise KeyError("No such key '%s'" % key)
def __setitem__(self, key, value):
self.ctr += 1
self.items_.add(key)
self.dct.setdefault(key, []).append((self.ctr, value))
def __delitem__(self, key):
state = self.dct[key][-1][0]
for a in self.dct.keys():
while self.dct[a] and self.dct[a][-1][0] >= state:
self.dct[a].pop()
if self.dct[a] == []: self.dct.pop(a)
forget = __delitem__
def __iter__(self):
return (x for x in self.dct.keys())
def __len__(self):
return len(self.dct)
import random
class Reader(object):
symbols = SymbolDict()
def rev_pctr(self, stack, rstack):
num = stack.pop()
self.program_ctr -= num
def adv_pctr(self, stack, rstack):
num = stack.pop()
self.program_ctr += num
def adv_pctr0(self, stack, rstack):
#print('adv0 -->', stack, rstack)
num = stack.pop()
cond = stack.pop()
if cond == 0:
stack.append(num)
self.adv_pctr(stack, rstack)
def save_program_ctr(self):
self.pcs.append(self.program_ctr)
def restore_program_ctr(self):
self.program_ctr = self.pcs.pop()
def rollback_program(self):
self.restore_program_ctr()
del self.program[self.program_ctr:]
def splice_program(self, words):
begin = self.peek_saved_program_ctr()
end = self.program_ctr + 1
self.program[begin:end] = words
def peek_saved_program_ctr(self):
return self.pcs[-1]
def drop_saved_program_ctr(self):
return self.pcs.pop()
def if_(self, stack, rstack=None):
def if_reader(gen):
counter = 0
if_clause = []
else_clause = []
cur_clause = if_clause
for word in gen:
if word == 'if':
cur_clause.extend(if_reader(gen))
continue
elif word == 'else':
cur_clause = else_clause
continue
elif word == 'then':
else_clause.extend(['nop'])
break
cur_clause.extend(self.expand_word(word))
if_clause.extend(['%d' % len(else_clause), 'adv'])
if_clause.insert(0, '%d' % len(if_clause))
if_clause.insert(1, 'adv0')
result = if_clause + else_clause
return result
## Below we replace the if statement with a call to lower-level primitives
## i.e. if is implemented as a kind of macro.
self.save_program_ctr()
self.program_ctr += 1 # since the program counter doesn't update until after the yield
gen = self.read_word()
self.splice_program(if_reader(gen))
self.restore_program_ctr()
self.program_ctr -= 1 # in order to pick up the beginning of the if statement
def words(self, stack, rstack=None):
words = sorted(self.symbols.keys())
mlen = max(len(x) for x in words)
c = 80 // (mlen + 2)
while words:
head, words = words[:c], words[c:]
print(' '.join(x.center(mlen) for x in head), file=self.out)
def forget(self, stack, rstack=None):
self.program_ctr += 1 # since the program counter doesn't update until after the yield
name, skipped = skip_run(self.read_word())
self.symbols.forget(name)
if skipped: self.inp.append([_RUN])
def colon(self, stack, rstack=None):
self.program_ctr += 1 # since the program counter doesn't update until after the yield
gen = self.read_word()
name = gen.next()
word = ' '
conts = []
while word != ';':
word = gen.next()
if word == _RUN: continue
conts.append(word)
conts.pop() # pop off the semicolon
self.compile(name, filter(None,conts))
#print(' >name', name, ' >symbols["%s"]' % name, self.symbols[name.lower()])
def expand_word(self, word):
if word in self.sym_words:
outp = [self.expand_word(w) for w in self.sym_words[word][:]]
return sum(outp, [])
else:
return [word]
def compile(self, name, words):
if hasattr(words, 'split'): words = words.split()
self.sym_words[name] = words[:]
@self.add_symbol(name)
def newfun(stack, rstack=None):
self.save_program_ctr()
self.splice_program(words[:])
self.program_ctr -= 1
newfun.__name__ = '_forth_%s' % name
def prog_print(self, stack, rstack=None):
print('<%d>' % len(self.program), end=' ', file=self.out)
for n in self.program:
print(n, end=' ', file=self.out)
print(file=self.out)
def set_pctr(self, v):
self.program_ctr = v
def begin_until(self, stack, rstack):
self.program_ctr += 1 # since the program counter doesn't update until after the yield
mark = self.program_ctr
word = ' '
loop_count = 0
words = []
while True:
word = self.read_word()
if word == 'begin': loop_count += 1
elif word == 'until':
if loop_count == 0: break
else: loop_count -= 1
words.append(word)
def mark_r(self, stack, rstack):
self.jmpr.append(self.program_ctr-1)
#print('markr', self.jmpr)
def jmp_r(self, stack, rstack):
dst = self.jmpr.pop()
self.set_pctr(dst)
#print('jmpr', dst, self.jmpr)
def jmp_clr(self, stack, rstack):
self.jmpr.pop()
#print('clrjmp', self.jmpr)
def mark(self, stack, rstack):
self.stack.append(self.program_ctr-1)
def jmp(self, stack, rstack):
dst = stack.pop()
self.set_pctr(dst)
def __init__(self, out=sys.stdout):
self.sym_words = SymbolDict()
self.stack = []
self.rstack = []
self.program = []
self.jmpr = []
self.pcs = []
self.mode = 0; # 0 - Normal; 1 - string reading
self.program_ctr = 0
self.out = out
self.add_symbol('words')(self.words)
self.add_symbol('.p')(self.prog_print)
self.add_symbol(':')(self.colon)
self.add_symbol('forget')(self.forget)
self.add_symbol('if')(self.if_)
self.add_symbol('jmp')(self.jmp)
self.add_symbol('rev')(self.rev_pctr)
self.add_symbol('adv')(self.adv_pctr)
self.add_symbol('adv0')(self.adv_pctr0)
self.add_symbol('mark')(self.mark)
self.add_symbol('markr')(self.mark_r)
self.add_symbol('jmpr')(self.jmp_r)
self.add_symbol('clrjmp')(self.jmp_clr)
def __getword(self):
while self.inp[-1] == []: self.inp.pop()
if hasattr(self.inp[-1], 'read'):
self.inp[-1] = read_word(self.inp[-1])
if hasattr(self.inp[-1], 'next'):
result = self.inp[-1].next()
else:
result = self.inp[-1].pop(0)
self.program.append(result)
def read_word(self):
while True:
while self.program_ctr >= len(self.program):
self.__getword()
yield self.program[self.program_ctr]
self.program_ctr += 1
def read(self, inp, silent=False):
self.inp = [inp]
delim = SPACE
if not silent: print(self.program_ctr, end='? ', file=self.out)
for word in self.read_word():
#print('<%s>' % word, end=' ')
if word == _RUN:
if not silent:
print(' ok', file=self.out)
print(self.program_ctr, end='? ', file=self.out)
continue
elif word == '."':
out = []
word = self.__getword()
while word != '"':
out.append(self.__getword)
word = self.__getword()
print(' '.join(out), file=self.out)
continue
elif word == '': continue
self.stack.append(word)
self.lookup()
def lookup(self, sym=None):
if sym is None:
sym = self.stack.pop()
result = None
if sym.lower() in self.symbols:
with redir_stdout(self.out):
result = self.symbols[sym.lower()](self.stack, self.rstack)
else:
result = self.numberp(sym)
if result is None: raise ValueError("Symbol %r not found" % sym)
else:
self.stack.append(result)
return result
def numberp(self, sym):
is_valid = -1 # -1 = undecided, 0 = False, 1 = True
typ = int
dot_acceptable = False
if sym == '': is_valid = 0
elif not (sym.startswith('-') or sym[0].isdigit()): is_valid = 0
if is_valid == 0: return None
else:
for char in sym[1:]:
if char.isdigit(): dot_acceptable = True
elif dot_acceptable and char == '.': typ = float
elif dot_acceptable and char == 'e': typ = float
else:
return None
else:
return typ(sym)
@classmethod
def add_symbol(cls, name):
def _i1(func):
cls.symbols[name.lower()] = func
return func
return _i1
@Reader.add_symbol('J')
def J(stack, rstack):
stack.append(rstack[-3])
@Reader.add_symbol('R@')
def rAt(stack, rstack):
stack.append(rstack[-1])
@Reader.add_symbol('I')
def I(stack, rstack):
stack.append(rstack[-1])
@Reader.add_symbol('R>')
def movP(stack, rstack):
stack.append(rstack.pop())
@Reader.add_symbol('>R')
def movR(stack, rstack):
rstack.append(stack.pop())
@Reader.add_symbol('2over')
def _2over(stack, rstack=None):
d, c, b, a = [stack.pop() for _ in range(4)]
stack.append(a)
stack.append(b)
stack.append(c)
stack.append(d)
stack.append(a)
stack.append(b)
@Reader.add_symbol('2dup')
def _2dup(stack, rstack=None):
b, a = [stack.pop() for _ in range(2)]
stack.append(a)
stack.append(b)
stack.append(a)
stack.append(b)
@Reader.add_symbol('2swap')
def _2swap(stack, rstack=None):
d, c, b, a = [stack.pop() for _ in range(4)]
stack.append(c)
stack.append(d)
stack.append(a)
stack.append(b)
@Reader.add_symbol('.r')
def stack_print(stack, rstack=None):
print('<%d>' % len(rstack), end=' ')
for n in rstack:
print(n, end=' ')
print()
@Reader.add_symbol('.s')
def stack_print(stack, rstack=None):
print('<%d>' % len(stack), end=' ')
for n in stack:
print(n, end=' ')
print()
@Reader.add_symbol('drop')
def drop(stack, rstack=None):
stack.pop()
@Reader.add_symbol('rot')
def rot(stack, rstack=None):
n1, n2, n3 = stack.pop(), stack.pop(), stack.pop()
#a, b, c
stack.extend([n2, n1, n3])
@Reader.add_symbol('dup')
def dup(stack, rstack=None):
a = stack.pop()
stack.append(a)
stack.append(a)
@Reader.add_symbol('over')
def over(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(a)
stack.append(b)
stack.append(a)
@Reader.add_symbol('swap')
def swap(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(b)
stack.append(a)
@Reader.add_symbol('%')
def mod(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(a % b)
@Reader.add_symbol('/')
def div(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(a / b)
@Reader.add_symbol('*')
def mul(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(a * b)
@Reader.add_symbol('-')
def min_(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(a - b)
@Reader.add_symbol('+')
def add(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(a + b)
@Reader.add_symbol('and')
def and_(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(a and b)
@Reader.add_symbol('or')
def or_(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(a or b)
@Reader.add_symbol('.')
def period(stack, rstack=None):
print(stack.pop(), end=' ')
@Reader.add_symbol('emit')
def emit(stack, rstack=None):
print(chr(stack.pop()), end='')
@Reader.add_symbol('=')
def eql(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(int(a == b))
@Reader.add_symbol('<')
def lt(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(int(a < b))
@Reader.add_symbol('>')
def gt(stack, rstack=None):
b, a = stack.pop(), stack.pop()
stack.append(int(a > b))
@Reader.add_symbol('nop')
def nop(*_):
pass
@Reader.add_symbol('clear')
def clear(stack, rstack):
del stack[:]
del rstack[:]
def init_reader():
reader = Reader()
reader.compile(*'0= 0 ='.split(None,1))
reader.compile(*'0> 0 >'.split(None,1))
reader.compile(*'0< 0 <'.split(None,1))
reader.compile('cr', ['10', 'emit'])
reader.compile('2drop', ['drop', 'drop'])
reader.compile('false', ['0'])
reader.compile('true', ['-1'])
reader.compile('invert', ['0=', 'if', 'true', 'else', 'false', 'then'])
reader.compile('?dup', 'dup if dup then'.split())
reader.compile('1+', '1 +'.split())
reader.compile('1-', '1 -'.split())
reader.compile('2+', '2 +'.split())
reader.compile('2-', '2 -'.split())
reader.compile('2*', '2 *'.split())
reader.compile('2/', '2 /'.split())
reader.compile('abs', 'dup 0< if -1 * then'.split())
reader.compile('negate', '-1 *'.split())
reader.compile('min', '2dup - 0> if swap then drop')
reader.compile('max', '2dup - 0< if swap then drop')
reader.compile('*/', 'rot rot * swap /')
reader.compile('*/mod', 'rot rot * swap /mod')
reader.compile('/mod1', '2dup % dup 2swap / rot drop')
reader.compile('mark>r', 'mark >r')
reader.compile('arrow', '45 emit 45 emit 62 emit')
reader.compile('loop0', '0= arrow .s if 98 emit cr else 97 emit cr .s r> .s jmp then')
reader.compile(*'spaces 0 do 32 emit loop'.split(None, 1))
reader.compile(*'do swap >r >r begin'.split(None, 1))
reader.compile('rdrop', 'r> drop')
reader.compile(*'loop r> 1+ r> 2dup >r >r < invert until rdrop rdrop'.split(None, 1))
reader.compile('begin', 'markr')
reader.compile('until', 'invert if jmpr else clrjmp then')
return reader
if __name__ == '__main__':
import sys
reader = init_reader()
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('file', nargs='?')
args = parser.parse_args()
if args.file == '-' or args.file == None:
fil = sys.stdin
reader.read(sys.stdin)
else:
with open(args.file) as f:
reader.read(f, silent=True)