memory.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2006 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <inttypes.h>

#include <archon/util/memory.H>


namespace Archon
{
  namespace Utilities
  {
    vector<bool> detectNativeEndianness()
    {
      uintmax_t v = 1;
      char *p = reinterpret_cast<char *>(&v);
      // The bit pattern of the index of the non-zero byte describes the
      // native endianness in exactly the way described above.
      int i;
      for(i=0; i<static_cast<int>(sizeof(v)); ++i) if(p[i]) break;

      vector<bool> r;
      // Determine the number of bits in the endianness descriptor
      int n = 0;
      int w = sizeof(v) >> 1;
      while(w)
      {
        r.push_back(i&w);
        w >>= 1;
        ++n;
      }
      reverse(r.begin(), r.end());
      return r;
    }


    bool compareEndianness(const vector<bool> &a, const vector<bool> &b,
                           int levels)
    {
      vector<bool> c;
      if(b.empty())
      {
        if(a.empty()) return true;
        c = detectNativeEndianness();
      }
      else c = b;

      if(!levels) levels = max(a.size(), c.size());

      for(int i=0; i<levels; ++i)
        if(a[i < static_cast<int>(a.size()) ? i : a.size()-1] !=
           c[i < static_cast<int>(c.size()) ? i : c.size()-1]) return false;

      return true;
    }


    vector<int> computeBytePermutation(const vector<bool> &endianness,
                                       int levels)
    {
      vector<bool> native = detectNativeEndianness();

      // Construct identity map
      int n = 1<<levels;
      vector<int> permutation(n);
      for(int i=0; i<n; ++i) permutation[i] = i;
      
      // For each level
      for(int i=0; i<levels; ++i)
      {
        // Swap only if we hav endianness disagreement on this level
        if(native[i < static_cast<int>(native.size()) ? i : native.size()-1] ==
           endianness[i < static_cast<int>(endianness.size()) ? i :
                      endianness.size()-1]) continue;

        int swapBlockSize = 1 << i+1;
        int numberOfSwapBlocks = n / swapBlockSize;
        int numberOfSwapsPerBlock = swapBlockSize / 2;

        // For each block that needs to be swapped
        for(int j=0; j<numberOfSwapBlocks; ++j)
        {
          // For each swap
          for(int k=0; k<numberOfSwapsPerBlock; ++k)
          {
            int offset = j * swapBlockSize + k;
            swap(permutation[offset],
                 permutation[offset+numberOfSwapsPerBlock]);
          }
        }
      }

      return permutation;
    }
  }
}

---