migration/savevm: wrap into qemu_loadvm_state_header()

[mirror_qemu.git] / libdecnumber / decNumber.c

diff --git a/libdecnumber/decNumber.c b/libdecnumber/decNumber.c
index a30632f94ec213a9d72ee3ca62eb46677e41fc3e..8c197023f45602484f3ec85c7b9a6f8eb8159826 100644 (file)
--- a/libdecnumber/decNumber.c
+++ b/libdecnumber/decNumber.c
@@ -166,10 +166,7 @@
 /*     **  -- raise to the power                                     */
 /* ------------------------------------------------------------------ */
 
-#include <stdlib.h>               /* for malloc, free, etc. */
-#include <stdio.h>                /* for printf [if needed] */
-#include <string.h>               /* for strcpy */
-#include <ctype.h>                /* for lower */
+#include "qemu/osdep.h"
 #include "libdecnumber/dconfig.h"
 #include "libdecnumber/decNumber.h"
 #include "libdecnumber/decNumberLocal.h"
@@ -2238,7 +2235,7 @@ decNumber * decNumberPower(decNumber *res, const decNumber *lhs,
       /* if a negative power the constant 1 is needed, and if not subset */
       /* invert the lhs now rather than inverting the result later */
       if (decNumberIsNegative(rhs)) {  /* was a **-n [hence digits>0] */
-       decNumber *inv=invbuff;         /* asssume use fixed buffer */
+       decNumber *inv=invbuff;         /* assume use fixed buffer */
        decNumberCopy(&dnOne, dac);     /* dnOne=1;  [needed now or later] */
        #if DECSUBSET
        if (set->extended) {            /* need to calculate 1/lhs */
@@ -3849,7 +3846,7 @@ static void decToString(const decNumber *dn, char *string, Flag eng) {
 /*                                                                   */
 /* Addition, especially x=x+1, is speed-critical.                    */
 /* The static buffer is larger than might be expected to allow for    */
-/* calls from higher-level funtions (notable exp).                   */
+/* calls from higher-level functions (notably exp).                  */
 /* ------------------------------------------------------------------ */
 static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
                            const decNumber *rhs, decContext *set,
@@ -4263,7 +4260,7 @@ static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
 /* long subtractions.  These are acc and var1 respectively.          */
 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
 /* The static buffers may be larger than might be expected to allow   */
-/* for calls from higher-level funtions (notable exp).               */
+/* for calls from higher-level functions (notably exp).                      */
 /* ------------------------------------------------------------------ */
 static decNumber * decDivideOp(decNumber *res,
                               const decNumber *lhs, const decNumber *rhs,
@@ -4778,7 +4775,7 @@ static decNumber * decDivideOp(decNumber *res,
            half=*up & 0x01;
            *up/=2;                /* [shift] */
            if (!half) continue;
-           *(up-1)+=(DECDPUNMAX+1)/2;
+           *(up-1)+=DIV_ROUND_UP(DECDPUNMAX, 2);
            }
          /* [accunits still describes the original remainder length] */
 
@@ -5254,7 +5251,7 @@ static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
 /*    exp(-x) where x can be the tiniest number (Ntiny).             */
 /*                                                                   */
 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop        */
-/*    iterations by appoximately a third with additional (although    */
+/*    iterations by approximately a third with additional (although    */
 /*    diminishing) returns as the range is reduced to even smaller    */
 /*    fractions.  However, h (the power of 10 used to correct the     */
 /*    result at the end, see below) must be kept <=8 as otherwise     */
@@ -5275,8 +5272,8 @@ static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
 /* 4. The working precisions for the static buffers are twice the     */
 /*    obvious size to allow for calls from decNumberPower.           */
 /* ------------------------------------------------------------------ */
-decNumber * decExpOp(decNumber *res, const decNumber *rhs,
-                        decContext *set, uInt *status) {
+static decNumber *decExpOp(decNumber *res, const decNumber *rhs,
+                           decContext *set, uInt *status) {
   uInt ignore=0;                  /* working status */
   Int h;                          /* adjusted exponent for 0.xxxx */
   Int p;                          /* working precision */
@@ -5563,7 +5560,8 @@ decNumber * decExpOp(decNumber *res, const decNumber *rhs,
 /*          where x is truncated (NB) into the range 10 through 99,  */
 /*          and then c = k>>2 and e = k&3.                           */
 /* ------------------------------------------------------------------ */
-const uShort LNnn[90]={9016,  8652,  8316,  8008,  7724,  7456,         7208,
+static const uShort LNnn[90] = {
+  9016,  8652,  8316,  8008,  7724,  7456,  7208,
   6972,         6748,  6540,  6340,  6148,  5968,  5792,  5628,  5464,  5312,
   5164,         5020,  4884,  4748,  4620,  4496,  4376,  4256,  4144,  4032,
  39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
@@ -5635,8 +5633,8 @@ const uShort LNnn[90]={9016,  8652,  8316,  8008,  7724,  7456,    7208,
 /* 5. The static buffers are larger than might be expected to allow   */
 /*    for calls from decNumberPower.                                 */
 /* ------------------------------------------------------------------ */
-decNumber * decLnOp(decNumber *res, const decNumber *rhs,
-                   decContext *set, uInt *status) {
+static decNumber *decLnOp(decNumber *res, const decNumber *rhs,
+                          decContext *set, uInt *status) {
   uInt ignore=0;                  /* working status accumulator */
   uInt needbytes;                 /* for space calculations */
   Int residue;                    /* rounding residue */
@@ -6052,9 +6050,9 @@ static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,
 /* The emphasis here is on speed for common cases, and avoiding              */
 /* coefficient comparison if possible.                               */
 /* ------------------------------------------------------------------ */
-decNumber * decCompareOp(decNumber *res, const decNumber *lhs,
-                        const decNumber *rhs, decContext *set,
-                        Flag op, uInt *status) {
+static decNumber *decCompareOp(decNumber *res, const decNumber *lhs,
+                               const decNumber *rhs, decContext *set,
+                               Flag op, uInt *status) {
   #if DECSUBSET
   decNumber *alloclhs=NULL;       /* non-NULL if rounded lhs allocated */
   decNumber *allocrhs=NULL;       /* .., rhs */
@@ -6086,11 +6084,11 @@ decNumber * decCompareOp(decNumber *res, const decNumber *lhs,
 
     /* If total ordering then handle differing signs 'up front' */
     if (op==COMPTOTAL) {               /* total ordering */
-      if (decNumberIsNegative(lhs) & !decNumberIsNegative(rhs)) {
+      if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) {
        result=-1;
        break;
        }
-      if (!decNumberIsNegative(lhs) & decNumberIsNegative(rhs)) {
+      if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) {
        result=+1;
        break;
        }