Line data Source code
1 : /* FreeTDS - Library of routines accessing Sybase and Microsoft databases
2 : * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Brian Bruns
3 : * Copyright (C) 2010-2015 Frediano Ziglio
4 : *
5 : * This library is free software; you can redistribute it and/or
6 : * modify it under the terms of the GNU Library General Public
7 : * License as published by the Free Software Foundation; either
8 : * version 2 of the License, or (at your option) any later version.
9 : *
10 : * This library is distributed in the hope that it will be useful,
11 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 : * Library General Public License for more details.
14 : *
15 : * You should have received a copy of the GNU Library General Public
16 : * License along with this library; if not, write to the
17 : * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 : * Boston, MA 02111-1307, USA.
19 : */
20 :
21 : #include <config.h>
22 :
23 : #include <stdarg.h>
24 : #include <stdio.h>
25 :
26 : #include <freetds/time.h>
27 :
28 : #include <assert.h>
29 : #include <ctype.h>
30 :
31 : #if HAVE_ERRNO_H
32 : #include <errno.h>
33 : #endif /* HAVE_ERRNO_H */
34 :
35 : #if HAVE_STDLIB_H
36 : #include <stdlib.h>
37 : #endif /* HAVE_STDLIB_H */
38 :
39 : #if HAVE_STRING_H
40 : #include <string.h>
41 : #endif /* HAVE_STRING_H */
42 :
43 : #if HAVE_STRINGS_H
44 : #include <strings.h>
45 : #endif /* HAVE_STRINGS_H */
46 :
47 : #include <freetds/tds.h>
48 : #include <freetds/convert.h>
49 : #include <freetds/bytes.h>
50 : #include <freetds/replacements.h>
51 : #include <freetds/utils.h>
52 :
53 : typedef unsigned short utf16_t;
54 :
55 : struct tds_time
56 : {
57 : int tm_year; /**< year (0=1900) */
58 : int tm_mon; /**< month (0-11) */
59 : int tm_mday; /**< month day (1-31) */
60 : int tm_hour; /**< hours (0-23) */
61 : int tm_min; /**< minutes (0-59) */
62 : int tm_sec; /**< seconds (0-59) */
63 : int tm_ns; /**< nanoseconds (0-999999999) */
64 : };
65 :
66 : static TDS_INT tds_convert_int(TDS_INT num, int desttype, CONV_RESULT * cr);
67 : static TDS_INT tds_convert_uint8(const TDS_UINT8 * src, int desttype, CONV_RESULT * cr);
68 : static int string_to_datetime(const char *datestr, TDS_UINT len, int desttype, CONV_RESULT * cr);
69 : static bool is_dd_mon_yyyy(char *t);
70 : static int store_dd_mon_yyy_date(char *datestr, struct tds_time *t);
71 : static const char *parse_numeric(const char *buf, const char *pend,
72 : bool * p_negative, size_t *p_digits, size_t *p_decimals);
73 :
74 : #define test_alloc(x) {if ((x)==NULL) return TDS_CONVERT_NOMEM;}
75 :
76 : /*
77 : * Macros for number checks.
78 : * They work for signed/unsigned integers and floating point values
79 : * (accounting for truncation of any fractional portions of the latter).
80 : */
81 : #define IS_TINYINT(x) ( -1 < (x) && (x) < 0x100 )
82 : #define IS_SMALLINT(x) ( -32769 < (x) && (x) < 32768 )
83 : #define IS_USMALLINT(x) ( -1 < (x) && (x) < 65536 )
84 : #define IS_SINT1(x) ( -129 < (x) && (x) < 128 )
85 :
86 : /*
87 : * Macros for integer number checks.
88 : * IS_UINT works for both integers and floating point values.
89 : *
90 : * f77: I don't write -2147483648, some compiler seem to have some problem
91 : * with this constant although is a valid 32bit value
92 : */
93 : #define TDS_INT_MIN (-2147483647-1)
94 : #define TDS_INT_MAX 2147483647
95 : #define INT_IS_INT(x) (TDS_INT_MIN <= (x) && (x) <= TDS_INT_MAX)
96 : #define TDS_UINT_MAX 4294967295u
97 : #define IS_UINT(x) (-1 < (TDS_INT8)(x) && (x) < (TDS_INT8) TDS_UINT_MAX + 1)
98 : #define TDS_INT8_MIN (-INT64_C(9223372036854775807)-1)
99 : #define TDS_INT8_MAX INT64_C(9223372036854775807)
100 :
101 : /*
102 : * Macros for floating point number checks.
103 : * To avoid possible loss of precision, use upper bounds for floating point
104 : * values and test MIN - (x) < 1 rather than MIN - 1 < (x) for signed
105 : * destination types.
106 : */
107 : #define TDS_INT_UPPER_FLOAT 2147483648.0f
108 : #define FLOAT_IS_INT(x) (TDS_INT_MIN - (x) < 1.0f && (x) < TDS_INT_UPPER_FLOAT)
109 : #define TDS_INT8_MIN_FLOAT (-9223372036854775808.0f)
110 : #define TDS_INT8_UPPER_FLOAT 9223372036854775808.0f
111 : #define FLOAT_IS_INT8(x) (TDS_INT8_MIN_FLOAT - (x) < 1.0f && (x) < TDS_INT8_UPPER_FLOAT)
112 : #define TDS_UINT8_UPPER 18446744073709551616.0f
113 : #define FLOAT_IS_UINT8(x) (-1.0f < (x) && (x) < TDS_UINT8_UPPER)
114 :
115 : #define TDS_ISDIGIT(c) ((c) >= '0' && (c) <= '9')
116 :
117 : #define BIGDATETIME_BIAS 693961
118 :
119 : /**
120 : * \ingroup libtds
121 : * \defgroup convert Conversion
122 : * Conversions between datatypes. Supports, for example, dbconvert().
123 : */
124 :
125 : /**
126 : * \addtogroup convert
127 : * @{
128 : */
129 :
130 : /**
131 : * convert a number in string to a TDSNUMERIC
132 : * @return sizeof(TDS_NUMERIC) on success, TDS_CONVERT_* failure code on failure
133 : */
134 : static int string_to_numeric(const char *instr, const char *pend, CONV_RESULT * cr);
135 :
136 : /**
137 : * convert a zero terminated string to NUMERIC
138 : * @return sizeof(TDS_NUMERIC) on success, TDS_CONVERT_* failure code on failure
139 : */
140 : static int stringz_to_numeric(const char *instr, CONV_RESULT * cr);
141 :
142 : static TDS_INT string_to_int(const char *buf, const char *pend, TDS_INT * res);
143 : static TDS_INT string_to_int8(const char *buf, const char *pend, TDS_INT8 * res);
144 : static TDS_INT string_to_uint8(const char *buf, const char *pend, TDS_UINT8 * res);
145 : static TDS_INT string_to_float(const TDS_CHAR * src, TDS_UINT srclen, int desttype, CONV_RESULT * cr);
146 :
147 : static int store_hour(const char *, const char *, struct tds_time *);
148 : static int store_time(const char *, struct tds_time *);
149 : static int store_yymmdd_date(const char *, struct tds_time *);
150 : static int store_monthname(const char *, struct tds_time *);
151 : static int store_numeric_date(const char *, struct tds_time *);
152 : static int store_mday(const char *, struct tds_time *);
153 : static int store_year(int, struct tds_time *);
154 :
155 : /* static int days_this_year (int years); */
156 : static bool is_timeformat(const char *);
157 : static bool is_numeric(const char *);
158 : static bool is_alphabetic(const char *);
159 : static bool is_ampm(const char *);
160 : #define is_monthname(s) (store_monthname(s, NULL) >= 0)
161 : static bool is_numeric_dateformat(const char *);
162 :
163 : #if 0
164 : static TDS_UINT utf16len(const utf16_t * s);
165 : static const char *tds_prtype(int token);
166 : #endif
167 :
168 : const char tds_hex_digits[] = "0123456789abcdef";
169 :
170 : /**
171 : * Copy a terminated string to result and return len or TDS_CONVERT_NOMEM
172 : */
173 : static TDS_INT
174 21312 : string_to_result(int desttype, const char *s, CONV_RESULT * cr)
175 : {
176 21312 : size_t len = strlen(s);
177 :
178 21312 : if (desttype != TDS_CONVERT_CHAR) {
179 6456 : cr->c = tds_new(TDS_CHAR, len + 1);
180 6456 : test_alloc(cr->c);
181 6456 : memcpy(cr->c, s, len + 1);
182 : } else {
183 14856 : memcpy(cr->cc.c, s, len < cr->cc.len ? len : cr->cc.len);
184 : }
185 21312 : return (TDS_INT)len;
186 : }
187 :
188 : /**
189 : * Copy binary data to to result and return len or TDS_CONVERT_NOMEM
190 : */
191 : static TDS_INT
192 2196 : binary_to_result(int desttype, const void *data, size_t len, CONV_RESULT * cr)
193 : {
194 2196 : if (desttype != TDS_CONVERT_BINARY) {
195 2166 : cr->ib = tds_new(TDS_CHAR, len);
196 2166 : test_alloc(cr->ib);
197 2166 : memcpy(cr->ib, data, len);
198 : } else {
199 30 : memcpy(cr->cb.ib, data, len < cr->cb.len ? len : cr->cb.len);
200 : }
201 2196 : return (TDS_INT)len;
202 : }
203 :
204 : #define CASE_ALL_CHAR \
205 : SYBCHAR: case SYBVARCHAR: case SYBTEXT: case XSYBCHAR: case XSYBVARCHAR
206 : #define CASE_ALL_BINARY \
207 : SYBBINARY: case SYBVARBINARY: case SYBIMAGE: case XSYBBINARY: case XSYBVARBINARY: \
208 : case SYBLONGBINARY: case TDS_CONVERT_BINARY
209 :
210 : /* TODO implement me */
211 : /*
212 : static TDS_INT
213 : tds_convert_ntext(int srctype,TDS_CHAR *src,TDS_UINT srclen,
214 : int desttype, CONV_RESULT *cr)
215 : {
216 : return TDS_CONVERT_NOAVAIL;
217 : }
218 : */
219 :
220 : static TDS_INT
221 18330 : tds_convert_binary(const TDS_UCHAR * src, TDS_INT srclen, int desttype, CONV_RESULT * cr)
222 : {
223 : int cplen;
224 : int s;
225 : char *c;
226 :
227 18330 : switch (desttype) {
228 768 : case TDS_CONVERT_CHAR:
229 768 : cplen = srclen * 2;
230 768 : if ((TDS_UINT)cplen > cr->cc.len)
231 480 : cplen = cr->cc.len;
232 :
233 768 : c = cr->cc.c;
234 800946 : for (s = 0; cplen >= 2; ++s, cplen -= 2) {
235 800178 : *c++ = tds_hex_digits[src[s]>>4];
236 800178 : *c++ = tds_hex_digits[src[s]&0xF];
237 : }
238 768 : if (cplen)
239 240 : *c = tds_hex_digits[src[s]>>4];
240 : return srclen * 2;
241 :
242 662 : case CASE_ALL_CHAR:
243 :
244 : /*
245 : * NOTE: Do not prepend 0x to string.
246 : * The libraries all expect a bare string, without a 0x prefix.
247 : * Applications such as isql and query analyzer provide the "0x" prefix.
248 : */
249 :
250 : /* 2 * source length + 1 for terminator */
251 :
252 662 : cr->c = tds_new(TDS_CHAR, (srclen * 2) + 1);
253 662 : test_alloc(cr->c);
254 :
255 : c = cr->c;
256 :
257 115122 : for (s = 0; s < srclen; s++) {
258 115122 : *c++ = tds_hex_digits[src[s]>>4];
259 115122 : *c++ = tds_hex_digits[src[s]&0xF];
260 : }
261 :
262 662 : *c = '\0';
263 662 : return (srclen * 2);
264 : break;
265 2080 : case SYBINT1:
266 : case SYBSINT1:
267 : case SYBUINT1:
268 : case SYBINT2:
269 : case SYBUINT2:
270 : case SYBINT4:
271 : case SYBUINT4:
272 : case SYBINT8:
273 : case SYBUINT8:
274 : case SYBMONEY4:
275 : case SYBMONEY:
276 : case SYBREAL:
277 : case SYBFLT8:
278 2080 : cplen = tds_get_size_by_type(desttype);
279 2080 : if (srclen >= cplen)
280 680 : srclen = cplen;
281 2080 : memcpy(cr, src, srclen);
282 2080 : memset(((char*) cr) + srclen, 0, cplen - srclen);
283 2080 : return cplen;
284 : break;
285 :
286 : /* conversions not allowed */
287 : case SYBDATETIME4:
288 : case SYBDATETIME:
289 : case SYBDATETIMN:
290 :
291 : /* TODO should we do some test for these types or work as ints ?? */
292 : case SYBDECIMAL:
293 : case SYBNUMERIC:
294 : case SYBBIT:
295 : case SYBBITN:
296 :
297 : default:
298 : break;
299 : }
300 : return TDS_CONVERT_NOAVAIL;
301 : }
302 :
303 : TDS_INT
304 1032 : tds_char2hex(TDS_CHAR *dest, TDS_UINT destlen, const TDS_CHAR * src, TDS_UINT srclen)
305 : {
306 : unsigned int i;
307 1032 : unsigned char hex1, c = 0;
308 :
309 : /* if srclen if odd we must add a "0" before ... */
310 1032 : i = 0; /* number where to start converting */
311 1032 : if (srclen & 1) {
312 360 : ++srclen;
313 360 : i = 1;
314 360 : --src;
315 : }
316 622120 : for (; i < srclen; ++i) {
317 622130 : hex1 = src[i];
318 :
319 622130 : if ('0' <= hex1 && hex1 <= '9')
320 519362 : hex1 &= 0x0f;
321 : else {
322 102768 : hex1 &= 0x20 ^ 0xff; /* mask off 0x20 to ensure upper case */
323 102768 : if ('A' <= hex1 && hex1 <= 'F') {
324 102758 : hex1 -= ('A' - 10);
325 : } else {
326 10 : tdsdump_log(TDS_DBG_INFO1,
327 : "error_handler: attempt to convert data stopped by syntax error in source field \n");
328 : return TDS_CONVERT_SYNTAX;
329 : }
330 : }
331 622120 : assert(hex1 < 0x10);
332 :
333 622120 : if ((i/2u) >= destlen)
334 0 : continue;
335 :
336 622120 : if (i & 1)
337 311240 : dest[i / 2u] = c | hex1;
338 : else
339 310880 : c = hex1 << 4;
340 : }
341 1022 : return srclen / 2u;
342 : }
343 :
344 : static TDS_INT
345 1424070 : tds_convert_char(const TDS_CHAR * src, TDS_UINT srclen, int desttype, CONV_RESULT * cr)
346 : {
347 : unsigned int i;
348 :
349 : TDS_INT8 mymoney;
350 : char mynumber[28];
351 :
352 : TDS_INT tds_i;
353 : TDS_INT8 tds_i8;
354 : TDS_UINT8 tds_ui8;
355 : TDS_INT rc;
356 :
357 : bool negative;
358 : size_t digits, decimals;
359 :
360 1424070 : switch (desttype) {
361 0 : case TDS_CONVERT_CHAR:
362 0 : memcpy(cr->cc.c, src, srclen < cr->cc.len ? srclen : cr->cc.len);
363 0 : return srclen;
364 :
365 2160 : case CASE_ALL_CHAR:
366 2160 : cr->c = tds_new(TDS_CHAR, srclen + 1);
367 2160 : test_alloc(cr->c);
368 2160 : memcpy(cr->c, src, srclen);
369 2160 : cr->c[srclen] = 0;
370 2160 : return srclen;
371 : break;
372 :
373 94030 : case SYBSINT1:
374 94030 : if ((rc = string_to_int(src, src + srclen, &tds_i)) < 0)
375 : return rc;
376 58660 : if (!IS_SINT1(tds_i))
377 : return TDS_CONVERT_OVERFLOW;
378 10970 : cr->ti = tds_i;
379 10970 : return sizeof(TDS_TINYINT);
380 : break;
381 202870 : case SYBINT1:
382 : case SYBUINT1:
383 202870 : if ((rc = string_to_int(src, src + srclen, &tds_i)) < 0)
384 : return rc;
385 126060 : if (!IS_TINYINT(tds_i))
386 : return TDS_CONVERT_OVERFLOW;
387 25520 : cr->ti = tds_i;
388 25520 : return sizeof(TDS_TINYINT);
389 : break;
390 101540 : case SYBINT2:
391 101540 : if ((rc = string_to_int(src, src + srclen, &tds_i)) < 0)
392 : return rc;
393 63080 : if (!IS_SMALLINT(tds_i))
394 : return TDS_CONVERT_OVERFLOW;
395 33330 : cr->si = tds_i;
396 33330 : return sizeof(TDS_SMALLINT);
397 : break;
398 101410 : case SYBUINT2:
399 101410 : if ((rc = string_to_int(src, src + srclen, &tds_i)) < 0)
400 : return rc;
401 62960 : if (!IS_USMALLINT(tds_i))
402 : return TDS_CONVERT_OVERFLOW;
403 23870 : cr->usi = (TDS_USMALLINT) tds_i;
404 23870 : return sizeof(TDS_USMALLINT);
405 : break;
406 102090 : case SYBINT4:
407 102090 : if ((rc = string_to_int(src, src + srclen, &tds_i)) < 0)
408 : return rc;
409 63480 : cr->i = tds_i;
410 63480 : return sizeof(TDS_INT);
411 : break;
412 101450 : case SYBUINT4:
413 101450 : if ((rc = string_to_int8(src, src + srclen, &tds_i8)) < 0)
414 : return rc;
415 89580 : if (!IS_UINT(tds_i8))
416 : return TDS_CONVERT_OVERFLOW;
417 39090 : cr->ui = (TDS_UINT) tds_i8;
418 39090 : return sizeof(TDS_UINT);
419 : break;
420 101720 : case SYBINT8:
421 101720 : if ((rc = string_to_int8(src, src + srclen, &tds_i8)) < 0)
422 : return rc;
423 89690 : cr->bi = tds_i8;
424 89690 : return sizeof(TDS_INT8);
425 : break;
426 101580 : case SYBUINT8:
427 101580 : if ((rc = string_to_uint8(src, src + srclen, &tds_ui8)) < 0)
428 : return rc;
429 52460 : cr->ubi = tds_ui8;
430 52460 : return sizeof(TDS_UINT8);
431 : break;
432 189250 : case SYBFLT8:
433 : case SYBREAL:
434 189250 : return string_to_float(src, srclen, desttype, cr);
435 : break;
436 590 : case SYBBIT:
437 : case SYBBITN:
438 590 : if ((rc = string_to_int(src, src + srclen, &tds_i)) < 0)
439 : return rc;
440 590 : cr->ti = tds_i ? 1 : 0;
441 590 : return sizeof(TDS_TINYINT);
442 : break;
443 203750 : case SYBMONEY:
444 : case SYBMONEY4:
445 :
446 203750 : src = parse_numeric(src, src + srclen, &negative, &digits, &decimals);
447 203750 : if (!src)
448 : return TDS_CONVERT_SYNTAX;
449 203720 : if (digits > 18)
450 : return TDS_CONVERT_OVERFLOW;
451 :
452 171480 : i = 0;
453 171480 : if (negative)
454 78360 : mynumber[i++] = '-';
455 1099000 : for (; digits; --digits)
456 1099000 : mynumber[i++] = *src++;
457 171480 : src++;
458 174280 : for (digits = 0; digits < 4 && digits < decimals; ++digits)
459 2800 : mynumber[i++] = *src++;
460 683120 : for (; digits < 4; ++digits)
461 683120 : mynumber[i++] = '0';
462 :
463 : /* convert number and check for overflow */
464 171480 : if ((rc = string_to_int8(mynumber, mynumber + i, &mymoney)) < 0)
465 : return rc;
466 :
467 163200 : if (desttype == SYBMONEY) {
468 81590 : cr->m.mny = mymoney;
469 81590 : return sizeof(TDS_MONEY);
470 : } else {
471 81610 : if (!INT_IS_INT(mymoney))
472 : return TDS_CONVERT_OVERFLOW;
473 54020 : cr->m4.mny4 = (TDS_INT) mymoney;
474 54020 : return sizeof(TDS_MONEY4);
475 : }
476 : break;
477 2868 : case SYBDATETIME:
478 : case SYBDATETIME4:
479 : case SYBMSTIME:
480 : case SYBMSDATE:
481 : case SYBMSDATETIME2:
482 : case SYBMSDATETIMEOFFSET:
483 : case SYBTIME:
484 : case SYBDATE:
485 : case SYB5BIGTIME:
486 : case SYB5BIGDATETIME:
487 2868 : return string_to_datetime(src, srclen, desttype, cr);
488 : break;
489 107630 : case SYBNUMERIC:
490 : case SYBDECIMAL:
491 107630 : return string_to_numeric(src, src + srclen, cr);
492 : break;
493 282 : case SYBUNIQUE:{
494 282 : unsigned n = 0;
495 : char c;
496 :
497 : /*
498 : * format: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
499 : * or {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
500 : * or XXXXXXXX-XXXX-XXXX-XXXXXXXXXXXXXXXX
501 : * or {XXXXXXXX-XXXX-XXXX-XXXXXXXXXXXXXXXX}
502 : * SQL seem to ignore the additional braces.
503 : */
504 282 : if (srclen < (32 + 3))
505 : return TDS_CONVERT_SYNTAX;
506 :
507 192 : if (src[0] == '{') {
508 10 : TDS_UINT last = (src[8+1 + 4+1 + 4+1 + 4 + 1] == '-') ? 32+4+1 : 32+3+1;
509 10 : if (srclen <= last || src[last] != '}')
510 : return TDS_CONVERT_SYNTAX;
511 10 : ++src;
512 : }
513 :
514 : /*
515 : * Test each character and get value.
516 : * sscanf works if the number terminates with less digits.
517 : */
518 5380 : for (i = 0; i < 32 + 3; ++i) {
519 5430 : c = src[i];
520 5430 : switch (i) {
521 162 : case 8:
522 162 : if (c != '-')
523 : return TDS_CONVERT_SYNTAX;
524 162 : cr->u.Data1 = n;
525 162 : n = 0;
526 162 : break;
527 162 : case 8+1 + 4:
528 162 : if (c != '-')
529 : return TDS_CONVERT_SYNTAX;
530 162 : cr->u.Data2 = n;
531 162 : n = 0;
532 162 : break;
533 152 : case 8+1 + 4+1 + 4:
534 152 : if (c != '-')
535 : return TDS_CONVERT_SYNTAX;
536 152 : cr->u.Data3 = n;
537 152 : n = 0;
538 152 : break;
539 152 : case 8+1 + 4+1 + 4+1 + 4:
540 : /* skip last (optional) dash */
541 152 : if (c == '-') {
542 112 : if (--srclen < 32 + 3)
543 : return TDS_CONVERT_SYNTAX;
544 112 : c = (++src)[i];
545 : }
546 : /* fall through */
547 : default:
548 4954 : n = n << 4;
549 4954 : if (c >= '0' && c <= '9')
550 3396 : n += c - '0';
551 : else {
552 1558 : c &= 0x20 ^ 0xff;
553 1558 : if (c >= 'A' && c <= 'F')
554 1508 : n += c - ('A' - 10);
555 : else
556 : return TDS_CONVERT_SYNTAX;
557 : }
558 4904 : if (i > (16 + 2) && !(i & 1)) {
559 1156 : cr->u.Data4[(i >> 1) - 10] = n;
560 1156 : n = 0;
561 : }
562 : }
563 : }
564 : }
565 : return sizeof(TDS_UNIQUE);
566 : default:
567 : return TDS_CONVERT_NOAVAIL;
568 : break;
569 : } /* end switch */
570 : } /* tds_convert_char */
571 :
572 : static TDS_INT
573 : tds_convert_bit(const TDS_CHAR * src, int desttype, CONV_RESULT * cr)
574 : {
575 6606 : return tds_convert_int(src[0] ? 1 : 0, desttype, cr);
576 : }
577 :
578 : static TDS_INT
579 : tds_convert_int1(const int8_t * src, int desttype, CONV_RESULT * cr)
580 : {
581 8424 : return tds_convert_int(*src, desttype, cr);
582 : }
583 :
584 : static TDS_INT
585 : tds_convert_uint1(const TDS_TINYINT * src, int desttype, CONV_RESULT * cr)
586 : {
587 21788 : return tds_convert_int(*src, desttype, cr);
588 : }
589 :
590 : static TDS_INT
591 : tds_convert_int2(const TDS_SMALLINT * src, int desttype, CONV_RESULT * cr)
592 : {
593 27396 : return tds_convert_int(*src, desttype, cr);
594 : }
595 :
596 : static TDS_INT
597 : tds_convert_uint2(const TDS_USMALLINT * src, int desttype, CONV_RESULT * cr)
598 : {
599 16562 : return tds_convert_int(*src, desttype, cr);
600 : }
601 :
602 : static TDS_INT
603 : tds_convert_int4(const TDS_INT * src, int desttype, CONV_RESULT * cr)
604 : {
605 51134 : return tds_convert_int(*src, desttype, cr);
606 : }
607 :
608 : static TDS_INT
609 : tds_convert_uint4(const TDS_UINT * src, int desttype, CONV_RESULT * cr)
610 : {
611 : TDS_UINT8 num;
612 :
613 27366 : num = *src;
614 27366 : return tds_convert_uint8(&num, desttype, cr);
615 : }
616 :
617 : static TDS_INT
618 : tds_convert_int_numeric(unsigned char scale,
619 : unsigned char sign, TDS_UINT num, CONV_RESULT * cr)
620 : {
621 14700 : unsigned char orig_prec = cr->n.precision, orig_scale = cr->n.scale;
622 14700 : cr->n.precision = 10;
623 14700 : cr->n.scale = scale;
624 14700 : cr->n.array[0] = sign;
625 14700 : cr->n.array[1] = 0;
626 14700 : TDS_PUT_UA4BE(&(cr->n.array[2]), num);
627 14700 : return tds_numeric_change_prec_scale(&(cr->n), orig_prec, orig_scale);
628 : }
629 :
630 : static TDS_INT
631 : tds_convert_int8_numeric(unsigned char scale,
632 : unsigned char sign, TDS_UINT8 num, CONV_RESULT * cr)
633 : {
634 6320 : unsigned char orig_prec = cr->n.precision, orig_scale = cr->n.scale;
635 6320 : cr->n.precision = 20;
636 6320 : cr->n.scale = scale;
637 6320 : cr->n.array[0] = sign;
638 6320 : cr->n.array[1] = 0;
639 6320 : TDS_PUT_UA4BE(&(cr->n.array[2]), (TDS_UINT) (num >> 32));
640 6320 : TDS_PUT_UA4BE(&(cr->n.array[6]), (TDS_UINT) num);
641 6320 : return tds_numeric_change_prec_scale(&(cr->n), orig_prec, orig_scale);
642 : }
643 :
644 : static TDS_INT
645 218938 : tds_convert_int(TDS_INT num, int desttype, CONV_RESULT * cr)
646 : {
647 : TDS_CHAR tmp_str[16];
648 :
649 218938 : switch (desttype) {
650 12548 : case TDS_CONVERT_CHAR:
651 : case CASE_ALL_CHAR:
652 12548 : sprintf(tmp_str, "%d", num);
653 12548 : return string_to_result(desttype, tmp_str, cr);
654 : break;
655 11354 : case SYBSINT1:
656 11354 : if (!IS_SINT1(num))
657 : return TDS_CONVERT_OVERFLOW;
658 2914 : cr->ti = (TDS_TINYINT) num;
659 2914 : return sizeof(TDS_TINYINT);
660 : break;
661 23888 : case SYBINT1:
662 : case SYBUINT1:
663 23888 : if (!IS_TINYINT(num))
664 : return TDS_CONVERT_OVERFLOW;
665 9158 : cr->ti = (TDS_TINYINT) num;
666 9158 : return sizeof(TDS_TINYINT);
667 : break;
668 14336 : case SYBINT2:
669 14336 : if (!IS_SMALLINT(num))
670 : return TDS_CONVERT_OVERFLOW;
671 10316 : cr->si = num;
672 10316 : return sizeof(TDS_SMALLINT);
673 : break;
674 11840 : case SYBUINT2:
675 11840 : if (!IS_USMALLINT(num))
676 : return TDS_CONVERT_OVERFLOW;
677 6800 : cr->usi = (TDS_USMALLINT) num;
678 6800 : return sizeof(TDS_USMALLINT);
679 : break;
680 20728 : case SYBINT4:
681 20728 : cr->i = num;
682 20728 : return sizeof(TDS_INT);
683 : break;
684 13068 : case SYBUINT4:
685 13068 : if (num < 0)
686 : return TDS_CONVERT_OVERFLOW;
687 9708 : cr->ui = (TDS_UINT) num;
688 9708 : return sizeof(TDS_UINT);
689 : break;
690 12170 : case SYBINT8:
691 12170 : cr->bi = num;
692 12170 : return sizeof(TDS_INT8);
693 : break;
694 12000 : case SYBUINT8:
695 12000 : if (num < 0)
696 : return TDS_CONVERT_OVERFLOW;
697 8640 : cr->ubi = (TDS_UINT8) num;
698 8640 : return sizeof(TDS_UINT8);
699 : break;
700 1186 : case SYBBIT:
701 : case SYBBITN:
702 1186 : cr->ti = num ? 1 : 0;
703 1186 : return sizeof(TDS_TINYINT);
704 : break;
705 11330 : case SYBFLT8:
706 11330 : cr->f = num;
707 11330 : return sizeof(TDS_FLOAT);
708 : break;
709 11330 : case SYBREAL:
710 11330 : cr->r = (TDS_REAL) num;
711 11330 : return sizeof(TDS_REAL);
712 : break;
713 11800 : case SYBMONEY4:
714 11800 : if (num > 214748 || num < -214748)
715 : return TDS_CONVERT_OVERFLOW;
716 10570 : cr->m4.mny4 = num * 10000;
717 10570 : return sizeof(TDS_MONEY4);
718 : break;
719 11920 : case SYBMONEY:
720 11920 : cr->m.mny = (TDS_INT8) num *10000;
721 :
722 11920 : return sizeof(TDS_MONEY);
723 : break;
724 12370 : case SYBNUMERIC:
725 : case SYBDECIMAL:
726 12370 : if (num < 0)
727 7060 : return tds_convert_int_numeric(0, 1, (TDS_UINT) -num, cr);
728 17680 : return tds_convert_int_numeric(0, 0, (TDS_UINT) num, cr);
729 : break;
730 : /* handled by upper layer */
731 : case CASE_ALL_BINARY:
732 : /* conversions not allowed */
733 : case SYBUNIQUE:
734 : case SYBDATETIME4:
735 : case SYBDATETIME:
736 : case SYBDATETIMN:
737 : default:
738 : break;
739 : }
740 : return TDS_CONVERT_NOAVAIL;
741 : }
742 :
743 : static TDS_INT
744 61284 : tds_convert_int8(const TDS_INT8 *src, int desttype, CONV_RESULT * cr)
745 : {
746 : TDS_INT8 buf;
747 : TDS_CHAR tmp_str[24];
748 :
749 61284 : memcpy(&buf, src, sizeof(buf));
750 61284 : if (INT_IS_INT(buf))
751 40594 : return tds_convert_int((TDS_INT) buf, desttype, cr);
752 :
753 20690 : switch (desttype) {
754 622 : case TDS_CONVERT_CHAR:
755 : case CASE_ALL_CHAR:
756 622 : sprintf(tmp_str, "%" PRId64, buf);
757 622 : return string_to_result(desttype, tmp_str, cr);
758 : break;
759 : case SYBINT1:
760 : case SYBSINT1:
761 : case SYBUINT1:
762 : case SYBINT2:
763 : case SYBUINT2:
764 : case SYBINT4:
765 : case SYBMONEY4:
766 : return TDS_CONVERT_OVERFLOW;
767 : break;
768 1370 : case SYBUINT4:
769 1370 : if (!IS_UINT(buf))
770 : return TDS_CONVERT_OVERFLOW;
771 230 : cr->ui = (TDS_UINT) buf;
772 230 : return sizeof(TDS_UINT);
773 : break;
774 1558 : case SYBINT8:
775 1558 : cr->bi = buf;
776 1558 : return sizeof(TDS_INT8);
777 : break;
778 1410 : case SYBUINT8:
779 1410 : if (buf < 0)
780 : return TDS_CONVERT_OVERFLOW;
781 780 : cr->ubi = (TDS_UINT8) buf;
782 780 : return sizeof(TDS_UINT8);
783 : break;
784 90 : case SYBBIT:
785 : case SYBBITN:
786 : /* this cannot be 0 as already tested above */
787 90 : cr->ti = 1;
788 90 : return sizeof(TDS_TINYINT);
789 : break;
790 1350 : case SYBFLT8:
791 1350 : cr->f = (TDS_FLOAT) buf;
792 1350 : return sizeof(TDS_FLOAT);
793 : break;
794 1350 : case SYBREAL:
795 1350 : cr->r = (TDS_REAL) buf;
796 1350 : return sizeof(TDS_REAL);
797 : break;
798 1320 : case SYBMONEY:
799 1320 : if (buf > (TDS_INT8_MAX / 10000) || buf < (TDS_INT8_MIN / 10000))
800 : return TDS_CONVERT_OVERFLOW;
801 910 : cr->m.mny = buf * 10000;
802 910 : return sizeof(TDS_MONEY);
803 : break;
804 1450 : case SYBNUMERIC:
805 : case SYBDECIMAL:
806 1450 : if (buf < 0)
807 1340 : return tds_convert_int8_numeric(0, 1, -buf, cr);
808 1560 : return tds_convert_int8_numeric(0, 0, buf, cr);
809 : break;
810 : /* conversions not allowed */
811 : case SYBUNIQUE:
812 : case SYBDATETIME4:
813 : case SYBDATETIME:
814 : case SYBDATETIMN:
815 : default:
816 : break;
817 : }
818 630 : return TDS_CONVERT_NOAVAIL;
819 : }
820 :
821 : static TDS_INT
822 62648 : tds_convert_uint8(const TDS_UINT8 *src, int desttype, CONV_RESULT * cr)
823 : {
824 : TDS_UINT8 buf;
825 : TDS_CHAR tmp_str[24];
826 :
827 62648 : memcpy(&buf, src, sizeof(buf));
828 : /* INT_IS_INT does not work here due to unsigned/signed conversions */
829 62648 : if (buf <= TDS_INT_MAX)
830 46434 : return tds_convert_int((TDS_INT) buf, desttype, cr);
831 :
832 16214 : switch (desttype) {
833 474 : case TDS_CONVERT_CHAR:
834 : case CASE_ALL_CHAR:
835 474 : sprintf(tmp_str, "%" PRIu64, buf);
836 474 : return string_to_result(desttype, tmp_str, cr);
837 : break;
838 : case SYBINT1:
839 : case SYBSINT1:
840 : case SYBUINT1:
841 : case SYBINT2:
842 : case SYBUINT2:
843 : case SYBINT4:
844 : case SYBMONEY4:
845 : return TDS_CONVERT_OVERFLOW;
846 : break;
847 1120 : case SYBUINT4:
848 1120 : if (!IS_UINT(buf))
849 : return TDS_CONVERT_OVERFLOW;
850 460 : cr->ui = (TDS_UINT) buf;
851 : return sizeof(TDS_UINT);
852 : break;
853 1160 : case SYBINT8:
854 1160 : if (buf > TDS_INT8_MAX)
855 : return TDS_CONVERT_OVERFLOW;
856 950 : cr->bi = (TDS_INT8) buf;
857 : return sizeof(TDS_INT8);
858 : break;
859 1180 : case SYBUINT8:
860 1180 : cr->ubi = buf;
861 : return sizeof(TDS_UINT8);
862 : break;
863 30 : case SYBBIT:
864 : case SYBBITN:
865 : /* this cannot be 0 as already tested above */
866 30 : cr->ti = 1;
867 : return sizeof(TDS_TINYINT);
868 : break;
869 1080 : case SYBFLT8:
870 1080 : cr->f = (TDS_FLOAT) buf;
871 : return sizeof(TDS_FLOAT);
872 : break;
873 1080 : case SYBREAL:
874 1080 : cr->r = (TDS_REAL) buf;
875 : return sizeof(TDS_REAL);
876 : break;
877 1110 : case SYBMONEY:
878 1110 : if (buf > (TDS_INT8_MAX / 10000))
879 : return TDS_CONVERT_OVERFLOW;
880 700 : cr->m.mny = buf * 10000;
881 : return sizeof(TDS_MONEY);
882 : break;
883 1180 : case SYBNUMERIC:
884 : case SYBDECIMAL:
885 2360 : return tds_convert_int8_numeric(0, 0, buf, cr);
886 : break;
887 : /* conversions not allowed */
888 : case SYBUNIQUE:
889 : case SYBDATETIME4:
890 : case SYBDATETIME:
891 : case SYBDATETIMN:
892 : default:
893 : break;
894 : }
895 : return TDS_CONVERT_NOAVAIL;
896 : }
897 :
898 : static TDS_INT
899 75164 : tds_convert_numeric(const TDS_NUMERIC * src, int desttype, CONV_RESULT * cr)
900 : {
901 : char tmpstr[MAXPRECISION];
902 : TDS_INT i, ret;
903 : TDS_INT8 bi;
904 :
905 75164 : switch (desttype) {
906 2292 : case TDS_CONVERT_CHAR:
907 : case CASE_ALL_CHAR:
908 2292 : if (tds_numeric_to_string(src, tmpstr) < 0)
909 : return TDS_CONVERT_FAIL;
910 2292 : return string_to_result(desttype, tmpstr, cr);
911 : break;
912 4680 : case SYBSINT1:
913 4680 : cr->n = *src;
914 4680 : ret = tds_numeric_change_prec_scale(&(cr->n), 3, 0);
915 4680 : if (ret < 0)
916 : return ret;
917 1280 : if (cr->n.array[1])
918 : return TDS_CONVERT_OVERFLOW;
919 1060 : i = cr->n.array[2];
920 1060 : if (cr->n.array[0])
921 520 : i = -i;
922 1060 : if (i != 0 && ((i >> 7) ^ cr->n.array[0]) & 1)
923 : return TDS_CONVERT_OVERFLOW;
924 650 : cr->ti = (TDS_TINYINT) i;
925 650 : return sizeof(TDS_TINYINT);
926 : break;
927 9440 : case SYBINT1:
928 : case SYBUINT1:
929 9440 : cr->n = *src;
930 9440 : ret = tds_numeric_change_prec_scale(&(cr->n), 3, 0);
931 9440 : if (ret < 0)
932 : return ret;
933 2640 : if (cr->n.array[1] || (cr->n.array[0] && cr->n.array[2]))
934 : return TDS_CONVERT_OVERFLOW;
935 1180 : cr->ti = cr->n.array[2];
936 1180 : return sizeof(TDS_TINYINT);
937 : break;
938 4810 : case SYBINT2:
939 4810 : cr->n = *src;
940 4810 : ret = tds_numeric_change_prec_scale(&(cr->n), 5, 0);
941 4810 : if (ret < 0)
942 : return ret;
943 2210 : if (cr->n.array[1])
944 : return TDS_CONVERT_OVERFLOW;
945 1990 : i = TDS_GET_UA2BE(&(cr->n.array[2]));
946 1990 : if (cr->n.array[0])
947 970 : i = -i;
948 1990 : if (i != 0 && ((i >> 15) ^ cr->n.array[0]) & 1)
949 : return TDS_CONVERT_OVERFLOW;
950 1580 : cr->si = (TDS_SMALLINT) i;
951 1580 : return sizeof(TDS_SMALLINT);
952 : break;
953 4760 : case SYBUINT2:
954 4760 : cr->n = *src;
955 4760 : ret = tds_numeric_change_prec_scale(&(cr->n), 5, 0);
956 4760 : if (ret < 0)
957 : return ret;
958 2200 : i = TDS_GET_UA2BE(&(cr->n.array[2]));
959 2200 : if ((i != 0 && cr->n.array[0]) || cr->n.array[1])
960 : return TDS_CONVERT_OVERFLOW;
961 1050 : cr->usi = (TDS_USMALLINT) i;
962 1050 : return sizeof(TDS_USMALLINT);
963 : break;
964 4910 : case SYBINT4:
965 4910 : cr->n = *src;
966 4910 : ret = tds_numeric_change_prec_scale(&(cr->n), 10, 0);
967 4910 : if (ret < 0)
968 : return ret;
969 3650 : if (cr->n.array[1])
970 : return TDS_CONVERT_OVERFLOW;
971 3430 : i = TDS_GET_UA4BE(&(cr->n.array[2]));
972 3430 : if (cr->n.array[0])
973 1640 : i = -i;
974 3430 : if (i != 0 && ((i >> 31) ^ cr->n.array[0]) & 1)
975 : return TDS_CONVERT_OVERFLOW;
976 3020 : cr->i = i;
977 3020 : return sizeof(TDS_INT);
978 : break;
979 4820 : case SYBUINT4:
980 4820 : cr->n = *src;
981 4820 : ret = tds_numeric_change_prec_scale(&(cr->n), 10, 0);
982 4820 : if (ret < 0)
983 : return ret;
984 3560 : i = TDS_GET_UA4BE(&(cr->n.array[2]));
985 3560 : if ((i != 0 && cr->n.array[0]) || cr->n.array[1])
986 : return TDS_CONVERT_OVERFLOW;
987 1780 : cr->ui = i;
988 1780 : return sizeof(TDS_UINT);
989 : break;
990 4970 : case SYBINT8:
991 4970 : cr->n = *src;
992 4970 : ret = tds_numeric_change_prec_scale(&(cr->n), 20, 0);
993 4970 : if (ret < 0)
994 : return ret;
995 4970 : if (cr->n.array[1])
996 : return TDS_CONVERT_OVERFLOW;
997 4750 : bi = TDS_GET_UA4BE(&(cr->n.array[2]));
998 4750 : bi = (bi << 32) + TDS_GET_UA4BE(&(cr->n.array[6]));
999 4750 : if (cr->n.array[0])
1000 2310 : bi = -bi;
1001 4750 : if (bi != 0 && ((bi >> 63) ^ cr->n.array[0]) & 1)
1002 : return TDS_CONVERT_OVERFLOW;
1003 4340 : cr->bi = bi;
1004 4340 : return sizeof(TDS_INT8);
1005 : break;
1006 4880 : case SYBUINT8:
1007 4880 : cr->n = *src;
1008 4880 : ret = tds_numeric_change_prec_scale(&(cr->n), 20, 0);
1009 4880 : if (ret < 0)
1010 : return ret;
1011 4880 : bi = TDS_GET_UA4BE(&(cr->n.array[2]));
1012 4880 : bi = (bi << 32) + TDS_GET_UA4BE(&(cr->n.array[6]));
1013 4880 : if ((bi != 0 && cr->n.array[0]) || cr->n.array[1])
1014 : return TDS_CONVERT_OVERFLOW;
1015 2470 : cr->ubi = bi;
1016 2470 : return sizeof(TDS_UINT8);
1017 : break;
1018 80 : case SYBBIT:
1019 : case SYBBITN:
1020 80 : cr->ti = 0;
1021 160 : for (i = tds_numeric_bytes_per_prec[src->precision]; --i > 0;)
1022 80 : if (src->array[i] != 0) {
1023 80 : cr->ti = 1;
1024 80 : break;
1025 : }
1026 : return sizeof(TDS_TINYINT);
1027 : break;
1028 4790 : case SYBMONEY4:
1029 4790 : cr->n = *src;
1030 4790 : ret = tds_numeric_change_prec_scale(&(cr->n), 10, 4);
1031 4790 : if (ret < 0)
1032 : return ret;
1033 2690 : if (cr->n.array[1])
1034 : return TDS_CONVERT_OVERFLOW;
1035 2690 : i = TDS_GET_UA4BE(&(cr->n.array[2]));
1036 2690 : if (cr->n.array[0])
1037 1310 : i = -i;
1038 2690 : if (i != 0 && ((i >> 31) ^ cr->n.array[0]) & 1)
1039 : return TDS_CONVERT_OVERFLOW;
1040 2490 : cr->m4.mny4 = i;
1041 2490 : return sizeof(TDS_MONEY4);
1042 : break;
1043 4890 : case SYBMONEY:
1044 4890 : cr->n = *src;
1045 4890 : ret = tds_numeric_change_prec_scale(&(cr->n), 20, 4);
1046 4890 : if (ret < 0)
1047 : return ret;
1048 4050 : if (cr->n.array[1])
1049 : return TDS_CONVERT_OVERFLOW;
1050 4050 : bi = TDS_GET_UA4BE(&(cr->n.array[2]));
1051 4050 : bi = (bi << 32) + TDS_GET_UA4BE(&(cr->n.array[6]));
1052 4050 : if (cr->n.array[0])
1053 1980 : bi = -bi;
1054 4050 : if (bi != 0 && ((bi >> 63) ^ cr->n.array[0]) & 1)
1055 : return TDS_CONVERT_OVERFLOW;
1056 3850 : cr->m.mny = bi;
1057 3850 : return sizeof(TDS_MONEY);
1058 : break;
1059 5642 : case SYBNUMERIC:
1060 : case SYBDECIMAL:
1061 : {
1062 5642 : unsigned char prec = cr->n.precision, scale = cr->n.scale;
1063 5642 : cr->n = *src;
1064 5642 : return tds_numeric_change_prec_scale(&(cr->n), prec, scale);
1065 : }
1066 : break;
1067 4680 : case SYBFLT8:
1068 4680 : if (tds_numeric_to_string(src, tmpstr) < 0)
1069 : return TDS_CONVERT_FAIL;
1070 4680 : cr->f = atof(tmpstr);
1071 4680 : return 8;
1072 : break;
1073 4680 : case SYBREAL:
1074 4680 : if (tds_numeric_to_string(src, tmpstr) < 0)
1075 : return TDS_CONVERT_FAIL;
1076 4680 : cr->r = (TDS_REAL) atof(tmpstr);
1077 4680 : return 4;
1078 : break;
1079 : /* conversions not allowed */
1080 : case SYBUNIQUE:
1081 : case SYBDATETIME4:
1082 : case SYBDATETIME:
1083 : case SYBDATETIMN:
1084 : default:
1085 : break;
1086 : }
1087 : return TDS_CONVERT_NOAVAIL;
1088 : }
1089 :
1090 : static TDS_INT
1091 35770 : tds_convert_money4(const TDSCONTEXT * tds_ctx, const TDS_MONEY4 * src, int desttype, CONV_RESULT * cr)
1092 : {
1093 : TDS_MONEY4 mny;
1094 : long dollars;
1095 :
1096 35770 : mny = *src;
1097 35770 : switch (desttype) {
1098 1490 : case TDS_CONVERT_CHAR:
1099 : case CASE_ALL_CHAR: {
1100 : char tmp_str[33];
1101 : char *p;
1102 : unsigned dollars;
1103 : /*
1104 : * round to 2 decimal digits
1105 : * rounding with dollars = (mny.mny4 + 5000) /10000
1106 : * can give arithmetic overflow so I use
1107 : * dollars = (mny.mny4/50 + 1)/2
1108 : */
1109 : /* TODO round also all conversions to int and from money ?? */
1110 1490 : p = tmp_str;
1111 1490 : if (mny.mny4 < 0) {
1112 310 : *p++ = '-';
1113 : /* we use unsigned cause this cause arithmetic problem for -2^31*/
1114 310 : dollars = -mny.mny4;
1115 : } else {
1116 1180 : dollars = mny.mny4;
1117 : }
1118 1490 : if (tds_ctx->money_use_2_digits) {
1119 : /* print only 2 decimal digits as server does */
1120 0 : dollars = (dollars + 50) / 100;
1121 0 : sprintf(p, "%u.%02u", dollars / 100u, dollars % 100u);
1122 : } else {
1123 1490 : sprintf(p, "%u.%04u", dollars / 10000u, dollars % 10000u);
1124 : }
1125 1490 : return string_to_result(desttype, tmp_str, cr);
1126 : } break;
1127 2170 : case SYBSINT1:
1128 2170 : dollars = mny.mny4 / 10000;
1129 2170 : if (!IS_SINT1(dollars))
1130 : return TDS_CONVERT_OVERFLOW;
1131 430 : cr->ti = (TDS_TINYINT) dollars;
1132 : return sizeof(TDS_TINYINT);
1133 : break;
1134 4420 : case SYBINT1:
1135 : case SYBUINT1:
1136 4420 : dollars = mny.mny4 / 10000;
1137 4420 : if (!IS_TINYINT(dollars))
1138 : return TDS_CONVERT_OVERFLOW;
1139 940 : cr->ti = (TDS_TINYINT) dollars;
1140 : return sizeof(TDS_TINYINT);
1141 : break;
1142 2310 : case SYBINT2:
1143 2310 : dollars = mny.mny4 / 10000;
1144 2310 : if (!IS_SMALLINT(dollars))
1145 : return TDS_CONVERT_OVERFLOW;
1146 1460 : cr->si = (TDS_SMALLINT) dollars;
1147 : return sizeof(TDS_SMALLINT);
1148 : break;
1149 2250 : case SYBUINT2:
1150 2250 : dollars = mny.mny4 / 10000;
1151 2250 : if (!IS_USMALLINT(dollars))
1152 : return TDS_CONVERT_OVERFLOW;
1153 980 : cr->usi = (TDS_USMALLINT) dollars;
1154 : return sizeof(TDS_USMALLINT);
1155 : break;
1156 2370 : case SYBINT4:
1157 2370 : cr->i = mny.mny4 / 10000;
1158 : return sizeof(TDS_INT);
1159 : break;
1160 2270 : case SYBUINT4:
1161 2270 : dollars = mny.mny4 / 10000;
1162 2270 : if (!IS_UINT(dollars))
1163 : return TDS_CONVERT_OVERFLOW;
1164 1220 : cr->ui = dollars;
1165 : return sizeof(TDS_UINT);
1166 : break;
1167 2320 : case SYBINT8:
1168 2320 : cr->bi = mny.mny4 / 10000;
1169 : return sizeof(TDS_INT8);
1170 : break;
1171 2270 : case SYBUINT8:
1172 2270 : dollars = mny.mny4 / 10000;
1173 2270 : if (dollars < 0)
1174 : return TDS_CONVERT_OVERFLOW;
1175 1220 : cr->ubi = dollars;
1176 : return sizeof(TDS_UINT8);
1177 : break;
1178 70 : case SYBBIT:
1179 : case SYBBITN:
1180 70 : cr->ti = mny.mny4 ? 1 : 0;
1181 : return sizeof(TDS_TINYINT);
1182 : break;
1183 2170 : case SYBFLT8:
1184 2170 : cr->f = ((TDS_FLOAT) mny.mny4) / 10000.0;
1185 : return sizeof(TDS_FLOAT);
1186 : break;
1187 2170 : case SYBREAL:
1188 2170 : cr->r = (TDS_REAL) (mny.mny4 / 10000.0);
1189 : return sizeof(TDS_REAL);
1190 : break;
1191 2270 : case SYBMONEY:
1192 2270 : cr->m.mny = (TDS_INT8) mny.mny4;
1193 : return sizeof(TDS_MONEY);
1194 : break;
1195 2260 : case SYBMONEY4:
1196 2260 : cr->m4 = mny;
1197 : return sizeof(TDS_MONEY4);
1198 : break;
1199 2330 : case SYBDECIMAL:
1200 : case SYBNUMERIC:
1201 2330 : if (mny.mny4 < 0)
1202 2200 : return tds_convert_int_numeric(4, 1, (TDS_UINT) -mny.mny4, cr);
1203 2460 : return tds_convert_int_numeric(4, 0, (TDS_UINT) mny.mny4, cr);
1204 : /* conversions not allowed */
1205 : case SYBUNIQUE:
1206 : case SYBDATETIME4:
1207 : case SYBDATETIME:
1208 : case SYBDATETIMN:
1209 : default:
1210 : return TDS_CONVERT_NOAVAIL;
1211 : break;
1212 : }
1213 : return TDS_CONVERT_FAIL;
1214 : }
1215 :
1216 : static TDS_INT
1217 54418 : tds_convert_money(const TDSCONTEXT * tds_ctx, const TDS_MONEY * src, int desttype, CONV_RESULT * cr)
1218 : {
1219 : char *s;
1220 :
1221 : TDS_INT8 mymoney, dollars;
1222 : char tmpstr[64];
1223 :
1224 54418 : tdsdump_log(TDS_DBG_FUNC, "tds_convert_money()\n");
1225 54418 : mymoney = ((TDS_INT8) src->tdsoldmoney.mnyhigh << 32) | src->tdsoldmoney.mnylow;
1226 :
1227 54418 : switch (desttype) {
1228 2004 : case TDS_CONVERT_CHAR:
1229 : case CASE_ALL_CHAR:
1230 2004 : s = tds_money_to_string((const TDS_MONEY *) src, tmpstr, tds_ctx->money_use_2_digits);
1231 2004 : return string_to_result(desttype, s, cr);
1232 : break;
1233 3430 : case SYBSINT1:
1234 3430 : if (mymoney <= -129 * 10000 || mymoney >= 128 * 10000)
1235 : return TDS_CONVERT_OVERFLOW;
1236 430 : cr->ti = (int8_t) (((TDS_INT) mymoney) / 10000);
1237 : return sizeof(TDS_TINYINT);
1238 : break;
1239 6940 : case SYBINT1:
1240 : case SYBUINT1:
1241 6940 : if (mymoney <= -10000 || mymoney >= 256 * 10000)
1242 : return TDS_CONVERT_OVERFLOW;
1243 : /* TODO: round ?? */
1244 940 : cr->ti = (TDS_TINYINT) (((TDS_INT) mymoney) / 10000);
1245 : return sizeof(TDS_TINYINT);
1246 : break;
1247 3570 : case SYBINT2:
1248 3570 : if (mymoney <= -32769 * 10000 || mymoney >= 32768 * 10000)
1249 : return TDS_CONVERT_OVERFLOW;
1250 1460 : cr->si = (TDS_SMALLINT) (((TDS_INT) mymoney) / 10000);
1251 : return sizeof(TDS_SMALLINT);
1252 : break;
1253 3510 : case SYBUINT2:
1254 3510 : if (mymoney <= -1 * 10000 || mymoney >= 65536 * 10000)
1255 : return TDS_CONVERT_OVERFLOW;
1256 980 : cr->usi = (TDS_USMALLINT) (((TDS_INT) mymoney) / 10000);
1257 : return sizeof(TDS_USMALLINT);
1258 : break;
1259 3670 : case SYBINT4:
1260 3670 : dollars = mymoney / 10000;
1261 3670 : if (!INT_IS_INT(dollars))
1262 : return TDS_CONVERT_OVERFLOW;
1263 2820 : cr->i = (TDS_INT) dollars;
1264 : return sizeof(TDS_INT);
1265 : break;
1266 3570 : case SYBUINT4:
1267 3570 : dollars = mymoney / 10000;
1268 3570 : if (!IS_UINT(dollars))
1269 : return TDS_CONVERT_OVERFLOW;
1270 1670 : cr->ui = (TDS_UINT) dollars;
1271 : return sizeof(TDS_UINT);
1272 : break;
1273 3680 : case SYBINT8:
1274 3680 : cr->bi = mymoney / 10000;
1275 : return sizeof(TDS_INT8);
1276 : break;
1277 3590 : case SYBUINT8:
1278 3590 : dollars = mymoney / 10000;
1279 3590 : if (dollars < 0)
1280 : return TDS_CONVERT_OVERFLOW;
1281 1910 : cr->ubi = (TDS_UINT8) dollars;
1282 : return sizeof(TDS_UINT8);
1283 : break;
1284 70 : case SYBBIT:
1285 : case SYBBITN:
1286 70 : cr->ti = mymoney ? 1 : 0;
1287 : return sizeof(TDS_TINYINT);
1288 : break;
1289 3484 : case SYBFLT8:
1290 3484 : cr->f = ((TDS_FLOAT) mymoney) / 10000.0;
1291 : return sizeof(TDS_FLOAT);
1292 : break;
1293 3430 : case SYBREAL:
1294 3430 : cr->r = (TDS_REAL) (mymoney / 10000.0);
1295 : return sizeof(TDS_REAL);
1296 : break;
1297 3530 : case SYBMONEY4:
1298 3530 : if (!INT_IS_INT(mymoney))
1299 : return TDS_CONVERT_OVERFLOW;
1300 2270 : cr->m4.mny4 = (TDS_INT) mymoney;
1301 : return sizeof(TDS_MONEY4);
1302 : break;
1303 3620 : case SYBMONEY:
1304 3620 : cr->m.mny = mymoney;
1305 : return sizeof(TDS_MONEY);
1306 : break;
1307 3690 : case SYBDECIMAL:
1308 : case SYBNUMERIC:
1309 3690 : if (mymoney < 0)
1310 3540 : return tds_convert_int8_numeric(4, 1, -mymoney, cr);
1311 3840 : return tds_convert_int8_numeric(4, 0, mymoney, cr);
1312 : break;
1313 : /* conversions not allowed */
1314 : case SYBUNIQUE:
1315 : case SYBDATETIME4:
1316 : case SYBDATETIME:
1317 : case SYBDATETIMN:
1318 : default:
1319 : break;
1320 : }
1321 : return TDS_CONVERT_NOAVAIL;
1322 : }
1323 :
1324 : static TDS_INT
1325 24326 : tds_convert_datetimeall(const TDSCONTEXT * tds_ctx, int srctype, const TDS_DATETIMEALL * dta, int desttype, CONV_RESULT * cr)
1326 : {
1327 : char whole_date_string[64];
1328 : const char *datetime_fmt;
1329 : TDSDATEREC when;
1330 :
1331 24326 : switch (desttype) {
1332 604 : case TDS_CONVERT_CHAR:
1333 : case CASE_ALL_CHAR:
1334 604 : tds_datecrack(srctype, dta, &when);
1335 604 : datetime_fmt = tds_ctx->locale->datetime_fmt;
1336 604 : if (srctype == SYBMSDATE && tds_ctx->locale->date_fmt)
1337 110 : datetime_fmt = tds_ctx->locale->date_fmt;
1338 604 : if (srctype == SYBMSTIME && tds_ctx->locale->time_fmt)
1339 220 : datetime_fmt = tds_ctx->locale->time_fmt;
1340 604 : tds_strftime(whole_date_string, sizeof(whole_date_string), datetime_fmt, &when,
1341 604 : dta->time_prec);
1342 :
1343 604 : return string_to_result(desttype, whole_date_string, cr);
1344 350 : case SYBDATETIME:
1345 350 : cr->dt.dtdays = dta->date;
1346 350 : cr->dt.dttime = (TDS_INT) ((dta->time * 3u + 50000u) / 100000u);
1347 : return sizeof(TDS_DATETIME);
1348 80 : case SYBDATETIME4:
1349 80 : if (!IS_USMALLINT(dta->date))
1350 : return TDS_CONVERT_OVERFLOW;
1351 80 : cr->dt4.days = (TDS_USMALLINT) dta->date;
1352 80 : cr->dt4.minutes = (TDS_USMALLINT) ((dta->time + 30u * 10000000u) / (60u * 10000000u));
1353 : return sizeof(TDS_DATETIME4);
1354 1552 : case SYBMSDATETIMEOFFSET:
1355 : case SYBMSDATE:
1356 : case SYBMSTIME:
1357 : case SYBMSDATETIME2:
1358 1552 : cr->dta = *dta;
1359 : return sizeof(TDS_DATETIMEALL);
1360 100 : case SYBDATE:
1361 100 : cr->date = dta->date;
1362 : return sizeof(TDS_DATE);
1363 80 : case SYBTIME:
1364 80 : cr->time = (TDS_INT) ((dta->time * 3u + 50000u) / 100000u);
1365 : return sizeof(TDS_TIME);
1366 90 : case SYB5BIGTIME:
1367 90 : cr->bigtime = dta->time / 10u;
1368 : return sizeof(TDS_UINT8);
1369 110 : case SYB5BIGDATETIME:
1370 220 : cr->bigtime = dta->time / 10u
1371 110 : + (dta->date + BIGDATETIME_BIAS) * (UINT64_C(86400) * 1000000u);
1372 : return sizeof(TDS_UINT8);
1373 : /* conversions not allowed */
1374 : case SYBUNIQUE:
1375 : case SYBBIT:
1376 : case SYBBITN:
1377 : case SYBINT1:
1378 : case SYBSINT1:
1379 : case SYBUINT1:
1380 : case SYBINT2:
1381 : case SYBUINT2:
1382 : case SYBINT4:
1383 : case SYBUINT4:
1384 : case SYBINT8:
1385 : case SYBUINT8:
1386 : case SYBMONEY4:
1387 : case SYBMONEY:
1388 : case SYBNUMERIC:
1389 : case SYBDECIMAL:
1390 : default:
1391 : break;
1392 : }
1393 : return TDS_CONVERT_NOAVAIL;
1394 : }
1395 :
1396 : static TDS_INT
1397 8134 : tds_convert_datetime(const TDSCONTEXT * tds_ctx, const TDS_DATETIME * dt, int desttype, unsigned precision, CONV_RESULT * cr)
1398 : {
1399 : char whole_date_string[64];
1400 : TDSDATEREC when;
1401 :
1402 8134 : switch (desttype) {
1403 508 : case TDS_CONVERT_CHAR:
1404 : case CASE_ALL_CHAR:
1405 508 : tds_datecrack(SYBDATETIME, dt, &when);
1406 508 : tds_strftime(whole_date_string, sizeof(whole_date_string), tds_ctx->locale->datetime_fmt, &when, 3);
1407 :
1408 508 : return string_to_result(desttype, whole_date_string, cr);
1409 10 : case SYBDATETIME:
1410 10 : cr->dt = *dt;
1411 : return sizeof(TDS_DATETIME);
1412 10 : case SYBDATETIME4:
1413 10 : if (!IS_USMALLINT(dt->dtdays))
1414 : return TDS_CONVERT_OVERFLOW;
1415 10 : cr->dt4.days = dt->dtdays;
1416 10 : cr->dt4.minutes = (dt->dttime / 300) / 60;
1417 : return sizeof(TDS_DATETIME4);
1418 30 : case SYBDATE:
1419 30 : cr->date = dt->dtdays;
1420 : return sizeof(TDS_DATE);
1421 30 : case SYBTIME:
1422 30 : cr->time = dt->dttime;
1423 : return sizeof(TDS_TIME);
1424 1206 : case SYBMSDATETIMEOFFSET:
1425 : case SYBMSDATE:
1426 : case SYBMSTIME:
1427 : case SYBMSDATETIME2:
1428 1206 : memset(&cr->dta, 0, sizeof(cr->dta));
1429 1206 : cr->dta.time_prec = precision;
1430 1206 : if (desttype == SYBMSDATETIMEOFFSET)
1431 20 : cr->dta.has_offset = 1;
1432 1206 : if (desttype != SYBMSDATE) {
1433 1186 : cr->dta.has_time = 1;
1434 1186 : cr->dta.time_prec = 3;
1435 1186 : cr->dta.time = (dt->dttime * UINT64_C(20) + 3) / 6 * 10000u;
1436 : }
1437 1206 : if (desttype != SYBMSTIME) {
1438 1186 : cr->dta.has_date = 1;
1439 1186 : cr->dta.date = dt->dtdays;
1440 : }
1441 : return sizeof(TDS_DATETIMEALL);
1442 20 : case SYB5BIGTIME:
1443 20 : cr->bigtime = (dt->dttime * UINT64_C(20) + 3u) / 6u * 1000u;
1444 : return sizeof(TDS_BIGTIME);
1445 20 : case SYB5BIGDATETIME:
1446 40 : cr->bigdatetime = (dt->dttime * UINT64_C(20) + 3u) / 6u * 1000u
1447 20 : + (dt->dtdays + BIGDATETIME_BIAS) * (UINT64_C(86400) * 1000000u);
1448 : return sizeof(TDS_BIGDATETIME);
1449 : /* conversions not allowed */
1450 : case SYBUNIQUE:
1451 : case SYBBIT:
1452 : case SYBBITN:
1453 : case SYBINT1:
1454 : case SYBSINT1:
1455 : case SYBUINT1:
1456 : case SYBINT2:
1457 : case SYBUINT2:
1458 : case SYBINT4:
1459 : case SYBUINT4:
1460 : case SYBINT8:
1461 : case SYBUINT8:
1462 : case SYBMONEY4:
1463 : case SYBMONEY:
1464 : case SYBNUMERIC:
1465 : case SYBDECIMAL:
1466 : default:
1467 : break;
1468 : }
1469 : return TDS_CONVERT_NOAVAIL;
1470 : }
1471 :
1472 : static TDS_INT
1473 3694 : tds_convert_datetime4(const TDSCONTEXT * tds_ctx, const TDS_DATETIME4 * dt4, int desttype, CONV_RESULT * cr)
1474 : {
1475 : TDS_DATETIME dt;
1476 :
1477 3694 : if (desttype == SYBDATETIME4) {
1478 0 : cr->dt4 = *dt4;
1479 0 : return sizeof(TDS_DATETIME4);
1480 : }
1481 :
1482 : /* convert to DATETIME and use tds_convert_datetime */
1483 3694 : dt.dtdays = dt4->days;
1484 3694 : dt.dttime = dt4->minutes * (60u * 300u);
1485 3694 : return tds_convert_datetime(tds_ctx, &dt, desttype, 0, cr);
1486 : }
1487 :
1488 : static TDS_INT
1489 3200 : tds_convert_time(const TDSCONTEXT * tds_ctx, const TDS_TIME * time, int desttype, CONV_RESULT * cr)
1490 : {
1491 : TDS_DATETIMEALL dta;
1492 :
1493 3200 : if (desttype == SYBTIME) {
1494 10 : cr->time = *time;
1495 10 : return sizeof(TDS_TIME);
1496 : }
1497 :
1498 : /* convert to DATETIMEALL and use tds_convert_datetimeall */
1499 3190 : memset(&dta, 0, sizeof(dta));
1500 3190 : dta.has_time = 1;
1501 3190 : dta.time_prec = 3;
1502 3190 : dta.time = (*time * UINT64_C(100000) + 2) / 3;
1503 3190 : dta.time = (*time * UINT64_C(20) + 3) / 6 * 10000;
1504 3190 : return tds_convert_datetimeall(tds_ctx, SYBMSTIME, &dta, desttype, cr);
1505 : }
1506 :
1507 : static TDS_INT
1508 3220 : tds_convert_date(const TDSCONTEXT * tds_ctx, const TDS_DATE * date, int desttype, CONV_RESULT * cr)
1509 : {
1510 : TDS_DATETIMEALL dta;
1511 :
1512 3220 : if (desttype == SYBDATE) {
1513 10 : cr->date = *date;
1514 10 : return sizeof(TDS_DATE);
1515 : }
1516 :
1517 : /* convert to DATETIMEALL and use tds_convert_datetimeall */
1518 3210 : memset(&dta, 0, sizeof(dta));
1519 3210 : dta.has_date = 1;
1520 3210 : dta.date = *date;
1521 3210 : return tds_convert_datetimeall(tds_ctx, SYBMSDATE, &dta, desttype, cr);
1522 : }
1523 :
1524 : static TDS_INT
1525 2740 : tds_convert_bigtime(const TDSCONTEXT * tds_ctx, const TDS_BIGTIME * bigtime, int desttype, CONV_RESULT * cr)
1526 : {
1527 : TDS_DATETIMEALL dta;
1528 :
1529 2740 : if (desttype == SYB5BIGTIME) {
1530 0 : cr->bigtime = *bigtime;
1531 0 : return sizeof(TDS_BIGTIME);
1532 : }
1533 :
1534 : /* convert to DATETIMEALL and use tds_convert_datetimeall */
1535 2740 : memset(&dta, 0, sizeof(dta));
1536 2740 : dta.time_prec = 6;
1537 2740 : dta.has_time = 1;
1538 2740 : dta.time = *bigtime % (UINT64_C(86400) * 1000000u) * 10u;
1539 2740 : return tds_convert_datetimeall(tds_ctx, SYBMSTIME, &dta, desttype, cr);
1540 : }
1541 :
1542 : static TDS_INT
1543 2770 : tds_convert_bigdatetime(const TDSCONTEXT * tds_ctx, const TDS_BIGDATETIME * bigdatetime, int desttype, CONV_RESULT * cr)
1544 : {
1545 : TDS_DATETIMEALL dta;
1546 : TDS_UINT8 bdt;
1547 :
1548 2770 : if (desttype == SYB5BIGDATETIME) {
1549 0 : cr->bigdatetime = *bigdatetime;
1550 : return sizeof(TDS_BIGDATETIME);
1551 : }
1552 :
1553 : /* convert to DATETIMEALL and use tds_convert_datetimeall */
1554 2770 : bdt = *bigdatetime;
1555 2770 : memset(&dta, 0, sizeof(dta));
1556 2770 : dta.time_prec = 6;
1557 2770 : dta.has_time = 1;
1558 2770 : dta.time = bdt % (UINT64_C(86400) * 1000000u) * 10u;
1559 2770 : bdt /= UINT64_C(86400) * 1000000u;
1560 2770 : dta.has_date = 1;
1561 2770 : dta.date = bdt - BIGDATETIME_BIAS;
1562 2770 : return tds_convert_datetimeall(tds_ctx, SYBMSDATETIME2, &dta, desttype, cr);
1563 : }
1564 :
1565 :
1566 : static TDS_INT
1567 65970 : tds_convert_real(const TDS_REAL* src, int desttype, CONV_RESULT * cr)
1568 : {
1569 : TDS_REAL the_value;
1570 :
1571 : /* FIXME how big should be this buffer ?? */
1572 : char tmp_str[128];
1573 : TDS_INT mymoney4;
1574 : TDS_INT8 mymoney;
1575 :
1576 65970 : the_value = *src;
1577 :
1578 65970 : switch (desttype) {
1579 258 : case TDS_CONVERT_CHAR:
1580 : case CASE_ALL_CHAR:
1581 258 : sprintf(tmp_str, "%.9g", the_value);
1582 258 : return string_to_result(desttype, tmp_str, cr);
1583 : break;
1584 4470 : case SYBSINT1:
1585 4470 : if (!IS_SINT1(the_value))
1586 : return TDS_CONVERT_OVERFLOW;
1587 430 : cr->ti = (TDS_TINYINT) the_value;
1588 : return sizeof(TDS_TINYINT);
1589 : break;
1590 8940 : case SYBINT1:
1591 : case SYBUINT1:
1592 8940 : if (!IS_TINYINT(the_value))
1593 : return TDS_CONVERT_OVERFLOW;
1594 860 : cr->ti = (TDS_TINYINT) the_value;
1595 : return sizeof(TDS_TINYINT);
1596 : break;
1597 4520 : case SYBINT2:
1598 4520 : if (!IS_SMALLINT(the_value))
1599 : return TDS_CONVERT_OVERFLOW;
1600 1370 : cr->si = (TDS_SMALLINT) the_value;
1601 : return sizeof(TDS_SMALLINT);
1602 : break;
1603 4470 : case SYBUINT2:
1604 4470 : if (!IS_USMALLINT(the_value))
1605 : return TDS_CONVERT_OVERFLOW;
1606 900 : cr->usi = (TDS_USMALLINT) the_value;
1607 : return sizeof(TDS_USMALLINT);
1608 : break;
1609 4520 : case SYBINT4:
1610 4520 : if (!FLOAT_IS_INT(the_value))
1611 : return TDS_CONVERT_OVERFLOW;
1612 2640 : cr->i = (TDS_INT) the_value;
1613 : return sizeof(TDS_INT);
1614 : break;
1615 4470 : case SYBUINT4:
1616 4470 : if (!IS_UINT(the_value))
1617 : return TDS_CONVERT_OVERFLOW;
1618 1530 : cr->ui = (TDS_UINT) the_value;
1619 : return sizeof(TDS_UINT);
1620 : break;
1621 4470 : case SYBINT8:
1622 4470 : if (!FLOAT_IS_INT8(the_value))
1623 : return TDS_CONVERT_OVERFLOW;
1624 3850 : cr->bi = (TDS_INT8) the_value;
1625 : return sizeof(TDS_INT8);
1626 : break;
1627 4470 : case SYBUINT8:
1628 4470 : if (!FLOAT_IS_UINT8(the_value))
1629 : return TDS_CONVERT_OVERFLOW;
1630 2160 : cr->ubi = (TDS_UINT8) the_value;
1631 : return sizeof(TDS_UINT8);
1632 : break;
1633 70 : case SYBBIT:
1634 : case SYBBITN:
1635 70 : cr->ti = the_value ? 1 : 0;
1636 : return sizeof(TDS_TINYINT);
1637 : break;
1638 :
1639 4740 : case SYBFLT8:
1640 4740 : cr->f = the_value;
1641 : return sizeof(TDS_FLOAT);
1642 : break;
1643 :
1644 4622 : case SYBREAL:
1645 4622 : cr->r = the_value;
1646 : return sizeof(TDS_REAL);
1647 : break;
1648 :
1649 4420 : case SYBMONEY:
1650 4420 : if (the_value > (TDS_REAL) (TDS_INT8_MAX / 10000) || the_value < (TDS_REAL) (TDS_INT8_MIN / 10000))
1651 : return TDS_CONVERT_OVERFLOW;
1652 3380 : mymoney = (TDS_INT8) (the_value * 10000);
1653 3380 : cr->m.mny = mymoney;
1654 : return sizeof(TDS_MONEY);
1655 : break;
1656 :
1657 4420 : case SYBMONEY4:
1658 4420 : if (the_value > (TDS_REAL) (TDS_INT_MAX / 10000) || the_value < (TDS_REAL) (TDS_INT_MIN / 10000))
1659 : return TDS_CONVERT_OVERFLOW;
1660 2120 : mymoney4 = (TDS_INT) (the_value * 10000);
1661 2120 : cr->m4.mny4 = mymoney4;
1662 : return sizeof(TDS_MONEY4);
1663 : break;
1664 4480 : case SYBNUMERIC:
1665 : case SYBDECIMAL:
1666 4480 : sprintf(tmp_str, "%.*f", cr->n.scale, the_value);
1667 4480 : return stringz_to_numeric(tmp_str, cr);
1668 : break;
1669 : /* not allowed */
1670 : case SYBUNIQUE:
1671 : case SYBDATETIME4:
1672 : case SYBDATETIME:
1673 : case SYBDATETIMN:
1674 : default:
1675 : break;
1676 : }
1677 : return TDS_CONVERT_NOAVAIL;
1678 : }
1679 :
1680 : /*
1681 : * TODO: emit SYBECLPR errors: "Data conversion resulted in loss of precision".
1682 : * There are many places where this would be correct to do, but the test is tedious
1683 : * (convert e.g. 1.5 -> SYBINT and test if output == input) and we don't have a good,
1684 : * API-independent alternative to tds_client_msg(). Postponed until then.
1685 : */
1686 : static TDS_INT
1687 66082 : tds_convert_flt8(const TDS_FLOAT* src, int desttype, CONV_RESULT * cr)
1688 : {
1689 : TDS_FLOAT the_value;
1690 : char tmp_str[25];
1691 :
1692 66082 : memcpy(&the_value, src, 8);
1693 66082 : switch (desttype) {
1694 306 : case TDS_CONVERT_CHAR:
1695 : case CASE_ALL_CHAR:
1696 306 : sprintf(tmp_str, "%.17g", the_value);
1697 306 : return string_to_result(desttype, tmp_str, cr);
1698 : break;
1699 4470 : case SYBSINT1:
1700 4470 : if (!IS_SINT1(the_value))
1701 : return TDS_CONVERT_OVERFLOW;
1702 430 : cr->ti = (TDS_TINYINT) the_value;
1703 430 : return sizeof(TDS_TINYINT);
1704 : break;
1705 8940 : case SYBINT1:
1706 : case SYBUINT1:
1707 8940 : if (!IS_TINYINT(the_value))
1708 : return TDS_CONVERT_OVERFLOW;
1709 860 : cr->ti = (TDS_TINYINT) the_value;
1710 860 : return sizeof(TDS_TINYINT);
1711 : break;
1712 4520 : case SYBINT2:
1713 4520 : if (!IS_SMALLINT(the_value))
1714 : return TDS_CONVERT_OVERFLOW;
1715 1370 : cr->si = (TDS_SMALLINT) the_value;
1716 1370 : return sizeof(TDS_SMALLINT);
1717 : break;
1718 4470 : case SYBUINT2:
1719 4470 : if (!IS_USMALLINT(the_value))
1720 : return TDS_CONVERT_OVERFLOW;
1721 900 : cr->usi = (TDS_USMALLINT) the_value;
1722 900 : return sizeof(TDS_USMALLINT);
1723 : break;
1724 4520 : case SYBINT4:
1725 4520 : if (!FLOAT_IS_INT(the_value))
1726 : return TDS_CONVERT_OVERFLOW;
1727 2630 : cr->i = (TDS_INT) the_value;
1728 2630 : return sizeof(TDS_INT);
1729 : break;
1730 4470 : case SYBUINT4:
1731 4470 : if (!IS_UINT(the_value))
1732 : return TDS_CONVERT_OVERFLOW;
1733 1530 : cr->ui = (TDS_UINT) the_value;
1734 1530 : return sizeof(TDS_UINT);
1735 : break;
1736 4470 : case SYBINT8:
1737 4470 : if (!FLOAT_IS_INT8(the_value))
1738 : return TDS_CONVERT_OVERFLOW;
1739 3850 : cr->bi = (TDS_INT8) the_value;
1740 3850 : return sizeof(TDS_INT8);
1741 : break;
1742 4470 : case SYBUINT8:
1743 4470 : if (!FLOAT_IS_UINT8(the_value))
1744 : return TDS_CONVERT_OVERFLOW;
1745 2160 : cr->ubi = (TDS_UINT8) the_value;
1746 2160 : return sizeof(TDS_UINT8);
1747 : break;
1748 70 : case SYBBIT:
1749 : case SYBBITN:
1750 70 : cr->ti = the_value ? 1 : 0;
1751 70 : return sizeof(TDS_TINYINT);
1752 : break;
1753 :
1754 4420 : case SYBMONEY:
1755 4420 : if (the_value > (TDS_FLOAT) (TDS_INT8_MAX / 10000) || the_value < (TDS_FLOAT) (TDS_INT8_MIN / 10000))
1756 : return TDS_CONVERT_OVERFLOW;
1757 3380 : cr->m.mny = (TDS_INT8) (the_value * 10000);
1758 :
1759 3380 : return sizeof(TDS_MONEY);
1760 : break;
1761 4420 : case SYBMONEY4:
1762 4420 : if (the_value > (TDS_FLOAT) (TDS_INT_MAX / 10000) || the_value < (TDS_FLOAT) (TDS_INT_MIN / 10000))
1763 : return TDS_CONVERT_OVERFLOW;
1764 2120 : cr->m4.mny4 = (TDS_INT) (the_value * 10000);
1765 2120 : return sizeof(TDS_MONEY4);
1766 : break;
1767 4740 : case SYBREAL:
1768 : /* TODO check overflow */
1769 4740 : cr->r = (TDS_REAL)the_value;
1770 4740 : return sizeof(TDS_REAL);
1771 : break;
1772 4676 : case SYBFLT8:
1773 4676 : cr->f = the_value;
1774 4676 : return sizeof(TDS_FLOAT);
1775 : break;
1776 4490 : case SYBNUMERIC:
1777 : case SYBDECIMAL:
1778 4490 : sprintf(tmp_str, "%.*f", cr->n.scale, the_value);
1779 4490 : return stringz_to_numeric(tmp_str, cr);
1780 : break;
1781 : /* not allowed */
1782 : case SYBUNIQUE:
1783 : case SYBDATETIME4:
1784 : case SYBDATETIME:
1785 : case SYBDATETIMN:
1786 : default:
1787 : break;
1788 : }
1789 : return TDS_CONVERT_NOAVAIL;
1790 : }
1791 :
1792 : static TDS_INT
1793 3134 : tds_convert_unique(const TDS_CHAR * src, int desttype, CONV_RESULT * cr)
1794 : {
1795 : /*
1796 : * raw data is equivalent to structure and always aligned,
1797 : * so this cast is portable
1798 : */
1799 3134 : const TDS_UNIQUE *u = (const TDS_UNIQUE *) src;
1800 : char buf[37];
1801 :
1802 3134 : switch (desttype) {
1803 206 : case TDS_CONVERT_CHAR:
1804 : case CASE_ALL_CHAR:
1805 2266 : sprintf(buf, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
1806 618 : (int) u->Data1, (int) u->Data2, (int) u->Data3,
1807 1648 : u->Data4[0], u->Data4[1], u->Data4[2], u->Data4[3], u->Data4[4], u->Data4[5], u->Data4[6], u->Data4[7]);
1808 206 : return string_to_result(desttype, buf, cr);
1809 : break;
1810 68 : case SYBUNIQUE:
1811 : /*
1812 : * Here we can copy raw to structure because we adjust
1813 : * byte order in tds_swap_datatype
1814 : */
1815 68 : memcpy(&(cr->u), src, sizeof(TDS_UNIQUE));
1816 68 : return sizeof(TDS_UNIQUE);
1817 : break;
1818 : /* do not warn for not convertible types */
1819 : case SYBBIT:
1820 : case SYBBITN:
1821 : case SYBINT1:
1822 : case SYBSINT1:
1823 : case SYBUINT1:
1824 : case SYBINT2:
1825 : case SYBUINT2:
1826 : case SYBINT4:
1827 : case SYBUINT4:
1828 : case SYBINT8:
1829 : case SYBUINT8:
1830 : case SYBMONEY4:
1831 : case SYBMONEY:
1832 : case SYBDATETIME4:
1833 : case SYBDATETIME:
1834 : case SYBDATETIMN:
1835 : case SYBREAL:
1836 : case SYBFLT8:
1837 : default:
1838 : break;
1839 : }
1840 : return TDS_CONVERT_NOAVAIL;
1841 : }
1842 :
1843 : static TDS_INT
1844 16208 : tds_convert_to_binary(int srctype, const TDS_CHAR * src, TDS_UINT srclen, int desttype, CONV_RESULT * cr)
1845 : {
1846 : size_t len;
1847 : TDS_CHAR *ib;
1848 :
1849 16208 : switch (srctype) {
1850 416 : case CASE_ALL_BINARY:
1851 416 : len = srclen;
1852 416 : break;
1853 : case SYBBIT:
1854 : case SYBBITN:
1855 : case SYBINT1:
1856 : case SYBSINT1:
1857 : case SYBUINT1:
1858 : len = 1;
1859 : break;
1860 130 : case SYBINT2:
1861 : case SYBUINT2:
1862 130 : len = 2;
1863 130 : break;
1864 170 : case SYBINT4:
1865 : case SYBUINT4:
1866 170 : len = 4;
1867 170 : break;
1868 150 : case SYBINT8:
1869 : case SYBUINT8:
1870 150 : len = sizeof(TDS_INT8);
1871 150 : break;
1872 60 : case SYBMONEY4:
1873 60 : len = sizeof(TDS_MONEY4);
1874 60 : break;
1875 60 : case SYBMONEY:
1876 60 : len = sizeof(TDS_MONEY);
1877 60 : break;
1878 120 : case SYBNUMERIC:
1879 : case SYBDECIMAL:
1880 120 : len = sizeof(TDS_NUMERIC);
1881 120 : break;
1882 60 : case SYBREAL:
1883 60 : len = sizeof(TDS_REAL);
1884 60 : break;
1885 60 : case SYBFLT8:
1886 60 : len = sizeof(TDS_FLOAT);
1887 60 : break;
1888 60 : case SYBDATETIME:
1889 60 : len = sizeof(TDS_DATETIME);
1890 60 : break;
1891 60 : case SYBDATETIME4:
1892 60 : len = sizeof(TDS_DATETIME4);
1893 60 : break;
1894 60 : case SYBTIME:
1895 60 : len = sizeof(TDS_TIME);
1896 60 : break;
1897 60 : case SYBDATE:
1898 60 : len = sizeof(TDS_DATE);
1899 60 : break;
1900 240 : case SYBMSTIME:
1901 : case SYBMSDATE:
1902 : case SYBMSDATETIME2:
1903 : case SYBMSDATETIMEOFFSET:
1904 240 : len = sizeof(TDS_DATETIMEALL);
1905 240 : break;
1906 60 : case SYB5BIGTIME:
1907 60 : len = sizeof(TDS_BIGTIME);
1908 60 : break;
1909 60 : case SYB5BIGDATETIME:
1910 60 : len = sizeof(TDS_BIGDATETIME);
1911 60 : break;
1912 60 : case SYBUNIQUE:
1913 60 : len = sizeof(TDS_UNIQUE);
1914 60 : break;
1915 992 : case CASE_ALL_CHAR:
1916 :
1917 : /* skip leading "0x" or "0X" */
1918 992 : if (srclen >= 2 && src[0] == '0' && (src[1] == 'x' || src[1] == 'X')) {
1919 230 : src += 2;
1920 230 : srclen -= 2;
1921 : }
1922 :
1923 : /* ignore trailing blanks and nulls */
1924 : /* FIXME is good to ignore null ?? */
1925 1048 : while (srclen > 0 && (src[srclen - 1] == ' ' || src[srclen - 1] == '\0'))
1926 : --srclen;
1927 :
1928 : /* a binary string output will be half the length of */
1929 : /* the string which represents it in hexadecimal */
1930 :
1931 992 : ib = cr->cb.ib;
1932 992 : if (desttype != TDS_CONVERT_BINARY) {
1933 : TDS_INT destlen;
1934 :
1935 778 : cr->ib = tds_new(TDS_CHAR, (srclen + 2u) / 2u);
1936 778 : test_alloc(cr->ib);
1937 778 : ib = cr->ib;
1938 778 : destlen = tds_char2hex(ib, 0xffffffffu, src, srclen);
1939 778 : if (destlen < 0)
1940 10 : TDS_ZERO_FREE(cr->ib);
1941 : return destlen;
1942 : }
1943 214 : return tds_char2hex(ib, cr->cb.len, src, srclen);
1944 :
1945 : default:
1946 : return TDS_CONVERT_NOAVAIL;
1947 : }
1948 2196 : return binary_to_result(desttype, src, len, cr);
1949 : }
1950 :
1951 : /**
1952 : * tds_convert
1953 : * convert a type to another.
1954 : * If you convert to SYBDECIMAL/SYBNUMERIC you MUST initialize precision
1955 : * and scale of cr.
1956 : * Do not expect strings to be zero terminated. Databases support zero inside
1957 : * string. Using strlen may result on data loss or even a segmentation fault.
1958 : * Instead, use memcpy to copy destination using length returned.
1959 : * This function does not handle NULL, srclen should be >0. Client libraries handle NULLs each in their own way.
1960 : * @param tds_ctx context (used in conversion to data and to return messages)
1961 : * @param srctype type of source
1962 : * @param src pointer to source data to convert
1963 : * @param srclen length in bytes of source (not counting terminator or strings)
1964 : * @param desttype type of destination
1965 : * @param cr structure to hold result
1966 : * @return length of result or TDS_CONVERT_* failure code on failure. All TDS_CONVERT_* constants are <0.
1967 : */
1968 : TDS_INT
1969 2592358 : tds_convert(const TDSCONTEXT *tds_ctx, int srctype, const void *src, TDS_UINT srclen, int desttype, CONV_RESULT *cr)
1970 : {
1971 2592358 : TDS_INT length = 0;
1972 :
1973 2592358 : assert(srclen >= 0 && srclen <= 2147483647u);
1974 :
1975 2592358 : if (srctype == SYBVARIANT) {
1976 2568 : const TDSVARIANT *v = (const TDSVARIANT*) src;
1977 2568 : srctype = v->type;
1978 2568 : src = v->data;
1979 2568 : srclen = v->data_len;
1980 : }
1981 :
1982 2592358 : switch (desttype) {
1983 16208 : case CASE_ALL_BINARY:
1984 16208 : return tds_convert_to_binary(srctype, src, srclen, desttype, cr);
1985 : }
1986 :
1987 2576150 : switch (srctype) {
1988 1424070 : case CASE_ALL_CHAR:
1989 1424070 : length = tds_convert_char(src, srclen, desttype, cr);
1990 1424070 : break;
1991 35770 : case SYBMONEY4:
1992 35770 : length = tds_convert_money4(tds_ctx, (const TDS_MONEY4 *) src, desttype, cr);
1993 35770 : break;
1994 54418 : case SYBMONEY:
1995 54418 : length = tds_convert_money(tds_ctx, (const TDS_MONEY *) src, desttype, cr);
1996 54418 : break;
1997 75164 : case SYBNUMERIC:
1998 : case SYBDECIMAL:
1999 75164 : length = tds_convert_numeric((const TDS_NUMERIC *) src, desttype, cr);
2000 75164 : break;
2001 6606 : case SYBBIT:
2002 : case SYBBITN:
2003 13212 : length = tds_convert_bit(src, desttype, cr);
2004 6606 : break;
2005 8424 : case SYBSINT1:
2006 16848 : length = tds_convert_int1((const int8_t *) src, desttype, cr);
2007 8424 : break;
2008 21788 : case SYBINT1:
2009 : case SYBUINT1:
2010 43576 : length = tds_convert_uint1((const TDS_TINYINT *) src, desttype, cr);
2011 21788 : break;
2012 27396 : case SYBINT2:
2013 54792 : length = tds_convert_int2((const TDS_SMALLINT *) src, desttype, cr);
2014 27396 : break;
2015 16562 : case SYBUINT2:
2016 33124 : length = tds_convert_uint2((const TDS_USMALLINT *) src, desttype, cr);
2017 16562 : break;
2018 51134 : case SYBINT4:
2019 102268 : length = tds_convert_int4((const TDS_INT *) src, desttype, cr);
2020 51134 : break;
2021 27366 : case SYBUINT4:
2022 54732 : length = tds_convert_uint4((const TDS_UINT *) src, desttype, cr);
2023 27366 : break;
2024 61284 : case SYBINT8:
2025 61284 : length = tds_convert_int8((const TDS_INT8 *) src, desttype, cr);
2026 61284 : break;
2027 35282 : case SYBUINT8:
2028 35282 : length = tds_convert_uint8((const TDS_UINT8 *) src, desttype, cr);
2029 35282 : break;
2030 65970 : case SYBREAL:
2031 65970 : length = tds_convert_real((const TDS_REAL *) src, desttype, cr);
2032 65970 : break;
2033 66082 : case SYBFLT8:
2034 66082 : length = tds_convert_flt8((const TDS_FLOAT *) src, desttype, cr);
2035 66082 : break;
2036 12416 : case SYBMSTIME:
2037 : case SYBMSDATE:
2038 : case SYBMSDATETIME2:
2039 : case SYBMSDATETIMEOFFSET:
2040 12416 : length = tds_convert_datetimeall(tds_ctx, srctype, (const TDS_DATETIMEALL *) src, desttype, cr);
2041 12416 : break;
2042 4440 : case SYBDATETIME:
2043 4440 : length = tds_convert_datetime(tds_ctx, (const TDS_DATETIME* ) src, desttype, 3, cr);
2044 4440 : break;
2045 3694 : case SYBDATETIME4:
2046 3694 : length = tds_convert_datetime4(tds_ctx, (const TDS_DATETIME4* ) src, desttype, cr);
2047 3694 : break;
2048 3200 : case SYBTIME:
2049 3200 : length = tds_convert_time(tds_ctx, (const TDS_TIME *) src, desttype, cr);
2050 3200 : break;
2051 3220 : case SYBDATE:
2052 3220 : length = tds_convert_date(tds_ctx, (const TDS_DATE *) src, desttype, cr);
2053 3220 : break;
2054 2740 : case SYB5BIGTIME:
2055 2740 : length = tds_convert_bigtime(tds_ctx, (const TDS_BIGTIME *) src, desttype, cr);
2056 2740 : break;
2057 2770 : case SYB5BIGDATETIME:
2058 2770 : length = tds_convert_bigdatetime(tds_ctx, (const TDS_BIGDATETIME *) src, desttype, cr);
2059 2770 : break;
2060 18330 : case CASE_ALL_BINARY:
2061 18330 : length = tds_convert_binary((const TDS_UCHAR *) src, srclen, desttype, cr);
2062 18330 : break;
2063 3134 : case SYBUNIQUE:
2064 3134 : length = tds_convert_unique(src, desttype, cr);
2065 3134 : break;
2066 : case SYBNVARCHAR:
2067 : case SYBNTEXT:
2068 : case SYBMSTABLE:
2069 : default:
2070 : return TDS_CONVERT_NOAVAIL;
2071 : break;
2072 : }
2073 :
2074 : /* fix MONEY case */
2075 : #if !defined(WORDS_BIGENDIAN)
2076 2031260 : if (length > 0 && desttype == SYBMONEY) {
2077 111680 : cr->m.mny = ((TDS_UINT8) cr->m.mny) >> 32 | (cr->m.mny << 32);
2078 : }
2079 : #endif
2080 : return length;
2081 : }
2082 :
2083 : static int
2084 2868 : string_to_datetime(const char *instr, TDS_UINT len, int desttype, CONV_RESULT * cr)
2085 : {
2086 : enum states {
2087 : GOING_IN_BLIND,
2088 : PUT_NUMERIC_IN_CONTEXT,
2089 : DOING_ALPHABETIC_DATE
2090 : };
2091 :
2092 : char *in;
2093 : char *tok;
2094 : char *lasts;
2095 : char last_token[32];
2096 2868 : int monthdone = 0;
2097 2868 : int yeardone = 0;
2098 2868 : int mdaydone = 0;
2099 :
2100 : struct tds_time t;
2101 :
2102 : unsigned int dt_time;
2103 : TDS_INT dt_days;
2104 : int i;
2105 :
2106 : enum states current_state;
2107 :
2108 2868 : memset(&t, '\0', sizeof(t));
2109 2868 : t.tm_mday = 1;
2110 :
2111 2868 : in = tds_strndup(instr, len);
2112 2868 : test_alloc(in);
2113 :
2114 2868 : tok = strtok_r(in, " ,", &lasts);
2115 :
2116 2868 : current_state = GOING_IN_BLIND;
2117 :
2118 11082 : while (tok != NULL) {
2119 :
2120 5356 : tdsdump_log(TDS_DBG_INFO1, "string_to_datetime: current_state = %d\n", current_state);
2121 5356 : switch (current_state) {
2122 3676 : case GOING_IN_BLIND:
2123 : /* If we have no idea of current context, then if we have */
2124 : /* encountered a purely alphabetic string, it MUST be an */
2125 : /* alphabetic month name or prefix... */
2126 :
2127 3676 : if (is_alphabetic(tok)) {
2128 830 : tdsdump_log(TDS_DBG_INFO1, "string_to_datetime: is_alphabetic\n");
2129 830 : if (store_monthname(tok, &t) >= 0) {
2130 820 : monthdone++;
2131 820 : current_state = DOING_ALPHABETIC_DATE;
2132 : } else {
2133 : goto string_garbled;
2134 : }
2135 : }
2136 :
2137 : /* ...whereas if it is numeric, it could be a number of */
2138 : /* things... */
2139 :
2140 2846 : else if (is_numeric(tok)) {
2141 40 : tdsdump_log(TDS_DBG_INFO1, "string_to_datetime: is_numeric\n");
2142 40 : switch (strlen(tok)) {
2143 : /* in this context a 4 character numeric can */
2144 : /* ONLY be the year part of an alphabetic date */
2145 :
2146 0 : case 4:
2147 0 : store_year(atoi(tok), &t);
2148 0 : yeardone++;
2149 0 : current_state = DOING_ALPHABETIC_DATE;
2150 0 : break;
2151 :
2152 : /* whereas these could be the hour part of a */
2153 : /* time specification ( 4 PM ) or the leading */
2154 : /* day part of an alphabetic date ( 15 Jan ) */
2155 :
2156 20 : case 2:
2157 : case 1:
2158 20 : strcpy(last_token, tok);
2159 20 : current_state = PUT_NUMERIC_IN_CONTEXT;
2160 20 : break;
2161 :
2162 : /* this must be a [YY]YYMMDD date */
2163 :
2164 20 : case 6:
2165 : case 8:
2166 20 : if (store_yymmdd_date(tok, &t))
2167 : current_state = GOING_IN_BLIND;
2168 : else
2169 : goto string_garbled;
2170 : break;
2171 :
2172 : /* anything else is nonsense... */
2173 :
2174 : default:
2175 : goto string_garbled;
2176 : break;
2177 : }
2178 : }
2179 :
2180 : /* it could be [M]M/[D]D/[YY]YY format */
2181 :
2182 2806 : else if (is_numeric_dateformat(tok)) {
2183 1018 : tdsdump_log(TDS_DBG_INFO1, "string_to_datetime: is_numeric_dateformat\n");
2184 1018 : store_numeric_date(tok, &t);
2185 1018 : current_state = GOING_IN_BLIND;
2186 1788 : } else if (is_dd_mon_yyyy(tok)) {
2187 10 : tdsdump_log(TDS_DBG_INFO1, "string_to_datetime: is_dd_mon_yyyy\n");
2188 10 : store_dd_mon_yyy_date(tok, &t);
2189 10 : current_state = GOING_IN_BLIND;
2190 1778 : } else if (is_timeformat(tok)) {
2191 1778 : tdsdump_log(TDS_DBG_INFO1, "string_to_datetime: is_timeformat\n");
2192 1778 : store_time(tok, &t);
2193 1778 : current_state = GOING_IN_BLIND;
2194 : } else {
2195 0 : tdsdump_log(TDS_DBG_INFO1, "string_to_datetime: string_garbled\n");
2196 : goto string_garbled;
2197 : }
2198 :
2199 : break; /* end of GOING_IN_BLIND */
2200 :
2201 1660 : case DOING_ALPHABETIC_DATE:
2202 :
2203 1660 : if (is_alphabetic(tok)) {
2204 0 : if (!monthdone && store_monthname(tok, &t) >= 0) {
2205 0 : monthdone++;
2206 0 : if (monthdone && yeardone && mdaydone)
2207 : current_state = GOING_IN_BLIND;
2208 : else
2209 0 : current_state = DOING_ALPHABETIC_DATE;
2210 : } else {
2211 : goto string_garbled;
2212 : }
2213 1660 : } else if (is_numeric(tok)) {
2214 1660 : if (mdaydone && yeardone)
2215 : goto string_garbled;
2216 : else
2217 1660 : switch (strlen(tok)) {
2218 840 : case 4:
2219 1680 : store_year(atoi(tok), &t);
2220 840 : yeardone++;
2221 840 : if (monthdone && yeardone && mdaydone)
2222 : current_state = GOING_IN_BLIND;
2223 : else
2224 0 : current_state = DOING_ALPHABETIC_DATE;
2225 : break;
2226 :
2227 820 : case 2:
2228 : case 1:
2229 820 : if (!mdaydone) {
2230 1640 : store_mday(tok, &t);
2231 :
2232 820 : mdaydone++;
2233 820 : if (monthdone && yeardone && mdaydone)
2234 : current_state = GOING_IN_BLIND;
2235 : else
2236 820 : current_state = DOING_ALPHABETIC_DATE;
2237 : } else {
2238 0 : store_year(atoi(tok), &t);
2239 0 : yeardone++;
2240 0 : if (monthdone && yeardone && mdaydone)
2241 : current_state = GOING_IN_BLIND;
2242 : else
2243 0 : current_state = DOING_ALPHABETIC_DATE;
2244 : }
2245 : break;
2246 :
2247 : default:
2248 : goto string_garbled;
2249 : }
2250 : } else {
2251 : goto string_garbled;
2252 : }
2253 :
2254 : break; /* end of DOING_ALPHABETIC_DATE */
2255 :
2256 20 : case PUT_NUMERIC_IN_CONTEXT:
2257 :
2258 20 : if (is_alphabetic(tok)) {
2259 20 : if (store_monthname(tok, &t) >= 0) {
2260 40 : store_mday(last_token, &t);
2261 20 : mdaydone++;
2262 20 : monthdone++;
2263 20 : if (monthdone && yeardone && mdaydone)
2264 : current_state = GOING_IN_BLIND;
2265 : else
2266 20 : current_state = DOING_ALPHABETIC_DATE;
2267 0 : } else if (is_ampm(tok)) {
2268 0 : store_hour(last_token, tok, &t);
2269 0 : current_state = GOING_IN_BLIND;
2270 : } else {
2271 : goto string_garbled;
2272 : }
2273 0 : } else if (is_numeric(tok)) {
2274 0 : switch (strlen(tok)) {
2275 : case 4:
2276 : case 2:
2277 0 : store_mday(last_token, &t);
2278 0 : mdaydone++;
2279 0 : store_year(atoi(tok), &t);
2280 0 : yeardone++;
2281 :
2282 0 : if (monthdone && yeardone && mdaydone)
2283 : current_state = GOING_IN_BLIND;
2284 : else
2285 0 : current_state = DOING_ALPHABETIC_DATE;
2286 : break;
2287 :
2288 : default:
2289 : goto string_garbled;
2290 : }
2291 : } else {
2292 : goto string_garbled;
2293 : }
2294 :
2295 : break; /* end of PUT_NUMERIC_IN_CONTEXT */
2296 : }
2297 :
2298 5346 : tok = strtok_r(NULL, " ,", &lasts);
2299 : }
2300 :
2301 2858 : i = (t.tm_mon - 13) / 12;
2302 8574 : dt_days = 1461 * (t.tm_year + 1900 + i) / 4 +
2303 5716 : (367 * (t.tm_mon - 1 - 12 * i)) / 12 - (3 * ((t.tm_year + 2000 + i) / 100)) / 4 + t.tm_mday - 693932;
2304 :
2305 2858 : free(in);
2306 :
2307 2858 : if (desttype == SYBDATE) {
2308 170 : cr->date = dt_days;
2309 170 : return sizeof(TDS_DATE);
2310 : }
2311 2688 : dt_time = t.tm_hour * 60 + t.tm_min;
2312 : /* TODO check for overflow */
2313 2688 : if (desttype == SYBDATETIME4) {
2314 640 : cr->dt4.days = dt_days;
2315 640 : cr->dt4.minutes = dt_time;
2316 640 : return sizeof(TDS_DATETIME4);
2317 : }
2318 2048 : dt_time = dt_time * 60 + t.tm_sec;
2319 2048 : if (desttype == SYBDATETIME) {
2320 770 : cr->dt.dtdays = dt_days;
2321 770 : cr->dt.dttime = dt_time * 300 + (t.tm_ns / 1000000u * 300 + 150) / 1000;
2322 770 : return sizeof(TDS_DATETIME);
2323 : }
2324 1278 : if (desttype == SYBTIME) {
2325 170 : cr->time = dt_time * 300 + (t.tm_ns / 1000000u * 300 + 150) / 1000;
2326 170 : return sizeof(TDS_TIME);
2327 : }
2328 1108 : if (desttype == SYB5BIGTIME) {
2329 90 : cr->bigtime = dt_time * UINT64_C(1000000) + t.tm_ns / 1000u;
2330 90 : return sizeof(TDS_BIGTIME);
2331 : }
2332 1018 : if (desttype == SYB5BIGDATETIME) {
2333 240 : cr->bigdatetime = (dt_days + BIGDATETIME_BIAS) * (UINT64_C(86400) * 1000000u)
2334 120 : + dt_time * UINT64_C(1000000) + t.tm_ns / 1000u;
2335 120 : return sizeof(TDS_BIGDATETIME);
2336 : }
2337 :
2338 898 : cr->dta.has_offset = 0;
2339 898 : cr->dta.offset = 0;
2340 898 : cr->dta.has_date = 1;
2341 898 : cr->dta.date = dt_days;
2342 898 : cr->dta.has_time = 1;
2343 898 : cr->dta.time_prec = 7; /* TODO correct value */
2344 898 : cr->dta.time = dt_time * UINT64_C(10000000) + t.tm_ns / 100u;
2345 898 : return sizeof(TDS_DATETIMEALL);
2346 :
2347 10 : string_garbled:
2348 10 : tdsdump_log(TDS_DBG_INFO1,
2349 : "error_handler: Attempt to convert data stopped by syntax error in source field \n");
2350 10 : free(in);
2351 10 : return TDS_CONVERT_SYNTAX;
2352 : }
2353 :
2354 : static int
2355 8970 : stringz_to_numeric(const char *instr, CONV_RESULT * cr)
2356 : {
2357 8970 : return string_to_numeric(instr, instr + strlen(instr), cr);
2358 : }
2359 :
2360 : static int
2361 116600 : string_to_numeric(const char *instr, const char *pend, CONV_RESULT * cr)
2362 : {
2363 : char mynumber[(MAXPRECISION + 7) / 8 * 8 + 8];
2364 :
2365 : /* num packaged 8 digit, see below for detail */
2366 : TDS_UINT packed_num[(MAXPRECISION + 7) / 8];
2367 :
2368 : char *ptr;
2369 :
2370 116600 : int i = 0;
2371 116600 : int j = 0;
2372 : int bytes;
2373 :
2374 : bool negative;
2375 : size_t digits, decimals;
2376 :
2377 : /* FIXME: application can pass invalid value for precision and scale ?? */
2378 116600 : if (cr->n.precision > MAXPRECISION)
2379 : return TDS_CONVERT_FAIL;
2380 :
2381 116600 : if (cr->n.precision == 0)
2382 0 : cr->n.precision = MAXPRECISION; /* assume max precision */
2383 :
2384 116600 : if (cr->n.scale > cr->n.precision)
2385 : return TDS_CONVERT_FAIL;
2386 :
2387 116600 : instr = parse_numeric(instr, pend, &negative, &digits, &decimals);
2388 116600 : if (!instr)
2389 : return TDS_CONVERT_SYNTAX;
2390 :
2391 116590 : cr->n.array[0] = negative ? 1 : 0;
2392 :
2393 : /* translate a number like 000ddddd.ffff to 00000000dddddffff00 */
2394 :
2395 : /*
2396 : * Having disposed of any sign and leading blanks,
2397 : * vet the digit string, counting places before and after
2398 : * the decimal point. Dispense with trailing blanks, if any.
2399 : */
2400 :
2401 116590 : ptr = mynumber;
2402 1049310 : for (i = 0; i < 8; ++i)
2403 932720 : *ptr++ = '0';
2404 :
2405 : /* too many digits, error */
2406 116590 : if (cr->n.precision - cr->n.scale < digits)
2407 : return TDS_CONVERT_OVERFLOW;
2408 :
2409 : /* copy digits before the dot */
2410 116300 : memcpy(ptr, instr, digits);
2411 116300 : ptr += digits;
2412 116300 : instr += digits + 1;
2413 :
2414 : /* copy digits after the dot */
2415 116300 : if (decimals > cr->n.scale)
2416 130 : decimals = cr->n.scale;
2417 116300 : memcpy(ptr, instr, decimals);
2418 :
2419 : /* fill up decimal digits */
2420 116300 : memset(ptr + decimals, '0', cr->n.scale - decimals);
2421 116300 : ptr += cr->n.scale;
2422 :
2423 : /*
2424 : * Packaged number explanation:
2425 : * We package 8 decimal digits in one number.
2426 : * Because 10^8 = 5^8 * 2^8 = 5^8 * 256, dividing 10^8 by 256 leaves no remainder.
2427 : * We can thus split it into bytes in an optimized way.
2428 : */
2429 :
2430 : /* transform to packaged one */
2431 116300 : j = -1;
2432 116300 : ptr -= 8;
2433 : do {
2434 183050 : TDS_UINT n = *ptr++;
2435 :
2436 1464400 : for (i = 1; i < 8; ++i)
2437 1281350 : n = n * 10u + *ptr++;
2438 : /* fix packet number and store */
2439 183050 : packed_num[++j] = n - ((TDS_UINT) '0' * 11111111lu);
2440 183050 : ptr -= 16;
2441 183050 : } while (ptr > mynumber);
2442 :
2443 116300 : memset(cr->n.array + 1, 0, sizeof(cr->n.array) - 1);
2444 116300 : bytes = tds_numeric_bytes_per_prec[cr->n.precision];
2445 232600 : while (j > 0 && !packed_num[j])
2446 0 : --j;
2447 :
2448 431110 : for (;;) {
2449 547410 : bool is_zero = true;
2450 547410 : TDS_UINT carry = 0;
2451 547410 : i = j;
2452 547410 : if (!packed_num[j])
2453 183050 : --j;
2454 : do {
2455 793050 : TDS_UINT tmp = packed_num[i];
2456 793050 : if (tmp)
2457 608740 : is_zero = false;
2458 :
2459 : /* divide for 256 for find another byte */
2460 : /*
2461 : * carry * (25u*25u*25u*25u) = carry * 10^8 / 256u
2462 : * using unsigned number is just an optimization
2463 : * compiler can translate division to a shift and remainder
2464 : * to a binary AND
2465 : */
2466 793050 : packed_num[i] = carry * (25u * 25u * 25u * 25u) + tmp / 256u;
2467 793050 : carry = tmp % 256u;
2468 793050 : } while(--i >= 0);
2469 547410 : if (is_zero)
2470 : break;
2471 : /*
2472 : * source number is limited to 38 decimal digit
2473 : * 10^39-1 < 2^128 (16 byte) so this cannot make an overflow
2474 : */
2475 431110 : cr->n.array[--bytes] = carry;
2476 : }
2477 : return sizeof(TDS_NUMERIC);
2478 : }
2479 :
2480 : static bool
2481 2806 : is_numeric_dateformat(const char *t)
2482 : {
2483 : const char *instr;
2484 2806 : int slashes = 0;
2485 2806 : int hyphens = 0;
2486 2806 : int periods = 0;
2487 2806 : int digits = 0;
2488 :
2489 16062 : for (instr = t; *instr; instr++) {
2490 15044 : if (!isdigit((unsigned char) *instr) && *instr != '/' && *instr != '-' && *instr != '.')
2491 : return false;
2492 :
2493 13256 : if (*instr == '/')
2494 0 : slashes++;
2495 13256 : else if (*instr == '-')
2496 2036 : hyphens++;
2497 11220 : else if (*instr == '.')
2498 0 : periods++;
2499 : else
2500 11220 : digits++;
2501 :
2502 : }
2503 1018 : if (hyphens + slashes + periods != 2)
2504 : return false;
2505 1018 : if (hyphens == 1 || slashes == 1 || periods == 1)
2506 : return false;
2507 :
2508 1018 : if (digits < 4 || digits > 8)
2509 : return false;
2510 :
2511 1018 : return true;
2512 :
2513 : }
2514 :
2515 : /* This function will check if an alphanumeric string */
2516 : /* holds a date in any of the following formats : */
2517 : /* DD-MON-YYYY */
2518 : /* DD-MON-YY */
2519 : /* DDMONYY */
2520 : /* DDMONYYYY */
2521 : static bool
2522 1788 : is_dd_mon_yyyy(char *t)
2523 : {
2524 : char *instr;
2525 : char month[4];
2526 :
2527 1788 : instr = t;
2528 :
2529 1788 : if (!isdigit((unsigned char) *instr))
2530 : return false;
2531 :
2532 1788 : instr++;
2533 :
2534 1788 : if (!isdigit((unsigned char) *instr))
2535 : return false;
2536 :
2537 1288 : instr++;
2538 :
2539 1288 : if (*instr == '-') {
2540 0 : instr++;
2541 :
2542 0 : strlcpy(month, instr, 4);
2543 :
2544 0 : if (!is_monthname(month))
2545 : return false;
2546 :
2547 0 : instr += 3;
2548 :
2549 0 : if (*instr != '-')
2550 : return false;
2551 :
2552 0 : instr++;
2553 0 : if (!isdigit((unsigned char) *instr))
2554 : return false;
2555 :
2556 0 : instr++;
2557 0 : if (!isdigit((unsigned char) *instr))
2558 : return false;
2559 :
2560 0 : instr++;
2561 :
2562 0 : if (*instr) {
2563 0 : if (!isdigit((unsigned char) *instr))
2564 : return false;
2565 :
2566 0 : instr++;
2567 0 : if (!isdigit((unsigned char) *instr))
2568 : return false;
2569 : }
2570 :
2571 : } else {
2572 :
2573 1288 : strlcpy(month, instr, 4);
2574 :
2575 1288 : if (!is_monthname(month))
2576 : return false;
2577 :
2578 10 : instr += 3;
2579 :
2580 10 : if (!isdigit((unsigned char) *instr))
2581 : return false;
2582 :
2583 10 : instr++;
2584 10 : if (!isdigit((unsigned char) *instr))
2585 : return false;
2586 :
2587 10 : instr++;
2588 10 : if (*instr) {
2589 10 : if (!isdigit((unsigned char) *instr))
2590 : return false;
2591 :
2592 10 : instr++;
2593 10 : if (!isdigit((unsigned char) *instr))
2594 : return false;
2595 : }
2596 : }
2597 :
2598 : return true;
2599 :
2600 : }
2601 :
2602 : static bool
2603 500 : is_ampm(const char *datestr)
2604 : {
2605 500 : if (strcasecmp(datestr, "am") == 0)
2606 : return true;
2607 :
2608 500 : if (strcasecmp(datestr, "pm") == 0)
2609 : return true;
2610 :
2611 0 : return false;
2612 : }
2613 :
2614 : static bool
2615 5356 : is_alphabetic(const char *datestr)
2616 : {
2617 : const char *s;
2618 :
2619 7986 : for (s = datestr; *s; s++) {
2620 7136 : if (!isalpha((unsigned char) *s))
2621 : return false;
2622 : }
2623 : return true;
2624 : }
2625 :
2626 : static bool
2627 4506 : is_numeric(const char *datestr)
2628 : {
2629 : const char *s;
2630 :
2631 16724 : for (s = datestr; *s; s++) {
2632 15024 : if (!isdigit((unsigned char) *s))
2633 : return false;
2634 : }
2635 : return true;
2636 : }
2637 :
2638 : static bool
2639 1778 : is_timeformat(const char *datestr)
2640 : {
2641 : const char *s;
2642 :
2643 18384 : for (s = datestr; *s; s++) {
2644 17106 : if (!isdigit((unsigned char) *s) && *s != ':' && *s != '.')
2645 : break;
2646 : }
2647 1778 : if (*s)
2648 500 : return is_ampm(s);
2649 :
2650 : return true;
2651 : }
2652 :
2653 : static int
2654 : store_year(int year, struct tds_time *t)
2655 : {
2656 :
2657 1888 : if (year < 0)
2658 : return 0;
2659 :
2660 1888 : if (year < 100) {
2661 10 : if (year > 49)
2662 0 : t->tm_year = year;
2663 : else
2664 10 : t->tm_year = 100 + year;
2665 : return (1);
2666 : }
2667 :
2668 1878 : if (year < 1753)
2669 : return (0);
2670 :
2671 1878 : if (year <= 9999) {
2672 1878 : t->tm_year = year - 1900;
2673 : return (1);
2674 : }
2675 :
2676 : return (0);
2677 :
2678 : }
2679 :
2680 : static int
2681 : store_mday(const char *datestr, struct tds_time *t)
2682 : {
2683 840 : int mday = atoi(datestr);
2684 :
2685 840 : if (mday > 0 && mday < 32) {
2686 840 : t->tm_mday = mday;
2687 : return 1;
2688 : }
2689 : return 0;
2690 : }
2691 :
2692 : static int
2693 1018 : store_numeric_date(const char *datestr, struct tds_time *t)
2694 : {
2695 1018 : int TDS_MONTH = 0;
2696 1018 : int TDS_DAY = 0;
2697 1018 : int TDS_YEAR = 0;
2698 :
2699 : int state;
2700 1018 : char last_char = 0;
2701 : const char *s;
2702 1018 : int month = 0, year = 0, mday = 0;
2703 :
2704 : /* Its YYYY-MM-DD format */
2705 :
2706 1018 : if (strlen(datestr) == 10 && *(datestr + 4) == '-' && *(datestr + 7) == '-') {
2707 :
2708 : TDS_YEAR = 0;
2709 : TDS_MONTH = 1;
2710 : TDS_DAY = 2;
2711 : state = TDS_YEAR;
2712 :
2713 : }
2714 : /* else we assume MDY */
2715 : else {
2716 0 : TDS_MONTH = 0;
2717 0 : TDS_DAY = 1;
2718 0 : TDS_YEAR = 2;
2719 0 : state = TDS_MONTH;
2720 : }
2721 11198 : for (s = datestr; *s; s++) {
2722 10180 : if (!isdigit((unsigned char) *s) && isdigit((unsigned char) last_char)) {
2723 2036 : state++;
2724 : } else {
2725 8144 : if (state == TDS_MONTH)
2726 2036 : month = (month * 10) + (*s - '0');
2727 8144 : if (state == TDS_DAY)
2728 2036 : mday = (mday * 10) + (*s - '0');
2729 8144 : if (state == TDS_YEAR)
2730 4072 : year = (year * 10) + (*s - '0');
2731 : }
2732 10180 : last_char = *s;
2733 : }
2734 :
2735 1018 : if (month > 0 && month < 13)
2736 1018 : t->tm_mon = month - 1;
2737 : else
2738 : return 0;
2739 1018 : if (mday > 0 && mday < 32)
2740 1018 : t->tm_mday = mday;
2741 : else
2742 : return 0;
2743 :
2744 1018 : return store_year(year, t);
2745 :
2746 : }
2747 :
2748 : static int
2749 10 : store_dd_mon_yyy_date(char *datestr, struct tds_time *t)
2750 : {
2751 :
2752 : char dd[3];
2753 : int mday;
2754 : char mon[4];
2755 : int year;
2756 :
2757 10 : tdsdump_log(TDS_DBG_INFO1, "store_dd_mon_yyy_date: %s\n", datestr);
2758 10 : strlcpy(dd, datestr, 3);
2759 10 : mday = atoi(dd);
2760 :
2761 10 : if (mday > 0 && mday < 32)
2762 10 : t->tm_mday = mday;
2763 : else
2764 : return 0;
2765 :
2766 10 : if (datestr[2] == '-') {
2767 0 : strlcpy(mon, &datestr[3], 4);
2768 :
2769 0 : if (store_monthname(mon, t) < 0) {
2770 0 : tdsdump_log(TDS_DBG_INFO1, "store_dd_mon_yyy_date: store_monthname failed\n");
2771 : return 0;
2772 : }
2773 :
2774 0 : year = atoi(&datestr[7]);
2775 0 : tdsdump_log(TDS_DBG_INFO1, "store_dd_mon_yyy_date: year %d\n", year);
2776 :
2777 0 : return store_year(year, t);
2778 : } else {
2779 10 : strlcpy(mon, &datestr[2], 4);
2780 :
2781 10 : if (store_monthname(mon, t) < 0) {
2782 0 : tdsdump_log(TDS_DBG_INFO1, "store_dd_mon_yyy_date: store_monthname failed\n");
2783 : return 0;
2784 : }
2785 :
2786 20 : year = atoi(&datestr[5]);
2787 10 : tdsdump_log(TDS_DBG_INFO1, "store_dd_mon_yyy_date: year %d\n", year);
2788 :
2789 10 : return store_year(year, t);
2790 : }
2791 :
2792 : }
2793 :
2794 : /**
2795 : * Test if a string is a month name and store correct month number
2796 : * @return month number (0-11) or -1 if not match
2797 : * @param datestr string to check
2798 : * @param t where to store month (if NULL no store is done)
2799 : */
2800 : static int
2801 2148 : store_monthname(const char *datestr, struct tds_time *t)
2802 : {
2803 : int ret;
2804 :
2805 2148 : tdsdump_log(TDS_DBG_INFO1, "store_monthname: %ld %s\n", (long) strlen(datestr), datestr);
2806 2148 : if (strlen(datestr) == 3) {
2807 2118 : if (strcasecmp(datestr, "jan") == 0)
2808 : ret = 0;
2809 1968 : else if (strcasecmp(datestr, "feb") == 0)
2810 : ret = 1;
2811 1968 : else if (strcasecmp(datestr, "mar") == 0)
2812 : ret = 2;
2813 1968 : else if (strcasecmp(datestr, "apr") == 0)
2814 : ret = 3;
2815 1788 : else if (strcasecmp(datestr, "may") == 0)
2816 : ret = 4;
2817 1778 : else if (strcasecmp(datestr, "jun") == 0)
2818 : ret = 5;
2819 1778 : else if (strcasecmp(datestr, "jul") == 0)
2820 : ret = 6;
2821 1778 : else if (strcasecmp(datestr, "aug") == 0)
2822 : ret = 7;
2823 1778 : else if (strcasecmp(datestr, "sep") == 0)
2824 : ret = 8;
2825 1778 : else if (strcasecmp(datestr, "oct") == 0)
2826 : ret = 9;
2827 1778 : else if (strcasecmp(datestr, "nov") == 0)
2828 : ret = 10;
2829 1778 : else if (strcasecmp(datestr, "dec") == 0)
2830 : ret = 11;
2831 : else
2832 : return -1;
2833 : } else {
2834 30 : if (strcasecmp(datestr, "january") == 0)
2835 : ret = 0;
2836 20 : else if (strcasecmp(datestr, "february") == 0)
2837 : ret = 1;
2838 20 : else if (strcasecmp(datestr, "march") == 0)
2839 : ret = 2;
2840 10 : else if (strcasecmp(datestr, "april") == 0)
2841 : ret = 3;
2842 10 : else if (strcasecmp(datestr, "june") == 0)
2843 : ret = 5;
2844 10 : else if (strcasecmp(datestr, "july") == 0)
2845 : ret = 6;
2846 10 : else if (strcasecmp(datestr, "august") == 0)
2847 : ret = 7;
2848 10 : else if (strcasecmp(datestr, "september") == 0)
2849 : ret = 8;
2850 10 : else if (strcasecmp(datestr, "october") == 0)
2851 : ret = 9;
2852 10 : else if (strcasecmp(datestr, "november") == 0)
2853 : ret = 10;
2854 10 : else if (strcasecmp(datestr, "december") == 0)
2855 : ret = 11;
2856 : else
2857 : return -1;
2858 : }
2859 860 : if (t)
2860 850 : t->tm_mon = ret;
2861 : return ret;
2862 : }
2863 :
2864 : static int
2865 20 : store_yymmdd_date(const char *datestr, struct tds_time *t)
2866 : {
2867 20 : int month = 0, year = 0, mday = 0;
2868 :
2869 : int wholedate;
2870 :
2871 20 : wholedate = atoi(datestr);
2872 :
2873 20 : year = wholedate / 10000;
2874 20 : month = (wholedate - (year * 10000)) / 100;
2875 20 : mday = (wholedate - (year * 10000) - (month * 100));
2876 :
2877 20 : if (month > 0 && month < 13)
2878 20 : t->tm_mon = month - 1;
2879 : else
2880 : return 0;
2881 20 : if (mday > 0 && mday < 32)
2882 20 : t->tm_mday = mday;
2883 : else
2884 : return 0;
2885 :
2886 20 : return (store_year(year, t));
2887 :
2888 : }
2889 :
2890 : static int
2891 1778 : store_time(const char *datestr, struct tds_time *t)
2892 : {
2893 : enum
2894 : { TDS_HOURS,
2895 : TDS_MINUTES,
2896 : TDS_SECONDS,
2897 : TDS_FRACTIONS
2898 : };
2899 :
2900 1778 : int state = TDS_HOURS;
2901 1778 : char last_sep = '\0';
2902 : const char *s;
2903 1778 : unsigned int hours = 0, minutes = 0, seconds = 0, nanosecs = 0;
2904 1778 : int ret = 1;
2905 1778 : unsigned ns_div = 1;
2906 :
2907 18384 : for (s = datestr; *s && strchr("apmAPM", (int) *s) == NULL; s++) {
2908 16606 : if (*s == ':' || *s == '.') {
2909 3814 : last_sep = *s;
2910 3814 : state++;
2911 : } else {
2912 12792 : if (*s < '0' || *s > '9')
2913 0 : ret = 0;
2914 12792 : switch (state) {
2915 3056 : case TDS_HOURS:
2916 3056 : hours = (hours * 10u) + (*s - '0');
2917 3056 : break;
2918 3556 : case TDS_MINUTES:
2919 3556 : minutes = (minutes * 10u) + (*s - '0');
2920 3556 : break;
2921 2556 : case TDS_SECONDS:
2922 2556 : seconds = (seconds * 10u) + (*s - '0');
2923 2556 : break;
2924 3624 : case TDS_FRACTIONS:
2925 3624 : if (ns_div < 1000000000u) {
2926 3624 : nanosecs = (nanosecs * 10u) + (*s - '0');
2927 3624 : ns_div *= 10;
2928 : }
2929 : break;
2930 : }
2931 : }
2932 : }
2933 1778 : if (*s) {
2934 500 : if (strcasecmp(s, "am") == 0) {
2935 0 : if (hours == 12)
2936 0 : hours = 0;
2937 :
2938 0 : t->tm_hour = hours;
2939 : }
2940 500 : if (strcasecmp(s, "pm") == 0) {
2941 500 : if (hours == 0)
2942 0 : ret = 0;
2943 500 : if (hours > 0u && hours < 12u)
2944 500 : t->tm_hour = hours + 12;
2945 : else
2946 0 : t->tm_hour = hours;
2947 : }
2948 : } else {
2949 1278 : if (hours < 24u)
2950 1278 : t->tm_hour = hours;
2951 : else
2952 : ret = 0;
2953 : }
2954 1778 : if (minutes < 60u)
2955 1778 : t->tm_min = minutes;
2956 : else
2957 : ret = 0;
2958 1778 : if (seconds < 60u)
2959 1778 : t->tm_sec = seconds;
2960 : else
2961 : ret = 0;
2962 1778 : tdsdump_log(TDS_DBG_FUNC, "store_time() nanosecs = %d\n", nanosecs);
2963 1778 : if (nanosecs) {
2964 548 : if (nanosecs < ns_div && last_sep == '.')
2965 548 : t->tm_ns = nanosecs * (1000000000u / ns_div);
2966 0 : else if (nanosecs < 1000u)
2967 0 : t->tm_ns = nanosecs * 1000000u;
2968 : else
2969 : ret = 0;
2970 : }
2971 :
2972 1778 : return (ret);
2973 : }
2974 :
2975 : static int
2976 0 : store_hour(const char *hour, const char *ampm, struct tds_time *t)
2977 : {
2978 0 : int ret = 1;
2979 : int hours;
2980 :
2981 0 : hours = atoi(hour);
2982 :
2983 0 : if (hours >= 0 && hours < 24) {
2984 0 : if (strcasecmp(ampm, "am") == 0) {
2985 0 : if (hours == 12)
2986 0 : hours = 0;
2987 :
2988 0 : t->tm_hour = hours;
2989 : }
2990 0 : if (strcasecmp(ampm, "pm") == 0) {
2991 0 : if (hours == 0)
2992 0 : ret = 0;
2993 0 : if (hours > 0 && hours < 12)
2994 0 : t->tm_hour = hours + 12;
2995 : else
2996 0 : t->tm_hour = hours;
2997 : }
2998 : }
2999 0 : return ret;
3000 : }
3001 :
3002 : /**
3003 : * Get same type but nullable
3004 : * @param srctype type requires
3005 : * @return nullable type
3006 : */
3007 : TDS_SERVER_TYPE
3008 86 : tds_get_null_type(TDS_SERVER_TYPE srctype)
3009 : {
3010 :
3011 86 : switch (srctype) {
3012 : case SYBCHAR:
3013 : return SYBVARCHAR;
3014 : break;
3015 32 : case SYBINT1:
3016 : case SYBSINT1:
3017 : case SYBUINT1:
3018 : case SYBINT2:
3019 : case SYBINT4:
3020 : case SYBINT8:
3021 : /* TODO sure ?? */
3022 : case SYBUINT2:
3023 : case SYBUINT4:
3024 : case SYBUINT8:
3025 32 : return SYBINTN;
3026 : break;
3027 0 : case SYBREAL:
3028 : case SYBFLT8:
3029 0 : return SYBFLTN;
3030 : break;
3031 0 : case SYBDATETIME:
3032 : case SYBDATETIME4:
3033 0 : return SYBDATETIMN;
3034 : break;
3035 4 : case SYBBIT:
3036 4 : return SYBBITN;
3037 : break;
3038 0 : case SYBMONEY:
3039 : case SYBMONEY4:
3040 0 : return SYBMONEYN;
3041 : break;
3042 0 : case SYBTIME:
3043 0 : return SYBTIMEN;
3044 : break;
3045 0 : case SYBDATE:
3046 0 : return SYBDATEN;
3047 : break;
3048 : default:
3049 : break;
3050 : }
3051 30 : return srctype;
3052 : }
3053 :
3054 : static void
3055 : two_digit(char *out, int num)
3056 : {
3057 562 : if (num < 1)
3058 : num = 1;
3059 562 : if (num > 31)
3060 : num = 31;
3061 592 : out[0] = num < 10 ? ' ' : num/10 + '0';
3062 592 : out[1] = num%10 + '0';
3063 : }
3064 :
3065 : /**
3066 : * format a date string according to an "extended" strftime(3) formatting definition.
3067 : * @param buf output buffer
3068 : * @param maxsize size of buffer in bytes (space include terminator)
3069 : * @param format format string passed to strftime(3), except that %z represents fraction of seconds.
3070 : * @param dr date to convert
3071 : * @param prec second fraction precision (0-7).
3072 : * @return length of string returned, 0 for error
3073 : */
3074 : size_t
3075 2056 : tds_strftime(char *buf, size_t maxsize, const char *format, const TDSDATEREC * dr, int prec)
3076 : {
3077 : struct tm tm;
3078 :
3079 : size_t length;
3080 : char *our_format;
3081 : char *pz;
3082 2056 : bool z_found = false;
3083 :
3084 2056 : assert(buf);
3085 2056 : assert(format);
3086 2056 : assert(dr);
3087 2056 : assert(0 <= dr->decimicrosecond && dr->decimicrosecond < 10000000);
3088 2056 : if (prec < 0 || prec > 7)
3089 0 : prec = 3;
3090 :
3091 2056 : tm.tm_sec = dr->second;
3092 2056 : tm.tm_min = dr->minute;
3093 2056 : tm.tm_hour = dr->hour;
3094 2056 : tm.tm_mday = dr->day;
3095 2056 : tm.tm_mon = dr->month;
3096 2056 : tm.tm_year = dr->year - 1900;
3097 2056 : tm.tm_wday = dr->weekday;
3098 2056 : tm.tm_yday = dr->dayofyear;
3099 2056 : tm.tm_isdst = 0;
3100 : #ifdef HAVE_STRUCT_TM_TM_ZONE
3101 2056 : tm.tm_zone = NULL;
3102 : #elif defined(HAVE_STRUCT_TM___TM_ZONE)
3103 : tm.__tm_zone = NULL;
3104 : #endif
3105 :
3106 : /* more characters are required because we replace %z with up to 7 digits */
3107 2056 : our_format = tds_new(char, strlen(format) + 1 + 5 + 1);
3108 2056 : if (!our_format)
3109 : return 0;
3110 :
3111 2056 : strcpy(our_format, format);
3112 :
3113 25062 : for (pz = our_format; *pz; ) {
3114 20950 : if (*pz++ != '%')
3115 9090 : continue;
3116 :
3117 11860 : switch (*pz) {
3118 10 : case 0:
3119 10 : *pz++ = '%';
3120 10 : *pz = 0;
3121 10 : continue;
3122 : case '%':
3123 : /* escaped, do not treat as format on next iteration */
3124 : break;
3125 562 : case 'e':
3126 : /* not portable: day of month, single digit preceded by a blank */
3127 : /* not supported on old Windows versions */
3128 562 : two_digit(pz-1, dr->day);
3129 : break;
3130 30 : case 'l':
3131 : /* not portable: 12-hour, single digit preceded by a blank */
3132 : /* not supported on: SCO Unix, AIX, HP-UX, Windows
3133 : * supported on: *BSD, MacOS, Linux, Solaris */
3134 30 : two_digit(pz-1, (dr->hour + 11u) % 12u + 1);
3135 : break;
3136 1424 : case 'z':
3137 : /*
3138 : * Look for "%z" in the format string. If found, replace it with dr->milliseconds.
3139 : * For example, if milliseconds is 124, the format string
3140 : * "%b %d %Y %H:%M:%S.%z" would become
3141 : * "%b %d %Y %H:%M:%S.124".
3142 : */
3143 1424 : if (z_found)
3144 : break;
3145 1424 : z_found = true;
3146 :
3147 1424 : --pz;
3148 2700 : if (prec || pz <= our_format || pz[-1] != '.') {
3149 : char buf[12];
3150 1276 : sprintf(buf, "%07d", dr->decimicrosecond);
3151 1276 : memcpy(pz, buf, prec);
3152 1276 : strcpy(pz + prec, format + (pz - our_format) + 2);
3153 1276 : pz += prec;
3154 : } else {
3155 148 : strcpy(pz - 1, format + (pz - our_format) + 2);
3156 148 : pz--;
3157 : }
3158 1424 : continue;
3159 : }
3160 10426 : ++pz;
3161 : }
3162 :
3163 2056 : length = strftime(buf, maxsize, our_format, &tm);
3164 :
3165 2056 : free(our_format);
3166 :
3167 2056 : return length;
3168 : }
3169 :
3170 : #if 0
3171 : static TDS_UINT
3172 : utf16len(const utf16_t * s)
3173 : {
3174 : const utf16_t *p = s;
3175 :
3176 : while (*p++)
3177 : continue;
3178 : return p - s;
3179 : }
3180 : #endif
3181 :
3182 : #include "tds_willconvert.h"
3183 :
3184 : /**
3185 : * Test if a conversion is possible
3186 : * @param srctype source type
3187 : * @param desttype destination type
3188 : * @return 0 if not convertible
3189 : */
3190 : unsigned char
3191 1613254 : tds_willconvert(int srctype, int desttype)
3192 : {
3193 : TDS_TINYINT cat_from, cat_to;
3194 : TDS_UINT yn;
3195 :
3196 1613254 : tdsdump_log(TDS_DBG_FUNC, "tds_willconvert(%d, %d)\n", srctype, desttype);
3197 :
3198 : /* they must be from 0 to 255 */
3199 1613254 : if (((srctype|desttype) & ~0xff) != 0)
3200 : return 0;
3201 :
3202 1613254 : cat_from = type2category[srctype];
3203 1613254 : cat_to = type2category[desttype];
3204 1613254 : yn = category_conversion[cat_from];
3205 :
3206 1613254 : yn = (yn >> cat_to) & 1;
3207 :
3208 1613254 : tdsdump_log(TDS_DBG_FUNC, "tds_willconvert(%d, %d) returns %s\n",
3209 : srctype, desttype, yn? "yes":"no");
3210 1613254 : return yn;
3211 : }
3212 :
3213 : #if 0
3214 : select day(d) as day, datepart(dw, d) as weekday, datepart(week, d) as week, d as 'date' from #t order by d
3215 : day weekday week date
3216 : ----------- ----------- ----------- ----------
3217 : 1 5 1 2009-01-01 Thursday
3218 : 2 6 1 2009-01-02 Friday
3219 : 3 7 1 2009-01-03 Saturday
3220 : 4 1 2 2009-01-04 Sunday
3221 : 5 2 2 2009-01-05
3222 : 6 3 2 2009-01-06
3223 : 7 4 2 2009-01-07
3224 : 8 5 2 2009-01-08
3225 : 9 6 2 2009-01-09
3226 : 10 7 2 2009-01-10
3227 : 11 1 3 2009-01-11
3228 : 12 2 3 2009-01-12
3229 : 13 3 3 2009-01-13
3230 : 14 4 3 2009-01-14
3231 : 15 5 3 2009-01-15
3232 : 16 6 3 2009-01-16
3233 : 17 7 3 2009-01-17
3234 : 18 1 4 2009-01-18
3235 : 19 2 4 2009-01-19
3236 : 20 3 4 2009-01-20
3237 : 21 4 4 2009-01-21
3238 : 22 5 4 2009-01-22
3239 : 23 6 4 2009-01-23
3240 : 24 7 4 2009-01-24
3241 : 25 1 5 2009-01-25
3242 : 26 2 5 2009-01-26
3243 : 27 3 5 2009-01-27
3244 : 28 4 5 2009-01-28
3245 : 29 5 5 2009-01-29
3246 : 30 6 5 2009-01-30
3247 : 31 7 5 2009-01-31
3248 : #endif
3249 : /**
3250 : * Convert from db date format to a structured date format
3251 : * @param datetype source date type. SYBDATETIME or SYBDATETIME4
3252 : * @param di source date
3253 : * @param dr destination date
3254 : * @return TDS_FAIL or TDS_SUCCESS
3255 : */
3256 : TDSRET
3257 4836 : tds_datecrack(TDS_INT datetype, const void *di, TDSDATEREC * dr)
3258 : {
3259 : int dt_days;
3260 : unsigned int dt_time;
3261 :
3262 4836 : int years, months, days, ydays, wday, hours, mins, secs, dms, tzone = 0;
3263 : int l, n, i, j;
3264 :
3265 4836 : memset(dr, 0, sizeof(*dr));
3266 :
3267 4836 : if (datetype == SYBMSDATE || datetype == SYBMSTIME
3268 4836 : || datetype == SYBMSDATETIME2 || datetype == SYBMSDATETIMEOFFSET) {
3269 3642 : const TDS_DATETIMEALL *dta = (const TDS_DATETIMEALL *) di;
3270 3642 : dt_days = (datetype == SYBMSTIME) ? 0 : dta->date;
3271 3642 : if (datetype == SYBMSDATE) {
3272 : dms = 0;
3273 : secs = 0;
3274 : dt_time = 0;
3275 : } else {
3276 3410 : dms = dta->time % 10000000u;
3277 3410 : dt_time = (unsigned int) (dta->time / 10000000u);
3278 3410 : secs = dt_time % 60;
3279 3410 : dt_time = dt_time / 60;
3280 : }
3281 3642 : if (datetype == SYBMSDATETIMEOFFSET) {
3282 126 : --dt_days;
3283 126 : dt_time = dt_time + 1440 + dta->offset;
3284 126 : dt_days += dt_time / 1440;
3285 126 : dt_time %= 1440;
3286 126 : tzone = dta->offset;
3287 : }
3288 1194 : } else if (datetype == SYBDATETIME) {
3289 808 : const TDS_DATETIME *dt = (const TDS_DATETIME *) di;
3290 808 : dt_time = dt->dttime;
3291 808 : dms = ((dt_time % 300) * 1000 + 150) / 300 * 10000u;
3292 808 : dt_time = dt_time / 300;
3293 808 : secs = dt_time % 60;
3294 808 : dt_time = dt_time / 60;
3295 808 : dt_days = dt->dtdays;
3296 386 : } else if (datetype == SYBDATETIME4) {
3297 140 : const TDS_DATETIME4 *dt4 = (const TDS_DATETIME4 *) di;
3298 140 : secs = 0;
3299 140 : dms = 0;
3300 140 : dt_days = dt4->days;
3301 140 : dt_time = dt4->minutes;
3302 246 : } else if (datetype == SYBDATE) {
3303 92 : dt_days = *((const TDS_DATE *) di);
3304 92 : dms = 0;
3305 92 : secs = 0;
3306 92 : dt_time = 0;
3307 154 : } else if (datetype == SYBTIME) {
3308 94 : dt_time = *((const TDS_TIME *) di);
3309 94 : dms = ((dt_time % 300) * 1000 + 150) / 300 * 10000u;
3310 94 : dt_time = dt_time / 300;
3311 94 : secs = dt_time % 60;
3312 94 : dt_time = dt_time / 60;
3313 94 : dt_days = 0;
3314 60 : } else if (datetype == SYB5BIGTIME) {
3315 30 : TDS_UINT8 bigtime = *((const TDS_BIGTIME *) di);
3316 30 : dt_days = 0;
3317 30 : dms = bigtime % 1000000u * 10u;
3318 30 : dt_time = (bigtime / 1000000u) % 86400u;
3319 30 : secs = dt_time % 60;
3320 30 : dt_time = dt_time / 60u;
3321 30 : } else if (datetype == SYB5BIGDATETIME) {
3322 30 : TDS_UINT8 bigdatetime = *((const TDS_BIGDATETIME*) di);
3323 30 : dms = bigdatetime % 1000000u * 10u;
3324 30 : bigdatetime /= 1000000u;
3325 30 : secs = bigdatetime % 60u;
3326 30 : bigdatetime /= 60u;
3327 30 : dt_time = bigdatetime % (24u*60u);
3328 30 : dt_days = bigdatetime / (24u*60u) - BIGDATETIME_BIAS;
3329 : } else {
3330 : return TDS_FAIL;
3331 : }
3332 :
3333 : /*
3334 : * -53690 is minimun (1753-1-1) (Gregorian calendar start in 1732)
3335 : * 2958463 is maximun (9999-12-31)
3336 : */
3337 4836 : l = dt_days + (146038 + 146097*4);
3338 4836 : wday = (l + 4) % 7;
3339 4836 : n = (4 * l) / 146097; /* n century */
3340 4836 : l = l - (146097 * n + 3) / 4; /* days from xx00-02-28 (y-m-d) */
3341 4836 : i = (4000 * (l + 1)) / 1461001; /* years from xx00-02-28 */
3342 4836 : l = l - (1461 * i) / 4; /* year days from xx00-02-28 */
3343 4836 : ydays = l >= 306 ? l - 305 : l + 60;
3344 4836 : l += 31;
3345 4836 : j = (80 * l) / 2447;
3346 4836 : days = l - (2447 * j) / 80;
3347 4836 : l = j / 11;
3348 4836 : months = j + 1 - 12 * l;
3349 4836 : years = 100 * (n - 1) + i + l;
3350 4836 : if (l == 0 && (years & 3) == 0 && (years % 100 != 0 || years % 400 == 0))
3351 550 : ++ydays;
3352 :
3353 4836 : hours = dt_time / 60;
3354 4836 : mins = dt_time % 60;
3355 :
3356 4836 : dr->year = years;
3357 4836 : dr->month = months;
3358 4836 : dr->quarter = months / 3;
3359 4836 : dr->day = days;
3360 4836 : dr->dayofyear = ydays;
3361 4836 : dr->weekday = wday;
3362 4836 : dr->hour = hours;
3363 4836 : dr->minute = mins;
3364 4836 : dr->second = secs;
3365 4836 : dr->decimicrosecond = dms;
3366 4836 : dr->timezone = tzone;
3367 4836 : return TDS_SUCCESS;
3368 : }
3369 :
3370 : /**
3371 : * \brief convert a number in string to TDS_INT
3372 : *
3373 : * \return TDS_CONVERT_* or failure code on error
3374 : * \remarks Sybase's char->int conversion tolerates embedded blanks,
3375 : * such that "convert( int, ' - 13 ' )" works.
3376 : * If we find blanks, we copy the string to a temporary buffer,
3377 : * skipping the blanks.
3378 : * We return the results of atoi() with a clean string.
3379 : *
3380 : * n.b. it is possible to embed all sorts of non-printable characters, but we
3381 : * only check for spaces. at this time, no one on the project has tested anything else.
3382 : */
3383 : static TDS_INT
3384 602530 : string_to_int(const char *buf, const char *pend, TDS_INT * res)
3385 : {
3386 : bool negative;
3387 : unsigned int num; /* we use unsigned here for best overflow check */
3388 : size_t digits, decimals;
3389 :
3390 602530 : buf = parse_numeric(buf, pend, &negative, &digits, &decimals);
3391 602530 : if (!buf)
3392 : return TDS_CONVERT_SYNTAX;
3393 :
3394 : num = 0;
3395 3766804 : for (; digits; --digits, ++buf) {
3396 : /* add a digit to number and check for overflow */
3397 : /* NOTE I didn't forget a digit, I check overflow before multiply to prevent overflow */
3398 3988134 : if (num > 214748364u)
3399 : return TDS_CONVERT_OVERFLOW;
3400 3766804 : num = num * 10u + (*buf - '0');
3401 : }
3402 :
3403 : /* check for overflow and convert unsigned to signed */
3404 380650 : if (negative) {
3405 173226 : if (num > 2147483648u)
3406 : return TDS_CONVERT_OVERFLOW;
3407 171036 : *res = 0 - num;
3408 : } else {
3409 207424 : if (num >= 2147483648u)
3410 : return TDS_CONVERT_OVERFLOW;
3411 203794 : *res = num;
3412 : }
3413 :
3414 : return sizeof(TDS_INT);
3415 : }
3416 :
3417 : /**
3418 : * \brief convert a number in string to TDS_INT8
3419 : *
3420 : * \return TDS_CONVERT_* or failure code on error
3421 : */
3422 : static TDS_INT /* copied from string_ti_int and modified */
3423 476230 : parse_int8(const char *buf, const char *pend, TDS_UINT8 * res, bool * p_negative)
3424 : {
3425 : TDS_UINT8 num;
3426 : size_t digits, decimals;
3427 :
3428 476230 : buf = parse_numeric(buf, pend, p_negative, &digits, &decimals);
3429 476230 : if (!buf)
3430 : return TDS_CONVERT_SYNTAX;
3431 :
3432 : num = 0;
3433 4363020 : for (; digits; --digits, ++buf) {
3434 : /* add a digit to number and check for overflow */
3435 4375000 : TDS_UINT8 prev = num;
3436 4375000 : if (num > (UINT64_C(1) << 63) / 5u)
3437 : return TDS_CONVERT_OVERFLOW;
3438 4367560 : num = num * 10u + (*buf - '0');
3439 4367560 : if (num < prev)
3440 : return TDS_CONVERT_OVERFLOW;
3441 : }
3442 :
3443 463880 : *res = num;
3444 463880 : return sizeof(TDS_INT8);
3445 : }
3446 :
3447 : /**
3448 : * \brief convert a number in string to TDS_INT8
3449 : *
3450 : * \return TDS_CONVERT_* or failure code on error
3451 : */
3452 : static TDS_INT /* copied from string_ti_int and modified */
3453 374650 : string_to_int8(const char *buf, const char *pend, TDS_INT8 * res)
3454 : {
3455 : TDS_UINT8 num;
3456 : TDS_INT parse_res;
3457 : bool negative;
3458 :
3459 374650 : parse_res = parse_int8(buf, pend, &num, &negative);
3460 374650 : if (parse_res < 0)
3461 : return parse_res;
3462 :
3463 : /* check for overflow and convert unsigned to signed */
3464 366420 : if (negative) {
3465 168400 : if (num > UINT64_C(1) << 63)
3466 : return TDS_CONVERT_OVERFLOW;
3467 157150 : *res = 0 - num;
3468 : } else {
3469 198020 : if (num >= UINT64_C(1) << 63)
3470 : return TDS_CONVERT_OVERFLOW;
3471 185320 : *res = num;
3472 : }
3473 : return sizeof(TDS_INT8);
3474 : }
3475 :
3476 : /**
3477 : * \brief convert a number in string to TDS_UINT8
3478 : *
3479 : * \return TDS_CONVERT_* or failure code on error
3480 : */
3481 : static TDS_INT /* copied from string_to_int8 and modified */
3482 101580 : string_to_uint8(const char *buf, const char *pend, TDS_UINT8 * res)
3483 : {
3484 : TDS_UINT8 num;
3485 : TDS_INT parse_res;
3486 : bool negative;
3487 :
3488 101580 : parse_res = parse_int8(buf, pend, &num, &negative);
3489 101580 : if (parse_res < 0)
3490 : return parse_res;
3491 :
3492 : /* check for overflow */
3493 97460 : if (negative && num)
3494 : return TDS_CONVERT_OVERFLOW;
3495 :
3496 52460 : *res = num;
3497 52460 : return sizeof(TDS_UINT8);
3498 : }
3499 :
3500 : /**
3501 : * Parse a string for numbers.
3502 : *
3503 : * Syntax can be something like " *[+-] *[0-9]*\.[0-9]* *".
3504 : *
3505 : * The function ignore all spaces. It strips leading zeroes which could
3506 : * possibly lead to overflow.
3507 : * The function returns a pointer to the integer part followed by *p_digits
3508 : * digits followed by a dot followed by *p_decimals digits (dot and
3509 : * fractional digits are optional, in this case *p_decimals is 0).
3510 : *
3511 : * @param buf start of string
3512 : * @param pend pointer to string end
3513 : * @param p_negative store if number is negative
3514 : * @param p_digits store number of integer digits
3515 : * @param p_decimals store number of fractional digits
3516 : * @return pointer to first not zero digit. If NULL this indicate a syntax
3517 : * error.
3518 : */
3519 : static const char *
3520 1399110 : parse_numeric(const char *buf, const char *pend, bool *p_negative, size_t *p_digits, size_t *p_decimals)
3521 : {
3522 : enum { blank = ' ' };
3523 : #define SKIP_IF(cond) while (p != pend && (cond)) ++p;
3524 : const char *p, *start;
3525 1399110 : bool negative = false;
3526 :
3527 1399110 : *p_decimals = 0;
3528 1399110 : p = buf;
3529 :
3530 : /* ignore leading spaces */
3531 1399110 : SKIP_IF(*p == blank);
3532 1399110 : if (p == pend) {
3533 700 : *p_negative = false;
3534 700 : *p_digits = 0;
3535 700 : return p;
3536 : }
3537 :
3538 : /* check for sign */
3539 1398410 : switch (*p) {
3540 644176 : case '-':
3541 644176 : negative = true;
3542 : /* fall thru */
3543 644346 : case '+':
3544 : /* skip spaces between sign and number */
3545 644346 : ++p;
3546 644346 : SKIP_IF(*p == blank);
3547 : break;
3548 : }
3549 1398410 : *p_negative = negative;
3550 :
3551 : /* a digit must be present */
3552 1398410 : if (p == pend)
3553 : return NULL;
3554 :
3555 : /*
3556 : * skip leading zeroes
3557 : * Not skipping them cause numbers like "000000000000" to
3558 : * appear like overflow
3559 : */
3560 10880 : SKIP_IF(*p == '0');
3561 :
3562 : start = p;
3563 12173534 : SKIP_IF(TDS_ISDIGIT(*p));
3564 1398250 : *p_digits = p - start;
3565 :
3566 : /* parse decimal part */
3567 1398250 : if (p != pend && *p == '.') {
3568 3860 : const char *decimals_start = ++p;
3569 3860 : SKIP_IF(TDS_ISDIGIT(*p));
3570 3860 : *p_decimals = p - decimals_start;
3571 : }
3572 :
3573 : /* check for trailing spaces */
3574 586 : SKIP_IF(*p == blank);
3575 1398250 : if (p != pend)
3576 : return NULL;
3577 :
3578 1397450 : return start;
3579 : }
3580 :
3581 : static TDS_INT
3582 189250 : string_to_float(const TDS_CHAR * src, TDS_UINT srclen, int desttype, CONV_RESULT * cr)
3583 : {
3584 : char tmpstr[128];
3585 : char *end;
3586 : double res;
3587 :
3588 : /* ignore leading spaces */
3589 378500 : while (srclen > 0 && src[0] == ' ')
3590 0 : ++src, --srclen;
3591 :
3592 : /* ignore trailing blanks and nulls */
3593 189250 : while (srclen > 0 && (src[srclen - 1] == ' ' || src[srclen - 1] == '\0'))
3594 : --srclen;
3595 :
3596 189250 : if (srclen >= sizeof(tmpstr))
3597 : return TDS_CONVERT_OVERFLOW;
3598 :
3599 189250 : memcpy(tmpstr, src, srclen);
3600 189250 : tmpstr[srclen] = 0;
3601 :
3602 189250 : errno = 0;
3603 189250 : res = strtod(tmpstr, &end);
3604 189250 : if (errno == ERANGE)
3605 : return TDS_CONVERT_OVERFLOW;
3606 189250 : if (end != tmpstr + srclen)
3607 : return TDS_CONVERT_SYNTAX;
3608 :
3609 189250 : if (desttype == SYBREAL) {
3610 : /* FIXME check overflows */
3611 94620 : cr->r = (TDS_REAL)res;
3612 94620 : return sizeof(TDS_REAL);
3613 : }
3614 94630 : cr->f = res;
3615 94630 : return sizeof(TDS_FLOAT);
3616 : }
3617 :
3618 : /** @} */
|
