vita-toolchain

git clone https://git.neptards.moe/neptards/vita-toolchain.git
Log | Files | Refs | README | LICENSE

types.h (2567B)

      1 /*
      2  * PSP Software Development Kit - http://www.pspdev.org
      3  * -----------------------------------------------------------------------
      4  * Licensed under the BSD license, see LICENSE in PSPSDK root for details.
      5  *
      6  * types.h - Definition of basic cross platform types.
      7  *
      8  * Copyright (c) 2005 James Forshaw <tyranid@gmail.com>
      9  *
     10  * $Id: types.h 2333 2007-10-31 19:37:40Z tyranid $
     11  */
     12 
     13 #ifndef __TYPES_H__
     14 #define __TYPES_H__
     15 
     16 #include <stdint.h>
     17 
     18 /* Re-define some system types */
     19 typedef uint8_t 	u8;
     20 typedef uint16_t 	u16;
     21 typedef uint32_t	u32;
     22 typedef uint64_t	u64;
     23 typedef int8_t		s8;
     24 typedef int16_t		s16;
     25 typedef int32_t		s32;
     26 typedef int64_t		s64;
     27 
     28 #ifdef WORDS_BIGENDIAN
     29 inline u32 lw_le(u32 data)
     30 {
     31 	u8 *ptr;
     32 	u32 val;
     33 
     34 	ptr = (u8*) &data;
     35 
     36 	val = ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24);
     37 
     38 	return val;
     39 }
     40 
     41 inline u16 lh_le(u16 data)
     42 {
     43 	u8 *ptr;
     44 	u16 val;
     45 
     46 	ptr = (u8*) &data;
     47 
     48 	val = ptr[0] | (ptr[1] << 8);
     49 
     50 	return val;
     51 }
     52 
     53 #define LW_LE(x) (lw_le((x)))
     54 #define LW_BE(x) (x)
     55 #define LH_LE(x) (lh_le((x)))
     56 #define LH_BE(x) (x)
     57 
     58 #else
     59 
     60 inline u32 lw_be(u32 data)
     61 {
     62 	u8 *ptr;
     63 	u32 val;
     64 
     65 	ptr = (u8*) &data;
     66 
     67 	val = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
     68 
     69 	return val;
     70 }
     71 
     72 inline u16 lh_be(u16 data)
     73 {
     74 	u8 *ptr;
     75 	u16 val;
     76 
     77 	ptr = (u8*) &data;
     78 
     79 	val = (ptr[0] << 16) | ptr[1];
     80 
     81 	return val;
     82 }
     83 
     84 #define LW_LE(x) (x)
     85 #define LW_BE(x) (lw_be((x)))
     86 #define LH_LE(x) (x)
     87 #define LH_BE(x) (lh_be((x)))
     88 
     89 #endif
     90 
     91 #define LW(x) (LW_LE(x))
     92 #define LH(x) (LH_LE(x))
     93 
     94 
     95 #ifdef WORDS_BIGENDIAN
     96 inline void sw_le(u32 *data, u32 val)
     97 {
     98 	u8* ptr = (u8*) data;
     99 
    100 	ptr[0] = (u8) (val & 0xFF);
    101 	ptr[1] = (u8) ((val >> 8) & 0xFF);
    102 	ptr[2] = (u8) ((val >> 16) & 0xFF);
    103 	ptr[3] = (u8) ((val >> 24) & 0xFF);
    104 }
    105 
    106 inline void sh_le(u16 *data, u16 val)
    107 {
    108 	u8 *ptr = (u8*) data;
    109 
    110 	ptr[0] = (u8) (val & 0xFF);
    111 	ptr[1] = (u8) ((val >> 8) & 0xFF);
    112 }
    113 
    114 #define SW_LE(x, v) (sw_le((x), (v)))
    115 #define SW_BE(x, v) (*(x) = (v))
    116 #define SH_LE(x, v) (sh_le((x), (v)))
    117 #define SH_BE(x, v) (*(x) = (v))
    118 
    119 #else
    120 
    121 inline void sw_be(u32 *data, u32 val)
    122 {
    123 	u8 *ptr = (u8*) data;
    124 
    125 	ptr[0] = (u8) ((val >> 24) & 0xFF);
    126 	ptr[1] = (u8) ((val >> 16) & 0xFF);
    127 	ptr[2] = (u8) ((val >> 8) & 0xFF);
    128 	ptr[3] = (u8) (val & 0xFF);
    129 }
    130 
    131 inline void sh_be(u16 *data, u16 val)
    132 {
    133 	u8* ptr = (u8*) data;
    134 
    135 	ptr[0] = (u8) ((val >> 8) & 0xFF);
    136 	ptr[1] = (u8) (val & 0xFF);
    137 }
    138 
    139 #define SW_LE(x, v) (*(x) = (v))
    140 #define SW_BE(x, v) (sw_be((x), (v)))
    141 #define SH_LE(x, v) (*(x) = (v))
    142 #define SH_BE(x, v) (sh_be((x), (v)))
    143 
    144 #endif
    145 
    146 #define SW(x, v) (SW_LE(x, v))
    147 #define SH(x, v) (SH_LE(x, v))
    148 
    149 #endif