source/texk/web2c/mplibdir/decContext.c

   1 /* ------------------------------------------------------------------ */
   2 /* Decimal Context module                                             */
   3 /* ------------------------------------------------------------------ */
   4 /* Copyright (c) IBM Corporation, 2000, 2009.  All rights reserved.   */
   5 /*                                                                    */
   6 /* This software is made available under the terms of the             */
   7 /* ICU License -- ICU 1.8.1 and later.                                */
   8 /*                                                                    */
   9 /* The description and User's Guide ("The decNumber C Library") for   */
  10 /* this software is called decNumber.pdf.  This document is           */
  11 /* available, together with arithmetic and format specifications,     */
  12 /* testcases, and Web links, on the General Decimal Arithmetic page.  */
  13 /*                                                                    */
  14 /* Please send comments, suggestions, and corrections to the author:  */
  15 /*   mfc@uk.ibm.com                                                   */
  16 /*   Mike Cowlishaw, IBM Fellow                                       */
  17 /*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
  18 /* ------------------------------------------------------------------ */
  19 /* This module comprises the routines for handling arithmetic         */
  20 /* context structures.                                                */
  21 /* ------------------------------------------------------------------ */
  22
  23 #include <string.h>           // for strcmp
  24 #include <stdio.h>            // for printf if DECCHECK
  25 #include "decContext.h"       // context and base types
  26 #include "decNumberLocal.h"   // decNumber local types, etc.
  27
  28 /* compile-time endian tester [assumes sizeof(Int)>1] */
  29 static  const  Int mfcone=1;                       // constant 1
  30 static  const  Flag *mfctop=(const Flag *)&mfcone; // -> top byte
  31 #define LITEND *mfctop        // named flag; 1=little-endian
  32
  33 /* ------------------------------------------------------------------ */
  34 /* round-for-reround digits                                           */
  35 /* ------------------------------------------------------------------ */
  36 const uByte DECSTICKYTAB[10]={1,1,2,3,4,6,6,7,8,9}; /* used if sticky */
  37
  38 /* ------------------------------------------------------------------ */
  39 /* Powers of ten (powers[n]==10**n, 0<=n<=9)                          */
  40 /* ------------------------------------------------------------------ */
  41 const uInt DECPOWERS[10]={1, 10, 100, 1000, 10000, 100000, 1000000,
  42                           10000000, 100000000, 1000000000};
  43
  44 /* ------------------------------------------------------------------ */
  45 /* decContextClearStatus -- clear bits in current status              */
  46 /*                                                                    */
  47 /*  context is the context structure to be queried                    */
  48 /*  mask indicates the bits to be cleared (the status bit that        */
  49 /*    corresponds to each 1 bit in the mask is cleared)               */
  50 /*  returns context                                                   */
  51 /*                                                                    */
  52 /* No error is possible.                                              */
  53 /* ------------------------------------------------------------------ */
  54 decContext *decContextClearStatus(decContext *context, uInt mask) {
  55   context->status&=~mask;
  56   return context;
  57   } // decContextClearStatus
  58
  59 /* ------------------------------------------------------------------ */
  60 /* decContextDefault -- initialize a context structure                */
  61 /*                                                                    */
  62 /*  context is the structure to be initialized                        */
  63 /*  kind selects the required set of default values, one of:          */
  64 /*      DEC_INIT_BASE       -- select ANSI X3-274 defaults            */
  65 /*      DEC_INIT_DECIMAL32  -- select IEEE 754 defaults, 32-bit       */
  66 /*      DEC_INIT_DECIMAL64  -- select IEEE 754 defaults, 64-bit       */
  67 /*      DEC_INIT_DECIMAL128 -- select IEEE 754 defaults, 128-bit      */
  68 /*      For any other value a valid context is returned, but with     */
  69 /*      Invalid_operation set in the status field.                    */
  70 /*  returns a context structure with the appropriate initial values.  */
  71 /* ------------------------------------------------------------------ */
  72 decContext * decContextDefault(decContext *context, Int kind) {
  73   // set defaults...
  74   context->digits=9;                         // 9 digits
  75   context->emax=DEC_MAX_EMAX;                // 9-digit exponents
  76   context->emin=DEC_MIN_EMIN;                // .. balanced
  77   context->round=DEC_ROUND_HALF_UP;          // 0.5 rises
  78   context->traps=DEC_Errors;                 // all but informational
  79   context->status=0;                         // cleared
  80   context->clamp=0;                          // no clamping
  81   #if DECSUBSET
  82   context->extended=0;                       // cleared
  83   #endif
  84   switch (kind) {
  85     case DEC_INIT_BASE:
  86       // [use defaults]
  87       break;
  88     case DEC_INIT_DECIMAL32:
  89       context->digits=7;                     // digits
  90       context->emax=96;                      // Emax
  91       context->emin=-95;                     // Emin
  92       context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
  93       context->traps=0;                      // no traps set
  94       context->clamp=1;                      // clamp exponents
  95       #if DECSUBSET
  96       context->extended=1;                   // set
  97       #endif
  98       break;
  99     case DEC_INIT_DECIMAL64:
 100       context->digits=16;                    // digits
 101       context->emax=384;                     // Emax
 102       context->emin=-383;                    // Emin
 103       context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
 104       context->traps=0;                      // no traps set
 105       context->clamp=1;                      // clamp exponents
 106       #if DECSUBSET
 107       context->extended=1;                   // set
 108       #endif
 109       break;
 110     case DEC_INIT_DECIMAL128:
 111       context->digits=34;                    // digits
 112       context->emax=6144;                    // Emax
 113       context->emin=-6143;                   // Emin
 114       context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
 115       context->traps=0;                      // no traps set
 116       context->clamp=1;                      // clamp exponents
 117       #if DECSUBSET
 118       context->extended=1;                   // set
 119       #endif
 120       break;
 121
 122     default:                                 // invalid Kind
 123       // use defaults, and ..
 124       decContextSetStatus(context, DEC_Invalid_operation); // trap
 125     }
 126
 127   return context;} // decContextDefault
 128
 129 /* ------------------------------------------------------------------ */
 130 /* decContextGetRounding -- return current rounding mode              */
 131 /*                                                                    */
 132 /*  context is the context structure to be queried                    */
 133 /*  returns the rounding mode                                         */
 134 /*                                                                    */
 135 /* No error is possible.                                              */
 136 /* ------------------------------------------------------------------ */
 137 enum rounding decContextGetRounding(decContext *context) {
 138   return context->round;
 139   } // decContextGetRounding
 140
 141 /* ------------------------------------------------------------------ */
 142 /* decContextGetStatus -- return current status                       */
 143 /*                                                                    */
 144 /*  context is the context structure to be queried                    */
 145 /*  returns status                                                    */
 146 /*                                                                    */
 147 /* No error is possible.                                              */
 148 /* ------------------------------------------------------------------ */
 149 uInt decContextGetStatus(decContext *context) {
 150   return context->status;
 151   } // decContextGetStatus
 152
 153 /* ------------------------------------------------------------------ */
 154 /* decContextRestoreStatus -- restore bits in current status          */
 155 /*                                                                    */
 156 /*  context is the context structure to be updated                    */
 157 /*  newstatus is the source for the bits to be restored               */
 158 /*  mask indicates the bits to be restored (the status bit that       */
 159 /*    corresponds to each 1 bit in the mask is set to the value of    */
 160 /*    the correspnding bit in newstatus)                              */
 161 /*  returns context                                                   */
 162 /*                                                                    */
 163 /* No error is possible.                                              */
 164 /* ------------------------------------------------------------------ */
 165 decContext *decContextRestoreStatus(decContext *context,
 166                                     uInt newstatus, uInt mask) {
 167   context->status&=~mask;               // clear the selected bits
 168   context->status|=(mask&newstatus);    // or in the new bits
 169   return context;
 170   } // decContextRestoreStatus
 171
 172 /* ------------------------------------------------------------------ */
 173 /* decContextSaveStatus -- save bits in current status                */
 174 /*                                                                    */
 175 /*  context is the context structure to be queried                    */
 176 /*  mask indicates the bits to be saved (the status bits that         */
 177 /*    correspond to each 1 bit in the mask are saved)                 */
 178 /*  returns the AND of the mask and the current status                */
 179 /*                                                                    */
 180 /* No error is possible.                                              */
 181 /* ------------------------------------------------------------------ */
 182 uInt decContextSaveStatus(decContext *context, uInt mask) {
 183   return context->status&mask;
 184   } // decContextSaveStatus
 185
 186 /* ------------------------------------------------------------------ */
 187 /* decContextSetRounding -- set current rounding mode                 */
 188 /*                                                                    */
 189 /*  context is the context structure to be updated                    */
 190 /*  newround is the value which will replace the current mode         */
 191 /*  returns context                                                   */
 192 /*                                                                    */
 193 /* No error is possible.                                              */
 194 /* ------------------------------------------------------------------ */
 195 decContext *decContextSetRounding(decContext *context,
 196                                   enum rounding newround) {
 197   context->round=newround;
 198   return context;
 199   } // decContextSetRounding
 200
 201 /* ------------------------------------------------------------------ */
 202 /* decContextSetStatus -- set status and raise trap if appropriate    */
 203 /*                                                                    */
 204 /*  context is the context structure to be updated                    */
 205 /*  status  is the DEC_ exception code                                */
 206 /*  returns the context structure                                     */
 207 /*                                                                    */
 208 /* Control may never return from this routine, if there is a signal   */
 209 /* handler and it takes a long jump.                                  */
 210 /* ------------------------------------------------------------------ */
 211 decContext * decContextSetStatus(decContext *context, uInt status) {
 212   context->status|=status;
 213   if (status & context->traps) raise(SIGFPE);
 214   return context;} // decContextSetStatus
 215
 216 /* ------------------------------------------------------------------ */
 217 /* decContextSetStatusFromString -- set status from a string + trap   */
 218 /*                                                                    */
 219 /*  context is the context structure to be updated                    */
 220 /*  string is a string exactly equal to one that might be returned    */
 221 /*            by decContextStatusToString                             */
 222 /*                                                                    */
 223 /*  The status bit corresponding to the string is set, and a trap     */
 224 /*  is raised if appropriate.                                         */
 225 /*                                                                    */
 226 /*  returns the context structure, unless the string is equal to      */
 227 /*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
 228 /*    returned.                                                       */
 229 /* ------------------------------------------------------------------ */
 230 decContext * decContextSetStatusFromString(decContext *context,
 231                                            const char *string) {
 232   if (strcmp(string, DEC_Condition_CS)==0)
 233     return decContextSetStatus(context, DEC_Conversion_syntax);
 234   if (strcmp(string, DEC_Condition_DZ)==0)
 235     return decContextSetStatus(context, DEC_Division_by_zero);
 236   if (strcmp(string, DEC_Condition_DI)==0)
 237     return decContextSetStatus(context, DEC_Division_impossible);
 238   if (strcmp(string, DEC_Condition_DU)==0)
 239     return decContextSetStatus(context, DEC_Division_undefined);
 240   if (strcmp(string, DEC_Condition_IE)==0)
 241     return decContextSetStatus(context, DEC_Inexact);
 242   if (strcmp(string, DEC_Condition_IS)==0)
 243     return decContextSetStatus(context, DEC_Insufficient_storage);
 244   if (strcmp(string, DEC_Condition_IC)==0)
 245     return decContextSetStatus(context, DEC_Invalid_context);
 246   if (strcmp(string, DEC_Condition_IO)==0)
 247     return decContextSetStatus(context, DEC_Invalid_operation);
 248   #if DECSUBSET
 249   if (strcmp(string, DEC_Condition_LD)==0)
 250     return decContextSetStatus(context, DEC_Lost_digits);
 251   #endif
 252   if (strcmp(string, DEC_Condition_OV)==0)
 253     return decContextSetStatus(context, DEC_Overflow);
 254   if (strcmp(string, DEC_Condition_PA)==0)
 255     return decContextSetStatus(context, DEC_Clamped);
 256   if (strcmp(string, DEC_Condition_RO)==0)
 257     return decContextSetStatus(context, DEC_Rounded);
 258   if (strcmp(string, DEC_Condition_SU)==0)
 259     return decContextSetStatus(context, DEC_Subnormal);
 260   if (strcmp(string, DEC_Condition_UN)==0)
 261     return decContextSetStatus(context, DEC_Underflow);
 262   if (strcmp(string, DEC_Condition_ZE)==0)
 263     return context;
 264   return NULL;  // Multiple status, or unknown
 265   } // decContextSetStatusFromString
 266
 267 /* ------------------------------------------------------------------ */
 268 /* decContextSetStatusFromStringQuiet -- set status from a string     */
 269 /*                                                                    */
 270 /*  context is the context structure to be updated                    */
 271 /*  string is a string exactly equal to one that might be returned    */
 272 /*            by decContextStatusToString                             */
 273 /*                                                                    */
 274 /*  The status bit corresponding to the string is set; no trap is     */
 275 /*  raised.                                                           */
 276 /*                                                                    */
 277 /*  returns the context structure, unless the string is equal to      */
 278 /*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
 279 /*    returned.                                                       */
 280 /* ------------------------------------------------------------------ */
 281 decContext * decContextSetStatusFromStringQuiet(decContext *context,
 282                                                 const char *string) {
 283   if (strcmp(string, DEC_Condition_CS)==0)
 284     return decContextSetStatusQuiet(context, DEC_Conversion_syntax);
 285   if (strcmp(string, DEC_Condition_DZ)==0)
 286     return decContextSetStatusQuiet(context, DEC_Division_by_zero);
 287   if (strcmp(string, DEC_Condition_DI)==0)
 288     return decContextSetStatusQuiet(context, DEC_Division_impossible);
 289   if (strcmp(string, DEC_Condition_DU)==0)
 290     return decContextSetStatusQuiet(context, DEC_Division_undefined);
 291   if (strcmp(string, DEC_Condition_IE)==0)
 292     return decContextSetStatusQuiet(context, DEC_Inexact);
 293   if (strcmp(string, DEC_Condition_IS)==0)
 294     return decContextSetStatusQuiet(context, DEC_Insufficient_storage);
 295   if (strcmp(string, DEC_Condition_IC)==0)
 296     return decContextSetStatusQuiet(context, DEC_Invalid_context);
 297   if (strcmp(string, DEC_Condition_IO)==0)
 298     return decContextSetStatusQuiet(context, DEC_Invalid_operation);
 299   #if DECSUBSET
 300   if (strcmp(string, DEC_Condition_LD)==0)
 301     return decContextSetStatusQuiet(context, DEC_Lost_digits);
 302   #endif
 303   if (strcmp(string, DEC_Condition_OV)==0)
 304     return decContextSetStatusQuiet(context, DEC_Overflow);
 305   if (strcmp(string, DEC_Condition_PA)==0)
 306     return decContextSetStatusQuiet(context, DEC_Clamped);
 307   if (strcmp(string, DEC_Condition_RO)==0)
 308     return decContextSetStatusQuiet(context, DEC_Rounded);
 309   if (strcmp(string, DEC_Condition_SU)==0)
 310     return decContextSetStatusQuiet(context, DEC_Subnormal);
 311   if (strcmp(string, DEC_Condition_UN)==0)
 312     return decContextSetStatusQuiet(context, DEC_Underflow);
 313   if (strcmp(string, DEC_Condition_ZE)==0)
 314     return context;
 315   return NULL;  // Multiple status, or unknown
 316   } // decContextSetStatusFromStringQuiet
 317
 318 /* ------------------------------------------------------------------ */
 319 /* decContextSetStatusQuiet -- set status without trap                */
 320 /*                                                                    */
 321 /*  context is the context structure to be updated                    */
 322 /*  status  is the DEC_ exception code                                */
 323 /*  returns the context structure                                     */
 324 /*                                                                    */
 325 /* No error is possible.                                              */
 326 /* ------------------------------------------------------------------ */
 327 decContext * decContextSetStatusQuiet(decContext *context, uInt status) {
 328   context->status|=status;
 329   return context;} // decContextSetStatusQuiet
 330
 331 /* ------------------------------------------------------------------ */
 332 /* decContextStatusToString -- convert status flags to a string       */
 333 /*                                                                    */
 334 /*  context is a context with valid status field                      */
 335 /*                                                                    */
 336 /*  returns a constant string describing the condition.  If multiple  */
 337 /*    (or no) flags are set, a generic constant message is returned.  */
 338 /* ------------------------------------------------------------------ */
 339 const char *decContextStatusToString(const decContext *context) {
 340   Int status=context->status;
 341
 342   // test the five IEEE first, as some of the others are ambiguous when
 343   // DECEXTFLAG=0
 344   if (status==DEC_Invalid_operation    ) return DEC_Condition_IO;
 345   if (status==DEC_Division_by_zero     ) return DEC_Condition_DZ;
 346   if (status==DEC_Overflow             ) return DEC_Condition_OV;
 347   if (status==DEC_Underflow            ) return DEC_Condition_UN;
 348   if (status==DEC_Inexact              ) return DEC_Condition_IE;
 349
 350   if (status==DEC_Division_impossible  ) return DEC_Condition_DI;
 351   if (status==DEC_Division_undefined   ) return DEC_Condition_DU;
 352   if (status==DEC_Rounded              ) return DEC_Condition_RO;
 353   if (status==DEC_Clamped              ) return DEC_Condition_PA;
 354   if (status==DEC_Subnormal            ) return DEC_Condition_SU;
 355   if (status==DEC_Conversion_syntax    ) return DEC_Condition_CS;
 356   if (status==DEC_Insufficient_storage ) return DEC_Condition_IS;
 357   if (status==DEC_Invalid_context      ) return DEC_Condition_IC;
 358   #if DECSUBSET
 359   if (status==DEC_Lost_digits          ) return DEC_Condition_LD;
 360   #endif
 361   if (status==0                        ) return DEC_Condition_ZE;
 362   return DEC_Condition_MU;  // Multiple errors
 363   } // decContextStatusToString
 364
 365 /* ------------------------------------------------------------------ */
 366 /* decContextTestEndian -- test whether DECLITEND is set correctly    */
 367 /*                                                                    */
 368 /*  quiet is 1 to suppress message; 0 otherwise                       */
 369 /*  returns 0 if DECLITEND is correct                                 */
 370 /*          1 if DECLITEND is incorrect and should be 1               */
 371 /*         -1 if DECLITEND is incorrect and should be 0               */
 372 /*                                                                    */
 373 /* A message is displayed if the return value is not 0 and quiet==0.  */
 374 /*                                                                    */
 375 /* No error is possible.                                              */
 376 /* ------------------------------------------------------------------ */
 377 Int decContextTestEndian(Flag quiet) {
 378   Int res=0;                  // optimist
 379   uInt dle=(uInt)DECLITEND;   // unsign
 380   if (dle>1) dle=1;           // ensure 0 or 1
 381
 382   if (LITEND!=DECLITEND) {
 383     if (!quiet) {             // always refer to this
 384       #if DECPRINT
 385       const char *adj;
 386       if (LITEND) adj="little";
 387              else adj="big";
 388       printf("Warning: DECLITEND is set to %d, but this computer appears to be %s-endian\n",
 389              DECLITEND, adj);
 390       #endif
 391       }
 392     res=(Int)LITEND-dle;
 393     }
 394   return res;
 395   } // decContextTestEndian
 396
 397 /* ------------------------------------------------------------------ */
 398 /* decContextTestSavedStatus -- test bits in saved status             */
 399 /*                                                                    */
 400 /*  oldstatus is the status word to be tested                         */
 401 /*  mask indicates the bits to be tested (the oldstatus bits that     */
 402 /*    correspond to each 1 bit in the mask are tested)                */
 403 /*  returns 1 if any of the tested bits are 1, or 0 otherwise         */
 404 /*                                                                    */
 405 /* No error is possible.                                              */
 406 /* ------------------------------------------------------------------ */
 407 uInt decContextTestSavedStatus(uInt oldstatus, uInt mask) {
 408   return (oldstatus&mask)!=0;
 409   } // decContextTestSavedStatus
 410
 411 /* ------------------------------------------------------------------ */
 412 /* decContextTestStatus -- test bits in current status                */
 413 /*                                                                    */
 414 /*  context is the context structure to be updated                    */
 415 /*  mask indicates the bits to be tested (the status bits that        */
 416 /*    correspond to each 1 bit in the mask are tested)                */
 417 /*  returns 1 if any of the tested bits are 1, or 0 otherwise         */
 418 /*                                                                    */
 419 /* No error is possible.                                              */
 420 /* ------------------------------------------------------------------ */
 421 uInt decContextTestStatus(decContext *context, uInt mask) {
 422   return (context->status&mask)!=0;
 423   } // decContextTestStatus
 424
 425 /* ------------------------------------------------------------------ */
 426 /* decContextZeroStatus -- clear all status bits                      */
 427 /*                                                                    */
 428 /*  context is the context structure to be updated                    */
 429 /*  returns context                                                   */
 430 /*                                                                    */
 431 /* No error is possible.                                              */
 432 /* ------------------------------------------------------------------ */
 433 decContext *decContextZeroStatus(decContext *context) {
 434   context->status=0;
 435   return context;
 436   } // decContextZeroStatus
 437