bignum.h

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C头文件 代码 · 共 349 行 · 第 1/2 页

                                Counter);       // Multiply quotient and subt.
  friend void divide (const CoolBignum&, const CoolBignum&, CoolBignum&, CoolBignum&); // Divide
  void resize (Counter);                        // Resize CoolBignum data
  CoolBignum& trim ();                          // Trim CoolBignum data
  friend CoolBignumE left_shift (const CoolBignum& b1, long l);
  friend CoolBignumE right_shift (const CoolBignum& b1, long l);
};


// Avoid deep copy with envelope. 
// None of the operations +=... can be done in place

#define CoolLetter CoolBignum
#define CoolEnvelope CoolBignumE                

#include <cool/Envelope.h>                      // Include envelope macros

#undef CoolLetter
#undef CoolEnvelope


// Need and initializer to construct static bignums.

class CoolBignum_Init {
public:
  CoolBignum_Init ();                           // Create constant Bignums
  ~CoolBignum_Init();                           // and destroy them once only
private:
  static int count;                             // number of init objects created
};

static CoolBignum_Init bignum_init1_s;          // trigger init of Bignums


// 

// status -- returns status of a CoolBignum
// Inputs:  none
// Outputs:  status of this CoolBignum
inline N_status CoolBignum::status () const {
  return this->state;                           // Return this->state
}

// operator! -- overloaded not operator for CoolBignums
// Inputs:  none
// Outputs:  Boolean not of this CoolBignum
inline Boolean CoolBignum::operator! () const {
  return (Boolean) (this->count == 0);          // Return 1 if CoolBignum's zero
}

// operator=  -- Assignment from an envelope back to real Bignum
// Input:     envelope reference
// Output:    Bignum reference with contents in envelope being swapped over

inline CoolBignum& CoolBignum::operator= (CoolBignumE& env){
  env.shallow_swap((CoolBignumE*)this, &env);   // same physical layout
  return *this;
}

// operator- -- overloaded subtraction operator for CoolBignums
// Inputs:  references to two CoolBignums
// Outputs:  the CoolBignum difference of the two input CoolBignums

inline CoolBignumE operator- (const CoolBignum& b1, const CoolBignum& b2) {
  return (b1 + (-b2));                          // negate b2 and add to b1
}


// operator!= -- overloaded != comparison operator for CoolBignums
// Inputs:  reference to CoolBignum
// Outputs:  Boolean result of the comparison
inline Boolean CoolBignum::operator!= (const CoolBignum& b) const {
  return !(*this == b);                         // call CoolBignum operator==
}



// operator<= -- overloaded <= operator for CoolBignums
// Inputs:  reference to CoolBignum
// Outputs:  Boolean result of <= comparison
inline Boolean CoolBignum::operator<= (const CoolBignum& b) const {
  return !(*this > b);                          // call CoolBignum operator>
}



// operator>= -- overloaded >= operator for CoolBignums
// Inputs:  reference to CoolBignum
// Outputs:  Boolean result of >= comparison
inline Boolean CoolBignum::operator>= (const CoolBignum& b) const {
  return !(*this < b);                  
}



// operator+= -- overloaded addition assignment operator for CoolBignums
// Inputs:  reference to CoolBignum
// Outputs:  reference to modified CoolBignum
inline CoolBignum& CoolBignum::operator+= (const CoolBignum& b) {
  *this = *this + b;                            // call CoolBignum operator+
  return *this;
}



// operator-= -- overloaded subtraction assignment operator for CoolBignums
// Inputs:  reference to CoolBignum
// Outputs:  reference to modified CoolBignum
inline CoolBignum& CoolBignum::operator-= (const CoolBignum& b) {
  *this = *this - b;                            // call CoolBignum operator-
  return *this;
}



// operator*= -- overloaded multiplication assignment operator for CoolBignums
// Inputs:  reference to CoolBignum
// Outputs:  reference to modified CoolBignum
inline CoolBignum& CoolBignum::operator*= (const CoolBignum& b) {
  *this = *this * b;                            // call CoolBignum operator*
  return *this;
}



// operator/= -- overloaded division assignment operator for CoolBignums
// Inputs:  reference to CoolBignum
// Outputs:  reference to modified CoolBignum
inline CoolBignum& CoolBignum::operator/= (const CoolBignum& b) {
  *this = *this / b;                            // call CoolBignum operator/
  return *this;
}



// operator%= -- overloaded modulus assignment operator for CoolBignums
// Inputs:  reference to CoolBignum
// Outputs:  reference to modified CoolBignum
inline CoolBignum& CoolBignum::operator%= (const CoolBignum& b) {
  *this = *this % b;                            // call CoolBignum operator%
  return *this;
}



// operator<<= -- overloaded left shift assignment operator for CoolBignums
// Inputs:  reference to CoolBignum
// Outputs:  reference to modified CoolBignum
inline CoolBignum& CoolBignum::operator<<= (const CoolBignum& b) {
  *this = *this << long(b);                     // call CoolBignum operator<<
  return *this;
}



// operator>>= -- overloaded right shift assignment operator for CoolBignums
// Inputs:  reference to CoolBignum
// Outputs:  reference to modified CoolBignum
inline CoolBignum& CoolBignum::operator>>= (const CoolBignum& b) {
  *this = *this >> long(b);                     // call CoolBignum operator>>
  return *this;
}



// operator<< -- output operator for pointers to CoolBignums
inline ostream& operator<< (ostream& os, const CoolBignum* b) {
  if (b) os << *b;                              // call CoolBignum output operator
  return os;                                    
}

#endif