[qemu.git] / libdecnumber / decContext.c

/* Decimal context module for the decNumber C Library.
   Copyright (C) 2005, 2007 Free Software Foundation, Inc.
   Contributed by IBM Corporation.  Author Mike Cowlishaw.

   This file is part of GCC.

   GCC is free software; you can redistribute it and/or modify it under
   the terms of the GNU General Public License as published by the Free
   Software Foundation; either version 2, or (at your option) any later
   version.

   In addition to the permissions in the GNU General Public License,
   the Free Software Foundation gives you unlimited permission to link
   the compiled version of this file into combinations with other
   programs, and to distribute those combinations without any
   restriction coming from the use of this file.  (The General Public
   License restrictions do apply in other respects; for example, they
   cover modification of the file, and distribution when not linked
   into a combine executable.)

   GCC is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.

   You should have received a copy of the GNU General Public License
   along with GCC; see the file COPYING.  If not, write to the Free
   Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301, USA.  */

/* ------------------------------------------------------------------ */
/* Decimal Context module					      */
/* ------------------------------------------------------------------ */
/* This module comprises the routines for handling arithmetic	      */
/* context structures.						      */
/* ------------------------------------------------------------------ */

#include <string.h>	      /* for strcmp */
#include <stdio.h>	      /* for printf if DECCHECK */
#include "libdecnumber/dconfig.h"
#include "libdecnumber/decContext.h"
#include "libdecnumber/decNumberLocal.h"

#if DECCHECK
/* compile-time endian tester [assumes sizeof(Int)>1] */
static	const  Int mfcone=1;		     /* constant 1 */
static	const  Flag *mfctop=(Flag *)&mfcone; /* -> top byte */
#define LITEND *mfctop		   /* named flag; 1=little-endian */
#endif

/* ------------------------------------------------------------------ */
/* round-for-reround digits					      */
/* ------------------------------------------------------------------ */
const uByte DECSTICKYTAB[10]={1,1,2,3,4,6,6,7,8,9}; /* used if sticky */

/* ------------------------------------------------------------------ */
/* Powers of ten (powers[n]==10**n, 0<=n<=9)			      */
/* ------------------------------------------------------------------ */
const uLong DECPOWERS[19] = {1, 10, 100, 1000, 10000, 100000, 1000000,
  10000000, 100000000, 1000000000, 10000000000ULL, 100000000000ULL,
  1000000000000ULL, 10000000000000ULL, 100000000000000ULL, 1000000000000000ULL,
  10000000000000000ULL, 100000000000000000ULL, 1000000000000000000ULL, };

/* ------------------------------------------------------------------ */
/* decContextClearStatus -- clear bits in current status	      */
/*								      */
/*  context is the context structure to be queried		      */
/*  mask indicates the bits to be cleared (the status bit that	      */
/*    corresponds to each 1 bit in the mask is cleared)		      */
/*  returns context						      */
/*								      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
decContext *decContextClearStatus(decContext *context, uInt mask) {
  context->status&=~mask;
  return context;
  } /* decContextClearStatus */

/* ------------------------------------------------------------------ */
/* decContextDefault -- initialize a context structure		      */
/*								      */
/*  context is the structure to be initialized			      */
/*  kind selects the required set of default values, one of:	      */
/*	DEC_INIT_BASE	    -- select ANSI X3-274 defaults	      */
/*	DEC_INIT_DECIMAL32  -- select IEEE 754r defaults, 32-bit      */
/*	DEC_INIT_DECIMAL64  -- select IEEE 754r defaults, 64-bit      */
/*	DEC_INIT_DECIMAL128 -- select IEEE 754r defaults, 128-bit     */
/*	For any other value a valid context is returned, but with     */
/*	Invalid_operation set in the status field.		      */
/*  returns a context structure with the appropriate initial values.  */
/* ------------------------------------------------------------------ */
decContext * decContextDefault(decContext *context, Int kind) {
  /* set defaults... */
  context->digits=9;			     /* 9 digits */
  context->emax=DEC_MAX_EMAX;		     /* 9-digit exponents */
  context->emin=DEC_MIN_EMIN;		     /* .. balanced */
  context->round=DEC_ROUND_HALF_UP;	     /* 0.5 rises */
  context->traps=DEC_Errors;		     /* all but informational */
  context->status=0;			     /* cleared */
  context->clamp=0;			     /* no clamping */
  #if DECSUBSET
  context->extended=0;			     /* cleared */
  #endif
  switch (kind) {
    case DEC_INIT_BASE:
      /* [use defaults] */
      break;
    case DEC_INIT_DECIMAL32:
      context->digits=7;		     /* digits */
      context->emax=96;			     /* Emax */
      context->emin=-95;		     /* Emin */
      context->round=DEC_ROUND_HALF_EVEN;    /* 0.5 to nearest even */
      context->traps=0;			     /* no traps set */
      context->clamp=1;			     /* clamp exponents */
      #if DECSUBSET
      context->extended=1;		     /* set */
      #endif
      break;
    case DEC_INIT_DECIMAL64:
      context->digits=16;		     /* digits */
      context->emax=384;		     /* Emax */
      context->emin=-383;		     /* Emin */
      context->round=DEC_ROUND_HALF_EVEN;    /* 0.5 to nearest even */
      context->traps=0;			     /* no traps set */
      context->clamp=1;			     /* clamp exponents */
      #if DECSUBSET
      context->extended=1;		     /* set */
      #endif
      break;
    case DEC_INIT_DECIMAL128:
      context->digits=34;		     /* digits */
      context->emax=6144;		     /* Emax */
      context->emin=-6143;		     /* Emin */
      context->round=DEC_ROUND_HALF_EVEN;    /* 0.5 to nearest even */
      context->traps=0;			     /* no traps set */
      context->clamp=1;			     /* clamp exponents */
      #if DECSUBSET
      context->extended=1;		     /* set */
      #endif
      break;

    default:				     /* invalid Kind */
      /* use defaults, and .. */
      decContextSetStatus(context, DEC_Invalid_operation); /* trap */
    }

  #if DECCHECK
  if (LITEND!=DECLITEND) {
    const char *adj;
    if (LITEND) adj="little";
	   else adj="big";
    printf("Warning: DECLITEND is set to %d, but this computer appears to be %s-endian\n",
	   DECLITEND, adj);
    }
  #endif
  return context;} /* decContextDefault */

/* ------------------------------------------------------------------ */
/* decContextGetRounding -- return current rounding mode	      */
/*								      */
/*  context is the context structure to be queried		      */
/*  returns the rounding mode					      */
/*								      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
enum rounding decContextGetRounding(decContext *context) {
  return context->round;
  } /* decContextGetRounding */

/* ------------------------------------------------------------------ */
/* decContextGetStatus -- return current status			      */
/*								      */
/*  context is the context structure to be queried		      */
/*  returns status						      */
/*								      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
uInt decContextGetStatus(decContext *context) {
  return context->status;
  } /* decContextGetStatus */

/* ------------------------------------------------------------------ */
/* decContextRestoreStatus -- restore bits in current status	      */
/*								      */
/*  context is the context structure to be updated		      */
/*  newstatus is the source for the bits to be restored		      */
/*  mask indicates the bits to be restored (the status bit that	      */
/*    corresponds to each 1 bit in the mask is set to the value of    */
/*    the correspnding bit in newstatus)			      */
/*  returns context						      */
/*								      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
decContext *decContextRestoreStatus(decContext *context,
				    uInt newstatus, uInt mask) {
  context->status&=~mask;		/* clear the selected bits */
  context->status|=(mask&newstatus);	/* or in the new bits */
  return context;
  } /* decContextRestoreStatus */

/* ------------------------------------------------------------------ */
/* decContextSaveStatus -- save bits in current status		      */
/*								      */
/*  context is the context structure to be queried		      */
/*  mask indicates the bits to be saved (the status bits that	      */
/*    correspond to each 1 bit in the mask are saved)		      */
/*  returns the AND of the mask and the current status		      */
/*								      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
uInt decContextSaveStatus(decContext *context, uInt mask) {
  return context->status&mask;
  } /* decContextSaveStatus */

/* ------------------------------------------------------------------ */
/* decContextSetRounding -- set current rounding mode		      */
/*								      */
/*  context is the context structure to be updated		      */
/*  newround is the value which will replace the current mode	      */
/*  returns context						      */
/*								      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
decContext *decContextSetRounding(decContext *context,
				  enum rounding newround) {
  context->round=newround;
  return context;
  } /* decContextSetRounding */

/* ------------------------------------------------------------------ */
/* decContextSetStatus -- set status and raise trap if appropriate    */
/*								      */
/*  context is the context structure to be updated		      */
/*  status  is the DEC_ exception code				      */
/*  returns the context structure				      */
/*								      */
/* Control may never return from this routine, if there is a signal   */
/* handler and it takes a long jump.				      */
/* ------------------------------------------------------------------ */
decContext * decContextSetStatus(decContext *context, uInt status) {
  context->status|=status;
  if (status & context->traps) raise(SIGFPE);
  return context;} /* decContextSetStatus */

/* ------------------------------------------------------------------ */
/* decContextSetStatusFromString -- set status from a string + trap   */
/*								      */
/*  context is the context structure to be updated		      */
/*  string is a string exactly equal to one that might be returned    */
/*	      by decContextStatusToString			      */
/*								      */
/*  The status bit corresponding to the string is set, and a trap     */
/*  is raised if appropriate.					      */
/*								      */
/*  returns the context structure, unless the string is equal to      */
/*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
/*    returned.							      */
/* ------------------------------------------------------------------ */
decContext * decContextSetStatusFromString(decContext *context,
					   const char *string) {
  if (strcmp(string, DEC_Condition_CS)==0)
    return decContextSetStatus(context, DEC_Conversion_syntax);
  if (strcmp(string, DEC_Condition_DZ)==0)
    return decContextSetStatus(context, DEC_Division_by_zero);
  if (strcmp(string, DEC_Condition_DI)==0)
    return decContextSetStatus(context, DEC_Division_impossible);
  if (strcmp(string, DEC_Condition_DU)==0)
    return decContextSetStatus(context, DEC_Division_undefined);
  if (strcmp(string, DEC_Condition_IE)==0)
    return decContextSetStatus(context, DEC_Inexact);
  if (strcmp(string, DEC_Condition_IS)==0)
    return decContextSetStatus(context, DEC_Insufficient_storage);
  if (strcmp(string, DEC_Condition_IC)==0)
    return decContextSetStatus(context, DEC_Invalid_context);
  if (strcmp(string, DEC_Condition_IO)==0)
    return decContextSetStatus(context, DEC_Invalid_operation);
  #if DECSUBSET
  if (strcmp(string, DEC_Condition_LD)==0)
    return decContextSetStatus(context, DEC_Lost_digits);
  #endif
  if (strcmp(string, DEC_Condition_OV)==0)
    return decContextSetStatus(context, DEC_Overflow);
  if (strcmp(string, DEC_Condition_PA)==0)
    return decContextSetStatus(context, DEC_Clamped);
  if (strcmp(string, DEC_Condition_RO)==0)
    return decContextSetStatus(context, DEC_Rounded);
  if (strcmp(string, DEC_Condition_SU)==0)
    return decContextSetStatus(context, DEC_Subnormal);
  if (strcmp(string, DEC_Condition_UN)==0)
    return decContextSetStatus(context, DEC_Underflow);
  if (strcmp(string, DEC_Condition_ZE)==0)
    return context;
  return NULL;	/* Multiple status, or unknown */
  } /* decContextSetStatusFromString */

/* ------------------------------------------------------------------ */
/* decContextSetStatusFromStringQuiet -- set status from a string     */
/*								      */
/*  context is the context structure to be updated		      */
/*  string is a string exactly equal to one that might be returned    */
/*	      by decContextStatusToString			      */
/*								      */
/*  The status bit corresponding to the string is set; no trap is     */
/*  raised.							      */
/*								      */
/*  returns the context structure, unless the string is equal to      */
/*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
/*    returned.							      */
/* ------------------------------------------------------------------ */
decContext * decContextSetStatusFromStringQuiet(decContext *context,
						const char *string) {
  if (strcmp(string, DEC_Condition_CS)==0)
    return decContextSetStatusQuiet(context, DEC_Conversion_syntax);
  if (strcmp(string, DEC_Condition_DZ)==0)
    return decContextSetStatusQuiet(context, DEC_Division_by_zero);
  if (strcmp(string, DEC_Condition_DI)==0)
    return decContextSetStatusQuiet(context, DEC_Division_impossible);
  if (strcmp(string, DEC_Condition_DU)==0)
    return decContextSetStatusQuiet(context, DEC_Division_undefined);
  if (strcmp(string, DEC_Condition_IE)==0)
    return decContextSetStatusQuiet(context, DEC_Inexact);
  if (strcmp(string, DEC_Condition_IS)==0)
    return decContextSetStatusQuiet(context, DEC_Insufficient_storage);
  if (strcmp(string, DEC_Condition_IC)==0)
    return decContextSetStatusQuiet(context, DEC_Invalid_context);
  if (strcmp(string, DEC_Condition_IO)==0)
    return decContextSetStatusQuiet(context, DEC_Invalid_operation);
  #if DECSUBSET
  if (strcmp(string, DEC_Condition_LD)==0)
    return decContextSetStatusQuiet(context, DEC_Lost_digits);
  #endif
  if (strcmp(string, DEC_Condition_OV)==0)
    return decContextSetStatusQuiet(context, DEC_Overflow);
  if (strcmp(string, DEC_Condition_PA)==0)
    return decContextSetStatusQuiet(context, DEC_Clamped);
  if (strcmp(string, DEC_Condition_RO)==0)
    return decContextSetStatusQuiet(context, DEC_Rounded);
  if (strcmp(string, DEC_Condition_SU)==0)
    return decContextSetStatusQuiet(context, DEC_Subnormal);
  if (strcmp(string, DEC_Condition_UN)==0)
    return decContextSetStatusQuiet(context, DEC_Underflow);
  if (strcmp(string, DEC_Condition_ZE)==0)
    return context;
  return NULL;	/* Multiple status, or unknown */
  } /* decContextSetStatusFromStringQuiet */

/* ------------------------------------------------------------------ */
/* decContextSetStatusQuiet -- set status without trap		      */
/*								      */
/*  context is the context structure to be updated		      */
/*  status  is the DEC_ exception code				      */
/*  returns the context structure				      */
/*								      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
decContext * decContextSetStatusQuiet(decContext *context, uInt status) {
  context->status|=status;
  return context;} /* decContextSetStatusQuiet */

/* ------------------------------------------------------------------ */
/* decContextStatusToString -- convert status flags to a string	      */
/*								      */
/*  context is a context with valid status field		      */
/*								      */
/*  returns a constant string describing the condition.	 If multiple  */
/*    (or no) flags are set, a generic constant message is returned.  */
/* ------------------------------------------------------------------ */
const char *decContextStatusToString(const decContext *context) {
  Int status=context->status;

  /* test the five IEEE first, as some of the others are ambiguous when */
  /* DECEXTFLAG=0 */
  if (status==DEC_Invalid_operation    ) return DEC_Condition_IO;
  if (status==DEC_Division_by_zero     ) return DEC_Condition_DZ;
  if (status==DEC_Overflow	       ) return DEC_Condition_OV;
  if (status==DEC_Underflow	       ) return DEC_Condition_UN;
  if (status==DEC_Inexact	       ) return DEC_Condition_IE;

  if (status==DEC_Division_impossible  ) return DEC_Condition_DI;
  if (status==DEC_Division_undefined   ) return DEC_Condition_DU;
  if (status==DEC_Rounded	       ) return DEC_Condition_RO;
  if (status==DEC_Clamped	       ) return DEC_Condition_PA;
  if (status==DEC_Subnormal	       ) return DEC_Condition_SU;
  if (status==DEC_Conversion_syntax    ) return DEC_Condition_CS;
  if (status==DEC_Insufficient_storage ) return DEC_Condition_IS;
  if (status==DEC_Invalid_context      ) return DEC_Condition_IC;
  #if DECSUBSET
  if (status==DEC_Lost_digits	       ) return DEC_Condition_LD;
  #endif
  if (status==0			       ) return DEC_Condition_ZE;
  return DEC_Condition_MU;  /* Multiple errors */
  } /* decContextStatusToString */

/* ------------------------------------------------------------------ */
/* decContextTestSavedStatus -- test bits in saved status	      */
/*								      */
/*  oldstatus is the status word to be tested			      */
/*  mask indicates the bits to be tested (the oldstatus bits that     */
/*    correspond to each 1 bit in the mask are tested)		      */
/*  returns 1 if any of the tested bits are 1, or 0 otherwise	      */
/*								      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
uInt decContextTestSavedStatus(uInt oldstatus, uInt mask) {
  return (oldstatus&mask)!=0;
  } /* decContextTestSavedStatus */

/* ------------------------------------------------------------------ */
/* decContextTestStatus -- test bits in current status		      */
/*								      */
/*  context is the context structure to be updated		      */
/*  mask indicates the bits to be tested (the status bits that	      */
/*    correspond to each 1 bit in the mask are tested)		      */
/*  returns 1 if any of the tested bits are 1, or 0 otherwise	      */
/*								      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
uInt decContextTestStatus(decContext *context, uInt mask) {
  return (context->status&mask)!=0;
  } /* decContextTestStatus */

/* ------------------------------------------------------------------ */
/* decContextZeroStatus -- clear all status bits		      */
/*								      */
/*  context is the context structure to be updated		      */
/*  returns context						      */
/*								      */
/* No error is possible.					      */
/* ------------------------------------------------------------------ */
decContext *decContextZeroStatus(decContext *context) {
  context->status=0;
  return context;
  } /* decContextZeroStatus */
Commit	Line	Data
72ac97cd TM	1	/* Decimal context module for the decNumber C Library.
	2	Copyright (C) 2005, 2007 Free Software Foundation, Inc.
	3	Contributed by IBM Corporation. Author Mike Cowlishaw.
	4
	5	This file is part of GCC.
	6
	7	GCC is free software; you can redistribute it and/or modify it under
	8	the terms of the GNU General Public License as published by the Free
	9	Software Foundation; either version 2, or (at your option) any later
	10	version.
	11
	12	In addition to the permissions in the GNU General Public License,
	13	the Free Software Foundation gives you unlimited permission to link
	14	the compiled version of this file into combinations with other
	15	programs, and to distribute those combinations without any
	16	restriction coming from the use of this file. (The General Public
	17	License restrictions do apply in other respects; for example, they
	18	cover modification of the file, and distribution when not linked
	19	into a combine executable.)
	20
	21	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	22	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	23	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	24	for more details.
	25
	26	You should have received a copy of the GNU General Public License
	27	along with GCC; see the file COPYING. If not, write to the Free
	28	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
	29	02110-1301, USA. */
	30
	31	/* ------------------------------------------------------------------ */
	32	/* Decimal Context module */
	33	/* ------------------------------------------------------------------ */
	34	/* This module comprises the routines for handling arithmetic */
	35	/* context structures. */
	36	/* ------------------------------------------------------------------ */
	37
	38	#include <string.h> /* for strcmp */
	39	#include <stdio.h> /* for printf if DECCHECK */
0f2d3732 TM	40	#include "libdecnumber/dconfig.h"
	41	#include "libdecnumber/decContext.h"
	42	#include "libdecnumber/decNumberLocal.h"
72ac97cd TM	43
	44	#if DECCHECK
	45	/* compile-time endian tester [assumes sizeof(Int)>1] */
	46	static const Int mfcone=1; /* constant 1 */
	47	static const Flag mfctop=(Flag )&mfcone; /* -> top byte */
	48	#define LITEND mfctop / named flag; 1=little-endian */
	49	#endif
	50
	51	/* ------------------------------------------------------------------ */
	52	/* round-for-reround digits */
	53	/* ------------------------------------------------------------------ */
	54	const uByte DECSTICKYTAB[10]={1,1,2,3,4,6,6,7,8,9}; /* used if sticky */
	55
	56	/* ------------------------------------------------------------------ */
	57	/* Powers of ten (powers[n]==10*n, 0<=n<=9) /
	58	/* ------------------------------------------------------------------ */
79af3572 TM	59	const uLong DECPOWERS[19] = {1, 10, 100, 1000, 10000, 100000, 1000000,
	60	10000000, 100000000, 1000000000, 10000000000ULL, 100000000000ULL,
	61	1000000000000ULL, 10000000000000ULL, 100000000000000ULL, 1000000000000000ULL,
	62	10000000000000000ULL, 100000000000000000ULL, 1000000000000000000ULL, };
72ac97cd TM	63
	64	/* ------------------------------------------------------------------ */
	65	/* decContextClearStatus -- clear bits in current status */
	66	/* */
	67	/* context is the context structure to be queried */
	68	/* mask indicates the bits to be cleared (the status bit that */
	69	/* corresponds to each 1 bit in the mask is cleared) */
	70	/* returns context */
	71	/* */
	72	/* No error is possible. */
	73	/* ------------------------------------------------------------------ */
	74	decContext decContextClearStatus(decContext context, uInt mask) {
	75	context->status&=~mask;
	76	return context;
	77	} /* decContextClearStatus */
	78
	79	/* ------------------------------------------------------------------ */
	80	/* decContextDefault -- initialize a context structure */
	81	/* */
	82	/* context is the structure to be initialized */
	83	/* kind selects the required set of default values, one of: */
	84	/* DEC_INIT_BASE -- select ANSI X3-274 defaults */
	85	/* DEC_INIT_DECIMAL32 -- select IEEE 754r defaults, 32-bit */
	86	/* DEC_INIT_DECIMAL64 -- select IEEE 754r defaults, 64-bit */
	87	/* DEC_INIT_DECIMAL128 -- select IEEE 754r defaults, 128-bit */
	88	/* For any other value a valid context is returned, but with */
	89	/* Invalid_operation set in the status field. */
	90	/* returns a context structure with the appropriate initial values. */
	91	/* ------------------------------------------------------------------ */
	92	decContext * decContextDefault(decContext *context, Int kind) {
	93	/* set defaults... */
	94	context->digits=9; /* 9 digits */
	95	context->emax=DEC_MAX_EMAX; /* 9-digit exponents */
	96	context->emin=DEC_MIN_EMIN; /* .. balanced */
	97	context->round=DEC_ROUND_HALF_UP; /* 0.5 rises */
	98	context->traps=DEC_Errors; /* all but informational */
	99	context->status=0; /* cleared */
	100	context->clamp=0; /* no clamping */
	101	#if DECSUBSET
	102	context->extended=0; /* cleared */
	103	#endif
	104	switch (kind) {
	105	case DEC_INIT_BASE:
	106	/* [use defaults] */
	107	break;
	108	case DEC_INIT_DECIMAL32:
	109	context->digits=7; /* digits */
	110	context->emax=96; /* Emax */
	111	context->emin=-95; /* Emin */
	112	context->round=DEC_ROUND_HALF_EVEN; /* 0.5 to nearest even */
	113	context->traps=0; /* no traps set */
	114	context->clamp=1; /* clamp exponents */
	115	#if DECSUBSET
	116	context->extended=1; /* set */
	117	#endif
	118	break;
	119	case DEC_INIT_DECIMAL64:
	120	context->digits=16; /* digits */
	121	context->emax=384; /* Emax */
	122	context->emin=-383; /* Emin */
	123	context->round=DEC_ROUND_HALF_EVEN; /* 0.5 to nearest even */
	124	context->traps=0; /* no traps set */
	125	context->clamp=1; /* clamp exponents */
	126	#if DECSUBSET
127	context->extended=1; /* set */
128	#endif
129	break;
130	case DEC_INIT_DECIMAL128:
131	context->digits=34; /* digits */
132	context->emax=6144; /* Emax */
133	context->emin=-6143; /* Emin */
134	context->round=DEC_ROUND_HALF_EVEN; /* 0.5 to nearest even */
135	context->traps=0; /* no traps set */
136	context->clamp=1; /* clamp exponents */
137	#if DECSUBSET
138	context->extended=1; /* set */
139	#endif
140	break;
141
142	default: /* invalid Kind */
143	/* use defaults, and .. */
144	decContextSetStatus(context, DEC_Invalid_operation); /* trap */
145	}
146
147	#if DECCHECK
148	if (LITEND!=DECLITEND) {
149	const char *adj;
150	if (LITEND) adj="little";
151	else adj="big";
152	printf("Warning: DECLITEND is set to %d, but this computer appears to be %s-endian\n",
153	DECLITEND, adj);
154	}
155	#endif
156	return context;} /* decContextDefault */
157
158	/* ------------------------------------------------------------------ */
159	/* decContextGetRounding -- return current rounding mode */
160	/* */
161	/* context is the context structure to be queried */
162	/* returns the rounding mode */
163	/* */
164	/* No error is possible. */
165	/* ------------------------------------------------------------------ */
166	enum rounding decContextGetRounding(decContext *context) {
167	return context->round;
168	} /* decContextGetRounding */
169
170	/* ------------------------------------------------------------------ */
171	/* decContextGetStatus -- return current status */
172	/* */
173	/* context is the context structure to be queried */
174	/* returns status */
175	/* */
176	/* No error is possible. */
177	/* ------------------------------------------------------------------ */
178	uInt decContextGetStatus(decContext *context) {
179	return context->status;
180	} /* decContextGetStatus */
181
182	/* ------------------------------------------------------------------ */
183	/* decContextRestoreStatus -- restore bits in current status */
184	/* */
185	/* context is the context structure to be updated */
186	/* newstatus is the source for the bits to be restored */
187	/* mask indicates the bits to be restored (the status bit that */
188	/* corresponds to each 1 bit in the mask is set to the value of */
189	/* the correspnding bit in newstatus) */
190	/* returns context */
191	/* */
192	/* No error is possible. */
193	/* ------------------------------------------------------------------ */
194	decContext decContextRestoreStatus(decContext context,
195	uInt newstatus, uInt mask) {
196	context->status&=~mask; /* clear the selected bits */
197	context->status\|=(mask&newstatus); /* or in the new bits */
198	return context;
199	} /* decContextRestoreStatus */
200
201	/* ------------------------------------------------------------------ */
202	/* decContextSaveStatus -- save bits in current status */
203	/* */
204	/* context is the context structure to be queried */
205	/* mask indicates the bits to be saved (the status bits that */
206	/* correspond to each 1 bit in the mask are saved) */
207	/* returns the AND of the mask and the current status */
208	/* */
209	/* No error is possible. */
210	/* ------------------------------------------------------------------ */
211	uInt decContextSaveStatus(decContext *context, uInt mask) {
212	return context->status&mask;
213	} /* decContextSaveStatus */
214
215	/* ------------------------------------------------------------------ */
216	/* decContextSetRounding -- set current rounding mode */
217	/* */
218	/* context is the context structure to be updated */
219	/* newround is the value which will replace the current mode */
220	/* returns context */
221	/* */
222	/* No error is possible. */
223	/* ------------------------------------------------------------------ */
224	decContext decContextSetRounding(decContext context,
225	enum rounding newround) {
226	context->round=newround;
227	return context;
228	} /* decContextSetRounding */
229
230	/* ------------------------------------------------------------------ */
231	/* decContextSetStatus -- set status and raise trap if appropriate */
232	/* */
233	/* context is the context structure to be updated */
234	/* status is the DEC_ exception code */
235	/* returns the context structure */
236	/* */
237	/* Control may never return from this routine, if there is a signal */
238	/* handler and it takes a long jump. */
239	/* ------------------------------------------------------------------ */
240	decContext * decContextSetStatus(decContext *context, uInt status) {
241	context->status\|=status;
242	if (status & context->traps) raise(SIGFPE);
243	return context;} /* decContextSetStatus */
244
245	/* ------------------------------------------------------------------ */
246	/* decContextSetStatusFromString -- set status from a string + trap */
247	/* */
248	/* context is the context structure to be updated */
249	/* string is a string exactly equal to one that might be returned */
250	/* by decContextStatusToString */
251	/* */
252	/* The status bit corresponding to the string is set, and a trap */
253	/* is raised if appropriate. */
254	/* */
255	/* returns the context structure, unless the string is equal to */
256	/* DEC_Condition_MU or is not recognized. In these cases NULL is */
257	/* returned. */
258	/* ------------------------------------------------------------------ */
259	decContext * decContextSetStatusFromString(decContext *context,
260	const char *string) {
261	if (strcmp(string, DEC_Condition_CS)==0)
262	return decContextSetStatus(context, DEC_Conversion_syntax);
263	if (strcmp(string, DEC_Condition_DZ)==0)
264	return decContextSetStatus(context, DEC_Division_by_zero);
265	if (strcmp(string, DEC_Condition_DI)==0)
266	return decContextSetStatus(context, DEC_Division_impossible);
267	if (strcmp(string, DEC_Condition_DU)==0)
268	return decContextSetStatus(context, DEC_Division_undefined);
269	if (strcmp(string, DEC_Condition_IE)==0)
270	return decContextSetStatus(context, DEC_Inexact);
271	if (strcmp(string, DEC_Condition_IS)==0)
272	return decContextSetStatus(context, DEC_Insufficient_storage);
273	if (strcmp(string, DEC_Condition_IC)==0)
274	return decContextSetStatus(context, DEC_Invalid_context);
275	if (strcmp(string, DEC_Condition_IO)==0)
276	return decContextSetStatus(context, DEC_Invalid_operation);
277	#if DECSUBSET
278	if (strcmp(string, DEC_Condition_LD)==0)
279	return decContextSetStatus(context, DEC_Lost_digits);
280	#endif
281	if (strcmp(string, DEC_Condition_OV)==0)
282	return decContextSetStatus(context, DEC_Overflow);
283	if (strcmp(string, DEC_Condition_PA)==0)
284	return decContextSetStatus(context, DEC_Clamped);
285	if (strcmp(string, DEC_Condition_RO)==0)
286	return decContextSetStatus(context, DEC_Rounded);
287	if (strcmp(string, DEC_Condition_SU)==0)
288	return decContextSetStatus(context, DEC_Subnormal);
289	if (strcmp(string, DEC_Condition_UN)==0)
290	return decContextSetStatus(context, DEC_Underflow);
291	if (strcmp(string, DEC_Condition_ZE)==0)
292	return context;
293	return NULL; /* Multiple status, or unknown */
294	} /* decContextSetStatusFromString */
295
296	/* ------------------------------------------------------------------ */
297	/* decContextSetStatusFromStringQuiet -- set status from a string */
298	/* */
299	/* context is the context structure to be updated */
300	/* string is a string exactly equal to one that might be returned */
301	/* by decContextStatusToString */
302	/* */
303	/* The status bit corresponding to the string is set; no trap is */
304	/* raised. */
305	/* */
306	/* returns the context structure, unless the string is equal to */
307	/* DEC_Condition_MU or is not recognized. In these cases NULL is */
308	/* returned. */
309	/* ------------------------------------------------------------------ */
310	decContext * decContextSetStatusFromStringQuiet(decContext *context,
311	const char *string) {
312	if (strcmp(string, DEC_Condition_CS)==0)
313	return decContextSetStatusQuiet(context, DEC_Conversion_syntax);
314	if (strcmp(string, DEC_Condition_DZ)==0)
315	return decContextSetStatusQuiet(context, DEC_Division_by_zero);
316	if (strcmp(string, DEC_Condition_DI)==0)
317	return decContextSetStatusQuiet(context, DEC_Division_impossible);
318	if (strcmp(string, DEC_Condition_DU)==0)
319	return decContextSetStatusQuiet(context, DEC_Division_undefined);
320	if (strcmp(string, DEC_Condition_IE)==0)
321	return decContextSetStatusQuiet(context, DEC_Inexact);
322	if (strcmp(string, DEC_Condition_IS)==0)
323	return decContextSetStatusQuiet(context, DEC_Insufficient_storage);
324	if (strcmp(string, DEC_Condition_IC)==0)
325	return decContextSetStatusQuiet(context, DEC_Invalid_context);
326	if (strcmp(string, DEC_Condition_IO)==0)
327	return decContextSetStatusQuiet(context, DEC_Invalid_operation);
328	#if DECSUBSET
329	if (strcmp(string, DEC_Condition_LD)==0)
330	return decContextSetStatusQuiet(context, DEC_Lost_digits);
331	#endif
332	if (strcmp(string, DEC_Condition_OV)==0)
333	return decContextSetStatusQuiet(context, DEC_Overflow);
334	if (strcmp(string, DEC_Condition_PA)==0)
335	return decContextSetStatusQuiet(context, DEC_Clamped);
336	if (strcmp(string, DEC_Condition_RO)==0)
337	return decContextSetStatusQuiet(context, DEC_Rounded);
338	if (strcmp(string, DEC_Condition_SU)==0)
339	return decContextSetStatusQuiet(context, DEC_Subnormal);
340	if (strcmp(string, DEC_Condition_UN)==0)
341	return decContextSetStatusQuiet(context, DEC_Underflow);
342	if (strcmp(string, DEC_Condition_ZE)==0)
343	return context;
344	return NULL; /* Multiple status, or unknown */
345	} /* decContextSetStatusFromStringQuiet */
346
347	/* ------------------------------------------------------------------ */
348	/* decContextSetStatusQuiet -- set status without trap */
349	/* */
350	/* context is the context structure to be updated */
351	/* status is the DEC_ exception code */
352	/* returns the context structure */
353	/* */
354	/* No error is possible. */
355	/* ------------------------------------------------------------------ */
356	decContext * decContextSetStatusQuiet(decContext *context, uInt status) {
357	context->status\|=status;
358	return context;} /* decContextSetStatusQuiet */
359
360	/* ------------------------------------------------------------------ */
361	/* decContextStatusToString -- convert status flags to a string */
362	/* */
363	/* context is a context with valid status field */
364	/* */
365	/* returns a constant string describing the condition. If multiple */
366	/* (or no) flags are set, a generic constant message is returned. */
367	/* ------------------------------------------------------------------ */
368	const char decContextStatusToString(const decContext context) {
369	Int status=context->status;
370
371	/* test the five IEEE first, as some of the others are ambiguous when */
372	/* DECEXTFLAG=0 */
373	if (status==DEC_Invalid_operation ) return DEC_Condition_IO;
374	if (status==DEC_Division_by_zero ) return DEC_Condition_DZ;
375	if (status==DEC_Overflow ) return DEC_Condition_OV;
376	if (status==DEC_Underflow ) return DEC_Condition_UN;
377	if (status==DEC_Inexact ) return DEC_Condition_IE;
378
379	if (status==DEC_Division_impossible ) return DEC_Condition_DI;
380	if (status==DEC_Division_undefined ) return DEC_Condition_DU;
381	if (status==DEC_Rounded ) return DEC_Condition_RO;
382	if (status==DEC_Clamped ) return DEC_Condition_PA;
383	if (status==DEC_Subnormal ) return DEC_Condition_SU;
384	if (status==DEC_Conversion_syntax ) return DEC_Condition_CS;
385	if (status==DEC_Insufficient_storage ) return DEC_Condition_IS;
386	if (status==DEC_Invalid_context ) return DEC_Condition_IC;
387	#if DECSUBSET
388	if (status==DEC_Lost_digits ) return DEC_Condition_LD;
389	#endif
390	if (status==0 ) return DEC_Condition_ZE;
391	return DEC_Condition_MU; /* Multiple errors */
392	} /* decContextStatusToString */
393
394	/* ------------------------------------------------------------------ */
395	/* decContextTestSavedStatus -- test bits in saved status */
396	/* */
397	/* oldstatus is the status word to be tested */
398	/* mask indicates the bits to be tested (the oldstatus bits that */
399	/* correspond to each 1 bit in the mask are tested) */
400	/* returns 1 if any of the tested bits are 1, or 0 otherwise */
401	/* */
402	/* No error is possible. */
403	/* ------------------------------------------------------------------ */
404	uInt decContextTestSavedStatus(uInt oldstatus, uInt mask) {
405	return (oldstatus&mask)!=0;
406	} /* decContextTestSavedStatus */
407
408	/* ------------------------------------------------------------------ */
409	/* decContextTestStatus -- test bits in current status */
410	/* */
411	/* context is the context structure to be updated */
412	/* mask indicates the bits to be tested (the status bits that */
413	/* correspond to each 1 bit in the mask are tested) */
414	/* returns 1 if any of the tested bits are 1, or 0 otherwise */
415	/* */
416	/* No error is possible. */
417	/* ------------------------------------------------------------------ */
418	uInt decContextTestStatus(decContext *context, uInt mask) {
419	return (context->status&mask)!=0;
420	} /* decContextTestStatus */
421
422	/* ------------------------------------------------------------------ */
423	/* decContextZeroStatus -- clear all status bits */
424	/* */
425	/* context is the context structure to be updated */
426	/* returns context */
427	/* */
428	/* No error is possible. */
429	/* ------------------------------------------------------------------ */
430	decContext decContextZeroStatus(decContext context) {
431	context->status=0;
432	return context;
433	} /* decContextZeroStatus */