gdjn  Diff

(* [ʞ] src/janet-lang.gcd vi:ft=d
 *  ~ lexi hale <lexi@hale.su>
 *  🄯 AGPLv3
 *  ? implement the godot-janet interface
 *)




use <janet.h>;

class JanetLang is ScriptLanguageExtension {
	use <stdio.h>;
	use "util.h";

	new {};



	impl _get_name() -> string {
		gd_string j;
		_t(string).newWithUtf8Chars(&j, "Janet");
		return j;
	};

................................................................................
			l("for"), l("forv"), l("forever"),
			l("seq"), l("catseq"),
			l("map"), l("mapcat"),
			l("find"),
			l("array"), l("tuple"),
			l("string"), l("buffer"),
			l("table"), l("struct"),





			(* et cetera ad nauseam *)
		};
		gd_packedStringArray r = {};
		_t(packedStringArray).empty(&r, nullptr);
		for (size_t i = 0; i < _sz(words); ++i) {
			gdu_array_string_pushPtr(&r, words[i].w, words[i].sz);
		}
................................................................................
		return janscr -> self;
	};
	impl _create_script() -> ref Object {
		auto janscr = gdjn_class_JanetScriptText_new();
		return janscr -> self;
	};




	impl _get_documentation() -> array[dictionary] {
		gd_array a = {};
		_t(array).ref(&a, &gdjn_ctx -> gd.dox);
		return gdjn_ctx -> gd.dox;

















	};

	impl _init() { /* (* "deprecated" but i still have to impl it?? *) */ }; 
	impl _frame() {};
	impl _thread_enter() { janet_init(); };
	impl _thread_exit() { janet_deinit(); };
	impl _finish() {};
................................................................................
		_t(dictionary).empty(&dict,nullptr);
		return dict;
	};
};

class JanetScript is ScriptExtension {
	var as string: path;


	new {
		_t(string).empty(&me -> path, nullptr);

	};
	del {
		_t(string).dtor(&me -> path);

	};

	impl _create_instance(array[variant] argv, int argc, ref Object owner, bool refCounted, int error) -> ref Object {






























	};
	impl _get_language() -> ref ScriptLanguage {
		return gdjn_ctx -> gd.janetLang_inst;
	};
	impl _set_path(string path, bool takeOver) {
		if (takeOver) {
			_t(string).dtor(&me -> path);
			me -> path = path;
		} else {
			_t(string).dtor(&me -> path);
			/* _t(string).copy(&me -> path, (void const*[]) {&path}); */
			me -> path = gdu_string_dup(&path);
		}
	};
	impl _get_base_script() -> ref Script {
		return nullptr;
	};
	impl _has_static_method(string-name method) -> bool {
		return false;
	};
................................................................................
	impl _get_global_name(string-name id) -> string-name {
		return gdu_sym_null();
	};
	impl _is_abstract() -> bool {
		return false; (* TODO abuse for non-class scripts? *)
	};
	impl _get_instance_base_type() -> string-name {
		return _gdu_intern("Object");
	};
	impl _is_valid() -> bool {
		return true;
	};
	impl _get_documentation() -> array[dictionary] {
		gd_array dox;
		_t(array).empty(&dox, nullptr);
		auto empty = gdu_sym_null();
		_t(array).setTyped(&dox,
			GDEXTENSION_VARIANT_TYPE_DICTIONARY, &empty, &empty);
		_t(stringName).dtor(&empty);
		return dox;
	};














};

class JanetScriptText extends JanetScript {
	var as string: src;
	new {
		_t(string).empty(&me -> src, nullptr);
	};
	del {
		_t(string).dtor(&me -> src);
	};

	impl _has_source_code() -> bool   { return true; };
	impl _get_source_code() -> string {

		auto d = gdu_string_dup(&me -> src);
		return d;
	};
	impl _set_source_code(string s) {




		_t(string).dtor(&me -> src);
		_t(string).copy(&me -> src, (void const*[]) {&s});
	};
	impl _reload(bool keepState) -> int (* Error *) {
		(* TODO *)
		return gd_Error_ok;























	};
};

import {
	typedef struct gdjn_janet_image {
		size_t   sz;
		uint8_t* buf;

(* [ʞ] src/janet-lang.gcd vi:ft=d
 *  ~ lexi hale <lexi@hale.su>
 *  🄯 AGPLv3
 *  ? implement the godot-janet interface
 *)

import "type.h";
import "util-gd.h";
use    "util-jn.h";
use    <janet.h>;

class JanetLang is ScriptLanguageExtension {
	(* use <stdio.h>; *)


	new {};

	(* var as array[ref Object]: placeholders; *)

	impl _get_name() -> string {
		gd_string j;
		_t(string).newWithUtf8Chars(&j, "Janet");
		return j;
	};

................................................................................
			l("for"), l("forv"), l("forever"),
			l("seq"), l("catseq"),
			l("map"), l("mapcat"),
			l("find"),
			l("array"), l("tuple"),
			l("string"), l("buffer"),
			l("table"), l("struct"),
			l("print"), l("prin"), l("pp"),
			(* gdjn macros *)
			l("defm"), l("defm-"),
			l("class"), l("defclass"), l("defclass-"),
			l("prop"),
			(* et cetera ad nauseam *)
		};
		gd_packedStringArray r = {};
		_t(packedStringArray).empty(&r, nullptr);
		for (size_t i = 0; i < _sz(words); ++i) {
			gdu_array_string_pushPtr(&r, words[i].w, words[i].sz);
		}
................................................................................
		return janscr -> self;
	};
	impl _create_script() -> ref Object {
		auto janscr = gdjn_class_JanetScriptText_new();
		return janscr -> self;
	};

	use {
		#define _typeCode(x) gd_ScriptLanguageExtension_LookupResultType_lookupResult##x
	};
	impl _get_documentation() -> array[dictionary] {
		gd_array a = {};
		_t(array).ref(&a, &gdjn_ctx -> gd.dox);
		return gdjn_ctx -> gd.dox;
	};
	impl _lookup_code
	(	string code;
		string symbol;
		string path;
		ref Object owner;
	) -> dictionary {
		gd_dictionary d;
		_t(dictionary).empty(&d, nullptr);
		gd_variant v;

		v = gd_variant_of_int(gd_Error_failed);
		gdu_setKey(&d, _pstrLit("result"), &v);

		v = gd_variant_of_int(_typeCode(ScriptLocation));
		gdu_setKey(&d, _pstrLit("type"), &v);
		return d;
	};

	impl _init() { /* (* "deprecated" but i still have to impl it?? *) */ }; 
	impl _frame() {};
	impl _thread_enter() { janet_init(); };
	impl _thread_exit() { janet_deinit(); };
	impl _finish() {};
................................................................................
		_t(dictionary).empty(&dict,nullptr);
		return dict;
	};
};

class JanetScript is ScriptExtension {
	var as string: path;
	var JanetTable*: env;
	
	new {
		_t(string).empty(&me -> path, nullptr);
		me -> env = nullptr;
	};
	del {
		_t(string).dtor(&me -> path);
		if (me -> env) janet_gcunroot(janet_wrap_table(me -> env));
	};


	class BaseInstance is Object {
		var as ref JanetScript: script;
		del {
			gd_refCounted_unreference(me -> script);
			printf("del script instance\n");
		};
	};
	class Instance extends JanetScript_BaseInstance {
	};
	class Placeholder extends JanetScript_BaseInstance {
	};

	(* impl _create_instance(array[variant] argv, int argc, ref Object owner, bool refCounted, int error) -> ref Object { *)
	impl _can_instantiate() -> bool {
		if (me -> env == nullptr) return false;
		return true; // FIXME
	};
	impl _instance_create(ref Object obj) -> ref Object {
		auto ci = gdjn_class_JanetScript_Instance_new();
		printf("made new script instance\n");
		ci -> super.script = me;
		gd_refCounted_reference(me -> self);
		return ci;
	};
	impl _placeholder_instance_create(ref Object obj) -> ref Object {
		auto ci = gdjn_class_JanetScript_Placeholder_new();
		printf("made new script placeholder\n");
		ci -> super.script = me;
		gd_refCounted_reference(me -> self);
		return ci;
	};
	impl _get_language() -> ref ScriptLanguage {
		return gdjn_ctx -> gd.janetLang_inst;
	};
	impl _set_path(string path, bool takeOver) {

		_t(string).dtor(&me -> path);



		/* _t(string).copy(&me -> path, (void const*[]) {&path}); */
		me -> path = gdu_string_dup(&path);

	};
	impl _get_base_script() -> ref Script {
		return nullptr;
	};
	impl _has_static_method(string-name method) -> bool {
		return false;
	};
................................................................................
	impl _get_global_name(string-name id) -> string-name {
		return gdu_sym_null();
	};
	impl _is_abstract() -> bool {
		return false; (* TODO abuse for non-class scripts? *)
	};
	impl _get_instance_base_type() -> string-name {
		return _gdu_intern("ScriptExtension");
	};
	impl _is_valid() -> bool {
		return true;
	};
	impl _get_documentation() -> array[dictionary] {
		gd_array dox;
		_t(array).empty(&dox, nullptr);
		auto empty = gdu_sym_null();
		_t(array).setTyped(&dox,
			GDEXTENSION_VARIANT_TYPE_DICTIONARY, &empty, &empty);
		_t(stringName).dtor(&empty);
		return dox;
	};
	
	(*
	impl _update_exports() {

	};
	impl _placeholder_instance_create
	(ref Object forObj) -> ref Object {
		
	};
	impl _placeholder_erased
	(ref Object ph) {
	};
	*)
		
};

class JanetScriptText extends JanetScript {
	var pstr: src;
	new {
		me -> src = (pstr){};
	};
	del {
		_drop(me -> src);
	};

	impl _has_source_code() -> bool   { return true; };
	impl _get_source_code() -> string {
		return gdu_str_sz(me -> src.v, me -> src.sz);
		/* auto d = gdu_string_dup(&me -> src); */
		/* return d; */
	};
	impl _set_source_code(string s) {
		_drop(me -> src);
		me -> src = gdu_string_pdup(&s);
		/* printf("janet: set script %d %s\n", (int)me -> src.sz, me -> src.v); */
		gdjn_class_JanetScriptText_method__reload(me, false);
		/* _t(string).dtor(&me -> src); */
		/* _t(string).copy(&me -> src, (void const*[]) {&s}); */
	};
	impl _reload(bool keepState) -> int (* Error *) {

		auto errorCode = gd_Error_ok;
		if (me -> super.env)
			janet_gcunroot(janet_wrap_table(me -> super.env));
		me -> super.env = nullptr;
		pstr path = _gdu_string_stackp(&me -> super.path);

		auto cls = jnu_table_extend(gdjn_ctx -> jn.api, 8);
		janet_gcroot(janet_wrap_table(cls));
		/* printf("janet: doing bytes %d %s\n", (int)me -> src.sz, me -> src.v); */
		int e = janet_dobytes(cls,
			(uint8_t const*)me -> src.v, me -> src.sz,
			path.v, nullptr);
		(* we discard the return value; the environment is what
		 * we're really interested in here *)
		/* printf("janet: bytes done, got %d\n",e); */
		if (e == 0) {
			me -> super.env = cls;
		} else {
			_err("janet module could not be loaded");
			errorCode = gd_Error_errParseError;
			janet_gcunroot(janet_wrap_table(cls));
		}

		return errorCode;
	};
};

import {
	typedef struct gdjn_janet_image {
		size_t   sz;
		uint8_t* buf;