Beispiel #1
0
    def handleParsed(m):
        constructor = None
        try:
            if sexprs.getClass(m) == 'Vector':
                return makeVector(m)

            elif sexprs.getClass(m) != 'Pair':

                if sexprs.getClass(m) == 'Symbol':
                    return Variable(m)
                else:
                    return Constant(m)
            elif isSpecialForm(m):
                constructorDict = {'IF':makeIfThenElse,\
                       'LAMBDA':makeLambda,\
                       'DEFINE':makeDefine,\
                       'OR':makeOr,\
                       'quote':makeQuote\
                       }
                constructor = constructorDict[m.car.s]
            elif isDerivedExp(m):
                derivedExps = {'COND':cond_To_If,\
                      'LET':let_To_Application,\
                      'LET*':letStar_To_Let,\
                      'LETREC':letrec_To_Yag,\
                      'AND':and_To_If,\
                      'quasiquote':quasiquote_To_Quote\
                      }

                constructor = derivedExps[m.car.s]
            else:
                constructor = makeApplic
            return constructor(m)
        except Exception as e:
            print(e)
	def handleParsed(m):
		constructor = None
		try:
			if sexprs.getClass(m)=='Vector':
				return makeVector(m)
				
			elif sexprs.getClass(m)!='Pair':

				if sexprs.getClass(m)=='Symbol':
					return Variable(m)
				else:
					return Constant(m)
			elif isSpecialForm(m):
				constructorDict = {'IF':makeIfThenElse,\
								   'LAMBDA':makeLambda,\
								   'DEFINE':makeDefine,\
								   'OR':makeOr,\
								   'quote':makeQuote\
								   }
				constructor = constructorDict[m.car.s]
			elif isDerivedExp(m):
				derivedExps = {'COND':cond_To_If,\
							   'LET':let_To_Application,\
							   'LET*':letStar_To_Let,\
							   'LETREC':letrec_To_Yag,\
							   'AND':and_To_If,\
							   'quasiquote':quasiquote_To_Quote\
							   }

				constructor = derivedExps[m.car.s]
			else:
				constructor = makeApplic
			return constructor(m)
		except Exception as e:
			print(e)
Beispiel #3
0
def schemeList_To_PythonList(lst):
    rest = lst
    py_list = []

    while sexprs.getClass(rest) == "Pair":
        py_list.append(rest.car)
        rest = rest.cdr
    if sexprs.getClass(rest) != 'Nil':
        py_list.append(rest)
    return py_list
def schemeList_To_PythonList(lst):
	rest = lst
	py_list = []

	while sexprs.getClass(rest)=="Pair":
		py_list.append(rest.car)
		rest = rest.cdr
	if sexprs.getClass(rest) != 'Nil':
		py_list.append(rest)
	return py_list
def makeLambda(lambdaExp):
	params = lambdaExp.cdr.car
	params_as_python = schemeList_To_PythonList(lambdaExp.cdr.car)
	parsed_body = AbstractSchemeExpr.handleParsed(lambdaExp.cdr.cdr.car)

	if sexprs.getClass(params)=='Pair':
		if params.isProperList():
			return LambdaSimple(params_as_python ,parsed_body)
		else:
			return LambdaOpt(params_as_python ,parsed_body)
	elif sexprs.getClass(params)=='Nil':
		return LambdaSimple(params_as_python ,parsed_body)
	else:
		return LambdaVar(params ,parsed_body)
Beispiel #6
0
def makeLambda(lambdaExp):
    params = lambdaExp.cdr.car
    params_as_python = schemeList_To_PythonList(lambdaExp.cdr.car)
    parsed_body = AbstractSchemeExpr.handleParsed(lambdaExp.cdr.cdr.car)

    if sexprs.getClass(params) == 'Pair':
        if params.isProperList():
            return LambdaSimple(params_as_python, parsed_body)
        else:
            return LambdaOpt(params_as_python, parsed_body)
    elif sexprs.getClass(params) == 'Nil':
        return LambdaSimple(params_as_python, parsed_body)
    else:
        return LambdaVar(params, parsed_body)
def makeApplic(exp):
	rest = exp
	argList = []
	while sexprs.getClass(rest)=="Pair":
		argList.append(AbstractSchemeExpr.handleParsed(rest.car))
		rest = rest.cdr
	return Applic(argList[0], argList[1:])
def makeOr(exp):
	rest = exp.cdr
	argList = []
	while sexprs.getClass(rest)=="Pair":
		argList.append(AbstractSchemeExpr.handleParsed(rest.car))
		rest = rest.cdr
	return Or(argList)
Beispiel #9
0
def makeOr(exp):
    rest = exp.cdr
    argList = []
    while sexprs.getClass(rest) == "Pair":
        argList.append(AbstractSchemeExpr.handleParsed(rest.car))
        rest = rest.cdr
    return Or(argList)
Beispiel #10
0
def makeApplic(exp):
    rest = exp
    argList = []
    while sexprs.getClass(rest) == "Pair":
        argList.append(AbstractSchemeExpr.handleParsed(rest.car))
        rest = rest.cdr
    return Applic(argList[0], argList[1:])
Beispiel #11
0
def vector_to_pyList(vec):
    t_list = []
    t_list.append(vec.car)
    temp = vec.cdr
    while sexprs.getClass(temp) != 'Nil':
        t_list.append(temp.car)
        temp = temp.cdr
    return t_list
	def visitConstant(self, obj):
		sym_str = str(obj)
		class_type = sexprs.getClass(obj.prop)
		if class_type=='Symbol' and not sym_str in self.symbol_table:
			self.symbol_table[sym_str] = self.memIndex()
		elif class_type == 'Pair':
			l = schemeList_To_PythonList(obj.prop)
			list(map(lambda x: Constant(x).symbol_analysis() , l))
def vector_to_pyList(vec):
	t_list = []
	t_list.append(vec.car)
	temp = vec.cdr
	while sexprs.getClass(temp) != 'Nil':
		t_list.append(temp.car)
		temp = temp.cdr
	return t_list
Beispiel #14
0
 def visitConstant(self, obj):
     sym_str = str(obj)
     class_type = sexprs.getClass(obj.prop)
     if class_type == 'Symbol' and not sym_str in self.symbol_table:
         self.symbol_table[sym_str] = self.memIndex()
     elif class_type == 'Pair':
         l = schemeList_To_PythonList(obj.prop)
         list(map(lambda x: Constant(x).symbol_analysis(), l))
	def visitConstant(self, obj):
		table = ConstantVisitor.CONSTANT_TABLE
		obj_str = str(obj)
		obj_class = sexprs.getClass(obj.prop)

		if obj_class=='HexNumber' or obj_class=='Integer' or obj_class=='Char': 
			if not obj_str in table:
				index = self.incCount(obj_class)
				val = obj.prop.getValue()
				table[obj_str] = {'index':index, 'size':2, 'type':ConstantVisitor.type_table[obj_class], 'val':val}

		elif obj_class =='Fraction':
			if not obj_str in table:
				index = self.incCount(obj_class)
				table[obj_str] = {'index':index, 'size':3, 'type':'T_FRACTION','car':obj.prop.numerator.getValue(),'cdr':obj.prop.denumerator.getValue()}

		elif obj_class=='Pair':
			if ConstantVisitor.top_flag:
				ConstantVisitor.top_flag = False
				top_list = topSort(obj.prop)
				for p in top_list:
					Constant(p).constant_analysis()
				ConstantVisitor.top_flag = True
			else:
				if not obj_str in table:
					index = self.incCount('Pair')
					table[obj_str] = {'index':index,'size':3, 'type':'T_PAIR','car':table[str(obj.prop.car)]['index'],'cdr':table[str(obj.prop.cdr)]['index']}

		elif obj_class=='Vector':
			top_list = vector_to_pyList(obj.prop)
			vars = []
			for i in range(len(top_list)):
				Constant(top_list[i]).constant_analysis()
				vars.append(table[str(top_list[i])]['index'])

			index = ConstantVisitor.const_counter
			table[obj_str] = {'index':index, 'size':len(top_list)+2, 'type':'T_VECTOR', 'val':vars}
			ConstantVisitor.const_counter+=len(top_list)+2


		elif obj_class=='String':
			index = ConstantVisitor.const_counter
			size = len(obj.prop.s)+2
			obj_str = str(obj)
			if not obj_str in table:
				table[obj_str] = {'index':index, 'size':size, 'type':'T_STRING','val':list(map(ord,list(obj.prop.s)))}
				ConstantVisitor.const_counter += size
		
		elif obj_class=='Symbol':
			if not obj_str in table:
				table[obj_str] = {'index':self.incCount('Symbol'), 'size':2, 'type':'T_SYMBOL', 'name':obj_str}
			pass
		else:
			pass

		return ConstantVisitor.CONSTANT_TABLE
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())
Beispiel #17
0
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 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
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 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()))
Beispiel #21
0
def topSort(exp):
    ans = []
    class_name = sexprs.getClass(exp)
    if class_name == 'Constant':
        return exp
    elif class_name == 'Pair':
        ans += topSort(exp.car)
        ans += topSort(exp.cdr)
        ans += [exp]
    elif class_name == 'Vector':
        ans += topSort(exp.car)
        temp = exp.cdr
        while (sexprs.getClass(temp) != 'Nil'):
            ans += topSort(temp.car)
            temp = temp.cdr
            ans += [exp]
    elif class_name == 'Symbol':
        ans += [exp]
    else:
        ans += [exp]

    return ans
def topSort(exp):
	ans = []
	class_name = sexprs.getClass(exp)	
	if class_name == 'Constant':
		return exp
	elif class_name == 'Pair':
		ans += topSort(exp.car)
		ans += topSort(exp.cdr)
		ans += [exp]
	elif class_name == 'Vector':
			ans += topSort(exp.car)
			temp = exp.cdr
			while(sexprs.getClass(temp) != 'Nil'):
				ans += topSort(temp.car)
				temp = temp.cdr
				ans += [exp]
	elif class_name == 'Symbol':
		ans += [exp]
	else:
		ans += [exp]
		
	return ans
Beispiel #23
0
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()))
Beispiel #24
0
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
Beispiel #25
0
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())
Beispiel #26
0
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()))
Beispiel #27
0
    def visitConstant(self, obj):
        table = ConstantVisitor.CONSTANT_TABLE
        obj_str = str(obj)
        obj_class = sexprs.getClass(obj.prop)

        if obj_class == 'HexNumber' or obj_class == 'Integer' or obj_class == 'Char':
            if not obj_str in table:
                index = self.incCount(obj_class)
                val = obj.prop.getValue()
                table[obj_str] = {
                    'index': index,
                    'size': 2,
                    'type': ConstantVisitor.type_table[obj_class],
                    'val': val
                }

        elif obj_class == 'Fraction':
            if not obj_str in table:
                index = self.incCount(obj_class)
                table[obj_str] = {
                    'index': index,
                    'size': 3,
                    'type': 'T_FRACTION',
                    'car': obj.prop.numerator.getValue(),
                    'cdr': obj.prop.denumerator.getValue()
                }

        elif obj_class == 'Pair':
            if ConstantVisitor.top_flag:
                ConstantVisitor.top_flag = False
                top_list = topSort(obj.prop)
                for p in top_list:
                    Constant(p).constant_analysis()
                ConstantVisitor.top_flag = True
            else:
                if not obj_str in table:
                    index = self.incCount('Pair')
                    table[obj_str] = {
                        'index': index,
                        'size': 3,
                        'type': 'T_PAIR',
                        'car': table[str(obj.prop.car)]['index'],
                        'cdr': table[str(obj.prop.cdr)]['index']
                    }

        elif obj_class == 'Vector':
            top_list = vector_to_pyList(obj.prop)
            vars = []
            for i in range(len(top_list)):
                Constant(top_list[i]).constant_analysis()
                vars.append(table[str(top_list[i])]['index'])

            index = ConstantVisitor.const_counter
            table[obj_str] = {
                'index': index,
                'size': len(top_list) + 2,
                'type': 'T_VECTOR',
                'val': vars
            }
            ConstantVisitor.const_counter += len(top_list) + 2

        elif obj_class == 'String':
            index = ConstantVisitor.const_counter
            size = len(obj.prop.s) + 2
            obj_str = str(obj)
            if not obj_str in table:
                table[obj_str] = {
                    'index': index,
                    'size': size,
                    'type': 'T_STRING',
                    'val': list(map(ord, list(obj.prop.s)))
                }
                ConstantVisitor.const_counter += size

        elif obj_class == 'Symbol':
            if not obj_str in table:
                table[obj_str] = {
                    'index': self.incCount('Symbol'),
                    'size': 2,
                    'type': 'T_SYMBOL',
                    'name': obj_str
                }
            pass
        else:
            pass

        return ConstantVisitor.CONSTANT_TABLE
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 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())
Beispiel #30
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))