Back Ward Language

# BackWardLanguage -
# stack-based language w/bare minimum
# functionality to do WardNumber algorithm
# Inspired by PostScript Language
# Author: SteveHowell
#
# See WardNumberInManyProgrammingLanguages for an
# example usage.
class Parser:
def __init__(self, fn):
self.fn = fn
def parse(self):
f = open(self.fn)
stack = interpreterStack()
for line in f.readlines():
tokens = line.split()
stack.pushmany(tokens)
class interpreterStack:
def __init__(self):
self.command = {}
self.builtins(['Output', 'Debug',
'Copy', 'Swap', 'Pop',
'Def', 'If', 'While',
'Clear', 'Add', 'Forall',
'Assign', 'Incr', 'Val',
'Set', 'Obj', 'Dict'])
self.command['}'] = builtIn(self.Anon)
self.stack = []
self.scope = Scope(self)
self.namespace = nameSpace()
def builtins(self, names):
for name in names:
self.command[name] = builtIn(getattr(self, name))
def pushmany(self, tokens):
for token in tokens:
self.push(token)
def push(self, token):
self.scope.push(token)
def run(self, token):
if token in self.command:
self.command[token].run()
else:
self.stack.append(token)
def append(self, token):
self.stack.append(token)
def pop(self):
return self.stack.pop()
def Def(self):
name = self.pop()
self.command[name] = self.pop()
def Anon(self):
cmd = Command(self)
self.stack.append(cmd)
def If(self):
else_cmd = self.pop()
if_cmd = self.pop()
self.pop().run()
cond = self.pop()
if int(cond) > 0:
if_cmd.run()
else:
else_cmd.run()
def While(self):
repeat_cmd = self.pop()
cond_cmd = self.pop()
while 1:
cond_cmd.run()
cond = self.pop()
if int(cond) == 0:
break
repeat_cmd.run()
def Copy(self):
count = int(self.pop())
list = self.stack[-1 * (count):]
for item in list:
self.stack.append(item)
def Pop(self):
self.stack.pop()
def Swap(self):
(self.stack[-1], self.stack[-2]) = (self.stack[-2], self.stack[-1])
def Obj(self):
self.namespace.lookup(self, 'obj')
def Set(self):
self.namespace.lookup(self, 'set')
def Dict(self):
self.namespace.lookup(self, 'dict')
def Add(self):
obj = self.pop()
obj.Add(self.pop())
def Clear(self):
obj = self.pop()
obj.Clear()
def Forall(self):
obj = self.pop()
obj.Forall(self)
def Val(self):
obj = self.pop()
self.append(obj.Val())
def Assign(self):
value = self.pop()
obj = self.pop()
obj.Assign(value)
def Incr(self):
obj = self.pop()
obj.Incr()
def Output(self):
obj = self.pop()
try:
obj.Output()
except:
print obj
def Debug(self):
obj = self.pop()
obj.Debug()
class builtIn:
def __init__(self, cmd):
self.cmd = cmd
def run(self):
apply(self.cmd)
class Scope:
def __init__(self, stack):
self.stack = stack
self.level = 0
def push(self, token):
if token == '{':
self.level = self.level + 1
if token == '}':
self.level = self.level - 1
if self.level == 0:
self.stack.run(token)
else:
self.stack.append(token)
class Command:
def __init__(self, stack):
# last curly should already be popped
self.stack = stack
self.tokens = []
level = 1
while 1:
token = stack.pop()
if token == '}':
level += 1
if token == '{':
level -= 1
if level == 0:
break
self.tokens.append(token)
self.tokens.reverse()
def run(self):
self.stack.pushmany(self.tokens)
class Keeper:
def __init__(self):
self.vars = {}
def find(self, key):
if key not in self.vars:
self.vars[key] = self.new_item()
return self.vars[key]
class setKeeper(Keeper):
def new_item(set): return Set()
class objKeeper(Keeper):
def new_item(set): return Obj()
class dictKeeper(Keeper):
def new_item(set): return nameSpace()
class nameSpace:
def __init__(self):
self.set = setKeeper()
self.keeper = {
'obj' : objKeeper(),
'set' : setKeeper(),
'dict' : dictKeeper(),
}
def lookup(self, stack, datatype):
key = stack.pop()
try:
key.lookup(stack, datatype)
except:
stack.append(self.keeper[datatype].find(key))
class Obj:
def __init__(self, obj=None):
self.obj = obj
def Assign(self, value):
self.obj = value
def Val(self):
return self.obj
def Incr(self):
self.obj = int(self.obj) + 1
class Set:
def __init__(self):
self.Clear()
def Add(self, value):
if value not in self.dict:
self.set.append(value)
self.dict[value] = 1
def Debug(self):
print 'debug:', self.set
def Forall(self, stack):
cmd = stack.pop()
for item in self.set:
stack.append(item)
cmd.run()
def Clear(self):
self.set = []
self.dict = {}
def Val(self):
return len(self.set)
Parser('stack.ps').parse()


---

Strange; that looks like PythonLanguage to me... ;)

OK, so it's a BackWardLanguage interpreter written in Python. Now that you've bootstrapped yourself, you need to supply a BackWard interpreter implemented in BackWard.

:)

Thank you for providing grammar, documentation, and examples for all us lazy people out there. :P

Yes, but where are its tests?