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 <string.h>

lVal lValBytecodeArray(const lBytecodeOp *ops, int opsLength, lArray *literals){
	lVal ret = lValAlloc(ltBytecodeArr, lBytecodeArrayAlloc(opsLength));
	ret.vBytecodeArr->literals = literals;
	ret.vBytecodeArr->literals->flags |= ARRAY_IMMUTABLE;
	memcpy(ret.vBytecodeArr->data, ops, opsLength);
	return ret;
}

static lVal lnfArrBytecodeArr(lClosure *c, lVal v){
	(void)c;
	lVal car = requireArray(lCar(v));
	if(unlikely(car.type == ltException)){
		return car;
	}
	lArray *arr = car.vArray;
	const int len = arr->length;
	lVal cadr = requireArray(lCadr(v));
	if(unlikely(cadr.type == ltException)){
		return cadr;
	}
	lArray *literals = cadr.vArray;
	lBytecodeOp *ops = malloc(sizeof(lBytecodeOp) * len);
	for(int i=0;i<len;i++){
		lVal t = requireInt(arr->data[i]);
		if(unlikely(t.type == ltException)){
			free(ops);
			return t;
		}
		ops[i] = t.vInt;
	}
	lVal ret = lValBytecodeArray(ops,len,literals);
	free(ops);
	return ret;
}

static lVal lnfBytecodeArrArr(lClosure *c, lVal v){
	(void)c;
	lVal car = requireBytecodeArray(lCar(v));
	if(unlikely(car.type == ltException)){
		return car;
	}
	lBytecodeArray *arr = car.vBytecodeArr;
	const int len = arr->dataEnd - arr->data;

	lVal ret = lValAlloc(ltArray, lArrayAlloc(len));
	for(int i=0;i<len;i++){
		ret.vArray->data[i] = lValInt(arr->data[i]);
	}
	return ret;
}

static lVal lnfBytecodeLiterals(lClosure *c, lVal v){
	(void)c;
	lVal car = requireBytecodeArray(lCar(v));
	if(unlikely(car.type == ltException)){
		return car;
	}
	lBytecodeArray *arr = car.vBytecodeArr;
	if(unlikely(arr->literals == NULL)){return NIL;}
	return lValAlloc(ltArray, arr->literals);
}

static lVal lnfBytecodeArrLength(lClosure *c, lVal v){
	(void)c;
	lVal car = requireBytecodeArray(lCar(v));
	if(unlikely(car.type == ltException)){
		return car;
	}
	lBytecodeArray *arr = car.vBytecodeArr;
	return lValInt(arr->dataEnd - arr->data);
}

void lOperationsBytecode(lClosure *c){
	lAddNativeFunc(c,"arr->bytecode-arr",    "(a)", "Turns an array of bytecode operations into a bytecode array", lnfArrBytecodeArr);
	lAddNativeFunc(c,"bytecode-arr->arr",    "(a)", "Turns an bytecode array into an array of bytecode operations", lnfBytecodeArrArr);
	lAddNativeFunc(c,"bytecode-literals",    "(a)", "Return the literal section of a BCA", lnfBytecodeLiterals);

	lAddNativeFunc(c,"bytecode-array/length","(a)", "Return the length of the bytecode-array A", lnfBytecodeArrLength);
}