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