X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffcname.c;h=96adc62ee34fb14c104b70649c46a85ed68e13c5;hb=7ce196733129b0e664c1bdc20f973f15167292f7;hp=2fc411f995b39c95b17a888e7760787f70710d8c;hpb=9ab79bdfb7f8bfbe108d1c676b361f69f6a5b043;p=fontconfig.git diff --git a/src/fcname.c b/src/fcname.c index 2fc411f..96adc62 100644 --- a/src/fcname.c +++ b/src/fcname.c @@ -22,15 +22,18 @@ * PERFORMANCE OF THIS SOFTWARE. */ +#include "fcint.h" #include #include #include #include -#include "fcint.h" /* Please do not revoke any of these bindings. */ +/* The __DUMMY__ object enables callers to distinguish the error return + * of FcObjectToPtrLookup from FC_FAMILY's FcObject, which would + * otherwise be 0. */ static const FcObjectType _FcBaseObjectTypes[] = { - { "__DUMMY__", FcTypeVoid, }, + { "__DUMMY__", FcTypeVoid, }, { FC_FAMILY, FcTypeString, }, { FC_FAMILYLANG, FcTypeString, }, { FC_STYLE, FcTypeString, }, @@ -45,14 +48,12 @@ static const FcObjectType _FcBaseObjectTypes[] = { { FC_PIXEL_SIZE, FcTypeDouble, }, { FC_SPACING, FcTypeInteger, }, { FC_FOUNDRY, FcTypeString, }, -/* { FC_CORE, FcTypeBool, }, */ { FC_ANTIALIAS, FcTypeBool, }, { FC_HINT_STYLE, FcTypeInteger, }, { FC_HINTING, FcTypeBool, }, { FC_VERTICAL_LAYOUT, FcTypeBool, }, { FC_AUTOHINT, FcTypeBool, }, { FC_GLOBAL_ADVANCE, FcTypeBool, }, -/* { FC_XLFD, FcTypeString, }, */ { FC_FILE, FcTypeString, }, { FC_INDEX, FcTypeInteger, }, { FC_RASTERIZER, FcTypeString, }, @@ -62,7 +63,6 @@ static const FcObjectType _FcBaseObjectTypes[] = { { FC_RGBA, FcTypeInteger, }, { FC_SCALE, FcTypeDouble, }, { FC_MINSPACE, FcTypeBool, }, -/* { FC_RENDER, FcTypeBool, },*/ { FC_CHAR_WIDTH, FcTypeInteger }, { FC_CHAR_HEIGHT, FcTypeInteger }, { FC_MATRIX, FcTypeMatrix }, @@ -155,6 +155,9 @@ FcNameGetObjectType (const char *object) for (l = _FcObjectTypes; l; l = l->next) { + if (l == (FcObjectTypeList*)_FcUserObjectNames) + continue; + for (i = 0; i < l->ntypes; i++) { t = &l->types[i]; @@ -176,18 +179,16 @@ static struct objectBucket *FcObjectBuckets[OBJECT_HASH_SIZE]; /* Design constraint: biggest_known_ntypes must never change * after any call to FcNameRegisterObjectTypes. */ static const FcObjectType *biggest_known_types = _FcBaseObjectTypes; -static FcBool allocated_biggest_known_types; static int biggest_known_ntypes = NUM_OBJECT_TYPES; -static int biggest_known_count = 0; -static char * biggest_ptr; -static FcObjectPtr +static FcObject FcObjectToPtrLookup (const char * object) { - FcObjectPtr i = 0, n; + FcObject i = 0, n; const FcObjectTypeList *l; FcObjectType *t = _FcUserObjectNames; + FcBool replace; for (l = _FcObjectTypes; l; l = l->next) { @@ -196,7 +197,7 @@ FcObjectToPtrLookup (const char * object) t = (FcObjectType *)&l->types[i]; if (!strcmp (object, t->object)) { - if (l == (FcObjectTypeList*)_FcUserObjectNames) + if (l->types == _FcUserObjectNames) return -i; else return l->basic_offset + i; @@ -204,27 +205,28 @@ FcObjectToPtrLookup (const char * object) } } - /* We didn't match. Look for the correct FcObjectTypeList - * to replace it in-place. */ + /* We didn't match. Look for the application's FcObjectTypeList + * and replace it in-place. */ for (l = _FcObjectTypes; l; l = l->next) { if (l->types == _FcUserObjectNames) break; } + replace = l && l->types == _FcUserObjectNames; if (!_FcUserObjectNames || - (l && l->types == _FcUserObjectNames && user_obj_alloc < l->ntypes)) + (replace && user_obj_alloc <= l->ntypes)) { int nt = user_obj_alloc + 4; - FcObjectType * t = realloc (_FcUserObjectNames, + FcObjectType * tt = realloc (_FcUserObjectNames, nt * sizeof (FcObjectType)); - if (!t) + if (!tt) return 0; - _FcUserObjectNames = t; + _FcUserObjectNames = tt; user_obj_alloc = nt; } - if (l && l->types == _FcUserObjectNames) + if (replace) { n = l->ntypes; FcNameUnregisterObjectTypesFree (l->types, l->ntypes, FcFalse); @@ -234,26 +236,25 @@ FcObjectToPtrLookup (const char * object) FcNameRegisterObjectTypes (_FcUserObjectNames, n+1); - for (l = _FcObjectTypes; l; l = l->next) - { - if (l->types == _FcUserObjectNames) - { - t = (FcObjectType *)l->types; - break; - } - } - - if (!t) + if (!_FcUserObjectNames) return 0; - t[n].object = object; - t[n].type = FcTypeVoid; + _FcUserObjectNames[n].object = object; + _FcUserObjectNames[n].type = FcTypeVoid; return -n; } -FcObjectPtr -FcObjectToPtr (const char * name) +FcBool +FcObjectValidType (FcObject object, FcType type) +{ + if (object < NUM_OBJECT_TYPES && _FcBaseObjectTypes[object].type != type) + return FcFalse; + return FcTrue; +} + +FcObject +FcObjectFromName (const char * name) { FcChar32 hash = FcStringHash ((const FcChar8 *) name); struct objectBucket **p; @@ -300,120 +301,24 @@ FcObjectStaticNameFini (void) } const char * -FcObjectPtrU (FcObjectPtr si) +FcObjectName (FcObject object) { const FcObjectTypeList *l; int i, j; - if (si > 0) + if (object > 0) { - if (si < biggest_known_ntypes) - return biggest_known_types[si].object; + if (object < biggest_known_ntypes) + return biggest_known_types[object].object; j = 0; for (l = _FcObjectTypes; l; l = l->next) for (i = 0; i < l->ntypes; i++, j++) - if (j == si) + if (j == object) return l->types[i].object; } - return _FcUserObjectNames[-si].object; -} - -int -FcObjectNeededBytes () -{ - int num = 0, i; - for (i = 0; i < biggest_known_ntypes; i++) - { - const char * t = biggest_known_types[i].object; - num = num + strlen(t) + 1; - } - biggest_known_count = num; - return num + sizeof(int); -} - -int -FcObjectNeededBytesAlign (void) -{ - return __alignof__ (int) + __alignof__ (char); -} - -void * -FcObjectDistributeBytes (FcCache * metadata, void * block_ptr) -{ - block_ptr = ALIGN (block_ptr, int); - *(int *)block_ptr = biggest_known_ntypes; - block_ptr = (int *) block_ptr + 1; - block_ptr = ALIGN (block_ptr, char); - biggest_ptr = block_ptr; - block_ptr = (char *) block_ptr + biggest_known_count; - return block_ptr; -} - -void -FcObjectSerialize () -{ - int i; - for (i = 0; i < biggest_known_ntypes; i++) - { - const char * t = biggest_known_types[i].object; - strcpy (biggest_ptr, t); - biggest_ptr = biggest_ptr + strlen(t) + 1; - } -} - -void * -FcObjectUnserialize (FcCache metadata, void *block_ptr) -{ - int new_biggest; - new_biggest = *(int *)block_ptr; - block_ptr = ALIGN (block_ptr, int); - block_ptr = (int *) block_ptr + 1; - if (biggest_known_ntypes < new_biggest) - { - int i; - char * bp = (char *)block_ptr; - FcObjectType * bn; - FcObjectTypeList * bnl; - - bn = malloc (sizeof (const FcObjectType) * (new_biggest + 1)); - if (!bn) - return 0; - - bnl = malloc (sizeof (FcObjectTypeList)); - if (!bnl) - { - free (bn); - return 0; - } - - for (i = 0; i < new_biggest; i++) - { - const FcObjectType * t = FcNameGetObjectType(bp); - if (t) - bn[i].type = t->type; - else - bn[i].type = FcTypeVoid; - bn[i].object = bp; - bp = bp + strlen(bp) + 1; - } - - FcNameUnregisterObjectTypesFree (biggest_known_types, biggest_known_ntypes, FcFalse); - if (allocated_biggest_known_types) - { - free ((FcObjectTypeList *)biggest_known_types); - } - else - allocated_biggest_known_types = FcTrue; - - FcNameRegisterObjectTypes (bn, new_biggest); - biggest_known_ntypes = new_biggest; - biggest_known_types = (const FcObjectType *)bn; - } - block_ptr = ALIGN (block_ptr, char); - block_ptr = (char *) block_ptr + biggest_known_count; - return block_ptr; + return _FcUserObjectNames[-object].object; } static const FcConstant _FcBaseConstants[] = { @@ -700,7 +605,7 @@ FcNameParse (const FcChar8 *name) for (;;) { name = FcNameFindNext (name, ":,", save, &delim); - if (t) + if (t && strcmp (t->object, _FcBaseObjectTypes[0].object)) { v = FcNameConvert (t->type, save, &m); if (!FcPatternAdd (pat, t->object, v, FcTrue)) @@ -812,11 +717,11 @@ FcNameUnparseValueList (FcStrBuf *buf, FcValueListPtr v, FcChar8 *escape) { - while (FcValueListPtrU(v)) + while (v) { - if (!FcNameUnparseValue (buf, &FcValueListPtrU(v)->value, escape)) + if (!FcNameUnparseValue (buf, &v->value, escape)) return FcFalse; - if (FcValueListPtrU(v = FcValueListPtrU(v)->next)) + if ((v = FcValueListNext(v)) != NULL) if (!FcNameUnparseString (buf, (FcChar8 *) ",", 0)) return FcFalse; } @@ -843,18 +748,18 @@ FcNameUnparseEscaped (FcPattern *pat, FcBool escape) const FcObjectType *o; FcStrBufInit (&buf, buf_static, sizeof (buf_static)); - e = FcPatternFindElt (pat, FC_FAMILY); + e = FcPatternObjectFindElt (pat, FC_FAMILY_OBJECT); if (e) { - if (!FcNameUnparseValueList (&buf, e->values, escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0)) + if (!FcNameUnparseValueList (&buf, FcPatternEltValues(e), escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0)) goto bail0; } - e = FcPatternFindElt (pat, FC_SIZE); + e = FcPatternObjectFindElt (pat, FC_SIZE_OBJECT); if (e) { if (!FcNameUnparseString (&buf, (FcChar8 *) "-", 0)) goto bail0; - if (!FcNameUnparseValueList (&buf, e->values, escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0)) + if (!FcNameUnparseValueList (&buf, FcPatternEltValues(e), escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0)) goto bail0; } for (l = _FcObjectTypes; l; l = l->next) @@ -867,7 +772,7 @@ FcNameUnparseEscaped (FcPattern *pat, FcBool escape) !strcmp (o->object, FC_FILE)) continue; - e = FcPatternFindElt (pat, o->object); + e = FcPatternObjectFindElt (pat, FcObjectFromName (o->object)); if (e) { if (!FcNameUnparseString (&buf, (FcChar8 *) ":", 0)) @@ -876,7 +781,7 @@ FcNameUnparseEscaped (FcPattern *pat, FcBool escape) goto bail0; if (!FcNameUnparseString (&buf, (FcChar8 *) "=", 0)) goto bail0; - if (!FcNameUnparseValueList (&buf, e->values, escape ? + if (!FcNameUnparseValueList (&buf, FcPatternEltValues(e), escape ? (FcChar8 *) FC_ESCAPE_VARIABLE : 0)) goto bail0; }