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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 129 - (hide annotations)
Tue Jul 24 20:32:51 2001 UTC (22 years, 9 months ago) by frodo
File MIME type: text/plain
File size: 52592 byte(s) 
(Frodo) Many new sheet things

  * Variable section and formula variable parsing
  * Info section
  * Name section
  * Better parsing of vararg functions
1 frodo 94 /*
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 frodo 121 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 frodo 129 static psiconv_sheet_cell_reference_t
80     psiconv_read_var_cellref (const psiconv_buffer buf, int lev,
81     psiconv_u32 off, int *length,
82     int *status)
83     {
84     int len=0;
85     int res;
86     psiconv_sheet_cell_reference_t result;
87     psiconv_u32 temp;
88    
89     psiconv_progress(lev+1,off+len,"Going to read a sheet cell reference");
90     psiconv_progress(lev+2,off+len,
91     "Going to read the initial byte (%02x expected)",0x00);
92     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
93     if (res)
94     goto ERROR1;
95     if (temp != 0x00) {
96     psiconv_warn(lev+2,off+len,
97     "Sheet cell reference initial byte unknown value (ignored)");
98     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
99     }
100     len ++;
101    
102     temp = psiconv_read_u32(buf,lev+2,off+len,&res);
103     if (res)
104     goto ERROR1;
105     if (temp & 0xffff0000) {
106     psiconv_warn(lev+2,off+len,
107     "Sheet cell row reference to unknown row (reset)");
108     }
109     result.row.offset = temp;
110     result.row.absolute = psiconv_bool_true;
111     len += 4;
112    
113     temp = psiconv_read_u32(buf,lev+2,off+len,&res);
114     if (res)
115     goto ERROR1;
116     if (temp & 0xffff0000) {
117     psiconv_warn(lev+2,off+len,
118     "Sheet cell column reference to unknown row (reset)");
119     }
120     result.column.offset = temp;
121     result.column.absolute = psiconv_bool_true;
122     len += 4;
123    
124     if (length)
125     *length = len;
126    
127     psiconv_progress(lev,off+len-1,
128     "End of sheet column reference (total length: %08x)", len);
129     return result;
130     ERROR1:
131     psiconv_warn(lev+1,off,"Reading of Sheet Column Reference failed");
132     if (length)
133     *length = 0;
134     if (status)
135     *status = res?res:-PSICONV_E_NOMEM;
136     return result;
137     }
138    
139     static psiconv_sheet_cell_block_t
140     psiconv_read_var_cellblock (const psiconv_buffer buf, int lev,
141     psiconv_u32 off, int *length,
142     int *status)
143     {
144     int len=0;
145     int res;
146     psiconv_sheet_cell_block_t result;
147     psiconv_u32 temp;
148    
149     psiconv_progress(lev+1,off+len,"Going to read a sheet cell block reference");
150     psiconv_progress(lev+2,off+len,
151     "Going to read the initial byte (%02x expected)",0x00);
152     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
153     if (res)
154     goto ERROR1;
155     if (temp != 0x00) {
156     psiconv_warn(lev+2,off+len,
157     "Sheet cell reference initial byte unknown value (ignored)");
158     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
159     }
160     len ++;
161    
162     temp = psiconv_read_u32(buf,lev+2,off+len,&res);
163     if (res)
164     goto ERROR1;
165     if (temp & 0xffff0000) {
166     psiconv_warn(lev+2,off+len,
167     "Sheet block initial row reference to unknown row (reset)");
168     }
169     result.first.row.offset = temp;
170     result.first.row.absolute = psiconv_bool_true;
171     len += 4;
172    
173     temp = psiconv_read_u32(buf,lev+2,off+len,&res);
174     if (res)
175     goto ERROR1;
176     if (temp & 0xffff0000) {
177     psiconv_warn(lev+2,off+len,
178     "Sheet block initial column reference to unknown row (reset)");
179     }
180     result.first.column.offset = temp;
181     result.first.column.absolute = psiconv_bool_true;
182     len += 4;
183    
184     temp = psiconv_read_u32(buf,lev+2,off+len,&res);
185     if (res)
186     goto ERROR1;
187     if (temp & 0xffff0000) {
188     psiconv_warn(lev+2,off+len,
189     "Sheet block final row reference to unknown row (reset)");
190     }
191     result.last.row.offset = temp;
192     result.last.row.absolute = psiconv_bool_true;
193     len += 4;
194    
195     temp = psiconv_read_u32(buf,lev+2,off+len,&res);
196     if (res)
197     goto ERROR1;
198     if (temp & 0xffff0000) {
199     psiconv_warn(lev+2,off+len,
200     "Sheet block final column reference to unknown row (reset)");
201     }
202     result.last.column.offset = temp;
203     result.last.column.absolute = psiconv_bool_true;
204     len += 4;
205    
206     if (length)
207     *length = len;
208    
209     psiconv_progress(lev,off+len-1,
210     "End of sheet cell block reference (total length: %08x)",
211     len);
212     return result;
213     ERROR1:
214     psiconv_warn(lev+1,off,"Reading of Sheet Cell Block Reference failed");
215     if (length)
216     *length = 0;
217     if (status)
218     *status = res?res:-PSICONV_E_NOMEM;
219     return result;
220     }
221    
222 frodo 111 int psiconv_parse_sheet_numberformat(const psiconv_buffer buf, int lev,
223     psiconv_u32 off, int *length,
224 frodo 121 psiconv_sheet_numberformat result)
225 frodo 111 {
226     int res=0;
227     int len=0;
228     psiconv_u8 temp;
229    
230     psiconv_progress(lev+1,off,"Going to read a sheet numberformat");
231    
232     psiconv_progress(lev+2,off+len,
233     "Going to read the initial byte (%02x expected)",0x02);
234     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
235     if (res)
236 frodo 121 goto ERROR1;
237 frodo 111 if (temp != 0x02) {
238     psiconv_warn(lev+2,off+len,
239     "Sheet numberformat initial byte unknown value (ignored)");
240     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
241     }
242     len ++;
243    
244     psiconv_progress(lev+2,off+len, "Going to read the code byte");
245     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
246     if (res)
247 frodo 121 goto ERROR1;
248 frodo 111 psiconv_debug(lev+2,off+len,"Code: %02x",temp);
249     if (temp == 0x00)
250 frodo 121 result->code = psiconv_numberformat_general;
251 frodo 111 else if (temp == 0x02)
252 frodo 121 result->code = psiconv_numberformat_fixeddecimal;
253 frodo 111 else if (temp == 0x04)
254 frodo 121 result->code = psiconv_numberformat_scientific;
255 frodo 111 else if (temp == 0x06)
256 frodo 121 result->code = psiconv_numberformat_currency;
257 frodo 111 else if (temp == 0x08)
258 frodo 121 result->code = psiconv_numberformat_percent;
259 frodo 111 else if (temp == 0x0A)
260 frodo 121 result->code = psiconv_numberformat_triads;
261 frodo 111 else if (temp == 0x0C)
262 frodo 121 result->code = psiconv_numberformat_boolean;
263 frodo 111 else if (temp == 0x0E)
264 frodo 121 result->code = psiconv_numberformat_text;
265 frodo 111 else if (temp == 0x10)
266 frodo 122 result->code = psiconv_numberformat_date_dmm;
267 frodo 111 else if (temp == 0x12)
268 frodo 122 result->code = psiconv_numberformat_date_mmd;
269 frodo 111 else if (temp == 0x14)
270 frodo 121 result->code = psiconv_numberformat_date_ddmmyy;
271 frodo 111 else if (temp == 0x16)
272 frodo 121 result->code = psiconv_numberformat_date_mmddyy;
273 frodo 111 else if (temp == 0x18)
274 frodo 121 result->code = psiconv_numberformat_date_yymmdd;
275 frodo 111 else if (temp == 0x1A)
276 frodo 122 result->code = psiconv_numberformat_date_dmmm;
277 frodo 111 else if (temp == 0x1C)
278 frodo 122 result->code = psiconv_numberformat_date_dmmmyy;
279     else if (temp == 0x1E)
280 frodo 121 result->code = psiconv_numberformat_date_ddmmmyy;
281 frodo 111 else if (temp == 0x20)
282 frodo 121 result->code = psiconv_numberformat_date_mmm;
283 frodo 111 else if (temp == 0x22)
284 frodo 121 result->code = psiconv_numberformat_date_monthname;
285 frodo 111 else if (temp == 0x24)
286 frodo 121 result->code = psiconv_numberformat_date_mmmyy;
287 frodo 111 else if (temp == 0x26)
288 frodo 121 result->code = psiconv_numberformat_date_monthnameyy;
289 frodo 111 else if (temp == 0x28)
290 frodo 122 result->code = psiconv_numberformat_date_monthnamedyyyy;
291 frodo 111 else if (temp == 0x2A)
292 frodo 121 result->code = psiconv_numberformat_datetime_ddmmyyyyhhii;
293 frodo 111 else if (temp == 0x2C)
294 frodo 121 result->code = psiconv_numberformat_datetime_ddmmyyyyHHii;
295 frodo 111 else if (temp == 0x2E)
296 frodo 121 result->code = psiconv_numberformat_datetime_mmddyyyyhhii;
297 frodo 111 else if (temp == 0x30)
298 frodo 121 result->code = psiconv_numberformat_datetime_mmddyyyyHHii;
299 frodo 111 else if (temp == 0x32)
300 frodo 121 result->code = psiconv_numberformat_datetime_yyyymmddhhii;
301 frodo 111 else if (temp == 0x34)
302 frodo 121 result->code = psiconv_numberformat_datetime_yyyymmddHHii;
303 frodo 111 else if (temp == 0x36)
304 frodo 121 result->code = psiconv_numberformat_time_hhii;
305 frodo 111 else if (temp == 0x38)
306 frodo 121 result->code = psiconv_numberformat_time_hhiiss;
307 frodo 111 else if (temp == 0x3A)
308 frodo 121 result->code = psiconv_numberformat_time_HHii;
309 frodo 111 else if (temp == 0x3C)
310 frodo 121 result->code = psiconv_numberformat_time_HHiiss;
311 frodo 111 else {
312     psiconv_warn(lev+2,off+len,"Unknown number format (assumed general)");
313 frodo 121 result->code = psiconv_numberformat_general;
314 frodo 111 }
315     len ++;
316    
317     psiconv_progress(lev+2,off+len, "Going to read the number of decimals");
318 frodo 122 result->decimal = psiconv_read_u8(buf,lev+2,off+len,&res) >> 1;
319 frodo 111 if (res)
320 frodo 121 goto ERROR1;
321     psiconv_debug(lev+2,off+len,"Decimals: %d",result->decimal);
322 frodo 111 len ++;
323    
324     if (length)
325     *length = len;
326    
327     psiconv_progress(lev,off+len-1,
328     "End of sheet number format (total length: %08x)", len);
329     return 0;
330    
331     ERROR1:
332     psiconv_warn(lev+1,off,"Reading of Sheet Number Format failed");
333     if (length)
334     *length = 0;
335     if (!res)
336     return -PSICONV_E_NOMEM;
337     else
338     return res;
339     }
340    
341 frodo 94 int psiconv_parse_sheet_status_section(const psiconv_buffer buf, int lev,
342     psiconv_u32 off, int *length,
343     psiconv_sheet_status_section *result)
344     {
345     int res=0;
346     int len=0;
347     psiconv_u32 temp;
348     int leng;
349    
350     psiconv_progress(lev+1,off,"Going to read the sheet status section");
351     if (!(*result = malloc(sizeof(**result))))
352     goto ERROR1;
353    
354     psiconv_progress(lev+2,off+len,
355     "Going to read the initial byte (%02x expected)",0x02);
356     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
357     if (res)
358     goto ERROR2;
359     if (temp != 0x02) {
360     psiconv_warn(lev+2,off+len,
361     "Sheet status section initial byte unknown value (ignored)");
362     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
363     }
364     len ++;
365    
366     psiconv_progress(lev+2,off+len,
367     "Going to read the cursor row");
368     (*result)->cursor_row = psiconv_read_u32(buf,lev+2,off + len,&res);
369     if (res)
370     goto ERROR2;
371     psiconv_debug(lev+2,off+len,"Cursor row: %08x",
372     (*result)->cursor_row);
373     len += 0x04;
374    
375     psiconv_progress(lev+2,off+len,
376     "Going to read the cursor column");
377     (*result)->cursor_column = psiconv_read_u32(buf,lev+2,off + len,&res);
378     if (res)
379     goto ERROR2;
380     psiconv_debug(lev+2,off+len,"Cursor column: %08x",
381     (*result)->cursor_column);
382     len += 0x04;
383    
384     psiconv_progress(lev+2,off+len,"Going to read initially display graph");
385     if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,
386     &(*result)->show_graph)))
387     goto ERROR2;
388     len += leng;
389    
390     psiconv_progress(lev+2,off+len,
391     "Going to read the toolbar status byte");
392     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
393     if (res)
394     goto ERROR2;
395    
396     (*result)->show_side_sheet_toolbar = temp&0x01 ? psiconv_bool_true :
397     psiconv_bool_false;
398     psiconv_debug(lev+2,off+len,"Show side sheet toolbar: %02x",
399     (*result)->show_side_sheet_toolbar);
400     (*result)->show_top_sheet_toolbar = temp&0x02 ? psiconv_bool_true :
401     psiconv_bool_false;
402     psiconv_debug(lev+2,off+len,"Show top sheet toolbar: %02x",
403     (*result)->show_top_sheet_toolbar);
404     (*result)->show_side_graph_toolbar = temp&0x04 ? psiconv_bool_true :
405     psiconv_bool_false;
406     psiconv_debug(lev+2,off+len,"Show side graph toolbar: %02x",
407     (*result)->show_side_graph_toolbar);
408     (*result)->show_top_graph_toolbar = temp&0x08 ? psiconv_bool_true :
409     psiconv_bool_false;
410     psiconv_debug(lev+2,off+len,"Show top graph toolbar: %02x",
411     (*result)->show_top_graph_toolbar);
412     if (temp & 0xf0) {
413     psiconv_warn(lev+2,off+len,"Sheet status section toolbar byte "
414     "flags contains unknown flags (ignored)");
415     psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
416     }
417     len ++;
418    
419     psiconv_progress(lev+2,off+len,
420     "Going to read the scrollbar status byte");
421     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
422     if (res)
423     goto ERROR2;
424     if ((temp & 0x03) == 0x03) {
425     psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "
426     "flags contains unknown flags (ignored)");
427     psiconv_debug(lev+2,off+len,"Unknown flag: %02x",temp & 0x03);
428     }
429     (*result)->show_horizontal_scrollbar = (temp&0x03) == 1? psiconv_triple_off :
430     (temp&0x03) == 2? psiconv_triple_auto:
431     psiconv_triple_on;
432     psiconv_debug(lev+2,off+len,"Show horizontal scrollbar: %02x",
433     (*result)->show_horizontal_scrollbar);
434     if ((temp & 0x0c) == 0x0c) {
435     psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "
436     "flags contains unknown flags (ignored)");
437     psiconv_debug(lev+2,off+len,"Unknown flag: %02x",temp & 0x0c);
438     }
439     (*result)->show_vertical_scrollbar = (temp&0x0c) ==0x04? psiconv_triple_off:
440     (temp&0x0c) ==0x08? psiconv_triple_auto:
441     psiconv_triple_on;
442     psiconv_debug(lev+2,off+len,"Show vertical scrollbar: %02x",
443     (*result)->show_vertical_scrollbar);
444     if (temp & 0xf0) {
445     psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "
446     "flags contains unknown flags (ignored)");
447     psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
448     }
449     len ++;
450    
451     psiconv_progress(lev+2,off+len,
452     "Going to read an unknown byte (%02x expected)",0x00);
453     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
454     if (res)
455     goto ERROR2;
456     if (temp != 0x00) {
457     psiconv_warn(lev+2,off+len,
458     "Sheet status section unknown byte unknown value (ignored)");
459 frodo 129 psiconv_debug(lev+2,off+len,"Unknown byte: %02x",temp);
460 frodo 94 }
461     len ++;
462    
463     psiconv_progress(lev+2,off+len,"Going to read sheet display size");
464     (*result)->sheet_display_size = psiconv_read_u32(buf,lev+2,off + len,&res);
465     if (res)
466     goto ERROR2;
467     psiconv_debug(lev+2,off+len,"Sheet display size: %08x",
468     (*result)->sheet_display_size);
469     len += 0x04;
470    
471     psiconv_progress(lev+2,off+len,"Going to read graph display size");
472     (*result)->graph_display_size = psiconv_read_u32(buf,lev+2,off + len,&res);
473     if (res)
474     goto ERROR2;
475     psiconv_debug(lev+2,off+len,"Graph display size: %08x",
476     (*result)->graph_display_size);
477     len += 0x04;
478    
479     if (length)
480     *length = len;
481    
482     psiconv_progress(lev,off+len-1,
483     "End of sheet status section (total length: %08x)", len);
484     return 0;
485    
486     ERROR2:
487     free (*result);
488     ERROR1:
489 frodo 110 psiconv_warn(lev+1,off,"Reading of Sheet Status Section failed");
490 frodo 94 if (length)
491     *length = 0;
492     if (!res)
493     return -PSICONV_E_NOMEM;
494     else
495     return res;
496     }
497    
498 frodo 95 int psiconv_parse_sheet_workbook_section(const psiconv_buffer buf, int lev,
499     psiconv_u32 off, int *length,
500     psiconv_sheet_workbook_section *result)
501     {
502 frodo 129 int res=0,with_name;
503     psiconv_u32 temp,formulas_off,worksheets_off,info_off,var_off,name_off=0;
504 frodo 95 int len=0;
505    
506     psiconv_progress(lev+1,off,"Going to read the sheet workbook section");
507     if (!(*result = malloc(sizeof(**result))))
508     goto ERROR1;
509    
510     psiconv_progress(lev+2,off+len,
511 frodo 129 "Going to read the initial byte (%02x or $02xexpected)",
512     0x02,0x04);
513 frodo 95 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
514     if (res)
515     goto ERROR2;
516 frodo 129 if ((temp != 0x04) && temp !=0x02) {
517 frodo 95 psiconv_warn(lev+2,off+len,
518     "Sheet workbook section initial byte unknown value (ignored)");
519     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
520     }
521 frodo 129 with_name = temp ==0x04;
522 frodo 95 len ++;
523    
524     psiconv_progress(lev+2,off+len,
525 frodo 129 "Going to read the offset of the sheet info Section");
526     info_off = psiconv_read_u32(buf,lev+2,off+len,&res);
527 frodo 95 if (res)
528     goto ERROR2;
529 frodo 129 psiconv_debug(lev+2,off+len,"Offset: %04x",info_off);
530 frodo 95 len += 4;
531    
532     psiconv_progress(lev+2,off+len,
533 frodo 97 "Going to read the offset of the Formulas List");
534     formulas_off = psiconv_read_u32(buf,lev+2,off+len,&res);
535 frodo 95 if (res)
536     goto ERROR2;
537 frodo 97 psiconv_debug(lev+2,off+len,"Offset: %04x",formulas_off);
538 frodo 95 len += 4;
539    
540     psiconv_progress(lev+2,off+len,
541 frodo 111 "Going to read the offset of the Worksheet List");
542 frodo 110 worksheets_off = psiconv_read_u32(buf,lev+2,off+len,&res);
543 frodo 95 if (res)
544     goto ERROR2;
545 frodo 111 psiconv_debug(lev+2,off+len,"Offset: %04x",worksheets_off);
546 frodo 95 len += 4;
547    
548     psiconv_progress(lev+2,off+len,
549 frodo 129 "Going to read the offset of the Variable List");
550     var_off = psiconv_read_u32(buf,lev+2,off+len,&res);
551 frodo 95 if (res)
552     goto ERROR2;
553 frodo 129 psiconv_debug(lev+2,off+len,"Offset: %04x",var_off);
554 frodo 95 len += 4;
555    
556 frodo 129 if (with_name) {
557     psiconv_progress(lev+2,off+len,
558     "Going to read the offset of the Name Section");
559     name_off = psiconv_read_u32(buf,lev+2,off+len,&res);
560     if (res)
561     goto ERROR2;
562     psiconv_debug(lev+2,off+len,"Offset: %04x",name_off);
563     len += 4;
564     }
565    
566    
567     psiconv_progress(lev+2,off+len,"Going to read the info section");
568     if ((res = psiconv_parse_sheet_info_section(buf,lev+2,info_off,NULL,
569     &(*result)->info)))
570     goto ERROR2;
571    
572     psiconv_progress(lev+2,off+len,"Going to read the variables list");
573     if ((res = psiconv_parse_sheet_variable_list(buf,lev+2,var_off,NULL,
574     &(*result)->variables)))
575     goto ERROR3;
576    
577 frodo 97 psiconv_progress(lev+2,off+len,"Going to read the formulas list");
578 frodo 129 if ((res = psiconv_parse_sheet_formula_list(buf,lev+2,formulas_off,NULL,
579 frodo 98 &(*result)->formulas)))
580 frodo 129 goto ERROR4;
581 frodo 97
582 frodo 111 psiconv_progress(lev+2,off+len,"Going to read the worksheet list");
583     if ((res = psiconv_parse_sheet_worksheet_list(buf,lev+2,worksheets_off,
584     NULL,&(*result)->worksheets)))
585 frodo 129 goto ERROR5;
586 frodo 97
587 frodo 129 if (with_name) {
588     psiconv_progress(lev+2,off+len,"Going to read the name section");
589    
590     if ((res = psiconv_parse_sheet_name_section(buf,lev+2,name_off,NULL,
591     &(*result)->name)))
592     goto ERROR6;
593     } else
594     (*result)->name = NULL;
595 frodo 110
596 frodo 95 if (length)
597     *length = len;
598    
599     psiconv_progress(lev,off+len-1,
600     "End of sheet workbook section (total length: %08x)", len);
601     return 0;
602    
603 frodo 129 ERROR6:
604     psiconv_free_sheet_worksheet_list((*result)->worksheets);
605     ERROR5:
606     psiconv_free_formula_list((*result)->formulas);
607     ERROR4:
608     psiconv_free_sheet_variable_list((*result)->variables);
609     ERROR3:
610     psiconv_free_sheet_info_section((*result)->info);
611 frodo 95 ERROR2:
612     free (*result);
613     ERROR1:
614     psiconv_warn(lev+1,off,"Reading of Sheet Workbook Section failed");
615     if (length)
616     *length = 0;
617     if (!res)
618     return -PSICONV_E_NOMEM;
619     else
620     return res;
621     }
622 frodo 97
623 frodo 129 int psiconv_parse_sheet_name_section(const psiconv_buffer buf, int lev,
624     psiconv_u32 off, int *length,
625     psiconv_sheet_name_section *result)
626     {
627     int res=0;
628     psiconv_u32 temp;
629     int len=0,leng;
630    
631     psiconv_progress(lev+1,off,"Going to read the sheet name section");
632     if (!(*result = malloc(sizeof(**result))))
633     goto ERROR1;
634    
635     psiconv_progress(lev+2,off+len,
636     "Going to read the initial byte (%02x expected)",0x02);
637     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
638     if (res)
639     goto ERROR2;
640     if (temp != 0x02) {
641     psiconv_warn(lev+2,off+len,
642     "Sheet name section initial byte unknown value (ignored)");
643     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
644     }
645     len ++;
646    
647     psiconv_progress(lev+2,off+len, "Going to read the sheet name");
648     (*result)->name = psiconv_read_string(buf,lev+2,off+len,&leng,&res);
649     if (res)
650     goto ERROR2;
651     len += leng;
652    
653     if (length)
654     *length = len;
655    
656     psiconv_progress(lev,off+len-1,
657     "End of sheet name section (total length: %08x)", len);
658     return 0;
659    
660     ERROR2:
661     free(*result);
662     ERROR1:
663     psiconv_warn(lev+1,off,"Reading of Sheet Name Section 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_info_section(const psiconv_buffer buf, int lev,
673     psiconv_u32 off, int *length,
674     psiconv_sheet_info_section *result)
675     {
676     int res=0;
677     psiconv_u32 temp;
678     int len=0;
679    
680     psiconv_progress(lev+1,off,"Going to read the sheet info section");
681     if (!(*result = malloc(sizeof(**result))))
682     goto ERROR1;
683    
684     psiconv_progress(lev+2,off+len,
685     "Going to read the initial byte (%02x expected)",0x02);
686     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
687     if (res)
688     goto ERROR2;
689     if (temp != 0x02) {
690     psiconv_warn(lev+2,off+len,
691     "Sheet info section initial byte unknown value (ignored)");
692     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
693     }
694     len ++;
695    
696     psiconv_progress(lev+2,off+len, "Going to read the flags byte");
697     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
698     if (res)
699     goto ERROR2;
700     (*result)->auto_recalc = temp & 0x01 ? psiconv_bool_true:psiconv_bool_false;
701     psiconv_debug(lev+2,off+len,"Auto recalculation: %02x",
702     (*result)->auto_recalc);
703     if ((temp & 0xfe) != 0x02) {
704     psiconv_warn(lev+2,off+len,"Sheet Info Section flags byte "
705     "contains unknown flags (ignored)");
706     psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp &0xfe);
707     }
708    
709     len ++;
710    
711    
712     if (length)
713     *length = len;
714    
715     psiconv_progress(lev,off+len-1,
716     "End of sheet info section (total length: %08x)", len);
717     return 0;
718    
719     ERROR2:
720     free(*result);
721     ERROR1:
722     psiconv_warn(lev+1,off,"Reading of Sheet Name Section failed");
723     if (length)
724     *length = 0;
725     if (!res)
726     return -PSICONV_E_NOMEM;
727     else
728     return res;
729     }
730    
731     int psiconv_parse_sheet_formula_list(const psiconv_buffer buf, int lev,
732 frodo 98 psiconv_u32 off, int *length,
733     psiconv_formula_list *result)
734 frodo 97 {
735     int res=0;
736     int len=0;
737     psiconv_u32 temp;
738 frodo 98 psiconv_formula formula;
739 frodo 97 psiconv_u32 listlen,i;
740     int leng;
741    
742 frodo 129 psiconv_progress(lev+1,off,"Going to read the sheet formula list");
743 frodo 98 if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s))))
744 frodo 97 goto ERROR1;
745    
746     psiconv_progress(lev+2,off+len,
747     "Going to read the initial byte (%02x expected)",0x02);
748     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
749     if (res)
750     goto ERROR2;
751     if (temp != 0x02) {
752     psiconv_warn(lev+2,off+len,
753 frodo 129 "Sheet formula list initial byte unknown value (ignored)");
754 frodo 97 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
755     }
756     len ++;
757    
758     psiconv_progress(lev+2,off+len,
759     "Going to read the number of formulas");
760     listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
761     if (res)
762     goto ERROR2;
763     psiconv_debug(lev+2,off+len,"Number of formulas: %d",listlen);
764     len += leng;
765    
766     psiconv_progress(lev+2,off+len,"Going to read all formulas");
767     for (i = 0; i < listlen; i++) {
768     psiconv_progress(lev+3,off+len,"Going to read formula %d",i);
769 frodo 98 if ((res = psiconv_parse_formula(buf,lev+3,off+len,&leng,&formula)))
770 frodo 97 goto ERROR2;
771     if ((res = psiconv_list_add(*result,formula)))
772     goto ERROR3;
773     len += leng;
774     }
775    
776     if (length)
777     *length = len;
778    
779     psiconv_progress(lev,off+len-1,
780 frodo 129 "End of sheet formula list (total length: %08x)", len);
781 frodo 97 return 0;
782    
783     ERROR3:
784 frodo 98 psiconv_free_formula(formula);
785 frodo 97 ERROR2:
786     psiconv_list_free(*result);
787     ERROR1:
788 frodo 129 psiconv_warn(lev+1,off,"Reading of Sheet Formula list failed");
789 frodo 97 if (length)
790     *length = 0;
791     if (!res)
792     return -PSICONV_E_NOMEM;
793     else
794     return res;
795     }
796 frodo 110
797     int psiconv_parse_sheet_cell(const psiconv_buffer buf, int lev,
798 frodo 121 psiconv_u32 off, int *length,
799     psiconv_sheet_cell *result,
800 frodo 128 const psiconv_sheet_cell_layout default_layout,
801     const psiconv_sheet_line_list row_default_layouts,
802     const psiconv_sheet_line_list col_default_layouts)
803 frodo 110 {
804     int res=0;
805     int len=0;
806     psiconv_u32 temp;
807     psiconv_bool_t has_layout;
808     int leng;
809    
810     psiconv_progress(lev+1,off,"Going to read a sheet cell structure");
811     if (!(*result = malloc(sizeof(**result))))
812     goto ERROR1;
813    
814 frodo 111 (*result)->layout = NULL;
815     (*result)->type = psiconv_cell_blank;
816    
817 frodo 110 psiconv_progress(lev+2,off+len,"Going to read the cell position");
818     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
819     if (res)
820     goto ERROR2;
821     len ++;
822     temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 8;
823     if (res)
824     goto ERROR2;
825     len ++;
826     temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 16;
827     if (res)
828     goto ERROR2;
829     len ++;
830     (*result)->column = (temp >> 2) & 0xFF;
831     (*result)->row = (temp >> 10) & 0x3FFF;
832     psiconv_debug(lev+2,off+len,"Cell position is col:%02x row:%04x",
833     (*result)->column,(*result)->row);
834 frodo 111 if (temp & 0x03) {
835     psiconv_warn(lev+2,off+len,"Unknown flags in cell position (ignored)");
836     psiconv_debug(lev+2,off+len,"Flags: %02x",temp & 0x03);
837     }
838 frodo 110
839     psiconv_progress(lev+2,off+len,"Going to read the cell type");
840     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
841     if (res)
842     goto ERROR2;
843     len ++;
844     (*result)->type = (temp >> 5) & 0x07;
845     (*result)->calculated = (temp & 0x08)?psiconv_bool_true:psiconv_bool_false;
846     has_layout = (temp & 0x10)?psiconv_bool_true:psiconv_bool_false;
847    
848     psiconv_progress(lev+2,off+len,"Going to read the cell value");
849     if ((*result)->type == psiconv_cell_blank) {
850     psiconv_debug(lev+2,off+len,"Cell type is blank: no value given.");
851     } else if ((*result)->type == psiconv_cell_int) {
852     psiconv_progress(lev+2,off+len,"Going to read an integer");
853     (*result)->data.dat_int = psiconv_read_u32(buf,lev+2,off+len,&res);
854     if (res)
855     goto ERROR2;
856     len += 4;
857     psiconv_debug(lev+2,off+len,"Cell contents: %ld",(*result)->data.dat_int);
858    
859     } else if ((*result)->type == psiconv_cell_bool) {
860     psiconv_progress(lev+2,off+len,"Going to read a boolean");
861 frodo 111 if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,
862     &(*result)->data.dat_bool)))
863 frodo 110 goto ERROR2;
864     psiconv_debug(lev+2,off+len,"Cell contents: %01x",temp);
865     (*result)->data.dat_bool = temp?psiconv_bool_true:psiconv_bool_false;
866 frodo 111 len += leng;
867 frodo 110 } else if ((*result)->type == psiconv_cell_error) {
868     psiconv_progress(lev+2,off+len,"Going to read the error code");
869 frodo 111 temp = psiconv_read_u16(buf,lev+2,off+len,&res);
870     if (res)
871     goto ERROR2;
872     if (temp == 0)
873     (*result)->data.dat_error = psiconv_sheet_error_none;
874     else if (temp == 1)
875     (*result)->data.dat_error = psiconv_sheet_error_null;
876     else if (temp == 2)
877     (*result)->data.dat_error = psiconv_sheet_error_divzero;
878     else if (temp == 3)
879     (*result)->data.dat_error = psiconv_sheet_error_value;
880     else if (temp == 4)
881     (*result)->data.dat_error = psiconv_sheet_error_reference;
882     else if (temp == 5)
883     (*result)->data.dat_error = psiconv_sheet_error_name;
884     else if (temp == 6)
885     (*result)->data.dat_error = psiconv_sheet_error_number;
886     else if (temp == 7)
887     (*result)->data.dat_error = psiconv_sheet_error_notavail;
888     else {
889     psiconv_warn(lev+2,off+len,"Unknown error code (default assumed)");
890     psiconv_debug(lev+2,off+len,"Error code: %04x",temp);
891     (*result)->data.dat_error = psiconv_sheet_error_none;
892     }
893 frodo 110 psiconv_debug(lev+2,off+len,"Cell contents: %04x",
894 frodo 111 (*result)->data.dat_error);
895     len += 2;
896 frodo 110 } else if ((*result)->type == psiconv_cell_float) {
897     psiconv_progress(lev+2,off+len,"Going to read a float");
898     (*result)->data.dat_float =
899     psiconv_read_float(buf,lev+2,off+len,&leng,&res);
900 frodo 111 if (res)
901     goto ERROR2;
902 frodo 110 psiconv_debug(lev+2,off+len,"Cell contents: %f",(*result)->data.dat_float);
903 frodo 111 len += leng;
904 frodo 110 } else if ((*result)->type == psiconv_cell_string) {
905     psiconv_progress(lev+2,off+len,"Going to read a string");
906     (*result)->data.dat_string =
907 frodo 111 psiconv_read_string(buf,lev+2,off+len,&leng,&res);
908     if (res)
909     goto ERROR2;
910 frodo 110 psiconv_debug(lev+2,off+len,"Cell contents: `%s'",
911     (*result)->data.dat_string);
912 frodo 111 len += leng;
913 frodo 110 } else {
914     psiconv_warn(lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type);
915 frodo 111 res = PSICONV_E_PARSE;
916     goto ERROR2;
917 frodo 110 }
918    
919 frodo 128 if (!((*result)->layout = psiconv_clone_cell_layout(
920     psiconv_get_default_layout(row_default_layouts,
921     col_default_layouts,
922     default_layout,
923     (*result)->row,
924     (*result)->column))))
925 frodo 121 goto ERROR2;
926 frodo 110 if (has_layout) {
927 frodo 111 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,
928 frodo 121 &leng,(*result)->layout)))
929 frodo 110 goto ERROR2;
930 frodo 111 len += leng;
931 frodo 110 }
932    
933     if ((*result)->calculated) {
934     psiconv_progress(lev+2,off+len,"Going to read the cell formula reference");
935     temp = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
936     if (res)
937     goto ERROR2;
938     psiconv_debug(lev+2,off+len,"Cell formula reference: %d",temp);
939     len += leng;
940 frodo 111 (*result)->ref_formula = temp;
941 frodo 110 }
942    
943     if (length)
944     *length = len;
945    
946     psiconv_progress(lev,off+len-1,
947     "End of sheet cell structure (total length: %08x)", len);
948     return 0;
949    
950     ERROR2:
951     psiconv_free_sheet_cell(*result);
952     ERROR1:
953     psiconv_warn(lev+1,off,"Reading of Sheet Cell Structure failed");
954     if (length)
955     *length = 0;
956     if (!res)
957     return -PSICONV_E_NOMEM;
958     else
959     return res;
960     }
961    
962     int psiconv_parse_sheet_cell_list(const psiconv_buffer buf, int lev,
963 frodo 128 psiconv_u32 off, int *length,
964     psiconv_sheet_cell_list *result,
965     const psiconv_sheet_cell_layout default_layout,
966     const psiconv_sheet_line_list row_default_layouts,
967     const psiconv_sheet_line_list col_default_layouts)
968 frodo 110 {
969     int res=0;
970     int len=0;
971     psiconv_u32 temp;
972     psiconv_sheet_cell cell;
973     psiconv_u32 listlen,i;
974     int leng;
975    
976 frodo 111 psiconv_progress(lev+1,off,"Going to read the sheet cell list");
977 frodo 110 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_cell_s))))
978     goto ERROR1;
979    
980     psiconv_progress(lev+2,off+len,
981     "Going to read the initial byte (%02x expected)",0x02);
982     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
983     if (res)
984     goto ERROR2;
985     if (temp != 0x02) {
986     psiconv_warn(lev+2,off+len,
987     "Sheet cell list initial byte unknown value (ignored)");
988     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
989     }
990     len ++;
991    
992     psiconv_progress(lev+2,off+len,
993     "Going to read the initial byte (%02x expected)",0x00);
994     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
995     if (res)
996     goto ERROR2;
997     if (temp != 0x00) {
998     psiconv_warn(lev+2,off+len,
999     "Sheet cell list initial byte unknown value (ignored)");
1000     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
1001     }
1002     len ++;
1003    
1004     psiconv_progress(lev+2,off+len,
1005     "Going to read the number of defined cells");
1006     listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
1007     if (res)
1008     goto ERROR2;
1009     psiconv_debug(lev+2,off+len,"Number of defined cells: %d",listlen);
1010     len += leng;
1011    
1012     psiconv_progress(lev+2,off+len,"Going to read all cells");
1013     for (i = 0; i < listlen; i++) {
1014     psiconv_progress(lev+3,off+len,"Going to read cell %d",i);
1015 frodo 121 if ((res = psiconv_parse_sheet_cell(buf,lev+3,off+len,&leng,&cell,
1016 frodo 128 default_layout,row_default_layouts,
1017     col_default_layouts)))
1018 frodo 110 goto ERROR2;
1019     if ((res = psiconv_list_add(*result,cell)))
1020     goto ERROR3;
1021 frodo 120 free(cell);
1022 frodo 110 len += leng;
1023     }
1024    
1025     if (length)
1026     *length = len;
1027    
1028     psiconv_progress(lev,off+len-1,
1029     "End of sheet cell list (total length: %08x)", len);
1030     return 0;
1031    
1032     ERROR3:
1033     psiconv_free_sheet_cell(cell);
1034     ERROR2:
1035     psiconv_free_sheet_cell_list(*result);
1036     ERROR1:
1037     psiconv_warn(lev+1,off,"Reading of Sheet Cells List failed");
1038     if (length)
1039     *length = 0;
1040     if (!res)
1041     return -PSICONV_E_NOMEM;
1042     else
1043     return res;
1044     }
1045    
1046    
1047 frodo 111 int psiconv_parse_sheet_worksheet_list( const psiconv_buffer buf, int lev,
1048     psiconv_u32 off, int *length,
1049     psiconv_sheet_worksheet_list *result)
1050 frodo 110 {
1051 frodo 111 psiconv_sheet_worksheet worksheet;
1052 frodo 110 int res=0;
1053     int len=0;
1054 frodo 111 psiconv_u8 temp;
1055     psiconv_u32 offset;
1056     int leng,i,nr;
1057 frodo 110
1058 frodo 111 psiconv_progress(lev+1,off,"Going to read the worksheet list");
1059     if (!(*result = psiconv_list_new(sizeof(*worksheet))))
1060     goto ERROR1;
1061    
1062 frodo 110 psiconv_progress(lev+2,off+len,
1063     "Going to read the initial bytes (%02x expected)",0x02);
1064     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
1065     if (res)
1066 frodo 111 goto ERROR2;
1067     if (temp != 0x02) {
1068 frodo 110 psiconv_warn(lev+2,off+len,
1069 frodo 111 "Sheet worksheet list initial byte unknown value (ignored)");
1070 frodo 110 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
1071     }
1072     len ++;
1073    
1074 frodo 111 psiconv_progress(lev+2,off+len,"Going to read the list length");
1075     nr = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
1076 frodo 110 if (res)
1077 frodo 111 goto ERROR2;
1078     psiconv_debug(lev+2,off+len,"Length: %02x",nr);
1079     len += leng;
1080 frodo 110
1081 frodo 111 psiconv_progress(lev+2,off+len,"Going to read the list");
1082     for (i=0 ; i < nr; i++) {
1083     psiconv_progress(lev+3,off+len,"Going to read element %d",i);
1084     psiconv_progress(lev+4,off+len,
1085     "Going to read the initial byte (%02x expected)",0x00);
1086     temp = psiconv_read_u8(buf,lev+4,off+len,&res);
1087     if (res)
1088     goto ERROR2;
1089     if (temp != 0x00) {
1090     psiconv_warn(lev+4,off+len,
1091     "Sheet worksheet element initial byte unknown value (ignored)");
1092     psiconv_debug(lev+4,off+len,"Initial byte: %02x",temp);
1093     }
1094     len ++;
1095    
1096     psiconv_progress(lev+4,off+len,"Going to read the worksheet offset");
1097     offset = psiconv_read_u32(buf,lev+2,off+len,&res);
1098     if (res)
1099     goto ERROR2;
1100     psiconv_debug(lev+4,off+len,"Offset: %08x",offset);
1101     len += 4;
1102    
1103     if ((res = psiconv_parse_sheet_worksheet(buf,lev+4,offset,NULL,
1104     &worksheet)))
1105     goto ERROR2;
1106     if ((res = psiconv_list_add(*result,worksheet)))
1107     goto ERROR3;
1108 frodo 120 free(worksheet);
1109 frodo 110 }
1110    
1111 frodo 111 if (length)
1112     *length = len;
1113 frodo 110
1114 frodo 111 psiconv_progress(lev,off+len-1,
1115     "End of worksheet list (total length: %08x)", len);
1116 frodo 110
1117 frodo 111 return 0;
1118    
1119     ERROR3:
1120     psiconv_free_sheet_worksheet(worksheet);
1121     ERROR2:
1122     psiconv_free_sheet_worksheet_list(*result);
1123     ERROR1:
1124     psiconv_warn(lev+1,off,"Reading of worksheet list failed");
1125     if (length)
1126     *length = 0;
1127     if (!res)
1128     return -PSICONV_E_NOMEM;
1129     else
1130     return res;
1131     }
1132    
1133     int psiconv_parse_sheet_cell_layout(const psiconv_buffer buf, int lev,
1134     psiconv_u32 off, int *length,
1135 frodo 121 psiconv_sheet_cell_layout result)
1136 frodo 111
1137     {
1138     int res=0;
1139     int len=0;
1140     int leng;
1141     psiconv_u8 temp;
1142    
1143     psiconv_progress(lev+1,off,"Going to read a sheet cell layout");
1144 frodo 110
1145     psiconv_progress(lev+2,off+len,
1146 frodo 111 "Going to read the first byte (%02x expected)",0x02);
1147 frodo 110 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
1148     if (res)
1149 frodo 121 goto ERROR1;
1150 frodo 110 if (temp != 0x02) {
1151     psiconv_warn(lev+2,off+len,
1152     "Worksheet section initial byte unknown value (ignored)");
1153     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
1154     }
1155     len ++;
1156    
1157     psiconv_progress(lev+2,off+len,"Going to read the default formats flag");
1158     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
1159     if (res)
1160 frodo 121 goto ERROR1;
1161 frodo 110 len ++;
1162    
1163     if (temp & 0x01) {
1164     psiconv_progress(lev+3,off+len,"Going to read the default paragraph codes");
1165     if ((res = psiconv_parse_paragraph_layout_list(buf,lev+3,off+len,&leng,
1166 frodo 121 result->paragraph)))
1167     goto ERROR1;
1168 frodo 110 len += leng;
1169     }
1170    
1171     if (temp & 0x02) {
1172     psiconv_progress(lev+3,off+len,"Going to read the default character codes");
1173     if ((res = psiconv_parse_character_layout_list(buf,lev+3,off+len,&leng,
1174 frodo 121 result->character)))
1175     goto ERROR1;
1176 frodo 110 len += leng;
1177     }
1178    
1179     if (temp & 0x04) {
1180 frodo 111 psiconv_progress(lev+3,off+len, "Going to read the default number format");
1181     psiconv_parse_sheet_numberformat(buf,lev+3,off+len,&leng,
1182 frodo 121 result->numberformat);
1183 frodo 111 len += leng;
1184 frodo 110 }
1185 frodo 111
1186     if (length)
1187     *length = len;
1188    
1189     psiconv_progress(lev,off+len-1,
1190     "End of sheet cell layout (total length: %08x)", len);
1191    
1192     return 0;
1193    
1194     ERROR1:
1195     psiconv_warn(lev+1,off,"Reading of sheet cell layout failed");
1196     if (length)
1197     *length = 0;
1198     if (!res)
1199     return -PSICONV_E_NOMEM;
1200     else
1201     return res;
1202     }
1203 frodo 110
1204 frodo 111
1205     int psiconv_parse_sheet_worksheet(const psiconv_buffer buf, int lev,
1206     psiconv_u32 off, int *length,
1207     psiconv_sheet_worksheet *result)
1208     {
1209     int res=0;
1210 frodo 128 psiconv_u32 temp,cells_off,grid_off,rows_off,cols_off;
1211 frodo 111 int len=0;
1212     int leng;
1213    
1214     psiconv_progress(lev+1,off,"Going to read the sheet worksheet section");
1215     if (!(*result = malloc(sizeof(**result))))
1216     goto ERROR1;
1217    
1218 frodo 110 psiconv_progress(lev+2,off+len,
1219 frodo 111 "Going to read the initial bytes (%02x expected)",0x04);
1220     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
1221     if (res)
1222     goto ERROR2;
1223     if (temp != 0x04) {
1224     psiconv_warn(lev+2,off+len,
1225     "Worksheet section initial byte unknown value (ignored)");
1226     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
1227     }
1228     len ++;
1229    
1230     psiconv_progress(lev+2,off+len, "Going to read the flags byte");
1231     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
1232     if (res)
1233     goto ERROR2;
1234     psiconv_debug(lev+2,off+len,"Flags byte: %02x",temp);
1235     (*result)->show_zeros = (temp & 0x01)?psiconv_bool_true:psiconv_bool_false;
1236     if (temp & 0xfe) {
1237     psiconv_warn(lev+2,off+len,
1238     "Worksheet section flags byte unknown bits (ignored)");
1239     }
1240     len ++;
1241    
1242     psiconv_progress(lev+2,off+len,"Going to read the default cell layout");
1243 frodo 121 if (!((*result)->default_layout = psiconv_basic_cell_layout()))
1244     goto ERROR2;
1245 frodo 111 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,&leng,
1246 frodo 121 (*result)->default_layout)))
1247     goto ERROR3;
1248 frodo 111 len += leng;
1249    
1250     psiconv_progress(lev+2,off+len,
1251 frodo 128 "Going to read the offset of the row defaults Section");
1252     rows_off = psiconv_read_u32(buf,lev+2,off+len,&res);
1253 frodo 110 if (res)
1254 frodo 111 goto ERROR3;
1255 frodo 128 psiconv_debug(lev+2,off+len,"Offset: %04x",rows_off);
1256 frodo 110 len += 4;
1257    
1258     psiconv_progress(lev+2,off+len,
1259 frodo 128 "Going to read the offset of the column defaults Section");
1260     cols_off = psiconv_read_u32(buf,lev+2,off+len,&res);
1261 frodo 110 if (res)
1262 frodo 111 goto ERROR3;
1263 frodo 128 psiconv_debug(lev+2,off+len,"Offset: %04x",cols_off);
1264 frodo 110 len += 4;
1265    
1266     psiconv_progress(lev+2,off+len,
1267     "Going to read the offset of the Cells List");
1268     cells_off = psiconv_read_u32(buf,lev+2,off+len,&res);
1269     if (res)
1270 frodo 111 goto ERROR3;
1271 frodo 110 psiconv_debug(lev+2,off+len,"Offset: %04x",cells_off);
1272     len += 4;
1273    
1274     psiconv_progress(lev+2,off+len,
1275     "Going to read the offset of the Grid Section");
1276     grid_off = psiconv_read_u32(buf,lev+2,off+len,&res);
1277     if (res)
1278 frodo 111 goto ERROR3;
1279 frodo 110 psiconv_debug(lev+2,off+len,"Offset: %04x",grid_off);
1280     len += 4;
1281    
1282     psiconv_progress(lev+2,off+len,
1283     "Going to read the offset of the 3rd ??? Section");
1284     temp = psiconv_read_u32(buf,lev+2,off+len,&res);
1285     if (res)
1286 frodo 111 goto ERROR3;
1287 frodo 110 psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
1288     len += 4;
1289    
1290 frodo 128 psiconv_progress(lev+2,off+len,"Going to read the row defaults");
1291     if ((res = psiconv_parse_sheet_line_list(buf,lev+2,rows_off,NULL,
1292     &(*result)->row_default_layouts,
1293     (*result)->default_layout)))
1294     goto ERROR3;
1295    
1296     psiconv_progress(lev+2,off+len,"Going to read the column defaults");
1297     if ((res = psiconv_parse_sheet_line_list(buf,lev+2,cols_off,NULL,
1298     &(*result)->col_default_layouts,
1299     (*result)->default_layout)))
1300     goto ERROR4;
1301    
1302 frodo 110 psiconv_progress(lev+2,off+len,"Going to read the cells list");
1303     if ((res = psiconv_parse_sheet_cell_list(buf,lev+2,cells_off,NULL,
1304 frodo 121 &(*result)->cells,
1305 frodo 128 (*result)->default_layout,
1306     (*result)->row_default_layouts,
1307     (*result)->col_default_layouts)))
1308     goto ERROR5;
1309 frodo 110
1310    
1311     /* TODO: parse grid section */
1312    
1313     if (length)
1314     *length = len;
1315    
1316     psiconv_progress(lev,off+len-1,
1317     "End of sheet worksheet section (total length: %08x)", len);
1318     return 0;
1319    
1320 frodo 128 ERROR5:
1321     psiconv_free_sheet_line_list((*result)->col_default_layouts);
1322     ERROR4:
1323     psiconv_free_sheet_line_list((*result)->row_default_layouts);
1324 frodo 111 ERROR3:
1325     psiconv_free_sheet_cell_layout((*result)->default_layout);
1326 frodo 110 ERROR2:
1327     free (*result);
1328     ERROR1:
1329     psiconv_warn(lev+1,off,"Reading of Sheet Worksheet Section failed");
1330     if (length)
1331     *length = 0;
1332     if (!res)
1333     return -PSICONV_E_NOMEM;
1334     else
1335     return res;
1336     }
1337    
1338 frodo 128 int psiconv_parse_sheet_line(const psiconv_buffer buf, int lev,
1339     psiconv_u32 off, int *length,
1340     psiconv_sheet_line *result,
1341     const psiconv_sheet_cell_layout default_layout)
1342     {
1343     int res=0;
1344     int len=0;
1345     int leng;
1346 frodo 110
1347 frodo 128
1348     psiconv_progress(lev+1,off,"Going to read a sheet line");
1349     if (!(*result = malloc(sizeof(**result))))
1350     goto ERROR1;
1351    
1352     psiconv_progress(lev+2,off+len,"Going to read the line number");
1353     (*result)->position = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
1354     if (res)
1355     goto ERROR2;
1356     psiconv_debug(lev+2,off+len,"Line number: %d\n",(*result)->position);
1357     len += leng;
1358    
1359     if (!((*result)->layout = psiconv_clone_cell_layout(default_layout)))
1360     goto ERROR2;
1361     if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,
1362     &leng,(*result)->layout)))
1363     goto ERROR3;
1364     len += leng;
1365    
1366     if (length)
1367     *length = len;
1368    
1369     psiconv_progress(lev,off+len-1,
1370     "End of the sheet line (total length: %08x)", len);
1371     return 0;
1372    
1373     ERROR3:
1374     psiconv_free_sheet_cell_layout((*result)->layout);
1375     ERROR2:
1376     free (*result);
1377     ERROR1:
1378     psiconv_warn(lev+1,off,"Reading of the sheet line failed");
1379     if (length)
1380     *length = 0;
1381     if (!res)
1382     return -PSICONV_E_NOMEM;
1383     else
1384     return res;
1385     }
1386    
1387    
1388     int psiconv_parse_sheet_line_list(const psiconv_buffer buf, int lev,
1389     psiconv_u32 off, int *length,
1390     psiconv_sheet_line_list *result,
1391     const psiconv_sheet_cell_layout default_layout)
1392     {
1393     int res=0;
1394     int len=0;
1395     psiconv_u32 temp;
1396     psiconv_sheet_line line;
1397     psiconv_u32 listlen,i;
1398     int leng;
1399    
1400     psiconv_progress(lev+1,off,"Going to read the sheet line list");
1401     if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_line_s))))
1402     goto ERROR1;
1403    
1404     psiconv_progress(lev+2,off+len,
1405     "Going to read the initial byte (%02x expected)",0x02);
1406     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
1407     if (res)
1408     goto ERROR2;
1409     if (temp != 0x02) {
1410     psiconv_warn(lev+2,off+len,
1411     "Sheet line list initial byte unknown value (ignored)");
1412     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
1413     }
1414     len ++;
1415    
1416     psiconv_progress(lev+2,off+len,
1417     "Going to read the number of defined lines");
1418     listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
1419     if (res)
1420     goto ERROR2;
1421     psiconv_debug(lev+2,off+len,"Number of defined lines: %d",listlen);
1422     len += leng;
1423    
1424     psiconv_progress(lev+2,off+len,"Going to read all lines");
1425     for (i = 0; i < listlen; i++) {
1426     psiconv_progress(lev+3,off+len,"Going to read line %d",i);
1427     if ((res = psiconv_parse_sheet_line(buf,lev+3,off+len,&leng,&line,
1428     default_layout)))
1429     goto ERROR2;
1430     if ((res = psiconv_list_add(*result,line)))
1431     goto ERROR3;
1432     free(line);
1433     len += leng;
1434     }
1435    
1436     if (length)
1437     *length = len;
1438    
1439     psiconv_progress(lev,off+len-1,
1440     "End of sheet line list (total length: %08x)", len);
1441     return 0;
1442    
1443     ERROR3:
1444     psiconv_free_sheet_line(line);
1445     ERROR2:
1446     psiconv_free_sheet_line_list(*result);
1447     ERROR1:
1448     psiconv_warn(lev+1,off,"Reading of Sheet Line List failed");
1449     if (length)
1450     *length = 0;
1451     if (!res)
1452     return -PSICONV_E_NOMEM;
1453     else
1454     return res;
1455     }
1456    
1457 frodo 129 int psiconv_parse_sheet_variable(const psiconv_buffer buf, int lev,
1458     psiconv_u32 off, int *length,
1459     psiconv_sheet_variable *result)
1460     {
1461     int res=0;
1462     int len=0;
1463     psiconv_u32 marker;
1464     int leng;
1465    
1466     psiconv_progress(lev+1,off,"Going to read a sheet variable");
1467     if (!(*result = malloc(sizeof(**result))))
1468     goto ERROR1;
1469    
1470     psiconv_progress(lev+2,off+len, "Going to read the variable name");
1471     (*result)->name = psiconv_read_string(buf,lev+2,off+len,&leng,&res);
1472     if (res)
1473     goto ERROR2;
1474     len += leng;
1475    
1476     psiconv_progress(lev+2,off+len,"Going to read the type marker");
1477     marker = psiconv_read_u8(buf,lev+2,off+len,&res);
1478     if (res)
1479     goto ERROR3;
1480     psiconv_debug(lev+2,off+len,"Marker: %02x",marker);
1481     len ++;
1482    
1483     if (marker == 0x00) {
1484     (*result)->type = psiconv_var_int;
1485     psiconv_progress(lev+2,off+len,"Going to read a signed integer");
1486     (*result)->data.dat_int = psiconv_read_sint(buf,lev+2,off+len,&leng,&res);
1487     if (res)
1488     goto ERROR3;
1489     psiconv_debug(lev+2,off+len,"Value: %d",(*result)->data.dat_int);
1490     len += leng;
1491     } else if (marker == 0x01) {
1492     (*result)->type = psiconv_var_float;
1493     psiconv_progress(lev+2,off+len,"Going to read a floating point number");
1494     (*result)->data.dat_float = psiconv_read_float(buf,lev+2,off+len,&leng,
1495     &res);
1496     if (res)
1497     goto ERROR3;
1498     psiconv_debug(lev+2,off+len,"Value: %f",(*result)->data.dat_float);
1499     len += leng;
1500     } else if (marker == 0x02) {
1501     (*result)->type = psiconv_var_string;
1502     psiconv_progress(lev+2,off+len,"Going to read a string");
1503     (*result)->data.dat_string = psiconv_read_string(buf,lev+2,off+len,&leng,
1504     &res);
1505     if (res)
1506     goto ERROR3;
1507     len += leng;
1508     } else if (marker == 0x03) {
1509     (*result)->type = psiconv_var_cellref;
1510     psiconv_progress(lev+2,off+len,"Going to read a cell reference");
1511     (*result)->data.dat_cellref = psiconv_read_var_cellref(buf,lev+2,off+len,
1512     &leng, &res);
1513     if (res)
1514     goto ERROR3;
1515     len += leng;
1516     } else if (marker == 0x04) {
1517     (*result)->type = psiconv_var_cellblock;
1518     psiconv_progress(lev+2,off+len,"Going to read a cell block reference");
1519     (*result)->data.dat_cellblock = psiconv_read_var_cellblock(buf,lev+2,
1520     off+len,
1521     &leng, &res);
1522     if (res)
1523     goto ERROR3;
1524     len += leng;
1525     } else {
1526     psiconv_warn(lev+2,off+len,"Sheet variable unknown type marker");
1527     res = -PSICONV_E_PARSE;
1528     goto ERROR3;
1529     }
1530    
1531     psiconv_progress(lev+2,off+len,"Going to read the variable number");
1532     (*result)->number = psiconv_read_u32(buf,lev+2,off+len,&res);
1533     if (res)
1534     goto ERROR4;
1535     psiconv_debug(lev+2,off+len,"Number: %08x",(*result)->number);
1536     len += 4;
1537    
1538     if (length)
1539     *length = len;
1540    
1541     psiconv_progress(lev,off+len-1,
1542     "End of sheet variable (total length: %08x)", len);
1543     return 0;
1544    
1545     ERROR4:
1546     if ((*result)->type == psiconv_var_string)
1547     free((*result)->data.dat_string);
1548     ERROR3:
1549     free((*result)->name);
1550     ERROR2:
1551     free (*result);
1552     ERROR1:
1553     psiconv_warn(lev+1,off,"Reading of Sheet Variable failed");
1554     if (length)
1555     *length = 0;
1556     if (!res)
1557     return -PSICONV_E_NOMEM;
1558     else
1559     return res;
1560     }
1561    
1562    
1563     int psiconv_parse_sheet_variable_list(const psiconv_buffer buf, int lev,
1564     psiconv_u32 off, int *length,
1565     psiconv_sheet_variable_list *result)
1566     {
1567     int res=0;
1568     int len=0;
1569     psiconv_u32 temp;
1570     psiconv_sheet_variable variable;
1571     psiconv_u32 listlen,i;
1572     int leng;
1573    
1574     psiconv_progress(lev+1,off,"Going to read the sheet variable list");
1575     if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_variable_s))))
1576     goto ERROR1;
1577    
1578     psiconv_progress(lev+2,off+len,
1579     "Going to read the initial byte (%02x expected)",0x02);
1580     temp = psiconv_read_u8(buf,lev+2,off+len,&res);
1581     if (res)
1582     goto ERROR2;
1583     if (temp != 0x02) {
1584     psiconv_warn(lev+2,off+len,
1585     "Sheet variable list initial byte unknown value (ignored)");
1586     psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
1587     }
1588     len ++;
1589    
1590     psiconv_progress(lev+2,off+len,
1591     "Going to read the number of variables");
1592     listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
1593     if (res)
1594     goto ERROR2;
1595     psiconv_debug(lev+2,off+len,"Number of variables: %d",listlen);
1596     len += leng;
1597    
1598     psiconv_progress(lev+2,off+len,"Going to read all variables");
1599     for (i = 0; i < listlen; i++) {
1600     psiconv_progress(lev+3,off+len,"Going to read variable %d",i);
1601     if ((res = psiconv_parse_sheet_variable(buf,lev+3,off+len,&leng,&variable)))
1602     goto ERROR2;
1603     if ((res = psiconv_list_add(*result,variable)))
1604     goto ERROR3;
1605     len += leng;
1606     }
1607    
1608     if (length)
1609     *length = len;
1610    
1611     psiconv_progress(lev,off+len-1,
1612     "End of sheet variabels list (total length: %08x)", len);
1613     return 0;
1614    
1615     ERROR3:
1616     psiconv_free_sheet_variable(variable);
1617     ERROR2:
1618     psiconv_list_free(*result);
1619     ERROR1:
1620     psiconv_warn(lev+1,off,"Reading of Sheet Variable list failed");
1621     if (length)
1622     *length = 0;
1623     if (!res)
1624     return -PSICONV_E_NOMEM;
1625     else
1626     return res;
1627     }
frodo@frodo.looijaard.name
 ViewVC Help
Powered by ViewVC 1.1.26