[fontconfig.git] / src / fcdbg.c

/*
 * $RCSId: xc/lib/fontconfig/src/fcdbg.c,v 1.10 2002/08/22 18:53:22 keithp Exp $
 *
 * 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 Keith Packard not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes 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,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL KEITH PACKARD 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 <stdio.h>
#include <stdlib.h>

void
FcValuePrint (const FcValue v)
{
    switch (v.type) {
    case FcTypeVoid:
	printf (" <void>");
	break;
    case FcTypeInteger:
	printf (" %d(i)", v.u.i);
	break;
    case FcTypeDouble:
	printf (" %g(f)", v.u.d);
	break;
    case FcTypeString:
	printf (" \"%s\"", v.u.s);
	break;
    case FcTypeBool:
	printf (" %s", v.u.b ? "FcTrue" : "FcFalse");
	break;
    case FcTypeMatrix:
	printf (" (%f %f; %f %f)", v.u.m->xx, v.u.m->xy, v.u.m->yx, v.u.m->yy);
	break;
    case FcTypeCharSet:	/* XXX */
	printf (" set");
	break;
    case FcTypeLangSet:
	printf (" ");
	FcLangSetPrint (v.u.l);
	break;
    case FcTypeFTFace:
	printf (" face");
	break;
    }
}

void
FcValueListPrint (FcValueListPtr l)
{
    for (; FcValueListPtrU(l); l = FcValueListPtrU(l)->next)
    {
	FcValuePrint (FcValueCanonicalize(&FcValueListPtrU(l)->value));
	switch (FcValueListPtrU(l)->binding) {
	case FcValueBindingWeak:
	    printf ("(w)");
	    break;
	case FcValueBindingStrong:
	    printf ("(s)");
	    break;
	case FcValueBindingSame:
	    printf ("(=)");
	    break;
	}
    }
}

void
FcLangSetPrint (const FcLangSet *ls)
{
    FcStrBuf	buf;
    FcChar8	init_buf[1024];
    
    FcStrBufInit (&buf, init_buf, sizeof (init_buf));
    if (FcNameUnparseLangSet (&buf, ls) && FcStrBufChar (&buf,'\0'))
       printf ("%s", buf.buf);
    else
       printf ("langset (alloc error)");
    FcStrBufDestroy (&buf);
}

void
FcPatternPrint (const FcPattern *p)
{
    int		    i;
    FcPatternElt   *e;
    
    if (!p)
    {
	printf ("Null pattern\n");
	return;
    }
    printf ("Pattern has %d elts (size %d)\n", p->num, p->size);
    for (i = 0; i < p->num; i++)
    {
	e = FcPatternEltU(p->elts) + i;
	printf ("\t%s:", FcObjectPtrU(e->object));
	/* so that fc-match properly displays file: foo... */
	if (e->object == FcObjectToPtr(FC_FILE))
	{
	    FcChar8 * s;
	    FcPatternGetString (p, FC_FILE, 0, &s);
	    printf (" \"%s\"", s);
	    switch (FcValueListPtrU(e->values)->binding) {
	    case FcValueBindingWeak:
	        printf ("(w)");
	        break;
	    case FcValueBindingStrong:
	        printf ("(s)");
	        break;
	    case FcValueBindingSame:
	        printf ("(=)");
	        break;
	    }
	}
	else
	    FcValueListPrint (e->values);
	printf ("\n");
    }
    printf ("\n");
}

void
FcOpPrint (FcOp op)
{
    switch (op) {
    case FcOpInteger: printf ("Integer"); break;
    case FcOpDouble: printf ("Double"); break;
    case FcOpString: printf ("String"); break;
    case FcOpMatrix: printf ("Matrix"); break;
    case FcOpBool: printf ("Bool"); break;
    case FcOpCharSet: printf ("CharSet"); break;
    case FcOpField: printf ("Field"); break;
    case FcOpConst: printf ("Const"); break;
    case FcOpAssign: printf ("Assign"); break;
    case FcOpAssignReplace: printf ("AssignReplace"); break;
    case FcOpPrepend: printf ("Prepend"); break;
    case FcOpPrependFirst: printf ("PrependFirst"); break;
    case FcOpAppend: printf ("Append"); break;
    case FcOpAppendLast: printf ("AppendLast"); break;
    case FcOpQuest: printf ("Quest"); break;
    case FcOpOr: printf ("Or"); break;
    case FcOpAnd: printf ("And"); break;
    case FcOpEqual: printf ("Equal"); break;
    case FcOpNotEqual: printf ("NotEqual"); break;
    case FcOpLess: printf ("Less"); break;
    case FcOpLessEqual: printf ("LessEqual"); break;
    case FcOpMore: printf ("More"); break;
    case FcOpMoreEqual: printf ("MoreEqual"); break;
    case FcOpContains: printf ("Contains"); break;
    case FcOpNotContains: printf ("NotContains"); break;
    case FcOpPlus: printf ("Plus"); break;
    case FcOpMinus: printf ("Minus"); break;
    case FcOpTimes: printf ("Times"); break;
    case FcOpDivide: printf ("Divide"); break;
    case FcOpNot: printf ("Not"); break;
    case FcOpNil: printf ("Nil"); break;
    case FcOpComma: printf ("Comma"); break;
    case FcOpFloor: printf ("Floor"); break;
    case FcOpCeil: printf ("Ceil"); break;
    case FcOpRound: printf ("Round"); break;
    case FcOpTrunc: printf ("Trunc"); break;
    case FcOpListing: printf ("Listing"); break;
    case FcOpInvalid: printf ("Invalid"); break;
    }
}

void
FcExprPrint (const FcExpr *expr)
{
    if (!expr) printf ("none");
    else switch (expr->op) {
    case FcOpInteger: printf ("%d", expr->u.ival); break;
    case FcOpDouble: printf ("%g", expr->u.dval); break;
    case FcOpString: printf ("\"%s\"", expr->u.sval); break;
    case FcOpMatrix: printf ("[%g %g %g %g]",
			      expr->u.mval->xx,
			      expr->u.mval->xy,
			      expr->u.mval->yx,
			      expr->u.mval->yy); break;
    case FcOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break;
    case FcOpCharSet: printf ("charset\n"); break;
    case FcOpNil: printf ("nil\n"); break;
    case FcOpField: printf ("%s", expr->u.field); break;
    case FcOpConst: printf ("%s", expr->u.constant); break;
    case FcOpQuest:
	FcExprPrint (expr->u.tree.left);
	printf (" quest ");
	FcExprPrint (expr->u.tree.right->u.tree.left);
	printf (" colon ");
	FcExprPrint (expr->u.tree.right->u.tree.right);
	break;
    case FcOpAssign:
    case FcOpAssignReplace:
    case FcOpPrependFirst:
    case FcOpPrepend:
    case FcOpAppend:
    case FcOpAppendLast:
    case FcOpOr:
    case FcOpAnd:
    case FcOpEqual:
    case FcOpNotEqual:
    case FcOpLess:
    case FcOpLessEqual:
    case FcOpMore:
    case FcOpMoreEqual:
    case FcOpContains:
    case FcOpListing:
    case FcOpNotContains:
    case FcOpPlus:
    case FcOpMinus:
    case FcOpTimes:
    case FcOpDivide:
    case FcOpComma:
	FcExprPrint (expr->u.tree.left);
	printf (" ");
	switch (expr->op) {
	case FcOpAssign: printf ("Assign"); break;
	case FcOpAssignReplace: printf ("AssignReplace"); break;
	case FcOpPrependFirst: printf ("PrependFirst"); break;
	case FcOpPrepend: printf ("Prepend"); break;
	case FcOpAppend: printf ("Append"); break;
	case FcOpAppendLast: printf ("AppendLast"); break;
	case FcOpOr: printf ("Or"); break;
	case FcOpAnd: printf ("And"); break;
	case FcOpEqual: printf ("Equal"); break;
	case FcOpNotEqual: printf ("NotEqual"); break;
	case FcOpLess: printf ("Less"); break;
	case FcOpLessEqual: printf ("LessEqual"); break;
	case FcOpMore: printf ("More"); break;
	case FcOpMoreEqual: printf ("MoreEqual"); break;
	case FcOpContains: printf ("Contains"); break;
	case FcOpListing: printf ("Listing"); break;
	case FcOpNotContains: printf ("NotContains"); break;
	case FcOpPlus: printf ("Plus"); break;
	case FcOpMinus: printf ("Minus"); break;
	case FcOpTimes: printf ("Times"); break;
	case FcOpDivide: printf ("Divide"); break;
	case FcOpComma: printf ("Comma"); break;
	default: break;
	}
	printf (" ");
	FcExprPrint (expr->u.tree.right);
	break;
    case FcOpNot:
	printf ("Not ");
	FcExprPrint (expr->u.tree.left);
	break;
    case FcOpFloor:
	printf ("Floor ");
	FcExprPrint (expr->u.tree.left);
	break;
    case FcOpCeil:
	printf ("Ceil ");
	FcExprPrint (expr->u.tree.left);
	break;
    case FcOpRound:
	printf ("Round ");
	FcExprPrint (expr->u.tree.left);
	break;
    case FcOpTrunc:
	printf ("Trunc ");
	FcExprPrint (expr->u.tree.left);
	break;
    case FcOpInvalid: printf ("Invalid"); break;
    }
}

void
FcTestPrint (const FcTest *test)
{
    switch (test->kind) {
    case FcMatchPattern:
	printf ("pattern ");
	break;
    case FcMatchFont:
	printf ("font ");
	break;
    }
    switch (test->qual) {
    case FcQualAny:
	printf ("any ");
	break;
    case FcQualAll:
	printf ("all ");
	break;
    case FcQualFirst:
	printf ("first ");
	break;
    case FcQualNotFirst:
	printf ("not_first ");
	break;
    }
    printf ("%s ", test->field);
    FcOpPrint (test->op);
    printf (" ");
    FcExprPrint (test->expr);
    printf ("\n");
}

void
FcEditPrint (const FcEdit *edit)
{
    printf ("Edit %s ", edit->field);
    FcOpPrint (edit->op);
    printf (" ");
    FcExprPrint (edit->expr);
}

void
FcSubstPrint (const FcSubst *subst)
{
    FcEdit	*e;
    FcTest	*t;
    
    printf ("match\n");
    for (t = subst->test; t; t = t->next)
    {
	printf ("\t");
	FcTestPrint (t);
    }
    printf ("edit\n");
    for (e = subst->edit; e; e = e->next)
    {
	printf ("\t");
	FcEditPrint (e);
	printf (";\n");
    }
    printf ("\n");
}

void
FcFontSetPrint (const FcFontSet *s)
{
    int	    i;

    printf ("FontSet %d of %d\n", s->nfont, s->sfont);
    for (i = 0; i < s->nfont; i++)
    {
	printf ("Font %d ", i);
	FcPatternPrint (s->fonts[i]);
    }
}

int FcDebugVal;

void
FcInitDebug (void)
{
    char    *e;

    e = getenv ("FC_DEBUG");
    if (e)
    {
        printf ("FC_DEBUG=%s\n", e);
        FcDebugVal = atoi (e);
        if (FcDebugVal < 0)
   	    FcDebugVal = 0;
    }
}
Commit	Line	Data
24330d27	1	/*
55ef7dac	2	* $RCSId: xc/lib/fontconfig/src/fcdbg.c,v 1.10 2002/08/22 18:53:22 keithp Exp $
24330d27	3	*
46b51147	4	* Copyright © 2000 Keith Packard
24330d27 KP	5	*
	6	* Permission to use, copy, modify, distribute, and sell this software and its
	7	* documentation for any purpose is hereby granted without fee, provided that
	8	* the above copyright notice appear in all copies and that both that
	9	* copyright notice and this permission notice appear in supporting
	10	* documentation, and that the name of Keith Packard not be used in
	11	* advertising or publicity pertaining to distribution of the software without
	12	* specific, written prior permission. Keith Packard makes no
	13	* representations about the suitability of this software for any purpose. It
	14	* is provided "as is" without express or implied warranty.
	15	*
	16	* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	17	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	18	* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	19	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
	20	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	21	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
	22	* PERFORMANCE OF THIS SOFTWARE.
	23	*/
	24
f045376c	25	#include "fcint.h"
24330d27 KP	26	#include <stdio.h>
24330d27 KP	27	#include <stdlib.h>
24330d27 KP	28
24330d27 KP	29	void
938bc633	30	FcValuePrint (const FcValue v)
24330d27 KP	31	{
	32	switch (v.type) {
	33	case FcTypeVoid:
	34	printf (" <void>");
	35	break;
	36	case FcTypeInteger:
2d39321f	37	printf (" %d(i)", v.u.i);
24330d27 KP	38	break;
24330d27 KP	39	case FcTypeDouble:
2d39321f	40	printf (" %g(f)", v.u.d);
24330d27 KP	41	break;
24330d27 KP	42	case FcTypeString:
4262e0b3	43	printf (" \"%s\"", v.u.s);
24330d27 KP	44	break;
	45	case FcTypeBool:
	46	printf (" %s", v.u.b ? "FcTrue" : "FcFalse");
	47	break;
	48	case FcTypeMatrix:
4262e0b3	49	printf (" (%f %f; %f %f)", v.u.m->xx, v.u.m->xy, v.u.m->yx, v.u.m->yy);
24330d27 KP	50	break;
	51	case FcTypeCharSet: /* XXX */
	52	printf (" set");
d8d73958 KP	53	break;
d8d73958 KP	54	case FcTypeLangSet:
55ef7dac	55	printf (" ");
4262e0b3	56	FcLangSetPrint (v.u.l);
24330d27	57	break;
88c747e2 KP	58	case FcTypeFTFace:
	59	printf (" face");
	60	break;
24330d27 KP	61	}
	62	}
	63
	64	void
cd2ec1a9	65	FcValueListPrint (FcValueListPtr l)
24330d27	66	{
cd2ec1a9	67	for (; FcValueListPtrU(l); l = FcValueListPtrU(l)->next)
7657345c	68	{
4262e0b3	69	FcValuePrint (FcValueCanonicalize(&FcValueListPtrU(l)->value));
cd2ec1a9	70	switch (FcValueListPtrU(l)->binding) {
602e6b1f	71	case FcValueBindingWeak:
7657345c	72	printf ("(w)");
602e6b1f KP	73	break;
	74	case FcValueBindingStrong:
	75	printf ("(s)");
	76	break;
	77	case FcValueBindingSame:
	78	printf ("(=)");
	79	break;
	80	}
7657345c	81	}
24330d27 KP	82	}
	83
	84	void
55ef7dac KP	85	FcLangSetPrint (const FcLangSet *ls)
	86	{
	87	FcStrBuf buf;
	88	FcChar8 init_buf[1024];
	89
	90	FcStrBufInit (&buf, init_buf, sizeof (init_buf));
	91	if (FcNameUnparseLangSet (&buf, ls) && FcStrBufChar (&buf,'\0'))
cd2ec1a9	92	printf ("%s", buf.buf);
55ef7dac	93	else
cd2ec1a9	94	printf ("langset (alloc error)");
55ef7dac KP	95	FcStrBufDestroy (&buf);
	96	}
	97
	98	void
938bc633	99	FcPatternPrint (const FcPattern *p)
24330d27 KP	100	{
	101	int i;
	102	FcPatternElt *e;
	103
	104	if (!p)
	105	{
	106	printf ("Null pattern\n");
	107	return;
	108	}
b97a34b5	109	printf ("Pattern has %d elts (size %d)\n", p->num, p->size);
24330d27 KP	110	for (i = 0; i < p->num; i++)
24330d27 KP	111	{
cd2ec1a9 PL	112	e = FcPatternEltU(p->elts) + i;
cd2ec1a9 PL	113	printf ("\t%s:", FcObjectPtrU(e->object));
5fe09702 PL	114	/* so that fc-match properly displays file: foo... */
	115	if (e->object == FcObjectToPtr(FC_FILE))
	116	{
	117	FcChar8 * s;
	118	FcPatternGetString (p, FC_FILE, 0, &s);
	119	printf (" \"%s\"", s);
	120	switch (FcValueListPtrU(e->values)->binding) {
	121	case FcValueBindingWeak:
	122	printf ("(w)");
	123	break;
	124	case FcValueBindingStrong:
	125	printf ("(s)");
	126	break;
	127	case FcValueBindingSame:
	128	printf ("(=)");
	129	break;
	130	}
	131	}
	132	else
	133	FcValueListPrint (e->values);
24330d27 KP	134	printf ("\n");
	135	}
	136	printf ("\n");
	137	}
	138
	139	void
	140	FcOpPrint (FcOp op)
	141	{
	142	switch (op) {
	143	case FcOpInteger: printf ("Integer"); break;
	144	case FcOpDouble: printf ("Double"); break;
	145	case FcOpString: printf ("String"); break;
	146	case FcOpMatrix: printf ("Matrix"); break;
	147	case FcOpBool: printf ("Bool"); break;
	148	case FcOpCharSet: printf ("CharSet"); break;
	149	case FcOpField: printf ("Field"); break;
	150	case FcOpConst: printf ("Const"); break;
	151	case FcOpAssign: printf ("Assign"); break;
	152	case FcOpAssignReplace: printf ("AssignReplace"); break;
	153	case FcOpPrepend: printf ("Prepend"); break;
	154	case FcOpPrependFirst: printf ("PrependFirst"); break;
	155	case FcOpAppend: printf ("Append"); break;
	156	case FcOpAppendLast: printf ("AppendLast"); break;
	157	case FcOpQuest: printf ("Quest"); break;
	158	case FcOpOr: printf ("Or"); break;
	159	case FcOpAnd: printf ("And"); break;
	160	case FcOpEqual: printf ("Equal"); break;
24330d27 KP	161	case FcOpNotEqual: printf ("NotEqual"); break;
	162	case FcOpLess: printf ("Less"); break;
	163	case FcOpLessEqual: printf ("LessEqual"); break;
	164	case FcOpMore: printf ("More"); break;
	165	case FcOpMoreEqual: printf ("MoreEqual"); break;
47d4f950 KP	166	case FcOpContains: printf ("Contains"); break;
47d4f950 KP	167	case FcOpNotContains: printf ("NotContains"); break;
24330d27 KP	168	case FcOpPlus: printf ("Plus"); break;
	169	case FcOpMinus: printf ("Minus"); break;
	170	case FcOpTimes: printf ("Times"); break;
	171	case FcOpDivide: printf ("Divide"); break;
	172	case FcOpNot: printf ("Not"); break;
	173	case FcOpNil: printf ("Nil"); break;
	174	case FcOpComma: printf ("Comma"); break;
3f7653c2 KP	175	case FcOpFloor: printf ("Floor"); break;
	176	case FcOpCeil: printf ("Ceil"); break;
	177	case FcOpRound: printf ("Round"); break;
	178	case FcOpTrunc: printf ("Trunc"); break;
74a623e0	179	case FcOpListing: printf ("Listing"); break;
24330d27 KP	180	case FcOpInvalid: printf ("Invalid"); break;
	181	}
	182	}
	183
	184	void
938bc633	185	FcExprPrint (const FcExpr *expr)
24330d27	186	{
662b8796 KP	187	if (!expr) printf ("none");
662b8796 KP	188	else switch (expr->op) {
24330d27 KP	189	case FcOpInteger: printf ("%d", expr->u.ival); break;
	190	case FcOpDouble: printf ("%g", expr->u.dval); break;
	191	case FcOpString: printf ("\"%s\"", expr->u.sval); break;
	192	case FcOpMatrix: printf ("[%g %g %g %g]",
	193	expr->u.mval->xx,
	194	expr->u.mval->xy,
	195	expr->u.mval->yx,
8c96d1fc	196	expr->u.mval->yy); break;
24330d27	197	case FcOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break;
c2e7c611	198	case FcOpCharSet: printf ("charset\n"); break;
8c96d1fc	199	case FcOpNil: printf ("nil\n"); break;
24330d27	200	case FcOpField: printf ("%s", expr->u.field); break;
c2e7c611	201	case FcOpConst: printf ("%s", expr->u.constant); break;
24330d27 KP	202	case FcOpQuest:
	203	FcExprPrint (expr->u.tree.left);
	204	printf (" quest ");
	205	FcExprPrint (expr->u.tree.right->u.tree.left);
	206	printf (" colon ");
	207	FcExprPrint (expr->u.tree.right->u.tree.right);
	208	break;
c2e7c611 KP	209	case FcOpAssign:
	210	case FcOpAssignReplace:
	211	case FcOpPrependFirst:
	212	case FcOpPrepend:
	213	case FcOpAppend:
	214	case FcOpAppendLast:
24330d27 KP	215	case FcOpOr:
	216	case FcOpAnd:
	217	case FcOpEqual:
24330d27 KP	218	case FcOpNotEqual:
	219	case FcOpLess:
	220	case FcOpLessEqual:
	221	case FcOpMore:
	222	case FcOpMoreEqual:
47d4f950	223	case FcOpContains:
74a623e0	224	case FcOpListing:
47d4f950	225	case FcOpNotContains:
24330d27 KP	226	case FcOpPlus:
	227	case FcOpMinus:
	228	case FcOpTimes:
	229	case FcOpDivide:
c2e7c611	230	case FcOpComma:
24330d27 KP	231	FcExprPrint (expr->u.tree.left);
	232	printf (" ");
	233	switch (expr->op) {
c2e7c611 KP	234	case FcOpAssign: printf ("Assign"); break;
	235	case FcOpAssignReplace: printf ("AssignReplace"); break;
	236	case FcOpPrependFirst: printf ("PrependFirst"); break;
	237	case FcOpPrepend: printf ("Prepend"); break;
	238	case FcOpAppend: printf ("Append"); break;
	239	case FcOpAppendLast: printf ("AppendLast"); break;
24330d27 KP	240	case FcOpOr: printf ("Or"); break;
	241	case FcOpAnd: printf ("And"); break;
	242	case FcOpEqual: printf ("Equal"); break;
24330d27 KP	243	case FcOpNotEqual: printf ("NotEqual"); break;
	244	case FcOpLess: printf ("Less"); break;
	245	case FcOpLessEqual: printf ("LessEqual"); break;
	246	case FcOpMore: printf ("More"); break;
	247	case FcOpMoreEqual: printf ("MoreEqual"); break;
47d4f950	248	case FcOpContains: printf ("Contains"); break;
74a623e0	249	case FcOpListing: printf ("Listing"); break;
47d4f950	250	case FcOpNotContains: printf ("NotContains"); break;
24330d27 KP	251	case FcOpPlus: printf ("Plus"); break;
	252	case FcOpMinus: printf ("Minus"); break;
	253	case FcOpTimes: printf ("Times"); break;
	254	case FcOpDivide: printf ("Divide"); break;
c2e7c611	255	case FcOpComma: printf ("Comma"); break;
24330d27 KP	256	default: break;
	257	}
	258	printf (" ");
	259	FcExprPrint (expr->u.tree.right);
	260	break;
	261	case FcOpNot:
	262	printf ("Not ");
	263	FcExprPrint (expr->u.tree.left);
	264	break;
3f7653c2 KP	265	case FcOpFloor:
	266	printf ("Floor ");
	267	FcExprPrint (expr->u.tree.left);
	268	break;
	269	case FcOpCeil:
	270	printf ("Ceil ");
	271	FcExprPrint (expr->u.tree.left);
	272	break;
	273	case FcOpRound:
	274	printf ("Round ");
	275	FcExprPrint (expr->u.tree.left);
	276	break;
	277	case FcOpTrunc:
	278	printf ("Trunc ");
	279	FcExprPrint (expr->u.tree.left);
	280	break;
c2e7c611	281	case FcOpInvalid: printf ("Invalid"); break;
24330d27 KP	282	}
	283	}
	284
	285	void
938bc633	286	FcTestPrint (const FcTest *test)
24330d27	287	{
938bc633 KP	288	switch (test->kind) {
	289	case FcMatchPattern:
	290	printf ("pattern ");
	291	break;
	292	case FcMatchFont:
	293	printf ("font ");
	294	break;
	295	}
24330d27 KP	296	switch (test->qual) {
	297	case FcQualAny:
	298	printf ("any ");
	299	break;
	300	case FcQualAll:
	301	printf ("all ");
	302	break;
6f6563ed KP	303	case FcQualFirst:
	304	printf ("first ");
	305	break;
	306	case FcQualNotFirst:
	307	printf ("not_first ");
	308	break;
24330d27 KP	309	}
	310	printf ("%s ", test->field);
	311	FcOpPrint (test->op);
	312	printf (" ");
	313	FcExprPrint (test->expr);
	314	printf ("\n");
	315	}
	316
	317	void
938bc633	318	FcEditPrint (const FcEdit *edit)
24330d27 KP	319	{
	320	printf ("Edit %s ", edit->field);
	321	FcOpPrint (edit->op);
	322	printf (" ");
	323	FcExprPrint (edit->expr);
	324	}
	325
	326	void
938bc633	327	FcSubstPrint (const FcSubst *subst)
24330d27 KP	328	{
	329	FcEdit *e;
	330	FcTest *t;
	331
	332	printf ("match\n");
	333	for (t = subst->test; t; t = t->next)
	334	{
	335	printf ("\t");
	336	FcTestPrint (t);
	337	}
	338	printf ("edit\n");
	339	for (e = subst->edit; e; e = e->next)
	340	{
	341	printf ("\t");
	342	FcEditPrint (e);
	343	printf (";\n");
	344	}
	345	printf ("\n");
	346	}
	347
	348	void
938bc633	349	FcFontSetPrint (const FcFontSet *s)
24330d27 KP	350	{
	351	int i;
	352
	353	printf ("FontSet %d of %d\n", s->nfont, s->sfont);
	354	for (i = 0; i < s->nfont; i++)
	355	{
	356	printf ("Font %d ", i);
	357	FcPatternPrint (s->fonts[i]);
	358	}
	359	}
	360
b97a34b5 PL	361	int FcDebugVal;
	362
	363	void
	364	FcInitDebug (void)
24330d27	365	{
b97a34b5	366	char *e;
24330d27	367
b97a34b5 PL	368	e = getenv ("FC_DEBUG");
b97a34b5 PL	369	if (e)
24330d27	370	{
b97a34b5 PL	371	printf ("FC_DEBUG=%s\n", e);
	372	FcDebugVal = atoi (e);
	373	if (FcDebugVal < 0)
	374	FcDebugVal = 0;
24330d27	375	}
24330d27	376	}