Mercurial > botc / file comparison

comparison: src/dataBuffer.cpp

src/dataBuffer.cpp

changeset 138
a426c1039655
parent 135
8b9132fea327
equal deleted inserted replaced
137:73d057b030d0 138:a426c1039655
27 */ 27 */
28 28
29 #include <cstring> 29 #include <cstring>
30 #include "dataBuffer.h" 30 #include "dataBuffer.h"
31 31
32 // ------------------------------------------------------------------------------------------------- 32 // _________________________________________________________________________________________________
33 // 33 //
34 DataBuffer::DataBuffer (int size) : 34 DataBuffer::DataBuffer (int size) :
35 m_buffer (new char[size]), 35 m_buffer (new char[size]),
36 m_allocatedSize (size), 36 m_allocatedSize (size),
37 m_position (&buffer()[0]) {} 37 m_position (&buffer()[0]) {}
38 38
39 // ------------------------------------------------------------------------------------------------- 39 // _________________________________________________________________________________________________
40 // 40 //
41 DataBuffer::~DataBuffer() 41 DataBuffer::~DataBuffer()
42 { 42 {
43 ASSERT (marks().isEmpty()); 43 ASSERT (marks().isEmpty());
44 ASSERT (references().isEmpty()); 44 ASSERT (references().isEmpty());
45 delete buffer(); 45 delete buffer();
46 } 46 }
47 47
48 // ------------------------------------------------------------------------------------------------- 48 // _________________________________________________________________________________________________
49 // 49 //
50 // Copies the contents of the given buffer into this buffer. The other buffer's marks and 50 // Copies the contents of the given buffer into this buffer. The other buffer's marks and
51 // references will be moved along and the buffer is then destroyed. 51 // references will be moved along and the buffer is then destroyed.
52 // 52 //
53 void DataBuffer::mergeAndDestroy (DataBuffer* other) 53 void DataBuffer::mergeAndDestroy (DataBuffer* other)
61 other->transferMarksTo (this); 61 other->transferMarksTo (this);
62 copyBuffer (other); 62 copyBuffer (other);
63 delete other; 63 delete other;
64 } 64 }
65 65
66 // ------------------------------------------------------------------------------------------------- 66 // _________________________________________________________________________________________________
67 // 67 //
68 // Clones this databuffer to a new one and returns it. Note that the original transfers its marks 68 // Clones this databuffer to a new one and returns it. Note that the original transfers its marks
69 // and references and loses them in the process. 69 // and references and loses them in the process.
70 // 70 //
71 DataBuffer* DataBuffer::clone() 71 DataBuffer* DataBuffer::clone()
105 105
106 m_marks.clear(); 106 m_marks.clear();
107 m_references.clear(); 107 m_references.clear();
108 } 108 }
109 109
110 // ------------------------------------------------------------------------------------------------- 110 // _________________________________________________________________________________________________
111 // 111 //
112 // Adds a new mark to the current position with the given name 112 // Adds a new mark to the current position with the given name
113 // 113 //
114 ByteMark* DataBuffer::addMark (const String& name) 114 ByteMark* DataBuffer::addMark (const String& name)
115 { 115 {
118 mark->pos = writtenSize(); 118 mark->pos = writtenSize();
119 m_marks << mark; 119 m_marks << mark;
120 return mark; 120 return mark;
121 } 121 }
122 122
123 // ------------------------------------------------------------------------------------------------- 123 // _________________________________________________________________________________________________
124 // 124 //
125 // Adds a new reference to the given mark at the current position. This function will write 4 125 // Adds a new reference to the given mark at the current position. This function will write 4
126 // bytes to the buffer whose value will be determined at final output writing. 126 // bytes to the buffer whose value will be determined at final output writing.
127 // 127 //
128 MarkReference* DataBuffer::addReference (ByteMark* mark) 128 MarkReference* DataBuffer::addReference (ByteMark* mark)
136 writeDWord (0xBEEFCAFE); 136 writeDWord (0xBEEFCAFE);
137 137
138 return ref; 138 return ref;
139 } 139 }
140 140
141 // ------------------------------------------------------------------------------------------------- 141 // _________________________________________________________________________________________________
142 // 142 //
143 // Moves the given mark to the current bytecode position. 143 // Moves the given mark to the current bytecode position.
144 // 144 //
145 void DataBuffer::adjustMark (ByteMark* mark) 145 void DataBuffer::adjustMark (ByteMark* mark)
146 { 146 {
147 mark->pos = writtenSize(); 147 mark->pos = writtenSize();
148 } 148 }
149 149
150 // ------------------------------------------------------------------------------------------------- 150 // _________________________________________________________________________________________________
151 // 151 //
152 // Shifts the given mark by the amount of bytes 152 // Shifts the given mark by the amount of bytes
153 // 153 //
154 void DataBuffer::offsetMark (ByteMark* mark, int bytes) 154 void DataBuffer::offsetMark (ByteMark* mark, int bytes)
155 { 155 {
156 mark->pos += bytes; 156 mark->pos += bytes;
157 } 157 }
158 158
159 // ------------------------------------------------------------------------------------------------- 159 // _________________________________________________________________________________________________
160 // 160 //
161 // Writes a push of the index of the given string. 8 bytes will be written and the string index 161 // Writes a push of the index of the given string. 8 bytes will be written and the string index
162 // will be pushed to stack. 162 // will be pushed to stack.
163 // 163 //
164 void DataBuffer::writeStringIndex (const String& a) 164 void DataBuffer::writeStringIndex (const String& a)
165 { 165 {
166 writeHeader (DataHeader::PushStringIndex); 166 writeHeader (DataHeader::PushStringIndex);
167 writeDWord (getStringTableIndex (a)); 167 writeDWord (getStringTableIndex (a));
168 } 168 }
169 169
170 // ------------------------------------------------------------------------------------------------- 170 // _________________________________________________________________________________________________
171 // 171 //
172 // Writes a data header. 4 bytes. 172 // Writes a data header. 4 bytes.
173 // 173 //
174 void DataBuffer::writeHeader (DataHeader data) 174 void DataBuffer::writeHeader (DataHeader data)
175 { 175 {
176 writeDWord (static_cast<int32_t> (data)); 176 writeDWord (static_cast<int32_t> (data));
177 } 177 }
178 178
179 // ------------------------------------------------------------------------------------------------- 179 // _________________________________________________________________________________________________
180 // 180 //
181 // Prints the buffer to stdout. 181 // Prints the buffer to stdout.
182 // 182 //
183 void DataBuffer::dump() 183 void DataBuffer::dump()
184 { 184 {
185 for (int i = 0; i < writtenSize(); ++i) 185 for (int i = 0; i < writtenSize(); ++i)
186 printf ("%d. [0x%X]\n", i, buffer()[i]); 186 printf ("%d. [0x%X]\n", i, buffer()[i]);
187 } 187 }
188 188
189 // ------------------------------------------------------------------------------------------------- 189 // _________________________________________________________________________________________________
190 // 190 //
191 // Ensures there's at least the given amount of bytes left in the buffer. Will resize if necessary, 191 // Ensures there's at least the given amount of bytes left in the buffer. Will resize if necessary,
192 // no-op if not. On resize, 512 extra bytes are allocated to reduce the amount of resizes. 192 // no-op if not. On resize, 512 extra bytes are allocated to reduce the amount of resizes.
193 // 193 //
194 void DataBuffer::checkSpace (int bytes) 194 void DataBuffer::checkSpace (int bytes)
217 std::memcpy (m_buffer, copy, allocatedSize()); 217 std::memcpy (m_buffer, copy, allocatedSize());
218 setPosition (buffer() + writesize); 218 setPosition (buffer() + writesize);
219 delete copy; 219 delete copy;
220 } 220 }
221 221
222 // ------------------------------------------------------------------------------------------------- 222 // _________________________________________________________________________________________________
223 // 223 //
224 // Writes the given byte into the buffer. 224 // Writes the given byte into the buffer.
225 // 225 //
226 void DataBuffer::writeByte (int8_t data) 226 void DataBuffer::writeByte (int8_t data)
227 { 227 {
228 checkSpace (1); 228 checkSpace (1);
229 *m_position++ = data; 229 *m_position++ = data;
230 } 230 }
231 231
232 // ------------------------------------------------------------------------------------------------- 232 // _________________________________________________________________________________________________
233 // 233 //
234 // Writes the given word into the buffer. 2 bytes will be written. 234 // Writes the given word into the buffer. 2 bytes will be written.
235 // 235 //
236 void DataBuffer::writeWord (int16_t data) 236 void DataBuffer::writeWord (int16_t data)
237 { 237 {
239 239
240 for (int i = 0; i < 2; ++i) 240 for (int i = 0; i < 2; ++i)
241 *m_position++ = (data >> (i * 8)) & 0xFF; 241 *m_position++ = (data >> (i * 8)) & 0xFF;
242 } 242 }
243 243
244 // ------------------------------------------------------------------------------------------------- 244 // _________________________________________________________________________________________________
245 // 245 //
246 // Writes the given dword into the buffer. 4bytes will be written. 246 // Writes the given dword into the buffer. 4bytes will be written.
247 // 247 //
248 void DataBuffer::writeDWord (int32_t data) 248 void DataBuffer::writeDWord (int32_t data)
249 { 249 {
251 251
252 for (int i = 0; i < 4; ++i) 252 for (int i = 0; i < 4; ++i)
253 *m_position++ = (data >> (i * 8)) & 0xFF; 253 *m_position++ = (data >> (i * 8)) & 0xFF;
254 } 254 }
255 255
256 // ------------------------------------------------------------------------------------------------- 256 // _________________________________________________________________________________________________
257 // 257 //
258 // Writes the given string to the databuffer. The string will be written as-is without using string 258 // Writes the given string to the databuffer. The string will be written as-is without using string
259 // indices. This will write 4 + length bytes. No header will be written. 259 // indices. This will write 4 + length bytes. No header will be written.
260 // 260 //
261 void DataBuffer::writeString (const String& a) 261 void DataBuffer::writeString (const String& a)
265 265
266 for (char c : a) 266 for (char c : a)
267 writeByte (c); 267 writeByte (c);
268 } 268 }
269 269
270 // ------------------------------------------------------------------------------------------------- 270 // _________________________________________________________________________________________________
271 // 271 //
272 // Tries to locate the mark by the given name. Returns null if not found. 272 // Tries to locate the mark by the given name. Returns null if not found.
273 // 273 //
274 ByteMark* DataBuffer::findMarkByName (const String& name) 274 ByteMark* DataBuffer::findMarkByName (const String& name)
275 { 275 {

Mercurial Repository: botc

mercurial