← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/my_decimal.h

  • 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:
drizzled/my_decimal.h
22
22
 
23
23
  It is interface module to fixed precision decimals library.
24
24
 
25
 
  Most functions use 'uint mask' as parameter, if during operation error
 
25
  Most functions use 'uint32_t mask' as parameter, if during operation error
26
26
  which fit in this mask is detected then it will be processed automatically
27
27
  here. (errors are E_DEC_* constants, see include/decimal.h)
28
28
 
76
76
#define DECIMAL_MAX_FIELD_SIZE DECIMAL_MAX_PRECISION
77
77
 
78
78
 
79
 
inline uint my_decimal_size(uint precision, uint scale)
 
79
inline uint32_t my_decimal_size(uint32_t precision, uint32_t scale)
80
80
{
81
81
  /*
82
82
    Always allocate more space to allow library to put decimal point
86
86
}
87
87
 
88
88
 
89
 
inline int my_decimal_int_part(uint precision, uint decimals)
 
89
inline int my_decimal_int_part(uint32_t precision, uint32_t decimals)
90
90
{
91
91
  return precision - ((decimals == DECIMAL_NOT_SPECIFIED) ? 0 : decimals);
92
92
}
112
112
    buf= buffer;
113
113
#if !defined (HAVE_purify) 
114
114
    /* Set buffer to 'random' value to find wrong buffer usage */
115
 
    for (uint i= 0; i < DECIMAL_BUFF_LENGTH; i++)
 
115
    for (uint32_t i= 0; i < DECIMAL_BUFF_LENGTH; i++)
116
116
      buffer[i]= i;
117
117
#endif
118
118
  }
124
124
 
125
125
  bool sign() const { return decimal_t::sign; }
126
126
  void sign(bool s) { decimal_t::sign= s; }
127
 
  uint precision() const { return intg + frac; }
 
127
  uint32_t precision() const { return intg + frac; }
128
128
};
129
129
 
130
130
int decimal_operation_results(int result);
142
142
  max_my_decimal(to, DECIMAL_MAX_PRECISION, 0);
143
143
}
144
144
 
145
 
inline int check_result(uint mask, int result)
 
145
inline int check_result(uint32_t mask, int result)
146
146
{
147
147
  if (result & mask)
148
148
    decimal_operation_results(result);
149
149
  return result;
150
150
}
151
151
 
152
 
inline int check_result_and_overflow(uint mask, int result, my_decimal *val)
 
152
inline int check_result_and_overflow(uint32_t mask, int result, my_decimal *val)
153
153
{
154
154
  if (check_result(mask, result) & E_DEC_OVERFLOW)
155
155
  {
161
161
  return result;
162
162
}
163
163
 
164
 
inline uint my_decimal_length_to_precision(uint length, uint scale,
 
164
inline uint32_t my_decimal_length_to_precision(uint32_t length, uint32_t scale,
165
165
                                           bool unsigned_flag)
166
166
{
167
167
  return (uint) (length - (scale>0 ? 1:0) - (unsigned_flag ? 0:1));
168
168
}
169
169
 
170
 
inline uint32_t my_decimal_precision_to_length(uint precision, uint8_t scale,
 
170
inline uint32_t my_decimal_precision_to_length(uint32_t precision, uint8_t scale,
171
171
                                             bool unsigned_flag)
172
172
{
173
173
  set_if_smaller(precision, DECIMAL_MAX_PRECISION);
190
190
 
191
191
 
192
192
inline
193
 
int my_decimal_get_binary_size(uint precision, uint scale)
 
193
int my_decimal_get_binary_size(uint32_t precision, uint32_t scale)
194
194
{
195
195
  return decimal_bin_size((int)precision, (int)scale);
196
196
}
204
204
}
205
205
 
206
206
 
207
 
int my_decimal2binary(uint mask, const my_decimal *d, unsigned char *bin, int prec,
 
207
int my_decimal2binary(uint32_t mask, const my_decimal *d, unsigned char *bin, int prec,
208
208
                      int scale);
209
209
 
210
210
 
211
211
inline
212
 
int binary2my_decimal(uint mask, const unsigned char *bin, my_decimal *d, int prec,
 
212
int binary2my_decimal(uint32_t mask, const unsigned char *bin, my_decimal *d, int prec,
213
213
                      int scale)
214
214
{
215
215
  return check_result(mask, bin2decimal(bin, (decimal_t*) d, prec, scale));
232
232
 
233
233
 
234
234
inline
235
 
int my_decimal_round(uint mask, const my_decimal *from, int scale,
 
235
int my_decimal_round(uint32_t mask, const my_decimal *from, int scale,
236
236
                     bool truncate, my_decimal *to)
237
237
{
238
238
  return check_result(mask, decimal_round((decimal_t*) from, to, scale,
241
241
 
242
242
 
243
243
inline
244
 
int my_decimal_floor(uint mask, const my_decimal *from, my_decimal *to)
 
244
int my_decimal_floor(uint32_t mask, const my_decimal *from, my_decimal *to)
245
245
{
246
246
  return check_result(mask, decimal_round((decimal_t*) from, to, 0, FLOOR));
247
247
}
248
248
 
249
249
 
250
250
inline
251
 
int my_decimal_ceiling(uint mask, const my_decimal *from, my_decimal *to)
 
251
int my_decimal_ceiling(uint32_t mask, const my_decimal *from, my_decimal *to)
252
252
{
253
253
  return check_result(mask, decimal_round((decimal_t*) from, to, 0, CEILING));
254
254
}
255
255
 
256
256
 
257
 
int my_decimal2string(uint mask, const my_decimal *d, uint fixed_prec,
258
 
                      uint fixed_dec, char filler, String *str);
 
257
int my_decimal2string(uint32_t mask, const my_decimal *d, uint32_t fixed_prec,
 
258
                      uint32_t fixed_dec, char filler, String *str);
259
259
 
260
260
inline
261
 
int my_decimal2int(uint mask, const my_decimal *d, bool unsigned_flag,
 
261
int my_decimal2int(uint32_t mask, const my_decimal *d, bool unsigned_flag,
262
262
                   int64_t *l)
263
263
{
264
264
  my_decimal rounded;
271
271
 
272
272
 
273
273
inline
274
 
int my_decimal2double(uint mask __attribute__((unused)), 
 
274
int my_decimal2double(uint32_t mask __attribute__((unused)), 
275
275
                      const my_decimal *d, double *result)
276
276
{
277
277
  /* No need to call check_result as this will always succeed */
280
280
 
281
281
 
282
282
inline
283
 
int str2my_decimal(uint mask, char *str, my_decimal *d, char **end)
 
283
int str2my_decimal(uint32_t mask, char *str, my_decimal *d, char **end)
284
284
{
285
285
  return check_result_and_overflow(mask, string2decimal(str,(decimal_t*)d,end),
286
286
                                   d);
287
287
}
288
288
 
289
289
 
290
 
int str2my_decimal(uint mask, const char *from, uint length,
 
290
int str2my_decimal(uint32_t mask, const char *from, uint32_t length,
291
291
                   const CHARSET_INFO * charset, my_decimal *decimal_value);
292
292
 
293
293
#if defined(DRIZZLE_SERVER)
294
294
inline
295
 
int string2my_decimal(uint mask, const String *str, my_decimal *d)
 
295
int string2my_decimal(uint32_t mask, const String *str, my_decimal *d)
296
296
{
297
297
  return str2my_decimal(mask, str->ptr(), str->length(), str->charset(), d);
298
298
}
304
304
#endif /*defined(DRIZZLE_SERVER) */
305
305
 
306
306
inline
307
 
int double2my_decimal(uint mask, double val, my_decimal *d)
 
307
int double2my_decimal(uint32_t mask, double val, my_decimal *d)
308
308
{
309
309
  return check_result_and_overflow(mask, double2decimal(val, (decimal_t*)d), d);
310
310
}
311
311
 
312
312
 
313
313
inline
314
 
int int2my_decimal(uint mask, int64_t i, bool unsigned_flag, my_decimal *d)
 
314
int int2my_decimal(uint32_t mask, int64_t i, bool unsigned_flag, my_decimal *d)
315
315
{
316
316
  return check_result(mask, (unsigned_flag ?
317
317
                             uint64_t2decimal((uint64_t)i, d) :
332
332
 
333
333
 
334
334
inline
335
 
int my_decimal_add(uint mask, my_decimal *res, const my_decimal *a,
 
335
int my_decimal_add(uint32_t mask, my_decimal *res, const my_decimal *a,
336
336
                   const my_decimal *b)
337
337
{
338
338
  return check_result_and_overflow(mask,
342
342
 
343
343
 
344
344
inline
345
 
int my_decimal_sub(uint mask, my_decimal *res, const my_decimal *a,
 
345
int my_decimal_sub(uint32_t mask, my_decimal *res, const my_decimal *a,
346
346
                   const my_decimal *b)
347
347
{
348
348
  return check_result_and_overflow(mask,
352
352
 
353
353
 
354
354
inline
355
 
int my_decimal_mul(uint mask, my_decimal *res, const my_decimal *a,
 
355
int my_decimal_mul(uint32_t mask, my_decimal *res, const my_decimal *a,
356
356
                   const my_decimal *b)
357
357
{
358
358
  return check_result_and_overflow(mask,
362
362
 
363
363
 
364
364
inline
365
 
int my_decimal_div(uint mask, my_decimal *res, const my_decimal *a,
 
365
int my_decimal_div(uint32_t mask, my_decimal *res, const my_decimal *a,
366
366
                   const my_decimal *b, int div_scale_inc)
367
367
{
368
368
  return check_result_and_overflow(mask,
373
373
 
374
374
 
375
375
inline
376
 
int my_decimal_mod(uint mask, my_decimal *res, const my_decimal *a,
 
376
int my_decimal_mod(uint32_t mask, my_decimal *res, const my_decimal *a,
377
377
                   const my_decimal *b)
378
378
{
379
379
  return check_result_and_overflow(mask,
400
400
}
401
401
 
402
402
 
403
 
void my_decimal_trim(uint32_t *precision, uint *scale);
 
403
void my_decimal_trim(uint32_t *precision, uint32_t *scale);
404
404
 
405
405
 
406
406
#endif /*my_decimal_h*/