gdjn  Diff

	impl _can_inherit_from_file()  -> bool { return true; };

	impl _handles_global_class_type(string t) -> bool { return false; };
	impl _get_type() -> string {
		gd_string s = {};
		_t(string).newWithUtf8Chars(&s, "JanetScriptText");
		return s;















	};
	impl _get_recognized_extensions() -> packed-string-array {
		gd_packedStringArray r = {};
		_t(packedStringArray).empty(&r, nullptr);
		_gdu_array_string_pushLit(&r, "janet");
		_gdu_array_string_pushLit(&r, "jimage");
		return r;
................................................................................
		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");
................................................................................
	impl _get_base_script() -> ref Script {
		return nullptr;
	};
	impl _has_static_method(string-name method) -> bool {
		return false;
	};
	impl _is_tool() -> bool { return false; }; (* FIXME *)
	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 {
................................................................................
		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;

	impl _can_inherit_from_file()  -> bool { return true; };

	impl _handles_global_class_type(string t) -> bool { return false; };
	impl _get_type() -> string {
		gd_string s = {};
		_t(string).newWithUtf8Chars(&s, "JanetScriptText");
		return s;
	};
	impl _get_public_functions() -> array[dictionary] {
		gd_array list;
		_t(array).empty(&list, nullptr);
		return list;
	};
	impl _get_public_constants() -> dictionary {
		gd_dictionary consts;
		_t(dictionary).empty(&consts, nullptr);
		return consts;
	};
	impl _get_public_annotations() -> array[dictionary] {
		gd_array list;
		_t(array).empty(&list, nullptr);
		return list;
	};
	impl _get_recognized_extensions() -> packed-string-array {
		gd_packedStringArray r = {};
		_t(packedStringArray).empty(&r, nullptr);
		_gdu_array_string_pushLit(&r, "janet");
		_gdu_array_string_pushLit(&r, "jimage");
		return r;
................................................................................
		return dict;
	};
};

class JanetScript is ScriptExtension {
	var as string: path;
	var JanetTable*: env;
	var pstr: id;
	var pstr: exportID;
	var pstr: uid;
	var pstr: doc;
	var pstr: inherit;
	
	var as array[dictionary]: methodBinds;

	use "vm.h";

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

		_t(array).empty(&me -> methodBinds, nullptr);
		me -> id       = (pstr){};
		me -> exportID = (pstr){};
		me -> uid      = (pstr){};
		me -> doc      = (pstr){};
		me -> inherit  = (pstr){};
	};
	del {
		_t(string).dtor(&me -> path);
		_t(array).dtor(&me -> methodBinds);
		if (me -> env) janet_gcunroot(janet_wrap_table(me -> env));
		_drop(me -> id);
		_drop(me -> exportID);
		_drop(me -> uid);
		_drop(me -> doc);
		_drop(me -> inherit);

	};

	class BaseInstance is Object {
		var as ref JanetScript: script;
		del {
			gd_refCounted_unreference(me -> script);
			printf("del script instance\n");
................................................................................
	impl _get_base_script() -> ref Script {
		return nullptr;
	};
	impl _has_static_method(string-name method) -> bool {
		return false;
	};
	impl _is_tool() -> bool { return false; }; (* FIXME *)
	impl _get_global_name() -> string-name {
		if (me -> exportID.v)
			return gdu_internp(me -> exportID);
		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_internp(me -> inherit);
	};
	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;
	};

	use {
		static pstr
		classParam
		(	JanetTable* env,
			const char* sym,
			pstr        dflt
		) {
			Janet v = janet_table_rawget(env, janet_csymbolv(sym));
			if (janet_type(v) != JANET_TABLE) return dflt;

			Janet s = janet_table_rawget(janet_unwrap_table(v), 
				janet_ckeywordv("value"));
			if (janet_type(s) == JANET_NIL) return dflt;

			JanetString str = janet_unwrap_string(s);
			return (pstr) {
				.v = (char*)str,
				.sz = janet_string_length(str),
			};
		}
	};
	impl _reload(bool keepState) -> int {
		gd_array_clear(&me -> methodBinds);
		/* parse the class environment */
		JanetTable* const env = me -> env;
		printf("core reload\n");

		pstr id      = classParam(env, "@id", (pstr){});
		pstr gdid    = classParam(env, "@gd-id", (pstr){});
		pstr inherit = classParam(env, "@inherit", _pstrLit("RefCounted"));
		pstr doc     = classParam(env, "@doc", (pstr){});

		if (gdid.v) me -> exportID = pstrDup(gdid);
			else me -> exportID = pstrDup(id);
		if (id.v) me -> id = pstrDup(id);

		if (doc.v) me -> doc = pstrDup(doc);
		if (inherit.v) me -> inherit = pstrDup(inherit);

		Janet wenv = janet_wrap_table(env);
		/* scan for bindings */
		for (Janet key = janet_next(wenv, janet_wrap_nil());
					janet_type(key) != JANET_NIL;
					key = janet_next(wenv, key)) {

			Janet val = janet_table_rawget(env, key);

			if (!janet_checktypes(key, JANET_TFLAG_BYTES)) continue;
			printf(" * consider val id %s (%s)\n",
					janet_unwrap_string(key),
					janet_type_names[janet_type(val)]);
			if (!janet_checktypes(val, JANET_TFLAG_DICTIONARY)) continue;
			JanetTable* v = janet_unwrap_table(val);
			Janet ty;
			const bool priv = gdjn_vm_metaFlag(v, "private");
			JanetString jkey = janet_unwrap_string(key);

			if (gdjn_vm_metaKey(v, "method", &ty)) {
			/* &&  janet_type(ty) == JANET_TABLE) { */
				printf("   * is method %s\n",
					janet_type_names[janet_type(ty)]);
				JanetTable* tspec = janet_unwrap_table(ty);
				/* janet_unwrap_function() */
				gd_dictionary meta;
				_t(dictionary).empty(&meta, nullptr);
				gdu_setKey_str(&meta, _pstrLit("name"),
					(pstr) {
						.sz = janet_string_length(jkey),
						.v = (char*)jkey,
					});

				/* build arg array */
				gd_array argList;
				_t(array).empty(&argList, nullptr);
				for (size_t j = 0; j < tspec -> count; ++j) {
				/*
					gd_dictionary
					gdu_array_append(&argList_, )
					*/
				}
				
				{gd_variant tv = gd_variant_of_array(argList);
				 gdu_setKey(&meta, _pstrLit("args"), &tv);}
					

				{gd_variant tv = gd_variant_of_dictionary(meta);
				 gd_array_append(&me -> methodBinds, &tv);}

				_t(array).dtor(&argList);
				_t(dictionary).dtor(&meta);
			} else if (gdjn_vm_metaKey(v, "prop", &ty)) {
			} else if (gdjn_vm_metaKey(v, "const", &ty)) {
			} else if (gdjn_vm_metaFlag(v, "subclass")) {
			};
			/* else: the value is not meaningful to godot; skip over */
		}
		return gd_Error_ok;
	};
	
	(*
	impl _update_exports() {

	};
	impl _placeholder_instance_create
	(ref Object forObj) -> ref Object {
................................................................................
		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));
		}
		if (errorCode != gd_Error_ok) return errorCode;


		/* invoke super by static dispatch */
		return gdjn_class_JanetScript_method__reload(&me -> super, keepState);
	};
};

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