/work/workdir/UnpackedTarball/fontconfig/src/fcdbg.c

Source (jump to first uncovered line)
/*
 * 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>

static void
_FcValuePrintFile (FILE *f, const FcValue v)
{
    switch (v.type) {
    case FcTypeUnknown:
  fprintf (f, "<unknown>");
  break;
    case FcTypeVoid:
  fprintf (f, "<void>");
  break;
    case FcTypeInteger:
  fprintf (f, "%d(i)", v.u.i);
  break;
    case FcTypeDouble:
  fprintf (f, "%g(f)", v.u.d);
  break;
    case FcTypeString:
  fprintf (f, "\"%s\"", v.u.s);
  break;
    case FcTypeBool:
  fprintf (f,
           v.u.b == FcTrue ? "True" : v.u.b == FcFalse ? "False"
                                                       : "DontCare");
  break;
    case FcTypeMatrix:
  fprintf (f, "[%g %g; %g %g]", v.u.m->xx, v.u.m->xy, v.u.m->yx, v.u.m->yy);
  break;
    case FcTypeCharSet: /* XXX */
  if (f == stdout)
      FcCharSetPrint (v.u.c);
  break;
    case FcTypeLangSet:
  FcLangSetPrint (v.u.l);
  break;
    case FcTypeFTFace:
  fprintf (f, "face");
  break;
    case FcTypeRange:
  fprintf (f, "[%g %g]", v.u.r->begin, v.u.r->end);
  break;
    }
}

void
FcValuePrintFile (FILE *f, const FcValue v)
{
    fprintf (f, " ");
    _FcValuePrintFile (f, v);
}

void
FcValuePrint (const FcValue v)
{
    printf (" ");
    _FcValuePrintFile (stdout, v);
}

void
FcValuePrintWithPosition (const FcValue v, FcBool show_pos_mark)
{
    if (show_pos_mark)
  printf (" [marker] ");
    else
  printf (" ");
    _FcValuePrintFile (stdout, v);
}

static void
FcValueBindingPrint (const FcValueListPtr l)
{
    switch (l->binding) {
    case FcValueBindingWeak:
  printf ("(w)");
  break;
    case FcValueBindingStrong:
  printf ("(s)");
  break;
    case FcValueBindingSame:
  printf ("(=)");
  break;
    default:
  /* shouldn't be reached */
  printf ("(?)");
  break;
    }
}

void
FcValueListPrintWithPosition (FcValueListPtr l, const FcValueListPtr pos)
{
    for (; l != NULL; l = FcValueListNext (l)) {
  FcValuePrintWithPosition (FcValueCanonicalize (&l->value), pos != NULL && l == pos);
  FcValueBindingPrint (l);
    }
    if (!pos)
  printf (" [marker]");
}

void
FcValueListPrint (FcValueListPtr l)
{
    for (; l != NULL; l = FcValueListNext (l)) {
  FcValuePrint (FcValueCanonicalize (&l->value));
  FcValueBindingPrint (l);
    }
}

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)
{
    FcPatternIter iter;

    if (!p) {
  printf ("Null pattern\n");
  return;
    }
    printf ("Pattern has %d elts (size %d)\n", FcPatternObjectCount (p), p->size);
    FcPatternIterStart (p, &iter);
    do {
  printf ("\t%s:", FcPatternIterGetObject (p, &iter));
  FcValueListPrint (FcPatternIterGetValues (p, &iter));
  printf ("\n");
    } while (FcPatternIterNext (p, &iter));
    printf ("\n");
}

#define FcOpFlagsPrint(_o_)             \
    {                                   \
  int f = FC_OP_GET_FLAGS (_o_);  \
  if (f & FcOpFlagIgnoreBlanks)   \
      printf ("(ignore blanks)"); \
    }

void
FcPatternPrint2 (FcPattern         *pp1,
                 FcPattern         *pp2,
                 const FcObjectSet *os)
{
    int           i, j, k, pos;
    FcPatternElt *e1, *e2;
    FcPattern    *p1, *p2;

    if (os) {
  p1 = FcPatternFilter (pp1, os);
  p2 = FcPatternFilter (pp2, os);
    } else {
  p1 = pp1;
  p2 = pp2;
    }
    printf ("Pattern has %d elts (size %d), %d elts (size %d)\n",
            p1->num, p1->size, p2->num, p2->size);
    for (i = 0, j = 0; i < p1->num; i++) {
  e1 = &FcPatternElts (p1)[i];
  e2 = &FcPatternElts (p2)[j];
  if (!e2 || e1->object != e2->object) {
      pos = FcPatternPosition (p2, FcObjectName (e1->object));
      if (pos >= 0) {
    for (k = j; k < pos; k++) {
        e2 = &FcPatternElts (p2)[k];
        printf ("\t%s: (None) -> ", FcObjectName (e2->object));
        FcValueListPrint (FcPatternEltValues (e2));
        printf ("\n");
    }
    j = pos;
    goto cont;
      } else {
    printf ("\t%s:", FcObjectName (e1->object));
    FcValueListPrint (FcPatternEltValues (e1));
    printf (" -> (None)\n");
      }
  } else {
  cont:
      printf ("\t%s:", FcObjectName (e1->object));
      FcValueListPrint (FcPatternEltValues (e1));
      printf (" -> ");
      e2 = &FcPatternElts (p2)[j];
      FcValueListPrint (FcPatternEltValues (e2));
      printf ("\n");
      j++;
  }
    }
    if (j < p2->num) {
  for (k = j; k < p2->num; k++) {
      e2 = &FcPatternElts (p2)[k];
      if (FcObjectName (e2->object)) {
    printf ("\t%s: (None) -> ", FcObjectName (e2->object));
    FcValueListPrint (FcPatternEltValues (e2));
    printf ("\n");
      }
  }
    }
    if (p1 != pp1)
  FcPatternDestroy (p1);
    if (p2 != pp2)
  FcPatternDestroy (p2);
}

void
FcOpPrint (FcOp op_)
{
    FcOp op = FC_OP_GET_OP (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 FcOpDelete: printf ("Delete"); break;
    case FcOpDeleteAll: printf ("DeleteAll"); break;
    case FcOpQuest: printf ("Quest"); break;
    case FcOpOr: printf ("Or"); break;
    case FcOpAnd: printf ("And"); break;
    case FcOpEqual:
  printf ("Equal");
  FcOpFlagsPrint (op_);
  break;
    case FcOpNotEqual:
  printf ("NotEqual");
  FcOpFlagsPrint (op_);
  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");
  FcOpFlagsPrint (op_);
  break;
    case FcOpInvalid: printf ("Invalid"); break;
    }
}

void
FcExprPrint (const FcExpr *expr)
{
    if (!expr)
  printf ("none");
    else
  switch (FC_OP_GET_OP (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 ("[");
      FcExprPrint (expr->u.mexpr->xx);
      printf (" ");
      FcExprPrint (expr->u.mexpr->xy);
      printf ("; ");
      FcExprPrint (expr->u.mexpr->yx);
      printf (" ");
      FcExprPrint (expr->u.mexpr->yy);
      printf ("]");
      break;
  case FcOpRange:
      printf ("(%g, %g)", expr->u.rval->begin, expr->u.rval->end);
      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.name.object));
      switch ((int)expr->u.name.kind) {
      case FcMatchPattern:
    printf ("(pattern) ");
    break;
      case FcMatchFont:
    printf ("(font) ");
    break;
      }
      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 (FC_OP_GET_OP (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");
    FcOpFlagsPrint (expr->op);
    break;
      case FcOpNotEqual:
    printf ("NotEqual");
    FcOpFlagsPrint (expr->op);
    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");
    FcOpFlagsPrint (expr->op);
    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;
    case FcMatchKindEnd:
  /* shouldn't be reached */
  return;
    }
    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
FcRulePrint (const FcRule *rule)
{
    FcRuleType    last_type = FcRuleUnknown;
    const FcRule *r;

    for (r = rule; r; r = r->next) {
  if (last_type != r->type) {
      switch (r->type) {
      case FcRuleTest:
    printf ("[test]\n");
    break;
      case FcRuleEdit:
    printf ("[edit]\n");
    break;
      default:
    break;
      }
      last_type = r->type;
  }
  printf ("\t");
  switch (r->type) {
  case FcRuleTest:
      FcTestPrint (r->u.test);
      break;
  case FcRuleEdit:
      FcEditPrint (r->u.edit);
      printf (";\n");
      break;
  default:
      break;
  }
    }
    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)
{
    if (!FcDebugVal) {
  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__

Coverage Report

Created: 2025-07-07 10:01

Line	Count	Source (jump to first uncovered line)
1		/*
2		* fontconfig/src/fcdbg.c
3		*
4		* Copyright © 2000 Keith Packard
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 the author(s) not be used in
11		* advertising or publicity pertaining to distribution of the software without
12		* specific, written prior permission. The authors make 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		* THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17		* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18		* EVENT SHALL THE AUTHOR(S) 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
25		#include "fcint.h"
26
27		#include <stdio.h>
28		#include <stdlib.h>
29
30		static void
31		_FcValuePrintFile (FILE *f, const FcValue v)
32	0	{
33	0	switch (v.type) {
34	0	case FcTypeUnknown:
35	0	fprintf (f, "<unknown>");
36	0	break;
37	0	case FcTypeVoid:
38	0	fprintf (f, "<void>");
39	0	break;
40	0	case FcTypeInteger:
41	0	fprintf (f, "%d(i)", v.u.i);
42	0	break;
43	0	case FcTypeDouble:
44	0	fprintf (f, "%g(f)", v.u.d);
45	0	break;
46	0	case FcTypeString:
47	0	fprintf (f, "\"%s\"", v.u.s);
48	0	break;
49	0	case FcTypeBool:
50	0	fprintf (f,
51	0	v.u.b == FcTrue ? "True" : v.u.b == FcFalse ? "False"
52	0	: "DontCare");
53	0	break;
54	0	case FcTypeMatrix:
55	0	fprintf (f, "[%g %g; %g %g]", v.u.m->xx, v.u.m->xy, v.u.m->yx, v.u.m->yy);
56	0	break;
57	0	case FcTypeCharSet: /* XXX */
58	0	if (f == stdout)
59	0	FcCharSetPrint (v.u.c);
60	0	break;
61	0	case FcTypeLangSet:
62	0	FcLangSetPrint (v.u.l);
63	0	break;
64	0	case FcTypeFTFace:
65	0	fprintf (f, "face");
66	0	break;
67	0	case FcTypeRange:
68	0	fprintf (f, "[%g %g]", v.u.r->begin, v.u.r->end);
69	0	break;
70	0	}
71	0	}
72
73		void
74		FcValuePrintFile (FILE *f, const FcValue v)
75	0	{
76	0	fprintf (f, " ");
77	0	_FcValuePrintFile (f, v);
78	0	}
79
80		void
81		FcValuePrint (const FcValue v)
82	0	{
83	0	printf (" ");
84	0	_FcValuePrintFile (stdout, v);
85	0	}
86
87		void
88		FcValuePrintWithPosition (const FcValue v, FcBool show_pos_mark)
89	0	{
90	0	if (show_pos_mark)
91	0	printf (" [marker] ");
92	0	else
93	0	printf (" ");
94	0	_FcValuePrintFile (stdout, v);
95	0	}
96
97		static void
98		FcValueBindingPrint (const FcValueListPtr l)
99	0	{
100	0	switch (l->binding) {
101	0	case FcValueBindingWeak:
102	0	printf ("(w)");
103	0	break;
104	0	case FcValueBindingStrong:
105	0	printf ("(s)");
106	0	break;
107	0	case FcValueBindingSame:
108	0	printf ("(=)");
109	0	break;
110	0	default:
111		/* shouldn't be reached */
112	0	printf ("(?)");
113	0	break;
114	0	}
115	0	}
116
117		void
118		FcValueListPrintWithPosition (FcValueListPtr l, const FcValueListPtr pos)
119	0	{
120	0	for (; l != NULL; l = FcValueListNext (l)) {
121	0	FcValuePrintWithPosition (FcValueCanonicalize (&l->value), pos != NULL && l == pos);
122	0	FcValueBindingPrint (l);
123	0	}
124	0	if (!pos)
125	0	printf (" [marker]");
126	0	}
127
128		void
129		FcValueListPrint (FcValueListPtr l)
130	0	{
131	0	for (; l != NULL; l = FcValueListNext (l)) {
132	0	FcValuePrint (FcValueCanonicalize (&l->value));
133	0	FcValueBindingPrint (l);
134	0	}
135	0	}
136
137		void
138		FcLangSetPrint (const FcLangSet *ls)
139	0	{
140	0	FcStrBuf buf;
141	0	FcChar8 init_buf[1024];
142
143	0	FcStrBufInit (&buf, init_buf, sizeof (init_buf));
144	0	if (FcNameUnparseLangSet (&buf, ls) && FcStrBufChar (&buf, '\0'))
145	0	printf ("%s", buf.buf);
146	0	else
147	0	printf ("langset (alloc error)");
148	0	FcStrBufDestroy (&buf);
149	0	}
150
151		void
152		FcCharSetPrint (const FcCharSet *c)
153	0	{
154	0	int i, j;
155	0	intptr_t *leaves = FcCharSetLeaves (c);
156	0	FcChar16 *numbers = FcCharSetNumbers (c);
157
158		#if 0
159		printf ("CharSet 0x%x\n", (intptr_t) c);
160		printf ("Leaves: +%d = 0x%x\n", c->leaves_offset, (intptr_t) leaves);
161		printf ("Numbers: +%d = 0x%x\n", c->numbers_offset, (intptr_t) numbers);
162
163		for (i = 0; i < c->num; i++)
164		{
165		printf ("Page %d: %04x +%d = 0x%x\n",
166		i, numbers[i], leaves[i],
167		(intptr_t) FcOffsetToPtr (leaves, leaves[i], FcCharLeaf));
168		}
169		#endif
170
171	0	printf ("\n");
172	0	for (i = 0; i < c->num; i++) {
173	0	intptr_t leaf_offset = leaves[i];
174	0	FcCharLeaf *leaf = FcOffsetToPtr (leaves, leaf_offset, FcCharLeaf);
175
176	0	printf ("\t");
177	0	printf ("%04x:", numbers[i]);
178	0	for (j = 0; j < 256 / 32; j++)
179	0	printf (" %08x", leaf->map[j]);
180	0	printf ("\n");
181	0	}
182	0	}
183
184		void
185		FcPatternPrint (const FcPattern *p)
186	0	{
187	0	FcPatternIter iter;
188
189	0	if (!p) {
190	0	printf ("Null pattern\n");
191	0	return;
192	0	}
193	0	printf ("Pattern has %d elts (size %d)\n", FcPatternObjectCount (p), p->size);
194	0	FcPatternIterStart (p, &iter);
195	0	do {
196	0	printf ("\t%s:", FcPatternIterGetObject (p, &iter));
197	0	FcValueListPrint (FcPatternIterGetValues (p, &iter));
198	0	printf ("\n");
199	0	} while (FcPatternIterNext (p, &iter));
200	0	printf ("\n");
201	0	}
202
203		#define FcOpFlagsPrint(_o_) \
204	0	{ \
205	0	int f = FC_OP_GET_FLAGS (_o_); \
206	0	if (f & FcOpFlagIgnoreBlanks) \
207	0	printf ("(ignore blanks)"); \
208	0	}
209
210		void
211		FcPatternPrint2 (FcPattern *pp1,
212		FcPattern *pp2,
213		const FcObjectSet *os)
214	0	{
215	0	int i, j, k, pos;
216	0	FcPatternElt e1, e2;
217	0	FcPattern p1, p2;
218
219	0	if (os) {
220	0	p1 = FcPatternFilter (pp1, os);
221	0	p2 = FcPatternFilter (pp2, os);
222	0	} else {
223	0	p1 = pp1;
224	0	p2 = pp2;
225	0	}
226	0	printf ("Pattern has %d elts (size %d), %d elts (size %d)\n",
227	0	p1->num, p1->size, p2->num, p2->size);
228	0	for (i = 0, j = 0; i < p1->num; i++) {
229	0	e1 = &FcPatternElts (p1)[i];
230	0	e2 = &FcPatternElts (p2)[j];
231	0	if (!e2 \|\| e1->object != e2->object) {
232	0	pos = FcPatternPosition (p2, FcObjectName (e1->object));
233	0	if (pos >= 0) {
234	0	for (k = j; k < pos; k++) {
235	0	e2 = &FcPatternElts (p2)[k];
236	0	printf ("\t%s: (None) -> ", FcObjectName (e2->object));
237	0	FcValueListPrint (FcPatternEltValues (e2));
238	0	printf ("\n");
239	0	}
240	0	j = pos;
241	0	goto cont;
242	0	} else {
243	0	printf ("\t%s:", FcObjectName (e1->object));
244	0	FcValueListPrint (FcPatternEltValues (e1));
245	0	printf (" -> (None)\n");
246	0	}
247	0	} else {
248	0	cont:
249	0	printf ("\t%s:", FcObjectName (e1->object));
250	0	FcValueListPrint (FcPatternEltValues (e1));
251	0	printf (" -> ");
252	0	e2 = &FcPatternElts (p2)[j];
253	0	FcValueListPrint (FcPatternEltValues (e2));
254	0	printf ("\n");
255	0	j++;
256	0	}
257	0	}
258	0	if (j < p2->num) {
259	0	for (k = j; k < p2->num; k++) {
260	0	e2 = &FcPatternElts (p2)[k];
261	0	if (FcObjectName (e2->object)) {
262	0	printf ("\t%s: (None) -> ", FcObjectName (e2->object));
263	0	FcValueListPrint (FcPatternEltValues (e2));
264	0	printf ("\n");
265	0	}
266	0	}
267	0	}
268	0	if (p1 != pp1)
269	0	FcPatternDestroy (p1);
270	0	if (p2 != pp2)
271	0	FcPatternDestroy (p2);
272	0	}
273
274		void
275		FcOpPrint (FcOp op_)
276	0	{
277	0	FcOp op = FC_OP_GET_OP (op_);
278
279	0	switch (op) {
280	0	case FcOpInteger: printf ("Integer"); break;
281	0	case FcOpDouble: printf ("Double"); break;
282	0	case FcOpString: printf ("String"); break;
283	0	case FcOpMatrix: printf ("Matrix"); break;
284	0	case FcOpRange: printf ("Range"); break;
285	0	case FcOpBool: printf ("Bool"); break;
286	0	case FcOpCharSet: printf ("CharSet"); break;
287	0	case FcOpLangSet: printf ("LangSet"); break;
288	0	case FcOpField: printf ("Field"); break;
289	0	case FcOpConst: printf ("Const"); break;
290	0	case FcOpAssign: printf ("Assign"); break;
291	0	case FcOpAssignReplace: printf ("AssignReplace"); break;
292	0	case FcOpPrepend: printf ("Prepend"); break;
293	0	case FcOpPrependFirst: printf ("PrependFirst"); break;
294	0	case FcOpAppend: printf ("Append"); break;
295	0	case FcOpAppendLast: printf ("AppendLast"); break;
296	0	case FcOpDelete: printf ("Delete"); break;
297	0	case FcOpDeleteAll: printf ("DeleteAll"); break;
298	0	case FcOpQuest: printf ("Quest"); break;
299	0	case FcOpOr: printf ("Or"); break;
300	0	case FcOpAnd: printf ("And"); break;
301	0	case FcOpEqual:
302	0	printf ("Equal");
303	0	FcOpFlagsPrint (op_);
304	0	break;
305	0	case FcOpNotEqual:
306	0	printf ("NotEqual");
307	0	FcOpFlagsPrint (op_);
308	0	break;
309	0	case FcOpLess: printf ("Less"); break;
310	0	case FcOpLessEqual: printf ("LessEqual"); break;
311	0	case FcOpMore: printf ("More"); break;
312	0	case FcOpMoreEqual: printf ("MoreEqual"); break;
313	0	case FcOpContains: printf ("Contains"); break;
314	0	case FcOpNotContains: printf ("NotContains"); break;
315	0	case FcOpPlus: printf ("Plus"); break;
316	0	case FcOpMinus: printf ("Minus"); break;
317	0	case FcOpTimes: printf ("Times"); break;
318	0	case FcOpDivide: printf ("Divide"); break;
319	0	case FcOpNot: printf ("Not"); break;
320	0	case FcOpNil: printf ("Nil"); break;
321	0	case FcOpComma: printf ("Comma"); break;
322	0	case FcOpFloor: printf ("Floor"); break;
323	0	case FcOpCeil: printf ("Ceil"); break;
324	0	case FcOpRound: printf ("Round"); break;
325	0	case FcOpTrunc: printf ("Trunc"); break;
326	0	case FcOpListing:
327	0	printf ("Listing");
328	0	FcOpFlagsPrint (op_);
329	0	break;
330	0	case FcOpInvalid: printf ("Invalid"); break;
331	0	}
332	0	}
333
334		void
335		FcExprPrint (const FcExpr *expr)
336	0	{
337	0	if (!expr)
338	0	printf ("none");
339	0	else
340	0	switch (FC_OP_GET_OP (expr->op)) {
341	0	case FcOpInteger: printf ("%d", expr->u.ival); break;
342	0	case FcOpDouble: printf ("%g", expr->u.dval); break;
343	0	case FcOpString: printf ("\"%s\"", expr->u.sval); break;
344	0	case FcOpMatrix:
345	0	printf ("[");
346	0	FcExprPrint (expr->u.mexpr->xx);
347	0	printf (" ");
348	0	FcExprPrint (expr->u.mexpr->xy);
349	0	printf ("; ");
350	0	FcExprPrint (expr->u.mexpr->yx);
351	0	printf (" ");
352	0	FcExprPrint (expr->u.mexpr->yy);
353	0	printf ("]");
354	0	break;
355	0	case FcOpRange:
356	0	printf ("(%g, %g)", expr->u.rval->begin, expr->u.rval->end);
357	0	break;
358	0	case FcOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break;
359	0	case FcOpCharSet: printf ("charset\n"); break;
360	0	case FcOpLangSet:
361	0	printf ("langset:");
362	0	FcLangSetPrint (expr->u.lval);
363	0	printf ("\n");
364	0	break;
365	0	case FcOpNil: printf ("nil\n"); break;
366	0	case FcOpField:
367	0	printf ("%s ", FcObjectName (expr->u.name.object));
368	0	switch ((int)expr->u.name.kind) {
369	0	case FcMatchPattern:
370	0	printf ("(pattern) ");
371	0	break;
372	0	case FcMatchFont:
373	0	printf ("(font) ");
374	0	break;
375	0	}
376	0	break;
377	0	case FcOpConst: printf ("%s", expr->u.constant); break;
378	0	case FcOpQuest:
379	0	FcExprPrint (expr->u.tree.left);
380	0	printf (" quest ");
381	0	FcExprPrint (expr->u.tree.right->u.tree.left);
382	0	printf (" colon ");
383	0	FcExprPrint (expr->u.tree.right->u.tree.right);
384	0	break;
385	0	case FcOpAssign:
386	0	case FcOpAssignReplace:
387	0	case FcOpPrependFirst:
388	0	case FcOpPrepend:
389	0	case FcOpAppend:
390	0	case FcOpAppendLast:
391	0	case FcOpOr:
392	0	case FcOpAnd:
393	0	case FcOpEqual:
394	0	case FcOpNotEqual:
395	0	case FcOpLess:
396	0	case FcOpLessEqual:
397	0	case FcOpMore:
398	0	case FcOpMoreEqual:
399	0	case FcOpContains:
400	0	case FcOpListing:
401	0	case FcOpNotContains:
402	0	case FcOpPlus:
403	0	case FcOpMinus:
404	0	case FcOpTimes:
405	0	case FcOpDivide:
406	0	case FcOpComma:
407	0	FcExprPrint (expr->u.tree.left);
408	0	printf (" ");
409	0	switch (FC_OP_GET_OP (expr->op)) {
410	0	case FcOpAssign: printf ("Assign"); break;
411	0	case FcOpAssignReplace: printf ("AssignReplace"); break;
412	0	case FcOpPrependFirst: printf ("PrependFirst"); break;
413	0	case FcOpPrepend: printf ("Prepend"); break;
414	0	case FcOpAppend: printf ("Append"); break;
415	0	case FcOpAppendLast: printf ("AppendLast"); break;
416	0	case FcOpOr: printf ("Or"); break;
417	0	case FcOpAnd: printf ("And"); break;
418	0	case FcOpEqual:
419	0	printf ("Equal");
420	0	FcOpFlagsPrint (expr->op);
421	0	break;
422	0	case FcOpNotEqual:
423	0	printf ("NotEqual");
424	0	FcOpFlagsPrint (expr->op);
425	0	break;
426	0	case FcOpLess: printf ("Less"); break;
427	0	case FcOpLessEqual: printf ("LessEqual"); break;
428	0	case FcOpMore: printf ("More"); break;
429	0	case FcOpMoreEqual: printf ("MoreEqual"); break;
430	0	case FcOpContains: printf ("Contains"); break;
431	0	case FcOpListing:
432	0	printf ("Listing");
433	0	FcOpFlagsPrint (expr->op);
434	0	break;
435	0	case FcOpNotContains: printf ("NotContains"); break;
436	0	case FcOpPlus: printf ("Plus"); break;
437	0	case FcOpMinus: printf ("Minus"); break;
438	0	case FcOpTimes: printf ("Times"); break;
439	0	case FcOpDivide: printf ("Divide"); break;
440	0	case FcOpComma: printf ("Comma"); break;
441	0	default: break;
442	0	}
443	0	printf (" ");
444	0	FcExprPrint (expr->u.tree.right);
445	0	break;
446	0	case FcOpNot:
447	0	printf ("Not ");
448	0	FcExprPrint (expr->u.tree.left);
449	0	break;
450	0	case FcOpFloor:
451	0	printf ("Floor ");
452	0	FcExprPrint (expr->u.tree.left);
453	0	break;
454	0	case FcOpCeil:
455	0	printf ("Ceil ");
456	0	FcExprPrint (expr->u.tree.left);
457	0	break;
458	0	case FcOpRound:
459	0	printf ("Round ");
460	0	FcExprPrint (expr->u.tree.left);
461	0	break;
462	0	case FcOpTrunc:
463	0	printf ("Trunc ");
464	0	FcExprPrint (expr->u.tree.left);
465	0	break;
466	0	case FcOpInvalid: printf ("Invalid"); break;
467	0	}
468	0	}
469
470		void
471		FcTestPrint (const FcTest *test)
472	0	{
473	0	switch (test->kind) {
474	0	case FcMatchPattern:
475	0	printf ("pattern ");
476	0	break;
477	0	case FcMatchFont:
478	0	printf ("font ");
479	0	break;
480	0	case FcMatchScan:
481	0	printf ("scan ");
482	0	break;
483	0	case FcMatchKindEnd:
484		/* shouldn't be reached */
485	0	return;
486	0	}
487	0	switch (test->qual) {
488	0	case FcQualAny:
489	0	printf ("any ");
490	0	break;
491	0	case FcQualAll:
492	0	printf ("all ");
493	0	break;
494	0	case FcQualFirst:
495	0	printf ("first ");
496	0	break;
497	0	case FcQualNotFirst:
498	0	printf ("not_first ");
499	0	break;
500	0	}
501	0	printf ("%s ", FcObjectName (test->object));
502	0	FcOpPrint (test->op);
503	0	printf (" ");
504	0	FcExprPrint (test->expr);
505	0	printf ("\n");
506	0	}
507
508		void
509		FcEditPrint (const FcEdit *edit)
510	0	{
511	0	printf ("Edit %s ", FcObjectName (edit->object));
512	0	FcOpPrint (edit->op);
513	0	printf (" ");
514	0	FcExprPrint (edit->expr);
515	0	}
516
517		void
518		FcRulePrint (const FcRule *rule)
519	0	{
520	0	FcRuleType last_type = FcRuleUnknown;
521	0	const FcRule *r;
522
523	0	for (r = rule; r; r = r->next) {
524	0	if (last_type != r->type) {
525	0	switch (r->type) {
526	0	case FcRuleTest:
527	0	printf ("[test]\n");
528	0	break;
529	0	case FcRuleEdit:
530	0	printf ("[edit]\n");
531	0	break;
532	0	default:
533	0	break;
534	0	}
535	0	last_type = r->type;
536	0	}
537	0	printf ("\t");
538	0	switch (r->type) {
539	0	case FcRuleTest:
540	0	FcTestPrint (r->u.test);
541	0	break;
542	0	case FcRuleEdit:
543	0	FcEditPrint (r->u.edit);
544	0	printf (";\n");
545	0	break;
546	0	default:
547	0	break;
548	0	}
549	0	}
550	0	printf ("\n");
551	0	}
552
553		void
554		FcFontSetPrint (const FcFontSet *s)
555	0	{
556	0	int i;
557
558	0	printf ("FontSet %d of %d\n", s->nfont, s->sfont);
559	0	for (i = 0; i < s->nfont; i++) {
560	0	printf ("Font %d ", i);
561	0	FcPatternPrint (s->fonts[i]);
562	0	}
563	0	}
564
565		int FcDebugVal;
566
567		void
568		FcInitDebug (void)
569	238	{
570	238	if (!FcDebugVal) {
571	238	char *e;
572
573	238	e = getenv ("FC_DEBUG");
574	238	if (e) {
575	0	printf ("FC_DEBUG=%s\n", e);
576	0	FcDebugVal = atoi (e);
577	0	if (FcDebugVal < 0)
578	0	FcDebugVal = 0;
579	0	}
580	238	}
581	238	}
582		#define __fcdbg__
583		#include "fcaliastail.h"
584		#undef __fcdbg__