1 // © 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@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 /* ------------------------------------------------------------------ */
uprv_decContextClearStatus(decContext * context,uInt mask)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 /* ------------------------------------------------------------------ */
uprv_decContextDefault(decContext * context,Int kind)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 /* ------------------------------------------------------------------ */
uprv_decContextGetRounding(decContext * context)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 /* ------------------------------------------------------------------ */
uprv_decContextGetStatus(decContext * context)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 /* ------------------------------------------------------------------ */
uprv_decContextRestoreStatus(decContext * context,uInt newstatus,uInt mask)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 /* ------------------------------------------------------------------ */
uprv_decContextSaveStatus(decContext * context,uInt mask)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 /* ------------------------------------------------------------------ */
uprv_decContextSetRounding(decContext * context,enum rounding newround)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 /* ------------------------------------------------------------------ */
uprv_decContextSetStatus(decContext * context,uInt status)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 /* ------------------------------------------------------------------ */
uprv_decContextSetStatusFromString(decContext * context,const char * string)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 /* ------------------------------------------------------------------ */
uprv_decContextSetStatusFromStringQuiet(decContext * context,const char * string)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 /* ------------------------------------------------------------------ */
uprv_decContextSetStatusQuiet(decContext * context,uInt status)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 /* ------------------------------------------------------------------ */
uprv_decContextStatusToString(const decContext * context)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 /* ------------------------------------------------------------------ */
uprv_decContextTestSavedStatus(uInt oldstatus,uInt mask)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 /* ------------------------------------------------------------------ */
uprv_decContextTestStatus(decContext * context,uInt mask)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 /* ------------------------------------------------------------------ */
uprv_decContextZeroStatus(decContext * context)428 U_CAPI decContext * U_EXPORT2 uprv_decContextZeroStatus(decContext *context) {
429 context->status=0;
430 return context;
431 } /* decContextZeroStatus */
432
433