Return to mamesf.h CVS log

Up to [Previous NeXT emulator] / previous_trunk / src / softfloat

Annotation of previous_trunk/src/softfloat/mamesf.h, revision 1.1.1.1

1.1       root        1: #ifndef MAMESF_H
                      2: #define MAMESF_H
                      3: 
                      4: /*----------------------------------------------------------------------------
                      5: | One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined.
                      6: *----------------------------------------------------------------------------*/
                      7: #ifdef LSB_FIRST
                      8: #define LITTLEENDIAN
                      9: #else
                     10: #define BIGENDIAN
                     11: #endif
                     12: 
                     13: /*----------------------------------------------------------------------------
                     14: | The macro `BITS64' can be defined to indicate that 64-bit integer types are
                     15: | supported by the compiler.
                     16: *----------------------------------------------------------------------------*/
                     17: #define BITS64
                     18: 
                     19: /*----------------------------------------------------------------------------
                     20: | Each of the following `typedef's defines the most convenient type that holds
                     21: | integers of at least as many bits as specified.  For example, `uint8' should
                     22: | be the most convenient type that can hold unsigned integers of as many as
                     23: | 8 bits.  The `flag' type must be able to hold either a 0 or 1.  For most
                     24: | implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed
                     25: | to the same as `int'.
                     26: *----------------------------------------------------------------------------*/
                     27: //#include "assert.h"
                     28: //#include "sysdeps.h"
                     29: #include "inttypes.h"
                     30: 
                     31: typedef int8_t flag;
                     32: typedef uint8_t uint8;
                     33: typedef int8_t int8;
                     34: typedef uint16_t uint16;
                     35: typedef int16_t int16;
                     36: typedef uint32_t uint32;
                     37: typedef int32_t int32;
                     38: typedef uint64_t uint64;
                     39: typedef int64_t int64;
                     40: 
                     41: /*----------------------------------------------------------------------------
                     42: | Each of the following `typedef's defines a type that holds integers
                     43: | of _exactly_ the number of bits specified.  For instance, for most
                     44: | implementation of C, `bits16' and `sbits16' should be `typedef'ed to
                     45: | `unsigned short int' and `signed short int' (or `short int'), respectively.
                     46: *----------------------------------------------------------------------------*/
                     47: typedef uint8_t bits8;
                     48: typedef int8_t sbits8;
                     49: typedef uint16_t bits16;
                     50: typedef int16_t sbits16;
                     51: typedef uint32_t bits32;
                     52: typedef int32_t sbits32;
                     53: typedef uint64_t bits64;
                     54: typedef int64_t sbits64;
                     55: 
                     56: /*----------------------------------------------------------------------------
                     57: | The `LIT64' macro takes as its argument a textual integer literal and
                     58: | if necessary ``marks'' the literal as having a 64-bit integer type.
                     59: | For example, the GNU C Compiler (`gcc') requires that 64-bit literals be
                     60: | appended with the letters `LL' standing for `long long', which is `gcc's
                     61: | name for the 64-bit integer type.  Some compilers may allow `LIT64' to be
                     62: | defined as the identity macro:  `#define LIT64( a ) a'.
                     63: *----------------------------------------------------------------------------*/
                     64: #define LIT64( a ) a##ULL
                     65: 
                     66: /*----------------------------------------------------------------------------
                     67: | The macro `INLINE' can be used before functions that should be inlined.  If
                     68: | a compiler does not support explicit inlining, this macro should be defined
                     69: | to be `static'.
                     70: *----------------------------------------------------------------------------*/
                     71: #define INLINE static inline
                     72: 
                     73: /*----------------------------------------------------------------------------
                     74:  | The macro `SOFTFLOAT_68K' can be defined to enable changes specific to
                     75:  | 6888x floating point coprocessor emulation.
                     76:  *----------------------------------------------------------------------------*/
                     77: #define SOFTFLOAT_68K
                     78: 
                     79: /*----------------------------------------------------------------------------
                     80:  | The macro `SOFTFLOAT_I860' can be defined to enable changes specific to
                     81:  | i860 floating point emulation.
                     82:  *----------------------------------------------------------------------------*/
                     83: #define SOFTFLOAT_I860
                     84: 
                     85: 
                     86: #endif //MAMESF_H

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.