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