gdjn  Diff

				  [ ;((<gd-sym> :%init) spec)
				   :binds (map bind-def
							   (or (spec :binds) []))
				   :methods (map bind-def
							   (or (spec :methods) []))
				   :ops (map bind-def
							   (or (spec :ops) []))

				   :ctors (or (spec :ctors) {})
				   :mode (spec :mode)])

	   :binds []
	   :methods []
	   :ctors {}
	   :ops []
	   :mode  :



	   :enum (fn [me]
				 (string "GDEXTENSION_VARIANT_TYPE_" (:scream me)))
	   ))

(defn env: [v dflt]
	(or ((os/environ) v) dflt))

................................................................................
		(has-value? x)))
(def variants (map |(:@new <gd-type> $) ~[
	{:id variant :binds [get-ptr-constructor
						 get-ptr-destructor
						 get-ptr-operator-evaluator
						 get-ptr-internal-getter
						 get-ptr-builtin-method


						 get-type
						 booleanize]}
	{:id bool        }


	{:id color }

	,;(map |{:id $} vector-types)
	,;(map |{:id $
			 :methods '[get set size resize fill clear
					    append append_array insert remove-at
					    has is-empty find rfind count
					    reverse slice duplicate]
			 :ctors {:empty []}
			 }
		   packed-types)
	{:id array
	 :binds [ref set-typed]

	 :ctors {:empty []}}

	{:id dictionary
	 :binds [set-typed operator-index operator-index-const]

	 :ctors {:empty []}}


	{:id string-name :mode :dc
	 :ops   [equal]
	 :binds [new-with-utf8-chars
			 new-with-utf8-chars-and-len]
	 :methods [length
			   ends-with begins-with
................................................................................
							 get-reference-count]}
	{:id script :binds [get-source-code set-source-code]}
	{:id file-access :binds [open close store-string get-as-text]}
	{:id resource-loader :binds [add-resource-format-loader
								 remove-resource-format-loader]}
	{:id resource-saver :binds [add-resource-format-saver
								remove-resource-format-saver]}


]))

(def global-enums (map |(:from <gd-sym> $) '[
	error
]))

(def singletons (map |(:from <gd-sym> $) '[
................................................................................
	(def api {
	  :decls   @[]
	  :aliases @[]
	  :calls   @[]
	  :defer-calls @[] # dependency Hel bypass
	  :types   @[]
	  :method-defs @[]


	})
	(def config (env: "gd_config" "double_64"))
	(def sizes (do
	   (var sz-list nil)
	   (loop [cfg :in (api-spec "builtin_class_sizes")
			      :until (not= nil sz-list)]
		   (when (= config (cfg "build_configuration"))
................................................................................
			(case (sizes x)
				4 small
				8 big
				(error (string "bad type size " (sizes x) " for " x))))
		(case x
			"int" (bp "int" "int32_t" "int64_t")
			"float" (bp "float" "float" "double")
			"bool" "bool"))

	(defn variant:gd->c [x]
		(def v (find |(= x (:tall (:@new <gd-sym> {:id ($ :id)}))) variants))
		(string "gd_" (:name v)))
	(defn translate-type [st &opt flags]
		(defn fl [x] (string/check-set (or flags :) x))
		(match (string/split "::" st)
			# enums can be directly mapped to a C
................................................................................
			(def id (string "gd_" (:tall class) "_" (e "name")))
			# the underlying type is IMPORTANT! godot enums
			# appear to use the godot int type, which (at present)
			# is always 8 bytes long. this means trying to write
			# a godot "enum" to a plain old C enum will, if you
			# are very lucky, cause your program to barf all over
			# the stack and immediately segfault
			(ln  "typedef enum %s : int64_t {" id)
			# thank the gods for C23. this would have been really
			# unpleasant otherwise
			(each n (e "values")
				(def ident (:from-snek <gd-sym> (n "name")))
				(def sym (:@new <gd-sym> ident))
				(ln "\t%s_%s = %d," id (:name sym) (n "value"))
				(ln "\t/* %s */"
................................................................................
			(def name (:from-snek <gd-sym> (v "name")))
			(ln "\tgd_%s_%s = %d," (:tall e) (:name name) (v "value"))
			(when (v "description")
				(ln "\t/* %s */" (v "description"))))
		(ln "} gd_%s;\n" (:tall e))
		)









	(loop [v :in variants
		   :let [vsz (or (sizes (:tall v))
						 (sizes (string (v :id) )))]]
		(add (api :aliases) # these are all opaque objects
			 "typedef _opaque(%d) gd_%s;"
			 vsz (:name v))
		(add (api :decls  ) "struct {")
		(def my-enum (:enum v))
		(add-methods v (v :binds))
		(add-enums v)






































		# bind builtins
		# WHY IS THIS *YET ANOTHER* COMPLETELY DIFFERENT API
		# for the SAME LITERAL THING fuck youuuuu
		(when (has-key? gdclasses (:tall v)) (loop [m :in (v :methods)
			   :let [method (get-in gdclasses [(:tall v) :methods
											   (:sulk m)])]]
................................................................................
					(translate-type (method :return_type))))
			(def args (method:args method (:tall v)
								   (if (method :is_const) :c :)))

			(def impl @[])
			(unless (= return-type "void")
				(array/push impl
					(string/format "typeof(%s) ret;" return-type)))
			(array/push impl
				(string/format "_g_typeDB -> gd_%s.%s("
							   (:name v) (:name m)))
					
			
			(array/push impl
						(string "\t" (if (method :is_static)
................................................................................
			(print "\ntypedef struct gdjn_typeDB {")
			(loop [d :in (api :decls)]
				(print "\t" d))
			(print "} gdjn_typeDB;")
			(each t (api :types) (print t))
			(print c-fetch-decl ";")
			(each m (api :method-defs)
				(print (m :dfn) ";")))



		"loader" (do
					 (print "#include <stdlib.h>\n"
							"#include <stdio.h>\n"
							"#include <assert.h>\n"
							"#include \"interface.h\"\n\n"
							"static gdjn_typeDB* _g_typeDB;\n\n"
							# HORRID HACK
							
							c-fetch-decl "{\n"
							;(map |(string "\t" $ "\n")
								  [ "_g_typeDB = t;"
								    ;(api :calls)



								    ;(api :defer-calls) ])
							"}")
					 (each m (api :method-defs)
						 (print (m :dfn) "{\n\t" (string/join (m :impl) "\n\t") "\n}\n")))))

				  [ ;((<gd-sym> :%init) spec)
				   :binds (map bind-def
							   (or (spec :binds) []))
				   :methods (map bind-def
							   (or (spec :methods) []))
				   :ops (map bind-def
							   (or (spec :ops) []))
				   :indexed (or (spec :indexed) false)
				   :ctors (or (spec :ctors) {})
				   :mode (spec :mode)
				   :c-repr (spec :c-repr)])
	   :binds []
	   :methods []
	   :ctors {}
	   :ops []
	   :mode  :
	   :c-type (fn [me]
				   (string (or (me :c-repr)
							   (string "gd_" (:name me)))))
	   :enum (fn [me]
				 (string "GDEXTENSION_VARIANT_TYPE_" (:scream me)))
	   ))

(defn env: [v dflt]
	(or ((os/environ) v) dflt))

................................................................................
		(has-value? x)))
(def variants (map |(:@new <gd-type> $) ~[
	{:id variant :binds [get-ptr-constructor
						 get-ptr-destructor
						 get-ptr-operator-evaluator
						 get-ptr-internal-getter
						 get-ptr-builtin-method
						 get-indexed set-indexed
						 get-named set-named
						 get-type
						 booleanize]}
	{:id bool  }
	{:id int   }
	{:id float }
	{:id color }

	,;(map |{:id $ :mode :dc} vector-types)
	,;(map |{:id $ :mode :dc
			 :methods '[get set size resize fill clear
					    append append_array insert remove-at
					    has is-empty find rfind count
					    reverse slice duplicate]
			 :ctors {:empty []}
			 }
		   packed-types)
	{:id array :mode :dc
	 :binds [ref set-typed operator-index operator-index-const]
	 :methods [size is-empty clear]
	 :ctors {:empty []}
	 :indexed true}
	{:id dictionary :mode :dc
	 :binds [set-typed operator-index operator-index-const]
	 :methods [size is-empty clear]
	 :ctors {:empty []}
	 :indexed true}

	{:id string-name :mode :dc
	 :ops   [equal]
	 :binds [new-with-utf8-chars
			 new-with-utf8-chars-and-len]
	 :methods [length
			   ends-with begins-with
................................................................................
							 get-reference-count]}
	{:id script :binds [get-source-code set-source-code]}
	{:id file-access :binds [open close store-string get-as-text]}
	{:id resource-loader :binds [add-resource-format-loader
								 remove-resource-format-loader]}
	{:id resource-saver :binds [add-resource-format-saver
								remove-resource-format-saver]}
	{:id script-language-extension}
	{:id script-extension}
]))

(def global-enums (map |(:from <gd-sym> $) '[
	error
]))

(def singletons (map |(:from <gd-sym> $) '[
................................................................................
	(def api {
	  :decls   @[]
	  :aliases @[]
	  :calls   @[]
	  :defer-calls @[] # dependency Hel bypass
	  :types   @[]
	  :method-defs @[]
	  :methods-inline @[]
	  :wrappers @[]
	})
	(def config (env: "gd_config" "double_64"))
	(def sizes (do
	   (var sz-list nil)
	   (loop [cfg :in (api-spec "builtin_class_sizes")
			      :until (not= nil sz-list)]
		   (when (= config (cfg "build_configuration"))
................................................................................
			(case (sizes x)
				4 small
				8 big
				(error (string "bad type size " (sizes x) " for " x))))
		(case x
			"int" (bp "int" "int32_t" "int64_t")
			"float" (bp "float" "float" "double")
			"bool" "bool"
			"object" "GDExtensionObjectPtr"))
	(defn variant:gd->c [x]
		(def v (find |(= x (:tall (:@new <gd-sym> {:id ($ :id)}))) variants))
		(string "gd_" (:name v)))
	(defn translate-type [st &opt flags]
		(defn fl [x] (string/check-set (or flags :) x))
		(match (string/split "::" st)
			# enums can be directly mapped to a C
................................................................................
			(def id (string "gd_" (:tall class) "_" (e "name")))
			# the underlying type is IMPORTANT! godot enums
			# appear to use the godot int type, which (at present)
			# is always 8 bytes long. this means trying to write
			# a godot "enum" to a plain old C enum will, if you
			# are very lucky, cause your program to barf all over
			# the stack and immediately segfault
			(ln  "typedef enum %s : GDExtensionInt {" id)
			# thank the gods for C23. this would have been really
			# unpleasant otherwise
			(each n (e "values")
				(def ident (:from-snek <gd-sym> (n "name")))
				(def sym (:@new <gd-sym> ident))
				(ln "\t%s_%s = %d," id (:name sym) (n "value"))
				(ln "\t/* %s */"
................................................................................
			(def name (:from-snek <gd-sym> (v "name")))
			(ln "\tgd_%s_%s = %d," (:tall e) (:name name) (v "value"))
			(when (v "description")
				(ln "\t/* %s */" (v "description"))))
		(ln "} gd_%s;\n" (:tall e))
		)

	(add (api :wrappers)
		 (string 
			 "auto getWrap = "
				 "(GDExtensionInterfaceGetVariantFromTypeConstructor)"
				 `getProc("get_variant_from_type_constructor");`
			 "\nauto getCast = "
				 "(GDExtensionInterfaceGetVariantToTypeConstructor)"
				 `getProc("get_variant_to_type_constructor");` "\n"))
	(loop [v :in variants
		   :let [vsz (or (sizes (:tall v))
						 (sizes (string (v :id) )))]]
		(add (api :aliases) # these are all opaque objects
			 "typedef _opaque(%d) gd_%s;"
			 vsz (:name v))
		(add (api :decls  ) "struct {")
		(def my-enum (:enum v))
		(add-methods v (v :binds))
		(add-enums v)
		(unless (= (v :id) 'variant)
			(add (api :decls)
				 "\tGDExtensionVariantFromTypeConstructorFunc wrap;")
			(add (api :decls)
				 "\tGDExtensionTypeFromVariantConstructorFunc cast;")
			(add (api :wrappers) "t -> gd_%s.wrap = getWrap(%s);"
				 (:name v) (:enum v))
			(add (api :wrappers) "t -> gd_%s.cast = getCast(%s);"
				 (:name v) (:enum v))
			(def ct (or (prim:gd->c (:name v))
						(variant:gd->c (:tall v))))
			(add (api :methods-inline)
				 (string "static inline %s\n"
						 "gd_variant_to_%s\n"
						 "(\tgd_variant const* const v\n"
						 ") {\n"
							 "\textern struct gdjn_typeDB* _g_typeDB;"
							 "\t%s ret = {};\n"
							 "\t_g_typeDB  -> gd_%s.cast(&ret, (void*)v);\n"
							 "\treturn ret;\n"
						 "}\n")
				 ct (:name v)
				 ct (:name v) )
			(add (api :methods-inline)
				 (string "static inline gd_variant\n"
						 "gd_variant_of_%s\n"
						 "(\t%s v\n"
						 ") {\n"
							 "\textern struct gdjn_typeDB* _g_typeDB;"
							 "\tgd_variant ret = {};\n"
							 "\t_g_typeDB -> gd_%s.wrap(&ret, &v);\n"
							 "\treturn ret;\n"
						 "}\n")
				 (:name v) 
				 ct
				 (:name v) 
			))

		# bind builtins
		# WHY IS THIS *YET ANOTHER* COMPLETELY DIFFERENT API
		# for the SAME LITERAL THING fuck youuuuu
		(when (has-key? gdclasses (:tall v)) (loop [m :in (v :methods)
			   :let [method (get-in gdclasses [(:tall v) :methods
											   (:sulk m)])]]
................................................................................
					(translate-type (method :return_type))))
			(def args (method:args method (:tall v)
								   (if (method :is_const) :c :)))

			(def impl @[])
			(unless (= return-type "void")
				(array/push impl
					(string/format "typeof(%s) ret = {};" return-type)))
			(array/push impl
				(string/format "_g_typeDB -> gd_%s.%s("
							   (:name v) (:name m)))
					
			
			(array/push impl
						(string "\t" (if (method :is_static)
................................................................................
			(print "\ntypedef struct gdjn_typeDB {")
			(loop [d :in (api :decls)]
				(print "\t" d))
			(print "} gdjn_typeDB;")
			(each t (api :types) (print t))
			(print c-fetch-decl ";")
			(each m (api :method-defs)
				(print (m :dfn) ";"))
			(each m (api :methods-inline)
				(print m)))

		"loader" (do
					 (print "#include <stdlib.h>\n"
							"#include <stdio.h>\n"
							"#include <assert.h>\n"
							"#include \"interface.h\"\n\n"
							"gdjn_typeDB* _g_typeDB;\n\n"
							# HORRID HACK
							
							c-fetch-decl "{\n"
							;(map |(string "\t" $ "\n")
								  [ "_g_typeDB = t;"
								    ;(api :calls)
									"{"
									;(api :wrappers)
									"}"
								    ;(api :defer-calls) ])
							"}")
					 (each m (api :method-defs)
						 (print (m :dfn) "{\n\t" (string/join (m :impl) "\n\t") "\n}\n")))))