/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
********************************************************************/
/**************************************************************************
**************************************************************************/
//
// MODULE: NSKIEEE.cpp
//
//
//	Purpose: Routines to convert between t16 float and ieee float.
//
//	Compaq 64-bit float format :                            
//     +--------------------------------------------------+
//     |s|            mantissa                 |  exp     |
//     +--------------------------------------------------+
//      1                54                         9      
//                                                         
//	Compaq 32-bit float format :                            
//     +--------------------------------------+            
//     |s|      mantissa           |  exp     |            
//     +--------------------------------------+            
//      1          22                   9                  
//                                                         
//	IEEE   64-bit float format :                            
//     +--------------------------------------------------+
//     |s|   exp      |             mantissa              |
//     +--------------------------------------------------+
//      1     11                       52                  
//                                                         
//IEEE   32-bit float format :                            
//     +--------------------------------------+            
//     |s|   exp      |       mantissa        |            
//     +--------------------------------------+            
//      1     8                  23                        
//                                                                 
// Compaq float exponent is expressed as an excessed-256 value     
// (biased by 256).                                                
// The exponent range is between -256 to +255.                     
//                                                                 
// IEEE float exponent is also biased. The exponent bias is 1023   
// for double (64 bits) format and 127 for single (32 bits) format.
//                                                                 
//-----------------------------------------------------------------
#include <windows.h>
#include <sqltypes.h>
#include <sqlExt.h>
#include "sqlcli.h"
#include "NSKIEEE.h"
#include "DrvrSrvr.h"
#ifdef NSK_PLATFORM
#include "kfpconv.h"
#endif

#define	IEEE_EXPONENT_BIAS		1023
#define T16_EXPONENT_BIAS			256
#define	BIAS_DIFFERENCE				767		// 1023 - 256 = 767
#define	IEEE_EXPONENT_BIAS_S	127		// single format
#define	BIAS_DIFFERENCE_S			-129	// 127 - 256 = -129

//----------------------------------------------------------------
// If the source length is not an even number, no swapping will
// be performed. No error is generated in this function.       
// IN/OUT : source/target, IN : swap length
//----------------------------------------------------------------
void ODBC::byte_swap(BYTE *source, long source_len)
{                                                              
#ifndef NSK_PLATFORM
	BYTE   *target;                                              
	BYTE    temp;                                                
	short   i;                                                   

	if (!(source_len % 2))
	{
		for (i = 1, target = source; i <= source_len /2; i++)
		{                                                 
			temp = source[i-1];                               
			target[i-1] = source[source_len - i];             
			source[source_len -i] = temp;                     
		}                                                 
	}
#endif
}   // byte_swap

// The following byte order inversion routines were written by Dale Rempert.  They are
// specific to the 80x86 processors.  Even though the external representation is little endian
// the internal representation is big endian.  Here is how these routines work.  Take a short
// in big endian say 0xCDAB.  When read by the processor it "sees" the value 0xABCD. We rotate
// this value by 8 bits yealding 0xCDAB. Then written out to memory we get 0xABCD.  For 4 & 8
// byte values I read two byes at a time and build one or two 4 byte "longs" then write out the 
// longs.  This minimizes the reads/writes to slower memory, and if the compiler is nice will
// keep the temps in registers.  Though some compilers will not do this if a routine contains
// inline assembly statements.  

// Note the only reasonable sizes for endian inversion are 2, 4, and 8 bytes.

// byte_swap a 16 bit field (i.e. 2 bytes)
void ODBC::byte_swap_2(BYTE *source)
{

#if defined(NSK_PLATFORM)
	return;
#endif

#if defined(WIN32) && !defined(_WIN64)
	unsigned short tmp;

	tmp = *(unsigned short *)source;
	_asm rol tmp,8
	*(unsigned short *)source = tmp; 
#endif

#if defined(_WIN64)
	byte_swap(source,2);
#endif
}   


// byte_swap a 32 bit field (i.e. 4 bytes)
void ODBC::byte_swap_4(BYTE *source)
{

#if defined(NSK_PLATFORM)
	return;
#endif

#if defined(WIN32) && !defined(_WIN64)
	unsigned long t32;
	unsigned short t16;

			t16 = *(unsigned short *)source;
			_asm rol t16,8
			t32 = ((unsigned long)t16) << 16;

			t16 = *(short *)(source+2);
			_asm rol t16,8
			t32 |= (unsigned long)t16;
			*(unsigned long *)source = t32; 
#endif

#if defined(_WIN64)
	byte_swap(source,4);
#endif
}   

// byte_swap a 64 bit field (i.e. 8 bytes)
// 0x1122334455667788 => 0x8877665544332211

void ODBC::byte_swap_8(BYTE *source)
{
#if defined(NSK_PLATFORM)
	return;
#endif

#if defined(WIN32) && !defined(_WIN64)
	unsigned long t32a, t32b;
	unsigned short t16;

			t16 = *(unsigned short *)source;		// 0x2211
			_asm rol t16,8				// 0x1122
			t32a = ((unsigned long)t16) << 16;	// 0x11220000

			t16 = *(unsigned short *)(source+2);	// 0x4433
			_asm rol t16,8				// 0x3344
			t32a |= (unsigned long)t16;			// 0x11223344
			
			t16 = *(unsigned short *)(source+4);	// 0x6655
			_asm rol t16,8				// 0x5566
			t32b = ((unsigned long)t16) << 16;	// 0x55660000

			t16 = *(unsigned short *)(source+6);	// 0x8877
			_asm rol t16,8				// 0x7788
			t32b |= (unsigned long)t16;			// 0x55667788

			*(unsigned long *)source = t32b;		// 0x88776655
			*(unsigned long *)(source+4) = t32a; // 0x44332211 
#endif

#if defined(_WIN64)
	byte_swap(source,8);
#endif
}   


// byte swap a string of chars in unicode UCS2 or any other chars in 
// fixed two byte representation.

void ODBC::byte_swap_string(BYTE *source, long source_len)
{                                                              
#if !defined(NSK_PLATFORM)
	unsigned short   *target;                                                                                              
	int   i; 
	unsigned short tmp;

	target = (unsigned short *)source;

	for (i = source_len /2; i > 0; i--)
	{ 
		tmp = *target;
#if defined(WIN32) && !defined(_WIN64)
		_asm rol tmp,8
#endif
#if defined(_WIN64)
		byte_swap((BYTE*)&tmp,2);
#endif
		*target++ = tmp;                   
	}                                                                                                   
#endif
}   // byte_swap_string


//-------------------------------------------------------------------- 
// Convert T16 64-bit float to IEEE float.                             
//	IN : T16 floating number, OUT: IEEE float
//  For alignment reason, this is not declared as long long *.          
//-------------------------------------------------------------------- 
short ODBC::conv_float64_to_ieee_d (BYTE *op)
{                                                                       
	unsigned int	exp;          // exponent
	BYTE rop[8];
	BYTE *exp1;
	BYTE *exp2;

	// Get exponent and sign.
	exp = ((op[6] & 0x01) << 8) | op[7];

	if (exp == 0)
		return (STATUS_OK);                                                   
	exp = exp + BIAS_DIFFERENCE;	//1023 - 256
	exp1 = (BYTE *)&exp;
	exp2 = exp1 + 1;

	rop[0] = (BYTE)((op[0] & 0x80) | (*exp2 << 4) | (*exp1 >> 4));
	rop[1] = (BYTE)((*exp1 << 4) | ((op[0] & 0x7F) >> 3));	// RS has to remove the sign
	rop[2] = (BYTE)((op[0] << 5) | (op[1] >> 3));
	rop[3] = (BYTE)((op[1] << 5) | (op[2] >> 3));
	rop[4] = (BYTE)((op[2] << 5) | (op[3] >> 3));
	rop[5] = (BYTE)((op[3] << 5) | (op[4] >> 3));
	rop[6] = (BYTE)((op[4] << 5) | (op[5] >> 3));
	rop[7] = (BYTE)((op[5] << 5) | (op[6] >> 3));

	byte_swap(rop, 8);
	memcpy(op, rop, 8);
                                                                         
	return (STATUS_OK);                                                   
} // conv_float64_to_ieee_d

//--------------------------------------------------------------------
// Convert IEEE float to T16 64-bit float.
//--------------------------------------------------------------------
short ODBC::conv_ieee_d_to_float64 (BYTE *op)
{                                                                       
	unsigned int	exp;          // exponent
	BYTE rop[8];
	BYTE *exp1;
	BYTE *exp2;

	byte_swap(op, 8);
	// Get exponent and sign.
	exp = (((op[0] & 0x7F) << 8 ) | (op[1] & 0xF0)) >> 4;

	if (exp == 0)
		return (STATUS_OK);                                                   
	if ((int)exp < (1023 - 256))
		return( STATUS_UNDERFLOW);
	if ((int)exp > (1023 + 255))
		return ( STATUS_OVERFLOW);
	
	exp = exp - BIAS_DIFFERENCE;	//1023 - 256
	exp1 = (BYTE *)&exp;
	exp2 = exp1 + 1;

	rop[0] = (BYTE)((op[0] & 0x80) | ((op[1] & 0x0F) << 3) | ((op[2] & 0xE0) >> 5));
	rop[1] = (BYTE)((op[2] << 3) | (op[3] >> 5));
	rop[2] = (BYTE)((op[3] << 3) | (op[4] >> 5));
	rop[3] = (BYTE)((op[4] << 3) | (op[5] >> 5));
	rop[4] = (BYTE)((op[5] << 3) | (op[6] >> 5));
	rop[5] = (BYTE)((op[6] << 3) | (op[7] >> 5));
	rop[6] = (BYTE)((op[7] << 3) | (*exp2));
	rop[7] = (BYTE)(*exp1);

	memcpy(op, rop, 8);
                                                                         
	return (STATUS_OK);                                                   
} // conv_ieee_d_to_float64

//--------------------------------------------------------------------
// Convert T16 32-bit float to IEEE float (single format)             
// IN : T16 floating number, OUT: IEEE float ,single format.
//--------------------------------------------------------------------
short ODBC::conv_float32_to_ieee_s (BYTE *op )
{                                                                       
	unsigned int	exp;          // exponent
	BYTE rop[4];

	// Get exponent.
	exp = ((op[2] & 0x01) << 8) | op[3];

	if (exp == 0)
		return (STATUS_OK);                                                   
	// Check underflow or overflow, since Tandem has 9-bits exponents
	// IEEE has 8-bits exponents.
	if ( (int)exp < (127 - 256))
		return ( STATUS_UNDERFLOW);
	if ( (int)exp > (127 + 255))
		return ( STATUS_OVERFLOW);

	exp = exp + BIAS_DIFFERENCE_S;	//	127 - 256

	rop[0] = (BYTE)((op[0] & 0x80) | (exp >> 1));
	rop[1] = (BYTE)(((exp & 0x01) << 7) | (op[0] & 0x7F));
	rop[2] = op[1];
	rop[3] = (BYTE)(op[2] & 0xFE);

	byte_swap(rop, 4);
	memcpy(op, rop, 4);
                                                                         
	return (STATUS_OK);                                                   
} // conv_float32_to_ieee

//--------------------------------------------------------------------
// Convert IEEE float to T16 64-bit float.                            
//--------------------------------------------------------------------
short ODBC::conv_ieee_s_to_float32 (BYTE *op )
{                                                                       
	unsigned int	exp;          // exponent
	BYTE rop[4];

	byte_swap(op, 4);
	// Get exponent.
	exp = ((op[0] & 0x7F) << 1) | ((op[1] & 0x80) >> 7);
	if (exp == 0)
		return (STATUS_OK);                                                   
	exp = exp - BIAS_DIFFERENCE_S;	//	127 - 256

	rop[0] = (BYTE)((op[0] & 0x80) | (op[1] & 0x7F));
	rop[1] = (BYTE)(op[2]);
	rop[2] = (BYTE)((op[3] & 0xFE) | (exp >> 8));
	rop[3] = (BYTE)(exp);

	memcpy(op, rop, 4);
                                                                         
	return (STATUS_OK);                                                   
} // conv_ieee_s_to_float32

//--------------------------------------------------------------------
// Convert depending on datatype.
//--------------------------------------------------------------------
short ODBC::Datatype_Dependent_Swap(BYTE *source, long dataType, SQLINTEGER charSet,long source_len, BOOL tandem_ieee, SQLSMALLINT CDataType)
{

	short rst = STATUS_OK;

	switch (dataType)
	{
		case SQLTYPECODE_CHAR:
		case SQLTYPECODE_INTERVAL:
//SQL_C_BINARY is specified, swap the data
			if ((charSet == SQLCHARSETCODE_UCS2) && (CDataType == SQL_C_BINARY))
				byte_swap_string(source, source_len);
			break;

		case SQLTYPECODE_VARCHAR_WITH_LENGTH:
		case SQLTYPECODE_VARCHAR:
		case SQLTYPECODE_VARCHAR_LONG:
			if ((charSet == SQLCHARSETCODE_UCS2) && (CDataType != SQL_C_BINARY))
				*(short*)source = 2 * (*(short *)source);
//SQL_C_BINARY is specified, swap the data
			if ((charSet == SQLCHARSETCODE_UCS2) && (CDataType == SQL_C_BINARY))
				byte_swap_string(source+2, *(short*)source);
			byte_swap_2(source);
			break;

		case SQLTYPECODE_SMALLINT:
		case SQLTYPECODE_SMALLINT_UNSIGNED:
			byte_swap_2(source);
			break;

		case SQLTYPECODE_INTEGER:
		case SQLTYPECODE_INTEGER_UNSIGNED:
			byte_swap_4(source);
			break;

		case SQLTYPECODE_LARGEINT:
			byte_swap_8(source);
			break;

		case SQLTYPECODE_IEEE_REAL:
			byte_swap_4(source);
			break;

    case SQLTYPECODE_IEEE_FLOAT:
	case SQLTYPECODE_IEEE_DOUBLE:
			byte_swap_8(source);
			break;

	case SQLTYPECODE_DATETIME:
			break;

	case SQLTYPECODE_DECIMAL_UNSIGNED:
	case SQLTYPECODE_DECIMAL:
	case SQLTYPECODE_DECIMAL_LARGE_UNSIGNED: // Tandem extension
	case SQLTYPECODE_DECIMAL_LARGE: // Tandem extension
			break;

	case SQLTYPECODE_NUMERIC:              //2
	case SQLTYPECODE_NUMERIC_UNSIGNED:    //-201
			byte_swap_bignum(source, source_len);
			break;

	default:
			byte_swap(source, source_len);
			break;
	}

	return (rst);
}

#ifdef NSK_PLATFORM
short ODBC::Datatype_Dependent_Convert(BYTE *source, long dataType, long source_len, BOOL tandem_ieee)
{
	uint32 rst = NSK_FLOAT_OK;
	return (rst);
}
#endif

void ODBC::SQLDatatype_Dependent_Swap(BYTE *source, long dataType, SQLINTEGER charSet, long dataLength, long DateTimeCode)
{

	switch (dataType)
	{
		case SQLTYPECODE_INTERVAL:
			break;

		case SQLTYPECODE_CHAR:
			if (charSet == SQLCHARSETCODE_UCS2)
				byte_swap_string(source,dataLength);
			break;

		case SQLTYPECODE_VARCHAR_WITH_LENGTH:
		case SQLTYPECODE_VARCHAR:
		case SQLTYPECODE_VARCHAR_LONG:
			byte_swap_2(source);
			if (charSet == SQLCHARSETCODE_UCS2)
				byte_swap_string(source+2,*(short *)source);
			break;

		case SQLTYPECODE_SMALLINT:
		case SQLTYPECODE_SMALLINT_UNSIGNED:
			byte_swap_2(source);
			break;

		case SQLTYPECODE_INTEGER:
		case SQLTYPECODE_INTEGER_UNSIGNED:
			byte_swap_4(source);
			break;

		case SQLTYPECODE_LARGEINT:
			byte_swap_8(source);
			break;

		case SQLTYPECODE_IEEE_REAL:
			byte_swap_4(source);
			break;

		case SQLTYPECODE_IEEE_FLOAT:
		case SQLTYPECODE_IEEE_DOUBLE:
			byte_swap_8(source);
			break;

		case SQLTYPECODE_DATETIME:
			switch (DateTimeCode)
			{
				case SQLDTCODE_DATE:
					byte_swap((BYTE *)&((DATE_TYPES *)source)->year, 2);
					break;
				case SQLDTCODE_TIME:
					if (dataLength == 7)
						byte_swap((BYTE *)&((TIME_TYPES *)source)->fraction, 4);
					break;
				case SQLDTCODE_TIMESTAMP:
					byte_swap((BYTE *)&((TIMESTAMP_TYPES *)source)->year, 2);
					if (dataLength == 11)
						byte_swap((BYTE *)&((TIMESTAMP_TYPES *)source)->fraction, 4);
					break;
			}
			break;

		case SQLTYPECODE_DECIMAL_UNSIGNED:
		case SQLTYPECODE_DECIMAL:
		case SQLTYPECODE_DECIMAL_LARGE_UNSIGNED: // Tandem extension
		case SQLTYPECODE_DECIMAL_LARGE: // Tandem extension
			break;

		case SQLTYPECODE_NUMERIC:              //2
		case SQLTYPECODE_NUMERIC_UNSIGNED:    //-201
			byte_swap_bignum(source, dataLength);
			break;

		default:
			break;
	}
}

#ifdef NSK_PLATFORM
short ODBC::SQLDatatype_Dependent_Convert(BYTE *source, long dataType, long DateTimeCode, BOOL tandem_ieee)
{

	uint32 rst = NSK_FLOAT_OK;
	return (rst);
}
#endif

long ODBC::dataLength(SQLSMALLINT SQLDataType, SQLINTEGER SQLOctetLength, SQLINTEGER SQLCharset, unsigned char* buffer)
{
	long allocLength = 0;
	switch (SQLDataType)
	{
	case SQLTYPECODE_CHAR:
	case SQLTYPECODE_BIT:
	case SQLTYPECODE_VARCHAR:
	case SQLTYPECODE_INTERVAL:
		allocLength = SQLOctetLength;
		break;
	case SQLTYPECODE_VARCHAR_WITH_LENGTH:
	case SQLTYPECODE_VARCHAR_LONG:
	case SQLTYPECODE_BITVAR:
		allocLength = *(USHORT *)buffer + 3;
		break;
	case SQLTYPECODE_SMALLINT:
	case SQLTYPECODE_SMALLINT_UNSIGNED:
	case SQLTYPECODE_INTEGER:
	case SQLTYPECODE_INTEGER_UNSIGNED:
	case SQLTYPECODE_LARGEINT:
	case SQLTYPECODE_IEEE_REAL:
	case SQLTYPECODE_IEEE_FLOAT:
	case SQLTYPECODE_IEEE_DOUBLE:
	case SQLTYPECODE_DATETIME:
	case SQLTYPECODE_DECIMAL_UNSIGNED:
	case SQLTYPECODE_DECIMAL:
	case SQLTYPECODE_DECIMAL_LARGE_UNSIGNED: // Tandem extension
	case SQLTYPECODE_DECIMAL_LARGE: // Tandem extension
	default:
		allocLength = SQLOctetLength;
		break;
	}
	return allocLength;
}

long ODBC::dataLength(SQLSMALLINT SQLDataType, SQLINTEGER SQLOctetLength, SQLINTEGER SQLCharset, unsigned char* buffer, BOOL out)
{
	long allocLength = 0;
	switch (SQLDataType)
	{
	case SQLTYPECODE_CHAR:
	case SQLTYPECODE_BIT:
	case SQLTYPECODE_VARCHAR:
	case SQLTYPECODE_INTERVAL:
		allocLength = SQLOctetLength;
		break;
	case SQLTYPECODE_VARCHAR_WITH_LENGTH:
	case SQLTYPECODE_VARCHAR_LONG:
	case SQLTYPECODE_BITVAR:
		if (out == FALSE)
			allocLength = *(USHORT *)buffer + 3;
		else
		{
			short length;
			length = *(USHORT *)buffer;
#ifndef NSK_PLATFORM
			byte_swap_2((unsigned char*)&length);
#endif
			allocLength = length + 2;
		}
		break;
	case SQLTYPECODE_SMALLINT:
	case SQLTYPECODE_SMALLINT_UNSIGNED:
	case SQLTYPECODE_INTEGER:
	case SQLTYPECODE_INTEGER_UNSIGNED:
	case SQLTYPECODE_LARGEINT:
	case SQLTYPECODE_IEEE_REAL:
	case SQLTYPECODE_IEEE_FLOAT:
	case SQLTYPECODE_IEEE_DOUBLE:
	case SQLTYPECODE_DATETIME:
	case SQLTYPECODE_DECIMAL_UNSIGNED:
	case SQLTYPECODE_DECIMAL:
	case SQLTYPECODE_DECIMAL_LARGE_UNSIGNED: // Tandem extension
	case SQLTYPECODE_DECIMAL_LARGE: // Tandem extension
	default:
		allocLength = SQLOctetLength;
		break;
	}
	return allocLength;
}

long ODBC::dataLengthFetchRowset(SQLSMALLINT SQLDataType, SQLINTEGER SQLOctetLength, SQLINTEGER maxRowLen, SQLINTEGER SQLCharset, unsigned char* buffer)
{
	long allocLength = 0;
	long maxRowLength = maxRowLen;

	switch (SQLDataType)
	{
	case SQLTYPECODE_VARCHAR_WITH_LENGTH:
	case SQLTYPECODE_VARCHAR_LONG:
	case SQLTYPECODE_BITVAR:
		allocLength = *(USHORT *)buffer + 2;
		break;
	case SQLTYPECODE_CHAR:
	case SQLTYPECODE_BIT:
	case SQLTYPECODE_VARCHAR:
		allocLength = SQLOctetLength - 1;
		if (maxRowLength > 0)
			allocLength = (allocLength>maxRowLength)?maxRowLength:allocLength;
		break;
	default:
		allocLength = SQLOctetLength;
		break;
	}
	return allocLength;
}

long ODBC::dataLengthFetchPerf(SQLSMALLINT SQLDataType, SQLINTEGER SQLOctetLength, SQLINTEGER maxRowLen, SQLINTEGER SQLCharset, unsigned char* buffer)
{
	long allocLength = 0;
	long maxRowLength = maxRowLen;

//
// For UCS2 data, the count always keeps octet unicode length. Total data length = count + sizeof(short) + 1 (null terminator)
//
	switch (SQLDataType)
	{
	case SQLTYPECODE_VARCHAR_WITH_LENGTH:
	case SQLTYPECODE_VARCHAR_LONG:
	case SQLTYPECODE_BITVAR:
		allocLength = *(USHORT *)buffer + 3;
		break;
	case SQLTYPECODE_CHAR:
	case SQLTYPECODE_BIT:
	case SQLTYPECODE_VARCHAR:
		allocLength = SQLOctetLength;
		if (maxRowLength > 0)
			allocLength = (allocLength>maxRowLength)?maxRowLength + 1:allocLength;
		break;
	default:
		allocLength = SQLOctetLength;
		break;
	}
	return allocLength;
}

long ODBC::adjustIndexForBulkFetch(SQLSMALLINT SQLDataType, long index)
{
	long totalLength = index;
	switch (SQLDataType)
	{
	case SQLTYPECODE_VARCHAR_WITH_LENGTH:
	case SQLTYPECODE_VARCHAR_LONG:
		totalLength = ((totalLength + 2 - 1) >> 1) << 1; 
		break;
	case SQLTYPECODE_SMALLINT:
	case SQLTYPECODE_SMALLINT_UNSIGNED:
		totalLength = ((totalLength + 2 - 1) >> 1) << 1; 
		break;
	case SQLTYPECODE_INTEGER:
	case SQLTYPECODE_INTEGER_UNSIGNED:
		totalLength = ((totalLength + 4 - 1) >> 2) << 2; 
		break;
	case SQLTYPECODE_LARGEINT:
	case SQLTYPECODE_IEEE_REAL:
	case SQLTYPECODE_IEEE_FLOAT:
	case SQLTYPECODE_IEEE_DOUBLE:
	case SQLTYPECODE_DATETIME:
		totalLength = ((totalLength + 8 - 1) >> 3) << 3; 
		break;
	case SQLTYPECODE_DECIMAL_UNSIGNED:
	case SQLTYPECODE_DECIMAL:
	case SQLTYPECODE_DECIMAL_LARGE_UNSIGNED: // Tandem extension
	case SQLTYPECODE_DECIMAL_LARGE: // Tandem extension
	case SQLTYPECODE_INTERVAL:		// Treating as CHAR
		break;
	default:
		break;
	}
	return totalLength;
}

short ODBC::convertFromUCS2(BYTE *source, long dataType, SQLINTEGER charSet, long octetLength)
{
// return values:  
//	0 = success, 
//	-1 = translation failed, 
//	-2 = translation passed but at least one char was replaced with the default substitution char.

// MAXCHARLEN needs to be big enough to hold the largest multibyte char string.
#ifndef NSK_PLATFORM

#define MAXCHARLEN 8000

	char Dest[MAXCHARLEN];
	short srcSz;
	int rc;

	bool DefaultCharRequired;
	LPBOOL PtrDefaultCharRequired = (LPBOOL)&DefaultCharRequired;

	if (charSet != SQLCHARSETCODE_UCS2)  return 0; /* only need to translate unicode data */
		switch (dataType)
	{
		case SQLTYPECODE_CHAR:
		case SQLTYPECODE_VARCHAR:

			rc = WideCharToMultiByte(CP_ACP,0,
								(LPCWSTR)source, octetLength/2, 
								Dest, MAXCHARLEN,
								NULL,PtrDefaultCharRequired);
			if (rc != 0)
			{
				memcpy(source, Dest, rc);
				source[rc] = 0;
			}
			else return -1;
			break;

		case SQLTYPECODE_VARCHAR_WITH_LENGTH:
		case SQLTYPECODE_VARCHAR_LONG:
			srcSz = (*(short *)source) / 2;
			rc = WideCharToMultiByte(CP_ACP,0,
									(LPCWSTR)(source+2),srcSz, 
									Dest, MAXCHARLEN,
									NULL,PtrDefaultCharRequired);

			if (rc != 0)
			{
//
// in the count field we always keep unicode octet length - we need that to calculate position 
// of the next column.
//				*(short*)source = rc;
				memcpy(source + 2, Dest, rc);
				source[rc + 2] = 0;
			}
			else return -1;
			break;
	}
	return (DefaultCharRequired == true) ? -2 : 0;
#else
	return 0;
#endif
}

short ODBC::convertToUCS2(BYTE *source, long dataType, SQLINTEGER charSet, short srcLength, long octetLength)
{
// return values:  
//	0 = success, 
//	-1 = translation failed, 
	int rc = 0;

// MAXCHARLEN needs to be big enough to hold the largest multibyte char string.
#ifndef NSK_PLATFORM

#define MAXCHARLEN 8000

	char Dest[MAXCHARLEN];

	if (charSet != SQLCHARSETCODE_UCS2)  return 0; /* only need to translate unicode data */
		switch (dataType)
	{
		case SQLTYPECODE_CHAR:
		case SQLTYPECODE_VARCHAR: 
			rc = MultiByteToWideChar(CP_ACP,0,
								(const char*)source, octetLength/2, 
								(LPWSTR)Dest, MAXCHARLEN);
			if (rc != 0)
			{
				if (rc < octetLength/2) 
				{
					rc = MultiByteToWideChar(CP_ACP,0,
										(const char*)source, octetLength/2 + (octetLength/2 - rc), 
										(LPWSTR)Dest, MAXCHARLEN);
				}
				memcpy(source, Dest, octetLength);
				source[octetLength] = 0;
				byte_swap_string(source, octetLength);
			}
			else return -1;
			break;

		case SQLTYPECODE_VARCHAR_WITH_LENGTH:
		case SQLTYPECODE_VARCHAR_LONG:
			rc = MultiByteToWideChar(CP_ACP,0,
								(const char*)source, srcLength, 
								(LPWSTR)Dest, MAXCHARLEN);
			if (rc != 0)
			{
				if (rc < srcLength)
				{
					memcpy(source , Dest, 2 * rc);
					source[2 * rc] = 0;
					byte_swap_string(source, 2 * rc);
				}
				else 
				{
					memcpy(source , Dest, 2 * srcLength);
					source[2 * srcLength] = 0;
					byte_swap_string(source, 2 * srcLength);
				}
			}
			else return -1;
			break;
	}
#endif
	return rc;	//sap

}

void ODBC::byte_swap_bignum(BYTE *source, long source_len)
{
#if !defined (NSK_PLATFORM)  || !defined (BIGE) 
  unsigned short   *target;                                                                                              
	int   i; 
	unsigned short *tmp;

	target = (unsigned short *)source;

	for (i = source_len /2; i > 0; i--)
	{ 
		tmp = target;
		
		if (*tmp != 0 && *tmp != 0xFFFF)
		{
			union
			{
				char c[2];
				unsigned short j;
			} u;
			char hold;
			u.j = *tmp;
			hold = u.c[0];
			u.c[0] = u.c[1];
			u.c[1] = hold;
			*tmp = u.j;
		}
		*target++ = *tmp;                   
	} 
#endif
}