[fontconfig.git] / src / fcdbg.c

/*
 * fontconfig/src/fcdbg.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 <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 (" ");
	FcCharSetPrint (v.u.c);
	break;
    case FcTypeLangSet:
	printf (" ");
	FcLangSetPrint (v.u.l);
	break;
    case FcTypeFTFace:
	printf (" face");
	break;
    }
}

void
FcValueListPrint (FcValueListPtr l)
{
    for (; l != NULL; l = FcValueListNext(l))
    {
	FcValuePrint (FcValueCanonicalize(&l->value));
	switch (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
FcCharSetPrint (const FcCharSet *c)
{
    int	i, j;
    intptr_t	*leaves = FcCharSetLeaves (c);
    FcChar16	*numbers = FcCharSetNumbers (c);

#if 0
    printf ("CharSet  0x%x\n", (intptr_t) c);
    printf ("Leaves:  +%d = 0x%x\n", c->leaves_offset, (intptr_t) leaves);
    printf ("Numbers: +%d = 0x%x\n", c->numbers_offset, (intptr_t) numbers);

    for (i = 0; i < c->num; i++)
    {
	printf ("Page %d: %04x +%d = 0x%x\n",
		i, numbers[i], leaves[i],
		(intptr_t) FcOffsetToPtr (leaves, leaves[i], FcCharLeaf));
    }
#endif
		
    printf ("\n");
    for (i = 0; i < c->num; i++)
    {
	intptr_t	leaf_offset = leaves[i];
	FcCharLeaf	*leaf = FcOffsetToPtr (leaves, leaf_offset, FcCharLeaf);
	
	printf ("\t");
	printf ("%04x:", numbers[i]);
	for (j = 0; j < 256/32; j++)
	    printf (" %08x", leaf->map[j]);
	printf ("\n");
    }
}

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 = &FcPatternElts(p)[i];
	printf ("\t%s:", FcObjectName(e->object));
	FcValueListPrint (FcPatternEltValues(e));
	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 FcOpRange: printf ("Range"); break;
    case FcOpBool: printf ("Bool"); break;
    case FcOpCharSet: printf ("CharSet"); break;
    case FcOpLangSet: printf ("LangSet"); 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 FcOpRange: break;
    case FcOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break;
    case FcOpCharSet: printf ("charset\n"); break;
    case FcOpLangSet:
	printf ("langset:");
	FcLangSetPrint(expr->u.lval);
	printf ("\n");
	break;
    case FcOpNil: printf ("nil\n"); break;
    case FcOpField: printf ("%s", FcObjectName(expr->u.object)); 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;
    case FcMatchScan:
	printf ("scan ");
	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 ", FcObjectName (test->object));
    FcOpPrint (test->op);
    printf (" ");
    FcExprPrint (test->expr);
    printf ("\n");
}

void
FcEditPrint (const FcEdit *edit)
{
    printf ("Edit %s ", FcObjectName (edit->object));
    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;
    }
}
#define __fcdbg__
#include "fcaliastail.h"
#undef __fcdbg__
Commit	Line	Data
24330d27	1	/*
317b8492	2	* fontconfig/src/fcdbg.c
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
5aaf466d	10	* documentation, and that the name of the author(s) not be used in
24330d27	11	* advertising or publicity pertaining to distribution of the software without
5aaf466d	12	* specific, written prior permission. The authors make no
24330d27 KP	13	* representations about the suitability of this software for any purpose. It
	14	* is provided "as is" without express or implied warranty.
	15	*
3074a73b	16	* THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
24330d27	17	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
3074a73b	18	* EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
24330d27 KP	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;
24330d27 KP	51	case FcTypeCharSet: /* XXX */
7ce19673 KP	52	printf (" ");
7ce19673 KP	53	FcCharSetPrint (v.u.c);
d8d73958 KP	54	break;
d8d73958 KP	55	case FcTypeLangSet:
55ef7dac	56	printf (" ");
4262e0b3	57	FcLangSetPrint (v.u.l);
24330d27	58	break;
88c747e2 KP	59	case FcTypeFTFace:
	60	printf (" face");
	61	break;
24330d27 KP	62	}
	63	}
	64
	65	void
cd2ec1a9	66	FcValueListPrint (FcValueListPtr l)
24330d27	67	{
7ce19673	68	for (; l != NULL; l = FcValueListNext(l))
7657345c	69	{
7ce19673 KP	70	FcValuePrint (FcValueCanonicalize(&l->value));
7ce19673 KP	71	switch (l->binding) {
602e6b1f	72	case FcValueBindingWeak:
7657345c	73	printf ("(w)");
602e6b1f KP	74	break;
	75	case FcValueBindingStrong:
	76	printf ("(s)");
	77	break;
	78	case FcValueBindingSame:
	79	printf ("(=)");
	80	break;
	81	}
7657345c	82	}
24330d27 KP	83	}
	84
	85	void
55ef7dac KP	86	FcLangSetPrint (const FcLangSet *ls)
	87	{
	88	FcStrBuf buf;
	89	FcChar8 init_buf[1024];
594dcef0	90
55ef7dac KP	91	FcStrBufInit (&buf, init_buf, sizeof (init_buf));
55ef7dac KP	92	if (FcNameUnparseLangSet (&buf, ls) && FcStrBufChar (&buf,'\0'))
cd2ec1a9	93	printf ("%s", buf.buf);
55ef7dac	94	else
cd2ec1a9	95	printf ("langset (alloc error)");
55ef7dac KP	96	FcStrBufDestroy (&buf);
	97	}
	98
7ce19673 KP	99	void
	100	FcCharSetPrint (const FcCharSet *c)
	101	{
	102	int i, j;
c0288648 KP	103	intptr_t *leaves = FcCharSetLeaves (c);
c0288648 KP	104	FcChar16 *numbers = FcCharSetNumbers (c);
594dcef0	105
c2c6976d	106	#if 0
c0288648 KP	107	printf ("CharSet 0x%x\n", (intptr_t) c);
	108	printf ("Leaves: +%d = 0x%x\n", c->leaves_offset, (intptr_t) leaves);
	109	printf ("Numbers: +%d = 0x%x\n", c->numbers_offset, (intptr_t) numbers);
594dcef0	110
c0288648 KP	111	for (i = 0; i < c->num; i++)
c0288648 KP	112	{
594dcef0 BE	113	printf ("Page %d: %04x +%d = 0x%x\n",
594dcef0 BE	114	i, numbers[i], leaves[i],
c0288648 KP	115	(intptr_t) FcOffsetToPtr (leaves, leaves[i], FcCharLeaf));
c0288648 KP	116	}
c2c6976d	117	#endif
c0288648	118
7c12181f	119	printf ("\n");
7ce19673 KP	120	for (i = 0; i < c->num; i++)
7ce19673 KP	121	{
c0288648 KP	122	intptr_t leaf_offset = leaves[i];
c0288648 KP	123	FcCharLeaf *leaf = FcOffsetToPtr (leaves, leaf_offset, FcCharLeaf);
7ce19673	124
7c12181f	125	printf ("\t");
c0288648	126	printf ("%04x:", numbers[i]);
7ce19673 KP	127	for (j = 0; j < 256/32; j++)
	128	printf (" %08x", leaf->map[j]);
	129	printf ("\n");
	130	}
	131	}
	132
55ef7dac	133	void
938bc633	134	FcPatternPrint (const FcPattern *p)
24330d27 KP	135	{
	136	int i;
	137	FcPatternElt *e;
594dcef0	138
24330d27 KP	139	if (!p)
	140	{
	141	printf ("Null pattern\n");
	142	return;
	143	}
b97a34b5	144	printf ("Pattern has %d elts (size %d)\n", p->num, p->size);
24330d27 KP	145	for (i = 0; i < p->num; i++)
24330d27 KP	146	{
7ce19673 KP	147	e = &FcPatternElts(p)[i];
7ce19673 KP	148	printf ("\t%s:", FcObjectName(e->object));
f9806ab4	149	FcValueListPrint (FcPatternEltValues(e));
24330d27 KP	150	printf ("\n");
	151	}
	152	printf ("\n");
	153	}
	154
	155	void
	156	FcOpPrint (FcOp op)
	157	{
	158	switch (op) {
	159	case FcOpInteger: printf ("Integer"); break;
	160	case FcOpDouble: printf ("Double"); break;
	161	case FcOpString: printf ("String"); break;
	162	case FcOpMatrix: printf ("Matrix"); break;
857b7efe	163	case FcOpRange: printf ("Range"); break;
24330d27 KP	164	case FcOpBool: printf ("Bool"); break;
24330d27 KP	165	case FcOpCharSet: printf ("CharSet"); break;
3c862aad	166	case FcOpLangSet: printf ("LangSet"); break;
24330d27 KP	167	case FcOpField: printf ("Field"); break;
	168	case FcOpConst: printf ("Const"); break;
	169	case FcOpAssign: printf ("Assign"); break;
	170	case FcOpAssignReplace: printf ("AssignReplace"); break;
	171	case FcOpPrepend: printf ("Prepend"); break;
	172	case FcOpPrependFirst: printf ("PrependFirst"); break;
	173	case FcOpAppend: printf ("Append"); break;
	174	case FcOpAppendLast: printf ("AppendLast"); break;
	175	case FcOpQuest: printf ("Quest"); break;
	176	case FcOpOr: printf ("Or"); break;
	177	case FcOpAnd: printf ("And"); break;
	178	case FcOpEqual: printf ("Equal"); break;
24330d27 KP	179	case FcOpNotEqual: printf ("NotEqual"); break;
	180	case FcOpLess: printf ("Less"); break;
	181	case FcOpLessEqual: printf ("LessEqual"); break;
	182	case FcOpMore: printf ("More"); break;
	183	case FcOpMoreEqual: printf ("MoreEqual"); break;
47d4f950 KP	184	case FcOpContains: printf ("Contains"); break;
47d4f950 KP	185	case FcOpNotContains: printf ("NotContains"); break;
24330d27 KP	186	case FcOpPlus: printf ("Plus"); break;
	187	case FcOpMinus: printf ("Minus"); break;
	188	case FcOpTimes: printf ("Times"); break;
	189	case FcOpDivide: printf ("Divide"); break;
	190	case FcOpNot: printf ("Not"); break;
	191	case FcOpNil: printf ("Nil"); break;
	192	case FcOpComma: printf ("Comma"); break;
3f7653c2 KP	193	case FcOpFloor: printf ("Floor"); break;
	194	case FcOpCeil: printf ("Ceil"); break;
	195	case FcOpRound: printf ("Round"); break;
	196	case FcOpTrunc: printf ("Trunc"); break;
74a623e0	197	case FcOpListing: printf ("Listing"); break;
24330d27 KP	198	case FcOpInvalid: printf ("Invalid"); break;
	199	}
	200	}
	201
	202	void
938bc633	203	FcExprPrint (const FcExpr *expr)
24330d27	204	{
662b8796 KP	205	if (!expr) printf ("none");
662b8796 KP	206	else switch (expr->op) {
24330d27 KP	207	case FcOpInteger: printf ("%d", expr->u.ival); break;
	208	case FcOpDouble: printf ("%g", expr->u.dval); break;
	209	case FcOpString: printf ("\"%s\"", expr->u.sval); break;
	210	case FcOpMatrix: printf ("[%g %g %g %g]",
	211	expr->u.mval->xx,
	212	expr->u.mval->xy,
	213	expr->u.mval->yx,
8c96d1fc	214	expr->u.mval->yy); break;
857b7efe	215	case FcOpRange: break;
24330d27	216	case FcOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break;
c2e7c611	217	case FcOpCharSet: printf ("charset\n"); break;
3c862aad AT	218	case FcOpLangSet:
	219	printf ("langset:");
	220	FcLangSetPrint(expr->u.lval);
	221	printf ("\n");
	222	break;
8c96d1fc	223	case FcOpNil: printf ("nil\n"); break;
7ce19673	224	case FcOpField: printf ("%s", FcObjectName(expr->u.object)); break;
c2e7c611	225	case FcOpConst: printf ("%s", expr->u.constant); break;
24330d27 KP	226	case FcOpQuest:
	227	FcExprPrint (expr->u.tree.left);
	228	printf (" quest ");
	229	FcExprPrint (expr->u.tree.right->u.tree.left);
	230	printf (" colon ");
	231	FcExprPrint (expr->u.tree.right->u.tree.right);
	232	break;
c2e7c611 KP	233	case FcOpAssign:
	234	case FcOpAssignReplace:
	235	case FcOpPrependFirst:
	236	case FcOpPrepend:
	237	case FcOpAppend:
	238	case FcOpAppendLast:
24330d27 KP	239	case FcOpOr:
	240	case FcOpAnd:
	241	case FcOpEqual:
24330d27 KP	242	case FcOpNotEqual:
	243	case FcOpLess:
	244	case FcOpLessEqual:
	245	case FcOpMore:
	246	case FcOpMoreEqual:
47d4f950	247	case FcOpContains:
74a623e0	248	case FcOpListing:
47d4f950	249	case FcOpNotContains:
24330d27 KP	250	case FcOpPlus:
	251	case FcOpMinus:
	252	case FcOpTimes:
	253	case FcOpDivide:
c2e7c611	254	case FcOpComma:
24330d27 KP	255	FcExprPrint (expr->u.tree.left);
	256	printf (" ");
	257	switch (expr->op) {
c2e7c611 KP	258	case FcOpAssign: printf ("Assign"); break;
	259	case FcOpAssignReplace: printf ("AssignReplace"); break;
	260	case FcOpPrependFirst: printf ("PrependFirst"); break;
	261	case FcOpPrepend: printf ("Prepend"); break;
	262	case FcOpAppend: printf ("Append"); break;
	263	case FcOpAppendLast: printf ("AppendLast"); break;
24330d27 KP	264	case FcOpOr: printf ("Or"); break;
	265	case FcOpAnd: printf ("And"); break;
	266	case FcOpEqual: printf ("Equal"); break;
24330d27 KP	267	case FcOpNotEqual: printf ("NotEqual"); break;
	268	case FcOpLess: printf ("Less"); break;
	269	case FcOpLessEqual: printf ("LessEqual"); break;
	270	case FcOpMore: printf ("More"); break;
	271	case FcOpMoreEqual: printf ("MoreEqual"); break;
47d4f950	272	case FcOpContains: printf ("Contains"); break;
74a623e0	273	case FcOpListing: printf ("Listing"); break;
47d4f950	274	case FcOpNotContains: printf ("NotContains"); break;
24330d27 KP	275	case FcOpPlus: printf ("Plus"); break;
	276	case FcOpMinus: printf ("Minus"); break;
	277	case FcOpTimes: printf ("Times"); break;
	278	case FcOpDivide: printf ("Divide"); break;
c2e7c611	279	case FcOpComma: printf ("Comma"); break;
24330d27 KP	280	default: break;
	281	}
	282	printf (" ");
	283	FcExprPrint (expr->u.tree.right);
	284	break;
	285	case FcOpNot:
	286	printf ("Not ");
	287	FcExprPrint (expr->u.tree.left);
	288	break;
3f7653c2 KP	289	case FcOpFloor:
	290	printf ("Floor ");
	291	FcExprPrint (expr->u.tree.left);
	292	break;
	293	case FcOpCeil:
	294	printf ("Ceil ");
	295	FcExprPrint (expr->u.tree.left);
	296	break;
	297	case FcOpRound:
	298	printf ("Round ");
	299	FcExprPrint (expr->u.tree.left);
	300	break;
	301	case FcOpTrunc:
	302	printf ("Trunc ");
	303	FcExprPrint (expr->u.tree.left);
	304	break;
c2e7c611	305	case FcOpInvalid: printf ("Invalid"); break;
24330d27 KP	306	}
	307	}
	308
	309	void
938bc633	310	FcTestPrint (const FcTest *test)
24330d27	311	{
938bc633 KP	312	switch (test->kind) {
	313	case FcMatchPattern:
	314	printf ("pattern ");
	315	break;
	316	case FcMatchFont:
	317	printf ("font ");
	318	break;
c2c6976d KP	319	case FcMatchScan:
	320	printf ("scan ");
	321	break;
938bc633	322	}
24330d27 KP	323	switch (test->qual) {
	324	case FcQualAny:
	325	printf ("any ");
	326	break;
	327	case FcQualAll:
	328	printf ("all ");
	329	break;
6f6563ed KP	330	case FcQualFirst:
	331	printf ("first ");
	332	break;
	333	case FcQualNotFirst:
	334	printf ("not_first ");
	335	break;
24330d27	336	}
7ce19673	337	printf ("%s ", FcObjectName (test->object));
24330d27 KP	338	FcOpPrint (test->op);
	339	printf (" ");
	340	FcExprPrint (test->expr);
	341	printf ("\n");
	342	}
	343
	344	void
938bc633	345	FcEditPrint (const FcEdit *edit)
24330d27	346	{
7ce19673	347	printf ("Edit %s ", FcObjectName (edit->object));
24330d27 KP	348	FcOpPrint (edit->op);
	349	printf (" ");
	350	FcExprPrint (edit->expr);
	351	}
	352
	353	void
938bc633	354	FcSubstPrint (const FcSubst *subst)
24330d27 KP	355	{
	356	FcEdit *e;
	357	FcTest *t;
594dcef0	358
24330d27 KP	359	printf ("match\n");
	360	for (t = subst->test; t; t = t->next)
	361	{
	362	printf ("\t");
	363	FcTestPrint (t);
	364	}
	365	printf ("edit\n");
	366	for (e = subst->edit; e; e = e->next)
	367	{
	368	printf ("\t");
	369	FcEditPrint (e);
	370	printf (";\n");
	371	}
	372	printf ("\n");
	373	}
	374
	375	void
938bc633	376	FcFontSetPrint (const FcFontSet *s)
24330d27 KP	377	{
	378	int i;
	379
	380	printf ("FontSet %d of %d\n", s->nfont, s->sfont);
	381	for (i = 0; i < s->nfont; i++)
	382	{
	383	printf ("Font %d ", i);
	384	FcPatternPrint (s->fonts[i]);
	385	}
	386	}
	387
b97a34b5 PL	388	int FcDebugVal;
	389
	390	void
	391	FcInitDebug (void)
24330d27	392	{
b97a34b5	393	char *e;
24330d27	394
b97a34b5 PL	395	e = getenv ("FC_DEBUG");
b97a34b5 PL	396	if (e)
24330d27	397	{
b97a34b5 PL	398	printf ("FC_DEBUG=%s\n", e);
	399	FcDebugVal = atoi (e);
	400	if (FcDebugVal < 0)
	401	FcDebugVal = 0;
24330d27	402	}
24330d27	403	}
23816bf9 KP	404	#define __fcdbg__
	405	#include "fcaliastail.h"
	406	#undef __fcdbg__