Ben / Nujel

/* Nujel - Copyright (C) 2020-2022 - Benjamin Vincent Schulenburg
 * This project uses the MIT license, a copy should be included under /LICENSE */
#ifndef NUJEL_AMALGAMATION
#include "nujel-private.h"
#endif

#include <stdlib.h>
#include <string.h>

static lVal lnfArrLength(lClosure *c, lVal v){
	(void)c;
	lVal car = requireArray(lCar(v));
	if(unlikely(car.type == ltException)){
		return car;
	}
	lArray *arr = car.vArray;
	return lValInt(arr->length);
}

static lVal lnfArrLengthSet(lClosure *c, lVal v){
	(void)c;
	lVal car = requireArray(lCar(v));
	if(unlikely(car.type == ltException)){
		return car;
	}
	lArray *arr = car.vArray;
	lVal lenVal = requireNaturalInt(lCadr(v));
	if(unlikely(lenVal.type == ltException)){
		return lenVal;
	}
	const int length = lenVal.vInt;
	lVal *newData = realloc(arr->data,length * sizeof(lVal));
	if (unlikely(newData == NULL)) {
		free(newData);
		return lValException("out-of-memory", "(array/allocate) couldn't allocate its array", v);
	}
	arr->data = newData;
	if(length > arr->length){
		memset(&arr->data[arr->length], 0, (((size_t)length) - arr->length) * sizeof(lVal *));
	}
	arr->length = length;
	return car;
}

static lVal lnfArrSet(lClosure *c, lVal v){
	(void)c;
	lVal car = requireMutableArray(lCar(v));
	if(unlikely(car.type == ltException)){
		return car;
	}
	lArray *arr = car.vArray;
	lVal keyV = requireInt(lCadr(v));
	if(unlikely(keyV.type == ltException)){
		return keyV;
	}
	const int key = keyV.vInt;
	if((key < 0) || (key >= arr->length)){
		return lValException("out-of-bounds","(array/set!) index provided is out of bounds", v);
	}
	const lVal vt = lCddr(v);
	if(vt.type != ltPair){
		return lValException("type-mismatch","(array/set!) needs a third argument", v);
	}
	arr->data[key] = vt.vList->car;
	return car;
}

static lVal lnfArrAllocate(lClosure *c, lVal v){
	(void)c;
	lVal lenV = requireNaturalInt(lCar(v));
	if(unlikely(lenV.type == ltException)){
		return lenV;
	}
	const int len = lenV.vInt;
	lVal r = lValAlloc(ltArray, lArrayAlloc(len));
	if(unlikely(len && (r.vArray->data == NULL))){
		return lValException("out-of-memory","(array/allocate] couldn't allocate its array", v);
	}
	return r;
}

/* Return the length of the list V */
static int lListLength(lVal v){
	int i = 0;
	for(lVal n = v;(n.type == ltPair) && (n.vList->car.type != ltNil); n = n.vList->cdr){
		i++;
	}
	return i;
}

lVal lnfArrNew(lClosure *c, lVal v){
	(void)c;
	int length = lListLength(v);
	lVal r = lValAlloc(ltArray, lArrayAlloc(length));
	int key = 0;
	for(lVal n = v; n.type == ltPair; n = n.vList->cdr){
		if(unlikely(key >= length)){break;}
		r.vArray->data[key++] = n.vList->car;
	}
	return r;
}

void lOperationsArray(lClosure *c){
	lAddNativeFunc(c,"array/new",      "args",                "Create a new array from ...ARGS",          lnfArrNew);
	lAddNativeFunc(c,"array/allocate", "(size)",              "Allocate a new array of SIZE",             lnfArrAllocate);
	lAddNativeFunc(c,"array/length",   "(array)",             "Return length of ARRAY",                   lnfArrLength);
	lAddNativeFunc(c,"array/length!",  "(array size)",        "Set a new LENGTH for ARRAY",               lnfArrLengthSet);
	lAddNativeFunc(c,"array/set!",     "(array index value)", "Set ARRAY at INDEX to &...VALUES",         lnfArrSet);
}