Changeset 13669


Ignore:
Timestamp:
Dec 14, 2012, 4:04:44 PM (10 years ago)
Author:
jordan
Message:

copyediting: indentation, whitespace

Location:
trunk/libtransmission
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/libtransmission/variant-benc.c

    r13667 r13669  
    5050                 int64_t        * setme_val)
    5151{
    52     char *      endptr;
    53     const void * begin;
    54     const void * end;
    55     int64_t      val;
    56 
    57     if (buf >= bufend)
    58         return EILSEQ;
    59     if (*buf != 'i')
    60         return EILSEQ;
    61 
    62     begin = buf + 1;
    63     end = memchr (begin, 'e', (bufend - buf) - 1);
    64     if (end == NULL)
    65         return EILSEQ;
    66 
    67     errno = 0;
    68     val = evutil_strtoll (begin, &endptr, 10);
    69     if (errno || (endptr != end)) /* incomplete parse */
    70         return EILSEQ;
    71     if (val && * (const char*)begin == '0') /* no leading zeroes! */
    72         return EILSEQ;
    73 
    74     *setme_end = (const uint8_t*)end + 1;
    75     *setme_val = val;
    76     return 0;
     52  char * endptr;
     53  const void * begin;
     54  const void * end;
     55  int64_t val;
     56
     57  if (buf >= bufend)
     58    return EILSEQ;
     59  if (*buf != 'i')
     60    return EILSEQ;
     61
     62  begin = buf + 1;
     63  end = memchr (begin, 'e', (bufend - buf) - 1);
     64  if (end == NULL)
     65    return EILSEQ;
     66
     67  errno = 0;
     68  val = evutil_strtoll (begin, &endptr, 10);
     69  if (errno || (endptr != end)) /* incomplete parse */
     70    return EILSEQ;
     71  if (val && * (const char*)begin == '0') /* no leading zeroes! */
     72    return EILSEQ;
     73
     74  *setme_end = (const uint8_t*)end + 1;
     75  *setme_val = val;
     76  return 0;
    7777}
    7878
    … …  
    9090                 size_t *         setme_strlen)
    9191{
    92     size_t      len;
    93     const void * end;
    94     char *      endptr;
    95 
    96     if (buf >= bufend)
    97         return EILSEQ;
    98 
    99     if (!isdigit (*buf))
    100         return EILSEQ;
    101 
    102     end = memchr (buf, ':', bufend - buf);
    103     if (end == NULL)
    104         return EILSEQ;
    105 
    106     errno = 0;
    107     len = strtoul ((const char*)buf, &endptr, 10);
    108     if (errno || endptr != end)
    109         return EILSEQ;
    110 
    111     if ((const uint8_t*)end + 1 + len > bufend)
    112         return EILSEQ;
    113 
    114     *setme_end = (const uint8_t*)end + 1 + len;
    115     *setme_str = (const uint8_t*)end + 1;
    116     *setme_strlen = len;
    117     return 0;
     92  size_t len;
     93  const void * end;
     94  char * endptr;
     95
     96  if (buf >= bufend)
     97    return EILSEQ;
     98
     99  if (!isdigit (*buf))
     100    return EILSEQ;
     101
     102  end = memchr (buf, ':', bufend - buf);
     103  if (end == NULL)
     104    return EILSEQ;
     105
     106  errno = 0;
     107  len = strtoul ((const char*)buf, &endptr, 10);
     108  if (errno || endptr != end)
     109    return EILSEQ;
     110
     111  if ((const uint8_t*)end + 1 + len > bufend)
     112    return EILSEQ;
     113
     114  *setme_end = (const uint8_t*)end + 1 + len;
     115  *setme_str = (const uint8_t*)end + 1;
     116  *setme_strlen = len;
     117  return 0;
    118118}
    119119
    … …  
    151151         int           type)
    152152{
    153     tr_variant * parent;
    154 
    155     assert (top);
    156     assert (parentStack);
    157 
    158     if (tr_ptrArrayEmpty (parentStack))
    159         return top;
    160 
    161     parent = tr_ptrArrayBack (parentStack);
    162     assert (parent);
    163 
    164     /* dictionary keys must be strings */
    165     if ((parent->type == TR_VARIANT_TYPE_DICT)
     153  tr_variant * parent;
     154
     155  assert (top);
     156  assert (parentStack);
     157
     158  if (tr_ptrArrayEmpty (parentStack))
     159    return top;
     160
     161  parent = tr_ptrArrayBack (parentStack);
     162  assert (parent);
     163
     164  /* dictionary keys must be strings */
     165  if ((parent->type == TR_VARIANT_TYPE_DICT)
    166166      && (type != TR_VARIANT_TYPE_STR)
    167167      && (! (parent->val.l.count % 2)))
    168         return NULL;
    169 
    170     makeroom (parent, 1);
    171     return parent->val.l.vals + parent->val.l.count++;
     168    return NULL;
     169
     170  makeroom (parent, 1);
     171  return parent->val.l.vals + parent->val.l.count++;
    172172}
    173173
    … …  
    184184                     const char   ** setme_end)
    185185{
    186     int            err;
    187     const uint8_t * buf = buf_in;
    188     const uint8_t * bufend = bufend_in;
    189 
    190     tr_variantInit (top, 0);
    191 
    192     while (buf != bufend)
     186  int err;
     187  const uint8_t * buf = buf_in;
     188  const uint8_t * bufend = bufend_in;
     189
     190  tr_variantInit (top, 0);
     191
     192  while (buf != bufend)
    193193    {
    194         if (buf > bufend) /* no more text to parse... */
    195             return 1;
    196 
    197         if (*buf == 'i') /* int */
    198         {
    199             int64_t         val;
    200             const uint8_t * end;
    201             tr_variant *       node;
    202 
    203             if ((err = tr_bencParseInt (buf, bufend, &end, &val)))
    204                 return err;
    205 
    206             node = getNode (top, parentStack, TR_VARIANT_TYPE_INT);
    207             if (!node)
    208                 return EILSEQ;
    209 
    210             tr_variantInitInt (node, val);
    211             buf = end;
    212 
    213             if (tr_ptrArrayEmpty (parentStack))
    214                 break;
    215         }
    216         else if (*buf == 'l') /* list */
    217         {
    218             tr_variant * node = getNode (top, parentStack, TR_VARIANT_TYPE_LIST);
    219             if (!node)
    220                 return EILSEQ;
    221             tr_variantInit (node, TR_VARIANT_TYPE_LIST);
    222             tr_ptrArrayAppend (parentStack, node);
    223             ++buf;
    224         }
    225         else if (*buf == 'd') /* dict */
    226         {
    227             tr_variant * node = getNode (top, parentStack, TR_VARIANT_TYPE_DICT);
    228             if (!node)
    229                 return EILSEQ;
    230             tr_variantInit (node, TR_VARIANT_TYPE_DICT);
    231             tr_ptrArrayAppend (parentStack, node);
    232             ++buf;
    233         }
    234         else if (*buf == 'e') /* end of list or dict */
    235         {
    236             tr_variant * node;
    237             ++buf;
    238             if (tr_ptrArrayEmpty (parentStack))
    239                 return EILSEQ;
    240 
    241             node = tr_ptrArrayBack (parentStack);
    242             if (tr_variantIsDict (node) && (node->val.l.count % 2))
     194      if (buf > bufend) /* no more text to parse... */
     195        return 1;
     196
     197      if (*buf == 'i') /* int */
     198        {
     199          int64_t val;
     200          const uint8_t * end;
     201          tr_variant * node;
     202
     203          if ((err = tr_bencParseInt (buf, bufend, &end, &val)))
     204            return err;
     205
     206          node = getNode (top, parentStack, TR_VARIANT_TYPE_INT);
     207          if (!node)
     208            return EILSEQ;
     209
     210          tr_variantInitInt (node, val);
     211          buf = end;
     212
     213          if (tr_ptrArrayEmpty (parentStack))
     214            break;
     215        }
     216      else if (*buf == 'l') /* list */
     217        {
     218          tr_variant * node = getNode (top, parentStack, TR_VARIANT_TYPE_LIST);
     219          if (!node)
     220            return EILSEQ;
     221
     222          tr_variantInit (node, TR_VARIANT_TYPE_LIST);
     223          tr_ptrArrayAppend (parentStack, node);
     224          ++buf;
     225        }
     226      else if (*buf == 'd') /* dict */
     227        {
     228          tr_variant * node = getNode (top, parentStack, TR_VARIANT_TYPE_DICT);
     229          if (!node)
     230            return EILSEQ;
     231
     232          tr_variantInit (node, TR_VARIANT_TYPE_DICT);
     233          tr_ptrArrayAppend (parentStack, node);
     234          ++buf;
     235        }
     236      else if (*buf == 'e') /* end of list or dict */
     237        {
     238          tr_variant * node;
     239          ++buf;
     240          if (tr_ptrArrayEmpty (parentStack))
     241              return EILSEQ;
     242
     243          node = tr_ptrArrayBack (parentStack);
     244          if (tr_variantIsDict (node) && (node->val.l.count % 2))
    243245            {
    244                 /* odd # of children in dict */
    245                 tr_variantFree (&node->val.l.vals[--node->val.l.count]);
    246                 return EILSEQ;
     246              /* odd # of children in dict */
     247              tr_variantFree (&node->val.l.vals[--node->val.l.count]);
     248              return EILSEQ;
    247249            }
    248250
    249             tr_ptrArrayPop (parentStack);
    250             if (tr_ptrArrayEmpty (parentStack))
    251                 break;
    252         }
    253         else if (isdigit (*buf)) /* string? */
    254         {
    255             const uint8_t * end;
    256             const uint8_t * str;
    257             size_t          str_len;
    258             tr_variant *      node;
    259 
    260             if ((err = tr_bencParseStr (buf, bufend, &end, &str, &str_len)))
    261                 return err;
    262 
    263             node = getNode (top, parentStack, TR_VARIANT_TYPE_STR);
    264             if (!node)
    265                 return EILSEQ;
    266 
    267             tr_variantInitStr (node, str, str_len);
    268             buf = end;
    269 
    270             if (tr_ptrArrayEmpty (parentStack))
    271                 break;
    272         }
    273         else /* invalid bencoded text... march past it */
    274         {
    275             ++buf;
     251          tr_ptrArrayPop (parentStack);
     252          if (tr_ptrArrayEmpty (parentStack))
     253            break;
     254        }
     255      else if (isdigit (*buf)) /* string? */
     256        {
     257          const uint8_t * end;
     258          const uint8_t * str;
     259          size_t str_len;
     260          tr_variant * node;
     261
     262          if ((err = tr_bencParseStr (buf, bufend, &end, &str, &str_len)))
     263            return err;
     264
     265          node = getNode (top, parentStack, TR_VARIANT_TYPE_STR);
     266          if (!node)
     267            return EILSEQ;
     268
     269          tr_variantInitStr (node, str, str_len);
     270          buf = end;
     271
     272          if (tr_ptrArrayEmpty (parentStack))
     273            break;
     274        }
     275      else /* invalid bencoded text... march past it */
     276        {
     277          ++buf;
    276278        }
    277279    }
    278280
    279     err = !tr_variantIsSomething (top) || !tr_ptrArrayEmpty (parentStack);
    280 
    281     if (!err && setme_end)
    282         *setme_end = (const char*) buf;
    283 
    284     return err;
     281  err = !tr_variantIsSomething (top) || !tr_ptrArrayEmpty (parentStack);
     282
     283  if (!err && setme_end)
     284    *setme_end = (const char*) buf;
     285
     286  return err;
    285287}
    286288

  • trunk/libtransmission/variant-json.c

    r13667 r13669  
    147147}
    148148
    149 /* so sscanf(in+2, "%4x", &val) was showing up at the top of the profiler... *shrug* */
     149/* like sscanf(in+2, "%4x", &val) but less slow */
    150150static bool
    151151decode_hex_string (const char * in, unsigned int * setme)
    … …  
    343343****/
    344344
    345 /** @brief Implementation helper class for tr_variantToBuffer (TR_VARIANT_FMT_JSON) */
    346345struct ParentState
    347346{
    … …  
    351350};
    352351
    353 /** @brief Implementation helper class for tr_variantToBuffer (TR_VARIANT_FMT_JSON) */
    354352struct jsonWalk
    355353{
    … …  
    378376  if (data->parents && data->parents->data)
    379377    {
    380       struct ParentState * parentState = data->parents->data;
    381 
    382       switch (parentState->bencType)
     378      struct ParentState * pstate = data->parents->data;
     379
     380      switch (pstate->bencType)
    383381        {
    384382          case TR_VARIANT_TYPE_DICT:
    385383            {
    386               const int i = parentState->childIndex++;
     384              const int i = pstate->childIndex++;
    387385              if (! (i % 2))
    388386                {
    … …  
    391389              else
    392390                {
    393                   const bool isLast = parentState->childIndex == parentState->childCount;
     391                  const bool isLast = pstate->childIndex == pstate->childCount;
    394392
    395393                  if (!isLast)
    … …  
    404402          case TR_VARIANT_TYPE_LIST:
    405403            {
    406               const bool isLast = ++parentState->childIndex == parentState->childCount;
     404              const bool isLast = ++pstate->childIndex == pstate->childCount;
    407405              if (!isLast)
    408406                {
    … …  
    423421                const tr_variant * benc)
    424422{
    425   struct ParentState * parentState = tr_new (struct ParentState, 1);
    426 
    427   parentState->bencType = benc->type;
    428   parentState->childIndex = 0;
    429   parentState->childCount = benc->val.l.count;
    430   tr_list_prepend (&data->parents, parentState);
     423  struct ParentState * pstate = tr_new (struct ParentState, 1);
     424
     425  pstate->bencType = benc->type;
     426  pstate->childIndex = 0;
     427  pstate->childCount = benc->val.l.count;
     428  tr_list_prepend (&data->parents, pstate);
    431429}
    432430

  • trunk/libtransmission/variant.c

    r13668 r13669  
    1212
    1313#include <assert.h>
    14 #include <ctype.h> /* isdigit () */
    1514#include <errno.h>
    1615#include <stdio.h> /* rename () */
    … …  
    7271 * this occurs when the string is too long for our string buffer */
    7372static inline int
    74 stringIsAlloced (const tr_variant * val)
    75 {
    76   return val->val.s.len >= sizeof (val->val.s.str.buf);
     73stringIsAlloced (const tr_variant * variant)
     74{
     75  return variant->val.s.len >= sizeof (variant->val.s.str.buf);
    7776}
    7877
    7978/* returns a const pointer to the variant's string */
    8079static inline const char*
    81 getStr (const tr_variant* val)
    82 {
    83   return stringIsAlloced (val) ? val->val.s.str.ptr : val->val.s.str.buf;
     80getStr (const tr_variant* variant)
     81{
     82  return stringIsAlloced (variant) ? variant->val.s.str.ptr
     83                                   : variant->val.s.str.buf;
    8484}
    8585
    8686static int
    87 dictIndexOf (const tr_variant * val, const char * key)
    88 {
    89   if (tr_variantIsDict (val))
     87dictIndexOf (const tr_variant * dict, const char * key)
     88{
     89  if (tr_variantIsDict (dict))
    9090    {
    9191      size_t i;
    9292      const size_t len = strlen (key);
    9393
    94       for (i=0; (i+1) < val->val.l.count; i += 2)
    95         {
    96           const tr_variant * child = val->val.l.vals + i;
     94      for (i=0; (i+1) < dict->val.l.count; i += 2)
     95        {
     96          const tr_variant * child = dict->val.l.vals + i;
    9797          if ((child->type == TR_VARIANT_TYPE_STR)
    9898              && (child->val.s.len == len)
    … …  
    106106
    107107tr_variant *
    108 tr_variantDictFind (tr_variant * val,
     108tr_variantDictFind (tr_variant * dict,
    109109                    const char * key)
    110110{
    111   const int i = dictIndexOf (val, key);
    112 
    113   return i < 0 ? NULL : &val->val.l.vals[i + 1];
     111  const int i = dictIndexOf (dict, key);
     112
     113  return i < 0 ? NULL : &dict->val.l.vals[i + 1];
    114114}
    115115
    … …  
    126126tr_variantListSize (const tr_variant * list)
    127127{
    128     return tr_variantIsList (list) ? list->val.l.count : 0;
     128  return tr_variantIsList (list) ? list->val.l.count : 0;
    129129}
    130130
    … …  
    133133                  size_t    i)
    134134{
    135     tr_variant * ret = NULL;
    136 
    137     if (tr_variantIsList (val) && (i < val->val.l.count))
    138         ret = val->val.l.vals + i;
    139     return ret;
     135  tr_variant * ret = NULL;
     136
     137  if (tr_variantIsList (val) && (i < val->val.l.count))
     138    ret = val->val.l.vals + i;
     139
     140  return ret;
    140141}
    141142
    … …  
    146147    {
    147148      tr_variantFree (&list->val.l.vals[i]);
    148       tr_removeElementFromArray (list->val.l.vals, i, sizeof (tr_variant), list->val.l.count--);
     149      tr_removeElementFromArray (list->val.l.vals, i,
     150                                 sizeof (tr_variant),
     151                                 list->val.l.count--);
    149152      return 1;
    150153    }
    … …  
    335338
    336339void
    337 tr_variantInitRaw (tr_variant * val, const void * src, size_t byteCount)
     340tr_variantInitRaw (tr_variant * variant, const void * src, size_t byteCount)
    338341{
    339342  char * setme;
    340   tr_variantInit (val, TR_VARIANT_TYPE_STR);
     343  tr_variantInit (variant, TR_VARIANT_TYPE_STR);
    341344
    342345  /* There's no way in benc notation to distinguish between
    … …  
    346349   * Append one, een to the raw arrays, just to be safe. */
    347350
    348   if (byteCount < sizeof (val->val.s.str.buf))
    349     setme = val->val.s.str.buf;
     351  if (byteCount < sizeof (variant->val.s.str.buf))
     352    setme = variant->val.s.str.buf;
    350353  else
    351     setme = val->val.s.str.ptr = tr_new (char, byteCount + 1);
     354    setme = variant->val.s.str.ptr = tr_new (char, byteCount + 1);
    352355
    353356  memcpy (setme, src, byteCount);
    354357  setme[byteCount] = '\0';
    355   val->val.s.len = byteCount;
     358  variant->val.s.len = byteCount;
    356359}
    357360
    358361void
    359 tr_variantInitStr (tr_variant * val, const void * str, int len)
     362tr_variantInitStr (tr_variant * variant, const void * str, int len)
    360363{
    361364  if (str == NULL)
    … …  
    364367    len = strlen (str);
    365368
    366   tr_variantInitRaw (val, str, len);
     369  tr_variantInitRaw (variant, str, len);
    367370}
    368371
    369372void
    370 tr_variantInitBool (tr_variant * b, bool value)
    371 {
    372   tr_variantInit (b, TR_VARIANT_TYPE_BOOL);
    373   b->val.b = value != 0;
     373tr_variantInitBool (tr_variant * variant, bool value)
     374{
     375  tr_variantInit (variant, TR_VARIANT_TYPE_BOOL);
     376  variant->val.b = value != 0;
    374377}
    375378
    … …  
    382385
    383386void
    384 tr_variantInitInt (tr_variant * b, int64_t value)
    385 {
    386   tr_variantInit (b, TR_VARIANT_TYPE_INT);
    387   b->val.i = value;
     387tr_variantInitInt (tr_variant * variant, int64_t value)
     388{
     389  tr_variantInit (variant, TR_VARIANT_TYPE_INT);
     390  variant->val.i = value;
    388391}
    389392
    390393int
    391 tr_variantInitList (tr_variant * b, size_t reserve_count)
    392 {
    393   tr_variantInit (b, TR_VARIANT_TYPE_LIST);
    394   return tr_variantListReserve (b, reserve_count);
     394tr_variantInitList (tr_variant * variant, size_t reserve_count)
     395{
     396  tr_variantInit (variant, TR_VARIANT_TYPE_LIST);
     397  return tr_variantListReserve (variant, reserve_count);
    395398}
    396399
    397400static int
    398 makeroom (tr_variant * container, size_t count)
     401containerReserve (tr_variant * container, size_t count)
    399402{
    400403  const size_t needed = container->val.l.count + count;
    … …  
    424427
    425428int
    426 tr_variantListReserve (tr_variant * b, size_t count)
    427 {
    428   assert (tr_variantIsList (b));
    429   return makeroom (b, count);
     429tr_variantListReserve (tr_variant * list, size_t count)
     430{
     431  assert (tr_variantIsList (list));
     432  return containerReserve (list, count);
    430433}
    431434
    432435int
    433 tr_variantInitDict (tr_variant * b, size_t reserve_count)
    434 {
    435   tr_variantInit (b, TR_VARIANT_TYPE_DICT);
    436   return tr_variantDictReserve (b, reserve_count);
     436tr_variantInitDict (tr_variant * variant, size_t reserve_count)
     437{
     438  tr_variantInit (variant, TR_VARIANT_TYPE_DICT);
     439  return tr_variantDictReserve (variant, reserve_count);
    437440}
    438441
    439442int
    440 tr_variantDictReserve (tr_variant * b, size_t reserve_count)
    441 {
    442   assert (tr_variantIsDict (b));
    443   return makeroom (b, reserve_count * 2);
     443tr_variantDictReserve (tr_variant  * dict,
     444                       size_t        reserve_count)
     445{
     446  assert (tr_variantIsDict (dict));
     447  return containerReserve (dict, reserve_count * 2);
    444448}
    445449
    … …  
    447451tr_variantListAdd (tr_variant * list)
    448452{
    449   tr_variant * item;
     453  tr_variant * child;
    450454
    451455  assert (tr_variantIsList (list));
    452456
    453   if (list->val.l.count == list->val.l.alloc)
    454     tr_variantListReserve (list, 4);
    455 
    456   assert (list->val.l.count < list->val.l.alloc);
    457 
    458   item = &list->val.l.vals[list->val.l.count];
    459   list->val.l.count++;
    460   tr_variantInit (item, TR_VARIANT_TYPE_INT);
    461 
    462   return item;
     457  containerReserve (list, 1);
     458  child = &list->val.l.vals[list->val.l.count++];
     459  tr_variantInit (child, TR_VARIANT_TYPE_INT);
     460
     461  return child;
    463462}
    464463
    465464tr_variant *
    466 tr_variantListAddInt (tr_variant * list, int64_t val)
    467 {
    468   tr_variant * node = tr_variantListAdd (list);
    469   tr_variantInitInt (node, val);
    470   return node;
     465tr_variantListAddInt (tr_variant  * list,
     466                      int64_t       val)
     467{
     468  tr_variant * child = tr_variantListAdd (list);
     469  tr_variantInitInt (child, val);
     470  return child;
    471471}
    472472
    473473tr_variant *
    474 tr_variantListAddReal (tr_variant * list, double val)
    475 {
    476   tr_variant * node = tr_variantListAdd (list);
    477   tr_variantInitReal (node, val);
    478   return node;
     474tr_variantListAddReal (tr_variant  * list,
     475                       double        val)
     476{
     477  tr_variant * child = tr_variantListAdd (list);
     478  tr_variantInitReal (child, val);
     479  return child;
    479480}
    480481
    481482tr_variant *
    482 tr_variantListAddBool (tr_variant * list, bool val)
    483 {
    484   tr_variant * node = tr_variantListAdd (list);
    485   tr_variantInitBool (node, val);
    486   return node;
     483tr_variantListAddBool (tr_variant  * list,
     484                       bool          val)
     485{
     486  tr_variant * child = tr_variantListAdd (list);
     487  tr_variantInitBool (child, val);
     488  return child;
    487489}
    488490
    489491tr_variant *
    490 tr_variantListAddStr (tr_variant * list, const char * val)
    491 {
    492   tr_variant * node = tr_variantListAdd (list);
    493   tr_variantInitStr (node, val, -1);
    494   return node;
     492tr_variantListAddStr (tr_variant  * list,
     493                      const char  * val)
     494{
     495  tr_variant * child = tr_variantListAdd (list);
     496  tr_variantInitStr (child, val, -1);
     497  return child;
    495498}
    496499
    497500tr_variant *
    498 tr_variantListAddRaw (tr_variant * list, const void * val, size_t len)
    499 {
    500   tr_variant * node = tr_variantListAdd (list);
    501   tr_variantInitRaw (node, val, len);
    502   return node;
     501tr_variantListAddRaw (tr_variant  * list,
     502                      const void  * val,
     503                      size_t        len)
     504{
     505  tr_variant * child = tr_variantListAdd (list);
     506  tr_variantInitRaw (child, val, len);
     507  return child;
    503508}
    504509
    … …  
    525530                   const char  * key)
    526531{
    527   tr_variant * keyval;
    528   tr_variant * itemval;
     532  tr_variant * child_key;
     533  tr_variant * child_val;
    529534
    530535  assert (tr_variantIsDict (dict));
    531   if (dict->val.l.count + 2 > dict->val.l.alloc)
    532     makeroom (dict, 2);
    533   assert (dict->val.l.count + 2 <= dict->val.l.alloc);
    534 
    535   keyval = dict->val.l.vals + dict->val.l.count++;
    536   tr_variantInitStr (keyval, key, -1);
    537 
    538   itemval = dict->val.l.vals + dict->val.l.count++;
    539   tr_variantInit (itemval, TR_VARIANT_TYPE_INT);
    540 
    541   return itemval;
     536
     537  containerReserve (dict, 2);
     538
     539  child_key = dict->val.l.vals + dict->val.l.count++;
     540  tr_variantInitStr (child_key, key, -1);
     541
     542  child_val = dict->val.l.vals + dict->val.l.count++;
     543  tr_variantInit (child_val, TR_VARIANT_TYPE_INT);
     544  return child_val;
    542545}
    543546
    … …  
    590593}
    591594
    592 tr_variant*
    593 tr_variantDictAddStr (tr_variant * dict, const char * key, const char * val)
     595static tr_variant *
     596dictRecycleOrAdd (tr_variant * dict, const char * key)
    594597{
    595598  tr_variant * child;
    … …  
    614617    child = tr_variantDictAdd (dict, key);
    615618
    616   /* set it */
     619  return child;
     620}
     621
     622
     623tr_variant*
     624tr_variantDictAddStr (tr_variant * dict, const char * key, const char * val)
     625{
     626  tr_variant * child = dictRecycleOrAdd (dict, key);
    617627  tr_variantInitStr (child, val, -1);
    618 
    619628  return child;
    620629}
    … …  
    626635                      size_t       len)
    627636{
    628   tr_variant * child;
    629 
    630   /* see if it already exists, and if so, try to reuse it */
    631   if ((child = tr_variantDictFind (dict, key)))
    632     {
    633       if (tr_variantIsString (child))
    634         {
    635           if (stringIsAlloced (child))
    636             tr_free (child->val.s.str.ptr);
    637         }
    638       else
    639         {
    640           tr_variantDictRemove (dict, key);
    641           child = NULL;
    642         }
    643     }
    644 
    645   /* if it doesn't exist, create it */
    646   if (child == NULL)
    647     child = tr_variantDictAdd (dict, key);
    648 
    649   /* set it */
     637  tr_variant * child = dictRecycleOrAdd (dict, key);
    650638  tr_variantInitRaw (child, src, len);
    651 
    652639  return child;
    653640}
    … …  
    724711
    725712static void
    726 nodeInitDict (struct SaveNode * node, const tr_variant * val, bool sort_dicts)
     713nodeInitDict (struct SaveNode   * node,
     714              const tr_variant  * val,
     715              bool                sort_dicts)
    727716{
    728717  const int n = val->val.l.count;
    … …  
    768757
    769758static void
    770 nodeInitList (struct SaveNode * node, const tr_variant * val)
     759nodeInitList (struct SaveNode   * node,
     760              const tr_variant  * val)
    771761{
    772762  int i;
    … …  
    784774
    785775static void
    786 nodeInitLeaf (struct SaveNode * node, const tr_variant * val)
    787 {
    788   assert (!tr_variantIsContainer (val));
    789 
    790   node->val = val;
     776nodeInitLeaf (struct SaveNode   * node,
     777              const tr_variant  * variant)
     778{
     779  assert (!tr_variantIsContainer (variant));
     780
     781  node->val = variant;
    791782}
    792783
    793784static void
    794 nodeInit (struct SaveNode * node, const tr_variant * val, bool sort_dicts)
     785nodeInit (struct SaveNode   * node,
     786          const tr_variant  * variant,
     787          bool                sort_dicts)
    795788{
    796789  static const struct SaveNode INIT_NODE = { NULL, 0, 0, 0, NULL };
    … …  
    798791  *node = INIT_NODE;
    799792
    800   if (tr_variantIsList (val))
    801     nodeInitList (node, val);
    802   else if (tr_variantIsDict (val))
    803     nodeInitDict (node, val, sort_dicts);
     793  if (tr_variantIsList (variant))
     794    nodeInitList (node, variant);
     795  else if (tr_variantIsDict (variant))
     796    nodeInitDict (node, variant, sort_dicts);
    804797  else
    805     nodeInitLeaf (node, val);
     798    nodeInitLeaf (node, variant);
    806799}
    807800
    … …  
    975968     else if (tr_variantIsString (val))
    976969       {
    977          tr_variantListAddRaw (target, (const uint8_t*)getStr (val), val->val.s.len);
     970         size_t len;
     971         const char * str;
     972         tr_variantGetStr (val, &str, &len);
     973         tr_variantListAddRaw (target, str, len);
    978974       }
    979975     else if (tr_variantIsDict (val))
    … …  
    10041000
    10051001bool
    1006 tr_variantDictChild (tr_variant * dict, size_t n, const char ** key, tr_variant ** val)
     1002tr_variantDictChild (tr_variant   * dict,
     1003                     size_t         n,
     1004                     const char  ** key,
     1005                     tr_variant  ** val)
    10071006{
    10081007  bool success = 0;
    … …  
    10601059          else if (tr_variantIsString (val))
    10611060            {
    1062               tr_variantDictAddRaw (target, key, getStr (val), val->val.s.len);
     1061              size_t len;
     1062              const char * str;
     1063              tr_variantGetStr (val, &str, &len);
     1064              tr_variantDictAddRaw (target, key, str, len);
    10631065            }
    10641066          else if (tr_variantIsDict (val) && tr_variantDictFindDict (target, key, &t))
    … …  
    11441146
    11451147int
    1146 tr_variantToFile (const tr_variant * top, tr_variant_fmt fmt, const char * filename)
     1148tr_variantToFile (const tr_variant  * top,
     1149                  tr_variant_fmt      fmt,
     1150                  const char        * filename)
    11471151{
    11481152  char * tmp;
    … …  
    11961200      else
    11971201        {
    1198           //tr_fsync (fd);
    11991202          tr_close_file (fd);
    12001203
    … …  
    12301233
    12311234int
    1232 tr_variantFromFile (tr_variant * setme, tr_variant_fmt fmt, const char * filename)
     1235tr_variantFromFile (tr_variant      * setme,
     1236                    tr_variant_fmt    fmt,
     1237                    const char      * filename)
    12331238{
    12341239  int err;
Note: See TracChangeset for help on using the changeset viewer.