Subversion Repositories tendra.SVN

/*

 * Copyright (c) 2002-2005 The TenDRA Project <http://www.tendra.org/>.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 * 3. Neither the name of The TenDRA Project nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific, prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS

 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * $Id$

 */

/*

    		 Crown Copyright (c) 1997

    This TenDRA(r) Computer Program is subject to Copyright

    owned by the United Kingdom Secretary of State for Defence

    acting through the Defence Evaluation and Research Agency

    (DERA).  It is made available to Recipients with a

    royalty-free licence for its use, reproduction, transfer

    to other parties and amendment for any purpose not excluding

    product development provided that any such use et cetera

    shall be deemed to be acceptance of the following conditions:-

        (1) Its Recipients shall ensure that this Notice is

        reproduced upon any copies or amended versions of it;

        (2) Any amended version of it shall be clearly marked to

        show both the nature of and the organisation responsible

        for the relevant amendment or amendments;

        (3) Its onward transfer from a recipient to another

        party shall be deemed to be that party's acceptance of

        these conditions;

        (4) DERA gives no warranty or assurance as to its

        quality or suitability for any purpose and DERA accepts

        no liability whatsoever in relation to any use to which

        it may be put.

*/

/* 	cross.h,v 1.3 1995/05/23 10:54:50 john Exp	 */

/*

  cross.h

  This file contains a set of macros & function declarations

  to process the 64 bit integer type INT64.  If compiling on a

  platform with 64 bit longs, INT64 can be represented as a

  long and the operations can be implemented by macros expanding

  to the simple arithmetic operations.  If, however, a 64 bit

  integral type is not available, then INT64 is represented

  by the flt64 type (see flpttypes.h) and the operations are

  represented by a set of functions, defined in cross.c

*/

/*

  cross.h,v

 * Revision 1.3  1995/05/23  10:54:50  john

 * Minor fixes to 64 bit support

 *

 * Revision 1.2  1995/05/16  10:46:21  john

 * Cosmetic change

 *

 * Revision 1.1.1.1  1995/03/23  10:39:05  john

 * Entered into CVS

 *

 * Revision 1.11  1995/03/23  10:03:18  john

 * Corrected some definitions

 *

 * Revision 1.10  1995/01/26  13:32:13  john

 * Corrected a few macro definitions

 *

*/

#ifndef CROSS_H

#define CROSS_H

#include <limits.h>

/*typedef char bool;*/

#include "output.h"

#include "flpttypes.h"

#include "exptypes.h"

#include "common_types.h"

extern flt64 exp_to_f64(exp);

typedef int INT32;

typedef unsigned int UINT32;

#define int8 char

#define int16 short

#define int32 int

#define is64(X)	((name(X) ==u64hd) || (name(X) ==s64hd) || (name(X) ==ptrhd))

#define is32(X)((name(X) ==slonghd) || (name(X) ==ulonghd))

/* some macros to access the fields of the flt64/INT64 type */

#if FS_64_BIT /* 64 bit ints can be represented as longs */

typedef long INT64;

#define clear_INT64(x)	((x) =0)

#define low_INT64(x)	(x)

#define isquad(x)	((unsigned long)(x) >UINT_MAX)

#define INT64_assign(x,y)((x) = (y))

#define out_INT64(x)(void)outlong((x))

#define INT64_mult(x,y,z)((z)?((x)*(y)):((unsigned long)((x)*(y))))

#if 0

#define INT64_divide(x,y,z)((z)?((x) / (y)):(unsigned long)((x) / (y)))

#else

#define INT64_divide(x,y,z)((x) / (y))

#endif

#define INT64_mod(x,y,z)((x)%(y))

#define INT64_add(x,y,z)((z)?((x) + (y)):(unsigned long)((x) + (y)))

#if 0

#define INT64_subtract(x,y,z)((z)?((x) - (y)):(unsigned long)((x) - (y)))

#else

#define INT64_subtract(x,y,z)((x) - (y))

#endif

#define INT64_increment(x)((x) +1)

#define INT64_decrement(x)((x) -1)

#define INT64_or(x,y)((x) | (y))

#define INT64_and(x,y)((x) & (y))

#define INT64_not(x)(~(x))

#define INT64_xor(x,y)((x)^(y))

#define INT64_shift_left(x,y,z)((x) << (y))

#define INT64_shift_right(x,y,z)((x) >> (y))

#define INT64_eq(x,y)((x) == (y))

#define INT64_leq(x,y)((x) <= (y))

#define INT64_lt(x,y)((x) < (y))

#define INT64_abs(x)(((x) >0)?(x):- (x))

#define make_INT64(big,small)	((small) + (((long)(big)) <<32))

#define umax 0xffffffffffffffffUL

#define smin 0x8000000000000000L

#define zero_int64 0L

#else	/* no 64 bit integral type available, use a struct of 2 32s */

typedef flt64 INT64;

#define clear_INT64(x)	{(x).big=0;(x).small=0;}

#define low_INT64(x)	(x).small

#define high_INT64(x)	(x).big

#define isquad(x)	((x).big!=0)

#define flt64_to_INT64(x) (x)		/* the types are identical */

#define INT64_assign(x,y)((x) = (y))

void out_INT64(INT64);

INT64 INT64_mult(INT64,INT64,bool);

INT64 INT64_divide(INT64,INT64,bool);

INT64 INT64_add(INT64,INT64,bool);

INT64 INT64_subtract(INT64,INT64,bool);

INT64 INT64_mod(INT64,INT64,bool);

INT64 INT64_increment(INT64);

INT64 INT64_decrement(INT64);

INT64 INT64_or(INT64,INT64);

INT64 INT64_and(INT64,INT64);

INT64 INT64_not(INT64);

INT64 INT64_xor(INT64,INT64);

INT64 INT64_shift_left(INT64,int,int);

INT64 INT64_shift_right(INT64,int,int);

bool INT64_eq(INT64,INT64);

bool INT64_leq(INT64,INT64);

bool INT64_lt(INT64,INT64);

INT64 make_INT64(INT32,UINT32);

#define umax {0xffffffff,0xffffffff}

#define smin {0x80000000,0x00000000}

#define zero_int64 make_INT64(0,0)

/*#define zero_int64 {0,0}*/

#endif 	/* #if alpha */

INT64  flt64_to_INT64(flt64);

INT64  exp_to_INT64(exp);

#endif	/* #ifndef CROSS_H */