#ifndef BIG_NUMHELPER_H
#define BIG_NUMHELPER_H
/* -*-C++-*-
 *****************************************************************************
 *
 * File:         BigNumHelper.h
 * Description:  Definition of class BigNumHelper
 * Created:      03/29/99
 * Language:     C++
 *
 *
// @@@ 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 @@@
 *
 *
 *****************************************************************************
 */

#include "Int64.h"
#include "NAType.h"

#define MSB_CLR_MSK     0x7F
#define MSB_SET_MSK     0x80

#ifdef NA_LITTLE_ENDIAN
  #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
  #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

class BigNumHelper {

public:

// The following method adds two Big Nums (without signs).
static short AddHelper(Lng32 dataLength,
		       char * leftData,
		       char * rightData,
		       char * resultData);

// The following method subtracts one Big Num from another (without signs).
static short SubHelper(Lng32 dataLength,
		       char * leftData,
		       char * rightData,
		       char * resultData);

// The following method multiplies two Big Nums (without signs).
// The assumption is that the result is big enough to hold the
// product.
static short MulHelper(Lng32 resultLength,
                       Lng32 leftLength,
		       Lng32 rightLength,
		       char * leftData,
		       char * rightData,
		       char * resultData);

// The following method divides one Big Num by another (both without signs),
// only if the divisor fits in an unsigned short. It returns 1 if there is
// a remainder, 0 if there is no remainder, and -1 if there is an error.
static short SimpleDivHelper(Lng32 dividendLength,
			     Lng32 divisorLength,
			     char * dividendData,
			     char * divisorData,
			     char * quotientData);

// The following method divides one Big Num by another (both without signs).
// It returns 1 if there is a remainder, 0 if there is no remainder. 
static short DivHelper(Lng32 dividendLength,
		       Lng32 divisorLength,
		       char * dividendData,
		       char * divisorData,
		       char * quotientData,
                       char * tempData);

// 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 ConvBigNumToBcdHelper(Lng32 sourceLength,
			           Lng32 targetLength,
			           char * sourceData,
			           char * targetData,
                                   NAMemory * heap);

// 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 ConvBcdToBigNumHelper(Lng32 sourceLength,
			           Lng32 targetLength,
			           char * sourceData,
			           char * targetData);

// 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).
static short ConvBigNumWithSignToBcdHelper(Lng32 sourceLength,
			                   Lng32 targetLength,
			                   char * sourceData,
			                   char * targetData,
                                           NAMemory * heap);

// 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 ConvBcdToBigNumWithSignHelper(Lng32 sourceLength,
			                   Lng32 targetLength,
			                   char * sourceData,
			                   char * targetData);

// The following method converts a given Big Num (without sign) into
// its equivalent ASCII string representation (with the more significant
// decimal digits in the lower addresses).
static short ConvBigNumToAsciiHelper(Lng32 sourceLength,
			             Lng32 targetLength,
			             char * sourceData,
			             char * targetData,
                                     NAMemory * heap);

// The following method converts a given ASCII string representation 
// (without sign, and with the more significant decimal digits in the lower
// addresses) into its equivalent Big Num representation.
static short ConvAsciiToBigNumHelper(Lng32 sourceLength,
			             Lng32 targetLength,
			             char * sourceData,
			             char * targetData);

// The following method converts a given Big Num (with sign) into
// its equivalent ASCII string representation (with the more significant
// decimal digits in the lower addresses).
static short ConvBigNumWithSignToAsciiHelper(Lng32 sourceLength,
			                     Lng32 targetLength,
			                     char * sourceData,
			                     char * targetData,
                                             NAMemory * heap);

// The following method converts a given ASCII string representation 
// (with sign, and with the more significant decimal digits in the lower
// addresses) into its equivalent Big Num representation.
static short ConvAsciiToBigNumWithSignHelper(Lng32 sourceLength,
			                     Lng32 targetLength,
			                     char * sourceData,
			                     char * targetData);

// Given a desired precision of a Big Num, the following method calculates 
// the required storage length (including the sign). We assume that the
// precision is > 0.  Storage will always be at a minimum 8 bytes.
static Lng32 ConvPrecisionToStorageLengthHelper(Lng32 precision);

// The following method converts an integer, 10^exponent, to a Big Num 
// representation (without sign). The given exponent should be >= 0.
static short ConvPowersOfTenToBigNumHelper(Lng32 exponent,
                                           Lng32 targetLength,
                                           Lng32 * finalTargetLength,
                                           char * targetData);

// The following converts an Int64 to a Big Num (with sign).
static short ConvInt64ToBigNumWithSignHelper(Lng32 targetLength,
                                             Int64 sourceData,
                                             char * targetData,
                                             NABoolean isUnsigned);

// The following converts a Big Num (with sign) into an Int64.
static short ConvBigNumWithSignToInt64Helper(Lng32 sourceLength,
                                             char * sourceData,
                                             void * targetData,
                                             NABoolean isUnsigned);

// The following converts a BIGNUM (with sign) into Int64 and scale it, 
// returning information about the conversion to the caller (e.g. 
// truncations, overflows). 
//
// The return value can have 5 possible values:
//   0: the conversion was ok
//   1: the result was rounded up to LLONG_MIN
//   2: the result was rounded down to LLONG_MAX
//   3: the result was rounded up
//   4: the result was rounded down
static short ConvBigNumWithSignToInt64AndScaleHelper(Lng32 sourceLength,
                                                     char * sourceData,
                                                     Int64 * targetData,
                                                     Lng32 exponent,
                                                     NAMemory * heap);

// The following converts a Big Num to a Big Num.
static short ConvBigNumWithSignToBigNumWithSignHelper(Lng32 sourceLength,
                                                      Lng32 targetLength,
                                                      char * sourceData,
                                                      char * targetData);


};

#endif // BIG_NUMHELPER_H