static void textgrid_header(SDatasource *ds, float end_time, int size, s_erc *error)
{
const char *str = "File type = \"ooTextFile\"\nObject class = \"TextGrid\"\n\nxmin = 0\nxmax = %f\ntiers? <exists>\nsize = %d\nitem []:\n";
char *buff = NULL;
size_t str_size;
S_CLR_ERR(error);
s_asprintf(&buff, error, str, end_time, size);
if (S_CHK_ERR(error, S_CONTERR,
"textgrid_header",
"Call to \"s_asprintf\" failed"))
return;
str_size = s_strsize(buff, error);
if (S_CHK_ERR(error, S_CONTERR,
"textgrid_header",
"Call to \"s_strsize\" failed"))
{
S_FREE(buff);
return;
}
SDatasourceWrite(ds, buff, sizeof(char), str_size, error);
if (S_CHK_ERR(error, S_CONTERR,
"textgrid_header",
"Call to \"SDatasourceWrite\" failed"))
{
S_FREE(buff);
return;
}
S_FREE(buff);
}
/**
* Replace the string list element's string. The replaced string is
* freed.
*/
S_API void s_str_list_element_replace(s_str_list_element *self, const char *string,
s_erc *error)
{
char *replaced;
char *new_string;
S_CLR_ERR(error);
if ((self == NULL) || (string == NULL))
return;
new_string = s_strdup(string, error);
if (S_CHK_ERR(error, S_CONTERR,
"s_str_list_element_replace",
"Call to \"s_strdup\" failed"))
return;
replaced = s_list_element_replace(self, new_string, error);
if (S_CHK_ERR(error, S_CONTERR,
"s_str_list_element_replace",
"Call to \"s_list_element_replace\" failed"))
{
S_FREE(new_string);
return;
}
S_FREE(replaced);
}
static void
py_syck_node_free( SyckNode *self )
{
PyObject *value = PyObject_GetAttrString( (PyObject *)self, "value" );
Py_XDECREF( value );
if ( self->type_id != NULL )
S_FREE( self->type_id );
if ( self->anchor != NULL )
S_FREE( self->anchor );
S_FREE( self );
PyMem_DEL( self );
}
static void Resize(SYour *self, uint32 new_size, s_erc *error)
{
float *samples;
S_CLR_ERR(error);
samples = S_CALLOC(float, new_size);
if (samples == NULL)
{
S_FTL_ERR(error, S_MEMERROR,
"Resize",
"Failed to allocate memory for 'float' object");
return;
}
if (self->samples != NULL)
{
memmove(samples, self->samples,
sizeof(float) * ((new_size < self->num_samples) ? new_size : self->num_samples));
S_FREE(self->samples);
}
self->samples = samples;
self->num_samples = new_size;
}
static int syck_load(lua_State *L)
{
struct parser_xtra *bonus;
SyckParser *parser;
SYMID v;
int obj;
if (!luaL_checkstring(L, 1))
luaL_typerror(L, 1, "string");
parser = syck_new_parser();
parser->bonus = S_ALLOC_N(struct parser_xtra, 1);
bonus = (struct parser_xtra *)parser->bonus;
bonus->orig = L;
bonus->L = lua_newthread(L);
syck_parser_str(parser, (char *)lua_tostring(L, 1), lua_strlen(L, 1), NULL);
syck_parser_handler(parser, lua_syck_parser_handler);
syck_parser_error_handler(parser, lua_syck_error_handler);
v = syck_parse(parser);
syck_lookup_sym(parser, v, (char **)&obj);
syck_free_parser(parser);
lua_pop(L,1); //pop the thread, we don't need it anymore.
lua_xmove(bonus->L, L, 1);
if ( parser->bonus != NULL )
S_FREE( parser->bonus );
return 1;
}
/*ARGSUSED*/
static scfga_ret_t
drv_to_dyncomp(di_node_t node, const char *phys, char **dyncompp, int *l_errnop)
{
char *drv;
int inst;
const int dynlen = MAXPATHLEN;
scfga_ret_t ret;
*l_errnop = 0;
if ((*dyncompp = calloc(1, dynlen)) == NULL) {
*l_errnop = errno;
return (SCFGA_LIB_ERR);
}
drv = di_driver_name(node);
inst = di_instance(node);
if (drv != NULL && inst != -1) {
if (snprintf(*dyncompp, dynlen, "%s%d", drv, inst) < dynlen) {
return (SCFGA_OK);
} else {
ret = SCFGA_LIB_ERR;
}
} else {
ret = SCFGA_APID_NOEXIST;
}
S_FREE(*dyncompp);
return (ret);
}
/*
* Ensure that our base64 encoder can do some basic
* binary encoding.
*/
void TestBase64Encode( CuTest *tc )
{
char gif[] = "GIF89a\f\000\f\000\204\000\000\377\377\367\365\365\356\351\351\345fff\000\000\000\347\347\347^^^\363\363\355\216\216\216\340\340\340\237\237\237\223\223\223\247\247\247\236\236\236iiiccc\243\243\243\204\204\204\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371!\376\016Made with GIMP\000,\000\000\000\000\f\000\f\000\000\005, \216\2010\236\343@\024\350i\020\304\321\212\010\034\317\200M$z\357\3770\205p\270\2601f\r\e\316\001\303\001\036\020' \202\n\001\000;";
char *enc = syck_base64enc( gif, 185 );
CuAssertStrEquals( tc, enc, "R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=\n" );
S_FREE( enc );
}
/* Make logical name for HBA based on driver and instance */
static int
drv_to_hba_logid(di_node_t node, di_minor_t minor, void *arg)
{
int inst;
char *drv, *mn, *log;
pathm_t *ptp;
const size_t loglen = MAXPATHLEN;
ptp = (pathm_t *)arg;
errno = 0;
mn = di_minor_name(minor);
drv = di_driver_name(node);
inst = di_instance(node);
log = calloc(1, loglen);
if (mn != NULL && drv != NULL && inst != -1 && log != NULL) {
/* Count does not include terminating NULL */
if (snprintf(log, loglen, "%s%d:%s", drv, inst, mn) < loglen) {
ptp->ret = SCFGA_OK;
ptp->log = log;
return (DI_WALK_TERMINATE);
}
}
S_FREE(log);
return (DI_WALK_CONTINUE);
}
/**
* Insert a string after given string list element. Return reference
* to inserted string element.
*/
S_API const s_str_list_element *s_str_list_insert_after(s_str_list_element *self,
const char *string, s_erc *error)
{
const s_str_list_element *el;
char *new_string;
S_CLR_ERR(error);
if ((self == NULL) || (string == NULL))
return NULL;
new_string = s_strdup(string, error);
if (S_CHK_ERR(error, S_CONTERR,
"s_str_list_insert_after",
"Call to \"s_strdup\" failed"))
return NULL;
el = s_list_insert_after(self, new_string, error);
if (S_CHK_ERR(error, S_CONTERR,
"s_str_list_insert_after",
"Call to \"s_list_insert_after\" failed"))
{
S_FREE(new_string);
return NULL;
}
return el;
}
/* search for item, if not found create a new one and add it. */
static SItem *get_item(s_hash_table *relation_items, uint32 item_node_number, s_erc *error)
{
uint32 *item_node_number_copy;
SItem *item;
const s_hash_element *he;
/* search for item, if not found create a new one and add it. */
he = s_hash_table_find(relation_items, (void*)&item_node_number,
sizeof(uint32), error);
if (S_CHK_ERR(error, S_CONTERR,
"get_item",
"Call to \"s_hash_table_find\" failed"))
return NULL;
if (he == NULL)
{
/* create new item */
item = S_NEW(SItem, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_item",
"Failed to create new Item"))
return NULL;
item_node_number_copy = S_MALLOC(uint32, 1);
if (item_node_number_copy == NULL)
{
S_FTL_ERR(error, S_MEMERROR,
"get_item",
"Failed to allocated memory for 'uint32' object");
S_FORCE_DELETE(item, "get_item", error);
return NULL;
}
*item_node_number_copy = item_node_number;
/* add to hash table */
s_hash_table_add(relation_items, (void*)item_node_number_copy,
sizeof(uint32), (void*)item, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_item",
"Call to \"s_hash_table_add\" failed"))
{
S_FREE(item_node_number_copy);
S_FORCE_DELETE(item, "get_item", error);
return NULL;
}
}
else
{
item = (SItem*)s_hash_element_get_data(he, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_item",
"Call to \"s_hash_element_get_data\" failed"))
return NULL;
}
return item;
}
static void DestroyString(void *obj, s_erc *error)
{
SString *self = obj;
S_CLR_ERR(error);
S_FREE(self->s);
}
/* required for s_list to free an elements */
static void s_str_list_free_fp(void *le, s_erc *error)
{
char *str = le;
S_CLR_ERR(error);
S_FREE(str);
}
static void filter_destructor(SHTSEngineMESynthUttProc105 *HTSsynth)
{
int i;
for (i = 0; i < HTSsynth->me_num_filters; i++)
{
if (HTSsynth->me_filter[i] != NULL)
S_FREE(HTSsynth->me_filter[i]);
}
if (HTSsynth->me_filter != NULL)
S_FREE(HTSsynth->me_filter);
if (HTSsynth->xp_sig != NULL)
S_FREE(HTSsynth->xp_sig);
if (HTSsynth->xn_sig != NULL)
S_FREE(HTSsynth->xn_sig);
if (HTSsynth->hp != NULL)
S_FREE(HTSsynth->hp);
if (HTSsynth->hn != NULL)
S_FREE(HTSsynth->hn);
if (HTSsynth->pd_filter != NULL)
S_FREE(HTSsynth->pd_filter);
}
static void Destroy(void *obj, s_erc *error)
{
SUttBreakUttProc *self = obj;
S_CLR_ERR(error);
if (self->white_space_chars != NULL)
S_FREE(self->white_space_chars);
if (self->single_char_symbols != NULL)
S_FREE(self->single_char_symbols);
if (self->pre_punc_symbols != NULL)
S_FREE(self->pre_punc_symbols);
if (self->post_punc_symbols != NULL)
S_FREE(self->post_punc_symbols);
}
static void Destroy(void *obj, s_erc *error)
{
SCostFunction *self = obj;
S_CLR_ERR(error);
if (self->feature_name != NULL)
S_FREE(self->feature_name);
}
static scfga_recur_t
def_dyncomp_to_devlink(dyn_t *dyntp)
{
struct stat sbuf;
int top;
size_t prelen, linklen;
assert(dyntp->dyncomp != NULL);
dyntp->l_errno = 0;
if (dyntp->devlink != NULL) {
goto lib_err;
}
prelen = strlen(DEV_DIR SLASH);
linklen = strlen(dyntp->dyncomp) + 1;
/*
* Check if the dynamic component was derived from a top level entry
* in "/dev"
*/
if (strncmp(dyntp->dyncomp, DEV_DIR SLASH, prelen) == 0) {
top = 1;
} else if (*dyntp->dyncomp != '/' && linklen > 1 &&
strchr(dyntp->dyncomp + 1, '/') != NULL) {
top = 0;
linklen += prelen; /* The "/dev/" needs to be prepended */
} else {
/* Not a dynamic component we handle */
return (SCFGA_CONTINUE);
}
if ((dyntp->devlink = calloc(1, linklen)) == NULL) {
dyntp->l_errno = errno;
goto lib_err;
}
*dyntp->devlink = '\0';
if (!top) {
(void) strcpy(dyntp->devlink, DEV_DIR SLASH);
}
(void) strcat(dyntp->devlink, dyntp->dyncomp);
if (lstat(dyntp->devlink, &sbuf) != -1 && S_ISLNK(sbuf.st_mode)) {
dyntp->ret = SCFGA_OK;
return (SCFGA_TERMINATE);
}
S_FREE(dyntp->devlink);
return (SCFGA_CONTINUE);
lib_err:
dyntp->ret = SCFGA_LIB_ERR;
return (SCFGA_TERMINATE);
}
static s_bool MapPyValPresent(const SMap *self, const char *key, s_erc *error)
{
SMapPy *pMap = (SMapPy*)self;
PyObject *pKey = NULL;
int rv;
S_CLR_ERR(error);
S_CHECK_PY_MAP(pMap, "MapPyValPresent");
pKey = s_set_pyobject_str(key, error);
if (S_CHK_ERR(error, S_CONTERR,
"MapPyValPresent",
"Call to \"s_set_pyobject_str\" failed"))
return FALSE;
rv = PyDict_Contains(S_PY_DICT(pMap), pKey);
if (rv == -1)
{
char *py_error = s_get_python_error_str();
if (py_error)
{
S_CTX_ERR(error, S_FAILURE,
"MapPyValPresent",
"Call to \"PyDict_Contains\" failed. Reported error: %s",
py_error);
S_FREE(py_error);
}
else
{
S_CTX_ERR(error, S_FAILURE,
"MapPyValPresent",
"Call to \"PyDict_Contains\" failed");
}
/* decrement reference of pKey */
Py_XDECREF(pKey);
return FALSE;
}
/* decrement reference of pKey */
Py_XDECREF(pKey);
if (rv == 1)
return TRUE;
return FALSE;
/* for S_CHECK_PY_MAP */
failure:
return FALSE;
}
static void items_content_table_free_fp(void *key, void *data, s_erc *error)
{
uint32 *item_content_id;
s_items_content_container *ic;
S_CLR_ERR(error);
item_content_id = key;
ic = data;
S_FREE(item_content_id);
if (ic != NULL)
{
if (ic->content != NULL)
S_FORCE_DELETE(ic->content, "items_content_table_free_fp", error);
S_FREE(ic);
}
}
scfga_ret_t
make_dyncomp(
di_node_t node,
const char *physpath,
char **dyncompp,
int *l_errnop)
{
char *devlink = NULL;
scfga_ret_t ret;
di_minor_t minor;
char *path;
char pathbuf[MAXPATHLEN];
int match_minor;
if (*dyncompp != NULL) {
return (SCFGA_LIB_ERR);
}
/* tag on minor name */
minor = di_minor_next(node, DI_MINOR_NIL);
if (minor == DI_MINOR_NIL) {
match_minor = 0;
path = (char *)physpath;
} else {
match_minor = 1;
(void) snprintf(pathbuf, MAXPATHLEN, "%s:%s", physpath,
di_minor_name(minor));
path = pathbuf;
}
/* Get the corresponding devlink from the physical path */
ret = physpath_to_devlink(path, &devlink, l_errnop, match_minor);
if (ret == SCFGA_OK) {
assert(devlink != NULL);
/* Create dynamic component. */
ret = devlink_to_dyncomp(devlink, dyncompp, l_errnop);
S_FREE(devlink);
if (ret == SCFGA_OK) {
assert(*dyncompp != NULL);
return (SCFGA_OK);
}
/*
* Failed to get devlink based dynamic component.
* Try driver and instance
*/
}
ret = drv_to_dyncomp(node, physpath, dyncompp, l_errnop);
assert(ret != SCFGA_OK || *dyncompp != NULL);
return (ret);
}
S_API char *s_str_list_to_string(s_str_list *self, const char *separator,
s_erc *error)
{
char *buf = NULL;
const s_str_list_element *itr;
S_CLR_ERR(error);
if ((self == NULL) || (separator == NULL))
return NULL;
itr = s_str_list_first(self, error);
if (S_CHK_ERR(error, S_CONTERR,
"s_str_list_to_string",
"Call to \"s_str_list_first\" failed"))
goto error_return;
while (itr != NULL)
{
const char *element;
element = s_str_list_element_get(itr, error);
if (S_CHK_ERR(error, S_CONTERR,
"s_str_list_to_string",
"Call to \"s_str_list_element_get\" failed"))
goto error_return;
if (buf == NULL)
s_asprintf(&buf, error, "%s", element);
else
s_asprintf(&buf, error, "%s%s%s", buf, separator, element);
if (S_CHK_ERR(error, S_CONTERR,
"s_str_list_to_string",
"Call to \"s_asprintf\" failed"))
goto error_return;
itr = s_str_list_element_next(itr, error);
if (S_CHK_ERR(error, S_CONTERR,
"s_str_list_merge",
"Call to \"s_str_list_element_next\" failed"))
goto error_return;
}
return buf;
error_return:
if (buf != NULL)
S_FREE(buf);
return NULL;
}
static void DestroyMMapFilesource(void *obj, s_erc *error)
{
SMMapFilesource *self = S_MMAPFILESOURCE(obj);
S_CLR_ERR(error);
s_mmapfile_close(self->handle, self->mem, error);
S_CHK_ERR(error, S_CONTERR,
"Call to \"s_mmapfile_close\" failed for file \"%s\"",
self->path? self->path : "NULL");
if (self->path != NULL)
S_FREE(self->path);
}
static void clear_hunpos_data(SHunposUttProc *hunposProc, s_erc *error)
{
S_CLR_ERR(error);
if (hunposProc->model_file != NULL)
S_FREE(hunposProc->model_file);
if (hunposProc->hunpos_instance != NULL)
hunpos_tagger_destroy(hunposProc->hunpos_instance, error);
hunposProc->hunpos_instance = NULL;
if (S_CHK_ERR(error, S_CONTERR,
"clear_hunpos_data",
"Call to \"hunpos_tagger_destroy\" failed"))
return;
}
/* For disks remove partition information, (s or p) */
static scfga_recur_t
disk_devlink_to_dyncomp(dyn_t *dyntp)
{
char *cp = NULL, *cp1 = NULL;
assert(dyntp->devlink != NULL);
dyntp->l_errno = 0;
if (dyntp->dyncomp != NULL) {
goto lib_err;
}
/* Check if a disk devlink */
if (strncmp(dyntp->devlink, DEV_DSK SLASH, strlen(DEV_DSK SLASH)) &&
strncmp(dyntp->devlink, DEV_RDSK SLASH, strlen(DEV_RDSK SLASH))) {
return (SCFGA_CONTINUE);
}
cp = dyntp->devlink + strlen(DEV_DIR SLASH);
if ((dyntp->dyncomp = strdup(cp)) == NULL) {
dyntp->l_errno = errno;
goto lib_err;
}
/* Get the leaf component from dsk/cXtYdZsN */
cp1 = strrchr(dyntp->dyncomp, '/');
/* Blank out partition information */
dyntp->ret = SCFGA_OK;
if ((cp = strchr(cp1 + 1, 's')) != NULL) {
*cp = '\0';
} else if ((cp = strchr(cp1 + 1, 'p')) != NULL) {
*cp = '\0';
} else {
S_FREE(dyntp->dyncomp);
dyntp->ret = SCFGA_ERR;
}
return (SCFGA_TERMINATE);
lib_err:
dyntp->ret = SCFGA_LIB_ERR;
return (SCFGA_TERMINATE);
}
static void DestroyVoid(void *obj, s_erc *error)
{
SVoid *self = obj;
S_CLR_ERR(error);
if (self->free_func != NULL)
self->free_func(self->ptr, error);
S_CHK_ERR(error, S_FAILURE,
"DestroyVoid",
"Call to SVoid object free function failed");
if (self->type_name != NULL)
S_FREE(self->type_name);
}
/*
* Generates the HBA logical ap_id from physical ap_id.
*/
scfga_ret_t
make_hba_logid(const char *hba_phys, char **hba_logpp, int *l_errnop)
{
walkarg_t u;
pathm_t pmt = {NULL};
scfga_ret_t ret;
if (*hba_logpp != NULL) {
return (SCFGA_ERR);
}
/* A devlink for the HBA may or may not exist */
if (get_hba_devlink(hba_phys, hba_logpp, l_errnop) == SCFGA_OK) {
assert(*hba_logpp != NULL);
return (SCFGA_OK);
}
/*
* No devlink based logical ap_id.
* Try driver name and instance number.
*/
u.minor_args.nodetype = DDI_NT_SCSI_ATTACHMENT_POINT;
u.minor_args.fcn = drv_to_hba_logid;
pmt.phys = (char *)hba_phys;
pmt.ret = SCFGA_APID_NOEXIST;
errno = 0;
ret = walk_tree(pmt.phys, &pmt, DINFOMINOR | DINFOPROP, &u,
SCFGA_WALK_MINOR, &pmt.l_errno);
if (ret == SCFGA_OK && (ret = pmt.ret) == SCFGA_OK) {
assert(pmt.log != NULL);
*hba_logpp = pmt.log;
return (SCFGA_OK);
}
/* failed to create logical ap_id */
if (pmt.log != NULL) {
S_FREE(pmt.log);
}
*l_errnop = pmt.l_errno;
return (ret);
}
S_API void SObjectResetString(SObject *self, const char *s, s_erc *error)
{
char *tmp;
s_bool type_is_good;
S_CLR_ERR(error);
if (self == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SObjectResetString",
"Argument \"self\" is NULL");
return;
}
type_is_good = SObjectIsType(self, "SString", error);
if (S_CHK_ERR(error, S_CONTERR,
"SObjectResetString",
"Call to \"SObjectIsType\" failed"))
return;
if (type_is_good == FALSE)
{
S_CTX_ERR(error, S_FAILURE,
"SObjectResetString",
"Given object \"self\" is not of type SString");
return;
}
tmp = ((SString*)self)->s;
S_FREE(tmp); /* checks !NULL */
if (s != NULL)
{
((SString*)self)->s = s_strdup(s, error);
S_CHK_ERR(error, S_CONTERR,
"SObjectResetString",
"Failed to copy new string");
}
else
{
((SString*)self)->s = NULL;
}
}
static void InitWindow(SWinFunc **self, sint32 size, sint32 centre, s_erc *error)
{
uint32 i;
S_CLR_ERR(error);
if (size <= 0)
{
S_CTX_ERR(error, S_FAILURE,
"InitWindow",
"Window function given a 0 or negative size (%d)",
size);
goto quit_error;
}
/* nothing to do, window is correct */
if ((uint32)size == (*self)->num_samples)
return;
if ((*self)->samples != NULL)
S_FREE((*self)->samples);
(*self)->samples = S_MALLOC(float, size);
if ((*self)->samples == NULL)
{
S_FTL_ERR(error, S_MEMERROR,
"InitWindow",
"Failed to allocate memory for 'float' object");
goto quit_error;
}
(*self)->num_samples = size;
for (i = 0; i < (*self)->num_samples; i++)
(*self)->samples[i] = 1.0;
quit_error:
S_DELETE(*self, "InitWindow", error);
*self = NULL;
S_UNUSED(centre);
}
static void MapPyValDelete(SMap *self, const char *key, s_erc *error)
{
SMapPy *pMap = (SMapPy*)self;
PyObject *pKey = NULL;
S_CLR_ERR(error);
S_CHECK_PY_MAP(pMap, "MapPyValDelete");
pKey = s_set_pyobject_str(key, error);
if (S_CHK_ERR(error, S_CONTERR,
"MapPyValDelete",
"Call to \"s_set_pyobject_str\" failed"))
return;
if (PyObject_DelItem(S_PY_DICT(pMap), pKey) == -1)
{
char *py_error = s_get_python_error_str();
if (py_error)
{
S_CTX_ERR(error, S_FAILURE,
"MapPyValDelete",
"Call to \"PyObject_DelItem\" failed. Reported error: %s",
py_error);
S_FREE(py_error);
}
else
{
S_CTX_ERR(error, S_FAILURE,
"MapPyValDelete",
"Call to \"PyObject_DelItem\" failed");
}
}
/* decrement reference of pkey */
Py_XDECREF(pKey);
/* for S_CHECK_PY_MAP */
failure:
return;
}
static void relation_items_table_free_fp(void *key, void *data, s_erc *error)
{
uint32 *item_node_number;
S_CLR_ERR(error);
item_node_number = key;
/*
* data are items. As soon as get_item is called (the item is
* either retrieved from the table or created and added to the table)
* then the item is also connected to the relation. So we do not need
* to delete the item, as when we delete the relation the item will go
* as well.
*/
if (item_node_number != NULL)
S_FREE(item_node_number);
S_UNUSED(data);
}
static char *PrintVoid(const SObject *self, s_erc *error)
{
const char *type = "[SVoid] %p";
char *buf;
S_CLR_ERR(error);
s_asprintf(&buf, error, type, ((SVoid*)self)->ptr);
if (S_CHK_ERR(error, S_CONTERR,
"PrintVoid",
"Call to \"s_asprintf\" failed"))
{
if (buf != NULL)
S_FREE(buf);
return NULL;
}
return buf;
}
