bug 658363 - move defines for double constants out of xslt r=sicking
authorTrevor Saunders <trev.saunders@gmail.com>
Thu, 19 May 2011 12:35:46 -0700
changeset 70222 2b53d3079c78a7d79f39476cf1e3539b80a9691e
parent 70221 5f991615ac6a521ff0e240d210e670b48ce6f909
child 70223 3b17ef9c3cd8e8a91dc7f5bd6657189a9233eb12
push idunknown
push userunknown
push dateunknown
reviewerssicking
bugs658363, 100644
milestone7.0a1
bug 658363 - move defines for double constants out of xslt r=sicking From 57a4aaadf8fef828764c35dad01ce6da54fbb638 Mon Sep 17 00:00:00 2001 xslt --- content/base/public/nsContentUtils.h | 93 +++++++++++++++++++ content/xslt/public/Makefile.in | 1 - content/xslt/public/txDouble.h | 133 --------------------------- content/xslt/src/base/txCore.h | 8 +- content/xslt/src/base/txDouble.cpp | 18 ++-- content/xslt/src/xpath/txRelationalExpr.cpp | 12 +- 6 files changed, 112 insertions(+), 153 deletions(-) delete mode 100644 content/xslt/public/txDouble.h
content/base/public/nsContentUtils.h
content/xslt/public/Makefile.in
content/xslt/public/txDouble.h
content/xslt/src/base/txCore.h
content/xslt/src/base/txDouble.cpp
content/xslt/src/xpath/txRelationalExpr.cpp
--- a/content/base/public/nsContentUtils.h
+++ b/content/base/public/nsContentUtils.h
@@ -46,16 +46,27 @@
 #if defined(XP_WIN) || defined(XP_OS2)
 #include <float.h>
 #endif
 
 #if defined(SOLARIS)
 #include <ieeefp.h>
 #endif
 
+//A trick to handle IEEE floating point exceptions on FreeBSD - E.D.
+#ifdef __FreeBSD__
+#include <ieeefp.h>
+#ifdef __alpha__
+static fp_except_t allmask = FP_X_INV|FP_X_OFL|FP_X_UFL|FP_X_DZ|FP_X_IMP;
+#else
+static fp_except_t allmask = FP_X_INV|FP_X_OFL|FP_X_UFL|FP_X_DZ|FP_X_IMP|FP_X_DNML;
+#endif
+static fp_except_t oldmask = fpsetmask(~allmask);
+#endif
+
 #include "nsAString.h"
 #include "nsIStatefulFrame.h"
 #include "nsINodeInfo.h"
 #include "nsNodeInfoManager.h"
 #include "nsContentList.h"
 #include "nsDOMClassInfoID.h"
 #include "nsIXPCScriptable.h"
 #include "nsIDOM3Node.h"
@@ -1924,16 +1935,98 @@ public:
   if (aIID.Equals(NS_GET_IID(_interface))) {                                  \
     foundInterface = static_cast<_interface *>(_allocator);                   \
     if (!foundInterface) {                                                    \
       *aInstancePtr = nsnull;                                                 \
       return NS_ERROR_OUT_OF_MEMORY;                                          \
     }                                                                         \
   } else
 
+/**
+ * Macros to workaround math-bugs bugs in various platforms
+ */
+
+/**
+ * Stefan Hanske <sh990154@mail.uni-greifswald.de> reports:
+ *  ARM is a little endian architecture but 64 bit double words are stored
+ * differently: the 32 bit words are in little endian byte order, the two words
+ * are stored in big endian`s way.
+ */
+
+#if defined(__arm) || defined(__arm32__) || defined(__arm26__) || defined(__arm__)
+#if !defined(__VFP_FP__)
+#define FPU_IS_ARM_FPA
+#endif
+#endif
+
+typedef union dpun {
+    struct {
+#if defined(IS_LITTLE_ENDIAN) && !defined(FPU_IS_ARM_FPA)
+        PRUint32 lo, hi;
+#else
+        PRUint32 hi, lo;
+#endif
+    } s;
+    PRFloat64 d;
+public:
+    operator double() const {
+        return d;
+    }
+} dpun;
+
+/**
+ * Utility class for doubles
+ */
+#if (__GNUC__ == 2 && __GNUC_MINOR__ > 95) || __GNUC__ > 2
+/**
+ * This version of the macros is safe for the alias optimizations
+ * that gcc does, but uses gcc-specific extensions.
+ */
+#define DOUBLE_HI32(x) (__extension__ ({ dpun u; u.d = (x); u.s.hi; }))
+#define DOUBLE_LO32(x) (__extension__ ({ dpun u; u.d = (x); u.s.lo; }))
+
+#else // __GNUC__
+
+/* We don't know of any non-gcc compilers that perform alias optimization,
+ * so this code should work.
+ */
+
+#if defined(IS_LITTLE_ENDIAN) && !defined(FPU_IS_ARM_FPA)
+#define DOUBLE_HI32(x)        (((PRUint32 *)&(x))[1])
+#define DOUBLE_LO32(x)        (((PRUint32 *)&(x))[0])
+#else
+#define DOUBLE_HI32(x)        (((PRUint32 *)&(x))[0])
+#define DOUBLE_LO32(x)        (((PRUint32 *)&(x))[1])
+#endif
+
+#endif // __GNUC__
+
+#define DOUBLE_HI32_SIGNBIT   0x80000000
+#define DOUBLE_HI32_EXPMASK   0x7ff00000
+#define DOUBLE_HI32_MANTMASK  0x000fffff
+
+#define DOUBLE_IS_NaN(x)                                                \
+((DOUBLE_HI32(x) & DOUBLE_HI32_EXPMASK) == DOUBLE_HI32_EXPMASK && \
+ (DOUBLE_LO32(x) || (DOUBLE_HI32(x) & DOUBLE_HI32_MANTMASK)))
+
+#ifdef IS_BIG_ENDIAN
+#define DOUBLE_NaN {{DOUBLE_HI32_EXPMASK | DOUBLE_HI32_MANTMASK,   \
+                        0xffffffff}}
+#else
+#define DOUBLE_NaN {{0xffffffff,                                         \
+                        DOUBLE_HI32_EXPMASK | DOUBLE_HI32_MANTMASK}}
+#endif
+
+#if defined(XP_WIN)
+#define DOUBLE_COMPARE(LVAL, OP, RVAL)                                  \
+    (!DOUBLE_IS_NaN(LVAL) && !DOUBLE_IS_NaN(RVAL) && (LVAL) OP (RVAL))
+#else
+#define DOUBLE_COMPARE(LVAL, OP, RVAL) ((LVAL) OP (RVAL))
+#endif
+
 /*
  * Check whether a floating point number is finite (not +/-infinity and not a
  * NaN value).
  */
 inline NS_HIDDEN_(PRBool) NS_FloatIsFinite(jsdouble f) {
 #ifdef WIN32
   return _finite(f);
 #else
--- a/content/xslt/public/Makefile.in
+++ b/content/xslt/public/Makefile.in
@@ -42,17 +42,16 @@ VPATH		= @srcdir@
 
 include $(DEPTH)/config/autoconf.mk
 
 MODULE       = content
 XPIDL_MODULE = content_xslt
 
 EXPORTS		= \
 		nsIDocumentTransformer.h \
-		txDouble.h \
 		$(NULL)
 
 XPIDLSRCS	= \
 		nsIXSLTException.idl  \
 		nsIXSLTProcessor.idl  \
 		nsIXSLTProcessorPrivate.idl  \
 		txIFunctionEvaluationContext.idl  \
 		txINodeSet.idl  \
deleted file mode 100644
--- a/content/xslt/public/txDouble.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Peter Van der Beken.
- * Portions created by the Initial Developer are Copyright (C) 2005
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Peter Van der Beken <peterv@propagandism.org>
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef __txdouble_h__
-#define __txdouble_h__
-
-//A trick to handle IEEE floating point exceptions on FreeBSD - E.D.
-#ifdef __FreeBSD__
-#include <ieeefp.h>
-#ifdef __alpha__
-static fp_except_t allmask = FP_X_INV|FP_X_OFL|FP_X_UFL|FP_X_DZ|FP_X_IMP;
-#else
-static fp_except_t allmask = FP_X_INV|FP_X_OFL|FP_X_UFL|FP_X_DZ|FP_X_IMP|FP_X_DNML;
-#endif
-static fp_except_t oldmask = fpsetmask(~allmask);
-#endif
-
-/**
- * Macros to workaround math-bugs bugs in various platforms
- */
-
-/**
- * Stefan Hanske <sh990154@mail.uni-greifswald.de> reports:
- *  ARM is a little endian architecture but 64 bit double words are stored
- * differently: the 32 bit words are in little endian byte order, the two words
- * are stored in big endian`s way.
- */
-
-#if defined(__arm) || defined(__arm32__) || defined(__arm26__) || defined(__arm__)
-#if !defined(__VFP_FP__)
-#define FPU_IS_ARM_FPA
-#endif
-#endif
-
-typedef union txdpun {
-    struct {
-#if defined(IS_LITTLE_ENDIAN) && !defined(FPU_IS_ARM_FPA)
-        PRUint32 lo, hi;
-#else
-        PRUint32 hi, lo;
-#endif
-    } s;
-    PRFloat64 d;
-public:
-    operator double() const {
-        return d;
-    }
-} txdpun;
-
-#if (__GNUC__ == 2 && __GNUC_MINOR__ > 95) || __GNUC__ > 2
-/**
- * This version of the macros is safe for the alias optimizations
- * that gcc does, but uses gcc-specific extensions.
- */
-#define TX_DOUBLE_HI32(x) (__extension__ ({ txdpun u; u.d = (x); u.s.hi; }))
-#define TX_DOUBLE_LO32(x) (__extension__ ({ txdpun u; u.d = (x); u.s.lo; }))
-
-#else // __GNUC__
-
-/* We don't know of any non-gcc compilers that perform alias optimization,
- * so this code should work.
- */
-
-#if defined(IS_LITTLE_ENDIAN) && !defined(FPU_IS_ARM_FPA)
-#define TX_DOUBLE_HI32(x)        (((PRUint32 *)&(x))[1])
-#define TX_DOUBLE_LO32(x)        (((PRUint32 *)&(x))[0])
-#else
-#define TX_DOUBLE_HI32(x)        (((PRUint32 *)&(x))[0])
-#define TX_DOUBLE_LO32(x)        (((PRUint32 *)&(x))[1])
-#endif
-
-#endif // __GNUC__
-
-#define TX_DOUBLE_HI32_SIGNBIT   0x80000000
-#define TX_DOUBLE_HI32_EXPMASK   0x7ff00000
-#define TX_DOUBLE_HI32_MANTMASK  0x000fffff
-
-#define TX_DOUBLE_IS_NaN(x)                                                \
-((TX_DOUBLE_HI32(x) & TX_DOUBLE_HI32_EXPMASK) == TX_DOUBLE_HI32_EXPMASK && \
- (TX_DOUBLE_LO32(x) || (TX_DOUBLE_HI32(x) & TX_DOUBLE_HI32_MANTMASK)))
-
-#ifdef IS_BIG_ENDIAN
-#define TX_DOUBLE_NaN {{TX_DOUBLE_HI32_EXPMASK | TX_DOUBLE_HI32_MANTMASK,   \
-                        0xffffffff}}
-#else
-#define TX_DOUBLE_NaN {{0xffffffff,                                         \
-                        TX_DOUBLE_HI32_EXPMASK | TX_DOUBLE_HI32_MANTMASK}}
-#endif
-
-#if defined(XP_WIN)
-#define TX_DOUBLE_COMPARE(LVAL, OP, RVAL)                                  \
-    (!TX_DOUBLE_IS_NaN(LVAL) && !TX_DOUBLE_IS_NaN(RVAL) && (LVAL) OP (RVAL))
-#else
-#define TX_DOUBLE_COMPARE(LVAL, OP, RVAL) ((LVAL) OP (RVAL))
-#endif
-
-#endif /* __txdouble_h__ */
--- a/content/xslt/src/base/txCore.h
+++ b/content/xslt/src/base/txCore.h
@@ -34,21 +34,21 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef __txCore_h__
 #define __txCore_h__
 
+#include "nsContentUtils.h"
 #include "nscore.h"
 #include "nsDebug.h"
 #include "nsTraceRefcnt.h"
 #include "prtypes.h"
-#include "txDouble.h"
 
 class nsAString;
 
 class txObject
 {
 public:
     txObject()
     {
@@ -68,19 +68,19 @@ public:
  * Utility class for doubles
  */
 class txDouble
 {
 public:
     /**
      * Useful constants
      */
-    static const txdpun NaN;
-    static const txdpun POSITIVE_INFINITY;
-    static const txdpun NEGATIVE_INFINITY;
+    static const dpun NaN;
+    static const dpun POSITIVE_INFINITY;
+    static const dpun NEGATIVE_INFINITY;
 
     /**
      * Determines whether the given double represents positive or negative
      * inifinity.
      */
     static PRBool isInfinite(double aDbl);
 
     /**
--- a/content/xslt/src/base/txDouble.cpp
+++ b/content/xslt/src/base/txDouble.cpp
@@ -45,49 +45,49 @@
 #endif
 #include "prdtoa.h"
 
 /*
  * Utility class for doubles
  */
 
 //-- Initialize Double related constants
-const txdpun Double::NaN = TX_DOUBLE_NaN;
+const dpun Double::NaN = DOUBLE_NaN;
 #ifdef IS_BIG_ENDIAN
-const txdpun Double::POSITIVE_INFINITY = {{TX_DOUBLE_HI32_EXPMASK, 0}};
-const txdpun Double::NEGATIVE_INFINITY = {{TX_DOUBLE_HI32_EXPMASK | TX_DOUBLE_HI32_SIGNBIT, 0}};
+const dpun Double::POSITIVE_INFINITY = {{DOUBLE_HI32_EXPMASK, 0}};
+const txdpun Double::NEGATIVE_INFINITY = {{DOUBLE_HI32_EXPMASK | DOUBLE_HI32_SIGNBIT, 0}};
 #else
-const txdpun Double::POSITIVE_INFINITY = {{0, TX_DOUBLE_HI32_EXPMASK}};
-const txdpun Double::NEGATIVE_INFINITY = {{0, TX_DOUBLE_HI32_EXPMASK | TX_DOUBLE_HI32_SIGNBIT}};
+const dpun Double::POSITIVE_INFINITY = {{0, DOUBLE_HI32_EXPMASK}};
+const dpun Double::NEGATIVE_INFINITY = {{0, DOUBLE_HI32_EXPMASK | DOUBLE_HI32_SIGNBIT}};
 #endif
 
 /*
  * Determines whether the given double represents positive or negative
  * inifinity
  */
 MBool Double::isInfinite(double aDbl)
 {
-    return ((TX_DOUBLE_HI32(aDbl) & ~TX_DOUBLE_HI32_SIGNBIT) == TX_DOUBLE_HI32_EXPMASK &&
-            !TX_DOUBLE_LO32(aDbl));
+    return ((DOUBLE_HI32(aDbl) & ~DOUBLE_HI32_SIGNBIT) == DOUBLE_HI32_EXPMASK &&
+            !DOUBLE_LO32(aDbl));
 }
 
 /*
  * Determines whether the given double is NaN
  */
 MBool Double::isNaN(double aDbl)
 {
-    return TX_DOUBLE_IS_NaN(aDbl);
+    return DOUBLE_IS_NaN(aDbl);
 }
 
 /*
  * Determines whether the given double is negative
  */
 MBool Double::isNeg(double aDbl)
 {
-    return (TX_DOUBLE_HI32(aDbl) & TX_DOUBLE_HI32_SIGNBIT) != 0;
+    return (DOUBLE_HI32(aDbl) & DOUBLE_HI32_SIGNBIT) != 0;
 }
 
 /*
  * Converts the given String to a double, if the String value does not
  * represent a double, NaN will be returned
  */
 class txStringToDouble
 {
--- a/content/xslt/src/xpath/txRelationalExpr.cpp
+++ b/content/xslt/src/xpath/txRelationalExpr.cpp
@@ -31,18 +31,18 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
+#include "nsContentUtils.h"
 #include "txExpr.h"
-#include "txDouble.h"
 #include "txNodeSet.h"
 #include "txIXPathContext.h"
 #include "txXPathTreeWalker.h"
 
 /**
  *  Compares the two ExprResults based on XPath 1.0 Recommendation (section 3.4)
  */
 PRBool
@@ -114,17 +114,17 @@ RelationalExpr::compareResults(txIEvalCo
             result = aLeft->booleanValue() == aRight->booleanValue();
         }
 
         // If either is a number, compare as numbers.
         else if (ltype == txAExprResult::NUMBER ||
                  rtype == txAExprResult::NUMBER) {
             double lval = aLeft->numberValue();
             double rval = aRight->numberValue();
-            result = TX_DOUBLE_COMPARE(lval, ==, rval);
+            result = DOUBLE_COMPARE(lval, ==, rval);
         }
 
         // Otherwise compare as strings. Try to use the stringobject in
         // StringResult if possible since that is a common case.
         else if ((lString = aLeft->stringValuePointer())) {
             if ((rString = aRight->stringValuePointer())) {
                 result = lString->Equals(*rString);
             }
@@ -149,29 +149,29 @@ RelationalExpr::compareResults(txIEvalCo
         return mOp == EQUAL ? result : !result;
     }
 
     double leftDbl = aLeft->numberValue();
     double rightDbl = aRight->numberValue();
     switch (mOp) {
         case LESS_THAN:
         {
-            return TX_DOUBLE_COMPARE(leftDbl, <, rightDbl);
+            return DOUBLE_COMPARE(leftDbl, <, rightDbl);
         }
         case LESS_OR_EQUAL:
         {
-            return TX_DOUBLE_COMPARE(leftDbl, <=, rightDbl);
+            return DOUBLE_COMPARE(leftDbl, <=, rightDbl);
         }
         case GREATER_THAN:
         {
-            return TX_DOUBLE_COMPARE(leftDbl, >, rightDbl);
+            return DOUBLE_COMPARE(leftDbl, >, rightDbl);
         }
         case GREATER_OR_EQUAL:
         {
-            return TX_DOUBLE_COMPARE(leftDbl, >=, rightDbl);
+            return DOUBLE_COMPARE(leftDbl, >=, rightDbl);
         }
         default:
         {
             NS_NOTREACHED("We should have caught all cases");
         }
     }
 
     return PR_FALSE;