开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
cs.c
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：15k
源码类别：

生物技术

开发平台：

C/C++

cs.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: cs.c,v $
  4.  * PRODUCTION Revision 1000.1  2003/11/17 22:20:08  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [ORIGINAL] Dev-tree R1.2
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* FreeTDS - Library of routines accessing Sybase and Microsoft databases
  11.  * Copyright (C) 1998-1999  Brian Bruns
  12.  *
  13.  * This library is free software; you can redistribute it and/or
  14.  * modify it under the terms of the GNU Library General Public
  15.  * License as published by the Free Software Foundation; either
  16.  * version 2 of the License, or (at your option) any later version.
  17.  *
  18.  * This library is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21.  * Library General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU Library General Public
  24.  * License along with this library; if not, write to the
  25.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  26.  * Boston, MA 02111-1307, USA.
  27.  */
  29. #include <tds_config.h>
  30. #include <cspublic.h>
  31. #include <tdsconvert.h>
  32. #include <time.h>
  34. static char  software_version[]   = "$Id: cs.c,v 1000.1 2003/11/17 22:20:08 gouriano Exp $";
  35. static void *no_unused_var_warn[] = {software_version,
  36.                                      no_unused_var_warn};
  39. CS_RETCODE cs_ctx_alloc(CS_INT version, CS_CONTEXT **ctx)
  40. {
  41. TDSCONTEXT *tds_ctx;
  43. *ctx = (CS_CONTEXT *) malloc(sizeof(CS_CONTEXT));
  44. memset(*ctx,'',sizeof(CS_CONTEXT));
  45. tds_ctx = tds_alloc_context();
  46. tds_ctx_set_parent(tds_ctx, *ctx);
  47. (*ctx)->tds_ctx = tds_ctx;
  48. if( tds_ctx->locale && !tds_ctx->locale->date_fmt ) {
  49. /* set default in case there's no locale file */
  50. tds_ctx->locale->date_fmt = strdup("%b %e %Y %l:%M%p"); 
  51. }
  52. return CS_SUCCEED;
  53. }
  54. CS_RETCODE cs_ctx_drop(CS_CONTEXT *ctx)
  55. {
  56. if (ctx) {
  57. if (ctx->tds_ctx) 
  58. tds_free_context(ctx->tds_ctx);
  59. free(ctx);
  60. }
  61. return CS_SUCCEED;
  62. }
  63. CS_RETCODE cs_config(CS_CONTEXT *ctx, CS_INT action, CS_INT property, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
  64. {
  65. return CS_SUCCEED;
  66. }
  68. CS_RETCODE cs_convert(CS_CONTEXT *ctx, CS_DATAFMT *srcfmt, CS_VOID *srcdata, 
  69.                       CS_DATAFMT *destfmt, CS_VOID *destdata, CS_INT *resultlen)
  70. {
  72. int src_type, src_len, desttype, destlen, len, i = 0;
  74. CONV_RESULT cres;
  76. unsigned char *dest;
  78. CS_RETCODE ret;
  80.     tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert()n");
  82.     src_type = _ct_get_server_type(srcfmt->datatype);
  83.     src_len  =  srcfmt ? srcfmt->maxlength : 0;
  84.     desttype = _ct_get_server_type(destfmt->datatype);
  85.     destlen  =  destfmt ? destfmt->maxlength : 0;
  87.     tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() srctype = %d (%d) desttype = %d (%d)n",
  88.                 src_type, src_len, desttype, destlen);
  90.     if (destlen <= 0)
  91.        return CS_SUCCEED;
  93.     dest = (unsigned char *)destdata;
  95.     /* If source is indicated to be NULL, set dest to low values */
  97.     if (srcdata == NULL) {
  99.        tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() srcdata is nulln");
  100.        memset(dest,'', destlen);
  101.        if (resultlen != (CS_INT *)NULL ) *resultlen = 0;
  102.        return CS_SUCCEED;
  104.     }
  105.        
  106.     /* many times we are asked to convert a data type to itself */
  108.     if (src_type == desttype) {
  110.        tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() srctype = desttypen");
  111.        switch (desttype) {
  113.           case SYBBINARY:
  114.           case SYBIMAGE:
  115.                if (src_len > destlen) {
  116.                   ret = CS_FAIL;
  117.                }
  118.                else {
  119.                   switch (destfmt->format) {
  120.                       case CS_FMT_PADNULL:
  121.                           memcpy(dest, srcdata, src_len);
  122.                           for ( i = src_len; i < destlen; i++)
  123.                               dest[i] = '';
  124.                           if (resultlen != (CS_INT *)NULL ) *resultlen = destlen;
  125.                           ret = CS_SUCCEED;
  126.                           break;
  127.                       case CS_FMT_UNUSED:
  128.                           memcpy(dest, srcdata, src_len);
  129.                           if (resultlen != (CS_INT *)NULL ) *resultlen = src_len;
  130.                           ret = CS_SUCCEED;
  131.                           break;
  132.                       default:
  133.                           ret = CS_FAIL;
  134.                           break;
  135.                           
  136.                   }
  137.                }
  138.                break;
  139.           case SYBCHAR:
  140.           case SYBVARCHAR:
  141.           case SYBTEXT:
  142.                tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() desttype = charactern");
  143.                if (src_len > destlen ) {
  144.                   ret = CS_FAIL;
  145.                }
  146.                else {
  147.                   switch (destfmt->format) {
  148.       
  149.                       case CS_FMT_NULLTERM:
  150.                           if (src_len == destlen ) { 
  151.                              ret = CS_FAIL;    /* not enough room for data + a null terminator - error */
  152.                           }
  153.                           else {
  154.                              memcpy(dest, srcdata, src_len);
  155.                              dest[src_len] = '';
  156.                              if (resultlen != (CS_INT *)NULL ) *resultlen = src_len+1;
  157.                              ret = CS_SUCCEED;
  158.                           }
  159.                           break;
  160.                              
  161.                       case CS_FMT_PADBLANK:
  162.                           memcpy(dest, srcdata, src_len);
  163.                           for ( i = src_len; i < destlen; i++)
  164.                               dest[i] = ' ';
  165.                           if (resultlen != (CS_INT *)NULL ) *resultlen = destlen;
  166.                           ret = CS_SUCCEED;
  167.                           break;
  169.                       case CS_FMT_PADNULL:
  170.                           memcpy(dest, srcdata, src_len);
  171.                           for ( i = src_len; i < destlen; i++)
  172.                               dest[i] = '';
  173.                           if (resultlen != (CS_INT *)NULL ) *resultlen = destlen;
  174.                           ret = CS_SUCCEED;
  175.                           break;
  176.                       case CS_FMT_UNUSED:
  177.                           memcpy(dest, srcdata, src_len);
  178.                           if (resultlen != (CS_INT *)NULL ) *resultlen = src_len;
  179.                           ret = CS_SUCCEED;
  180.                           break;
  181.                       default:
  182.                           ret = CS_FAIL;
  183.                           break;
  184.                   }
  185.                }
  186.                break;
  187.           case SYBINT1:
  188.           case SYBINT2:
  189.           case SYBINT4:
  190.           case SYBFLT8:
  191.           case SYBREAL:
  192.           case SYBBIT:
  193.           case SYBBITN:
  194.           case SYBMONEY:
  195.           case SYBMONEY4:
  196.           case SYBDATETIME:
  197.           case SYBDATETIME4:
  198.                if (src_len > destlen) {
  199.                   ret = CS_FAIL;
  200.                }
  201.                else {
  202.                   memcpy (dest, srcdata, src_len);
  203.                   if (resultlen != (CS_INT *)NULL ) *resultlen = src_len;
  204.                   ret = CS_SUCCEED;
  205.                } 
  206.                break;
  208.           case SYBNUMERIC:
  209.           case SYBDECIMAL:
  210.                if (src_len > destlen ) {
  211.                   ret = CS_FAIL;
  212.                }
  213.                else {
  214.                   memcpy (dest, srcdata, src_len);
  215.                   if (resultlen != (CS_INT *)NULL ) *resultlen = src_len;
  216.                   ret = CS_SUCCEED;
  217.                } 
  218.                break;
  219.  
  220.           default:
  221.                ret = CS_FAIL;
  222.                break;
  223.        }
  224.       
  225.        return ret;
  227.     }  /* src type == dest type */
  230. /* set the output precision/scale for conversions to numeric type */
  231. if (is_numeric_type(desttype)) {
  232. cres.n.precision = destfmt->precision;
  233. cres.n.scale     = destfmt->scale;
  234. if (destfmt->precision == CS_SRC_VALUE)
  235. cres.n.precision = srcfmt->precision;
  236. if (destfmt->scale == CS_SRC_VALUE)
  237. cres.n.scale = srcfmt->scale;
  238. }
  239.     
  240.     tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() calling tds_convertn");
  241.     len = tds_convert(ctx->tds_ctx, src_type, srcdata, src_len, desttype, &cres);
  243.     if (len == TDS_FAIL)
  244.        return CS_FAIL;
  245.     tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() tds_convert returned %dn", len);
  247.     switch (desttype) {
  248.         case SYBBINARY:
  249.         case SYBIMAGE:
  251.              if (len > destlen) {
  252.                 free(cres.ib);
  253.                 fprintf(stderr,"error_handler: Data-conversion resulted in overflow.n");
  254.                 ret = CS_FAIL;
  255.              }
  256.              else {
  257.                 memcpy(dest, cres.ib, len);
  258.                 free(cres.ib);
  259.                 for ( i = len ; i < destlen; i++ )
  260.                     dest[i] = '';
  261.                 if (resultlen != (CS_INT *)NULL ) *resultlen = destlen;
  262.                 ret = CS_SUCCEED;
  263.              }
  264.              break;
  265.         case SYBBIT:
  266.         case SYBBITN:
  267.      /* fall trough, act same way of TINYINT */
  268.         case SYBINT1:
  269.              memcpy(dest,&(cres.ti),1);
  270.              if (resultlen != (CS_INT *)NULL ) *resultlen = 1;
  271.              ret = CS_SUCCEED;
  272.              break;
  273.         case SYBINT2:
  274.              memcpy(dest,&(cres.si),2);
  275.              if (resultlen != (CS_INT *)NULL ) *resultlen = 2;
  276.              ret = CS_SUCCEED;
  277.              break;
  278.         case SYBINT4:
  279.              memcpy(dest,&(cres.i),4);
  280.              if (resultlen != (CS_INT *)NULL ) *resultlen = 4;
  281.              ret = CS_SUCCEED;
  282.              break;
  283.         case SYBFLT8:
  284.              memcpy(dest,&(cres.f),8);
  285.              if (resultlen != (CS_INT *)NULL ) *resultlen = 8;
  286.              ret = CS_SUCCEED;
  287.              break;
  288.         case SYBREAL:
  289.              memcpy(dest,&(cres.r),4);
  290.              if (resultlen != (CS_INT *)NULL ) *resultlen = 4;
  291.              ret = CS_SUCCEED;
  292.              break;
  293.         case SYBMONEY:
  294.              
  295.              tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() copying %d bytes to srcn", sizeof(TDS_MONEY));
  296.              memcpy(dest,&(cres.m),sizeof(TDS_MONEY));
  297.              if (resultlen != (CS_INT *)NULL ) *resultlen = sizeof(TDS_MONEY);
  298.              ret = CS_SUCCEED;
  299.              break;
  300.         case SYBMONEY4:
  301.              memcpy(dest,&(cres.m4),sizeof(TDS_MONEY4));
  302.              if (resultlen != (CS_INT *)NULL ) *resultlen = sizeof(TDS_MONEY4);
  303.              ret = CS_SUCCEED;
  304.              break;
  305.         case SYBDATETIME:
  306.              memcpy(dest,&(cres.dt),sizeof(TDS_DATETIME));
  307.              if (resultlen != (CS_INT *)NULL ) *resultlen = sizeof(TDS_DATETIME);
  308.              ret = CS_SUCCEED;
  309.              break;
  310.         case SYBDATETIME4:
  311.              memcpy(dest,&(cres.dt4),sizeof(TDS_DATETIME4));
  312.              if (resultlen != (CS_INT *)NULL ) *resultlen = sizeof(TDS_DATETIME4);
  313.              ret = CS_SUCCEED;
  314.              break;
  315.         case SYBNUMERIC:
  316.         case SYBDECIMAL:
  317.              memcpy(dest,&(cres.n), sizeof(TDS_NUMERIC));
  318.              if (resultlen != (CS_INT *)NULL ) *resultlen = sizeof(TDS_NUMERIC);
  319.              ret = CS_SUCCEED;
  320.              break;
  321.         case SYBCHAR:
  322.         case SYBVARCHAR:
  323.         case SYBTEXT:
  324.              if (len > destlen) {
  325.                 fprintf(stderr,"error_handler: Data-conversion resulted in overflow.n");
  326.                 ret = CS_FAIL;
  327.              }
  328.              else {
  329.                 switch (destfmt->format) {
  330.     
  331.                     case CS_FMT_NULLTERM:
  332.                         tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() FMT_NULLTERMn");
  333.                         if (len == destlen ) { 
  334.                            tdsdump_log(TDS_DBG_FUNC, "%L not enough room for data + a null terminator - errorn");
  335.                            ret = CS_FAIL;    /* not enough room for data + a null terminator - error */
  336.                         }
  337.                         else {
  338.                            memcpy(dest, cres.c, len);
  339.    dest[len] = 0;
  340.                            if (resultlen != (CS_INT *)NULL ) *resultlen = len+1;
  341.                            ret = CS_SUCCEED;
  342.                         }
  343.                         break;
  344.                            
  345.                     case CS_FMT_PADBLANK:
  346.                         tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() FMT_PADBLANKn");
  347. /* strcpy here can lead to a small buffer overflow */
  348.                         memcpy(dest, cres.c, len);
  349.                         for ( i = len; i < destlen; i++)
  350.                             dest[i] = ' ';
  351.                         if (resultlen != (CS_INT *)NULL ) *resultlen = destlen;
  352.                         ret = CS_SUCCEED;
  353.                         break;
  355.                     case CS_FMT_PADNULL:
  356.                         tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() FMT_PADNULLn");
  357. /* strcpy here can lead to a small buffer overflow */
  358.                         memcpy(dest, cres.c, len);
  359.                         for ( i = len; i < destlen; i++)
  360.                             dest[i] = '';
  361.                         if (resultlen != (CS_INT *)NULL ) *resultlen = destlen;
  362.                         ret = CS_SUCCEED;
  363.                         break;
  364.                     case CS_FMT_UNUSED:
  365.                         tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() FMT_UNUSEDn");
  366.                         memcpy(dest, cres.c, len);
  367.                         if (resultlen != (CS_INT *)NULL ) *resultlen = len;
  368.                         ret = CS_SUCCEED;
  369.                         break;
  370.                     default:
  371.                         ret = CS_FAIL;
  372.                         break;
  373.                 }
  374.              }
  375.              free(cres.c);
  376.              break;
  377.     }
  378.     tdsdump_log(TDS_DBG_FUNC, "%L inside cs_convert() returning  %dn", ret);
  379.     return (ret);
  380. }
  381. CS_RETCODE cs_dt_crack(CS_CONTEXT *ctx, CS_INT datetype, CS_VOID *dateval, CS_DATEREC *daterec)
  382. {
  383. CS_DATETIME *dt;
  384. CS_DATETIME4 *dt4;
  385. time_t tmp_secs_from_epoch;
  386. struct tm *t;
  387. TDSDATEREC dr;
  389. if (datetype == CS_DATETIME_TYPE) {
  390. dt = (TDS_DATETIME *)dateval;
  391. tds_datecrack(SYBDATETIME, dt, &dr);
  392. } else if (datetype == CS_DATETIME4_TYPE) {
  393. dt4 = (TDS_DATETIME4 *)dateval;
  394. tds_datecrack(SYBDATETIME4, dt4, &dr);
  395. } else {
  396. return CS_FAIL;
  397. }
  398.     t = (struct tm *) gmtime(&tmp_secs_from_epoch);
  399. daterec->dateyear   = dr.year;
  400. daterec->datemonth  = dr.month;
  401. daterec->datedmonth = dr.day;
  402. daterec->datedyear  = dr.dayofyear;
  403. daterec->datedweek  = dr.weekday;
  404. daterec->datehour   = dr.hour;
  405. daterec->dateminute = dr.minute;
  406. daterec->datesecond = dr.second;
  407. daterec->datetzone   = 0; 
  409. return CS_SUCCEED;
  410. }
  411. CS_RETCODE cs_loc_alloc(CS_CONTEXT *ctx, CS_LOCALE **locptr)
  412. { 
  413. return CS_SUCCEED;
  414. }
  415. CS_RETCODE cs_loc_drop(CS_CONTEXT *ctx, CS_LOCALE *locale)
  416. { 
  417. return CS_SUCCEED;
  418. }
  419. CS_RETCODE cs_locale(CS_CONTEXT *ctx, CS_INT action, CS_LOCALE *locale, CS_INT type, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
  420. { 
  421. return CS_SUCCEED;
  422. }
  423. CS_RETCODE cs_dt_info(CS_CONTEXT *ctx, CS_INT action, CS_LOCALE *locale, CS_INT type, CS_INT item, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
  424. {
  425. if (action==CS_SET) {
  426. switch(type) {
  427. case CS_DT_CONVFMT:
  428. break;
  429. }
  430. }
  431. return CS_SUCCEED;
  432. }