src/fcdbg.c

   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 #include <stdio.h>
  27 #include <stdlib.h>
  28
  29 static void
  30 _FcValuePrint (const FcValue v)
  31 {
  32     switch (v.type) {
  33     case FcTypeVoid:
  34         printf ("<void>");
  35         break;
  36     case FcTypeInteger:
  37         printf ("%d(i)", v.u.i);
  38         break;
  39     case FcTypeDouble:
  40         printf ("%g(f)", v.u.d);
  41         break;
  42     case FcTypeString:
  43         printf ("\"%s\"", v.u.s);
  44         break;
  45     case FcTypeBool:
  46         printf ("%s", v.u.b ? "FcTrue" : "FcFalse");
  47         break;
  48     case FcTypeMatrix:
  49         printf ("(%f %f; %f %f)", v.u.m->xx, v.u.m->xy, v.u.m->yx, v.u.m->yy);
  50         break;
  51     case FcTypeCharSet: /* XXX */
  52         FcCharSetPrint (v.u.c);
  53         break;
  54     case FcTypeLangSet:
  55         FcLangSetPrint (v.u.l);
  56         break;
  57     case FcTypeFTFace:
  58         printf ("face");
  59         break;
  60     }
  61 }
  62
  63 void
  64 FcValuePrint (const FcValue v)
  65 {
  66     printf (" ");
  67     _FcValuePrint (v);
  68 }
  69
  70 void
  71 FcValuePrintWithPosition (const FcValue v, FcBool show_pos_mark)
  72 {
  73     if (show_pos_mark)
  74         printf (" [insert here] ");
  75     else
  76         printf (" ");
  77     _FcValuePrint (v);
  78 }
  79
  80 static void
  81 FcValueBindingPrint (const FcValueListPtr l)
  82 {
  83     switch (l->binding) {
  84     case FcValueBindingWeak:
  85         printf ("(w)");
  86         break;
  87     case FcValueBindingStrong:
  88         printf ("(s)");
  89         break;
  90     case FcValueBindingSame:
  91         printf ("(=)");
  92         break;
  93     }
  94 }
  95
  96 void
  97 FcValueListPrintWithPosition (FcValueListPtr l, const FcValueListPtr pos)
  98 {
  99     for (; l != NULL; l = FcValueListNext(l))
 100     {
 101         FcValuePrintWithPosition (FcValueCanonicalize (&l->value), pos != NULL && l == pos);
 102         FcValueBindingPrint (l);
 103     }
 104     if (!pos)
 105         printf (" [insert here]");
 106 }
 107
 108 void
 109 FcValueListPrint (FcValueListPtr l)
 110 {
 111     for (; l != NULL; l = FcValueListNext(l))
 112     {
 113         FcValuePrint (FcValueCanonicalize (&l->value));
 114         FcValueBindingPrint (l);
 115     }
 116 }
 117
 118 void
 119 FcLangSetPrint (const FcLangSet *ls)
 120 {
 121     FcStrBuf    buf;
 122     FcChar8     init_buf[1024];
 123
 124     FcStrBufInit (&buf, init_buf, sizeof (init_buf));
 125     if (FcNameUnparseLangSet (&buf, ls) && FcStrBufChar (&buf,'\0'))
 126        printf ("%s", buf.buf);
 127     else
 128        printf ("langset (alloc error)");
 129     FcStrBufDestroy (&buf);
 130 }
 131
 132 void
 133 FcCharSetPrint (const FcCharSet *c)
 134 {
 135     int i, j;
 136     intptr_t    *leaves = FcCharSetLeaves (c);
 137     FcChar16    *numbers = FcCharSetNumbers (c);
 138
 139 #if 0
 140     printf ("CharSet  0x%x\n", (intptr_t) c);
 141     printf ("Leaves:  +%d = 0x%x\n", c->leaves_offset, (intptr_t) leaves);
 142     printf ("Numbers: +%d = 0x%x\n", c->numbers_offset, (intptr_t) numbers);
 143
 144     for (i = 0; i < c->num; i++)
 145     {
 146         printf ("Page %d: %04x +%d = 0x%x\n",
 147                 i, numbers[i], leaves[i],
 148                 (intptr_t) FcOffsetToPtr (leaves, leaves[i], FcCharLeaf));
 149     }
 150 #endif
 151
 152     printf ("\n");
 153     for (i = 0; i < c->num; i++)
 154     {
 155         intptr_t        leaf_offset = leaves[i];
 156         FcCharLeaf      *leaf = FcOffsetToPtr (leaves, leaf_offset, FcCharLeaf);
 157
 158         printf ("\t");
 159         printf ("%04x:", numbers[i]);
 160         for (j = 0; j < 256/32; j++)
 161             printf (" %08x", leaf->map[j]);
 162         printf ("\n");
 163     }
 164 }
 165
 166 void
 167 FcPatternPrint (const FcPattern *p)
 168 {
 169     int             i;
 170     FcPatternElt   *e;
 171
 172     if (!p)
 173     {
 174         printf ("Null pattern\n");
 175         return;
 176     }
 177     printf ("Pattern has %d elts (size %d)\n", p->num, p->size);
 178     for (i = 0; i < p->num; i++)
 179     {
 180         e = &FcPatternElts(p)[i];
 181         printf ("\t%s:", FcObjectName(e->object));
 182         FcValueListPrint (FcPatternEltValues(e));
 183         printf ("\n");
 184     }
 185     printf ("\n");
 186 }
 187
 188 #define FcOpFlagsPrint(_o_)             \
 189     {                                   \
 190         int f = FC_OP_GET_FLAGS (_o_);  \
 191         if (f & FcOpFlagIgnoreBlanks)   \
 192             printf ("(ignore blanks)"); \
 193     }
 194
 195 void
 196 FcOpPrint (FcOp op_)
 197 {
 198     FcOp op = FC_OP_GET_OP (op_);
 199
 200     switch (op) {
 201     case FcOpInteger: printf ("Integer"); break;
 202     case FcOpDouble: printf ("Double"); break;
 203     case FcOpString: printf ("String"); break;
 204     case FcOpMatrix: printf ("Matrix"); break;
 205     case FcOpRange: printf ("Range"); break;
 206     case FcOpBool: printf ("Bool"); break;
 207     case FcOpCharSet: printf ("CharSet"); break;
 208     case FcOpLangSet: printf ("LangSet"); break;
 209     case FcOpField: printf ("Field"); break;
 210     case FcOpConst: printf ("Const"); break;
 211     case FcOpAssign: printf ("Assign"); break;
 212     case FcOpAssignReplace: printf ("AssignReplace"); break;
 213     case FcOpPrepend: printf ("Prepend"); break;
 214     case FcOpPrependFirst: printf ("PrependFirst"); break;
 215     case FcOpAppend: printf ("Append"); break;
 216     case FcOpAppendLast: printf ("AppendLast"); break;
 217     case FcOpQuest: printf ("Quest"); break;
 218     case FcOpOr: printf ("Or"); break;
 219     case FcOpAnd: printf ("And"); break;
 220     case FcOpEqual: printf ("Equal"); FcOpFlagsPrint (op_); break;
 221     case FcOpNotEqual: printf ("NotEqual"); FcOpFlagsPrint (op_); break;
 222     case FcOpLess: printf ("Less"); break;
 223     case FcOpLessEqual: printf ("LessEqual"); break;
 224     case FcOpMore: printf ("More"); break;
 225     case FcOpMoreEqual: printf ("MoreEqual"); break;
 226     case FcOpContains: printf ("Contains"); break;
 227     case FcOpNotContains: printf ("NotContains"); break;
 228     case FcOpPlus: printf ("Plus"); break;
 229     case FcOpMinus: printf ("Minus"); break;
 230     case FcOpTimes: printf ("Times"); break;
 231     case FcOpDivide: printf ("Divide"); break;
 232     case FcOpNot: printf ("Not"); break;
 233     case FcOpNil: printf ("Nil"); break;
 234     case FcOpComma: printf ("Comma"); break;
 235     case FcOpFloor: printf ("Floor"); break;
 236     case FcOpCeil: printf ("Ceil"); break;
 237     case FcOpRound: printf ("Round"); break;
 238     case FcOpTrunc: printf ("Trunc"); break;
 239     case FcOpListing: printf ("Listing"); FcOpFlagsPrint (op_); break;
 240     case FcOpInvalid: printf ("Invalid"); break;
 241     }
 242 }
 243
 244 void
 245 FcExprPrint (const FcExpr *expr)
 246 {
 247     if (!expr) printf ("none");
 248     else switch (FC_OP_GET_OP (expr->op)) {
 249     case FcOpInteger: printf ("%d", expr->u.ival); break;
 250     case FcOpDouble: printf ("%g", expr->u.dval); break;
 251     case FcOpString: printf ("\"%s\"", expr->u.sval); break;
 252     case FcOpMatrix:
 253         printf ("[");
 254         FcExprPrint (expr->u.mexpr->xx);
 255         printf (" ");
 256         FcExprPrint (expr->u.mexpr->xy);
 257         printf (" ");
 258         FcExprPrint (expr->u.mexpr->yx);
 259         printf (" ");
 260         FcExprPrint (expr->u.mexpr->yx);
 261         printf ("]");
 262         break;
 263     case FcOpRange: break;
 264     case FcOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break;
 265     case FcOpCharSet: printf ("charset\n"); break;
 266     case FcOpLangSet:
 267         printf ("langset:");
 268         FcLangSetPrint(expr->u.lval);
 269         printf ("\n");
 270         break;
 271     case FcOpNil: printf ("nil\n"); break;
 272     case FcOpField: printf ("%s", FcObjectName(expr->u.object)); break;
 273     case FcOpConst: printf ("%s", expr->u.constant); break;
 274     case FcOpQuest:
 275         FcExprPrint (expr->u.tree.left);
 276         printf (" quest ");
 277         FcExprPrint (expr->u.tree.right->u.tree.left);
 278         printf (" colon ");
 279         FcExprPrint (expr->u.tree.right->u.tree.right);
 280         break;
 281     case FcOpAssign:
 282     case FcOpAssignReplace:
 283     case FcOpPrependFirst:
 284     case FcOpPrepend:
 285     case FcOpAppend:
 286     case FcOpAppendLast:
 287     case FcOpOr:
 288     case FcOpAnd:
 289     case FcOpEqual:
 290     case FcOpNotEqual:
 291     case FcOpLess:
 292     case FcOpLessEqual:
 293     case FcOpMore:
 294     case FcOpMoreEqual:
 295     case FcOpContains:
 296     case FcOpListing:
 297     case FcOpNotContains:
 298     case FcOpPlus:
 299     case FcOpMinus:
 300     case FcOpTimes:
 301     case FcOpDivide:
 302     case FcOpComma:
 303         FcExprPrint (expr->u.tree.left);
 304         printf (" ");
 305         switch (FC_OP_GET_OP (expr->op)) {
 306         case FcOpAssign: printf ("Assign"); break;
 307         case FcOpAssignReplace: printf ("AssignReplace"); break;
 308         case FcOpPrependFirst: printf ("PrependFirst"); break;
 309         case FcOpPrepend: printf ("Prepend"); break;
 310         case FcOpAppend: printf ("Append"); break;
 311         case FcOpAppendLast: printf ("AppendLast"); break;
 312         case FcOpOr: printf ("Or"); break;
 313         case FcOpAnd: printf ("And"); break;
 314         case FcOpEqual: printf ("Equal"); FcOpFlagsPrint (expr->op); break;
 315         case FcOpNotEqual: printf ("NotEqual"); FcOpFlagsPrint (expr->op); break;
 316         case FcOpLess: printf ("Less"); break;
 317         case FcOpLessEqual: printf ("LessEqual"); break;
 318         case FcOpMore: printf ("More"); break;
 319         case FcOpMoreEqual: printf ("MoreEqual"); break;
 320         case FcOpContains: printf ("Contains"); break;
 321         case FcOpListing: printf ("Listing"); FcOpFlagsPrint (expr->op); break;
 322         case FcOpNotContains: printf ("NotContains"); break;
 323         case FcOpPlus: printf ("Plus"); break;
 324         case FcOpMinus: printf ("Minus"); break;
 325         case FcOpTimes: printf ("Times"); break;
 326         case FcOpDivide: printf ("Divide"); break;
 327         case FcOpComma: printf ("Comma"); break;
 328         default: break;
 329         }
 330         printf (" ");
 331         FcExprPrint (expr->u.tree.right);
 332         break;
 333     case FcOpNot:
 334         printf ("Not ");
 335         FcExprPrint (expr->u.tree.left);
 336         break;
 337     case FcOpFloor:
 338         printf ("Floor ");
 339         FcExprPrint (expr->u.tree.left);
 340         break;
 341     case FcOpCeil:
 342         printf ("Ceil ");
 343         FcExprPrint (expr->u.tree.left);
 344         break;
 345     case FcOpRound:
 346         printf ("Round ");
 347         FcExprPrint (expr->u.tree.left);
 348         break;
 349     case FcOpTrunc:
 350         printf ("Trunc ");
 351         FcExprPrint (expr->u.tree.left);
 352         break;
 353     case FcOpInvalid: printf ("Invalid"); break;
 354     }
 355 }
 356
 357 void
 358 FcTestPrint (const FcTest *test)
 359 {
 360     switch (test->kind) {
 361     case FcMatchPattern:
 362         printf ("pattern ");
 363         break;
 364     case FcMatchFont:
 365         printf ("font ");
 366         break;
 367     case FcMatchScan:
 368         printf ("scan ");
 369         break;
 370     }
 371     switch (test->qual) {
 372     case FcQualAny:
 373         printf ("any ");
 374         break;
 375     case FcQualAll:
 376         printf ("all ");
 377         break;
 378     case FcQualFirst:
 379         printf ("first ");
 380         break;
 381     case FcQualNotFirst:
 382         printf ("not_first ");
 383         break;
 384     }
 385     printf ("%s ", FcObjectName (test->object));
 386     FcOpPrint (test->op);
 387     printf (" ");
 388     FcExprPrint (test->expr);
 389     printf ("\n");
 390 }
 391
 392 void
 393 FcEditPrint (const FcEdit *edit)
 394 {
 395     printf ("Edit %s ", FcObjectName (edit->object));
 396     FcOpPrint (edit->op);
 397     printf (" ");
 398     FcExprPrint (edit->expr);
 399 }
 400
 401 void
 402 FcSubstPrint (const FcSubst *subst)
 403 {
 404     FcEdit      *e;
 405     FcTest      *t;
 406
 407     printf ("match\n");
 408     for (t = subst->test; t; t = t->next)
 409     {
 410         printf ("\t");
 411         FcTestPrint (t);
 412     }
 413     printf ("edit\n");
 414     for (e = subst->edit; e; e = e->next)
 415     {
 416         printf ("\t");
 417         FcEditPrint (e);
 418         printf (";\n");
 419     }
 420     printf ("\n");
 421 }
 422
 423 void
 424 FcFontSetPrint (const FcFontSet *s)
 425 {
 426     int     i;
 427
 428     printf ("FontSet %d of %d\n", s->nfont, s->sfont);
 429     for (i = 0; i < s->nfont; i++)
 430     {
 431         printf ("Font %d ", i);
 432         FcPatternPrint (s->fonts[i]);
 433     }
 434 }
 435
 436 int FcDebugVal;
 437
 438 void
 439 FcInitDebug (void)
 440 {
 441     char    *e;
 442
 443     e = getenv ("FC_DEBUG");
 444     if (e)
 445     {
 446         printf ("FC_DEBUG=%s\n", e);
 447         FcDebugVal = atoi (e);
 448         if (FcDebugVal < 0)
 449             FcDebugVal = 0;
 450     }
 451 }
 452 #define __fcdbg__
 453 #include "fcaliastail.h"
 454 #undef __fcdbg__