/*

 * 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 "fcftint.h"

/* Objects MT-safe for readonly access. */

FcPattern *

FcPatternCreate (void)

{

    FcPattern	*p;

    p = (FcPattern *) malloc (sizeof (FcPattern));

    if (!p)

	return 0;

    memset (p, 0, sizeof (FcPattern));

    p->num = 0;

    p->size = 0;

    p->elts_offset = FcPtrToOffset (p, NULL);

    FcRefInit (&p->ref, 1);

    return p;

}

void

FcValueDestroy (FcValue v)

{

    switch ((int) v.type) {

    case FcTypeString:

	FcFree (v.u.s);

	break;

    case FcTypeMatrix:

	FcMatrixFree ((FcMatrix *) v.u.m);

	break;

    case FcTypeCharSet:

	FcCharSetDestroy ((FcCharSet *) v.u.c);

	break;

    case FcTypeLangSet:

	FcLangSetDestroy ((FcLangSet *) v.u.l);

	break;

    case FcTypeRange:

	FcRangeDestroy ((FcRange *) v.u.r);

	break;

    default:

	break;

    }

}

FcValue

FcValueCanonicalize (const FcValue *v)

{

    FcValue new;

    switch ((int) v->type)

    {

    case FcTypeString:

	new.u.s = FcValueString(v);

	new.type = FcTypeString;

	break;

    case FcTypeCharSet:

	new.u.c = FcValueCharSet(v);

	new.type = FcTypeCharSet;

	break;

    case FcTypeLangSet:

	new.u.l = FcValueLangSet(v);

	new.type = FcTypeLangSet;

	break;

    case FcTypeRange:

	new.u.r = FcValueRange(v);

	new.type = FcTypeRange;

	break;

    default:

	new = *v;

	break;

    }

    return new;

}

FcValue

FcValueSave (FcValue v)

{

    switch ((int) v.type) {

    case FcTypeString:

	v.u.s = FcStrdup (v.u.s);

	if (!v.u.s)

	    v.type = FcTypeVoid;

	break;

    case FcTypeMatrix:

	v.u.m = FcMatrixCopy (v.u.m);

	if (!v.u.m)

	    v.type = FcTypeVoid;

	break;

    case FcTypeCharSet:

	v.u.c = FcCharSetCopy ((FcCharSet *) v.u.c);

	if (!v.u.c)

	    v.type = FcTypeVoid;

	break;

    case FcTypeLangSet:

	v.u.l = FcLangSetCopy (v.u.l);

	if (!v.u.l)

	    v.type = FcTypeVoid;

	break;

    case FcTypeRange:

	v.u.r = FcRangeCopy (v.u.r);

	if (!v.u.r)

	    v.type = FcTypeVoid;

	break;

    default:

	break;

    }

    return v;

}

FcValueListPtr

FcValueListCreate (void)

{

    return calloc (1, sizeof (FcValueList));

}

void

FcValueListDestroy (FcValueListPtr l)

{

    FcValueListPtr next;

    for (; l; l = next)

    {

	switch ((int) l->value.type) {

	case FcTypeString:

	    FcFree (l->value.u.s);

	    break;

	case FcTypeMatrix:

	    FcMatrixFree ((FcMatrix *)l->value.u.m);

	    break;

	case FcTypeCharSet:

	    FcCharSetDestroy

		((FcCharSet *) (l->value.u.c));

	    break;

	case FcTypeLangSet:

	    FcLangSetDestroy

		((FcLangSet *) (l->value.u.l));

	    break;

	case FcTypeRange:

	    FcRangeDestroy ((FcRange *) (l->value.u.r));

	    break;

	default:

	    break;

	}

	next = FcValueListNext(l);

	free(l);

    }

}

FcValueListPtr

FcValueListPrepend (FcValueListPtr vallist,

		    FcValue        value,

		    FcValueBinding binding)

{

    FcValueListPtr new;

    if (value.type == FcTypeVoid)

	return vallist;

    new = FcValueListCreate ();

    if (!new)

	return vallist;

    new->value = FcValueSave (value);

    new->binding = binding;

    new->next = vallist;

    return new;

}

FcValueListPtr

FcValueListAppend (FcValueListPtr vallist,

		   FcValue        value,

		   FcValueBinding binding)

{

    FcValueListPtr new, last;

    if (value.type == FcTypeVoid)

	return vallist;

    new = FcValueListCreate ();

    if (!new)

	return vallist;

    new->value = FcValueSave (value);

    new->binding = binding;

    new->next = NULL;

    if (vallist)

    {

	for (last = vallist; FcValueListNext (last); last = FcValueListNext (last));

	last->next = new;

    }

    else

	vallist = new;

    return vallist;

}

FcValueListPtr

FcValueListDuplicate(FcValueListPtr orig)

{

    FcValueListPtr new = NULL, l, t = NULL;

    FcValue v;

    for (l = orig; l != NULL; l = FcValueListNext (l))

    {

	if (!new)

	{

	    t = new = FcValueListCreate();

	}

	else

	{

	    t->next = FcValueListCreate();

	    t = FcValueListNext (t);

	}

	v = FcValueCanonicalize (&l->value);

	t->value = FcValueSave (v);

	t->binding = l->binding;

	t->next = NULL;

    }

    return new;

}

FcBool

FcValueEqual (FcValue va, FcValue vb)

{

    if (va.type != vb.type)

    {

	if (va.type == FcTypeInteger)

	{

	    va.type = FcTypeDouble;

	    va.u.d = va.u.i;

	}

	if (vb.type == FcTypeInteger)

	{

	    vb.type = FcTypeDouble;

	    vb.u.d = vb.u.i;

	}

	if (va.type != vb.type)

	    return FcFalse;

    }

    switch (va.type) {

    case FcTypeUnknown:

	return FcFalse;	/* don't know how to compare this object */

    case FcTypeVoid:

	return FcTrue;

    case FcTypeInteger:

	return va.u.i == vb.u.i;

    case FcTypeDouble:

	return va.u.d == vb.u.d;

    case FcTypeString:

	return FcStrCmpIgnoreCase (va.u.s, vb.u.s) == 0;

    case FcTypeBool:

	return va.u.b == vb.u.b;

    case FcTypeMatrix:

	return FcMatrixEqual (va.u.m, vb.u.m);

    case FcTypeCharSet:

	return FcCharSetEqual (va.u.c, vb.u.c);

    case FcTypeFTFace:

	return va.u.f == vb.u.f;

    case FcTypeLangSet:

	return FcLangSetEqual (va.u.l, vb.u.l);

    case FcTypeRange:

	return FcRangeIsInRange (va.u.r, vb.u.r);

    }

    return FcFalse;

}

static FcChar32

FcDoubleHash (double d)

{

    if (d < 0)

	d = -d;

    if (d > 0xffffffff)

	d = 0xffffffff;

    return (FcChar32) d;

}

FcChar32

FcStringHash (const FcChar8 *s)

{

    FcChar8	c;

    FcChar32	h = 0;

    if (s)

	while ((c = *s++))

	    h = ((h << 1) | (h >> 31)) ^ c;

    return h;

}

static FcChar32

FcValueHash (const FcValue *v)

{

    switch (v->type) {

    case FcTypeUnknown:

    case FcTypeVoid:

	return 0;

    case FcTypeInteger:

	return (FcChar32) v->u.i;

    case FcTypeDouble:

	return FcDoubleHash (v->u.d);

    case FcTypeString:

	return FcStringHash (FcValueString(v));

    case FcTypeBool:

	return (FcChar32) v->u.b;

    case FcTypeMatrix:

	return (FcDoubleHash (v->u.m->xx) ^

		FcDoubleHash (v->u.m->xy) ^

		FcDoubleHash (v->u.m->yx) ^

		FcDoubleHash (v->u.m->yy));

    case FcTypeCharSet:

	return (FcChar32) FcValueCharSet(v)->num;

    case FcTypeFTFace:

	return FcStringHash ((const FcChar8 *) ((FT_Face) v->u.f)->family_name) ^

	       FcStringHash ((const FcChar8 *) ((FT_Face) v->u.f)->style_name);

    case FcTypeLangSet:

	return FcLangSetHash (FcValueLangSet(v));

    case FcTypeRange:

	return FcRangeHash (v->u.r);

    }

    return 0;

}

static FcBool

FcValueListEqual (FcValueListPtr la, FcValueListPtr lb)

{

    if (la == lb)

	return FcTrue;

    while (la && lb)

    {

	if (!FcValueEqual (la->value, lb->value))

	    return FcFalse;

	la = FcValueListNext(la);

	lb = FcValueListNext(lb);

    }

    if (la || lb)

	return FcFalse;

    return FcTrue;

}

static FcChar32

FcValueListHash (FcValueListPtr l)

{

    FcChar32	hash = 0;

    for (; l; l = FcValueListNext(l))

    {

	hash = ((hash << 1) | (hash >> 31)) ^ FcValueHash (&l->value);

    }

    return hash;

}

static void *

FcPatternGetCacheObject (FcPattern *p)

{

  /* We use a value to find the cache, instead of the FcPattern object

   * because the pattern itself may be a cache allocation if we rewrote the path,

   * so the p may not be in the cached region. */

  return FcPatternEltValues(&FcPatternElts (p)[0]);

}

FcPattern *

FcPatternCacheRewriteFile (const FcPattern *p,

                           FcCache *cache,

                           const FcChar8 *relocated_font_file)

{

    FcPatternElt *elts = FcPatternElts (p);

    size_t i,j;

    FcChar8 *data;

    FcPattern *new_p;

    FcPatternElt *new_elts;

    FcValueList *new_value_list;

    size_t new_path_len = strlen ((char *)relocated_font_file);

    FcChar8 *new_path;

    /* Allocate space for the patter, the PatternElt headers and

     * the FC_FILE FcValueList and path that will be freed with the

     * cache */

    data = FcCacheAllocate (cache,

			    sizeof (FcPattern) +

			    p->num * sizeof (FcPatternElt) +

			    sizeof (FcValueList) +

			    new_path_len + 1);

    new_p = (FcPattern *)data;

    data += sizeof (FcPattern);

    new_elts = (FcPatternElt *)(data);

    data += p->num * sizeof (FcPatternElt);

    new_value_list = (FcValueList *)data;

    data += sizeof (FcValueList);

    new_path = data;

    *new_p = *p;

    new_p->elts_offset = FcPtrToOffset (new_p, new_elts);

    /* Copy all but the FILE values from the cache */

    for (i = 0, j = 0; i < p->num; i++)

    {

	FcPatternElt *elt = &elts[i];

	new_elts[j].object = elt->object;

	if (elt->object != FC_FILE_OBJECT)

	    new_elts[j++].values = FcPatternEltValues(elt);

	else

	    new_elts[j++].values = new_value_list;

    }

    new_value_list->next = NULL;

    new_value_list->value.type = FcTypeString;

    new_value_list->value.u.s = new_path;

    new_value_list->binding = FcValueBindingWeak;

    /* Add rewritten path at the end */

    strcpy ((char *)new_path, (char *)relocated_font_file);

    return new_p;

}

void

FcPatternDestroy (FcPattern *p)

{

    int		    i;

    FcPatternElt    *elts;

    if (!p)

	return;

    if (FcRefIsConst (&p->ref))

    {

	FcCacheObjectDereference (FcPatternGetCacheObject(p));

	return;

    }

    if (FcRefDec (&p->ref) != 1)

	return;

    elts = FcPatternElts (p);

    for (i = 0; i < FcPatternObjectCount (p); i++)

	FcValueListDestroy (FcPatternEltValues(&elts[i]));

    free (elts);

    free (p);

}

int

FcPatternObjectCount (const FcPattern *pat)

{

    if (pat)

	return pat->num;

    return 0;

}

static int

FcPatternObjectPosition (const FcPattern *p, FcObject object)

{

    int	    low, high, mid, c;

    FcPatternElt    *elts = FcPatternElts(p);

    low = 0;

    high = FcPatternObjectCount (p) - 1;

    c = 1;

    mid = 0;

    while (low <= high)

    {

	mid = (low + high) >> 1;

	c = elts[mid].object - object;

	if (c == 0)

	    return mid;

	if (c < 0)

	    low = mid + 1;

	else

	    high = mid - 1;

    }

    if (c < 0)

	mid++;

    return -(mid + 1);

}

int

FcPatternPosition (const FcPattern *p, const char *object)

{

    return FcPatternObjectPosition (p, FcObjectFromName (object));

}

FcPatternElt *

FcPatternObjectFindElt (const FcPattern *p, FcObject object)

{

    int	    i = FcPatternObjectPosition (p, object);

    if (i < 0)

	return 0;

    return &FcPatternElts(p)[i];

}

FcPatternElt *

FcPatternObjectInsertElt (FcPattern *p, FcObject object)

{

    int		    i;

    FcPatternElt   *e;

    i = FcPatternObjectPosition (p, object);

    if (i < 0)

    {

	i = -i - 1;

	/* reallocate array */

	if (FcPatternObjectCount (p) + 1 >= p->size)

	{

	    int s = p->size + 16;

	    if (p->size)

	    {

		FcPatternElt *e0 = FcPatternElts(p);

		e = (FcPatternElt *) realloc (e0, s * sizeof (FcPatternElt));

		if (!e) /* maybe it was mmapped */

		{

		    e = malloc(s * sizeof (FcPatternElt));

		    if (e)

			memcpy(e, e0, FcPatternObjectCount (p) * sizeof (FcPatternElt));

		}

	    }

	    else

		e = (FcPatternElt *) malloc (s * sizeof (FcPatternElt));

	    if (!e)

		return FcFalse;

	    p->elts_offset = FcPtrToOffset (p, e);

	    while (p->size < s)

	    {

		e[p->size].object = 0;

		e[p->size].values = NULL;

		p->size++;

	    }

	}

	e = FcPatternElts(p);

	/* move elts up */

	memmove (e + i + 1,

		 e + i,

		 sizeof (FcPatternElt) *

		 (FcPatternObjectCount (p) - i));

	/* bump count */

	p->num++;

	e[i].object = object;

	e[i].values = NULL;

    }

    return FcPatternElts(p) + i;

}

FcBool

FcPatternEqual (const FcPattern *pa, const FcPattern *pb)

{

    FcPatternIter ia, ib;

    if (pa == pb)

	return FcTrue;

    if (FcPatternObjectCount (pa) != FcPatternObjectCount (pb))

	return FcFalse;

    FcPatternIterStart (pa, &ia);

    FcPatternIterStart (pb, &ib;;

    do {

	FcBool ra, rb;

	if (!FcPatternIterEqual (pa, &ia, pb, &ib))

	    return FcFalse;

	ra = FcPatternIterNext (pa, &ia);

	rb = FcPatternIterNext (pb, &ib;;

	if (!ra && !rb)

	    break;

    } while (1);

    return FcTrue;

}

FcChar32

FcPatternHash (const FcPattern *p)

{

    int		i;

    FcChar32	h = 0;

    FcPatternElt    *pe = FcPatternElts(p);

    for (i = 0; i < FcPatternObjectCount (p); i++)

    {

	h = (((h << 1) | (h >> 31)) ^

	     pe[i].object ^

	     FcValueListHash (FcPatternEltValues(&pe[i])));

    }

    return h;

}

FcBool

FcPatternEqualSubset (const FcPattern *pai, const FcPattern *pbi, const FcObjectSet *os)

{

    FcPatternElt    *ea, *eb;

    int		    i;

    for (i = 0; i < os->nobject; i++)

    {

	FcObject    object = FcObjectFromName (os->objects[i]);

	ea = FcPatternObjectFindElt (pai, object);

	eb = FcPatternObjectFindElt (pbi, object);

	if (ea)

	{

	    if (!eb)

		return FcFalse;

	    if (!FcValueListEqual (FcPatternEltValues(ea), FcPatternEltValues(eb)))

		return FcFalse;

	}

	else

	{

	    if (eb)

		return FcFalse;

	}

    }

    return FcTrue;

}

FcBool

FcPatternObjectListAdd (FcPattern	*p,

			FcObject	object,

			FcValueListPtr	list,

			FcBool		append)

{

    FcPatternElt   *e;

    FcValueListPtr l, *prev;

    if (FcRefIsConst (&p->ref))

	goto bail0;

    /*

     * Make sure the stored type is valid for built-in objects

     */

    for (l = list; l != NULL; l = FcValueListNext (l))

    {

	if (!FcObjectValidType (object, l->value.type))

	{

	    fprintf (stderr,

		     "Fontconfig warning: FcPattern object %s does not accept value", FcObjectName (object));

	    FcValuePrintFile (stderr, l->value);

	    fprintf (stderr, "\n");

	    goto bail0;

	}

    }

    e = FcPatternObjectInsertElt (p, object);

    if (!e)

	goto bail0;

    if (append)

    {

	for (prev = &e->values; *prev; prev = &(*prev)->next)

	    ;

	*prev = list;

    }

    else

    {

	for (prev = &list; *prev; prev = &(*prev)->next)

	    ;

	*prev = e->values;

	e->values = list;

    }

    return FcTrue;

bail0:

    return FcFalse;

}

FcBool

FcPatternObjectAddWithBinding  (FcPattern	*p,

				FcObject	object,

				FcValue		value,

				FcValueBinding  binding,

				FcBool		append)

{

    FcPatternElt   *e;

    FcValueListPtr new, *prev;

    if (FcRefIsConst (&p->ref))

	goto bail0;

    new = FcValueListCreate ();

    if (!new)

	goto bail0;

    value = FcValueSave (value);

    if (value.type == FcTypeVoid)

	goto bail1;

    /*

     * Make sure the stored type is valid for built-in objects

     */

    if (!FcObjectValidType (object, value.type))

    {

	fprintf (stderr,

		 "Fontconfig warning: FcPattern object %s does not accept value",

		 FcObjectName (object));

	FcValuePrintFile (stderr, value);

	fprintf (stderr, "\n");

	goto bail1;

    }

    new->value = value;

    new->binding = binding;

    new->next = NULL;

    e = FcPatternObjectInsertElt (p, object);

    if (!e)

	goto bail2;

    if (append)

    {

	for (prev = &e->values; *prev; prev = &(*prev)->next)

	    ;

	*prev = new;

    }

    else

    {

	new->next = e->values;

	e->values = new;

    }

    return FcTrue;

bail2:

    FcValueDestroy (value);

bail1:

    free (new);

bail0:

    return FcFalse;

}

FcBool

FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append)

{

    return FcPatternObjectAddWithBinding (p, object,

					  value, FcValueBindingStrong, append);

}

FcBool

FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append)

{

    return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),

					  value, FcValueBindingStrong, append);

}

FcBool

FcPatternAddWeak  (FcPattern *p, const char *object, FcValue value, FcBool append)

{

    return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),

					  value, FcValueBindingWeak, append);

}

FcBool

FcPatternObjectDel (FcPattern *p, FcObject object)

{

    FcPatternElt   *e;

    e = FcPatternObjectFindElt (p, object);

    if (!e)

	return FcFalse;

    /* destroy value */

    FcValueListDestroy (e->values);

    /* shuffle existing ones down */

    memmove (e, e+1,

	     (FcPatternElts(p) + FcPatternObjectCount (p) - (e + 1)) *

	     sizeof (FcPatternElt));

    p->num--;

    e = FcPatternElts(p) + FcPatternObjectCount (p);

    e->object = 0;

    e->values = NULL;

    return FcTrue;

}

FcBool

FcPatternDel (FcPattern *p, const char *object)

{

    return FcPatternObjectDel (p, FcObjectFromName (object));

}

FcBool

FcPatternRemove (FcPattern *p, const char *object, int id)

{

    FcPatternElt    *e;

    FcValueListPtr  *prev, l;

    e = FcPatternObjectFindElt (p, FcObjectFromName (object));

    if (!e)

	return FcFalse;

    for (prev = &e->values; (l = *prev); prev = &l->next)

    {

	if (!id)

	{

	    *prev = l->next;

	    l->next = NULL;

	    FcValueListDestroy (l);

	    if (!e->values)

		FcPatternDel (p, object);

	    return FcTrue;

	}

	id--;

    }

    return FcFalse;

}

FcBool

FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i)

{

    FcValue	v;

    v.type = FcTypeInteger;

    v.u.i = i;

    return FcPatternObjectAdd (p, object, v, FcTrue);

}

FcBool

FcPatternAddInteger (FcPattern *p, const char *object, int i)

{

    return FcPatternObjectAddInteger (p, FcObjectFromName (object), i);

}

FcBool

FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d)

{

    FcValue	v;

    v.type = FcTypeDouble;

    v.u.d = d;

    return FcPatternObjectAdd (p, object, v, FcTrue);

}

FcBool

FcPatternAddDouble (FcPattern *p, const char *object, double d)

{

    return FcPatternObjectAddDouble (p, FcObjectFromName (object), d);

}

FcBool

FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s)

{

    FcValue	v;

    if (!s)

    {

	v.type = FcTypeVoid;

	v.u.s = 0;

	return FcPatternObjectAdd (p, object, v, FcTrue);

    }

    v.type = FcTypeString;

    v.u.s = s;

    return FcPatternObjectAdd (p, object, v, FcTrue);