|
1960
|
1 /* |
|
|
2 |
|
|
3 Copyright (C) 1996 John W. Eaton |
|
|
4 |
|
|
5 This file is part of Octave. |
|
|
6 |
|
|
7 Octave is free software; you can redistribute it and/or modify it |
|
|
8 under the terms of the GNU General Public License as published by the |
|
|
9 Free Software Foundation; either version 2, or (at your option) any |
|
|
10 later version. |
|
|
11 |
|
|
12 Octave is distributed in the hope that it will be useful, but WITHOUT |
|
|
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
15 for more details. |
|
|
16 |
|
|
17 You should have received a copy of the GNU General Public License |
|
|
18 along with Octave; see the file COPYING. If not, write to the Free |
|
|
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
|
|
20 |
|
|
21 */ |
|
|
22 |
|
|
23 #ifdef HAVE_CONFIG_H |
|
|
24 #include <config.h> |
|
|
25 #endif |
|
|
26 |
|
|
27 #include <iostream.h> |
|
|
28 |
|
|
29 #include "byte-swap.h" |
|
|
30 #include "data-conv.h" |
|
|
31 #include "lo-error.h" |
|
|
32 |
|
|
33 #define swap_1_bytes(x, y) |
|
|
34 |
|
|
35 #define LS_DO_READ(TYPE,swap,data,size,len,stream) \ |
|
|
36 do \ |
|
|
37 { \ |
|
|
38 volatile TYPE *ptr = (TYPE *) data; \ |
|
|
39 stream.read ((TYPE *) ptr, size * len); \ |
|
|
40 if (swap) \ |
|
|
41 swap_ ## size ## _bytes ((char *) ptr, len); \ |
|
|
42 TYPE tmp = ptr[0]; \ |
|
|
43 for (int i = len - 1; i > 0; i--) \ |
|
|
44 data[i] = ptr[i]; \ |
|
|
45 data[0] = tmp; \ |
|
|
46 } \ |
|
|
47 while (0) |
|
|
48 |
|
|
49 // Have to use copy here to avoid writing over data accessed via |
|
|
50 // Matrix::data(). |
|
|
51 |
|
|
52 #define LS_DO_WRITE(TYPE,data,size,len,stream) \ |
|
|
53 do \ |
|
|
54 { \ |
|
|
55 char tmp_type = (char) type; \ |
|
|
56 stream.write (&tmp_type, 1); \ |
|
|
57 TYPE *ptr = new TYPE [len]; \ |
|
|
58 for (int i = 0; i < len; i++) \ |
|
|
59 ptr[i] = (TYPE) data[i]; \ |
|
|
60 stream.write ((TYPE *) ptr, size * len); \ |
|
|
61 delete [] ptr ; \ |
|
|
62 } \ |
|
|
63 while (0) |
|
|
64 |
|
|
65 // Loading variables from files. |
|
|
66 |
|
|
67 static void |
|
|
68 gripe_unrecognized_float_fmt (void) |
|
|
69 { |
|
|
70 (*current_liboctave_error_handler) |
|
|
71 ("unrecognized floating point format requested"); |
|
|
72 } |
|
|
73 |
|
|
74 static void |
|
|
75 gripe_data_conversion (const char *from, const char *to) |
|
|
76 { |
|
|
77 (*current_liboctave_error_handler) |
|
|
78 ("unable to convert from %s to %s format", from, to); |
|
|
79 } |
|
|
80 |
|
|
81 // But first, some data conversion routines. |
|
|
82 |
|
|
83 // Currently, we only handle conversions for the IEEE types. To fix |
|
|
84 // that, make more of the following routines work. |
|
|
85 |
|
|
86 // XXX FIXME XXX -- assumes sizeof (Complex) == 8 |
|
|
87 // XXX FIXME XXX -- assumes sizeof (double) == 8 |
|
|
88 // XXX FIXME XXX -- assumes sizeof (float) == 4 |
|
|
89 |
|
|
90 static void |
|
|
91 IEEE_big_double_to_IEEE_little_double (double *d, int len) |
|
|
92 { |
|
|
93 swap_8_bytes ((char *) d, len); |
|
|
94 } |
|
|
95 |
|
|
96 static void |
|
|
97 VAX_D_double_to_IEEE_little_double (double * /* d */, int /* len */) |
|
|
98 { |
|
|
99 gripe_data_conversion ("VAX D float", "IEEE little endian format"); |
|
|
100 } |
|
|
101 |
|
|
102 static void |
|
|
103 VAX_G_double_to_IEEE_little_double (double * /* d */, int /* len */) |
|
|
104 { |
|
|
105 gripe_data_conversion ("VAX G float", "IEEE little endian format"); |
|
|
106 } |
|
|
107 |
|
|
108 static void |
|
|
109 Cray_to_IEEE_little_double (double * /* d */, int /* len */) |
|
|
110 { |
|
|
111 gripe_data_conversion ("Cray", "IEEE little endian format"); |
|
|
112 } |
|
|
113 |
|
|
114 static void |
|
|
115 IEEE_big_float_to_IEEE_little_float (float *d, int len) |
|
|
116 { |
|
|
117 swap_4_bytes ((char *) d, len); |
|
|
118 } |
|
|
119 |
|
|
120 static void |
|
|
121 VAX_D_float_to_IEEE_little_float (float * /* d */, int /* len */) |
|
|
122 { |
|
|
123 gripe_data_conversion ("VAX D float", "IEEE little endian format"); |
|
|
124 } |
|
|
125 |
|
|
126 static void |
|
|
127 VAX_G_float_to_IEEE_little_float (float * /* d */, int /* len */) |
|
|
128 { |
|
|
129 gripe_data_conversion ("VAX G float", "IEEE little endian format"); |
|
|
130 } |
|
|
131 |
|
|
132 static void |
|
|
133 Cray_to_IEEE_little_float (float * /* d */, int /* len */) |
|
|
134 { |
|
|
135 gripe_data_conversion ("Cray", "IEEE little endian format"); |
|
|
136 } |
|
|
137 |
|
|
138 static void |
|
|
139 IEEE_little_double_to_IEEE_big_double (double *d, int len) |
|
|
140 { |
|
|
141 swap_8_bytes ((char *) d, len); |
|
|
142 } |
|
|
143 |
|
|
144 static void |
|
|
145 VAX_D_double_to_IEEE_big_double (double * /* d */, int /* len */) |
|
|
146 { |
|
|
147 gripe_data_conversion ("VAX D float", "IEEE big endian format"); |
|
|
148 } |
|
|
149 |
|
|
150 static void |
|
|
151 VAX_G_double_to_IEEE_big_double (double * /* d */, int /* len */) |
|
|
152 { |
|
|
153 gripe_data_conversion ("VAX G float", "IEEE big endian format"); |
|
|
154 } |
|
|
155 |
|
|
156 static void |
|
|
157 Cray_to_IEEE_big_double (double * /* d */, int /* len */) |
|
|
158 { |
|
|
159 gripe_data_conversion ("Cray", "IEEE big endian format"); |
|
|
160 } |
|
|
161 |
|
|
162 static void |
|
|
163 IEEE_little_float_to_IEEE_big_float (float *d, int len) |
|
|
164 { |
|
|
165 swap_4_bytes ((char *) d, len); |
|
|
166 } |
|
|
167 |
|
|
168 static void |
|
|
169 VAX_D_float_to_IEEE_big_float (float * /* d */, int /* len */) |
|
|
170 { |
|
|
171 gripe_data_conversion ("VAX D float", "IEEE big endian format"); |
|
|
172 } |
|
|
173 |
|
|
174 static void |
|
|
175 VAX_G_float_to_IEEE_big_float (float * /* d */, int /* len */) |
|
|
176 { |
|
|
177 gripe_data_conversion ("VAX G float", "IEEE big endian format"); |
|
|
178 } |
|
|
179 |
|
|
180 static void |
|
|
181 Cray_to_IEEE_big_float (float * /* d */, int /* len */) |
|
|
182 { |
|
|
183 gripe_data_conversion ("Cray", "IEEE big endian format"); |
|
|
184 } |
|
|
185 |
|
|
186 static void |
|
|
187 IEEE_little_double_to_VAX_D_double (double * /* d */, int /* len */) |
|
|
188 { |
|
|
189 gripe_data_conversion ("IEEE little endian", "VAX D"); |
|
|
190 } |
|
|
191 |
|
|
192 static void |
|
|
193 IEEE_big_double_to_VAX_D_double (double * /* d */, int /* len */) |
|
|
194 { |
|
|
195 gripe_data_conversion ("IEEE big endian", "VAX D"); |
|
|
196 } |
|
|
197 |
|
|
198 static void |
|
|
199 VAX_G_double_to_VAX_D_double (double * /* d */, int /* len */) |
|
|
200 { |
|
|
201 gripe_data_conversion ("VAX G float", "VAX D"); |
|
|
202 } |
|
|
203 |
|
|
204 static void |
|
|
205 Cray_to_VAX_D_double (double * /* d */, int /* len */) |
|
|
206 { |
|
|
207 gripe_data_conversion ("Cray", "VAX D"); |
|
|
208 } |
|
|
209 |
|
|
210 static void |
|
|
211 IEEE_little_float_to_VAX_D_float (float * /* d */, int /* len */) |
|
|
212 { |
|
|
213 gripe_data_conversion ("IEEE little endian", "VAX D"); |
|
|
214 } |
|
|
215 |
|
|
216 static void |
|
|
217 IEEE_big_float_to_VAX_D_float (float * /* d */, int /* len */) |
|
|
218 { |
|
|
219 gripe_data_conversion ("IEEE big endian", "VAX D"); |
|
|
220 } |
|
|
221 |
|
|
222 static void |
|
|
223 VAX_G_float_to_VAX_D_float (float * /* d */, int /* len */) |
|
|
224 { |
|
|
225 gripe_data_conversion ("VAX G float", "VAX D"); |
|
|
226 } |
|
|
227 |
|
|
228 static void |
|
|
229 Cray_to_VAX_D_float (float * /* d */, int /* len */) |
|
|
230 { |
|
|
231 gripe_data_conversion ("Cray", "VAX D"); |
|
|
232 } |
|
|
233 |
|
|
234 static void |
|
|
235 IEEE_little_double_to_VAX_G_double (double * /* d */, int /* len */) |
|
|
236 { |
|
|
237 gripe_data_conversion ("IEEE little endian", "VAX G"); |
|
|
238 } |
|
|
239 |
|
|
240 static void |
|
|
241 IEEE_big_double_to_VAX_G_double (double * /* d */, int /* len */) |
|
|
242 { |
|
|
243 gripe_data_conversion ("IEEE big endian", "VAX G"); |
|
|
244 } |
|
|
245 |
|
|
246 static void |
|
|
247 VAX_D_double_to_VAX_G_double (double * /* d */, int /* len */) |
|
|
248 { |
|
|
249 gripe_data_conversion ("VAX D float", "VAX G"); |
|
|
250 } |
|
|
251 |
|
|
252 static void |
|
|
253 Cray_to_VAX_G_double (double * /* d */, int /* len */) |
|
|
254 { |
|
|
255 gripe_data_conversion ("VAX G float", "VAX G"); |
|
|
256 } |
|
|
257 |
|
|
258 static void |
|
|
259 IEEE_little_float_to_VAX_G_float (float * /* d */, int /* len */) |
|
|
260 { |
|
|
261 gripe_data_conversion ("IEEE little endian", "VAX G"); |
|
|
262 } |
|
|
263 |
|
|
264 static void |
|
|
265 IEEE_big_float_to_VAX_G_float (float * /* d */, int /* len */) |
|
|
266 { |
|
|
267 gripe_data_conversion ("IEEE big endian", "VAX G"); |
|
|
268 } |
|
|
269 |
|
|
270 static void |
|
|
271 VAX_D_float_to_VAX_G_float (float * /* d */, int /* len */) |
|
|
272 { |
|
|
273 gripe_data_conversion ("VAX D float", "VAX G"); |
|
|
274 } |
|
|
275 |
|
|
276 static void |
|
|
277 Cray_to_VAX_G_float (float * /* d */, int /* len */) |
|
|
278 { |
|
|
279 gripe_data_conversion ("VAX G float", "VAX G"); |
|
|
280 } |
|
|
281 |
|
|
282 void |
|
|
283 do_double_format_conversion (double *data, int len, |
|
|
284 floating_point_format fmt) |
|
|
285 { |
|
|
286 switch (native_float_format) |
|
|
287 { |
|
|
288 case OCTAVE_IEEE_LITTLE: |
|
|
289 switch (fmt) |
|
|
290 { |
|
|
291 case OCTAVE_IEEE_LITTLE: |
|
|
292 break; |
|
|
293 |
|
|
294 case OCTAVE_IEEE_BIG: |
|
|
295 IEEE_big_double_to_IEEE_little_double (data, len); |
|
|
296 break; |
|
|
297 |
|
|
298 case OCTAVE_VAX_D: |
|
|
299 VAX_D_double_to_IEEE_little_double (data, len); |
|
|
300 break; |
|
|
301 |
|
|
302 case OCTAVE_VAX_G: |
|
|
303 VAX_G_double_to_IEEE_little_double (data, len); |
|
|
304 break; |
|
|
305 |
|
|
306 case OCTAVE_CRAY: |
|
|
307 Cray_to_IEEE_little_double (data, len); |
|
|
308 break; |
|
|
309 |
|
|
310 default: |
|
|
311 gripe_unrecognized_float_fmt (); |
|
|
312 break; |
|
|
313 } |
|
|
314 break; |
|
|
315 |
|
|
316 case OCTAVE_IEEE_BIG: |
|
|
317 switch (fmt) |
|
|
318 { |
|
|
319 case OCTAVE_IEEE_LITTLE: |
|
|
320 IEEE_little_double_to_IEEE_big_double (data, len); |
|
|
321 break; |
|
|
322 |
|
|
323 case OCTAVE_IEEE_BIG: |
|
|
324 break; |
|
|
325 |
|
|
326 case OCTAVE_VAX_D: |
|
|
327 VAX_D_double_to_IEEE_big_double (data, len); |
|
|
328 break; |
|
|
329 |
|
|
330 case OCTAVE_VAX_G: |
|
|
331 VAX_G_double_to_IEEE_big_double (data, len); |
|
|
332 break; |
|
|
333 |
|
|
334 case OCTAVE_CRAY: |
|
|
335 Cray_to_IEEE_big_double (data, len); |
|
|
336 break; |
|
|
337 |
|
|
338 default: |
|
|
339 gripe_unrecognized_float_fmt (); |
|
|
340 break; |
|
|
341 } |
|
|
342 break; |
|
|
343 |
|
|
344 case OCTAVE_VAX_D: |
|
|
345 switch (fmt) |
|
|
346 { |
|
|
347 case OCTAVE_IEEE_LITTLE: |
|
|
348 IEEE_little_double_to_VAX_D_double (data, len); |
|
|
349 break; |
|
|
350 |
|
|
351 case OCTAVE_IEEE_BIG: |
|
|
352 IEEE_big_double_to_VAX_D_double (data, len); |
|
|
353 break; |
|
|
354 |
|
|
355 case OCTAVE_VAX_D: |
|
|
356 break; |
|
|
357 |
|
|
358 case OCTAVE_VAX_G: |
|
|
359 VAX_G_double_to_VAX_D_double (data, len); |
|
|
360 break; |
|
|
361 |
|
|
362 case OCTAVE_CRAY: |
|
|
363 Cray_to_VAX_D_double (data, len); |
|
|
364 break; |
|
|
365 |
|
|
366 default: |
|
|
367 gripe_unrecognized_float_fmt (); |
|
|
368 break; |
|
|
369 } |
|
|
370 break; |
|
|
371 |
|
|
372 case OCTAVE_VAX_G: |
|
|
373 switch (fmt) |
|
|
374 { |
|
|
375 case OCTAVE_IEEE_LITTLE: |
|
|
376 IEEE_little_double_to_VAX_G_double (data, len); |
|
|
377 break; |
|
|
378 |
|
|
379 case OCTAVE_IEEE_BIG: |
|
|
380 IEEE_big_double_to_VAX_G_double (data, len); |
|
|
381 break; |
|
|
382 |
|
|
383 case OCTAVE_VAX_D: |
|
|
384 VAX_D_double_to_VAX_G_double (data, len); |
|
|
385 break; |
|
|
386 |
|
|
387 case OCTAVE_VAX_G: |
|
|
388 break; |
|
|
389 |
|
|
390 case OCTAVE_CRAY: |
|
|
391 Cray_to_VAX_G_double (data, len); |
|
|
392 break; |
|
|
393 |
|
|
394 default: |
|
|
395 gripe_unrecognized_float_fmt (); |
|
|
396 break; |
|
|
397 } |
|
|
398 break; |
|
|
399 |
|
|
400 default: |
|
|
401 (*current_liboctave_error_handler) |
|
|
402 ("impossible state reached in file `%s' at line %d", |
|
|
403 __FILE__, __LINE__); |
|
|
404 break; |
|
|
405 } |
|
|
406 } |
|
|
407 |
|
|
408 void |
|
|
409 do_float_format_conversion (float *data, int len, |
|
|
410 floating_point_format fmt) |
|
|
411 { |
|
|
412 switch (native_float_format) |
|
|
413 { |
|
|
414 case OCTAVE_IEEE_LITTLE: |
|
|
415 switch (fmt) |
|
|
416 { |
|
|
417 case OCTAVE_IEEE_LITTLE: |
|
|
418 break; |
|
|
419 |
|
|
420 case OCTAVE_IEEE_BIG: |
|
|
421 IEEE_big_float_to_IEEE_little_float (data, len); |
|
|
422 break; |
|
|
423 |
|
|
424 case OCTAVE_VAX_D: |
|
|
425 VAX_D_float_to_IEEE_little_float (data, len); |
|
|
426 break; |
|
|
427 |
|
|
428 case OCTAVE_VAX_G: |
|
|
429 VAX_G_float_to_IEEE_little_float (data, len); |
|
|
430 break; |
|
|
431 |
|
|
432 case OCTAVE_CRAY: |
|
|
433 Cray_to_IEEE_little_float (data, len); |
|
|
434 break; |
|
|
435 |
|
|
436 default: |
|
|
437 gripe_unrecognized_float_fmt (); |
|
|
438 break; |
|
|
439 } |
|
|
440 break; |
|
|
441 |
|
|
442 case OCTAVE_IEEE_BIG: |
|
|
443 switch (fmt) |
|
|
444 { |
|
|
445 case OCTAVE_IEEE_LITTLE: |
|
|
446 IEEE_little_float_to_IEEE_big_float (data, len); |
|
|
447 break; |
|
|
448 |
|
|
449 case OCTAVE_IEEE_BIG: |
|
|
450 break; |
|
|
451 |
|
|
452 case OCTAVE_VAX_D: |
|
|
453 VAX_D_float_to_IEEE_big_float (data, len); |
|
|
454 break; |
|
|
455 |
|
|
456 case OCTAVE_VAX_G: |
|
|
457 VAX_G_float_to_IEEE_big_float (data, len); |
|
|
458 break; |
|
|
459 |
|
|
460 case OCTAVE_CRAY: |
|
|
461 Cray_to_IEEE_big_float (data, len); |
|
|
462 break; |
|
|
463 |
|
|
464 default: |
|
|
465 gripe_unrecognized_float_fmt (); |
|
|
466 break; |
|
|
467 } |
|
|
468 break; |
|
|
469 |
|
|
470 case OCTAVE_VAX_D: |
|
|
471 switch (fmt) |
|
|
472 { |
|
|
473 case OCTAVE_IEEE_LITTLE: |
|
|
474 IEEE_little_float_to_VAX_D_float (data, len); |
|
|
475 break; |
|
|
476 |
|
|
477 case OCTAVE_IEEE_BIG: |
|
|
478 IEEE_big_float_to_VAX_D_float (data, len); |
|
|
479 break; |
|
|
480 |
|
|
481 case OCTAVE_VAX_D: |
|
|
482 break; |
|
|
483 |
|
|
484 case OCTAVE_VAX_G: |
|
|
485 VAX_G_float_to_VAX_D_float (data, len); |
|
|
486 break; |
|
|
487 |
|
|
488 case OCTAVE_CRAY: |
|
|
489 Cray_to_VAX_D_float (data, len); |
|
|
490 break; |
|
|
491 |
|
|
492 default: |
|
|
493 gripe_unrecognized_float_fmt (); |
|
|
494 break; |
|
|
495 } |
|
|
496 break; |
|
|
497 |
|
|
498 case OCTAVE_VAX_G: |
|
|
499 switch (fmt) |
|
|
500 { |
|
|
501 case OCTAVE_IEEE_LITTLE: |
|
|
502 IEEE_little_float_to_VAX_G_float (data, len); |
|
|
503 break; |
|
|
504 |
|
|
505 case OCTAVE_IEEE_BIG: |
|
|
506 IEEE_big_float_to_VAX_G_float (data, len); |
|
|
507 break; |
|
|
508 |
|
|
509 case OCTAVE_VAX_D: |
|
|
510 VAX_D_float_to_VAX_G_float (data, len); |
|
|
511 break; |
|
|
512 |
|
|
513 case OCTAVE_VAX_G: |
|
|
514 break; |
|
|
515 |
|
|
516 case OCTAVE_CRAY: |
|
|
517 Cray_to_VAX_G_float (data, len); |
|
|
518 break; |
|
|
519 |
|
|
520 default: |
|
|
521 gripe_unrecognized_float_fmt (); |
|
|
522 break; |
|
|
523 } |
|
|
524 break; |
|
|
525 |
|
|
526 default: |
|
|
527 (*current_liboctave_error_handler) |
|
|
528 ("impossible state reached in file `%s' at line %d", |
|
|
529 __FILE__, __LINE__); |
|
|
530 break; |
|
|
531 } |
|
|
532 } |
|
|
533 |
|
|
534 void |
|
|
535 read_doubles (istream& is, double *data, save_type type, int len, |
|
|
536 int swap, floating_point_format fmt) |
|
|
537 { |
|
|
538 switch (type) |
|
|
539 { |
|
|
540 case LS_U_CHAR: |
|
|
541 LS_DO_READ (unsigned char, swap, data, 1, len, is); |
|
|
542 break; |
|
|
543 |
|
|
544 case LS_U_SHORT: |
|
|
545 LS_DO_READ (unsigned TWO_BYTE_INT, swap, data, 2, len, is); |
|
|
546 break; |
|
|
547 |
|
|
548 case LS_U_INT: |
|
|
549 LS_DO_READ (unsigned FOUR_BYTE_INT, swap, data, 4, len, is); |
|
|
550 break; |
|
|
551 |
|
|
552 case LS_CHAR: |
|
|
553 LS_DO_READ (signed char, swap, data, 1, len, is); |
|
|
554 break; |
|
|
555 |
|
|
556 case LS_SHORT: |
|
|
557 LS_DO_READ (TWO_BYTE_INT, swap, data, 2, len, is); |
|
|
558 break; |
|
|
559 |
|
|
560 case LS_INT: |
|
|
561 LS_DO_READ (FOUR_BYTE_INT, swap, data, 4, len, is); |
|
|
562 break; |
|
|
563 |
|
|
564 case LS_FLOAT: |
|
|
565 { |
|
|
566 volatile float *ptr = (float *) data; |
|
|
567 is.read (data, 4 * len); |
|
|
568 do_float_format_conversion ((float *) data, len, fmt); |
|
|
569 float tmp = ptr[0]; |
|
|
570 for (int i = len - 1; i > 0; i--) |
|
|
571 data[i] = ptr[i]; |
|
|
572 data[0] = tmp; |
|
|
573 } |
|
|
574 break; |
|
|
575 |
|
|
576 case LS_DOUBLE: |
|
|
577 is.read (data, 8 * len); |
|
|
578 do_double_format_conversion (data, len, fmt); |
|
|
579 break; |
|
|
580 |
|
|
581 default: |
|
|
582 is.clear (ios::failbit|is.rdstate ()); |
|
|
583 break; |
|
|
584 } |
|
|
585 } |
|
|
586 |
|
|
587 void |
|
|
588 write_doubles (ostream& os, const double *data, save_type type, int len) |
|
|
589 { |
|
|
590 switch (type) |
|
|
591 { |
|
|
592 case LS_U_CHAR: |
|
|
593 LS_DO_WRITE (unsigned char, data, 1, len, os); |
|
|
594 break; |
|
|
595 |
|
|
596 case LS_U_SHORT: |
|
|
597 LS_DO_WRITE (unsigned TWO_BYTE_INT, data, 2, len, os); |
|
|
598 break; |
|
|
599 |
|
|
600 case LS_U_INT: |
|
|
601 LS_DO_WRITE (unsigned FOUR_BYTE_INT, data, 4, len, os); |
|
|
602 break; |
|
|
603 |
|
|
604 case LS_CHAR: |
|
|
605 LS_DO_WRITE (signed char, data, 1, len, os); |
|
|
606 break; |
|
|
607 |
|
|
608 case LS_SHORT: |
|
|
609 LS_DO_WRITE (TWO_BYTE_INT, data, 2, len, os); |
|
|
610 break; |
|
|
611 |
|
|
612 case LS_INT: |
|
|
613 LS_DO_WRITE (FOUR_BYTE_INT, data, 4, len, os); |
|
|
614 break; |
|
|
615 |
|
|
616 case LS_FLOAT: |
|
|
617 LS_DO_WRITE (float, data, 4, len, os); |
|
|
618 break; |
|
|
619 |
|
|
620 case LS_DOUBLE: |
|
|
621 { |
|
|
622 char tmp_type = (char) type; |
|
|
623 os.write (&tmp_type, 1); |
|
|
624 os.write (data, 8 * len); |
|
|
625 } |
|
|
626 break; |
|
|
627 |
|
|
628 default: |
|
|
629 (*current_liboctave_error_handler) |
|
|
630 ("unrecognized data format requested"); |
|
|
631 break; |
|
|
632 } |
|
|
633 } |
|
|
634 |
|
|
635 /* |
|
|
636 ;;; Local Variables: *** |
|
|
637 ;;; mode: C++ *** |
|
|
638 ;;; End: *** |
|
|
639 */ |
