libdecnumber/decContext.c

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