Changeset 1598 for trunk/source/cddefines.h

Timestamp:

12/01/07 10:29:50 (12 months ago)

Author:

peter

Message:

source/cddefines.h:

• Fix indentation, several cosmetic changes. No change in functionality.
  

source/helike_cs.cpp:

• Fix compiler warnings about missing newline and prototype without corresponding routine.
  

source/lines_service.h:
source/lines_service.cpp:

• Fix compiler warning about deprecated conversion const char* -> char*.
  

source/hydrocollid.cpp:

• Fix compiler warnings about unused variable and prototype without corresponding routine.
  

Files:

• trunk/source/cddefines.h (modified) (8 diffs)

trunk/source/cddefines.h

@@ -837 +837 @@
         static const int _nd = lgBC ? 3 : 1;
         T* p[_nd]; // p[0] current pointer, p[1] lower bound, p[2] upper bound
-        void bounds_check(const T* t) const
-        {
-#ifdef _MSC_VER
-                /* disable warning that conditional expression is constant, true or false in if */
-#       pragma warning( disable : 4127 )
-#endif
-                if (lgBC) 
+        void _bounds_check( const T* t ) const
+        {
+#ifdef _MSC_VER
+                /* disable warning that conditional expression is constant, true or false in if */
+#               pragma warning( disable : 4127 )
+#endif
+                if( lgBC ) 
                 {
                         if( t < p[1] || t >= p[2] )
@@ -850 +850 @@
                                 fprintf( ioQQQ, " ptr = %#lx, valid region: %#lx <= ptr < %#lx\n",
 #ifdef _MSC_VER
-                                                                 (size_t)t, (size_t)p[1], (size_t)p[2] );
+                                        (size_t)t, (size_t)p[1], (size_t)p[2] );
 #else
-                                          (unsigned long)t, (unsigned long)p[1], (unsigned long)p[2] );
-#endif
-                        TotalInsanity();
-                  }
-                }
-        }
-  T* index_checked ( const ptrdiff_t n) const
-  {
-          T* t;
-    t = p[0]+n;
-    bounds_check(t);
-    return t;
-  }
-        void set_vals(T* p0, T* p1, T* p2)
-        {
-#ifdef _MSC_VER
-                /* disable warning that conditional expression is constant, true or false in if */
-#       pragma warning( disable : 4127 )
+                                        (unsigned long)t, (unsigned long)p[1], (unsigned long)p[2] );
+#endif
+                                TotalInsanity();
+                        }
+                }
+        }
+        T* _index_checked ( const ptrdiff_t n ) const
+        {
+                T* t = p[0]+n;
+                _bounds_check(t);
+                return t;
+        }
+        void _set_vals( T* p0, T* p1, T* p2 )
+        {
+#ifdef _MSC_VER
+                /* disable warning that conditional expression is constant, true or false in if */
+#               pragma warning( disable : 4127 )
 #endif
                 if( lgBC )
@@ -882 +881 @@
         basic_pntr( T* p0, T* p1, T* p2 )
         {
-                set_vals(p0,p1,p2);
+                _set_vals( p0, p1, p2 );
         }
         basic_pntr( T* p0 )
         {
-                set_vals(p0,NULL,NULL);
+                _set_vals( p0, NULL, NULL );
         }
 public:
         basic_pntr()
         {
-                set_vals(NULL,NULL,NULL);
+                _set_vals( NULL, NULL, NULL );
         }
         basic_pntr( const basic_pntr& t )
@@ -897 +896 @@
                 *this = t;
         }
-  // virtual destructor (in case of destruction via basic_pntr*, see Sutter EC++ p77)
-  virtual ~basic_pntr() {};
+        // virtual destructor (in case of destruction via basic_pntr*, see Sutter EC++ p77)
+        virtual ~basic_pntr() {};
         // pre-increment
-  basic_pntr& operator++ ()
+        basic_pntr& operator++ ()
         {
                 ++p[0];
                 return *this;
         }
-  // post-increment
-  const basic_pntr operator++ (int)
-        {
-                basic_pntr t (*this);
-                ++*this;
+        // post-increment
+        const basic_pntr operator++ (int)
+        {
+                basic_pntr t( *this );
+                ++(*this);
                 return t;
         }
@@ -919 +918 @@
         }
         // post-decrement
-  const basic_pntr operator-- (int)
-        {
-                basic_pntr t (*this);
-                --*this;
+        const basic_pntr operator-- (int)
+        {
+                basic_pntr t( *this );
+                --(*this);
                 return t;
         }
@@ -929 +928 @@
         // conversion from basic_pntr -> pntr or const_pntr to work; this would also create
         // an implicit and silent conversion from const_pntr -> pntr, which is illegal...
-  basic_pntr& operator+= ( const ptrdiff_t n ) { p[0] += n; return *this; }
+        basic_pntr& operator+= ( const ptrdiff_t n ) { p[0] += n; return *this; }
         basic_pntr& operator-= ( const ptrdiff_t n ) { p[0] -= n; return *this; }
         // dereference
         T& operator* () const
         {
-                return *(index_checked(0));
+                return *(_index_checked(0));
         }
         T* operator-> () const
         {
-                return index_checked(0);
+                return _index_checked(0);
         }
         T& operator[] ( const ptrdiff_t n ) const
         {
-                return *(index_checked(n));
+                return *(_index_checked(n));
         }
         // finally, define the boolean operators...
@@ -969 +968 @@
         const pntr operator+ ( const ptrdiff_t n ) const { pntr s = *this; s += n; return s; }
         const pntr operator- ( const ptrdiff_t n ) const { pntr s = *this; s -= n; return s; }
-        /* const */ ptrdiff_t operator- ( const pntr& t ) const { return &(*this[0]) - &t[0]; }
+        ptrdiff_t operator- ( const pntr& t ) const { return &(*this[0]) - &t[0]; }
 };
 
@@ -1020 +1019 @@
         const const_pntr operator+ ( const ptrdiff_t n ) const { const_pntr s = *this; s += n; return s; }
         const const_pntr operator- ( const ptrdiff_t n ) const { const_pntr s = *this; s -= n; return s; }
-        /* const */ ptrdiff_t operator- ( const const_pntr& t ) const { return &(*this[0]) - &t[0]; }
+        ptrdiff_t operator- ( const const_pntr& t ) const { return &(*this[0]) - &t[0]; }
 };