/[public]/psiconv/trunk/lib/psiconv/parse_sheet.c
ViewVC logotype

Contents of /psiconv/trunk/lib/psiconv/parse_sheet.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 128 - (show annotations)
Wed Jul 18 12:24:08 2001 UTC (22 years, 8 months ago) by frodo
File MIME type: text/plain
File size: 38564 byte(s)
(Frodo) Sheet line defaults added

1 /*
2 parse_sheet.c - Part of psiconv, a PSION 5 file formats converter
3 Copyright (c) 2001 Frodo Looijaard <frodol@dds.nl>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20 #include "config.h"
21 #include "compat.h"
22
23 #include <stdlib.h>
24
25 #include "parse_routines.h"
26 #include "error.h"
27
28 static psiconv_sheet_cell_layout psiconv_basic_cell_layout(void)
29 {
30 psiconv_sheet_cell_layout result;
31 if (!(result = malloc(sizeof(*result))))
32 goto ERROR1;
33 if (!(result->character = psiconv_basic_character_layout()))
34 goto ERROR2;
35 if (!(result->paragraph = psiconv_basic_paragraph_layout()))
36 goto ERROR3;
37 if (!(result->numberformat = malloc(sizeof(*result->numberformat))))
38 goto ERROR4;
39 result->numberformat->code = psiconv_numberformat_general;
40 result->numberformat->decimal = 2;
41 return result;
42 ERROR4:
43 psiconv_free_paragraph_layout(result->paragraph);
44 ERROR3:
45 psiconv_free_character_layout(result->character);
46 ERROR2:
47 free(result);
48 ERROR1:
49 return NULL;
50 }
51
52 static psiconv_sheet_cell_layout psiconv_clone_cell_layout
53 (psiconv_sheet_cell_layout original)
54 {
55 psiconv_sheet_cell_layout result;
56 if (!(result = malloc(sizeof(*result))))
57 goto ERROR1;
58 if (!(result->character =
59 psiconv_clone_character_layout(original->character)))
60 goto ERROR2;
61 if (!(result->paragraph =
62 psiconv_clone_paragraph_layout(original->paragraph)))
63 goto ERROR3;
64 if (!(result->numberformat = malloc(sizeof(*result->numberformat))))
65 goto ERROR4;
66 result->numberformat->code = original->numberformat->code;
67 result->numberformat->decimal = original->numberformat->decimal;
68 return result;
69 ERROR4:
70 psiconv_free_paragraph_layout(result->paragraph);
71 ERROR3:
72 psiconv_free_character_layout(result->character);
73 ERROR2:
74 free(result);
75 ERROR1:
76 return NULL;
77 }
78
79 int psiconv_parse_sheet_numberformat(const psiconv_buffer buf, int lev,
80 psiconv_u32 off, int *length,
81 psiconv_sheet_numberformat result)
82 {
83 int res=0;
84 int len=0;
85 psiconv_u8 temp;
86
87 psiconv_progress(lev+1,off,"Going to read a sheet numberformat");
88
89 psiconv_progress(lev+2,off+len,
90 "Going to read the initial byte (%02x expected)",0x02);
91 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
92 if (res)
93 goto ERROR1;
94 if (temp != 0x02) {
95 psiconv_warn(lev+2,off+len,
96 "Sheet numberformat initial byte unknown value (ignored)");
97 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
98 }
99 len ++;
100
101 psiconv_progress(lev+2,off+len, "Going to read the code byte");
102 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
103 if (res)
104 goto ERROR1;
105 psiconv_debug(lev+2,off+len,"Code: %02x",temp);
106 if (temp == 0x00)
107 result->code = psiconv_numberformat_general;
108 else if (temp == 0x02)
109 result->code = psiconv_numberformat_fixeddecimal;
110 else if (temp == 0x04)
111 result->code = psiconv_numberformat_scientific;
112 else if (temp == 0x06)
113 result->code = psiconv_numberformat_currency;
114 else if (temp == 0x08)
115 result->code = psiconv_numberformat_percent;
116 else if (temp == 0x0A)
117 result->code = psiconv_numberformat_triads;
118 else if (temp == 0x0C)
119 result->code = psiconv_numberformat_boolean;
120 else if (temp == 0x0E)
121 result->code = psiconv_numberformat_text;
122 else if (temp == 0x10)
123 result->code = psiconv_numberformat_date_dmm;
124 else if (temp == 0x12)
125 result->code = psiconv_numberformat_date_mmd;
126 else if (temp == 0x14)
127 result->code = psiconv_numberformat_date_ddmmyy;
128 else if (temp == 0x16)
129 result->code = psiconv_numberformat_date_mmddyy;
130 else if (temp == 0x18)
131 result->code = psiconv_numberformat_date_yymmdd;
132 else if (temp == 0x1A)
133 result->code = psiconv_numberformat_date_dmmm;
134 else if (temp == 0x1C)
135 result->code = psiconv_numberformat_date_dmmmyy;
136 else if (temp == 0x1E)
137 result->code = psiconv_numberformat_date_ddmmmyy;
138 else if (temp == 0x20)
139 result->code = psiconv_numberformat_date_mmm;
140 else if (temp == 0x22)
141 result->code = psiconv_numberformat_date_monthname;
142 else if (temp == 0x24)
143 result->code = psiconv_numberformat_date_mmmyy;
144 else if (temp == 0x26)
145 result->code = psiconv_numberformat_date_monthnameyy;
146 else if (temp == 0x28)
147 result->code = psiconv_numberformat_date_monthnamedyyyy;
148 else if (temp == 0x2A)
149 result->code = psiconv_numberformat_datetime_ddmmyyyyhhii;
150 else if (temp == 0x2C)
151 result->code = psiconv_numberformat_datetime_ddmmyyyyHHii;
152 else if (temp == 0x2E)
153 result->code = psiconv_numberformat_datetime_mmddyyyyhhii;
154 else if (temp == 0x30)
155 result->code = psiconv_numberformat_datetime_mmddyyyyHHii;
156 else if (temp == 0x32)
157 result->code = psiconv_numberformat_datetime_yyyymmddhhii;
158 else if (temp == 0x34)
159 result->code = psiconv_numberformat_datetime_yyyymmddHHii;
160 else if (temp == 0x36)
161 result->code = psiconv_numberformat_time_hhii;
162 else if (temp == 0x38)
163 result->code = psiconv_numberformat_time_hhiiss;
164 else if (temp == 0x3A)
165 result->code = psiconv_numberformat_time_HHii;
166 else if (temp == 0x3C)
167 result->code = psiconv_numberformat_time_HHiiss;
168 else {
169 psiconv_warn(lev+2,off+len,"Unknown number format (assumed general)");
170 result->code = psiconv_numberformat_general;
171 }
172 len ++;
173
174 psiconv_progress(lev+2,off+len, "Going to read the number of decimals");
175 result->decimal = psiconv_read_u8(buf,lev+2,off+len,&res) >> 1;
176 if (res)
177 goto ERROR1;
178 psiconv_debug(lev+2,off+len,"Decimals: %d",result->decimal);
179 len ++;
180
181 if (length)
182 *length = len;
183
184 psiconv_progress(lev,off+len-1,
185 "End of sheet number format (total length: %08x)", len);
186 return 0;
187
188 ERROR1:
189 psiconv_warn(lev+1,off,"Reading of Sheet Number Format failed");
190 if (length)
191 *length = 0;
192 if (!res)
193 return -PSICONV_E_NOMEM;
194 else
195 return res;
196 }
197
198 int psiconv_parse_sheet_status_section(const psiconv_buffer buf, int lev,
199 psiconv_u32 off, int *length,
200 psiconv_sheet_status_section *result)
201 {
202 int res=0;
203 int len=0;
204 psiconv_u32 temp;
205 int leng;
206
207 psiconv_progress(lev+1,off,"Going to read the sheet status section");
208 if (!(*result = malloc(sizeof(**result))))
209 goto ERROR1;
210
211 psiconv_progress(lev+2,off+len,
212 "Going to read the initial byte (%02x expected)",0x02);
213 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
214 if (res)
215 goto ERROR2;
216 if (temp != 0x02) {
217 psiconv_warn(lev+2,off+len,
218 "Sheet status section initial byte unknown value (ignored)");
219 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
220 }
221 len ++;
222
223 psiconv_progress(lev+2,off+len,
224 "Going to read the cursor row");
225 (*result)->cursor_row = psiconv_read_u32(buf,lev+2,off + len,&res);
226 if (res)
227 goto ERROR2;
228 psiconv_debug(lev+2,off+len,"Cursor row: %08x",
229 (*result)->cursor_row);
230 len += 0x04;
231
232 psiconv_progress(lev+2,off+len,
233 "Going to read the cursor column");
234 (*result)->cursor_column = psiconv_read_u32(buf,lev+2,off + len,&res);
235 if (res)
236 goto ERROR2;
237 psiconv_debug(lev+2,off+len,"Cursor column: %08x",
238 (*result)->cursor_column);
239 len += 0x04;
240
241 psiconv_progress(lev+2,off+len,"Going to read initially display graph");
242 if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,
243 &(*result)->show_graph)))
244 goto ERROR2;
245 len += leng;
246
247 psiconv_progress(lev+2,off+len,
248 "Going to read the toolbar status byte");
249 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
250 if (res)
251 goto ERROR2;
252
253 (*result)->show_side_sheet_toolbar = temp&0x01 ? psiconv_bool_true :
254 psiconv_bool_false;
255 psiconv_debug(lev+2,off+len,"Show side sheet toolbar: %02x",
256 (*result)->show_side_sheet_toolbar);
257 (*result)->show_top_sheet_toolbar = temp&0x02 ? psiconv_bool_true :
258 psiconv_bool_false;
259 psiconv_debug(lev+2,off+len,"Show top sheet toolbar: %02x",
260 (*result)->show_top_sheet_toolbar);
261 (*result)->show_side_graph_toolbar = temp&0x04 ? psiconv_bool_true :
262 psiconv_bool_false;
263 psiconv_debug(lev+2,off+len,"Show side graph toolbar: %02x",
264 (*result)->show_side_graph_toolbar);
265 (*result)->show_top_graph_toolbar = temp&0x08 ? psiconv_bool_true :
266 psiconv_bool_false;
267 psiconv_debug(lev+2,off+len,"Show top graph toolbar: %02x",
268 (*result)->show_top_graph_toolbar);
269 if (temp & 0xf0) {
270 psiconv_warn(lev+2,off+len,"Sheet status section toolbar byte "
271 "flags contains unknown flags (ignored)");
272 psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
273 }
274 len ++;
275
276 psiconv_progress(lev+2,off+len,
277 "Going to read the scrollbar status byte");
278 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
279 if (res)
280 goto ERROR2;
281 if ((temp & 0x03) == 0x03) {
282 psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "
283 "flags contains unknown flags (ignored)");
284 psiconv_debug(lev+2,off+len,"Unknown flag: %02x",temp & 0x03);
285 }
286 (*result)->show_horizontal_scrollbar = (temp&0x03) == 1? psiconv_triple_off :
287 (temp&0x03) == 2? psiconv_triple_auto:
288 psiconv_triple_on;
289 psiconv_debug(lev+2,off+len,"Show horizontal scrollbar: %02x",
290 (*result)->show_horizontal_scrollbar);
291 if ((temp & 0x0c) == 0x0c) {
292 psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "
293 "flags contains unknown flags (ignored)");
294 psiconv_debug(lev+2,off+len,"Unknown flag: %02x",temp & 0x0c);
295 }
296 (*result)->show_vertical_scrollbar = (temp&0x0c) ==0x04? psiconv_triple_off:
297 (temp&0x0c) ==0x08? psiconv_triple_auto:
298 psiconv_triple_on;
299 psiconv_debug(lev+2,off+len,"Show vertical scrollbar: %02x",
300 (*result)->show_vertical_scrollbar);
301 if (temp & 0xf0) {
302 psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "
303 "flags contains unknown flags (ignored)");
304 psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
305 }
306 len ++;
307
308 psiconv_progress(lev+2,off+len,
309 "Going to read an unknown byte (%02x expected)",0x00);
310 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
311 if (res)
312 goto ERROR2;
313 if (temp != 0x00) {
314 psiconv_warn(lev+2,off+len,
315 "Sheet status section unknown byte unknown value (ignored)");
316 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
317 }
318 len ++;
319
320 psiconv_progress(lev+2,off+len,"Going to read sheet display size");
321 (*result)->sheet_display_size = psiconv_read_u32(buf,lev+2,off + len,&res);
322 if (res)
323 goto ERROR2;
324 psiconv_debug(lev+2,off+len,"Sheet display size: %08x",
325 (*result)->sheet_display_size);
326 len += 0x04;
327
328 psiconv_progress(lev+2,off+len,"Going to read graph display size");
329 (*result)->graph_display_size = psiconv_read_u32(buf,lev+2,off + len,&res);
330 if (res)
331 goto ERROR2;
332 psiconv_debug(lev+2,off+len,"Graph display size: %08x",
333 (*result)->graph_display_size);
334 len += 0x04;
335
336 if (length)
337 *length = len;
338
339 psiconv_progress(lev,off+len-1,
340 "End of sheet status section (total length: %08x)", len);
341 return 0;
342
343 ERROR2:
344 free (*result);
345 ERROR1:
346 psiconv_warn(lev+1,off,"Reading of Sheet Status Section failed");
347 if (length)
348 *length = 0;
349 if (!res)
350 return -PSICONV_E_NOMEM;
351 else
352 return res;
353 }
354
355 int psiconv_parse_sheet_workbook_section(const psiconv_buffer buf, int lev,
356 psiconv_u32 off, int *length,
357 psiconv_sheet_workbook_section *result)
358 {
359 int res=0;
360 psiconv_u32 temp,formulas_off,worksheets_off;
361 int len=0;
362
363 psiconv_progress(lev+1,off,"Going to read the sheet workbook section");
364 if (!(*result = malloc(sizeof(**result))))
365 goto ERROR1;
366
367 psiconv_progress(lev+2,off+len,
368 "Going to read the initial byte (%02x expected)",0x04);
369 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
370 if (res)
371 goto ERROR2;
372 if (temp != 0x04) {
373 psiconv_warn(lev+2,off+len,
374 "Sheet workbook section initial byte unknown value (ignored)");
375 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
376 }
377 len ++;
378
379 psiconv_progress(lev+2,off+len,
380 "Going to read the offset of the 1st ??? Section");
381 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
382 if (res)
383 goto ERROR2;
384 psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
385 len += 4;
386
387 psiconv_progress(lev+2,off+len,
388 "Going to read the offset of the Formulas List");
389 formulas_off = psiconv_read_u32(buf,lev+2,off+len,&res);
390 if (res)
391 goto ERROR2;
392 psiconv_debug(lev+2,off+len,"Offset: %04x",formulas_off);
393 len += 4;
394
395 psiconv_progress(lev+2,off+len,
396 "Going to read the offset of the Worksheet List");
397 worksheets_off = psiconv_read_u32(buf,lev+2,off+len,&res);
398 if (res)
399 goto ERROR2;
400 psiconv_debug(lev+2,off+len,"Offset: %04x",worksheets_off);
401 len += 4;
402
403 psiconv_progress(lev+2,off+len,
404 "Going to read the offset of the 4th ??? Section");
405 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
406 if (res)
407 goto ERROR2;
408 psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
409 len += 4;
410
411 psiconv_progress(lev+2,off+len,"Going to read the formulas list");
412 if ((res = psiconv_parse_sheet_formula_table(buf,lev+2,formulas_off,NULL,
413 &(*result)->formulas)))
414 goto ERROR2;
415
416 psiconv_progress(lev+2,off+len,"Going to read the worksheet list");
417 if ((res = psiconv_parse_sheet_worksheet_list(buf,lev+2,worksheets_off,
418 NULL,&(*result)->worksheets)))
419 goto ERROR2;
420
421
422 if (length)
423 *length = len;
424
425 psiconv_progress(lev,off+len-1,
426 "End of sheet workbook section (total length: %08x)", len);
427 return 0;
428
429 ERROR2:
430 free (*result);
431 ERROR1:
432 psiconv_warn(lev+1,off,"Reading of Sheet Workbook Section failed");
433 if (length)
434 *length = 0;
435 if (!res)
436 return -PSICONV_E_NOMEM;
437 else
438 return res;
439 }
440
441 int psiconv_parse_sheet_formula_table(const psiconv_buffer buf, int lev,
442 psiconv_u32 off, int *length,
443 psiconv_formula_list *result)
444 {
445 int res=0;
446 int len=0;
447 psiconv_u32 temp;
448 psiconv_formula formula;
449 psiconv_u32 listlen,i;
450 int leng;
451
452 psiconv_progress(lev+1,off,"Going to read the sheet formula table");
453 if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s))))
454 goto ERROR1;
455
456 psiconv_progress(lev+2,off+len,
457 "Going to read the initial byte (%02x expected)",0x02);
458 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
459 if (res)
460 goto ERROR2;
461 if (temp != 0x02) {
462 psiconv_warn(lev+2,off+len,
463 "Sheet formula table initial byte unknown value (ignored)");
464 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
465 }
466 len ++;
467
468 psiconv_progress(lev+2,off+len,
469 "Going to read the number of formulas");
470 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
471 if (res)
472 goto ERROR2;
473 psiconv_debug(lev+2,off+len,"Number of formulas: %d",listlen);
474 len += leng;
475
476 psiconv_progress(lev+2,off+len,"Going to read all formulas");
477 for (i = 0; i < listlen; i++) {
478 psiconv_progress(lev+3,off+len,"Going to read formula %d",i);
479 if ((res = psiconv_parse_formula(buf,lev+3,off+len,&leng,&formula)))
480 goto ERROR2;
481 if ((res = psiconv_list_add(*result,formula)))
482 goto ERROR3;
483 len += leng;
484 }
485
486 if (length)
487 *length = len;
488
489 psiconv_progress(lev,off+len-1,
490 "End of sheet formula table (total length: %08x)", len);
491 return 0;
492
493 ERROR3:
494 psiconv_free_formula(formula);
495 ERROR2:
496 psiconv_list_free(*result);
497 ERROR1:
498 psiconv_warn(lev+1,off,"Reading of Sheet Formula Table failed");
499 if (length)
500 *length = 0;
501 if (!res)
502 return -PSICONV_E_NOMEM;
503 else
504 return res;
505 }
506
507 int psiconv_parse_sheet_cell(const psiconv_buffer buf, int lev,
508 psiconv_u32 off, int *length,
509 psiconv_sheet_cell *result,
510 const psiconv_sheet_cell_layout default_layout,
511 const psiconv_sheet_line_list row_default_layouts,
512 const psiconv_sheet_line_list col_default_layouts)
513 {
514 int res=0;
515 int len=0;
516 psiconv_u32 temp;
517 psiconv_bool_t has_layout;
518 int leng;
519
520 psiconv_progress(lev+1,off,"Going to read a sheet cell structure");
521 if (!(*result = malloc(sizeof(**result))))
522 goto ERROR1;
523
524 (*result)->layout = NULL;
525 (*result)->type = psiconv_cell_blank;
526
527 psiconv_progress(lev+2,off+len,"Going to read the cell position");
528 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
529 if (res)
530 goto ERROR2;
531 len ++;
532 temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 8;
533 if (res)
534 goto ERROR2;
535 len ++;
536 temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 16;
537 if (res)
538 goto ERROR2;
539 len ++;
540 (*result)->column = (temp >> 2) & 0xFF;
541 (*result)->row = (temp >> 10) & 0x3FFF;
542 psiconv_debug(lev+2,off+len,"Cell position is col:%02x row:%04x",
543 (*result)->column,(*result)->row);
544 if (temp & 0x03) {
545 psiconv_warn(lev+2,off+len,"Unknown flags in cell position (ignored)");
546 psiconv_debug(lev+2,off+len,"Flags: %02x",temp & 0x03);
547 }
548
549 psiconv_progress(lev+2,off+len,"Going to read the cell type");
550 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
551 if (res)
552 goto ERROR2;
553 len ++;
554 (*result)->type = (temp >> 5) & 0x07;
555 (*result)->calculated = (temp & 0x08)?psiconv_bool_true:psiconv_bool_false;
556 has_layout = (temp & 0x10)?psiconv_bool_true:psiconv_bool_false;
557
558 psiconv_progress(lev+2,off+len,"Going to read the cell value");
559 if ((*result)->type == psiconv_cell_blank) {
560 psiconv_debug(lev+2,off+len,"Cell type is blank: no value given.");
561 } else if ((*result)->type == psiconv_cell_int) {
562 psiconv_progress(lev+2,off+len,"Going to read an integer");
563 (*result)->data.dat_int = psiconv_read_u32(buf,lev+2,off+len,&res);
564 if (res)
565 goto ERROR2;
566 len += 4;
567 psiconv_debug(lev+2,off+len,"Cell contents: %ld",(*result)->data.dat_int);
568
569 } else if ((*result)->type == psiconv_cell_bool) {
570 psiconv_progress(lev+2,off+len,"Going to read a boolean");
571 if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,
572 &(*result)->data.dat_bool)))
573 goto ERROR2;
574 psiconv_debug(lev+2,off+len,"Cell contents: %01x",temp);
575 (*result)->data.dat_bool = temp?psiconv_bool_true:psiconv_bool_false;
576 len += leng;
577 } else if ((*result)->type == psiconv_cell_error) {
578 psiconv_progress(lev+2,off+len,"Going to read the error code");
579 temp = psiconv_read_u16(buf,lev+2,off+len,&res);
580 if (res)
581 goto ERROR2;
582 if (temp == 0)
583 (*result)->data.dat_error = psiconv_sheet_error_none;
584 else if (temp == 1)
585 (*result)->data.dat_error = psiconv_sheet_error_null;
586 else if (temp == 2)
587 (*result)->data.dat_error = psiconv_sheet_error_divzero;
588 else if (temp == 3)
589 (*result)->data.dat_error = psiconv_sheet_error_value;
590 else if (temp == 4)
591 (*result)->data.dat_error = psiconv_sheet_error_reference;
592 else if (temp == 5)
593 (*result)->data.dat_error = psiconv_sheet_error_name;
594 else if (temp == 6)
595 (*result)->data.dat_error = psiconv_sheet_error_number;
596 else if (temp == 7)
597 (*result)->data.dat_error = psiconv_sheet_error_notavail;
598 else {
599 psiconv_warn(lev+2,off+len,"Unknown error code (default assumed)");
600 psiconv_debug(lev+2,off+len,"Error code: %04x",temp);
601 (*result)->data.dat_error = psiconv_sheet_error_none;
602 }
603 psiconv_debug(lev+2,off+len,"Cell contents: %04x",
604 (*result)->data.dat_error);
605 len += 2;
606 } else if ((*result)->type == psiconv_cell_float) {
607 psiconv_progress(lev+2,off+len,"Going to read a float");
608 (*result)->data.dat_float =
609 psiconv_read_float(buf,lev+2,off+len,&leng,&res);
610 if (res)
611 goto ERROR2;
612 psiconv_debug(lev+2,off+len,"Cell contents: %f",(*result)->data.dat_float);
613 len += leng;
614 } else if ((*result)->type == psiconv_cell_string) {
615 psiconv_progress(lev+2,off+len,"Going to read a string");
616 (*result)->data.dat_string =
617 psiconv_read_string(buf,lev+2,off+len,&leng,&res);
618 if (res)
619 goto ERROR2;
620 psiconv_debug(lev+2,off+len,"Cell contents: `%s'",
621 (*result)->data.dat_string);
622 len += leng;
623 } else {
624 psiconv_warn(lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type);
625 res = PSICONV_E_PARSE;
626 goto ERROR2;
627 }
628
629 if (!((*result)->layout = psiconv_clone_cell_layout(
630 psiconv_get_default_layout(row_default_layouts,
631 col_default_layouts,
632 default_layout,
633 (*result)->row,
634 (*result)->column))))
635 goto ERROR2;
636 if (has_layout) {
637 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,
638 &leng,(*result)->layout)))
639 goto ERROR2;
640 len += leng;
641 }
642
643 if ((*result)->calculated) {
644 psiconv_progress(lev+2,off+len,"Going to read the cell formula reference");
645 temp = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
646 if (res)
647 goto ERROR2;
648 psiconv_debug(lev+2,off+len,"Cell formula reference: %d",temp);
649 len += leng;
650 (*result)->ref_formula = temp;
651 }
652
653 if (length)
654 *length = len;
655
656 psiconv_progress(lev,off+len-1,
657 "End of sheet cell structure (total length: %08x)", len);
658 return 0;
659
660 ERROR2:
661 psiconv_free_sheet_cell(*result);
662 ERROR1:
663 psiconv_warn(lev+1,off,"Reading of Sheet Cell Structure failed");
664 if (length)
665 *length = 0;
666 if (!res)
667 return -PSICONV_E_NOMEM;
668 else
669 return res;
670 }
671
672 int psiconv_parse_sheet_cell_list(const psiconv_buffer buf, int lev,
673 psiconv_u32 off, int *length,
674 psiconv_sheet_cell_list *result,
675 const psiconv_sheet_cell_layout default_layout,
676 const psiconv_sheet_line_list row_default_layouts,
677 const psiconv_sheet_line_list col_default_layouts)
678 {
679 int res=0;
680 int len=0;
681 psiconv_u32 temp;
682 psiconv_sheet_cell cell;
683 psiconv_u32 listlen,i;
684 int leng;
685
686 psiconv_progress(lev+1,off,"Going to read the sheet cell list");
687 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_cell_s))))
688 goto ERROR1;
689
690 psiconv_progress(lev+2,off+len,
691 "Going to read the initial byte (%02x expected)",0x02);
692 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
693 if (res)
694 goto ERROR2;
695 if (temp != 0x02) {
696 psiconv_warn(lev+2,off+len,
697 "Sheet cell list initial byte unknown value (ignored)");
698 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
699 }
700 len ++;
701
702 psiconv_progress(lev+2,off+len,
703 "Going to read the initial byte (%02x expected)",0x00);
704 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
705 if (res)
706 goto ERROR2;
707 if (temp != 0x00) {
708 psiconv_warn(lev+2,off+len,
709 "Sheet cell list initial byte unknown value (ignored)");
710 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
711 }
712 len ++;
713
714 psiconv_progress(lev+2,off+len,
715 "Going to read the number of defined cells");
716 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
717 if (res)
718 goto ERROR2;
719 psiconv_debug(lev+2,off+len,"Number of defined cells: %d",listlen);
720 len += leng;
721
722 psiconv_progress(lev+2,off+len,"Going to read all cells");
723 for (i = 0; i < listlen; i++) {
724 psiconv_progress(lev+3,off+len,"Going to read cell %d",i);
725 if ((res = psiconv_parse_sheet_cell(buf,lev+3,off+len,&leng,&cell,
726 default_layout,row_default_layouts,
727 col_default_layouts)))
728 goto ERROR2;
729 if ((res = psiconv_list_add(*result,cell)))
730 goto ERROR3;
731 free(cell);
732 len += leng;
733 }
734
735 if (length)
736 *length = len;
737
738 psiconv_progress(lev,off+len-1,
739 "End of sheet cell list (total length: %08x)", len);
740 return 0;
741
742 ERROR3:
743 psiconv_free_sheet_cell(cell);
744 ERROR2:
745 psiconv_free_sheet_cell_list(*result);
746 ERROR1:
747 psiconv_warn(lev+1,off,"Reading of Sheet Cells List failed");
748 if (length)
749 *length = 0;
750 if (!res)
751 return -PSICONV_E_NOMEM;
752 else
753 return res;
754 }
755
756
757 int psiconv_parse_sheet_worksheet_list( const psiconv_buffer buf, int lev,
758 psiconv_u32 off, int *length,
759 psiconv_sheet_worksheet_list *result)
760 {
761 psiconv_sheet_worksheet worksheet;
762 int res=0;
763 int len=0;
764 psiconv_u8 temp;
765 psiconv_u32 offset;
766 int leng,i,nr;
767
768 psiconv_progress(lev+1,off,"Going to read the worksheet list");
769 if (!(*result = psiconv_list_new(sizeof(*worksheet))))
770 goto ERROR1;
771
772 psiconv_progress(lev+2,off+len,
773 "Going to read the initial bytes (%02x expected)",0x02);
774 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
775 if (res)
776 goto ERROR2;
777 if (temp != 0x02) {
778 psiconv_warn(lev+2,off+len,
779 "Sheet worksheet list initial byte unknown value (ignored)");
780 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
781 }
782 len ++;
783
784 psiconv_progress(lev+2,off+len,"Going to read the list length");
785 nr = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
786 if (res)
787 goto ERROR2;
788 psiconv_debug(lev+2,off+len,"Length: %02x",nr);
789 len += leng;
790
791 psiconv_progress(lev+2,off+len,"Going to read the list");
792 for (i=0 ; i < nr; i++) {
793 psiconv_progress(lev+3,off+len,"Going to read element %d",i);
794 psiconv_progress(lev+4,off+len,
795 "Going to read the initial byte (%02x expected)",0x00);
796 temp = psiconv_read_u8(buf,lev+4,off+len,&res);
797 if (res)
798 goto ERROR2;
799 if (temp != 0x00) {
800 psiconv_warn(lev+4,off+len,
801 "Sheet worksheet element initial byte unknown value (ignored)");
802 psiconv_debug(lev+4,off+len,"Initial byte: %02x",temp);
803 }
804 len ++;
805
806 psiconv_progress(lev+4,off+len,"Going to read the worksheet offset");
807 offset = psiconv_read_u32(buf,lev+2,off+len,&res);
808 if (res)
809 goto ERROR2;
810 psiconv_debug(lev+4,off+len,"Offset: %08x",offset);
811 len += 4;
812
813 if ((res = psiconv_parse_sheet_worksheet(buf,lev+4,offset,NULL,
814 &worksheet)))
815 goto ERROR2;
816 if ((res = psiconv_list_add(*result,worksheet)))
817 goto ERROR3;
818 free(worksheet);
819 }
820
821 if (length)
822 *length = len;
823
824 psiconv_progress(lev,off+len-1,
825 "End of worksheet list (total length: %08x)", len);
826
827 return 0;
828
829 ERROR3:
830 psiconv_free_sheet_worksheet(worksheet);
831 ERROR2:
832 psiconv_free_sheet_worksheet_list(*result);
833 ERROR1:
834 psiconv_warn(lev+1,off,"Reading of worksheet list failed");
835 if (length)
836 *length = 0;
837 if (!res)
838 return -PSICONV_E_NOMEM;
839 else
840 return res;
841 }
842
843 int psiconv_parse_sheet_cell_layout(const psiconv_buffer buf, int lev,
844 psiconv_u32 off, int *length,
845 psiconv_sheet_cell_layout result)
846
847 {
848 int res=0;
849 int len=0;
850 int leng;
851 psiconv_u8 temp;
852
853 psiconv_progress(lev+1,off,"Going to read a sheet cell layout");
854
855 psiconv_progress(lev+2,off+len,
856 "Going to read the first byte (%02x expected)",0x02);
857 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
858 if (res)
859 goto ERROR1;
860 if (temp != 0x02) {
861 psiconv_warn(lev+2,off+len,
862 "Worksheet section initial byte unknown value (ignored)");
863 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
864 }
865 len ++;
866
867 psiconv_progress(lev+2,off+len,"Going to read the default formats flag");
868 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
869 if (res)
870 goto ERROR1;
871 len ++;
872
873 if (temp & 0x01) {
874 psiconv_progress(lev+3,off+len,"Going to read the default paragraph codes");
875 if ((res = psiconv_parse_paragraph_layout_list(buf,lev+3,off+len,&leng,
876 result->paragraph)))
877 goto ERROR1;
878 len += leng;
879 }
880
881 if (temp & 0x02) {
882 psiconv_progress(lev+3,off+len,"Going to read the default character codes");
883 if ((res = psiconv_parse_character_layout_list(buf,lev+3,off+len,&leng,
884 result->character)))
885 goto ERROR1;
886 len += leng;
887 }
888
889 if (temp & 0x04) {
890 psiconv_progress(lev+3,off+len, "Going to read the default number format");
891 psiconv_parse_sheet_numberformat(buf,lev+3,off+len,&leng,
892 result->numberformat);
893 len += leng;
894 }
895
896 if (length)
897 *length = len;
898
899 psiconv_progress(lev,off+len-1,
900 "End of sheet cell layout (total length: %08x)", len);
901
902 return 0;
903
904 ERROR1:
905 psiconv_warn(lev+1,off,"Reading of sheet cell layout failed");
906 if (length)
907 *length = 0;
908 if (!res)
909 return -PSICONV_E_NOMEM;
910 else
911 return res;
912 }
913
914
915 int psiconv_parse_sheet_worksheet(const psiconv_buffer buf, int lev,
916 psiconv_u32 off, int *length,
917 psiconv_sheet_worksheet *result)
918 {
919 int res=0;
920 psiconv_u32 temp,cells_off,grid_off,rows_off,cols_off;
921 int len=0;
922 int leng;
923
924 psiconv_progress(lev+1,off,"Going to read the sheet worksheet section");
925 if (!(*result = malloc(sizeof(**result))))
926 goto ERROR1;
927
928 psiconv_progress(lev+2,off+len,
929 "Going to read the initial bytes (%02x expected)",0x04);
930 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
931 if (res)
932 goto ERROR2;
933 if (temp != 0x04) {
934 psiconv_warn(lev+2,off+len,
935 "Worksheet section initial byte unknown value (ignored)");
936 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
937 }
938 len ++;
939
940 psiconv_progress(lev+2,off+len, "Going to read the flags byte");
941 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
942 if (res)
943 goto ERROR2;
944 psiconv_debug(lev+2,off+len,"Flags byte: %02x",temp);
945 (*result)->show_zeros = (temp & 0x01)?psiconv_bool_true:psiconv_bool_false;
946 if (temp & 0xfe) {
947 psiconv_warn(lev+2,off+len,
948 "Worksheet section flags byte unknown bits (ignored)");
949 }
950 len ++;
951
952 psiconv_progress(lev+2,off+len,"Going to read the default cell layout");
953 if (!((*result)->default_layout = psiconv_basic_cell_layout()))
954 goto ERROR2;
955 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,&leng,
956 (*result)->default_layout)))
957 goto ERROR3;
958 len += leng;
959
960 psiconv_progress(lev+2,off+len,
961 "Going to read the offset of the row defaults Section");
962 rows_off = psiconv_read_u32(buf,lev+2,off+len,&res);
963 if (res)
964 goto ERROR3;
965 psiconv_debug(lev+2,off+len,"Offset: %04x",rows_off);
966 len += 4;
967
968 psiconv_progress(lev+2,off+len,
969 "Going to read the offset of the column defaults Section");
970 cols_off = psiconv_read_u32(buf,lev+2,off+len,&res);
971 if (res)
972 goto ERROR3;
973 psiconv_debug(lev+2,off+len,"Offset: %04x",cols_off);
974 len += 4;
975
976 psiconv_progress(lev+2,off+len,
977 "Going to read the offset of the Cells List");
978 cells_off = psiconv_read_u32(buf,lev+2,off+len,&res);
979 if (res)
980 goto ERROR3;
981 psiconv_debug(lev+2,off+len,"Offset: %04x",cells_off);
982 len += 4;
983
984 psiconv_progress(lev+2,off+len,
985 "Going to read the offset of the Grid Section");
986 grid_off = psiconv_read_u32(buf,lev+2,off+len,&res);
987 if (res)
988 goto ERROR3;
989 psiconv_debug(lev+2,off+len,"Offset: %04x",grid_off);
990 len += 4;
991
992 psiconv_progress(lev+2,off+len,
993 "Going to read the offset of the 3rd ??? Section");
994 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
995 if (res)
996 goto ERROR3;
997 psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
998 len += 4;
999
1000 psiconv_progress(lev+2,off+len,"Going to read the row defaults");
1001 if ((res = psiconv_parse_sheet_line_list(buf,lev+2,rows_off,NULL,
1002 &(*result)->row_default_layouts,
1003 (*result)->default_layout)))
1004 goto ERROR3;
1005
1006 psiconv_progress(lev+2,off+len,"Going to read the column defaults");
1007 if ((res = psiconv_parse_sheet_line_list(buf,lev+2,cols_off,NULL,
1008 &(*result)->col_default_layouts,
1009 (*result)->default_layout)))
1010 goto ERROR4;
1011
1012 psiconv_progress(lev+2,off+len,"Going to read the cells list");
1013 if ((res = psiconv_parse_sheet_cell_list(buf,lev+2,cells_off,NULL,
1014 &(*result)->cells,
1015 (*result)->default_layout,
1016 (*result)->row_default_layouts,
1017 (*result)->col_default_layouts)))
1018 goto ERROR5;
1019
1020
1021 /* TODO: parse grid section */
1022
1023 if (length)
1024 *length = len;
1025
1026 psiconv_progress(lev,off+len-1,
1027 "End of sheet worksheet section (total length: %08x)", len);
1028 return 0;
1029
1030 ERROR5:
1031 psiconv_free_sheet_line_list((*result)->col_default_layouts);
1032 ERROR4:
1033 psiconv_free_sheet_line_list((*result)->row_default_layouts);
1034 ERROR3:
1035 psiconv_free_sheet_cell_layout((*result)->default_layout);
1036 ERROR2:
1037 free (*result);
1038 ERROR1:
1039 psiconv_warn(lev+1,off,"Reading of Sheet Worksheet Section failed");
1040 if (length)
1041 *length = 0;
1042 if (!res)
1043 return -PSICONV_E_NOMEM;
1044 else
1045 return res;
1046 }
1047
1048 int psiconv_parse_sheet_line(const psiconv_buffer buf, int lev,
1049 psiconv_u32 off, int *length,
1050 psiconv_sheet_line *result,
1051 const psiconv_sheet_cell_layout default_layout)
1052 {
1053 int res=0;
1054 int len=0;
1055 int leng;
1056
1057
1058 psiconv_progress(lev+1,off,"Going to read a sheet line");
1059 if (!(*result = malloc(sizeof(**result))))
1060 goto ERROR1;
1061
1062 psiconv_progress(lev+2,off+len,"Going to read the line number");
1063 (*result)->position = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
1064 if (res)
1065 goto ERROR2;
1066 psiconv_debug(lev+2,off+len,"Line number: %d\n",(*result)->position);
1067 len += leng;
1068
1069 if (!((*result)->layout = psiconv_clone_cell_layout(default_layout)))
1070 goto ERROR2;
1071 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,
1072 &leng,(*result)->layout)))
1073 goto ERROR3;
1074 len += leng;
1075
1076 if (length)
1077 *length = len;
1078
1079 psiconv_progress(lev,off+len-1,
1080 "End of the sheet line (total length: %08x)", len);
1081 return 0;
1082
1083 ERROR3:
1084 psiconv_free_sheet_cell_layout((*result)->layout);
1085 ERROR2:
1086 free (*result);
1087 ERROR1:
1088 psiconv_warn(lev+1,off,"Reading of the sheet line failed");
1089 if (length)
1090 *length = 0;
1091 if (!res)
1092 return -PSICONV_E_NOMEM;
1093 else
1094 return res;
1095 }
1096
1097
1098 int psiconv_parse_sheet_line_list(const psiconv_buffer buf, int lev,
1099 psiconv_u32 off, int *length,
1100 psiconv_sheet_line_list *result,
1101 const psiconv_sheet_cell_layout default_layout)
1102 {
1103 int res=0;
1104 int len=0;
1105 psiconv_u32 temp;
1106 psiconv_sheet_line line;
1107 psiconv_u32 listlen,i;
1108 int leng;
1109
1110 psiconv_progress(lev+1,off,"Going to read the sheet line list");
1111 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_line_s))))
1112 goto ERROR1;
1113
1114 psiconv_progress(lev+2,off+len,
1115 "Going to read the initial byte (%02x expected)",0x02);
1116 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
1117 if (res)
1118 goto ERROR2;
1119 if (temp != 0x02) {
1120 psiconv_warn(lev+2,off+len,
1121 "Sheet line list initial byte unknown value (ignored)");
1122 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
1123 }
1124 len ++;
1125
1126 psiconv_progress(lev+2,off+len,
1127 "Going to read the number of defined lines");
1128 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
1129 if (res)
1130 goto ERROR2;
1131 psiconv_debug(lev+2,off+len,"Number of defined lines: %d",listlen);
1132 len += leng;
1133
1134 psiconv_progress(lev+2,off+len,"Going to read all lines");
1135 for (i = 0; i < listlen; i++) {
1136 psiconv_progress(lev+3,off+len,"Going to read line %d",i);
1137 if ((res = psiconv_parse_sheet_line(buf,lev+3,off+len,&leng,&line,
1138 default_layout)))
1139 goto ERROR2;
1140 if ((res = psiconv_list_add(*result,line)))
1141 goto ERROR3;
1142 free(line);
1143 len += leng;
1144 }
1145
1146 if (length)
1147 *length = len;
1148
1149 psiconv_progress(lev,off+len-1,
1150 "End of sheet line list (total length: %08x)", len);
1151 return 0;
1152
1153 ERROR3:
1154 psiconv_free_sheet_line(line);
1155 ERROR2:
1156 psiconv_free_sheet_line_list(*result);
1157 ERROR1:
1158 psiconv_warn(lev+1,off,"Reading of Sheet Line List failed");
1159 if (length)
1160 *length = 0;
1161 if (!res)
1162 return -PSICONV_E_NOMEM;
1163 else
1164 return res;
1165 }
1166

frodo@frodo.looijaard.name
ViewVC Help
Powered by ViewVC 1.1.26