clipsruby 0.0.39 → 0.0.41

data/ext/clipsruby/clipsruby.c

@@ -476,31 +476,6 @@ static VALUE clips_environment_defclass_static_get_instance_list(int argc, VALUE
 }
 
 
-static VALUE clips_environment_make_instance(VALUE self, VALUE string)
-{
-	Environment *env;
-
-	TypedData_Get_Struct(self, Environment, &Environment_type, env);
-
-	Instance *instance = MakeInstance(env, StringValueCStr(string));
-
-	if (instance == NULL) {
-		return Qnil;
-	}
-
-	VALUE rb_instance =
-		TypedData_Wrap_Struct(rb_const_get(CLASS_OF(self), rb_intern("Instance")), &Instance_type, instance);
-
-	rb_iv_set(rb_instance, "@environment", self);
-
-	return rb_instance;
-}
-
-static VALUE clips_environment_static_make_instance(VALUE self, VALUE rbEnvironment, VALUE string)
-{
-	return clips_environment_make_instance(rbEnvironment, string);
-}
-
 static VALUE clips_environment_instance_unmake(VALUE self)
 {
 	Instance *instance;
@@ -869,6 +844,329 @@ static VALUE clips_environment_static_assert_hash(VALUE self, VALUE environment,
 	return clips_environment_assert_hash(environment, deftemplate_name, hash);
 }
 
+static int _clips_environment_make_instance(VALUE key, VALUE value, VALUE args)
+{
+	const char *cslot_name;
+	switch(TYPE(key))
+	{
+		case T_SYMBOL:
+			cslot_name = rb_id2name(SYM2ID(key));
+			break;
+		case T_STRING:
+			cslot_name = StringValueCStr(key);
+			break;
+		default:
+			rb_raise(rb_eTypeError, "Slot name must be a String or a Symbol");
+			return ST_CONTINUE;
+	}
+
+	VALUE *ib_and_env = (VALUE*)args;
+	InstanceBuilder *ib = (InstanceBuilder*) ib_and_env[0];
+	Environment *env = (Environment*) ib_and_env[1];
+	CLIPSValue cv = VALUE_to_CLIPSValue(value, env);
+	handle_pse_error(IBPutSlot(ib, cslot_name, &cv), cslot_name);
+
+	return ST_CONTINUE;
+}
+
+static VALUE clips_environment_make_instance(int argc, VALUE *argv, VALUE rbEnvironment) {
+	VALUE first_argument, second_argument, third_argument, defclass_class, rb_instance;
+	Environment *env;
+	Defclass *defclass;
+	InstanceBuilder *ib;
+	Instance *instance;
+	const char *instance_name;
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	rb_scan_args(argc, argv, "12", &first_argument, &second_argument, &third_argument);
+
+	defclass_class = rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Defclass"));
+
+	// first argument must be a defclass
+	switch (TYPE(first_argument))
+	{
+		case T_OBJECT:
+		case T_DATA:
+			if (CLASS_OF(first_argument) == defclass_class) {
+				TypedData_Get_Struct(first_argument, Defclass, &Defclass_type, defclass);
+				ib = CreateInstanceBuilder(env, DefclassName(defclass));
+				break;
+			} else {
+				rb_warn("First argument must be a Defclass; first argument was an object, but not %s class; it was a %s", rb_class2name(defclass_class), rb_class2name(first_argument));
+				return Qnil;
+			}
+		case T_STRING:
+			ib = CreateInstanceBuilder(env, StringValueCStr(first_argument));
+			break;
+		case T_SYMBOL:
+			ib = CreateInstanceBuilder(env, rb_id2name(SYM2ID(first_argument)));
+			break;
+		default:
+			rb_warn("First argument must be a Defclass; type wasn't a Defclass, a string, or a symbol; it was a %s!", rb_class2name(rb_obj_class(first_argument)));
+			return Qnil;
+	}
+
+	switch (IBError(env))
+	{
+		case IBE_NO_ERROR:
+			break;
+		case IBE_NULL_POINTER_ERROR:
+			rb_warn("Could not make instance; null pointer error. This could be a bug in clipsruby!");
+			IBDispose(ib);
+			return Qnil;
+		case IBE_DEFCLASS_NOT_FOUND_ERROR:
+			IBDispose(ib);
+			switch (TYPE(first_argument)) {
+				case T_STRING:
+					instance = MakeInstance(env, StringValueCStr(first_argument));
+					break;
+				case T_SYMBOL:
+					instance = MakeInstance(env, rb_id2name(SYM2ID(first_argument)));
+					break;
+				default:
+					instance = NULL;
+					break;
+			}
+			if (instance == NULL) {
+				rb_warn("Could not make instance; defclass not found, and first argument was not a valid make-instance string!");
+				return Qnil;
+			} else {
+				rb_instance =
+					TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, instance);
+
+				rb_iv_set(rb_instance, "@environment", rbEnvironment);
+
+				return rb_instance;
+			}
+		case IBE_COULD_NOT_CREATE_ERROR:
+			rb_warn("Could not make instance; This could be a bug in clipsruby!");
+			IBDispose(ib);
+			return Qnil;
+		case IBE_RULE_NETWORK_ERROR:
+			rb_warn("Could not make instance; Rule network error!");
+			IBDispose(ib);
+			return Qnil;
+	}
+
+	void *args[2] = { (void *)ib, (void *)env };
+
+	switch(TYPE(second_argument))
+	{
+		case T_STRING:
+		case T_SYMBOL:
+			instance_name = rb_id2name(SYM2ID(second_argument));
+			break;
+		case T_NIL:
+			instance_name = NULL;
+			break;
+		case T_HASH:
+			instance_name = NULL;
+			rb_hash_foreach(second_argument, _clips_environment_make_instance, (VALUE)args);
+			break;
+		default:
+			rb_warn("Could not make instance; second argument must be the name of the new instance or the slot hash!");
+			IBDispose(ib);
+			return Qnil;
+	}
+
+	switch(TYPE(third_argument))
+	{
+		case T_NIL:
+			break;
+		case T_HASH:
+			rb_hash_foreach(third_argument, _clips_environment_make_instance, (VALUE)args);
+			break;
+		default:
+			rb_warn("Could not make instance; third argument must be nil or the slot hash!");
+			IBDispose(ib);
+			return Qnil;
+	}
+
+	if ((instance = IBMake(ib, instance_name)) == NULL)
+	{
+		switch (IBError(env))
+		{
+			case IBE_NO_ERROR:
+				break;
+			case IBE_NULL_POINTER_ERROR:
+				rb_warn("Could not make instance; null pointer error. This could be a bug in clipsruby!");
+				IBDispose(ib);
+				return Qnil;
+			case IBE_DEFCLASS_NOT_FOUND_ERROR:
+				rb_warn("Could not make instance; defclass not found!");
+				IBDispose(ib);
+				return Qnil;
+			case IBE_COULD_NOT_CREATE_ERROR:
+				rb_warn("Could not make instance; This could be a bug in clipsruby!");
+				IBDispose(ib);
+				return Qnil;
+			case IBE_RULE_NETWORK_ERROR:
+				rb_warn("Could not make instance; Rule network error!");
+				IBDispose(ib);
+				return Qnil;
+		}
+	}
+
+	IBDispose(ib);
+
+	rb_instance =
+		TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, instance);
+
+	rb_iv_set(rb_instance, "@environment", rbEnvironment);
+
+	return rb_instance;
+}
+
+static VALUE clips_environment_static_make_instance(int argc, VALUE *argv, VALUE klass) {
+	VALUE rbEnvironment, first_argument, second_argument, third_argument, defclass_class, rb_instance;
+	Environment *env;
+	Defclass *defclass;
+	InstanceBuilder *ib;
+	Instance *instance;
+	const char *instance_name;
+
+	rb_scan_args(argc, argv, "22", &rbEnvironment, &first_argument, &second_argument, &third_argument);
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	defclass_class = rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Defclass"));
+
+	// first argument must be a defclass
+	switch (TYPE(first_argument))
+	{
+		case T_OBJECT:
+		case T_DATA:
+			if (CLASS_OF(first_argument) == defclass_class) {
+				TypedData_Get_Struct(first_argument, Defclass, &Defclass_type, defclass);
+				ib = CreateInstanceBuilder(env, DefclassName(defclass));
+				break;
+			} else {
+				rb_warn("First argument must be a Defclass; first argument was an object, but not %s class; it was a %s", rb_class2name(defclass_class), rb_class2name(first_argument));
+				return Qnil;
+			}
+		case T_STRING:
+			ib = CreateInstanceBuilder(env, StringValueCStr(first_argument));
+			break;
+		case T_SYMBOL:
+			ib = CreateInstanceBuilder(env, rb_id2name(SYM2ID(first_argument)));
+			break;
+		default:
+			rb_warn("First argument must be a Defclass; type wasn't a Defclass, a string, or a symbol; it was a %s!", rb_class2name(rb_obj_class(first_argument)));
+			return Qnil;
+	}
+
+	switch (IBError(env))
+	{
+		case IBE_NO_ERROR:
+			break;
+		case IBE_NULL_POINTER_ERROR:
+			rb_warn("Could not make instance; null pointer error. This could be a bug in clipsruby!");
+			IBDispose(ib);
+			return Qnil;
+		case IBE_DEFCLASS_NOT_FOUND_ERROR:
+			IBDispose(ib);
+			switch (TYPE(first_argument)) {
+				case T_STRING:
+					instance = MakeInstance(env, StringValueCStr(first_argument));
+					break;
+				case T_SYMBOL:
+					instance = MakeInstance(env, rb_id2name(SYM2ID(first_argument)));
+					break;
+				default:
+					instance = NULL;
+					break;
+			}
+			if (instance == NULL) {
+				rb_warn("Could not make instance; defclass not found, and first argument was not a valid make-instance string!");
+				return Qnil;
+			} else {
+				rb_instance =
+					TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, instance);
+
+				rb_iv_set(rb_instance, "@environment", rbEnvironment);
+
+				return rb_instance;
+			}
+		case IBE_COULD_NOT_CREATE_ERROR:
+			rb_warn("Could not make instance; This could be a bug in clipsruby!");
+			IBDispose(ib);
+			return Qnil;
+		case IBE_RULE_NETWORK_ERROR:
+			rb_warn("Could not make instance; Rule network error!");
+			IBDispose(ib);
+			return Qnil;
+	}
+
+	void *args[2] = { (void *)ib, (void *)env };
+
+	switch(TYPE(second_argument))
+	{
+		case T_STRING:
+		case T_SYMBOL:
+			instance_name = rb_id2name(SYM2ID(second_argument));
+			break;
+		case T_NIL:
+			instance_name = NULL;
+			break;
+		case T_HASH:
+			instance_name = NULL;
+			rb_hash_foreach(second_argument, _clips_environment_make_instance, (VALUE)args);
+			break;
+		default:
+			rb_warn("Could not make instance; second argument must be the name of the new instance or the slot hash!");
+			IBDispose(ib);
+			return Qnil;
+	}
+
+	switch(TYPE(third_argument))
+	{
+		case T_NIL:
+			break;
+		case T_HASH:
+			rb_hash_foreach(third_argument, _clips_environment_make_instance, (VALUE)args);
+			break;
+		default:
+			rb_warn("Could not make instance; third argument must be nil or the slot hash!");
+			IBDispose(ib);
+			return Qnil;
+	}
+
+	if ((instance = IBMake(ib, instance_name)) == NULL)
+	{
+		switch (IBError(env))
+		{
+			case IBE_NO_ERROR:
+				break;
+			case IBE_NULL_POINTER_ERROR:
+				rb_warn("Could not make instance; null pointer error. This could be a bug in clipsruby!");
+				IBDispose(ib);
+				return Qnil;
+			case IBE_DEFCLASS_NOT_FOUND_ERROR:
+				rb_warn("Could not make instance; defclass not found!");
+				IBDispose(ib);
+				return Qnil;
+			case IBE_COULD_NOT_CREATE_ERROR:
+				rb_warn("Could not make instance; This could be a bug in clipsruby!");
+				IBDispose(ib);
+				return Qnil;
+			case IBE_RULE_NETWORK_ERROR:
+				rb_warn("Could not make instance; Rule network error!");
+				IBDispose(ib);
+				return Qnil;
+		}
+	}
+
+	IBDispose(ib);
+
+	rb_instance =
+		TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, instance);
+
+	rb_iv_set(rb_instance, "@environment", rbEnvironment);
+
+	return rb_instance;
+}
+
 static VALUE clips_environment_deftemplate_assert_hash(VALUE self, VALUE hash)
 {
 	const char *cdeftemplate_name;
@@ -1266,10 +1564,6 @@ static VALUE clips_environment_defclass_subclasses(int argc, VALUE *argv, VALUE
 
 	rb_scan_args(argc, argv, "01", &inherit);
 
-	if (NIL_P(inherit)) {
-		inherit = Qfalse;
-	}
-
 	TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
 
 	ClassSubclasses(defclass, &value, RTEST(inherit));
@@ -1299,6 +1593,46 @@ static VALUE clips_environment_defclass_static_subclasses(int argc, VALUE *argv,
 	return out;
 }
 
+static VALUE clips_environment_defclass_slots(int argc, VALUE *argv, VALUE rbDefclass)
+{
+	VALUE rbEnvironment, inherit;
+	Defclass *defclass;
+	CLIPSValue value;
+	VALUE out;
+
+	rbEnvironment = rb_iv_get(rbDefclass, "@environment");
+
+	rb_scan_args(argc, argv, "01", &inherit);
+
+	TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+
+	ClassSlots(defclass, &value, RTEST(inherit));
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_defclass_static_slots(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE rbEnvironment, inherit, rbDefclass;
+	Defclass *defclass;
+	CLIPSValue value;
+	VALUE out;
+
+	rb_scan_args(argc, argv, "11", &rbDefclass, &inherit);
+
+	TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+
+	rbEnvironment = rb_iv_get(rbDefclass, "@environment");
+
+	ClassSlots(defclass, &value, RTEST(inherit));
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
 static VALUE clips_environment_run(int argc, VALUE *argv, VALUE environment) {
 	VALUE integer;
 	Environment *env;
@@ -1436,6 +1770,57 @@ static VALUE clips_environment_fact_static_to_h(VALUE self, VALUE rbFact)
 	return clips_environment_fact_to_h(rbFact);
 }
 
+static VALUE clips_environment_instance_to_h(int argc, VALUE *argv, VALUE rbInstance)
+{
+	VALUE rbEnvironment, inherit;
+	Instance *instance;
+	CLIPSValue key, value;
+	rbEnvironment = rb_iv_get(rbInstance, "@environment");
+
+	TypedData_Get_Struct(rbInstance, Instance, &Instance_type, instance);
+
+	rb_scan_args(argc, argv, "01", &inherit);
+
+	ClassSlots(InstanceClass(instance), &key, RTEST(inherit));
+
+	VALUE hash = rb_hash_new();
+	for (size_t i = 0; i < key.multifieldValue->length; i++)
+	{
+		VALUE innerValue;
+		DirectGetSlot(instance, key.multifieldValue->contents[i].lexemeValue->contents, &value);
+		CLIPSValue_to_VALUE(&value, &innerValue, &rbEnvironment);
+		rb_hash_aset(hash, ID2SYM(rb_intern(key.multifieldValue->contents[i].lexemeValue->contents)), innerValue);
+	}
+
+	return hash;
+}
+
+static VALUE clips_environment_instance_static_to_h(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE rbInstance, rbEnvironment, inherit;
+	Instance *instance;
+	CLIPSValue key, value;
+
+	rb_scan_args(argc, argv, "11", &rbInstance, &inherit);
+
+	rbEnvironment = rb_iv_get(rbInstance, "@environment");
+
+	TypedData_Get_Struct(rbInstance, Instance, &Instance_type, instance);
+
+	ClassSlots(InstanceClass(instance), &key, RTEST(inherit));
+
+	VALUE hash = rb_hash_new();
+	for (size_t i = 0; i < key.multifieldValue->length; i++)
+	{
+		VALUE innerValue;
+		DirectGetSlot(instance, key.multifieldValue->contents[i].lexemeValue->contents, &value);
+		CLIPSValue_to_VALUE(&value, &innerValue, &rbEnvironment);
+		rb_hash_aset(hash, ID2SYM(rb_intern(key.multifieldValue->contents[i].lexemeValue->contents)), innerValue);
+	}
+
+	return hash;
+}
+
 static VALUE clips_environment_batch_star(VALUE self, VALUE path)
 {
 	Environment *env;
@@ -4290,8 +4675,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbEnvironment, "unwatch_focus", clips_environment_unwatch_focus, 0);
 	rb_define_singleton_method(rbEnvironment, "get_watch_state", clips_environment_static_get_watch_state, 2);
 	rb_define_method(rbEnvironment, "get_watch_state", clips_environment_get_watch_state, 1);
-	rb_define_singleton_method(rbEnvironment, "make_instance", clips_environment_static_make_instance, 2);
-	rb_define_method(rbEnvironment, "make_instance", clips_environment_make_instance, 1);
+	rb_define_singleton_method(rbEnvironment, "make_instance", clips_environment_static_make_instance, -1);
+	rb_define_method(rbEnvironment, "make_instance", clips_environment_make_instance, -1);
 
 	VALUE rbDeffacts = rb_define_class_under(rbEnvironment, "Deffacts", rb_cObject);
 	rb_define_alloc_func(rbDeffacts, deffacts_alloc);
@@ -4416,6 +4801,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbDefclass, "superclasses", clips_environment_defclass_superclasses, -1);
 	rb_define_singleton_method(rbDefclass, "subclasses", clips_environment_defclass_static_subclasses, -1);
 	rb_define_method(rbDefclass, "subclasses", clips_environment_defclass_subclasses, -1);
+	rb_define_singleton_method(rbDefclass, "slots", clips_environment_defclass_static_slots, -1);
+	rb_define_method(rbDefclass, "slots", clips_environment_defclass_slots, -1);
 
 	VALUE rbInstance = rb_define_class_under(rbEnvironment, "Instance", rb_cObject);
 	rb_define_alloc_func(rbInstance, instance_alloc);
@@ -4429,4 +4816,6 @@ void Init_clipsruby(void)
 	rb_define_method(rbInstance, "name", clips_environment_instance_name, 0);
 	rb_define_singleton_method(rbInstance, "pp_form", clips_environment_instance_static_pp_form, 1);
 	rb_define_method(rbInstance, "pp_form", clips_environment_instance_pp_form, 0);
+	rb_define_singleton_method(rbInstance, "to_h", clips_environment_instance_static_to_h, -1);
+	rb_define_method(rbInstance, "to_h", clips_environment_instance_to_h, -1);
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clipsruby
 version: !ruby/object:Gem::Version
-  version: 0.0.39
+  version: 0.0.41
 platform: ruby
 authors:
 - Ryan Johnston
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-30 00:00:00.000000000 Z
+date: 2024-10-02 00:00:00.000000000 Z
 dependencies: []
 description: Calling the CLIPS programming language from within Ruby
 email: mrryanjohnston@gmail.com