CW Cyrix's Git Repository Mirror
Browse code

Use #pragma once instead of include guards.

Naram Qashat authored on 2014/09/08 14:47:36
Showing 1 changed files
src/in_2sf/desmume/mem.h
History View file @ b6add6e
... ... 
@@ -17,8 +17,7 @@
17 17 
 	along with the this software.  If not, see <http://www.gnu.org/licenses/>.
18 18 
 */
19 19
20 
-#ifndef MEM_H
21 
-#define MEM_H
20 
+#pragma once
22 21
23 22 
 #include <cstdlib>
24 23 
 #include <cassert>
... ... 
@@ -129,5 +128,3 @@ inline void T1WriteQuad(uint8_t *const mem, uint32_t addr, uint64_t val)
129 128 
 	*reinterpret_cast<uint64_t *>(mem + addr) = val;
130 129 
 #endif
131 130 
 }
132 
-
133 
-#endif
Browse code

Removed a bunch of casts, they seem to be fine without them in most cases.

Naram Qashat authored on 2013/04/18 23:22:54
Showing 1 changed files
src/in_2sf/desmume/mem.h
History View file @ 5807752
... ... 
@@ -43,7 +43,7 @@ inline uint16_t T1ReadWord_guaranteedAligned(const uint8_t *const mem, uint32_t
43 43 
 {
44 44 
 	assert(!(addr & 1));
45 45 
 #ifdef WORDS_BIGENDIAN
46 
-	return (static_cast<uint8_t *>(mem)[addr + 1] << 8) | static_cast<uint8_t *>(mem)[addr];
46 
+	return (mem[addr + 1] << 8) | mem[addr];
47 47 
 #else
48 48 
 	return *reinterpret_cast<const uint16_t *>(mem + addr);
49 49 
 #endif
... ... 
@@ -52,7 +52,7 @@ inline uint16_t T1ReadWord_guaranteedAligned(const uint8_t *const mem, uint32_t
52 52 
 inline uint16_t T1ReadWord(const uint8_t *const mem, uint32_t addr)
53 53 
 {
54 54 
 #ifdef WORDS_BIGENDIAN
55 
-	return (static_cast<uint8_t *>(mem)[addr + 1] << 8) | static_cast<uint8_t *>(mem)[addr];
55 
+	return (mem[addr + 1] << 8) | mem[addr];
56 56 
 #else
57 57 
 	return *reinterpret_cast<const uint16_t *>(mem + addr);
58 58 
 #endif
... ... 
@@ -62,7 +62,7 @@ inline uint32_t T1ReadLong_guaranteedAligned(const uint8_t *const mem, uint32_t
62 62 
 {
63 63 
 	assert(!(addr & 3));
64 64 
 #ifdef WORDS_BIGENDIAN
65 
-	return  mem[addr + 3] << 24 | mem[addr + 2] << 16 | mem[addr + 1] << 8 | mem[addr];
65 
+	return (mem[addr + 3] << 24) | (mem[addr + 2] << 16) | (mem[addr + 1] << 8) | mem[addr];
66 66 
 #else
67 67 
 	return *reinterpret_cast<const uint32_t *>(mem + addr);
68 68 
 #endif
... ... 
@@ -72,7 +72,7 @@ inline uint32_t T1ReadLong(const uint8_t *const mem, uint32_t addr)
72 72 
 {
73 73 
 	addr &= ~3;
74 74 
 #ifdef WORDS_BIGENDIAN
75 
-	return  mem[addr + 3] << 24 | mem[addr + 2] << 16 | mem[addr + 1] << 8 | mem[addr];
75 
+	return (mem[addr + 3] << 24) | (mem[addr + 2] << 16) | (mem[addr + 1] << 8) | mem[addr];
76 76 
 #else
77 77 
 	return *reinterpret_cast<const uint32_t *>(mem + addr);
78 78 
 #endif
... ... 
@@ -81,8 +81,7 @@ inline uint32_t T1ReadLong(const uint8_t *const mem, uint32_t addr)
81 81 
 inline uint64_t T1ReadQuad(const uint8_t *const mem, uint32_t addr)
82 82 
 {
83 83 
 #ifdef WORDS_BIGENDIAN
84 
-	return  uint64_t(mem[addr + 7]) << 56 | uint64_t(mem[addr + 6]) << 48 | uint64_t(mem[addr + 5]) << 40 | uint64_t(mem[addr + 4]) << 32 |
85 
-		uint64_t(mem[addr + 3]) << 24 | uint64_t(mem[addr + 2]) << 16 | uint64_t(mem[addr + 1]) << 8  | uint64_t(mem[addr]);
84 
+	return (mem[addr + 7] << 56) | (mem[addr + 6] << 48) | (mem[addr + 5] << 40) | (mem[addr + 4] << 32) | (mem[addr + 3] << 24) | (mem[addr + 2] << 16) | (mem[addr + 1] << 8)  | mem[addr];
86 85 
 #else
87 86 
 	return *reinterpret_cast<const uint64_t *>(mem + addr);
88 87 
 #endif
... ... 
@@ -118,7 +117,7 @@ inline void T1WriteLong(uint8_t *const mem, uint32_t addr, uint32_t val)
118 117 
 inline void T1WriteQuad(uint8_t *const mem, uint32_t addr, uint64_t val)
119 118 
 {
120 119 
 #ifdef WORDS_BIGENDIAN
121 
-	mem[addr + 7] = (val >> 56);
120 
+	mem[addr + 7] = val >> 56;
122 121 
 	mem[addr + 6] = (val >> 48) & 0xFF;
123 122 
 	mem[addr + 5] = (val >> 40) & 0xFF;
124 123 
 	mem[addr + 4] = (val >> 32) & 0xFF;
Browse code

Updating in_2sf to use a newish version of DeSmuME, 0.9.9 from SVN. Somewhat cleaned up as well, but not everything because it's a pain in the ass.

Naram Qashat authored on 2013/04/18 17:22:55
Showing 1 changed files
src/in_2sf/desmume/mem.h
History View file @ dfb7763
... ... 
@@ -22,106 +22,100 @@
22 22
23 23 
 #include <cstdlib>
24 24 
 #include <cassert>
25 
-
26 25 
 #include "types.h"
27 26
28 
-//this was originally declared in MMU.h but we suffered some organizational problems and had to remove it
27 
+// this was originally declared in MMU.h but we suffered some organizational problems and had to remove it
29 28 
 enum MMU_ACCESS_TYPE
30 29 
 {
31 
-	MMU_AT_CODE, //used for cpu prefetches
32 
-	MMU_AT_DATA, //used for cpu read/write
33 
-	MMU_AT_GPU, //used for gpu read/write
34 
-	MMU_AT_DMA, //used for dma read/write (blocks access to TCM)
35 
-	MMU_AT_DEBUG //used for emulator debugging functions (bypasses some debug handling)
30 
+	MMU_AT_CODE, // used for cpu prefetches
31 
+	MMU_AT_DATA, // used for cpu read/write
32 
+	MMU_AT_GPU, // used for gpu read/write
33 
+	MMU_AT_DMA, // used for dma read/write (blocks access to TCM)
34 
+	MMU_AT_DEBUG // used for emulator debugging functions (bypasses some debug handling)
36 35 
 };
37 36
38 
-static inline uint8_t T1ReadByte(uint8_t* const mem, const uint32_t addr)
37 
+inline uint8_t T1ReadByte(const uint8_t *const mem, uint32_t addr)
39 38 
 {
40 
-   return mem[addr];
39 
+	return mem[addr];
41 40 
 }
42 41
43 
-static inline uint16_t T1ReadWord_guaranteedAligned(void* const mem, const uint32_t addr)
42 
+inline uint16_t T1ReadWord_guaranteedAligned(const uint8_t *const mem, uint32_t addr)
44 43 
 {
45 
-	assert((addr&1)==0);
44 
+	assert(!(addr & 1));
46 45 
 #ifdef WORDS_BIGENDIAN
47 
-   return (((uint8_t*)mem)[addr + 1] << 8) | ((uint8_t*)mem)[addr];
46 
+	return (static_cast<uint8_t *>(mem)[addr + 1] << 8) | static_cast<uint8_t *>(mem)[addr];
48 47 
 #else
49 
-   return *(uint16_t*)((uint8_t*)mem + addr);
48 
+	return *reinterpret_cast<const uint16_t *>(mem + addr);
50 49 
 #endif
51 50 
 }
52 51
53 
-static inline uint16_t T1ReadWord(void* const mem, const uint32_t addr)
52 
+inline uint16_t T1ReadWord(const uint8_t *const mem, uint32_t addr)
54 53 
 {
55 54 
 #ifdef WORDS_BIGENDIAN
56 
-   return (((uint8_t*)mem)[addr + 1] << 8) | ((uint8_t*)mem)[addr];
55 
+	return (static_cast<uint8_t *>(mem)[addr + 1] << 8) | static_cast<uint8_t *>(mem)[addr];
57 56 
 #else
58 
-   return *((uint16_t *) ((uint8_t*)mem + addr));
57 
+	return *reinterpret_cast<const uint16_t *>(mem + addr);
59 58 
 #endif
60 59 
 }
61 60
62 
-static inline uint32_t T1ReadLong_guaranteedAligned(uint8_t* const  mem, const uint32_t addr)
61 
+inline uint32_t T1ReadLong_guaranteedAligned(const uint8_t *const mem, uint32_t addr)
63 62 
 {
64 
-	assert((addr&3)==0);
63 
+	assert(!(addr & 3));
65 64 
 #ifdef WORDS_BIGENDIAN
66 
-   return  mem[addr + 3] << 24 | mem[addr + 2] << 16 |
67 
-           mem[addr + 1] << 8 | mem[addr];
65 
+	return  mem[addr + 3] << 24 | mem[addr + 2] << 16 | mem[addr + 1] << 8 | mem[addr];
68 66 
 #else
69 
-	return *(uint32_t*)(mem + addr);
67 
+	return *reinterpret_cast<const uint32_t *>(mem + addr);
70 68 
 #endif
71 69 
 }
72 70
73 
-
74 
-static inline uint32_t T1ReadLong(uint8_t* const  mem, uint32_t addr)
71 
+inline uint32_t T1ReadLong(const uint8_t *const mem, uint32_t addr)
75 72 
 {
76 
-   addr &= ~3;
73 
+	addr &= ~3;
77 74 
 #ifdef WORDS_BIGENDIAN
78 
-   return  mem[addr + 3] << 24 | mem[addr + 2] << 16 |
79 
-           mem[addr + 1] << 8 | mem[addr];
75 
+	return  mem[addr + 3] << 24 | mem[addr + 2] << 16 | mem[addr + 1] << 8 | mem[addr];
80 76 
 #else
81 
-   return *(uint32_t*)(mem + addr);
77 
+	return *reinterpret_cast<const uint32_t *>(mem + addr);
82 78 
 #endif
83 79 
 }
84 80
85 
-static inline uint64_t T1ReadQuad(uint8_t* const mem, const uint32_t addr)
81 
+inline uint64_t T1ReadQuad(const uint8_t *const mem, uint32_t addr)
86 82 
 {
87 83 
 #ifdef WORDS_BIGENDIAN
88 
-   return  uint64_t(mem[addr + 7]) << 56 | uint64_t(mem[addr + 6]) << 48 |
89 
-           uint64_t(mem[addr + 5]) << 40 | uint64_t(mem[addr + 4]) << 32 |
90 
-           uint64_t(mem[addr + 3]) << 24 | uint64_t(mem[addr + 2]) << 16 |
91 
-           uint64_t(mem[addr + 1]) << 8  | uint64_t(mem[addr    ]);
84 
+	return  uint64_t(mem[addr + 7]) << 56 | uint64_t(mem[addr + 6]) << 48 | uint64_t(mem[addr + 5]) << 40 | uint64_t(mem[addr + 4]) << 32 |
85 
+		uint64_t(mem[addr + 3]) << 24 | uint64_t(mem[addr + 2]) << 16 | uint64_t(mem[addr + 1]) << 8  | uint64_t(mem[addr]);
92 86 
 #else
93 
-   return *((uint64_t *) (mem + addr));
87 
+	return *reinterpret_cast<const uint64_t *>(mem + addr);
94 88 
 #endif
95 89 
 }
96 90
97 
-static inline void T1WriteByte(uint8_t* const mem, const uint32_t addr, const uint8_t val)
91 
+inline void T1WriteByte(uint8_t *const mem, uint32_t addr, uint8_t val)
98 92 
 {
99 
-   mem[addr] = val;
93 
+	mem[addr] = val;
100 94 
 }
101 95
102 
-static inline void T1WriteWord(uint8_t* const mem, const uint32_t addr, const uint16_t val)
96 
+inline void T1WriteWord(uint8_t *const mem, uint32_t addr, uint16_t val)
103 97 
 {
104 98 
 #ifdef WORDS_BIGENDIAN
105 
-   mem[addr + 1] = val >> 8;
106 
-   mem[addr] = val & 0xFF;
99 
+	mem[addr + 1] = val >> 8;
100 
+	mem[addr] = val & 0xFF;
107 101 
 #else
108 
-   *((uint16_t *) (mem + addr)) = val;
102 
+	*reinterpret_cast<uint16_t *>(mem + addr) = val;
109 103 
 #endif
110 104 
 }
111 105
112 
-static inline void T1WriteLong(uint8_t* const mem, const uint32_t addr, const uint32_t val)
106 
+inline void T1WriteLong(uint8_t *const mem, uint32_t addr, uint32_t val)
113 107 
 {
114 108 
 #ifdef WORDS_BIGENDIAN
115 
-   mem[addr + 3] = val >> 24;
116 
-   mem[addr + 2] = (val >> 16) & 0xFF;
117 
-   mem[addr + 1] = (val >> 8) & 0xFF;
118 
-   mem[addr] = val & 0xFF;
109 
+	mem[addr + 3] = val >> 24;
110 
+	mem[addr + 2] = (val >> 16) & 0xFF;
111 
+	mem[addr + 1] = (val >> 8) & 0xFF;
112 
+	mem[addr] = val & 0xFF;
119 113 
 #else
120 
-   *((uint32_t *) (mem + addr)) = val;
114 
+	*reinterpret_cast<uint32_t *>(mem + addr) = val;
121 115 
 #endif
122 116 
 }
123 117
124 
-static inline void T1WriteQuad(uint8_t* const mem, const uint32_t addr, const uint64_t val)
118 
+inline void T1WriteQuad(uint8_t *const mem, uint32_t addr, uint64_t val)
125 119 
 {
126 120 
 #ifdef WORDS_BIGENDIAN
127 121 
 	mem[addr + 7] = (val >> 56);
... ... 
@@ -129,61 +123,12 @@ static inline void T1WriteQuad(uint8_t* const mem, const uint32_t addr, const ui
129 123 
 	mem[addr + 5] = (val >> 40) & 0xFF;
130 124 
 	mem[addr + 4] = (val >> 32) & 0xFF;
131 125 
 	mem[addr + 3] = (val >> 24) & 0xFF;
132 
-    mem[addr + 2] = (val >> 16) & 0xFF;
133 
-    mem[addr + 1] = (val >> 8) & 0xFF;
134 
-    mem[addr] = val & 0xFF;
126 
+	mem[addr + 2] = (val >> 16) & 0xFF;
127 
+	mem[addr + 1] = (val >> 8) & 0xFF;
128 
+	mem[addr] = val & 0xFF;
135 129 
 #else
136 
-	*((uint64_t *) (mem + addr)) = val;
130 
+	*reinterpret_cast<uint64_t *>(mem + addr) = val;
137 131 
 #endif
138 132 
 }
139 133
140 
-//static inline uint8_t T2ReadByte(uint8_t* const  mem, const uint32_t addr)
141 
-//{
142 
-//#ifdef WORDS_BIGENDIAN
143 
-//   return mem[addr ^ 1];
144 
-//#else
145 
-//   return mem[addr];
146 
-//#endif
147 
-//}
148 
-//
149 
-
150 
-/*static inline uint16_t HostReadWord(uint8_t* const mem, const uint32_t addr)
151 
-{
152 
-   return *((uint16_t *) (mem + addr));
153 
-}*/
154 
-
155 
-//
156 
-//static inline uint32_t T2ReadLong(uint8_t* const mem, const uint32_t addr)
157 
-//{
158 
-//#ifdef WORDS_BIGENDIAN
159 
-//   return *((uint16_t *) (mem + addr + 2)) << 16 | *((uint16_t *) (mem + addr));
160 
-//#else
161 
-//   return *((uint32_t *) (mem + addr));
162 
-//#endif
163 
-//}
164 
-//
165 
-//static inline void T2WriteByte(uint8_t* const mem, const uint32_t addr, const uint8_t val)
166 
-//{
167 
-//#ifdef WORDS_BIGENDIAN
168 
-//   mem[addr ^ 1] = val;
169 
-//#else
170 
-//   mem[addr] = val;
171 
-//#endif
172 
-//}
173 
-
174 
-/*static inline void HostWriteWord(uint8_t* const mem, const uint32_t addr, const uint16_t val)
175 
-{
176 
-   *((uint16_t *) (mem + addr)) = val;
177 
-}*/
178 
-
179 
-/*static inline void HostWriteTwoWords(uint8_t* const mem, const uint32_t addr, const uint32_t val)
180 
-{
181 
-#ifdef WORDS_BIGENDIAN
182 
-   *((uint16_t *) (mem + addr + 2)) = val >> 16;
183 
-   *((uint16_t *) (mem + addr)) = val & 0xFFFF;
184 
-#else
185 
-   *((uint32_t *) (mem + addr)) = val;
186 
-#endif
187 
-}*/
188 
-
189 134 
 #endif
Browse code

Import actual code.

Naram Qashat authored on 2013/03/26 02:41:19
Showing 1 changed files
src/in_2sf/desmume/mem.h
History View file @ bc076aa
1 1 
new file mode 100644
... ... 
@@ -0,0 +1,189 @@
1 
+/*
2 
+	Copyright (C) 2005 Theo Berkau
3 
+	Copyright (C) 2005-2006 Guillaume Duhamel
4 
+	Copyright (C) 2008-2010 DeSmuME team
5 
+
6 
+	This file is free software: you can redistribute it and/or modify
7 
+	it under the terms of the GNU General Public License as published by
8 
+	the Free Software Foundation, either version 2 of the License, or
9 
+	(at your option) any later version.
10 
+
11 
+	This file is distributed in the hope that it will be useful,
12 
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
13 
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 
+	GNU General Public License for more details.
15 
+
16 
+	You should have received a copy of the GNU General Public License
17 
+	along with the this software.  If not, see <http://www.gnu.org/licenses/>.
18 
+*/
19 
+
20 
+#ifndef MEM_H
21 
+#define MEM_H
22 
+
23 
+#include <cstdlib>
24 
+#include <cassert>
25 
+
26 
+#include "types.h"
27 
+
28 
+//this was originally declared in MMU.h but we suffered some organizational problems and had to remove it
29 
+enum MMU_ACCESS_TYPE
30 
+{
31 
+	MMU_AT_CODE, //used for cpu prefetches
32 
+	MMU_AT_DATA, //used for cpu read/write
33 
+	MMU_AT_GPU, //used for gpu read/write
34 
+	MMU_AT_DMA, //used for dma read/write (blocks access to TCM)
35 
+	MMU_AT_DEBUG //used for emulator debugging functions (bypasses some debug handling)
36 
+};
37 
+
38 
+static inline uint8_t T1ReadByte(uint8_t* const mem, const uint32_t addr)
39 
+{
40 
+   return mem[addr];
41 
+}
42 
+
43 
+static inline uint16_t T1ReadWord_guaranteedAligned(void* const mem, const uint32_t addr)
44 
+{
45 
+	assert((addr&1)==0);
46 
+#ifdef WORDS_BIGENDIAN
47 
+   return (((uint8_t*)mem)[addr + 1] << 8) | ((uint8_t*)mem)[addr];
48 
+#else
49 
+   return *(uint16_t*)((uint8_t*)mem + addr);
50 
+#endif
51 
+}
52 
+
53 
+static inline uint16_t T1ReadWord(void* const mem, const uint32_t addr)
54 
+{
55 
+#ifdef WORDS_BIGENDIAN
56 
+   return (((uint8_t*)mem)[addr + 1] << 8) | ((uint8_t*)mem)[addr];
57 
+#else
58 
+   return *((uint16_t *) ((uint8_t*)mem + addr));
59 
+#endif
60 
+}
61 
+
62 
+static inline uint32_t T1ReadLong_guaranteedAligned(uint8_t* const  mem, const uint32_t addr)
63 
+{
64 
+	assert((addr&3)==0);
65 
+#ifdef WORDS_BIGENDIAN
66 
+   return  mem[addr + 3] << 24 | mem[addr + 2] << 16 |
67 
+           mem[addr + 1] << 8 | mem[addr];
68 
+#else
69 
+	return *(uint32_t*)(mem + addr);
70 
+#endif
71 
+}
72 
+
73 
+
74 
+static inline uint32_t T1ReadLong(uint8_t* const  mem, uint32_t addr)
75 
+{
76 
+   addr &= ~3;
77 
+#ifdef WORDS_BIGENDIAN
78 
+   return  mem[addr + 3] << 24 | mem[addr + 2] << 16 |
79 
+           mem[addr + 1] << 8 | mem[addr];
80 
+#else
81 
+   return *(uint32_t*)(mem + addr);
82 
+#endif
83 
+}
84 
+
85 
+static inline uint64_t T1ReadQuad(uint8_t* const mem, const uint32_t addr)
86 
+{
87 
+#ifdef WORDS_BIGENDIAN
88 
+   return  uint64_t(mem[addr + 7]) << 56 | uint64_t(mem[addr + 6]) << 48 |
89 
+           uint64_t(mem[addr + 5]) << 40 | uint64_t(mem[addr + 4]) << 32 |
90 
+           uint64_t(mem[addr + 3]) << 24 | uint64_t(mem[addr + 2]) << 16 |
91 
+           uint64_t(mem[addr + 1]) << 8  | uint64_t(mem[addr    ]);
92 
+#else
93 
+   return *((uint64_t *) (mem + addr));
94 
+#endif
95 
+}
96 
+
97 
+static inline void T1WriteByte(uint8_t* const mem, const uint32_t addr, const uint8_t val)
98 
+{
99 
+   mem[addr] = val;
100 
+}
101 
+
102 
+static inline void T1WriteWord(uint8_t* const mem, const uint32_t addr, const uint16_t val)
103 
+{
104 
+#ifdef WORDS_BIGENDIAN
105 
+   mem[addr + 1] = val >> 8;
106 
+   mem[addr] = val & 0xFF;
107 
+#else
108 
+   *((uint16_t *) (mem + addr)) = val;
109 
+#endif
110 
+}
111 
+
112 
+static inline void T1WriteLong(uint8_t* const mem, const uint32_t addr, const uint32_t val)
113 
+{
114 
+#ifdef WORDS_BIGENDIAN
115 
+   mem[addr + 3] = val >> 24;
116 
+   mem[addr + 2] = (val >> 16) & 0xFF;
117 
+   mem[addr + 1] = (val >> 8) & 0xFF;
118 
+   mem[addr] = val & 0xFF;
119 
+#else
120 
+   *((uint32_t *) (mem + addr)) = val;
121 
+#endif
122 
+}
123 
+
124 
+static inline void T1WriteQuad(uint8_t* const mem, const uint32_t addr, const uint64_t val)
125 
+{
126 
+#ifdef WORDS_BIGENDIAN
127 
+	mem[addr + 7] = (val >> 56);
128 
+	mem[addr + 6] = (val >> 48) & 0xFF;
129 
+	mem[addr + 5] = (val >> 40) & 0xFF;
130 
+	mem[addr + 4] = (val >> 32) & 0xFF;
131 
+	mem[addr + 3] = (val >> 24) & 0xFF;
132 
+    mem[addr + 2] = (val >> 16) & 0xFF;
133 
+    mem[addr + 1] = (val >> 8) & 0xFF;
134 
+    mem[addr] = val & 0xFF;
135 
+#else
136 
+	*((uint64_t *) (mem + addr)) = val;
137 
+#endif
138 
+}
139 
+
140 
+//static inline uint8_t T2ReadByte(uint8_t* const  mem, const uint32_t addr)
141 
+//{
142 
+//#ifdef WORDS_BIGENDIAN
143 
+//   return mem[addr ^ 1];
144 
+//#else
145 
+//   return mem[addr];
146 
+//#endif
147 
+//}
148 
+//
149 
+
150 
+/*static inline uint16_t HostReadWord(uint8_t* const mem, const uint32_t addr)
151 
+{
152 
+   return *((uint16_t *) (mem + addr));
153 
+}*/
154 
+
155 
+//
156 
+//static inline uint32_t T2ReadLong(uint8_t* const mem, const uint32_t addr)
157 
+//{
158 
+//#ifdef WORDS_BIGENDIAN
159 
+//   return *((uint16_t *) (mem + addr + 2)) << 16 | *((uint16_t *) (mem + addr));
160 
+//#else
161 
+//   return *((uint32_t *) (mem + addr));
162 
+//#endif
163 
+//}
164 
+//
165 
+//static inline void T2WriteByte(uint8_t* const mem, const uint32_t addr, const uint8_t val)
166 
+//{
167 
+//#ifdef WORDS_BIGENDIAN
168 
+//   mem[addr ^ 1] = val;
169 
+//#else
170 
+//   mem[addr] = val;
171 
+//#endif
172 
+//}
173 
+
174 
+/*static inline void HostWriteWord(uint8_t* const mem, const uint32_t addr, const uint16_t val)
175 
+{
176 
+   *((uint16_t *) (mem + addr)) = val;
177 
+}*/
178 
+
179 
+/*static inline void HostWriteTwoWords(uint8_t* const mem, const uint32_t addr, const uint32_t val)
180 
+{
181 
+#ifdef WORDS_BIGENDIAN
182 
+   *((uint16_t *) (mem + addr + 2)) = val >> 16;
183 
+   *((uint16_t *) (mem + addr)) = val & 0xFFFF;
184 
+#else
185 
+   *((uint32_t *) (mem + addr)) = val;
186 
+#endif
187 
+}*/
188 
+
189 
+#endif