Warning fixes

[fontconfig.git] / src / fcstr.c

diff --git a/src/fcstr.c b/src/fcstr.c
index 658890e6920a7d31536399196b6671568f0d79f1..6cf7d7022a9a51dc88b4e309c7bc14999347d400 100644 (file)
--- a/src/fcstr.c
+++ b/src/fcstr.c
@@ -1,5 +1,5 @@
 /*
- * $XFree86: $
+ * $XFree86: xc/lib/fontconfig/src/fcstr.c,v 1.2 2002/02/15 06:01:28 keithp Exp $
  *
  * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
  *
@@ -27,46 +27,46 @@
 #include <string.h>
 #include "fcint.h"
 
-char *
-FcStrCopy (const char *s)
+FcChar8 *
+FcStrCopy (const FcChar8 *s)
 {
-    char       *r;
+    FcChar8    *r;
 
     if (!s)
        return 0;
-    r = (char *) malloc (strlen (s) + 1);
+    r = (FcChar8 *) malloc (strlen ((char *) s) + 1);
     if (!r)
        return 0;
-    FcMemAlloc (FC_MEM_STRING, strlen (s) + 1);
-    strcpy (r, s);
+    FcMemAlloc (FC_MEM_STRING, strlen ((char *) s) + 1);
+    strcpy ((char *) r, (char *) s);
     return r;
 }
 
-char *
-FcStrPlus (const char *s1, const char *s2)
+FcChar8 *
+FcStrPlus (const FcChar8 *s1, const FcChar8 *s2)
 {
-    int            l = strlen (s1) + strlen (s2) + 1;
-    char    *s = malloc (l);
+    int            l = strlen ((char *)s1) + strlen ((char *) s2) + 1;
+    FcChar8 *s = malloc (l);
 
     if (!s)
        return 0;
     FcMemAlloc (FC_MEM_STRING, l);
-    strcpy (s, s1);
-    strcat (s, s2);
+    strcpy ((char *) s, (char *) s1);
+    strcat ((char *) s, (char *) s2);
     return s;
 }
 
 void
-FcStrFree (char *s)
+FcStrFree (FcChar8 *s)
 {
-    FcMemFree (FC_MEM_STRING, strlen (s) + 1);
+    FcMemFree (FC_MEM_STRING, strlen ((char *) s) + 1);
     free (s);
 }
 
 int
-FcStrCmpIgnoreCase (const char *s1, const char *s2)
+FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
 {
-    char    c1, c2;
+    FcChar8 c1, c2;
     
     for (;;) 
     {
@@ -186,3 +186,93 @@ FcUtf8Len (FcChar8 *string,
        *wchar = 1;
     return FcTrue;
 }
+
+void
+FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size)
+{
+    buf->buf = init;
+    buf->allocated = FcFalse;
+    buf->failed = FcFalse;
+    buf->len = 0;
+    buf->size = size;
+}
+
+void
+FcStrBufDestroy (FcStrBuf *buf)
+{
+    if (buf->allocated)
+    {
+       free (buf->buf);
+       FcStrBufInit (buf, 0, 0);
+    }
+}
+
+FcChar8 *
+FcStrBufDone (FcStrBuf *buf)
+{
+    FcChar8 *ret;
+
+    ret = malloc (buf->len + 1);
+    if (ret)
+    {
+       memcpy (ret, buf->buf, buf->len);
+       ret[buf->len] = '\0';
+    }
+    FcStrBufDestroy (buf);
+    return ret;
+}
+
+FcBool
+FcStrBufChar (FcStrBuf *buf, FcChar8 c)
+{
+    if (buf->len == buf->size)
+    {
+       FcChar8     *new;
+       int         size;
+
+       if (buf->allocated)
+       {
+           size = buf->size * 2;
+           new = realloc (buf->buf, size);
+       }
+       else
+       {
+           size = buf->size + 1024;
+           new = malloc (size);
+           if (new)
+           {
+               buf->allocated = FcTrue;
+               memcpy (new, buf->buf, buf->len);
+           }
+       }
+       if (!new)
+       {
+           buf->failed = FcTrue;
+           return FcFalse;
+       }
+       buf->size = size;
+       buf->buf = new;
+    }
+    buf->buf[buf->len++] = c;
+    return FcTrue;
+}
+
+FcBool
+FcStrBufString (FcStrBuf *buf, const FcChar8 *s)
+{
+    FcChar8 c;
+    while ((c = *s++))
+       if (!FcStrBufChar (buf, c))
+           return FcFalse;
+    return FcTrue;
+}
+
+FcBool
+FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len)
+{
+    while (len-- > 0)
+       if (!FcStrBufChar (buf, *s++))
+           return FcFalse;
+    return FcTrue;
+}
+