/*
- * $XFree86: $
+ * $XFree86: xc/lib/fontconfig/src/fcstr.c,v 1.5 2002/05/29 22:07:33 keithp Exp $
*
* Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
*
#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 (;;)
{
if (c1 != c2)
break;
}
- return (int) c2 - (int) c1;
+ return (int) c1 - (int) c2;
+}
+
+int
+FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)
+{
+ FcChar8 c1, c2;
+
+ for (;;)
+ {
+ do
+ c1 = *s1++;
+ while (c1 == ' ');
+ do
+ c2 = *s2++;
+ while (c2 == ' ');
+ if (!c1 || !c2)
+ break;
+ c1 = FcToLower (c1);
+ c2 = FcToLower (c2);
+ if (c1 != c2)
+ break;
+ }
+ return (int) c1 - (int) c2;
+}
+
+int
+FcStrCmp (const FcChar8 *s1, const FcChar8 *s2)
+{
+ FcChar8 c1, c2;
+
+ if (s1 == s2)
+ return 0;
+ for (;;)
+ {
+ c1 = *s1++;
+ c2 = *s2++;
+ if (!c1 || !c2)
+ break;
+ if (c1 != c2)
+ break;
+ }
+ return (int) c1 - (int) c2;
}
int
*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;
+}
+
+FcChar8 *
+FcStrCopyFilename (const FcChar8 *s)
+{
+ FcChar8 *new;
+
+ if (*s == '~')
+ {
+ FcChar8 *home = (FcChar8 *) getenv ("HOME");
+ int size = strlen ((char *) home) + strlen ((char *) s);
+ if (!home)
+ return 0;
+ new = (FcChar8 *) malloc (size);
+ if (!new)
+ return 0;
+ FcMemAlloc (FC_MEM_STRING, size);
+ strcpy ((char *) new, (char *) home);
+ strcat ((char *) new, (char *) s + 1);
+ }
+ else
+ {
+ int size = strlen ((char *) s) + 1;
+ new = (FcChar8 *) malloc (size);
+ if (!new)
+ return 0;
+ FcMemAlloc (FC_MEM_STRING, size);
+ strcpy ((char *) new, (const char *) s);
+ }
+ return new;
+}
+
+FcChar8 *
+FcStrDirname (const FcChar8 *file)
+{
+ FcChar8 *slash;
+ FcChar8 *dir;
+
+ slash = (FcChar8 *) strrchr ((char *) file, '/');
+ if (!slash)
+ return FcStrCopy ((FcChar8 *) ".");
+ dir = malloc ((slash - file) + 1);
+ if (!dir)
+ return 0;
+ FcMemAlloc (FC_MEM_STRING, (slash - file) + 1);
+ strncpy ((char *) dir, (const char *) file, slash - file);
+ dir[slash - file] = '\0';
+ return dir;
+}
+
+FcChar8 *
+FcStrBasename (const FcChar8 *file)
+{
+ FcChar8 *slash;
+
+ slash = (FcChar8 *) strrchr ((char *) file, '/');
+ if (!slash)
+ return FcStrCopy (file);
+ return FcStrCopy (slash + 1);
+}
+
+FcStrSet *
+FcStrSetCreate (void)
+{
+ FcStrSet *set = malloc (sizeof (FcStrSet));
+ if (!set)
+ return 0;
+ FcMemAlloc (FC_MEM_STRSET, sizeof (FcStrSet));
+ set->ref = 1;
+ set->num = 0;
+ set->size = 0;
+ set->strs = 0;
+ return set;
+}
+
+static FcBool
+_FcStrSetAppend (FcStrSet *set, FcChar8 *s)
+{
+ if (FcStrSetMember (set, s))
+ {
+ FcStrFree (s);
+ return FcTrue;
+ }
+ if (set->num == set->size)
+ {
+ FcChar8 **strs = malloc ((set->size + 2) * sizeof (FcChar8 *));
+
+ if (!strs)
+ return FcFalse;
+ FcMemAlloc (FC_MEM_STRSET, (set->size + 2) * sizeof (FcChar8 *));
+ set->size = set->size + 1;
+ if (set->num)
+ memcpy (strs, set->strs, set->num * sizeof (FcChar8 *));
+ if (set->strs)
+ free (set->strs);
+ set->strs = strs;
+ }
+ set->strs[set->num++] = s;
+ set->strs[set->num] = 0;
+ return FcTrue;
+}
+
+FcBool
+FcStrSetMember (FcStrSet *set, const FcChar8 *s)
+{
+ int i;
+
+ for (i = 0; i < set->num; i++)
+ if (!FcStrCmp (set->strs[i], s))
+ return FcTrue;
+ return FcFalse;
+}
+
+FcBool
+FcStrSetAdd (FcStrSet *set, const FcChar8 *s)
+{
+ FcChar8 *new = FcStrCopy (s);
+ if (!new)
+ return FcFalse;
+ if (!_FcStrSetAppend (set, new))
+ {
+ FcStrFree (new);
+ return FcFalse;
+ }
+ return FcTrue;
+}
+
+FcBool
+FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s)
+{
+ FcChar8 *new = FcStrCopyFilename (s);
+ if (!new)
+ return FcFalse;
+ if (!_FcStrSetAppend (set, new))
+ {
+ FcStrFree (new);
+ return FcFalse;
+ }
+ return FcTrue;
+}
+
+FcBool
+FcStrSetDel (FcStrSet *set, const FcChar8 *s)
+{
+ int i;
+
+ for (i = 0; i < set->num; i++)
+ if (!FcStrCmp (set->strs[i], s))
+ {
+ FcStrFree (set->strs[i]);
+ /*
+ * copy remaining string pointers and trailing
+ * NULL
+ */
+ memmove (&set->strs[i], &set->strs[i+1],
+ (set->num - i) * sizeof (FcChar8 *));
+ set->num--;
+ return FcTrue;
+ }
+ return FcFalse;
+}
+
+void
+FcStrSetDestroy (FcStrSet *set)
+{
+ if (--set->ref == 0)
+ {
+ int i;
+
+ for (i = 0; i < set->num; i++)
+ FcStrFree (set->strs[i]);
+ FcMemFree (FC_MEM_STRSET, (set->size) * sizeof (FcChar8 *));
+ if (set->strs)
+ free (set->strs);
+ FcMemFree (FC_MEM_STRSET, sizeof (FcStrSet));
+ free (set);
+ }
+}
+
+FcStrList *
+FcStrListCreate (FcStrSet *set)
+{
+ FcStrList *list;
+
+ list = malloc (sizeof (FcStrList));
+ if (!list)
+ return 0;
+ FcMemAlloc (FC_MEM_STRLIST, sizeof (FcStrList));
+ list->set = set;
+ set->ref++;
+ list->n = 0;
+ return list;
+}
+
+FcChar8 *
+FcStrListNext (FcStrList *list)
+{
+ if (list->n >= list->set->num)
+ return 0;
+ return list->set->strs[list->n++];
+}
+
+void
+FcStrListDone (FcStrList *list)
+{
+ FcStrSetDestroy (list->set);
+ FcMemFree (FC_MEM_STRLIST, sizeof (FcStrList));
+ free (list);
+}
git.wh0rd.org / fontconfig.git / blobdiff