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] */ 29static const Int mfcone=1; // constant 1 30static 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/* ------------------------------------------------------------------ */ 36const 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/* ------------------------------------------------------------------ */ 41const 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/* ------------------------------------------------------------------ */ 54decContext *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/* ------------------------------------------------------------------ */ 72decContext * 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/* ------------------------------------------------------------------ */ 137enum 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/* ------------------------------------------------------------------ */ 149uInt 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/* ------------------------------------------------------------------ */ 165decContext *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/* ------------------------------------------------------------------ */ 182uInt 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/* ------------------------------------------------------------------ */ 195decContext *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/* ------------------------------------------------------------------ */ 211decContext * 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/* ------------------------------------------------------------------ */ 230decContext * 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/* ------------------------------------------------------------------ */ 281decContext * 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/* ------------------------------------------------------------------ */ 327decContext * 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/* ------------------------------------------------------------------ */ 339const 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/* ------------------------------------------------------------------ */ 377Int 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/* ------------------------------------------------------------------ */ 407uInt 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/* ------------------------------------------------------------------ */ 421uInt 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/* ------------------------------------------------------------------ */ 433decContext *decContextZeroStatus(decContext *context) { 434 context->status=0; 435 return context; 436 } // decContextZeroStatus 437 438 |