src/fcdbg.c

   1 /*
   2  * $RCSId: xc/lib/fontconfig/src/fcdbg.c,v 1.10 2002/08/22 18:53:22 keithp Exp $
   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 <stdio.h>
  26 #include <stdlib.h>
  27 #include "fcint.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 (" set");
  53         break;
  54     case FcTypeLangSet:
  55         printf (" ");
  56         FcLangSetPrint (v.u.l);
  57         break;
  58     case FcTypeFTFace:
  59         printf (" face");
  60         break;
  61     }
  62 }
  63
  64 void
  65 FcValueListPrint (const FcValueList *l)
  66 {
  67     for (; l; l = l->next)
  68     {
  69         FcValuePrint (l->value);
  70         switch (l->binding) {
  71         case FcValueBindingWeak:
  72             printf ("(w)");
  73             break;
  74         case FcValueBindingStrong:
  75             printf ("(s)");
  76             break;
  77         case FcValueBindingSame:
  78             printf ("(=)");
  79             break;
  80         }
  81     }
  82 }
  83
  84 void
  85 FcLangSetPrint (const FcLangSet *ls)
  86 {
  87     FcStrBuf    buf;
  88     FcChar8     init_buf[1024];
  89
  90     FcStrBufInit (&buf, init_buf, sizeof (init_buf));
  91     if (FcNameUnparseLangSet (&buf, ls) && FcStrBufChar (&buf,'\0'))
  92         printf ("%s", buf.buf);
  93     else
  94         printf ("langset (alloc error)");
  95     FcStrBufDestroy (&buf);
  96 }
  97
  98 void
  99 FcPatternPrint (const FcPattern *p)
 100 {
 101     int             i;
 102     FcPatternElt   *e;
 103
 104     if (!p)
 105     {
 106         printf ("Null pattern\n");
 107         return;
 108     }
 109     printf ("Pattern %d of %d\n", p->num, p->size);
 110     for (i = 0; i < p->num; i++)
 111     {
 112         e = &p->elts[i];
 113         printf ("\t%s:", e->object);
 114         FcValueListPrint (e->values);
 115         printf ("\n");
 116     }
 117     printf ("\n");
 118 }
 119
 120 void
 121 FcOpPrint (FcOp op)
 122 {
 123     switch (op) {
 124     case FcOpInteger: printf ("Integer"); break;
 125     case FcOpDouble: printf ("Double"); break;
 126     case FcOpString: printf ("String"); break;
 127     case FcOpMatrix: printf ("Matrix"); break;
 128     case FcOpBool: printf ("Bool"); break;
 129     case FcOpCharSet: printf ("CharSet"); break;
 130     case FcOpField: printf ("Field"); break;
 131     case FcOpConst: printf ("Const"); break;
 132     case FcOpAssign: printf ("Assign"); break;
 133     case FcOpAssignReplace: printf ("AssignReplace"); break;
 134     case FcOpPrepend: printf ("Prepend"); break;
 135     case FcOpPrependFirst: printf ("PrependFirst"); break;
 136     case FcOpAppend: printf ("Append"); break;
 137     case FcOpAppendLast: printf ("AppendLast"); break;
 138     case FcOpQuest: printf ("Quest"); break;
 139     case FcOpOr: printf ("Or"); break;
 140     case FcOpAnd: printf ("And"); break;
 141     case FcOpEqual: printf ("Equal"); break;
 142     case FcOpNotEqual: printf ("NotEqual"); break;
 143     case FcOpLess: printf ("Less"); break;
 144     case FcOpLessEqual: printf ("LessEqual"); break;
 145     case FcOpMore: printf ("More"); break;
 146     case FcOpMoreEqual: printf ("MoreEqual"); break;
 147     case FcOpContains: printf ("Contains"); break;
 148     case FcOpNotContains: printf ("NotContains"); break;
 149     case FcOpPlus: printf ("Plus"); break;
 150     case FcOpMinus: printf ("Minus"); break;
 151     case FcOpTimes: printf ("Times"); break;
 152     case FcOpDivide: printf ("Divide"); break;
 153     case FcOpNot: printf ("Not"); break;
 154     case FcOpNil: printf ("Nil"); break;
 155     case FcOpComma: printf ("Comma"); break;
 156     case FcOpFloor: printf ("Floor"); break;
 157     case FcOpCeil: printf ("Ceil"); break;
 158     case FcOpRound: printf ("Round"); break;
 159     case FcOpTrunc: printf ("Trunc"); break;
 160     case FcOpInvalid: printf ("Invalid"); break;
 161     }
 162 }
 163
 164 void
 165 FcExprPrint (const FcExpr *expr)
 166 {
 167     if (!expr) printf ("none");
 168     else switch (expr->op) {
 169     case FcOpInteger: printf ("%d", expr->u.ival); break;
 170     case FcOpDouble: printf ("%g", expr->u.dval); break;
 171     case FcOpString: printf ("\"%s\"", expr->u.sval); break;
 172     case FcOpMatrix: printf ("[%g %g %g %g]",
 173                               expr->u.mval->xx,
 174                               expr->u.mval->xy,
 175                               expr->u.mval->yx,
 176                               expr->u.mval->yy); break;
 177     case FcOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break;
 178     case FcOpCharSet: printf ("charset\n"); break;
 179     case FcOpNil: printf ("nil\n"); break;
 180     case FcOpField: printf ("%s", expr->u.field); break;
 181     case FcOpConst: printf ("%s", expr->u.constant); break;
 182     case FcOpQuest:
 183         FcExprPrint (expr->u.tree.left);
 184         printf (" quest ");
 185         FcExprPrint (expr->u.tree.right->u.tree.left);
 186         printf (" colon ");
 187         FcExprPrint (expr->u.tree.right->u.tree.right);
 188         break;
 189     case FcOpAssign:
 190     case FcOpAssignReplace:
 191     case FcOpPrependFirst:
 192     case FcOpPrepend:
 193     case FcOpAppend:
 194     case FcOpAppendLast:
 195     case FcOpOr:
 196     case FcOpAnd:
 197     case FcOpEqual:
 198     case FcOpNotEqual:
 199     case FcOpLess:
 200     case FcOpLessEqual:
 201     case FcOpMore:
 202     case FcOpMoreEqual:
 203     case FcOpContains:
 204     case FcOpNotContains:
 205     case FcOpPlus:
 206     case FcOpMinus:
 207     case FcOpTimes:
 208     case FcOpDivide:
 209     case FcOpComma:
 210         FcExprPrint (expr->u.tree.left);
 211         printf (" ");
 212         switch (expr->op) {
 213         case FcOpAssign: printf ("Assign"); break;
 214         case FcOpAssignReplace: printf ("AssignReplace"); break;
 215         case FcOpPrependFirst: printf ("PrependFirst"); break;
 216         case FcOpPrepend: printf ("Prepend"); break;
 217         case FcOpAppend: printf ("Append"); break;
 218         case FcOpAppendLast: printf ("AppendLast"); break;
 219         case FcOpOr: printf ("Or"); break;
 220         case FcOpAnd: printf ("And"); break;
 221         case FcOpEqual: printf ("Equal"); break;
 222         case FcOpNotEqual: printf ("NotEqual"); break;
 223         case FcOpLess: printf ("Less"); break;
 224         case FcOpLessEqual: printf ("LessEqual"); break;
 225         case FcOpMore: printf ("More"); break;
 226         case FcOpMoreEqual: printf ("MoreEqual"); break;
 227         case FcOpContains: printf ("Contains"); break;
 228         case FcOpNotContains: printf ("NotContains"); break;
 229         case FcOpPlus: printf ("Plus"); break;
 230         case FcOpMinus: printf ("Minus"); break;
 231         case FcOpTimes: printf ("Times"); break;
 232         case FcOpDivide: printf ("Divide"); break;
 233         case FcOpComma: printf ("Comma"); break;
 234         default: break;
 235         }
 236         printf (" ");
 237         FcExprPrint (expr->u.tree.right);
 238         break;
 239     case FcOpNot:
 240         printf ("Not ");
 241         FcExprPrint (expr->u.tree.left);
 242         break;
 243     case FcOpFloor:
 244         printf ("Floor ");
 245         FcExprPrint (expr->u.tree.left);
 246         break;
 247     case FcOpCeil:
 248         printf ("Ceil ");
 249         FcExprPrint (expr->u.tree.left);
 250         break;
 251     case FcOpRound:
 252         printf ("Round ");
 253         FcExprPrint (expr->u.tree.left);
 254         break;
 255     case FcOpTrunc:
 256         printf ("Trunc ");
 257         FcExprPrint (expr->u.tree.left);
 258         break;
 259     case FcOpInvalid: printf ("Invalid"); break;
 260     }
 261 }
 262
 263 void
 264 FcTestPrint (const FcTest *test)
 265 {
 266     switch (test->kind) {
 267     case FcMatchPattern:
 268         printf ("pattern ");
 269         break;
 270     case FcMatchFont:
 271         printf ("font ");
 272         break;
 273     }
 274     switch (test->qual) {
 275     case FcQualAny:
 276         printf ("any ");
 277         break;
 278     case FcQualAll:
 279         printf ("all ");
 280         break;
 281     case FcQualFirst:
 282         printf ("first ");
 283         break;
 284     case FcQualNotFirst:
 285         printf ("not_first ");
 286         break;
 287     }
 288     printf ("%s ", test->field);
 289     FcOpPrint (test->op);
 290     printf (" ");
 291     FcExprPrint (test->expr);
 292     printf ("\n");
 293 }
 294
 295 void
 296 FcEditPrint (const FcEdit *edit)
 297 {
 298     printf ("Edit %s ", edit->field);
 299     FcOpPrint (edit->op);
 300     printf (" ");
 301     FcExprPrint (edit->expr);
 302 }
 303
 304 void
 305 FcSubstPrint (const FcSubst *subst)
 306 {
 307     FcEdit      *e;
 308     FcTest      *t;
 309
 310     printf ("match\n");
 311     for (t = subst->test; t; t = t->next)
 312     {
 313         printf ("\t");
 314         FcTestPrint (t);
 315     }
 316     printf ("edit\n");
 317     for (e = subst->edit; e; e = e->next)
 318     {
 319         printf ("\t");
 320         FcEditPrint (e);
 321         printf (";\n");
 322     }
 323     printf ("\n");
 324 }
 325
 326 void
 327 FcFontSetPrint (const FcFontSet *s)
 328 {
 329     int     i;
 330
 331     printf ("FontSet %d of %d\n", s->nfont, s->sfont);
 332     for (i = 0; i < s->nfont; i++)
 333     {
 334         printf ("Font %d ", i);
 335         FcPatternPrint (s->fonts[i]);
 336     }
 337 }
 338
 339 int
 340 FcDebug (void)
 341 {
 342     static int  initialized;
 343     static int  debug;
 344
 345     if (!initialized)
 346     {
 347         char    *e;
 348
 349         initialized = 1;
 350         e = getenv ("FC_DEBUG");
 351         if (e)
 352         {
 353             printf ("FC_DEBUG=%s\n", e);
 354             debug = atoi (e);
 355             if (debug < 0)
 356                 debug = 0;
 357         }
 358     }
 359     return debug;
 360 }