cirilisp/internals.c

#include <string.h>

#include "util.h"
#include "eval.h"

int allNums(object list)
{
	object *currentCell = &list;
	while (TYPE(*currentCell) != nilObject)
	{
		if (TYPE(CAR(*currentCell)) != numberObject)
		{
			return 0;
		}
		currentCell = &CDR(*currentCell);
	}
	return 1;
}

int allSyms(object list)
{
	object *currentCell = &list;
	while (TYPE(*currentCell) != nilObject)
	{
		if (TYPE(CAR(*currentCell)) != symbolObject)
		{
			return 0;
		}
		currentCell = &CDR(*currentCell);
	}
	return 1;
}



object addInt(object parameters)
{
	object result;
	TYPE(result) = numberObject;

	if (!allNums(parameters))
	{
		SIGERR(typeError);
	}
	else if (listLength(parameters) == 0)
	{
		result = longlongToNumber(0LL);
	}
	else
	{
		object first, rest;
		first = CAR(parameters);
		rest = addInt(CDR(parameters));

		result = plusNum(first, rest);
	}

	return result;
}

object subtractInt(object parameters)
{
	object result;
	TYPE(result) = numberObject;

	if (!allNums(parameters))
	{
		SIGERR(typeError);
	}
	else if (listLength(parameters) == 0)
	{
		SIGERR(argumentNumberError);
	}
	else if (listLength(parameters) == 1)
	{
		result = minusNum(CAR(parameters));
	}
	else
	{
		result = plusNum(CAR(parameters),
				minusNum(addInt(CDR(parameters))));
	}

	return result;
}

object multiplyInt(object parameters)
{
	object result;
	TYPE(result) = numberObject;

	if (!allNums(parameters))
	{
		SIGERR(typeError);
	}
	else if (listLength(parameters) == 0)
	{
		result = longlongToNumber(1LL);
	}
	else
	{
		object first, rest;
		first = CAR(parameters);
		rest = multiplyInt(CDR(parameters));

		result = timesNum(first,rest);
	}

	return result;
}

object divideInt(object parameters)
{
	object result;
	TYPE(result) = numberObject;

	if (!allNums(parameters))
	{
		SIGERR(typeError);
	}
	else if (listLength(parameters) == 0)
	{
		SIGERR(argumentNumberError);
	}
	else if (listLength(parameters) == 1)
	{
		result = inverseNum(CAR(parameters));
	}
	else
	{
		object check = inverseNum(multiplyInt(CDR(parameters)));
		if (TYPE(check) != errorObject)
		{
			result = timesNum(CAR(parameters),
				inverseNum(multiplyInt(CDR(parameters))));
		}
		else
		{
			result = check;
		}
		result = shortenFractionNum(result);
	}

	return result;
}

object exactToInexactInt(object parameters)
{
	object result;

	if (listLength(parameters) != 1)
	{
		SIGERR(argumentNumberError);
	}
	else if (TYPE(CAR(parameters)) != numberObject)
	{
		SIGERR(typeError);
	}
	else
	{
		result = exactToInexactNum(CAR(parameters));
	}

	return result;
}

object inexactToExactInt(object parameters)
{
	object result;

	if (listLength(parameters) != 1)
	{
		SIGERR(argumentNumberError);
	}
	else if (TYPE(CAR(parameters)) != numberObject)
	{
		SIGERR(typeError);
	}
	else
	{
		result = inexactToExactNum(CAR(parameters));
	}

	return result;
}

object quoteInt(object parameters)
{
	object result;
	if (listLength(parameters) != 1)
	{
		SIGERR(argumentNumberError);
	}
	else
	{
		result = copyObject(CAR(parameters));
	}
	return result;
}

int validArgumentList(object list)
{
	if (!properList(list) || !allSyms(list))
	{
		return 0;
	}
	else
	{
		int allUniqueSyms = 1;
		object *currentSymbol1 = &list;
		while (TYPE(*currentSymbol1) != nilObject)
		{
			object *currentSymbol2 = &CDR(*currentSymbol1);
			while (TYPE(*currentSymbol2) != nilObject)
			{
				if (!strcmp(SYM(CAR(*currentSymbol1)),
					SYM(CAR(*currentSymbol2))))
				{
					allUniqueSyms = 0;
					goto breakloop;
				}
				currentSymbol2 = &CDR(*currentSymbol2);
			}
			currentSymbol1 = &CDR(*currentSymbol1);
		}
breakloop:
		return allUniqueSyms;
	}
}

object lambdaInt(object parameters, env currentEnv)
{
	object result;
	if (listLength(parameters) < 2)
	{
		SIGERR(argumentNumberError);
	}
	else if (!validArgumentList(CAR(parameters)))
	{
		SIGERR(typeError);
	}
	else
	{
		TYPE(result) = procedureObject;
		PROC(result) = createProcedure();
		PROC_TYPE(result) = compoundProc;
		PROC_COMP_ARGS(result) = copyObject(CAR(parameters));
		PROC_COMP_BODY(result) = copyObject(CDR(parameters));
		PROC_COMP_ENV(result) = currentEnv;
	}

	return result;
}

object defineInt(object parameters, env currentEnv)
{
	object result, value;
	if (listLength(parameters) == 0)
	{
		SIGERR(argumentNumberError);
	}
	else if (TYPE(CAR(parameters)) == symbolObject)
	{
		if (listLength(parameters) == 2)
		{
			result = copyObject(CAR(parameters));
			value = eval(copyObject(CAR(CDR(parameters))),
					currentEnv);
			if (TYPE(value) == errorObject)
			{
				SIGERR(ERR(value));
			}
			addSymbolVariable(SYM(result), value, currentEnv);
		}
		else
		{
			SIGERR(argumentNumberError);
		}
	}
	else if (TYPE(CAR(parameters)) == consObject)
	{
		if (listLength(parameters) >= 2)
		{
			if (allSyms(CAR(parameters)))
			{
				result = copyObject(CAR(CAR(parameters)));
				object args = copyObject(CDR(CAR(parameters)));
				deleteObject(CAR(parameters));
				CAR(parameters) = copyObject(args);
				deleteObject(args);
				object proc = lambdaInt(parameters,
					currentEnv);
				addSymbolVariable(SYM(result), proc,
					currentEnv);
			}
			else
			{
				SIGERR(typeError);
			}
		}
		else
		{
			SIGERR(argumentNumberError);
		}
	}
	else
	{
		SIGERR(typeError);
	}

	return result;
}

object lessInt(object parameters)
{
	if (!allNums(parameters))
	{
		SIGERR(typeError);
	}

	if (listLength(parameters) == 0 || listLength(parameters) == 1)
	{
		return intToBool(1);
	}

	int resultInt = 1;
	object *current = &parameters;
	while (TYPE(CDR(*current)) != nilObject)
	{
		if (cmp(CAR(*current), CAR(CDR(*current))) >= 0)
		{
			resultInt = 0;
			break;
		}
		current = &CDR(*current);
	}

	object result;
	TYPE(result) = boolObject;
	BOOL(result) = resultInt;
	return result;
}

object greaterInt(object parameters)
{
	if (!allNums(parameters))
	{
		SIGERR(typeError);
	}

	if (listLength(parameters) == 0 || listLength(parameters) == 1)
	{
		return intToBool(1);
	}

	int resultInt = 1;
	object *current = &parameters;
	while (TYPE(CDR(*current)) != nilObject)
	{
		if (cmp(CAR(*current), CAR(CDR(*current))) <= 0)
		{
			resultInt = 0;
			break;
		}
		current = &CDR(*current);
	}

	object result;
	TYPE(result) = boolObject;
	BOOL(result) = resultInt;
	return result;
}

object ifInt(object parameters, env currentEnv)
{
	object predicate, result;
	switch (listLength(parameters))
	{
	case 2:
		predicate = eval(copyObject(CAR(parameters)), currentEnv);
		if (TYPE(predicate) == errorObject)
		{
			SIGERR(ERR(predicate));
		}

		if (TYPE(predicate) == boolObject && BOOL(predicate) == 0)
		{
			TYPE(result) = unspecifiedObject;
		}
		else
		{
			result = eval(copyObject(CAR(CDR(parameters))),
				currentEnv);
		}

		if (TYPE(result) == errorObject)
		{
			SIGERR(ERR(result));
		}
		break;
	case 3:
		predicate = eval(copyObject(CAR(parameters)), currentEnv);
		if (TYPE(predicate) == errorObject)
		{
			SIGERR(ERR(predicate));
		}

		if (TYPE(predicate) == boolObject && BOOL(predicate) == 0)
		{
			result = eval(copyObject(CAR(CDR(CDR(parameters)))),
				currentEnv);
		}
		else
		{
			result = eval(copyObject(CAR(CDR(parameters))),
				currentEnv);
		}

		if (TYPE(result) == errorObject)
		{
			SIGERR(ERR(result));
		}
		break;
	default:
		SIGERR(argumentNumberError);
	}

	return result;
}