def andToIf(s_exp):
if isinstance(s_exp,sexprs.Nil):
return sexprs.true()
if isinstance(s_exp,sexprs.Pair):
if isinstance(s_exp.second,sexprs.Nil):
return s_exp.first
return sexprs.Pair(sexprs.Symbol("IF"),sexprs.Pair(s_exp.first,sexprs.Pair(
sexprs.Pair(sexprs.Symbol("AND"),s_exp.second)
,sexprs.Pair(sexprs.false(),sexprs.Nil()))))
def condToIf (s_exp):
if isinstance(s_exp,sexprs.Pair):
if isinstance(s_exp.second, sexprs.Nil):
if isinstance(s_exp.first.first,sexprs.Symbol)and s_exp.first.first.string=="ELSE":
return s_exp.first.second.first
return sexprs.Pair(sexprs.Symbol("IF"), sexprs.Pair(s_exp.first.first, sexprs.Pair(s_exp.first.second.first, sexprs.Nil())))
return sexprs.Pair(sexprs.Symbol("IF"),sexprs.Pair(s_exp.first.first,sexprs.Pair(s_exp.first.second.first,sexprs.Pair(
sexprs.Pair(sexprs.Symbol("COND"),s_exp.second)
,sexprs.Nil()))))
def condToIf_Rec(exp):
test = exp.car.car
action = exp.car.cdr.car
if exp.getLength() == 2:
l = [sexprs.Symbol('IF'), test, action, exp.cdr.car.cdr.car]
return reader.makePair(l, sexprs.Nil())
else:
l = [sexprs.Symbol('IF'), test, action, condToIf_Rec(exp.cdr)]
return reader.makePair(l, sexprs.Nil())
def letToYagApplic(s_exp):
body=s_exp.second.first
if isinstance(s_exp.first,sexprs.Nil):
return body
generatedSymbol=genSym.newGenSym()
param=[];
values=[];
temp=s_exp.first
while isinstance(temp,sexprs.Pair):
param.append(temp.first.first)
values.append(temp.first.second.first)
temp=temp.second
s_param=sexprs.Nil()
for x in reversed (param):
s_param=sexprs.Pair(x,s_param)
s_param=sexprs.Pair(generatedSymbol,s_param)
s_values=[]
for y in values:
s_values.append(y)
firstLambda=sexprs.Pair(
sexprs.Symbol("LAMBDA"),
sexprs.Pair(
s_param,
sexprs.Pair(
body,
sexprs.Nil()
)
)
)
list_of_lambdas=[]
for x in s_values:
list_of_lambdas.append(
sexprs.Pair(
sexprs.Symbol("LAMBDA"),
sexprs.Pair(
s_param,
sexprs.Pair(
x,
sexprs.Nil(
)
)))
)
pairedListofLambdas=sexprs.Nil()
for x in reversed(list_of_lambdas):
pairedListofLambdas=sexprs.Pair(x,pairedListofLambdas)
pairedListofLambdas=sexprs.Pair(firstLambda,pairedListofLambdas)
return sexprs.Pair(
sexprs.Symbol("YAG"),
pairedListofLambdas
)
def QuoteGen(prefix, name):
return ps.parser(pc.pcWord(prefix)) \
.pack(removeCatenStar) \
.delayed_parser(lambda: pSexpr) \
.caten() \
.pack(lambda m: sexprs.Pair(sexprs.Symbol(name), sexprs.Pair(m[1], sexprs.Nil()))) \
.done()
def __init__(self,s_exp):
if isinstance(s_exp,sexprs.Pair):
if isinstance(s_exp.first,sexprs.Pair):
self.var=AbstractSchemeExpr.parse_after_reader(s_exp.first.first)
rest=sexprs.Pair(s_exp.first.second,s_exp.second)
rest=sexprs.Pair(sexprs.Symbol('LAMBDA'),rest)
self.body=AbstractSchemeExpr.parse_after_reader(rest)
else:
self.var=AbstractSchemeExpr.parse_after_reader(s_exp.first)
self.body=AbstractSchemeExpr.parse_after_reader(s_exp.second.first)
def and_To_If_rec(exp):
if sexprs.getClass(exp) == 'Nil':
l = [
sexprs.Symbol('IF'),
sexprs.Boolean(True),
sexprs.Boolean(True),
sexprs.Boolean(True)
]
return reader.makePair(l, sexprs.Nil())
if exp.getLength() == 1:
l = [sexprs.Symbol('IF'), exp.car, exp.car, sexprs.Boolean(False)]
return reader.makePair(l, sexprs.Nil())
else:
l = [
sexprs.Symbol('IF'), exp.car,
and_To_If_rec(exp.cdr),
sexprs.Boolean(False)
]
return reader.makePair(l, sexprs.Nil())
def letStar_To_Let_recursive(bindings, body):
if sexprs.getClass(bindings) == 'Nil':
return body
else:
l = [
sexprs.Symbol('LET'),
reader.makePair([bindings.car], sexprs.Nil()),
letStar_To_Let_recursive(bindings.cdr, body)
]
return reader.makePair(l, sexprs.Nil())
def letrec_To_Yag(exp):
lambda_variabls, lambda_values = get_let_vars(exp.cdr.car), get_let_vals(
exp.cdr.car)
lambda_variabls = sexprs.Pair(gensym(), lambda_variabls)
body = exp.cdr.cdr.car
l = [
reader.makePair([sexprs.Symbol('LAMBDA'), lambda_variabls, body],
sexprs.Nil())
]
while sexprs.getClass(lambda_values) != 'Nil':
lambda_l = [
sexprs.Symbol('LAMBDA'), lambda_variabls, lambda_values.car
]
l.append(reader.makePair(lambda_l, sexprs.Nil()))
lambda_values = lambda_values.cdr
final_l = [sexprs.Symbol('Yag')] + l
return AbstractSchemeExpr.handleParsed(
reader.makePair(final_l, sexprs.Nil()))
def let_To_Application(exp):
lambde_variabls, lambde_values = get_let_vars(exp.cdr.car), get_let_vals(
exp.cdr.car)
lambda_body = exp.cdr.cdr.car
return AbstractSchemeExpr.handleParsed(
sexprs.Pair(
sexprs.Pair(
sexprs.Symbol('LAMBDA'),
sexprs.Pair(lambde_variabls,
sexprs.Pair(lambda_body, sexprs.Nil()))),
lambde_values))
def letStarToApplic(s_exp):
if isinstance(s_exp, sexprs.Pair) and isinstance(s_exp.second, sexprs.Pair):
body = s_exp.second.first
if isinstance(s_exp.first, sexprs.Nil):
return body
if isinstance(s_exp.first, sexprs.Pair):
param = s_exp.first.first.first
value = s_exp.first.first.second.first
rest = s_exp.first.second
return sexprs.Pair(
sexprs.Pair(sexprs.Symbol("LAMBDA"), sexprs.Pair(
sexprs.Pair(param, sexprs.Nil())
, sexprs.Pair(
sexprs.Pair(sexprs.Symbol("LET*"), sexprs.Pair(
rest
, sexprs.Pair(
body
, sexprs.Nil())))
, sexprs.Nil())))
, sexprs.Pair(
value
, sexprs.Nil()))
def makeDefine(exp):
if sexprs.getClass(exp.cdr.car) != 'Pair':
symbol = AbstractSchemeExpr.handleParsed(exp.cdr.car)
value = AbstractSchemeExpr.handleParsed(exp.cdr.cdr.car)
return Def(symbol, value)
else:
symbol = exp.cdr.car.car
lambda_args = exp.cdr.car.cdr
lambda_body = exp.cdr.cdr.car
lambda_components = [sexprs.Symbol('LAMBDA'), lambda_args, lambda_body]
l = [exp.car, symbol, reader.makePair(lambda_components, sexprs.Nil())]
return AbstractSchemeExpr.handleParsed(reader.makePair(
l, sexprs.Nil()))
def QQ_expend(s_exp):
if isinstance(s_exp,sexprs.Pair):
if isinstance(s_exp.first,sexprs.Symbol) and isinstance(s_exp.second,sexprs.Pair):
if s_exp.first.string=="unquote":
return s_exp.second.first
elif s_exp.first.string=="unquote-splicing":
raise (Exception("unquote-splicing here makes no sense!"))
a=s_exp.first
b=s_exp.second
if isinstance(a,sexprs.Pair) and isinstance(a.first,sexprs.Symbol) and a.first.string=="unquote-splicing":
if isinstance(b, sexprs.Nil):
return a.second.first
return sexprs.Pair(sexprs.Symbol('APPEND'), sexprs.Pair(a.second.first
, sexprs.Pair(QQ_expend(b), sexprs.Nil())))
elif isinstance(b,sexprs.Pair) and isinstance(b.first,sexprs.Symbol) and b.first.string=="unquote-splicing":
return sexprs.Pair(sexprs.Symbol('CONS'), sexprs.Pair(QQ_expend(a)
, sexprs.Pair(b.second.first, sexprs.Nil())))
return sexprs.Pair(sexprs.Symbol('CONS'), sexprs.Pair(QQ_expend(a)
, sexprs.Pair(QQ_expend(b), sexprs.Nil())))
elif isinstance(s_exp,sexprs.Vector):
return sexprs.Pair(sexprs.Symbol("LIST->VECTOR") , sexprs.Pair(QQ_expend(vectorToList(s_exp)),sexprs.Nil()))
elif isinstance(s_exp,sexprs.Nil) or isinstance(s_exp,sexprs.Symbol):
return sexprs.Pair(sexprs.Symbol("quote"), sexprs.Pair(s_exp,sexprs.Nil()))
return s_exp
def letToApplic(s_exp):
param=[]
values=[]
temp=s_exp.first
while isinstance(temp,sexprs.Pair):
param.append(temp.first.first)
values.append(temp.first.second.first)
temp=temp.second
body=s_exp.second.first
s_param=sexprs.Nil()
for x in reversed (param):
s_param=sexprs.Pair(x,s_param)
s_values=sexprs.Nil()
for y in reversed(values):
s_values=sexprs.Pair(y,s_values)
return sexprs.Pair(
sexprs.Pair(sexprs.Symbol('LAMBDA'), sexprs.Pair(s_param, sexprs.Pair(body, sexprs.Nil()))),
s_values
)
def quasiquote_To_Quote_rec(exp):
if isUnquote(exp):
return exp.cdr.car
elif isUnquoteSplicing(exp):
raise IllegalQQuoteLocation()
elif sexprs.getClass(exp) == 'Pair':
first = exp.car
rest = exp.cdr
if isUnquoteSplicing(first):
return reader.makePair([
sexprs.Symbol('APPEND'), first.cdr.car,
quasiquote_To_Quote_rec(rest)
], sexprs.Nil())
elif isUnquoteSplicing(rest):
return reader.makePair([
sexprs.Symbol('CONS'),
quasiquote_To_Quote_rec(first), rest.cdr.car
], sexprs.Nil())
else:
return reader.makePair([
sexprs.Symbol('CONS'),
quasiquote_To_Quote_rec(first),
quasiquote_To_Quote_rec(rest)
], sexprs.Nil())
elif sexprs.getClass(exp) == 'Vector':
l = [
sexprs.Symbol('LIST->VECTOR'),
quasiquote_To_Quote_rec(
reader.makePair([sexprs.Symbol('VECTOR->LIST'), exp],
sexprs.Nil()))
]
return reader.makePair(l, sexprs.Nil())
elif sexprs.getClass(exp) == 'Symbol' or sexprs.getClass(exp) == 'Nil':
l = [sexprs.Symbol('quote'), exp]
return reader.makePair(l, sexprs.Nil())
else:
return exp
.parser(pc.pcChar(';')) \
.delayed_parser(lambda : pSexpr) \
.caten() \
.caten() \
.done()
pCommentsAndWhitespaces= ps.parser(pWhiteSpace) \
.parser(pSexprsComment) \
.parser(pLineComment) \
.disjs(3) \
.star() \
.done()
pSymbol= ps.parser(pc.pcEverythingSymbolStar) \
.pack(removeCatenStar) \
.pack(lambda x: sexprs.Symbol(x)) \
.done()
pString= ps.parser(pc.pcChar('"')) \
.parser(pc.pcWord("\l")) \
.parser(pc.pcWord("\"")) \
.parser(pc.pcEverythingStringStar) \
.pack(removeCatenStar) \
.disjs(3) \
.catenRSpecial() \
.parser(pc.pcChar('"')) \
.catenRSpecial() \
.parser(pc.pcChar('"')) \
.parser(pc.pcChar('"')) \
.catenRSpecial() \
.disj() \
.done()
number_p = ps.parser(frac_p) \
.parser(int_p) \
.disj() \
.done() \
symbol_p = ps.parser(pc.pcRange('a','z')) \
.parser(pc.pcRange('A','Z')) \
.parser(pc.pcRange('0','9')) \
.parser(pc.pcOneOf('!$^*-_=+<>/?')) \
.disjs(4) \
.plus() \
.parser(number_p) \
.butNot() \
.pack(lambda m: sexprs.Symbol("".join(m).upper())) \
.done()
'''
string_p = ps.parser(pc.const(lambda x: x=='"')) \
.parser(pc.const(lambda x: x=="\\")) \
.parser(pc.pcOneOf('"nrtfl\\')) \
.caten() \
.pack(lambda m: m[0]+"".join(m[1])) \
.parser(pc.const(lambda x: x!='"')) \
.disj() \
.star() \
.parser(pc.const(lambda x: x=='"')) \
.catens(3) \
.pack(lambda m: sexprs.String("".join(m[1]))) \
.done()
'''
def gensym():
global Gensym_count
ans = 'gen_llokk' + str(Gensym_count)
Gensym_count += 1
return sexprs.Symbol(ans)
.done()
pLetter = ps.const(lambda ch: 'a'<= ch <='z')\
.pack(lambda s: chr(ord(s)-32))\
.const(lambda ch:'A'<= ch <='Z' )\
.disj()\
.done()
symbol = ps.parser(pc.const(lambda ch : '<' <= ch <= '?' or ch == '$' or ch == '!'\
or ('*' <= ch <= '/' and ch != ',' and ch != '.')\
or '^' <= ch <= '_'))\
.const(lambda ch : '0'<= ch <='9' )\
.parser(pLetter)\
.disjs(3)\
.plus()\
.pack(lambda s : classes.Symbol("".join(s)))\
.done()
pString = ps.word('\"')\
.const(lambda ch: ch!='\"')\
.star()\
.word('\"')\
.caten()\
.pack(lambda s: "".join(s[0]+s[1]))\
.star()\
.caten()\
.pack(lambda s: (classes.String(s[0][0]+"".join(s[1]))) )\
.done()
pNamedChar = ps.wordCI('newline')\
.wordCI('return')\
def create_const_table(s_exp):
exist=False
notExist=True
if isinstance(s_exp,AbstractLambda):
s_exp.body = Const_table.create_const_table(s_exp.body)
elif isinstance(s_exp,Def):
s_exp.var = Const_table.create_const_table(sexprs.Symbol(s_exp.var.Var.string.upper()))
s_exp.body = Const_table.create_const_table(s_exp.body)
elif isinstance(s_exp,Or):
for x in s_exp.param:
x = Const_table.create_const_table(x)
elif isinstance(s_exp,Constant):
s_exp.con = Const_table.create_const_table(s_exp.con)
s_exp.ref=s_exp.con.ref
if isinstance(s_exp,sexprs.Void):
s_exp.ref=1
elif isinstance(s_exp,sexprs.Nil):
s_exp.ref=2
elif isinstance(s_exp,sexprs.true):
s_exp.ref=3
elif isinstance(s_exp,sexprs.false):
s_exp.ref=5
elif isinstance(s_exp,IfThenElse):
Const_table.create_const_table(s_exp.Condition)
Const_table.create_const_table(s_exp.Then)
Const_table.create_const_table(s_exp.Else)
elif isinstance(s_exp,Applic):
Const_table.create_const_table(s_exp.applic)
for x in s_exp.param:
Const_table.create_const_table(x)
elif isinstance(s_exp,VarFree):
s_exp.Var=Const_table.create_const_table(s_exp.Var)
elif isinstance (s_exp,sexprs.Char):
for x in range(1,len(Const_table.const_table)):
if Const_table.const_table[x] == 'T_CHAR':
if Const_table.const_table[x+1] == s_exp.char:
notExist=False
s_exp.ref=x
if notExist:
s_exp.ref=Const_table.const_table[0]
Const_table.const_table.append('T_CHAR')
if s_exp.char == 'newline':
Const_table.const_table.append(10)
elif s_exp.char == 'page':
Const_table.const_table.append(12)
elif s_exp.char == 'return':
Const_table.const_table.append(13)
elif s_exp.char == 'tab':
Const_table.const_table.append(9)
elif s_exp.char == 'lambda':
Const_table.const_table.append(0x03bb)
else:
Const_table.const_table.append(ord(s_exp.char))
Const_table.const_table[0]+=2
elif isinstance (s_exp,sexprs.Symbol):
temp = sexprs.String(s_exp.string);
temp= Const_table.create_const_table(temp);
for x in range(1,len(Const_table.const_table)):
if Const_table.const_table[x] == 'T_SYMBOL':
if Const_table.const_table[x+1] == temp.ref:
notExist=False
s_exp.ref=x
if notExist:
s_exp.ref=Const_table.const_table[0]
Const_table.const_table.append('T_SYMBOL')
Const_table.const_table.append(temp.ref)
Const_table.const_table[0]+=2
elif isinstance (s_exp,sexprs.String):
for x in range(1,len(Const_table.const_table)):
if Const_table.const_table[x] == 'T_STRING':
temp_symbol=""
for i in range(1,int(Const_table.const_table[x+1]+1)):
temp_symbol+=chr(Const_table.const_table[x+1+i])
if temp_symbol == s_exp.string:
notExist=False
s_exp.ref=x
if notExist:
s_exp.ref=Const_table.const_table[0]
Const_table.const_table.append('T_STRING')
Const_table.const_table.append(s_exp.length)
Const_table.const_table[0]+=2+s_exp.length
for x in range (0,s_exp.length):
Const_table.const_table.append(ord(s_exp.string[x]))
elif isinstance(s_exp,sexprs.Integer):
for x in range(1,len(Const_table.const_table)):
if Const_table.const_table[x] == 'T_INTEGER':
if Const_table.const_table[x+1] == s_exp.number:
exist = True
s_exp.ref=x
if not exist:
s_exp.ref=Const_table.const_table[0]
Const_table.const_table.append('T_INTEGER')
Const_table.const_table.append(s_exp.number)
Const_table.const_table[0]+=2
elif isinstance (s_exp,sexprs.Fraction):
for x in range(1,len(Const_table.const_table)):
if Const_table.const_table[x] == 'T_FRACTION':
if Const_table.const_table[x+1] == s_exp.nume:
if Const_table.const_table[x+2] == s_exp.deno:
exist = True
s_exp.ref=x
if not exist:
s_exp.ref=Const_table.const_table[0]
Const_table.const_table.append('T_FRACTION')
Const_table.const_table.append(s_exp.nume)
Const_table.const_table.append(s_exp.deno)
Const_table.const_table[0]+=3
elif isinstance(s_exp,sexprs.Pair):
s_exp.second = Const_table.create_const_table(s_exp.second)
s_exp.first = Const_table.create_const_table(s_exp.first)
for x in range(1,len(Const_table.const_table)):
if Const_table.const_table[x] == 'T_PAIR':
if Const_table.const_table[x+1] == s_exp.first.ref:
if Const_table.const_table[x+2] == s_exp.second.ref:
exist = True
s_exp.ref=x
if not exist:
s_exp.ref=Const_table.const_table[0]
Const_table.const_table.append('T_PAIR')
Const_table.const_table.append(s_exp.first.ref)
Const_table.const_table.append(s_exp.second.ref)
Const_table.const_table[0] += 3
elif isinstance(s_exp,sexprs.Vector):
for x in range (0,len(s_exp.elements)):
s_exp.elements[x]=Const_table.create_const_table(s_exp.elements[x])
for x in range(1,len(Const_table.const_table)):
if Const_table.const_table[x] == 'T_VECTOR':
if Const_table.const_table[x+1] == s_exp.length:
all=True
for y in range (0,len(s_exp.elements)):
if Const_table.const_table[x+y+2] != s_exp.elements[y].ref:
all=False
if all:
exist = True
s_exp.ref=x
if not exist:
Const_table.const_table.append('T_VECTOR')
Const_table.const_table.append(s_exp.length)
s_exp.ref=Const_table.const_table[0]
start_pos=Const_table.const_table[0]+2
Const_table.const_table[0] += 2 + s_exp.length
for i in range (0,s_exp.length):
Const_table.const_table.append(0)
i=0;
for x in s_exp.elements:
temp= Const_table.create_const_table(x)
Const_table.const_table[start_pos+i]=(temp.ref)
i=i+1
return s_exp
def newGenSym():
res="@"+'G'+str(genSym.count)
genSym.count=genSym.count+1
return sexprs.Symbol(res)