text: /* ------------------------------------------------------------------ */
  /* Decimal Context module                                             */
  /* ------------------------------------------------------------------ */
  /* Copyright (c) IBM Corporation, 2000, 2009.  All rights reserved.   */
  /*                                                                    */
  /* This software is made available under the terms of the             */
  /* ICU License -- ICU 1.8.1 and later.                                */
  /*                                                                    */
  /* The description and User's Guide ("The decNumber C Library") for   */
  /* this software is called decNumber.pdf.  This document is           */
  /* available, together with arithmetic and format specifications,     */
  /* testcases, and Web links, on the General Decimal Arithmetic page.  */
  /*                                                                    */
  /* Please send comments, suggestions, and corrections to the author:  */
  /*   mfc@uk.ibm.com                                                   */
  /*   Mike Cowlishaw, IBM Fellow                                       */
  /*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
  /* ------------------------------------------------------------------ */
  /* This module comprises the routines for handling arithmetic         */
  /* context structures.                                                */
  /* ------------------------------------------------------------------ */
  
  #include <string.h>           // for strcmp
  #include <stdio.h>            // for printf if DECCHECK
  #include "decContext.h"       // context and base types
  #include "decNumberLocal.h"   // decNumber local types, etc.
  
  /* compile-time endian tester [assumes sizeof(Int)>1] */
  static  const  Int mfcone=1;                       // constant 1
  static  const  Flag *mfctop=(const Flag *)&mfcone; // -> top byte
  #define LITEND *mfctop        // named flag; 1=little-endian
  
  /* ------------------------------------------------------------------ */
  /* round-for-reround digits                                           */
  /* ------------------------------------------------------------------ */
  const uByte DECSTICKYTAB[10]={1,1,2,3,4,6,6,7,8,9}; /* used if sticky */
  
  /* ------------------------------------------------------------------ */
  /* Powers of ten (powers[n]==10**n, 0<=n<=9)                          */
  /* ------------------------------------------------------------------ */
  const uInt DECPOWERS[10]={1, 10, 100, 1000, 10000, 100000, 1000000,
                            10000000, 100000000, 1000000000};
  
  const uLong bigpowers[20]={1, 10, 100, 1000, 10000, 100000, 1000000,
                             10000000, 100000000, 1000000000, 10000000000,
  			   100000000000, 1000000000000, 10000000000000,
  			   100000000000000, 1000000000000000,
  			   10000000000000000, 100000000000000000,
  			   1000000000000000000ULL, 10000000000000000000ULL};
  
  /* ------------------------------------------------------------------ */
  /* decContextClearStatus -- clear bits in current status              */
  /*                                                                    */
  /*  context is the context structure to be queried                    */
  /*  mask indicates the bits to be cleared (the status bit that        */
  /*    corresponds to each 1 bit in the mask is cleared)               */
  /*  returns context                                                   */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  decContext *decContextClearStatus(decContext *context, uInt mask) {
    context->status&=~mask;
    return context;
    } // decContextClearStatus
  
  /* ------------------------------------------------------------------ */
  /* decContextDefault -- initialize a context structure                */
  /*                                                                    */
  /*  context is the structure to be initialized                        */
  /*  kind selects the required set of default values, one of:          */
  /*      DEC_INIT_BASE       -- select ANSI X3-274 defaults            */
  /*      DEC_INIT_DECIMAL32  -- select IEEE 754 defaults, 32-bit       */
  /*      DEC_INIT_DECIMAL64  -- select IEEE 754 defaults, 64-bit       */
  /*      DEC_INIT_DECIMAL128 -- select IEEE 754 defaults, 128-bit      */
  /*      For any other value a valid context is returned, but with     */
  /*      Invalid_operation set in the status field.                    */
  /*  returns a context structure with the appropriate initial values.  */
  /* ------------------------------------------------------------------ */
  decContext * decContextDefault(decContext *context, Int kind) {
    // set defaults...
    context->digits=9;                         // 9 digits
    context->emax=DEC_MAX_EMAX;                // 9-digit exponents
    context->emin=DEC_MIN_EMIN;                // .. balanced
    context->round=DEC_ROUND_HALF_UP;          // 0.5 rises
    context->traps=DEC_Errors;                 // all but informational
    context->status=0;                         // cleared
    context->clamp=0;                          // no clamping
    #if DECSUBSET
    context->extended=0;                       // cleared
    #endif
    switch (kind) {
      case DEC_INIT_BASE:
        // [use defaults]
        break;
      case DEC_INIT_DECIMAL32:
        context->digits=7;                     // digits
        context->emax=96;                      // Emax
        context->emin=-95;                     // Emin
        context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
        context->traps=0;                      // no traps set
        context->clamp=1;                      // clamp exponents
        #if DECSUBSET
        context->extended=1;                   // set
        #endif
        break;
      case DEC_INIT_DECIMAL64:
        context->digits=16;                    // digits
        context->emax=384;                     // Emax
        context->emin=-383;                    // Emin
        context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
        context->traps=0;                      // no traps set
        context->clamp=1;                      // clamp exponents
        #if DECSUBSET
        context->extended=1;                   // set
        #endif
        break;
      case DEC_INIT_DECIMAL128:
        context->digits=34;                    // digits
        context->emax=6144;                    // Emax
        context->emin=-6143;                   // Emin
        context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
        context->traps=0;                      // no traps set
        context->clamp=1;                      // clamp exponents
        #if DECSUBSET
        context->extended=1;                   // set
        #endif
        break;
  
      default:                                 // invalid Kind
        // use defaults, and ..
        decContextSetStatus(context, DEC_Invalid_operation); // trap
      }
  
    return context;} // decContextDefault
  
  /* ------------------------------------------------------------------ */
  /* decContextGetRounding -- return current rounding mode              */
  /*                                                                    */
  /*  context is the context structure to be queried                    */
  /*  returns the rounding mode                                         */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  enum rounding decContextGetRounding(decContext *context) {
    return context->round;
    } // decContextGetRounding
  
  /* ------------------------------------------------------------------ */
  /* decContextGetStatus -- return current status                       */
  /*                                                                    */
  /*  context is the context structure to be queried                    */
  /*  returns status                                                    */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  uInt decContextGetStatus(decContext *context) {
    return context->status;
    } // decContextGetStatus
  
  /* ------------------------------------------------------------------ */
  /* decContextRestoreStatus -- restore bits in current status          */
  /*                                                                    */
  /*  context is the context structure to be updated                    */
  /*  newstatus is the source for the bits to be restored               */
  /*  mask indicates the bits to be restored (the status bit that       */
  /*    corresponds to each 1 bit in the mask is set to the value of    */
  /*    the correspnding bit in newstatus)                              */
  /*  returns context                                                   */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  decContext *decContextRestoreStatus(decContext *context,
                                      uInt newstatus, uInt mask) {
    context->status&=~mask;               // clear the selected bits
    context->status|=(mask&newstatus);    // or in the new bits
    return context;
    } // decContextRestoreStatus
  
  /* ------------------------------------------------------------------ */
  /* decContextSaveStatus -- save bits in current status                */
  /*                                                                    */
  /*  context is the context structure to be queried                    */
  /*  mask indicates the bits to be saved (the status bits that         */
  /*    correspond to each 1 bit in the mask are saved)                 */
  /*  returns the AND of the mask and the current status                */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  uInt decContextSaveStatus(decContext *context, uInt mask) {
    return context->status&mask;
    } // decContextSaveStatus
  
  /* ------------------------------------------------------------------ */
  /* decContextSetRounding -- set current rounding mode                 */
  /*                                                                    */
  /*  context is the context structure to be updated                    */
  /*  newround is the value which will replace the current mode         */
  /*  returns context                                                   */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  decContext *decContextSetRounding(decContext *context,
                                    enum rounding newround) {
    context->round=newround;
    return context;
    } // decContextSetRounding
  
  /* ------------------------------------------------------------------ */
  /* decContextSetStatus -- set status and raise trap if appropriate    */
  /*                                                                    */
  /*  context is the context structure to be updated                    */
  /*  status  is the DEC_ exception code                                */
  /*  returns the context structure                                     */
  /*                                                                    */
  /* Control may never return from this routine, if there is a signal   */
  /* handler and it takes a long jump.                                  */
  /* ------------------------------------------------------------------ */
  decContext * decContextSetStatus(decContext *context, uInt status) {
    context->status|=status;
    if (status & context->traps) raise(SIGFPE);
    return context;} // decContextSetStatus
  
  /* ------------------------------------------------------------------ */
  /* decContextSetStatusFromString -- set status from a string + trap   */
  /*                                                                    */
  /*  context is the context structure to be updated                    */
  /*  string is a string exactly equal to one that might be returned    */
  /*            by decContextStatusToString                             */
  /*                                                                    */
  /*  The status bit corresponding to the string is set, and a trap     */
  /*  is raised if appropriate.                                         */
  /*                                                                    */
  /*  returns the context structure, unless the string is equal to      */
  /*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
  /*    returned.                                                       */
  /* ------------------------------------------------------------------ */
  decContext * decContextSetStatusFromString(decContext *context,
                                             const char *string) {
    if (strcmp(string, DEC_Condition_CS)==0)
      return decContextSetStatus(context, DEC_Conversion_syntax);
    if (strcmp(string, DEC_Condition_DZ)==0)
      return decContextSetStatus(context, DEC_Division_by_zero);
    if (strcmp(string, DEC_Condition_DI)==0)
      return decContextSetStatus(context, DEC_Division_impossible);
    if (strcmp(string, DEC_Condition_DU)==0)
      return decContextSetStatus(context, DEC_Division_undefined);
    if (strcmp(string, DEC_Condition_IE)==0)
      return decContextSetStatus(context, DEC_Inexact);
    if (strcmp(string, DEC_Condition_IS)==0)
      return decContextSetStatus(context, DEC_Insufficient_storage);
    if (strcmp(string, DEC_Condition_IC)==0)
      return decContextSetStatus(context, DEC_Invalid_context);
    if (strcmp(string, DEC_Condition_IO)==0)
      return decContextSetStatus(context, DEC_Invalid_operation);
    #if DECSUBSET
    if (strcmp(string, DEC_Condition_LD)==0)
      return decContextSetStatus(context, DEC_Lost_digits);
    #endif
    if (strcmp(string, DEC_Condition_OV)==0)
      return decContextSetStatus(context, DEC_Overflow);
    if (strcmp(string, DEC_Condition_PA)==0)
      return decContextSetStatus(context, DEC_Clamped);
    if (strcmp(string, DEC_Condition_RO)==0)
      return decContextSetStatus(context, DEC_Rounded);
    if (strcmp(string, DEC_Condition_SU)==0)
      return decContextSetStatus(context, DEC_Subnormal);
    if (strcmp(string, DEC_Condition_UN)==0)
      return decContextSetStatus(context, DEC_Underflow);
    if (strcmp(string, DEC_Condition_ZE)==0)
      return context;
    return NULL;  // Multiple status, or unknown
    } // decContextSetStatusFromString
  
  /* ------------------------------------------------------------------ */
  /* decContextSetStatusFromStringQuiet -- set status from a string     */
  /*                                                                    */
  /*  context is the context structure to be updated                    */
  /*  string is a string exactly equal to one that might be returned    */
  /*            by decContextStatusToString                             */
  /*                                                                    */
  /*  The status bit corresponding to the string is set; no trap is     */
  /*  raised.                                                           */
  /*                                                                    */
  /*  returns the context structure, unless the string is equal to      */
  /*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
  /*    returned.                                                       */
  /* ------------------------------------------------------------------ */
  decContext * decContextSetStatusFromStringQuiet(decContext *context,
                                                  const char *string) {
    if (strcmp(string, DEC_Condition_CS)==0)
      return decContextSetStatusQuiet(context, DEC_Conversion_syntax);
    if (strcmp(string, DEC_Condition_DZ)==0)
      return decContextSetStatusQuiet(context, DEC_Division_by_zero);
    if (strcmp(string, DEC_Condition_DI)==0)
      return decContextSetStatusQuiet(context, DEC_Division_impossible);
    if (strcmp(string, DEC_Condition_DU)==0)
      return decContextSetStatusQuiet(context, DEC_Division_undefined);
    if (strcmp(string, DEC_Condition_IE)==0)
      return decContextSetStatusQuiet(context, DEC_Inexact);
    if (strcmp(string, DEC_Condition_IS)==0)
      return decContextSetStatusQuiet(context, DEC_Insufficient_storage);
    if (strcmp(string, DEC_Condition_IC)==0)
      return decContextSetStatusQuiet(context, DEC_Invalid_context);
    if (strcmp(string, DEC_Condition_IO)==0)
      return decContextSetStatusQuiet(context, DEC_Invalid_operation);
    #if DECSUBSET
    if (strcmp(string, DEC_Condition_LD)==0)
      return decContextSetStatusQuiet(context, DEC_Lost_digits);
    #endif
    if (strcmp(string, DEC_Condition_OV)==0)
      return decContextSetStatusQuiet(context, DEC_Overflow);
    if (strcmp(string, DEC_Condition_PA)==0)
      return decContextSetStatusQuiet(context, DEC_Clamped);
    if (strcmp(string, DEC_Condition_RO)==0)
      return decContextSetStatusQuiet(context, DEC_Rounded);
    if (strcmp(string, DEC_Condition_SU)==0)
      return decContextSetStatusQuiet(context, DEC_Subnormal);
    if (strcmp(string, DEC_Condition_UN)==0)
      return decContextSetStatusQuiet(context, DEC_Underflow);
    if (strcmp(string, DEC_Condition_ZE)==0)
      return context;
    return NULL;  // Multiple status, or unknown
    } // decContextSetStatusFromStringQuiet
  
  /* ------------------------------------------------------------------ */
  /* decContextSetStatusQuiet -- set status without trap                */
  /*                                                                    */
  /*  context is the context structure to be updated                    */
  /*  status  is the DEC_ exception code                                */
  /*  returns the context structure                                     */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  decContext * decContextSetStatusQuiet(decContext *context, uInt status) {
    context->status|=status;
    return context;} // decContextSetStatusQuiet
  
  /* ------------------------------------------------------------------ */
  /* decContextStatusToString -- convert status flags to a string       */
  /*                                                                    */
  /*  context is a context with valid status field                      */
  /*                                                                    */
  /*  returns a constant string describing the condition.  If multiple  */
  /*    (or no) flags are set, a generic constant message is returned.  */
  /* ------------------------------------------------------------------ */
  const char *decContextStatusToString(const decContext *context) {
    Int status=context->status;
  
    // test the five IEEE first, as some of the others are ambiguous when
    // DECEXTFLAG=0
    if (status==DEC_Invalid_operation    ) return DEC_Condition_IO;
    if (status==DEC_Division_by_zero     ) return DEC_Condition_DZ;
    if (status==DEC_Overflow             ) return DEC_Condition_OV;
    if (status==DEC_Underflow            ) return DEC_Condition_UN;
    if (status==DEC_Inexact              ) return DEC_Condition_IE;
  
    if (status==DEC_Division_impossible  ) return DEC_Condition_DI;
    if (status==DEC_Division_undefined   ) return DEC_Condition_DU;
    if (status==DEC_Rounded              ) return DEC_Condition_RO;
    if (status==DEC_Clamped              ) return DEC_Condition_PA;
    if (status==DEC_Subnormal            ) return DEC_Condition_SU;
    if (status==DEC_Conversion_syntax    ) return DEC_Condition_CS;
    if (status==DEC_Insufficient_storage ) return DEC_Condition_IS;
    if (status==DEC_Invalid_context      ) return DEC_Condition_IC;
    #if DECSUBSET
    if (status==DEC_Lost_digits          ) return DEC_Condition_LD;
    #endif
    if (status==0                        ) return DEC_Condition_ZE;
    return DEC_Condition_MU;  // Multiple errors
    } // decContextStatusToString
  
  /* ------------------------------------------------------------------ */
  /* decContextTestEndian -- test whether DECLITEND is set correctly    */
  /*                                                                    */
  /*  quiet is 1 to suppress message; 0 otherwise                       */
  /*  returns 0 if DECLITEND is correct                                 */
  /*          1 if DECLITEND is incorrect and should be 1               */
  /*         -1 if DECLITEND is incorrect and should be 0               */
  /*                                                                    */
  /* A message is displayed if the return value is not 0 and quiet==0.  */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  Int decContextTestEndian(Flag quiet) {
    Int res=0;                  // optimist
    uInt dle=(uInt)DECLITEND;   // unsign
    if (dle>1) dle=1;           // ensure 0 or 1
  
    if (LITEND!=DECLITEND) {
      if (!quiet) {             // always refer to this
        #if DECPRINT
        const char *adj;
        if (LITEND) adj="little";
               else adj="big";
        printf("Warning: DECLITEND is set to %d, but this computer appears to be %s-endian\n",
               DECLITEND, adj);
        #endif
        }
      res=(Int)LITEND-dle;
      }
    return res;
    } // decContextTestEndian
  
  /* ------------------------------------------------------------------ */
  /* decContextTestSavedStatus -- test bits in saved status             */
  /*                                                                    */
  /*  oldstatus is the status word to be tested                         */
  /*  mask indicates the bits to be tested (the oldstatus bits that     */
  /*    correspond to each 1 bit in the mask are tested)                */
  /*  returns 1 if any of the tested bits are 1, or 0 otherwise         */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  uInt decContextTestSavedStatus(uInt oldstatus, uInt mask) {
    return (oldstatus&mask)!=0;
    } // decContextTestSavedStatus
  
  /* ------------------------------------------------------------------ */
  /* decContextTestStatus -- test bits in current status                */
  /*                                                                    */
  /*  context is the context structure to be updated                    */
  /*  mask indicates the bits to be tested (the status bits that        */
  /*    correspond to each 1 bit in the mask are tested)                */
  /*  returns 1 if any of the tested bits are 1, or 0 otherwise         */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  uInt decContextTestStatus(decContext *context, uInt mask) {
    return (context->status&mask)!=0;
    } // decContextTestStatus
  
  /* ------------------------------------------------------------------ */
  /* decContextZeroStatus -- clear all status bits                      */
  /*                                                                    */
  /*  context is the context structure to be updated                    */
  /*  returns context                                                   */
  /*                                                                    */
  /* No error is possible.                                              */
  /* ------------------------------------------------------------------ */
  decContext *decContextZeroStatus(decContext *context) {
    context->status=0;
    return context;
    } // decContextZeroStatus
  
  