| /**********************************************************************
|
| // @@@ 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 @@@ |
| **********************************************************************/
|
| /* -*-C++-*-
|
| *****************************************************************************
|
| *
|
| * File: ExpConvMxcs.cpp
|
| * Description:
|
| *
|
| * Created: 8/30/2007
|
| * Language: C++
|
| *
|
| *
|
| *
|
| *
|
| *****************************************************************************
|
| */
|
|
|
|
|
| #include <string.h>
|
| #include <limits.h>
|
| #include <windows.h> // added by ODBC
|
| #ifdef NA_MXCS
|
| #undef NA_LITTLE_ENDIAN
|
| #else
|
| #include "Platform.h"
|
| #endif
|
|
|
| //#if defined (NA_LITTLE_ENDIAN) || defined(NA_MXCS) // commented out by ODBC
|
| #ifndef NSK_PLATFORM
|
| #include <math.h>
|
| #define MathPow(op1, op2, err) pow(op1, op2)
|
| #else
|
| //#ifdef NA_NSK
|
| #include "ieeemath.h"
|
| #endif //NA_NSK
|
|
|
| #define EXE_CONVERT_STRING_ERROR -8413
|
| #define EXE_NUMERIC_OVERFLOW -8411
|
| //#define EXE_UNSIGNED_OVERFLOW -8432 // commented out by ODBC
|
| #define EXE_STRING_OVERFLOW -8402
|
| #define EXE_CONVERT_INTERVAL_ERROR -8422
|
| #define SQL_SMALL_SIZE 2
|
| #define SQL_INT_SIZE 4
|
| #define SQL_LARGE_SIZE 8
|
|
|
| #define REC_DATE_YEAR 1
|
| #define REC_DATE_MONTH 2
|
| #define REC_DATE_DAY 3
|
| #define REC_DATE_HOUR 4
|
| #define REC_DATE_MINUTE 5
|
| #define REC_DATE_SECOND 6
|
|
|
| // interval datatypes
|
| #define REC_MIN_INTERVAL 195
|
| #define REC_INT_YEAR 195
|
| #define REC_INT_MONTH 196
|
| #define REC_INT_YEAR_MONTH 197
|
| #define REC_INT_DAY 198
|
| #define REC_INT_HOUR 199
|
| #define REC_INT_DAY_HOUR 200
|
| #define REC_INT_MINUTE 201
|
| #define REC_INT_HOUR_MINUTE 202
|
| #define REC_INT_DAY_MINUTE 203
|
| #define REC_INT_SECOND 204
|
| #define REC_INT_MINUTE_SECOND 205
|
| #define REC_INT_HOUR_SECOND 206
|
| #define REC_INT_DAY_SECOND 207
|
| #define REC_MAX_INTERVAL 208
|
|
|
| #define REC_NUM_BIG_UNSIGNED 155
|
| #define REC_NUM_BIG_SIGNED 156
|
|
|
| #define MSB_CLR_MSK 0x7F
|
| #define MSB_SET_MSK 0x80
|
|
|
| #if defined (NA_LITTLE_ENDIAN) || defined(NA_MXCS)
|
| typedef _int64 Int64;
|
| #else // added by ODBC
|
| typedef long long int Int64; // ditto
|
| #endif // ditto
|
|
|
| #ifndef NSK_PLATFORM // ditto
|
| #define BIGN_CLR_SIGN(bignum, len) (((char*)bignum)[len - 1] &= MSB_CLR_MSK);
|
| #define BIGN_SET_SIGN(bignum, len) (((char*)bignum)[len - 1] |= MSB_SET_MSK);
|
| #define BIGN_GET_SIGN(bignum, len) \
|
| ((char)(((char*)bignum)[len - 1] & MSB_SET_MSK));
|
| #else
|
| //typedef long long int Int64; // commented out by ODBC
|
|
|
| #define BIGN_CLR_SIGN(bignum, len) (((char*)bignum)[len - 2] &= MSB_CLR_MSK);
|
| #define BIGN_SET_SIGN(bignum, len) (((char*)bignum)[len - 2] |= MSB_SET_MSK);
|
| #define BIGN_GET_SIGN(bignum, len) \
|
| ((char)(((char*)bignum)[len - 2] & MSB_SET_MSK));
|
|
|
| #endif
|
|
|
| #ifndef NSK_PLATFORM
|
| #ifndef LLONG_MAX
|
| #define LLONG_MAX _I64_MAX
|
| #endif
|
| // The .NET 2003 headers changed the way LLONG_MIN is defined, which
|
| // causes problems when LLONG_MIN is cast to a double. Previously
|
| // LLONG_MIN was defined to I64_MIN, which works correctly. Redefine
|
| // it here so things work correctly. This only affects NT builds.
|
| #undef LLONG_MIN
|
| #define LLONG_MIN _I64_MIN
|
|
|
| #else
|
|
|
| #ifndef LLONG_MAX
|
| #define LLONG_MAX 9223372036854775807
|
| #endif
|
|
|
| #ifndef LLONG_MIN
|
| #define LLONG_MIN (-9223372036854775807-1)
|
| #endif
|
| #endif
|
|
|
| static const unsigned short powersOfTen[] = {10, // 10^1
|
| 100, // 10^2
|
| 1000, // 10^3
|
| 10000}; // 10^4
|
|
|
| // The following method converts a given BCD string representation (without sign,
|
| // and with the more significant decimal digits in the lower addresses)
|
| // into its equivalent Big Num representation.
|
|
|
| static short BigNumHelper_ConvBcdToBigNumHelper(long sourceLength,
|
| long targetLength,
|
| char * sourceData,
|
| char * targetData)
|
| {
|
| // Recast from bytes to unsigned shorts.
|
| long targetLengthInShorts = targetLength/2;
|
| unsigned short * targetDataInShorts = (unsigned short *) targetData;
|
|
|
| // Initialize the Big Num to zero.
|
| int i = 0;
|
| for (i = 0; i < targetLengthInShorts; i++)
|
| targetDataInShorts[i] = 0;
|
| long finalTargetLengthInShorts = 1;
|
|
|
| // Ignore leading zeros in BCD. If all zeros, return.
|
| long zeros = 0;
|
| while (zeros < sourceLength && !sourceData[zeros])
|
| zeros++;
|
| if (zeros == sourceLength)
|
| return 0;
|
|
|
| int actualSourceLength = sourceLength - zeros;
|
| char * actualSourceData = sourceData + zeros;
|
|
|
| //#if defined (NA_LITTLE_ENDIAN) || defined(NA_MXCS) // commented out by ODBC
|
| #ifndef NSK_PLATFORM // added by ODBC
|
| union {
|
| unsigned int temp;
|
| struct {
|
| unsigned short remainder;
|
| unsigned short carry;
|
| } tempParts;
|
| };
|
| #else
|
| union {
|
| unsigned int temp;
|
| struct {
|
| unsigned short carry;
|
| unsigned short remainder;
|
| } tempParts;
|
| };
|
| #endif
|
|
|
| // Compute the Big Num as follows. First, chunk up the BCD
|
| // string into chunks of 4-digit unsigned short numbers. Iterate
|
| // over these chunks, and at each iteration, multiply the current
|
| // Big Num by 10^4 and then add the numeric value of this chunk
|
| // to it.
|
| for (i = 0; i < actualSourceLength; i += 4) {
|
|
|
| // Compute the numeric value of the next 4-digit chunk.
|
| unsigned short temp1 = 0;
|
| int j = 0;
|
| while ((j < 4) && (i+j < actualSourceLength)) {
|
| temp1 = temp1*10 + actualSourceData[i+j];
|
| j++;
|
| }
|
| unsigned short power = powersOfTen[j - 1];
|
|
|
| // Multiply the previous Big Num by 10^4 and add the value
|
| // of the current chunk to it. It is more efficient to insert the
|
| // multiplication and addition code here than to call the Helper()
|
| // methods.
|
| temp = ((unsigned long) targetDataInShorts[0]) * power + temp1;
|
| targetDataInShorts[0] = tempParts.remainder;
|
| for (j = 1; j < finalTargetLengthInShorts; j++) {
|
| temp = ((unsigned long) targetDataInShorts[j]) * power + tempParts.carry;
|
| targetDataInShorts[j] = tempParts.remainder;
|
| }
|
| if (tempParts.carry) {
|
| if (finalTargetLengthInShorts >= targetLengthInShorts)
|
| return -1;
|
| finalTargetLengthInShorts++;
|
| targetDataInShorts[finalTargetLengthInShorts - 1] = tempParts.carry;
|
| }
|
| }
|
|
|
| return 0;
|
|
|
| }
|
|
|
| // The following method converts a given BCD string representation
|
| // (with sign, and with the more significant decimal digits in the lower
|
| // addresses) into its equivalent Big Num representation.
|
|
|
| static short BigNumHelper_ConvBcdToBigNumWithSignHelper(long sourceLength,
|
| long targetLength,
|
| char * sourceData,
|
| char * targetData)
|
| {
|
| short result = BigNumHelper_ConvBcdToBigNumHelper(sourceLength - 1,
|
| targetLength,
|
| sourceData + 1,
|
| targetData);
|
|
|
| // Set up sign.
|
| if (sourceData[0] == '-')
|
| BIGN_SET_SIGN(targetData, targetLength);
|
|
|
| return result;
|
| }
|
|
|
|
|
|
|
| // The following method converts a given Big Num (with sign) into
|
| // its equivalent BCD string representation (with the more significant
|
| // decimal digits in the lower addresses).
|
|
|
| // The following method converts a given Big Num (without sign) into
|
| // its equivalent BCD string representation (with the more significant decimal
|
| // digits in the lower addresses).
|
|
|
| static short BigNumHelper_ConvBigNumToBcdHelper(long sourceLength,
|
| long targetLength,
|
| char * sourceData,
|
| char * targetData)
|
| {
|
| // Recast from bytes to unsigned shorts.
|
| long sourceLengthInShorts = sourceLength/2;
|
| unsigned short * sourceDataInShorts = (unsigned short *) sourceData;
|
|
|
| unsigned short * tempSourceDataInShorts = new unsigned short [sourceLength/2];
|
|
|
|
|
| int i = 0;
|
| for (i = 0; i < sourceLengthInShorts; i++)
|
| tempSourceDataInShorts[i] = sourceDataInShorts[i];
|
|
|
| // Initialize the BCD to zero.
|
| for (i = 0; i < targetLength; i++)
|
| targetData[i] = 0;
|
| char * finalTargetData = targetData + targetLength - 1;
|
| long finalTargetLength = 1;
|
|
|
| // Ignore trailing zeros in the Big Num. If all zeros, return.
|
| long actualSourceLengthInShorts = sourceLengthInShorts;
|
| while (!tempSourceDataInShorts[actualSourceLengthInShorts - 1] && actualSourceLengthInShorts > 0)
|
| actualSourceLengthInShorts--;
|
| if (!actualSourceLengthInShorts) {
|
| delete tempSourceDataInShorts;
|
| return 0;
|
| }
|
|
|
| union {
|
| //unsigned int temp; // commented out by ODBC
|
| unsigned long temp; // added by ODBC
|
| unsigned short temp1[2];
|
| };
|
|
|
| unsigned short remainder = 0;
|
|
|
| // Compute the final BCD as follows. Keep dividing the Big Num by 10^4
|
| // until the quotient becomes less than 10^4. At each iteration, compute
|
| // the 4-digit BCD representation of the remainder, and append it to the
|
| // left of the final BCD. For the final remainder, compute its BCD
|
| // representation (which may be less than 4-digits) and append it to the
|
| // left of the final BCD.
|
|
|
| finalTargetData++;
|
| finalTargetLength = 0;
|
| while ((actualSourceLengthInShorts != 1) ||
|
| (tempSourceDataInShorts[actualSourceLengthInShorts - 1] >= 10000)) {
|
|
|
| // Divide the Big Num by 10^4. It is more efficient to insert
|
| // the division code than to call SimpleDivideHelper();
|
| int j = 0;
|
| for (j = actualSourceLengthInShorts - 1; j >= 0; j--) {
|
|
|
| //#if defined (NA_LITTLE_ENDIAN) || defined(NA_MXCS) //commented out by ODBC
|
| #ifndef NSK_PLATFORM // added by ODBC
|
| temp1[0] = tempSourceDataInShorts[j];
|
| temp1[1] = remainder;
|
| #else
|
| temp1[1] = tempSourceDataInShorts[j];
|
| temp1[0] = remainder;
|
| #endif
|
|
|
| tempSourceDataInShorts[j] = (unsigned short) (temp / 10000);
|
| remainder = (unsigned short) (temp % 10000);
|
| }
|
| if (!tempSourceDataInShorts[actualSourceLengthInShorts - 1])
|
| actualSourceLengthInShorts--;
|
|
|
| // Compute the BCD representation of the remainder and append to the
|
| // left of the final BCD.
|
| for (j = 0; j < 4; j++) {
|
| if (finalTargetLength >= targetLength) {
|
| delete tempSourceDataInShorts;
|
| return -1;
|
| }
|
| finalTargetData--;
|
| finalTargetLength++;
|
| finalTargetData[0] = remainder % 10;
|
| remainder = remainder / 10;
|
| }
|
| }
|
|
|
| // Compute the BCD representation of the final remainder and append to the
|
| // left of the final BCD.
|
| remainder = tempSourceDataInShorts[0];
|
| while (remainder) {
|
| if (finalTargetLength >= targetLength) {
|
| delete tempSourceDataInShorts;
|
| return -1;
|
| }
|
| finalTargetData--;
|
| finalTargetLength++;
|
| finalTargetData[0] = remainder % 10;
|
| remainder = remainder / 10;
|
| }
|
|
|
| delete tempSourceDataInShorts;
|
| return 0;
|
|
|
| }
|
|
|
| static short BigNumHelper_ConvBigNumWithSignToBcdHelper(long sourceLength,
|
| long targetLength,
|
| char * sourceData,
|
| char * targetData)
|
| {
|
| char sign = BIGN_GET_SIGN(sourceData, sourceLength);
|
|
|
| // Set up sign.
|
| targetData[0] = (sign) ? '-' : '+';
|
|
|
| // Temporarily clear source sign
|
| BIGN_CLR_SIGN(sourceData, sourceLength);
|
|
|
| short result = BigNumHelper_ConvBigNumToBcdHelper(sourceLength,
|
| targetLength - 1,
|
| sourceData,
|
| targetData + 1);
|
|
|
| // Restore sign
|
| if (sign)
|
| BIGN_SET_SIGN(sourceData, sourceLength);
|
|
|
| return result;
|
| }
|
|
|
| static short convInt64ToDecMxcs(char *target, long targetLen, Int64 source)
|
| {
|
| unsigned long flags = 0;
|
| bool negative = (source < 0);
|
| long currPos = targetLen - 1;
|
| char offset = '0';
|
|
|
| if (negative && (currPos >= 0)) {
|
| if (source == LLONG_MIN) {
|
| // before we can convert this to a positive number, we have to
|
| // work on the first digit. Otherwise, we would cause an overflow.
|
| int temp = (int)(source % 10);
|
| target[currPos--] = (char)('0' + (temp < 0 ? -temp: temp));
|
| source /= 10;
|
| }
|
| // now make source positive
|
| source = -source;
|
| }
|
|
|
| while (source != 0) {
|
| if (currPos < 0) {
|
| // target is not long enough - overflow
|
| return EXE_STRING_OVERFLOW;
|
| }
|
|
|
| //#pragma nowarn(1506) // warning elimination
|
| target[currPos--] = /*'0' + */(char)(source % 10); // NOTE - ODBC MUST not have '0'
|
| //#pragma warn(1506) // warning elimination
|
| source /= 10;
|
| }
|
|
|
| // zero pad the leading spaces
|
| while (currPos >= 0)
|
| target[currPos--] = '0' - offset;
|
|
|
| if (negative)
|
| target[0] |= 0200;
|
|
|
| return 0;
|
| }
|
|
|
| static short safe_add_digit_to_double(double dvalue, // Original value
|
| int digit, // Single digit to be added
|
| double * result
|
| )
|
| {
|
| *result = dvalue * 10 + digit;
|
| return 0;
|
| }
|
|
|
| static short convAsciiToFloat64Mxcs(char * target, char *source, long sourceLen)
|
| {
|
| short err = 0;
|
|
|
| double ptarget;
|
|
|
| // skip leading and trailing blanks and adjust source and sourceLen
|
| // accordingly
|
| long i = 0;
|
| for (; i < sourceLen && *source == ' '; i++)
|
| source++;
|
|
|
| if (i == sourceLen) {
|
| // string contains only blanks.
|
| return EXE_CONVERT_STRING_ERROR;
|
| }
|
|
|
| sourceLen -= i;
|
|
|
| // we know that we found at least one non-blank character.
|
| // so we just decrement sourceLen till we scanned all
|
| // trailing blanks
|
| while (source[sourceLen - 1] == ' ') {
|
| sourceLen--;
|
| }
|
|
|
| enum State {START, SKIP_BLANKS, MANT_BEFORE_SIGN, MANT_AFTER_SIGN,
|
| EXP_START, EXPONENT, xxERROR}; // ODBC changed ERROR to xxERROR
|
|
|
| int cp = 0;
|
| double mantissa = 0;
|
| double exponent = 0;
|
| bool negMantissa = false;
|
| bool negExponent = false;
|
| int numScale = 0;
|
| bool validNum = false;
|
|
|
| State state = START;
|
| bool skipChar;
|
| while (cp < sourceLen)
|
| {
|
| skipChar = false;
|
| // cout << "state = " << state << endl;
|
|
|
| switch (state)
|
| {
|
| case START:
|
| if ((source[cp] == '+') || (source[cp] == '-'))
|
| {
|
| if (source[cp] == '-')
|
| negMantissa = true;
|
| state = SKIP_BLANKS;
|
| skipChar = true;
|
| }
|
| else
|
| state = MANT_BEFORE_SIGN;
|
| break;
|
|
|
| case SKIP_BLANKS:
|
| if (source[cp] != ' ')
|
| state = MANT_BEFORE_SIGN;
|
| else
|
| skipChar = true;
|
| break;
|
|
|
| case MANT_BEFORE_SIGN:
|
| if (source[cp] == '.')
|
| {
|
| state = MANT_AFTER_SIGN;
|
| }
|
| else if ((source[cp] == 'E') || (source[cp] == 'e'))
|
| {
|
| validNum = false;
|
| state = EXP_START;
|
| }
|
| else if ((source[cp] < '0') || (source[cp] > '9'))
|
| state = xxERROR;
|
| else
|
| {
|
| if (safe_add_digit_to_double(mantissa,
|
| source[cp] - '0',
|
| &mantissa) != 0)
|
| {
|
| return EXE_NUMERIC_OVERFLOW;
|
| }
|
| validNum = true;
|
| }
|
| skipChar = true;
|
| break;
|
|
|
| case MANT_AFTER_SIGN:
|
| if ((source[cp] == 'E') || (source[cp] == 'e'))
|
| {
|
| if (!validNum)
|
| state = xxERROR;
|
| else
|
| {
|
| validNum = false;
|
| state = EXP_START;
|
| }
|
| }
|
| else if ((source[cp] < '0') || (source[cp] > '9'))
|
| state = xxERROR;
|
| else
|
| {
|
| numScale++;
|
| if (safe_add_digit_to_double(mantissa,
|
| source[cp] - '0',
|
| &mantissa) != 0)
|
| {
|
| return EXE_NUMERIC_OVERFLOW;
|
| }
|
| validNum = true;
|
| }
|
| skipChar = true;
|
| break;
|
|
|
| case EXP_START:
|
| if ((source[cp] == '+') || (source[cp] == '-'))
|
| {
|
| if (source[cp] == '-')
|
| negExponent = true;
|
| skipChar = true;
|
| }
|
| state = EXPONENT;
|
| break;
|
|
|
| case EXPONENT:
|
| if ((source[cp] < '0') || (source[cp] > '9'))
|
| state = xxERROR;
|
| else
|
| {
|
| if (safe_add_digit_to_double(exponent,
|
| source[cp] - '0',
|
| &exponent) != 0)
|
| {
|
| return EXE_NUMERIC_OVERFLOW;
|
| }
|
| validNum = true;
|
| }
|
| skipChar = true;
|
| break;
|
|
|
| case xxERROR:
|
| // string contains only blanks.
|
| return EXE_CONVERT_STRING_ERROR;
|
| break;
|
|
|
| default:
|
| state = xxERROR;
|
| break;
|
|
|
| } // switch state
|
|
|
| if ((state != xxERROR) && (skipChar))
|
| cp++;
|
| } // while
|
|
|
| if (!validNum)
|
| {
|
| return EXE_CONVERT_STRING_ERROR;
|
| };
|
|
|
| double scale = MathPow(10.0, (double)numScale, err);
|
| if (err)
|
| {
|
| return EXE_NUMERIC_OVERFLOW;
|
| }
|
|
|
| if (negMantissa)
|
| mantissa = - mantissa;
|
|
|
| mantissa = mantissa / scale;
|
|
|
| if (negExponent)
|
| exponent = - exponent;
|
| exponent = MathPow(10.0, exponent, err);
|
| if (err)
|
| {
|
| return EXE_NUMERIC_OVERFLOW;
|
| }
|
| ptarget = mantissa * exponent;
|
|
|
| if (target)
|
| {
|
| memcpy(target, (char*)&ptarget, sizeof(double));
|
| }
|
|
|
| // conversion was OK
|
| return 0;
|
| };
|
|
|
|
|
| ///////////////////////////////////////////////////////////////////
|
| // function to convert an ASCII string to DEC or LARGEDEC
|
| // the first character of a LARGEDEC is a sign and is ignored here.
|
| // In fact, call has to pass in &target[1], targetLen - 1, and
|
| // offset = '0', if the conversion is ASCII -> LARGEDEC.
|
| // if conversion is ASCII -> DEC, caller has to pass
|
| // &target[0], targetLen, and offset = 0.
|
| // Also, this function always sets the sign bit for DEC if the
|
| // source is negative. For LARGEDEC this has to be changed
|
| // accordingly.
|
| // The function assumes that source is at least
|
| // sourceLen long. Trailing '\0' is not recongnized
|
| ///////////////////////////////////////////////////////////////////
|
| static short convAsciiToDecMxcs(char *target,
|
| long targetLen,
|
| long targetScale,
|
| char *source,
|
| long sourceLen,
|
| char offset,
|
| BOOL *truncation) { // added by ODBC
|
|
|
| short negative = 0; // default is a positive value
|
| long sourceStart = 0; // start of source after skipping 0 and ' '
|
| long sourceScale = 0; // by default the scale is 0
|
| long targetPos = targetLen - 1; // current positon in the target
|
|
|
| // skip leading blanks
|
| while ((sourceStart < sourceLen) && (source[sourceStart] == ' '))
|
| sourceStart++;
|
|
|
| // only blanks found, error
|
| if (sourceStart == sourceLen) {
|
| return EXE_CONVERT_STRING_ERROR;
|
| };
|
|
|
| // skip trailing blanks. We know that we found already some
|
| // non-blank character, thus sourceLen is always > sourceStart
|
| while (source[sourceLen - 1] == ' ')
|
| sourceLen--;
|
|
|
| // if the string contains 'e' or 'E' it actually represents
|
| // a float value. Do a ASCII -> DOUBLE -> DEC
|
| // use a for-loop to find the 'e'. If we find one, we do the
|
| // described conversion and return. If we do not find one,
|
| // we go on with this function.
|
| // Also, start at the end of the string, if we have an 'e' it
|
| // is probably closer to the end.
|
| for (long i = sourceLen - 1; i >= sourceStart; i--) {
|
| if (source[i] == 'E' || source[i] == 'e') {
|
| // found a float representation.
|
|
|
| double intermediate;
|
| if (convAsciiToFloat64Mxcs((char*)&intermediate,
|
| &source[sourceStart],
|
| sourceLen - sourceStart))
|
|
|
| return EXE_CONVERT_STRING_ERROR;
|
|
|
| // scale the intermediate
|
| for (long j = 0; j < targetScale; j++) {
|
| intermediate *= 10.0;
|
|
|
| if ((intermediate < LLONG_MIN) || (intermediate > LLONG_MAX)) {
|
| return EXE_NUMERIC_OVERFLOW;
|
| };
|
| }
|
|
|
| if (convInt64ToDecMxcs(target,
|
| targetLen,
|
| (Int64) intermediate))
|
| return EXE_CONVERT_STRING_ERROR;
|
| return 0;
|
| }
|
| }
|
|
|
| // the string does not represent a float value. Go on with
|
| // the processing
|
| long sourcePos = sourceLen - 1; // current position in the string
|
|
|
| // check for sign
|
| if (source[sourceStart] == '+')
|
| sourceStart++;
|
| else if (source[sourceStart] == '-') {
|
| negative = 1;
|
| sourceStart++;
|
| };
|
|
|
| // skip leading zeros
|
| while((sourceStart < sourceLen) && (source[sourceStart] == '0'))
|
| sourceStart++;
|
|
|
| // only zeros found, target is 0
|
| if (sourceStart == sourceLen) {
|
| memset(target, '0' - offset, targetLen);
|
| return 0;
|
| };
|
|
|
| // determine the scale of the source
|
| long index = sourceStart;
|
| long pointPos = -1;
|
| while ((index < sourceLen) && pointPos < 0) {
|
| if (source[index] == '.')
|
| pointPos = index;
|
| else
|
| index++;
|
| };
|
| if (pointPos >= 0)
|
| // determine sourceScale
|
| sourceScale = sourceLen - pointPos - 1;
|
|
|
| short raiseOverflowWarning = 0;
|
|
|
| // procress digits, start from end
|
| while ((sourcePos >= sourceStart) && (targetPos >= 0)) {
|
| // add zeros to adjust scale
|
| if (targetScale > sourceScale) {
|
| target[targetPos--] = '0' - offset;
|
| targetScale--;
|
| }
|
| else if (targetScale < sourceScale) {
|
| // skip source digits
|
| // but at least one of the digits skipped is not a '0', then
|
| // a EXE_NUMERIC_OVERFLOW warning needs to be raised
|
| if (source[sourcePos] != '0')
|
| raiseOverflowWarning = 1;
|
| sourcePos--;
|
| sourceScale--;
|
| }
|
| else if (sourcePos == pointPos) {
|
| // simply skip the decimal point
|
| sourcePos--;
|
| }
|
| else {
|
| // if source is not a digit, we have an error
|
| if (source[sourcePos] < '0' || source[sourcePos] > '9') {
|
| return EXE_CONVERT_STRING_ERROR;
|
| };
|
| // copy source to target
|
| target[targetPos--] = source[sourcePos--] - offset;
|
| };
|
| };
|
|
|
| if (raiseOverflowWarning) // added by ODBC
|
| *truncation = TRUE; // added by ODBC
|
| // ExRaiseSqlWarning(heap, diagsArea, EXE_NUMERIC_OVERFLOW);
|
|
|
| // we might be right on the decimal point. Skip it before test for
|
| // overflow
|
| if (sourcePos == pointPos)
|
| sourcePos--;
|
|
|
| // if we couldn't copy all digits, we had an overflow
|
| if (sourcePos >= sourceStart) {
|
| return EXE_NUMERIC_OVERFLOW;
|
| };
|
|
|
| // left pad the target with zeros
|
| while (targetPos >= 0)
|
| target[targetPos--] = '0' - offset;
|
|
|
| // add sign
|
| if (negative)
|
| target[0] |= 0200;
|
|
|
| return 0;
|
| };
|
|
|
|
|
| //////////////////////////////////////////////////////////////////
|
| // function to convert BIGNUM to LARGEDEC
|
| ///////////////////////////////////////////////////////////////////
|
| static short convBigNumToLargeDecMxcs(char *target,
|
| long targetLen,
|
| char *source,
|
| long sourceLen)
|
| {
|
|
|
| // Convert the Big Num (with sign) into a BCD representation by calling
|
| // a BigNumHelper method
|
| short retCode = BigNumHelper_ConvBigNumWithSignToBcdHelper(sourceLen,
|
| targetLen,
|
| source,
|
| target);
|
| if (retCode == -1) {
|
| // target is not long enough - overflow
|
| return EXE_NUMERIC_OVERFLOW;
|
| };
|
|
|
| return 0;
|
| }
|
|
|
| //////////////////////////////////////////////////////////////////
|
| // function to convert a LARGEDEC to an ASCII string
|
| // Trailing '\0' is not set!
|
| //
|
| // For fixed char target, left pad blanks if leftPad is true, or
|
| // right pad blanks otherwise.
|
| //
|
| // For varchar target, left-justify string without blank pads
|
| // to the right.
|
| //
|
| // convDoIt sets leftPad to true if callers pass in a
|
| // CONV_UNKNOWN_LEFTPAD to convDoIt.
|
| ///////////////////////////////////////////////////////////////////
|
| static short convLargeDecToAsciiMxcs(char *target,
|
| long targetLen,
|
| char *source,
|
| long sourceLen,
|
| long sourceScale,
|
| char * varCharLen,
|
| long varCharLenSize,
|
| short leftPad)
|
| {
|
|
|
| if(source[0] < 2)
|
| {
|
| unsigned short realSource[256];
|
| memcpy((char *)realSource, source, sourceLen);
|
|
|
| if(realSource[0]) source[0] = '-';
|
| else source[0] = '+';
|
|
|
| int realLength = 1+(sourceLen-2)/5;
|
| for(int srcPos=sourceLen-1; srcPos; srcPos--)
|
| {
|
| unsigned long r = 0;
|
| for(int i=1; i<=realLength; i++)
|
| {
|
| unsigned long q = (realSource[i] + r) / 10;
|
| r = (r + realSource[i]) - 10 * q;
|
| realSource[i] = (short)q;
|
| r <<= 16;
|
| }
|
| source[srcPos] = (char)(r >>= 16);
|
| }
|
| }
|
|
|
| if (targetLen < sourceLen) targetLen = sourceLen; // added by ODBC
|
|
|
| if (varCharLenSize)
|
| leftPad = 0;
|
| // skip leading zeros; start with index == 1; index == 0 is sign
|
| // stop looking one position before the decimal point. This
|
| // position is sourceLen - sourceScale - 1
|
| long currPos = 1;
|
| while ((currPos < (sourceLen - sourceScale - 1)) && source[currPos] == 0)
|
| currPos++;
|
|
|
| long padLen = targetLen;
|
| if (source[0] == '-')
|
| padLen--;
|
| long requiredDigits = sourceLen - currPos - sourceScale;
|
|
|
| padLen -= requiredDigits;
|
|
|
| if (padLen < 0)
|
| requiredDigits -= padLen;
|
|
|
| if (sourceScale) {
|
| if (padLen > 1) { // fraction exists
|
| padLen--; // for decimal point
|
| sourceScale = (sourceScale < padLen ? sourceScale : padLen);
|
| padLen -= sourceScale;
|
| }
|
| else // no fraction
|
| sourceScale = 0;
|
| }
|
|
|
| long targetPos = 0;
|
|
|
| // if target is fixed length and leftPad, left pad blanks
|
| // commented out by ODBC
|
| /*
|
| if (leftPad) {
|
| for (; targetPos < padLen; targetPos++)
|
| target[targetPos] = ' ';
|
| }
|
| */
|
| // commented out by ODBC
|
|
|
| // fill in sign
|
| if (source[0] == '-')
|
| target[targetPos++] = '-';
|
|
|
| // fill in digits
|
| long i = 0;
|
| for (i = 0; i < requiredDigits; i++, targetPos++, currPos++)
|
| target[targetPos] = source[currPos] + '0';
|
|
|
| // if we have a scale, add decimal point and some digits
|
| if (sourceScale) {
|
| target[targetPos++] = '.';
|
| for (i = 0; i < sourceScale; i++, targetPos++, currPos++)
|
| target[targetPos] = source[currPos] + '0';
|
| };
|
|
|
| // Right pad blanks for fixed char.
|
| if (!leftPad && !varCharLenSize)
|
| while (targetPos < targetLen)
|
| target[targetPos++] = ' ';
|
|
|
| // set length field for variable length targets
|
| if (varCharLenSize) {
|
| if (varCharLenSize == sizeof(long))
|
| memcpy(varCharLen, (char *) &targetPos, sizeof(long));
|
| else {
|
| short VCLen = (short) targetPos;
|
| memcpy(varCharLen, (char *) &VCLen, sizeof(short));
|
| };
|
| };
|
|
|
| target[targetPos] = '\0'; // added by ODBC
|
|
|
| // make sure that the source fits in the target
|
| // we might skip some digits after the decimal point
|
| // to make it fit
|
| if (padLen < 0) {
|
| // target string is not long enough - overflow
|
| return EXE_STRING_OVERFLOW;
|
| };
|
| return 0;
|
| };
|
|
|
|
|
| //////////////////////////////////////////////////////////////////////////
|
| // *********************************
|
| //////////////////////////////////////////////////////////////////////////
|
|
|
| ///////////////////////////////////////////////////////////////////
|
| // function to convert an ASCII string to BIGNUM.
|
| //
|
| // First convert from ASCII to LARGEDEC, then convert from LARGEDEC
|
| // to BIGNUM
|
| ///////////////////////////////////////////////////////////////////
|
| static short convAsciiToBigNumMxcs(char *target,
|
| long targetLen,
|
| // long targetType, // commented out by ODBC
|
| long targetPrecision,
|
| long targetScale,
|
| char *source,
|
| long sourceLen,
|
| BOOL *truncation) // added by ODBC
|
| {
|
| short retCode = 0;
|
| // Convert from ASCII to an intermediate LARGEDEC, using the function convAsciiToDec().
|
| // To understand this function call, it will be helpful to review the
|
| // comments in its definition earlier.
|
| char * intermediateLargeDec = new char[targetPrecision + 1];
|
| retCode = convAsciiToDecMxcs(intermediateLargeDec + 1,
|
| targetPrecision,
|
| targetScale,
|
| source,
|
| sourceLen,
|
| '0',
|
| truncation); // added by ODBC
|
| if (retCode)
|
| {
|
| delete intermediateLargeDec;
|
| return retCode;
|
| }
|
|
|
| /* // commented out by ODBC
|
| if ((targetType == REC_NUM_BIG_UNSIGNED) &&
|
| (intermediateLargeDec[1] &0200))
|
| {
|
| delete intermediateLargeDec;
|
|
|
| return EXE_UNSIGNED_OVERFLOW;
|
| }
|
| */ // commented out by ODBC
|
|
|
| // Set the sign byte in the intermediate LARGEDEC.
|
| if (intermediateLargeDec[1] &0200) {
|
| // reset the bit
|
| intermediateLargeDec[1] &= 0177;
|
| intermediateLargeDec[0] = '-';
|
| }
|
| else
|
| intermediateLargeDec[0] = '+';
|
|
|
| // Convert from the intermediate LARGEDEC to BIGNUM using a BigNumHelper method.
|
| retCode = BigNumHelper_ConvBcdToBigNumWithSignHelper(targetPrecision + 1,
|
| targetLen,
|
| intermediateLargeDec,
|
| target);
|
| delete intermediateLargeDec;
|
|
|
| if (retCode == -1) {
|
| // target is not long enough - overflow
|
| return EXE_NUMERIC_OVERFLOW;
|
| };
|
|
|
| return 0;
|
| }
|
|
|
| //////////////////////////////////////////////////////////////////
|
| // function to convert a BIGNUM to an ASCII string
|
| // Trailing '\0' is not set!
|
| //
|
| // This function first converts the BIGNUM to an intermediate
|
| // LARGEDEC, then calls the previous function convLargeDecToAscii()
|
| ///////////////////////////////////////////////////////////////////
|
| /*static*/ short convBigNumToAsciiMxcs(char *target,
|
| long targetLen,
|
| char *source,
|
| long sourceLen,
|
| long sourcePrecision,
|
| long sourceScale)
|
| {
|
| char * intermediateLargeDec = new char[sourcePrecision + 1]; // one extra byte for the sign.
|
| short retCode = convBigNumToLargeDecMxcs(intermediateLargeDec,
|
| sourcePrecision + 1,
|
| source,
|
| sourceLen);
|
| if (retCode)
|
| return retCode;
|
|
|
| retCode = convLargeDecToAsciiMxcs(target,
|
| targetLen,
|
| intermediateLargeDec,
|
| sourcePrecision + 1,
|
| sourceScale,
|
| 0, 0,
|
| /* #ifdef NA_MXCS // commented out by ODBC
|
| 0); // ditto
|
| #else */ // ditto
|
| 1);
|
| //#endif // ditto
|
|
|
| delete intermediateLargeDec;
|
| return retCode;
|
| };
|
|
|
| static short getIntervalStartField(long datatype)
|
| {
|
| switch (datatype) {
|
| case REC_INT_YEAR: return REC_DATE_YEAR;
|
| case REC_INT_MONTH: return REC_DATE_MONTH;
|
| case REC_INT_YEAR_MONTH: return REC_DATE_YEAR;
|
| case REC_INT_DAY: return REC_DATE_DAY;
|
| case REC_INT_HOUR: return REC_DATE_HOUR;
|
| case REC_INT_DAY_HOUR: return REC_DATE_DAY;
|
| case REC_INT_MINUTE: return REC_DATE_MINUTE;
|
| case REC_INT_HOUR_MINUTE: return REC_DATE_HOUR;
|
| case REC_INT_DAY_MINUTE: return REC_DATE_DAY;
|
| case REC_INT_SECOND: return REC_DATE_SECOND;
|
| case REC_INT_MINUTE_SECOND: return REC_DATE_MINUTE;
|
| case REC_INT_HOUR_SECOND: return REC_DATE_HOUR;
|
| case REC_INT_DAY_SECOND: return REC_DATE_DAY;
|
| default:
|
| break;
|
| }
|
| return REC_DATE_YEAR;
|
| }
|
|
|
| static short getIntervalEndField(long datatype)
|
| {
|
| switch (datatype) {
|
| case REC_INT_YEAR: return REC_DATE_YEAR;
|
| case REC_INT_MONTH: return REC_DATE_MONTH;
|
| case REC_INT_YEAR_MONTH: return REC_DATE_MONTH;
|
| case REC_INT_DAY: return REC_DATE_DAY;
|
| case REC_INT_HOUR: return REC_DATE_HOUR;
|
| case REC_INT_DAY_HOUR: return REC_DATE_HOUR;
|
| case REC_INT_MINUTE: return REC_DATE_MINUTE;
|
| case REC_INT_HOUR_MINUTE: return REC_DATE_MINUTE;
|
| case REC_INT_DAY_MINUTE: return REC_DATE_MINUTE;
|
| case REC_INT_SECOND: return REC_DATE_SECOND;
|
| case REC_INT_MINUTE_SECOND: return REC_DATE_SECOND;
|
| case REC_INT_HOUR_SECOND: return REC_DATE_SECOND;
|
| case REC_INT_DAY_SECOND: return REC_DATE_SECOND;
|
| default:
|
| break;
|
| }
|
| return REC_DATE_YEAR;
|
| }
|
|
|
| //////////////////////////////////////////////////////////////////
|
| // This function count the number of digits in a non-negative Int64.
|
| // The function assumes that targetLen is 1 to 19, inclusive.
|
| ///////////////////////////////////////////////////////////////////
|
| static long getDigitCount(Int64 value)
|
| {
|
| static const Int64 decValue[] = {0,
|
| 9,
|
| 99,
|
| 999,
|
| 9999,
|
| 99999,
|
| 999999,
|
| 9999999,
|
| 99999999,
|
| 999999999,
|
| 9999999999,
|
| 99999999999,
|
| 999999999999,
|
| 9999999999999,
|
| 99999999999999,
|
| 999999999999999,
|
| 9999999999999999,
|
| 99999999999999999,
|
| 999999999999999999};
|
|
|
| for (int i = 4; i <= 16; i += 4)
|
| if (value <= decValue[i]) {
|
| if (value <= decValue[i-3])
|
| return(i-3);
|
| if (value <= decValue[i-2])
|
| return(i-2);
|
| if (value <= decValue[i-1])
|
| return(i-1);
|
| else return i;
|
| }
|
| if (value <= decValue[17])
|
| return 17;
|
| if (value <= decValue[18])
|
| return 18;
|
| return 19;
|
| }
|
| ///////////////////////////////////////////////////////////////////
|
| // function to convert interval field ASCII string to Int64
|
| // The function reads at most sourceLen number of characters.
|
| // Or until it encounters a non-digit character and sets the
|
| // sourceLen to the actual length of the string read if it is
|
| // smaller than sourceLen.
|
| // This function is used for ASCII to INTERVAL conversions only.
|
| // Blanks and sign are already removed.
|
| ///////////////////////////////////////////////////////////////////
|
| static short convAsciiFieldToInt64Mxcs(Int64 &target,
|
| long targetScale,
|
| char *source,
|
| long &sourceLen,
|
| unsigned long flags)
|
| {
|
| /* // the function is commented out by ODBC
|
| long currPos = 0; // current position in the string
|
| target = 0; // result
|
| while ((currPos < sourceLen) && ((source[currPos] >= '0') &&
|
| (source[currPos] <= '9')))
|
| {
|
| short thisDigit = source[currPos] - '0';
|
| if (target > (LLONG_MAX / 10))
|
| { // next power of 10 causes an overflow
|
| return EXE_NUMERIC_OVERFLOW;
|
| }
|
| target *= 10;
|
| if (target > LLONG_MAX - thisDigit)
|
| { // adding this digit causes an overflow
|
| return EXE_NUMERIC_OVERFLOW;
|
|
|
| }
|
| target += thisDigit;
|
| currPos++;
|
| }
|
| if (!currPos)
|
| {
|
| // No digits were found
|
| return EXE_CONVERT_STRING_ERROR;
|
| }
|
| // return the number of digits read
|
| sourceLen = currPos;
|
| */ // the function is commented out by ODBC
|
| return 0;
|
| };
|
|
|
| ///////////////////////////////////////////////////////////////////
|
| // function to convert an ASCII string to an interval datatype.
|
| ///////////////////////////////////////////////////////////////////
|
| static short convAsciiToIntervalMxcs(char *target,
|
| long targetLen,
|
| long targetDatatype,
|
| long leadingPrecision,
|
| long fractionPrecision,
|
| char *source,
|
| long sourceLen,
|
| short allowSignInInterval,
|
| unsigned long flags)
|
| {
|
| short retCode = 0;
|
|
|
| // skip leading and trailing blanks and adjust source and sourceLen
|
| // accordingly
|
| while ((sourceLen > 0) && (*source == ' '))
|
| {
|
| source++;
|
| sourceLen--;
|
| }
|
|
|
| if (!sourceLen)
|
| {
|
| // string contains no digits
|
| return EXE_CONVERT_INTERVAL_ERROR;
|
| };
|
|
|
| short negInterval = 0;
|
| if ((source[0] == '-') || (source[0] == '+')) {
|
| if (! allowSignInInterval)
|
| {
|
| // string starts with a sign - not allowed
|
| return EXE_CONVERT_INTERVAL_ERROR;
|
| }
|
| else
|
| {
|
| if (source[0] == '-')
|
| negInterval = 1;
|
| source += 1;
|
| sourceLen -= 1;
|
| }
|
| }
|
| // we know that we found at least one non-blank character.
|
| // so we just decrement sourceLen till we scanned all
|
| // trailing blanks
|
| while (source[sourceLen - 1] == ' ')
|
| sourceLen--;
|
|
|
| char delimiter[] = "^-^:::";
|
| unsigned short maxFieldValue[] = { 0, 11, 0, 23, 59, 59 };
|
|
|
| short start = getIntervalStartField(targetDatatype);
|
| short end = getIntervalEndField(targetDatatype);
|
|
|
| // convert the first field
|
| Int64 intermediate;
|
| long fieldLen = leadingPrecision;
|
| if (fieldLen > sourceLen)
|
| fieldLen = sourceLen; // so we don't read garbage past end of string
|
|
|
| retCode = convAsciiFieldToInt64Mxcs(intermediate,
|
| 0, // targetScale
|
| source,
|
| fieldLen,
|
| flags);
|
| if (retCode)
|
| return retCode;
|
|
|
| long strIndex = fieldLen;
|
| Int64 fieldValue;
|
|
|
| for (int field = start+1; field <= end; field++)
|
| {
|
| int index = field - REC_DATE_YEAR;
|
|
|
| // Make sure there is still some string left before we look
|
| // for the delimiter. The '+1' in the test also makes sure
|
| // there is at least one character after the delimiter.
|
| // Without the '+1', we get a strange string conversion
|
| // error, EXE_CONVERT_STRING_ERROR, instead of the more
|
| // reasonable interval conversion error,
|
| // EXE_CONVERT_INTERVAL_ERROR, on interval strings like
|
| // '20-'. Though interval strings like '20-hithere' will
|
| // still get EXE_CONVERT_STRING_ERROR.
|
| if (strIndex + 1 >= sourceLen)
|
| {
|
| return EXE_CONVERT_INTERVAL_ERROR;
|
| }
|
|
|
| // get the delimiter preceding this field
|
| if (source[strIndex] != delimiter[index])
|
| {
|
| // HOUR can be preceded by either ':' or ' '
|
| if ((field != REC_DATE_HOUR) || (source[strIndex] != ' '))
|
| {
|
| return EXE_CONVERT_INTERVAL_ERROR;
|
| }
|
| }
|
|
|
| strIndex++; // step over delimiter
|
| fieldLen = 2;
|
| if (fieldLen > sourceLen - strIndex)
|
| fieldLen = sourceLen - strIndex; // don't go off end of string
|
|
|
| // convert the next field
|
| retCode = convAsciiFieldToInt64Mxcs(fieldValue,
|
| 0, // targetScale
|
| &source[strIndex],
|
| fieldLen,
|
| flags);
|
| if (retCode)
|
| return retCode;
|
|
|
| if (fieldValue > maxFieldValue[index])
|
| {
|
| return EXE_CONVERT_INTERVAL_ERROR;
|
| }
|
| strIndex += fieldLen;
|
| intermediate = intermediate * (maxFieldValue[index]+1) + fieldValue;
|
| }
|
|
|
| // adjust the value for fractionPrecision
|
| for (short i = 0; i < fractionPrecision; i++)
|
| {
|
| intermediate *= 10;
|
| }
|
|
|
| // if the end field is SECOND, it may have a fractional part
|
| if ((end == REC_DATE_SECOND) && (source[strIndex] == '.'))
|
| {
|
| long sourcePrecision = (sourceLen - strIndex - 1);
|
| unsigned long fraction = 0;
|
| if (sourcePrecision)
|
| {
|
| Int64 interm;
|
| retCode = convAsciiFieldToInt64Mxcs(interm,
|
| 0,
|
| &source[strIndex+1],
|
| sourcePrecision, // sourceLen
|
| flags);
|
| if (retCode)
|
| return retCode;
|
|
|
| if (interm < 0)
|
| {
|
| return EXE_NUMERIC_OVERFLOW;
|
| }
|
| else if (interm > ULONG_MAX)
|
| {
|
| return EXE_NUMERIC_OVERFLOW;
|
| }
|
| else
|
| {
|
| *(unsigned int *)target = (unsigned long) interm;
|
| }
|
| };
|
|
|
| // scale up or down if necessary
|
| while (sourcePrecision < fractionPrecision)
|
| {
|
| fraction *= 10;
|
| sourcePrecision++;
|
| }
|
|
|
| unsigned long oldFraction = fraction;
|
| unsigned long scaleDownValue = 1;
|
|
|
| while (sourcePrecision > fractionPrecision)
|
| {
|
| fraction /= 10;
|
| scaleDownValue *= 10;
|
| sourcePrecision--;
|
| }
|
|
|
| // Detect if meaningful scale truncation has occured. If so, raise an error
|
| if (oldFraction > (fraction * scaleDownValue)) {
|
| return EXE_CONVERT_INTERVAL_ERROR;
|
| }
|
|
|
| intermediate += fraction;
|
| }
|
| else
|
| {
|
| // check if the string is completely converted
|
| if (strIndex != sourceLen)
|
| {
|
| return EXE_CONVERT_INTERVAL_ERROR;
|
| }
|
| }
|
|
|
| switch (targetLen)
|
| {
|
| case SQL_SMALL_SIZE:
|
| if ((intermediate < SHRT_MIN) || (intermediate > SHRT_MAX))
|
| {
|
| return EXE_CONVERT_INTERVAL_ERROR;
|
| };
|
| if (negInterval)
|
| *(short *)target = -(short)intermediate;
|
| else
|
| *(short *)target = (short)intermediate;
|
| break;
|
|
|
| case SQL_INT_SIZE:
|
| if ((intermediate < INT_MIN) || (intermediate > INT_MAX))
|
| {
|
| return EXE_CONVERT_INTERVAL_ERROR;
|
| };
|
| if (negInterval)
|
| *(int *)target = -(int)intermediate;
|
| else
|
| *(int *)target = (int)intermediate;
|
| break;
|
|
|
| case SQL_LARGE_SIZE:
|
| if (negInterval)
|
| *(Int64 *)target = -intermediate;
|
| else
|
| *(Int64 *)target = intermediate;
|
| break;
|
|
|
| default:
|
| return EXE_CONVERT_INTERVAL_ERROR;
|
| }
|
| return 0;
|
| };
|
| //////////////////////////////////////////////////////////////////
|
| // function to convert an Int64 to an ASCII string
|
| // Trailing '\0' is not set!
|
| //
|
| // For fixed char targets, left pad fillers if leftPad is
|
| // true, or right pad fillers (default mode) otherwise.
|
| //
|
| // convDoIt sets leftPad to true if callers pass in a
|
| // CONV_UNKNOWN_LEFTPAD to convDoIt.
|
| //
|
| // In only a few cases of fixed char, leftPad will be set to true.
|
| // e.g., caller wants to convert 7 -> 07 as in month -> ascii
|
| // or 8 -> ' 8' as in sqlci display
|
| ///////////////////////////////////////////////////////////////////
|
| static short convInt64ToAsciiMxcs(char *target,
|
| long targetLen,
|
| Int64 source,
|
| long scale,
|
| char filler,
|
| short leadingSign,
|
| short leftPad)
|
| {
|
| long digitCnt = 0;
|
| short negative = (source < 0);
|
| short fixRightMost = 0; // true if need to fix the rightmost digit.
|
|
|
| long padLen = targetLen;
|
| long requiredDigits = 0;
|
| long leftMost; // leftmost digit.
|
| long rightMost; // rightmost digit.
|
| long sign = 0;
|
|
|
| // Int64 newSource = (negative ? -source : source);
|
| Int64 newSource = 0;
|
| if ((negative) && (source == 0x8000000000000000)) // = -2 ** 63
|
| {
|
| newSource = 0x7fffffffffffffff;
|
| // 123456789012345
|
| digitCnt = 19;
|
| fixRightMost = 1;
|
| }
|
| else
|
| {
|
| newSource = (negative ? -source : source);
|
| digitCnt = getDigitCount(newSource);
|
| }
|
|
|
| if (leadingSign || negative) {
|
| sign = 1;
|
| padLen--;
|
| }
|
| // No truncation allowed.
|
| requiredDigits = digitCnt;
|
| // Add extra zero's.
|
| if (scale > requiredDigits)
|
| requiredDigits += (scale - requiredDigits);
|
| padLen -= requiredDigits;
|
| if (scale)
|
| padLen--; // decimal point
|
| if (padLen < 0) {
|
| // target string is not long enough - overflow
|
| return EXE_STRING_OVERFLOW;
|
| }
|
|
|
| if (leftPad) {
|
| leftMost = padLen + sign;
|
| }
|
| else {
|
| leftMost = sign;
|
| }
|
|
|
| long currPos;
|
| // Add filler.
|
| rightMost = currPos = targetLen - 1;
|
| if (padLen) {
|
| long start;
|
| if (leftPad) { // Pad to the left.
|
| start = sign;
|
| }
|
| else { // Pad to the right
|
| start = targetLen - padLen;
|
| rightMost = currPos = start - 1;
|
| }
|
| memset(&target[start], filler, padLen);
|
| }
|
|
|
| // Convert the fraction part and add decimal point.
|
| if (scale) {
|
| long low = (currPos - scale);
|
| for (; currPos > low; currPos--) {
|
| target[currPos] = (char)((newSource % 10) + '0');
|
| newSource /= 10;
|
| }
|
| target[currPos--] = '.';
|
| }
|
|
|
| // Convert the integer part.
|
| for (; currPos >= leftMost; currPos--) {
|
| target[currPos] = (char)((newSource % 10) + '0');
|
| newSource /= 10;
|
| }
|
|
|
| // Add sign.
|
| if (leadingSign) {
|
| if (negative)
|
| target[0] = '-';
|
| else
|
| target[0] = '+';
|
| }
|
| else if (negative)
|
| target[currPos] = '-';
|
|
|
| // Fix the rightmost digit for -2 ** 63.
|
| if (fixRightMost && target[rightMost] == '7')
|
| target[rightMost] = '8';
|
|
|
| if (newSource != 0 || currPos < -1)
|
| { // Sanity check fails.
|
| return EXE_STRING_OVERFLOW;
|
| }
|
|
|
| return 0;
|
| };
|
|
|
| ///////////////////////////////////////////////////////////////////
|
| // function to convert a INTERVAL to a string.
|
| ///////////////////////////////////////////////////////////////////
|
| static short convIntervalToAsciiMxcs(char *source,
|
| long sourceLen,
|
| long leadingPrecision,
|
| long fractionPrecision,
|
| short sourceType,
|
| char *inTarget,
|
| long inTargetLen,
|
| short leftPad)
|
| {
|
| short retCode = 0;
|
|
|
| char delimiter[] = "^-^ ::";
|
| unsigned short maxFieldValue[] = { 0, 11, 0, 23, 59, 59 };
|
|
|
| long realTargetLen;
|
|
|
| short startField = getIntervalStartField(sourceType);
|
| short endField = getIntervalEndField(sourceType);
|
|
|
| Int64 value;
|
| switch (sourceLen)
|
| {
|
| case SQL_SMALL_SIZE:
|
| {
|
| short temp;
|
| memcpy((char *) &temp, source, sourceLen);
|
| value = temp;
|
| break;
|
| }
|
| case SQL_INT_SIZE:
|
| {
|
| long temp;
|
| memcpy((char *) &temp, source, sourceLen);
|
| value = temp;
|
| break;
|
| }
|
| case SQL_LARGE_SIZE:
|
| memcpy((char *) &value, source, sourceLen);
|
| break;
|
| default:
|
| return -1;
|
| }
|
|
|
| char sign = '+';
|
| if (value < 0)
|
| {
|
| sign = '-';
|
| value = -value;
|
| }
|
|
|
| // 1 for -ve sign, each field is 2 + delimiter
|
| realTargetLen = (sign == '-' ? 1 : 0)
|
| + leadingPrecision + (endField - startField) * 3;
|
| short targetIndex = (short) realTargetLen;
|
| if (fractionPrecision)
|
| realTargetLen += fractionPrecision + 1; // 1 for '.'
|
|
|
| if (inTargetLen < realTargetLen)
|
| {
|
| return EXE_STRING_OVERFLOW;
|
| }
|
|
|
| long targetLen = inTargetLen;
|
| char * target = inTarget;
|
| if ((leftPad) && (targetLen > realTargetLen))
|
| {
|
| // left blankpad the target.
|
| for (int i = 0; i < (targetLen - realTargetLen); i++)
|
| {
|
| target[i] = ' ';
|
| }
|
|
|
| // switch target and targetLen to be equal to realTargetLen.
|
| target = (char *)((long)inTarget + (targetLen - realTargetLen));
|
| targetLen = realTargetLen;
|
| }
|
|
|
| Int64 factor = 1;
|
| Int64 fieldVal;
|
| if (fractionPrecision)
|
| {
|
| // realTargetLen += fractionPrecision + 1; // 1 for '.'
|
| for (unsigned i = fractionPrecision; i > 0; i--)
|
| {
|
| factor *= 10;
|
| }
|
| fieldVal = value;
|
| value = value / factor;
|
| fieldVal -= value * factor;
|
| }
|
|
|
| while (targetLen < realTargetLen)
|
| {
|
| // cut fraction till it fits. At this point we know that
|
| // precision = 0 will fit
|
| fieldVal /= 10;
|
| fractionPrecision--;
|
| realTargetLen--;
|
| if (!fractionPrecision)
|
| realTargetLen--; // remove '.'
|
| };
|
|
|
| // if target is fixed length, fill target string flushed right
|
| for (int i = 0; i < (targetLen - realTargetLen); i++, target++)
|
| *target = ' ';
|
|
|
| // convert fraction part if any. targetIndex was set earlier
|
| if (fractionPrecision)
|
| {
|
| targetIndex += 1; // 1 for '.'
|
| memset(target+targetIndex, '0', fractionPrecision);
|
| retCode = convInt64ToAsciiMxcs(target + targetIndex,
|
| fractionPrecision, // targetLen
|
| (Int64) fieldVal,
|
| 0, // scale,
|
| '0', // filler character
|
| 0,
|
| 1); // leftPad
|
| if (retCode)
|
| return retCode;
|
|
|
| targetIndex--;
|
| target[targetIndex] = '.';
|
| };
|
|
|
| // Now rest of the fields except leading field...
|
| for (int field = endField; field > startField; field--)
|
| {
|
| int index = field - REC_DATE_YEAR; // zero-based array index!
|
|
|
| factor = (short)maxFieldValue[index]+1;
|
| fieldVal = value;
|
| value = value / factor;
|
| fieldVal -= value * factor;
|
| targetIndex -= 2;
|
|
|
| retCode = convInt64ToAsciiMxcs(target + targetIndex,
|
| 2, // targetLen
|
| (Int64) fieldVal,
|
| 0, // scale,
|
| '0', // filler character
|
| 0,
|
| 1); // leftPad
|
| if (retCode)
|
| return retCode;
|
|
|
| targetIndex--;
|
| target[targetIndex] = delimiter[index];
|
| };
|
|
|
| // leading field
|
| retCode = convInt64ToAsciiMxcs(target + (sign == '-' ? 1 : 0),
|
| leadingPrecision, // targetLen
|
| (Int64) value,
|
| 0, // scale,
|
| ' ', // filler character
|
| 0,
|
| 1); // leftPad
|
| if (retCode)
|
| return retCode;
|
|
|
| if (sign == '-')
|
| {
|
| target[0] = sign;
|
| }
|
| // else
|
| // {
|
| // target[0] = ' ';
|
| // }
|
|
|
| return 0;
|
| };
|
|
|
| /////////////////////////////////////////////////////////////////////////////
|
| //
|
| // This method converts given 'source' to 'target' value.
|
| //
|
| // Following conversions are currently supported:
|
| // Bignum signed or unsigned to fixed ascii string.
|
| // Interval to fixed ascii string.
|
| // Fixed ascii string to BigNum signed or unsigned.
|
| // Fixed ascii string to Interval datatype.
|
| //
|
| // Conversion from sql data to user string for output:
|
| // ===================================================
|
| // source: pointer to buffer containing source value.
|
| // sourceLen: length of data in 'source'
|
| // sourceType: FS datatype of source value.
|
| // FS datatypes are defined in sqlcli.h and are of the
|
| // form: _SQLDT_*.
|
| // These datatype are also returned after describe when
|
| // SQLDESC_ITEM_ID of SQLDESC_TYPE_FS is used.
|
| // sourcePrecision: Returned after describe:
|
| // For numerics and chars:
|
| // value returned when SQLDESC_PRECISION
|
| // ITEM_ID is retrieved
|
| // For intervals: value returned when SQLDESC_INT_LEAD_PREC
|
| // ITEM_ID is retrieved
|
| // sourceScale: Returned after describe:
|
| // For numerics and chars:
|
| // value returned when SQLDESC_SCALE
|
| // ITEM_ID is retrieved
|
| // For intervals: value returned when SQLDESC_PRECISION
|
| // ITEM_ID is retrieved
|
| //
|
| // target: pointer to buffer where target will be moved in ascii form
|
| // targetLen: length of target buffer. Must be big enough to hold the
|
| // returned value in string format.
|
| // For BigNums, targetLen = bignum precision + 1
|
| // targetType: 0
|
| // targetPrecision: 0
|
| // targetScale: 0
|
| //
|
| // flags: 0
|
| //
|
| // Conversion from user string to sql data for input:
|
| // ==================================================
|
| // Save as the previous section with source replacing the target.
|
| //
|
| // ***************************************************************************
|
| //
|
| // MXCS/DBTR callers should set the define NA_MXCS
|
| // before compiling this file.
|
| //
|
| // ***************************************************************************
|
| // Return Code: 0, if conversion was successful.
|
| // <sql-error-code>, in case of an error
|
| //
|
| // ***************************************************************************
|
| //
|
| // This file is maintained by SQL.
|
| // DO NOT MAKE ANY CHANGES TO THIS FILE ON MXCS/DBTR END without updating
|
| // the version that is checked in to SQL.
|
| // Doing that will cause incompatibility and lost code.
|
| //
|
| ///////////////////////////////////////////////////////////////////////////////
|
| short convDoItMxcs(char * source,
|
| long sourceLen,
|
| short sourceType,
|
| long sourcePrecision,
|
| long sourceScale,
|
| char * target,
|
| long targetLen,
|
| short targetType,
|
| long targetPrecision,
|
| long targetScale,
|
| long flags,
|
| BOOL *truncation) // added by ODBC
|
| {
|
|
|
| short retCode = -1;
|
| if (sourceType == 0)
|
| {
|
| if ((targetType == REC_NUM_BIG_UNSIGNED) || (targetType == REC_NUM_BIG_SIGNED))
|
| {
|
| // ascii to bignum conversion
|
| retCode = convAsciiToBigNumMxcs(target, targetLen,
|
| // targetType, // commented out by ODBC
|
| targetPrecision, targetScale,
|
| source, sourceLen, truncation);
|
| }
|
| else if ((targetType >= REC_MIN_INTERVAL) &&
|
| (targetType <= REC_MAX_INTERVAL))
|
| {
|
| // ascii to interval conversion
|
| retCode = convAsciiToIntervalMxcs(target,
|
| targetLen,
|
| targetType,
|
| targetPrecision,
|
| targetScale,
|
| source,
|
| sourceLen,
|
| 1, //allowSignInInterval
|
| 0);
|
| }
|
| }
|
| else if (targetType == 0)
|
| {
|
| if ((sourceType == REC_NUM_BIG_UNSIGNED) || (sourceType == REC_NUM_BIG_SIGNED))
|
| {
|
| retCode = convBigNumToAsciiMxcs(target, targetLen,
|
| source, sourceLen,
|
| sourcePrecision, sourceScale);
|
| }
|
| else if ((sourceType >= REC_MIN_INTERVAL) &&
|
| (sourceType <= REC_MAX_INTERVAL))
|
| {
|
| retCode = convIntervalToAsciiMxcs(source,
|
| sourceLen,
|
| sourcePrecision,
|
| sourceScale,
|
| sourceType,
|
| target,
|
| targetLen,
|
| 1); //leftPad
|
|
|
| }
|
| }
|
|
|
| return retCode;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
