/*
- * $RCSId: xc/lib/fontconfig/src/fcstr.c,v 1.10 2002/08/31 22:17:32 keithp Exp $
+ * fontconfig/src/fcstr.c
*
* Copyright © 2000 Keith Packard
*
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
+ * documentation, and that the name of the author(s) not be used in
* advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission. Keith Packard makes no
+ * specific, written prior permission. The authors make no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
FcChar8 *
FcStrCopy (const FcChar8 *s)
int mid = (min + max) >> 1;
FcChar32 low = fcCaseFold[mid].upper;
FcChar32 high = low + FcCaseFoldUpperCount (&fcCaseFold[mid]);
-
+
if (high <= ucs4)
min = mid + 1;
else if (ucs4 < low)
w->read = 0;
}
r = *w->src++;
-
+
if ((r & 0xc0) == 0xc0)
return FcStrCaseWalkerLong (w, r);
if ('A' <= r && r <= 'Z')
{
r = *w->src++;
} while (r == ' ');
-
+
if ((r & 0xc0) == 0xc0)
return FcStrCaseWalkerLong (w, r);
if ('A' <= r && r <= 'Z')
FcChar8 c1, c2;
if (s1 == s2) return 0;
-
+
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
-
- for (;;)
+
+ for (;;)
{
c1 = FcStrCaseWalkerNext (&w1);
c2 = FcStrCaseWalkerNext (&w2);
FcChar8 c1, c2;
if (s1 == s2) return 0;
-
+
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
-
- for (;;)
+
+ for (;;)
{
c1 = FcStrCaseWalkerNextIgnoreBlanks (&w1);
c2 = FcStrCaseWalkerNextIgnoreBlanks (&w2);
FcStrCmp (const FcChar8 *s1, const FcChar8 *s2)
{
FcChar8 c1, c2;
-
+
if (s1 == s2)
return 0;
- for (;;)
+ for (;;)
{
c1 = *s1++;
c2 = *s2++;
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
-
- for (;;)
+
+ for (;;)
{
c1 = FcStrCaseWalkerNextIgnoreBlanks (&w1);
c2 = FcStrCaseWalkerNextIgnoreBlanks (&w2);
return 0;
}
+static FcBool
+FcCharIsPunct (const FcChar8 c)
+{
+ if (c < '0')
+ return FcTrue;
+ if (c <= '9')
+ return FcFalse;
+ if (c < 'A')
+ return FcTrue;
+ if (c <= 'Z')
+ return FcFalse;
+ if (c < 'a')
+ return FcTrue;
+ if (c <= 'z')
+ return FcFalse;
+ if (c <= '~')
+ return FcTrue;
+ return FcFalse;
+}
+
/*
* Is the head of s1 equal to s2?
*/
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
-
- for (;;)
+
+ for (;;)
{
c1 = FcStrCaseWalkerNext (&w1);
c2 = FcStrCaseWalkerNext (&w2);
return 0;
}
+/*
+ * Does s1 contain an instance of s2 on a word boundary (ignoring case)?
+ */
+
+const FcChar8 *
+FcStrContainsWord (const FcChar8 *s1, const FcChar8 *s2)
+{
+ FcBool wordStart = FcTrue;
+ int s1len = strlen ((char *) s1);
+ int s2len = strlen ((char *) s2);
+
+ while (s1len >= s2len)
+ {
+ if (wordStart &&
+ FcStrIsAtIgnoreCase (s1, s2) &&
+ (s1len == s2len || FcCharIsPunct (s1[s2len])))
+ {
+ return s1;
+ }
+ wordStart = FcFalse;
+ if (FcCharIsPunct (*s1))
+ wordStart = FcTrue;
+ s1++;
+ s1len--;
+ }
+ return 0;
+}
+
const FcChar8 *
FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
{
if (s1 == s2)
return s1;
-
+
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
-
+
c2 = FcStrCaseWalkerNext (&w2);
-
+
for (;;)
{
cur = w1.src;
if (!c2)
return 0;
- for (;;)
+ for (;;)
{
p = s1;
c1 = *s1++;
if (len == 0)
return 0;
-
+
s = *src++;
len--;
-
+
if (!(s & 0x80))
{
result = s;
extra = 0;
- }
+ }
else if (!(s & 0x40))
{
return -1;
}
if (extra > len)
return -1;
-
+
while (extra--)
{
result <<= 6;
int clen;
FcChar32 c;
FcChar32 max;
-
+
n = 0;
max = 0;
while (len)
{
int bits;
FcChar8 *d = dest;
-
+
if (ucs4 < 0x80) { *d++= ucs4; bits= -6; }
else if (ucs4 < 0x800) { *d++= ((ucs4 >> 6) & 0x1F) | 0xC0; bits= 0; }
else if (ucs4 < 0x10000) { *d++= ((ucs4 >> 12) & 0x0F) | 0xE0; bits= 6; }
if (len < 2)
return 0;
-
+
a = GetUtf16 (src, endian); src += 2; len -= 2;
-
- /*
- * Check for surrogate
+
+ /*
+ * Check for surrogate
*/
if ((a & 0xfc00) == 0xd800)
{
int clen;
FcChar32 c;
FcChar32 max;
-
+
n = 0;
max = 0;
while (len)
void
FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size)
{
- buf->buf = init;
+ if (init)
+ {
+ buf->buf = init;
+ buf->size = size;
+ } else
+ {
+ buf->buf = buf->buf_static;
+ buf->size = sizeof (buf->buf_static);
+ }
buf->allocated = FcFalse;
buf->failed = FcFalse;
buf->len = 0;
- buf->size = size;
}
void
{
FcChar8 *ret;
- ret = malloc (buf->len + 1);
+ if (buf->failed)
+ ret = NULL;
+ else
+ ret = malloc (buf->len + 1);
if (ret)
{
FcMemAlloc (FC_MEM_STRING, buf->len + 1);
return ret;
}
+FcChar8 *
+FcStrBufDoneStatic (FcStrBuf *buf)
+{
+ FcStrBufChar (buf, '\0');
+
+ if (buf->failed)
+ return NULL;
+
+ return buf->buf;
+}
+
FcBool
FcStrBufChar (FcStrBuf *buf, FcChar8 c)
{
FcChar8 *new;
int size;
+ if (buf->failed)
+ return FcFalse;
+
if (buf->allocated)
{
size = buf->size * 2;
FcStrCopyFilename (const FcChar8 *s)
{
FcChar8 *new;
-
+
if (*s == '~')
{
FcChar8 *home = FcConfigHome ();
return slash;
}
-
+
FcChar8 *
FcStrDirname (const FcChar8 *file)
{
return FcStrCopy (slash + 1);
}
-FcChar8 *
-FcStrCanonFilename (const FcChar8 *s)
+static FcChar8 *
+FcStrCanonAbsoluteFilename (const FcChar8 *s)
{
FcChar8 *file;
FcChar8 *f;
const FcChar8 *slash;
int size;
-
- if (*s != '/')
- {
- FcChar8 *full;
-
- 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 = FcStrCanonFilename (full);
- FcStrFree (full);
- return file;
- }
+
size = strlen ((char *) s) + 1;
file = malloc (size);
if (!file)
if (slash)
{
switch (s - slash) {
+ case 1:
+ f -= 1; /* squash // and trim final / from file */
+ break;
case 2:
if (!strncmp ((char *) slash, "/.", 2))
{
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;
+
+ if (*p == '\\')
+ {
+ *p = '/';
+ p++;
+ dest++;
+ }
+ while (p < end)
+ {
+ if (*p == '\\')
+ *p = '/';
+
+ if (*p != '/'
+ || last != '/')
+ {
+ *dest++ = *p;
+ }
+
+ last = *p;
+ p++;
+ }
+
+ *dest = 0;
+}
+#endif
+
+FcChar8 *
+FcStrCanonFilename (const FcChar8 *s)
+{
+#ifdef _WIN32
+ FcChar8 full[FC_MAX_FILE_LEN + 2];
+ int size = GetFullPathName (s, sizeof (full) -1,
+ full, NULL);
+
+ if (size == 0)
+ perror ("GetFullPathName");
+
+ FcConvertDosPath (full);
+ return FcStrCanonAbsoluteFilename (full);
+#else
+ if (s[0] == '/')
+ return FcStrCanonAbsoluteFilename (s);
+ else
+ {
+ 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 *
FcStrSetCreate (void)
{
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)
+ {
+ FcMemFree (FC_MEM_STRSET, (set->size + 1) * sizeof (FcChar8 *));
free (set->strs);
+ }
+ set->size = set->size + 1;
set->strs = strs;
}
set->strs[set->num++] = s;
* copy remaining string pointers and trailing
* NULL
*/
- memmove (&set->strs[i], &set->strs[i+1],
+ memmove (&set->strs[i], &set->strs[i+1],
(set->num - i) * sizeof (FcChar8 *));
set->num--;
return FcTrue;
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)
+ {
+ FcMemFree (FC_MEM_STRSET, (set->size + 1) * sizeof (FcChar8 *));
free (set->strs);
+ }
FcMemFree (FC_MEM_STRSET, sizeof (FcStrSet));
free (set);
}
free (list);
}
+#define __fcstr__
+#include "fcaliastail.h"
+#undef __fcstr__