1 /* ------------------------------------------------------------------ */ 2 /* Decimal Context module */ 3 /* ------------------------------------------------------------------ */ 4 /* Copyright (c) IBM Corporation, 2000-2010. 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 (at) 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=(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 U_CAPI decContext * U_EXPORT2 uprv_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 U_CAPI decContext * U_EXPORT2 uprv_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 uprv_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 U_CAPI enum rounding U_EXPORT2 uprv_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 U_CAPI uInt U_EXPORT2 uprv_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 U_CAPI decContext * U_EXPORT2 uprv_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 U_CAPI uInt U_EXPORT2 uprv_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 U_CAPI decContext * U_EXPORT2 uprv_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 U_CAPI decContext * U_EXPORT2 uprv_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 U_CAPI decContext * U_EXPORT2 uprv_decContextSetStatusFromString(decContext *context, 231 const char *string) { 232 if (strcmp(string, DEC_Condition_CS)==0) 233 return uprv_decContextSetStatus(context, DEC_Conversion_syntax); 234 if (strcmp(string, DEC_Condition_DZ)==0) 235 return uprv_decContextSetStatus(context, DEC_Division_by_zero); 236 if (strcmp(string, DEC_Condition_DI)==0) 237 return uprv_decContextSetStatus(context, DEC_Division_impossible); 238 if (strcmp(string, DEC_Condition_DU)==0) 239 return uprv_decContextSetStatus(context, DEC_Division_undefined); 240 if (strcmp(string, DEC_Condition_IE)==0) 241 return uprv_decContextSetStatus(context, DEC_Inexact); 242 if (strcmp(string, DEC_Condition_IS)==0) 243 return uprv_decContextSetStatus(context, DEC_Insufficient_storage); 244 if (strcmp(string, DEC_Condition_IC)==0) 245 return uprv_decContextSetStatus(context, DEC_Invalid_context); 246 if (strcmp(string, DEC_Condition_IO)==0) 247 return uprv_decContextSetStatus(context, DEC_Invalid_operation); 248 #if DECSUBSET 249 if (strcmp(string, DEC_Condition_LD)==0) 250 return uprv_decContextSetStatus(context, DEC_Lost_digits); 251 #endif 252 if (strcmp(string, DEC_Condition_OV)==0) 253 return uprv_decContextSetStatus(context, DEC_Overflow); 254 if (strcmp(string, DEC_Condition_PA)==0) 255 return uprv_decContextSetStatus(context, DEC_Clamped); 256 if (strcmp(string, DEC_Condition_RO)==0) 257 return uprv_decContextSetStatus(context, DEC_Rounded); 258 if (strcmp(string, DEC_Condition_SU)==0) 259 return uprv_decContextSetStatus(context, DEC_Subnormal); 260 if (strcmp(string, DEC_Condition_UN)==0) 261 return uprv_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 U_CAPI decContext * U_EXPORT2 uprv_decContextSetStatusFromStringQuiet(decContext *context, 282 const char *string) { 283 if (strcmp(string, DEC_Condition_CS)==0) 284 return uprv_decContextSetStatusQuiet(context, DEC_Conversion_syntax); 285 if (strcmp(string, DEC_Condition_DZ)==0) 286 return uprv_decContextSetStatusQuiet(context, DEC_Division_by_zero); 287 if (strcmp(string, DEC_Condition_DI)==0) 288 return uprv_decContextSetStatusQuiet(context, DEC_Division_impossible); 289 if (strcmp(string, DEC_Condition_DU)==0) 290 return uprv_decContextSetStatusQuiet(context, DEC_Division_undefined); 291 if (strcmp(string, DEC_Condition_IE)==0) 292 return uprv_decContextSetStatusQuiet(context, DEC_Inexact); 293 if (strcmp(string, DEC_Condition_IS)==0) 294 return uprv_decContextSetStatusQuiet(context, DEC_Insufficient_storage); 295 if (strcmp(string, DEC_Condition_IC)==0) 296 return uprv_decContextSetStatusQuiet(context, DEC_Invalid_context); 297 if (strcmp(string, DEC_Condition_IO)==0) 298 return uprv_decContextSetStatusQuiet(context, DEC_Invalid_operation); 299 #if DECSUBSET 300 if (strcmp(string, DEC_Condition_LD)==0) 301 return uprv_decContextSetStatusQuiet(context, DEC_Lost_digits); 302 #endif 303 if (strcmp(string, DEC_Condition_OV)==0) 304 return uprv_decContextSetStatusQuiet(context, DEC_Overflow); 305 if (strcmp(string, DEC_Condition_PA)==0) 306 return uprv_decContextSetStatusQuiet(context, DEC_Clamped); 307 if (strcmp(string, DEC_Condition_RO)==0) 308 return uprv_decContextSetStatusQuiet(context, DEC_Rounded); 309 if (strcmp(string, DEC_Condition_SU)==0) 310 return uprv_decContextSetStatusQuiet(context, DEC_Subnormal); 311 if (strcmp(string, DEC_Condition_UN)==0) 312 return uprv_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 U_CAPI decContext * U_EXPORT2 uprv_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 U_CAPI const char * U_EXPORT2 uprv_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 U_CAPI Int U_EXPORT2 uprv_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 const char *adj; 384 if (!quiet) { 385 if (LITEND) adj="little"; 386 else adj="big"; 387 printf("Warning: DECLITEND is set to %d, but this computer appears to be %s-endian\n", 388 DECLITEND, adj); 389 } 390 res=(Int)LITEND-dle; 391 } 392 return res; 393 } /* decContextTestEndian */ 394 395 /* ------------------------------------------------------------------ */ 396 /* decContextTestSavedStatus -- test bits in saved status */ 397 /* */ 398 /* oldstatus is the status word to be tested */ 399 /* mask indicates the bits to be tested (the oldstatus bits that */ 400 /* correspond to each 1 bit in the mask are tested) */ 401 /* returns 1 if any of the tested bits are 1, or 0 otherwise */ 402 /* */ 403 /* No error is possible. */ 404 /* ------------------------------------------------------------------ */ 405 U_CAPI uInt U_EXPORT2 uprv_decContextTestSavedStatus(uInt oldstatus, uInt mask) { 406 return (oldstatus&mask)!=0; 407 } /* decContextTestSavedStatus */ 408 409 /* ------------------------------------------------------------------ */ 410 /* decContextTestStatus -- test bits in current status */ 411 /* */ 412 /* context is the context structure to be updated */ 413 /* mask indicates the bits to be tested (the status bits that */ 414 /* correspond to each 1 bit in the mask are tested) */ 415 /* returns 1 if any of the tested bits are 1, or 0 otherwise */ 416 /* */ 417 /* No error is possible. */ 418 /* ------------------------------------------------------------------ */ 419 U_CAPI uInt U_EXPORT2 uprv_decContextTestStatus(decContext *context, uInt mask) { 420 return (context->status&mask)!=0; 421 } /* decContextTestStatus */ 422 423 /* ------------------------------------------------------------------ */ 424 /* decContextZeroStatus -- clear all status bits */ 425 /* */ 426 /* context is the context structure to be updated */ 427 /* returns context */ 428 /* */ 429 /* No error is possible. */ 430 /* ------------------------------------------------------------------ */ 431 U_CAPI decContext * U_EXPORT2 uprv_decContextZeroStatus(decContext *context) { 432 context->status=0; 433 return context; 434 } /* decContextZeroStatus */ 435 436
