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