.ad 8
.bm 8
.fm 4
.bt $Copyright (c) 2000-2005 SAP AG$$Page %$
.tm 12
.hm 6
.hs 3
.tt 1 $SQL$Project Distributed Database System$VPA04FC$
.tt 2 $$$
.TT 3 $BurkhardD$CONVERSION FROM DATABASE$2001-05-10$
***********************************************************
.nf

.nf

.nf

    ========== licence begin  GPL
    Copyright (c) 2000-2005 SAP AG

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    ========== licence end
.fo


.fo


.fo
Module  :
=========
.sp
Purpose :
.CM *-END-* purpose -------------------------------------
Define  :
#ifndef DEBUG
#line 21 "vpa04fc" 
#endif
.CM *-END-* define --------------------------------------
Use     :
.CM *-END-* use -----------------------------------------
Synonym :
.CM *-END-* synonym -------------------------------------
.sp;.cp 3
Author  : BurkhardD
.sp
.cp 3
Created : 08-31-1993
.sp
.cp 3
Version : 1994-04-25
.sp
.cp 3
Release :  7.3    Date : 2001-05-10
.sp
Release :  7.3    Date : 2001-05-10
Specification:
.CM *-END-* specification -------------------------------
.sp 2
***********************************************************
.sp
.cp 10
.fo
.oc _/1
Description:
.CM *-END-* description ---------------------------------
.sp 2
***********************************************************
.sp
.cp 10
.nf
.oc _/1
Structure:
.CM *-END-* structure -----------------------------------
.sp 2
**********************************************************
.sp
.cp 10
.nf
.CM -lll-
Code    :
#ifndef DEBUG
#line 67 "vpa04fc" 
#endif
#include <stdlib.h>

#include "vpa00global.h"
#include "hpa05num.h"
#include "hsp78_0.h"

/* Prototypes */
#ifdef VSP40
void FAR PCALL s40gbyte (const char *, int, int, char*, int, int, char*);
#else
void apfgbyte(char *buf, int pos, int len, char *dest, int dpos, int dlen, char *truncated);
#define s40gbyte apfgbyte
#endif

#define API_NUMERIC_DEFAULT_SCALE 0

/* pa04checkseprt() - get separator character and put in local_string */

API_RETCODE pa04checkseprt( UCHAR *in_str,
                            UDWORD in_len)
{
#define PA04OLDSEPRT	'.'
    static UCHAR pa04sep='\0';
    API_RETCODE	 api_retcode;
    UCHAR        buffer[API_CHAR_LENGTH_DECIMAL];
    UDWORD	     i;
    SDOUBLE	     dValue=12.9;

    API_TRACE(API_TR_ENTRY, "pa04checkseprt", 0);
    API_TRACE(API_TR_PTR, "in_str", &in_str);
    API_TRACE_BUF(in_str, 0, ((in_len > 40) ? 40 : in_len));
    API_TRACE(API_TR_UDWORD, "in_len", &in_len);
  
    api_retcode = API_OK;
  
    if (pa04sep == '\0') {
        /* API_SPRINTF which is mapped to wsprintf does not work here */
        sprintf( (char*) buffer, "%.2f", dValue);
        pa04sep=buffer[2];
    }
    for (i=0; i < in_len; i++) {
        if (in_str[i] == PA04OLDSEPRT) {
            in_str[i]=pa04sep;
            break;
        }		      
    }  
    API_TRACE(API_TR_EXIT,"pa04checkseprt",0);
    API_TRACE_BUF(in_str, 0, ((in_len > 40) ? 40 : in_len));
    API_TRACE(API_TR_UCHAR, "pa04sep", &pa04sep);
    API_TRACE(API_TR_UDWORD, "in_len", &in_len);
    API_TRACE(API_TR_API_RETCODE,"api_retcode",&api_retcode);

    return(api_retcode);
} /* pa04checkseprt */


/* apfbinary() - convert SQL to C: Binary */
API_RETCODE apfbinary( UCHAR  *in_ptr,
                       UDWORD  in_length,
                       UDWORD *moved_len_ptr,
                       SWORD   in_format,
                       UCHAR  *out_ptr,
                       UDWORD  out_length,
                       SWORD   out_format,
                       UDWORD *used )

{
    API_RETCODE api_retcode;
    UDWORD len;
    UDWORD moved_len;
    SWORD trunc = 0;
    UCHAR FAR * ptr;
    UDWORD inlen;

    API_TRACE(API_TR_ENTRY, "apfbinary", 0);
    API_TRACE(API_TR_PTR, "in_ptr", &in_ptr);
    API_TRACE_BUF(in_ptr, 0, ((in_length > 40) ? 40 : in_length));
    API_TRACE(API_TR_UDWORD, "in_length", &in_length);
    API_TRACE(API_TR_UDWORD, "*moved_len_ptr", moved_len_ptr);
    moved_len = *moved_len_ptr;
    API_TRACE(API_TR_SWORD, "in_format", &in_format);
    API_TRACE(API_TR_PTR, "out_ptr", &out_ptr);
    API_TRACE(API_TR_UDWORD, "out_length", &out_length);
    API_TRACE(API_TR_SWORD, "out_format", &out_format);  

    api_retcode = API_OK;
   
    switch (out_format) {
    case (SQL_C_WCHAR): {
        ptr = in_ptr + moved_len;
        inlen = in_length - moved_len;
        if (out_length > 0) {
            len = inlen;
        }	    
        else {	    
            *used = inlen * 2 * sizeof(SQLWCHAR);
            api_retcode = API_TRUNCATE;
            len = 0;
        }	    
#define VPA04_BUF_LENGTH 1024
        if (len > 0) {
          tsp00_Uint4   destBytesWritten;        /* number of bytes written */
          tsp00_Uint4   srcBytesParsed;          /* number of bytes parsed */
          tsp00_Uint4   currDestLen = out_length;
          tsp00_Uint4   currDestPos = 0;
          tsp78ConversionResult rc;
          UCHAR buffer[VPA04_BUF_LENGTH * 2];
          UCHAR *outPtr = out_ptr;
          UDWORD currSourceLen = len;
          UDWORD currSourcePos = 1;

          *used = 0;
          while (len > 0) {
            currSourceLen = len > VPA04_BUF_LENGTH ? VPA04_BUF_LENGTH : len;
            len -= currSourceLen;

            s40gbyte ( (char*) ptr, currSourcePos, (int)currSourceLen,
                       (char*) buffer, 1, (int)VPA04_BUF_LENGTH * 2,
                       (char*) &trunc);
            currSourcePos += currSourceLen;
            /* http://pts:1080/webpts?wptsdetail=yes&ErrorType=0&ErrorID=1140302
               bin -> hex:  1 byte -> 2 characters */
            rc = sp78convertBuffer (sp77encodingUCS2Native,
                                    outPtr, currDestLen,
                                    &destBytesWritten,
                                    sp77encodingAscii, buffer,
                                    currSourceLen * 2,
                                    &srcBytesParsed);
            currDestLen -= destBytesWritten;
            currDestPos += destBytesWritten;
            outPtr += destBytesWritten;
            *used += destBytesWritten;

            if (rc == sp78_TargetExhausted) {
              API_TRACE(API_TR_SWORD, "trunc", &trunc);
              *used = len * 2 * sizeof (SQLWCHAR);
              api_retcode = API_TRUNCATE;
              break;
            }
          }

          *moved_len_ptr += currSourcePos;
          /* append always terminator */
          API_MEMCPY (outPtr,
                      sp77encodingUCS2Native->charTable->terminator.bytes,
                      sp77encodingUCS2Native->charTable->terminator.byteCount);
        } 
        else {
            if (moved_len > 0)
                api_retcode = API_NO_DATA_FOUND;
        }
        break;
    }
    case (SQL_C_CHAR): {
        ptr = in_ptr + moved_len;
        inlen = in_length - moved_len;
        if (out_length > 0) {
            len = inlen;
        }	    
        else {	    
            *used = inlen*2;
            api_retcode = API_TRUNCATE;
            len = 0;
        }	    
        if (len > 0) {
            s40gbyte ( (char*) ptr, 1, (int)len,
                       (char*) out_ptr, 1, (int)out_length, (char*) &trunc);
            API_TRACE(API_TR_SWORD, "trunc", &trunc);
            *used = len*2;
            if (trunc || *used >= out_length) {	       
                api_retcode = API_TRUNCATE;
                if (out_length > 0) {
                    len = out_length / 2;
                    len -= (out_length%2) ? 0 : 1;
                    *moved_len_ptr += len;
                    out_ptr[len*2] = 0;
                }
            }
            else {
                *moved_len_ptr += len;
                out_ptr[*used] = 0;
            }
        } 
        else {
            if (moved_len > 0)
                api_retcode = API_NO_DATA_FOUND;
        }
        break;
    }
    case (SQL_C_BINARY): {
        ptr = in_ptr + moved_len;
        inlen = in_length - moved_len;
        if (inlen > out_length) {
            len = out_length;
            api_retcode = API_TRUNCATE;
        }
        else 
            len = inlen;
        if (inlen > 0) {
            API_MEMCPY(out_ptr, ptr, (int)len);
            *used = inlen;
            *moved_len_ptr += len;
        }
        else {
            api_retcode = API_NO_DATA_FOUND;
        }
        break;
    }
    case (SQL_C_BIT): {}      /* PTS 1112777 */
    case (SQL_C_SHORT): {}
    case (SQL_C_SSHORT): {}
    case (SQL_C_USHORT): {}
    case (SQL_C_LONG): {}
    case (SQL_C_SLONG): {}
    case (SQL_C_ULONG): {}
    case (SQL_C_FLOAT): {}
    case (SQL_C_DOUBLE): {}
    case (SQL_C_TYPE_DATE): {}
    case (SQL_C_TYPE_TIME): {}
    case (SQL_C_TYPE_TIMESTAMP): {}
    case (SQL_C_DATE): {}
    case (SQL_C_TIME): {}
    case (SQL_C_TIMESTAMP): {}
    case (SQL_C_STINYINT): {}
    case (SQL_C_UTINYINT): {}
    case (SQL_C_TINYINT): {}
        /* these three are new in 3.0 */
    case (SQL_C_NUMERIC): {}
    case (SQL_C_SBIGINT): {}
    case (SQL_C_UBIGINT): {
        API_TRACE(API_TR_SWORD, "format not supported", &out_format);
        api_retcode = API_INVALID;
        break;
    }
    default: {	       
        api_retcode = API_NOT_OK;
        break;
    }
    }; /* switch */
    API_TRACE(API_TR_UDWORD,"*used", used);
    API_TRACE(API_TR_EXIT,"apfbinary",0);
    API_TRACE(API_TR_API_RETCODE,"api_retcode",&api_retcode);
    
    return(api_retcode);
} /* apfbinary */


/* apfnumeric() - convert SQL to C: Numeric */
API_RETCODE apfnumeric( UCHAR   *in_ptr,
                        UDWORD   in_length,
                        UWORD    in_scale,
                        UDWORD  *moved_len_ptr,
                        SWORD    in_format,
                        UCHAR   *out_ptr,
                        UDWORD   out_length,
                        SWORD    out_format,
                        UWORD    numericScale,
                        UDWORD  *used)
{
    API_RETCODE  api_retcode;
    SFLOAT       local_float;
    SDOUBLE      local_double;
    tsp00_Int4   local_int4;   /* Use this for SQL_INETEGER, not SDWORD which has
                                * 8 bytes on 64 bit platforms. PTS 1104429 */
    SDWORD       local_long;
    SWORD        local_short;
    SCHAR        local_char;
    UCHAR        local_string[API_CHAR_LENGTH_CHAR+1];

    API_TRACE(API_TR_ENTRY, "apfnumeric", 0);
    API_TRACE(API_TR_PTR, "in_ptr", &in_ptr);
    API_TRACE_BUF(in_ptr, 0, ((in_length > 40) ? 40 : in_length));
    API_TRACE(API_TR_UDWORD, "in_length", &in_length);
    API_TRACE(API_TR_UWORD, "in_scale", &in_scale);
    API_TRACE(API_TR_UDWORD, "*moved_len_ptr", moved_len_ptr);
    API_TRACE(API_TR_SWORD, "in_format", &in_format);
    API_TRACE(API_TR_PTR, "out_ptr", &out_ptr);
    API_TRACE(API_TR_UDWORD, "out_length", &out_length);
    API_TRACE(API_TR_SWORD, "out_format", &out_format);  
    API_TRACE(API_TR_PTR, "&used", &used);  

    if (*moved_len_ptr != 0) {
        api_retcode = API_NO_DATA_FOUND;
    }
    else {      
        api_retcode = API_OK;
        switch (in_format) {
        case (SQL_CHAR): {}
        case (SQL_UNICODE): {}
        case (SQL_VARCHAR): {}
        case (SQL_UNICODE_VARCHAR): {}
        case (SQL_LONGVARCHAR): {}
        case (SQL_UNICODE_LONGVARCHAR): {}
        case (SQL_BINARY): {}
        case (SQL_VARBINARY): {}
        case (SQL_LONGVARBINARY): {}
        case (SQL_DECIMAL): {}           
        case (SQL_NUMERIC): {
            SDWORD len;
            len = (in_length > sizeof(local_string)-1) ?
                sizeof(local_string)-1 : in_length;
            API_MEMCPY(local_string, in_ptr, (int)len);
            local_string[len] = 0;
            switch (out_format) {      /* INNER SWITCH */
            case (SQL_C_CHAR): {
                api_retcode =
                    aptnm2ch( local_string,
                              in_format,
                              out_ptr,
                              out_length,
                              (UWORD)(((UDWORD)in_scale > out_length) ?
                                      out_length - 2 : in_scale),
                              SQL_VARCHAR,
                              used);
                break;
            }
            case (SQL_C_WCHAR): {
                api_retcode =
                    aptnm2chw( local_string,
                               in_format,
                               out_ptr,
                               out_length,
                               (UWORD)(((UDWORD)in_scale > out_length) ?
                                       out_length - 2 : in_scale),
                               SQL_VARCHAR,
                               used);
                break;
            }
            case (SQL_C_BINARY): {     
                *used = in_length;
                if (in_length > out_length)
                    api_retcode = API_DATA_LOSS;
                else {
                    API_MEMCPY(out_ptr, in_ptr, (int)*used);
                }
                break;
            }
            case (SQL_C_SSHORT): {}
            case (SQL_C_USHORT): {}
            case (SQL_C_SHORT): {
                api_retcode = aptchsl( in_ptr, out_format);
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    local_short = (SWORD) atoi( (char*) local_string);
                    *used = sizeof(SWORD);
                    API_MEMCPY( out_ptr, (UCHAR*) &local_short, (int)*used);
                }
                break;
            }
            case (SQL_C_SLONG): {}
            case (SQL_C_ULONG): {}
            case (SQL_C_LONG): {
                api_retcode = aptchsl( local_string, out_format);
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    local_long = atol( (char*) local_string);
                    *used = sizeof(SDWORD);
                    API_MEMCPY(out_ptr, (UCHAR FAR *) &local_long, (int)*used);
                }
                break;
            }
            case (SQL_C_STINYINT): {}
            case (SQL_C_UTINYINT): {}
            case (SQL_C_TINYINT): {
                api_retcode = aptchsl(in_ptr, out_format);
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    local_char = (SCHAR) atoi( (char*) local_string);
                    *used = sizeof(SCHAR);
                    API_MEMCPY(out_ptr, (UCHAR*) &local_char, (int)*used);
                }
                break;
            }
            case (SQL_C_NUMERIC): { /* new in 3.0 */
                SQL_NUMERIC_STRUCT local_numeric;
                api_retcode = pa05String2Numeric( local_string,
                                                  numericScale,
                                                  &local_numeric );
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    *used = sizeof( SQL_NUMERIC_STRUCT );
                    API_MEMCPY( out_ptr, (UCHAR*) &local_numeric, (int)*used);
                }; /* if */
                break;
            }
#ifdef BIGINT_SUPPORTED
            case (SQL_C_SBIGINT): {} /* new in 3.0 */
            case (SQL_C_UBIGINT): { /* new in 3.0 */
                API_BIGINT local_bigint;
                api_retcode = aptchsl( in_ptr, out_format );
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    local_bigint = (API_BIGINT)
                        API_ATOI64( (char*) (local_string) );
                    *used = sizeof(API_BIGINT);
                    API_MEMCPY( out_ptr, (UCHAR*) &local_bigint,
                                (int)*used);
                }
                break;
            }
#endif /* BIGINT_SUPPORTED */
            case (SQL_C_FLOAT): {
                api_retcode = aptchfd(local_string, out_format);
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    if (api_retcode == API_TRUNCATE)
                        api_retcode = API_OK;
                    /* check separator */
#ifndef WIN		     
                    pa04checkseprt(local_string, in_length);
#elif WIN32
                    pa04checkseprt(local_string, in_length);
#endif
                    local_float = (SFLOAT) atof( (char*) local_string );
                    *used = sizeof(SFLOAT);
                    API_MEMCPY(out_ptr, (UCHAR*) &local_float, (int)*used);
                }
                break;
            }
            case (SQL_C_DOUBLE): {
                api_retcode = aptchfd(local_string, out_format);
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    if (api_retcode == API_TRUNCATE)
                        api_retcode = API_OK;
                    /* check separator */
#ifndef WIN		     
                    pa04checkseprt(local_string, in_length);
#elif WIN32
                    pa04checkseprt(local_string, in_length);
#endif
                    local_double = atof((char*) local_string);
                    *used = sizeof(SDOUBLE);
                    API_MEMCPY( out_ptr, (UCHAR*) &local_double, (int)*used);
                }
                break;
            }
            case (SQL_C_TYPE_DATE): {}
            case (SQL_C_TYPE_TIME): {}
            case (SQL_C_TYPE_TIMESTAMP): {}
            case (SQL_C_DATE): {}
            case (SQL_C_TIME): {}
            case (SQL_C_TIMESTAMP): {
                api_retcode = API_INVALID;
                break;
            }
            default : {
                api_retcode = API_NOT_OK;
            }
            } /* INNER SWITCH */
            break;
        }
        case (SQL_SMALLINT): {                   /* ODBC book, pg 480 */
            API_MEMCPY((UCHAR*) &local_short, in_ptr, sizeof(SWORD));
            switch (out_format) {               /* INNER SWITCH      */
            case (SQL_C_CHAR): {
                API_SPRINTF( (char*) local_string,
                             (char*) PRINT_SHORT, local_short );
                api_retcode = aptnm2ch( local_string,
                                        in_format,
                                        out_ptr,
                                        out_length,
                                        API_REAL_PREC,
                                        SQL_VARCHAR,
                                        used);
                break;
            }
            case (SQL_C_WCHAR): {
                API_SPRINTF( (char*) local_string,
                             (char*) PRINT_SHORT, local_short );
                api_retcode = aptnm2chw (local_string,
                                         in_format,
                                         out_ptr,
                                         out_length,
                                         API_REAL_PREC,
                                         SQL_VARCHAR,
                                         used);
                break;
            }
            case (SQL_C_BINARY): {     
                *used = sizeof(SWORD);
                if (sizeof(SWORD) > out_length)
                    api_retcode = API_DATA_LOSS;
                else {
                    API_MEMCPY(out_ptr, in_ptr, (int)*used);
                }
                break;
            }
            case (SQL_C_USHORT): {
                if (local_short<0) {
                    api_retcode = API_DATA_LOSS;
                    break;
                }; /* if */
            }
            case (SQL_C_SSHORT): {}
            case (SQL_C_SHORT): {
                *used = sizeof(SWORD);
                API_MEMCPY( out_ptr, (UCHAR*)  &local_short, (int)*used);
                break;
            }
            case (SQL_C_ULONG): {
                /* should we check this?
                if (local_short<0) {
                    api_retcode = API_DATA_LOSS;
                    break;
                };
                */
            }
            case (SQL_C_SLONG): {}
            case (SQL_C_LONG): {
                local_long = (SDWORD) local_short;
                *used = sizeof(SDWORD);
                API_MEMCPY( out_ptr, (UCHAR*) &local_long, (int)*used);
                break;
            }
            case (SQL_C_UTINYINT): {
                /* should we check this?
                if (local_short<0) {
                    api_retcode = API_DATA_LOSS;
                    break;
                };
                */
            }
            case (SQL_C_STINYINT): {}
            case (SQL_C_TINYINT): {
                API_SPRINTF( (char*) local_string, PRINT_SHORT, local_short);
                api_retcode = aptchsl(local_string, out_format);
                if (api_retcode == API_OK) {
                    local_char = (SCHAR) local_short;
                    API_MEMCPY( out_ptr,
                                (UCHAR*) &local_char,
                                sizeof(SCHAR));
                }
                *used = sizeof(SCHAR);
                break;
            }
            case (SQL_C_NUMERIC): { /* new in 3.0 */
                SQL_NUMERIC_STRUCT local_numeric;

                API_MEMSET( &local_numeric, 0, sizeof( local_numeric ));
                if (local_short<0) {
                    local_numeric.sign = NUMERIC_NEGATIVE_SIGN;
                    local_short = -local_short;
                } else {
                    local_numeric.sign = NUMERIC_POSITIVE_SIGN;
                }; /* else */
                API_MEMCPY( &local_numeric.val,
                            &local_short,
                            sizeof( local_short ));
                local_numeric.precision = 5;
                local_numeric.scale = API_NUMERIC_DEFAULT_SCALE;
                API_MEMCPY( out_ptr,
                            (UCHAR*) &local_numeric,
                            sizeof( local_numeric ));
                break;
            }
#ifdef BIGINT_SUPPORTED
            case (SQL_C_SBIGINT): {} /* new in 3.0 */
            case (SQL_C_UBIGINT): { /* new in 3.0 */
                API_BIGINT local_bigint;

                API_SPRINTF( (char*) local_string,
                             (char*) PRINT_SHORT, local_short );
                api_retcode = aptchsl( local_string, out_format );
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    local_bigint = (API_BIGINT) local_short;
                    API_MEMCPY( out_ptr,
                                (UCHAR*) &local_bigint,
                                sizeof( local_bigint ));
                    *used = sizeof( local_bigint );
                };
                break;
            }
#endif /* BIGINT_SUPPORTED */            
            case (SQL_C_BIT): {
                if (local_short)
                    local_char = TRUE;
                else
                    local_char = FALSE;
                *used = sizeof(SCHAR);
                API_MEMCPY(out_ptr, (UCHAR*) &local_char, (int)*used);
            }
            case (SQL_C_FLOAT): {
                local_float = (SFLOAT) local_short;
                *used = sizeof(SFLOAT);
                API_MEMCPY(out_ptr, (UCHAR*) &local_float, (int)*used);
                break;
            }
            case (SQL_C_DOUBLE): {
                local_double = (SDOUBLE) local_short;
                *used = sizeof(SDOUBLE);
                API_MEMCPY(out_ptr, (UCHAR*) &local_double, (int)*used);
                break;
            }
            case (SQL_C_TYPE_DATE): {}
            case (SQL_C_TYPE_TIME): {}
            case (SQL_C_TYPE_TIMESTAMP): {}
            case (SQL_C_DATE): {}
            case (SQL_C_TIME): {}
            case (SQL_C_TIMESTAMP): {
                api_retcode = API_INVALID;
                break;
            }
            default: {
                API_TRACE(API_TR_SWORD, "format not supported", &out_format);
                api_retcode = API_NOT_OK;
                break;
            }
            }  /* inner switch */
            break;
        }    
        case (SQL_INTEGER): {                    /* ODBC book, pg 480 */
            API_MEMCPY((UCHAR*) &local_int4, in_ptr, sizeof(local_int4));
            local_long = (SDWORD) local_int4;
            API_SPRINTF( (char*) local_string, (char*) PRINT_LONG, local_long);
            switch (out_format) {              
            case (SQL_C_CHAR): {
                api_retcode = aptnm2ch( local_string,
                                        in_format,
                                        out_ptr,
                                        out_length,
                                        API_REAL_PREC,
                                        SQL_VARCHAR,
                                        used);
                break;
            }
            case (SQL_C_WCHAR): {
                api_retcode = aptnm2chw (local_string,
                                         in_format,
                                         out_ptr,
                                         out_length,
                                         API_REAL_PREC,
                                         SQL_VARCHAR,
                                         used);
                break;
            }
            case (SQL_C_BINARY): {     
                *used = sizeof(local_int4);
                if (sizeof(local_int4) > out_length)
                    api_retcode = API_DATA_LOSS;
                else {
                    API_MEMCPY( out_ptr, in_ptr, (int)*used);
                }
                break;
            }
            case (SQL_C_SSHORT): {}
            case (SQL_C_USHORT): {}
            case (SQL_C_SHORT): {
                api_retcode = aptchsl(local_string, out_format);
                *used = sizeof(SWORD);
                if (api_retcode == API_OK) {
                    local_short = (SWORD) local_long;
                    API_MEMCPY( out_ptr, (UCHAR*) &local_short, (int) *used);
                }
            }
            break;
            case (SQL_C_SLONG): {}
            case (SQL_C_ULONG): {}
            case (SQL_C_LONG): {
                API_MEMCPY( out_ptr, &local_long, sizeof(SDWORD));
                *used = sizeof(SDWORD);
                break;
            }
            case (SQL_C_STINYINT): {}
            case (SQL_C_UTINYINT): {}
            case (SQL_C_TINYINT): {
                api_retcode = aptchsl(local_string, out_format);
                *used = sizeof(SCHAR);
                if (api_retcode == API_OK) {
                    local_char = (SCHAR) local_long;
                    API_MEMCPY(out_ptr, (UCHAR FAR *) &local_char, (int)*used);
                }
                break;
            }
            case (SQL_C_NUMERIC): { /* new in 3.0 */
                SQL_NUMERIC_STRUCT local_numeric;

                API_MEMSET( &local_numeric, 0, sizeof( local_numeric ));
                if (local_long<0) {
                    local_numeric.sign = NUMERIC_NEGATIVE_SIGN;
                    local_long = -local_long;
                } else {
                    local_numeric.sign = NUMERIC_POSITIVE_SIGN;
                }; /* else */
                API_MEMCPY( &local_numeric.val,
                            &local_long,
                            sizeof( local_long ));
                local_numeric.precision = 10;
                local_numeric.scale = API_NUMERIC_DEFAULT_SCALE;
                API_MEMCPY( out_ptr,
                            (UCHAR*) &local_numeric,
                            sizeof( local_numeric ));
                break;
            }
#ifdef BIGINT_SUPPORTED
            case (SQL_C_SBIGINT): { } /* new in 3.0 */
            case (SQL_C_UBIGINT): {   /* new in 3.0 */
                API_BIGINT local_bigint;

                API_SPRINTF( (char*) local_string,
                             (char*) PRINT_LONG, local_int4 );
                api_retcode = aptchsl( local_string, out_format );
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    local_bigint = (API_BIGINT) local_long;
                    API_MEMCPY( out_ptr,
                                (UCHAR*) &local_bigint,
                                sizeof( local_bigint ));
                    *used = sizeof( local_bigint );
                };
                break;
            }
#endif /* BIGINT_SUPPORTED */
            case (SQL_C_BIT): {
                if (local_long)
                    local_char = TRUE;
                else
                    local_char = FALSE;
                *used = sizeof(SCHAR);
                API_MEMCPY(out_ptr, (UCHAR FAR *) &local_char, (int)*used);		  
            }
            case (SQL_C_FLOAT): {       /* convert to a string to   */
                /* get number of digits     */
                api_retcode = aptchfd(local_string, out_format);
                *used = sizeof(SFLOAT);
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    if (api_retcode == API_TRUNCATE)
                        api_retcode = API_OK;
                    local_float = (SFLOAT) local_long;
                    API_MEMCPY(out_ptr, (UCHAR*) &local_float, (int)*used);
                }
                break;
            }
            case (SQL_C_DOUBLE): {      /* conversion without any    */
                *used = sizeof(SDOUBLE);
                api_retcode = aptchfd( local_string, out_format);
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    if (api_retcode == API_TRUNCATE)
                        api_retcode = API_OK;
                    local_double = (SDOUBLE) local_long;
                    API_MEMCPY( out_ptr,
                                (UCHAR*) &local_double,
                                (int)*used);
                }
                break;
            }
            case (SQL_C_TYPE_DATE): {}
            case (SQL_C_TYPE_TIME): {}
            case (SQL_C_TYPE_TIMESTAMP): {}
            case (SQL_C_DATE): {}
            case (SQL_C_TIME): {}
            case (SQL_C_TIMESTAMP): {
                api_retcode = API_INVALID;
                break;
            }
            default: {
                API_TRACE(API_TR_SWORD, "format not supported", &out_format);
                api_retcode = API_NOT_OK;
                break;
            }
            } /* inner switch */
            break;
        }   
        case (SQL_REAL): {                        /* ODBC book, pg 480 */
            API_MEMCPY( (UCHAR*) &local_float, in_ptr, sizeof(SFLOAT));
            API_TRACE( API_TR_SFLOAT, "float", &local_float);
            pa08flt(local_string, (SDOUBLE) local_float, in_format);
            switch (out_format) {                /* INNER SWITCH      */
            case (SQL_C_CHAR): {
                api_retcode = aptnm2ch( local_string,
                                        in_format,
                                        out_ptr,
                                        out_length,
                                        (UWORD) out_length, /* PTS 1121561 */
                                        SQL_VARCHAR,
                                        used);
                break;
            }
            case (SQL_C_WCHAR): {
                api_retcode = aptnm2chw (local_string,
                                         in_format,
                                         out_ptr,
                                         out_length,
                                         (UWORD) out_length, /* API_REAL_PREC,*/
                                         SQL_VARCHAR,
                                         used);
                break;
            }
            case (SQL_C_BINARY): {     
                *used = sizeof(SFLOAT);
                if (sizeof(SFLOAT) > out_length)
                    api_retcode = API_DATA_LOSS;
                else {
                    API_MEMCPY(out_ptr, in_ptr, (int)*used);
                }
                break;
            }
            case (SQL_C_SSHORT): {}
            case (SQL_C_USHORT): {}
            case (SQL_C_SHORT):{                /* check value       */
                *used = sizeof(SWORD);
                api_retcode = aptchsl(local_string, out_format);
                switch(api_retcode) {
                case API_TRUNCATE: {
                    local_short = (SWORD) atoi( (char*) local_string);
                    API_MEMCPY(out_ptr, (UCHAR*) &local_short, (int)*used);
                    break;
                }
                case API_OK: {
                  /* PTS ?? */
                  if (out_format == SQL_C_USHORT) {
                    UWORD local_ushort = (UWORD) local_float;
                    API_MEMCPY(out_ptr, (UCHAR*) &local_ushort, (int)*used);
                  } else {
                    local_short = (SWORD) local_float;
                    API_MEMCPY(out_ptr, (UCHAR*) &local_short, (int)*used);
                  }
                  break;
                }
                }
                break;
            }
            case (SQL_C_SLONG): {}
            case (SQL_C_ULONG): {}
            case (SQL_C_LONG): {         
                *used = sizeof(SDWORD);
                api_retcode = aptchsl(local_string, out_format);
                switch(api_retcode) {
                case API_TRUNCATE: {
                    local_long = atol( (char*) local_string);
                    API_MEMCPY(out_ptr, (UCHAR FAR *) &local_long, (int)*used);
                    break;
                }
                case API_OK: {
                    local_long = (SDWORD) local_float;
                    API_MEMCPY(out_ptr, (UCHAR FAR *) &local_long, (int)*used);
                    break;
                }
                }
                break;
            }
            case (SQL_C_STINYINT): {}
            case (SQL_C_UTINYINT): {}
            case (SQL_C_TINYINT): {         
                *used = sizeof(SCHAR);
                api_retcode = aptchsl(local_string, out_format);
                switch(api_retcode) {
                case API_TRUNCATE: {
                    local_char = (SCHAR) atoi((char*) local_string);
                    API_MEMCPY(out_ptr, (UCHAR FAR *) &local_char, (int)*used);
                    break;
                }
                case API_OK: {
                    local_char = (SCHAR) local_float;
                    API_MEMCPY(out_ptr, (UCHAR FAR *) &local_char, (int)*used);
                    break;
                }
                }
                break;
            }
            case (SQL_C_NUMERIC): { /* new in 3.0 */
                SQL_NUMERIC_STRUCT local_numeric;

                api_retcode = pa05Double2Numeric( (SDOUBLE) local_float,
                                                  &local_numeric );
                if ( api_retcode == API_TRUNCATE || api_retcode == API_OK ) {
                    *used = sizeof( local_numeric );
                    /*local_numeric.precision = API_SQL_FLOAT_PRECISION;*/
                    API_MEMCPY( out_ptr, (UCHAR*) &local_numeric, (int)*used);
                }; /* if */
                break;
            }
#ifdef BIGINT_SUPPORTED
            case (SQL_C_SBIGINT): {} /* new in 3.0 */
            case (SQL_C_UBIGINT): { /* new in 3.0 */
                API_BIGINT local_bigint;

                api_retcode = aptchsl( local_string, out_format);
                switch(api_retcode) {
                case API_TRUNCATE: {
                    *used = sizeof( local_bigint );
                    local_bigint = API_ATOI64((char*) (local_string));
                    API_MEMCPY(out_ptr, (UCHAR*) &local_bigint, (int)*used);
                    break;
                }
                case API_OK: {
                    *used = sizeof( local_bigint );
                    local_bigint = (API_BIGINT) local_float;
                    API_MEMCPY(out_ptr, (UCHAR*) &local_bigint, (int)*used);
                    break;
                }
                }; /* switch */
                break;
            }
#endif /* BIGINT_SUPPORTED */
            case (SQL_C_BIT): {
                if (local_float)
                    local_char = TRUE;
                else
                    local_char = FALSE;
                *used = sizeof(SCHAR);
                API_MEMCPY(out_ptr, (UCHAR FAR *) &local_char, (int)*used);    
            }
            case (SQL_C_FLOAT): {
                *used = sizeof(SFLOAT);
                API_MEMCPY(out_ptr, in_ptr, (int)*used);
                break;
            }
            case (SQL_C_DOUBLE): {
                *used = sizeof(SDOUBLE);
                local_double = (SDOUBLE) local_float;
                API_MEMCPY(out_ptr, (UCHAR FAR *) &local_double, (int)*used);
                break;
            }
            case (SQL_C_TYPE_DATE): {}
            case (SQL_C_TYPE_TIME): {}
            case (SQL_C_TYPE_TIMESTAMP): {}
            case (SQL_C_DATE): {}
            case (SQL_C_TIME): {}
            case (SQL_C_TIMESTAMP): {
                api_retcode = API_INVALID;
                break;
            }
            default: {
                API_TRACE(API_TR_SWORD, "format not supported", &out_format);
                api_retcode = API_NOT_OK;
                break;
            }
            } /* inner switch */
        }   /* inner definition area */
        break;

        case (SQL_FLOAT): {}                        /* ODBC book ,pg 480 */
        case (SQL_DOUBLE): {
            API_MEMCPY((UCHAR FAR *) &local_double, in_ptr, sizeof(SDOUBLE));
            API_TRACE(API_TR_SDOUBLE, "double", &local_double);
            pa08flt(local_string, local_double, in_format);
            switch (out_format) {                /* INNER SWITCH     */
            case (SQL_C_CHAR): {
                api_retcode = aptnm2ch( local_string,
                                        in_format,
                                        out_ptr,
                                        out_length,
                                        (UWORD) out_length, /* PTS 1121561 */
                                        SQL_VARCHAR,
                                        used);
                break;
            }
            case (SQL_C_WCHAR): {
                api_retcode = aptnm2chw (local_string,
                                         in_format,
                                         out_ptr,
                                         out_length,
                                         (UWORD) out_length, /* PTS 1121561 */
                                         SQL_VARCHAR,
                                         used);
                break;
            }
            case (SQL_C_BINARY): {     
                *used = sizeof(SDOUBLE);
                if (sizeof(SDOUBLE) > out_length)
                    api_retcode = API_DATA_LOSS;
                else {
                    API_MEMCPY(out_ptr, in_ptr, (int)*used);
                }
                break;
            }
            case (SQL_C_SSHORT): {}
            case (SQL_C_USHORT): {}
            case (SQL_C_SHORT): {               /* check value       */
                *used = sizeof(SWORD);
                api_retcode = aptchsl(local_string, out_format);
                switch(api_retcode) {
                case API_TRUNCATE: {
                    local_short = (SWORD) atoi( (char*) local_string);
                    API_MEMCPY(out_ptr, (UCHAR*)  &local_short, (int)*used);
                    break;
                }
                case API_OK: {
                  /* PTS ?? */
                  if (out_format == SQL_C_USHORT) {
                    UWORD local_ushort = (UWORD) local_double;
                    API_MEMCPY(out_ptr, (UCHAR*) &local_ushort, (int)*used);
                  } else {
                    local_short = (SWORD) local_double;
                    API_MEMCPY(out_ptr, (UCHAR*) &local_short, (int)*used);
                  }
                  break;
                }
                }
                break;
            }
            case (SQL_C_SLONG): {}
            case (SQL_C_ULONG): {}
            case (SQL_C_LONG): {    
                *used = sizeof(SDWORD);
                api_retcode = aptchsl(local_string, out_format);
                switch(api_retcode) {
                case API_TRUNCATE: {
                    local_long = atol((char*) local_string );
                    API_MEMCPY(out_ptr, (UCHAR FAR *) &local_long, (int)*used);
                    break;
                }
                case API_OK: {
                    local_long = (SDWORD) local_double;
                    API_MEMCPY(out_ptr, (UCHAR FAR *) &local_long, (int)*used);
                    break;
                }
                }
                break;
            }
            case (SQL_C_STINYINT): {}
            case (SQL_C_UTINYINT): {}
            case (SQL_C_TINYINT): {    
                *used = sizeof(SCHAR);
                api_retcode = aptchsl(local_string, out_format);
                switch(api_retcode) {
                case API_TRUNCATE: {
                    local_char = (SCHAR) atoi((char*) local_string);
                    API_MEMCPY(out_ptr, (UCHAR FAR *) &local_char, (int)*used);
                    break;
                }
                case API_OK: {
                    local_char = (SCHAR) local_double;
                    API_MEMCPY(out_ptr, (UCHAR FAR *) &local_char, (int)*used);
                    break;
                }
                }
                break;
            }
            case (SQL_C_NUMERIC): { /* new in 3.0 */
                SQL_NUMERIC_STRUCT local_numeric;

                api_retcode = pa05Double2Numeric( local_double,
                                                  &local_numeric );
                if ( api_retcode == API_TRUNCATE || api_retcode == API_OK ) {
                    *used = sizeof( local_numeric );
                    /*local_numeric.precision = 16;*/
                    API_MEMCPY( out_ptr, (UCHAR*) &local_numeric, (int)*used);
                }; /* if */
                break;
            }
#ifdef BIGINT_SUPPORTED
            case (SQL_C_SBIGINT): {} /* new in 3.0 */
            case (SQL_C_UBIGINT): { /* new in 3.0 */
                API_BIGINT local_bigint;
                *used = sizeof( API_BIGINT );
                api_retcode = aptchsl( local_string, out_format);
                switch(api_retcode) {
                case API_TRUNCATE: {
                    local_bigint = API_ATOI64( (char*) (local_string));
                    API_MEMCPY( out_ptr, (UCHAR*) &local_bigint, (int)*used);
                    break;
                }
                case API_OK: {
                    local_bigint = (API_BIGINT) local_double;
                    API_MEMCPY(out_ptr, (UCHAR*) &local_bigint, (int)*used);
                    break;
                }
                }; /* switch */
                break;
            }
#endif /* BIGINT_SUPPORTED */
            case (SQL_C_BIT): {
                if (local_double)
                    local_char = TRUE;
                else
                    local_char = FALSE;
                *used = sizeof(SCHAR);
                API_MEMCPY(out_ptr, (UCHAR FAR *) &local_char, (int)*used);    
            }
            case (SQL_C_FLOAT): {
                *used = sizeof(SFLOAT);
                api_retcode = aptchfd(local_string, out_format);
                switch(api_retcode) {
                case API_TRUNCATE: {
                    api_retcode = API_OK;
                    /* check separator */
#ifndef WIN       
                    pa04checkseprt(local_string, in_length);
#elif WIN32
                    pa04checkseprt(local_string, in_length);
#endif
                    local_float = (SFLOAT) atof( (char*) local_string);
                    API_MEMCPY(out_ptr, (UCHAR*) &local_float, (int)*used);
                    break;
                }
                case API_OK: {
                    local_float = (SFLOAT) local_double;
                    API_MEMCPY( out_ptr,
                                (UCHAR*) &local_float,
                                (int) *used);
                    break;
                }
                }
                break;
            }
            case (SQL_C_DOUBLE): {
                *used = sizeof(SDOUBLE);
                API_MEMCPY(out_ptr, in_ptr, (int)*used);
                break;
            }
            case (SQL_C_TYPE_DATE): {}
            case (SQL_C_TYPE_TIME): {}
            case (SQL_C_TYPE_TIMESTAMP): {}
            case (SQL_C_DATE): {}
            case (SQL_C_TIME): {}
            case (SQL_C_TIMESTAMP): {
                api_retcode = API_INVALID;
                break;
            }
            default: {
                api_retcode = API_INVALID;
                break;
            }
            }   /* inner switch */
            break;
        }      /* inner definition area */
        case (SQL_BIT): {                   
            API_MEMCPY((UCHAR FAR *) &local_char, in_ptr, sizeof(char));
            switch (out_format) {               /* INNER SWITCH      */
            case (SQL_C_CHAR): {
                API_SPRINTF( (char*) local_string, "%d", local_char);
                API_TRACE( API_TR_STRING, "local_string", local_string);
                api_retcode = aptnm2ch( local_string,
                                        in_format,
                                        out_ptr,
                                        out_length,
                                        API_REAL_PREC,
                                        SQL_VARCHAR,
                                        used);        
                break;
            }
            case (SQL_C_WCHAR): {
                 API_SPRINTF( (char*) local_string, "%d", local_char); 
                 API_TRACE( API_TR_STRING, "local_string", local_string); 
                api_retcode = aptnm2chw( local_string,
                                        in_format,
                                        out_ptr,
                                        out_length,
                                        API_REAL_PREC,
                                        SQL_VARCHAR,
                                        used);        
                break;
            }
            case (SQL_C_BINARY): {
                if (sizeof(char) > out_length) {
                    api_retcode = API_DATA_LOSS;
                    break;
                }
            }
            case (SQL_C_BIT): {}    
            case (SQL_C_STINYINT): {}
            case (SQL_C_UTINYINT): {}    
            case (SQL_C_TINYINT): {     
                *used = sizeof(char);
                API_MEMCPY(out_ptr, in_ptr, (int)*used);
                break;
            }
            case (SQL_C_SSHORT): {}
            case (SQL_C_USHORT): {}
            case (SQL_C_SHORT): {
              /* PTS ?? */
              if (out_format == SQL_C_USHORT) {
                UWORD local_ushort = (UWORD) local_char;
                API_MEMCPY(out_ptr, (UCHAR*) &local_ushort, (int)*used);
              } else {
                local_short = (SWORD) local_char;
                *used = sizeof(SWORD);
                API_MEMCPY(out_ptr, (UCHAR*)  &local_short, (int)*used);
              }
              break;
            }
            case (SQL_C_SLONG): {}
            case (SQL_C_ULONG): {}
            case (SQL_C_LONG): {
                local_long = (SDWORD) local_char;
                *used = sizeof(SDWORD);
                API_MEMCPY(out_ptr, (UCHAR*) &local_long, (int)*used);
                break;
            }
            case (SQL_C_NUMERIC): { /* new in 3.0 */
                SQL_NUMERIC_STRUCT local_numeric;

                API_MEMSET( &local_numeric, 0, sizeof( local_numeric ));
                API_MEMCPY( &local_numeric.val,
                            &local_char,
                            sizeof( local_char ));
                local_numeric.precision = 1;
                local_numeric.scale = API_NUMERIC_DEFAULT_SCALE;
                *used = sizeof(SQL_NUMERIC_STRUCT);
                API_MEMCPY( out_ptr,
                            (UCHAR*) &local_numeric,
                            *used);
                break;
            }
#ifdef BIGINT_SUPPORTED
            case (SQL_C_SBIGINT): {} /* new in 3.0 */
            case (SQL_C_UBIGINT): { /* new in 3.0 */
                API_BIGINT local_bigint;
                
                local_bigint = (API_BIGINT) local_char;
                *used = sizeof(API_BIGINT);
                API_MEMCPY(out_ptr, (UCHAR*) &local_bigint, (int)*used);
                break;
            }
#endif /* BIGINT_SUPPORTED */
            case (SQL_C_FLOAT): {
                local_float = (SFLOAT) local_char;
                *used = sizeof(SFLOAT);
                API_MEMCPY(out_ptr, (UCHAR FAR *) &local_float, (int)*used);
                break;
            }
            case (SQL_C_DOUBLE): {
                local_double = (SDOUBLE) local_char;
                *used = sizeof(SDOUBLE);
                API_MEMCPY(out_ptr, (UCHAR*) &local_double, (int)*used);
                break;
            }
            case (SQL_C_TYPE_DATE): {}
            case (SQL_C_TYPE_TIME): {}
            case (SQL_C_TYPE_TIMESTAMP): {}
            case (SQL_C_DATE): {}
            case (SQL_C_TIME): {}
            case (SQL_C_TIMESTAMP): {
                api_retcode = API_INVALID;
                break;
            }
            default: {
                API_TRACE(API_TR_SWORD, "format not supported", &out_format);
                api_retcode = API_NOT_OK;
                break;
            }
            }  /* inner switch */
            break;
        }    
        case (SQL_TYPE_DATE): {}           /* ODBC book, pg 480 */
        case (SQL_TYPE_TIME): {}
        case (SQL_TYPE_TIMESTAMP): {}
        case (SQL_DATE): {}           /* ODBC book, pg 480 */
        case (SQL_TIME): {}
        case (SQL_TIMESTAMP): {
            api_retcode = API_INVALID;
            break;
        }
        default: {
            api_retcode = API_NOT_OK;
            break;
        }
        }
    }
    if (api_retcode == API_OK || api_retcode == API_TRUNCATE)
        *moved_len_ptr = *used;
    API_TRACE(API_TR_UDWORD,"*used", used);
    API_TRACE(API_TR_EXIT,"apfnumeric",0);
    API_TRACE(API_TR_API_RETCODE,"api_retcode",&api_retcode);

    return(api_retcode);
} /* apfnumeric */


/* apfchar() - convert SQL to C: Character */
API_RETCODE apfchar(UCHAR   *in_ptr,
                    UDWORD   in_length,
                    UDWORD  *moved_len_ptr,
                    SWORD    in_format,
                    UCHAR   *out_ptr,
                    UDWORD   out_length,
                    SWORD    out_format,
                    UWORD    numericScale,
                    UDWORD  *used)

{
    API_RETCODE api_retcode;
    UDWORD len;
    UDWORD moved_len;
    UCHAR destBuf[1024];

    API_TRACE(API_TR_ENTRY, "apfchar", 0);
    API_TRACE(API_TR_PTR, "in_ptr", &in_ptr);
    API_TRACE(API_TR_UDWORD, "in_length", &in_length);
    API_TRACE(API_TR_UDWORD, "*moved_len_ptr", moved_len_ptr);
    moved_len = *moved_len_ptr;
    API_TRACE(API_TR_SWORD, "in_format", &in_format);
    API_TRACE(API_TR_PTR, "out_ptr", &out_ptr);
    API_TRACE(API_TR_UDWORD, "out_length", &out_length);
    API_TRACE(API_TR_SWORD, "out_format", &out_format);  

    api_retcode = API_OK;

    /* convert UCS2 to ASCII, if numeric data, date, time or
       timestamp has to be converted */
    if (out_format != SQL_C_CHAR && out_format != SQL_C_WCHAR &&
        out_format != SQL_C_BIT  && out_format != SQL_C_BINARY)
      if (in_format == SQL_WVARCHAR || in_format == SQL_WLONGVARCHAR ) {
        tsp00_Uint4   destBytesWritten;
        tsp00_Uint4   srcBytesParsed;
        
        sp78convertString (sp77encodingAscii,
                           destBuf, (tsp00_Uint4) sizeof (destBuf),
                           &destBytesWritten,
                           TRUE,
                           sp77encodingUCS2Native, 
                           in_ptr, in_length,
                           &srcBytesParsed);

        in_ptr = destBuf;
      }

   
    API_TRACE_BUF(in_ptr, 0, ((in_length > 40) ? 40 : in_length));
    switch (out_format) {
    case (SQL_C_CHAR): {     
        UCHAR FAR * ptr;
        UDWORD inlen;
        ptr = in_ptr + moved_len;
        inlen = in_length - moved_len;
        if (inlen > 0) {
            UCHAR c;
            /*            SWORD format = in_format; */
            SWORD format = out_format;
            if (format == SQL_CHAR)
              format = SQL_VARCHAR;
/*             if (format == SQL_UNICODE) */
/*               format = SQL_CHAR; */
/*             else if (format == SQL_UNICODE_VARCHAR) */
/*               format = SQL_VARCHAR; */
            c = out_ptr[0];
            api_retcode = apgstst( ptr,
                                   inlen,
                                   in_format,
                                   out_ptr,
                                   out_length,
                                   format,
                                   used );
            if (api_retcode == API_OK) {
                if (*used == 0 && *moved_len_ptr > 0) {
                    out_ptr[0] = c;
                    api_retcode = API_NO_DATA_FOUND;
                }
                if (!*moved_len_ptr && !*used) /* special case empty string */
                    *moved_len_ptr = in_length;
                else
                  /* moved_len_ptr is moved in bytes => depends from encoding
                     http://pts:1080/webpts?wptsdetail=yes&ErrorType=0&ErrorID=1126177 */
                        if (in_format == SQL_CHAR || in_format == SQL_VARCHAR ||
                            in_format == SQL_LONGVARCHAR)
                            *moved_len_ptr += *used;
                        else
                            *moved_len_ptr += *used * sizeof(tsp81_UCS2Char);

            }
            else 
                if (api_retcode == API_TRUNCATE)
                    if (out_length > 0) {   /* PTS 1119132 */
                        if (in_format == SQL_CHAR || in_format == SQL_VARCHAR ||
                            in_format == SQL_LONGVARCHAR)
                            *moved_len_ptr += out_length - 1;
                        else
                            *moved_len_ptr += out_length * sizeof(tsp81_UCS2Char) - sizeof(tsp81_UCS2Char);
                    }
        }
        else {
            api_retcode = API_NO_DATA_FOUND;
        }
        break;
    }
    case (SQL_C_WCHAR): {
        UCHAR FAR * ptr;
        UDWORD inlen;
        ptr = in_ptr + moved_len;
        inlen = in_length - moved_len;
        if (inlen > 0) {
            UCHAR c;
            SWORD format = out_format;
            if (format == SQL_WCHAR)
              format = SQL_WVARCHAR;
            /* use only even number of bytes for unicode */
            if (out_length & 1)
              out_length--;
            c = out_ptr[0];
            api_retcode = apgstst( ptr,
                                   inlen,
                                   in_format,
                                   out_ptr,
                                   out_length,
                                   format,
                                   used );
            if (api_retcode == API_OK) {
                if (*used == 0 && *moved_len_ptr > 0) {
                    out_ptr[0] = c;
                    api_retcode = API_NO_DATA_FOUND;
                }
                if (!*moved_len_ptr && !*used) /* special case empty string */
                    *moved_len_ptr = in_length;
                else
                    *moved_len_ptr += *used;
            }
            else 
                if (api_retcode == API_TRUNCATE)
                    if (out_length > 0) {   /* PTS 1119132 */
                        if (in_format == SQL_WCHAR || in_format == SQL_WVARCHAR ||
                            in_format == SQL_WLONGVARCHAR)
                            *moved_len_ptr += out_length - sizeof(tsp81_UCS2Char);
                        else
                            *moved_len_ptr += out_length / sizeof(tsp81_UCS2Char) - 1;
                    }
        }
        else {
            api_retcode = API_NO_DATA_FOUND;
        }
        break;
    }

    case (SQL_C_BIT): {                /* PTS 1112777 */
        UCHAR *inPtr;
        tsp00_Uint4   destBytesWritten;        /* number of bytes written */
        tsp00_Uint4   srcBytesParsed;          /* number of bytes parsed */
        tsp78ConversionResult rc = sp78_Ok;
        UCHAR localString[API_CHAR_LENGTH_CHAR+1];

        if (in_format == SQL_WCHAR || 
            in_format == SQL_WVARCHAR ||
            in_format == SQL_WLONGVARCHAR) {
            rc = sp78convertString (sp77encodingAscii,
                                    localString, sizeof (localString),
                                    &destBytesWritten,
                                    TRUE,
                                    sp77encodingUCS2Native,
                                    in_ptr, in_length,
                                    &srcBytesParsed);
            inPtr = localString;
        }
        else
            inPtr = in_ptr;

        if (rc != sp78_Ok && rc != sp78_TargetExhausted)  {
            api_retcode = API_NOT_OK;
        }
        else {
            SDOUBLE local_double;
            api_retcode = aptchfd (inPtr, out_format);
            if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                local_double = atof( (char*) in_ptr);
                api_retcode = API_OK;
                /* this constants are exact representable in IEEE */
                if (local_double == 0.0)
                  *(char*) out_ptr = 0;
                else if (local_double == 1.0)
                  *(char*) out_ptr = 1;
                else if (0.0 < local_double && local_double < 1.0) {
                  *(char*) out_ptr = 0;
                  api_retcode = API_FRACTIONAL_TRUNC;
                }
                else if (1.0 < local_double && local_double < 2.0) {
                  *(char*) out_ptr = 1;
                  api_retcode = API_FRACTIONAL_TRUNC;
                }
                else
                  api_retcode = API_DATA_LOSS;
            }
            else {
              api_retcode = API_INVALID_CHAR;
            }
        }
        break;
    }

    case (SQL_C_BINARY): {
        /* ADIS 1001445
           if (p = API_MEMCHR(in_ptr, 0, (int)in_length))
           len = p - in_ptr;
           else 
        */
        len = in_length;
        /* for SQL_VARCHAR a null terminator is reserved
         * see (pa20PopulateDesc PTS 1103571 */
        if (in_format == SQL_VARCHAR) {
          /* as the source string is null-terminated, get the length
             http://pts:1080/webpts?wptsdetail=yes&ErrorType=0&ErrorID=1130638 */
            len = strlen ((char*) in_ptr);
        }
        if (in_format == SQL_WVARCHAR) {
            len = sp81UCS2strlen ((tsp81_UCS2Char*) in_ptr) * sizeof(SQLWCHAR);
        }
        len -= moved_len;
        *used = len;
        if (*used == 0 && *moved_len_ptr > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            if (len > out_length) {
                len = out_length;
                api_retcode = API_TRUNCATE;     
                *moved_len_ptr += out_length;
            } 
            else if (api_retcode == API_OK)
                *moved_len_ptr += *used;
            API_MEMCPY(out_ptr, in_ptr + moved_len, (int)len);
        }
        break;
    }
    case (SQL_C_SSHORT): {}
    case (SQL_C_USHORT): {}
    case (SQL_C_SHORT): {
        if (moved_len > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            api_retcode = apgsti2(in_ptr, in_length, out_ptr, out_format);
            if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                *used = sizeof(SWORD);
                *moved_len_ptr = *used;
            }
        }
        break;
    }      
    case (SQL_C_SLONG): {}
    case (SQL_C_ULONG): {}
    case (SQL_C_LONG): {
        if (moved_len > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            api_retcode = apgsti4(in_ptr, in_length, out_ptr, out_format);
            if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                *used = sizeof(SDWORD);
                *moved_len_ptr = *used;
            }
        }
        break;
    }
    case (SQL_C_STINYINT): {}
    case (SQL_C_UTINYINT): {}
    case (SQL_C_TINYINT): {
        if (moved_len > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            api_retcode = apgsti1(in_ptr, in_length, out_ptr, out_format);
            if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                *used = sizeof(SCHAR);
                *moved_len_ptr = *used;
            }
        }
        break;
    }
    case (SQL_C_NUMERIC): { /* new in 3.0 */
        if (moved_len > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            SQL_NUMERIC_STRUCT local_numeric;
            api_retcode = pa05String2Numeric( in_ptr,
                                              numericScale,
                                              &local_numeric );
            if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                *used = sizeof( SQL_NUMERIC_STRUCT );
                *moved_len_ptr = *used;
                API_MEMCPY( out_ptr, (UCHAR*) &local_numeric, (int)*used);
            }; /* if */
        }        
        break;
    }
#ifdef BIGINT_SUPPORTED
    case (SQL_C_SBIGINT): { } /* new in 3.0 */
    case (SQL_C_UBIGINT): { /* new in 3.0 */
        if (moved_len > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            api_retcode = apgsti8( in_ptr, in_length, out_ptr, out_format );
            if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                *used = sizeof(API_BIGINT);
                *moved_len_ptr = *used;
            }
        }
        break;
    }    
#endif /* BIGINT_SUPPORTED */
    case (SQL_C_FLOAT): {
        if (moved_len > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            api_retcode = apgstfd(in_ptr, in_length, out_ptr, out_format);
            if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                if (api_retcode == API_TRUNCATE)
                    api_retcode = API_OK;
                *used = sizeof(SFLOAT);  
                *moved_len_ptr = *used;
            }
        }
        break;
    }
    case (SQL_C_DOUBLE): {
        if (moved_len > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            api_retcode = apgstfd(in_ptr, in_length, out_ptr, out_format);
            if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                if (api_retcode == API_TRUNCATE)
                    api_retcode = API_OK;
                *used = sizeof(SDOUBLE);
                *moved_len_ptr = *used;
            }
        }
        break;
    }
    case SQL_C_DATE:
    case SQL_C_TYPE_DATE: {
        if (moved_len > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            api_retcode = apgchdt(in_ptr);
            if (api_retcode == API_OK) {
                api_retcode = apgstdt( in_ptr,
                                       SQL_TYPE_DATE,
                                       (VOID*) out_ptr,
                                       out_format,
                                       used );
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    *moved_len_ptr = *used;
                }
            }
        }
        break;
    }
    case SQL_C_TIME:
    case SQL_C_TYPE_TIME: {
        if (moved_len > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            api_retcode = apgchtm(in_ptr);
            if (api_retcode == API_OK) {
                api_retcode = apgstdt( in_ptr,
                                       SQL_TYPE_TIME,
                                       (VOID*) out_ptr,
                                       out_format,
                                       used );
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    *moved_len_ptr = *used;
                }
            }
        }
        break;
    }
    case SQL_C_TIMESTAMP:
    case SQL_C_TYPE_TIMESTAMP: {
        if (moved_len > 0)
            api_retcode = API_NO_DATA_FOUND;
        else {
            api_retcode = apgchts(in_ptr);
            if (api_retcode == API_OK) {
                api_retcode = apgstdt( in_ptr,
                                       SQL_TYPE_TIMESTAMP,
                                       (VOID*) out_ptr,
                                       out_format,
                                       used );
                if (api_retcode == API_OK || api_retcode == API_TRUNCATE) {
                    *moved_len_ptr = *used;
                }
            }
        }
        break;
    }
    default: {        
        API_TRACE(API_TR_SWORD, "format not supported", &out_format);
        api_retcode = API_NOT_OK;
        break;
    }
    }
    API_TRACE(API_TR_UDWORD,"*used", used);
    API_TRACE(API_TR_UDWORD,"moved_len", moved_len_ptr);
    API_TRACE(API_TR_EXIT,"apfchar",0);
    API_TRACE(API_TR_API_RETCODE,"api_retcode",&api_retcode);

    return(api_retcode);
} /* apfchar */


/* apfdate() - convert SQL to C: Date */
API_RETCODE apfdate(UCHAR FAR * in_ptr,
                    UDWORD in_length,
                    UDWORD FAR * moved_len_ptr,
                    SWORD in_format,
                    UCHAR FAR * out_ptr,
                    UDWORD out_length,
                    SWORD out_format,
                    UDWORD *used)
{
    API_RETCODE api_retcode;
    UDWORD len = 0;
    UCHAR local_string[API_CHAR_LENGTH_CHAR+2];

    API_RETCODE (*chkfunc) (UCHAR FAR *string_ptr);

    chkfunc = NULL;

    API_TRACE(API_TR_ENTRY, "apfdate", 0);
    API_TRACE(API_TR_PTR, "in_ptr", &in_ptr);
    API_TRACE(API_TR_UDWORD, "in_length", &in_length);
    API_TRACE(API_TR_UDWORD, "*moved_len_ptr", moved_len_ptr);
    API_TRACE(API_TR_SWORD, "in_format", &in_format);
    API_TRACE(API_TR_PTR, "out_ptr", &out_ptr);
    API_TRACE(API_TR_UDWORD, "out_length", &out_length);
    API_TRACE(API_TR_SWORD, "out_format", &out_format);  

    if (*moved_len_ptr != 0) {
        api_retcode = API_NO_DATA_FOUND;
    }
    else {      
        api_retcode = API_OK;

        API_TRACE_BUF(in_ptr, 0, ((in_length > 40) ? 40 : in_length));
        switch (in_format) {
        case (SQL_DATE):
        case (SQL_TYPE_DATE): { 
            chkfunc = *apgchdt;
            len = API_DATE_PREC;
            break;
        }
        case (SQL_TIME):
        case (SQL_TYPE_TIME): {  
            chkfunc = *apgchtm;
            len = API_TIME_PREC;
            break;
        }
        case (SQL_TIMESTAMP):
        case (SQL_TYPE_TIMESTAMP): {  
            chkfunc = *apgchts;
            len = API_TIMESTAMP_EXT_PREC;
            break;
        }
        default : {
            API_TRACE(API_TR_SWORD, "format not supported", &out_format);
            api_retcode = API_NOT_OK;
            break;
        }
        }
        if (api_retcode == API_OK) {
            switch (out_format) {
            case (SQL_C_WCHAR): {}
            case (SQL_C_CHAR): {
                API_MEMCPY(local_string, in_ptr, (int)len);
                local_string[len] = local_string[len+1] = 0;
                switch (in_format) {      /* INNER SWITCH */
                case (SQL_CHAR): {}
                case (SQL_UNICODE): {}
                case (SQL_VARCHAR): {}
                case (SQL_UNICODE_VARCHAR): {}
                case (SQL_LONGVARCHAR): {}
                case (SQL_UNICODE_LONGVARCHAR): {}
                case (SQL_BINARY): {}
                case (SQL_VARBINARY): {}
                case (SQL_LONGVARBINARY): {}
                case (SQL_TYPE_DATE): {}
                case (SQL_TYPE_TIME): {}
                case (SQL_TYPE_TIMESTAMP): {}
                case (SQL_DATE): {}
                case (SQL_TIME): {}
                case (SQL_TIMESTAMP): {
                    SWORD local_out_format = SQL_VARCHAR;
                    api_retcode = chkfunc (local_string);
                    if (out_format == SQL_C_WCHAR)
                        local_out_format = SQL_WVARCHAR;
                        
                    if (api_retcode == API_OK) {
                        api_retcode = apgstst( local_string,
                                               (UDWORD) SQL_NTS,
                                               in_format,
                                               out_ptr,
                                               out_length,
                                               local_out_format,
                                               used);
                    }
                    break;
                }
                case (SQL_INTEGER): {}
                case (SQL_SMALLINT): {}
                case (SQL_NUMERIC): {}
                case (SQL_DECIMAL): {}
                case (SQL_FLOAT): {}
                case (SQL_DOUBLE): {
                    api_retcode = API_INVALID;        
                    break;
                }        
                default: {
                    api_retcode = API_NOT_OK;
                    break;
                }
                } /* switch real_c_type */
                break;
            }      
            case (SQL_C_TYPE_DATE): {} 
            case (SQL_C_TYPE_TIME): {} 
            case (SQL_C_TYPE_TIMESTAMP): {}
            case (SQL_C_DATE): {} 
            case (SQL_C_TIME): {} 
            case (SQL_C_TIMESTAMP): {  
                switch (in_format) {      /* INNER SWITCH */
                case (SQL_CHAR): {}
                case (SQL_UNICODE): {}
                case (SQL_VARCHAR): {}
                case (SQL_UNICODE_VARCHAR): {}
                case (SQL_LONGVARCHAR): {}
                case (SQL_UNICODE_LONGVARCHAR): {}
                case (SQL_BINARY): {}
                case (SQL_VARBINARY): {}
                case (SQL_LONGVARBINARY): {}
                case (SQL_TYPE_DATE): {}
                case (SQL_TYPE_TIME): {}
                case (SQL_TYPE_TIMESTAMP): {}
                case (SQL_DATE): {}
                case (SQL_TIME): {}
                case (SQL_TIMESTAMP): {
                    API_MEMCPY(local_string, in_ptr, (int)len);
                    local_string[len] = 0;
                    api_retcode = chkfunc (local_string);        
                    if (api_retcode == API_OK) {
                        api_retcode = apgstdt( local_string,
                                               in_format,
                                               (VOID*) out_ptr,
                                               out_format,
                                               used);
                    }
                    break;
                }
                case (SQL_INTEGER): {}
                case (SQL_SMALLINT): {}
                case (SQL_NUMERIC): {}
                case (SQL_DECIMAL): {}
                case (SQL_FLOAT): {}
                case (SQL_DOUBLE): {
                    api_retcode = API_INVALID;        
                    break;
                }        
                default: {
                    API_TRACE(API_TR_SWORD, "format not supported",
                              &out_format);
                    api_retcode = API_NOT_OK;
                    break;
                }
                }
                break;
            }
            case (SQL_C_BINARY): {     
                *used = in_length;
                if (in_length > out_length) {
                    api_retcode = API_DATA_LOSS;
                }
                else {
                    API_MEMCPY(out_ptr, in_ptr, (int)*used);
                }
                break;
            }
            case (SQL_C_SSHORT): {}
            case (SQL_C_USHORT): {}
            case (SQL_C_SHORT): {}
            case (SQL_C_SLONG): {}
            case (SQL_C_ULONG): {}
            case (SQL_C_LONG): {}
            case (SQL_C_STINYINT): {}
            case (SQL_C_UTINYINT): {}
            case (SQL_C_TINYINT): {}
            case (SQL_C_UBIGINT): {}
            case (SQL_C_SBIGINT): {}
            case (SQL_C_NUMERIC): {}
            case (SQL_C_BIT): {}
            case (SQL_C_FLOAT): {}
            case (SQL_C_DOUBLE): {
                api_retcode = API_INVALID;        
            }
            default: {
                API_TRACE(API_TR_SWORD, "format not supported", &out_format);
                api_retcode = API_NOT_OK;
                break;
            }
            }
        }
        if (api_retcode == API_OK || api_retcode == API_TRUNCATE)
            *moved_len_ptr = *used;
    }
    API_TRACE(API_TR_UDWORD,"*used", used);
    API_TRACE(API_TR_EXIT,"apfdate",0);
    API_TRACE(API_TR_API_RETCODE,"api_retcode",&api_retcode);

    return(api_retcode);
} /* apfdate */


void apfgbyte(char *buf, int pos, int len, char *dest, int dpos, int dlen, char *truncated)
{
    int di;
    int si;
    int lo_dig;
    int hi_dig;
    *truncated = 0;
    di = 0;
    si = 0;
    dpos--;
    pos--;
    while (!*truncated && si < len) {
        if (dlen < di + 2)
            {
                *truncated = 1;
            }
        else
            {
                UCHAR c = *(buf+pos+si);
                tsp00_Uint1 l = 0x0f;
                tsp00_Uint1 h = 0xf0;
                hi_dig = c & l;
                lo_dig = c & h;
                hi_dig = *(buf+pos + si) >> 4 & 0x000f;
                lo_dig = (*(buf+pos + si) >= 0) ?
                    *(buf+pos+si) & 15
                    : (*(buf+pos+si) % 16) ? 16 + *(buf+pos+si) & 15 : 0;
                if (hi_dig <= 9)
                    *(dest+dpos+di) = (char)(hi_dig + '0');
                else
                    *(dest+dpos+di) = (char)(hi_dig - 10 + 'A');
                di++;
                if (lo_dig <= 9)
                    *(dest+dpos+di) = (char)(lo_dig + '0');
                else
                    *(dest+dpos+di) = (char)(lo_dig - 10 + 'A');
                di++;
                si++;
            }
    }
    API_MEMSET(dest+dpos+di, '0', dlen-di);
} /* apfgbyte */



/* end of vpa04fc */
.CM *-END-* code ----------------------------------------
.SP 2 
***********************************************************
