[esnacc-dev] [PATCH] cxx-lib/asn-real: Fix encoding

Aaron Conole aconole at bytheb.org
Mon Jan 30 16:18:37 UTC 2017


From: Aaron Conole <aconole at redhat.com>

BER Encoding of asn-real was broken for a long time.  This cleans up the file
and restores base-2 encoding to function properly.

Signed-off-by: Aaron Conole <aconole at bytheb.org>
---
 cxx-lib/src/asn-real.cpp | 694 ++++++-----------------------------------------
 1 file changed, 87 insertions(+), 607 deletions(-)

diff --git a/cxx-lib/src/asn-real.cpp b/cxx-lib/src/asn-real.cpp
index 5d2784f..d38516a 100644
--- a/cxx-lib/src/asn-real.cpp
+++ b/cxx-lib/src/asn-real.cpp
@@ -143,48 +143,34 @@
 
 _BEGIN_SNACC_NAMESPACE
 
-#ifndef IEEE_REAL_LIB
-/* ieee functions (in case not in math.h)*/
-extern "C" {
-extern int iszero (double);
-#ifdef VDAIEEE_NOT_GPP_30
-extern int isinf (double);
-extern int signbit (double);
-#endif
-extern int ilogb (double);
-extern double scalbn (double, int);
-}
-#endif
-
-double AsnPlusInfinity();
-double AsnMinusInfinity();
+static double AsnPlusInfinity();
+static double AsnMinusInfinity();
 
 /*
  * Declare and init the PLUS and MINUS INFINITY values.
  *
  */
-const AsnReal PLUS_INFINITY (AsnPlusInfinity());
-const AsnReal MINUS_INFINITY (AsnMinusInfinity());
-
-#define ENC_PLUS_INFINITY	0x40
-#define ENC_MINUS_INFINITY	0x41
-
-#define REAL_BINARY		0x80
-#define REAL_SIGN		0x40
-#define REAL_EXPLEN_MASK	0x03
-#define REAL_EXPLEN_1		0x00
-#define REAL_EXPLEN_2		0x01
-#define REAL_EXPLEN_3		0x02
-#define REAL_EXPLEN_LONG	0x03
-#define REAL_FACTOR_MASK	0x0c
-#define REAL_BASE_MASK		0x30
-#define REAL_BASE_2		0x00
-#define REAL_BASE_8		0x10
-#define REAL_BASE_16		0x20
+const AsnReal PLUS_INFINITY(AsnPlusInfinity());
+const AsnReal MINUS_INFINITY(AsnMinusInfinity());
+
+#define ENC_PLUS_INFINITY   0x40
+#define ENC_MINUS_INFINITY  0x41
+
+#define REAL_BINARY         0x80
+#define REAL_SIGN           0x40
+#define REAL_EXPLEN_MASK    0x03
+#define REAL_EXPLEN_1       0x00
+#define REAL_EXPLEN_2       0x01
+#define REAL_EXPLEN_3       0x02
+#define REAL_EXPLEN_LONG    0x03
+#define REAL_FACTOR_MASK    0x0c
+#define REAL_BASE_MASK      0x30
+#define REAL_BASE_2         0x00
+#define REAL_BASE_8         0x10
+#define REAL_BASE_16        0x20
 
 // Returns the smallest octet length needed to hold the given long int value
-unsigned int
-SignedIntOctetLen (long int val)
+static unsigned int SignedIntOctetLen(long int val)
 {
     unsigned long int mask = (0x7f80L << ((sizeof (long int) - 2) * 8));
     unsigned int retVal = sizeof (long int);
@@ -192,240 +178,32 @@ SignedIntOctetLen (long int val)
     if (val < 0)
         val = val ^ (~0L);  /* XOR val with all 1's */
 
-    while ((retVal > 1) && ((val & mask) == 0))
-    {
+    while ((retVal > 1) && ((val & mask) == 0)) {
         mask >>= 8;
         retVal--;
     }
 
     return retVal;
-
-} /* SignedIntOctetLen */
-
-
-
-#ifdef IEEE_REAL_FMT
-
-// Returns the PLUS INFINITY in double format
-// This assumes that a C++ double is an IEEE double.
-// The bits for IEEE double PLUS INFINITY are
-// 0x7ff0000000000000
-double AsnPlusInfinity()
-{
-    double d;
-    unsigned char *c = (unsigned char *)&d;
-
-#if WORDS_BIGENDIAN
-    c[0] = 0x7f;
-    c[1] = 0xf0;
-    c[2] = 0x0;
-    c[3] = 0x0;
-    c[4] = 0x0;
-    c[5] = 0x0;
-    c[6] = 0x0;
-    c[7] = 0x0;
-#else
-    c[7] = 0x7f;
-    c[6] = 0xf0;
-    c[5] = 0x0;
-    c[4] = 0x0;
-    c[3] = 0x0;
-    c[2] = 0x0;
-    c[1] = 0x0;
-    c[0] = 0x0;
-#endif
-
-    return d;
-} /* AsnPlusInfinity */
-
-double AsnMinusInfinity()
-{
-    return -AsnPlusInfinity();
 }
 
-#if SIZEOF_DOUBLE != 8
-  #error oops: doubles are expected to be 8 bytes in size!
-#endif
-
-/*
- * Use this routine if you system/compiler represents doubles in the IEEE format.
- */
-AsnLen AsnReal::BEncContent (AsnBuf &b) const
-{
-    int	exponent;
-    int isNeg;
-#if SIZEOF_LONG == 8
-    unsigned long mantissa, val, *p;
-    int i;
-#elif SIZEOF_LONG == 4
-    unsigned char *dbl;
-    unsigned long int *first4;
-    unsigned long int *second4;
-#else
-  #error long neither 8 nor 4 bytes in size?
-#endif
-
-    /* no contents for 0.0 reals */
-    if (value == 0.0) /* all bits zero, disregarding top/sign bit */
-        return 0;
-
-#if SIZEOF_LONG == 8
-    /*
-     * this part assumes that sizeof (long) == sizeof (double) == 8
-     * It shouldn't be endian-dependent but I haven't verified that
-     */
-
-    p = (unsigned long*) &value;
-    val = *p;
-
-    isNeg = (val >> 63) & 1;
-    /* special real values for +/- oo */
-    if (!finite (value))
-    {
-        if (isNeg)
-		{
-			b.PutByteRvs(ENC_MINUS_INFINITY);
-		}
-		else
-        {
-			b.PutByteRvs(ENC_PLUS_INFINITY);
-		}
-
-		return 1;
-    }
-    else /* encode a binary real value */
-    {
-	exponent = (val >> 52) & 0x7ff;
-	mantissa = (val & 0xfffffffffffffL) | 0x10000000000000L;
-
-	for (i = 0; i < 7; i++)
-	{
-          b.PutByteRvs(mantissa & 0xff);
-	  mantissa >>= 8;
-        }
-        exponent -= (1023 + 52);
-
-#elif SIZEOF_LONG == 4
-    /*
-     * this part assumes that sizeof (long) == 4 and
-     * that sizeof (double) == 8
-     *
-     * sign  exponent
-     *     b 2-12 incl
-     *  Sv-----------v----- rest is mantissa
-     * -------------------------------------------
-     * |         |
-     * -------------------------------------------
-     *  123456878 1234
-     *
-     * sign bit is 1 if real is < 0
-     * exponent is an 11 bit unsigned value (subtract 1023 to get correct exp value)
-     * decimal pt implied before mantissa (ie mantissa is all fractional)
-     * and implicit 1 bit to left of decimal
-     *
-     * when given NaN (not a number - ie oo/oo) it encodes the wrong value
-     * instead of checking for the error. If you want to check for it,
-     *  a NaN is any sign bit with a max exponent (all bits a 1) followed
-     *  by any non-zero mantissa. (a zero mantissa is used for infinity)
-     *
-     */
-
-    first4 = (unsigned long int*) (dbl = (unsigned char*) &value);
-    second4 = (unsigned long int *) (dbl + sizeof (long int));
-
-    /* no contents for 0.0 reals */
-    if (value == 0.0) /* all bits zero, disregarding top/sign bit */
-        return 0;
-
-    isNeg = dbl[0] & 0x80;
-
-    /* special real values for +/- oo */
-    if (((*first4 & 0x7fffffff) == 0x7ff00000) && (*second4 == 0))
-    {
-        if (isNeg)
-            b.PutByteRvs (ENC_MINUS_INFINITY);
-        else
-            b.PutByteRvs (ENC_PLUS_INFINITY);
-
-        return 1;
-    }
-    else  /* encode a binary real value */
-    {
-        exponent = (((*first4) >> 20) & 0x07ff);
-
-        /* write the mantissa (N value) */
-        b.PutSegRvs ((char*)(dbl+2), sizeof (double)-2);
-
-        /*
-         * The rightmost 4 bits of a double 2nd octet are the
-         * most sig bits of the mantissa.
-         * write the most signficant byte of the asn1 real manitssa,
-         * adding implicit bit to 'left of decimal' if not de-normalized
-         * (de normalized if exponent == 0)
-         *
-         * if the double is not in de-normalized form subtract 1023
-         * from the exponent to get proper signed exponent.
-         *
-         * for both the normalized and de-norm forms
-         * correct the exponent by subtracting 52 since:
-         *   1. mantissa is 52 bits in the double (56 in ASN.1 REAL form)
-         *   2. implicit decimal at the beginning of double's mantissa
-         *   3. ASN.1 REAL's implicit decimal is after its mantissa
-         * so converting the double mantissa to the ASN.1 form has the
-         * effect of multiplying it by 2^52. Subtracting 52 from the
-         * exponent corrects this.
-         */
-        if (exponent == 0) /* de-normalized - no implicit 1 to left of dec.*/
-        {
-            b.PutByteRvs (dbl[1] & 0x0f);
-            exponent -= 52;
-        }
-        else
-        {
-            b.PutByteRvs ((dbl[1] & 0x0f) | 0x10); /* 0x10 adds implicit bit */
-            exponent -= (1023 + 52);
-        }
-
-#else
-  #error long neither 8 nor 4 bytes in size?
-#endif
-
-        /*  write the exponent  */
-        b.PutByteRvs (exponent & 0xff);
-        b.PutByteRvs (exponent >> 8);
-
-        /* write format octet */
-        /* bb is 00 since base is 2 so do nothing */
-        /* ff is 00 since no other shifting is nec */
-        if (isNeg)
-            b.PutByteRvs (REAL_BINARY | REAL_EXPLEN_2 | REAL_SIGN);
-        else
-            b.PutByteRvs (REAL_BINARY | REAL_EXPLEN_2);
-
-        return sizeof (double) + 2;
-    }
-
-    /* not reached */
-
-}  /*  AsnReal::BEncContent */
-
-#else  /* IEEE_REAL_FMT not def */
-
-#ifdef IEEE_REAL_LIB
-
 // Returns the PLUS INFINITY in double format
 // this assumes you have the IEEE functions in
 // the math lib
-double AsnPlusInfinity()
+static double AsnPlusInfinity()
 {
-    return infinity();
-} /* AsnPlusInfinity */
+    return std::numeric_limits<float>::infinity();
+}
 
-double AsnMinusInfinity()
+static double AsnMinusInfinity()
 {
     return -AsnPlusInfinity();
 }
 
+static bool iszero(double v)
+{
+    return (std::fpclassify(v) == FP_ZERO);
+}
+
 // This routine uses the ieee library routines to encode
 // this AsnReal's double value
 AsnLen AsnReal::BEncContent (AsnBuf &b) const
@@ -435,44 +213,36 @@ AsnLen AsnReal::BEncContent (AsnBuf &b) const
     double tmpMantissa;
     unsigned int truncatedMantissa;
     int exponent;
-    unsigned int expLen;
+    size_t  i, mantissaLen, expLen;
     int sign;
     unsigned char buf[sizeof (double)];
-    int i, mantissaLen;
     unsigned char firstOctet;
 
     /* no contents for 0.0 reals */
-    if (iszero (value))
+    if (iszero(value))
         return 0;
 
     /* special real values for +/- oo */
-    if (isinf (value))
-    {
+    if (isinf (value)) {
         if (signbit (value)) /* neg */
             b.PutByteRvs (ENC_MINUS_INFINITY);
         else
             b.PutByteRvs (ENC_PLUS_INFINITY);
-
         encLen = 1;
-    }
-    else  /* encode a binary real value */
-    {
+    } else {
         if (signbit (value))
             sign = -1;
         else
             sign = 1;
 
-        exponent =  ilogb (value);
+        exponent = ilogb(value);
 
         /* get the absolute value of the mantissa (subtract 1 to make < 1) */
         mantissa = scalbn (fabs (value), -exponent-1);
-
-
         tmpMantissa = mantissa;
 
         /* convert mantissa into an unsigned integer */
-        for (i = 0; i < sizeof (double); i++)
-        {
+        for (i = 0; i < sizeof (double); i++) {
             /* normalizied so shift 8 bits worth to the left of the decimal */
             tmpMantissa *= (1<<8);
 
@@ -536,7 +306,7 @@ AsnLen AsnReal::BEncContent (AsnBuf &b) const
          */
         exponent++; /* compensate for trick to put mantissa < 1 */
         exponent -= (mantissaLen * 8);
-        expLen = SignedIntOctetLen (exponent);
+        expLen = SignedIntOctetLen(exponent);
 
         switch (expLen)
         {
@@ -560,225 +330,24 @@ AsnLen AsnReal::BEncContent (AsnBuf &b) const
         b.PutSegRvs ((char*)buf, mantissaLen);
 
         /* write the exponent */
-        for (i = expLen; i > 0; i--)
-        {
+        for (i = expLen; i > 0; i--) {
             b.PutByteRvs (exponent);
-            exponent >> 8;
+            exponent >>= 8;
         }
 
         /* write the exponents length if nec */
-        if (expLen > 3)
-        {
+        if (expLen > 3) {
             encLen++;
             b.PutByteRvs (expLen);
         }
 
         /* write the format octet */
         b.PutByteRvs (firstOctet);
-
     }
     return encLen;
 
 }  /*  AsnReal::BEncContent */
 
-#else  /* neither IEEE_REAL_FMT or IEEE_REAL_LIB are def */
-
-
-// Returns the PLUS INFINITY in double format
-// This assumes that a C++ double is an IEEE double.
-// The bits for IEEE double PLUS INFINITY are
-// 0x7ff0000000000000
-// NOTE: this is a guess - you should set this up for
-// your architecture
-double AsnPlusInfinity()
-{
-    double d;
-    unsigned char *c;
-    unsigned long i;
-
-    c = (unsigned char*)&d;
-    c[0] = 0x7f;
-    c[1] = 0xf0;
-    for (i = 2; i < sizeof (double); i++)
-        c[i] = 0;
-    return d;
-} /* AsnPlusInfinity */
-
-double AsnMinusInfinity()
-{
-    return -AsnPlusInfinity();
-}
-
-/*
- * Encodes the content of an ASN.1 REAL value to the given buffer.
- * This version of the routine does not assume an IEEE double rep.
- * or the existence of the IEEE library routines.  Uses old style
- * UNIX frexp etc.
- */
-AsnLen AsnReal::BEncContent (AsnBuf &b) const
-{
-    unsigned long int encLen;
-    double mantissa;
-    double tmpMantissa;
-    unsigned int truncatedMantissa;
-    int exponent;
-    unsigned int expLen;
-    int sign;
-    unsigned char buf[sizeof (double)];
-    unsigned int i, mantissaLen=0;
-    unsigned char firstOctet;
-
-    /* no contents for 0.0 reals */
-    if (value == 0.0)
-        return 0;
-
-    /* special real values for +/- oo */
-    if (value == MINUS_INFINITY)
-    {
-        b.PutByteRvs (ENC_MINUS_INFINITY);
-        encLen = 1;
-    }
-    else if (value == PLUS_INFINITY)
-    {
-        b.PutByteRvs (ENC_PLUS_INFINITY);
-        encLen = 1;
-    }
-    else  /* encode a binary real value */
-    {
-        /*
-         * this is what frexp gets from value
-         * value == mantissa * 2^exponent
-         * where 0.5 <= |manitissa| < 1.0
-         */
-        mantissa = frexp (value, &exponent);
-
-        /* set sign and make mantissa = | mantissa | */
-        if (mantissa < 0.0)
-        {
-            sign = -1;
-            mantissa *= -1;
-        }
-        else
-            sign = 1;
-
-
-        tmpMantissa = mantissa;
-
-        /* convert mantissa into an unsigned integer */
-        for (i = 0; i < sizeof (double); i++)
-        {
-            /* normalizied so shift 8 bits worth to the left of the decimal */
-            tmpMantissa *= (1<<8);
-
-            /* grab only (octet sized) the integer part */
-            truncatedMantissa = (unsigned int) tmpMantissa;
-
-            /* remove part to left of decimal now for next iteration */
-            tmpMantissa -= truncatedMantissa;
-
-            /* write into tmp buffer */
-            buf[i] = (unsigned char)truncatedMantissa;
-
-            /* keep track of last non zero octet so can zap trailing zeros */
-            if (truncatedMantissa)
-                mantissaLen = i+1;
-        }
-
-        /*
-         * write format octet  (first octet of content)
-         *  field  1 S bb ff ee
-         *  bit#   8 7 65 43 21
-         *
-         * 1 in bit#1 means binary rep
-         * 1 in bit#2 means the mantissa is neg, 0 pos
-         * bb is the base:    65  base
-         *                    00    2
-         *                    01    8
-         *                    10    16
-         *                    11    future ext.
-         *
-         * ff is the Value of F where  Mantissa = sign x N x 2^F
-         *    FF can be one of 0 to 3 inclusive. (used to save re-alignment)
-         *
-         * ee is the length of the exponent:  21   length
-         *                                    00     1
-         *                                    01     2
-         *                                    10     3
-         *                                    11     long form
-         *
-         *
-         * encoded binary real value looks like
-         *
-         *     fmt oct
-         *   --------------------------------------------------------
-         *   |1Sbbffee|  exponent (2's comp)  |   N (unsigned int)  |
-         *   --------------------------------------------------------
-         *    87654321
-         */
-        firstOctet = REAL_BINARY;
-        if (sign == -1)
-            firstOctet |= REAL_SIGN;
-
-        /* bb is 00 since base is 2 so do nothing */
-        /* ff is 00 since no other shifting is nec */
-
-        /*
-         * get exponent calculate its encoded length
-         * Note that the process of converting the mantissa
-         * double to an int shifted the decimal mantissaLen * 8
-         * to the right - so correct that here
-         */
-        //exponent -= (mantissaLen * 8);
-        expLen = SignedIntOctetLen (exponent);
-
-        switch (expLen)
-        {
-            case 1:
-                firstOctet |= REAL_EXPLEN_1;
-                break;
-            case 2:
-                firstOctet |= REAL_EXPLEN_2;
-                break;
-            case 3:
-                firstOctet |= REAL_EXPLEN_3;
-                break;
-            default:
-                firstOctet |= REAL_EXPLEN_LONG;
-                break;
-        }
-
-        encLen = mantissaLen + expLen + 1;
-
-        /* write the mantissa (N value) */
-        b.PutSegRvs ((char*)buf, mantissaLen);
-
-        /* write the exponent */
-        for (i = expLen; i > 0; i--)
-        {
-            b.PutByteRvs ((unsigned char)exponent);
-            //RWC;10/10/00;I suspect we need this for multi-byte exponents... 
-            exponent = exponent >> 8;
-        }
-
-        /* write the exponents length if nec */
-        if (expLen > 3)
-        {
-            encLen++;
-            b.PutByteRvs ((unsigned char)expLen);
-        }
-
-        /* write the format octet */
-        b.PutByteRvs (firstOctet);
-
-    }
-    return encLen;
-
-}  /*  AsnReal::BEncContent */
-
-
-
-#endif
-#endif
 
 static double domainExp(double i, int j)
 {
@@ -856,7 +425,7 @@ void AsnReal::BDecContent (const AsnBuf &b, AsnTag /* tagId */, AsnLen elmtLen,
                     i = firstExpOctet-1;
                     firstExpOctet =  b.GetByte();
                     if (firstExpOctet & 0x80)
-                        exponent = (-1 <<8) | firstExpOctet;
+                        exponent = (~0UL << 8) | firstExpOctet;
                     else
                         exponent = firstExpOctet;
                     for (;i > 0; firstExpOctet--, i--)
@@ -872,7 +441,7 @@ void AsnReal::BDecContent (const AsnBuf &b, AsnTag /* tagId */, AsnLen elmtLen,
                 
                 mantissa = domainExp(mantissa, 8) + cValue;
             }
-	    
+
             switch (firstOctet & REAL_BASE_MASK)
             {
             case REAL_BASE_2:
@@ -914,57 +483,46 @@ void AsnReal::BDecContent (const AsnBuf &b, AsnTag /* tagId */, AsnLen elmtLen,
 
 AsnLen AsnReal::PEnc (AsnBufBits &b) const
 {
-	AsnLen len=0;
+    AsnLen len=0;
     long templen = 0;
-	AsnBuf tempBuf;
-	char* seg = NULL;
-
-	templen += BEncContent(tempBuf);
-
-	seg = new char[templen + 1];
-
-	tempBuf.GetSeg(seg, templen);
-	
-	len += PEncDefLenTo127(b, templen);
-
-	if(templen > 0)
-	{
-
-		templen *= 8;
-
-		len += b.OctetAlignWrite();
-
-
-		len += b.PutBits((unsigned char*) seg, templen);
-	}
+    AsnBuf tempBuf;
+    char* seg = NULL;
+
+    templen += BEncContent(tempBuf);
+    seg = new char[templen + 1];
+    tempBuf.GetSeg(seg, templen);
+    len += PEncDefLenTo127(b, templen);
+
+    if (templen > 0) {
+        templen *= 8;
+        len += b.OctetAlignWrite();
+        len += b.PutBits((unsigned char*) seg, templen);
+    }
 
     delete[] seg;
-	return len;
+    return len;
 }
 
 
 void AsnReal::PDec (AsnBufBits &b, AsnLen &bitsDecoded)
 {
-	AsnBuf tempBuf;
-	AsnLen bytesDecoded = 0;
-	unsigned char* seg;
-	unsigned long lseg;
-
-	seg = b.GetBits(8);
-	lseg = (unsigned long)seg[0];
-	bitsDecoded += 8;
-	
-	bitsDecoded += b.OctetAlignRead();
-
+    AsnBuf tempBuf;
+    AsnLen bytesDecoded = 0;
+    unsigned char* seg;
+    unsigned long lseg;
+
+    seg = b.GetBits(8);
+    lseg = (unsigned long)seg[0];
+    bitsDecoded += 8 + b.OctetAlignRead();
     delete [] seg;
-	seg = b.GetBits(lseg * 8);
 
-	tempBuf.PutSegRvs((char*)seg, lseg);
+    seg = b.GetBits(lseg * 8);
+    tempBuf.PutSegRvs((char*)seg, lseg);
 
-	
-	BDecContent (tempBuf, MAKE_TAG_ID (UNIV, PRIM, REAL_TAG_CODE), lseg, bytesDecoded);
+    BDecContent(tempBuf, MAKE_TAG_ID(UNIV, PRIM, REAL_TAG_CODE),
+                lseg, bytesDecoded);
 
-	bitsDecoded += (bytesDecoded * 8);
+    bitsDecoded += (bytesDecoded * 8);
     delete [] seg;
 }
 
@@ -972,9 +530,9 @@ void AsnReal::PDec (AsnBufBits &b, AsnLen &bitsDecoded)
 AsnLen AsnReal::BEnc (AsnBuf &b) const
 {
     AsnLen l;
-    l =  BEncContent (b);
-    l += BEncDefLen (b, l);
-    l += BEncTag1 (b, UNIV, PRIM, REAL_TAG_CODE);
+    l =  BEncContent(b);
+    l += BEncDefLen(b, l);
+    l += BEncTag1(b, UNIV, PRIM, REAL_TAG_CODE);
     return l;
 }
 
@@ -985,14 +543,14 @@ void AsnReal::BDec (const AsnBuf &b, AsnLen &bytesDecoded)
     AsnLen elmtLen;
     AsnTag tagId;
 
-    tagId = BDecTag (b, bytesDecoded); 
-    if (tagId != MAKE_TAG_ID (UNIV, PRIM, REAL_TAG_CODE))
-    {
+    tagId = BDecTag(b, bytesDecoded); 
+    if (tagId != MAKE_TAG_ID(UNIV, PRIM, REAL_TAG_CODE)) {
         throw InvalidTagException(typeName(), tagId, STACK_ENTRY);
     }
-    elmtLen = BDecLen (b, bytesDecoded);
 
-    BDecContent (b, MAKE_TAG_ID (UNIV, PRIM, REAL_TAG_CODE), elmtLen, bytesDecoded);
+    elmtLen = BDecLen(b, bytesDecoded);
+    BDecContent(b, MAKE_TAG_ID(UNIV, PRIM, REAL_TAG_CODE),
+                elmtLen, bytesDecoded);
 }
 
 void AsnReal::Print(std::ostream& os, unsigned short /*indent*/) const
@@ -1012,111 +570,33 @@ void AsnReal::PrintXML (std::ostream &os, const char *lpszTitle) const
 
 char* AsnReal::checkRealValRange(const double m_Lower, const double m_Upper) const
 {
-
-	double ltemp;
-    char* pError=NULL;
+    double ltemp = value;
+    char* pError = NULL;
     char cTmperr[200];
 
-
-   ltemp=value;
-
-   if(ltemp<=m_Upper && ltemp >= m_Lower)
-   {
-	return pError;
-   }
-   else
-   {
-	if(ltemp>m_Upper)
-    {
+    if (ltemp > m_Upper) {
         sprintf(cTmperr, "_______\nREAL--Valuerange Constraints:\n_______\nError: --Value out of range--\nValue: %.5f is above the Upper Limit: %.5f \n", ltemp, m_Upper);
         pError = strdup(cTmperr);
-        return pError;
-    }
-    else if(ltemp<m_Lower)
-    {
+    } else if (ltemp < m_Lower) {
         sprintf(cTmperr, "_______\nREAL--Valuerange Constraints:\n_______\nError: --Value out of range--\nValue: %.5f is below the Lower Limit: %.5f \n", ltemp, m_Lower);
         pError = strdup(cTmperr);
-        return pError;
     }
-    else
-    {
-        return pError;
-    }
-   }
 
-   return pError;
+    return pError;
 }
 
 char* AsnReal::checkRealSingleVal(const double m_SingleVal) const
 {
-
-	double ltemp;
-    char* pError=NULL;
+    double ltemp = value;
+    char* pError = NULL;
     char cTmperr[200];
 
-
-   ltemp=value;
-
-   if(ltemp==m_SingleVal)
-   {
-	return pError;
-   }
-   else
-   {
+    if (ltemp != m_SingleVal) {
         sprintf(cTmperr, "_______\nREAL--SingleValue Constraints:\n_______\nError: --Values must match--\nValue: %.5f is not equal to the Constraint Single Value:  %.5f \n", ltemp, m_SingleVal);
         pError = strdup(cTmperr);
-        return pError;
-   
    }
 
    return pError;
 }
 
-
-
-
-#if META
-
-const AsnRealTypeDesc AsnReal::_desc (NULL, NULL, false, AsnTypeDesc::REAL, NULL);
-
-const AsnTypeDesc *AsnReal::_getdesc() const
-{
-  return &_desc;
-}
-
-#if TCL
-
-int AsnReal::TclGetVal (Tcl_Interp *interp) const
-{
-  if (value == PLUS_INFINITY)
-    strcpy (interp->result, "+inf");
-  else if (value == MINUS_INFINITY)
-    strcpy (interp->result, "-inf");
-  else
-    sprintf (interp->result, "%g", value);
-  return TCL_OK;
-}
-
-int AsnReal::TclSetVal (Tcl_Interp *interp, const char *valstr)
-{
-  double valval;
-
-  if (!strcmp (valstr, "+inf"))
-    valval = PLUS_INFINITY;
-  else if (!strcmp (valstr, "-inf"))
-    valval = MINUS_INFINITY;
-  else if (Tcl_GetDouble (interp, (char*)valstr, &valval) != TCL_OK)
-    return TCL_ERROR;
-
-  value = valval;
-
-  return TCL_OK;
-}
-
-#endif /* TCL */
-#endif /* META */
-
-
-
-
 _END_SNACC_NAMESPACE
-- 
2.7.4



More information about the dev mailing list