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