summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/array.c164
-rw-r--r--src/avl_tree.c78
-rw-r--r--src/builtin_hashes.c66
-rw-r--r--src/conf.c186
-rw-r--r--src/dlinked_list.c194
-rw-r--r--src/file.c12
-rw-r--r--src/linked_list.c176
-rw-r--r--src/mbuff.c148
-rw-r--r--src/mem.c58
-rw-r--r--src/module.c56
-rw-r--r--src/msgs.c22
-rw-r--r--src/obj.c14
-rw-r--r--src/objpair.c24
-rw-r--r--src/options.c30
-rw-r--r--src/pthreads.c114
-rw-r--r--src/regexp.c62
-rw-r--r--src/socket.c136
-rw-r--r--src/str.c196
-rw-r--r--src/strings.c148
-rw-r--r--src/tok.c52
-rw-r--r--src/url.c94
-rw-r--r--src/ustr.c196
22 files changed, 1113 insertions, 1113 deletions
diff --git a/src/array.c b/src/array.c
index c432efd..55fc532 100644
--- a/src/array.c
+++ b/src/array.c
@@ -189,7 +189,7 @@ spif_array_list_new(void)
self = SPIF_ALLOC(array);
if (!spif_array_list_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(array);
+ self = (spif_array_t) NULL;
}
return self;
}
@@ -204,7 +204,7 @@ spif_array_list_init(spif_array_t self)
return FALSE;
}
self->len = 0;
- self->items = SPIF_NULL_TYPE_C(spif_obj_t *);
+ self->items = (spif_obj_t *) NULL;
return TRUE;
}
@@ -216,7 +216,7 @@ spif_array_vector_new(void)
self = SPIF_ALLOC(array);
if (!spif_array_vector_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(array);
+ self = (spif_array_t) NULL;
}
return self;
}
@@ -229,7 +229,7 @@ spif_array_map_new(void)
self = SPIF_ALLOC(array);
if (!spif_array_map_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(array);
+ self = (spif_array_t) NULL;
}
return self;
}
@@ -244,7 +244,7 @@ spif_array_vector_init(spif_array_t self)
return FALSE;
}
self->len = 0;
- self->items = SPIF_NULL_TYPE_C(spif_obj_t *);
+ self->items = (spif_obj_t *) NULL;
return TRUE;
}
@@ -258,7 +258,7 @@ spif_array_map_init(spif_array_t self)
return FALSE;
}
self->len = 0;
- self->items = SPIF_NULL_TYPE_C(spif_obj_t *);
+ self->items = (spif_obj_t *) NULL;
return TRUE;
}
@@ -301,20 +301,20 @@ spif_array_show(spif_array_t self, spif_charptr_t name, spif_str_t buff, size_t
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
- "(spif_array_t) %s: %10p {\n", name, SPIF_CAST(ptr) self);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
+ "(spif_array_t) %s: %10p {\n", name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
- spif_str_append_from_ptr(buff, SPIF_CAST(charptr) tmp);
+ spif_str_append_from_ptr(buff, (spif_charptr_t) tmp);
}
if (SPIF_ARRAY_ISNULL(self->items)) {
- spif_str_append_from_ptr(buff, SPIF_CAST(charptr) SPIF_NULLSTR_TYPE_PTR(obj));
+ spif_str_append_from_ptr(buff, (spif_charptr_t) SPIF_NULLSTR_TYPE_PTR(obj));
} else {
for (i = 0; i < self->len; i++) {
spif_obj_t o = self->items[i];
- sprintf(SPIF_CAST_C(char *) tmp, "item %d", i);
+ sprintf((char *) tmp, "item %d", i);
if (SPIF_OBJ_ISNULL(o)) {
char tmp2[4096];
@@ -326,8 +326,8 @@ spif_array_show(spif_array_t self, spif_charptr_t name, spif_str_t buff, size_t
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent, "}\n");
- spif_str_append_from_ptr(buff, SPIF_CAST(charptr) tmp);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
+ spif_str_append_from_ptr(buff, (spif_charptr_t) tmp);
return buff;
}
@@ -361,14 +361,14 @@ spif_array_list_dup(spif_array_t self)
spif_array_t tmp;
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(array));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_array_t) NULL);
tmp = spif_array_list_new();
- REQUIRE_RVAL(!SPIF_ARRAY_ISNULL(tmp), SPIF_NULL_TYPE(array));
+ REQUIRE_RVAL(!SPIF_ARRAY_ISNULL(tmp), (spif_array_t) NULL);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(array));
- tmp->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
+ tmp->items = (spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
for (i = 0; i < self->len; i++) {
- tmp->items[i] = SPIF_CAST(obj) SPIF_OBJ_DUP(SPIF_OBJ(self->items[i]));
+ tmp->items[i] = (spif_obj_t) SPIF_OBJ_DUP(SPIF_OBJ(self->items[i]));
}
return tmp;
}
@@ -379,14 +379,14 @@ spif_array_vector_dup(spif_array_t self)
spif_array_t tmp;
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(array));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_array_t) NULL);
tmp = spif_array_vector_new();
- REQUIRE_RVAL(!SPIF_ARRAY_ISNULL(tmp), SPIF_NULL_TYPE(array));
+ REQUIRE_RVAL(!SPIF_ARRAY_ISNULL(tmp), (spif_array_t) NULL);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(array));
- tmp->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
+ tmp->items = (spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
for (i = 0; i < self->len; i++) {
- tmp->items[i] = SPIF_CAST(obj) SPIF_OBJ_DUP(SPIF_OBJ(self->items[i]));
+ tmp->items[i] = (spif_obj_t) SPIF_OBJ_DUP(SPIF_OBJ(self->items[i]));
}
return tmp;
}
@@ -397,14 +397,14 @@ spif_array_map_dup(spif_array_t self)
spif_array_t tmp;
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(array));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_array_t) NULL);
tmp = spif_array_map_new();
- REQUIRE_RVAL(!SPIF_ARRAY_ISNULL(tmp), SPIF_NULL_TYPE(array));
+ REQUIRE_RVAL(!SPIF_ARRAY_ISNULL(tmp), (spif_array_t) NULL);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(array));
- tmp->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
+ tmp->items = (spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
for (i = 0; i < self->len; i++) {
- tmp->items[i] = SPIF_CAST(obj) SPIF_OBJ_DUP(SPIF_OBJ(self->items[i]));
+ tmp->items[i] = (spif_obj_t) SPIF_OBJ_DUP(SPIF_OBJ(self->items[i]));
}
return tmp;
}
@@ -412,7 +412,7 @@ spif_array_map_dup(spif_array_t self)
static spif_classname_t
spif_array_type(spif_array_t self)
{
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -422,9 +422,9 @@ spif_array_append(spif_array_t self, spif_obj_t obj)
ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), FALSE);
self->len++;
if (self->items) {
- self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
+ self->items = (spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
} else {
- self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
+ self->items = (spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
}
self->items[self->len - 1] = obj;
return TRUE;
@@ -447,7 +447,7 @@ spif_array_vector_contains(spif_array_t self, spif_obj_t obj)
static spif_listidx_t
spif_array_count(spif_array_t self)
{
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(listidx));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_listidx_t) NULL);
return self->len;
}
@@ -456,8 +456,8 @@ spif_array_list_find(spif_array_t self, spif_obj_t obj)
{
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), (spif_obj_t) NULL);
for (i = 0; i < self->len; i++) {
if (SPIF_OBJ_ISNULL(self->items[i])) {
continue;
@@ -466,7 +466,7 @@ spif_array_list_find(spif_array_t self, spif_obj_t obj)
return self->items[i];
}
}
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_obj_t
@@ -475,9 +475,9 @@ spif_array_vector_find(spif_array_t self, spif_obj_t obj)
spif_listidx_t start, end, mid;
spif_cmp_t diff;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(self->len > 0, SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), (spif_obj_t) NULL);
+ REQUIRE_RVAL(self->len > 0, (spif_obj_t) NULL);
for (start = 0, end = self->len - 1; start <= end; ) {
mid = (end - start) / 2 + start;
@@ -488,22 +488,22 @@ spif_array_vector_find(spif_array_t self, spif_obj_t obj)
start = mid + 1;
} else {
end = mid - 1;
- if (end == SPIF_CAST(listidx) -1) {
+ if (end == (spif_listidx_t) -1) {
break;
}
}
}
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_obj_t
spif_array_get(spif_array_t self, spif_listidx_t idx)
{
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_obj_t) NULL);
if (idx < 0) {
idx += self->len;
}
- return (((idx >= 0) && (idx < self->len)) ? (self->items[idx]) : (SPIF_NULL_TYPE(obj)));
+ return (((idx >= 0) && (idx < self->len)) ? (self->items[idx]) : ((spif_obj_t) NULL));
}
static spif_obj_t
@@ -512,9 +512,9 @@ spif_array_map_get(spif_array_t self, spif_obj_t key)
spif_listidx_t start, end, mid;
spif_cmp_t diff;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(key), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(self->len > 0, SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(key), (spif_obj_t) NULL);
+ REQUIRE_RVAL(self->len > 0, (spif_obj_t) NULL);
for (start = 0, end = self->len - 1; start <= end; ) {
mid = (end - start) / 2 + start;
@@ -525,12 +525,12 @@ spif_array_map_get(spif_array_t self, spif_obj_t key)
start = mid + 1;
} else {
end = mid - 1;
- if (end == SPIF_CAST(listidx) -1) {
+ if (end == (spif_listidx_t) -1) {
break;
}
}
}
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_list_t
@@ -538,7 +538,7 @@ spif_array_get_keys(spif_array_t self, spif_list_t key_list)
{
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(list));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_list_t) NULL);
if (SPIF_LIST_ISNULL(key_list)) {
key_list = SPIF_LIST_NEW(array);
}
@@ -554,7 +554,7 @@ spif_array_get_pairs(spif_array_t self, spif_list_t pair_list)
{
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(list));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_list_t) NULL);
if (SPIF_LIST_ISNULL(pair_list)) {
pair_list = SPIF_LIST_NEW(array);
}
@@ -570,7 +570,7 @@ spif_array_get_values(spif_array_t self, spif_list_t value_list)
{
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(list));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_list_t) NULL);
if (SPIF_LIST_ISNULL(value_list)) {
value_list = SPIF_LIST_NEW(array);
}
@@ -612,7 +612,7 @@ spif_array_index(spif_array_t self, spif_obj_t obj)
{
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_CAST(listidx) -1);
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_listidx_t) -1);
for (i = 0; i < self->len; i++) {
if (SPIF_OBJ_ISNULL(self->items[i])) {
if (SPIF_OBJ_ISNULL(obj)) {
@@ -624,7 +624,7 @@ spif_array_index(spif_array_t self, spif_obj_t obj)
return i;
}
}
- return SPIF_CAST(listidx) (-1);
+ return (spif_listidx_t) (-1);
}
static spif_bool_t
@@ -635,9 +635,9 @@ spif_array_insert(spif_array_t self, spif_obj_t obj)
ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), FALSE);
REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), FALSE);
if (self->items) {
- self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * (self->len + 1));
+ self->items = (spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * (self->len + 1));
} else {
- self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * (self->len + 1));
+ self->items = (spif_obj_t *) MALLOC(sizeof(spif_obj_t) * (self->len + 1));
}
for (i = 0; i < self->len && SPIF_CMP_IS_GREATER(SPIF_OBJ_COMP(obj, self->items[i])); i++);
@@ -672,9 +672,9 @@ spif_array_insert_at(spif_array_t self, spif_obj_t obj, spif_listidx_t idx)
}
if (self->items) {
- self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * (self->len + 1));
+ self->items = (spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * (self->len + 1));
} else {
- self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * (self->len + 1));
+ self->items = (spif_obj_t *) MALLOC(sizeof(spif_obj_t) * (self->len + 1));
}
if (left > 0) {
@@ -693,8 +693,8 @@ spif_array_insert_at(spif_array_t self, spif_obj_t obj, spif_listidx_t idx)
static spif_iterator_t
spif_array_iterator(spif_array_t self)
{
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(iterator));
- return SPIF_CAST(iterator) spif_array_iterator_new(self);
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_iterator_t) NULL);
+ return (spif_iterator_t) spif_array_iterator_new(self);
}
static spif_bool_t
@@ -703,9 +703,9 @@ spif_array_prepend(spif_array_t self, spif_obj_t obj)
ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), FALSE);
REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), FALSE);
if (self->items) {
- self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * (self->len + 1));
+ self->items = (spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * (self->len + 1));
} else {
- self->items = SPIF_CAST_C(spif_obj_t *) MALLOC(sizeof(spif_obj_t) * (self->len + 1));
+ self->items = (spif_obj_t *) MALLOC(sizeof(spif_obj_t) * (self->len + 1));
}
memmove(self->items + 1, self->items, sizeof(spif_obj_t) * self->len);
@@ -720,18 +720,18 @@ spif_array_remove(spif_array_t self, spif_obj_t item)
spif_obj_t tmp;
spif_listidx_t i, left;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), (spif_obj_t) NULL);
for (i = 0; i < self->len && !SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(item, self->items[i])); i++);
if (i == self->len) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
left = self->len - i - 1;
tmp = self->items[i];
memmove(self->items + i, self->items + i + 1, sizeof(spif_obj_t) * left);
self->len--;
- self->items = SPIF_CAST_PTR(obj) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
+ self->items = (spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
return tmp;
}
@@ -742,18 +742,18 @@ spif_array_map_remove(spif_array_t self, spif_obj_t item)
spif_obj_t tmp;
spif_listidx_t i, left;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), (spif_obj_t) NULL);
for (i = 0; i < self->len && !SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(self->items[i], item)); i++);
if (i == self->len) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
left = self->len - i - 1;
tmp = self->items[i];
memmove(self->items + i, self->items + i + 1, sizeof(spif_obj_t) * left);
self->len--;
- self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
+ self->items = (spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
return tmp;
}
@@ -764,20 +764,20 @@ spif_array_remove_at(spif_array_t self, spif_listidx_t idx)
spif_obj_t tmp;
spif_listidx_t left;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_obj_t) NULL);
if (idx < 0) {
/* Negative indexes go backward from the end of the list. */
idx += self->len;
}
if ((idx < 0) || (idx >= self->len)) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
left = self->len - idx - 1;
tmp = self->items[idx];
memmove(self->items + idx, self->items + idx + 1, sizeof(spif_obj_t) * left);
self->len--;
- self->items = SPIF_CAST_C(spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
+ self->items = (spif_obj_t *) REALLOC(self->items, sizeof(spif_obj_t) * self->len);
return tmp;
}
@@ -823,8 +823,8 @@ spif_array_to_array(spif_array_t self)
spif_obj_t *tmp;
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), SPIF_NULL_TYPE_PTR(obj));
- tmp = SPIF_CAST_PTR(obj) MALLOC(sizeof(spif_obj_t) * self->len);
+ ASSERT_RVAL(!SPIF_ARRAY_ISNULL(self), (spif_obj_t *) NULL);
+ tmp = (spif_obj_t *) MALLOC(sizeof(spif_obj_t) * self->len);
for (i = 0; i < self->len; i++) {
tmp[i] = SPIF_OBJ(self->items[i]);
}
@@ -839,7 +839,7 @@ spif_array_iterator_new(spif_array_t subject)
self = SPIF_ALLOC(array_iterator);
if (!spif_array_iterator_init(self, subject)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(array_iterator);
+ self = (spif_array_iterator_t) NULL;
}
return self;
}
@@ -862,7 +862,7 @@ static spif_bool_t
spif_array_iterator_done(spif_array_iterator_t self)
{
ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), FALSE);
- self->subject = SPIF_NULL_TYPE(array);
+ self->subject = (spif_array_t) NULL;
self->current_index = 0;
return TRUE;
}
@@ -889,23 +889,23 @@ spif_array_iterator_show(spif_array_iterator_t self, spif_charptr_t name, spif_s
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
- "(spif_array_iterator_t) %s: %10p {\n", name, SPIF_CAST(ptr) self);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
+ "(spif_array_iterator_t) %s: %10p {\n", name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
spif_str_append_from_ptr(buff, tmp);
}
- buff = spif_array_show(self->subject, SPIF_CAST(charptr) "subject", buff, indent + 2);
+ buff = spif_array_show(self->subject, (spif_charptr_t) "subject", buff, indent + 2);
memset(tmp, ' ', indent + 2);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
" (spif_listidx_t) current_index: %lu\n",
- SPIF_CAST_C(unsigned long) self->current_index);
+ (unsigned long) self->current_index);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent, "}\n");
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -930,7 +930,7 @@ spif_array_iterator_dup(spif_array_iterator_t self)
{
spif_array_iterator_t tmp;
- ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(array_iterator));
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), (spif_array_iterator_t) NULL);
tmp = spif_array_iterator_new(self->subject);
tmp->current_index = self->current_index;
return tmp;
@@ -939,7 +939,7 @@ spif_array_iterator_dup(spif_array_iterator_t self)
static spif_classname_t
spif_array_iterator_type(spif_array_iterator_t self)
{
- ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -963,8 +963,8 @@ spif_array_iterator_next(spif_array_iterator_t self)
{
spif_obj_t tmp;
- ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->subject), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->subject), (spif_obj_t) NULL);
tmp = spif_array_get(self->subject, self->current_index);
self->current_index++;
return tmp;
diff --git a/src/avl_tree.c b/src/avl_tree.c
index 2c7754d..25673f2 100644
--- a/src/avl_tree.c
+++ b/src/avl_tree.c
@@ -117,7 +117,7 @@ spif_avl_tree_node_new(void)
self = SPIF_ALLOC(avl_tree_node);
if (!spif_avl_tree_node_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(avl_tree_node);
+ self = (spif_avl_tree_node_t) NULL;
}
return self;
}
@@ -126,9 +126,9 @@ static spif_bool_t
spif_avl_tree_node_init(spif_avl_tree_node_t self)
{
ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(self), FALSE);
- self->data = SPIF_NULL_TYPE(obj);
+ self->data = (spif_obj_t) NULL;
self->balance = BALANCED;
- self->left = self->right = SPIF_NULL_TYPE(avl_tree_node);
+ self->left = self->right = (spif_avl_tree_node_t) NULL;
return TRUE;
}
@@ -136,17 +136,17 @@ static spif_bool_t
spif_avl_tree_node_done(spif_avl_tree_node_t self)
{
ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(self), FALSE);
- if (self->data != SPIF_NULL_TYPE(obj)) {
+ if (self->data != (spif_obj_t) NULL) {
SPIF_OBJ_DEL(self->data);
- self->data = SPIF_NULL_TYPE(obj);
+ self->data = (spif_obj_t) NULL;
}
- if (self->left != SPIF_NULL_TYPE(avl_tree_node)) {
+ if (self->left != (spif_avl_tree_node_t) NULL) {
spif_avl_tree_node_done(self->left);
- self->left = SPIF_NULL_TYPE(avl_tree_node);
+ self->left = (spif_avl_tree_node_t) NULL;
}
- if (self->right != SPIF_NULL_TYPE(avl_tree_node)) {
+ if (self->right != (spif_avl_tree_node_t) NULL) {
spif_avl_tree_node_done(self->right);
- self->right = SPIF_NULL_TYPE(avl_tree_node);
+ self->right = (spif_avl_tree_node_t) NULL;
}
self->balance = BALANCED;
return TRUE;
@@ -219,7 +219,7 @@ spif_avl_tree_node_dup(spif_avl_tree_node_t self)
{
spif_avl_tree_node_t tmp;
- ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(self), SPIF_NULL_TYPE(avl_tree_node));
+ ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(self), (spif_avl_tree_node_t) NULL);
tmp = spif_avl_tree_node_new();
tmp->data = SPIF_OBJ_DUP(self->data);
tmp->balance = self->balance;
@@ -235,7 +235,7 @@ spif_avl_tree_node_dup(spif_avl_tree_node_t self)
static spif_classname_t
spif_avl_tree_node_type(spif_avl_tree_node_t self)
{
- ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(self), (spif_classname_t) NULL);
USE_VAR(self);
return SPIF_CLASS_VAR(avl_tree_node)->classname;
}
@@ -254,7 +254,7 @@ spif_avl_tree_new(void)
self = SPIF_ALLOC(avl_tree);
if (!spif_avl_tree_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(avl_tree);
+ self = (spif_avl_tree_t) NULL;
}
return self;
}
@@ -266,7 +266,7 @@ spif_avl_tree_init(spif_avl_tree_t self)
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_VECTORCLASS_VAR(avl_tree)));
self->len = 0;
- self->root = SPIF_NULL_TYPE(avl_tree_node);
+ self->root = (spif_avl_tree_node_t) NULL;
return TRUE;
}
@@ -276,7 +276,7 @@ spif_avl_tree_done(spif_avl_tree_t self)
ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), FALSE);
if (self->len) {
spif_avl_tree_node_del(self->root);
- self->root = SPIF_NULL_TYPE(avl_tree_node);
+ self->root = (spif_avl_tree_node_t) NULL;
self->len = 0;
}
return TRUE;
@@ -309,7 +309,7 @@ spif_avl_tree_show(spif_avl_tree_t self, spif_charptr_t name, spif_str_t buff, s
spif_str_append_from_ptr(buff, tmp);
}
- snprintf(tmp + indent, sizeof(tmp) - indent, " len: %lu\n", SPIF_CAST_C(unsigned long) self->len);
+ snprintf(tmp + indent, sizeof(tmp) - indent, " len: %lu\n", (unsigned long) self->len);
spif_str_append_from_ptr(buff, tmp);
if (SPIF_AVL_TREE_NODE_ISNULL(self->root)) {
@@ -336,7 +336,7 @@ spif_avl_tree_dup(spif_avl_tree_t self)
{
spif_avl_tree_t tmp;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(avl_tree));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_avl_tree_t) NULL);
tmp = spif_avl_tree_new();
tmp->root = spif_avl_tree_node_dup(self->root);
tmp->len = self->len;
@@ -346,7 +346,7 @@ spif_avl_tree_dup(spif_avl_tree_t self)
static spif_classname_t
spif_avl_tree_type(spif_avl_tree_t self)
{
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -360,7 +360,7 @@ spif_avl_tree_contains(spif_avl_tree_t self, spif_obj_t obj)
static spif_listidx_t
spif_avl_tree_count(spif_avl_tree_t self)
{
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(listidx));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_listidx_t) NULL);
return self->len;
}
@@ -369,8 +369,8 @@ spif_avl_tree_find(spif_avl_tree_t self, spif_obj_t obj)
{
spif_avl_tree_node_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), (spif_obj_t) NULL);
for (current = self->root; current; ) {
spif_cmp_t cmp;
@@ -383,7 +383,7 @@ spif_avl_tree_find(spif_avl_tree_t self, spif_obj_t obj)
current = current->left;
}
}
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_bool_t
@@ -417,7 +417,7 @@ static spif_obj_t
spif_avl_tree_next(spif_avl_tree_t self)
{
USE_VAR(self);
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_obj_t
@@ -425,10 +425,10 @@ spif_avl_tree_remove(spif_avl_tree_t self, spif_obj_t item)
{
spif_avl_tree_node_t current, tmp;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), (spif_obj_t) NULL);
if (SPIF_AVL_TREE_NODE_ISNULL(self->root)) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
} else if (SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(item, self->root->data))) {
tmp = self->root;
self->root = self->root->next;
@@ -438,11 +438,11 @@ spif_avl_tree_remove(spif_avl_tree_t self, spif_obj_t item)
tmp = current->next;
current->next = current->next->next;
} else {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
}
item = tmp->data;
- tmp->data = SPIF_NULL_TYPE(obj);
+ tmp->data = (spif_obj_t) NULL;
spif_avl_tree_node_del(tmp);
self->len--;
@@ -456,10 +456,10 @@ spif_avl_tree_to_array(spif_avl_tree_t self)
spif_avl_tree_node_t current;
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE_PTR(obj));
- tmp = SPIF_CAST_PTR(obj) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_obj_t *) NULL);
+ tmp = (spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
for (i = 0, current = self->root; i < self->len; current = current->next, i++) {
- tmp[i] = SPIF_CAST(obj) SPIF_OBJ(spif_avl_tree_node_get_data(current));
+ tmp[i] = (spif_obj_t) SPIF_OBJ(spif_avl_tree_node_get_data(current));
}
return tmp;
}
@@ -476,7 +476,7 @@ insert_node(spif_avl_tree_node_t root, spif_avl_tree_node_t node, spif_uint8_t *
int taller_subnode = 0;
spif_cmp_t diff;
- ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(root), SPIF_NULL_TYPE(avl_tree_node));
+ ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(root), (spif_avl_tree_node_t) NULL);
ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(node), root);
ASSERT_RVAL(!SPIF_PTR_ISNULL(taller), root);
@@ -578,7 +578,7 @@ remove_node(spif_avl_tree_node_t root, spif_avl_tree_node_t node, spif_avl_tree_
int shorter_subnode = 0;
spif_cmp_t diff;
- ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(root), SPIF_NULL_TYPE(avl_tree_node));
+ ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(root), (spif_avl_tree_node_t) NULL);
ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(node), root);
ASSERT_RVAL(!SPIF_PTR_ISNULL(removed), root);
ASSERT_RVAL(!SPIF_PTR_ISNULL(shorter), root);
@@ -621,7 +621,7 @@ remove_node(spif_avl_tree_node_t root, spif_avl_tree_node_t node, spif_avl_tree_
/* node must be in the left subtree of root. */
if (SPIF_AVL_TREE_NODE_ISNULL(root->left)) {
/* Nothing there. We didn't find it. */
- *removed = SPIF_NULL_TYPE(avl_tree_node);
+ *removed = (spif_avl_tree_node_t) NULL;
return root;
} else {
/* Search the left tree. */
@@ -695,12 +695,12 @@ left_balance(spif_avl_tree_node_t root)
{
spif_avl_tree_node_t node, subnode;
- ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(root), SPIF_NULL_TYPE(avl_tree_node));
+ ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(root), (spif_avl_tree_node_t) NULL);
node = root->left;
ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(node), root);
- subnode = SPIF_NULL_TYPE(avl_tree_node);
+ subnode = (spif_avl_tree_node_t) NULL;
switch (node->balance) {
case LEFT_HEAVY:
@@ -740,12 +740,12 @@ right_balance(spif_avl_tree_node_t root)
{
spif_avl_tree_node_t node, subnode;
- ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(root), SPIF_NULL_TYPE(avl_tree_node));
+ ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(root), (spif_avl_tree_node_t) NULL);
node = root->right;
ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(node), root);
- subnode = SPIF_NULL_TYPE(avl_tree_node);
+ subnode = (spif_avl_tree_node_t) NULL;
switch (node->balance) {
case RIGHT_HEAVY:
@@ -785,7 +785,7 @@ rotate_left(spif_avl_tree_node_t node)
{
spif_avl_tree_node_t right_child;
- ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(node), SPIF_NULL_TYPE(avl_tree_node));
+ ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(node), (spif_avl_tree_node_t) NULL);
ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(node->right), node);
right_child = node->right;
@@ -800,7 +800,7 @@ rotate_right(spif_avl_tree_node_t node)
{
spif_avl_tree_node_t left_child;
- ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(node), SPIF_NULL_TYPE(avl_tree_node));
+ ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(node), (spif_avl_tree_node_t) NULL);
ASSERT_RVAL(!SPIF_AVL_TREE_NODE_ISNULL(node->left), node);
left_child = node->left;
diff --git a/src/builtin_hashes.c b/src/builtin_hashes.c
index 5c35eb1..7fda314 100644
--- a/src/builtin_hashes.c
+++ b/src/builtin_hashes.c
@@ -29,7 +29,7 @@ static const char __attribute__((unused)) cvs_ident[] = "$Id$";
#include <libast_internal.h>
-#define BUILTIN_RANDOM_SEED (SPIF_CAST(uint32) 0xf721b64d)
+#define BUILTIN_RANDOM_SEED ((spif_uint32_t) 0xf721b64d)
/*
* Bob Jenkins' hash algorithm as published in December 1996. Public
@@ -67,9 +67,9 @@ spifhash_jenkins(register spif_uint8_t *key, register spif_uint32_t length, regi
/* The loop below handles most of the key (all but the last
length % 12 bytes). */
while (len >= 12) {
- a += (key[0] + (SPIF_CAST(uint32) key[1] << 8) + (SPIF_CAST(uint32) key[2] << 16) + (SPIF_CAST(uint32) key[3] << 24));
- b += (key[4] + (SPIF_CAST(uint32) key[5] << 8) + (SPIF_CAST(uint32) key[6] << 16) + (SPIF_CAST(uint32) key[7] << 24));
- c += (key[8] + (SPIF_CAST(uint32) key[9] << 8) + (SPIF_CAST(uint32) key[10] << 16) + (SPIF_CAST(uint32) key[11] << 24));
+ a += (key[0] + ((spif_uint32_t) key[1] << 8) + ((spif_uint32_t) key[2] << 16) + ((spif_uint32_t) key[3] << 24));
+ b += (key[4] + ((spif_uint32_t) key[5] << 8) + ((spif_uint32_t) key[6] << 16) + ((spif_uint32_t) key[7] << 24));
+ c += (key[8] + ((spif_uint32_t) key[9] << 8) + ((spif_uint32_t) key[10] << 16) + ((spif_uint32_t) key[11] << 24));
SPIFHASH_JENKINS_MIX(a, b, c);
key += 12;
len -= 12;
@@ -79,16 +79,16 @@ spifhash_jenkins(register spif_uint8_t *key, register spif_uint32_t length, regi
bytes. All cases drop through to the next case. */
c += length;
switch (len) {
- case 11: c += (SPIF_CAST(uint32) key[10] << 24);
- case 10: c += (SPIF_CAST(uint32) key[9] << 16);
- case 9: c += (SPIF_CAST(uint32) key[8] << 8);
- case 8: b += (SPIF_CAST(uint32) key[7] << 24);
- case 7: b += (SPIF_CAST(uint32) key[6] << 16);
- case 6: b += (SPIF_CAST(uint32) key[5] << 8);
+ case 11: c += ((spif_uint32_t) key[10] << 24);
+ case 10: c += ((spif_uint32_t) key[9] << 16);
+ case 9: c += ((spif_uint32_t) key[8] << 8);
+ case 8: b += ((spif_uint32_t) key[7] << 24);
+ case 7: b += ((spif_uint32_t) key[6] << 16);
+ case 6: b += ((spif_uint32_t) key[5] << 8);
case 5: b += key[4];
- case 4: a += (SPIF_CAST(uint32) key[3] << 24);
- case 3: a += (SPIF_CAST(uint32) key[2] << 16);
- case 2: a += (SPIF_CAST(uint32) key[1] << 8);
+ case 4: a += ((spif_uint32_t) key[3] << 24);
+ case 3: a += ((spif_uint32_t) key[2] << 16);
+ case 2: a += ((spif_uint32_t) key[1] << 8);
case 1: a += key[0];
/* case 0: nothing left to add */
}
@@ -119,7 +119,7 @@ spif_uint32_t
spifhash_jenkins32(spif_uint8_t *key, register spif_uint32_t length, register spif_uint32_t seed)
{
register spif_uint32_t a, b, c, len;
- register spif_uint32_t *key_dword = SPIF_CAST_PTR(uint32) key;
+ register spif_uint32_t *key_dword = (spif_uint32_t *) key;
len = length;
a = b = BUILTIN_RANDOM_SEED; /* This can be any 32-bit value. */
@@ -178,12 +178,12 @@ spifhash_jenkinsLE(register spif_uint8_t *key, register spif_uint32_t length, re
/* The loop below handles most of the key (all but the last
length % 12 bytes). */
- if ((SPIF_CAST(uint32) key) & 3) {
+ if (((spif_uint32_t) key) & 3) {
/* Not 32-bit aligned. Use old method. */
while (len >= 12) {
- a += (key[0] + (SPIF_CAST(uint32) key[1] << 8) + (SPIF_CAST(uint32) key[2] << 16) + (SPIF_CAST(uint32) key[3] << 24));
- b += (key[4] + (SPIF_CAST(uint32) key[5] << 8) + (SPIF_CAST(uint32) key[6] << 16) + (SPIF_CAST(uint32) key[7] << 24));
- c += (key[8] + (SPIF_CAST(uint32) key[9] << 8) + (SPIF_CAST(uint32) key[10] << 16) + (SPIF_CAST(uint32) key[11] << 24));
+ a += (key[0] + ((spif_uint32_t) key[1] << 8) + ((spif_uint32_t) key[2] << 16) + ((spif_uint32_t) key[3] << 24));
+ b += (key[4] + ((spif_uint32_t) key[5] << 8) + ((spif_uint32_t) key[6] << 16) + ((spif_uint32_t) key[7] << 24));
+ c += (key[8] + ((spif_uint32_t) key[9] << 8) + ((spif_uint32_t) key[10] << 16) + ((spif_uint32_t) key[11] << 24));
SPIFHASH_JENKINS_MIX(a, b, c);
key += 12;
len -= 12;
@@ -193,9 +193,9 @@ spifhash_jenkinsLE(register spif_uint8_t *key, register spif_uint32_t length, re
while (len >= 12) {
/* These three lines are the only ones which differ from
spifhash_jenkins(). */
- a += *(SPIF_CAST_PTR(uint32) key);
- b += *(SPIF_CAST_PTR(uint32) (key + 4));
- c += *(SPIF_CAST_PTR(uint32) (key + 8));
+ a += *((spif_uint32_t *) key);
+ b += *((spif_uint32_t *) (key + 4));
+ c += *((spif_uint32_t *) (key + 8));
SPIFHASH_JENKINS_MIX(a, b, c);
key += 12;
len -= 12;
@@ -207,25 +207,25 @@ spifhash_jenkinsLE(register spif_uint8_t *key, register spif_uint32_t length, re
c += length;
switch (len) {
case 11:
- c += (SPIF_CAST(uint32) key[10] << 24);
+ c += ((spif_uint32_t) key[10] << 24);
case 10:
- c += (SPIF_CAST(uint32) key[9] << 16);
+ c += ((spif_uint32_t) key[9] << 16);
case 9:
- c += (SPIF_CAST(uint32) key[8] << 8);
+ c += ((spif_uint32_t) key[8] << 8);
case 8:
- b += (SPIF_CAST(uint32) key[7] << 24);
+ b += ((spif_uint32_t) key[7] << 24);
case 7:
- b += (SPIF_CAST(uint32) key[6] << 16);
+ b += ((spif_uint32_t) key[6] << 16);
case 6:
- b += (SPIF_CAST(uint32) key[5] << 8);
+ b += ((spif_uint32_t) key[5] << 8);
case 5:
b += key[4];
case 4:
- a += (SPIF_CAST(uint32) key[3] << 24);
+ a += ((spif_uint32_t) key[3] << 24);
case 3:
- a += (SPIF_CAST(uint32) key[2] << 16);
+ a += ((spif_uint32_t) key[2] << 16);
case 2:
- a += (SPIF_CAST(uint32) key[1] << 8);
+ a += ((spif_uint32_t) key[1] << 8);
case 1:
a += key[0];
/* case 0: nothing left to add */
@@ -322,15 +322,15 @@ spifhash_fnv(spif_uint8_t *key, spif_uint32_t len, spif_uint32_t seed)
spif_uint32_t hash;
if (!seed) {
- seed = SPIF_CAST(uint32) 0x811c9dc5; /* FNV-1a 32-bit init. */
+ seed = (spif_uint32_t) 0x811c9dc5; /* FNV-1a 32-bit init. */
}
for (hash = seed; key < key_end; key++) {
- hash ^= SPIF_CAST(uint32) (*key);
+ hash ^= (spif_uint32_t) (*key);
#ifdef __GNUC__
hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
#else
- hash *= SPIF_CAST(uint32) 0x01000193; /* 32-bit FNV-1 prime. */
+ hash *= (spif_uint32_t) 0x01000193; /* 32-bit FNV-1 prime. */
#endif
}
diff --git a/src/conf.c b/src/conf.c
index aff7392..1d2e74b 100644
--- a/src/conf.c
+++ b/src/conf.c
@@ -75,7 +75,7 @@ spifconf_init_subsystem(void)
ctx_idx = 0;
context = (ctx_t *) MALLOC(sizeof(ctx_t) * ctx_cnt);
MEMSET(context, 0, sizeof(ctx_t) * ctx_cnt);
- context[0].name = SPIF_CAST(charptr) STRDUP("null");
+ context[0].name = (spif_charptr_t) STRDUP("null");
context[0].handler = parse_null;
/* Initialize the context state stack and set the current context to "null" */
@@ -110,10 +110,10 @@ spifconf_init_subsystem(void)
unsigned char
spifconf_register_context(spif_charptr_t name, ctx_handler_t handler)
{
- ASSERT_RVAL(!SPIF_PTR_ISNULL(name), SPIF_CAST_C(unsigned char) -1);
- ASSERT_RVAL(!SPIF_PTR_ISNULL(handler), SPIF_CAST_C(unsigned char) -1);
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(name), (unsigned char) -1);
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(handler), (unsigned char) -1);
- if (strcasecmp(SPIF_CAST_C(char *) name, "null")) {
+ if (strcasecmp((char *) name, "null")) {
if (++ctx_idx == ctx_cnt) {
ctx_cnt *= 2;
context = (ctx_t *) REALLOC(context, sizeof(ctx_t) * ctx_cnt);
@@ -121,7 +121,7 @@ spifconf_register_context(spif_charptr_t name, ctx_handler_t handler)
} else {
FREE(context[0].name);
}
- context[ctx_idx].name = SPIF_CAST(charptr) STRDUP(name);
+ context[ctx_idx].name = (spif_charptr_t) STRDUP(name);
context[ctx_idx].handler = handler;
D_CONF(("Added context \"%s\" with ID %d and handler 0x%08x\n", context[ctx_idx].name, ctx_idx, context[ctx_idx].handler));
return (ctx_idx);
@@ -131,8 +131,8 @@ spifconf_register_context(spif_charptr_t name, ctx_handler_t handler)
unsigned char
spifconf_register_fstate(FILE * fp, spif_charptr_t path, spif_charptr_t outfile, unsigned long line, unsigned char flags)
{
- ASSERT_RVAL(!SPIF_PTR_ISNULL(fp), SPIF_CAST_C(unsigned char) -1);
- ASSERT_RVAL(!SPIF_PTR_ISNULL(path), SPIF_CAST_C(unsigned char) -1);
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(fp), (unsigned char) -1);
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(path), (unsigned char) -1);
if (++fstate_idx == fstate_cnt) {
fstate_cnt *= 2;
@@ -150,9 +150,9 @@ spifconf_register_fstate(FILE * fp, spif_charptr_t path, spif_charptr_t outfile,
unsigned char
spifconf_register_builtin(char *name, spifconf_func_ptr_t ptr)
{
- ASSERT_RVAL(!SPIF_PTR_ISNULL(name), SPIF_CAST_C(unsigned char) -1);
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(name), (unsigned char) -1);
- builtins[builtin_idx].name = SPIF_CAST(charptr) STRDUP(name);
+ builtins[builtin_idx].name = (spif_charptr_t) STRDUP(name);
builtins[builtin_idx].ptr = ptr;
if (++builtin_idx == builtin_cnt) {
builtin_cnt *= 2;
@@ -225,10 +225,10 @@ spifconf_get_var(const spif_charptr_t var)
{
spifconf_var_t *v;
- ASSERT_RVAL(!SPIF_PTR_ISNULL(var), SPIF_NULL_TYPE_C(spif_charptr_t));
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(var), (spif_charptr_t) NULL);
D_CONF(("var == \"%s\"\n", var));
for (v = spifconf_vars; v; v = v->next) {
- if (!strcmp(SPIF_CAST_C(char *) v->var, SPIF_CAST_C(char *) var)) {
+ if (!strcmp((char *) v->var, (char *) var)) {
D_CONF(("Found it at %10p: \"%s\" == \"%s\"\n", v, v->var, v->value));
return (v->value);
}
@@ -248,7 +248,7 @@ spifconf_put_var(spif_charptr_t var, spif_charptr_t val)
for (v = spifconf_vars; v; loc = v, v = v->next) {
int n;
- n = strcmp(SPIF_CAST_C(char *) var, SPIF_CAST_C(char *) v->var);
+ n = strcmp((char *) var, (char *) v->var);
D_CONF(("Comparing at %10p: \"%s\" -> \"%s\", n == %d\n", v, v->var, v->value, n));
if (n == 0) {
FREE(v->value);
@@ -274,8 +274,8 @@ spifconf_put_var(spif_charptr_t var, spif_charptr_t val)
return;
}
D_CONF(("Inserting new var/val pair between \"%s\" and \"%s\"\n",
- ((loc) ? (loc->var) : (SPIF_CAST(charptr) "-beginning-")),
- ((v) ? (v->var) : (SPIF_CAST(charptr) "-end-"))));
+ ((loc) ? (loc->var) : ((spif_charptr_t) "-beginning-")),
+ ((v) ? (v->var) : ((spif_charptr_t) "-end-"))));
tmp = spifconf_new_var();
if (loc == NULL) {
tmp->next = spifconf_vars;
@@ -294,7 +294,7 @@ builtin_random(spif_charptr_t param)
unsigned long n, index;
static unsigned int rseed = 0;
- REQUIRE_RVAL(!SPIF_PTR_ISNULL(param), SPIF_NULL_TYPE_C(spif_charptr_t));
+ REQUIRE_RVAL(!SPIF_PTR_ISNULL(param), (spif_charptr_t) NULL);
D_PARSE(("builtin_random(%s) called\n", NONULL(param)));
if (rseed == 0) {
@@ -317,27 +317,27 @@ builtin_exec(spif_charptr_t param)
FILE *fp;
int fd;
- REQUIRE_RVAL(!SPIF_PTR_ISNULL(param), SPIF_NULL_TYPE_C(spif_charptr_t));
+ REQUIRE_RVAL(!SPIF_PTR_ISNULL(param), (spif_charptr_t) NULL);
D_PARSE(("builtin_exec(%s) called\n", NONULL(param)));
Command = (spif_charptr_t) MALLOC(CONFIG_BUFF);
- strcpy(SPIF_CAST_C(char *) OutFile, "Eterm-exec-");
+ strcpy((char *) OutFile, "Eterm-exec-");
fd = spiftool_temp_file(OutFile, sizeof(OutFile));
if ((fd < 0) || fchmod(fd, (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) {
libast_print_error("Unable to create unique temporary file for \"%s\" -- %s\n", param, strerror(errno));
return ((spif_charptr_t) NULL);
}
- maxlen = strlen(SPIF_CAST_C(char *) param) + strlen(SPIF_CAST_C(char *) OutFile) + 8;
+ maxlen = strlen((char *) param) + strlen((char *) OutFile) + 8;
if (maxlen > CONFIG_BUFF) {
libast_print_error("Parse error in file %s, line %lu: Cannot execute command, line too long\n",
file_peek_path(), file_peek_line());
return ((spif_charptr_t) NULL);
}
- strcpy(SPIF_CAST_C(char *) Command, SPIF_CAST_C(char *) param);
- strcat(SPIF_CAST_C(char *) Command, " >");
- strcat(SPIF_CAST_C(char *) Command, SPIF_CAST_C(char *) OutFile);
- system(SPIF_CAST_C(char *) Command);
+ strcpy((char *) Command, (char *) param);
+ strcat((char *) Command, " >");
+ strcat((char *) Command, (char *) OutFile);
+ system((char *) Command);
if ((fp = fdopen(fd, "rb")) != NULL) {
fseek(fp, 0, SEEK_END);
fsize = ftell(fp);
@@ -347,7 +347,7 @@ builtin_exec(spif_charptr_t param)
fread(Output, fsize, 1, fp);
Output[fsize] = 0;
fclose(fp);
- remove(SPIF_CAST_C(char *) OutFile);
+ remove((char *) OutFile);
Output = spiftool_condense_whitespace(Output);
} else {
libast_print_warning("Command at line %lu of file %s returned no output.\n",
@@ -386,7 +386,7 @@ builtin_get(spif_charptr_t param)
if (f) {
FREE(f);
}
- return (SPIF_CAST(charptr) STRDUP(v));
+ return ((spif_charptr_t) STRDUP(v));
} else if (f) {
return f;
} else {
@@ -429,7 +429,7 @@ builtin_dirscan(spif_charptr_t param)
}
D_PARSE(("builtin_dirscan(%s)\n", param));
dir = spiftool_get_word(1, param);
- dirp = opendir(SPIF_CAST_C(char *) dir);
+ dirp = opendir((char *) dir);
if (!dirp) {
return NULL;
}
@@ -440,8 +440,8 @@ builtin_dirscan(spif_charptr_t param)
for (i = 0; (dp = readdir(dirp)) != NULL;) {
spif_char_t fullname[PATH_MAX];
- snprintf(SPIF_CAST_C(char *) fullname, sizeof(fullname), "%s/%s", dir, dp->d_name);
- if (stat(SPIF_CAST_C(char *) fullname, &filestat)) {
+ snprintf((char *) fullname, sizeof(fullname), "%s/%s", dir, dp->d_name);
+ if (stat((char *) fullname, &filestat)) {
D_PARSE((" -> Couldn't stat() file %s -- %s\n", fullname, strerror(errno)));
} else {
if (S_ISREG(filestat.st_mode)) {
@@ -449,8 +449,8 @@ builtin_dirscan(spif_charptr_t param)
len = strlen(dp->d_name);
if (len < n) {
- strcat(SPIF_CAST_C(char *) buff, dp->d_name);
- strcat(SPIF_CAST_C(char *) buff, " ");
+ strcat((char *) buff, dp->d_name);
+ strcat((char *) buff, " ");
n -= len + 1;
}
}
@@ -469,7 +469,7 @@ builtin_version(spif_charptr_t param)
USE_VAR(param);
D_PARSE(("builtin_version(%s) called\n", NONULL(param)));
- return (SPIF_CAST(charptr) STRDUP(libast_program_version));
+ return ((spif_charptr_t) STRDUP(libast_program_version));
}
static spif_charptr_t
@@ -481,7 +481,7 @@ builtin_appname(spif_charptr_t param)
D_PARSE(("builtin_appname(%s) called\n", NONULL(param)));
snprintf(buff, sizeof(buff), "%s-%s", libast_program_name, libast_program_version);
- return (SPIF_CAST(charptr) STRDUP(buff));
+ return ((spif_charptr_t) STRDUP(buff));
}
/* spifconf_shell_expand() takes care of shell variable expansion, quote conventions,
@@ -498,7 +498,7 @@ spifconf_shell_expand(spif_charptr_t s)
const spif_uint32_t max = CONFIG_BUFF - 1;
spif_charptr_t Command, Output, EnvVar;
- ASSERT_RVAL(s != NULL, SPIF_NULL_TYPE(charptr));
+ ASSERT_RVAL(s != NULL, (spif_charptr_t) NULL);
#if 0
newbuff = (spif_charptr_t) MALLOC(CONFIG_BUFF);
@@ -508,10 +508,10 @@ spifconf_shell_expand(spif_charptr_t s)
switch (*pbuff) {
case '~':
D_CONF(("Tilde detected.\n"));
- EnvVar = SPIF_CAST(charptr) getenv("HOME");
+ EnvVar = (spif_charptr_t) getenv("HOME");
if (!in_single && !in_double && EnvVar && *EnvVar) {
spiftool_safe_strncpy(newbuff + j, EnvVar, max - j);
- cnt1 = strlen(SPIF_CAST_C(char *) EnvVar) - 1;
+ cnt1 = strlen((char *) EnvVar) - 1;
cnt2 = max - j - 1;
j += MIN(cnt1, cnt2);
} else {
@@ -559,8 +559,8 @@ spifconf_shell_expand(spif_charptr_t s)
D_CONF(("%% detected.\n"));
for (k = 0, pbuff++; builtins[k].name != NULL; k++) {
D_PARSE(("Checking for function %%%s, pbuff == \"%s\"\n", builtins[k].name, pbuff));
- l = strlen(SPIF_CAST_C(char *) builtins[k].name);
- if (!strncasecmp(SPIF_CAST_C(char *) builtins[k].name, SPIF_CAST_C(char *) pbuff, l)
+ l = strlen((char *) builtins[k].name);
+ if (!strncasecmp((char *) builtins[k].name, (char *) pbuff, l)
&& ((pbuff[l] == '(')
|| (pbuff[l] == ' '
&& pbuff[l + 1] == ')'))) {
@@ -571,7 +571,7 @@ spifconf_shell_expand(spif_charptr_t s)
newbuff[j] = *pbuff;
} else {
D_CONF(("Call to built-in function %s detected.\n", builtins[k].name));
- Command = SPIF_CAST(charptr) MALLOC(CONFIG_BUFF);
+ Command = (spif_charptr_t) MALLOC(CONFIG_BUFF);
pbuff += l;
if (*pbuff != '(')
pbuff++;
@@ -591,15 +591,15 @@ spifconf_shell_expand(spif_charptr_t s)
*(--tmp1) = 0;
if (l) {
libast_print_error("parse error in file %s, line %lu: Mismatched parentheses\n", file_peek_path(), file_peek_line());
- return SPIF_NULL_TYPE(charptr);
+ return (spif_charptr_t) NULL;
}
Command = spifconf_shell_expand(Command);
- Output = SPIF_CAST(charptr) (builtins[k].ptr) (Command);
+ Output = (spif_charptr_t) (builtins[k].ptr) (Command);
FREE(Command);
if (Output) {
if (*Output) {
spiftool_safe_strncpy(newbuff + j, Output, max - j);
- l = strlen(SPIF_CAST_C(char *) Output) - 1;
+ l = strlen((char *) Output) - 1;
cnt2 = max - j - 1;
j += MIN(l, cnt2);
} else {
@@ -616,7 +616,7 @@ spifconf_shell_expand(spif_charptr_t s)
#if ALLOW_BACKQUOTE_EXEC
D_CONF(("Backquotes detected. Evaluating expression.\n"));
if (!in_single) {
- Command = SPIF_CAST(charptr) MALLOC(CONFIG_BUFF);
+ Command = (spif_charptr_t) MALLOC(CONFIG_BUFF);
l = 0;
for (pbuff++; *pbuff && *pbuff != '`' && l < max; pbuff++, l++) {
Command[l] = *pbuff;
@@ -629,7 +629,7 @@ spifconf_shell_expand(spif_charptr_t s)
if (Output) {
if (*Output) {
spiftool_safe_strncpy(newbuff + j, Output, max - j);
- l = strlen(SPIF_CAST_C(char *) Output) - 1;
+ l = strlen((char *) Output) - 1;
cnt2 = max - j - 1;
j += MIN(l, cnt2);
} else {
@@ -650,7 +650,7 @@ spifconf_shell_expand(spif_charptr_t s)
case '$':
D_CONF(("Environment variable detected. Evaluating.\n"));
if (!in_single) {
- EnvVar = SPIF_CAST(charptr) MALLOC(128);
+ EnvVar = (spif_charptr_t) MALLOC(128);
switch (*(++pbuff)) {
case '{':
for (pbuff++, k = 0; *pbuff != '}' && k < 127; k++, pbuff++)
@@ -666,10 +666,10 @@ spifconf_shell_expand(spif_charptr_t s)
break;
}
EnvVar[k] = 0;
- tmp = SPIF_CAST(charptr) getenv(SPIF_CAST_C(char *) EnvVar);
+ tmp = (spif_charptr_t) getenv((char *) EnvVar);
if (tmp && *tmp) {
spiftool_safe_strncpy(newbuff, tmp, max - j);
- cnt1 = strlen(SPIF_CAST_C(char *) tmp) - 1;
+ cnt1 = strlen((char *) tmp) - 1;
cnt2 = max - j - 1;
j += MIN(cnt1, cnt2);
}
@@ -709,10 +709,10 @@ spifconf_shell_expand(spif_charptr_t s)
D_PARSE(("spifconf_shell_expand(%s) returning \"%s\"\n", s, newbuff));
D_PARSE((" strlen(s) == %lu, strlen(newbuff) == %lu, j == %lu\n",
- strlen(SPIF_CAST_C(char *) s),
- strlen(SPIF_CAST_C(char *) newbuff), j));
+ strlen((char *) s),
+ strlen((char *) newbuff), j));
- strcpy(SPIF_CAST_C(char *) s, SPIF_CAST_C(char *) newbuff);
+ strcpy((char *) s, (char *) newbuff);
#if 0
FREE(newbuff);
#endif
@@ -731,28 +731,28 @@ spifconf_find_file(const spif_charptr_t file, const spif_charptr_t dir, const sp
REQUIRE_RVAL(file != NULL, NULL);
- getcwd(SPIF_CAST_C(char *) name, PATH_MAX);
+ getcwd((char *) name, PATH_MAX);
D_CONF(("spifconf_find_file(\"%s\", \"%s\", \"%s\") called from directory \"%s\".\n",
file, NONULL(dir), NONULL(pathlist), name));
/* Make sure our supplied settings don't overflow. */
- len = strlen(SPIF_CAST_C(char *) file) + ((dir) ? (strlen(SPIF_CAST_C(char *) dir)) : (0)) + 2;
- if ((len > SPIF_CAST(int32) sizeof(name)) || (len <= 0)) {
+ len = strlen((char *) file) + ((dir) ? (strlen((char *) dir)) : (0)) + 2;
+ if ((len > (spif_int32_t) sizeof(name)) || (len <= 0)) {
D_CONF(("Too big. I lose. :(\n"));
return ((spif_charptr_t) NULL);
}
if (dir) {
- strcpy(SPIF_CAST_C(char *) name, SPIF_CAST_C(char *) dir);
- strcat(SPIF_CAST_C(char *) name, "/");
- strcat(SPIF_CAST_C(char *) name, SPIF_CAST_C(char *) file);
+ strcpy((char *) name, (char *) dir);
+ strcat((char *) name, "/");
+ strcat((char *) name, (char *) file);
} else {
- strcpy(SPIF_CAST_C(char *) name, SPIF_CAST_C(char *) file);
+ strcpy((char *) name, (char *) file);
}
- len = strlen(SPIF_CAST_C(char *) name);
+ len = strlen((char *) name);
D_CONF(("Checking for file \"%s\"\n", name));
- if ((!access(SPIF_CAST_C(char *) name, R_OK))
- && (!stat(SPIF_CAST_C(char *) name, &fst))
+ if ((!access((char *) name, R_OK))
+ && (!stat((char *) name, &fst))
&& (!S_ISDIR(fst.st_mode))) {
D_CONF(("Found \"%s\"\n", name));
return ((spif_charptr_t) name);
@@ -769,10 +769,10 @@ spifconf_find_file(const spif_charptr_t file, const spif_charptr_t dir, const sp
short n;
/* Calculate the length of the next directory in the path */
- if ((p = SPIF_CAST(charptr) strchr(SPIF_CAST_C(char *) path, ':')) != NULL) {
+ if ((p = (spif_charptr_t) strchr((char *) path, ':')) != NULL) {
n = p++ - path;
} else {
- n = strlen(SPIF_CAST_C(char *) path);
+ n = strlen((char *) path);
}
/* Don't try if it's too long */
@@ -783,11 +783,11 @@ spifconf_find_file(const spif_charptr_t file, const spif_charptr_t dir, const sp
full_path[n++] = '/';
}
full_path[n] = '\0';
- strcat(SPIF_CAST_C(char *) full_path, SPIF_CAST_C(char *) name);
+ strcat((char *) full_path, (char *) name);
D_CONF(("Checking for file \"%s\"\n", full_path));
- if ((!access(SPIF_CAST_C(char *) full_path, R_OK))
- && (!stat(SPIF_CAST_C(char *) full_path, &fst))
+ if ((!access((char *) full_path, R_OK))
+ && (!stat((char *) full_path, &fst))
&& (!S_ISDIR(fst.st_mode))) {
D_CONF(("Found \"%s\"\n", full_path));
return ((spif_charptr_t) full_path);
@@ -810,14 +810,14 @@ spifconf_open_file(spif_charptr_t name)
ASSERT_RVAL(name != NULL, NULL);
- snprintf(SPIF_CAST_C(char *) test, sizeof(test), "<%s-", libast_program_name);
- testlen = SPIF_CAST(stridx) strlen(SPIF_CAST_C(char *) test);
+ snprintf((char *) test, sizeof(test), "<%s-", libast_program_name);
+ testlen = (spif_stridx_t) strlen((char *) test);
/* Read first line from config file. Using spif_str_new_from_fp() would read the
* whole file, so we don't do that here. */
- fp = fopen(SPIF_CAST_C(char *) name, "rt");
+ fp = fopen((char *) name, "rt");
REQUIRE_RVAL(fp != NULL, NULL);
- fgets(SPIF_CAST_C(char *) buff, 256, fp);
+ fgets((char *) buff, 256, fp);
ver_str = spif_str_new_from_ptr(buff);
/* Check for magic string. */
@@ -830,14 +830,14 @@ spifconf_open_file(spif_charptr_t name)
}
/* Check version number against current application version. */
- begin_ptr = SPIF_STR_STR(ver_str) + spif_str_index(ver_str, SPIF_CAST(char) '-') + 1;
- end_ptr = SPIF_STR_STR(ver_str) + spif_str_index(ver_str, SPIF_CAST(char) '>');
+ begin_ptr = SPIF_STR_STR(ver_str) + spif_str_index(ver_str, (spif_char_t) '-') + 1;
+ end_ptr = SPIF_STR_STR(ver_str) + spif_str_index(ver_str, (spif_char_t) '>');
D_CONF(("Begin pointer is %10p (%s), end pointer is %10p (%s), length is %d, buffer size is %d\n",
- begin_ptr, begin_ptr, end_ptr, end_ptr, SPIF_CAST_C(int) (end_ptr - begin_ptr), sizeof(buff)));
+ begin_ptr, begin_ptr, end_ptr, end_ptr, (int) (end_ptr - begin_ptr), sizeof(buff)));
if (SPIF_PTR_ISNULL(end_ptr)) {
spiftool_safe_strncpy(buff, begin_ptr, sizeof(buff));
} else {
- testlen = MIN(SPIF_CAST_C(int) sizeof(buff), SPIF_CAST_C(int) (end_ptr - begin_ptr + 1));
+ testlen = MIN((int) sizeof(buff), (int) (end_ptr - begin_ptr + 1));
spiftool_safe_strncpy(buff, begin_ptr, testlen);
}
ver = spiftool_version_compare(buff, libast_program_version);
@@ -863,7 +863,7 @@ spifconf_parse_line(FILE * fp, spif_charptr_t buff)
SPIFCONF_PARSE_RET();
}
if (fp == NULL) {
- file_push(NULL, SPIF_CAST(charptr) "<argv>", NULL, 0, 0);
+ file_push(NULL, (spif_charptr_t) "<argv>", NULL, 0, 0);
ctx_begin(1);
buff = spiftool_get_pword(2, buff);
if (!buff) {
@@ -882,7 +882,7 @@ spifconf_parse_line(FILE * fp, spif_charptr_t buff)
spif_charptr_t path;
FILE *fp;
- spifconf_shell_expand(SPIF_CAST(charptr) buff);
+ spifconf_shell_expand((spif_charptr_t) buff);
path = spiftool_get_word(2, buff + 1);
if ((fp = spifconf_open_file(path)) == NULL) {
libast_print_error("Parsing file %s, line %lu: Unable to locate %%included config file %s (%s), continuing\n", file_peek_path(),
@@ -899,12 +899,12 @@ spifconf_parse_line(FILE * fp, spif_charptr_t buff)
if (file_peek_preproc()) {
SPIFCONF_PARSE_RET();
}
- strcpy(SPIF_CAST_C(char *) fname, "Eterm-preproc-");
+ strcpy((char *) fname, "Eterm-preproc-");
fd = spiftool_temp_file(fname, PATH_MAX);
- outfile = SPIF_CAST(charptr) STRDUP(fname);
- snprintf(SPIF_CAST_C(char *) cmd, PATH_MAX, "%s < %s > %s",
+ outfile = (spif_charptr_t) STRDUP(fname);
+ snprintf((char *) cmd, PATH_MAX, "%s < %s > %s",
spiftool_get_pword(2, buff), file_peek_path(), fname);
- system(SPIF_CAST_C(char *) cmd);
+ system((char *) cmd);
fp = fdopen(fd, "rt");
if (fp != NULL) {
fclose(file_peek_fp());
@@ -916,7 +916,7 @@ spifconf_parse_line(FILE * fp, spif_charptr_t buff)
if (file_peek_skip()) {
SPIFCONF_PARSE_RET();
}
- spifconf_shell_expand(SPIF_CAST(charptr) buff);
+ spifconf_shell_expand((spif_charptr_t) buff);
}
break;
case 'b':
@@ -929,7 +929,7 @@ spifconf_parse_line(FILE * fp, spif_charptr_t buff)
}
/* Intentional pass-through */
case 'e':
- if (!BEG_STRCASECMP(buff, "end ") || !strcasecmp(SPIF_CAST_C(char *) buff, "end")) {
+ if (!BEG_STRCASECMP(buff, "end ") || !strcasecmp((char *) buff, "end")) {
ctx_end();
break;
}
@@ -938,7 +938,7 @@ spifconf_parse_line(FILE * fp, spif_charptr_t buff)
if (file_peek_skip()) {
SPIFCONF_PARSE_RET();
}
- spifconf_shell_expand(SPIF_CAST(charptr) buff);
+ spifconf_shell_expand((spif_charptr_t) buff);
ctx_poke_state((*ctx_id_to_func(id)) (buff, ctx_peek_state()));
}
SPIFCONF_PARSE_RET();
@@ -950,7 +950,7 @@ spif_charptr_t
spifconf_parse(spif_charptr_t conf_name, const spif_charptr_t dir, const spif_charptr_t path)
{
FILE *fp;
- spif_charptr_t name = NULL, p = SPIF_CAST(charptr) ".";
+ spif_charptr_t name = NULL, p = (spif_charptr_t) ".";
spif_char_t buff[CONFIG_BUFF], orig_dir[PATH_MAX];
REQUIRE_RVAL(conf_name != NULL, 0);
@@ -958,13 +958,13 @@ spifconf_parse(spif_charptr_t conf_name, const spif_charptr_t dir, const spif_ch
*orig_dir = 0;
if (path) {
if ((name = spifconf_find_file(conf_name, dir, path)) != NULL) {
- if ((p = SPIF_CAST(charptr) strrchr(SPIF_CAST_C(char *) name, '/')) != NULL) {
- getcwd(SPIF_CAST_C(char *) orig_dir, PATH_MAX);
+ if ((p = (spif_charptr_t) strrchr((char *) name, '/')) != NULL) {
+ getcwd((char *) orig_dir, PATH_MAX);
*p = 0;
p = name;
- chdir(SPIF_CAST_C(char *) name);
+ chdir((char *) name);
} else {
- p = SPIF_CAST(charptr) ".";
+ p = (spif_charptr_t) ".";
}
} else {
return NULL;
@@ -977,35 +977,35 @@ spifconf_parse(spif_charptr_t conf_name, const spif_charptr_t dir, const spif_ch
file_push(fp, conf_name, NULL, 1, 0);
for (; fstate_idx > 0;) {
- for (; fgets(SPIF_CAST_C(char *) buff, CONFIG_BUFF, file_peek_fp());) {
+ for (; fgets((char *) buff, CONFIG_BUFF, file_peek_fp());) {
file_inc_line();
- if (!strchr(SPIF_CAST_C(char *) buff, '\n')) {
+ if (!strchr((char *) buff, '\n')) {
libast_print_error("Parse error in file %s, line %lu: line too long\n",
file_peek_path(), file_peek_line());
- for (; fgets(SPIF_CAST_C(char *) buff, CONFIG_BUFF, file_peek_fp())
- && !strrchr(SPIF_CAST_C(char *) buff, '\n'););
+ for (; fgets((char *) buff, CONFIG_BUFF, file_peek_fp())
+ && !strrchr((char *) buff, '\n'););
continue;
}
spifconf_parse_line(fp, buff);
}
fclose(file_peek_fp());
if (file_peek_preproc()) {
- remove(SPIF_CAST_C(char *) file_peek_outfile());
+ remove((char *) file_peek_outfile());
FREE(file_peek_outfile());
}
file_pop();
}
if (*orig_dir) {
- chdir(SPIF_CAST_C(char *) orig_dir);
+ chdir((char *) orig_dir);
}
D_CONF(("Returning \"%s\"\n", p));
- return (SPIF_CAST(charptr) STRDUP(p));
+ return ((spif_charptr_t) STRDUP(p));
}
static void *
parse_null(spif_charptr_t buff, void *state)
{
- ASSERT_RVAL(!SPIF_PTR_ISNULL(buff), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(buff), (spif_ptr_t) NULL);
if (*buff == SPIFCONF_BEGIN_CHAR) {
return (NULL);
} else if (*buff == SPIFCONF_END_CHAR) {
diff --git a/src/dlinked_list.c b/src/dlinked_list.c
index f588166..113b5d5 100644
--- a/src/dlinked_list.c
+++ b/src/dlinked_list.c
@@ -220,7 +220,7 @@ spif_dlinked_list_item_new(void)
self = SPIF_ALLOC(dlinked_list_item);
if (!spif_dlinked_list_item_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(dlinked_list_item);
+ self = (spif_dlinked_list_item_t) NULL;
}
return self;
}
@@ -229,9 +229,9 @@ static spif_bool_t
spif_dlinked_list_item_init(spif_dlinked_list_item_t self)
{
ASSERT_RVAL(!SPIF_DLINKED_LIST_ITEM_ISNULL(self), FALSE);
- self->data = SPIF_NULL_TYPE(obj);
- self->prev = SPIF_NULL_TYPE(dlinked_list_item);
- self->next = SPIF_NULL_TYPE(dlinked_list_item);
+ self->data = (spif_obj_t) NULL;
+ self->prev = (spif_dlinked_list_item_t) NULL;
+ self->next = (spif_dlinked_list_item_t) NULL;
return TRUE;
}
@@ -239,12 +239,12 @@ static spif_bool_t
spif_dlinked_list_item_done(spif_dlinked_list_item_t self)
{
ASSERT_RVAL(!SPIF_DLINKED_LIST_ITEM_ISNULL(self), FALSE);
- if (self->data != SPIF_NULL_TYPE(obj)) {
+ if (self->data != (spif_obj_t) NULL) {
SPIF_OBJ_DEL(self->data);
}
- self->data = SPIF_NULL_TYPE(obj);
- self->prev = SPIF_NULL_TYPE(dlinked_list_item);
- self->next = SPIF_NULL_TYPE(dlinked_list_item);
+ self->data = (spif_obj_t) NULL;
+ self->prev = (spif_dlinked_list_item_t) NULL;
+ self->next = (spif_dlinked_list_item_t) NULL;
return TRUE;
}
@@ -268,17 +268,17 @@ spif_dlinked_list_item_show(spif_dlinked_list_item_t self, spif_charptr_t name,
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_dlinked_list_item_t) %s (%9p <- %9p -> %9p): ",
- name, SPIF_CAST(ptr) self->prev, SPIF_CAST(ptr) self,
- SPIF_CAST(ptr) self->next);
+ name, (spif_ptr_t) self->prev, (spif_ptr_t) self,
+ (spif_ptr_t) self->next);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
- spif_str_append_from_ptr(buff, SPIF_CAST(charptr) tmp);
+ spif_str_append_from_ptr(buff, (spif_charptr_t) tmp);
}
if (SPIF_DLINKED_LIST_ITEM_ISNULL(self->data)) {
- spif_str_append_from_ptr(buff, SPIF_CAST(charptr) SPIF_NULLSTR_TYPE(obj));
+ spif_str_append_from_ptr(buff, (spif_charptr_t) SPIF_NULLSTR_TYPE(obj));
} else {
buff = SPIF_OBJ_SHOW(self->data, buff, 0);
}
@@ -297,7 +297,7 @@ spif_dlinked_list_item_dup(spif_dlinked_list_item_t self)
{
spif_dlinked_list_item_t tmp;
- ASSERT_RVAL(!SPIF_DLINKED_LIST_ITEM_ISNULL(self), SPIF_NULL_TYPE(dlinked_list_item));
+ ASSERT_RVAL(!SPIF_DLINKED_LIST_ITEM_ISNULL(self), (spif_dlinked_list_item_t) NULL);
tmp = spif_dlinked_list_item_new();
tmp->data = SPIF_OBJ_DUP(self->data);
return tmp;
@@ -306,7 +306,7 @@ spif_dlinked_list_item_dup(spif_dlinked_list_item_t self)
static spif_classname_t
spif_dlinked_list_item_type(spif_dlinked_list_item_t self)
{
- ASSERT_RVAL(!SPIF_DLINKED_LIST_ITEM_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_DLINKED_LIST_ITEM_ISNULL(self), (spif_classname_t) NULL);
return SPIF_CLASS_VAR(dlinked_list_item)->classname;
}
@@ -323,7 +323,7 @@ spif_dlinked_list_new(void)
self = SPIF_ALLOC(dlinked_list);
if (!spif_dlinked_list_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(dlinked_list);
+ self = (spif_dlinked_list_t) NULL;
}
return self;
}
@@ -336,7 +336,7 @@ spif_dlinked_list_vector_new(void)
self = SPIF_ALLOC(dlinked_list);
if (!spif_dlinked_list_vector_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(dlinked_list);
+ self = (spif_dlinked_list_t) NULL;
}
return self;
}
@@ -349,7 +349,7 @@ spif_dlinked_list_map_new(void)
self = SPIF_ALLOC(dlinked_list);
if (!spif_dlinked_list_map_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(dlinked_list);
+ self = (spif_dlinked_list_t) NULL;
}
return self;
}
@@ -361,8 +361,8 @@ spif_dlinked_list_init(spif_dlinked_list_t self)
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_LISTCLASS_VAR(dlinked_list)));
self->len = 0;
- self->head = SPIF_NULL_TYPE(dlinked_list_item);
- self->tail = SPIF_NULL_TYPE(dlinked_list_item);
+ self->head = (spif_dlinked_list_item_t) NULL;
+ self->tail = (spif_dlinked_list_item_t) NULL;
return TRUE;
}
@@ -373,8 +373,8 @@ spif_dlinked_list_vector_init(spif_dlinked_list_t self)
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_VECTORCLASS_VAR(dlinked_list)));
self->len = 0;
- self->head = SPIF_NULL_TYPE(dlinked_list_item);
- self->tail = SPIF_NULL_TYPE(dlinked_list_item);
+ self->head = (spif_dlinked_list_item_t) NULL;
+ self->tail = (spif_dlinked_list_item_t) NULL;
return TRUE;
}
@@ -385,8 +385,8 @@ spif_dlinked_list_map_init(spif_dlinked_list_t self)
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_MAPCLASS_VAR(dlinked_list)));
self->len = 0;
- self->head = SPIF_NULL_TYPE(dlinked_list_item);
- self->tail = SPIF_NULL_TYPE(dlinked_list_item);
+ self->head = (spif_dlinked_list_item_t) NULL;
+ self->tail = (spif_dlinked_list_item_t) NULL;
return TRUE;
}
@@ -405,8 +405,8 @@ spif_dlinked_list_done(spif_dlinked_list_t self)
spif_dlinked_list_item_del(tmp);
}
self->len = 0;
- self->head = SPIF_NULL_TYPE(dlinked_list_item);
- self->tail = SPIF_NULL_TYPE(dlinked_list_item);
+ self->head = (spif_dlinked_list_item_t) NULL;
+ self->tail = (spif_dlinked_list_item_t) NULL;
}
return TRUE;
}
@@ -433,8 +433,8 @@ spif_dlinked_list_show(spif_dlinked_list_t self, spif_charptr_t name, spif_str_t
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
- "(spif_dlinked_list_t) %s: %10p {\n", name, SPIF_CAST(ptr) self);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
+ "(spif_dlinked_list_t) %s: %10p {\n", name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -442,16 +442,16 @@ spif_dlinked_list_show(spif_dlinked_list_t self, spif_charptr_t name, spif_str_t
}
if (SPIF_DLINKED_LIST_ITEM_ISNULL(self->head)) {
- spif_str_append_from_ptr(buff, SPIF_CAST(charptr) SPIF_NULLSTR_TYPE(obj));
+ spif_str_append_from_ptr(buff, (spif_charptr_t) SPIF_NULLSTR_TYPE(obj));
} else {
for (current = self->head, i = 0; current; current = current->next, i++) {
- sprintf(SPIF_CAST_C(char *) tmp, "item %d", i);
+ sprintf((char *) tmp, "item %d", i);
buff = spif_dlinked_list_item_show(current, tmp, buff, indent + 2);
}
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent, "}\n");
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -469,17 +469,17 @@ spif_dlinked_list_dup(spif_dlinked_list_t self)
spif_dlinked_list_t tmp;
spif_dlinked_list_item_t src, dest, prev;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(dlinked_list));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_dlinked_list_t) NULL);
tmp = spif_dlinked_list_new();
memcpy(tmp, self, SPIF_SIZEOF_TYPE(dlinked_list));
tmp->head = spif_dlinked_list_item_dup(self->head);
- for (src = self->head, dest = tmp->head, prev = SPIF_NULL_TYPE(dlinked_list_item);
+ for (src = self->head, dest = tmp->head, prev = (spif_dlinked_list_item_t) NULL;
src->next;
src = src->next, prev = dest, dest = dest->next) {
dest->next = spif_dlinked_list_item_dup(src->next);
dest->prev = prev;
}
- dest->next = SPIF_NULL_TYPE(dlinked_list_item);
+ dest->next = (spif_dlinked_list_item_t) NULL;
tmp->tail = prev;
return tmp;
}
@@ -490,17 +490,17 @@ spif_dlinked_list_vector_dup(spif_dlinked_list_t self)
spif_dlinked_list_t tmp;
spif_dlinked_list_item_t src, dest, prev;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(dlinked_list));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_dlinked_list_t) NULL);
tmp = spif_dlinked_list_vector_new();
memcpy(tmp, self, SPIF_SIZEOF_TYPE(dlinked_list));
tmp->head = spif_dlinked_list_item_dup(self->head);
- for (src = self->head, dest = tmp->head, prev = SPIF_NULL_TYPE(dlinked_list_item);
+ for (src = self->head, dest = tmp->head, prev = (spif_dlinked_list_item_t) NULL;
src->next;
src = src->next, prev = dest, dest = dest->next) {
dest->next = spif_dlinked_list_item_dup(src->next);
dest->prev = prev;
}
- dest->next = SPIF_NULL_TYPE(dlinked_list_item);
+ dest->next = (spif_dlinked_list_item_t) NULL;
tmp->tail = prev;
return tmp;
}
@@ -511,17 +511,17 @@ spif_dlinked_list_map_dup(spif_dlinked_list_t self)
spif_dlinked_list_t tmp;
spif_dlinked_list_item_t src, dest, prev;
- ASSERT_RVAL(!SPIF_MAP_ISNULL(self), SPIF_NULL_TYPE(dlinked_list));
+ ASSERT_RVAL(!SPIF_MAP_ISNULL(self), (spif_dlinked_list_t) NULL);
tmp = spif_dlinked_list_map_new();
memcpy(tmp, self, SPIF_SIZEOF_TYPE(dlinked_list));
tmp->head = spif_dlinked_list_item_dup(self->head);
- for (src = self->head, dest = tmp->head, prev = SPIF_NULL_TYPE(dlinked_list_item);
+ for (src = self->head, dest = tmp->head, prev = (spif_dlinked_list_item_t) NULL;
src->next;
src = src->next, prev = dest, dest = dest->next) {
dest->next = spif_dlinked_list_item_dup(src->next);
dest->prev = prev;
}
- dest->next = SPIF_NULL_TYPE(dlinked_list_item);
+ dest->next = (spif_dlinked_list_item_t) NULL;
tmp->tail = prev;
return tmp;
}
@@ -529,7 +529,7 @@ spif_dlinked_list_map_dup(spif_dlinked_list_t self)
static spif_classname_t
spif_dlinked_list_type(spif_dlinked_list_t self)
{
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -550,9 +550,9 @@ spif_dlinked_list_append(spif_dlinked_list_t self, spif_obj_t obj)
self->tail = item;
} else {
self->tail = self->head = item;
- item->prev = SPIF_NULL_TYPE(dlinked_list_item);
+ item->prev = (spif_dlinked_list_item_t) NULL;
}
- item->next = SPIF_NULL_TYPE(dlinked_list_item);
+ item->next = (spif_dlinked_list_item_t) NULL;
self->len++;
return TRUE;
}
@@ -583,14 +583,14 @@ spif_dlinked_list_find(spif_dlinked_list_t self, spif_obj_t obj)
{
spif_dlinked_list_item_t current;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), (spif_obj_t) NULL);
for (current = self->head; current; current = current->next) {
if (SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(obj, current->data))) {
return current->data;
}
}
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_obj_t
@@ -598,8 +598,8 @@ spif_dlinked_list_vector_find(spif_dlinked_list_t self, spif_obj_t obj)
{
spif_dlinked_list_item_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), (spif_obj_t) NULL);
for (current = self->head; current; current = current->next) {
spif_cmp_t c;
@@ -610,7 +610,7 @@ spif_dlinked_list_vector_find(spif_dlinked_list_t self, spif_obj_t obj)
break;
}
}
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_obj_t
@@ -619,20 +619,20 @@ spif_dlinked_list_get(spif_dlinked_list_t self, spif_listidx_t idx)
spif_listidx_t i;
spif_dlinked_list_item_t current;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t) NULL);
if (idx < 0) {
/* Negative indexes go backward from the end of the list. */
idx += self->len;
}
- REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(obj));
+ REQUIRE_RVAL(idx >= 0, (spif_obj_t) NULL);
+ REQUIRE_RVAL(idx < self->len, (spif_obj_t) NULL);
if (idx > (self->len / 2)) {
for (current = self->tail, i = self->len - 1; current && i > idx; i--, current = current->prev);
- return (current ? (current->data) : SPIF_NULL_TYPE(obj));
+ return (current ? (current->data) : (spif_obj_t) NULL);
} else {
for (current = self->head, i = 0; current && i < idx; i++, current = current->next);
- return (current ? (current->data) : SPIF_NULL_TYPE(obj));
+ return (current ? (current->data) : (spif_obj_t) NULL);
}
}
@@ -641,13 +641,13 @@ spif_dlinked_list_map_get(spif_dlinked_list_t self, spif_obj_t key)
{
spif_dlinked_list_item_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(key), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(key), (spif_obj_t) NULL);
for (current = self->head; current; current = current->next) {
spif_cmp_t c;
/* current->data is always non-NULL in maps. */
- ASSERT_RVAL(!SPIF_OBJ_ISNULL(current->data), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_OBJ_ISNULL(current->data), (spif_obj_t) NULL);
c = SPIF_OBJ_COMP(current->data, key);
if (SPIF_CMP_IS_EQUAL(c)) {
return SPIF_OBJPAIR(current->data)->value;
@@ -655,7 +655,7 @@ spif_dlinked_list_map_get(spif_dlinked_list_t self, spif_obj_t key)
break;
}
}
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_list_t
@@ -663,7 +663,7 @@ spif_dlinked_list_get_keys(spif_dlinked_list_t self, spif_list_t key_list)
{
spif_dlinked_list_item_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(list));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_list_t) NULL);
if (SPIF_LIST_ISNULL(key_list)) {
key_list = SPIF_LIST_NEW(linked_list);
}
@@ -679,7 +679,7 @@ spif_dlinked_list_get_pairs(spif_dlinked_list_t self, spif_list_t pair_list)
{
spif_dlinked_list_item_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(list));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_list_t) NULL);
if (SPIF_LIST_ISNULL(pair_list)) {
pair_list = SPIF_LIST_NEW(linked_list);
}
@@ -695,7 +695,7 @@ spif_dlinked_list_get_values(spif_dlinked_list_t self, spif_list_t value_list)
{
spif_dlinked_list_item_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(list));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_list_t) NULL);
if (SPIF_LIST_ISNULL(value_list)) {
value_list = SPIF_LIST_NEW(linked_list);
}
@@ -739,7 +739,7 @@ spif_dlinked_list_index(spif_dlinked_list_t self, spif_obj_t obj)
spif_listidx_t i;
spif_dlinked_list_item_t current;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_CAST(listidx) -1);
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_listidx_t) -1);
for (current = self->head, i = 0; current && !SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(obj, current->data)); i++, current = current->next);
return (current ? i : ((spif_listidx_t) (-1)));
}
@@ -795,7 +795,7 @@ spif_dlinked_list_insert_at(spif_dlinked_list_t self, spif_obj_t obj, spif_listi
return spif_dlinked_list_append(self, obj);
} else if (idx > self->len) {
for (i = self->len; i < idx; i++) {
- spif_dlinked_list_append(self, SPIF_NULL_TYPE(obj));
+ spif_dlinked_list_append(self, (spif_obj_t) NULL);
}
return spif_dlinked_list_append(self, obj);
} else if (idx > (self->len / 2)) {
@@ -823,8 +823,8 @@ spif_dlinked_list_insert_at(spif_dlinked_list_t self, spif_obj_t obj, spif_listi
static spif_iterator_t
spif_dlinked_list_iterator(spif_dlinked_list_t self)
{
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(iterator));
- return SPIF_CAST(iterator) spif_dlinked_list_iterator_new(self);
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_iterator_t) NULL);
+ return (spif_iterator_t) spif_dlinked_list_iterator_new(self);
}
static spif_bool_t
@@ -855,14 +855,14 @@ spif_dlinked_list_remove(spif_dlinked_list_t self, spif_obj_t item)
{
spif_dlinked_list_item_t current, tmp;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t) NULL);
if (SPIF_DLINKED_LIST_ITEM_ISNULL(self->head)) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
for (current = self->head; current && !SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(item, current->data)); current = current->next);
if (SPIF_DLINKED_LIST_ITEM_ISNULL(current)) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
tmp = current;
if (!SPIF_DLINKED_LIST_ITEM_ISNULL(tmp->prev)) {
@@ -878,7 +878,7 @@ spif_dlinked_list_remove(spif_dlinked_list_t self, spif_obj_t item)
self->tail = tmp->prev;
}
item = tmp->data;
- tmp->data = SPIF_NULL_TYPE(obj);
+ tmp->data = (spif_obj_t) NULL;
spif_dlinked_list_item_del(tmp);
self->len--;
@@ -890,10 +890,10 @@ spif_dlinked_list_map_remove(spif_dlinked_list_t self, spif_obj_t item)
{
spif_dlinked_list_item_t current, tmp;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), (spif_obj_t) NULL);
if (SPIF_DLINKED_LIST_ITEM_ISNULL(self->head)) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
} else if (SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(self->head->data, item))) {
tmp = self->head;
self->head = self->head->next;
@@ -903,11 +903,11 @@ spif_dlinked_list_map_remove(spif_dlinked_list_t self, spif_obj_t item)
tmp = current->next;
current->next = current->next->next;
} else {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
}
item = tmp->data;
- tmp->data = SPIF_NULL_TYPE(obj);
+ tmp->data = (spif_obj_t) NULL;
spif_dlinked_list_item_del(tmp);
self->len--;
@@ -921,17 +921,17 @@ spif_dlinked_list_remove_at(spif_dlinked_list_t self, spif_listidx_t idx)
spif_dlinked_list_item_t current;
spif_obj_t tmp;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t) NULL);
if (SPIF_DLINKED_LIST_ITEM_ISNULL(self->head)) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
if (idx < 0) {
/* Negative indexes go backward from the end of the list. */
idx += self->len;
}
- REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(obj));
+ REQUIRE_RVAL(idx >= 0, (spif_obj_t) NULL);
+ REQUIRE_RVAL(idx < self->len, (spif_obj_t) NULL);
if (idx > (self->len / 2)) {
for (current = self->tail, i = self->len - 1; current && i > idx; i--, current = current->prev);
@@ -940,7 +940,7 @@ spif_dlinked_list_remove_at(spif_dlinked_list_t self, spif_listidx_t idx)
}
if (SPIF_DLINKED_LIST_ITEM_ISNULL(current)) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
if (!SPIF_DLINKED_LIST_ITEM_ISNULL(current->prev)) {
current->prev->next = current->next;
@@ -956,7 +956,7 @@ spif_dlinked_list_remove_at(spif_dlinked_list_t self, spif_listidx_t idx)
}
tmp = spif_dlinked_list_item_get_data(current);
- current->data = SPIF_NULL_TYPE(obj);
+ current->data = (spif_obj_t) NULL;
spif_dlinked_list_item_del(current);
self->len--;
@@ -1012,10 +1012,10 @@ spif_dlinked_list_to_array(spif_dlinked_list_t self)
spif_dlinked_list_item_t current;
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE_PTR(obj));
- tmp = SPIF_CAST_C(spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t *) NULL);
+ tmp = (spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
for (i = 0, current = self->head; i < self->len; current = current->next, i++) {
- tmp[i] = SPIF_CAST(obj) SPIF_OBJ(spif_dlinked_list_item_get_data(current));
+ tmp[i] = (spif_obj_t) SPIF_OBJ(spif_dlinked_list_item_get_data(current));
}
return tmp;
}
@@ -1033,7 +1033,7 @@ spif_dlinked_list_iterator_new(spif_dlinked_list_t subject)
self = SPIF_ALLOC(dlinked_list_iterator);
if (!spif_dlinked_list_iterator_init(self, subject)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(dlinked_list_iterator);
+ self = (spif_dlinked_list_iterator_t) NULL;
}
return self;
}
@@ -1046,7 +1046,7 @@ spif_dlinked_list_iterator_init(spif_dlinked_list_iterator_t self, spif_dlinked_
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_ITERATORCLASS_VAR(dlinked_list)));
self->subject = subject;
if (SPIF_LIST_ISNULL(self->subject)) {
- self->current = SPIF_NULL_TYPE(dlinked_list_item);
+ self->current = (spif_dlinked_list_item_t) NULL;
} else {
self->current = self->subject->head;
}
@@ -1057,8 +1057,8 @@ static spif_bool_t
spif_dlinked_list_iterator_done(spif_dlinked_list_iterator_t self)
{
ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), FALSE);
- self->subject = SPIF_NULL_TYPE(dlinked_list);
- self->current = SPIF_NULL_TYPE(dlinked_list_item);
+ self->subject = (spif_dlinked_list_t) NULL;
+ self->current = (spif_dlinked_list_item_t) NULL;
return TRUE;
}
@@ -1082,21 +1082,21 @@ spif_dlinked_list_iterator_show(spif_dlinked_list_iterator_t self, spif_charptr_
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_dlinked_list_iterator_t) %s: %10p {\n", name,
- SPIF_CAST(ptr) self);
+ (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
spif_str_append_from_ptr(buff, tmp);
}
- buff = spif_dlinked_list_show(self->subject, SPIF_CAST(charptr) "subject",
+ buff = spif_dlinked_list_show(self->subject, (spif_charptr_t) "subject",
buff, indent + 2);
- buff = spif_dlinked_list_item_show(self->current, SPIF_CAST(charptr) "current",
+ buff = spif_dlinked_list_item_show(self->current, (spif_charptr_t) "current",
buff, indent + 2);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent, "}\n");
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -1112,7 +1112,7 @@ spif_dlinked_list_iterator_dup(spif_dlinked_list_iterator_t self)
{
spif_dlinked_list_iterator_t tmp;
- ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(dlinked_list_iterator));
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), (spif_dlinked_list_iterator_t) NULL);
tmp = spif_dlinked_list_iterator_new(self->subject);
tmp->current = self->current;
return tmp;
@@ -1121,7 +1121,7 @@ spif_dlinked_list_iterator_dup(spif_dlinked_list_iterator_t self)
static spif_classname_t
spif_dlinked_list_iterator_type(spif_dlinked_list_iterator_t self)
{
- ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -1145,9 +1145,9 @@ spif_dlinked_list_iterator_next(spif_dlinked_list_iterator_t self)
{
spif_obj_t tmp;
- ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->subject), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_DLINKED_LIST_ITEM_ISNULL(self->current), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->subject), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_DLINKED_LIST_ITEM_ISNULL(self->current), (spif_obj_t) NULL);
tmp = self->current->data;
self->current = self->current->next;
return tmp;
diff --git a/src/file.c b/src/file.c
index edf3802..d44ec8c 100644
--- a/src/file.c
+++ b/src/file.c
@@ -67,20 +67,20 @@ spiftool_temp_file(spif_charptr_t ftemplate, size_t len)
int fd;
mode_t m;
- ASSERT_RVAL(!SPIF_PTR_ISNULL(ftemplate), SPIF_CAST_C(int) -1);
- ASSERT_RVAL(len > 0, SPIF_CAST_C(int) -1);
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(ftemplate), (int) -1);
+ ASSERT_RVAL(len > 0, (int) -1);
if (getenv("TMPDIR")) {
- snprintf(SPIF_CAST_C(char *) buff, sizeof(buff),
+ snprintf((char *) buff, sizeof(buff),
"%s/%sXXXXXX", getenv("TMPDIR"), ftemplate);
} else if (getenv("TMP")) {
- snprintf(SPIF_CAST_C(char *) buff, sizeof(buff),
+ snprintf((char *) buff, sizeof(buff),
"%s/%sXXXXXX", getenv("TMP"), ftemplate);
} else {
- snprintf(SPIF_CAST_C(char *) buff, sizeof(buff),
+ snprintf((char *) buff, sizeof(buff),
"/tmp/%sXXXXXX", ftemplate);
}
m = umask(0077);
- fd = mkstemp(SPIF_CAST_C(char *) buff);
+ fd = mkstemp((char *) buff);
umask(m);
if ((fd < 0) || fchmod(fd, (S_IRUSR | S_IWUSR))) {
return (-1);
diff --git a/src/linked_list.c b/src/linked_list.c
index 64b1be6..57563ad 100644
--- a/src/linked_list.c
+++ b/src/linked_list.c
@@ -218,7 +218,7 @@ spif_linked_list_item_new(void)
self = SPIF_ALLOC(linked_list_item);
if (!spif_linked_list_item_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(linked_list_item);
+ self = (spif_linked_list_item_t) NULL;
}
return self;
}
@@ -227,8 +227,8 @@ static spif_bool_t
spif_linked_list_item_init(spif_linked_list_item_t self)
{
ASSERT_RVAL(!SPIF_LINKED_LIST_ITEM_ISNULL(self), FALSE);
- self->data = SPIF_NULL_TYPE(obj);
- self->next = SPIF_NULL_TYPE(linked_list_item);
+ self->data = (spif_obj_t) NULL;
+ self->next = (spif_linked_list_item_t) NULL;
return TRUE;
}
@@ -236,11 +236,11 @@ static spif_bool_t
spif_linked_list_item_done(spif_linked_list_item_t self)
{
ASSERT_RVAL(!SPIF_LINKED_LIST_ITEM_ISNULL(self), FALSE);
- if (self->data != SPIF_NULL_TYPE(obj)) {
+ if (self->data != (spif_obj_t) NULL) {
SPIF_OBJ_DEL(self->data);
}
- self->data = SPIF_NULL_TYPE(obj);
- self->next = SPIF_NULL_TYPE(linked_list_item);
+ self->data = (spif_obj_t) NULL;
+ self->next = (spif_linked_list_item_t) NULL;
return TRUE;
}
@@ -264,16 +264,16 @@ spif_linked_list_item_show(spif_linked_list_item_t self, spif_charptr_t name, sp
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_linked_list_item_t) %s (%9p -> %9p): ",
- name, SPIF_CAST(ptr) self, SPIF_CAST(ptr) self->next);
+ name, (spif_ptr_t) self, (spif_ptr_t) self->next);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
spif_str_append_from_ptr(buff, tmp);
}
if (SPIF_LINKED_LIST_ITEM_ISNULL(self->data)) {
- spif_str_append_from_ptr(buff, SPIF_CAST(charptr) SPIF_NULLSTR_TYPE(obj) "\n");
+ spif_str_append_from_ptr(buff, (spif_charptr_t) SPIF_NULLSTR_TYPE(obj) "\n");
} else {
buff = SPIF_OBJ_SHOW(self->data, buff, 0);
}
@@ -285,7 +285,7 @@ spif_linked_list_item_comp(spif_linked_list_item_t self, spif_linked_list_item_t
{
SPIF_OBJ_COMP_CHECK_NULL(self, other);
SPIF_OBJ_COMP_CHECK_NULL(self->data, other->data);
- return (SPIF_CAST(cmp) SPIF_OBJ_COMP(SPIF_OBJ(self->data), SPIF_OBJ(other->data)));
+ return ((spif_cmp_t) SPIF_OBJ_COMP(SPIF_OBJ(self->data), SPIF_OBJ(other->data)));
}
static spif_linked_list_item_t
@@ -304,7 +304,7 @@ spif_linked_list_item_dup(spif_linked_list_item_t self)
static spif_classname_t
spif_linked_list_item_type(spif_linked_list_item_t self)
{
- ASSERT_RVAL(!SPIF_LINKED_LIST_ITEM_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_LINKED_LIST_ITEM_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -320,7 +320,7 @@ spif_linked_list_new(void)
self = SPIF_ALLOC(linked_list);
if (!spif_linked_list_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(linked_list);
+ self = (spif_linked_list_t) NULL;
}
return self;
}
@@ -333,7 +333,7 @@ spif_linked_list_vector_new(void)
self = SPIF_ALLOC(linked_list);
if (!spif_linked_list_vector_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(linked_list);
+ self = (spif_linked_list_t) NULL;
}
return self;
}
@@ -346,7 +346,7 @@ spif_linked_list_map_new(void)
self = SPIF_ALLOC(linked_list);
if (!spif_linked_list_map_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(linked_list);
+ self = (spif_linked_list_t) NULL;
}
return self;
}
@@ -360,7 +360,7 @@ spif_linked_list_init(spif_linked_list_t self)
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
t = spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_LISTCLASS_VAR(linked_list)));
self->len = 0;
- self->head = SPIF_NULL_TYPE(linked_list_item);
+ self->head = (spif_linked_list_item_t) NULL;
return t;
}
@@ -373,7 +373,7 @@ spif_linked_list_vector_init(spif_linked_list_t self)
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
t = spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_VECTORCLASS_VAR(linked_list)));
self->len = 0;
- self->head = SPIF_NULL_TYPE(linked_list_item);
+ self->head = (spif_linked_list_item_t) NULL;
return t;
}
@@ -386,7 +386,7 @@ spif_linked_list_map_init(spif_linked_list_t self)
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
t = spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_MAPCLASS_VAR(linked_list)));
self->len = 0;
- self->head = SPIF_NULL_TYPE(linked_list_item);
+ self->head = (spif_linked_list_item_t) NULL;
return t;
}
@@ -405,7 +405,7 @@ spif_linked_list_done(spif_linked_list_t self)
spif_linked_list_item_del(tmp);
}
self->len = 0;
- self->head = SPIF_NULL_TYPE(linked_list_item);
+ self->head = (spif_linked_list_item_t) NULL;
}
return TRUE;
}
@@ -432,29 +432,29 @@ spif_linked_list_show(spif_linked_list_t self, spif_charptr_t name, spif_str_t b
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
- "(spif_linked_list_t) %s: %10p {\n", name, SPIF_CAST(ptr) self);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
+ "(spif_linked_list_t) %s: %10p {\n", name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
spif_str_append_from_ptr(buff, tmp);
}
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent, " len: %lu\n",
- SPIF_CAST_C(unsigned long) self->len);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, " len: %lu\n",
+ (unsigned long) self->len);
spif_str_append_from_ptr(buff, tmp);
if (SPIF_LINKED_LIST_ITEM_ISNULL(self->head)) {
- spif_str_append_from_ptr(buff, SPIF_CAST(charptr) SPIF_NULLSTR_TYPE(obj) "\n");
+ spif_str_append_from_ptr(buff, (spif_charptr_t) SPIF_NULLSTR_TYPE(obj) "\n");
} else {
for (current = self->head, i = 0; current; current = current->next, i++) {
- sprintf(SPIF_CAST_C(char *) tmp, "item %d", i);
+ sprintf((char *) tmp, "item %d", i);
buff = spif_linked_list_item_show(current, tmp, buff, indent + 2);
}
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent, "}\n");
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -473,14 +473,14 @@ spif_linked_list_dup(spif_linked_list_t self)
spif_linked_list_t tmp;
spif_linked_list_item_t src, dest;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(linked_list));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_linked_list_t) NULL);
tmp = spif_linked_list_new();
memcpy(tmp, self, SPIF_SIZEOF_TYPE(linked_list));
tmp->head = spif_linked_list_item_dup(self->head);
for (src = self->head, dest = tmp->head; src->next; src = src->next, dest = dest->next) {
dest->next = spif_linked_list_item_dup(src->next);
}
- dest->next = SPIF_NULL_TYPE(linked_list_item);
+ dest->next = (spif_linked_list_item_t) NULL;
return tmp;
}
@@ -490,14 +490,14 @@ spif_linked_list_vector_dup(spif_linked_list_t self)
spif_linked_list_t tmp;
spif_linked_list_item_t src, dest;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(linked_list));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_linked_list_t) NULL);
tmp = spif_linked_list_vector_new();
memcpy(tmp, self, SPIF_SIZEOF_TYPE(linked_list));
tmp->head = spif_linked_list_item_dup(self->head);
for (src = self->head, dest = tmp->head; src->next; src = src->next, dest = dest->next) {
dest->next = spif_linked_list_item_dup(src->next);
}
- dest->next = SPIF_NULL_TYPE(linked_list_item);
+ dest->next = (spif_linked_list_item_t) NULL;
return tmp;
}
@@ -507,21 +507,21 @@ spif_linked_list_map_dup(spif_linked_list_t self)
spif_linked_list_t tmp;
spif_linked_list_item_t src, dest;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(linked_list));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_linked_list_t) NULL);
tmp = spif_linked_list_map_new();
memcpy(tmp, self, SPIF_SIZEOF_TYPE(linked_list));
tmp->head = spif_linked_list_item_dup(self->head);
for (src = self->head, dest = tmp->head; src->next; src = src->next, dest = dest->next) {
dest->next = spif_linked_list_item_dup(src->next);
}
- dest->next = SPIF_NULL_TYPE(linked_list_item);
+ dest->next = (spif_linked_list_item_t) NULL;
return tmp;
}
static spif_classname_t
spif_linked_list_type(spif_linked_list_t self)
{
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -564,7 +564,7 @@ spif_linked_list_vector_contains(spif_linked_list_t self, spif_obj_t obj)
static spif_listidx_t
spif_linked_list_count(spif_linked_list_t self)
{
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(listidx));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_listidx_t) NULL);
return self->len;
}
@@ -573,15 +573,15 @@ spif_linked_list_find(spif_linked_list_t self, spif_obj_t obj)
{
spif_linked_list_item_t current;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), (spif_obj_t) NULL);
for (current = self->head; current; current = current->next) {
/* current->data may be NULL here, so use obj methods. */
if (SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(obj, current->data))) {
return current->data;
}
}
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_obj_t
@@ -589,13 +589,13 @@ spif_linked_list_vector_find(spif_linked_list_t self, spif_obj_t obj)
{
spif_linked_list_item_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(obj), (spif_obj_t) NULL);
for (current = self->head; current; current = current->next) {
spif_cmp_t c;
/* current->data is always non-NULL in vectors. */
- ASSERT_RVAL(!SPIF_OBJ_ISNULL(current->data), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_OBJ_ISNULL(current->data), (spif_obj_t) NULL);
c = SPIF_OBJ_COMP(current->data, obj);
if (SPIF_CMP_IS_EQUAL(c)) {
return current->data;
@@ -603,7 +603,7 @@ spif_linked_list_vector_find(spif_linked_list_t self, spif_obj_t obj)
break;
}
}
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_obj_t
@@ -612,15 +612,15 @@ spif_linked_list_get(spif_linked_list_t self, spif_listidx_t idx)
spif_listidx_t i;
spif_linked_list_item_t current;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t) NULL);
if (idx < 0) {
/* Negative indexes go backward from the end of the list. */
idx += self->len;
}
- REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(obj));
+ REQUIRE_RVAL(idx >= 0, (spif_obj_t) NULL);
+ REQUIRE_RVAL(idx < self->len, (spif_obj_t) NULL);
for (current = self->head, i = 0; current && i < idx; i++, current = current->next);
- return (current ? (current->data) : SPIF_NULL_TYPE(obj));
+ return (current ? (current->data) : (spif_obj_t) NULL);
}
static spif_obj_t
@@ -628,13 +628,13 @@ spif_linked_list_map_get(spif_linked_list_t self, spif_obj_t key)
{
spif_linked_list_item_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(key), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(key), (spif_obj_t) NULL);
for (current = self->head; current; current = current->next) {
spif_cmp_t c;
/* current->data is always non-NULL in maps. */
- ASSERT_RVAL(!SPIF_OBJ_ISNULL(current->data), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_OBJ_ISNULL(current->data), (spif_obj_t) NULL);
c = SPIF_OBJ_COMP(current->data, key);
if (SPIF_CMP_IS_EQUAL(c)) {
return SPIF_OBJPAIR(current->data)->value;
@@ -642,7 +642,7 @@ spif_linked_list_map_get(spif_linked_list_t self, spif_obj_t key)
break;
}
}
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
static spif_list_t
@@ -650,7 +650,7 @@ spif_linked_list_get_keys(spif_linked_list_t self, spif_list_t key_list)
{
spif_linked_list_item_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(list));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_list_t) NULL);
if (SPIF_LIST_ISNULL(key_list)) {
key_list = SPIF_LIST_NEW(linked_list);
}
@@ -666,7 +666,7 @@ spif_linked_list_get_pairs(spif_linked_list_t self, spif_list_t pair_list)
{
spif_linked_list_item_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(list));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_list_t) NULL);
if (SPIF_LIST_ISNULL(pair_list)) {
pair_list = SPIF_LIST_NEW(linked_list);
}
@@ -682,7 +682,7 @@ spif_linked_list_get_values(spif_linked_list_t self, spif_list_t value_list)
{
spif_linked_list_item_t current;
- ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), SPIF_NULL_TYPE(list));
+ ASSERT_RVAL(!SPIF_VECTOR_ISNULL(self), (spif_list_t) NULL);
if (SPIF_LIST_ISNULL(value_list)) {
value_list = SPIF_LIST_NEW(linked_list);
}
@@ -726,9 +726,9 @@ spif_linked_list_index(spif_linked_list_t self, spif_obj_t obj)
spif_listidx_t i;
spif_linked_list_item_t current;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_CAST(listidx) -1);
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_listidx_t) -1);
for (current = self->head, i = 0; current && !SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(obj, current->data)); i++, current = current->next);
- return (current ? i : (SPIF_CAST(listidx) -1));
+ return (current ? i : ((spif_listidx_t) -1));
}
static spif_bool_t
@@ -790,7 +790,7 @@ spif_linked_list_insert_at(spif_linked_list_t self, spif_obj_t obj, spif_listidx
static spif_iterator_t
spif_linked_list_iterator(spif_linked_list_t self)
{
- return SPIF_CAST(iterator) spif_linked_list_iterator_new(self);
+ return (spif_iterator_t) spif_linked_list_iterator_new(self);
}
static spif_bool_t
@@ -817,10 +817,10 @@ spif_linked_list_remove(spif_linked_list_t self, spif_obj_t item)
{
spif_linked_list_item_t current, tmp;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), (spif_obj_t) NULL);
if (SPIF_LINKED_LIST_ITEM_ISNULL(self->head)) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
} else if (SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(item, self->head->data))) {
tmp = self->head;
self->head = self->head->next;
@@ -830,11 +830,11 @@ spif_linked_list_remove(spif_linked_list_t self, spif_obj_t item)
tmp = current->next;
current->next = current->next->next;
} else {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
}
item = tmp->data;
- tmp->data = SPIF_NULL_TYPE(obj);
+ tmp->data = (spif_obj_t) NULL;
spif_linked_list_item_del(tmp);
self->len--;
@@ -846,10 +846,10 @@ spif_linked_list_map_remove(spif_linked_list_t self, spif_obj_t item)
{
spif_linked_list_item_t current, tmp;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_OBJ_ISNULL(item), (spif_obj_t) NULL);
if (SPIF_LINKED_LIST_ITEM_ISNULL(self->head)) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
} else if (SPIF_CMP_IS_EQUAL(SPIF_OBJ_COMP(self->head->data, item))) {
tmp = self->head;
self->head = self->head->next;
@@ -859,11 +859,11 @@ spif_linked_list_map_remove(spif_linked_list_t self, spif_obj_t item)
tmp = current->next;
current->next = current->next->next;
} else {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
}
item = tmp->data;
- tmp->data = SPIF_NULL_TYPE(obj);
+ tmp->data = (spif_obj_t) NULL;
spif_linked_list_item_del(tmp);
self->len--;
@@ -877,30 +877,30 @@ spif_linked_list_remove_at(spif_linked_list_t self, spif_listidx_t idx)
spif_linked_list_item_t item, current;
spif_obj_t tmp;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t) NULL);
if (idx < 0) {
/* Negative indexes go backward from the end of the list. */
idx += self->len;
}
- REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(obj));
+ REQUIRE_RVAL(idx >= 0, (spif_obj_t) NULL);
+ REQUIRE_RVAL(idx < self->len, (spif_obj_t) NULL);
if (SPIF_LINKED_LIST_ITEM_ISNULL(self->head)) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
} else if (idx == 0) {
item = self->head;
self->head = item->next;
} else {
for (current = self->head, i = 1; current->next && i < idx; i++, current = current->next);
if (i != idx) {
- return SPIF_NULL_TYPE(obj);
+ return (spif_obj_t) NULL;
}
item = current->next;
current->next = item->next;
}
self->len--;
tmp = spif_linked_list_item_get_data(item);
- item->data = SPIF_NULL_TYPE(obj);
+ item->data = (spif_obj_t) NULL;
spif_linked_list_item_del(item);
return tmp;
}
@@ -911,7 +911,7 @@ spif_linked_list_reverse(spif_linked_list_t self)
spif_linked_list_item_t current, tmp, previous;
ASSERT_RVAL(!SPIF_LIST_ISNULL(self), FALSE);
- for (previous = SPIF_NULL_TYPE(linked_list_item), current = self->head; current; previous = tmp) {
+ for (previous = (spif_linked_list_item_t) NULL, current = self->head; current; previous = tmp) {
tmp = current;
current = current->next;
tmp->next = previous;
@@ -954,10 +954,10 @@ spif_linked_list_to_array(spif_linked_list_t self)
spif_linked_list_item_t current;
spif_listidx_t i;
- ASSERT_RVAL(!SPIF_LIST_ISNULL(self), SPIF_NULL_TYPE_PTR(obj));
- tmp = SPIF_CAST_C(spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
+ ASSERT_RVAL(!SPIF_LIST_ISNULL(self), (spif_obj_t *) NULL);
+ tmp = (spif_obj_t *) MALLOC(SPIF_SIZEOF_TYPE(obj) * self->len);
for (i = 0, current = self->head; i < self->len; current = current->next, i++) {
- tmp[i] = SPIF_CAST(obj) SPIF_OBJ(spif_linked_list_item_get_data(current));
+ tmp[i] = (spif_obj_t) SPIF_OBJ(spif_linked_list_item_get_data(current));
}
return tmp;
}
@@ -974,7 +974,7 @@ spif_linked_list_iterator_new(spif_linked_list_t subject)
self = SPIF_ALLOC(linked_list_iterator);
if (!spif_linked_list_iterator_init(self, subject)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(linked_list_iterator);
+ self = (spif_linked_list_iterator_t) NULL;
}
return self;
}
@@ -987,7 +987,7 @@ spif_linked_list_iterator_init(spif_linked_list_iterator_t self, spif_linked_lis
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_ITERATORCLASS_VAR(linked_list)));
self->subject = subject;
if (SPIF_LIST_ISNULL(self->subject)) {
- self->current = SPIF_NULL_TYPE(linked_list_item);
+ self->current = (spif_linked_list_item_t) NULL;
} else {
self->current = self->subject->head;
}
@@ -999,8 +999,8 @@ spif_linked_list_iterator_done(spif_linked_list_iterator_t self)
{
ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), FALSE);
/* Do not destroy these objects. The list owns them! */
- self->subject = SPIF_NULL_TYPE(linked_list);
- self->current = SPIF_NULL_TYPE(linked_list_item);
+ self->subject = (spif_linked_list_t) NULL;
+ self->current = (spif_linked_list_item_t) NULL;
return TRUE;
}
@@ -1024,19 +1024,19 @@ spif_linked_list_iterator_show(spif_linked_list_iterator_t self, spif_charptr_t
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_linked_list_iterator_t) %s: %10p {\n",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
spif_str_append_from_ptr(buff, tmp);
}
- buff = spif_linked_list_show(self->subject, SPIF_CAST(charptr) "subject", buff, indent + 2);
- buff = spif_linked_list_item_show(self->current, SPIF_CAST(charptr) "current", buff, indent + 2);
+ buff = spif_linked_list_show(self->subject, (spif_charptr_t) "subject", buff, indent + 2);
+ buff = spif_linked_list_item_show(self->current, (spif_charptr_t) "current", buff, indent + 2);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent, "}\n");
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -1054,7 +1054,7 @@ spif_linked_list_iterator_dup(spif_linked_list_iterator_t self)
{
spif_linked_list_iterator_t tmp;
- ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(linked_list_iterator));
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), (spif_linked_list_iterator_t) NULL);
tmp = spif_linked_list_iterator_new(self->subject);
tmp->current = self->current;
return tmp;
@@ -1063,7 +1063,7 @@ spif_linked_list_iterator_dup(spif_linked_list_iterator_t self)
static spif_classname_t
spif_linked_list_iterator_type(spif_linked_list_iterator_t self)
{
- ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -1087,9 +1087,9 @@ spif_linked_list_iterator_next(spif_linked_list_iterator_t self)
{
spif_obj_t tmp;
- ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->subject), SPIF_NULL_TYPE(obj));
- REQUIRE_RVAL(!SPIF_LINKED_LIST_ITEM_ISNULL(self->current), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->subject), (spif_obj_t) NULL);
+ REQUIRE_RVAL(!SPIF_LINKED_LIST_ITEM_ISNULL(self->current), (spif_obj_t) NULL);
tmp = self->current->data;
self->current = self->current->next;
return tmp;
diff --git a/src/mbuff.c b/src/mbuff.c
index 69bd9bb..1d83504 100644
--- a/src/mbuff.c
+++ b/src/mbuff.c
@@ -71,7 +71,7 @@ static SPIF_CONST_TYPE(mbuffclass) mb_class = {
(spif_func_t) spif_mbuff_subbuff_to_ptr,
(spif_func_t) spif_mbuff_trim
};
-SPIF_TYPE(class) SPIF_CLASS_VAR(mbuff) = SPIF_CAST(class) &mb_class;
+SPIF_TYPE(class) SPIF_CLASS_VAR(mbuff) = (spif_class_t) &mb_class;
SPIF_TYPE(mbuffclass) SPIF_MBUFFCLASS_VAR(mbuff) = &mb_class;
/* *INDENT-ON* */
@@ -85,7 +85,7 @@ spif_mbuff_new(void)
self = SPIF_ALLOC(mbuff);
if (!spif_mbuff_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(mbuff);
+ self = (spif_mbuff_t) NULL;
}
return self;
}
@@ -98,7 +98,7 @@ spif_mbuff_new_from_ptr(spif_byteptr_t old, spif_memidx_t len)
self = SPIF_ALLOC(mbuff);
if (!spif_mbuff_init_from_ptr(self, old, len)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(mbuff);
+ self = (spif_mbuff_t) NULL;
}
return self;
}
@@ -111,7 +111,7 @@ spif_mbuff_new_from_buff(spif_byteptr_t buff, spif_memidx_t len, spif_memidx_t s
self = SPIF_ALLOC(mbuff);
if (!spif_mbuff_init_from_buff(self, buff, len, size)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(mbuff);
+ self = (spif_mbuff_t) NULL;
}
return self;
}
@@ -124,7 +124,7 @@ spif_mbuff_new_from_fp(FILE * fp)
self = SPIF_ALLOC(mbuff);
if (!spif_mbuff_init_from_fp(self, fp)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(mbuff);
+ self = (spif_mbuff_t) NULL;
}
return self;
}
@@ -137,7 +137,7 @@ spif_mbuff_new_from_fd(int fd)
self = SPIF_ALLOC(mbuff);
if (!spif_mbuff_init_from_fd(self, fd)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(mbuff);
+ self = (spif_mbuff_t) NULL;
}
return self;
}
@@ -148,7 +148,7 @@ spif_mbuff_init(spif_mbuff_t self)
ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), FALSE);
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_MBUFFCLASS_VAR(mbuff)));
- self->buff = SPIF_NULL_TYPE(byteptr);
+ self->buff = (spif_byteptr_t) NULL;
self->len = 0;
self->size = 0;
return TRUE;
@@ -158,11 +158,11 @@ spif_bool_t
spif_mbuff_init_from_ptr(spif_mbuff_t self, spif_byteptr_t old, spif_memidx_t len)
{
ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), FALSE);
- REQUIRE_RVAL((old != SPIF_NULL_TYPE(byteptr)), spif_mbuff_init(self));
+ REQUIRE_RVAL((old != (spif_byteptr_t) NULL), spif_mbuff_init(self));
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_MBUFFCLASS_VAR(mbuff)));
self->len = self->size = len;
- self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+ self->buff = (spif_byteptr_t) MALLOC(self->size);
memcpy(self->buff, old, self->len);
return TRUE;
}
@@ -173,14 +173,14 @@ spif_mbuff_init_from_buff(spif_mbuff_t self, spif_byteptr_t buff, spif_memidx_t
ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), FALSE);
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_MBUFFCLASS_VAR(mbuff)));
- if (buff != SPIF_NULL_TYPE(byteptr)) {
+ if (buff != (spif_byteptr_t) NULL) {
self->len = len;
} else {
self->len = 0;
}
self->size = MAX(size, self->len);
- self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
- if (buff != SPIF_NULL_TYPE(byteptr)) {
+ self->buff = (spif_byteptr_t) MALLOC(self->size);
+ if (buff != (spif_byteptr_t) NULL) {
memcpy(self->buff, buff, self->len);
}
return TRUE;
@@ -193,7 +193,7 @@ spif_mbuff_init_from_fp(spif_mbuff_t self, FILE *fp)
spif_memidx_t file_size;
ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), FALSE);
- ASSERT_RVAL((fp != SPIF_NULL_TYPE_C(FILE *)), FALSE);
+ ASSERT_RVAL((fp != (FILE *) NULL), FALSE);
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_MBUFFCLASS_VAR(mbuff)));
@@ -206,7 +206,7 @@ spif_mbuff_init_from_fp(spif_mbuff_t self, FILE *fp)
D_OBJ(("Unable to seek to EOF -- %s.\n", strerror(errno)));
self->size = buff_inc;
self->len = 0;
- self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+ self->buff = (spif_byteptr_t) MALLOC(self->size);
for (p = self->buff; (cnt = fread(p, 1, buff_inc, fp)) > 0; p += buff_inc) {
self->len += cnt;
@@ -217,12 +217,12 @@ spif_mbuff_init_from_fp(spif_mbuff_t self, FILE *fp)
break;
} else {
self->size += buff_inc;
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, self->size);
}
}
self->size = self->len;
if (self->size) {
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, self->size);
} else {
FREE(self->buff);
}
@@ -235,7 +235,7 @@ spif_mbuff_init_from_fp(spif_mbuff_t self, FILE *fp)
return FALSE;
}
self->len = self->size = file_size;
- self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+ self->buff = (spif_byteptr_t) MALLOC(self->size);
if (fread(self->buff, file_size, 1, fp) < 1) {
FREE(self->buff);
@@ -257,8 +257,8 @@ spif_mbuff_init_from_fd(spif_mbuff_t self, int fd)
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_MBUFFCLASS_VAR(mbuff)));
- file_pos = lseek(fd, SPIF_CAST_C(off_t) 0, SEEK_CUR);
- file_size = SPIF_CAST(memidx) lseek(fd, SPIF_CAST_C(off_t) 0, SEEK_END);
+ file_pos = lseek(fd, (off_t) 0, SEEK_CUR);
+ file_size = (spif_memidx_t) lseek(fd, (off_t) 0, SEEK_END);
lseek(fd, file_pos, SEEK_SET);
if (file_size < 0) {
spif_byteptr_t p;
@@ -267,7 +267,7 @@ spif_mbuff_init_from_fd(spif_mbuff_t self, int fd)
D_OBJ(("Unable to seek to EOF -- %s.\n", strerror(errno)));
self->size = buff_inc;
self->len = 0;
- self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+ self->buff = (spif_byteptr_t) MALLOC(self->size);
for (p = self->buff; (cnt = read(fd, p, buff_inc)) > 0; p += buff_inc) {
self->len += cnt;
@@ -275,18 +275,18 @@ spif_mbuff_init_from_fd(spif_mbuff_t self, int fd)
break;
} else {
self->size += buff_inc;
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, self->size);
}
}
self->size = self->len;
if (self->size) {
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, self->size);
} else {
FREE(self->buff);
}
} else {
self->len = self->size = file_size;
- self->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+ self->buff = (spif_byteptr_t) MALLOC(self->size);
if (read(fd, p, file_size) < 1) {
FREE(self->buff);
@@ -304,7 +304,7 @@ spif_mbuff_done(spif_mbuff_t self)
FREE(self->buff);
self->len = 0;
self->size = 0;
- self->buff = SPIF_NULL_TYPE(byteptr);
+ self->buff = (spif_byteptr_t) NULL;
}
return TRUE;
}
@@ -330,9 +330,9 @@ spif_mbuff_show(spif_mbuff_t self, spif_byteptr_t name, spif_str_t buff, size_t
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_mbuff_t) %s: %10p (length %lu, size %lu) {\n",
- name, SPIF_CAST(ptr) self, SPIF_CAST(ulong) self->len, SPIF_CAST(ulong) self->size);
+ name, (spif_ptr_t) self, (spif_ulong_t) self->len, (spif_ulong_t) self->size);
if (SPIF_MBUFF_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -343,8 +343,8 @@ spif_mbuff_show(spif_mbuff_t self, spif_byteptr_t name, spif_str_t buff, size_t
for (j = 0; j < self->len; j += 8) {
spif_memidx_t k, l, len;
- snprintf(SPIF_CHARPTR_C(tmp) + indent + 2, sizeof(tmp) - indent - 2, "0x%08lx ", SPIF_CAST(long) j);
- len = strlen(SPIF_CHARPTR_C(tmp));
+ snprintf((char *) tmp + indent + 2, sizeof(tmp) - indent - 2, "0x%08lx ", (spif_long_t) j);
+ len = strlen((char *) tmp);
if ((sizeof(tmp) - indent - 2) > 46) {
spif_char_t buffr[9];
@@ -352,19 +352,19 @@ spif_mbuff_show(spif_mbuff_t self, spif_byteptr_t name, spif_str_t buff, size_t
memcpy(buffr, self->buff + j, l);
memset(buffr + l, 0, 9 - l);
for (k = 0; k < l; k++) {
- sprintf(SPIF_CHARPTR_C(tmp) + 14 + (k * 3), "%02x ", self->buff[j + k]);
+ sprintf((char *) tmp + 14 + (k * 3), "%02x ", self->buff[j + k]);
}
for (; k < 8; k++) {
- strcat(SPIF_CHARPTR_C(tmp) + 14, " ");
+ strcat((char *) tmp + 14, " ");
}
- sprintf(SPIF_CHARPTR_C(tmp) + 38, "%-8s\n", spiftool_safe_str(SPIF_CAST(charptr) (buffr), l));
+ sprintf((char *) tmp + 38, "%-8s\n", spiftool_safe_str((spif_charptr_t) (buffr), l));
} else {
- snprintf(SPIF_CHARPTR_C(tmp) + indent + 2, sizeof(tmp) - indent - 2, "!X!");
+ snprintf((char *) tmp + indent + 2, sizeof(tmp) - indent - 2, "!X!");
}
spif_str_append_from_ptr(buff, tmp);
}
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "}\n");
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -380,10 +380,10 @@ spif_mbuff_dup(spif_mbuff_t self)
{
spif_mbuff_t tmp;
- ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), SPIF_NULL_TYPE(mbuff));
+ ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), (spif_mbuff_t) NULL);
tmp = SPIF_ALLOC(mbuff);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(mbuff));
- tmp->buff = SPIF_CAST(byteptr) MALLOC(self->size);
+ tmp->buff = (spif_byteptr_t) MALLOC(self->size);
memcpy(tmp->buff, self->buff, self->size);
tmp->len = self->len;
tmp->size = self->size;
@@ -393,7 +393,7 @@ spif_mbuff_dup(spif_mbuff_t self)
spif_classname_t
spif_mbuff_type(spif_mbuff_t self)
{
- ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), SPIF_CAST(classname) SPIF_NULLSTR_TYPE(classname));
+ ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), (spif_classname_t) SPIF_NULLSTR_TYPE(classname));
return SPIF_OBJ_CLASSNAME(self);
}
@@ -404,7 +404,7 @@ spif_mbuff_append(spif_mbuff_t self, spif_mbuff_t other)
REQUIRE_RVAL(!SPIF_MBUFF_ISNULL(other), FALSE);
if (other->size && other->len) {
self->size += other->size;
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, self->size);
memcpy(self->buff + self->len, SPIF_MBUFF_BUFF(other), other->len);
self->len += other->len;
}
@@ -415,10 +415,10 @@ spif_bool_t
spif_mbuff_append_from_ptr(spif_mbuff_t self, spif_byteptr_t other, spif_memidx_t len)
{
ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), FALSE);
- REQUIRE_RVAL((other != SPIF_NULL_TYPE(byteptr)), FALSE);
+ REQUIRE_RVAL((other != (spif_byteptr_t) NULL), FALSE);
if (len) {
self->size += len;
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, self->size);
memcpy(self->buff + self->len, other, len);
self->len += len;
}
@@ -458,13 +458,13 @@ spif_mbuff_find(spif_mbuff_t self, spif_mbuff_t other)
{
spif_byteptr_t tmp;
- ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), (SPIF_CAST(memidx) -1));
- REQUIRE_RVAL(!SPIF_MBUFF_ISNULL(other), (SPIF_CAST(memidx) -1));
- tmp = SPIF_CAST(byteptr) memmem(SPIF_MBUFF_BUFF(self), self->len, SPIF_MBUFF_BUFF(other), other->len);
+ ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), ((spif_memidx_t) -1));
+ REQUIRE_RVAL(!SPIF_MBUFF_ISNULL(other), ((spif_memidx_t) -1));
+ tmp = (spif_byteptr_t) memmem(SPIF_MBUFF_BUFF(self), self->len, SPIF_MBUFF_BUFF(other), other->len);
if (tmp) {
- return SPIF_CAST(memidx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_MBUFF_BUFF(self)));
+ return (spif_memidx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_MBUFF_BUFF(self)));
} else {
- return SPIF_CAST(memidx) (self->len);
+ return (spif_memidx_t) (self->len);
}
}
@@ -473,13 +473,13 @@ spif_mbuff_find_from_ptr(spif_mbuff_t self, spif_byteptr_t other, spif_memidx_t
{
spif_byteptr_t tmp;
- ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), (SPIF_CAST(memidx) -1));
- REQUIRE_RVAL((other != SPIF_NULL_TYPE(byteptr)), (SPIF_CAST(memidx) -1));
- tmp = SPIF_CAST(byteptr) memmem(SPIF_MBUFF_BUFF(self), self->len, other, len);
+ ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), ((spif_memidx_t) -1));
+ REQUIRE_RVAL((other != (spif_byteptr_t) NULL), ((spif_memidx_t) -1));
+ tmp = (spif_byteptr_t) memmem(SPIF_MBUFF_BUFF(self), self->len, other, len);
if (tmp) {
- return SPIF_CAST(memidx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_MBUFF_BUFF(self)));
+ return (spif_memidx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_MBUFF_BUFF(self)));
} else {
- return SPIF_CAST(memidx) (self->len);
+ return (spif_memidx_t) (self->len);
}
}
@@ -489,9 +489,9 @@ spif_mbuff_index(spif_mbuff_t self, spif_uint8_t c)
spif_byteptr_t tmp;
spif_memidx_t i;
- ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), (SPIF_CAST(memidx) -1));
+ ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), ((spif_memidx_t) -1));
for (tmp = self->buff, i = 0; ((int) *tmp != (int) (c)) && (i < self->len); i++, tmp++);
- return SPIF_CAST(memidx) (SPIF_CAST(long) tmp - SPIF_CAST(long) self->buff);
+ return (spif_memidx_t) ((spif_long_t) tmp - (spif_long_t) self->buff);
}
spif_cmp_t
@@ -520,7 +520,7 @@ spif_mbuff_prepend(spif_mbuff_t self, spif_mbuff_t other)
REQUIRE_RVAL(!SPIF_MBUFF_ISNULL(other), FALSE);
if (other->size && other->len) {
self->size += other->size;
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, self->size);
memmove(self->buff + other->len, self->buff, self->len);
memcpy(self->buff, SPIF_MBUFF_BUFF(other), other->len);
self->len += other->len;
@@ -532,10 +532,10 @@ spif_bool_t
spif_mbuff_prepend_from_ptr(spif_mbuff_t self, spif_byteptr_t other, spif_memidx_t len)
{
ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), FALSE);
- REQUIRE_RVAL((other != SPIF_NULL_TYPE(byteptr)), FALSE);
+ REQUIRE_RVAL((other != (spif_byteptr_t) NULL), FALSE);
if (len) {
self->size += len;
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, self->size);
memmove(self->buff + len, self->buff, self->len);
memcpy(self->buff, other, len);
self->len += len;
@@ -550,7 +550,7 @@ spif_mbuff_reverse(spif_mbuff_t self)
int i, j;
ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), FALSE);
- REQUIRE_RVAL(self->buff != SPIF_NULL_TYPE(byteptr), FALSE);
+ REQUIRE_RVAL(self->buff != (spif_byteptr_t) NULL, FALSE);
for (j = 0, i = self->len - 1; i > j; i--, j++) {
SWAP(tmp[j], tmp[i]);
@@ -563,13 +563,13 @@ spif_mbuff_rindex(spif_mbuff_t self, spif_uint8_t c)
{
spif_byteptr_t tmp;
- ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), (SPIF_CAST(memidx) -1));
+ ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), ((spif_memidx_t) -1));
for (tmp = self->buff + self->len - 1; (*tmp != c) && (tmp >= self->buff); tmp--);
if ((tmp == self->buff) && (*tmp != c)) {
- return SPIF_CAST(memidx) (self->len);
+ return (spif_memidx_t) (self->len);
} else {
- return SPIF_CAST(memidx) (SPIF_CAST(long) tmp - SPIF_CAST(long) self->buff);
+ return (spif_memidx_t) ((spif_long_t) tmp - (spif_long_t) self->buff);
}
}
@@ -592,7 +592,7 @@ spif_mbuff_splice(spif_mbuff_t self, spif_memidx_t idx, spif_memidx_t cnt, spif_
REQUIRE_RVAL(cnt <= (self->len - idx), FALSE);
newsize = self->len + ((SPIF_MBUFF_ISNULL(other)) ? (0) : (other->len)) - cnt;
- ptmp = tmp = SPIF_CAST(byteptr) MALLOC(newsize);
+ ptmp = tmp = (spif_byteptr_t) MALLOC(newsize);
if (idx > 0) {
memcpy(tmp, self->buff, idx);
ptmp += idx;
@@ -603,7 +603,7 @@ spif_mbuff_splice(spif_mbuff_t self, spif_memidx_t idx, spif_memidx_t cnt, spif_
}
memcpy(ptmp, self->buff + idx + cnt, self->len - idx - cnt + 1);
if (self->size < newsize) {
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, newsize);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, newsize);
self->size = newsize;
}
self->len = newsize;
@@ -634,7 +634,7 @@ spif_mbuff_splice_from_ptr(spif_mbuff_t self, spif_memidx_t idx, spif_memidx_t c
REQUIRE_RVAL(cnt <= (self->len - idx), FALSE);
newsize = self->len + len - cnt;
- ptmp = tmp = SPIF_CAST(byteptr) MALLOC(newsize);
+ ptmp = tmp = (spif_byteptr_t) MALLOC(newsize);
if (idx > 0) {
memcpy(tmp, self->buff, idx);
ptmp += idx;
@@ -645,7 +645,7 @@ spif_mbuff_splice_from_ptr(spif_mbuff_t self, spif_memidx_t idx, spif_memidx_t c
}
memcpy(ptmp, self->buff + idx + cnt, self->len - idx - cnt);
if (self->size < newsize) {
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, newsize);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, newsize);
self->size = newsize;
}
self->len = newsize;
@@ -661,7 +661,7 @@ spif_mbuff_sprintf(spif_mbuff_t self, spif_charptr_t format, ...)
ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), FALSE);
va_start(ap, format);
- if (self->buff != SPIF_NULL_TYPE(byteptr)) {
+ if (self->buff != (spif_byteptr_t) NULL) {
spif_mbuff_done(self);
}
if (*format == 0) {
@@ -678,7 +678,7 @@ spif_mbuff_sprintf(spif_mbuff_t self, spif_charptr_t format, ...)
} else {
c++;
self->len = self->size = c;
- self->buff = SPIF_CAST(charptr) MALLOC(self->size);
+ self->buff = (spif_charptr_t) MALLOC(self->size);
c = vsnprintf(self->buff, self->size, format, ap);
}
return ((c >= 0) ? (TRUE) : (FALSE));
@@ -689,16 +689,16 @@ spif_mbuff_sprintf(spif_mbuff_t self, spif_charptr_t format, ...)
spif_mbuff_t
spif_mbuff_subbuff(spif_mbuff_t self, spif_memidx_t idx, spif_memidx_t cnt)
{
- ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), SPIF_NULL_TYPE(mbuff));
+ ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), (spif_mbuff_t) NULL);
if (idx < 0) {
idx = self->len + idx;
}
- REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(mbuff));
- REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(mbuff));
+ REQUIRE_RVAL(idx >= 0, (spif_mbuff_t) NULL);
+ REQUIRE_RVAL(idx < self->len, (spif_mbuff_t) NULL);
if (cnt <= 0) {
cnt = self->len - idx + cnt;
}
- REQUIRE_RVAL(cnt >= 0, SPIF_NULL_TYPE(mbuff));
+ REQUIRE_RVAL(cnt >= 0, (spif_mbuff_t) NULL);
UPPER_BOUND(cnt, self->len - idx);
return spif_mbuff_new_from_buff(self->buff + idx, cnt, cnt);
}
@@ -708,19 +708,19 @@ spif_mbuff_subbuff_to_ptr(spif_mbuff_t self, spif_memidx_t idx, spif_memidx_t cn
{
spif_byteptr_t newmbuff;
- ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), SPIF_NULL_TYPE(byteptr));
+ ASSERT_RVAL(!SPIF_MBUFF_ISNULL(self), (spif_byteptr_t) NULL);
if (idx < 0) {
idx = self->len + idx;
}
- REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(byteptr));
- REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(byteptr));
+ REQUIRE_RVAL(idx >= 0, (spif_byteptr_t) NULL);
+ REQUIRE_RVAL(idx < self->len, (spif_byteptr_t) NULL);
if (cnt <= 0) {
cnt = self->len - idx + cnt;
}
- REQUIRE_RVAL(cnt >= 0, SPIF_NULL_TYPE(byteptr));
+ REQUIRE_RVAL(cnt >= 0, (spif_byteptr_t) NULL);
UPPER_BOUND(cnt, self->len - idx);
- newmbuff = SPIF_CAST(byteptr) MALLOC(cnt + 1);
+ newmbuff = (spif_byteptr_t) MALLOC(cnt + 1);
memcpy(newmbuff, SPIF_MBUFF_BUFF(self) + idx, cnt);
newmbuff[cnt] = 0;
return newmbuff;
@@ -745,7 +745,7 @@ spif_mbuff_trim(spif_mbuff_t self)
}
if (self->size != self->len) {
self->size = self->len;
- self->buff = SPIF_CAST(byteptr) REALLOC(self->buff, self->size);
+ self->buff = (spif_byteptr_t) REALLOC(self->buff, self->size);
}
return TRUE;
}
diff --git a/src/mem.c b/src/mem.c
index 23fbdb4..2b4a877 100644
--- a/src/mem.c
+++ b/src/mem.c
@@ -156,7 +156,7 @@ memrec_add_var(memrec_t *memrec, const spif_charptr_t filename, unsigned long li
D_MEM(("Storing as pointer #%lu at %10p (from %10p).\n", memrec->cnt, p, memrec->ptrs));
p->ptr = ptr;
p->size = size;
- spiftool_safe_strncpy(p->file, SPIF_CONST_CAST(charptr) filename, LIBAST_FNAME_LEN);
+ spiftool_safe_strncpy(p->file, (const spif_charptr_t) filename, LIBAST_FNAME_LEN);
p->file[LIBAST_FNAME_LEN] = 0;
p->line = line;
}
@@ -267,7 +267,7 @@ memrec_chg_var(memrec_t *memrec, const spif_charptr_t var, const spif_charptr_t
D_MEM(("Changing variable %s (%10p, %lu -> %10p, %lu)\n", var, oldp, p->size, newp, size));
p->ptr = newp;
p->size = size;
- spiftool_safe_strncpy(p->file, SPIF_CONST_CAST(charptr) filename, LIBAST_FNAME_LEN);
+ spiftool_safe_strncpy(p->file, (const spif_charptr_t) filename, LIBAST_FNAME_LEN);
p->line = line;
}
@@ -293,7 +293,7 @@ memrec_dump_pointers(memrec_t *memrec)
spif_char_t buff[9];
ASSERT(memrec != NULL);
- fprintf(LIBAST_DEBUG_FD, "PTR: %lu pointers stored.\n", SPIF_CAST_C(unsigned long) memrec->cnt);
+ fprintf(LIBAST_DEBUG_FD, "PTR: %lu pointers stored.\n", (unsigned long) memrec->cnt);
fprintf(LIBAST_DEBUG_FD,
"PTR: Pointer | Filename | Line | Address | Size | Offset | 00 01 02 03 04 05 06 07 | ASCII \n");
fprintf(LIBAST_DEBUG_FD,
@@ -306,7 +306,7 @@ memrec_dump_pointers(memrec_t *memrec)
for (p = memrec->ptrs, j = 0; j < len; j += 8) {
fprintf(LIBAST_DEBUG_FD, "PTR: %07lu | %20s | %6lu | %10p | %06lu | %07x | ",
(unsigned long) 0, "", (unsigned long) 0,
- SPIF_CAST(ptr) memrec->ptrs,
+ (spif_ptr_t) memrec->ptrs,
(unsigned long) (sizeof(ptr_t) * memrec->cnt), (unsigned int) j);
/* l is the number of characters we're going to output */
l = ((len - j < 8) ? (len - j) : (8));
@@ -332,8 +332,8 @@ memrec_dump_pointers(memrec_t *memrec)
total += p->size;
for (j = 0; j < p->size; j += 8) {
fprintf(LIBAST_DEBUG_FD, "PTR: %07lu | %20s | %6lu | %10p | %06lu | %07x | ",
- i + 1, NONULL(p->file), SPIF_CAST_C(unsigned long) p->line,
- p->ptr, SPIF_CAST_C(unsigned long) p->size, SPIF_CAST_C(unsigned) j);
+ i + 1, NONULL(p->file), (unsigned long) p->line,
+ p->ptr, (unsigned long) p->size, (unsigned) j);
/* l is the number of characters we're going to output */
l = ((p->size - j < 8) ? (p->size - j) : (8));
/* Copy l bytes (up to 8) from p->ptr to buffer */
@@ -378,7 +378,7 @@ memrec_dump_resources(memrec_t *memrec)
ASSERT(memrec != NULL);
len = memrec->cnt;
fprintf(LIBAST_DEBUG_FD, "RES: %lu resources stored.\n",
- SPIF_CAST_C(unsigned long) memrec->cnt);
+ (unsigned long) memrec->cnt);
fprintf(LIBAST_DEBUG_FD, "RES: Index | Resource ID | Filename | Line | Size \n");
fprintf(LIBAST_DEBUG_FD, "RES: -------+-------------+----------------------+--------+--------\n");
fflush(LIBAST_DEBUG_FD);
@@ -386,13 +386,13 @@ memrec_dump_resources(memrec_t *memrec)
for (p = memrec->ptrs, i = 0, total = 0; i < len; i++, p++) {
total += p->size;
fprintf(LIBAST_DEBUG_FD, "RES: %5lu | 0x%08lx | %20s | %6lu | %6lu\n",
- i, SPIF_CAST_C(unsigned long) p->ptr, NONULL(p->file),
- SPIF_CAST_C(unsigned long) p->line,
- SPIF_CAST_C(unsigned long) p->size);
+ i, (unsigned long) p->ptr, NONULL(p->file),
+ (unsigned long) p->line,
+ (unsigned long) p->size);
/* Flush after every line in case we crash */
fflush(LIBAST_DEBUG_FD);
}
- fprintf(LIBAST_DEBUG_FD, "RES: Total size: %lu bytes\n", SPIF_CAST_C(unsigned long) total);
+ fprintf(LIBAST_DEBUG_FD, "RES: Total size: %lu bytes\n", (unsigned long) total);
fflush(LIBAST_DEBUG_FD);
}
@@ -431,9 +431,9 @@ spifmem_malloc(const spif_charptr_t filename, unsigned long line, size_t size)
D_MEM(("%lu bytes requested at %s:%lu\n", size, NONULL(filename), line));
temp = (void *) malloc(size);
- ASSERT_RVAL(!SPIF_PTR_ISNULL(temp), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(temp), (spif_ptr_t) NULL);
if (DEBUG_LEVEL >= DEBUG_MEM) {
- memrec_add_var(&malloc_rec, SPIF_CAST(charptr) NONULL(filename), line, temp, size);
+ memrec_add_var(&malloc_rec, (spif_charptr_t) NONULL(filename), line, temp, size);
}
return (temp);
}
@@ -478,9 +478,9 @@ spifmem_realloc(const spif_charptr_t var, const spif_charptr_t filename, unsigne
temp = NULL;
} else {
temp = (void *) realloc(ptr, size);
- ASSERT_RVAL(!SPIF_PTR_ISNULL(temp), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(temp), (spif_ptr_t) NULL);
if (DEBUG_LEVEL >= DEBUG_MEM) {
- memrec_chg_var(&malloc_rec, var, SPIF_CAST(charptr) NONULL(filename), line, ptr, temp, size);
+ memrec_chg_var(&malloc_rec, var, (spif_charptr_t) NONULL(filename), line, ptr, temp, size);
}
}
return (temp);
@@ -520,9 +520,9 @@ spifmem_calloc(const spif_charptr_t filename, unsigned long line, size_t count,
D_MEM(("%lu units of %lu bytes each requested at %s:%lu\n", count, size, NONULL(filename), line));
temp = (void *) calloc(count, size);
- ASSERT_RVAL(!SPIF_PTR_ISNULL(temp), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(temp), (spif_ptr_t) NULL);
if (DEBUG_LEVEL >= DEBUG_MEM) {
- memrec_add_var(&malloc_rec, SPIF_CAST(charptr) NONULL(filename), line, temp, size * count);
+ memrec_add_var(&malloc_rec, (spif_charptr_t) NONULL(filename), line, temp, size * count);
}
return (temp);
}
@@ -556,7 +556,7 @@ spifmem_free(const spif_charptr_t var, const spif_charptr_t filename, unsigned l
D_MEM(("Variable %s (%10p) at %s:%lu\n", var, ptr, NONULL(filename), line));
if (ptr) {
if (DEBUG_LEVEL >= DEBUG_MEM) {
- memrec_rem_var(&malloc_rec, var, SPIF_CAST(charptr) NONULL(filename), line, ptr);
+ memrec_rem_var(&malloc_rec, var, (spif_charptr_t) NONULL(filename), line, ptr);
}
free(ptr);
} else {
@@ -587,14 +587,14 @@ spifmem_strdup(const spif_charptr_t var, const spif_charptr_t filename, unsigned
register spif_charptr_t newstr;
register size_t len;
- ASSERT_RVAL(!SPIF_PTR_ISNULL(str), SPIF_NULL_TYPE_C(spif_charptr_t));
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(str), (spif_charptr_t) NULL);
USE_VAR(var);
D_MEM(("Variable %s (%10p) at %s:%lu\n", var, str, NONULL(filename), line));
- len = strlen(SPIF_CAST_C(char *) str) + 1; /* Copy NUL byte also */
- newstr = SPIF_CAST(charptr) spifmem_malloc(SPIF_CAST(charptr) NONULL(filename), line, len);
- ASSERT_RVAL(!SPIF_PTR_ISNULL(newstr), SPIF_NULL_TYPE(ptr));
- strcpy(SPIF_CAST_C(char *) newstr, SPIF_CAST_C(char *) str);
+ len = strlen((char *) str) + 1; /* Copy NUL byte also */
+ newstr = (spif_charptr_t) spifmem_malloc((spif_charptr_t) NONULL(filename), line, len);
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(newstr), (spif_ptr_t) NULL);
+ strcpy((char *) newstr, (char *) str);
return (newstr);
}
@@ -649,7 +649,7 @@ spifmem_x_create_pixmap(const spif_charptr_t filename, unsigned long line, Displ
D_MEM(("Created %ux%u pixmap 0x%08x of depth %u for window 0x%08x at %s:%lu\n", w, h, p, depth, win, NONULL(filename), line));
ASSERT_RVAL(p != None, None);
if (DEBUG_LEVEL >= DEBUG_MEM) {
- memrec_add_var(&pixmap_rec, SPIF_CAST(charptr) NONULL(filename), line, (void *) p, w * h * (depth / 8));
+ memrec_add_var(&pixmap_rec, (spif_charptr_t) NONULL(filename), line, (void *) p, w * h * (depth / 8));
}
return (p);
}
@@ -677,7 +677,7 @@ spifmem_x_free_pixmap(const spif_charptr_t var, const spif_charptr_t filename, u
D_MEM(("Freeing pixmap %s (0x%08x) at %s:%lu\n", var, p, NONULL(filename), line));
if (p) {
if (DEBUG_LEVEL >= DEBUG_MEM) {
- memrec_rem_var(&pixmap_rec, var, SPIF_CAST(charptr) NONULL(filename), line, (void *) p);
+ memrec_rem_var(&pixmap_rec, var, (spif_charptr_t) NONULL(filename), line, (void *) p);
}
XFreePixmap(d, p);
} else {
@@ -710,7 +710,7 @@ spifmem_imlib_register_pixmap(const spif_charptr_t var, const spif_charptr_t fil
if (p) {
if (DEBUG_LEVEL >= DEBUG_MEM) {
if (!memrec_find_var(&pixmap_rec, (void *) p)) {
- memrec_add_var(&pixmap_rec, SPIF_CAST(charptr) NONULL(filename), line, (void *) p, 1);
+ memrec_add_var(&pixmap_rec, (spif_charptr_t) NONULL(filename), line, (void *) p, 1);
} else {
D_MEM(("Pixmap 0x%08x already registered.\n"));
}
@@ -743,7 +743,7 @@ spifmem_imlib_free_pixmap(const spif_charptr_t var, const spif_charptr_t filenam
D_MEM(("Freeing pixmap %s (0x%08x) at %s:%lu using Imlib2\n", var, p, NONULL(filename), line));
if (p) {
if (DEBUG_LEVEL >= DEBUG_MEM) {
- memrec_rem_var(&pixmap_rec, var, SPIF_CAST(charptr) NONULL(filename), line, (void *) p);
+ memrec_rem_var(&pixmap_rec, var, (spif_charptr_t) NONULL(filename), line, (void *) p);
}
imlib_free_pixmap_and_mask(p);
} else {
@@ -802,7 +802,7 @@ spifmem_x_create_gc(const spif_charptr_t filename, unsigned long line, Display *
gc = XCreateGC(d, win, mask, gcv);
ASSERT_RVAL(gc != None, None);
if (DEBUG_LEVEL >= DEBUG_MEM) {
- memrec_add_var(&gc_rec, SPIF_CAST(charptr) NONULL(filename), line, (void *) gc, sizeof(XGCValues));
+ memrec_add_var(&gc_rec, (spif_charptr_t) NONULL(filename), line, (void *) gc, sizeof(XGCValues));
}
return (gc);
}
@@ -830,7 +830,7 @@ spifmem_x_free_gc(const spif_charptr_t var, const spif_charptr_t filename, unsig
D_MEM(("spifmem_x_free_gc() called for variable %s (0x%08x) at %s:%lu\n", var, gc, NONULL(filename), line));
if (gc) {
if (DEBUG_LEVEL >= DEBUG_MEM) {
- memrec_rem_var(&gc_rec, var, SPIF_CAST(charptr) NONULL(filename), line, (void *) gc);
+ memrec_rem_var(&gc_rec, var, (spif_charptr_t) NONULL(filename), line, (void *) gc);
}
XFreeGC(d, gc);
} else {
diff --git a/src/module.c b/src/module.c
index 19819ca..7957880 100644
--- a/src/module.c
+++ b/src/module.c
@@ -49,7 +49,7 @@ static SPIF_CONST_TYPE(moduleclass) s_class = {
(spif_func_t) spif_module_run,
(spif_func_t) spif_module_unload,
};
-SPIF_TYPE(class) SPIF_CLASS_VAR(module) = SPIF_CAST(class) &s_class;
+SPIF_TYPE(class) SPIF_CLASS_VAR(module) = (spif_class_t) &s_class;
SPIF_TYPE(moduleclass) SPIF_MODULECLASS_VAR(module) = &s_class;
/* *INDENT-ON* */
@@ -63,7 +63,7 @@ spif_module_new(void)
self = SPIF_ALLOC(module);
if (!spif_module_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(module);
+ self = (spif_module_t) NULL;
}
return self;
}
@@ -74,9 +74,9 @@ spif_module_init(spif_module_t self)
ASSERT_RVAL(!SPIF_MODULE_ISNULL(self), FALSE);
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_MODULECLASS_VAR(module)));
- self->name = SPIF_NULL_TYPE(str);
- self->path = SPIF_NULL_TYPE(str);
- self->module_handle = SPIF_NULL_TYPE(ptr);
+ self->name = (spif_str_t) NULL;
+ self->path = (spif_str_t) NULL;
+ self->module_handle = (spif_ptr_t) NULL;
self->main_handle = dlopen(NULL, RTLD_LAZY);
return TRUE;
}
@@ -89,15 +89,15 @@ spif_module_done(spif_module_t self)
ASSERT_RVAL(!SPIF_MODULE_ISNULL(self), FALSE);
if (self->module_handle) {
ret = spif_module_unload(self);
- self->module_handle = SPIF_NULL_TYPE(ptr);
+ self->module_handle = (spif_ptr_t) NULL;
}
if (!SPIF_STR_ISNULL(self->name)) {
spif_str_del(self->name);
- self->name = SPIF_NULL_TYPE(str);
+ self->name = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->path)) {
spif_str_del(self->path);
- self->path = SPIF_NULL_TYPE(str);
+ self->path = (spif_str_t) NULL;
}
return ret;
}
@@ -123,9 +123,9 @@ spif_module_show(spif_module_t self, spif_charptr_t name, spif_str_t buff, size_
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_module_t) %s: %10p { \"",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -138,13 +138,13 @@ spif_module_show(spif_module_t self, spif_charptr_t name, spif_str_t buff, size_
}
buff = spif_str_show(self->name, SPIF_CHARPTR("name"), buff, indent);
buff = spif_str_show(self->path, SPIF_CHARPTR("path"), buff, indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_ptr_t) module_handle: 0x%p\n", self->module_handle);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_ptr_t) module_handle: 0x%p\n", self->module_handle);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_ptr_t) main_handle: 0x%p\n", self->main_handle);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_ptr_t) main_handle: 0x%p\n", self->main_handle);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp), sizeof(tmp), "}\n");
+ snprintf((char *) tmp, sizeof(tmp), "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -171,7 +171,7 @@ spif_module_dup(spif_module_t self)
{
spif_module_t tmp;
- ASSERT_RVAL(!SPIF_MODULE_ISNULL(self), SPIF_NULL_TYPE(module));
+ ASSERT_RVAL(!SPIF_MODULE_ISNULL(self), (spif_module_t) NULL);
tmp = SPIF_ALLOC(module);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(module));
tmp->name = spif_str_dup(self->name);
@@ -182,7 +182,7 @@ spif_module_dup(spif_module_t self)
spif_classname_t
spif_module_type(spif_module_t self)
{
- ASSERT_RVAL(!SPIF_MODULE_ISNULL(self), SPIF_CAST(classname) SPIF_NULLSTR_TYPE(classname));
+ ASSERT_RVAL(!SPIF_MODULE_ISNULL(self), (spif_classname_t) SPIF_NULLSTR_TYPE(classname));
return SPIF_OBJ_CLASSNAME(self);
}
@@ -192,14 +192,14 @@ spif_module_call(spif_module_t self, spif_charptr_t fname, spif_ptr_t data)
spif_func_t fp;
spif_charptr_t err;
- fp = SPIF_CAST(func) spif_module_getsym(self, fname);
+ fp = (spif_func_t) spif_module_getsym(self, fname);
if (SPIF_PTR_ISNULL(err)) {
/* No error. Proceed. */
return (fp)(data);
} else {
libast_print_warning("Unable to call function %s() from module \"%s\" -- %s\n", fname, SPIF_STR_STR(self->name), err);
}
- return SPIF_NULL_TYPE(ptr);
+ return (spif_ptr_t) NULL;
}
spif_ptr_t
@@ -208,25 +208,25 @@ spif_module_getsym(spif_module_t self, spif_charptr_t sym)
spif_ptr_t psym;
spif_charptr_t err;
- ASSERT_RVAL(!SPIF_MODULE_ISNULL(self), SPIF_NULL_TYPE(ptr));
- ASSERT_RVAL(!SPIF_PTR_ISNULL(sym), SPIF_NULL_TYPE(ptr));
- REQUIRE_RVAL(!SPIF_PTR_ISNULL(self->main_handle), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(!SPIF_MODULE_ISNULL(self), (spif_ptr_t) NULL);
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(sym), (spif_ptr_t) NULL);
+ REQUIRE_RVAL(!SPIF_PTR_ISNULL(self->main_handle), (spif_ptr_t) NULL);
dlerror();
- psym = SPIF_CAST(ptr) dlsym(self->module_handle, (const char *) sym);
- err = SPIF_CAST(charptr) dlerror();
+ psym = (spif_ptr_t) dlsym(self->module_handle, (const char *) sym);
+ err = (spif_charptr_t) dlerror();
if (SPIF_PTR_ISNULL(err)) {
/* No error. Proceed. */
return psym;
} else {
- psym = SPIF_CAST(ptr) dlsym(self->main_handle, (const char *) sym);
- err = SPIF_CAST(charptr) dlerror();
+ psym = (spif_ptr_t) dlsym(self->main_handle, (const char *) sym);
+ err = (spif_charptr_t) dlerror();
if (SPIF_PTR_ISNULL(err)) {
/* No error. Proceed. */
return psym;
} else {
#ifdef RTLD_DEFAULT
- psym = SPIF_CAST(ptr) dlsym(RTLD_DEFAULT, (const char *) sym);
- err = SPIF_CAST(charptr) dlerror();
+ psym = (spif_ptr_t) dlsym(RTLD_DEFAULT, (const char *) sym);
+ err = (spif_charptr_t) dlerror();
if (SPIF_PTR_ISNULL(err)) {
/* No error. Proceed. */
return psym;
@@ -236,7 +236,7 @@ spif_module_getsym(spif_module_t self, spif_charptr_t sym)
SPIF_STR_STR(self->name), err);
}
}
- return SPIF_NULL_TYPE(ptr);
+ return (spif_ptr_t) NULL;
}
spif_bool_t
@@ -297,7 +297,7 @@ spif_module_unload(spif_module_t self)
libast_print_warning("Unable to dlclose() \"%s\" -- %s\n", SPIF_STR_STR(self->path), dlerror());
return FALSE;
}
- self->module_handle = SPIF_NULL_TYPE(ptr);
+ self->module_handle = (spif_ptr_t) NULL;
return TRUE;
}
diff --git a/src/msgs.c b/src/msgs.c
index 9fec44a..5012e3d 100644
--- a/src/msgs.c
+++ b/src/msgs.c
@@ -49,7 +49,7 @@ static const char __attribute__((unused)) cvs_ident[] = "$Id$";
* some built-in functions. This variable must be set using the
* libast_set_program_name() function.
*/
-spif_charptr_t libast_program_name = SPIF_CAST(charptr) PACKAGE;
+spif_charptr_t libast_program_name = (spif_charptr_t) PACKAGE;
/**
* Program version.
*
@@ -58,7 +58,7 @@ spif_charptr_t libast_program_name = SPIF_CAST(charptr) PACKAGE;
* number checking and some built-in functions. This variable must be
* set using the libast_set_program_version() function.
*/
-spif_charptr_t libast_program_version = SPIF_CAST(charptr) VERSION;
+spif_charptr_t libast_program_version = (spif_charptr_t) VERSION;
/**
* Silence mode
@@ -83,17 +83,17 @@ void
libast_set_program_name(const char *progname)
{
if (libast_program_name) {
- if (!strcmp(SPIF_CAST_C(char *) libast_program_name, progname)) {
+ if (!strcmp((char *) libast_program_name, progname)) {
return;
}
- if (strcmp(SPIF_CAST_C(char *) libast_program_name, PACKAGE)) {
+ if (strcmp((char *) libast_program_name, PACKAGE)) {
FREE(libast_program_name);
}
}
if (progname) {
- libast_program_name = SPIF_CAST(charptr) STRDUP(progname);
+ libast_program_name = (spif_charptr_t) STRDUP(progname);
} else {
- libast_program_name = SPIF_CAST(charptr) PACKAGE;
+ libast_program_name = (spif_charptr_t) PACKAGE;
}
}
@@ -112,17 +112,17 @@ void
libast_set_program_version(const char *progversion)
{
if (libast_program_version) {
- if (!strcmp(SPIF_CAST_C(char *) libast_program_version, progversion)) {
+ if (!strcmp((char *) libast_program_version, progversion)) {
return;
}
- if (strcmp(SPIF_CAST_C(char *) libast_program_version, VERSION)) {
+ if (strcmp((char *) libast_program_version, VERSION)) {
FREE(libast_program_version);
}
}
if (progversion) {
- libast_program_version = SPIF_CAST(charptr) STRDUP(progversion);
+ libast_program_version = (spif_charptr_t) STRDUP(progversion);
} else {
- libast_program_version = SPIF_CAST(charptr) VERSION;
+ libast_program_version = (spif_charptr_t) VERSION;
}
}
@@ -163,7 +163,7 @@ libast_dprintf(const char *format, ...)
va_list args;
int n;
- ASSERT_RVAL(!SPIF_PTR_ISNULL(format), SPIF_CAST_C(int) -1);
+ ASSERT_RVAL(!SPIF_PTR_ISNULL(format), (int) -1);
REQUIRE_RVAL(!silent, 0);
REQUIRE_RVAL(libast_program_name != NULL, 0);
va_start(args, format);
diff --git a/src/obj.c b/src/obj.c
index d1508a1..fcefc3c 100644
--- a/src/obj.c
+++ b/src/obj.c
@@ -121,7 +121,7 @@ spif_obj_new(void)
self = SPIF_ALLOC(obj);
if (!spif_obj_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(obj);
+ self = (spif_obj_t) NULL;
}
return self;
}
@@ -249,9 +249,9 @@ spif_obj_show(spif_obj_t self, spif_charptr_t name, spif_str_t buff, size_t inde
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_obj_t) %s: %10p \"%s\"\n",
- name, SPIF_CAST(ptr) self, SPIF_OBJ_CLASSNAME(self));
+ name, (spif_ptr_t) self, SPIF_OBJ_CLASSNAME(self));
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -283,7 +283,7 @@ spif_cmp_t
spif_obj_comp(spif_obj_t self, spif_obj_t other)
{
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- return SPIF_CMP_FROM_INT(SPIF_CAST(ulong) self - SPIF_CAST(ulong) other);
+ return SPIF_CMP_FROM_INT((spif_ulong_t) self - (spif_ulong_t) other);
}
/**
@@ -311,7 +311,7 @@ spif_obj_dup(spif_obj_t self)
{
spif_obj_t tmp;
- ASSERT_RVAL(!SPIF_OBJ_ISNULL(self), SPIF_NULL_TYPE(obj));
+ ASSERT_RVAL(!SPIF_OBJ_ISNULL(self), (spif_obj_t) NULL);
tmp = spif_obj_new();
memcpy(tmp, self, SPIF_SIZEOF_TYPE(obj));
return tmp;
@@ -334,7 +334,7 @@ spif_obj_dup(spif_obj_t self)
spif_classname_t
spif_obj_type(spif_obj_t self)
{
- ASSERT_RVAL(!SPIF_OBJ_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_OBJ_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -361,7 +361,7 @@ spif_obj_type(spif_obj_t self)
spif_class_t
spif_obj_get_class(spif_obj_t self)
{
- ASSERT_RVAL(!SPIF_OBJ_ISNULL(self), SPIF_NULL_TYPE(class));
+ ASSERT_RVAL(!SPIF_OBJ_ISNULL(self), (spif_class_t) NULL);
return SPIF_OBJ_CLASS(self);
}
diff --git a/src/objpair.c b/src/objpair.c
index 88b07d9..9bae412 100644
--- a/src/objpair.c
+++ b/src/objpair.c
@@ -121,7 +121,7 @@ spif_objpair_new(void)
self = SPIF_ALLOC(objpair);
if (!spif_objpair_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(objpair);
+ self = (spif_objpair_t) NULL;
}
return self;
}
@@ -145,7 +145,7 @@ spif_objpair_new_from_key(spif_obj_t key)
self = SPIF_ALLOC(objpair);
if (!spif_objpair_init_from_key(self, key)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(objpair);
+ self = (spif_objpair_t) NULL;
}
return self;
}
@@ -169,7 +169,7 @@ spif_objpair_new_from_value(spif_obj_t value)
self = SPIF_ALLOC(objpair);
if (!spif_objpair_init_from_value(self, value)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(objpair);
+ self = (spif_objpair_t) NULL;
}
return self;
}
@@ -195,7 +195,7 @@ spif_objpair_new_from_both(spif_obj_t key, spif_obj_t value)
self = SPIF_ALLOC(objpair);
if (!spif_objpair_init_from_both(self, key, value)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(objpair);
+ self = (spif_objpair_t) NULL;
}
return self;
}
@@ -241,7 +241,7 @@ spif_objpair_init_from_key(spif_objpair_t self, spif_obj_t key)
ASSERT_RVAL(!SPIF_OBJ_ISNULL(key), FALSE);
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(objpair));
self->key = SPIF_OBJ_DUP(SPIF_OBJ(key));
- self->value = SPIF_NULL_TYPE(obj);
+ self->value = (spif_obj_t) NULL;
return TRUE;
}
@@ -265,7 +265,7 @@ spif_objpair_init_from_value(spif_objpair_t self, spif_obj_t value)
ASSERT_RVAL(!SPIF_OBJPAIR_ISNULL(self), FALSE);
ASSERT_RVAL(!SPIF_OBJ_ISNULL(value), FALSE);
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(objpair));
- self->key = SPIF_NULL_TYPE(obj);
+ self->key = (spif_obj_t) NULL;
self->value = SPIF_OBJ_DUP(SPIF_OBJ(value));
return TRUE;
}
@@ -317,11 +317,11 @@ spif_objpair_done(spif_objpair_t self)
if (!SPIF_OBJ_ISNULL(SPIF_OBJ(self->key))) {
SPIF_OBJ_DEL(SPIF_OBJ(self->key));
}
- self->key = SPIF_NULL_TYPE(obj);
+ self->key = (spif_obj_t) NULL;
if (!SPIF_OBJ_ISNULL(SPIF_OBJ(self->value))) {
SPIF_OBJ_DEL(SPIF_OBJ(self->value));
}
- self->value = SPIF_NULL_TYPE(obj);
+ self->value = (spif_obj_t) NULL;
return TRUE;
}
@@ -375,9 +375,9 @@ spif_objpair_show(spif_objpair_t self, spif_charptr_t name, spif_str_t buff, siz
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CAST_C(char *) tmp + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_objpair_t) %s: %10p \"%s\"\n",
- name, SPIF_CAST(ptr) self, SPIF_OBJ_CLASSNAME(self));
+ name, (spif_ptr_t) self, SPIF_OBJ_CLASSNAME(self));
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -426,7 +426,7 @@ spif_objpair_comp(spif_objpair_t self, spif_obj_t other)
spif_objpair_t
spif_objpair_dup(spif_objpair_t self)
{
- ASSERT_RVAL(!SPIF_OBJPAIR_ISNULL(self), SPIF_NULL_TYPE(objpair));
+ ASSERT_RVAL(!SPIF_OBJPAIR_ISNULL(self), (spif_objpair_t) NULL);
return spif_objpair_new_from_both(self->key, self->value);
}
@@ -445,7 +445,7 @@ spif_objpair_dup(spif_objpair_t self)
spif_classname_t
spif_objpair_type(spif_objpair_t self)
{
- ASSERT_RVAL(!SPIF_OBJPAIR_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_OBJPAIR_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(SPIF_OBJ(self));
}
diff --git a/src/options.c b/src/options.c
index 0a8b4b9..afdd123 100644
--- a/src/options.c
+++ b/src/options.c
@@ -160,7 +160,7 @@ spifopt_usage(void)
printf(" ");
}
printf("--%s", SPIFOPT_OPT_LONG(i));
- for (col = strlen(SPIF_CAST_C(char *) SPIFOPT_OPT_LONG(i)); col < l_long; col++) {
+ for (col = strlen((char *) SPIFOPT_OPT_LONG(i)); col < l_long; col++) {
printf(" ");
}
printf(" %-6s %s\n", get_option_type_string(SPIFOPT_OPT_TYPE(i)), SPIFOPT_OPT_DESC(i));
@@ -190,9 +190,9 @@ find_long_option(spif_charptr_t opt)
for (j = 0; j < SPIFOPT_NUMOPTS_GET(); j++) {
size_t l;
- l = strlen(SPIF_CHARPTR_C(SPIFOPT_OPT_LONG(j)));
+ l = strlen((char *) SPIFOPT_OPT_LONG(j));
/* Look for matches to the part before the =, if any. */
- if (!strncasecmp(SPIF_CHARPTR_C(SPIFOPT_OPT_LONG(j)), SPIF_CHARPTR_C(opt), l)
+ if (!strncasecmp((char *) SPIFOPT_OPT_LONG(j), (char *) opt, l)
&& (opt[l] == '=' || !opt[l])) {
/* Got one. */
D_OPTIONS(("Match found at %d: %s == %s\n", j, SPIFOPT_OPT_LONG(j), opt));
@@ -257,7 +257,7 @@ find_value_long(spif_charptr_t arg, spif_charptr_t next_arg, spif_charptr_t hase
{
spif_charptr_t val_ptr;
- if ((val_ptr = SPIF_CHARPTR(strchr(SPIF_CHARPTR_C(arg), '='))) != NULL) {
+ if ((val_ptr = SPIF_CHARPTR(strchr((char *) arg, '='))) != NULL) {
val_ptr++;
*hasequal = 1;
} else {
@@ -427,7 +427,7 @@ static void
handle_integer(spif_int32_t n, spif_charptr_t val_ptr)
{
D_OPTIONS(("Integer option detected\n"));
- *((int *) SPIFOPT_OPT_VALUE(n)) = strtol(SPIF_CHARPTR_C(val_ptr), (char **) NULL, 0);
+ *((int *) SPIFOPT_OPT_VALUE(n)) = strtol((char *) val_ptr, (char **) NULL, 0);
}
/**
@@ -448,7 +448,7 @@ static void
handle_string(spif_int32_t n, spif_charptr_t val_ptr)
{
D_OPTIONS(("String option detected\n"));
- *((const char **) SPIFOPT_OPT_VALUE(n)) = SPIF_CAST_C(char *) STRDUP(val_ptr);
+ *((const char **) SPIFOPT_OPT_VALUE(n)) = (char *) STRDUP(val_ptr);
}
@@ -480,30 +480,30 @@ handle_arglist(spif_int32_t n, spif_charptr_t val_ptr, unsigned char hasequal,
D_OPTIONS(("Argument list option detected\n"));
if (hasequal) {
/* There's an equals sign, so just parse the rest of this option into words. */
- tmp = SPIF_CAST_PTR(charptr) MALLOC(sizeof(spif_charptr_t) * (spiftool_num_words(val_ptr) + 1));
+ tmp = (spif_charptr_t *) MALLOC(sizeof(spif_charptr_t) * (spiftool_num_words(val_ptr) + 1));
for (k = 0; val_ptr; k++) {
tmp[k] = spiftool_get_word(1, val_ptr);
val_ptr = spiftool_get_pword(2, val_ptr);
D_OPTIONS(("tmp[%d] == %s\n", k, tmp[k]));
}
- tmp[k] = SPIF_NULL_TYPE(charptr);
- *(SPIF_CAST_C(spif_charptr_t **) SPIFOPT_OPT_VALUE(n)) = tmp;
+ tmp[k] = (spif_charptr_t) NULL;
+ *((spif_charptr_t **) SPIFOPT_OPT_VALUE(n)) = tmp;
} else {
unsigned short len = argc - i;
/* No equals sign, so use the rest of the command line and break. */
- tmp = SPIF_CAST_PTR(charptr) MALLOC(sizeof(spif_charptr_t ) * (argc - i + 1));
+ tmp = (spif_charptr_t *) MALLOC(sizeof(spif_charptr_t ) * (argc - i + 1));
for (k = 0; k < len; k++) {
- tmp[k] = SPIF_CAST(charptr) STRDUP(argv[k + i]);
+ tmp[k] = (spif_charptr_t) STRDUP(argv[k + i]);
D_OPTIONS(("tmp[%d] == %s\n", k, tmp[k]));
if (SPIFOPT_FLAGS_IS_SET(SPIFOPT_SETTING_REMOVE_ARGS)) {
argv[k + i] = NULL;
}
}
- tmp[k] = SPIF_NULL_TYPE(charptr);
- *(SPIF_CAST_C(spif_charptr_t **) SPIFOPT_OPT_VALUE(n)) = tmp;
+ tmp[k] = (spif_charptr_t) NULL;
+ *((spif_charptr_t **) SPIFOPT_OPT_VALUE(n)) = tmp;
}
}
@@ -584,7 +584,7 @@ spifopt_parse(int argc, char *argv[])
if (val_ptr) {
if (val_ptr == SPIF_CHARPTR(argv[i + 1])) {
i++;
- opt += strlen(SPIF_CHARPTR_C(opt));
+ opt += strlen((char *) opt);
}
}
@@ -602,7 +602,7 @@ spifopt_parse(int argc, char *argv[])
}
spif_str_append_from_ptr(warn, SPIFOPT_OPT_LONG(j));
spif_str_append_from_ptr(warn, SPIF_CHARPTR(" option is deprecated and should not be used.\n"));
- libast_print_warning(SPIF_CHARPTR_C(SPIF_STR_STR(warn)));
+ libast_print_warning((char *) SPIF_STR_STR(warn));
spif_str_del(warn);
}
diff --git a/src/pthreads.c b/src/pthreads.c
index 5cebf09..2fe76d6 100644
--- a/src/pthreads.c
+++ b/src/pthreads.c
@@ -58,7 +58,7 @@ static SPIF_CONST_TYPE(threadclass) pt_class = {
(spif_func_t) spif_pthreads_wait,
(spif_func_t) spif_pthreads_wait_for
};
-SPIF_TYPE(class) SPIF_CLASS_VAR(pthreads) = SPIF_CAST(class) &pt_class;
+SPIF_TYPE(class) SPIF_CLASS_VAR(pthreads) = (spif_class_t) &pt_class;
SPIF_TYPE(threadclass) SPIF_THREADCLASS_VAR(pthreads) = &pt_class;
static SPIF_CONST_TYPE(mutexclass) ptm_class = {
@@ -77,7 +77,7 @@ static SPIF_CONST_TYPE(mutexclass) ptm_class = {
(spif_func_t) spif_pthreads_mutex_lock_nowait,
(spif_func_t) spif_pthreads_mutex_unlock
};
-SPIF_TYPE(class) SPIF_CLASS_VAR(pthreads_mutex) = SPIF_CAST(class) &ptm_class;
+SPIF_TYPE(class) SPIF_CLASS_VAR(pthreads_mutex) = (spif_class_t) &ptm_class;
SPIF_TYPE(mutexclass) SPIF_MUTEXCLASS_VAR(pthreads_mutex) = &ptm_class;
static SPIF_CONST_TYPE(conditionclass) ptc_class = {
@@ -97,7 +97,7 @@ static SPIF_CONST_TYPE(conditionclass) ptc_class = {
(spif_func_t) spif_pthreads_condition_wait,
(spif_func_t) spif_pthreads_condition_wait_timed
};
-SPIF_TYPE(class) SPIF_CLASS_VAR(pthreads_condition) = SPIF_CAST(class) &ptc_class;
+SPIF_TYPE(class) SPIF_CLASS_VAR(pthreads_condition) = (spif_class_t) &ptc_class;
SPIF_TYPE(conditionclass) SPIF_CONDITIONCLASS_VAR(pthreads_condition) = &ptc_class;
/* *INDENT-ON* */
@@ -111,7 +111,7 @@ spif_pthreads_new(void)
self = SPIF_ALLOC(pthreads);
if (!spif_pthreads_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(pthreads);
+ self = (spif_pthreads_t) NULL;
}
return self;
}
@@ -124,7 +124,7 @@ spif_pthreads_new_with_func(spif_thread_func_t func, spif_thread_data_t data)
self = SPIF_ALLOC(pthreads);
if (!spif_pthreads_init_with_func(self, func, data)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(pthreads);
+ self = (spif_pthreads_t) NULL;
}
return self;
}
@@ -138,9 +138,9 @@ spif_pthreads_init(spif_pthreads_t self)
self->handle = (pthread_t) 0;
self->creator = (pthread_t) 0;
pthread_attr_init(&self->attr);
- self->main_func = SPIF_NULL_TYPE(thread_func);
- self->data = SPIF_NULL_TYPE(thread_data);
- self->tls_keys = SPIF_NULL_TYPE(list);
+ self->main_func = (spif_thread_func_t) NULL;
+ self->data = (spif_thread_data_t) NULL;
+ self->tls_keys = (spif_list_t) NULL;
return TRUE;
}
@@ -155,7 +155,7 @@ spif_pthreads_init_with_func(spif_pthreads_t self, spif_thread_func_t func, spif
pthread_attr_init(&self->attr);
self->main_func = func;
self->data = data;
- self->tls_keys = SPIF_NULL_TYPE(list);
+ self->tls_keys = (spif_list_t) NULL;
return TRUE;
}
@@ -172,10 +172,10 @@ spif_pthreads_done(spif_pthreads_t self)
self->creator = pthread_self();
pthread_attr_destroy(&self->attr);
pthread_attr_init(&self->attr);
- self->main_func = SPIF_NULL_TYPE(thread_func);
+ self->main_func = (spif_thread_func_t) NULL;
if (self->tls_keys) {
SPIF_LIST_DEL(self->tls_keys);
- self->tls_keys = SPIF_NULL_TYPE(list);
+ self->tls_keys = (spif_list_t) NULL;
}
return ret;
}
@@ -200,9 +200,9 @@ spif_pthreads_show(spif_pthreads_t self, spif_charptr_t name, spif_str_t buff, s
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_pthreads_t) %s: %10p { \"",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -213,19 +213,19 @@ spif_pthreads_show(spif_pthreads_t self, spif_charptr_t name, spif_str_t buff, s
if (indent < sizeof(tmp)) {
memset(tmp, ' ', indent);
}
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(pthread_t) handle: %ld\n", (long) self->handle);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(pthread_t) handle: %ld\n", (long) self->handle);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(pthread_t) creator: %ld\n", (long) self->creator);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(pthread_t) creator: %ld\n", (long) self->creator);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(pthread_attr_t) attr: %10p {...}\n", &self->attr);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(pthread_attr_t) attr: %10p {...}\n", &self->attr);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_thread_func_t) main_func: %10p\n", self->main_func);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_thread_func_t) main_func: %10p\n", self->main_func);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_thread_data_t) data: %10p\n", self->data);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_thread_data_t) data: %10p\n", self->data);
spif_str_append_from_ptr(buff, tmp);
if (SPIF_LIST_ISNULL(self->tls_keys)) {
@@ -234,7 +234,7 @@ spif_pthreads_show(spif_pthreads_t self, spif_charptr_t name, spif_str_t buff, s
buff = SPIF_LIST_SHOW(self->tls_keys, buff, indent);
}
- snprintf(SPIF_CHARPTR_C(tmp), sizeof(tmp), "}\n");
+ snprintf((char *) tmp, sizeof(tmp), "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -254,7 +254,7 @@ spif_pthreads_dup(spif_pthreads_t self)
{
spif_pthreads_t tmp;
- ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), SPIF_NULL_TYPE(pthreads));
+ ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), (spif_pthreads_t) NULL);
tmp = SPIF_ALLOC(pthreads);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(pthreads));
tmp->tls_keys = SPIF_LIST_DUP(self->tls_keys);
@@ -264,7 +264,7 @@ spif_pthreads_dup(spif_pthreads_t self)
spif_classname_t
spif_pthreads_type(spif_pthreads_t self)
{
- ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), SPIF_CAST(classname) SPIF_NULLSTR_TYPE(classname));
+ ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), (spif_classname_t) SPIF_NULLSTR_TYPE(classname));
return SPIF_OBJ_CLASSNAME(self);
}
@@ -291,10 +291,10 @@ spif_pthreads_get_condition(spif_pthreads_t self)
{
spif_pthreads_condition_t cond;
- ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), SPIF_NULL_TYPE(condition));
+ ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), (spif_condition_t) NULL);
cond = spif_pthreads_condition_new();
spif_pthreads_mutex_set_creator(SPIF_PTHREADS_MUTEX(cond), SPIF_THREAD(self));
- return SPIF_CAST(condition) cond;
+ return (spif_condition_t) cond;
}
spif_mutex_t
@@ -302,10 +302,10 @@ spif_pthreads_get_mutex(spif_pthreads_t self)
{
spif_pthreads_mutex_t mutex;
- ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), SPIF_NULL_TYPE(mutex));
+ ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), (spif_mutex_t) NULL);
mutex = spif_pthreads_mutex_new();
spif_pthreads_mutex_set_creator(mutex, SPIF_THREAD(self));
- return SPIF_CAST(mutex) mutex;
+ return (spif_mutex_t) mutex;
}
spif_bool_t
@@ -321,7 +321,7 @@ spif_bool_t
spif_pthreads_run(spif_pthreads_t self)
{
ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), FALSE);
- REQUIRE_RVAL(self->main_func != SPIF_NULL_TYPE(thread_func), FALSE);
+ REQUIRE_RVAL(self->main_func != (spif_thread_func_t) NULL, FALSE);
REQUIRE_RVAL(self->handle == (pthread_t) 0, FALSE);
if (!pthread_create(&self->handle, &self->attr, self->main_func, self)) {
@@ -337,9 +337,9 @@ spif_pthreads_tls_calloc(spif_pthreads_t self, size_t count, size_t size)
spif_tls_handle_t handle;
spif_ptr_t data;
- ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), SPIF_CAST(tls_handle) -1);
- REQUIRE_RVAL(count, SPIF_CAST(tls_handle) -1);
- REQUIRE_RVAL(size, SPIF_CAST(tls_handle) -1);
+ ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), (spif_tls_handle_t) -1);
+ REQUIRE_RVAL(count, (spif_tls_handle_t) -1);
+ REQUIRE_RVAL(size, (spif_tls_handle_t) -1);
handle = spif_pthreads_tls_malloc(self, count * size);
data = spif_pthreads_tls_get(self, handle);
@@ -355,16 +355,16 @@ spif_pthreads_tls_free(spif_pthreads_t self, spif_tls_handle_t handle)
ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), FALSE);
REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->tls_keys), FALSE);
- key = SPIF_CAST(mbuff) SPIF_LIST_REMOVE_AT(self->tls_keys, handle);
+ key = (spif_mbuff_t) SPIF_LIST_REMOVE_AT(self->tls_keys, handle);
if (handle != SPIF_LIST_COUNT(self->tls_keys)) {
/* If this isn't the last item in our list, insert an empty placeholder
so that numeric indexes which have already been given out will remain valid. */
- SPIF_LIST_INSERT_AT(self->tls_keys, SPIF_NULL_TYPE(obj), handle);
+ SPIF_LIST_INSERT_AT(self->tls_keys, (spif_obj_t) NULL, handle);
}
if (!SPIF_MBUFF_ISNULL(key)) {
spif_ptr_t ptr;
- ptr = SPIF_CAST(ptr) pthread_getspecific(*((pthread_key_t *) SPIF_MBUFF_BUFF(key)));
+ ptr = (spif_ptr_t) pthread_getspecific(*((pthread_key_t *) SPIF_MBUFF_BUFF(key)));
if (ptr && !pthread_key_delete(*((pthread_key_t *) SPIF_MBUFF_BUFF(key)))) {
FREE(ptr);
return TRUE;
@@ -378,14 +378,14 @@ spif_pthreads_tls_get(spif_pthreads_t self, spif_tls_handle_t handle)
{
spif_mbuff_t key;
- ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), (spif_ptr_t) NULL);
REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->tls_keys), FALSE);
- key = SPIF_CAST(mbuff) SPIF_LIST_GET(self->tls_keys, handle);
+ key = (spif_mbuff_t) SPIF_LIST_GET(self->tls_keys, handle);
if (!SPIF_MBUFF_ISNULL(key)) {
- return (SPIF_CAST(ptr) pthread_getspecific(*((pthread_key_t *) SPIF_MBUFF_BUFF(key))));
+ return ((spif_ptr_t) pthread_getspecific(*((pthread_key_t *) SPIF_MBUFF_BUFF(key))));
}
- return SPIF_NULL_TYPE(ptr);
+ return (spif_ptr_t) NULL;
}
spif_tls_handle_t
@@ -394,7 +394,7 @@ spif_pthreads_tls_malloc(spif_pthreads_t self, spif_memidx_t size)
pthread_key_t key;
spif_ptr_t ptr;
- ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), SPIF_CAST(tls_handle) -1);
+ ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), (spif_tls_handle_t) -1);
if (SPIF_LIST_ISNULL(self->tls_keys)) {
self->tls_keys = SPIF_LIST_NEW(array);
@@ -408,7 +408,7 @@ spif_pthreads_tls_malloc(spif_pthreads_t self, spif_memidx_t size)
pthread_setspecific(key, ptr);
/* The key is actually copied into the mbuff buffer. */
- tls_key = spif_mbuff_new_from_ptr(SPIF_CAST(byteptr) &key, sizeof(pthread_key_t));
+ tls_key = spif_mbuff_new_from_ptr((spif_byteptr_t) &key, sizeof(pthread_key_t));
/* Since the pointer returned by MALLOC() is only stored locally in
this function and as keyed in the TLS data store, it cannot be
@@ -417,7 +417,7 @@ spif_pthreads_tls_malloc(spif_pthreads_t self, spif_memidx_t size)
return (SPIF_LIST_COUNT(self->tls_keys) - 1);
}
}
- return (SPIF_CAST(tls_handle) -1);
+ return ((spif_tls_handle_t) -1);
}
static void
@@ -434,11 +434,11 @@ spif_pthreads_tls_realloc(spif_pthreads_t self, spif_tls_handle_t handle, spif_m
ASSERT_RVAL(!SPIF_PTHREADS_ISNULL(self), FALSE);
REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->tls_keys), FALSE);
- key = SPIF_CAST(mbuff) SPIF_LIST_GET(self->tls_keys, handle);
+ key = (spif_mbuff_t) SPIF_LIST_GET(self->tls_keys, handle);
if (!SPIF_MBUFF_ISNULL(key)) {
spif_ptr_t ptr;
- ptr = SPIF_CAST(ptr) pthread_getspecific(*((pthread_key_t *) SPIF_MBUFF_BUFF(key)));
+ ptr = (spif_ptr_t) pthread_getspecific(*((pthread_key_t *) SPIF_MBUFF_BUFF(key)));
if (ptr) {
ptr = REALLOC(ptr, size);
if (ptr) {
@@ -479,7 +479,7 @@ spif_pthreads_mutex_new(void)
self = SPIF_ALLOC(pthreads_mutex);
if (!spif_pthreads_mutex_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(pthreads_mutex);
+ self = (spif_pthreads_mutex_t) NULL;
}
return self;
}
@@ -490,7 +490,7 @@ spif_pthreads_mutex_init(spif_pthreads_mutex_t self)
ASSERT_RVAL(!SPIF_PTHREADS_MUTEX_ISNULL(self), FALSE);
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_MUTEXCLASS_VAR(pthreads_mutex)));
- self->creator = SPIF_NULL_TYPE(thread);
+ self->creator = (spif_thread_t) NULL;
pthread_mutex_init(&self->mutex, NULL);
return TRUE;
}
@@ -501,7 +501,7 @@ spif_pthreads_mutex_done(spif_pthreads_mutex_t self)
spif_bool_t ret = TRUE;
ASSERT_RVAL(!SPIF_PTHREADS_MUTEX_ISNULL(self), FALSE);
- self->creator = SPIF_NULL_TYPE(thread);
+ self->creator = (spif_thread_t) NULL;
if (!pthread_mutex_unlock(&self->mutex)) {
/* It was locked. Destroy it. */
pthread_mutex_destroy(&self->mutex);
@@ -530,9 +530,9 @@ spif_pthreads_mutex_show(spif_pthreads_mutex_t self, spif_charptr_t name, spif_s
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_pthreads_mutex_t) %s: %10p { \"",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -549,10 +549,10 @@ spif_pthreads_mutex_show(spif_pthreads_mutex_t self, spif_charptr_t name, spif_s
buff = SPIF_THREAD_SHOW(self->creator, buff, indent);
}
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(pthread_mutex_t) mutex: %10p {...}\n", &self->mutex);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(pthread_mutex_t) mutex: %10p {...}\n", &self->mutex);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp), sizeof(tmp), "}\n");
+ snprintf((char *) tmp, sizeof(tmp), "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -569,7 +569,7 @@ spif_pthreads_mutex_dup(spif_pthreads_mutex_t self)
{
spif_pthreads_mutex_t tmp;
- ASSERT_RVAL(!SPIF_PTHREADS_MUTEX_ISNULL(self), SPIF_NULL_TYPE(pthreads_mutex));
+ ASSERT_RVAL(!SPIF_PTHREADS_MUTEX_ISNULL(self), (spif_pthreads_mutex_t) NULL);
tmp = SPIF_ALLOC(pthreads_mutex);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(pthreads_mutex));
return tmp;
@@ -578,7 +578,7 @@ spif_pthreads_mutex_dup(spif_pthreads_mutex_t self)
spif_classname_t
spif_pthreads_mutex_type(spif_pthreads_mutex_t self)
{
- ASSERT_RVAL(!SPIF_PTHREADS_MUTEX_ISNULL(self), SPIF_CAST(classname) SPIF_NULLSTR_TYPE(classname));
+ ASSERT_RVAL(!SPIF_PTHREADS_MUTEX_ISNULL(self), (spif_classname_t) SPIF_NULLSTR_TYPE(classname));
return SPIF_OBJ_CLASSNAME(self);
}
@@ -611,7 +611,7 @@ spif_pthreads_condition_new(void)
self = SPIF_ALLOC(pthreads_condition);
if (!spif_pthreads_condition_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(pthreads_condition);
+ self = (spif_pthreads_condition_t) NULL;
}
return self;
}
@@ -658,9 +658,9 @@ spif_pthreads_condition_show(spif_pthreads_condition_t self, spif_charptr_t name
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_pthreads_condition_t) %s: %10p { \"",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -673,10 +673,10 @@ spif_pthreads_condition_show(spif_pthreads_condition_t self, spif_charptr_t name
}
buff = spif_pthreads_mutex_show(SPIF_PTHREADS_MUTEX(self), "self", buff, indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(pthread_cond_t) cond: %10p {...}\n", &self->cond);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(pthread_cond_t) cond: %10p {...}\n", &self->cond);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp), sizeof(tmp), "}\n");
+ snprintf((char *) tmp, sizeof(tmp), "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -693,7 +693,7 @@ spif_pthreads_condition_dup(spif_pthreads_condition_t self)
{
spif_pthreads_condition_t tmp;
- ASSERT_RVAL(!SPIF_PTHREADS_CONDITION_ISNULL(self), SPIF_NULL_TYPE(pthreads_condition));
+ ASSERT_RVAL(!SPIF_PTHREADS_CONDITION_ISNULL(self), (spif_pthreads_condition_t) NULL);
tmp = SPIF_ALLOC(pthreads_condition);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(pthreads_condition));
return tmp;
@@ -702,7 +702,7 @@ spif_pthreads_condition_dup(spif_pthreads_condition_t self)
spif_classname_t
spif_pthreads_condition_type(spif_pthreads_condition_t self)
{
- ASSERT_RVAL(!SPIF_PTHREADS_CONDITION_ISNULL(self), SPIF_CAST(classname) SPIF_NULLSTR_TYPE(classname));
+ ASSERT_RVAL(!SPIF_PTHREADS_CONDITION_ISNULL(self), (spif_classname_t) SPIF_NULLSTR_TYPE(classname));
return SPIF_OBJ_CLASSNAME(self);
}
diff --git a/src/regexp.c b/src/regexp.c
index da2b3da..5ca43cd 100644
--- a/src/regexp.c
+++ b/src/regexp.c
@@ -52,7 +52,7 @@ spif_regexp_new(void)
self = SPIF_ALLOC(regexp);
if (!spif_regexp_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(regexp);
+ self = (spif_regexp_t) NULL;
}
return self;
}
@@ -65,7 +65,7 @@ spif_regexp_new_from_str(spif_str_t other)
self = SPIF_ALLOC(regexp);
if (!spif_regexp_init_from_str(self, other)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(regexp);
+ self = (spif_regexp_t) NULL;
}
return self;
}
@@ -78,7 +78,7 @@ spif_regexp_new_from_ptr(spif_charptr_t other)
self = SPIF_ALLOC(regexp);
if (!spif_regexp_init_from_ptr(self, other)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(regexp);
+ self = (spif_regexp_t) NULL;
}
return self;
}
@@ -91,8 +91,8 @@ spif_regexp_init(spif_regexp_t self)
return FALSE;
}
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(regexp));
- self->data = SPIF_NULL_TYPE(ptr);
- spif_regexp_set_flags(self, SPIF_NULL_TYPE(charptr));
+ self->data = (spif_ptr_t) NULL;
+ spif_regexp_set_flags(self, (spif_charptr_t) NULL);
return TRUE;
}
@@ -104,7 +104,7 @@ spif_regexp_init_from_str(spif_regexp_t self, spif_str_t other)
return FALSE;
}
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(regexp));
- self->data = SPIF_NULL_TYPE(ptr);
+ self->data = (spif_ptr_t) NULL;
spif_regexp_set_flags(self, SPIF_CHARPTR(""));
return TRUE;
}
@@ -117,7 +117,7 @@ spif_regexp_init_from_ptr(spif_regexp_t self, spif_charptr_t other)
return FALSE;
}
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(regexp));
- self->data = SPIF_NULL_TYPE(ptr);
+ self->data = (spif_ptr_t) NULL;
spif_regexp_set_flags(self, SPIF_CHARPTR(""));
return TRUE;
}
@@ -127,7 +127,7 @@ spif_regexp_done(spif_regexp_t self)
{
ASSERT_RVAL(!SPIF_REGEXP_ISNULL(self), FALSE);
spif_str_done(SPIF_STR(self));
- if (self->data != SPIF_NULL_TYPE(ptr)) {
+ if (self->data != (spif_ptr_t) NULL) {
FREE(self->data);
}
self->flags = 0;
@@ -154,16 +154,16 @@ spif_regexp_show(spif_regexp_t self, spif_charptr_t name, spif_str_t buff, size_
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_regexp_t) %s: %10p {\n",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_REGEXP_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
spif_str_append_from_ptr(buff, tmp);
}
- snprintf(SPIF_CHARPTR_C(tmp), sizeof(tmp), "}\n");
+ snprintf((char *) tmp, sizeof(tmp), "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -180,7 +180,7 @@ spif_regexp_dup(spif_regexp_t self)
{
spif_regexp_t tmp;
- ASSERT_RVAL(!SPIF_REGEXP_ISNULL(self), SPIF_NULL_TYPE(regexp));
+ ASSERT_RVAL(!SPIF_REGEXP_ISNULL(self), (spif_regexp_t) NULL);
tmp = spif_regexp_new_from_str(SPIF_STR(self));
tmp->flags = self->flags;
@@ -191,7 +191,7 @@ spif_regexp_dup(spif_regexp_t self)
spif_classname_t
spif_regexp_type(spif_regexp_t self)
{
- ASSERT_RVAL(!SPIF_REGEXP_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_REGEXP_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -199,7 +199,7 @@ spif_bool_t
spif_regexp_compile(spif_regexp_t self)
{
ASSERT_RVAL(!SPIF_REGEXP_ISNULL(self), FALSE);
- if (self->data != SPIF_NULL_TYPE(ptr)) {
+ if (self->data != (spif_ptr_t) NULL) {
FREE(self->data);
}
#if LIBAST_REGEXP_SUPPORT_PCRE
@@ -207,7 +207,7 @@ spif_regexp_compile(spif_regexp_t self)
const char *errptr;
int erroffset;
- self->data = SPIF_CAST(ptr) pcre_compile(SPIF_CHARPTR_C(SPIF_STR_STR(SPIF_STR(self))),
+ self->data = (spif_ptr_t) pcre_compile((char *) SPIF_STR_STR(SPIF_STR(self)),
self->flags, &errptr, &erroffset, NULL);
if (SPIF_PTR_ISNULL(self->data)) {
libast_print_error("PCRE compilation of \"%s\" failed at offset %d -- %s\n",
@@ -221,9 +221,9 @@ spif_regexp_compile(spif_regexp_t self)
char buff[256];
int errcode;
- self->data = SPIF_CAST(ptr) MALLOC(sizeof(regex_t));
- if ((errcode = regcomp(SPIF_CAST_C(regex_t *) self->data, SPIF_STR_STR(SPIF_STR(self)), (self->flags & 0xffff))) != 0) {
- regerror(errcode, SPIF_CAST_C(regex_t *) self->data, buff, sizeof(buff));
+ self->data = (spif_ptr_t) MALLOC(sizeof(regex_t));
+ if ((errcode = regcomp((regex_t *) self->data, SPIF_STR_STR(SPIF_STR(self)), (self->flags & 0xffff))) != 0) {
+ regerror(errcode, (regex_t *) self->data, buff, sizeof(buff));
libast_print_error("POSIX regexp compilation of \"%s\" failed -- %s\n", SPIF_STR_STR(SPIF_STR(self)), buff);
FREE(self->data);
return FALSE;
@@ -245,7 +245,7 @@ spif_regexp_matches_str(spif_regexp_t self, spif_str_t subject)
{
int rc;
- rc = pcre_exec(SPIF_CAST_C(pcre *) self->data, NULL, SPIF_CHARPTR_C(SPIF_STR_STR(subject)),
+ rc = pcre_exec((pcre *) self->data, NULL, (char *) SPIF_STR_STR(subject),
spif_str_get_len(subject), 0, 0, NULL, 0);
if (rc == 0) {
return TRUE;
@@ -261,14 +261,14 @@ spif_regexp_matches_str(spif_regexp_t self, spif_str_t subject)
int rc;
char errbuf[256];
- rc = regexec(SPIF_CAST_C(regex_t *) self->data, SPIF_STR_STR(subject), (size_t) 0, (regmatch_t *) NULL,
+ rc = regexec((regex_t *) self->data, SPIF_STR_STR(subject), (size_t) 0, (regmatch_t *) NULL,
((self->flags >> 8) & 0xffff));
if (rc == 0) {
return TRUE;
} else if (rc == REG_NOMATCH) {
return FALSE;
} else {
- regerror(rc, SPIF_CAST_C(regex_t *) self->data, errbuf, sizeof(errbuf));
+ regerror(rc, (regex_t *) self->data, errbuf, sizeof(errbuf));
libast_print_error("POSIX regexp matching error on \"%s\" -- %s\n", SPIF_STR_STR(subject), errbuf);
return FALSE;
}
@@ -277,8 +277,8 @@ spif_regexp_matches_str(spif_regexp_t self, spif_str_t subject)
{
spif_charptr_t err;
- err = SPIF_CAST(charptr) re_comp(SPIF_STR_STR(SPIF_STR(self)));
- if (err != SPIF_NULL_TYPE(charptr)) {
+ err = (spif_charptr_t) re_comp(SPIF_STR_STR(SPIF_STR(self)));
+ if (err != (spif_charptr_t) NULL) {
libast_print_error("BSD regexp compilation of \"%s\" failed -- %s\n", SPIF_STR_STR(SPIF_STR(self)), err);
return FALSE;
}
@@ -296,8 +296,8 @@ spif_regexp_matches_ptr(spif_regexp_t self, spif_charptr_t subject)
{
int rc;
- rc = pcre_exec(SPIF_CAST_C(pcre *) self->data, NULL, SPIF_CHARPTR_C(subject),
- strlen(SPIF_CHARPTR_C(subject)), 0, 0, NULL, 0);
+ rc = pcre_exec((pcre *) self->data, NULL, (char *) subject,
+ strlen((char *) subject), 0, 0, NULL, 0);
if (rc == 0) {
return TRUE;
} else if (rc == PCRE_ERROR_NOMATCH) {
@@ -312,14 +312,14 @@ spif_regexp_matches_ptr(spif_regexp_t self, spif_charptr_t subject)
int rc;
char errbuf[256];
- rc = regexec(SPIF_CAST_C(regex_t *) self->data, subject, (size_t) 0, (regmatch_t *) NULL,
+ rc = regexec((regex_t *) self->data, subject, (size_t) 0, (regmatch_t *) NULL,
((self->flags >> 8) & 0xffff));
if (rc == 0) {
return TRUE;
} else if (rc == REG_NOMATCH) {
return FALSE;
} else {
- regerror(rc, SPIF_CAST_C(regex_t *) self->data, errbuf, sizeof(errbuf));
+ regerror(rc, (regex_t *) self->data, errbuf, sizeof(errbuf));
libast_print_error("POSIX regexp matching error on \"%s\" -- %s\n", subject, errbuf);
return FALSE;
}
@@ -328,8 +328,8 @@ spif_regexp_matches_ptr(spif_regexp_t self, spif_charptr_t subject)
{
spif_charptr_t err;
- err = SPIF_CAST(charptr) re_comp(SPIF_STR_STR(SPIF_STR(self)));
- if (err != SPIF_NULL_TYPE(charptr)) {
+ err = (spif_charptr_t) re_comp(SPIF_STR_STR(SPIF_STR(self)));
+ if (err != (spif_charptr_t) NULL) {
libast_print_error("BSD regexp compilation of \"%s\" failed -- %s\n", SPIF_STR_STR(SPIF_STR(self)), err);
return FALSE;
}
@@ -341,7 +341,7 @@ spif_regexp_matches_ptr(spif_regexp_t self, spif_charptr_t subject)
int
spif_regexp_get_flags(spif_regexp_t self)
{
- ASSERT_RVAL(!SPIF_REGEXP_ISNULL(self), SPIF_CAST_C(int) 0);
+ ASSERT_RVAL(!SPIF_REGEXP_ISNULL(self), (int) 0);
return self->flags;
}
@@ -357,7 +357,7 @@ spif_regexp_set_flags(spif_regexp_t self, spif_charptr_t flagstr)
self->flags = REG_EXTENDED | REG_NEWLINE;
#endif
- REQUIRE_RVAL(flagstr != SPIF_NULL_TYPE(charptr), FALSE);
+ REQUIRE_RVAL(flagstr != (spif_charptr_t) NULL, FALSE);
for (p = flagstr; *p; p++) {
switch (*p) {
#if LIBAST_REGEXP_SUPPORT_PCRE
diff --git a/src/socket.c b/src/socket.c
index fab8182..cb8d8e3 100644
--- a/src/socket.c
+++ b/src/socket.c
@@ -61,7 +61,7 @@ spif_socket_new(void)
self = SPIF_ALLOC(socket);
if (!spif_socket_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(socket);
+ self = (spif_socket_t) NULL;
}
return self;
}
@@ -74,7 +74,7 @@ spif_socket_new_from_urls(spif_url_t surl, spif_url_t durl)
self = SPIF_ALLOC(socket);
if (!spif_socket_init_from_urls(self, surl, durl)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(socket);
+ self = (spif_socket_t) NULL;
}
return self;
}
@@ -89,11 +89,11 @@ spif_socket_init(spif_socket_t self)
self->fam = AF_INET;
self->type = SOCK_STREAM;
self->proto = 0;
- self->addr = SPIF_NULL_TYPE(sockaddr);
+ self->addr = (spif_sockaddr_t) NULL;
self->len = 0;
self->flags = 0;
- self->local_url = SPIF_NULL_TYPE(url);
- self->remote_url = SPIF_NULL_TYPE(url);
+ self->local_url = (spif_url_t) NULL;
+ self->remote_url = (spif_url_t) NULL;
return TRUE;
}
@@ -107,18 +107,18 @@ spif_socket_init_from_urls(spif_socket_t self, spif_url_t surl, spif_url_t durl)
self->fam = AF_INET;
self->type = SOCK_STREAM;
self->proto = 0;
- self->addr = SPIF_NULL_TYPE(sockaddr);
+ self->addr = (spif_sockaddr_t) NULL;
self->len = 0;
self->flags = 0;
if (!SPIF_URL_ISNULL(surl)) {
self->local_url = spif_url_dup(surl);
} else {
- self->local_url = SPIF_NULL_TYPE(url);
+ self->local_url = (spif_url_t) NULL;
}
if (!SPIF_URL_ISNULL(durl)) {
self->remote_url = spif_url_dup(durl);
} else {
- self->remote_url = SPIF_NULL_TYPE(url);
+ self->remote_url = (spif_url_t) NULL;
}
return TRUE;
}
@@ -133,19 +133,19 @@ spif_socket_done(spif_socket_t self)
self->fam = AF_INET;
self->type = SOCK_STREAM;
self->proto = 0;
- if (self->addr != SPIF_NULL_TYPE(sockaddr)) {
+ if (self->addr != (spif_sockaddr_t) NULL) {
SPIF_DEALLOC(self->addr);
- self->addr = SPIF_NULL_TYPE(sockaddr);
+ self->addr = (spif_sockaddr_t) NULL;
}
self->len = 0;
self->flags = 0;
if (!SPIF_URL_ISNULL(self->local_url)) {
spif_url_del(self->local_url);
- self->local_url = SPIF_NULL_TYPE(url);
+ self->local_url = (spif_url_t) NULL;
}
if (!SPIF_URL_ISNULL(self->remote_url)) {
spif_url_del(self->remote_url);
- self->remote_url = SPIF_NULL_TYPE(url);
+ self->remote_url = (spif_url_t) NULL;
}
return TRUE;
}
@@ -170,9 +170,9 @@ spif_socket_show(spif_socket_t self, spif_charptr_t name, spif_str_t buff, size_
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_socket_t) %s: %10p {\n",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -181,32 +181,32 @@ spif_socket_show(spif_socket_t self, spif_charptr_t name, spif_str_t buff, size_
indent += 2;
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_sockfd_t) fd: %d\n", self->fd);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_sockfd_t) fd: %d\n", self->fd);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_sockfamily_t) fam: %d\n", (int) self->fam);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_sockfamily_t) fam: %d\n", (int) self->fam);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_socktype_t) type: %d\n", (int) self->type);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_socktype_t) type: %d\n", (int) self->type);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_sockproto_t) proto: %d\n", (int) self->proto);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_sockproto_t) proto: %d\n", (int) self->proto);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_sockaddr_t) addr: %10p\n", SPIF_CAST(ptr) self->addr);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_sockaddr_t) addr: %10p\n", (spif_ptr_t) self->addr);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_sockaddr_len_t) len: %lu\n", (unsigned long) self->len);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_sockaddr_len_t) len: %lu\n", (unsigned long) self->len);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_uint32_t) flags: 0x%08x\n", (unsigned) self->flags);
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_uint32_t) flags: 0x%08x\n", (unsigned) self->flags);
spif_str_append_from_ptr(buff, tmp);
spif_url_show(self->local_url, SPIF_CHARPTR("local_url"), buff, indent);
spif_url_show(self->remote_url, SPIF_CHARPTR("remote_url"), buff, indent);
indent -= 2;
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "}\n");
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
@@ -223,7 +223,7 @@ spif_socket_dup(spif_socket_t self)
{
spif_socket_t tmp;
- ASSERT_RVAL(!SPIF_SOCKET_ISNULL(self), SPIF_NULL_TYPE(socket));
+ ASSERT_RVAL(!SPIF_SOCKET_ISNULL(self), (spif_socket_t) NULL);
tmp = spif_socket_new();
if (self->fd >= 0) {
tmp->fd = dup(self->fd);
@@ -232,8 +232,8 @@ spif_socket_dup(spif_socket_t self)
tmp->type = self->type;
tmp->proto = self->proto;
tmp->len = self->len;
- if (self->addr != SPIF_NULL_TYPE(sockaddr)) {
- tmp->addr = SPIF_CAST(sockaddr) MALLOC(tmp->len);
+ if (self->addr != (spif_sockaddr_t) NULL) {
+ tmp->addr = (spif_sockaddr_t) MALLOC(tmp->len);
memcpy(tmp->addr, self->addr, tmp->len);
}
tmp->flags = self->flags;
@@ -249,7 +249,7 @@ spif_socket_dup(spif_socket_t self)
spif_classname_t
spif_socket_type(spif_socket_t self)
{
- ASSERT_RVAL(!SPIF_SOCKET_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_SOCKET_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -266,11 +266,11 @@ spif_socket_open(spif_socket_t self)
if (SPIF_SOCKET_FLAGS_IS_SET(self, SPIF_SOCKET_FLAGS_FAMILY_INET)) {
self->fam = AF_INET;
if (!SPIF_URL_ISNULL(self->remote_url)) {
- self->addr = SPIF_CAST(sockaddr) spif_url_get_ipaddr(self->remote_url);
+ self->addr = (spif_sockaddr_t) spif_url_get_ipaddr(self->remote_url);
} else {
- self->addr = SPIF_NULL_TYPE(sockaddr);
+ self->addr = (spif_sockaddr_t) NULL;
}
- if (self->addr == SPIF_NULL_TYPE(sockaddr)) {
+ if (self->addr == (spif_sockaddr_t) NULL) {
self->len = 0;
} else {
self->len = SPIF_SIZEOF_TYPE(ipsockaddr);
@@ -278,11 +278,11 @@ spif_socket_open(spif_socket_t self)
} else if (SPIF_SOCKET_FLAGS_IS_SET(self, SPIF_SOCKET_FLAGS_FAMILY_UNIX)) {
self->fam = AF_UNIX;
if (!SPIF_URL_ISNULL(self->remote_url)) {
- self->addr = SPIF_CAST(sockaddr) spif_url_get_unixaddr(self->remote_url);
+ self->addr = (spif_sockaddr_t) spif_url_get_unixaddr(self->remote_url);
} else {
- self->addr = SPIF_NULL_TYPE(sockaddr);
+ self->addr = (spif_sockaddr_t) NULL;
}
- if (self->addr == SPIF_NULL_TYPE(sockaddr)) {
+ if (self->addr == (spif_sockaddr_t) NULL) {
self->len = 0;
} else {
self->len = SPIF_SIZEOF_TYPE(unixsockaddr);
@@ -306,7 +306,7 @@ spif_socket_open(spif_socket_t self)
ASSERT_NOTREACHED_RVAL(FALSE);
}
- self->fd = SPIF_CAST(sockfd) socket(self->fam, self->type, self->proto);
+ self->fd = (spif_sockfd_t) socket(self->fam, self->type, self->proto);
if (self->fd < 0) {
libast_print_error("Unable to create socket(%d, %d, %d) -- %s\n", (int) self->fam,
(int) self->type, (int) self->proto, strerror(errno));
@@ -321,7 +321,7 @@ spif_socket_open(spif_socket_t self)
addr = spif_url_get_ipaddr(self->local_url);
D_OBJ(("Binding to port %d\n", ntohs(addr->sin_port)));
- if (bind(self->fd, SPIF_CAST(sockaddr) addr, SPIF_SIZEOF_TYPE(ipsockaddr))) {
+ if (bind(self->fd, (spif_sockaddr_t) addr, SPIF_SIZEOF_TYPE(ipsockaddr))) {
libast_print_error("Unable to bind socket %d to %s -- %s\n", (int) self->fd,
SPIF_STR_STR(self->local_url), strerror(errno));
FREE(addr);
@@ -333,7 +333,7 @@ spif_socket_open(spif_socket_t self)
addr = spif_url_get_unixaddr(self->local_url);
- if (bind(self->fd, SPIF_CAST(sockaddr) addr, SPIF_SIZEOF_TYPE(unixsockaddr))) {
+ if (bind(self->fd, (spif_sockaddr_t) addr, SPIF_SIZEOF_TYPE(unixsockaddr))) {
libast_print_error("Unable to bind socket %d to %s -- %s\n", (int) self->fd,
SPIF_STR_STR(self->local_url), strerror(errno));
FREE(addr);
@@ -425,7 +425,7 @@ spif_socket_accept(spif_socket_t self)
int newfd;
spif_socket_t tmp;
- ASSERT_RVAL(!SPIF_SOCKET_ISNULL(self), SPIF_NULL_TYPE(socket));
+ ASSERT_RVAL(!SPIF_SOCKET_ISNULL(self), (spif_socket_t) NULL);
addr = SPIF_ALLOC(sockaddr);
len = SPIF_SIZEOF_TYPE(sockaddr);
@@ -435,7 +435,7 @@ spif_socket_accept(spif_socket_t self)
if (newfd < 0) {
libast_print_error("Unable to accept() connection on %d -- %s\n", self->fd, strerror(errno));
- return SPIF_NULL_TYPE(socket);
+ return (spif_socket_t) NULL;
}
/* We got one. Create and return a new socket object for the accepted connection. */
@@ -443,9 +443,9 @@ spif_socket_accept(spif_socket_t self)
tmp->fd = newfd;
SPIF_SOCKET_FLAGS_CLEAR(tmp, (SPIF_SOCKET_FLAGS_LISTEN | SPIF_SOCKET_FLAGS_HAVE_INPUT | SPIF_SOCKET_FLAGS_CAN_OUTPUT));
if (SPIF_SOCKET_FLAGS_IS_SET(self, SPIF_SOCKET_FLAGS_FAMILY_INET)) {
- tmp->remote_url = spif_url_new_from_ipaddr(SPIF_CAST(ipsockaddr) addr);
+ tmp->remote_url = spif_url_new_from_ipaddr((spif_ipsockaddr_t) addr);
} else if (SPIF_SOCKET_FLAGS_IS_SET(self, SPIF_SOCKET_FLAGS_FAMILY_UNIX)) {
- tmp->remote_url = spif_url_new_from_unixaddr(SPIF_CAST(unixsockaddr) addr);
+ tmp->remote_url = spif_url_new_from_unixaddr((spif_unixsockaddr_t) addr);
}
SPIF_DEALLOC(addr);
if (SPIF_SOCKET_FLAGS_IS_SET(self, SPIF_SOCKET_FLAGS_NBIO)) {
@@ -518,7 +518,7 @@ spif_socket_recv(spif_socket_t self)
{
spif_str_t new_str;
- ASSERT_RVAL(!SPIF_SOCKET_ISNULL(self), SPIF_NULL_TYPE(str));
+ ASSERT_RVAL(!SPIF_SOCKET_ISNULL(self), (spif_str_t) NULL);
new_str = spif_str_new_from_fd(self->fd);
return new_str;
}
@@ -625,7 +625,7 @@ spif_url_new_from_ipaddr(spif_ipsockaddr_t ipaddr)
self = SPIF_ALLOC(url);
if (!spif_url_init_from_ipaddr(self, ipaddr)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(url);
+ self = (spif_url_t) NULL;
}
return self;
}
@@ -639,18 +639,18 @@ spif_url_init_from_ipaddr(spif_url_t self, spif_ipsockaddr_t ipaddr)
ASSERT_RVAL(!SPIF_URL_ISNULL(self), FALSE);
spif_str_init(SPIF_STR(self));
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(url));
- self->proto = SPIF_NULL_TYPE(str);
- self->user = SPIF_NULL_TYPE(str);
- self->passwd = SPIF_NULL_TYPE(str);
- self->path = SPIF_NULL_TYPE(str);
- self->query = SPIF_NULL_TYPE(str);
+ self->proto = (spif_str_t) NULL;
+ self->user = (spif_str_t) NULL;
+ self->passwd = (spif_str_t) NULL;
+ self->path = (spif_str_t) NULL;
+ self->query = (spif_str_t) NULL;
/* Try up to 3 times to resolve the hostname. */
h_errno = 0;
tries = 0;
do {
tries++;
- hinfo = gethostbyaddr(SPIF_CONST_CAST_C(char *) &(ipaddr->sin_addr), sizeof(ipaddr->sin_addr), AF_INET);
+ hinfo = gethostbyaddr((const char *) &(ipaddr->sin_addr), sizeof(ipaddr->sin_addr), AF_INET);
} while ((tries <= 3) && (hinfo == NULL) && (h_errno == TRY_AGAIN));
if (hinfo == NULL || hinfo->h_name == NULL) {
spif_charptr_t buff;
@@ -673,7 +673,7 @@ spif_url_new_from_unixaddr(spif_unixsockaddr_t unixaddr)
self = SPIF_ALLOC(url);
if (!spif_url_init_from_unixaddr(self, unixaddr)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(url);
+ self = (spif_url_t) NULL;
}
return self;
}
@@ -684,17 +684,17 @@ spif_url_init_from_unixaddr(spif_url_t self, spif_unixsockaddr_t unixaddr)
ASSERT_RVAL(!SPIF_URL_ISNULL(self), FALSE);
spif_str_init(SPIF_STR(self));
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(url));
- self->proto = SPIF_NULL_TYPE(str);
- self->user = SPIF_NULL_TYPE(str);
- self->passwd = SPIF_NULL_TYPE(str);
- self->host = SPIF_NULL_TYPE(str);
- self->port = SPIF_NULL_TYPE(str);
- self->query = SPIF_NULL_TYPE(str);
+ self->proto = (spif_str_t) NULL;
+ self->user = (spif_str_t) NULL;
+ self->passwd = (spif_str_t) NULL;
+ self->host = (spif_str_t) NULL;
+ self->port = (spif_str_t) NULL;
+ self->query = (spif_str_t) NULL;
if (unixaddr->sun_path != NULL) {
self->path = spif_str_new_from_ptr(SPIF_CHARPTR(unixaddr->sun_path));
} else {
- self->path = SPIF_NULL_TYPE(str);
+ self->path = (spif_str_t) NULL;
}
return TRUE;
}
@@ -707,27 +707,27 @@ spif_url_get_ipaddr(spif_url_t self)
spif_ipsockaddr_t addr;
spif_str_t hostname;
- ASSERT_RVAL(!SPIF_URL_ISNULL(self), SPIF_NULL_TYPE(ipsockaddr));
+ ASSERT_RVAL(!SPIF_URL_ISNULL(self), (spif_ipsockaddr_t) NULL);
/* We need a hostname of some type to connect to. */
hostname = SPIF_STR(spif_url_get_host(self));
- REQUIRE_RVAL(!SPIF_STR_ISNULL(hostname), SPIF_NULL_TYPE(ipsockaddr));
+ REQUIRE_RVAL(!SPIF_STR_ISNULL(hostname), (spif_ipsockaddr_t) NULL);
/* Try up to 3 times to resolve the hostname. */
h_errno = 0;
tries = 0;
do {
tries++;
- hinfo = gethostbyname(SPIF_CHARPTR_C(SPIF_STR_STR(hostname)));
+ hinfo = gethostbyname((char *) SPIF_STR_STR(hostname));
} while ((tries <= 3) && (hinfo == NULL) && (h_errno == TRY_AGAIN));
if (hinfo == NULL) {
libast_print_error("Unable to resolve hostname \"%s\" -- %s\n", SPIF_STR_STR(hostname), hstrerror(h_errno));
- return SPIF_NULL_TYPE(ipsockaddr);
+ return (spif_ipsockaddr_t) NULL;
}
if (hinfo->h_addr_list == NULL) {
libast_print_error("Invalid address list returned by gethostbyname()\n");
- return SPIF_NULL_TYPE(ipsockaddr);
+ return (spif_ipsockaddr_t) NULL;
}
/* Grab the host IP address and port number, both in network byte order. */
@@ -745,13 +745,13 @@ spif_url_get_unixaddr(spif_url_t self)
{
spif_unixsockaddr_t addr;
- ASSERT_RVAL(!SPIF_URL_ISNULL(self), SPIF_NULL_TYPE(unixsockaddr));
+ ASSERT_RVAL(!SPIF_URL_ISNULL(self), (spif_unixsockaddr_t) NULL);
/* No address to look up, just a file path. */
addr = SPIF_ALLOC(unixsockaddr);
addr->sun_family = AF_UNIX;
addr->sun_path[0] = 0;
- strncat(addr->sun_path, SPIF_CHARPTR_C(SPIF_STR_STR(spif_url_get_path(self))), sizeof(addr->sun_path) - 1);
+ strncat(addr->sun_path, (char *) SPIF_STR_STR(spif_url_get_path(self)), sizeof(addr->sun_path) - 1);
return addr;
}
@@ -760,15 +760,15 @@ spif_url_get_portnum(spif_url_t self)
{
spif_str_t port_str;
- ASSERT_RVAL(!SPIF_URL_ISNULL(self), SPIF_NULL_TYPE(sockport));
+ ASSERT_RVAL(!SPIF_URL_ISNULL(self), (spif_sockport_t) NULL);
/* Return the integer form of the port number for a URL */
port_str = spif_url_get_port(self);
if (!SPIF_STR_ISNULL(port_str)) {
- return SPIF_CAST(sockport) spif_str_to_num(port_str, 10);
+ return (spif_sockport_t) spif_str_to_num(port_str, 10);
}
- return SPIF_CAST(sockport) 0;
+ return (spif_sockport_t) 0;
}
static spif_bool_t
@@ -810,12 +810,12 @@ spif_socket_get_proto(spif_socket_t self)
} else {
/* IP socket. See if they gave us a protocol name. */
SPIF_SOCKET_FLAGS_SET(self, SPIF_SOCKET_FLAGS_FAMILY_INET);
- proto = getprotobyname(SPIF_CHARPTR_C(SPIF_STR_STR(proto_str)));
+ proto = getprotobyname((char *) SPIF_STR_STR(proto_str));
if (proto == NULL) {
/* If it's not a protocol, it's probably a service. */
- serv = getservbyname(SPIF_CHARPTR_C(SPIF_STR_STR(proto_str)), "tcp");
+ serv = getservbyname((char *) SPIF_STR_STR(proto_str), "tcp");
if (serv == NULL) {
- serv = getservbyname(SPIF_CHARPTR_C(SPIF_STR_STR(proto_str)), "udp");
+ serv = getservbyname((char *) SPIF_STR_STR(proto_str), "udp");
}
if (serv != NULL) {
/* If we found one, get the protocol info too. */
diff --git a/src/str.c b/src/str.c
index 676e53b..83b4ac3 100644
--- a/src/str.c
+++ b/src/str.c
@@ -83,7 +83,7 @@ static SPIF_CONST_TYPE(strclass) s_class = {
(spif_func_t) spif_str_trim,
(spif_func_t) spif_str_upcase
};
-SPIF_TYPE(class) SPIF_CLASS_VAR(str) = SPIF_CAST(class) &s_class;
+SPIF_TYPE(class) SPIF_CLASS_VAR(str) = (spif_class_t) &s_class;
SPIF_TYPE(strclass) SPIF_STRCLASS_VAR(str) = &s_class;
/* *INDENT-ON* */
@@ -97,7 +97,7 @@ spif_str_new(void)
self = SPIF_ALLOC(str);
if (!spif_str_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(str);
+ self = (spif_str_t) NULL;
}
return self;
}
@@ -110,7 +110,7 @@ spif_str_new_from_ptr(spif_charptr_t old)
self = SPIF_ALLOC(str);
if (!spif_str_init_from_ptr(self, old)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(str);
+ self = (spif_str_t) NULL;
}
return self;
}
@@ -123,7 +123,7 @@ spif_str_new_from_buff(spif_charptr_t buff, spif_stridx_t size)
self = SPIF_ALLOC(str);
if (!spif_str_init_from_buff(self, buff, size)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(str);
+ self = (spif_str_t) NULL;
}
return self;
}
@@ -136,7 +136,7 @@ spif_str_new_from_fp(FILE * fp)
self = SPIF_ALLOC(str);
if (!spif_str_init_from_fp(self, fp)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(str);
+ self = (spif_str_t) NULL;
}
return self;
}
@@ -149,7 +149,7 @@ spif_str_new_from_fd(int fd)
self = SPIF_ALLOC(str);
if (!spif_str_init_from_fd(self, fd)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(str);
+ self = (spif_str_t) NULL;
}
return self;
}
@@ -162,7 +162,7 @@ spif_str_new_from_num(long num)
self = SPIF_ALLOC(str);
if (!spif_str_init_from_num(self, num)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(str);
+ self = (spif_str_t) NULL;
}
return self;
}
@@ -173,7 +173,7 @@ spif_str_init(spif_str_t self)
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_STRCLASS_VAR(str)));
- self->s = SPIF_NULL_TYPE(charptr);
+ self->s = (spif_charptr_t) NULL;
self->len = 0;
self->size = 0;
return TRUE;
@@ -183,12 +183,12 @@ spif_bool_t
spif_str_init_from_ptr(spif_str_t self, spif_charptr_t old)
{
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
- REQUIRE_RVAL((old != SPIF_NULL_TYPE(charptr)), spif_str_init(self));
+ REQUIRE_RVAL((old != (spif_charptr_t) NULL), spif_str_init(self));
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_STRCLASS_VAR(str)));
- self->len = strlen(SPIF_CONST_CAST_C(char *) old);
+ self->len = strlen((const char *) old);
self->size = self->len + 1;
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
+ self->s = (spif_charptr_t) MALLOC(self->size);
memcpy(self->s, old, self->size);
return TRUE;
}
@@ -200,16 +200,16 @@ spif_str_init_from_buff(spif_str_t self, spif_charptr_t buff, spif_stridx_t size
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_STRCLASS_VAR(str)));
self->size = size;
- if (buff != SPIF_NULL_TYPE(charptr)) {
- self->len = strnlen(SPIF_CONST_CAST_C(char *) buff, size);
+ if (buff != (spif_charptr_t) NULL) {
+ self->len = strnlen((const char *) buff, size);
} else {
self->len = 0;
}
if (self->size == self->len) {
self->size++;
}
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
- if (buff != SPIF_NULL_TYPE(charptr)) {
+ self->s = (spif_charptr_t) MALLOC(self->size);
+ if (buff != (spif_charptr_t) NULL) {
memcpy(self->s, buff, self->len);
}
self->s[self->len] = 0;
@@ -222,18 +222,18 @@ spif_str_init_from_fp(spif_str_t self, FILE *fp)
spif_charptr_t p, end = NULL;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
- ASSERT_RVAL((fp != SPIF_NULL_TYPE_C(FILE *)), FALSE);
+ ASSERT_RVAL((fp != (FILE *) NULL), FALSE);
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_STRCLASS_VAR(str)));
self->size = buff_inc;
self->len = 0;
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
+ self->s = (spif_charptr_t) MALLOC(self->size);
- for (p = self->s; fgets(SPIF_CAST_C(char *)p, buff_inc, fp); p += buff_inc) {
- if ((end = SPIF_CAST(charptr)
- strchr(SPIF_CONST_CAST_C(char *)p, '\n')) == NULL) {
+ for (p = self->s; fgets((char *)p, buff_inc, fp); p += buff_inc) {
+ if ((end = (spif_charptr_t)
+ strchr((const char *)p, '\n')) == NULL) {
self->size += buff_inc;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
} else {
*end = 0;
break;
@@ -241,9 +241,9 @@ spif_str_init_from_fp(spif_str_t self, FILE *fp)
}
self->len = (spif_stridx_t) ((end)
? (end - self->s)
- : ((int) strlen(SPIF_CONST_CAST_C(char *)self->s)));
+ : ((int) strlen((const char *)self->s)));
self->size = self->len + 1;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
return TRUE;
}
@@ -259,16 +259,16 @@ spif_str_init_from_fd(spif_str_t self, int fd)
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_STRCLASS_VAR(str)));
self->size = buff_inc;
self->len = 0;
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
+ self->s = (spif_charptr_t) MALLOC(self->size);
for (p = self->s; ((n = read(fd, p, buff_inc)) > 0) || (errno == EINTR);) {
self->size += n;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
p += n;
}
self->len = self->size - buff_inc;
self->size = self->len + 1;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
self->s[self->len] = 0;
return TRUE;
}
@@ -282,11 +282,11 @@ spif_str_init_from_num(spif_str_t self, long num)
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_STRCLASS_VAR(str)));
- snprintf(SPIF_CHARPTR_C(buff), sizeof(buff), "%ld", num);
- self->len = strlen(SPIF_CHARPTR_C(buff));
+ snprintf((char *) buff, sizeof(buff), "%ld", num);
+ self->len = strlen((char *) buff);
self->size = self->len + 1;
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
- strcpy(SPIF_CHARPTR_C(self->s), SPIF_CHARPTR_C(buff));
+ self->s = (spif_charptr_t) MALLOC(self->size);
+ strcpy((char *) self->s, (char *) buff);
return TRUE;
}
@@ -299,7 +299,7 @@ spif_str_done(spif_str_t self)
FREE(self->s);
self->len = 0;
self->size = 0;
- self->s = SPIF_NULL_TYPE(charptr);
+ self->s = (spif_charptr_t) NULL;
}
return TRUE;
}
@@ -324,9 +324,9 @@ spif_str_show(spif_str_t self, spif_charptr_t name, spif_str_t buff, size_t inde
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_str_t) %s: %10p { \"",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -335,7 +335,7 @@ spif_str_show(spif_str_t self, spif_charptr_t name, spif_str_t buff, size_t inde
spif_str_append(buff, self);
- snprintf(SPIF_CHARPTR_C(tmp), sizeof(tmp), "\", len %lu, size %lu }\n", (unsigned long) self->len,
+ snprintf((char *) tmp, sizeof(tmp), "\", len %lu, size %lu }\n", (unsigned long) self->len,
(unsigned long) self->size);
spif_str_append_from_ptr(buff, tmp);
return buff;
@@ -352,10 +352,10 @@ spif_str_dup(spif_str_t self)
{
spif_str_t tmp;
- ASSERT_RVAL(!SPIF_STR_ISNULL(self), SPIF_NULL_TYPE(str));
+ ASSERT_RVAL(!SPIF_STR_ISNULL(self), (spif_str_t) NULL);
tmp = SPIF_ALLOC(str);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(str));
- tmp->s = SPIF_CAST(charptr) STRDUP(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self));
+ tmp->s = (spif_charptr_t) STRDUP((const char *) SPIF_STR_STR(self));
tmp->len = self->len;
tmp->size = self->size;
return tmp;
@@ -364,7 +364,7 @@ spif_str_dup(spif_str_t self)
spif_classname_t
spif_str_type(spif_str_t self)
{
- ASSERT_RVAL(!SPIF_STR_ISNULL(self), SPIF_CAST(classname) SPIF_NULLSTR_TYPE(classname));
+ ASSERT_RVAL(!SPIF_STR_ISNULL(self), (spif_classname_t) SPIF_NULLSTR_TYPE(classname));
return SPIF_OBJ_CLASSNAME(self);
}
@@ -375,7 +375,7 @@ spif_str_append(spif_str_t self, spif_str_t other)
REQUIRE_RVAL(!SPIF_STR_ISNULL(other), FALSE);
if (other->size && other->len) {
self->size += other->size - 1;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
memcpy(self->s + self->len, SPIF_STR_STR(other), other->len + 1);
self->len += other->len;
}
@@ -389,7 +389,7 @@ spif_str_append_char(spif_str_t self, spif_char_t c)
self->len++;
if (self->size <= self->len) {
self->size++;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
}
self->s[self->len - 1] = c;
self->s[self->len] = 0;
@@ -402,11 +402,11 @@ spif_str_append_from_ptr(spif_str_t self, spif_charptr_t other)
spif_stridx_t len;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
- REQUIRE_RVAL((other != SPIF_NULL_TYPE(charptr)), FALSE);
- len = strlen(SPIF_CONST_CAST_C(char *) other);
+ REQUIRE_RVAL((other != (spif_charptr_t) NULL), FALSE);
+ len = strlen((const char *) other);
if (len) {
self->size += len;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
memcpy(self->s + self->len, other, len + 1);
self->len += len;
}
@@ -419,7 +419,7 @@ spif_str_casecmp(spif_str_t self, spif_str_t other)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strcasecmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(SPIF_STR_STR(other)));
+ c = strcasecmp((char *) SPIF_STR_STR(self), (char *) SPIF_STR_STR(other));
return SPIF_CMP_FROM_INT(c);
}
@@ -429,7 +429,7 @@ spif_str_casecmp_with_ptr(spif_str_t self, spif_charptr_t other)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strcasecmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(other));
+ c = strcasecmp((char *) SPIF_STR_STR(self), (char *) other);
return SPIF_CMP_FROM_INT(c);
}
@@ -448,7 +448,7 @@ spif_str_cmp(spif_str_t self, spif_str_t other)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strcmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(SPIF_STR_STR(other)));
+ c = strcmp((char *) SPIF_STR_STR(self), (char *) SPIF_STR_STR(other));
return SPIF_CMP_FROM_INT(c);
}
@@ -458,7 +458,7 @@ spif_str_cmp_with_ptr(spif_str_t self, spif_charptr_t other)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strcmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(other));
+ c = strcmp((char *) SPIF_STR_STR(self), (char *) other);
return SPIF_CMP_FROM_INT(c);
}
@@ -479,14 +479,14 @@ spif_str_find(spif_str_t self, spif_str_t other)
{
char *tmp;
- ASSERT_RVAL(!SPIF_STR_ISNULL(self), (SPIF_CAST(stridx) -1));
- REQUIRE_RVAL(!SPIF_STR_ISNULL(other), (SPIF_CAST(stridx) -1));
- tmp = strstr(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self),
- SPIF_CONST_CAST_C(char *) SPIF_STR_STR(other));
+ ASSERT_RVAL(!SPIF_STR_ISNULL(self), ((spif_stridx_t) -1));
+ REQUIRE_RVAL(!SPIF_STR_ISNULL(other), ((spif_stridx_t) -1));
+ tmp = strstr((const char *) SPIF_STR_STR(self),
+ (const char *) SPIF_STR_STR(other));
if (tmp) {
- return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_STR_STR(self)));
+ return (spif_stridx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_STR_STR(self)));
} else {
- return SPIF_CAST(stridx) (self->len);
+ return (spif_stridx_t) (self->len);
}
}
@@ -495,14 +495,14 @@ spif_str_find_from_ptr(spif_str_t self, spif_charptr_t other)
{
char *tmp;
- ASSERT_RVAL(!SPIF_STR_ISNULL(self), (SPIF_CAST(stridx) -1));
- REQUIRE_RVAL((other != SPIF_NULL_TYPE(charptr)), (SPIF_CAST(stridx) -1));
- tmp = strstr(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self),
- SPIF_CONST_CAST_C(char *) other);
+ ASSERT_RVAL(!SPIF_STR_ISNULL(self), ((spif_stridx_t) -1));
+ REQUIRE_RVAL((other != (spif_charptr_t) NULL), ((spif_stridx_t) -1));
+ tmp = strstr((const char *) SPIF_STR_STR(self),
+ (const char *) other);
if (tmp) {
- return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_STR_STR(self)));
+ return (spif_stridx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_STR_STR(self)));
} else {
- return SPIF_CAST(stridx) (self->len);
+ return (spif_stridx_t) (self->len);
}
}
@@ -511,12 +511,12 @@ spif_str_index(spif_str_t self, spif_char_t c)
{
char *tmp;
- ASSERT_RVAL(!SPIF_STR_ISNULL(self), (SPIF_CAST(stridx) -1));
- tmp = index(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self), c);
+ ASSERT_RVAL(!SPIF_STR_ISNULL(self), ((spif_stridx_t) -1));
+ tmp = index((const char *) SPIF_STR_STR(self), c);
if (tmp) {
- return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_STR_STR(self)));
+ return (spif_stridx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_STR_STR(self)));
} else {
- return SPIF_CAST(stridx) (self->len);
+ return (spif_stridx_t) (self->len);
}
}
@@ -526,7 +526,7 @@ spif_str_ncasecmp(spif_str_t self, spif_str_t other, spif_stridx_t cnt)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strncasecmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(SPIF_STR_STR(other)), cnt);
+ c = strncasecmp((char *) SPIF_STR_STR(self), (char *) SPIF_STR_STR(other), cnt);
return SPIF_CMP_FROM_INT(c);
}
@@ -536,7 +536,7 @@ spif_str_ncasecmp_with_ptr(spif_str_t self, spif_charptr_t other, spif_stridx_t
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strncasecmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(other), cnt);
+ c = strncasecmp((char *) SPIF_STR_STR(self), (char *) other, cnt);
return SPIF_CMP_FROM_INT(c);
}
@@ -546,7 +546,7 @@ spif_str_ncmp(spif_str_t self, spif_str_t other, spif_stridx_t cnt)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strncmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(SPIF_STR_STR(other)), cnt);
+ c = strncmp((char *) SPIF_STR_STR(self), (char *) SPIF_STR_STR(other), cnt);
return SPIF_CMP_FROM_INT(c);
}
@@ -556,7 +556,7 @@ spif_str_ncmp_with_ptr(spif_str_t self, spif_charptr_t other, spif_stridx_t cnt)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strncmp(SPIF_CHARPTR_C(SPIF_STR_STR(self)), SPIF_CHARPTR_C(other), cnt);
+ c = strncmp((char *) SPIF_STR_STR(self), (char *) other, cnt);
return SPIF_CMP_FROM_INT(c);
}
@@ -567,7 +567,7 @@ spif_str_prepend(spif_str_t self, spif_str_t other)
REQUIRE_RVAL(!SPIF_STR_ISNULL(other), FALSE);
if (other->size && other->len) {
self->size += other->size - 1;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
memmove(self->s + other->len, self->s, self->len + 1);
memcpy(self->s, SPIF_STR_STR(other), other->len);
self->len += other->len;
@@ -582,10 +582,10 @@ spif_str_prepend_char(spif_str_t self, spif_char_t c)
self->len++;
if (self->size <= self->len) {
self->size++;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
}
memmove(self->s + 1, self->s, self->len + 1);
- self->s[0] = SPIF_CAST(uchar) c;
+ self->s[0] = (spif_uchar_t) c;
return TRUE;
}
@@ -595,11 +595,11 @@ spif_str_prepend_from_ptr(spif_str_t self, spif_charptr_t other)
spif_stridx_t len;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
- REQUIRE_RVAL((other != SPIF_NULL_TYPE(charptr)), FALSE);
- len = strlen(SPIF_CONST_CAST_C(char *) other);
+ REQUIRE_RVAL((other != (spif_charptr_t) NULL), FALSE);
+ len = strlen((const char *) other);
if (len) {
self->size += len;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
memmove(self->s + len, self->s, self->len + 1);
memcpy(self->s, other, len);
self->len += len;
@@ -611,7 +611,7 @@ spif_bool_t
spif_str_reverse(spif_str_t self)
{
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
- return ((strrev(SPIF_CAST_C(char *) self->s)) ? TRUE : FALSE);
+ return ((strrev((char *) self->s)) ? TRUE : FALSE);
}
spif_stridx_t
@@ -619,12 +619,12 @@ spif_str_rindex(spif_str_t self, spif_char_t c)
{
char *tmp;
- ASSERT_RVAL(!SPIF_STR_ISNULL(self), (SPIF_CAST(stridx) -1));
- tmp = rindex(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self), c);
+ ASSERT_RVAL(!SPIF_STR_ISNULL(self), ((spif_stridx_t) -1));
+ tmp = rindex((const char *) SPIF_STR_STR(self), c);
if (tmp) {
- return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_STR_STR(self)));
+ return (spif_stridx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_STR_STR(self)));
} else {
- return SPIF_CAST(stridx) (self->len);
+ return (spif_stridx_t) (self->len);
}
}
@@ -647,7 +647,7 @@ spif_str_splice(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt, spif_str_
REQUIRE_RVAL(cnt <= (self->len - idx), FALSE);
newsize = self->len + ((SPIF_STR_ISNULL(other)) ? (0) : (other->len)) - cnt + 1;
- ptmp = tmp = SPIF_CAST(charptr) MALLOC(newsize);
+ ptmp = tmp = (spif_charptr_t) MALLOC(newsize);
if (idx > 0) {
memcpy(tmp, self->s, idx);
ptmp += idx;
@@ -658,7 +658,7 @@ spif_str_splice(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt, spif_str_
}
memcpy(ptmp, self->s + idx + cnt, self->len - idx - cnt + 1);
if (self->size < newsize) {
- self->s = SPIF_CAST(charptr) REALLOC(self->s, newsize);
+ self->s = (spif_charptr_t) REALLOC(self->s, newsize);
self->size = newsize;
}
self->len = newsize - 1;
@@ -674,7 +674,7 @@ spif_str_splice_from_ptr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt,
spif_stridx_t len, newsize;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
- len = (other ? strlen(SPIF_CONST_CAST_C(char *) other) : 0);
+ len = (other ? strlen((const char *) other) : 0);
if (idx < 0) {
idx = self->len + idx;
}
@@ -687,7 +687,7 @@ spif_str_splice_from_ptr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt,
REQUIRE_RVAL(cnt <= (self->len - idx), FALSE);
newsize = self->len + len - cnt + 1;
- ptmp = tmp = SPIF_CAST(charptr) MALLOC(newsize);
+ ptmp = tmp = (spif_charptr_t) MALLOC(newsize);
if (idx > 0) {
memcpy(tmp, self->s, idx);
ptmp += idx;
@@ -698,7 +698,7 @@ spif_str_splice_from_ptr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt,
}
memcpy(ptmp, self->s + idx + cnt, self->len - idx - cnt + 1);
if (self->size < newsize) {
- self->s = SPIF_CAST(charptr) REALLOC(self->s, newsize);
+ self->s = (spif_charptr_t) REALLOC(self->s, newsize);
self->size = newsize;
}
self->len = newsize - 1;
@@ -714,7 +714,7 @@ spif_str_sprintf(spif_str_t self, spif_charptr_t format, ...)
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
va_start(ap, format);
- if (self->s != SPIF_NULL_TYPE(charptr)) {
+ if (self->s != (spif_charptr_t) NULL) {
spif_str_done(self);
}
if (*format == 0) {
@@ -731,7 +731,7 @@ spif_str_sprintf(spif_str_t self, spif_charptr_t format, ...)
} else {
self->len = c;
self->size = c + 1;
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
+ self->s = (spif_charptr_t) MALLOC(self->size);
c = vsnprintf(self->s, c + 1, format, ap);
}
return ((c >= 0) ? (TRUE) : (FALSE));
@@ -742,16 +742,16 @@ spif_str_sprintf(spif_str_t self, spif_charptr_t format, ...)
spif_str_t
spif_str_substr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt)
{
- ASSERT_RVAL(!SPIF_STR_ISNULL(self), SPIF_NULL_TYPE(str));
+ ASSERT_RVAL(!SPIF_STR_ISNULL(self), (spif_str_t) NULL);
if (idx < 0) {
idx = self->len + idx;
}
- REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(str));
- REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(str));
+ REQUIRE_RVAL(idx >= 0, (spif_str_t) NULL);
+ REQUIRE_RVAL(idx < self->len, (spif_str_t) NULL);
if (cnt <= 0) {
cnt = self->len - idx + cnt;
}
- REQUIRE_RVAL(cnt >= 0, SPIF_NULL_TYPE(str));
+ REQUIRE_RVAL(cnt >= 0, (spif_str_t) NULL);
UPPER_BOUND(cnt, self->len - idx);
return spif_str_new_from_buff(SPIF_STR_STR(self) + idx, cnt);
}
@@ -761,19 +761,19 @@ spif_str_substr_to_ptr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt)
{
spif_charptr_t newstr;
- ASSERT_RVAL(!SPIF_STR_ISNULL(self), SPIF_NULL_TYPE(charptr));
+ ASSERT_RVAL(!SPIF_STR_ISNULL(self), (spif_charptr_t) NULL);
if (idx < 0) {
idx = self->len + idx;
}
- REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(charptr));
- REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(charptr));
+ REQUIRE_RVAL(idx >= 0, (spif_charptr_t) NULL);
+ REQUIRE_RVAL(idx < self->len, (spif_charptr_t) NULL);
if (cnt <= 0) {
cnt = self->len - idx + cnt;
}
- REQUIRE_RVAL(cnt >= 0, SPIF_NULL_TYPE(charptr));
+ REQUIRE_RVAL(cnt >= 0, (spif_charptr_t) NULL);
UPPER_BOUND(cnt, self->len - idx);
- newstr = SPIF_CAST(charptr) MALLOC(cnt + 1);
+ newstr = (spif_charptr_t) MALLOC(cnt + 1);
memcpy(newstr, SPIF_STR_STR(self) + idx, cnt);
newstr[cnt] = 0;
return newstr;
@@ -782,15 +782,15 @@ spif_str_substr_to_ptr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt)
double
spif_str_to_float(spif_str_t self)
{
- ASSERT_RVAL(!SPIF_STR_ISNULL(self), SPIF_CAST_C(double) NAN);
- return (double) (strtod(SPIF_CONST_CAST_C(char *)SPIF_STR_STR(self), (char **) NULL));
+ ASSERT_RVAL(!SPIF_STR_ISNULL(self), (double) NAN);
+ return (double) (strtod((const char *)SPIF_STR_STR(self), (char **) NULL));
}
size_t
spif_str_to_num(spif_str_t self, int base)
{
- ASSERT_RVAL(!SPIF_STR_ISNULL(self), (SPIF_CAST_C(size_t) -1));
- return (size_t) (strtoul(SPIF_CONST_CAST_C(char *) SPIF_STR_STR(self), (char **) NULL, base));
+ ASSERT_RVAL(!SPIF_STR_ISNULL(self), ((size_t) -1));
+ return (size_t) (strtoul((const char *) SPIF_STR_STR(self), (char **) NULL, base));
}
spif_bool_t
@@ -810,7 +810,7 @@ spif_str_trim(spif_str_t self)
self->len = (spif_stridx_t) (end - start);
self->size = self->len + 1;
memmove(self->s, start, self->size);
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
return TRUE;
}
diff --git a/src/strings.c b/src/strings.c
index c618c43..1195861 100644
--- a/src/strings.c
+++ b/src/strings.c
@@ -49,11 +49,11 @@ memmem(const void *haystack, register size_t haystacklen, const void *needle, re
register unsigned long i;
register size_t len = haystacklen - needlelen;
- REQUIRE_RVAL(needle != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
- REQUIRE_RVAL(haystack != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
- REQUIRE_RVAL(needlelen > 0, SPIF_NULL_TYPE(ptr));
- REQUIRE_RVAL(haystacklen > 0, SPIF_NULL_TYPE(ptr));
- REQUIRE_RVAL(haystacklen > needlelen, SPIF_NULL_TYPE(ptr));
+ REQUIRE_RVAL(needle != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
+ REQUIRE_RVAL(haystack != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
+ REQUIRE_RVAL(needlelen > 0, (spif_ptr_t) NULL);
+ REQUIRE_RVAL(haystacklen > 0, (spif_ptr_t) NULL);
+ REQUIRE_RVAL(haystacklen > needlelen, (spif_ptr_t) NULL);
for (i = 0; i < len; i++) {
if (!memcmp(hs + i, n, needlelen)) {
return (hs + i);
@@ -69,7 +69,7 @@ strnlen(register const char *s, size_t maxlen)
{
register size_t n;
- REQUIRE_RVAL(s, SPIF_CAST_C(size_t) 0);
+ REQUIRE_RVAL(s, (size_t) 0);
for (n = 0; *s && n < maxlen; s++, n++);
return n;
}
@@ -105,10 +105,10 @@ strcasestr(const char *haystack, register const char *needle)
register const spif_uchar_t *t;
register size_t len;
- REQUIRE_RVAL(needle != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
- REQUIRE_RVAL(haystack != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ REQUIRE_RVAL(needle != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
+ REQUIRE_RVAL(haystack != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
len = strlen(needle);
- for (t = SPIF_CAST_PTR(uchar) haystack; t && *t; t++) {
+ for (t = (spif_uchar_t *) haystack; t && *t; t++) {
if (!strncasecmp(t, needle, len)) {
return ((char *) t);
}
@@ -123,7 +123,7 @@ strcasechr(const char *haystack, register const char needle)
{
register const char *t;
- REQUIRE_RVAL(haystack != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ REQUIRE_RVAL(haystack != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
for (t = haystack; t && *t; t++) {
if (tolower(*t) == tolower(needle)) {
return ((char *) t);
@@ -139,8 +139,8 @@ strcasepbrk(const char *haystack, register const char *needle)
{
register const char *t;
- REQUIRE_RVAL(needle != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
- REQUIRE_RVAL(haystack != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ REQUIRE_RVAL(needle != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
+ REQUIRE_RVAL(haystack != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
for (t = haystack; t && *t; t++) {
if (strcasechr(needle, *t)) {
return ((char *) t);
@@ -156,7 +156,7 @@ strrev(register char *str)
{
register int i, j;
- REQUIRE_RVAL(str != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ REQUIRE_RVAL(str != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
i = strlen(str);
for (j = 0, i--; i > j; i--, j++) {
(void) SWAP(str[j], str[i]);
@@ -173,8 +173,8 @@ strsep(char **str, register char *sep)
register char *s = *str;
char *sptr;
- REQUIRE_RVAL(str != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
- REQUIRE_RVAL(sep != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ REQUIRE_RVAL(str != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
+ REQUIRE_RVAL(sep != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
D_STRINGS(("strsep(%s, %s) called.\n", *str, sep));
sptr = s;
for (; *s && !strchr(sep, *s); s++);
@@ -228,7 +228,7 @@ spiftool_safe_strncat(spif_charptr_t dest, const spif_charptr_t src, spif_int32_
REQUIRE_RVAL(!SPIF_PTR_ISNULL(src), FALSE);
REQUIRE_RVAL(size > 0, FALSE);
- len = strnlen(SPIF_CHARPTR_C(dest), size);
+ len = strnlen((char *) dest, size);
if (len >= size) {
return FALSE;
} else {
@@ -246,16 +246,16 @@ spiftool_substr(spif_charptr_t str, spif_int32_t idx, spif_int32_t cnt)
spif_uint32_t start_pos, char_count;
spif_uint32_t len;
- REQUIRE_RVAL(str != SPIF_NULL_TYPE(charptr), SPIF_NULL_TYPE(charptr));
+ REQUIRE_RVAL(str != (spif_charptr_t) NULL, (spif_charptr_t) NULL);
- len = SPIF_CAST(uint32) strlen(SPIF_CHARPTR_C(str));
+ len = (spif_uint32_t) strlen((char *) str);
if (idx < 0) {
start_pos = len + idx;
} else {
start_pos = idx;
}
- REQUIRE_RVAL(start_pos < len, SPIF_NULL_TYPE(charptr));
+ REQUIRE_RVAL(start_pos < len, (spif_charptr_t) NULL);
if (cnt <= 0) {
char_count = len - start_pos + cnt;
@@ -264,7 +264,7 @@ spiftool_substr(spif_charptr_t str, spif_int32_t idx, spif_int32_t cnt)
}
UPPER_BOUND(char_count, len - start_pos);
- newstr = SPIF_CAST(charptr) MALLOC(char_count + 1);
+ newstr = (spif_charptr_t) MALLOC(char_count + 1);
memcpy(newstr, str + start_pos, char_count);
newstr[char_count] = 0;
return newstr;
@@ -342,7 +342,7 @@ spiftool_regexp_match_r(register const spif_charptr_t str, register const spif_c
}
#endif
-#define IS_DELIM(c) ((delim != NULL) ? (strchr(SPIF_CHARPTR_C(delim), (c)) != NULL) : (isspace(c)))
+#define IS_DELIM(c) ((delim != NULL) ? (strchr((char *) delim, (c)) != NULL) : (isspace(c)))
#define IS_QUOTE(c) (quote && quote == (c))
spif_charptr_t *
@@ -363,7 +363,7 @@ spiftool_split(const spif_charptr_t delim, const spif_charptr_t str)
}
/* Before we do anything, skip leading "whitespace." */
- for (pstr = SPIF_CAST(charptr) str; *pstr && IS_DELIM(*pstr); pstr++);
+ for (pstr = (spif_charptr_t) str; *pstr && IS_DELIM(*pstr); pstr++);
/* The outermost for loop is where we traverse the string. Each new
word brings us back to the top where we resize our string list. */
@@ -377,8 +377,8 @@ spiftool_split(const spif_charptr_t delim, const spif_charptr_t str)
/* The string we're about to create can't possibly be larger than the remainder
of the string we have yet to parse, so allocate that much space to start. */
- len = strlen(SPIF_CHARPTR_C(pstr)) + 1;
- if ((slist[cnt] = SPIF_CAST(charptr) MALLOC(len)) == NULL) {
+ len = strlen((char *) pstr) + 1;
+ if ((slist[cnt] = (spif_charptr_t) MALLOC(len)) == NULL) {
libast_print_error("split(): Unable to allocate memory -- %s.\n", strerror(errno));
return ((spif_charptr_t *) NULL);
}
@@ -413,8 +413,8 @@ spiftool_split(const spif_charptr_t delim, const spif_charptr_t str)
*pdest = 0;
/* Reallocate the new string to be just the right size. */
- len = strlen(SPIF_CHARPTR_C(slist[cnt])) + 1;
- slist[cnt] = SPIF_CAST(charptr) REALLOC(slist[cnt], len);
+ len = strlen((char *) slist[cnt]) + 1;
+ slist[cnt] = (spif_charptr_t) REALLOC(slist[cnt], len);
/* Move past any trailing "whitespace." */
for (; *pstr && IS_DELIM(*pstr); pstr++);
@@ -444,23 +444,23 @@ spiftool_join(spif_charptr_t sep, spif_charptr_t *slist)
size_t len, slen;
spif_charptr_t new_str;
- ASSERT_RVAL(slist != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
- REQUIRE_RVAL(*slist != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(slist != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
+ REQUIRE_RVAL(*slist != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
if (sep == NULL) {
sep = SPIF_CHARPTR("");
}
- slen = strlen(SPIF_CHARPTR_C(sep));
+ slen = strlen((char *) sep);
for (i = len = 0; slist[i]; i++) {
- len += strlen(SPIF_CHARPTR_C(slist[i]));
+ len += strlen((char *) slist[i]);
}
len += slen * (i - 1);
- new_str = SPIF_CAST(charptr) MALLOC(len + 1);
- strcpy(SPIF_CHARPTR_C(new_str), SPIF_CHARPTR_C(slist[0]));
+ new_str = (spif_charptr_t) MALLOC(len + 1);
+ strcpy((char *) new_str, (char *) slist[0]);
for (i = 1; slist[i]; i++) {
if (slen) {
- strcat(SPIF_CHARPTR_C(new_str), SPIF_CHARPTR_C(sep));
+ strcat((char *) new_str, (char *) sep);
}
- strcat(SPIF_CHARPTR_C(new_str), SPIF_CHARPTR_C(slist[i]));
+ strcat((char *) new_str, (char *) slist[i]);
}
return new_str;
}
@@ -476,11 +476,11 @@ spiftool_get_word(unsigned long index, const spif_charptr_t str)
char delim = 0;
register unsigned long i, j, k;
- ASSERT_RVAL(str != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
- k = strlen(SPIF_CHARPTR_C(str)) + 1;
- if ((tmpstr = SPIF_CAST(charptr) MALLOC(k)) == NULL) {
+ ASSERT_RVAL(str != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
+ k = strlen((char *) str) + 1;
+ if ((tmpstr = (spif_charptr_t) MALLOC(k)) == NULL) {
libast_print_error("get_word(%lu, %s): Unable to allocate memory -- %s.\n", index, str, strerror(errno));
- return (SPIF_CAST(charptr) NULL);
+ return ((spif_charptr_t) NULL);
}
*tmpstr = 0;
for (i = 0, j = 0; j < index && str[i]; j++) {
@@ -517,9 +517,9 @@ spiftool_get_word(unsigned long index, const spif_charptr_t str)
if (j != index) {
FREE(tmpstr);
D_STRINGS(("get_word(%lu, %s) returning NULL.\n", index, str));
- return (SPIF_CAST(charptr) NULL);
+ return ((spif_charptr_t) NULL);
} else {
- tmpstr = SPIF_CAST(charptr) REALLOC(tmpstr, strlen(SPIF_CHARPTR_C(tmpstr)) + 1);
+ tmpstr = (spif_charptr_t) REALLOC(tmpstr, strlen((char *) tmpstr) + 1);
D_STRINGS(("get_word(%lu, %s) returning \"%s\".\n", index, str, tmpstr));
return (tmpstr);
}
@@ -529,10 +529,10 @@ spiftool_get_word(unsigned long index, const spif_charptr_t str)
spif_charptr_t
spiftool_get_pword(unsigned long index, const spif_charptr_t str)
{
- register spif_charptr_t tmpstr = SPIF_CAST(charptr) str;
+ register spif_charptr_t tmpstr = (spif_charptr_t) str;
register unsigned long j;
- ASSERT_RVAL(str != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(str != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
for (; isspace(*tmpstr) && *tmpstr; tmpstr++);
for (j = 1; j < index && *tmpstr; j++) {
for (; !isspace(*tmpstr) && *tmpstr; tmpstr++);
@@ -544,10 +544,10 @@ spiftool_get_pword(unsigned long index, const spif_charptr_t str)
}
if (*tmpstr == '\0') {
D_STRINGS(("get_pword(%lu, %s) returning NULL.\n", index, str));
- return (SPIF_CAST(charptr) NULL);
+ return ((spif_charptr_t) NULL);
} else {
D_STRINGS(("get_pword(%lu, %s) returning \"%s\"\n", index, str, tmpstr));
- return SPIF_CAST(charptr) tmpstr;
+ return (spif_charptr_t) tmpstr;
}
}
@@ -559,7 +559,7 @@ spiftool_num_words(const spif_charptr_t str)
char delim = 0;
register unsigned long i;
- ASSERT_RVAL(str != SPIF_NULL_TYPE(ptr), SPIF_CAST_C(unsigned long) -1);
+ ASSERT_RVAL(str != (spif_ptr_t) NULL, (unsigned long) -1);
for (i = 0; str[i] && IS_DELIM(str[i]); i++);
for (; str[i]; cnt++) {
switch (str[i]) {
@@ -598,7 +598,7 @@ spiftool_chomp(spif_charptr_t s)
REQUIRE_RVAL(*s, s);
for (front = s; *front && isspace(*front); front++);
- for (back = s + strlen(SPIF_CHARPTR_C(s)) - 1; *back && isspace(*back) && back > front; back--);
+ for (back = s + strlen((char *) s) - 1; *back && isspace(*back) && back > front; back--);
*(++back) = 0;
if (front != s) {
@@ -612,7 +612,7 @@ spiftool_downcase_str(spif_charptr_t str)
{
register spif_charptr_t tmp;
- ASSERT_RVAL(str != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(str != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
for (tmp = str; *tmp; tmp++) {
*tmp = tolower(*tmp);
}
@@ -625,7 +625,7 @@ spiftool_upcase_str(spif_charptr_t str)
{
register spif_charptr_t tmp;
- ASSERT_RVAL(str != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(str != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
for (tmp = str; *tmp; tmp++) {
*tmp = toupper(*tmp);
}
@@ -640,7 +640,7 @@ spiftool_condense_whitespace(spif_charptr_t s)
register unsigned char gotspc = 0;
register spif_charptr_t pbuff = s, pbuff2 = s;
- ASSERT_RVAL(s != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(s != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
D_STRINGS(("condense_whitespace(%s) called.\n", s));
for (; *pbuff2; pbuff2++) {
if (isspace(*pbuff2)) {
@@ -659,7 +659,7 @@ spiftool_condense_whitespace(spif_charptr_t s)
pbuff--;
*pbuff = 0;
D_STRINGS(("condense_whitespace() returning \"%s\".\n", s));
- return (SPIF_CAST(charptr) REALLOC(s, strlen(SPIF_CHARPTR_C(s)) + 1));
+ return ((spif_charptr_t) REALLOC(s, strlen((char *) s) + 1));
}
spif_charptr_t
@@ -667,7 +667,7 @@ spiftool_safe_str(register spif_charptr_t str, unsigned short len)
{
register unsigned short i;
- ASSERT_RVAL(str != SPIF_NULL_TYPE(ptr), SPIF_NULL_TYPE(ptr));
+ ASSERT_RVAL(str != (spif_ptr_t) NULL, (spif_ptr_t) NULL);
for (i = 0; i < len; i++) {
if (iscntrl(str[i])) {
str[i] = '.';
@@ -684,7 +684,7 @@ spiftool_hex_dump(void *buff, register size_t count)
register spif_charptr_t ptr;
spif_char_t buffr[9];
- ASSERT(buff != SPIF_NULL_TYPE(ptr));
+ ASSERT(buff != (spif_ptr_t) NULL);
fprintf(stderr, " Address | Size | Offset | 00 01 02 03 04 05 06 07 | ASCII \n");
fprintf(stderr, "-----------+--------+---------+-------------------------+---------\n");
for (ptr = buff, j = 0; j < count; j += 8) {
@@ -698,7 +698,7 @@ spiftool_hex_dump(void *buff, register size_t count)
for (; k < 8; k++) {
fprintf(stderr, " ");
}
- fprintf(stderr, "| %-8s\n", spiftool_safe_str(SPIF_CAST(charptr) buffr, l));
+ fprintf(stderr, "| %-8s\n", spiftool_safe_str((spif_charptr_t) buffr, l));
}
}
@@ -730,26 +730,26 @@ spiftool_version_compare(spif_charptr_t v1, spif_charptr_t v2)
D_CONF((" -> Comparing as words \"%s\" vs. \"%s\"\n", buff1, buff2));
/* Some strings require special handling. */
- if (!strcmp(SPIF_CHARPTR_C(buff1), "snap")) {
+ if (!strcmp((char *) buff1, "snap")) {
ival1 = 1;
- } else if (!strcmp(SPIF_CHARPTR_C(buff1), "pre")) {
+ } else if (!strcmp((char *) buff1, "pre")) {
ival1 = 2;
- } else if (!strcmp(SPIF_CHARPTR_C(buff1), "alpha")) {
+ } else if (!strcmp((char *) buff1, "alpha")) {
ival1 = 3;
- } else if (!strcmp(SPIF_CHARPTR_C(buff1), "beta")) {
+ } else if (!strcmp((char *) buff1, "beta")) {
ival1 = 4;
- } else if (!strcmp(SPIF_CHARPTR_C(buff1), "rc")) {
+ } else if (!strcmp((char *) buff1, "rc")) {
ival1 = 5;
}
- if (!strcmp(SPIF_CHARPTR_C(buff2), "snap")) {
+ if (!strcmp((char *) buff2, "snap")) {
ival2 = 1;
- } else if (!strcmp(SPIF_CHARPTR_C(buff2), "pre")) {
+ } else if (!strcmp((char *) buff2, "pre")) {
ival2 = 2;
- } else if (!strcmp(SPIF_CHARPTR_C(buff2), "alpha")) {
+ } else if (!strcmp((char *) buff2, "alpha")) {
ival2 = 3;
- } else if (!strcmp(SPIF_CHARPTR_C(buff2), "beta")) {
+ } else if (!strcmp((char *) buff2, "beta")) {
ival2 = 4;
- } else if (!strcmp(SPIF_CHARPTR_C(buff2), "rc")) {
+ } else if (!strcmp((char *) buff2, "rc")) {
ival2 = 5;
}
if (ival1 != ival2) {
@@ -760,7 +760,7 @@ spiftool_version_compare(spif_charptr_t v1, spif_charptr_t v2)
int c;
/* Two arbitrary strings. Compare them too. */
- if ((c = strcmp(SPIF_CHARPTR_C(buff1), SPIF_CHARPTR_C(buff2))) != 0) {
+ if ((c = strcmp((char *) buff1, (char *) buff2)) != 0) {
D_CONF((" -> %d\n", (int) SPIF_CMP_FROM_INT(c)));
return SPIF_CMP_FROM_INT(c);
}
@@ -776,9 +776,9 @@ spiftool_version_compare(spif_charptr_t v1, spif_charptr_t v2)
*p1 = *p2 = 0;
/* Convert the strings into actual integers. */
- ival1 = SPIF_CAST(int32) strtol(SPIF_CHARPTR_C(buff1), (char **) NULL, 10);
- ival2 = SPIF_CAST(int32) strtol(SPIF_CHARPTR_C(buff2), (char **) NULL, 10);
- D_CONF((" -> Comparing as integers %d vs. %d\n", SPIF_CAST_C(int) ival1, SPIF_CAST_C(int) ival2));
+ ival1 = (spif_int32_t) strtol((char *) buff1, (char **) NULL, 10);
+ ival2 = (spif_int32_t) strtol((char *) buff2, (char **) NULL, 10);
+ D_CONF((" -> Comparing as integers %d vs. %d\n", (int) ival1, (int) ival2));
/* Compare the integers and return if not equal. */
c = SPIF_CMP_FROM_INT(ival1 - ival2);
@@ -796,22 +796,22 @@ spiftool_version_compare(spif_charptr_t v1, spif_charptr_t v2)
*p1 = *p2 = 0;
D_CONF((" -> Comparing as non-alphanumeric strings \"%s\" vs. \"%s\"\n", buff1, buff2));
- c = SPIF_CMP_FROM_INT(strcasecmp(SPIF_CHARPTR_C(buff1), SPIF_CHARPTR_C(buff2)));
+ c = SPIF_CMP_FROM_INT(strcasecmp((char *) buff1, (char *) buff2));
if (!SPIF_CMP_IS_EQUAL(c)) {
D_CONF((" -> %d\n", (int) c));
return c;
}
} else {
D_CONF((" -> Comparing as alphanumeric strings \"%s\" vs. \"%s\"\n", buff1, buff2));
- D_CONF((" -> %d\n", (int) SPIF_CMP_FROM_INT(strcasecmp(SPIF_CHARPTR_C(buff1), SPIF_CHARPTR_C(buff2)))));
- return SPIF_CMP_FROM_INT(strcasecmp(SPIF_CHARPTR_C(buff1), SPIF_CHARPTR_C(buff2)));
+ D_CONF((" -> %d\n", (int) SPIF_CMP_FROM_INT(strcasecmp((char *) buff1, (char *) buff2))));
+ return SPIF_CMP_FROM_INT(strcasecmp((char *) buff1, (char *) buff2));
}
}
/* We've reached the end of one of the strings. */
if (*v1) {
- if (!BEG_STRCASECMP(SPIF_CHARPTR_C(v1), "snap") || !BEG_STRCASECMP(SPIF_CHARPTR_C(v1), "pre")
- || !BEG_STRCASECMP(SPIF_CHARPTR_C(v1), "alpha") || !BEG_STRCASECMP(SPIF_CHARPTR_C(v1), "beta")) {
+ if (!BEG_STRCASECMP((char *) v1, "snap") || !BEG_STRCASECMP((char *) v1, "pre")
+ || !BEG_STRCASECMP((char *) v1, "alpha") || !BEG_STRCASECMP((char *) v1, "beta")) {
D_CONF((" -> <\n"));
return SPIF_CMP_LESS;
} else {
@@ -819,8 +819,8 @@ spiftool_version_compare(spif_charptr_t v1, spif_charptr_t v2)
return SPIF_CMP_GREATER;
}
} else if (*v2) {
- if (!BEG_STRCASECMP(SPIF_CHARPTR_C(v2), "snap") || !BEG_STRCASECMP(SPIF_CHARPTR_C(v2), "pre")
- || !BEG_STRCASECMP(SPIF_CHARPTR_C(v2), "alpha") || !BEG_STRCASECMP(SPIF_CHARPTR_C(v2), "beta")) {
+ if (!BEG_STRCASECMP((char *) v2, "snap") || !BEG_STRCASECMP((char *) v2, "pre")
+ || !BEG_STRCASECMP((char *) v2, "alpha") || !BEG_STRCASECMP((char *) v2, "beta")) {
D_CONF((" -> >\n"));
return SPIF_CMP_GREATER;
} else {
diff --git a/src/tok.c b/src/tok.c
index 4c02501..7363d1d 100644
--- a/src/tok.c
+++ b/src/tok.c
@@ -52,7 +52,7 @@ spif_tok_new(void)
self = SPIF_ALLOC(tok);
if (!spif_tok_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(tok);
+ self = (spif_tok_t) NULL;
}
return self;
}
@@ -65,7 +65,7 @@ spif_tok_new_from_ptr(spif_charptr_t old)
self = SPIF_ALLOC(tok);
if (!spif_tok_init_from_ptr(self, old)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(tok);
+ self = (spif_tok_t) NULL;
}
return self;
}
@@ -78,7 +78,7 @@ spif_tok_new_from_fp(FILE * fp)
self = SPIF_ALLOC(tok);
if (!spif_tok_init_from_fp(self, fp)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(tok);
+ self = (spif_tok_t) NULL;
}
return self;
}
@@ -91,7 +91,7 @@ spif_tok_new_from_fd(int fd)
self = SPIF_ALLOC(tok);
if (!spif_tok_init_from_fd(self, fd)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(tok);
+ self = (spif_tok_t) NULL;
}
return self;
}
@@ -116,12 +116,12 @@ spif_tok_init(spif_tok_t self)
} else if (!spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(tok))) {
return FALSE;
}
- self->src = SPIF_NULL_TYPE(str);
+ self->src = (spif_str_t) NULL;
self->quote = '\'';
self->dquote = '\"';
self->escape = '\\';
- self->tokens = SPIF_NULL_TYPE(list);
- self->sep = SPIF_NULL_TYPE(str);
+ self->tokens = (spif_list_t) NULL;
+ self->sep = (spif_str_t) NULL;
return TRUE;
}
@@ -138,8 +138,8 @@ spif_tok_init_from_ptr(spif_tok_t self, spif_charptr_t old)
self->quote = '\'';
self->dquote = '\"';
self->escape = '\\';
- self->tokens = SPIF_NULL_TYPE(list);
- self->sep = SPIF_NULL_TYPE(str);
+ self->tokens = (spif_list_t) NULL;
+ self->sep = (spif_str_t) NULL;
return ((SPIF_STR_ISNULL(self->src)) ? (FALSE) : (TRUE));
}
@@ -156,8 +156,8 @@ spif_tok_init_from_fp(spif_tok_t self, FILE * fp)
self->quote = '\'';
self->dquote = '\"';
self->escape = '\\';
- self->tokens = SPIF_NULL_TYPE(list);
- self->sep = SPIF_NULL_TYPE(str);
+ self->tokens = (spif_list_t) NULL;
+ self->sep = (spif_str_t) NULL;
return ((SPIF_STR_ISNULL(self->src)) ? (FALSE) : (TRUE));
}
@@ -174,8 +174,8 @@ spif_tok_init_from_fd(spif_tok_t self, int fd)
self->quote = '\'';
self->dquote = '\"';
self->escape = '\\';
- self->tokens = SPIF_NULL_TYPE(list);
- self->sep = SPIF_NULL_TYPE(str);
+ self->tokens = (spif_list_t) NULL;
+ self->sep = (spif_str_t) NULL;
return ((SPIF_STR_ISNULL(self->src)) ? (FALSE) : (TRUE));
}
@@ -185,15 +185,15 @@ spif_tok_done(spif_tok_t self)
ASSERT_RVAL(!SPIF_TOK_ISNULL(self), FALSE);
if (!SPIF_LIST_ISNULL(self->tokens)) {
SPIF_LIST_DEL(self->tokens);
- self->tokens = SPIF_NULL_TYPE(list);
+ self->tokens = (spif_list_t) NULL;
}
if (!SPIF_STR_ISNULL(self->src)) {
spif_str_del(SPIF_STR(self->src));
- self->src = SPIF_NULL_TYPE(str);
+ self->src = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->sep)) {
spif_str_del(SPIF_STR(self->sep));
- self->sep = SPIF_NULL_TYPE(str);
+ self->sep = (spif_str_t) NULL;
}
self->quote = '\'';
self->dquote = '\"';
@@ -212,9 +212,9 @@ spif_tok_show(spif_tok_t self, spif_charptr_t name, spif_str_t buff, size_t inde
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_tok_t) %s: %10p {\n",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -225,20 +225,20 @@ spif_tok_show(spif_tok_t self, spif_charptr_t name, spif_str_t buff, size_t inde
indent += 2;
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_char_t) quote: '%c' (0x%02x)\n",
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_char_t) quote: '%c' (0x%02x)\n",
(char) self->quote, (unsigned int) self->quote);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_char_t) dquote: '%c' (0x%02x)\n",
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_char_t) dquote: '%c' (0x%02x)\n",
(char) self->dquote, (unsigned int) self->dquote);
spif_str_append_from_ptr(buff, tmp);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "(spif_char_t) escape: '%c' (0x%02x)\n",
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_char_t) escape: '%c' (0x%02x)\n",
(char) self->escape, (unsigned int) self->escape);
spif_str_append_from_ptr(buff, tmp);
SPIF_LIST_SHOW(self->tokens, buff, indent);
indent -= 2;
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "}\n");
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -256,7 +256,7 @@ spif_tok_dup(spif_tok_t self)
{
spif_tok_t tmp;
- ASSERT_RVAL(!SPIF_TOK_ISNULL(self), SPIF_NULL_TYPE(tok));
+ ASSERT_RVAL(!SPIF_TOK_ISNULL(self), (spif_tok_t) NULL);
tmp = spif_tok_new();
tmp->src = spif_str_dup(SPIF_STR(self->src));
tmp->quote = self->quote;
@@ -271,7 +271,7 @@ spif_tok_dup(spif_tok_t self)
spif_classname_t
spif_tok_type(spif_tok_t self)
{
- ASSERT_RVAL(!SPIF_TOK_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_TOK_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -289,11 +289,11 @@ spif_tok_eval(spif_tok_t self)
ASSERT_RVAL(!SPIF_TOK_ISNULL(self), FALSE);
REQUIRE_RVAL(!SPIF_STR_ISNULL(self->src), FALSE);
- pstr = SPIF_CAST_C(const char *) SPIF_STR_STR(SPIF_STR(self->src));
+ pstr = (const char *) SPIF_STR_STR(SPIF_STR(self->src));
len = spif_str_get_len(SPIF_STR(self->src));
if (!SPIF_STR_ISNULL(self->sep)) {
- delim = SPIF_CAST_C(const char *) SPIF_STR_STR(SPIF_STR(self->sep));
+ delim = (const char *) SPIF_STR_STR(SPIF_STR(self->sep));
}
if (!SPIF_LIST_ISNULL(self->tokens)) {
diff --git a/src/url.c b/src/url.c
index 2623e08..09bf84a 100644
--- a/src/url.c
+++ b/src/url.c
@@ -54,7 +54,7 @@ spif_url_new(void)
self = SPIF_ALLOC(url);
if (!spif_url_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(url);
+ self = (spif_url_t) NULL;
}
return self;
}
@@ -67,7 +67,7 @@ spif_url_new_from_str(spif_str_t other)
self = SPIF_ALLOC(url);
if (!spif_url_init_from_str(self, other)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(url);
+ self = (spif_url_t) NULL;
}
return self;
}
@@ -80,7 +80,7 @@ spif_url_new_from_ptr(spif_charptr_t other)
self = SPIF_ALLOC(url);
if (!spif_url_init_from_ptr(self, other)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(url);
+ self = (spif_url_t) NULL;
}
return self;
}
@@ -93,13 +93,13 @@ spif_url_init(spif_url_t self)
return FALSE;
}
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(url));
- self->proto = SPIF_NULL_TYPE(str);
- self->user = SPIF_NULL_TYPE(str);
- self->passwd = SPIF_NULL_TYPE(str);
- self->host = SPIF_NULL_TYPE(str);
- self->port = SPIF_NULL_TYPE(str);
- self->path = SPIF_NULL_TYPE(str);
- self->query = SPIF_NULL_TYPE(str);
+ self->proto = (spif_str_t) NULL;
+ self->user = (spif_str_t) NULL;
+ self->passwd = (spif_str_t) NULL;
+ self->host = (spif_str_t) NULL;
+ self->port = (spif_str_t) NULL;
+ self->path = (spif_str_t) NULL;
+ self->query = (spif_str_t) NULL;
return TRUE;
}
@@ -111,13 +111,13 @@ spif_url_init_from_str(spif_url_t self, spif_str_t other)
return FALSE;
}
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(url));
- self->proto = SPIF_NULL_TYPE(str);
- self->user = SPIF_NULL_TYPE(str);
- self->passwd = SPIF_NULL_TYPE(str);
- self->host = SPIF_NULL_TYPE(str);
- self->port = SPIF_NULL_TYPE(str);
- self->path = SPIF_NULL_TYPE(str);
- self->query = SPIF_NULL_TYPE(str);
+ self->proto = (spif_str_t) NULL;
+ self->user = (spif_str_t) NULL;
+ self->passwd = (spif_str_t) NULL;
+ self->host = (spif_str_t) NULL;
+ self->port = (spif_str_t) NULL;
+ self->path = (spif_str_t) NULL;
+ self->query = (spif_str_t) NULL;
spif_url_parse(self);
return TRUE;
}
@@ -130,13 +130,13 @@ spif_url_init_from_ptr(spif_url_t self, spif_charptr_t other)
return FALSE;
}
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(url));
- self->proto = SPIF_NULL_TYPE(str);
- self->user = SPIF_NULL_TYPE(str);
- self->passwd = SPIF_NULL_TYPE(str);
- self->host = SPIF_NULL_TYPE(str);
- self->port = SPIF_NULL_TYPE(str);
- self->path = SPIF_NULL_TYPE(str);
- self->query = SPIF_NULL_TYPE(str);
+ self->proto = (spif_str_t) NULL;
+ self->user = (spif_str_t) NULL;
+ self->passwd = (spif_str_t) NULL;
+ self->host = (spif_str_t) NULL;
+ self->port = (spif_str_t) NULL;
+ self->path = (spif_str_t) NULL;
+ self->query = (spif_str_t) NULL;
spif_url_parse(self);
return TRUE;
}
@@ -147,31 +147,31 @@ spif_url_done(spif_url_t self)
ASSERT_RVAL(!SPIF_URL_ISNULL(self), FALSE);
if (!SPIF_STR_ISNULL(self->proto)) {
spif_str_del(self->proto);
- self->proto = SPIF_NULL_TYPE(str);
+ self->proto = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->user)) {
spif_str_del(self->user);
- self->user = SPIF_NULL_TYPE(str);
+ self->user = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->passwd)) {
spif_str_del(self->passwd);
- self->passwd = SPIF_NULL_TYPE(str);
+ self->passwd = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->host)) {
spif_str_del(self->host);
- self->host = SPIF_NULL_TYPE(str);
+ self->host = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->port)) {
spif_str_del(self->port);
- self->port = SPIF_NULL_TYPE(str);
+ self->port = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->path)) {
spif_str_del(self->path);
- self->path = SPIF_NULL_TYPE(str);
+ self->path = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->query)) {
spif_str_del(self->query);
- self->query = SPIF_NULL_TYPE(str);
+ self->query = (spif_str_t) NULL;
}
spif_str_done(SPIF_STR(self));
return TRUE;
@@ -197,9 +197,9 @@ spif_url_show(spif_url_t self, spif_charptr_t name, spif_str_t buff, size_t inde
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_url_t) %s: %10p {\n",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_STR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -214,7 +214,7 @@ spif_url_show(spif_url_t self, spif_charptr_t name, spif_str_t buff, size_t inde
buff = spif_str_show(self->path, SPIF_CHARPTR("path"), buff, indent + 2);
buff = spif_str_show(self->query, SPIF_CHARPTR("query"), buff, indent + 2);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent, "}\n");
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
@@ -231,7 +231,7 @@ spif_url_dup(spif_url_t self)
{
spif_url_t tmp;
- ASSERT_RVAL(!SPIF_URL_ISNULL(self), SPIF_NULL_TYPE(url));
+ ASSERT_RVAL(!SPIF_URL_ISNULL(self), (spif_url_t) NULL);
tmp = spif_url_new_from_str(SPIF_STR(self));
return tmp;
}
@@ -239,7 +239,7 @@ spif_url_dup(spif_url_t self)
spif_classname_t
spif_url_type(spif_url_t self)
{
- ASSERT_RVAL(!SPIF_URL_ISNULL(self), SPIF_NULL_TYPE(classname));
+ ASSERT_RVAL(!SPIF_URL_ISNULL(self), (spif_classname_t) NULL);
return SPIF_OBJ_CLASSNAME(self);
}
@@ -261,7 +261,7 @@ spif_url_parse(spif_url_t self)
pstr = s;
/* Check for "proto:" at the beginning. */
- pend = SPIF_CHARPTR(strchr(SPIF_CHARPTR_C(s), ':'));
+ pend = SPIF_CHARPTR(strchr((char *) s, ':'));
if (pend != NULL) {
for (; pstr < pend; pstr++) {
if (!isalnum(*pstr)) {
@@ -283,9 +283,9 @@ spif_url_parse(spif_url_t self)
}
/* Knock out the path and query if they're there. */
- pend = SPIF_CHARPTR(strchr(SPIF_CHARPTR_C(pstr), '/'));
+ pend = SPIF_CHARPTR(strchr((char *) pstr, '/'));
if (pend != NULL) {
- spif_charptr_t tmp = SPIF_CHARPTR(strchr(SPIF_CHARPTR_C(pend), '?'));
+ spif_charptr_t tmp = SPIF_CHARPTR(strchr((char *) pend, '?'));
if (tmp != NULL) {
self->query = spif_str_new_from_ptr(tmp + 1);
@@ -293,7 +293,7 @@ spif_url_parse(spif_url_t self)
} else {
self->path = spif_str_new_from_ptr(pend);
}
- } else if ((pend = SPIF_CHARPTR(strchr(SPIF_CHARPTR_C(pstr), '?'))) != NULL) {
+ } else if ((pend = SPIF_CHARPTR(strchr((char *) pstr, '?'))) != NULL) {
self->query = spif_str_new_from_ptr(pend + 1);
} else {
for (pend = pstr; *pend; pend++);
@@ -301,9 +301,9 @@ spif_url_parse(spif_url_t self)
/* At this point, pend *must* point to the end of the user/pass/host/port part. */
/* Check for an @ sign, which would mean we have auth info. */
- ptmp = SPIF_CHARPTR(strchr(SPIF_CHARPTR_C(pstr), '@'));
+ ptmp = SPIF_CHARPTR(strchr((char *) pstr, '@'));
if ((ptmp != NULL) && (ptmp < pend)) {
- spif_charptr_t tmp = SPIF_CHARPTR(strchr(SPIF_CHARPTR_C(pstr), ':'));
+ spif_charptr_t tmp = SPIF_CHARPTR(strchr((char *) pstr, ':'));
if ((tmp != NULL) && (tmp < ptmp)) {
/* Both username and password. */
@@ -316,7 +316,7 @@ spif_url_parse(spif_url_t self)
}
/* All that remains now between pstr and pend is host and maybe port. */
- ptmp = SPIF_CHARPTR(strchr(SPIF_CHARPTR_C(pstr), ':'));
+ ptmp = SPIF_CHARPTR(strchr((char *) pstr, ':'));
if ((ptmp != NULL) && (ptmp < pend)) {
self->host = spif_str_new_from_buff(pstr, ptmp - pstr);
self->port = spif_str_new_from_buff((ptmp + 1), pend - ptmp - 1);
@@ -329,12 +329,12 @@ spif_url_parse(spif_url_t self)
spif_protoinfo_t proto;
spif_servinfo_t serv;
- proto = getprotobyname(SPIF_CHARPTR_C(SPIF_STR_STR(self->proto)));
+ proto = getprotobyname((char *) SPIF_STR_STR(self->proto));
if (proto == NULL) {
/* If it's not a protocol, it's probably a service. */
- serv = getservbyname(SPIF_CHARPTR_C(SPIF_STR_STR(self->proto)), "tcp");
+ serv = getservbyname((char *) SPIF_STR_STR(self->proto), "tcp");
if (serv == NULL) {
- serv = getservbyname(SPIF_CHARPTR_C(SPIF_STR_STR(self->proto)), "udp");
+ serv = getservbyname((char *) SPIF_STR_STR(self->proto), "udp");
}
if (serv != NULL) {
proto = getprotobyname(serv->s_proto);
@@ -344,7 +344,7 @@ spif_url_parse(spif_url_t self)
if (proto != NULL) {
spif_char_t buff[32];
- snprintf(SPIF_CHARPTR_C(buff), sizeof(buff), "%d", ntohs(serv->s_port));
+ snprintf((char *) buff, sizeof(buff), "%d", ntohs(serv->s_port));
self->port = spif_str_new_from_ptr(buff);
}
}
diff --git a/src/ustr.c b/src/ustr.c
index 3361976..35c80ab 100644
--- a/src/ustr.c
+++ b/src/ustr.c
@@ -83,7 +83,7 @@ static SPIF_CONST_TYPE(strclass) s_class = {
(spif_func_t) spif_ustr_trim,
(spif_func_t) spif_ustr_upcase
};
-SPIF_TYPE(class) SPIF_CLASS_VAR(ustr) = SPIF_CAST(class) &s_class;
+SPIF_TYPE(class) SPIF_CLASS_VAR(ustr) = (spif_class_t) &s_class;
SPIF_TYPE(strclass) SPIF_STRCLASS_VAR(ustr) = &s_class;
/* *INDENT-ON* */
@@ -97,7 +97,7 @@ spif_ustr_new(void)
self = SPIF_ALLOC(ustr);
if (!spif_ustr_init(self)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(ustr);
+ self = (spif_ustr_t) NULL;
}
return self;
}
@@ -110,7 +110,7 @@ spif_ustr_new_from_ptr(spif_charptr_t old)
self = SPIF_ALLOC(ustr);
if (!spif_ustr_init_from_ptr(self, old)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(ustr);
+ self = (spif_ustr_t) NULL;
}
return self;
}
@@ -123,7 +123,7 @@ spif_ustr_new_from_buff(spif_charptr_t buff, spif_ustridx_t size)
self = SPIF_ALLOC(ustr);
if (!spif_ustr_init_from_buff(self, buff, size)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(ustr);
+ self = (spif_ustr_t) NULL;
}
return self;
}
@@ -136,7 +136,7 @@ spif_ustr_new_from_fp(FILE * fp)
self = SPIF_ALLOC(ustr);
if (!spif_ustr_init_from_fp(self, fp)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(ustr);
+ self = (spif_ustr_t) NULL;
}
return self;
}
@@ -149,7 +149,7 @@ spif_ustr_new_from_fd(int fd)
self = SPIF_ALLOC(ustr);
if (!spif_ustr_init_from_fd(self, fd)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(ustr);
+ self = (spif_ustr_t) NULL;
}
return self;
}
@@ -162,7 +162,7 @@ spif_ustr_new_from_num(long num)
self = SPIF_ALLOC(ustr);
if (!spif_ustr_init_from_num(self, num)) {
SPIF_DEALLOC(self);
- self = SPIF_NULL_TYPE(ustr);
+ self = (spif_ustr_t) NULL;
}
return self;
}
@@ -173,7 +173,7 @@ spif_ustr_init(spif_ustr_t self)
ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
- self->s = SPIF_NULL_TYPE(charptr);
+ self->s = (spif_charptr_t) NULL;
self->len = 0;
self->size = 0;
return TRUE;
@@ -183,12 +183,12 @@ spif_bool_t
spif_ustr_init_from_ptr(spif_ustr_t self, spif_charptr_t old)
{
ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
- REQUIRE_RVAL((old != SPIF_NULL_TYPE(charptr)), spif_ustr_init(self));
+ REQUIRE_RVAL((old != (spif_charptr_t) NULL), spif_ustr_init(self));
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
- self->len = strlen(SPIF_CONST_CAST_C(char *) old);
+ self->len = strlen((const char *) old);
self->size = self->len + 1;
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
+ self->s = (spif_charptr_t) MALLOC(self->size);
memcpy(self->s, old, self->size);
return TRUE;
}
@@ -200,16 +200,16 @@ spif_ustr_init_from_buff(spif_ustr_t self, spif_charptr_t buff, spif_ustridx_t s
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
self->size = size;
- if (buff != SPIF_NULL_TYPE(charptr)) {
- self->len = strnlen(SPIF_CONST_CAST_C(char *) buff, size);
+ if (buff != (spif_charptr_t) NULL) {
+ self->len = strnlen((const char *) buff, size);
} else {
self->len = 0;
}
if (self->size == self->len) {
self->size++;
}
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
- if (buff != SPIF_NULL_TYPE(charptr)) {
+ self->s = (spif_charptr_t) MALLOC(self->size);
+ if (buff != (spif_charptr_t) NULL) {
memcpy(self->s, buff, self->len);
}
self->s[self->len] = 0;
@@ -222,18 +222,18 @@ spif_ustr_init_from_fp(spif_ustr_t self, FILE *fp)
spif_charptr_t p, end = NULL;
ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
- ASSERT_RVAL((fp != SPIF_NULL_TYPE_C(FILE *)), FALSE);
+ ASSERT_RVAL((fp != (FILE *) NULL), FALSE);
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
self->size = buff_inc;
self->len = 0;
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
+ self->s = (spif_charptr_t) MALLOC(self->size);
- for (p = self->s; fgets(SPIF_CAST_C(char *)p, buff_inc, fp); p += buff_inc) {
- if ((end = SPIF_CAST(charptr)
- strchr(SPIF_CONST_CAST_C(char *)p, '\n')) == NULL) {
+ for (p = self->s; fgets((char *)p, buff_inc, fp); p += buff_inc) {
+ if ((end = (spif_charptr_t)
+ strchr((const char *)p, '\n')) == NULL) {
self->size += buff_inc;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
} else {
*end = 0;
break;
@@ -241,9 +241,9 @@ spif_ustr_init_from_fp(spif_ustr_t self, FILE *fp)
}
self->len = (spif_ustridx_t) ((end)
? (end - self->s)
- : ((int) strlen(SPIF_CONST_CAST_C(char *)self->s)));
+ : ((int) strlen((const char *)self->s)));
self->size = self->len + 1;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
return TRUE;
}
@@ -259,16 +259,16 @@ spif_ustr_init_from_fd(spif_ustr_t self, int fd)
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
self->size = buff_inc;
self->len = 0;
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
+ self->s = (spif_charptr_t) MALLOC(self->size);
for (p = self->s; ((n = read(fd, p, buff_inc)) > 0) || (errno == EINTR);) {
self->size += n;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
p += n;
}
self->len = self->size - buff_inc;
self->size = self->len + 1;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
self->s[self->len] = 0;
return TRUE;
}
@@ -282,11 +282,11 @@ spif_ustr_init_from_num(spif_ustr_t self, long num)
/* ***NOT NEEDED*** spif_obj_init(SPIF_OBJ(self)); */
spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(ustr));
- snprintf(SPIF_CHARPTR_C(buff), sizeof(buff), "%ld", num);
- self->len = strlen(SPIF_CHARPTR_C(buff));
+ snprintf((char *) buff, sizeof(buff), "%ld", num);
+ self->len = strlen((char *) buff);
self->size = self->len + 1;
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
- strcpy(SPIF_CHARPTR_C(self->s), SPIF_CHARPTR_C(buff));
+ self->s = (spif_charptr_t) MALLOC(self->size);
+ strcpy((char *) self->s, (char *) buff);
return TRUE;
}
@@ -299,7 +299,7 @@ spif_ustr_done(spif_ustr_t self)
FREE(self->s);
self->len = 0;
self->size = 0;
- self->s = SPIF_NULL_TYPE(charptr);
+ self->s = (spif_charptr_t) NULL;
}
return TRUE;
}
@@ -324,9 +324,9 @@ spif_ustr_show(spif_ustr_t self, spif_charptr_t name, spif_str_t buff, size_t in
}
memset(tmp, ' ', indent);
- snprintf(SPIF_CHARPTR_C(tmp) + indent, sizeof(tmp) - indent,
+ snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_ustr_t) %s: %10p { \"",
- name, SPIF_CAST(ptr) self);
+ name, (spif_ptr_t) self);
if (SPIF_USTR_ISNULL(buff)) {
buff = spif_str_new_from_ptr(tmp);
} else {
@@ -335,7 +335,7 @@ spif_ustr_show(spif_ustr_t self, spif_charptr_t name, spif_str_t buff, size_t in
/*spif_str_append(buff, self);*/
- snprintf(SPIF_CHARPTR_C(tmp), sizeof(tmp), "\", len %lu, size %lu }\n", (unsigned long) self->len,
+ snprintf((char *) tmp, sizeof(tmp), "\", len %lu, size %lu }\n", (unsigned long) self->len,
(unsigned long) self->size);
spif_str_append_from_ptr(buff, tmp);
return buff;
@@ -352,10 +352,10 @@ spif_ustr_dup(spif_ustr_t self)
{
spif_ustr_t tmp;
- ASSERT_RVAL(!SPIF_USTR_ISNULL(self), SPIF_NULL_TYPE(ustr));
+ ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (spif_ustr_t) NULL);
tmp = SPIF_ALLOC(ustr);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(ustr));
- tmp->s = SPIF_CAST(charptr) STRDUP(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self));
+ tmp->s = (spif_charptr_t) STRDUP((const char *) SPIF_USTR_STR(self));
tmp->len = self->len;
tmp->size = self->size;
return tmp;
@@ -364,7 +364,7 @@ spif_ustr_dup(spif_ustr_t self)
spif_classname_t
spif_ustr_type(spif_ustr_t self)
{
- ASSERT_RVAL(!SPIF_USTR_ISNULL(self), SPIF_CAST(classname) SPIF_NULLSTR_TYPE(classname));
+ ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (spif_classname_t) SPIF_NULLSTR_TYPE(classname));
return SPIF_OBJ_CLASSNAME(self);
}
@@ -375,7 +375,7 @@ spif_ustr_append(spif_ustr_t self, spif_ustr_t other)
REQUIRE_RVAL(!SPIF_USTR_ISNULL(other), FALSE);
if (other->size && other->len) {
self->size += other->size - 1;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
memcpy(self->s + self->len, SPIF_USTR_STR(other), other->len + 1);
self->len += other->len;
}
@@ -389,7 +389,7 @@ spif_ustr_append_char(spif_ustr_t self, spif_char_t c)
self->len++;
if (self->size <= self->len) {
self->size++;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
}
self->s[self->len - 1] = c;
self->s[self->len] = 0;
@@ -402,11 +402,11 @@ spif_ustr_append_from_ptr(spif_ustr_t self, spif_charptr_t other)
spif_ustridx_t len;
ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
- REQUIRE_RVAL((other != SPIF_NULL_TYPE(charptr)), FALSE);
- len = strlen(SPIF_CONST_CAST_C(char *) other);
+ REQUIRE_RVAL((other != (spif_charptr_t) NULL), FALSE);
+ len = strlen((const char *) other);
if (len) {
self->size += len;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
memcpy(self->s + self->len, other, len + 1);
self->len += len;
}
@@ -419,7 +419,7 @@ spif_ustr_casecmp(spif_ustr_t self, spif_ustr_t other)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strcasecmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(SPIF_USTR_STR(other)));
+ c = strcasecmp((char *) SPIF_USTR_STR(self), (char *) SPIF_USTR_STR(other));
return SPIF_CMP_FROM_INT(c);
}
@@ -429,7 +429,7 @@ spif_ustr_casecmp_with_ptr(spif_ustr_t self, spif_charptr_t other)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strcasecmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(other));
+ c = strcasecmp((char *) SPIF_USTR_STR(self), (char *) other);
return SPIF_CMP_FROM_INT(c);
}
@@ -448,7 +448,7 @@ spif_ustr_cmp(spif_ustr_t self, spif_ustr_t other)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strcmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(SPIF_USTR_STR(other)));
+ c = strcmp((char *) SPIF_USTR_STR(self), (char *) SPIF_USTR_STR(other));
return SPIF_CMP_FROM_INT(c);
}
@@ -458,7 +458,7 @@ spif_ustr_cmp_with_ptr(spif_ustr_t self, spif_charptr_t other)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strcmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(other));
+ c = strcmp((char *) SPIF_USTR_STR(self), (char *) other);
return SPIF_CMP_FROM_INT(c);
}
@@ -479,14 +479,14 @@ spif_ustr_find(spif_ustr_t self, spif_ustr_t other)
{
char *tmp;
- ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (SPIF_CAST(stridx) -1));
- REQUIRE_RVAL(!SPIF_USTR_ISNULL(other), (SPIF_CAST(stridx) -1));
- tmp = strstr(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self),
- SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(other));
+ ASSERT_RVAL(!SPIF_USTR_ISNULL(self), ((spif_stridx_t) -1));
+ REQUIRE_RVAL(!SPIF_USTR_ISNULL(other), ((spif_stridx_t) -1));
+ tmp = strstr((const char *) SPIF_USTR_STR(self),
+ (const char *) SPIF_USTR_STR(other));
if (tmp) {
- return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_USTR_STR(self)));
+ return (spif_stridx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_USTR_STR(self)));
} else {
- return SPIF_CAST(stridx) (self->len);
+ return (spif_stridx_t) (self->len);
}
}
@@ -495,14 +495,14 @@ spif_ustr_find_from_ptr(spif_ustr_t self, spif_charptr_t other)
{
char *tmp;
- ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (SPIF_CAST(stridx) -1));
- REQUIRE_RVAL((other != SPIF_NULL_TYPE(charptr)), (SPIF_CAST(stridx) -1));
- tmp = strstr(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self),
- SPIF_CONST_CAST_C(char *) other);
+ ASSERT_RVAL(!SPIF_USTR_ISNULL(self), ((spif_stridx_t) -1));
+ REQUIRE_RVAL((other != (spif_charptr_t) NULL), ((spif_stridx_t) -1));
+ tmp = strstr((const char *) SPIF_USTR_STR(self),
+ (const char *) other);
if (tmp) {
- return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_USTR_STR(self)));
+ return (spif_stridx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_USTR_STR(self)));
} else {
- return SPIF_CAST(stridx) (self->len);
+ return (spif_stridx_t) (self->len);
}
}
@@ -511,12 +511,12 @@ spif_ustr_index(spif_ustr_t self, spif_char_t c)
{
char *tmp;
- ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (SPIF_CAST(stridx) -1));
- tmp = index(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self), c);
+ ASSERT_RVAL(!SPIF_USTR_ISNULL(self), ((spif_stridx_t) -1));
+ tmp = index((const char *) SPIF_USTR_STR(self), c);
if (tmp) {
- return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_USTR_STR(self)));
+ return (spif_stridx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_USTR_STR(self)));
} else {
- return SPIF_CAST(stridx) (self->len);
+ return (spif_stridx_t) (self->len);
}
}
@@ -526,7 +526,7 @@ spif_ustr_ncasecmp(spif_ustr_t self, spif_ustr_t other, spif_ustridx_t cnt)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strncasecmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(SPIF_USTR_STR(other)), cnt);
+ c = strncasecmp((char *) SPIF_USTR_STR(self), (char *) SPIF_USTR_STR(other), cnt);
return SPIF_CMP_FROM_INT(c);
}
@@ -536,7 +536,7 @@ spif_ustr_ncasecmp_with_ptr(spif_ustr_t self, spif_charptr_t other, spif_ustridx
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strncasecmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(other), cnt);
+ c = strncasecmp((char *) SPIF_USTR_STR(self), (char *) other, cnt);
return SPIF_CMP_FROM_INT(c);
}
@@ -546,7 +546,7 @@ spif_ustr_ncmp(spif_ustr_t self, spif_ustr_t other, spif_ustridx_t cnt)
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strncmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(SPIF_USTR_STR(other)), cnt);
+ c = strncmp((char *) SPIF_USTR_STR(self), (char *) SPIF_USTR_STR(other), cnt);
return SPIF_CMP_FROM_INT(c);
}
@@ -556,7 +556,7 @@ spif_ustr_ncmp_with_ptr(spif_ustr_t self, spif_charptr_t other, spif_ustridx_t c
int c;
SPIF_OBJ_COMP_CHECK_NULL(self, other);
- c = strncmp(SPIF_CHARPTR_C(SPIF_USTR_STR(self)), SPIF_CHARPTR_C(other), cnt);
+ c = strncmp((char *) SPIF_USTR_STR(self), (char *) other, cnt);
return SPIF_CMP_FROM_INT(c);
}
@@ -567,7 +567,7 @@ spif_ustr_prepend(spif_ustr_t self, spif_ustr_t other)
REQUIRE_RVAL(!SPIF_USTR_ISNULL(other), FALSE);
if (other->size && other->len) {
self->size += other->size - 1;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
memmove(self->s + other->len, self->s, self->len + 1);
memcpy(self->s, SPIF_USTR_STR(other), other->len);
self->len += other->len;
@@ -582,10 +582,10 @@ spif_ustr_prepend_char(spif_ustr_t self, spif_char_t c)
self->len++;
if (self->size <= self->len) {
self->size++;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
}
memmove(self->s + 1, self->s, self->len + 1);
- self->s[0] = SPIF_CAST(uchar) c;
+ self->s[0] = (spif_uchar_t) c;
return TRUE;
}
@@ -595,11 +595,11 @@ spif_ustr_prepend_from_ptr(spif_ustr_t self, spif_charptr_t other)
spif_ustridx_t len;
ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
- REQUIRE_RVAL((other != SPIF_NULL_TYPE(charptr)), FALSE);
- len = strlen(SPIF_CONST_CAST_C(char *) other);
+ REQUIRE_RVAL((other != (spif_charptr_t) NULL), FALSE);
+ len = strlen((const char *) other);
if (len) {
self->size += len;
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
memmove(self->s + len, self->s, self->len + 1);
memcpy(self->s, other, len);
self->len += len;
@@ -611,7 +611,7 @@ spif_bool_t
spif_ustr_reverse(spif_ustr_t self)
{
ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
- return ((strrev(SPIF_CAST_C(char *) self->s)) ? TRUE : FALSE);
+ return ((strrev((char *) self->s)) ? TRUE : FALSE);
}
spif_ustridx_t
@@ -619,12 +619,12 @@ spif_ustr_rindex(spif_ustr_t self, spif_char_t c)
{
char *tmp;
- ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (SPIF_CAST(stridx) -1));
- tmp = rindex(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self), c);
+ ASSERT_RVAL(!SPIF_USTR_ISNULL(self), ((spif_stridx_t) -1));
+ tmp = rindex((const char *) SPIF_USTR_STR(self), c);
if (tmp) {
- return SPIF_CAST(stridx) (SPIF_CAST(long) tmp - SPIF_CAST(long) (SPIF_USTR_STR(self)));
+ return (spif_stridx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_USTR_STR(self)));
} else {
- return SPIF_CAST(stridx) (self->len);
+ return (spif_stridx_t) (self->len);
}
}
@@ -647,7 +647,7 @@ spif_ustr_splice(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t cnt, spif_
REQUIRE_RVAL(cnt <= (self->len - idx), FALSE);
newsize = self->len + ((SPIF_USTR_ISNULL(other)) ? (0) : (other->len)) - cnt + 1;
- ptmp = tmp = SPIF_CAST(charptr) MALLOC(newsize);
+ ptmp = tmp = (spif_charptr_t) MALLOC(newsize);
if (idx > 0) {
memcpy(tmp, self->s, idx);
ptmp += idx;
@@ -658,7 +658,7 @@ spif_ustr_splice(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t cnt, spif_
}
memcpy(ptmp, self->s + idx + cnt, self->len - idx - cnt + 1);
if (self->size < newsize) {
- self->s = SPIF_CAST(charptr) REALLOC(self->s, newsize);
+ self->s = (spif_charptr_t) REALLOC(self->s, newsize);
self->size = newsize;
}
self->len = newsize - 1;
@@ -674,7 +674,7 @@ spif_ustr_splice_from_ptr(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t c
spif_ustridx_t len, newsize;
ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
- len = (other ? strlen(SPIF_CONST_CAST_C(char *) other) : 0);
+ len = (other ? strlen((const char *) other) : 0);
if (idx < 0) {
idx = self->len + idx;
}
@@ -687,7 +687,7 @@ spif_ustr_splice_from_ptr(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t c
REQUIRE_RVAL(cnt <= (self->len - idx), FALSE);
newsize = self->len + len - cnt + 1;
- ptmp = tmp = SPIF_CAST(charptr) MALLOC(newsize);
+ ptmp = tmp = (spif_charptr_t) MALLOC(newsize);
if (idx > 0) {
memcpy(tmp, self->s, idx);
ptmp += idx;
@@ -698,7 +698,7 @@ spif_ustr_splice_from_ptr(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t c
}
memcpy(ptmp, self->s + idx + cnt, self->len - idx - cnt + 1);
if (self->size < newsize) {
- self->s = SPIF_CAST(charptr) REALLOC(self->s, newsize);
+ self->s = (spif_charptr_t) REALLOC(self->s, newsize);
self->size = newsize;
}
self->len = newsize - 1;
@@ -714,7 +714,7 @@ spif_ustr_sprintf(spif_ustr_t self, spif_charptr_t format, ...)
ASSERT_RVAL(!SPIF_USTR_ISNULL(self), FALSE);
va_start(ap, format);
- if (self->s != SPIF_NULL_TYPE(charptr)) {
+ if (self->s != (spif_charptr_t) NULL) {
spif_ustr_done(self);
}
if (*format == 0) {
@@ -731,7 +731,7 @@ spif_ustr_sprintf(spif_ustr_t self, spif_charptr_t format, ...)
} else {
self->len = c;
self->size = c + 1;
- self->s = SPIF_CAST(charptr) MALLOC(self->size);
+ self->s = (spif_charptr_t) MALLOC(self->size);
c = vsnprintf(self->s, c + 1, format, ap);
}
return ((c >= 0) ? (TRUE) : (FALSE));
@@ -742,16 +742,16 @@ spif_ustr_sprintf(spif_ustr_t self, spif_charptr_t format, ...)
spif_ustr_t
spif_ustr_substr(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t cnt)
{
- ASSERT_RVAL(!SPIF_USTR_ISNULL(self), SPIF_NULL_TYPE(ustr));
+ ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (spif_ustr_t) NULL);
if (idx < 0) {
idx = self->len + idx;
}
- REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(ustr));
- REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(ustr));
+ REQUIRE_RVAL(idx >= 0, (spif_ustr_t) NULL);
+ REQUIRE_RVAL(idx < self->len, (spif_ustr_t) NULL);
if (cnt <= 0) {
cnt = self->len - idx + cnt;
}
- REQUIRE_RVAL(cnt >= 0, SPIF_NULL_TYPE(ustr));
+ REQUIRE_RVAL(cnt >= 0, (spif_ustr_t) NULL);
UPPER_BOUND(cnt, self->len - idx);
return spif_ustr_new_from_buff(SPIF_USTR_STR(self) + idx, cnt);
}
@@ -761,19 +761,19 @@ spif_ustr_substr_to_ptr(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t cnt
{
spif_charptr_t newstr;
- ASSERT_RVAL(!SPIF_USTR_ISNULL(self), SPIF_NULL_TYPE(charptr));
+ ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (spif_charptr_t) NULL);
if (idx < 0) {
idx = self->len + idx;
}
- REQUIRE_RVAL(idx >= 0, SPIF_NULL_TYPE(charptr));
- REQUIRE_RVAL(idx < self->len, SPIF_NULL_TYPE(charptr));
+ REQUIRE_RVAL(idx >= 0, (spif_charptr_t) NULL);
+ REQUIRE_RVAL(idx < self->len, (spif_charptr_t) NULL);
if (cnt <= 0) {
cnt = self->len - idx + cnt;
}
- REQUIRE_RVAL(cnt >= 0, SPIF_NULL_TYPE(charptr));
+ REQUIRE_RVAL(cnt >= 0, (spif_charptr_t) NULL);
UPPER_BOUND(cnt, self->len - idx);
- newstr = SPIF_CAST(charptr) MALLOC(cnt + 1);
+ newstr = (spif_charptr_t) MALLOC(cnt + 1);
memcpy(newstr, SPIF_USTR_STR(self) + idx, cnt);
newstr[cnt] = 0;
return newstr;
@@ -782,15 +782,15 @@ spif_ustr_substr_to_ptr(spif_ustr_t self, spif_ustridx_t idx, spif_ustridx_t cnt
double
spif_ustr_to_float(spif_ustr_t self)
{
- ASSERT_RVAL(!SPIF_USTR_ISNULL(self), SPIF_CAST_C(double) NAN);
- return (double) (strtod(SPIF_CONST_CAST_C(char *)SPIF_USTR_STR(self), (char **) NULL));
+ ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (double) NAN);
+ return (double) (strtod((const char *)SPIF_USTR_STR(self), (char **) NULL));
}
size_t
spif_ustr_to_num(spif_ustr_t self, int base)
{
- ASSERT_RVAL(!SPIF_USTR_ISNULL(self), (SPIF_CAST_C(size_t) -1));
- return (size_t) (strtoul(SPIF_CONST_CAST_C(char *) SPIF_USTR_STR(self), (char **) NULL, base));
+ ASSERT_RVAL(!SPIF_USTR_ISNULL(self), ((size_t) -1));
+ return (size_t) (strtoul((const char *) SPIF_USTR_STR(self), (char **) NULL, base));
}
spif_bool_t
@@ -810,7 +810,7 @@ spif_ustr_trim(spif_ustr_t self)
self->len = (spif_ustridx_t) (end - start);
self->size = self->len + 1;
memmove(self->s, start, self->size);
- self->s = SPIF_CAST(charptr) REALLOC(self->s, self->size);
+ self->s = (spif_charptr_t) REALLOC(self->s, self->size);
return TRUE;
}
View Lorry Controller Status