rosapps/smartpdf/fitz/stream/obj_array.c

   1 #include "fitz-base.h"
   2 #include "fitz-stream.h"
   3
   4 void fz_droparray(fz_obj *obj);
   5
   6 fz_error *
   7 fz_newarray(fz_obj **op, int initialcap)
   8 {
   9         fz_obj *obj;
  10         int i;
  11
  12         obj = *op = fz_malloc(sizeof (fz_obj));
  13         if (!obj) return fz_outofmem;
  14
  15         obj->refs = 1;
  16         obj->kind = FZ_ARRAY;
  17
  18         obj->u.a.len = 0;
  19         obj->u.a.cap = initialcap > 0 ? initialcap : 6;
  20
  21         obj->u.a.items = fz_malloc(sizeof (fz_obj*) * obj->u.a.cap);
  22         if (!obj->u.a.items) { fz_free(obj); return fz_outofmem; }
  23
  24         for (i = 0; i < obj->u.a.cap; i++)
  25                 obj->u.a.items[i] = nil;
  26
  27         return nil;
  28 }
  29
  30 fz_error *
  31 fz_copyarray(fz_obj **op, fz_obj *obj)
  32 {
  33         fz_error *error;
  34         fz_obj *new;
  35         int i;
  36
  37         if (!fz_isarray(obj))
  38                 return fz_throw("typecheck in copyarray");
  39
  40         error = fz_newarray(&new, fz_arraylen(obj));
  41         if (error) return error;
  42         *op = new;
  43
  44         for (i = 0; i < fz_arraylen(obj); i++) {
  45                 error = fz_arraypush(new, fz_arrayget(obj, i));
  46                 if (error) { fz_droparray(new); return error; }
  47         }
  48
  49         return nil;
  50 }
  51
  52 fz_error *
  53 fz_deepcopyarray(fz_obj **op, fz_obj *obj)
  54 {
  55         fz_error *error;
  56         fz_obj *new;
  57         fz_obj *val;
  58         int i;
  59
  60         if (!fz_isarray(obj))
  61                 return fz_throw("typecheck in deepcopyarray");
  62
  63         error = fz_newarray(&new, fz_arraylen(obj));
  64         if (error) return error;
  65         *op = new;
  66
  67         for (i = 0; i < fz_arraylen(obj); i++)
  68         {
  69                 val = fz_arrayget(obj, i);
  70
  71                 if (fz_isarray(val)) {
  72                         error = fz_deepcopyarray(&val, val);
  73                         if (error) { fz_droparray(new); return error; }
  74                         error = fz_arraypush(new, val);
  75                         if (error) { fz_dropobj(val); fz_droparray(new); return error; }
  76                         fz_dropobj(val);
  77                 }
  78
  79                 else if (fz_isdict(val)) {
  80                         error = fz_deepcopydict(&val, val);
  81                         if (error) { fz_droparray(new); return error; }
  82                         error = fz_arraypush(new, val);
  83                         if (error) { fz_dropobj(val); fz_droparray(new); return error; }
  84                         fz_dropobj(val);
  85                 }
  86
  87                 else {
  88                         error = fz_arraypush(new, val);
  89                         if (error) { fz_droparray(new); return error; }
  90                 }
  91         }
  92
  93         return nil;
  94 }
  95
  96 int
  97 fz_arraylen(fz_obj *obj)
  98 {
  99         if (!fz_isarray(obj))
 100                 return 0;
 101         return obj->u.a.len;
 102 }
 103
 104 fz_obj *
 105 fz_arrayget(fz_obj *obj, int i)
 106 {
 107         if (!fz_isarray(obj))
 108                 return nil;
 109
 110         if (i < 0 || i >= obj->u.a.len)
 111                 return nil;
 112
 113         return obj->u.a.items[i];
 114 }
 115
 116 fz_error *
 117 fz_arrayput(fz_obj *obj, int i, fz_obj *item)
 118 {
 119         if (!fz_isarray(obj))
 120                 return fz_throw("typecheck in arrayput");
 121         if (i < 0)
 122                 return fz_throw("rangecheck in arrayput: %d < 0", i);
 123         if (i >= obj->u.a.len)
 124                 return fz_throw("rangecheck in arrayput: %d > %d", i, obj->u.a.len);
 125
 126         if (obj->u.a.items[i])
 127                 fz_dropobj(obj->u.a.items[i]);
 128         obj->u.a.items[i] = fz_keepobj(item);
 129
 130         return nil;
 131 }
 132
 133 static fz_error *
 134 growarray(fz_obj *obj)
 135 {
 136         fz_obj **newitems;
 137         int newcap;
 138         int i;
 139
 140         newcap = obj->u.a.cap * 2;
 141         newitems = fz_realloc(obj->u.a.items, sizeof (fz_obj*) * newcap);
 142         if (!newitems) return fz_outofmem;
 143
 144         obj->u.a.items = newitems;
 145         for (i = obj->u.a.cap ; i < newcap; i++)
 146                 obj->u.a.items[i] = nil;
 147         obj->u.a.cap = newcap;
 148
 149         return nil;
 150 }
 151
 152 fz_error *
 153 fz_arraypush(fz_obj *obj, fz_obj *item)
 154 {
 155         fz_error *error;
 156
 157         if (!fz_isarray(obj))
 158                 return fz_throw("typecheck in arraypush");
 159
 160         if (obj->u.a.len + 1 > obj->u.a.cap) {
 161                 error = growarray(obj);
 162                 if (error) return error;
 163         }
 164
 165         obj->u.a.items[obj->u.a.len] = fz_keepobj(item);
 166         obj->u.a.len++;
 167
 168         return nil;
 169 }
 170
 171 void
 172 fz_droparray(fz_obj *obj)
 173 {
 174         int i;
 175
 176         assert(obj->kind == FZ_ARRAY);
 177
 178         for (i = 0; i < obj->u.a.len; i++)
 179                 if (obj->u.a.items[i])
 180                         fz_dropobj(obj->u.a.items[i]);
 181
 182         fz_free(obj->u.a.items);
 183         fz_free(obj);
 184 }
 185