walkero
/
fontconfig
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
fontconfig/src/fcstr.c

1549 lines
27 KiB
C
Raw Blame History

/*
* fontconfig/src/fcstr.c
*
* Copyright © 2000 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* 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 the author(s) not be used in
* advertising or publicity pertaining to distribution of the software without
* 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.
*
* THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* 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
* PERFORMANCE OF THIS SOFTWARE.
*/
#include "fcint.h"
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
/* Objects MT-safe for readonly access. */
FcChar8 *
FcStrCopy (const FcChar8 *s)
{
return FcStrdup (s);
}
static FcChar8 *
FcStrMakeTriple (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 *s3)
{
int s1l = s1 ? strlen ((char *) s1) : 0;
int s2l = s2 ? strlen ((char *) s2) : 0;
int s3l = s3 ? strlen ((char *) s3) : 0;
int l = s1l + 1 + s2l + 1 + s3l + 1;
FcChar8 *s = malloc (l);
if (!s)
return 0;
if (s1)
memcpy (s, s1, s1l + 1);
else
s[0] = '\0';
if (s2)
memcpy (s + s1l + 1, s2, s2l + 1);
else
s[s1l + 1] = '\0';
if (s3)
memcpy (s + s1l + 1 + s2l + 1, s3, s3l + 1);
else
s[s1l + 1 + s2l + 1] = '\0';
return s;
}
FcChar8 *
FcStrPlus (const FcChar8 *s1, const FcChar8 *s2)
{
int s1l = strlen ((char *) s1);
int s2l = strlen ((char *) s2);
int l = s1l + s2l + 1;
FcChar8 *s = malloc (l);
if (!s)
return 0;
memcpy (s, s1, s1l);
memcpy (s + s1l, s2, s2l + 1);
return s;
}
void
FcStrFree (FcChar8 *s)
{
free (s);
}
#include "../fc-case/fccase.h"
#define FcCaseFoldUpperCount(cf) \
((cf)->method == FC_CASE_FOLD_FULL ? 1 : (cf)->count)
typedef struct _FcCaseWalker {
const FcChar8 *read;
const FcChar8 *src;
FcChar8 utf8[FC_MAX_CASE_FOLD_CHARS + 1];
} FcCaseWalker;
static void
FcStrCaseWalkerInit (const FcChar8 *src, FcCaseWalker *w)
{
w->src = src;
w->read = 0;
}
static FcChar8
FcStrCaseWalkerLong (FcCaseWalker *w, FcChar8 r)
{
FcChar32 ucs4;
int slen;
int len = strlen((char*)w->src);
slen = FcUtf8ToUcs4 (w->src - 1, &ucs4, len + 1);
if (slen <= 0)
return r;
if (FC_MIN_FOLD_CHAR <= ucs4 && ucs4 <= FC_MAX_FOLD_CHAR)
{
int min = 0;
int max = FC_NUM_CASE_FOLD;
while (min <= max)
{
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)
max = mid - 1;
else
{
const FcCaseFold *fold = &fcCaseFold[mid];
int dlen;
switch (fold->method) {
case FC_CASE_FOLD_EVEN_ODD:
if ((ucs4 & 1) != (fold->upper & 1))
return r;
/* fall through ... */
default:
dlen = FcUcs4ToUtf8 (ucs4 + fold->offset, w->utf8);
break;
case FC_CASE_FOLD_FULL:
dlen = fold->count;
memcpy (w->utf8, fcCaseFoldChars + fold->offset, dlen);
break;
}
/* consume rest of src utf-8 bytes */
w->src += slen - 1;
/* read from temp buffer */
w->utf8[dlen] = '\0';
w->read = w->utf8;
return *w->read++;
}
}
}
return r;
}
static FcChar8
FcStrCaseWalkerNext (FcCaseWalker *w, const char *delims)
{
FcChar8 r;
if (w->read)
{
if ((r = *w->read++))
return r;
w->read = 0;
}
do
{
r = *w->src++;
} while (r != 0 && delims && strchr (delims, r));
if ((r & 0xc0) == 0xc0)
return FcStrCaseWalkerLong (w, r);
if ('A' <= r && r <= 'Z')
r = r - 'A' + 'a';
return r;
}
FcChar8 *
FcStrDowncase (const FcChar8 *s)
{
FcCaseWalker w;
int len = 0;
FcChar8 *dst, *d;
FcStrCaseWalkerInit (s, &w);
while (FcStrCaseWalkerNext (&w, NULL))
len++;
d = dst = malloc (len + 1);
if (!d)
return 0;
FcStrCaseWalkerInit (s, &w);
while ((*d++ = FcStrCaseWalkerNext (&w, NULL)));
return dst;
}
int
FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
{
FcCaseWalker w1, w2;
FcChar8 c1, c2;
if (s1 == s2) return 0;
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
for (;;)
{
c1 = FcStrCaseWalkerNext (&w1, NULL);
c2 = FcStrCaseWalkerNext (&w2, NULL);
if (!c1 || (c1 != c2))
break;
}
return (int) c1 - (int) c2;
}
int
FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)
{
return FcStrCmpIgnoreCaseAndDelims (s1, s2, (const FcChar8 *)" ");
}
int
FcStrCmpIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 *delims)
{
FcCaseWalker w1, w2;
FcChar8 c1, c2;
if (s1 == s2) return 0;
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
for (;;)
{
c1 = FcStrCaseWalkerNext (&w1, (const char *)delims);
c2 = FcStrCaseWalkerNext (&w2, (const char *)delims);
if (!c1 || (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 || c1 != c2)
break;
}
return (int) c1 - (int) c2;
}
/*
* Return a hash value for a string
*/
FcChar32
FcStrHashIgnoreCase (const FcChar8 *s)
{
FcChar32 h = 0;
FcCaseWalker w;
FcChar8 c;
FcStrCaseWalkerInit (s, &w);
while ((c = FcStrCaseWalkerNext (&w, NULL)))
h = ((h << 3) ^ (h >> 3)) ^ c;
return h;
}
/*
* Is the head of s1 equal to s2?
*/
static FcBool
FcStrIsAtIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)
{
FcCaseWalker w1, w2;
FcChar8 c1, c2;
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
for (;;)
{
c1 = FcStrCaseWalkerNext (&w1, " ");
c2 = FcStrCaseWalkerNext (&w2, " ");
if (!c1 || (c1 != c2))
break;
}
return c1 == c2 || !c2;
}
/*
* Does s1 contain an instance of s2 (ignoring blanks and case)?
*/
const FcChar8 *
FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)
{
while (*s1)
{
if (FcStrIsAtIgnoreBlanksAndCase (s1, s2))
return s1;
s1++;
}
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?
*/
static FcBool
FcStrIsAtIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
{
FcCaseWalker w1, w2;
FcChar8 c1, c2;
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
for (;;)
{
c1 = FcStrCaseWalkerNext (&w1, NULL);
c2 = FcStrCaseWalkerNext (&w2, NULL);
if (!c1 || (c1 != c2))
break;
}
return c1 == c2 || !c2;
}
/*
* Does s1 contain an instance of s2 (ignoring blanks and case)?
*/
const FcChar8 *
FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
{
while (*s1)
{
if (FcStrIsAtIgnoreCase (s1, s2))
return s1;
s1++;
}
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;
}
/*
* returns the number of strings (ignoring delimiters and case) being matched
*/
int
FcStrMatchIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 *delims)
{
FcCaseWalker w1, w2;
FcChar8 c1, c2;
if (s1 == s2) return 0;
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
for (;;)
{
c1 = FcStrCaseWalkerNext (&w1, (const char *)delims);
c2 = FcStrCaseWalkerNext (&w2, (const char *)delims);
if (!c1 || (c1 != c2))
break;
}
return w1.src - s1 - 1;
}
FcBool
FcStrGlobMatch (const FcChar8 *glob,
const FcChar8 *string)
{
FcChar8 c;
while ((c = *glob++))
{
switch (c) {
case '*':
/* short circuit common case */
if (!*glob)
return FcTrue;
/* short circuit another common case */
if (strchr ((char *) glob, '*') == 0)
{
size_t l1, l2;
l1 = strlen ((char *) string);
l2 = strlen ((char *) glob);
if (l1 < l2)
return FcFalse;
string += (l1 - l2);
}
while (*string)
{
if (FcStrGlobMatch (glob, string))
return FcTrue;
string++;
}
return FcFalse;
case '?':
if (*string++ == '\0')
return FcFalse;
break;
default:
if (*string++ != c)
return FcFalse;
break;
}
}
return *string == '\0';
}
const FcChar8 *
FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
{
FcCaseWalker w1, w2;
FcChar8 c1, c2;
const FcChar8 *cur;
if (!s1 || !s2)
return 0;
if (s1 == s2)
return s1;
FcStrCaseWalkerInit (s1, &w1);
FcStrCaseWalkerInit (s2, &w2);
c2 = FcStrCaseWalkerNext (&w2, NULL);
for (;;)
{
cur = w1.src;
c1 = FcStrCaseWalkerNext (&w1, NULL);
if (!c1)
break;
if (c1 == c2)
{
FcCaseWalker w1t = w1;
FcCaseWalker w2t = w2;
FcChar8 c1t, c2t;
for (;;)
{
c1t = FcStrCaseWalkerNext (&w1t, NULL);
c2t = FcStrCaseWalkerNext (&w2t, NULL);
if (!c2t)
return cur;
if (c2t != c1t)
break;
}
}
}
return 0;
}
const FcChar8 *
FcStrStr (const FcChar8 *s1, const FcChar8 *s2)
{
FcChar8 c1, c2;
const FcChar8 * p = s1;
const FcChar8 * b = s2;
if (!s1 || !s2)
return 0;
if (s1 == s2)
return s1;
again:
c2 = *s2++;
if (!c2)
return 0;
for (;;)
{
p = s1;
c1 = *s1++;
if (!c1 || c1 == c2)
break;
}
if (c1 != c2)
return 0;
for (;;)
{
c1 = *s1;
c2 = *s2;
if (c1 && c2 && c1 != c2)
{
s1 = p + 1;
s2 = b;
goto again;
}
if (!c2)
return p;
if (!c1)
return 0;
++ s1;
++ s2;
}
/* never reached. */
}
int
FcUtf8ToUcs4 (const FcChar8 *src_orig,
FcChar32 *dst,
int len)
{
const FcChar8 *src = src_orig;
FcChar8 s;
int extra;
FcChar32 result;
if (len == 0)
return 0;
s = *src++;
len--;
if (!(s & 0x80))
{
result = s;
extra = 0;
}
else if (!(s & 0x40))
{
return -1;
}
else if (!(s & 0x20))
{
result = s & 0x1f;
extra = 1;
}
else if (!(s & 0x10))
{
result = s & 0xf;
extra = 2;
}
else if (!(s & 0x08))
{
result = s & 0x07;
extra = 3;
}
else if (!(s & 0x04))
{
result = s & 0x03;
extra = 4;
}
else if ( ! (s & 0x02))
{
result = s & 0x01;
extra = 5;
}
else
{
return -1;
}
if (extra > len)
return -1;
while (extra--)
{
result <<= 6;
s = *src++;
if ((s & 0xc0) != 0x80)
return -1;
result |= s & 0x3f;
}
*dst = result;
return src - src_orig;
}
FcBool
FcUtf8Len (const FcChar8 *string,
int len,
int *nchar,
int *wchar)
{
int n;
int clen;
FcChar32 c;
FcChar32 max;
n = 0;
max = 0;
while (len)
{
clen = FcUtf8ToUcs4 (string, &c, len);
if (clen <= 0) /* malformed UTF8 string */
return FcFalse;
if (c > max)
max = c;
string += clen;
len -= clen;
n++;
}
*nchar = n;
if (max >= 0x10000)
*wchar = 4;
else if (max > 0x100)
*wchar = 2;
else
*wchar = 1;
return FcTrue;
}
int
FcUcs4ToUtf8 (FcChar32 ucs4,
FcChar8 dest[FC_UTF8_MAX_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; }
else if (ucs4 < 0x200000) { *d++= ((ucs4 >> 18) & 0x07) | 0xF0; bits= 12; }
else if (ucs4 < 0x4000000) { *d++= ((ucs4 >> 24) & 0x03) | 0xF8; bits= 18; }
else if (ucs4 < 0x80000000) { *d++= ((ucs4 >> 30) & 0x01) | 0xFC; bits= 24; }
else return 0;
for ( ; bits >= 0; bits-= 6) {
*d++= ((ucs4 >> bits) & 0x3F) | 0x80;
}
return d - dest;
}
#define GetUtf16(src,endian) \
((FcChar16) ((src)[endian == FcEndianBig ? 0 : 1] << 8) | \
(FcChar16) ((src)[endian == FcEndianBig ? 1 : 0]))
int
FcUtf16ToUcs4 (const FcChar8 *src_orig,
FcEndian endian,
FcChar32 *dst,
int len) /* in bytes */
{
const FcChar8 *src = src_orig;
FcChar16 a, b;
FcChar32 result;
if (len < 2)
return 0;
a = GetUtf16 (src, endian); src += 2; len -= 2;
/*
* Check for surrogate
*/
if ((a & 0xfc00) == 0xd800)
{
if (len < 2)
return 0;
b = GetUtf16 (src, endian); src += 2; len -= 2;
/*
* Check for invalid surrogate sequence
*/
if ((b & 0xfc00) != 0xdc00)
return 0;
result = ((((FcChar32) a & 0x3ff) << 10) |
((FcChar32) b & 0x3ff)) + 0x10000;
}
else
result = a;
*dst = result;
return src - src_orig;
}
FcBool
FcUtf16Len (const FcChar8 *string,
FcEndian endian,
int len, /* in bytes */
int *nchar,
int *wchar)
{
int n;
int clen;
FcChar32 c;
FcChar32 max;
n = 0;
max = 0;
while (len)
{
clen = FcUtf16ToUcs4 (string, endian, &c, len);
if (clen <= 0) /* malformed UTF8 string */
return FcFalse;
if (c > max)
max = c;
string += clen;
len -= clen;
n++;
}
*nchar = n;
if (max >= 0x10000)
*wchar = 4;
else if (max > 0x100)
*wchar = 2;
else
*wchar = 1;
return FcTrue;
}
void
FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size)
{
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;
}
void
FcStrBufDestroy (FcStrBuf *buf)
{
if (buf->allocated)
{
free (buf->buf);
FcStrBufInit (buf, 0, 0);
}
}
FcChar8 *
FcStrBufDone (FcStrBuf *buf)
{
FcChar8 *ret;
if (buf->failed)
ret = NULL;
else
ret = malloc (buf->len + 1);
if (ret)
{
memcpy (ret, buf->buf, buf->len);
ret[buf->len] = '\0';
}
FcStrBufDestroy (buf);
return ret;
}
FcChar8 *
FcStrBufDoneStatic (FcStrBuf *buf)
{
FcStrBufChar (buf, '\0');
if (buf->failed)
return NULL;
return buf->buf;
}
FcBool
FcStrBufChar (FcStrBuf *buf, FcChar8 c)
{
if (buf->len == buf->size)
{
FcChar8 *new;
int size;
if (buf->failed)
return FcFalse;
if (buf->allocated)
{
size = buf->size * 2;
new = realloc (buf->buf, size);
}
else
{
size = buf->size + 64;
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;
}
FcBool
FcStrUsesHome (const FcChar8 *s)
{
return *s == '~';
}
FcBool
FcStrIsAbsoluteFilename (const FcChar8 *s)
{
#ifdef _WIN32
if (*s == '\\' ||
(isalpha (*s) && s[1] == ':' && (s[2] == '/' || s[2] == '\\')))
return FcTrue;
#endif
return *s == '/';
}
FcChar8 *
FcStrBuildFilename (const FcChar8 *path,
...)
{
va_list ap;
FcStrSet *sset;
FcStrList *list;
FcChar8 *s, *ret = NULL, *p;
size_t len = 0;
if (!path)
return NULL;
sset = FcStrSetCreateEx (FCSS_ALLOW_DUPLICATES | FCSS_GROW_BY_64);
if (!sset)
return NULL;
if (!FcStrSetAdd (sset, path))
goto bail0;
va_start (ap, path);
while (1)
{
s = (FcChar8 *)va_arg (ap, FcChar8 *);
if (!s)
break;
if (!FcStrSetAdd (sset, s))
goto bail1;
}
list = FcStrListCreate (sset);
while ((s = FcStrListNext (list)))
{
len += strlen ((const char *)s) + 1;
}
list->n = 0;
ret = malloc (sizeof (FcChar8) * (len + 1));
if (!ret)
goto bail2;
p = ret;
while ((s = FcStrListNext (list)))
{
if (p != ret)
{
p[0] = FC_DIR_SEPARATOR;
p++;
}
len = strlen ((const char *)s);
memcpy (p, s, len);
p += len;
}
*p = 0;
bail2:
FcStrListDone (list);
bail1:
va_end (ap);
bail0:
FcStrSetDestroy (sset);
return ret;
}
FcChar8 *
FcStrCopyFilename (const FcChar8 *s)
{
FcChar8 *new;
if (*s == '~')
{
FcChar8 *home = FcConfigHome ();
FcChar8 *full;
int size;
if (!home)
return NULL;
size = strlen ((char *) home) + strlen ((char *) s);
full = (FcChar8 *) malloc (size + 1);
if (!full)
return NULL;
strcpy ((char *) full, (char *) home);
strcat ((char *) full, (char *) s + 1);
new = FcStrCanonFilename (full);
free (full);
}
else
new = FcStrCanonFilename (s);
return new;
}
FcChar8 *
FcStrLastSlash (const FcChar8 *path)
{
FcChar8 *slash;
slash = (FcChar8 *) strrchr ((const char *) path, '/');
#ifdef _WIN32
{
FcChar8 *backslash;
backslash = (FcChar8 *) strrchr ((const char *) path, '\\');
if (!slash || (backslash && backslash > slash))
slash = backslash;
}
#endif
return slash;
}
FcChar8 *
FcStrDirname (const FcChar8 *file)
{
FcChar8 *slash;
FcChar8 *dir;
slash = FcStrLastSlash (file);
if (!slash)
return FcStrCopy ((FcChar8 *) ".");
dir = malloc ((slash - file) + 1);
if (!dir)
return 0;
strncpy ((char *) dir, (const char *) file, slash - file);
dir[slash - file] = '\0';
return dir;
}
FcChar8 *
FcStrBasename (const FcChar8 *file)
{
FcChar8 *slash;
slash = FcStrLastSlash (file);
if (!slash)
return FcStrCopy (file);
return FcStrCopy (slash + 1);
}
static FcChar8 *
FcStrCanonAbsoluteFilename (const FcChar8 *s)
{
FcChar8 *file;
FcChar8 *f;
const FcChar8 *slash;
int size;
size = strlen ((char *) s) + 1;
file = malloc (size);
if (!file)
return NULL;
slash = NULL;
f = file;
#ifdef _WIN32
if (*s == '/' && *(s+1) == '/') /* Network path, do not squash // */
*f++ = *s++;
#endif
for (;;) {
if (*s == '/' || *s == '\0')
{
if (slash)
{
switch (s - slash) {
case 1:
f -= 1; /* squash // and trim final / from file */
break;
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;
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 ((LPCSTR) s, sizeof (full) -1,
(LPSTR) full, NULL);
if (size == 0)
perror ("GetFullPathName");
FcConvertDosPath ((char *) 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;
full = FcStrBuildFilename (cwd, s, NULL);
file = FcStrCanonAbsoluteFilename (full);
FcStrFree (full);
return file;
}
#endif
}
FcStrSet *
FcStrSetCreate (void)
{
return FcStrSetCreateEx (FCSS_DEFAULT);
}
FcStrSet *
FcStrSetCreateEx (unsigned int control)
{
FcStrSet *set = malloc (sizeof (FcStrSet));
if (!set)
return 0;
FcRefInit (&set->ref, 1);
set->num = 0;
set->size = 0;
set->strs = 0;
set->control = control;
return set;
}
static FcBool
_FcStrSetGrow (FcStrSet *set, int growElements)
{
/* accommodate an additional NULL entry at the end of the array */
FcChar8 **strs = malloc ((set->size + growElements + 1) * sizeof (FcChar8 *));
if (!strs)
return FcFalse;
if (set->num)
memcpy (strs, set->strs, set->num * sizeof (FcChar8 *));
if (set->strs)
free (set->strs);
set->size = set->size + growElements;
set->strs = strs;
return FcTrue;
}
static FcBool
_FcStrSetAppend (FcStrSet *set, FcChar8 *s)
{
if (!FcStrSetHasControlBit (set, FCSS_ALLOW_DUPLICATES))
{
if (FcStrSetMember (set, s))
{
FcStrFree (s);
return FcTrue;
}
}
if (set->num == set->size)
{
int growElements = FcStrSetHasControlBit (set, FCSS_GROW_BY_64) ? 64 : 1;
if (!_FcStrSetGrow(set, growElements))
return FcFalse;
}
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;
}
static int
fc_strcmp_r (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 **ret)
{
FcChar8 c1, c2;
if (s1 == s2)
{
if (ret)
*ret = NULL;
return 0;
}
for (;;)
{
if (s1)
c1 = *s1++;
else
c1 = 0;
if (s2)
c2 = *s2++;
else
c2 = 0;
if (!c1 || c1 != c2)
break;
}
if (ret)
*ret = s1;
return (int) c1 - (int) c2;
}
FcBool
FcStrSetMemberAB (FcStrSet *set, const FcChar8 *a, FcChar8 *b, FcChar8 **ret)
{
int i;
const FcChar8 *s = NULL;
for (i = 0; i < set->num; i++)
{
if (!fc_strcmp_r (set->strs[i], a, &s) && s)
{
if (!fc_strcmp_r (s, b, NULL))
{
if (ret)
*ret = set->strs[i];
return FcTrue;
}
}
}
if (ret)
*ret = NULL;
return FcFalse;
}
FcBool
FcStrSetEqual (FcStrSet *sa, FcStrSet *sb)
{
int i;
if (sa->num != sb->num)
return FcFalse;
for (i = 0; i < sa->num; i++)
if (!FcStrSetMember (sb, sa->strs[i]))
return FcFalse;
return FcTrue;
}
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
FcStrSetAddTriple (FcStrSet *set, const FcChar8 *a, const FcChar8 *b, const FcChar8 *c)
{
FcChar8 *new = FcStrMakeTriple (a, b, c);
if (!new)
return FcFalse;
if (!_FcStrSetAppend (set, new))
{
FcStrFree (new);
return FcFalse;
}
return FcTrue;
}
const FcChar8 *
FcStrTripleSecond (FcChar8 *str)
{
FcChar8 *second = str + strlen((char *) str) + 1;
if (*second == '\0')
return 0;
return second;
}
const FcChar8 *
FcStrTripleThird (FcChar8 *str)
{
FcChar8 *second = str + strlen ((char *) str) + 1;
FcChar8 *third = second + strlen ((char *) second) + 1;
if (*third == '\0')
return 0;
return third;
}
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
FcStrSetAddFilenamePairWithSalt (FcStrSet *set, const FcChar8 *a, const FcChar8 *b, const FcChar8 *salt)
{
FcChar8 *new_a = NULL;
FcChar8 *new_b = NULL;
FcChar8 *rs = NULL;
FcBool ret;
if (a)
{
new_a = FcStrCopyFilename (a);
if (!new_a)
return FcFalse;
}
if (b)
{
new_b = FcStrCopyFilename(b);
if (!new_b)
{
if (new_a)
FcStrFree(new_a);
return FcFalse;
}
}
/* Override maps with new one if exists */
if (FcStrSetMemberAB (set, new_a, new_b, &rs))
{
FcStrSetDel (set, rs);
}
ret = FcStrSetAddTriple (set, new_a, new_b, salt);
if (new_a)
FcStrFree (new_a);
if (new_b)
FcStrFree (new_b);
return ret;
}
FcBool
FcStrSetAddLangs (FcStrSet *strs, const char *languages)
{
const char *p = languages, *next;
FcChar8 lang[128] = {0}, *normalized_lang;
size_t len;
FcBool ret = FcFalse;
if (!languages)
return FcFalse;
while ((next = strchr (p, ':')))
{
len = next - p;
len = FC_MIN (len, 127);
strncpy ((char *) lang, p, len);
lang[len] = 0;
/* ignore an empty item */
if (*lang)
{
normalized_lang = FcLangNormalize ((const FcChar8 *) lang);
if (normalized_lang)
{
FcStrSetAdd (strs, normalized_lang);
FcStrFree (normalized_lang);
ret = FcTrue;
}
}
p = next + 1;
}
if (*p)
{
normalized_lang = FcLangNormalize ((const FcChar8 *) p);
if (normalized_lang)
{
FcStrSetAdd (strs, normalized_lang);
FcStrFree (normalized_lang);
ret = FcTrue;
}
}
return ret;
}
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;
}
FcBool
FcStrSetDeleteAll (FcStrSet *set)
{
int i;
if (FcRefIsConst (&set->ref))
return FcFalse;
for (i = set->num; i > 0; i--)
{
FcStrFree (set->strs[i - 1]);
set->num--;
}
return FcTrue;
}
/* TODO Make public */
static FcStrSet *
FcStrSetReference (FcStrSet *set)
{
if (FcRefIsConst (&set->ref))
return set;
FcRefInc (&set->ref);
return set;
}
void
FcStrSetDestroy (FcStrSet *set)
{
int i;
/* We rely on this in FcGetDefaultLangs for caching. */
if (FcRefIsConst (&set->ref))
return;
if (FcRefDec (&set->ref) != 1)
return;
for (i = 0; i < set->num; i++)
FcStrFree (set->strs[i]);
if (set->strs)
free (set->strs);
free (set);
}
FcStrList *
FcStrListCreate (FcStrSet *set)
{
FcStrList *list;
list = malloc (sizeof (FcStrList));
if (!list)
return 0;
list->set = set;
FcStrSetReference (set);
list->n = 0;
return list;
}
void
FcStrListFirst (FcStrList *list)
{
list->n = 0;
}
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);
free (list);
}
#define __fcstr__
#include "fcaliastail.h"
#undef __fcstr__
Reference in New Issue View Git Blame Copy Permalink