Changeset 254

Timestamp:

Nov 28, 2002, 4:51:54 PM (18 years ago)

Author:

pooh

Message:

• Code cleanup and comments.
• Inline definitions moved to .ih file.

Location:

to-imperative/trunk/libp++

Files:

• pxx_common.cc (modified) (5 diffs)
• pxx_common.hh (modified) (5 diffs)
• pxx_common.ih (added)

to-imperative/trunk/libp++/pxx_common.cc

@@ -1 +1 @@
 //
-// Copyright (C) 2000, 2001 Andrey Slepuhin <pooh@msu.ru>
+// Copyright (C) 2000, 2001, 2002 Andrey Slepuhin <pooh@msu.ru>
 //
 // libp++ is free software; you can redistribute it and/or modify
@@ -21 +21 @@
 // Author: Andrey Slepuhin <pooh@msu.ru>
 
-#include "pxx_common.hh"
+#include "pxx_common.ih"
 
-#include <cstdarg>
+#include <stdarg.h>
 #include <unistd.h>
 
 namespace pxx
 {
+
+unsigned debug_level = 0 ;
 
 void (*terminate) (int _error_code) = null ;
@@ -42 +44 @@
 }
 
+void dprint (unsigned _level, char* _fmt, ...) {
+  if ((debug_level & _level) != 0) {
+    va_list ap;
+    va_start(ap, _fmt);
+    vfprintf(stderr, _fmt, ap);
+    va_end(ap);
+  }
+}
+
 size_t page_size ;
 size_t orders[256] ;
-size_t rounds[sizeof(size_t) * 8] ;
+size_t exps_of_two[sizeof(size_t) * 8] ;
 
+//
+// Internal class used to initialize necessary data
 class Init
 {
@@ -59 +72 @@
       unsigned s = i;
       orders[i] = 0;
-//      if (s != 0) s--;
       while (s) {
         s >>= 1;
@@ -66 +78 @@
       orders[i]--;
     }
-    for (i = 0; i < sizeof(rounds) / sizeof(rounds[0]); i++) {
-      rounds[i] = 1 << i;
+    for (i = 0; i < sizeof(exps_of_two) / sizeof(exps_of_two[0]); i++) {
+      exps_of_two[i] = 1 << i;
     }
   }

to-imperative/trunk/libp++/pxx_common.hh

@@ -24 +24 @@
 #define __pxx_common_hh__
 
+//
+// This is needed to allow the use of macros for integer constant
+//  initialization.
+#define __STDC_CONSTANT_MACROS
 #include <inttypes.h>
+
 #include <stdio.h>
 #include <stdlib.h>
@@ -31 +36 @@
 namespace pxx
 {
-
-#define __STDC_CONSTANT_MACROS
 
 #ifndef DEBUG
@@ -42 +45 @@
 #endif
 
+//
+// Define macros for uintptr_t type.
 #if UINTPTR_MAX == UINT32_MAX
 #define UINTPTR_C(x) UINT32_C(x)
@@ -50 +55 @@
 #endif
 
+//
+// Useful macros.
 #define null (0)
-
 #define self (*this)
-
-typedef void* Ptr ;
-
 #define zref(_type) (*((_type*)(0)))
 
+//
+// A macro to use in a case of fatal errors. Prints a message and source file
+// information (function name, file name and line number).
 #define FATAL \
   fprintf( \
@@ -72 +78 @@
   }
 
+extern unsigned debug_level ;
+
+//
+// A function to be called when fatal error occured. By default exit is called.
 extern void (*terminate) (int _error_code) ;
+//
+// A function to print fatal error messages.
 extern void fatal (char* _fmt, ...) ;
+//
+// A function to print debug messages.
+extern void dprint (unsigned _level, char* _fmt, ...) ;
+//
+// A memory page size. Should be initialized at runtime due to architectures
+// with a variable page size.
+extern size_t page_size ;
+//
+// An array containing ceilings of binary logarythms of small integers.
+extern size_t orders[256] ;
+//
+// An array containing exponents of 2.
+extern size_t exps_of_two[sizeof(size_t) * 8] ;
 
-extern size_t page_size ;
-extern size_t orders [256] ;
-extern size_t rounds [sizeof(size_t) * 8] ;
+//
+// This function returns a ceiling of a binary logarythm of its argument.
+inline size_t get_order (size_t _size) ;
+//
+// This function checks whether a pointer is properly aligned. The second
+// argument should be an exponent of 2.
+inline bool ptr_is_aligned (void const* _ptr, uintptr_t _align) ;
+//
+// This function aligns a pointer, rounding it to a smaller value.
+inline void* ptr_align (void const* _ptr, uintptr_t _align) ;
+//
+// This function aligns an integer size, rounding it to a smaller value.
+inline size_t size_align (size_t _size, size_t _align) ;
+//
+// These functions implement bit operations on pointer values.
+inline void* ptr_and (void const* _p1, void const* _p2) ;
+inline void* ptr_or (void const* _p1, void const* _p2) ;
+inline void* ptr_xor (void const* _p1, void const* _p2) ;
+//
+// This function finds the least significant bit by which two pointers differ
+// and returns an integer where this bit is set.
+inline uintptr_t ptr_diff (void const* _p1, void const* _p2) ;
+//
+// Pointer arithmetic.
+template <typename type_t>
+  inline type_t* ptr_add_offset (type_t* _ptr, ssize_t _value) ;
+template <typename type_t>
+  inline type_t* ptr_sub_offset (type_t* _ptr, ssize_t _value) ;
+template <typename type1_t, typename type2_t>
+  inline ssize_t ptr_sub (type1_t* _ptr1, type2_t* _ptr2) ;
 
-static inline
-size_t get_order (size_t _size)
-{
-  if (_size > 0) _size--;
-#if 1
-  size_t b;
-  int n = -8;
-  do {
-    b = _size & size_t(0xFF);
-    _size >>= 8;
-    n += 8;
-  } while (_size != 0);
-  return orders [b] + n + 1;
-#else
-  size_t n = 0;
-  if (_size & 0xFFFF0000) { _size &= 0xFFFF0000; n += 16; }
-  if (_size & 0xFF00FF00) { _size &= 0xFF00FF00; n += 8; }
-  if (_size & 0xF0F0F0F0) { _size &= 0xF0F0F0F0; n += 4; }
-  if (_size & 0xCCCCCCCC) { _size &= 0xCCCCCCCC; n += 2; }
-  if (_size & 0xAAAAAAAA) n += 1;
-  return n + 1;
-#endif
-}
-
-static inline
-bool aligned (void* _ptr, uintptr_t _align)
-{
-  return ((_align - 1) & uintptr_t(_ptr)) == 0;
-}
-
-static inline
-void* ptr_align (void* _ptr, uintptr_t _align)
-{
-  return (void*)(((uintptr_t)_ptr) & (~(_align - 1)));
-}
-
-static inline
-size_t size_align (size_t _size, size_t _align)
-{
-  _align--;
-  return (_size + _align) & (~(_align));
-}
-
-inline void* ptr_and (void* _p1, void* _p2)
-{
-  return (void*)((uintptr_t)_p1 & (uintptr_t)_p2);
-}
-
-inline void* ptr_or (void* _p1, void* _p2)
-{
-  return (void*)((uintptr_t)_p1 | (uintptr_t)_p2);
-}
-
-inline void* ptr_xor (void* _p1, void* _p2)
-{
-  return (void*)((uintptr_t)_p1 ^ (uintptr_t)_p2);
-}
-
-inline void* ptr_diff (void* _p1, void* _p2)
-{
-  uintptr_t diff = (uintptr_t)_p1 ^ (uintptr_t)_p2;
-  return (void*)(((diff ^ (diff - 1)) >> 1) + 1);
-}
-
-template <typename typeT>
-inline typeT* ptr_add (typeT* _ptr, size_t _value)
-{
-  return (typeT*)((char*)_ptr + _value);
-}
-
-template <typename typeT>
-inline typeT* ptr_sub (typeT* _ptr, size_t _value)
-{
-  return (typeT*)((char*)_ptr - _value);
-}
-
-template <typename typeT1, typename typeT2>
-inline ssize_t sub_ptr (typeT1* _ptr1, typeT2* _ptr2)
-{
-  return ((char*)_ptr1 - (char*)_ptr2);
-}
-
+//
+// We provide our own maximum and minimum macros to avoid naming conflicts
 #define pxx_max(a,b) ((a) > (b) ? (a) : (b))
+#define pxx_min(a,b) ((a) < (b) ? (a) : (b))
 
 }