lib/obj2buck.c

   1 /*
   2  *      Generating V33 buckets
   3  *
   4  *      (c) 2004, Robert Spalek <robert@ucw.cz>
   5  */
   6
   7 #include "lib/lib.h"
   8 #include "lib/fastbuf.h"
   9 #include "lib/obj2buck.h"
  10 #include "lib/bucket.h"
  11 #include "charset/unistream.h"
  12
  13 #include <string.h>
  14 #include <stdarg.h>
  15
  16 static uns use_v33;
  17
  18 void
  19 attr_set_type(uns type)
  20 {
  21   switch (type)
  22     {
  23     case BUCKET_TYPE_PLAIN:
  24     case BUCKET_TYPE_V30:
  25       use_v33 = 0;
  26       break;
  27     case BUCKET_TYPE_V33:
  28     case BUCKET_TYPE_V33_LIZARD:
  29       use_v33 = 1;
  30       break;
  31     default:
  32       die("Don't know how to generate buckets of type %08x", type);
  33     }
  34 }
  35
  36 inline byte *
  37 put_attr(byte *ptr, uns type, byte *val, uns len)
  38 {
  39   if (use_v33)
  40   {
  41     PUT_UTF8(ptr, len+1);
  42     memcpy(ptr, val, len);
  43     ptr += len;
  44     *ptr++ = type;
  45   }
  46   else
  47   {
  48     *ptr++ = type;
  49     memcpy(ptr, val, len);
  50     ptr += len;
  51     *ptr++ = '\n';
  52   }
  53   return ptr;
  54 }
  55
  56 byte *
  57 put_attr_str(byte *ptr, uns type, byte *val)
  58 {
  59   return put_attr(ptr, type, val, strlen(val));
  60 }
  61
  62 inline byte *
  63 put_attr_vformat(byte *ptr, uns type, byte *mask, va_list va)
  64 {
  65   if (use_v33)
  66   {
  67     uns len = vsprintf(ptr+1, mask, va);
  68     if (len >= 127)
  69     {
  70       byte tmp[6], *tmp_end = tmp;
  71       PUT_UTF8(tmp_end, len+1);
  72       uns l = tmp_end - tmp;
  73       memmove(ptr+l, ptr+1, len);
  74       memcpy(ptr, tmp, l);
  75       ptr += l + len;
  76     }
  77     else
  78     {
  79       *ptr = len+1;
  80       ptr += len+1;
  81     }
  82     *ptr++ = type;
  83   }
  84   else
  85   {
  86     *ptr++ = type;
  87     ptr += vsprintf(ptr, mask, va);
  88     *ptr++ = '\n';
  89   }
  90   return ptr;
  91 }
  92
  93 byte *
  94 put_attr_format(byte *ptr, uns type, char *mask, ...)
  95 {
  96   va_list va;
  97   va_start(va, mask);
  98   byte *ret = put_attr_vformat(ptr, type, mask, va);
  99   va_end(va);
 100   return ret;
 101 }
 102
 103 byte *
 104 put_attr_num(byte *ptr, uns type, uns val)
 105 {
 106   if (use_v33)
 107   {
 108     uns len = sprintf(ptr+1, "%d", val) + 1;
 109     *ptr = len;
 110     ptr += len;
 111     *ptr++ = type;
 112   }
 113   else
 114     ptr += sprintf(ptr, "%c%d\n", type, val);
 115   return ptr;
 116 }
 117
 118 inline void
 119 bput_attr(struct fastbuf *b, uns type, byte *val, uns len)
 120 {
 121   if (use_v33)
 122   {
 123     bput_utf8(b, len+1);
 124     bwrite(b, val, len);
 125     bputc(b, type);
 126   }
 127   else
 128   {
 129     bputc(b, type);
 130     bwrite(b, val, len);
 131     bputc(b, '\n');
 132   }
 133 }
 134
 135 void
 136 bput_attr_str(struct fastbuf *b, uns type, byte *val)
 137 {
 138   bput_attr(b, type, val, strlen(val));
 139 }
 140
 141 inline void
 142 bput_attr_vformat(struct fastbuf *b, uns type, byte *mask, va_list va)
 143 {
 144   if (use_v33)
 145   {
 146     int len = vsnprintf(NULL, 0, mask, va);
 147     if (len < 0)
 148       die("vsnprintf() does not support size=0");
 149     bput_utf8(b, len+1);
 150     vbprintf(b, mask, va);
 151     bputc(b, type);
 152   }
 153   else
 154   {
 155     bputc(b, type);
 156     vbprintf(b, mask, va);
 157     bputc(b, '\n');
 158   }
 159 }
 160
 161 void
 162 bput_attr_format(struct fastbuf *b, uns type, char *mask, ...)
 163 {
 164   va_list va;
 165   va_start(va, mask);
 166   bput_attr_vformat(b, type, mask, va);
 167   va_end(va);
 168 }
 169
 170 void
 171 bput_attr_num(struct fastbuf *b, uns type, uns val)
 172 {
 173   if (use_v33)
 174   {
 175     byte tmp[12];
 176     uns len = sprintf(tmp, "%d", val);
 177     bputc(b, len+1);
 178     bwrite(b, tmp, len);
 179     bputc(b, type);
 180   }
 181   else
 182     bprintf(b, "%c%d\n", type, val);
 183 }