X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffcstr.c;h=eaae935c5e68f2db2642ca0cffbe98cb84879dfe;hb=b5803016d74856eb44b05876f0d7178bfec0df47;hp=1391b6554dbc5dede8a737e839853114448d8108;hpb=cd2ec1a940888ebcbd323a8000d2fcced41ddf9e;p=fontconfig.git

diff --git a/src/fcstr.c b/src/fcstr.c
index 1391b65..eaae935 100644
--- a/src/fcstr.c
+++ b/src/fcstr.c
@@ -22,23 +22,28 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
+#include "fcint.h"
 #include <stdlib.h>
 #include <ctype.h>
 #include <string.h>
-#include "fcint.h"
+#ifdef _WIN32
+#include <windows.h>
+#endif
 
 FcChar8 *
 FcStrCopy (const FcChar8 *s)
 {
-    FcChar8	*r;
+    int     len;
+    FcChar8 *r;
 
     if (!s)
 	return 0;
-    r = (FcChar8 *) malloc (strlen ((char *) s) + 1);
+    len = strlen ((char *) s) + 1;
+    r = (FcChar8 *) malloc (len);
     if (!r)
 	return 0;
-    FcMemAlloc (FC_MEM_STRING, strlen ((char *) s) + 1);
-    strcpy ((char *) r, (char *) s);
+    FcMemAlloc (FC_MEM_STRING, len);
+    memcpy (r, s, len);
     return r;
 }
 
@@ -74,7 +79,6 @@ FcStrFree (FcChar8 *s)
 typedef struct _FcCaseWalker {
     const FcChar8   *read;
     const FcChar8   *src;
-    int		    len;
     FcChar8	    utf8[FC_MAX_CASE_FOLD_CHARS + 1];
 } FcCaseWalker;
 
@@ -83,7 +87,6 @@ FcStrCaseWalkerInit (const FcChar8 *src, FcCaseWalker *w)
 {
     w->src = src;
     w->read = 0;
-    w->len = strlen (src);
 }
 
 static FcChar8
@@ -91,8 +94,9 @@ FcStrCaseWalkerLong (FcCaseWalker *w, FcChar8 r)
 {
     FcChar32	ucs4;
     int		slen;
+    int		len = strlen((char*)w->src);
 
-    slen = FcUtf8ToUcs4 (w->src - 1, &ucs4, w->len + 1);
+    slen = FcUtf8ToUcs4 (w->src - 1, &ucs4, len + 1);
     if (slen <= 0)
 	return r;
     if (FC_MIN_FOLD_CHAR <= ucs4 && ucs4 <= FC_MAX_FOLD_CHAR)
@@ -131,7 +135,6 @@ FcStrCaseWalkerLong (FcCaseWalker *w, FcChar8 r)
 		
 		/* consume rest of src utf-8 bytes */
 		w->src += slen - 1;
-		w->len -= slen - 1;
 		
 		/* read from temp buffer */
 		w->utf8[dlen] = '\0';
@@ -155,7 +158,6 @@ FcStrCaseWalkerNext (FcCaseWalker *w)
 	w->read = 0;
     }
     r = *w->src++;
-    --w->len;
     
     if ((r & 0xc0) == 0xc0)
 	return FcStrCaseWalkerLong (w, r);
@@ -178,7 +180,6 @@ FcStrCaseWalkerNextIgnoreBlanks (FcCaseWalker *w)
     do
     {
 	r = *w->src++;
-	--w->len;
     } while (r == ' ');
     
     if ((r & 0xc0) == 0xc0)
@@ -453,8 +454,7 @@ again:
 	++ s1;
 	++ s2;
     }
-
-    return 0;
+    /* never reached. */
 }
 
 int
@@ -711,7 +711,7 @@ FcStrBufChar (FcStrBuf *buf, FcChar8 c)
 	}
 	else
 	{
-	    size = buf->size + 1024;
+	    size = buf->size + 64;
 	    new = malloc (size);
 	    if (new)
 	    {
@@ -767,26 +767,21 @@ FcStrCopyFilename (const FcChar8 *s)
     if (*s == '~')
     {
 	FcChar8	*home = FcConfigHome ();
+	FcChar8	*full;
 	int	size;
 	if (!home)
 	    return 0;
 	size = strlen ((char *) home) + strlen ((char *) s);
-	new = (FcChar8 *) malloc (size);
-	if (!new)
+	full = (FcChar8 *) malloc (size);
+	if (!full)
 	    return 0;
-	FcMemAlloc (FC_MEM_STRING, size);
-	strcpy ((char *) new, (char *) home);
-	strcat ((char *) new, (char *) s + 1);
+	strcpy ((char *) full, (char *) home);
+	strcat ((char *) full, (char *) s + 1);
+	new = FcStrCanonFilename (full);
+	free (full);
     }
     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);
-    }
+	new = FcStrCanonFilename (s);
     return new;
 }
 
@@ -838,75 +833,133 @@ FcStrBasename (const FcChar8 *file)
     return FcStrCopy (slash + 1);
 }
 
-FcStrSet *
-FcStrSetCreate (void)
+static FcChar8 *
+FcStrCanonAbsoluteFilename (const FcChar8 *s)
 {
-    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->storage = FcStorageDynamic;
-    set->u.strs = 0;
-    return set;
+    FcChar8 *file;
+    FcChar8 *f;
+    const FcChar8 *slash;
+    int size;
+
+    size = strlen ((char *) s) + 1;
+    file = malloc (size);
+    if (!file)
+	return NULL;
+    FcMemAlloc (FC_MEM_STRING, size);
+    slash = NULL;
+    f = file;
+    for (;;) {
+	if (*s == '/' || *s == '\0')
+	{
+	    if (slash)
+	    {
+		switch (s - slash) {
+		case 2:
+		    if (!strncmp ((char *) slash, "/.", 2))
+		    {
+			f -= 2;	/* trim /. from file */
+		    }
+		    break;
+		case 3:
+		    if (!strncmp ((char *) slash, "/..", 3))
+		    {
+			f -= 3;	/* trim /.. from file */
+			while (f > file) {
+			    if (*--f == '/')
+				break;
+			}
+		    }
+		    break;
+		}
+	    }
+	    slash = s;
+	}
+	if (!(*f++ = *s++))
+	    break;
+    }
+    return file;
 }
+ 
+#ifdef _WIN32
+/*
+ * Convert '\\' to '/' , remove double '/' 
+ */
+static void
+FcConvertDosPath (char *str)
+{
+  size_t len = strlen (str);
+  char *p = str;
+  char *dest = str;
+  char *end = str + len;
+  char last = 0;
+  
+  while (p < end)
+    {
+      if (*p == '\\')
+	*p = '/';
 
-static FcChar8 * strset_buf = 0; 
-static int strset_buf_ptr = 0, strset_buf_count = 0;
-static int * strset_idx = 0; 
-static int strset_idx_ptr = 0, strset_idx_count = 0;
-static FcStrSet * strsets = 0; 
-static int strset_ptr = 0, strset_count = 0;
+      if (*p != '/'
+	  || last != '/')
+	{
+	  *dest++ = *p;
+	}
 
-void FcStrSetClearStatic()
-{
-    strset_buf = 0; strset_buf_ptr = 0; strset_buf_count = 0;
-    strset_idx = 0; strset_idx_ptr = 0; strset_idx_count = 0;
-    strsets = 0; strset_ptr = 0; strset_count = 0;
+      last = *p;
+      p++;
+    }
+
+  *dest = 0;
 }
+#endif
 
 FcChar8 *
-FcStrSetGet (const FcStrSet *set, int i)
+FcStrCanonFilename (const FcChar8 *s)
 {
-    int index;
-    switch (set->storage)
+#ifdef _WIN32
+    FcChar8 full[FC_MAX_FILE_LEN + 2];
+    FcChar8 basename[FC_MAX_FILE_LEN + 2];
+    int size = GetFullPathName (s, sizeof (full) -1,
+				full,
+				basename);
+
+    if (size == 0)
+	perror ("GetFullPathName");
+
+    FcConvertDosPath (full);
+    return FcStrCanonAbsoluteFilename (full);
+#else
+    if (s[0] == '/')
+	return FcStrCanonAbsoluteFilename (s);
+    else
     {
-    case FcStorageStatic:
-	index = strset_idx[set->u.stridx_offset];
-	if (index == -1)
-	    return 0;
-	return &strset_buf[index];
-    case FcStorageDynamic:
-	return set->u.strs[i];
-    default:
-	return 0;
+	FcChar8	*full;
+	FcChar8 *file;
+
+	FcChar8	cwd[FC_MAX_FILE_LEN + 2];
+	if (getcwd ((char *) cwd, FC_MAX_FILE_LEN) == NULL)
+	    return NULL;
+	strcat ((char *) cwd, "/");
+	full = FcStrPlus (cwd, s);
+	file = FcStrCanonAbsoluteFilename (full);
+	FcStrFree (full);
+	return file;
     }
+#endif
 }
 
+
 FcStrSet *
-FcStrSetPtrU (const FcStrSetPtr set)
+FcStrSetCreate (void)
 {
-    switch (set.storage)
-    {
-    case FcStorageStatic:
-	return &strsets[set.u.stat];
-    case FcStorageDynamic:
-	return (FcStrSet *)set.u.dyn;
-    default:
+    FcStrSet	*set = malloc (sizeof (FcStrSet));
+    if (!set)
 	return 0;
-    }
-}
-
-FcStrSetPtr
-FcStrSetPtrCreateDynamic (const FcStrSet * set)
-{
-    FcStrSetPtr new;
-
-    new.storage = FcStorageDynamic;
-    new.u.dyn = (FcStrSet *)set;
-    return new;
+    FcMemAlloc (FC_MEM_STRSET, sizeof (FcStrSet));
+    set->ref = 1;
+    set->num = 0;
+    set->size = 0;
+    set->strs = 0;
+    return set;
 }
 
 static FcBool
@@ -917,7 +970,7 @@ _FcStrSetAppend (FcStrSet *set, FcChar8 *s)
 	FcStrFree (s);
 	return FcTrue;
     }
-    if (set->num == set->size || set->storage == FcStorageStatic)
+    if (set->num == set->size)
     {
 	FcChar8	**strs = malloc ((set->size + 2) * sizeof (FcChar8 *));
 
@@ -925,24 +978,14 @@ _FcStrSetAppend (FcStrSet *set, FcChar8 *s)
 	    return FcFalse;
 	FcMemAlloc (FC_MEM_STRSET, (set->size + 2) * sizeof (FcChar8 *));
 	set->size = set->size + 1;
-	if (set->storage == FcStorageDynamic)
-	{
-	    if (set->num)
-		memcpy (strs, set->u.strs, set->num * sizeof (FcChar8 *));
-	    if (set->u.strs)
-		free (set->u.strs);
-	}
-	else 
-	{
-	    if (set->num)
-		memcpy (strs, strset_idx+set->u.stridx_offset, 
-			set->num * sizeof (FcChar8 *));
-	    set->storage = FcStorageDynamic;
-	}
-	set->u.strs = strs;
+	if (set->num)
+	    memcpy (strs, set->strs, set->num * sizeof (FcChar8 *));
+	if (set->strs)
+	    free (set->strs);
+	set->strs = strs;
     }
-    set->u.strs[set->num++] = s;
-    set->u.strs[set->num] = 0;
+    set->strs[set->num++] = s;
+    set->strs[set->num] = 0;
     return FcTrue;
 }
 
@@ -952,7 +995,7 @@ FcStrSetMember (FcStrSet *set, const FcChar8 *s)
     int	i;
 
     for (i = 0; i < set->num; i++)
-	if (!FcStrCmp (FcStrSetGet(set, i), s))
+	if (!FcStrCmp (set->strs[i], s))
 	    return FcTrue;
     return FcFalse;
 }
@@ -964,7 +1007,7 @@ FcStrSetEqual (FcStrSet *sa, FcStrSet *sb)
     if (sa->num != sb->num)
 	return FcFalse;
     for (i = 0; i < sa->num; i++)
-	if (!FcStrSetMember (sb, FcStrSetGet(sa, i)))
+	if (!FcStrSetMember (sb, sa->strs[i]))
 	    return FcFalse;
     return FcTrue;
 }
@@ -1003,15 +1046,14 @@ FcStrSetDel (FcStrSet *set, const FcChar8 *s)
     int	i;
 
     for (i = 0; i < set->num; i++)
-	if (!FcStrCmp (FcStrSetGet(set, i), s))
+	if (!FcStrCmp (set->strs[i], s))
 	{
-	    if (set->storage == FcStorageDynamic)
-		FcStrFree (set->u.strs[i]);
+	    FcStrFree (set->strs[i]);
 	    /*
 	     * copy remaining string pointers and trailing
 	     * NULL
 	     */
-	    memmove (FcStrSetGet(set, i), FcStrSetGet(set, i+1),
+	    memmove (&set->strs[i], &set->strs[i+1], 
 		     (set->num - i) * sizeof (FcChar8 *));
 	    set->num--;
 	    return FcTrue;
@@ -1026,123 +1068,16 @@ FcStrSetDestroy (FcStrSet *set)
     {
 	int	i;
     
-	if (set->storage == FcStorageDynamic)
-	{
-	    for (i = 0; i < set->num; i++)
-		FcStrFree (set->u.strs[i]);
-	    FcMemFree (FC_MEM_STRSET, (set->size) * sizeof (FcChar8 *));
-	    if (set->u.strs)
-		free (set->u.strs);
-	    FcMemFree (FC_MEM_STRSET, sizeof (FcStrSet));
-	}
+	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);
     }
 }
 
-static int _FcStrSetSort_helper (const void * a, const void * b)
-{
-    return FcStrCmp (&strset_buf[(int)a], 
-		     &strset_buf[(int)b]);
-}
-
-void
-FcStrSetSort (FcStrSet * set)
-{
-    switch (set->storage)
-    {
-    case FcStorageDynamic:
-	qsort (set->u.strs, set->num, sizeof (FcChar8 *), 
-	       (int (*)(const void *, const void *)) FcStrCmp);
-	break;
-    case FcStorageStatic:
-	qsort (strset_idx+set->u.stridx_offset, set->num, sizeof (int), 
-	       _FcStrSetSort_helper);
-	break;
-    default:
-	break;
-    }
-}
-
-FcBool
-FcStrSetPrepareSerialize (const FcStrSet *set)
-{
-    int i;
-
-    if (!set)
-	return FcTrue;
-
-    strset_count ++;
-    strset_idx_count += set->num;
-    for (i = 0; i < set->num; i++)
-    {
-	if (FcStrSetGet(set, i))
-	    strset_buf_count += strlen(FcStrSetGet(set, i));
-    }
-
-    return FcTrue;
-}
-
-FcStrSetPtr
-FcStrSetSerialize (FcStrSet *set)
-{
-    FcStrSet * new;
-    FcStrSetPtr newp;
-    int i;
-
-    if (!strsets)
-    {
-	strsets = malloc (strset_count * sizeof(FcStrSet));
-	if (!strsets) goto bail1;
-	strset_idx = malloc (strset_idx_count * sizeof(int));
-	if (!strset_idx) goto bail2;
-	strset_buf = malloc (strset_buf_count * sizeof (FcChar8));
-	if (!strset_buf) goto bail3;
-    }
-
-    if (!set)
-	return FcStrSetPtrCreateDynamic(0);
-
-    newp.storage = FcStorageStatic;
-    newp.u.stat = strset_ptr;
-
-    new = &strsets[strset_ptr++];
-    new->ref = set->ref;
-    new->num = set->num;
-    new->size = set->num;
-    new->storage = FcStorageStatic;
-    new->u.stridx_offset = strset_idx_ptr;
-    for (i = 0; i < set->num; i++)
-    {
-	FcChar8 * s = FcStrSetGet(set, i);
-
-	if (s)
-	{
-	    memcpy(strset_buf+strset_buf_ptr, s,
-		   strlen((char *)s));
-	    strset_idx[strset_idx_ptr++] = strset_buf_ptr;
-	    strset_buf_ptr += strlen((char *)s)+1;
-	}
-	else
-	    strset_idx[strset_idx_ptr++] = -1;
-    }
-
-    if (strset_ptr > strset_count || strset_idx_ptr > strset_idx_count)
-	return FcStrSetPtrCreateDynamic(0);
-
-    // problem with multiple ptrs to the same LangSet.
-    // should hash LangSets or something.
-    // FcStrSetDestroy (set);
-
-    return newp;
-
- bail3:
-    free (strset_idx);
- bail2:
-    free (strsets);
- bail1:
-    return FcStrSetPtrCreateDynamic(0);
-}
-
 FcStrList *
 FcStrListCreate (FcStrSet *set)
 {
@@ -1163,7 +1098,7 @@ FcStrListNext (FcStrList *list)
 {
     if (list->n >= list->set->num)
 	return 0;
-    return FcStrSetGet(list->set, list->n++);
+    return list->set->strs[list->n++];
 }
 
 void
@@ -1173,3 +1108,7 @@ FcStrListDone (FcStrList *list)
     FcMemFree (FC_MEM_STRLIST, sizeof (FcStrList));
     free (list);
 }
+
+#define __fcstr__
+#include "fcaliastail.h"
+#undef __fcstr__