Remove Windows support

[solanum.git] / librb / src / tools.c

diff --git a/librb/src/tools.c b/librb/src/tools.c
index 992508fb596358290b6c573b03cdcb8132ce72c4..ecc852fb6f2111feffdfcecb5225263006c367ce 100644 (file)
--- a/librb/src/tools.c
+++ b/librb/src/tools.c
@@ -134,7 +134,6 @@ rb_string_to_array(char *string, char **parv, int maxpara)
 }
 
 #ifndef HAVE_STRCASECMP
-#ifndef _WIN32
 /* Fallback taken from FreeBSD. --Elizafox */
 int
 rb_strcasecmp(const char *s1, const char *s2)
@@ -150,14 +149,7 @@ rb_strcasecmp(const char *s1, const char *s2)
 
        return (tolower(*us1) - tolower(*--us2));
 }
-#else /* _WIN32 */
-int
-rb_strcasecmp(const char *s1, const char *s2)
-{
-       return stricmp(s1, s2);
-}
-#endif /* _WIN32 */
-#else /* HAVE_STRCASECMP */
+#else
 int
 rb_strcasecmp(const char *s1, const char *s2)
 {
@@ -166,7 +158,6 @@ rb_strcasecmp(const char *s1, const char *s2)
 #endif
 
 #ifndef HAVE_STRNCASECMP
-#ifndef _WIN32
 /* Fallback taken from FreeBSD. --Elizafox */
 int
 rb_strncasecmp(const char *s1, const char *s2, size_t n)
@@ -186,14 +177,7 @@ rb_strncasecmp(const char *s1, const char *s2, size_t n)
        }
        return 0;
 }
-#else /* _WIN32 */
-int
-rb_strncasecmp(const char *s1, const char *s2, size_t n)
-{
-       return strnicmp(s1, s2, n);
-}
-#endif /* _WIN32 */
-#else /* HAVE_STRNCASECMP */
+#else
 int
 rb_strncasecmp(const char *s1, const char *s2, size_t n)
 {
@@ -399,127 +383,68 @@ rb_dirname (const char *path)
        return rb_strndup(path, ((uintptr_t)s - (uintptr_t)path) + 2);
 }
 
-size_t rb_zstring_serialized(rb_zstring_t *zs, void **buf, size_t *buflen)
-{
-        uint8_t *p;
-        size_t alloclen = sizeof(uint16_t) + zs->len;
-
-        p = rb_malloc(sizeof(alloclen));
-        memcpy(p, &zs->len, sizeof(uint16_t));
-        p += sizeof(uint16_t);
-        memcpy(p, zs->data, zs->len);
-        return alloclen;
-}
 
-size_t rb_zstring_deserialize(rb_zstring_t *zs, void *buf)
-{
-       uint8_t *p = (uint8_t *)buf;
-
-       memcpy(&zs->len, p, sizeof(uint16_t));
-       p += sizeof(uint16_t);
-       if(zs->len == 0)
-       {
-               zs->data = NULL;
-               return sizeof(uint16_t);
-       }
-       zs->data = rb_malloc(zs->len);
-       memcpy(zs->data, p, zs->len);
-       return zs->len + sizeof(uint16_t);
-}
 
-void rb_zstring_free(rb_zstring_t *zs)
+int rb_fsnprint(char *buf, size_t len, const rb_strf_t *strings)
 {
-       rb_free(zs->data);
-       rb_free(zs);
+       size_t used = 0;
+       size_t remaining = len;
 
-}
+       while (strings != NULL) {
+               int ret = 0;
 
-rb_zstring_t *rb_zstring_alloc(void)
-{
-       rb_zstring_t *zs = rb_malloc(sizeof(rb_zstring_t));
-       return zs;
-}
+               if (strings->length != 0) {
+                       remaining = strings->length;
+                       if (remaining > len - used)
+                               remaining = len - used;
+               }
 
-rb_zstring_t *rb_zstring_from_c_len(const char *buf, size_t len)
-{
-       rb_zstring_t *zs;
-
-       if(len > UINT16_MAX-1)
-               return NULL;
-
-       zs = rb_zstring_alloc();
-       zs->alloclen = zs->len = (uint16_t)len;
-       zs->alloclen = (uint16_t)len;
-       if(zs->alloclen < 128)
-               zs->alloclen = 128;
-       zs->data = rb_malloc(zs->alloclen);
-       memcpy(zs->data, buf, zs->len);
-       return(zs);
-}
+               if (remaining == 0)
+                       break;
 
-rb_zstring_t *rb_zstring_from_c(const char *buf)
-{
-       return rb_zstring_from_c_len(buf, strlen(buf));
-}
+               if (strings->format != NULL) {
+                       if (strings->format_args != NULL) {
+                               ret = vsnprintf(buf + used, remaining,
+                                       strings->format, *strings->format_args);
+                       } else {
+                               ret = rb_strlcpy(buf + used,
+                                       strings->format, remaining);
+                       }
+               } else if (strings->func != NULL) {
+                       ret = strings->func(buf + used, remaining,
+                               strings->func_args);
+               }
 
-size_t rb_zstring_len(rb_zstring_t *zs)
-{
-       return zs->len;
-}
+               if (ret < 0) {
+                       return ret;
+               } else if ((size_t)ret > remaining - 1) {
+                       used += remaining - 1;
+               } else {
+                       used += ret;
+               }
 
-void rb_zstring_append_from_zstring(rb_zstring_t *dst_zs, rb_zstring_t *src_zs)
-{
-       void *ep;
-       size_t nlen = dst_zs->len + src_zs->len;
+               if (used >= len - 1) {
+                       used = len - 1;
+                       break;
+               }
 
-       if(nlen > dst_zs->alloclen)
-       {
-               dst_zs->alloclen += src_zs->len + 64;
-               dst_zs->data = rb_realloc(dst_zs->data, dst_zs->alloclen);
+               remaining -= ret;
+               strings = strings->next;
        }
 
-       ep = dst_zs->data + dst_zs->len;
-       memcpy(ep, src_zs->data, src_zs->len);
-}
-
-void rb_zstring_append_from_c(rb_zstring_t *zs, const char *buf, size_t len)
-{
-       void *ep;
-       size_t nlen = zs->len + len;
-
-       if(nlen > zs->alloclen)
-       {
-               zs->alloclen += len + 64;
-               zs->data = rb_realloc(zs->data, zs->alloclen);
-       }
-       ep = zs->data + zs->len;
-       zs->len += len;
-       memcpy(ep, buf, len);
+       return used;
 }
 
-char *rb_zstring_to_c(rb_zstring_t *zs, char *buf, size_t len)
+int rb_fsnprintf(char *buf, size_t len, const rb_strf_t *strings, const char *format, ...)
 {
-        size_t cpylen;
-        if(len < zs->len)
-                cpylen = len - 1;
-        else
-                cpylen = zs->len;
-        buf[cpylen] = '\0';
-        memcpy(buf, zs->data, cpylen);
-        return buf;
-}
+       va_list args;
+       rb_strf_t prepend_string = { .format = format, .format_args = &args, .next = strings };
+       int ret;
 
+       va_start(args, format);
+       ret = rb_fsnprint(buf, len, &prepend_string);
+       va_end(args);
 
-char *rb_zstring_to_c_alloc(rb_zstring_t *zs)
-{
-       char *p;
-       p = rb_malloc(zs->len+1);
-       memcpy(p, zs->data, zs->len);
-       return p;
+       return ret;
 }
 
-size_t rb_zstring_to_ptr(rb_zstring_t *zs, void **ptr)
-{
-       *ptr = (void *)zs->data;
-       return zs->len;
-}