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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 111 Revision 130
… …
23#include <stdlib.h> 23#include <stdlib.h>
24 24
25#include "parse_routines.h" 25#include "parse_routines.h"
26#include "error.h" 26#include "error.h"
27 27
28static 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;
42ERROR4:
43 psiconv_free_paragraph_layout(result->paragraph);
44ERROR3:
45 psiconv_free_character_layout(result->character);
46ERROR2:
47 free(result);
48ERROR1:
49 return NULL;
50}
51
52static 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;
69ERROR4:
70 psiconv_free_paragraph_layout(result->paragraph);
71ERROR3:
72 psiconv_free_character_layout(result->character);
73ERROR2:
74 free(result);
75ERROR1:
76 return NULL;
77}
78
79static 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;
130ERROR1:
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
139static 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;
213ERROR1:
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
28int psiconv_parse_sheet_numberformat(const psiconv_buffer buf, int lev, 222int psiconv_parse_sheet_numberformat(const psiconv_buffer buf, int lev,
29 psiconv_u32 off, int *length, 223 psiconv_u32 off, int *length,
30 psiconv_sheet_numberformat *result) 224 psiconv_sheet_numberformat result)
31{ 225{
32 int res=0; 226 int res=0;
33 int len=0; 227 int len=0;
34 psiconv_u8 temp; 228 psiconv_u8 temp;
35 229
36 psiconv_progress(lev+1,off,"Going to read a sheet numberformat"); 230 psiconv_progress(lev+1,off,"Going to read a sheet numberformat");
37 if (!(*result = malloc(sizeof(**result))))
38 goto ERROR1;
39 231
40 psiconv_progress(lev+2,off+len, 232 psiconv_progress(lev+2,off+len,
41 "Going to read the initial byte (%02x expected)",0x02); 233 "Going to read the initial byte (%02x expected)",0x02);
42 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 234 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
43 if (res) 235 if (res)
44 goto ERROR2; 236 goto ERROR1;
45 if (temp != 0x02) { 237 if (temp != 0x02) {
46 psiconv_warn(lev+2,off+len, 238 psiconv_warn(lev+2,off+len,
47 "Sheet numberformat initial byte unknown value (ignored)"); 239 "Sheet numberformat initial byte unknown value (ignored)");
48 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 240 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
49 } 241 }
50 len ++; 242 len ++;
51 243
52 psiconv_progress(lev+2,off+len, "Going to read the code byte"); 244 psiconv_progress(lev+2,off+len, "Going to read the code byte");
53 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 245 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
54 if (res) 246 if (res)
55 goto ERROR2; 247 goto ERROR1;
56 psiconv_debug(lev+2,off+len,"Code: %02x",temp); 248 psiconv_debug(lev+2,off+len,"Code: %02x",temp);
57 if (temp == 0x00) 249 if (temp == 0x00)
58 (*result)->code = psiconv_numberformat_general; 250 result->code = psiconv_numberformat_general;
59 else if (temp == 0x02) 251 else if (temp == 0x02)
60 (*result)->code = psiconv_numberformat_fixeddecimal; 252 result->code = psiconv_numberformat_fixeddecimal;
61 else if (temp == 0x04) 253 else if (temp == 0x04)
62 (*result)->code = psiconv_numberformat_scientific; 254 result->code = psiconv_numberformat_scientific;
63 else if (temp == 0x06) 255 else if (temp == 0x06)
64 (*result)->code = psiconv_numberformat_currency; 256 result->code = psiconv_numberformat_currency;
65 else if (temp == 0x08) 257 else if (temp == 0x08)
66 (*result)->code = psiconv_numberformat_percent; 258 result->code = psiconv_numberformat_percent;
67 else if (temp == 0x0A) 259 else if (temp == 0x0A)
68 (*result)->code = psiconv_numberformat_triads; 260 result->code = psiconv_numberformat_triads;
69 else if (temp == 0x0C) 261 else if (temp == 0x0C)
70 (*result)->code = psiconv_numberformat_boolean; 262 result->code = psiconv_numberformat_boolean;
71 else if (temp == 0x0E) 263 else if (temp == 0x0E)
72 (*result)->code = psiconv_numberformat_text; 264 result->code = psiconv_numberformat_text;
73 else if (temp == 0x10) 265 else if (temp == 0x10)
74 (*result)->code = psiconv_numberformat_date_ddmm; 266 result->code = psiconv_numberformat_date_dmm;
75 else if (temp == 0x12) 267 else if (temp == 0x12)
76 (*result)->code = psiconv_numberformat_date_mmdd; 268 result->code = psiconv_numberformat_date_mmd;
77 else if (temp == 0x14) 269 else if (temp == 0x14)
78 (*result)->code = psiconv_numberformat_date_ddmmyy; 270 result->code = psiconv_numberformat_date_ddmmyy;
79 else if (temp == 0x16) 271 else if (temp == 0x16)
80 (*result)->code = psiconv_numberformat_date_mmddyy; 272 result->code = psiconv_numberformat_date_mmddyy;
81 else if (temp == 0x18) 273 else if (temp == 0x18)
82 (*result)->code = psiconv_numberformat_date_yymmdd; 274 result->code = psiconv_numberformat_date_yymmdd;
83 else if (temp == 0x1A) 275 else if (temp == 0x1A)
84 (*result)->code = psiconv_numberformat_date_ddmmm; 276 result->code = psiconv_numberformat_date_dmmm;
85 else if (temp == 0x1C) 277 else if (temp == 0x1C)
86 (*result)->code = psiconv_numberformat_date_ddmmmyy; 278 result->code = psiconv_numberformat_date_dmmmyy;
87 else if (temp == 0x1E) 279 else if (temp == 0x1E)
88 (*result)->code = psiconv_numberformat_date_ddmmmyyyy; 280 result->code = psiconv_numberformat_date_ddmmmyy;
89 else if (temp == 0x20) 281 else if (temp == 0x20)
90 (*result)->code = psiconv_numberformat_date_mmm; 282 result->code = psiconv_numberformat_date_mmm;
91 else if (temp == 0x22) 283 else if (temp == 0x22)
92 (*result)->code = psiconv_numberformat_date_monthname; 284 result->code = psiconv_numberformat_date_monthname;
93 else if (temp == 0x24) 285 else if (temp == 0x24)
94 (*result)->code = psiconv_numberformat_date_mmmyy; 286 result->code = psiconv_numberformat_date_mmmyy;
95 else if (temp == 0x26) 287 else if (temp == 0x26)
96 (*result)->code = psiconv_numberformat_date_monthnameyy; 288 result->code = psiconv_numberformat_date_monthnameyy;
97 else if (temp == 0x28) 289 else if (temp == 0x28)
98 (*result)->code = psiconv_numberformat_date_monthnameddyyyy; 290 result->code = psiconv_numberformat_date_monthnamedyyyy;
99 else if (temp == 0x2A) 291 else if (temp == 0x2A)
100 (*result)->code = psiconv_numberformat_datetime_ddmmyyyyhhii; 292 result->code = psiconv_numberformat_datetime_ddmmyyyyhhii;
101 else if (temp == 0x2C) 293 else if (temp == 0x2C)
102 (*result)->code = psiconv_numberformat_datetime_ddmmyyyyHHii; 294 result->code = psiconv_numberformat_datetime_ddmmyyyyHHii;
103 else if (temp == 0x2E) 295 else if (temp == 0x2E)
104 (*result)->code = psiconv_numberformat_datetime_mmddyyyyhhii; 296 result->code = psiconv_numberformat_datetime_mmddyyyyhhii;
105 else if (temp == 0x30) 297 else if (temp == 0x30)
106 (*result)->code = psiconv_numberformat_datetime_mmddyyyyHHii; 298 result->code = psiconv_numberformat_datetime_mmddyyyyHHii;
107 else if (temp == 0x32) 299 else if (temp == 0x32)
108 (*result)->code = psiconv_numberformat_datetime_yyyymmddhhii; 300 result->code = psiconv_numberformat_datetime_yyyymmddhhii;
109 else if (temp == 0x34) 301 else if (temp == 0x34)
110 (*result)->code = psiconv_numberformat_datetime_yyyymmddHHii; 302 result->code = psiconv_numberformat_datetime_yyyymmddHHii;
111 else if (temp == 0x36) 303 else if (temp == 0x36)
112 (*result)->code = psiconv_numberformat_time_hhii; 304 result->code = psiconv_numberformat_time_hhii;
113 else if (temp == 0x38) 305 else if (temp == 0x38)
114 (*result)->code = psiconv_numberformat_time_hhiiss; 306 result->code = psiconv_numberformat_time_hhiiss;
115 else if (temp == 0x3A) 307 else if (temp == 0x3A)
116 (*result)->code = psiconv_numberformat_time_HHii; 308 result->code = psiconv_numberformat_time_HHii;
117 else if (temp == 0x3C) 309 else if (temp == 0x3C)
118 (*result)->code = psiconv_numberformat_time_HHiiss; 310 result->code = psiconv_numberformat_time_HHiiss;
119 else { 311 else {
120 psiconv_warn(lev+2,off+len,"Unknown number format (assumed general)"); 312 psiconv_warn(lev+2,off+len,"Unknown number format (assumed general)");
121 (*result)->code = psiconv_numberformat_general; 313 result->code = psiconv_numberformat_general;
122 } 314 }
123 len ++; 315 len ++;
124 316
125 psiconv_progress(lev+2,off+len, "Going to read the number of decimals"); 317 psiconv_progress(lev+2,off+len, "Going to read the number of decimals");
126 (*result)->decimal = psiconv_read_u8(buf,lev+2,off+len,&res); 318 result->decimal = psiconv_read_u8(buf,lev+2,off+len,&res) >> 1;
127 if (res) 319 if (res)
128 goto ERROR2; 320 goto ERROR1;
129 psiconv_debug(lev+2,off+len,"Decimals: %d",(*result)->decimal); 321 psiconv_debug(lev+2,off+len,"Decimals: %d",result->decimal);
130 len ++; 322 len ++;
131 323
132 if (length) 324 if (length)
133 *length = len; 325 *length = len;
134 326
135 psiconv_progress(lev,off+len-1, 327 psiconv_progress(lev,off+len-1,
136 "End of sheet number format (total length: %08x)", len); 328 "End of sheet number format (total length: %08x)", len);
137 return 0; 329 return 0;
138 330
139ERROR2:
140 free (*result);
141ERROR1: 331ERROR1:
142 psiconv_warn(lev+1,off,"Reading of Sheet Number Format failed"); 332 psiconv_warn(lev+1,off,"Reading of Sheet Number Format failed");
143 if (length) 333 if (length)
144 *length = 0; 334 *length = 0;
145 if (!res) 335 if (!res)
… …
264 if (res) 454 if (res)
265 goto ERROR2; 455 goto ERROR2;
266 if (temp != 0x00) { 456 if (temp != 0x00) {
267 psiconv_warn(lev+2,off+len, 457 psiconv_warn(lev+2,off+len,
268 "Sheet status section unknown byte unknown value (ignored)"); 458 "Sheet status section unknown byte unknown value (ignored)");
269 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 459 psiconv_debug(lev+2,off+len,"Unknown byte: %02x",temp);
270 } 460 }
271 len ++; 461 len ++;
272 462
273 psiconv_progress(lev+2,off+len,"Going to read sheet display size"); 463 psiconv_progress(lev+2,off+len,"Going to read sheet display size");
274 (*result)->sheet_display_size = psiconv_read_u32(buf,lev+2,off + len,&res); 464 (*result)->sheet_display_size = psiconv_read_u32(buf,lev+2,off + len,&res);
… …
307 497
308int psiconv_parse_sheet_workbook_section(const psiconv_buffer buf, int lev, 498int psiconv_parse_sheet_workbook_section(const psiconv_buffer buf, int lev,
309 psiconv_u32 off, int *length, 499 psiconv_u32 off, int *length,
310 psiconv_sheet_workbook_section *result) 500 psiconv_sheet_workbook_section *result)
311{ 501{
312 int res=0; 502 int res=0,with_name;
313 psiconv_u32 temp,formulas_off,worksheets_off; 503 psiconv_u32 temp,formulas_off,worksheets_off,info_off,var_off,name_off=0;
314 int len=0; 504 int len=0;
315 505
316 psiconv_progress(lev+1,off,"Going to read the sheet workbook section"); 506 psiconv_progress(lev+1,off,"Going to read the sheet workbook section");
317 if (!(*result = malloc(sizeof(**result)))) 507 if (!(*result = malloc(sizeof(**result))))
318 goto ERROR1; 508 goto ERROR1;
319 509
320 psiconv_progress(lev+2,off+len, 510 psiconv_progress(lev+2,off+len,
321 "Going to read the initial byte (%02x expected)",0x04); 511 "Going to read the initial byte (%02x or %02x expected)",
512 0x02,0x04);
322 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 513 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
323 if (res) 514 if (res)
324 goto ERROR2; 515 goto ERROR2;
325 if (temp != 0x04) { 516 if ((temp != 0x04) && temp !=0x02) {
326 psiconv_warn(lev+2,off+len, 517 psiconv_warn(lev+2,off+len,
327 "Sheet workbook section initial byte unknown value (ignored)"); 518 "Sheet workbook section initial byte unknown value (ignored)");
328 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 519 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
329 } 520 }
521 with_name = temp ==0x04;
330 len ++; 522 len ++;
331 523
332 psiconv_progress(lev+2,off+len, 524 psiconv_progress(lev+2,off+len,
333 "Going to read the offset of the 1st ??? Section"); 525 "Going to read the offset of the sheet info Section");
334 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 526 info_off = psiconv_read_u32(buf,lev+2,off+len,&res);
335 if (res) 527 if (res)
336 goto ERROR2; 528 goto ERROR2;
337 psiconv_debug(lev+2,off+len,"Offset: %04x",temp); 529 psiconv_debug(lev+2,off+len,"Offset: %04x",info_off);
338 len += 4; 530 len += 4;
339 531
340 psiconv_progress(lev+2,off+len, 532 psiconv_progress(lev+2,off+len,
341 "Going to read the offset of the Formulas List"); 533 "Going to read the offset of the Formulas List");
342 formulas_off = psiconv_read_u32(buf,lev+2,off+len,&res); 534 formulas_off = psiconv_read_u32(buf,lev+2,off+len,&res);
… …
352 goto ERROR2; 544 goto ERROR2;
353 psiconv_debug(lev+2,off+len,"Offset: %04x",worksheets_off); 545 psiconv_debug(lev+2,off+len,"Offset: %04x",worksheets_off);
354 len += 4; 546 len += 4;
355 547
356 psiconv_progress(lev+2,off+len, 548 psiconv_progress(lev+2,off+len,
357 "Going to read the offset of the 4th ??? Section"); 549 "Going to read the offset of the Variable List");
358 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 550 var_off = psiconv_read_u32(buf,lev+2,off+len,&res);
359 if (res) 551 if (res)
360 goto ERROR2; 552 goto ERROR2;
361 psiconv_debug(lev+2,off+len,"Offset: %04x",temp); 553 psiconv_debug(lev+2,off+len,"Offset: %04x",var_off);
362 len += 4; 554 len += 4;
363 555
556 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
364 psiconv_progress(lev+2,off+len,"Going to read the formulas list"); 577 psiconv_progress(lev+2,off+len,"Going to read the formulas list");
365 if ((res = psiconv_parse_sheet_formula_table(buf,lev+2,formulas_off,NULL, 578 if ((res = psiconv_parse_sheet_formula_list(buf,lev+2,formulas_off,NULL,
366 &(*result)->formulas))) 579 &(*result)->formulas)))
367 goto ERROR2; 580 goto ERROR4;
368 581
369 psiconv_progress(lev+2,off+len,"Going to read the worksheet list"); 582 psiconv_progress(lev+2,off+len,"Going to read the worksheet list");
370 if ((res = psiconv_parse_sheet_worksheet_list(buf,lev+2,worksheets_off, 583 if ((res = psiconv_parse_sheet_worksheet_list(buf,lev+2,worksheets_off,
371 NULL,&(*result)->worksheets))) 584 NULL,&(*result)->worksheets)))
372 goto ERROR2; 585 goto ERROR5;
373 586
587 if (with_name) {
588 psiconv_progress(lev+2,off+len,"Going to read the name section");
589 if ((res = psiconv_parse_sheet_name_section(buf,lev+2,name_off,NULL,
590 &(*result)->name)))
591 goto ERROR6;
592 } else
593 (*result)->name = NULL;
374 594
375 if (length) 595 if (length)
376 *length = len; 596 *length = len;
377 597
378 psiconv_progress(lev,off+len-1, 598 psiconv_progress(lev,off+len-1,
379 "End of sheet workbook section (total length: %08x)", len); 599 "End of sheet workbook section (total length: %08x)", len);
380 return 0; 600 return 0;
381 601
602ERROR6:
603 psiconv_free_sheet_worksheet_list((*result)->worksheets);
604ERROR5:
605 psiconv_free_formula_list((*result)->formulas);
606ERROR4:
607 psiconv_free_sheet_variable_list((*result)->variables);
608ERROR3:
609 psiconv_free_sheet_info_section((*result)->info);
382ERROR2: 610ERROR2:
383 free (*result); 611 free (*result);
384ERROR1: 612ERROR1:
385 psiconv_warn(lev+1,off,"Reading of Sheet Workbook Section failed"); 613 psiconv_warn(lev+1,off,"Reading of Sheet Workbook Section failed");
386 if (length) 614 if (length)
… …
389 return -PSICONV_E_NOMEM; 617 return -PSICONV_E_NOMEM;
390 else 618 else
391 return res; 619 return res;
392} 620}
393 621
622int psiconv_parse_sheet_name_section(const psiconv_buffer buf, int lev,
623 psiconv_u32 off, int *length,
624 psiconv_sheet_name_section *result)
625{
626 int res=0;
627 psiconv_u32 temp;
628 int len=0,leng;
629
630 psiconv_progress(lev+1,off,"Going to read the sheet name section");
631 if (!(*result = malloc(sizeof(**result))))
632 goto ERROR1;
633
634 psiconv_progress(lev+2,off+len,
635 "Going to read the initial byte (%02x expected)",0x02);
636 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
637 if (res)
638 goto ERROR2;
639 if (temp != 0x02) {
640 psiconv_warn(lev+2,off+len,
641 "Sheet name section initial byte unknown value (ignored)");
642 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
643 }
644 len ++;
645
646 psiconv_progress(lev+2,off+len, "Going to read the sheet name");
647 (*result)->name = psiconv_read_string(buf,lev+2,off+len,&leng,&res);
648 if (res)
649 goto ERROR2;
650 len += leng;
651
652 if (length)
653 *length = len;
654
655 psiconv_progress(lev,off+len-1,
656 "End of sheet name section (total length: %08x)", len);
657 return 0;
658
659ERROR2:
660 free(*result);
661ERROR1:
662 psiconv_warn(lev+1,off,"Reading of Sheet Name Section failed");
663 if (length)
664 *length = 0;
665 if (!res)
666 return -PSICONV_E_NOMEM;
667 else
668 return res;
669}
670
671int psiconv_parse_sheet_info_section(const psiconv_buffer buf, int lev,
672 psiconv_u32 off, int *length,
673 psiconv_sheet_info_section *result)
674{
675 int res=0;
676 psiconv_u32 temp;
677 int len=0;
678
679 psiconv_progress(lev+1,off,"Going to read the sheet info section");
680 if (!(*result = malloc(sizeof(**result))))
681 goto ERROR1;
682
683 psiconv_progress(lev+2,off+len,
684 "Going to read the initial byte (%02x expected)",0x02);
685 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
686 if (res)
687 goto ERROR2;
688 if (temp != 0x02) {
689 psiconv_warn(lev+2,off+len,
690 "Sheet info section initial byte unknown value (ignored)");
691 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
692 }
693 len ++;
694
695 psiconv_progress(lev+2,off+len, "Going to read the flags byte");
696 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
697 if (res)
698 goto ERROR2;
699 (*result)->auto_recalc = temp & 0x01 ? psiconv_bool_true:psiconv_bool_false;
700 psiconv_debug(lev+2,off+len,"Auto recalculation: %02x",
701 (*result)->auto_recalc);
702 if ((temp & 0xfe) != 0x02) {
703 psiconv_warn(lev+2,off+len,"Sheet Info Section flags byte "
704 "contains unknown flags (ignored)");
705 psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp &0xfe);
706 }
707
708 len ++;
709
710
711 if (length)
712 *length = len;
713
714 psiconv_progress(lev,off+len-1,
715 "End of sheet info section (total length: %08x)", len);
716 return 0;
717
718ERROR2:
719 free(*result);
720ERROR1:
721 psiconv_warn(lev+1,off,"Reading of Sheet Name Section failed");
722 if (length)
723 *length = 0;
724 if (!res)
725 return -PSICONV_E_NOMEM;
726 else
727 return res;
728}
729
394int psiconv_parse_sheet_formula_table(const psiconv_buffer buf, int lev, 730int psiconv_parse_sheet_formula_list(const psiconv_buffer buf, int lev,
395 psiconv_u32 off, int *length, 731 psiconv_u32 off, int *length,
396 psiconv_formula_list *result) 732 psiconv_formula_list *result)
397{ 733{
398 int res=0; 734 int res=0;
399 int len=0; 735 int len=0;
400 psiconv_u32 temp; 736 psiconv_u32 temp;
401 psiconv_formula formula; 737 psiconv_formula formula;
402 psiconv_u32 listlen,i; 738 psiconv_u32 listlen,i;
403 int leng; 739 int leng;
404 740
405 psiconv_progress(lev+1,off,"Going to read the sheet formula table"); 741 psiconv_progress(lev+1,off,"Going to read the sheet formula list");
406 if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s)))) 742 if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s))))
407 goto ERROR1; 743 goto ERROR1;
408 744
409 psiconv_progress(lev+2,off+len, 745 psiconv_progress(lev+2,off+len,
410 "Going to read the initial byte (%02x expected)",0x02); 746 "Going to read the initial byte (%02x expected)",0x02);
411 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 747 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
412 if (res) 748 if (res)
413 goto ERROR2; 749 goto ERROR2;
414 if (temp != 0x02) { 750 if (temp != 0x02) {
415 psiconv_warn(lev+2,off+len, 751 psiconv_warn(lev+2,off+len,
416 "Sheet formula table initial byte unknown value (ignored)"); 752 "Sheet formula list initial byte unknown value (ignored)");
417 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 753 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
418 } 754 }
419 len ++; 755 len ++;
420 756
421 psiconv_progress(lev+2,off+len, 757 psiconv_progress(lev+2,off+len,
… …
438 774
439 if (length) 775 if (length)
440 *length = len; 776 *length = len;
441 777
442 psiconv_progress(lev,off+len-1, 778 psiconv_progress(lev,off+len-1,
443 "End of sheet formula table (total length: %08x)", len); 779 "End of sheet formula list (total length: %08x)", len);
444 return 0; 780 return 0;
445 781
446ERROR3: 782ERROR3:
447 psiconv_free_formula(formula); 783 psiconv_free_formula(formula);
448ERROR2: 784ERROR2:
449 psiconv_list_free(*result); 785 psiconv_list_free(*result);
450ERROR1: 786ERROR1:
451 psiconv_warn(lev+1,off,"Reading of Sheet Formula Table failed"); 787 psiconv_warn(lev+1,off,"Reading of Sheet Formula list failed");
452 if (length) 788 if (length)
453 *length = 0; 789 *length = 0;
454 if (!res) 790 if (!res)
455 return -PSICONV_E_NOMEM; 791 return -PSICONV_E_NOMEM;
456 else 792 else
457 return res; 793 return res;
458} 794}
459 795
460int psiconv_parse_sheet_cell(const psiconv_buffer buf, int lev, 796int psiconv_parse_sheet_cell(const psiconv_buffer buf, int lev,
461 psiconv_u32 off, int *length, 797 psiconv_u32 off, int *length,
462 psiconv_sheet_cell *result) 798 psiconv_sheet_cell *result,
799 const psiconv_sheet_cell_layout default_layout,
800 const psiconv_sheet_line_list row_default_layouts,
801 const psiconv_sheet_line_list col_default_layouts)
463{ 802{
464 int res=0; 803 int res=0;
465 int len=0; 804 int len=0;
466 psiconv_u32 temp; 805 psiconv_u32 temp;
467 psiconv_bool_t has_layout; 806 psiconv_bool_t has_layout;
… …
574 psiconv_warn(lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type); 913 psiconv_warn(lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type);
575 res = PSICONV_E_PARSE; 914 res = PSICONV_E_PARSE;
576 goto ERROR2; 915 goto ERROR2;
577 } 916 }
578 917
918 if (!((*result)->layout = psiconv_clone_cell_layout(
919 psiconv_get_default_layout(row_default_layouts,
920 col_default_layouts,
921 default_layout,
922 (*result)->row,
923 (*result)->column))))
924 goto ERROR2;
579 if (has_layout) { 925 if (has_layout) {
580 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len, 926 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,
581 &leng,&(*result)->layout))) 927 &leng,(*result)->layout)))
582 goto ERROR2; 928 goto ERROR2;
583 len += leng; 929 len += leng;
584 } 930 }
585 931
586 if ((*result)->calculated) { 932 if ((*result)->calculated) {
… …
611 else 957 else
612 return res; 958 return res;
613} 959}
614 960
615int psiconv_parse_sheet_cell_list(const psiconv_buffer buf, int lev, 961int psiconv_parse_sheet_cell_list(const psiconv_buffer buf, int lev,
616 psiconv_u32 off, int *length, 962 psiconv_u32 off, int *length,
617 psiconv_sheet_cell_list *result) 963 psiconv_sheet_cell_list *result,
964 const psiconv_sheet_cell_layout default_layout,
965 const psiconv_sheet_line_list row_default_layouts,
966 const psiconv_sheet_line_list col_default_layouts)
618{ 967{
619 int res=0; 968 int res=0;
620 int len=0; 969 int len=0;
621 psiconv_u32 temp; 970 psiconv_u32 temp;
622 psiconv_sheet_cell cell; 971 psiconv_sheet_cell cell;
… …
660 len += leng; 1009 len += leng;
661 1010
662 psiconv_progress(lev+2,off+len,"Going to read all cells"); 1011 psiconv_progress(lev+2,off+len,"Going to read all cells");
663 for (i = 0; i < listlen; i++) { 1012 for (i = 0; i < listlen; i++) {
664 psiconv_progress(lev+3,off+len,"Going to read cell %d",i); 1013 psiconv_progress(lev+3,off+len,"Going to read cell %d",i);
665 if ((res = psiconv_parse_sheet_cell(buf,lev+3,off+len,&leng,&cell))) 1014 if ((res = psiconv_parse_sheet_cell(buf,lev+3,off+len,&leng,&cell,
1015 default_layout,row_default_layouts,
1016 col_default_layouts)))
666 goto ERROR2; 1017 goto ERROR2;
667 if ((res = psiconv_list_add(*result,cell))) 1018 if ((res = psiconv_list_add(*result,cell)))
668 goto ERROR3; 1019 goto ERROR3;
1020 free(cell);
669 len += leng; 1021 len += leng;
670 } 1022 }
671 1023
672 if (length) 1024 if (length)
673 *length = len; 1025 *length = len;
… …
750 if ((res = psiconv_parse_sheet_worksheet(buf,lev+4,offset,NULL, 1102 if ((res = psiconv_parse_sheet_worksheet(buf,lev+4,offset,NULL,
751 &worksheet))) 1103 &worksheet)))
752 goto ERROR2; 1104 goto ERROR2;
753 if ((res = psiconv_list_add(*result,worksheet))) 1105 if ((res = psiconv_list_add(*result,worksheet)))
754 goto ERROR3; 1106 goto ERROR3;
755 psiconv_free_sheet_worksheet(worksheet); 1107 free(worksheet);
756 } 1108 }
757 1109
758 if (length) 1110 if (length)
759 *length = len; 1111 *length = len;
760 1112
… …
777 return res; 1129 return res;
778} 1130}
779 1131
780int psiconv_parse_sheet_cell_layout(const psiconv_buffer buf, int lev, 1132int psiconv_parse_sheet_cell_layout(const psiconv_buffer buf, int lev,
781 psiconv_u32 off, int *length, 1133 psiconv_u32 off, int *length,
782 psiconv_sheet_cell_layout *result) 1134 psiconv_sheet_cell_layout result)
783 1135
784{ 1136{
785 int res=0; 1137 int res=0;
786 int len=0; 1138 int len=0;
787 int leng; 1139 int leng;
788 psiconv_u8 temp; 1140 psiconv_u8 temp;
789 1141
790 psiconv_progress(lev+1,off,"Going to read a sheet cell layout"); 1142 psiconv_progress(lev+1,off,"Going to read a sheet cell layout");
791 if (!(*result = malloc(sizeof(**result))))
792 goto ERROR1;
793 1143
794 (*result)->character = NULL;
795 (*result)->paragraph = NULL;
796 (*result)->numberformat = NULL;
797
798 psiconv_progress(lev+2,off+len, 1144 psiconv_progress(lev+2,off+len,
799 "Going to read the first byte (%02x expected)",0x02); 1145 "Going to read the first byte (%02x expected)",0x02);
800 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1146 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
801 if (res) 1147 if (res)
802 goto ERROR2; 1148 goto ERROR1;
803 if (temp != 0x02) { 1149 if (temp != 0x02) {
804 psiconv_warn(lev+2,off+len, 1150 psiconv_warn(lev+2,off+len,
805 "Worksheet section initial byte unknown value (ignored)"); 1151 "Worksheet section initial byte unknown value (ignored)");
806 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1152 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
807 } 1153 }
808 len ++; 1154 len ++;
809 1155
810 psiconv_progress(lev+2,off+len,"Going to read the default formats flag"); 1156 psiconv_progress(lev+2,off+len,"Going to read the default formats flag");
811 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1157 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
812 if (res) 1158 if (res)
813 goto ERROR2; 1159 goto ERROR1;
814 len ++; 1160 len ++;
815 1161
816 if (temp & 0x01) { 1162 if (temp & 0x01) {
817 if (!((*result)->paragraph = psiconv_basic_paragraph_layout()))
818 goto ERROR2;
819 psiconv_progress(lev+3,off+len,"Going to read the default paragraph codes"); 1163 psiconv_progress(lev+3,off+len,"Going to read the default paragraph codes");
820 if ((res = psiconv_parse_paragraph_layout_list(buf,lev+3,off+len,&leng, 1164 if ((res = psiconv_parse_paragraph_layout_list(buf,lev+3,off+len,&leng,
821 (*result)->paragraph))) 1165 result->paragraph)))
822 goto ERROR2; 1166 goto ERROR1;
823 len += leng; 1167 len += leng;
824 } 1168 }
825 1169
826 if (temp & 0x02) { 1170 if (temp & 0x02) {
827 psiconv_progress(lev+3,off+len,"Going to read the default character codes"); 1171 psiconv_progress(lev+3,off+len,"Going to read the default character codes");
828 if (!((*result)->character = psiconv_basic_character_layout()))
829 goto ERROR2;
830 if ((res = psiconv_parse_character_layout_list(buf,lev+3,off+len,&leng, 1172 if ((res = psiconv_parse_character_layout_list(buf,lev+3,off+len,&leng,
831 (*result)->character))) 1173 result->character)))
832 goto ERROR2; 1174 goto ERROR1;
833 len += leng; 1175 len += leng;
834 } 1176 }
835 1177
836 if (temp & 0x04) { 1178 if (temp & 0x04) {
837 psiconv_progress(lev+3,off+len, "Going to read the default number format"); 1179 psiconv_progress(lev+3,off+len, "Going to read the default number format");
838 psiconv_parse_sheet_numberformat(buf,lev+3,off+len,&leng, 1180 psiconv_parse_sheet_numberformat(buf,lev+3,off+len,&leng,
839 &(*result)->numberformat); 1181 result->numberformat);
840 len += leng; 1182 len += leng;
841 } 1183 }
842 1184
843 if (length) 1185 if (length)
844 *length = len; 1186 *length = len;
… …
846 psiconv_progress(lev,off+len-1, 1188 psiconv_progress(lev,off+len-1,
847 "End of sheet cell layout (total length: %08x)", len); 1189 "End of sheet cell layout (total length: %08x)", len);
848 1190
849 return 0; 1191 return 0;
850 1192
851ERROR2:
852 psiconv_free_sheet_cell_layout(*result);
853ERROR1: 1193ERROR1:
854 psiconv_warn(lev+1,off,"Reading of sheet cell layout failed"); 1194 psiconv_warn(lev+1,off,"Reading of sheet cell layout failed");
855 if (length) 1195 if (length)
856 *length = 0; 1196 *length = 0;
857 if (!res) 1197 if (!res)
… …
864int psiconv_parse_sheet_worksheet(const psiconv_buffer buf, int lev, 1204int psiconv_parse_sheet_worksheet(const psiconv_buffer buf, int lev,
865 psiconv_u32 off, int *length, 1205 psiconv_u32 off, int *length,
866 psiconv_sheet_worksheet *result) 1206 psiconv_sheet_worksheet *result)
867{ 1207{
868 int res=0; 1208 int res=0;
869 psiconv_u32 temp,cells_off,grid_off; 1209 psiconv_u32 temp,cells_off,grid_off,rows_off,cols_off;
870 int len=0; 1210 int len=0;
871 int leng; 1211 int leng;
872 1212
873 psiconv_progress(lev+1,off,"Going to read the sheet worksheet section"); 1213 psiconv_progress(lev+1,off,"Going to read the sheet worksheet section");
874 if (!(*result = malloc(sizeof(**result)))) 1214 if (!(*result = malloc(sizeof(**result))))
… …
897 "Worksheet section flags byte unknown bits (ignored)"); 1237 "Worksheet section flags byte unknown bits (ignored)");
898 } 1238 }
899 len ++; 1239 len ++;
900 1240
901 psiconv_progress(lev+2,off+len,"Going to read the default cell layout"); 1241 psiconv_progress(lev+2,off+len,"Going to read the default cell layout");
1242 if (!((*result)->default_layout = psiconv_basic_cell_layout()))
1243 goto ERROR2;
902 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,&leng, 1244 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,&leng,
903 &(*result)->default_layout))) 1245 (*result)->default_layout)))
904 goto ERROR2; 1246 goto ERROR3;
905 len += leng; 1247 len += leng;
906 1248
907 psiconv_progress(lev+2,off+len, 1249 psiconv_progress(lev+2,off+len,
1250 "Going to read the offset of the row defaults Section");
1251 rows_off = psiconv_read_u32(buf,lev+2,off+len,&res);
1252 if (res)
1253 goto ERROR3;
1254 psiconv_debug(lev+2,off+len,"Offset: %04x",rows_off);
1255 len += 4;
1256
1257 psiconv_progress(lev+2,off+len,
1258 "Going to read the offset of the column defaults Section");
1259 cols_off = psiconv_read_u32(buf,lev+2,off+len,&res);
1260 if (res)
1261 goto ERROR3;
1262 psiconv_debug(lev+2,off+len,"Offset: %04x",cols_off);
1263 len += 4;
1264
1265 psiconv_progress(lev+2,off+len,
1266 "Going to read the offset of the Cells List");
1267 cells_off = psiconv_read_u32(buf,lev+2,off+len,&res);
1268 if (res)
1269 goto ERROR3;
1270 psiconv_debug(lev+2,off+len,"Offset: %04x",cells_off);
1271 len += 4;
1272
1273 psiconv_progress(lev+2,off+len,
1274 "Going to read the offset of the Grid Section");
1275 grid_off = psiconv_read_u32(buf,lev+2,off+len,&res);
1276 if (res)
1277 goto ERROR3;
1278 psiconv_debug(lev+2,off+len,"Offset: %04x",grid_off);
1279 len += 4;
1280
1281 psiconv_progress(lev+2,off+len,
908 "Going to read the offset of the 1st ??? Section"); 1282 "Going to read the offset of the 3rd ??? Section");
909 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 1283 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
910 if (res) 1284 if (res)
911 goto ERROR3; 1285 goto ERROR3;
912 psiconv_debug(lev+2,off+len,"Offset: %04x",temp); 1286 psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
913 len += 4; 1287 len += 4;
914 1288
915 psiconv_progress(lev+2,off+len, 1289 psiconv_progress(lev+2,off+len,"Going to read the row defaults");
916 "Going to read the offset of the 2nd ??? Section"); 1290 if ((res = psiconv_parse_sheet_line_list(buf,lev+2,rows_off,NULL,
917 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 1291 &(*result)->row_default_layouts,
918 if (res) 1292 (*result)->default_layout)))
919 goto ERROR3; 1293 goto ERROR3;
920 psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
921 len += 4;
922 1294
923 psiconv_progress(lev+2,off+len, 1295 psiconv_progress(lev+2,off+len,"Going to read the column defaults");
924 "Going to read the offset of the Cells List"); 1296 if ((res = psiconv_parse_sheet_line_list(buf,lev+2,cols_off,NULL,
925 cells_off = psiconv_read_u32(buf,lev+2,off+len,&res); 1297 &(*result)->col_default_layouts,
926 if (res) 1298 (*result)->default_layout)))
927 goto ERROR3; 1299 goto ERROR4;
928 psiconv_debug(lev+2,off+len,"Offset: %04x",cells_off);
929 len += 4;
930
931 psiconv_progress(lev+2,off+len,
932 "Going to read the offset of the Grid Section");
933 grid_off = psiconv_read_u32(buf,lev+2,off+len,&res);
934 if (res)
935 goto ERROR3;
936 psiconv_debug(lev+2,off+len,"Offset: %04x",grid_off);
937 len += 4;
938
939 psiconv_progress(lev+2,off+len,
940 "Going to read the offset of the 3rd ??? Section");
941 temp = psiconv_read_u32(buf,lev+2,off+len,&res);
942 if (res)
943 goto ERROR3;
944 psiconv_debug(lev+2,off+len,"Offset: %04x",temp);
945 len += 4;
946 1300
947 psiconv_progress(lev+2,off+len,"Going to read the cells list"); 1301 psiconv_progress(lev+2,off+len,"Going to read the cells list");
948 if ((res = psiconv_parse_sheet_cell_list(buf,lev+2,cells_off,NULL, 1302 if ((res = psiconv_parse_sheet_cell_list(buf,lev+2,cells_off,NULL,
949 &(*result)->cells))) 1303 &(*result)->cells,
1304 (*result)->default_layout,
1305 (*result)->row_default_layouts,
1306 (*result)->col_default_layouts)))
950 goto ERROR3; 1307 goto ERROR5;
951 1308
952 1309
953/* TODO: parse grid section */ 1310/* TODO: parse grid section */
954 1311
955 if (length) 1312 if (length)
… …
957 1314
958 psiconv_progress(lev,off+len-1, 1315 psiconv_progress(lev,off+len-1,
959 "End of sheet worksheet section (total length: %08x)", len); 1316 "End of sheet worksheet section (total length: %08x)", len);
960 return 0; 1317 return 0;
961 1318
1319ERROR5:
1320 psiconv_free_sheet_line_list((*result)->col_default_layouts);
1321ERROR4:
1322 psiconv_free_sheet_line_list((*result)->row_default_layouts);
962ERROR3: 1323ERROR3:
963 psiconv_free_sheet_cell_layout((*result)->default_layout); 1324 psiconv_free_sheet_cell_layout((*result)->default_layout);
964ERROR2: 1325ERROR2:
965 free (*result); 1326 free (*result);
966ERROR1: 1327ERROR1:
… …
971 return -PSICONV_E_NOMEM; 1332 return -PSICONV_E_NOMEM;
972 else 1333 else
973 return res; 1334 return res;
974} 1335}
975 1336
1337int psiconv_parse_sheet_line(const psiconv_buffer buf, int lev,
1338 psiconv_u32 off, int *length,
1339 psiconv_sheet_line *result,
1340 const psiconv_sheet_cell_layout default_layout)
1341{
1342 int res=0;
1343 int len=0;
1344 int leng;
976 1345
1346
1347 psiconv_progress(lev+1,off,"Going to read a sheet line");
1348 if (!(*result = malloc(sizeof(**result))))
1349 goto ERROR1;
1350
1351 psiconv_progress(lev+2,off+len,"Going to read the line number");
1352 (*result)->position = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
1353 if (res)
1354 goto ERROR2;
1355 psiconv_debug(lev+2,off+len,"Line number: %d\n",(*result)->position);
1356 len += leng;
1357
1358 if (!((*result)->layout = psiconv_clone_cell_layout(default_layout)))
1359 goto ERROR2;
1360 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,
1361 &leng,(*result)->layout)))
1362 goto ERROR3;
1363 len += leng;
1364
1365 if (length)
1366 *length = len;
1367
1368 psiconv_progress(lev,off+len-1,
1369 "End of the sheet line (total length: %08x)", len);
1370 return 0;
1371
1372ERROR3:
1373 psiconv_free_sheet_cell_layout((*result)->layout);
1374ERROR2:
1375 free (*result);
1376ERROR1:
1377 psiconv_warn(lev+1,off,"Reading of the sheet line failed");
1378 if (length)
1379 *length = 0;
1380 if (!res)
1381 return -PSICONV_E_NOMEM;
1382 else
1383 return res;
1384}
1385
1386
1387int psiconv_parse_sheet_line_list(const psiconv_buffer buf, int lev,
1388 psiconv_u32 off, int *length,
1389 psiconv_sheet_line_list *result,
1390 const psiconv_sheet_cell_layout default_layout)
1391{
1392 int res=0;
1393 int len=0;
1394 psiconv_u32 temp;
1395 psiconv_sheet_line line;
1396 psiconv_u32 listlen,i;
1397 int leng;
1398
1399 psiconv_progress(lev+1,off,"Going to read the sheet line list");
1400 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_line_s))))
1401 goto ERROR1;
1402
1403 psiconv_progress(lev+2,off+len,
1404 "Going to read the initial byte (%02x expected)",0x02);
1405 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
1406 if (res)
1407 goto ERROR2;
1408 if (temp != 0x02) {
1409 psiconv_warn(lev+2,off+len,
1410 "Sheet line list initial byte unknown value (ignored)");
1411 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
1412 }
1413 len ++;
1414
1415 psiconv_progress(lev+2,off+len,
1416 "Going to read the number of defined lines");
1417 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
1418 if (res)
1419 goto ERROR2;
1420 psiconv_debug(lev+2,off+len,"Number of defined lines: %d",listlen);
1421 len += leng;
1422
1423 psiconv_progress(lev+2,off+len,"Going to read all lines");
1424 for (i = 0; i < listlen; i++) {
1425 psiconv_progress(lev+3,off+len,"Going to read line %d",i);
1426 if ((res = psiconv_parse_sheet_line(buf,lev+3,off+len,&leng,&line,
1427 default_layout)))
1428 goto ERROR2;
1429 if ((res = psiconv_list_add(*result,line)))
1430 goto ERROR3;
1431 free(line);
1432 len += leng;
1433 }
1434
1435 if (length)
1436 *length = len;
1437
1438 psiconv_progress(lev,off+len-1,
1439 "End of sheet line list (total length: %08x)", len);
1440 return 0;
1441
1442ERROR3:
1443 psiconv_free_sheet_line(line);
1444ERROR2:
1445 psiconv_free_sheet_line_list(*result);
1446ERROR1:
1447 psiconv_warn(lev+1,off,"Reading of Sheet Line List failed");
1448 if (length)
1449 *length = 0;
1450 if (!res)
1451 return -PSICONV_E_NOMEM;
1452 else
1453 return res;
1454}
1455
1456int psiconv_parse_sheet_variable(const psiconv_buffer buf, int lev,
1457 psiconv_u32 off, int *length,
1458 psiconv_sheet_variable *result)
1459{
1460 int res=0;
1461 int len=0;
1462 psiconv_u32 marker;
1463 int leng;
1464
1465 psiconv_progress(lev+1,off,"Going to read a sheet variable");
1466 if (!(*result = malloc(sizeof(**result))))
1467 goto ERROR1;
1468
1469 psiconv_progress(lev+2,off+len, "Going to read the variable name");
1470 (*result)->name = psiconv_read_string(buf,lev+2,off+len,&leng,&res);
1471 if (res)
1472 goto ERROR2;
1473 len += leng;
1474
1475 psiconv_progress(lev+2,off+len,"Going to read the type marker");
1476 marker = psiconv_read_u8(buf,lev+2,off+len,&res);
1477 if (res)
1478 goto ERROR3;
1479 psiconv_debug(lev+2,off+len,"Marker: %02x",marker);
1480 len ++;
1481
1482 if (marker == 0x00) {
1483 (*result)->type = psiconv_var_int;
1484 psiconv_progress(lev+2,off+len,"Going to read a signed integer");
1485 (*result)->data.dat_int = psiconv_read_sint(buf,lev+2,off+len,&leng,&res);
1486 if (res)
1487 goto ERROR3;
1488 psiconv_debug(lev+2,off+len,"Value: %d",(*result)->data.dat_int);
1489 len += leng;
1490 } else if (marker == 0x01) {
1491 (*result)->type = psiconv_var_float;
1492 psiconv_progress(lev+2,off+len,"Going to read a floating point number");
1493 (*result)->data.dat_float = psiconv_read_float(buf,lev+2,off+len,&leng,
1494 &res);
1495 if (res)
1496 goto ERROR3;
1497 psiconv_debug(lev+2,off+len,"Value: %f",(*result)->data.dat_float);
1498 len += leng;
1499 } else if (marker == 0x02) {
1500 (*result)->type = psiconv_var_string;
1501 psiconv_progress(lev+2,off+len,"Going to read a string");
1502 (*result)->data.dat_string = psiconv_read_string(buf,lev+2,off+len,&leng,
1503 &res);
1504 if (res)
1505 goto ERROR3;
1506 len += leng;
1507 } else if (marker == 0x03) {
1508 (*result)->type = psiconv_var_cellref;
1509 psiconv_progress(lev+2,off+len,"Going to read a cell reference");
1510 (*result)->data.dat_cellref = psiconv_read_var_cellref(buf,lev+2,off+len,
1511 &leng, &res);
1512 if (res)
1513 goto ERROR3;
1514 len += leng;
1515 } else if (marker == 0x04) {
1516 (*result)->type = psiconv_var_cellblock;
1517 psiconv_progress(lev+2,off+len,"Going to read a cell block reference");
1518 (*result)->data.dat_cellblock = psiconv_read_var_cellblock(buf,lev+2,
1519 off+len,
1520 &leng, &res);
1521 if (res)
1522 goto ERROR3;
1523 len += leng;
1524 } else {
1525 psiconv_warn(lev+2,off+len,"Sheet variable unknown type marker");
1526 res = -PSICONV_E_PARSE;
1527 goto ERROR3;
1528 }
1529
1530 psiconv_progress(lev+2,off+len,"Going to read the variable number");
1531 (*result)->number = psiconv_read_u32(buf,lev+2,off+len,&res);
1532 if (res)
1533 goto ERROR4;
1534 psiconv_debug(lev+2,off+len,"Number: %08x",(*result)->number);
1535 len += 4;
1536
1537 if (length)
1538 *length = len;
1539
1540 psiconv_progress(lev,off+len-1,
1541 "End of sheet variable (total length: %08x)", len);
1542 return 0;
1543
1544ERROR4:
1545 if ((*result)->type == psiconv_var_string)
1546 free((*result)->data.dat_string);
1547ERROR3:
1548 free((*result)->name);
1549ERROR2:
1550 free (*result);
1551ERROR1:
1552 psiconv_warn(lev+1,off,"Reading of Sheet Variable failed");
1553 if (length)
1554 *length = 0;
1555 if (!res)
1556 return -PSICONV_E_NOMEM;
1557 else
1558 return res;
1559}
1560
1561
1562int psiconv_parse_sheet_variable_list(const psiconv_buffer buf, int lev,
1563 psiconv_u32 off, int *length,
1564 psiconv_sheet_variable_list *result)
1565{
1566 int res=0;
1567 int len=0;
1568 psiconv_u32 temp;
1569 psiconv_sheet_variable variable;
1570 psiconv_u32 listlen,i;
1571 int leng;
1572
1573 psiconv_progress(lev+1,off,"Going to read the sheet variable list");
1574 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_variable_s))))
1575 goto ERROR1;
1576
1577 psiconv_progress(lev+2,off+len,
1578 "Going to read the initial byte (%02x expected)",0x02);
1579 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
1580 if (res)
1581 goto ERROR2;
1582 if (temp != 0x02) {
1583 psiconv_warn(lev+2,off+len,
1584 "Sheet variable list initial byte unknown value (ignored)");
1585 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);
1586 }
1587 len ++;
1588
1589 psiconv_progress(lev+2,off+len,
1590 "Going to read the number of variables");
1591 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);
1592 if (res)
1593 goto ERROR2;
1594 psiconv_debug(lev+2,off+len,"Number of variables: %d",listlen);
1595 len += leng;
1596
1597 psiconv_progress(lev+2,off+len,"Going to read all variables");
1598 for (i = 0; i < listlen; i++) {
1599 psiconv_progress(lev+3,off+len,"Going to read variable %d",i);
1600 if ((res = psiconv_parse_sheet_variable(buf,lev+3,off+len,&leng,&variable)))
1601 goto ERROR2;
1602 if ((res = psiconv_list_add(*result,variable)))
1603 goto ERROR3;
1604 len += leng;
1605 }
1606
1607 if (length)
1608 *length = len;
1609
1610 psiconv_progress(lev,off+len-1,
1611 "End of sheet variabels list (total length: %08x)", len);
1612 return 0;
1613
1614ERROR3:
1615 psiconv_free_sheet_variable(variable);
1616ERROR2:
1617 psiconv_list_free(*result);
1618ERROR1:
1619 psiconv_warn(lev+1,off,"Reading of Sheet Variable list failed");
1620 if (length)
1621 *length = 0;
1622 if (!res)
1623 return -PSICONV_E_NOMEM;
1624 else
1625 return res;
1626}
Legend:
Removed from v.111  
changed lines
  Added in v.130
frodo@frodo.looijaard.name
 ViewVC Help
Powered by ViewVC 1.1.26