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