/* lzo_ptr.h -- low-level pointer constructs

   This file is part of the LZO real-time data compression library.

   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer

   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer

   All Rights Reserved.

   The LZO library is free software; you can redistribute it and/or

   modify it under the terms of the GNU General Public License as

   published by the Free Software Foundation; either version 2 of

   the License, or (at your option) any later version.

   The LZO library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with the LZO library; see the file COPYING.

   If not, write to the Free Software Foundation, Inc.,

   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

   Markus F.X.J. Oberhumer

   <markus@oberhumer.com></markus@oberhumer.com>

   http://www.oberhumer.com/opensource/lzo/

 */

/* WARNING: this file should *not* be used by applications. It is

   part of the implementation of the library and is subject

   to change.

 */

#ifndef __LZO_PTR_H

#define __LZO_PTR_H

#ifdef __cplusplus

extern "C" {

#endif

/***********************************************************************

// Integral types

************************************************************************/

#if !defined(lzo_uintptr_t)

#  if defined(__LZO_MMODEL_HUGE)

#    define lzo_uintptr_t   unsigned long

#  else

#    define lzo_uintptr_t   acc_uintptr_t

#    ifdef __ACC_INTPTR_T_IS_POINTER

#      define __LZO_UINTPTR_T_IS_POINTER 1

#    endif

#  endif

#endif

/***********************************************************************

//

************************************************************************/

/* Always use the safe (=integral) version for pointer-comparisions.

 * The compiler should optimize away the additional casts anyway.

 *

 * Note that this only works if the representation and ordering

 * of the pointer and the integral is the same (at bit level).

 *

 * Most 16-bit compilers have their own view about pointers -

 * fortunately they don't care about comparing pointers

 * that are pointing to Nirvana.

 */

#if (LZO_ARCH_I086)

#define PTR(a)              ((lzo_bytep) (a))

/* only need the low bits of the pointer -> offset is ok */

#define PTR_ALIGNED_4(a)    ((ACC_PTR_FP_OFF(a) & 3) == 0)

#define PTR_ALIGNED2_4(a,b) (((ACC_PTR_FP_OFF(a) | ACC_PTR_FP_OFF(b)) & 3) == 0)

#elif (LZO_MM_PVP)

#define PTR(a)              ((lzo_bytep) (a))

#define PTR_ALIGNED_8(a)    ((((lzo_uintptr_t)(a)) >> 61) == 0)

#define PTR_ALIGNED2_8(a,b) ((((lzo_uintptr_t)(a)|(lzo_uintptr_t)(b)) >> 61) == 0)

#else

#define PTR(a)              ((lzo_uintptr_t) (a))

#define PTR_LINEAR(a)       PTR(a)

#define PTR_ALIGNED_4(a)    ((PTR_LINEAR(a) & 3) == 0)

#define PTR_ALIGNED_8(a)    ((PTR_LINEAR(a) & 7) == 0)

#define PTR_ALIGNED2_4(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0)

#define PTR_ALIGNED2_8(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0)

#endif

#define PTR_LT(a,b)         (PTR(a) < PTR(b))

#define PTR_GE(a,b)         (PTR(a) >= PTR(b))

#define PTR_DIFF(a,b)       (PTR(a) - PTR(b))

#define pd(a,b)             ((lzo_uint) ((a)-(b)))

LZO_EXTERN(lzo_uintptr_t)

__lzo_ptr_linear(const lzo_voidp ptr);

typedef union

{

    char            a_char;

    unsigned char   a_uchar;

    short           a_short;

    unsigned short  a_ushort;

    int             a_int;

    unsigned int    a_uint;

    long            a_long;

    unsigned long   a_ulong;

    lzo_int         a_lzo_int;

    lzo_uint        a_lzo_uint;

    lzo_int32       a_lzo_int32;

    lzo_uint32      a_lzo_uint32;

    ptrdiff_t       a_ptrdiff_t;

    lzo_uintptr_t   a_lzo_uintptr_t;

    lzo_voidp       a_lzo_voidp;

    void *          a_void_p;

    lzo_bytep       a_lzo_bytep;

    lzo_bytepp      a_lzo_bytepp;

    lzo_uintp       a_lzo_uintp;

    lzo_uint *      a_lzo_uint_p;

    lzo_uint32p     a_lzo_uint32p;

    lzo_uint32 *    a_lzo_uint32_p;

    unsigned char * a_uchar_p;

    char *          a_char_p;

}

lzo_full_align_t;

#ifdef __cplusplus

} /* extern "C" */

#endif

#endif /* already included */

/*

vi:ts=4:et

*/