rosapps/smartpdf/fitz/stream/obj_simple.c

   1 #include "fitz-base.h"
   2 #include "fitz-stream.h"
   3
   4 extern void fz_droparray(fz_obj *array);
   5 extern void fz_dropdict(fz_obj *dict);
   6
   7 //#define DO_OBJ_STATS 1
   8
   9 #ifdef DO_OBJ_STATS
  10 static int objstats[FZ_POINTER+1];
  11 static int intsLessThan65k;
  12
  13 static const char *getTypeName(int type)
  14 {
  15     switch (type) {
  16         case FZ_NULL:
  17             return "FZ_NULL";
  18         case FZ_BOOL:
  19             return "FZ_BOOL";
  20         case FZ_INT:
  21             return "FZ_INT";
  22         case FZ_REAL:
  23             return "FZ_REAL";
  24         case FZ_STRING:
  25             return "FZ_STRING";
  26         case FZ_NAME:
  27             return "FZ_NAME";
  28         case FZ_ARRAY:
  29             return "FZ_ARRAY";
  30         case FZ_DICT:
  31             return "FZ_DICT";
  32         case FZ_INDIRECT:
  33             return "FZ_INDIRECT";
  34         case FZ_POINTER:
  35             return "FZ_POINTER";
  36     }
  37     return "unknown";
  38 }
  39
  40 void dump_type_stats(void)
  41 {
  42     int i;
  43     int total = 0;
  44     int val;
  45     double percent;
  46
  47     for (i = FZ_NULL; i <= FZ_POINTER; i++) {
  48         total += objstats[i];
  49     }
  50
  51     printf("total: %d\n", total);
  52     for (i = FZ_NULL; i <= FZ_POINTER; i++) {
  53         val = objstats[i];
  54         percent = ((double)val * 100.0) / (double)total;
  55         printf("%5d %.2f%% %s\n", val, percent, getTypeName(i));
  56     }
  57     val = intsLessThan65k;
  58     percent = ((double)val * 100.0) / (double)total;
  59     printf("%5d %.2f%% %s\n", val, percent, "intsLessThan65k");
  60 }
  61 #else
  62 void dump_type_stats(void)
  63 {
  64 }
  65 #endif
  66
  67 #ifdef DO_OBJ_STATS
  68 #define NEWOBJ(KIND,SIZE)            \
  69         fz_obj *o;                       \
  70         o = *op = fz_malloc(SIZE);       \
  71         if (!o) return fz_outofmem;      \
  72         o->refs = 1;                    \
  73         o->kind = KIND;                  \
  74         objstats[KIND]++;
  75 #else
  76 #define NEWOBJ(KIND,SIZE)            \
  77         fz_obj *o;                       \
  78         o = *op = fz_malloc(SIZE);       \
  79         if (!o) return fz_outofmem;      \
  80         o->refs = 1;                    \
  81         o->kind = KIND;
  82 #endif
  83
  84 fz_error *
  85 fz_newnull(fz_obj **op)
  86 {
  87         NEWOBJ(FZ_NULL, sizeof (fz_obj));
  88         return nil;
  89 }
  90
  91 fz_error *
  92 fz_newbool(fz_obj **op, int b)
  93 {
  94         NEWOBJ(FZ_BOOL, sizeof (fz_obj));
  95         o->u.b = b;
  96         return nil;
  97 }
  98
  99 fz_error *
 100 fz_newint(fz_obj **op, int i)
 101 {
 102         NEWOBJ(FZ_INT, sizeof (fz_obj));
 103         o->u.i = i;
 104 #ifdef DO_OBJ_STATS
 105         if (i < 65536)
 106                 ++intsLessThan65k;
 107 #endif DO_OBJ_STATS
 108         return nil;
 109 }
 110
 111 fz_error *
 112 fz_newreal(fz_obj **op, float f)
 113 {
 114         NEWOBJ(FZ_REAL, sizeof (fz_obj));
 115         o->u.f = f;
 116         return nil;
 117 }
 118
 119 fz_error *
 120 fz_newstring(fz_obj **op, char *str, int len)
 121 {
 122         NEWOBJ(FZ_STRING, offsetof(fz_obj, u.s.buf) + len + 1);
 123         o->u.s.len = len;
 124         memcpy(o->u.s.buf, str, len);
 125         o->u.s.buf[len] = '\0';
 126         return nil;
 127 }
 128
 129 fz_error *
 130 fz_newname(fz_obj **op, char *str)
 131 {
 132         NEWOBJ(FZ_NAME, offsetof(fz_obj, u.n) + strlen(str) + 1);
 133         strcpy(o->u.n, str);
 134         return nil;
 135 }
 136
 137 fz_error *
 138 fz_newindirect(fz_obj **op, int objid, int genid)
 139 {
 140         NEWOBJ(FZ_INDIRECT, sizeof (fz_obj));
 141         o->u.r.oid = objid;
 142         o->u.r.gid = genid;
 143         return nil;
 144 }
 145
 146 fz_error *
 147 fz_newpointer(fz_obj **op, void *p)
 148 {
 149     NEWOBJ(FZ_POINTER, sizeof (fz_obj));
 150     o->u.p = p;
 151     return nil;
 152 }
 153
 154 fz_obj *
 155 fz_keepobj(fz_obj *o)
 156 {
 157     assert(o != nil);
 158     assert(o->refs > 0);
 159     o->refs ++;
 160     return o;
 161 }
 162
 163 void
 164 fz_dropobj(fz_obj *o)
 165 {
 166     assert(o != nil);
 167     assert(o->refs > 0);
 168     if (--o->refs == 0)
 169     {
 170         if (o->kind == FZ_ARRAY)
 171             fz_droparray(o);
 172         else if (o->kind == FZ_DICT)
 173             fz_dropdict(o);
 174         else
 175             fz_free(o);
 176     }
 177 }
 178
 179 int
 180 fz_isnull(fz_obj *obj)
 181 {
 182         return obj ? obj->kind == FZ_NULL : 0;
 183 }
 184
 185 int
 186 fz_isbool(fz_obj *obj)
 187 {
 188         return obj ? obj->kind == FZ_BOOL : 0;
 189 }
 190
 191 int
 192 fz_isint(fz_obj *obj)
 193 {
 194         return obj ? obj->kind == FZ_INT : 0;
 195 }
 196
 197 int
 198 fz_isreal(fz_obj *obj)
 199 {
 200         return obj ? obj->kind == FZ_REAL : 0;
 201 }
 202
 203 int
 204 fz_isstring(fz_obj *obj)
 205 {
 206         return obj ? obj->kind == FZ_STRING : 0;
 207 }
 208
 209 int
 210 fz_isname(fz_obj *obj)
 211 {
 212         return obj ? obj->kind == FZ_NAME : 0;
 213 }
 214
 215 int
 216 fz_isarray(fz_obj *obj)
 217 {
 218         return obj ? obj->kind == FZ_ARRAY : 0;
 219 }
 220
 221 int
 222 fz_isdict(fz_obj *obj)
 223 {
 224         return obj ? obj->kind == FZ_DICT : 0;
 225 }
 226
 227 int
 228 fz_isindirect(fz_obj *obj)
 229 {
 230         return obj ? obj->kind == FZ_INDIRECT : 0;
 231 }
 232
 233 int
 234 fz_ispointer(fz_obj *obj)
 235 {
 236         return obj ? obj->kind == FZ_POINTER : 0;
 237 }
 238
 239 int
 240 fz_tobool(fz_obj *obj)
 241 {
 242         if (fz_isbool(obj))
 243                 return obj->u.b;
 244         return 0;
 245 }
 246
 247 int
 248 fz_toint(fz_obj *obj)
 249 {
 250         if (fz_isint(obj))
 251                 return obj->u.i;
 252         if (fz_isreal(obj))
 253                 return obj->u.f;
 254         return 0;
 255 }
 256
 257 float
 258 fz_toreal(fz_obj *obj)
 259 {
 260         if (fz_isreal(obj))
 261                 return obj->u.f;
 262         if (fz_isint(obj))
 263                 return obj->u.i;
 264         return 0;
 265 }
 266
 267 char *
 268 fz_toname(fz_obj *obj)
 269 {
 270         if (fz_isname(obj))
 271                 return obj->u.n;
 272         return "";
 273 }
 274
 275 char *
 276 fz_tostrbuf(fz_obj *obj)
 277 {
 278         if (fz_isstring(obj))
 279                 return obj->u.s.buf;
 280         return "";
 281 }
 282
 283 int
 284 fz_tostrlen(fz_obj *obj)
 285 {
 286         if (fz_isstring(obj))
 287                 return obj->u.s.len;
 288         return 0;
 289 }
 290
 291 int
 292 fz_tonum(fz_obj *obj)
 293 {
 294         if (fz_isindirect(obj))
 295                 return obj->u.r.oid;
 296         return 0;
 297 }
 298
 299 int
 300 fz_togen(fz_obj *obj)
 301 {
 302         if (fz_isindirect(obj))
 303                 return obj->u.r.gid;
 304         return 0;
 305 }
 306
 307 void *
 308 fz_topointer(fz_obj *obj)
 309 {
 310         if (fz_ispointer(obj))
 311                 return obj->u.p;
 312         return nil;
 313 }
 314
 315 fz_error *
 316 fz_newnamefromstring(fz_obj **op, fz_obj *str)
 317 {
 318         NEWOBJ(FZ_NAME, offsetof(fz_obj, u.n) + fz_tostrlen(str) + 1);
 319         memcpy(o->u.n, fz_tostrbuf(str), fz_tostrlen(str));
 320         o->u.n[fz_tostrlen(str)] = '\0';
 321         return nil;
 322 }
 323
 324 int
 325 fz_objcmp(fz_obj *a, fz_obj *b)
 326 {
 327         int i;
 328
 329         if (a == b)
 330                 return 0;
 331         if (a->kind != b->kind)
 332                 return 1;
 333
 334         switch (a->kind)
 335         {
 336         case FZ_NULL: return 0;
 337         case FZ_BOOL: return a->u.b - b->u.b;
 338         case FZ_INT: return a->u.i - b->u.i;
 339         case FZ_REAL: return a->u.f - b->u.f;
 340         case FZ_STRING:
 341                 if (a->u.s.len != b->u.s.len)
 342                         return a->u.s.len - b->u.s.len;
 343                 return memcmp(a->u.s.buf, b->u.s.buf, a->u.s.len);
 344         case FZ_NAME:
 345                 return strcmp(a->u.n, b->u.n);
 346
 347         case FZ_INDIRECT:
 348                 if (a->u.r.oid == b->u.r.oid)
 349                         return a->u.r.gid - b->u.r.gid;
 350                 return a->u.r.oid - b->u.r.oid;
 351
 352         case FZ_ARRAY:
 353                 if (a->u.a.len != b->u.a.len)
 354                         return a->u.a.len - b->u.a.len;
 355                 for (i = 0; i < a->u.a.len; i++)
 356                         if (fz_objcmp(a->u.a.items[i], b->u.a.items[i]))
 357                                 return 1;
 358                 return 0;
 359
 360         case FZ_DICT:
 361                 if (a->u.d.len != b->u.d.len)
 362                         return a->u.d.len - b->u.d.len;
 363                 for (i = 0; i < a->u.d.len; i++)
 364                 {
 365                         if (fz_objcmp(a->u.d.items[i].k, b->u.d.items[i].k))
 366                                 return 1;
 367                         if (fz_objcmp(a->u.d.items[i].v, b->u.d.items[i].v))
 368                                 return 1;
 369                 }
 370                 return 0;
 371         }
 372         return 1;
 373 }
 374