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 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 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 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 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 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 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 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 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 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 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.const(lambda ch: ch > ' ')) \
.caten() \
.pack(lambda m: sexprs.Char(m[1])) \
.done()
char_p = ps.parser(named_char_p) \
.parser(hex_char_p) \
.parser(visible_char_p) \
.disjs(3) \
.done()
nil_p = ps.parser(pc.const(lambda x: x=='(')) \
.parser(p_skip) \
.parser(pc.const(lambda x: x==')')) \
.catens(3) \
.pack(lambda m: sexprs.Nil()) \
.done()
proper_p = ps.parser(pc.const(lambda x: x=='(')) \
.delayed_parser(lambda: pSexpr) \
.star() \
.parser(pc.const(lambda x: x==')')) \
.catens(3) \
.pack(lambda m: list_to_pair(m[1],sexprs.Nil())) \
.done()
improper_p = ps.parser(pc.const(lambda x: x=='(')) \
.delayed_parser(lambda: pSexpr) \
.plus() \
.parser(pc.const(lambda x: x=='.')) \
.delayed_parser(lambda: pSexpr) \
.done()
pFractions = ps.parser(pSignNumber) \
.parser(pc.pcWord('/')) \
.caten() \
.parser(pPositivNumber) \
.caten() \
.pack(lambda x: sexprs.Fraction(x[0][0],x[1] )) \
.done()
########################################### end of number part ###########################################
pNil = ps.parser(pc.pcWord('(')) \
.parser(pCommentsAndWhitespaces) \
.parser(pc.pcWord(')')) \
.catens(3) \
.pack(lambda x: sexprs.Nil()) \
.done()
########################################### end of nil part ###########################################
pSexpr = ps.parser(pCommentsAndWhitespaces) \
.delayed_parser(lambda : pProperList) \
.delayed_parser(lambda : pImproperList) \
.delayed_parser(lambda : pVector) \
.parser(pBoolean) \
.parser(pFractions) \
.parser(pSignNumber) \
.parser(pNil) \
.parser(pQuote) \
.parser(pQuasiQuote) \
.parser(pUnquote) \
.parser(pHexChar)\
.parser(pVisibleChar)\
.disjs(3)\
.caten()\
.pack(lambda s: s[1])\
.done()
pNil = ps.word('(')\
.parser(singleWhiteSpace)\
.parser(SexprComment)\
.disj()\
.star()\
.word(')')\
.catens(3)\
.pack(lambda s: classes.Nil())\
.done()
properList = ps.parser(pc.pcWord('('))\
.delayed_parser(lambda : pSexpr)\
.plus()\
.parser(pc.pcWord(')'))\
.catens(3)\
.pack(lambda m: makePair(m[1],classes.Nil()) )\
.done()
improperList = ps.parser(pc.pcWord('('))\
.delayed_parser(lambda : pSexpr)\
.plus()\
.parser(pc.pcWord('.'))\
.pack(lambda c : c[0])\
def get_let_vals(exp):
if sexprs.getClass(exp) == 'Nil':
return sexprs.Nil()
else:
return sexprs.Pair(exp.car.cdr.car, get_let_vals(exp.cdr))
def vectorToList(s_exp):
elem=s_exp.elements
if len(elem)==0:
return sexprs.Nil()
return sexprs.Pair(elem[0],vectorToList(elem[1:]))
