# figure out if we're in python or tinypy (tinypy displays "1.0" as "1")
is_tinypy = (str(1.0) == "1")
if not is_tinypy:
from boot import *
################################################################################
RM = 'rm -f '
VM = './vm '
TINYPY = './tinypy '
TMP = 'tmp.txt'
if '-mingw32' in ARGV or "-win" in ARGV:
RM = 'del '
VM = 'vm '
TINYPY = 'tinypy '
TMP = 'tmp.txt'
#TMP = 'stdout.txt'
def system_rm(fname):
system(RM+fname)
################################################################################
#if not is_tinypy:
#v = chksize()
#assert (v < 65536)
################################################################################
def t_show(t):
if t.type == 'string': return '"'+t.val+'"'
if t.type == 'number': return t.val
if t.type == 'symbol': return t.val
if t.type == 'name': return '$'+t.val
return t.type
def t_tokenize(s,exp=''):
import tokenize
result = tokenize.tokenize(s)
res = ' '.join([t_show(t) for t in result])
#print(s); print(exp); print(res)
assert(res == exp)
if __name__ == '__main__':
t_tokenize("234",'234')
t_tokenize("234.234",'234.234')
t_tokenize("phil",'$phil')
t_tokenize("_phil234",'$_phil234')
t_tokenize("'phil'",'"phil"')
t_tokenize('"phil"','"phil"')
t_tokenize("'phil' x",'"phil" $x')
t_tokenize("#comment","")
t_tokenize("and","and")
t_tokenize("=","=")
t_tokenize("()","( )")
t_tokenize("(==)","( == )")
t_tokenize("phil=234","$phil = 234")
t_tokenize("a b","$a $b")
t_tokenize("a\nb","$a nl $b")
t_tokenize("a\n b","$a nl indent $b dedent")
t_tokenize("a\n b\n c", "$a nl indent $b nl indent $c dedent dedent")
t_tokenize("a\n b\n c", "$a nl indent $b nl $c dedent")
t_tokenize("a\n b\n \n c", "$a nl indent $b nl nl indent $c dedent dedent")
t_tokenize("a\n b\nc", "$a nl indent $b nl dedent $c")
t_tokenize("a\n b\n c\nd", "$a nl indent $b nl indent $c nl dedent dedent $d")
t_tokenize("(\n )","( )")
t_tokenize(" x","indent $x dedent")
t_tokenize(" #","")
t_tokenize("None","None")
################################################################################
def t_lisp(t):
if t.type == 'block':
return """{%s}"""%' '.join([t_lisp(tt) for tt in t.items])
if t.type == 'statement':
return """%s;"""%' '.join([t_lisp(tt) for tt in t.items])
if t.items == None: return t.val
args = ''.join([" "+t_lisp(tt) for tt in t.items])
return "("+t.val+args+")"
def t_parse(s,ex=''):
import tokenize, parse
r = ''
tokens = tokenize.tokenize(s)
tree = parse.parse(s,tokens)
r = t_lisp(tree)
#print(s); print(ex); print(r)
assert(r==ex)
if __name__ == '__main__':
t_parse('2+4*3', '(+ 2 (* 4 3))')
t_parse('4*(2+3)', '(* 4 (+ 2 3))')
t_parse('(2+3)*4', '(* (+ 2 3) 4)')
t_parse('1<2', '(< 1 2)')
t_parse('x=3', '(= x 3)')
t_parse('x = 2*3', '(= x (* 2 3))')
t_parse('x = y', '(= x y)')
t_parse('2,3', '(, 2 3)')
t_parse('2,3,4', '(, 2 3 4)')
t_parse('[]', '([])')
t_parse('[1]', '([] 1)')
t_parse('[2,3,4]', '([] 2 3 4)')
t_parse('print(3)', '($ print 3)')
t_parse('print()', '($ print)')
t_parse('print(2,3)', '($ print 2 3)')
t_parse('def fnc():pass', '(def fnc (():) pass)')
t_parse('def fnc(x):pass', '(def fnc ((): x) pass)')
t_parse('def fnc(x,y):pass', '(def fnc ((): x y) pass)')
t_parse('x\ny\nz', '(; x y z)')
t_parse('return x', '(return x)')
t_parse('print(test(2,3))', '($ print ($ test 2 3))')
t_parse('x.y', '(. x y)')
t_parse('get(2).x', '(. ($ get 2) x)')
t_parse('{}', '({})')
t_parse('True', 'True')
t_parse('False', 'False')
t_parse('None', 'None')
t_parse('while 1:pass', '(while 1 pass)')
t_parse('for x in y:pass', '(for x y pass)')
t_parse('print("x")', '($ print x)')
t_parse('if 1: pass', '(if (elif 1 pass))')
t_parse('x = []', '(= x ([]))')
t_parse('x[1]', '(. x 1)')
t_parse('import sdl', '(import sdl)')
t_parse('2 is 3', '(is 2 3)')
t_parse('2 is not 3', '(isnot 2 3)')
t_parse('x is None', '(is x None)')
t_parse('2 is 3 or 4 is 5', '(or (is 2 3) (is 4 5))')
t_parse('e.x == 3 or e.x == 4', '(or (== (. e x) 3) (== (. e x) 4))')
t_parse('if 1==2: 3\nelif 4:5\nelse:6', '(if (elif (== 1 2) 3) (elif 4 5) (else 6))')
t_parse('x = y(2)*3 + y(4)*5', '(= x (+ (* ($ y 2) 3) (* ($ y 4) 5)))')
t_parse('x(1,2)+y(3,4)', '(+ ($ x 1 2) ($ y 3 4))')
t_parse('x(a,b,c[d])', '($ x a b (. c d))')
t_parse('x(1,2)*j+y(3,4)*k+z(5,6)*l', '(+ (+ (* ($ x 1 2) j) (* ($ y 3 4) k)) (* ($ z 5 6) l))')
t_parse('a = b.x/c * 2 - 1', '(= a (- (* (/ (. b x) c) 2) 1))')
t_parse('for x in y: z', '(for x y z)')
t_parse('min(255,n*2)','($ min 255 (* n 2))')
t_parse('c = pal[i*8]','(= c (. pal (* i 8)))')
t_parse('{x:y,a:b}','({} x y a b)')
t_parse('x[1:2:3]','(. x (: 1 2 3))')
if is_tinypy: t_parse('x - -234','(- x -234)')
else: t_parse('x - -234','(- x -234.0)')
t_parse('x - -y','(- x (- 0 y))')
t_parse('x = ((y*4)-2)','(= x (- (* y 4) 2))')
if is_tinypy: t_parse('print([1,2,"OK",4][-3:3][1])','($ print (. (. ([] 1 2 OK 4) (: -3 3)) 1))')
else: t_parse('print([1,2,"OK",4][-3:3][1])','($ print (. (. ([] 1 2 OK 4) (: -3.0 3)) 1))')
t_parse('a,b = 1,2','(= (, a b) (, 1 2))')
t_parse('class C: pass','(class C (methods pass))')
t_parse('def test(*v): pass','(def test ((): (* v)) pass)')
t_parse('def test(**v): pass','(def test ((): (** v)) pass)')
t_parse('test(*v)','($ test (* v))')
t_parse('test(**v)','($ test (** v))')
t_parse('def test(x=y): pass','(def test ((): (= x y)) pass)')
t_parse('test(x=y)','($ test (= x y))')
t_parse('def test(y="K",x="Z"): pass','(def test ((): (= y K) (= x Z)) pass)')
t_parse('return x+y','(return (+ x y))')
t_parse('if "a" is not "b": pass','(if (elif (isnot a b) pass))')
t_parse('z = 0\nfor x in y: pass','(; (= z 0) (for x y pass))')
t_parse('for k in {"OK":0}: pass','(for k ({} OK 0) pass)')
t_parse('print(test(10,3,z=50000,*[200],**{"x":4000}))','($ print ($ test 10 3 (= z 50000) (* ([] 200)) (** ({} x 4000))))')
t_parse('x="OK";print(x)','(; (= x OK) ($ print x))')
t_parse('[(1,3)]','([] (, 1 3))')
t_parse('x[:]','(. x (: None None))')
t_parse('x[:1]','(. x (: None 1))')
t_parse('x[1:]','(. x (: 1 None))')
t_parse('return\nx','(; return x)')
t_parse('"""test"""','test')
t_parse('return a,b','(return (, a b))')
################################################################################
def showerror(cmd, ss, ex, res):
print(cmd)
print("ss : '" + str(ss) + "'")
print("ex : '" + str(ex) + "'")
print("res: '" + str(res) + "'")
def t_render(ss,ex,exact=True):
import tokenize, parse, encode
if not istype(ss,'list'): ss =[ss]
n = 1
for s in ss:
fname = 'tmp'+str(n)+'.tpc'
system_rm(fname)
tokens = tokenize.tokenize(s)
t = parse.parse(s,tokens)
r = encode.encode(fname,s,t)
f = save(fname,r)
n += 1
system_rm('tmp.txt')
cmd = VM + fname + " > tmp.txt"
system(cmd)
res = load(TMP).strip()
#print(ss,ex,res)
if exact:
if res != ex: showerror(cmd, ss, ex, res)
assert(res == ex)
else:
if ex not in res: showerror(cmd, ss, ex, res)
assert(ex in res)
def test_range():
t_render("""print(str(range(4))[:5])""","<list")
t_render("""print(len(range(4)))""","4")
t_render("""print(range(4)[0])""","0")
t_render("""print(range(4)[1])""","1")
t_render("""print(range(4)[-1])""","3")
t_render("""print(str(range(-4))[:5])""","<list")
t_render("""print(len(range(-4)))""","0")
t_render("""print(str(range(0,5,3))[:5])""","<list")
t_render("""print(len(range(0,5,3)))""","2")
t_render("""print(range(0,5,3)[0])""","0")
t_render("""print(range(0,5,3)[1])""","3")
t_render("""print(range(0,5,3)[-1])""","3")
t_render("""print(str(range(5,0,-3))[:5])""","<list")
t_render("""print(len(range(5,0,-3)))""","2")
t_render("""print(range(5,0,-3)[0])""","5")
t_render("""print(range(5,0,-3)[1])""","2")
t_render("""print(range(5,0,-3)[-1])""","2")
t_render("""print(str(range(-8,-4))[:5])""","<list")
t_render("""print(len(range(-8,-4)))""","4")
t_render("""print(range(-8,-4)[0])""","-8")
t_render("""print(range(-8,-4)[1])""","-7")
t_render("""print(range(-8,-4)[-1])""","-5")
t_render("""print(str(range(-4,-8,-1))[:5])""","<list")
t_render("""print(len(range(-4,-8,-1)))""","4")
t_render("""print(range(-4,-8,-1)[0])""","-4")
t_render("""print(range(-4,-8,-1)[1])""","-5")
t_render("""print(range(-4,-8,-1)[-1])""","-7")
t_render("""print(str(range(-4,-8))[:5])""","<list")
t_render("""print(len(range(-4,-8)))""","0")
t_render("""print(str(range(-8,-4,-1))[:5])""","<list")
t_render("""print(len(range(-8,-4,-1)))""","0")
t_render("""print(str(range(0,4,0))[:5])""","<list")
t_render("""print(len(range(0,4,0)))""","0")
if __name__ == '__main__':
t_render('print("hello world")',"hello world")
t_render('print(234)',"234")
t_render('a=3\nprint(a)',"3")
t_render('print(2+3)',"5")
t_render("""
x = 2
x += 3
print(x)
"""
,"5")
t_render("""
x = "OK"
print(x)
"""
,"OK")
t_render("""
a,b = 1,2
print(a+b)
"""
,"3")
t_render("""
x = 1
if x == 1:
print("yes")
""","yes")
t_render("""
if 0 == 1:
print("X")
else:
print("OK")
"""
,"OK")
t_render("""
if 0 == 1:
print("X")
elif 1 == 2:
print("Y")
else:
print("OK")
"""
,"OK")
t_render("""
def test(x,y):
return x+y
r = test(3,5)
print(r)
""","8")
t_render("""
x = 1
t = 0
while x<=5:
t = t+x
x = x+1
print(t)
""","15")
t_render("""
x = {}
x.y = "test"
print(x.y)
""","test")
t_render("""
if "a" is "a":
print("OK")
"""
,"OK")
t_render("""
if "a" is not "b":
print("OK")
"""
,"OK")
t_render("""
if None is None:
print("OK")
"""
,"OK")
t_render("""
if "x" is "x" or "y" is "y":
print("OK")
"""
,"OK")
t_render("""
x = 1
while x < 3:
break
x = x + 1
print(x)
"""
,"1")
t_render("""
x = 1
n = 0
while x < 10:
x = x + 1
if n == 2:
continue
n = n + 1
print(n)
"""
,"2")
t_render("""
def test(x): return x
y = test(1)*2 + test(3)*4 + test(5)*6
print(y)
"""
,"44")
t_render("""
def test(a,b): return a+b
print(test(1,1)+test(1,1))
"""
,"4")
t_render("""
def test(): print("OK")
x = test
x()
"""
,"OK")
t_render("""
x = [2,4,6]
print(x[1])
"""
,"4")
t_render("""
def test(): print("OK")
x = [1,test,2]
x[1]()
"""
,"OK")
t_render("""
z = 0
for x in [1,2,3]:
z += x
print(z)
"""
,"6")
t_render("""
z = 0
for x in range(1,4):
z += x
print(z)
"""
,"6")
t_render("""
x = {'a':'OK'}
print(x.a)
"""
,"OK")
t_render("""print("1234"[1:3])""","23")
t_render("""print("1234"[-3:3])""","23")
t_render("""print([1,2,"OK",4][-3:3][1])""","OK")
t_render("""
n = 0
for x in range(0,10,2):
n += 1
print(n)
"""
,"5")
t_render("""print(max(3,8,2,6))""","8")
t_render("""print(min(3,4,2,6))""","2")
t_render("""for k in {'OK':0}: print(k)""","OK")
t_render("""
X = "OK"
def test(): print(X)
test()
"""
,"OK")
t_render("""
a = 4
def test(z):
for i in range(0,a):
z += i
return z
print(test(1))
"""
,"7")
t_render("""
def test(self): print(self)
fnc = bind(test,"OK")
fnc()
"""
,"OK")
t_render("""
class C:
def __init__(self,data): self.data = data
def print(self): print(self.data)
C("OK").print()
"""
,"OK")
t_render("""
x = [v*v for v in range(0,5)]
print(x[3])
"""
,"9")
t_render("""
t = [[y*10+x for x in range(0,10)] for y in range(0,10)]
print(t[2][3])
"""
,"23")
t_render("""
x = [1]
x.extend([2,3])
print(x[1])
"""
,"2")
#t_render("""
#x = {'a':3}
#merge(x,{'b':4})
#print(x.b)
#"""
#,"4")
t_render("""
x = [1,2,3]
y = copy(x)
y[0] *= 10
print(x[0]+y[0])
"""
,"11")
t_render("""
x = {'a':3}
y = copy(x)
y.a *= 10
print(x.a+y.a)
"""
,"33")
t_render("""
x = {}
y = x['x']
"""
,'KeyError',0)
t_render("""
x = []
y = x[1]
"""
,'KeyError',0)
t_render("""print("O"+"K")""","OK")
t_render("""print("-".join(["O","K"]))""","O-K")
t_render("""print("OK-OK".split("-")[1])""","OK")
t_render("""
def test(*v): return max(v[2])
print(test(*[1,2,"OK"]))
"""
,"OK")
t_render("""
def test(**v): return v['x']
print(test(**{'x':'OK'}))
"""
,"OK")
#t_render("""
#def test(y='K',x='Z'): print(x+y)
#test(x='O')
#"""
#,"OK")
t_render("""
def test(y='K',x='Z'): print(x+y)
test('O')
"""
,"ZO")
#t_render("""
#def test(a,b=2,*c,**d): return a+b+c[0]+d['x']+d['z']
#print(test(10,3,z=50000,*[200],**{'x':4000}))
#"""
#,"54213")
t_render("""print("".join(["O"]+["K"]))""","OK")
t_render("""x="OK";print(x)""","OK")
t_render("""x = [1,2,] ; print(x[1])""","2")
t_render("""a,b,d = [0],0,'OK'; print(d)""","OK")
t_render("""
def test(): raise
try:
test()
except:
print("OK")
""","OK")
t_render("""print("OKx"[:-1])""","OK")
t_render("""print("xOK"[1:])""","OK")
t_render("""a,b = "OK"; print(a+b)""","OK")
t_render("""
def test(a,b):
print a+b[2]
test(1,3)
""","Exception",False)
t_render("""
def test(): raise
test()
""","Exception",False)
t_render(['OK="OK"',"import tmp1\nprint(tmp1.OK)"],"OK")
t_render(['O="O"','K="K"',"import tmp1, tmp2\nprint(tmp1.O+tmp2.K)"],"OK")
t_render("""
def test(): return
x = 1
print(test())
""","None")
t_render("""
def test(): pass
x = 1
print(test())
""","None")
t_render("""
def test():
global x
x = "OK"
test()
print(x)
""","OK")
t_render("""
class X:
pass
y = X()
print("OK")
""","OK")
t_render("""
class X: pass
def test(): y = X()
test()
print("OK")
""","OK")
t_render(["class X: pass\ndef test(): y = X()","import tmp1\ntmp1.test();print('OK')"],"OK")
t_render("print(len([1,2,3]))","3")
t_render('if not "?" in "xyz": print("OK")',"OK")
t_render('print({1:"OK"}[1])',"OK")
t_render('print(len("\0"))',"1")
t_render('print(1 in {1:2})',"1")
t_render('x = {1:2}; del x[1]; print(len(x))','0')
t_render("""
def test(t):
t = "O"+t
print(t)
test("K")
""","OK")
t_render("""print([1,2,3].index(3))""","2")
t_render("""print("1,2,3".split(",").index("3"))""","2")
t_render("""v = [3,2,1]; v.sort(); print(v[0])""","1")
t_render("""print(abs(-5))""","5")
t_render("""print(int(1.234))""","1")
t_render("print(int(round(1.5)))","2")
t_render("print(ord('X'))","88")
t_render("print(ord(chr(128)))","128")
#t_render("print(fsize('LICENSE.txt'))","181")
t_render("print(int('ff',16))","255")
t_render("""
def test(x,y): print(x); return y
test('a',1) or test('b',1) and test('c',0)
""","a")
t_render("def test(): print('OK')\n{'__call__':test}()","OK")
t_render("""
class A:
def __init__(self):
self.a = 'O'
self.b = 'x'
def test(self):
print("KO")
class B(A):
def __init__(self):
A.__init__(self)
self.b = 'K'
def test(self):
print(self.a+self.b)
B().test()
""","OK")
t_render("""
class A:
def test(self):
print(self)
A.test("OK")
""","OK")
t_render("""
def test():
def fnc():
print("OK")
fnc()
test()
""","OK")
t_render("""print("aa..bbb...ccc".replace("..","X"))""","aaXbbbX.ccc")
t_render("""print("..bbb..".replace("..","X"))""","XbbbX")
t_render("""print("234".replace("\r\n","\n"))""","234")
t_render("""print("a\0b".replace("\0","X"))""","aXb")
t_render("""x = "a\0b"; x = x.replace("\0","c"); print(x)""","acb")
t_render("""print(0xff)""","255")
t_render("""x=(1,3);print({x:'OK'}[x])""","OK")
t_render("""x=(1,3);y=(1,3);print({x:'OK'}[y])""","OK")
t_render("""print({(1,3):'OK'}[(1,3)])""","OK")
t_render("def test(): test()\ntest()","Exception",0)
t_render("x = []; x.append(x); print(x<x)","0");
t_render("x = []; x.append(x); print({x:'OK'}[x])","OK")
#t_render("print(float(str(4294967296))==float('4294967296'))","1")
t_render("print(2**3)","8")
#t_render("x = 'OK',\nprint(x[0])","OK")
test_range()
t_render(['v="OK"',"from tmp1 import *\nprint(v)"],"OK")
t_render(['v="OK"',"from tmp1 import v\nprint(v)"],"OK")
t_render(['x="X";y="K"',"x = 'O'\nfrom tmp1 import y\nprint(x+y)"],"OK")
t_render("""
def test(**e):
print(e['x'])
test(x='OK')
""","OK")
# test register allocator
s = "def f():pass\n"+("f()\n"*256)+"print('OK')"
t_render(s,"OK")
t_render("print(2**3)","8")
t_render("print(2*3**2)", "18", False)
t_render("""
def test(**v): return 'OK'
print(test())
"""
,"OK")
t_render("""
def test(**v):
v['x'] = 'OK'
return v
print(test()['x'])
"""
,"OK")
################################################################################
def t_boot(ss,ex,exact=True):
if not istype(ss,'list'): ss =[ss]
n = 1
for s in ss:
fname = 'tmp'+str(n)+'.tpc'
system_rm(fname)
fname = 'tmp'+str(n)+'.py'
save(fname,s)
n += 1
system_rm('tmp.txt')
system(TINYPY+fname+' > tmp.txt')
res = load(TMP).strip()
#print(ss,ex,res)
if exact: assert(res == ex)
else: assert(ex in res)
is_boot = False
try:
assert(is_tinypy == True)
x = compile('x=3','')
is_boot = True
except:
pass
if is_boot == True and __name__ == '__main__':
print("# t_boot")
t_boot(["def test(): print('OK')","import tmp1; tmp1.test()"],"OK")