Ben / Nujel

/* Nujel - Copyright (C) 2020-2022 - Benjamin Vincent Schulenburg
 * This project uses the MIT license, a copy should be included under /LICENSE */
/*
 * In this file you will find different subroutines for casting from one type to
 * another, as well as code for determining which type would be most fitting when
 * you have to for example add two values together.
 */
#ifndef NUJEL_AMALGAMATION
#include "nujel-private.h"
#endif

lVal lValExceptionType(lVal v, lType T){
	char buf[128];
	snprintf(buf, sizeof(buf), "expected argument of type %s, not: ", getTypeSymbolT(T)->c);
	buf[sizeof(buf)-1] = 0;
	return lValException("type-error", buf, v);
}

lVal lValExceptionArity(lVal v, int arity){
	char buf[128];
	snprintf(buf, sizeof(buf), "This subroutine needs %i arguments", arity);
	buf[sizeof(buf)-1] = 0;
	return lValException("arity-error", buf, v);
}

lVal lValExceptionNonNumeric(lVal v){
	return lValException("type-error","Can't calculate with non numeric types", v);
}

lVal lValExceptionFloat(lVal v){
	return lValException("type-error","This function can only be used with floats",v);
}

/* Cast v to be an int without memory allocations, or return fallback */
i64 castToInt(const lVal v, i64 fallback){
	switch(v.type){
		case ltFloat: return v.vFloat;
		case ltInt:   return v.vInt;
		default:      return fallback;
	}
}

/* Cast v to be a bool without memory allocations, or return false */
bool castToBool(const lVal v){
	return (v.type == ltBool ? v.vBool : likely(v.type != ltNil));
}

const char *castToString(const lVal v, const char *fallback){
	return (v.type != ltString) ? fallback : v.vString->data;
}

/* Determine which type has the highest precedence between a and b */
lType lTypecast(const lType a, const lType b){
	if (likely(a == b)){
		return a;
	}
	if((a == ltFloat) || (b == ltFloat)){
		return ltFloat;
	}
	return ltNil;
}

lVal requireInt(lVal v){
	if(unlikely(v.type != ltInt)){
		return lValException("type-error", "Need an :Int", v);
	}
	return v;
}

lVal requireNaturalInt(lVal v){
	if(unlikely(v.type != ltInt)){
		return lValException("type-error", "Need an :Int", v);
	}
	if(unlikely(v.vInt < 0)){
		return lValException("type-error", "Expected a Natural int, not: ", v);
	}
	return v;
}

lVal requireBytecodeArray(lVal v){
	if(unlikely(v.type != ltBytecodeArr)){
		return lValException("type-error", "Need an :BytecodeArray", v);
	}
	return v;
}

lVal requireFloat(lVal v){
	if(likely(v.type == ltFloat)){
		return v;
	} else if(v.type == ltInt){
		return lValFloat(v.vInt);
	} else {
		return lValException("type-error", "Need an :Int or :Float", v);
	}
}

lVal requireArray(lVal v){
	if(unlikely(v.type != ltArray)){
		return lValException("type-error", "Need an :Array", v);
	}
	return v;
}

lVal requireMutableArray(lVal v){
	if(unlikely(v.type != ltArray)){
		return lValException("type-error", "Need an :Array", v);
	}
	if(unlikely(v.vArray->flags & ARRAY_IMMUTABLE)){
		return lValException("type-error", "The provided array is immutable", v);
	}
	return v;
}

lVal requireString(lVal v){
	if(unlikely(v.type != ltString)){
		return lValException("type-error", "Need a :String", v);
	}
	return v;
}

lVal requireBuffer(lVal v){
	if(unlikely(v.type != ltBuffer)){
		return lValException("type-error", "Need a :Buffer", v);
	}
	return v;
}

lVal requireMutableBuffer(lVal v){
	if(unlikely(v.type != ltBuffer)){
		return lValException("type-error", "Need a :Buffer", v);
	}
	if(unlikely(v.vBuffer->flags & BUFFER_IMMUTABLE)){
		return lValException("type-error", "Buffer is immutable", v);
	}
	return v;
}

lVal requireBufferView(lVal v){
	if(unlikely(v.type != ltBufferView)){
		return lValException("type-error", "Need a :BufferView", v);
	}
	return v;
}

lVal requireMutableBufferView(lVal v){
	if(unlikely(v.type != ltBufferView)){
		return lValException("type-error", "Need a :BufferView", v);
	}
	if(unlikely(v.vBufferView->flags & BUFFER_VIEW_IMMUTABLE)){
		return lValException("type-error", "BufferView is immutable", v);
	}
	return v;
}

lVal requireTree(lVal v){
	if(unlikely(v.type != ltTree)){
		return lValException("type-error", "Need a :Tree", v);
	}
	return v;
}

lVal requireMutableTree(lVal v){
	if(unlikely(v.type != ltTree)){
		return lValException("type-error", "Need a :Tree", v);
	}
	if(unlikely(v.vTree->root && v.vTree->root->flags & TREE_IMMUTABLE)){
		return lValException("type-error", "Tree is immutable", v);
	}
	return v;
}

lVal requireSymbol(lVal v){
	if(unlikely(v.type != ltSymbol)){
		return lValException("type-error", "Need a :Symbol", v);
	}
	return v;
}

lVal requireKeyword(lVal v){
	if(unlikely(v.type != ltKeyword)){
		return lValException("type-error", "Need a :Keyword", v);
	}
	return v;
}

lVal requireSymbolic(lVal v){
	if(unlikely((v.type != ltKeyword) && (v.type != ltSymbol))){
		return lValException("type-error", "Need a :Symbol or :Keyword", v);
	}
	return v;
}

lVal optionalSymbolic(lVal v, const lSymbol *fallback){
	if(likely(v.type == ltNil)){
		return lValSymS(fallback);
	}
	return requireSymbolic(v);
}

lVal requireClosure(lVal v){
	if(unlikely(!((v.type == ltLambda)
		|| (v.type == ltEnvironment)
		|| (v.type == ltMacro))))
	{
			return lValException("type-error", "Need a closure, not: ", v);
	}
	return v;
}

lVal requireCallable(lVal v){
	if(unlikely(!((v.type == ltLambda)
		|| (v.type == ltNativeFunc)
		|| (v.type == ltMacro))))
	{
			return lValException("type-error", "Need something callable, not: ", v);
	}
	return v;
}

lVal requireFileHandle(lVal v){
	if(unlikely(v.type != ltFileHandle)) {
		return lValException("type-error", "Need a :FileHandle", v);
	}
	return v;
}

lVal requirePair(lVal v){
	if(unlikely(v.type != ltPair)){
		return lValException("type-error", "Need a :Pair", v);
	}
	return v;
}