spif_str_t
spif_str_show(spif_str_t self, spif_charptr_t name, spif_str_t buff, size_t indent)
{
spif_char_t tmp[4096];
if (SPIF_STR_ISNULL(self)) {
SPIF_OBJ_SHOW_NULL(str, name, buff, indent, tmp);
return buff;
}
memset(tmp, ' ', indent);
snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_str_t) %s: %10p { \"",
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);
}
spif_str_append(buff, self);
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;
}
spif_bool_t
spif_str_append(spif_str_t self, spif_str_t other)
{
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
REQUIRE_RVAL(!SPIF_STR_ISNULL(other), FALSE);
if (other->size && other->len) {
self->size += other->size - 1;
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;
}
return TRUE;
}
spif_bool_t
spif_url_unparse(spif_url_t self)
{
ASSERT_RVAL(!SPIF_URL_ISNULL(self), FALSE);
spif_str_done(SPIF_STR(self));
spif_str_init_from_ptr(SPIF_STR(self), SPIF_CHARPTR(""));
/* First, proto followed by a colon. */
if (!SPIF_STR_ISNULL(self->proto)) {
spif_str_append(SPIF_STR(self), self->proto);
spif_str_append_char(SPIF_STR(self), ':');
}
/* If we have a port but no host, make it localhost. */
if (!SPIF_STR_ISNULL(self->port) && SPIF_STR_ISNULL(self->host)) {
self->host = spif_str_new_from_ptr(SPIF_CHARPTR("localhost"));
}
/* We need the // if we have a hostname. */
if (!SPIF_STR_ISNULL(self->host)) {
spif_str_append_from_ptr(SPIF_STR(self), SPIF_CHARPTR("//"));
}
if (!SPIF_STR_ISNULL(self->user)) {
spif_str_append(SPIF_STR(self), self->user);
if (!SPIF_STR_ISNULL(self->passwd)) {
spif_str_append_char(SPIF_STR(self), ':');
spif_str_append(SPIF_STR(self), self->passwd);
}
spif_str_append_char(SPIF_STR(self), '@');
}
if (!SPIF_STR_ISNULL(self->host)) {
spif_str_append(SPIF_STR(self), self->host);
if (!SPIF_STR_ISNULL(self->port)) {
spif_str_append_char(SPIF_STR(self), ':');
spif_str_append(SPIF_STR(self), self->port);
}
}
if (!SPIF_STR_ISNULL(self->path)) {
spif_str_append(SPIF_STR(self), self->path);
}
if (!SPIF_STR_ISNULL(self->query)) {
spif_str_append_char(SPIF_STR(self), '?');
spif_str_append(SPIF_STR(self), self->query);
}
return TRUE;
}
spif_stridx_t
spif_str_find(spif_str_t self, spif_str_t other)
{
char *tmp;
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_stridx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_STR_STR(self)));
} else {
return (spif_stridx_t) (self->len);
}
}
spif_str_t
spif_url_show(spif_url_t self, spif_charptr_t name, spif_str_t buff, size_t indent)
{
spif_char_t tmp[4096];
if (SPIF_URL_ISNULL(self)) {
SPIF_OBJ_SHOW_NULL(url, name, buff, indent, tmp);
return buff;
}
memset(tmp, ' ', indent);
snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_url_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_str_show(self->proto, SPIF_CHARPTR("proto"), buff, indent + 2);
buff = spif_str_show(self->user, SPIF_CHARPTR("user"), buff, indent + 2);
buff = spif_str_show(self->passwd, SPIF_CHARPTR("passwd"), buff, indent + 2);
buff = spif_str_show(self->host, SPIF_CHARPTR("host"), buff, indent + 2);
buff = spif_str_show(self->port, SPIF_CHARPTR("port"), buff, indent + 2);
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((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
spif_bool_t
spif_str_init_from_fd(spif_str_t self, int fd)
{
int n;
spif_charptr_t p;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
ASSERT_RVAL((fd >= 0), 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_charptr_t) MALLOC(self->size);
for (p = self->s; ((n = read(fd, p, buff_inc)) > 0) || (errno == EINTR);) {
self->size += n;
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_charptr_t) REALLOC(self->s, self->size);
self->s[self->len] = 0;
return TRUE;
}
spif_bool_t
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 != (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_charptr_t) MALLOC(self->size);
for (p = self->s; fgets((char *)p, buff_inc, fp); p += buff_inc) {
if (!(end = (spif_charptr_t)strchr((const char *)p, '\n'))) {
self->size += buff_inc;
self->s = (spif_charptr_t) REALLOC(self->s, self->size);
} else {
*end = 0;
break;
}
}
self->len = (spif_stridx_t) ((end)
? (end - self->s)
: ((int) strlen((const char *)self->s)));
self->size = self->len + 1;
self->s = (spif_charptr_t) REALLOC(self->s, self->size);
return TRUE;
}
spif_bool_t
spif_str_clear(spif_str_t self, spif_char_t c)
{
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
memset(self->s, c, self->size);
self->s[self->len] = 0;
return TRUE;
}
static spif_bool_t
action_handle_script(event_t *ev, spif_eterm_action_t action)
{
REQUIRE_RVAL(!SPIF_PTR_ISNULL(ev), FALSE);
REQUIRE_RVAL(!SPIF_STR_ISNULL(action->parameter), FALSE);
script_parse(SPIF_STR_STR(action->parameter));
return 1;
}
static spif_bool_t
action_handle_string(event_t *ev, spif_eterm_action_t action)
{
REQUIRE_RVAL(!SPIF_PTR_ISNULL(ev), FALSE);
REQUIRE_RVAL(!SPIF_STR_ISNULL(action->parameter), FALSE);
cmd_write(SPIF_STR_STR(action->parameter), spif_str_get_len(SPIF_STR(action->parameter)));
return 1;
}
spif_bool_t
spif_str_del(spif_str_t self)
{
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
spif_str_done(self);
SPIF_DEALLOC(self);
return TRUE;
}
spif_bool_t
spif_socket_send(spif_socket_t self, spif_str_t data)
{
size_t len;
int num_written;
struct timeval tv = { 0, 0 };
ASSERT_RVAL(!SPIF_SOCKET_ISNULL(self), FALSE);
REQUIRE_RVAL(!SPIF_STR_ISNULL(data), FALSE);
len = spif_str_get_len(data);
REQUIRE_RVAL(len > 0, FALSE);
num_written = write(self->fd, SPIF_STR_STR(data), len);
for (; (num_written < 0) && ((errno == EAGAIN) || (errno == EINTR)); ) {
tv.tv_usec += 10000;
if (tv.tv_usec == 1000000) {
tv.tv_usec = 0;
tv.tv_sec++;
}
select(0, NULL, NULL, NULL, &tv);
num_written = write(self->fd, SPIF_STR_STR(data), len);
}
if (num_written < 0) {
D_OBJ(("Unable to write to socket %d -- %s\n", self->fd, strerror(errno)));
switch (errno) {
case EFBIG:
{
spif_bool_t b;
spif_str_t tmp_buf;
spif_charptr_t s;
long left;
for (left = len, s = SPIF_CHARPTR(SPIF_STR_STR(data)); left > 0; s += 1024, left -= 1024) {
tmp_buf = spif_str_new_from_buff(s, 1024);
b = spif_socket_send(self, tmp_buf);
if (b == FALSE) {
spif_str_del(tmp_buf);
return b;
}
}
}
break;
case EIO:
case EPIPE:
close(self->fd);
/* Drop */
case EBADF:
case EINVAL:
default:
self->fd = -1;
SPIF_SOCKET_FLAGS_CLEAR(self, SPIF_SOCKET_FLAGS_IOSTATE);
return FALSE;
break;
}
}
return TRUE;
}
spif_bool_t
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_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->user)) {
spif_str_del(self->user);
self->user = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->passwd)) {
spif_str_del(self->passwd);
self->passwd = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->host)) {
spif_str_del(self->host);
self->host = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->port)) {
spif_str_del(self->port);
self->port = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->path)) {
spif_str_del(self->path);
self->path = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->query)) {
spif_str_del(self->query);
self->query = (spif_str_t) NULL;
}
spif_str_done(SPIF_STR(self));
return TRUE;
}
spif_bool_t
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_charptr_t) NULL;
self->len = 0;
self->size = 0;
return TRUE;
}
spif_bool_t
spif_str_upcase(spif_str_t self)
{
spif_charptr_t tmp;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
for (tmp = self->s; *tmp; tmp++) {
*tmp = toupper(*tmp);
}
return TRUE;
}
spif_bool_t
spif_str_done(spif_str_t self)
{
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
if (self->size) {
FREE(self->s);
self->len = 0;
self->size = 0;
self->s = (spif_charptr_t) NULL;
}
return TRUE;
}
spif_bool_t
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_list_t) NULL;
}
if (!SPIF_STR_ISNULL(self->src)) {
spif_str_del(SPIF_STR(self->src));
self->src = (spif_str_t) NULL;
}
if (!SPIF_STR_ISNULL(self->sep)) {
spif_str_del(SPIF_STR(self->sep));
self->sep = (spif_str_t) NULL;
}
self->quote = '\'';
self->dquote = '\"';
self->escape = '\\';
return TRUE;
}
spif_str_t
spif_socket_show(spif_socket_t self, spif_charptr_t name, spif_str_t buff, size_t indent)
{
spif_char_t tmp[4096];
if (SPIF_SOCKET_ISNULL(self)) {
SPIF_OBJ_SHOW_NULL(socket, name, buff, indent, tmp);
return buff;
}
memset(tmp, ' ', indent);
snprintf((char *) tmp + indent, sizeof(tmp) - indent,
"(spif_socket_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);
}
indent += 2;
memset(tmp, ' ', indent);
snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_sockfd_t) fd: %d\n", self->fd);
spif_str_append_from_ptr(buff, tmp);
snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_sockfamily_t) fam: %d\n", (int) self->fam);
spif_str_append_from_ptr(buff, tmp);
snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_socktype_t) type: %d\n", (int) self->type);
spif_str_append_from_ptr(buff, tmp);
snprintf((char *) tmp + indent, sizeof(tmp) - indent, "(spif_sockproto_t) proto: %d\n", (int) self->proto);
spif_str_append_from_ptr(buff, tmp);
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((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((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((char *) tmp + indent, sizeof(tmp) - indent, "}\n");
spif_str_append_from_ptr(buff, tmp);
return buff;
}
spif_str_t
spif_str_dup(spif_str_t self)
{
spif_str_t tmp;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), (spif_str_t) NULL);
tmp = SPIF_ALLOC(str);
memcpy(tmp, self, SPIF_SIZEOF_TYPE(str));
tmp->s = (spif_charptr_t) STRDUP((const char *) SPIF_STR_STR(self));
tmp->len = self->len;
tmp->size = self->size;
return tmp;
}
spif_bool_t
spif_str_append_char(spif_str_t self, spif_char_t c)
{
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
self->len++;
if (self->size <= self->len) {
self->size++;
self->s = (spif_charptr_t) REALLOC(self->s, self->size);
}
self->s[self->len - 1] = c;
self->s[self->len] = 0;
return TRUE;
}
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_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((const char *) old);
self->size = self->len + 1;
self->s = (spif_charptr_t) MALLOC(self->size);
memcpy(self->s, old, self->size);
return TRUE;
}
spif_bool_t
spif_str_prepend_char(spif_str_t self, spif_char_t c)
{
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
self->len++;
if (self->size <= self->len) {
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_uchar_t) c;
return TRUE;
}
spif_stridx_t
spif_str_rindex(spif_str_t self, spif_char_t c)
{
char *tmp;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), ((spif_stridx_t) -1));
tmp = rindex((const char *) SPIF_STR_STR(self), c);
if (tmp) {
return (spif_stridx_t) ((spif_long_t) tmp - (spif_long_t) (SPIF_STR_STR(self)));
} else {
return (spif_stridx_t) (self->len);
}
}
spif_bool_t
spif_str_splice(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt, spif_str_t other)
{
spif_charptr_t tmp, ptmp;
spif_stridx_t newsize;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
if (idx < 0) {
idx = self->len + idx;
}
REQUIRE_RVAL(idx >= 0, FALSE);
REQUIRE_RVAL(idx < self->len, FALSE);
if (cnt < 0) {
cnt = idx + self->len + cnt;
}
REQUIRE_RVAL(cnt >= 0, FALSE);
REQUIRE_RVAL(cnt <= (self->len - idx), FALSE);
newsize = self->len + ((SPIF_STR_ISNULL(other)) ? (0) : (other->len)) - cnt + 1;
ptmp = tmp = (spif_charptr_t) MALLOC(newsize);
if (idx > 0) {
memcpy(tmp, self->s, idx);
ptmp += idx;
}
if (!SPIF_OBJ_ISNULL(other)) {
memcpy(ptmp, other->s, other->len);
ptmp += other->len;
}
memcpy(ptmp, self->s + idx + cnt, self->len - idx - cnt + 1);
if (self->size < newsize) {
self->s = (spif_charptr_t) REALLOC(self->s, newsize);
self->size = newsize;
}
self->len = newsize - 1;
memcpy(self->s, tmp, newsize);
FREE(tmp);
return TRUE;
}
static spif_sockport_t
spif_url_get_portnum(spif_url_t self)
{
spif_str_t port_str;
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_sockport_t) spif_str_to_num(port_str, 10);
}
return (spif_sockport_t) 0;
}
spif_bool_t
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_charptr_t) NULL), FALSE);
len = strlen((const char *) other);
if (len) {
self->size += len;
self->s = (spif_charptr_t) REALLOC(self->s, self->size);
memcpy(self->s + self->len, other, len + 1);
self->len += len;
}
return TRUE;
}
static spif_bool_t
action_handle_echo(event_t *ev, spif_eterm_action_t action)
{
REQUIRE_RVAL(!SPIF_PTR_ISNULL(ev), FALSE);
REQUIRE_RVAL(!SPIF_STR_ISNULL(action->parameter), FALSE);
#ifdef ESCREEN
if (TermWin.screen && TermWin.screen->backend) {
# ifdef NS_HAVE_SCREEN
/* translate escapes */
ns_parse_screen_interactive(TermWin.screen, SPIF_STR_STR(action->parameter));
# endif
} else
#endif
tt_write(SPIF_STR_STR(action->parameter), spif_str_get_len(SPIF_STR(action->parameter)));
return 1;
}
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_str_t) NULL);
if (idx < 0) {
idx = self->len + idx;
}
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_str_t) NULL);
UPPER_BOUND(cnt, self->len - idx);
return spif_str_new_from_buff(SPIF_STR_STR(self) + idx, cnt);
}
spif_bool_t
spif_str_init_from_num(spif_str_t self, long num)
{
spif_char_t buff[28];
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)));
snprintf((char *) buff, sizeof(buff), "%ld", num);
self->len = strlen((char *) buff);
self->size = self->len + 1;
self->s = (spif_charptr_t) MALLOC(self->size);
strcpy((char *) self->s, (char *) buff);
return TRUE;
}
spif_bool_t
spif_tok_init_from_fd(spif_tok_t self, int fd)
{
ASSERT_RVAL(!SPIF_TOK_ISNULL(self), FALSE);
if (!spif_obj_init(SPIF_OBJ(self))) {
return FALSE;
} else if (!spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS_VAR(tok))) {
return FALSE;
}
self->src = spif_str_new_from_fd(fd);
self->quote = '\'';
self->dquote = '\"';
self->escape = '\\';
self->tokens = (spif_list_t) NULL;
self->sep = (spif_str_t) NULL;
return ((SPIF_STR_ISNULL(self->src)) ? (FALSE) : (TRUE));
}
