예제 #1
0
파일: voice.c 프로젝트: Cyofanni/speect
static void unload_voice_plugins(SList *plugins, s_erc *error)
{
	SIterator *itr;
	SObject *plugin;


	S_CLR_ERR(error);

	itr = S_ITERATOR_GET(plugins, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "unload_voice_plugins",
				  "Call to \"S_ITERATOR_GET\" failed"))
		return;

	while (itr != NULL)
	{
		plugin = SIteratorUnlink(itr, error);
		if (S_CHK_ERR(error, S_CONTERR,
					  "unload_voice_plugins",
					  "Call to \"SIteratorUnlink\" failed"))
		{
			S_DELETE(itr, "unload_voice_plugins", error);
			return;
		}


		S_DELETE(plugin, "unload_voice_plugins", error);
		itr = SIteratorNext(itr);
	}

	S_DELETE(plugins, "unload_voice_plugins", error);
}
예제 #2
0
파일: plugin.c 프로젝트: Cyofanni/speect
/* plug-in register function */
static void plugin_register_function(s_erc *error)
{
	S_CLR_ERR(error);

	/* load phoneset plug-in */
	phonesetPlugin = s_pm_load_plugin("phoneset.spi", error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_REG_STR,
				  "Call to \"s_pm_load_plugin\" failed"))
		return;

	/* register plug-in classes here */
	_s_phoneset_json_class_reg(error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_REG_STR,
				  SPCT_PLUGIN_REG_FAIL_STR))
	{
		S_DELETE(phonesetPlugin, SPCT_PLUGIN_REG_STR, error);
		return;
	}

	_s_serialized_json_phoneset_reg(error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_REG_STR,
				  "Failed to register SJSONPhonesetFile class"))
	{
		s_erc local_err = S_SUCCESS;


		S_DELETE(phonesetPlugin, SPCT_PLUGIN_REG_STR, error);
		_s_phoneset_json_class_free(&local_err);
		return;
	}
}
예제 #3
0
파일: plugin.c 프로젝트: Cyofanni/speect
/* plug-in register function */
static void plugin_register_function(s_erc *error)
{
	S_CLR_ERR(error);

	/*
	 * load the ebml plug-in
	 */
	ebmlPlugin = s_pm_load_plugin("ebml.spi", error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_REG_STR,
				  "Call to \"s_pm_load_plugin\" failed"))
		return;

	trackFloatPlugin = s_pm_load_plugin("track_float.spi", error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_REG_STR,
				  "Call to \"s_pm_load_plugin\" failed"))
	{
		S_DELETE(ebmlPlugin, SPCT_PLUGIN_REG_STR, error);
		return;
	}

	/* register plug-in classes here */
	_s_serialized_ebml_track_float_reg(error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_REG_STR,
				  SPCT_PLUGIN_REG_FAIL_STR))
	{
		S_DELETE(trackFloatPlugin, SPCT_PLUGIN_REG_STR, error);
		S_DELETE(ebmlPlugin, SPCT_PLUGIN_REG_STR, error);
		return;
	}

}
예제 #4
0
S_API void STokenstreamFileInit(STokenstreamFile **self, const char *path, s_erc *error)
{
	S_CLR_ERR(error);

	if (path == NULL)
	{
		S_CTX_ERR(error, S_ARGERROR,
				  "STokenstreamFileInit",
				  "Argument \"path\" is NULL");
		return;
	}

	(*self)->ds = SFilesourceOpenFile(path, "r", error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "STokenstreamFileInit",
				  "Call to \"SFilesourceOpenFile\" failed"))
	{
		S_DELETE(*self, "STokenstreamFileInit", error);
		*self = NULL;
		return;
	}

	/* get the first character */
	STokenstreamGetChar(S_TOKENSTREAM(*self), error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "STokenstreamFileInit",
				  "Call to \"STokenstreamGetChar\" failed"))
	{
		S_DELETE(*self, "STokenstreamFileInit", error);
		*self = NULL;
		return;
	}
}
D3DShaderManager::~D3DShaderManager()
{
	// Safely delete all the shader objects.
	S_DELETE(m_TextureShader);
	S_DELETE(m_D3DLightShader);
	S_DELETE(m_BumpMapShader);
}
예제 #6
0
파일: plugin.c 프로젝트: Cyofanni/speect
/* plug-in register function */
static void plugin_register_function(s_erc *error)
{
	S_CLR_ERR(error);

	/* load plug-ins */
	syllabificationPlugin = s_pm_load_plugin("syllabification.spi", error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_REG_STR,
				  "Call to \"s_pm_load_plugin\" failed"))
		return;

	/* register plug-in classes here */
	_s_syllabification_rewrites_rule_class_reg(error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_REG_STR,
				  "Failed to register SSyllabificationRewritesRule class"))
	{
		S_DELETE(syllabificationPlugin, SPCT_PLUGIN_REG_STR, error);
		return;
	}

	_s_syllabification_rewrites_class_reg(error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_REG_STR,
			  SPCT_PLUGIN_REG_FAIL_STR))
	{
		s_erc local_err = S_SUCCESS;


		_s_syllabification_rewrites_rule_class_free(&local_err);
		S_DELETE(syllabificationPlugin, SPCT_PLUGIN_REG_STR, error);
		return;
	}
}
State::~State()
{
	// Give the state access to the DirectX systems
	S_DELETE(m_CpuMonitor);
	S_DELETE(m_HPRTimer);
	S_DELETE(m_RenderToTexture);
	S_DELETE( m_MouseBitmap );
}
예제 #8
0
static s_bool _item_match(const char *PATT, const char *THING, const SMap *sets,
						  s_erc *error)
{
	int rv;
	s_bool is_present;
	const SObject *tmp;
	const SList *setList;
	SObject *thingObject;

	S_CLR_ERR(error);
	rv = s_strcmp(PATT, THING, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "_item_match",
				  "Call to \"s_strcmp\" failed"))
		return FALSE;

	if (rv == 0)
		return TRUE;

	if (sets == NULL)
		return FALSE;

	tmp = SMapGetObjectDef(sets, PATT, NULL, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "_item_match",
				  "Call to \"SMapGetObjectDef\" failed"))
		return FALSE;

	if (tmp == NULL)
		return FALSE;

	setList = S_CAST(tmp, SList, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "_item_match",
				  "Call to \"S_CAST(SList)\" failed"))
		return FALSE;

	thingObject = SObjectSetString(THING, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "_item_match",
				  "Call to \"SObjectSetString\" failed"))
		return FALSE;

	is_present = SListValPresent(setList, thingObject, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "_item_match",
				  "Call to \"SListValPresent\" failed"))
	{
		S_DELETE(thingObject, "_item_match", error);
		return FALSE;
	}

	S_DELETE(thingObject, "_item_match", error);
	return is_present;
}
예제 #9
0
파일: vit_path.c 프로젝트: Cyofanni/speect
static void Destroy(void *obj, s_erc *error)
{
	SViterbiPath *self = obj;


	S_CLR_ERR(error);
	if (self->features != NULL)
		S_DELETE(self->features, "Destroy", error);

	if (self->next != NULL)
		S_DELETE(self->next, "Destroy", error);
}
예제 #10
0
파일: py_map.c 프로젝트: Cyofanni/speect
static void DestroyMapPy(void *obj, s_erc *error)
{
	SMapPy *self = obj;


	S_CLR_ERR(error);

	if (self->pyObject != NULL)
		S_DELETE(self->pyObject, "DestroyMapPy", error);

	if (self->staticObjects != NULL)
		S_DELETE(self->staticObjects, "DestroyMapPy", error);
}
예제 #11
0
파일: plugin.c 프로젝트: Cyofanni/speect
/* plug-in exit function */
static void plugin_exit_function(s_erc *error)
{
	S_CLR_ERR(error);

	/* free plug-in classes here */
	_s_serialized_ebml_track_float_free(error);
	S_CHK_ERR(error, S_CONTERR,
			  SPCT_PLUGIN_EXIT_STR,
			  SPCT_PLUGIN_EXIT_FAIL_STR);

	S_DELETE(ebmlPlugin, SPCT_PLUGIN_EXIT_STR, error);
	S_DELETE(trackFloatPlugin, SPCT_PLUGIN_EXIT_STR, error);
}
예제 #12
0
static void Destroy(void *obj, s_erc *error)
{
	STokenstreamFile *self = obj;


	S_CLR_ERR(error);

	if (self->ds != NULL)
		S_DELETE(self->ds, "Destroy", error);

	if (--num_file_tokenstreams == 0)
		S_DELETE(tokenstream, "Destroy", error);
}
예제 #13
0
static void s_compute_stresses ( const SFeatProcessor* proc, SItem* word, s_erc *error )
{
	S_CLR_ERR(error);
	SItem *wordAsSylStructure = SItemAs(word, "SylStructure", error);
	if (S_CHK_ERR(error, S_CONTERR,
		      "s_compute_stresses",
		      "Call to \"SItemAs\" failed"))
		return;

	SItem *syllable = SItemDaughter(wordAsSylStructure, error);
	if (S_CHK_ERR(error, S_CONTERR,
		      "s_compute_stresses",
		      "Call to \"SItemDaughter\" failed"))
		return;

	SObject* result = NULL;
	while (syllable != NULL)
	{
		result = SFeatProcessorRun ( proc, syllable, error);
		if (S_CHK_ERR(error, S_CONTERR,
					  "s_compute_stresses",
					  "Call to \"SItemPathToFeatProc\" failed"))
			goto s_compute_stresses_cleanup;

		const char* resultString = SObjectGetString ( result, error );
		if (S_CHK_ERR(error, S_CONTERR,
					  "s_compute_stresses",
					  "Call to \"SObjectGetInt\" failed"))
			goto s_compute_stresses_cleanup;

		SItemSetString ( syllable, "stress", resultString, error );
		if (S_CHK_ERR(error, S_CONTERR,
					  "s_compute_stresses",
					  "Call to \"SItemSetInt\" failed"))
			goto s_compute_stresses_cleanup;

		syllable = SItemNext ( syllable, error );
		if (S_CHK_ERR(error, S_CONTERR,
					  "s_compute_stresses",
					  "Call to \"SItemNext\" failed"))
			goto s_compute_stresses_cleanup;
		if(result != NULL) {
			S_DELETE(result, "s_compute_stresses", error);
		}
	}
s_compute_stresses_cleanup:
	if(result != NULL) {
		S_DELETE(result, "s_compute_stresses", error);
	}

}
예제 #14
0
파일: utterance.c 프로젝트: Cyofanni/speect
static void DestroyUtt(void *obj, s_erc *error)
{
	SUtterance *self = obj;
	SIterator *itr;
	SRelation *rel;

	S_CLR_ERR(error);

	s_mutex_lock(&(self->utt_mutex));

	S_DELETE(self->features, "DestroyUtt", error);

	/* Relations don't delete their contents (no dispose) */
	itr = S_ITERATOR_GET(self->relations, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "DestroyUtt",
				  "Call to \"S_ITERATOR_GET\" failed"))
	{
		S_DELETE(self->relations, "DestroyUtt", error);
		s_mutex_unlock(&(self->utt_mutex));
		s_mutex_destroy(&(self->utt_mutex));
		return;
	}

	while (itr)
	{
		rel = S_RELATION(SIteratorUnlink(itr, error));
		if (S_CHK_ERR(error, S_CONTERR,
					  "DestroyUtt",
					  "Call to \"SMapIteratorUnlink\" failed"))
		{
			S_DELETE(self->relations, "DestroyUtt", error);
			S_DELETE(itr, "DestroyUtt", error);
			s_mutex_unlock(&(self->utt_mutex));
			s_mutex_destroy(&(self->utt_mutex));
			return;
		}

		S_FORCE_DELETE(rel, "DestroyUtt", error);

		itr = SIteratorNext(itr);
	}

	S_DELETE(self->relations, "DestroyUtt", error);
	s_mutex_unlock(&(self->utt_mutex));
	s_mutex_destroy(&(self->utt_mutex));
	s_mutex_destroy(&(self->utt_id_mutex));
}
예제 #15
0
파일: py_map.c 프로젝트: Cyofanni/speect
S_API void SMapPyInit(SMapPy **self, PyObject *object, s_erc *error)
{
	S_CLR_ERR(error);

	if ((*self) == NULL)
	{
		S_CTX_ERR(error, S_ARGERROR,
				  "SMapPyInit",
				  "Argument \"self\" is NULL");
		goto error_clean_up;
	}

	if (object == NULL)
	{
		S_CTX_ERR(error, S_ARGERROR,
				  "SMapPyInit",
				  "Argument \"self\" is NULL");
		goto error_clean_up;
	}

	/* set this map's Python object */
	SPyObjectSet((*self)->pyObject, object, error);
	if (S_CHK_ERR(error, S_ARGERROR,
				  "SMapPyInit",
				  "Call to \"SPyObjectSet\" failed"))
		goto error_clean_up;

	/* all OK */
	return;

	/* clean up code */
error_clean_up:
	S_DELETE((*self), "SMapPyInit", error);
	(*self) = NULL;
}
예제 #16
0
파일: plugin.c 프로젝트: Cyofanni/speect
/* plug-in exit function */
static void plugin_exit_function(s_erc *error)
{
	s_erc local_err = S_SUCCESS;


	S_CLR_ERR(error);

	/* free plug-in classes here */
	_s_serialized_json_phoneset_free(&local_err);
	S_CHK_ERR(&local_err, S_CONTERR,
			  SPCT_PLUGIN_EXIT_STR,
			  "Failed to free SJSONPhonesetFile class");

	_s_phoneset_json_class_free(error);
	S_CHK_ERR(error, S_CONTERR,
			  SPCT_PLUGIN_EXIT_STR,
			  SPCT_PLUGIN_EXIT_FAIL_STR);

	if ((error != NULL)
		&& (*error == S_SUCCESS)
		&& (local_err != S_SUCCESS))
		*error = local_err;

	S_DELETE(phonesetPlugin, SPCT_PLUGIN_EXIT_STR, error);
}
예제 #17
0
파일: plugin.c 프로젝트: Cyofanni/speect
/* plug-in exit function */
static void plugin_exit_function(s_erc *error)
{
	s_erc local_err = S_SUCCESS;


	S_CLR_ERR(error);

	/* free plug-in classes here */
	_s_syllabification_rewrites_rule_class_free(error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_EXIT_STR,
				  "Failed to free SSyllabificationRewritesRule class"))
		if (error != NULL)
			local_err = *error;

	_s_syllabification_rewrites_class_free(error);
	if (S_CHK_ERR(error, S_CONTERR,
				  SPCT_PLUGIN_EXIT_STR,
				  SPCT_PLUGIN_EXIT_FAIL_STR))
		if (error != NULL)
			local_err = *error;

	if ((error != NULL)
		&& (*error == S_SUCCESS)
		&& (local_err != S_SUCCESS))
		*error = local_err;

	S_DELETE(syllabificationPlugin, SPCT_PLUGIN_EXIT_STR, error);
}
예제 #18
0
파일: primitives.c 프로젝트: Oghma/speect
S_API SObject *SObjectSetString(const char *s, s_erc *error)
{
    SString *self;


    S_CLR_ERR(error);

    if (s == NULL)
    {
        S_CTX_ERR(error, S_ARGERROR,
                  "SObjectSetString",
                  "Argument \"s\" is NULL");
        return NULL;
    }

    self = S_NEW(SString, error);
    if (S_CHK_ERR(error, S_FAILURE,
                  "SObjectSetString",
                  "Failed to create new SString object"))
        return NULL;

    self->s = s_strdup(s, error);
    if (S_CHK_ERR(error, S_CONTERR,
                  "SObjectSetString",
                  "Failed to copy string"))
    {
        S_DELETE(self, "SObjectSetString", error);
        return NULL;
    }

    return S_OBJECT(self);
}
예제 #19
0
    bool MatchPool::pop(int size_type, MatchRes &res) {
        std::vector<MatchEntity*> camps;
        for (int i = 0;i < _camp_size; i++) {
            MatchEntity *ent = E_NEW MatchEntity;
            ent->camp = i;
            camps.push_back(ent);
        }

        int success = pop(size_type, camps);

        // merge result
        res.type = _type;
        for (size_t i = 0;i < camps.size(); i++) {
            TeamSet members;
            camps[i]->get_members(members);
            if (!success) {
                // restore
                TeamSet::iterator itr = members.begin();
                for (;itr != members.end(); ++itr) {
                    MatchEntity *ent = get_entity(*itr);
                    if (ent) {
                        ent->status = MATCH_PENDING;
                    }
                }
            } else {
                res.teams.push_back(members);
            }
            S_DELETE(camps[i]);
        }

        return success;
    }
예제 #20
0
static void DestroyItmContent(void *obj, s_erc *error)
{
	SItmContent *self = obj;


	S_CLR_ERR(error);

	s_mutex_lock(&(self->content_mutex));

	if (self->relations != NULL)
		S_DELETE(self->relations, "DestroyItmContent", error);

	if (self->features != NULL)
		S_DELETE(self->features, "DestroyItmContent", error);

	s_mutex_unlock(&(self->content_mutex));
	s_mutex_destroy(&(self->content_mutex));
}
예제 #21
0
static void Destroy(void *obj, s_erc *error)
{
	SViterbiCandidate *self = obj;


	S_CLR_ERR(error);
	if (self->next != NULL)
		S_DELETE(self->next, "Destroy", error);
}
예제 #22
0
static void DestroyDataWriter(void *obj, s_erc *error)
{
	SDataWriter *self = obj;


	S_CLR_ERR(error);

	if (self->ds != NULL)
		S_DELETE(self->ds, "DestroyDataWriter", error);
}
예제 #23
0
S_API SDatasource *SMMapFilesourceOpenFile(const char *path, s_erc *error)
{
	SMMapFilesource *self;
	uint8 *mem;
	size_t map_size;
	s_mmap_file_handle *handle;


	S_CLR_ERR(error);

	self = S_NEW(SMMapFilesource, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "SMMapFilesourceOpenFile",
				  "Failed to create new object"))
		return NULL;

	self->path = s_strdup(path, error);

	if (S_CHK_ERR(error, S_CONTERR,
				  "SMMapFilesourceOpenFile",
				  "Failed to duplicate file path"))
	{
		S_DELETE(self, "SMMapFilesourceOpenFile", error);
		return NULL;
	}

	handle = s_mmapfile_open(path, &map_size, &mem, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "SMMapFilesourceOpenFile"
				  "Call to \"s_mmapfile_open\" failed for file \"%s\"",
				  path))
	{
		S_DELETE(self, "SMMapFilesourceOpenFile", error);
		return NULL;
	}

	self->handle = handle;
	self->mem = mem;
	self->map_size = map_size;

	return S_DATASOURCE(self);
}
예제 #24
0
파일: plugin.c 프로젝트: Cyofanni/speect
/* plug-in exit function */
static void plugin_exit_function(s_erc *error)
{
	S_CLR_ERR(error);

	/* free plug-in classes here */
	_s_word_pos_class_free(error);
	S_CHK_ERR(error, S_CONTERR,
			  SPCT_PLUGIN_EXIT_STR,
			  SPCT_PLUGIN_EXIT_FAIL_STR);

	S_DELETE(costFuncPlugin, SPCT_PLUGIN_EXIT_STR, error);
}
예제 #25
0
파일: plugin.c 프로젝트: Cyofanni/speect
/* plug-in exit function */
static void plugin_exit_function(s_erc *error)
{
	S_CLR_ERR(error);

	/* free plug-in classes here */
	_s_hts_engine_synth_utt_proc_104_class_free(error);
	S_CHK_ERR(error, S_CONTERR,
			  SPCT_PLUGIN_EXIT_STR,
			  SPCT_PLUGIN_EXIT_FAIL_STR);

	S_DELETE(audioPlugin, SPCT_PLUGIN_EXIT_STR, error);
}
예제 #26
0
파일: plugin.c 프로젝트: Cyofanni/speect
/* plug-in exit function */
static void plugin_exit_function(s_erc *error)
{
	S_CLR_ERR(error);

	/* free plug-in classes here */
	_s_serialized_json_syllabification_rewrites_free(error);
	S_CHK_ERR(error, S_CONTERR,
			  SPCT_PLUGIN_EXIT_STR,
			  SPCT_PLUGIN_EXIT_FAIL_STR);

	S_DELETE(syllabificationRewritesPlugin, SPCT_PLUGIN_EXIT_STR, error);
}
예제 #27
0
static int _ds_close(void * context)
{
	s_erc error;
	SDatasource * ds = (SDatasource*) context;
	S_CLR_ERR(&error);
	if (ds != NULL)
		S_DELETE(ds, "_ds_close", &error);
	if (S_CHK_ERR(&error, S_CONTERR,
		      "_ds_close",
		      "Call to \"xmlOutputClose\" failed"))
		return -1;
	return 0;
}
예제 #28
0
파일: phrase_type.c 프로젝트: mivoq/speect
static void Destroy(void *obj, s_erc *error)
{
	S_CLR_ERR(error);
	SPhraseTypeFeatProc *castSelf = S_CAST(obj, SPhraseTypeFeatProc, error);
	if (S_CHK_ERR(error, S_CONTERR,
		      "Destroy",
		      "Call to S_CAST failed"))
		return;

	if(castSelf->symbols != NULL) {
		/* delete the symbols map */
		S_DELETE(castSelf->symbols, "Destroy", error);
		castSelf->symbols = NULL;
	}
}
예제 #29
0
파일: num_syls.c 프로젝트: Cyofanni/speect
static void SetFeature(const SCostFunction *self, SItem *item, s_erc *error)
{
	SObject *extractedFeature = NULL;


	S_CLR_ERR(error);
	if (item == NULL)
	{
		S_CTX_ERR(error, S_ARGERROR,
				  "SetFeature",
				  "Argument \"item\" is NULL");
		goto quit_error;
	}

	extractedFeature = SItemPathToFeatProc(item,
										   "R:SylStructure.parent.parent.word_num_syls",
										   error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "SetFeature",
				  "Call to \"SItemPathToFeatProc\" failed"))
		goto quit_error;

	if (extractedFeature == NULL)
	{
		/* segment item might not have a word, e.g inserted silences. */
		extractedFeature = SObjectSetInt(0, error);
		if (S_CHK_ERR(error, S_CONTERR,
					  "SetFeature",
					  "Call to \"SObjectSetInt\" failed"))
			goto quit_error;
	}

	SItemSetObject(item, self->feature_name, extractedFeature, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "SetFeature",
				  "Call to \"SItemSetObject\" failed"))
		goto quit_error;

	/* all OK here */
	return;

	/* errors be here */
quit_error:
	if (extractedFeature != NULL)
		S_DELETE(extractedFeature, "SetFeature", error);
}
예제 #30
0
파일: primitives.c 프로젝트: Oghma/speect
S_API SObject *SObjectSetVoid(void *ptr,
                              const char *type_name,
                              s_svoid_free_fp free_func,
                              s_erc *error)
{
    SVoid *self;


    S_CLR_ERR(error);

    if (ptr == NULL)
    {
        S_CTX_ERR(error, S_ARGERROR,
                  "SObjectSetVoid",
                  "Argument \"ptr\" is NULL");
        return NULL;
    }

    if (type_name == NULL)
    {
        S_CTX_ERR(error, S_ARGERROR,
                  "SObjectSetVoid",
                  "Argument \"type_name\" is NULL");
        return NULL;
    }


    self = S_NEW(SVoid, error);
    if (S_CHK_ERR(error, S_FAILURE,
                  "SObjectSetVoid",
                  "Failed to create new 'SVoid' object"))
        return NULL;

    self->ptr = ptr;
    self->free_func = free_func;
    self->type_name = s_strdup(type_name, error);
    if (S_CHK_ERR(error, S_CONTERR,
                  "SObjectSetVoid",
                  "Failed to copy type name"))
    {
        S_DELETE(self, "SObjectSetVoid", error);
        return NULL;
    }

    return S_OBJECT(self);
}