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