← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/base64.c

  • Committer: Brian Aker
  • Date: 2008-10-06 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/base64.c
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
 
#include <drizzled/global.h>
17
16
#include <mystrings/m_string.h>  /* strchr() */
18
17
#include <mystrings/m_ctype.h>  /* my_isspace() */
19
18
#include <mysys/base64.h>
20
 
#include <cstdio>
21
 
#include <cmath>
22
 
 
23
 
using namespace std;
24
 
 
25
 
template <class T, class U>
26
 
inline void skip_space(T src, U i, const U size)
27
 
{
28
 
  while (i < size && my_isspace(&my_charset_utf8_general_ci, * src))
29
 
  {
30
 
    i++;
31
 
    src++;
32
 
 
33
 
    if (i == size)
34
 
    {
35
 
      break;
36
 
    }
37
 
  }
38
 
}
39
19
 
40
20
#ifndef MAIN
41
21
 
60
40
int
61
41
base64_needed_decoded_length(int length_of_encoded_data)
62
42
{
63
 
  return (int) ceil((double)(length_of_encoded_data * 3 / 4));
 
43
  return (int) ceil(length_of_encoded_data * 3 / 4);
64
44
}
65
45
 
66
46
 
122
102
static inline uint
123
103
pos(unsigned char c)
124
104
{
125
 
  return (uint32_t) (strchr(base64_table, c) - base64_table);
 
105
  return (uint) (strchr(base64_table, c) - base64_table);
 
106
}
 
107
 
 
108
 
 
109
#define SKIP_SPACE(src, i, size)                                \
 
110
{                                                               \
 
111
  while (i < size && my_isspace(&my_charset_utf8_general_ci, * src))     \
 
112
  {                                                             \
 
113
    i++;                                                        \
 
114
    src++;                                                      \
 
115
  }                                                             \
 
116
  if (i == size)                                                \
 
117
  {                                                             \
 
118
    break;                                                      \
 
119
  }                                                             \
126
120
}
127
121
 
128
122
 
172
166
    unsigned c= 0;
173
167
    size_t mark= 0;
174
168
 
175
 
    skip_space(src, i, len);
176
 
 
177
 
    c += pos(*src++);
178
 
    c <<= 6;
179
 
    i++;
180
 
 
181
 
    skip_space(src, i, len);
182
 
 
183
 
    c += pos(*src++);
184
 
    c <<= 6;
185
 
    i++;
186
 
 
187
 
    skip_space(src, i, len);
 
169
    SKIP_SPACE(src, i, len);
 
170
 
 
171
    c += pos(*src++);
 
172
    c <<= 6;
 
173
    i++;
 
174
 
 
175
    SKIP_SPACE(src, i, len);
 
176
 
 
177
    c += pos(*src++);
 
178
    c <<= 6;
 
179
    i++;
 
180
 
 
181
    SKIP_SPACE(src, i, len);
188
182
 
189
183
    if (*src != '=')
190
184
      c += pos(*src++);
199
193
    c <<= 6;
200
194
    i++;
201
195
 
202
 
    skip_space(src, i, len);
 
196
    SKIP_SPACE(src, i, len);
203
197
 
204
198
    if (*src != '=')
205
199
      c += pos(*src++);
213
207
    i++;
214
208
 
215
209
  end:
216
 
    b[0]= char((c >> 16) & 0xff);
217
 
    b[1]= char((c >>  8) & 0xff);
218
 
    b[2]= char((c >>  0) & 0xff);
 
210
    b[0]= (c >> 16) & 0xff;
 
211
    b[1]= (c >>  8) & 0xff;
 
212
    b[2]= (c >>  0) & 0xff;
219
213
 
220
214
    for (j=0; j<3-mark; j++)
221
215
      *d++= b[j];
228
222
    The variable 'i' is set to 'len' when padding has been read, so it
229
223
    does not actually reflect the number of bytes read from 'src'.
230
224
   */
231
 
  return (i != len) ? -1 : int(d - dst_base);
 
225
  return i != len ? -1 : d - dst_base;
232
226
}
233
227
 
234
228
 
288
282
      printf("       --------- src ---------   --------- dst ---------\n");
289
283
      for (k= 0; k<src_len; k+=8)
290
284
      {
291
 
        printf("%.4x   ", (uint32_t) k);
 
285
        printf("%.4x   ", (uint) k);
292
286
        for (l=0; l<8 && k+l<src_len; l++)
293
287
        {
294
288
          unsigned char c= src[k+l];
305
299
        printf("\n");
306
300
      }
307
301
      printf("src length: %.8x, dst length: %.8x\n",
308
 
             (uint32_t) src_len, (uint32_t) dst_len);
 
302
             (uint) src_len, (uint) dst_len);
309
303
      require(0);
310
304
    }
311
305
  }