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