Debian Codegraph @

unikey/byteio.cpp

raw
1 /*
2 * SPDX-FileCopyrightText: 1998-2002 Pham Kim Long <[email protected]>
3 *
4 * SPDX-License-Identifier: GPL-2.0-or-later
5 */
6 #include "byteio.h"
7 #include <string.h>
8
9 //------------------------------------------------
10 StringBIStream::StringBIStream(UKBYTE *data, int len, int elementSize) {
11 m_data = m_current = data;
12 m_len = m_left = len;
13 if (len == -1) {
14 if (elementSize == 2)
15 m_eos = (*(UKWORD *)data == 0);
16 else if (elementSize == 4)
17 m_eos = (*(UKDWORD *)data == 4);
18 else
19 m_eos = (*data == 0);
20 } else
21 m_eos = (len <= 0);
22 m_didBookmark = 0;
23 }
24
25 //------------------------------------------------
26 int StringBIStream::eos() { return m_eos; }
27
28 //------------------------------------------------
29 int StringBIStream::getNext(UKBYTE &b) {
30 if (m_eos)
31 return 0;
32 b = *m_current++;
33 if (m_len == -1) {
34 m_eos = (b == 0);
35 } else {
36 m_left--;
37 m_eos = (m_left <= 0);
38 }
39 return 1;
40 }
41
42 //------------------------------------------------
43 int StringBIStream::unget(UKBYTE b) {
44 if (m_current != m_data) {
45 *--m_current = b;
46 m_eos = 0;
47 if (m_len != -1)
48 m_left++;
49 }
50 return 1;
51 }
52
53 //------------------------------------------------
54 int StringBIStream::getNextW(UKWORD &w) {
55 if (m_eos)
56 return 0;
57 w = *((UKWORD *)m_current);
58 m_current += 2;
59 if (m_len == -1)
60 m_eos = (w == 0);
61 else {
62 m_left -= 2;
63 m_eos = (m_left <= 0);
64 }
65 return 1;
66 }
67
68 //------------------------------------------------
69 int StringBIStream::getNextDW(UKDWORD &dw) {
70 if (m_eos)
71 return 0;
72
73 dw = *((UKDWORD *)m_current);
74 m_current += 4;
75 if (m_len == -1)
76 m_eos = (dw == 0);
77 else {
78 m_left -= 4;
79 m_eos = (m_left <= 0);
80 }
81 return 1;
82 }
83
84 //------------------------------------------------
85 int StringBIStream::peekNext(UKBYTE &b) {
86 if (m_eos)
87 return 0;
88 b = *m_current;
89 return 1;
90 }
91
92 //------------------------------------------------
93 int StringBIStream::peekNextW(UKWORD &w) {
94 if (m_eos)
95 return 0;
96 w = *((UKWORD *)m_current);
97 return 1;
98 }
99
100 /*
101 //------------------------------------------------
102 int StringBIStream::peekNextDW(UKDWORD & dw)
103 {
104 if (m_eos)
105 return 0;
106 dw = *((UKDWORD *)m_current);
107 return 1;
108 }
109 */
110
111 //------------------------------------------------
112 void StringBIStream::reopen() {
113 m_current = m_data;
114 m_left = m_len;
115 if (m_len == -1)
116 m_eos = (m_data == 0);
117 else
118 m_eos = (m_len <= 0);
119 m_didBookmark = 0;
120 }
121
122 //------------------------------------------------
123 int StringBIStream::bookmark() {
124 m_didBookmark = 1;
125 m_bookmark.current = m_current;
126 m_bookmark.data = m_data;
127 m_bookmark.eos = m_eos;
128 m_bookmark.left = m_left;
129 m_bookmark.len = m_len;
130 return 1;
131 }
132
133 //------------------------------------------------
134 int StringBIStream::gotoBookmark() {
135 if (!m_didBookmark)
136 return 0;
137 m_current = m_bookmark.current;
138 m_data = m_bookmark.data;
139 m_eos = m_bookmark.eos;
140 m_left = m_bookmark.left;
141 m_len = m_bookmark.len;
142 return 1;
143 }
144
145 //------------------------------------------------
146 int StringBIStream::close() { return 1; };
147
148 //////////////////////////////////////////////////
149 // Class StringBOStream
150 //////////////////////////////////////////////////
151
152 //------------------------------------------------
153 StringBOStream::StringBOStream(UKBYTE *buf, int len) {
154 m_current = m_buf = buf;
155 m_len = len;
156 m_out = 0;
157 m_bad = 0;
158 }
159
160 //------------------------------------------------
161 int StringBOStream::putB(UKBYTE b) {
162 m_out++;
163 /*
164 if (m_out >= 2147483647) {
165 int err;
166 err = 1;
167 }
168 */
169 if (m_bad)
170 return 0;
171 /*
172 if (m_out < 0) {
173 int i;
174 i = 1;
175 }
176 */
177 if (m_out <= m_len) {
178 *m_current++ = b;
179 return 1;
180 }
181 m_bad = 1;
182 return 0;
183 }
184
185 //------------------------------------------------
186 int StringBOStream::putW(UKWORD w) {
187 m_out += 2;
188 if (m_bad)
189 return 0;
190 if (m_out <= m_len) {
191 *((UKWORD *)m_current) = w;
192 m_current += 2;
193 return 1;
194 }
195 m_bad = 1;
196 return 0;
197 }
198
199 //------------------------------------------------
200 int StringBOStream::puts(const char *s, int size) {
201 if (size == -1) {
202 while (*s) {
203 m_out++;
204 if (m_out <= m_len)
205 *m_current++ = *s;
206 s++;
207 }
208 if (!m_bad && m_out > m_len)
209 m_bad = 1;
210 return (!m_bad);
211 }
212
213 int n;
214 if (!m_bad && m_out <= m_len) {
215 n = m_len - m_out;
216 if (n > size)
217 n = size;
218 memcpy(m_current, s, n);
219 m_current += n;
220 }
221
222 m_out += size;
223 if (!m_bad && m_out > m_len)
224 m_bad = 1;
225 return (!m_bad);
226 }
227
228 //------------------------------------------------
229 void StringBOStream::reopen() {
230 m_current = m_buf;
231 m_out = 0;
232 m_bad = 0;
233 }
234
235 //------------------------------------------------
236 int StringBOStream::isOK() { return !m_bad; }
237
238 ////////////////////////////////////////////////////
239 // Class FileBIStream //
240 ////////////////////////////////////////////////////
241
242 //----------------------------------------------------
243 FileBIStream::FileBIStream(int bufSize, char *buf) {
244 m_file = NULL;
245 m_buf = buf;
246 m_bufSize = bufSize;
247 m_own = 1;
248 m_didBookmark = 0;
249
250 m_readAhead = 0;
251 m_lastIsAhead = 0;
252 }
253
254 //----------------------------------------------------
255 FileBIStream::~FileBIStream() {
256 if (m_own)
257 close();
258 }
259
260 //----------------------------------------------------
261 int FileBIStream::open(const char *fileName) {
262 m_file = fopen(fileName, "rb");
263 if (m_file == NULL)
264 return 0;
265 setvbuf(m_file, m_buf, _IOFBF, m_bufSize);
266 m_own = 0;
267 m_readAhead = 0;
268 m_lastIsAhead = 0;
269 return 1;
270 }
271
272 //----------------------------------------------------
273 int FileBIStream::close() {
274 if (m_file != NULL) {
275 fclose(m_file);
276 m_file = NULL;
277 }
278 return 1;
279 }
280
281 //----------------------------------------------------
282 void FileBIStream::attach(FILE *f) {
283 m_file = f;
284 m_own = 0;
285 m_readAhead = 0;
286 m_lastIsAhead = 0;
287 }
288
289 //----------------------------------------------------
290 int FileBIStream::eos() {
291 if (m_readAhead)
292 return 0;
293 return feof(m_file);
294 }
295
296 //----------------------------------------------------
297 int FileBIStream::getNext(UKBYTE &b) {
298 if (m_readAhead) {
299 m_readAhead = 0;
300 b = m_readByte;
301 m_lastIsAhead = 1;
302 return 1;
303 }
304
305 m_lastIsAhead = 0;
306 b = fgetc(m_file);
307 return (!feof(m_file));
308 }
309
310 //----------------------------------------------------
311 int FileBIStream::peekNext(UKBYTE &b) {
312 if (m_readAhead) {
313 b = m_readByte;
314 return 1;
315 }
316
317 b = fgetc(m_file);
318 if (feof(m_file))
319 return 0;
320 ungetc(b, m_file);
321 return 1;
322 }
323
324 //----------------------------------------------------
325 int FileBIStream::unget(UKBYTE b) {
326 if (m_lastIsAhead) {
327 m_lastIsAhead = 0;
328 m_readAhead = 1;
329 m_readByte = b;
330 return 1;
331 }
332
333 ungetc(b, m_file);
334 return 1;
335 }
336
337 //----------------------------------------------------
338 int FileBIStream::getNextW(UKWORD &w) {
339 UKBYTE b1, b2;
340
341 if (getNext(b1)) {
342 if (getNext(b2)) {
343 *((UKBYTE *)&w) = b1;
344 *(((UKBYTE *)&w) + 1) = b2;
345 return 1;
346 }
347 }
348 return 0;
349 }
350
351 //----------------------------------------------------
352 int FileBIStream::getNextDW(UKDWORD &dw) {
353 UKWORD w1, w2;
354 if (getNextW(w1)) {
355 if (getNextW(w2)) {
356 *((UKWORD *)&dw) = w1;
357 *(((UKWORD *)&dw) + 1) = w2;
358 return 1;
359 }
360 }
361 return 0;
362 }
363 //----------------------------------------------------
364 int FileBIStream::peekNextW(UKWORD &w) {
365 UKBYTE hi, low;
366 if (getNext(low)) {
367 if (getNext(hi)) {
368 unget(hi);
369 w = hi;
370 w = (w << 8) + low;
371 m_readAhead = 1;
372 m_readByte = low;
373 m_lastIsAhead = 0;
374 return 1;
375 }
376
377 m_readAhead = 1;
378 m_readByte = low;
379 m_lastIsAhead = 0;
380 return 0;
381 }
382 return 0;
383 }
384
385 //----------------------------------------------------
386 int FileBIStream::bookmark() {
387 m_didBookmark = 1;
388 m_bookmark.pos = ftell(m_file);
389 return 1;
390 }
391
392 //----------------------------------------------------
393 int FileBIStream::gotoBookmark() {
394 if (!m_didBookmark)
395 return 0;
396 fseek(m_file, m_bookmark.pos, SEEK_SET);
397 return 1;
398 }
399
400 ////////////////////////////////////////////////////
401 // Class FileBOStream //
402 ////////////////////////////////////////////////////
403 //----------------------------------------------------
404 FileBOStream::FileBOStream(int bufSize, char *buf) {
405 m_file = NULL;
406 m_buf = buf;
407 m_bufSize = bufSize;
408 m_own = 1;
409 m_bad = 1;
410 }
411
412 //----------------------------------------------------
413 FileBOStream::~FileBOStream() {
414 if (m_own)
415 close();
416 }
417
418 //----------------------------------------------------
419 int FileBOStream::open(const char *fileName) {
420 m_file = fopen(fileName, "wb");
421 if (m_file == NULL)
422 return 0;
423 m_bad = 0;
424 setvbuf(m_file, m_buf, _IOFBF, m_bufSize);
425 m_own = 1;
426 return 1;
427 }
428
429 //----------------------------------------------------
430 void FileBOStream::attach(FILE *f) {
431 m_file = f;
432 m_own = 0;
433 m_bad = 0;
434 }
435
436 //----------------------------------------------------
437 int FileBOStream::close() {
438 if (m_file != NULL) {
439 fclose(m_file);
440 m_file = NULL;
441 }
442 return 1;
443 }
444
445 //----------------------------------------------------
446 int FileBOStream::putB(UKBYTE b) {
447 if (m_bad)
448 return 0;
449 m_bad = (fputc(b, m_file) == EOF);
450 return (!m_bad);
451 }
452
453 //----------------------------------------------------
454 int FileBOStream::putW(UKWORD w) {
455 if (m_bad)
456 return 0;
457 // m_bad = (fputwc(w, m_file) == WEOF);
458 m_bad = (fputc((UKBYTE)w, m_file) == EOF);
459 if (m_bad)
460 return 0;
461 m_bad = (fputc((UKBYTE)(w >> 8), m_file) == EOF);
462 return (!m_bad);
463 }
464
465 //----------------------------------------------------
466 int FileBOStream::puts(const char *s, int size) {
467 if (m_bad)
468 return 0;
469 if (size == -1) {
470 m_bad = (fputs(s, m_file) == EOF);
471 return (!m_bad);
472 }
473 int out = fwrite(s, 1, size, m_file);
474 m_bad = (out != size);
475 return (!m_bad);
476 }
477
478 //----------------------------------------------------
479 int FileBOStream::isOK() { return !m_bad; }