LCOV - code coverage report
Current view: top level - src/tds - convert.c (source / functions) Hit Total Coverage
Test: FreeTDS coverage Lines: 1475 1578 93.5 %
Date: 2025-07-05 12:09:11 Functions: 47 48 97.9 %

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

Generated by: LCOV version 1.13