/[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 129 Revision 183
… …
22 22
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
28#ifdef DMALLOC
29#include <dmalloc.h>
30#endif
27 31
28static psiconv_sheet_cell_layout psiconv_basic_cell_layout(void) 32static psiconv_sheet_cell_layout psiconv_basic_cell_layout(void)
29{ 33{
30 psiconv_sheet_cell_layout result; 34 psiconv_sheet_cell_layout result;
31 if (!(result = malloc(sizeof(*result)))) 35 if (!(result = malloc(sizeof(*result))))
… …
75ERROR1: 79ERROR1:
76 return NULL; 80 return NULL;
77} 81}
78 82
79static psiconv_sheet_cell_reference_t 83static psiconv_sheet_cell_reference_t
80 psiconv_read_var_cellref (const psiconv_buffer buf, int lev, 84 psiconv_read_var_cellref (const psiconv_config config,
85 const psiconv_buffer buf, int lev,
81 psiconv_u32 off, int *length, 86 psiconv_u32 off, int *length,
82 int *status) 87 int *status)
83{ 88{
84 int len=0; 89 int len=0;
85 int res; 90 int res;
86 psiconv_sheet_cell_reference_t result; 91 psiconv_sheet_cell_reference_t result;
87 psiconv_u32 temp; 92 psiconv_u32 temp;
88 93
89 psiconv_progress(lev+1,off+len,"Going to read a sheet cell reference"); 94 psiconv_progress(config,lev+1,off+len,"Going to read a sheet cell reference");
90 psiconv_progress(lev+2,off+len, 95 psiconv_progress(config,lev+2,off+len,
91 "Going to read the initial byte (%02x expected)",0x00); 96 "Going to read the initial byte (%02x expected)",0x00);
92 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 97 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
93 if (res) 98 if (res)
94 goto ERROR1; 99 goto ERROR1;
95 if (temp != 0x00) { 100 if (temp != 0x00) {
96 psiconv_warn(lev+2,off+len, 101 psiconv_warn(config,lev+2,off+len,
97 "Sheet cell reference initial byte unknown value (ignored)"); 102 "Sheet cell reference initial byte unknown value (ignored)");
98 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 103 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
99 } 104 }
100 len ++; 105 len ++;
101 106
102 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 107 temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
103 if (res) 108 if (res)
104 goto ERROR1; 109 goto ERROR1;
105 if (temp & 0xffff0000) { 110 if (temp & 0xffff0000) {
106 psiconv_warn(lev+2,off+len, 111 psiconv_warn(config,lev+2,off+len,
107 "Sheet cell row reference to unknown row (reset)"); 112 "Sheet cell row reference to unknown row (reset)");
108 } 113 }
109 result.row.offset = temp; 114 result.row.offset = temp;
110 result.row.absolute = psiconv_bool_true; 115 result.row.absolute = psiconv_bool_true;
111 len += 4; 116 len += 4;
112 117
113 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 118 temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
114 if (res) 119 if (res)
115 goto ERROR1; 120 goto ERROR1;
116 if (temp & 0xffff0000) { 121 if (temp & 0xffff0000) {
117 psiconv_warn(lev+2,off+len, 122 psiconv_warn(config,lev+2,off+len,
118 "Sheet cell column reference to unknown row (reset)"); 123 "Sheet cell column reference to unknown row (reset)");
119 } 124 }
120 result.column.offset = temp; 125 result.column.offset = temp;
121 result.column.absolute = psiconv_bool_true; 126 result.column.absolute = psiconv_bool_true;
122 len += 4; 127 len += 4;
123 128
124 if (length) 129 if (length)
125 *length = len; 130 *length = len;
126 131
127 psiconv_progress(lev,off+len-1, 132 psiconv_progress(config,lev,off+len-1,
128 "End of sheet column reference (total length: %08x)", len); 133 "End of sheet column reference (total length: %08x)", len);
129 return result; 134 return result;
130ERROR1: 135ERROR1:
131 psiconv_warn(lev+1,off,"Reading of Sheet Column Reference failed"); 136 psiconv_warn(config,lev+1,off,"Reading of Sheet Column Reference failed");
132 if (length) 137 if (length)
133 *length = 0; 138 *length = 0;
134 if (status) 139 if (status)
135 *status = res?res:-PSICONV_E_NOMEM; 140 *status = res?res:-PSICONV_E_NOMEM;
136 return result; 141 return result;
137} 142}
138 143
139static psiconv_sheet_cell_block_t 144static psiconv_sheet_cell_block_t
140 psiconv_read_var_cellblock (const psiconv_buffer buf, int lev, 145 psiconv_read_var_cellblock (const psiconv_config config,
146 const psiconv_buffer buf, int lev,
141 psiconv_u32 off, int *length, 147 psiconv_u32 off, int *length,
142 int *status) 148 int *status)
143{ 149{
144 int len=0; 150 int len=0;
145 int res; 151 int res;
146 psiconv_sheet_cell_block_t result; 152 psiconv_sheet_cell_block_t result;
147 psiconv_u32 temp; 153 psiconv_u32 temp;
148 154
149 psiconv_progress(lev+1,off+len,"Going to read a sheet cell block reference"); 155 psiconv_progress(config,lev+1,off+len,"Going to read a sheet cell block reference");
150 psiconv_progress(lev+2,off+len, 156 psiconv_progress(config,lev+2,off+len,
151 "Going to read the initial byte (%02x expected)",0x00); 157 "Going to read the initial byte (%02x expected)",0x00);
152 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 158 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
153 if (res) 159 if (res)
154 goto ERROR1; 160 goto ERROR1;
155 if (temp != 0x00) { 161 if (temp != 0x00) {
156 psiconv_warn(lev+2,off+len, 162 psiconv_warn(config,lev+2,off+len,
157 "Sheet cell reference initial byte unknown value (ignored)"); 163 "Sheet cell reference initial byte unknown value (ignored)");
158 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 164 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
159 } 165 }
160 len ++; 166 len ++;
161 167
162 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 168 temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
163 if (res) 169 if (res)
164 goto ERROR1; 170 goto ERROR1;
165 if (temp & 0xffff0000) { 171 if (temp & 0xffff0000) {
166 psiconv_warn(lev+2,off+len, 172 psiconv_warn(config,lev+2,off+len,
167 "Sheet block initial row reference to unknown row (reset)"); 173 "Sheet block initial row reference to unknown row (reset)");
168 } 174 }
169 result.first.row.offset = temp; 175 result.first.row.offset = temp;
170 result.first.row.absolute = psiconv_bool_true; 176 result.first.row.absolute = psiconv_bool_true;
171 len += 4; 177 len += 4;
172 178
173 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 179 temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
174 if (res) 180 if (res)
175 goto ERROR1; 181 goto ERROR1;
176 if (temp & 0xffff0000) { 182 if (temp & 0xffff0000) {
177 psiconv_warn(lev+2,off+len, 183 psiconv_warn(config,lev+2,off+len,
178 "Sheet block initial column reference to unknown row (reset)"); 184 "Sheet block initial column reference to unknown row (reset)");
179 } 185 }
180 result.first.column.offset = temp; 186 result.first.column.offset = temp;
181 result.first.column.absolute = psiconv_bool_true; 187 result.first.column.absolute = psiconv_bool_true;
182 len += 4; 188 len += 4;
183 189
184 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 190 temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
185 if (res) 191 if (res)
186 goto ERROR1; 192 goto ERROR1;
187 if (temp & 0xffff0000) { 193 if (temp & 0xffff0000) {
188 psiconv_warn(lev+2,off+len, 194 psiconv_warn(config,lev+2,off+len,
189 "Sheet block final row reference to unknown row (reset)"); 195 "Sheet block final row reference to unknown row (reset)");
190 } 196 }
191 result.last.row.offset = temp; 197 result.last.row.offset = temp;
192 result.last.row.absolute = psiconv_bool_true; 198 result.last.row.absolute = psiconv_bool_true;
193 len += 4; 199 len += 4;
194 200
195 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 201 temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
196 if (res) 202 if (res)
197 goto ERROR1; 203 goto ERROR1;
198 if (temp & 0xffff0000) { 204 if (temp & 0xffff0000) {
199 psiconv_warn(lev+2,off+len, 205 psiconv_warn(config,lev+2,off+len,
200 "Sheet block final column reference to unknown row (reset)"); 206 "Sheet block final column reference to unknown row (reset)");
201 } 207 }
202 result.last.column.offset = temp; 208 result.last.column.offset = temp;
203 result.last.column.absolute = psiconv_bool_true; 209 result.last.column.absolute = psiconv_bool_true;
204 len += 4; 210 len += 4;
205 211
206 if (length) 212 if (length)
207 *length = len; 213 *length = len;
208 214
209 psiconv_progress(lev,off+len-1, 215 psiconv_progress(config,lev,off+len-1,
210 "End of sheet cell block reference (total length: %08x)", 216 "End of sheet cell block reference (total length: %08x)",
211 len); 217 len);
212 return result; 218 return result;
213ERROR1: 219ERROR1:
214 psiconv_warn(lev+1,off,"Reading of Sheet Cell Block Reference failed"); 220 psiconv_warn(config,lev+1,off,"Reading of Sheet Cell Block Reference failed");
215 if (length) 221 if (length)
216 *length = 0; 222 *length = 0;
217 if (status) 223 if (status)
218 *status = res?res:-PSICONV_E_NOMEM; 224 *status = res?res:-PSICONV_E_NOMEM;
219 return result; 225 return result;
220} 226}
221 227
222int psiconv_parse_sheet_numberformat(const psiconv_buffer buf, int lev, 228int psiconv_parse_sheet_numberformat(const psiconv_config config,
229 const psiconv_buffer buf, int lev,
223 psiconv_u32 off, int *length, 230 psiconv_u32 off, int *length,
224 psiconv_sheet_numberformat result) 231 psiconv_sheet_numberformat result)
225{ 232{
226 int res=0; 233 int res=0;
227 int len=0; 234 int len=0;
228 psiconv_u8 temp; 235 psiconv_u8 temp;
229 236
230 psiconv_progress(lev+1,off,"Going to read a sheet numberformat"); 237 psiconv_progress(config,lev+1,off,"Going to read a sheet numberformat");
231 238
232 psiconv_progress(lev+2,off+len, 239 psiconv_progress(config,lev+2,off+len,
233 "Going to read the initial byte (%02x expected)",0x02); 240 "Going to read the initial byte (%02x expected)",0x02);
234 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 241 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
235 if (res) 242 if (res)
236 goto ERROR1; 243 goto ERROR1;
237 if (temp != 0x02) { 244 if (temp != 0x02) {
238 psiconv_warn(lev+2,off+len, 245 psiconv_warn(config,lev+2,off+len,
239 "Sheet numberformat initial byte unknown value (ignored)"); 246 "Sheet numberformat initial byte unknown value (ignored)");
240 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 247 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
241 } 248 }
242 len ++; 249 len ++;
243 250
244 psiconv_progress(lev+2,off+len, "Going to read the code byte"); 251 psiconv_progress(config,lev+2,off+len, "Going to read the code byte");
245 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 252 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
246 if (res) 253 if (res)
247 goto ERROR1; 254 goto ERROR1;
248 psiconv_debug(lev+2,off+len,"Code: %02x",temp); 255 psiconv_debug(config,lev+2,off+len,"Code: %02x",temp);
249 if (temp == 0x00) 256 if (temp == 0x00)
250 result->code = psiconv_numberformat_general; 257 result->code = psiconv_numberformat_general;
251 else if (temp == 0x02) 258 else if (temp == 0x02)
252 result->code = psiconv_numberformat_fixeddecimal; 259 result->code = psiconv_numberformat_fixeddecimal;
253 else if (temp == 0x04) 260 else if (temp == 0x04)
… …
307 else if (temp == 0x3A) 314 else if (temp == 0x3A)
308 result->code = psiconv_numberformat_time_HHii; 315 result->code = psiconv_numberformat_time_HHii;
309 else if (temp == 0x3C) 316 else if (temp == 0x3C)
310 result->code = psiconv_numberformat_time_HHiiss; 317 result->code = psiconv_numberformat_time_HHiiss;
311 else { 318 else {
312 psiconv_warn(lev+2,off+len,"Unknown number format (assumed general)"); 319 psiconv_warn(config,lev+2,off+len,"Unknown number format (assumed general)");
313 result->code = psiconv_numberformat_general; 320 result->code = psiconv_numberformat_general;
314 } 321 }
315 len ++; 322 len ++;
316 323
317 psiconv_progress(lev+2,off+len, "Going to read the number of decimals"); 324 psiconv_progress(config,lev+2,off+len, "Going to read the number of decimals");
318 result->decimal = psiconv_read_u8(buf,lev+2,off+len,&res) >> 1; 325 result->decimal = psiconv_read_u8(config,buf,lev+2,off+len,&res) >> 1;
319 if (res) 326 if (res)
320 goto ERROR1; 327 goto ERROR1;
321 psiconv_debug(lev+2,off+len,"Decimals: %d",result->decimal); 328 psiconv_debug(config,lev+2,off+len,"Decimals: %d",result->decimal);
322 len ++; 329 len ++;
323 330
324 if (length) 331 if (length)
325 *length = len; 332 *length = len;
326 333
327 psiconv_progress(lev,off+len-1, 334 psiconv_progress(config,lev,off+len-1,
328 "End of sheet number format (total length: %08x)", len); 335 "End of sheet number format (total length: %08x)", len);
329 return 0; 336 return 0;
330 337
331ERROR1: 338ERROR1:
332 psiconv_warn(lev+1,off,"Reading of Sheet Number Format failed"); 339 psiconv_warn(config,lev+1,off,"Reading of Sheet Number Format failed");
333 if (length) 340 if (length)
334 *length = 0; 341 *length = 0;
335 if (!res) 342 if (!res)
336 return -PSICONV_E_NOMEM; 343 return -PSICONV_E_NOMEM;
337 else 344 else
338 return res; 345 return res;
339} 346}
340 347
341int psiconv_parse_sheet_status_section(const psiconv_buffer buf, int lev, 348int psiconv_parse_sheet_status_section(const psiconv_config config,
349 const psiconv_buffer buf, int lev,
342 psiconv_u32 off, int *length, 350 psiconv_u32 off, int *length,
343 psiconv_sheet_status_section *result) 351 psiconv_sheet_status_section *result)
344{ 352{
345 int res=0; 353 int res=0;
346 int len=0; 354 int len=0;
347 psiconv_u32 temp; 355 psiconv_u32 temp;
348 int leng; 356 int leng;
349 357
350 psiconv_progress(lev+1,off,"Going to read the sheet status section"); 358 psiconv_progress(config,lev+1,off,"Going to read the sheet status section");
351 if (!(*result = malloc(sizeof(**result)))) 359 if (!(*result = malloc(sizeof(**result))))
352 goto ERROR1; 360 goto ERROR1;
353 361
354 psiconv_progress(lev+2,off+len, 362 psiconv_progress(config,lev+2,off+len,
355 "Going to read the initial byte (%02x expected)",0x02); 363 "Going to read the initial byte (%02x expected)",0x02);
356 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 364 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
357 if (res) 365 if (res)
358 goto ERROR2; 366 goto ERROR2;
359 if (temp != 0x02) { 367 if (temp != 0x02) {
360 psiconv_warn(lev+2,off+len, 368 psiconv_warn(config,lev+2,off+len,
361 "Sheet status section initial byte unknown value (ignored)"); 369 "Sheet status section initial byte unknown value (ignored)");
362 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 370 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
363 } 371 }
364 len ++; 372 len ++;
365 373
366 psiconv_progress(lev+2,off+len, 374 psiconv_progress(config,lev+2,off+len,
367 "Going to read the cursor row"); 375 "Going to read the cursor row");
368 (*result)->cursor_row = psiconv_read_u32(buf,lev+2,off + len,&res); 376 (*result)->cursor_row = psiconv_read_u32(config,buf,lev+2,off + len,&res);
369 if (res) 377 if (res)
370 goto ERROR2; 378 goto ERROR2;
371 psiconv_debug(lev+2,off+len,"Cursor row: %08x", 379 psiconv_debug(config,lev+2,off+len,"Cursor row: %08x",
372 (*result)->cursor_row); 380 (*result)->cursor_row);
373 len += 0x04; 381 len += 0x04;
374 382
375 psiconv_progress(lev+2,off+len, 383 psiconv_progress(config,lev+2,off+len,
376 "Going to read the cursor column"); 384 "Going to read the cursor column");
377 (*result)->cursor_column = psiconv_read_u32(buf,lev+2,off + len,&res); 385 (*result)->cursor_column = psiconv_read_u32(config,buf,lev+2,off + len,&res);
378 if (res) 386 if (res)
379 goto ERROR2; 387 goto ERROR2;
380 psiconv_debug(lev+2,off+len,"Cursor column: %08x", 388 psiconv_debug(config,lev+2,off+len,"Cursor column: %08x",
381 (*result)->cursor_column); 389 (*result)->cursor_column);
382 len += 0x04; 390 len += 0x04;
383 391
384 psiconv_progress(lev+2,off+len,"Going to read initially display graph"); 392 psiconv_progress(config,lev+2,off+len,"Going to read initially display graph");
385 if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng, 393 if ((res = psiconv_parse_bool(config,buf,lev+2,off+len,&leng,
386 &(*result)->show_graph))) 394 &(*result)->show_graph)))
387 goto ERROR2; 395 goto ERROR2;
388 len += leng; 396 len += leng;
389 397
390 psiconv_progress(lev+2,off+len, 398 psiconv_progress(config,lev+2,off+len,
391 "Going to read the toolbar status byte"); 399 "Going to read the toolbar status byte");
392 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 400 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
393 if (res) 401 if (res)
394 goto ERROR2; 402 goto ERROR2;
395 403
396 (*result)->show_side_sheet_toolbar = temp&0x01 ? psiconv_bool_true : 404 (*result)->show_side_sheet_toolbar = temp&0x01 ? psiconv_bool_true :
397 psiconv_bool_false; 405 psiconv_bool_false;
398 psiconv_debug(lev+2,off+len,"Show side sheet toolbar: %02x", 406 psiconv_debug(config,lev+2,off+len,"Show side sheet toolbar: %02x",
399 (*result)->show_side_sheet_toolbar); 407 (*result)->show_side_sheet_toolbar);
400 (*result)->show_top_sheet_toolbar = temp&0x02 ? psiconv_bool_true : 408 (*result)->show_top_sheet_toolbar = temp&0x02 ? psiconv_bool_true :
401 psiconv_bool_false; 409 psiconv_bool_false;
402 psiconv_debug(lev+2,off+len,"Show top sheet toolbar: %02x", 410 psiconv_debug(config,lev+2,off+len,"Show top sheet toolbar: %02x",
403 (*result)->show_top_sheet_toolbar); 411 (*result)->show_top_sheet_toolbar);
404 (*result)->show_side_graph_toolbar = temp&0x04 ? psiconv_bool_true : 412 (*result)->show_side_graph_toolbar = temp&0x04 ? psiconv_bool_true :
405 psiconv_bool_false; 413 psiconv_bool_false;
406 psiconv_debug(lev+2,off+len,"Show side graph toolbar: %02x", 414 psiconv_debug(config,lev+2,off+len,"Show side graph toolbar: %02x",
407 (*result)->show_side_graph_toolbar); 415 (*result)->show_side_graph_toolbar);
408 (*result)->show_top_graph_toolbar = temp&0x08 ? psiconv_bool_true : 416 (*result)->show_top_graph_toolbar = temp&0x08 ? psiconv_bool_true :
409 psiconv_bool_false; 417 psiconv_bool_false;
410 psiconv_debug(lev+2,off+len,"Show top graph toolbar: %02x", 418 psiconv_debug(config,lev+2,off+len,"Show top graph toolbar: %02x",
411 (*result)->show_top_graph_toolbar); 419 (*result)->show_top_graph_toolbar);
412 if (temp & 0xf0) { 420 if (temp & 0xf0) {
413 psiconv_warn(lev+2,off+len,"Sheet status section toolbar byte " 421 psiconv_warn(config,lev+2,off+len,"Sheet status section toolbar byte "
414 "flags contains unknown flags (ignored)"); 422 "flags contains unknown flags (ignored)");
415 psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp & 0xf0); 423 psiconv_debug(config,lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
416 } 424 }
417 len ++; 425 len ++;
418 426
419 psiconv_progress(lev+2,off+len, 427 psiconv_progress(config,lev+2,off+len,
420 "Going to read the scrollbar status byte"); 428 "Going to read the scrollbar status byte");
421 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 429 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
422 if (res) 430 if (res)
423 goto ERROR2; 431 goto ERROR2;
424 if ((temp & 0x03) == 0x03) { 432 if ((temp & 0x03) == 0x03) {
425 psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte " 433 psiconv_warn(config,lev+2,off+len,"Sheet status section scrollbar byte "
426 "flags contains unknown flags (ignored)"); 434 "flags contains unknown flags (ignored)");
427 psiconv_debug(lev+2,off+len,"Unknown flag: %02x",temp & 0x03); 435 psiconv_debug(config,lev+2,off+len,"Unknown flag: %02x",temp & 0x03);
428 } 436 }
429 (*result)->show_horizontal_scrollbar = (temp&0x03) == 1? psiconv_triple_off : 437 (*result)->show_horizontal_scrollbar = (temp&0x03) == 1? psiconv_triple_off :
430 (temp&0x03) == 2? psiconv_triple_auto: 438 (temp&0x03) == 2? psiconv_triple_auto:
431 psiconv_triple_on; 439 psiconv_triple_on;
432 psiconv_debug(lev+2,off+len,"Show horizontal scrollbar: %02x", 440 psiconv_debug(config,lev+2,off+len,"Show horizontal scrollbar: %02x",
433 (*result)->show_horizontal_scrollbar); 441 (*result)->show_horizontal_scrollbar);
434 if ((temp & 0x0c) == 0x0c) { 442 if ((temp & 0x0c) == 0x0c) {
435 psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte " 443 psiconv_warn(config,lev+2,off+len,"Sheet status section scrollbar byte "
436 "flags contains unknown flags (ignored)"); 444 "flags contains unknown flags (ignored)");
437 psiconv_debug(lev+2,off+len,"Unknown flag: %02x",temp & 0x0c); 445 psiconv_debug(config,lev+2,off+len,"Unknown flag: %02x",temp & 0x0c);
438 } 446 }
439 (*result)->show_vertical_scrollbar = (temp&0x0c) ==0x04? psiconv_triple_off: 447 (*result)->show_vertical_scrollbar = (temp&0x0c) ==0x04? psiconv_triple_off:
440 (temp&0x0c) ==0x08? psiconv_triple_auto: 448 (temp&0x0c) ==0x08? psiconv_triple_auto:
441 psiconv_triple_on; 449 psiconv_triple_on;
442 psiconv_debug(lev+2,off+len,"Show vertical scrollbar: %02x", 450 psiconv_debug(config,lev+2,off+len,"Show vertical scrollbar: %02x",
443 (*result)->show_vertical_scrollbar); 451 (*result)->show_vertical_scrollbar);
444 if (temp & 0xf0) { 452 if (temp & 0xf0) {
445 psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte " 453 psiconv_warn(config,lev+2,off+len,"Sheet status section scrollbar byte "
446 "flags contains unknown flags (ignored)"); 454 "flags contains unknown flags (ignored)");
447 psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp & 0xf0); 455 psiconv_debug(config,lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
448 } 456 }
449 len ++; 457 len ++;
450 458
451 psiconv_progress(lev+2,off+len, 459 psiconv_progress(config,lev+2,off+len,
452 "Going to read an unknown byte (%02x expected)",0x00); 460 "Going to read an unknown byte (%02x expected)",0x00);
453 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 461 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
454 if (res) 462 if (res)
455 goto ERROR2; 463 goto ERROR2;
456 if (temp != 0x00) { 464 if (temp != 0x00) {
457 psiconv_warn(lev+2,off+len, 465 psiconv_warn(config,lev+2,off+len,
458 "Sheet status section unknown byte unknown value (ignored)"); 466 "Sheet status section unknown byte unknown value (ignored)");
459 psiconv_debug(lev+2,off+len,"Unknown byte: %02x",temp); 467 psiconv_debug(config,lev+2,off+len,"Unknown byte: %02x",temp);
460 } 468 }
461 len ++; 469 len ++;
462 470
463 psiconv_progress(lev+2,off+len,"Going to read sheet display size"); 471 psiconv_progress(config,lev+2,off+len,"Going to read sheet display size");
464 (*result)->sheet_display_size = psiconv_read_u32(buf,lev+2,off + len,&res); 472 (*result)->sheet_display_size = psiconv_read_u32(config,buf,lev+2,off + len,&res);
465 if (res) 473 if (res)
466 goto ERROR2; 474 goto ERROR2;
467 psiconv_debug(lev+2,off+len,"Sheet display size: %08x", 475 psiconv_debug(config,lev+2,off+len,"Sheet display size: %08x",
468 (*result)->sheet_display_size); 476 (*result)->sheet_display_size);
469 len += 0x04; 477 len += 0x04;
470 478
471 psiconv_progress(lev+2,off+len,"Going to read graph display size"); 479 psiconv_progress(config,lev+2,off+len,"Going to read graph display size");
472 (*result)->graph_display_size = psiconv_read_u32(buf,lev+2,off + len,&res); 480 (*result)->graph_display_size = psiconv_read_u32(config,buf,lev+2,off + len,&res);
473 if (res) 481 if (res)
474 goto ERROR2; 482 goto ERROR2;
475 psiconv_debug(lev+2,off+len,"Graph display size: %08x", 483 psiconv_debug(config,lev+2,off+len,"Graph display size: %08x",
476 (*result)->graph_display_size); 484 (*result)->graph_display_size);
477 len += 0x04; 485 len += 0x04;
478 486
479 if (length) 487 if (length)
480 *length = len; 488 *length = len;
481 489
482 psiconv_progress(lev,off+len-1, 490 psiconv_progress(config,lev,off+len-1,
483 "End of sheet status section (total length: %08x)", len); 491 "End of sheet status section (total length: %08x)", len);
484 return 0; 492 return 0;
485 493
486ERROR2: 494ERROR2:
487 free (*result); 495 free (*result);
488ERROR1: 496ERROR1:
489 psiconv_warn(lev+1,off,"Reading of Sheet Status Section failed"); 497 psiconv_warn(config,lev+1,off,"Reading of Sheet Status Section failed");
490 if (length) 498 if (length)
491 *length = 0; 499 *length = 0;
492 if (!res) 500 if (!res)
493 return -PSICONV_E_NOMEM; 501 return -PSICONV_E_NOMEM;
494 else 502 else
495 return res; 503 return res;
496} 504}
497 505
498int psiconv_parse_sheet_workbook_section(const psiconv_buffer buf, int lev, 506int psiconv_parse_sheet_workbook_section(const psiconv_config config,
507 const psiconv_buffer buf, int lev,
499 psiconv_u32 off, int *length, 508 psiconv_u32 off, int *length,
500 psiconv_sheet_workbook_section *result) 509 psiconv_sheet_workbook_section *result)
501{ 510{
502 int res=0,with_name; 511 int res=0,with_name;
503 psiconv_u32 temp,formulas_off,worksheets_off,info_off,var_off,name_off=0; 512 psiconv_u32 temp,formulas_off,worksheets_off,info_off,var_off,name_off=0;
504 int len=0; 513 int len=0;
505 514
506 psiconv_progress(lev+1,off,"Going to read the sheet workbook section"); 515 psiconv_progress(config,lev+1,off,"Going to read the sheet workbook section");
507 if (!(*result = malloc(sizeof(**result)))) 516 if (!(*result = malloc(sizeof(**result))))
508 goto ERROR1; 517 goto ERROR1;
509 518
510 psiconv_progress(lev+2,off+len, 519 psiconv_progress(config,lev+2,off+len,
511 "Going to read the initial byte (%02x or $02xexpected)", 520 "Going to read the initial byte (%02x or %02x expected)",
512 0x02,0x04); 521 0x02,0x04);
513 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 522 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
514 if (res) 523 if (res)
515 goto ERROR2; 524 goto ERROR2;
516 if ((temp != 0x04) && temp !=0x02) { 525 if ((temp != 0x04) && temp !=0x02) {
517 psiconv_warn(lev+2,off+len, 526 psiconv_warn(config,lev+2,off+len,
518 "Sheet workbook section initial byte unknown value (ignored)"); 527 "Sheet workbook section initial byte unknown value (ignored)");
519 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 528 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
520 } 529 }
521 with_name = temp ==0x04; 530 with_name = temp ==0x04;
522 len ++; 531 len ++;
523 532
524 psiconv_progress(lev+2,off+len, 533 psiconv_progress(config,lev+2,off+len,
525 "Going to read the offset of the sheet info Section"); 534 "Going to read the offset of the sheet info Section");
526 info_off = psiconv_read_u32(buf,lev+2,off+len,&res); 535 info_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
527 if (res) 536 if (res)
528 goto ERROR2; 537 goto ERROR2;
529 psiconv_debug(lev+2,off+len,"Offset: %04x",info_off); 538 psiconv_debug(config,lev+2,off+len,"Offset: %04x",info_off);
530 len += 4; 539 len += 4;
531 540
532 psiconv_progress(lev+2,off+len, 541 psiconv_progress(config,lev+2,off+len,
533 "Going to read the offset of the Formulas List"); 542 "Going to read the offset of the Formulas List");
534 formulas_off = psiconv_read_u32(buf,lev+2,off+len,&res); 543 formulas_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
535 if (res) 544 if (res)
536 goto ERROR2; 545 goto ERROR2;
537 psiconv_debug(lev+2,off+len,"Offset: %04x",formulas_off); 546 psiconv_debug(config,lev+2,off+len,"Offset: %04x",formulas_off);
538 len += 4; 547 len += 4;
539 548
540 psiconv_progress(lev+2,off+len, 549 psiconv_progress(config,lev+2,off+len,
541 "Going to read the offset of the Worksheet List"); 550 "Going to read the offset of the Worksheet List");
542 worksheets_off = psiconv_read_u32(buf,lev+2,off+len,&res); 551 worksheets_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
543 if (res) 552 if (res)
544 goto ERROR2; 553 goto ERROR2;
545 psiconv_debug(lev+2,off+len,"Offset: %04x",worksheets_off); 554 psiconv_debug(config,lev+2,off+len,"Offset: %04x",worksheets_off);
546 len += 4; 555 len += 4;
547 556
548 psiconv_progress(lev+2,off+len, 557 psiconv_progress(config,lev+2,off+len,
549 "Going to read the offset of the Variable List"); 558 "Going to read the offset of the Variable List");
550 var_off = psiconv_read_u32(buf,lev+2,off+len,&res); 559 var_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
551 if (res) 560 if (res)
552 goto ERROR2; 561 goto ERROR2;
553 psiconv_debug(lev+2,off+len,"Offset: %04x",var_off); 562 psiconv_debug(config,lev+2,off+len,"Offset: %04x",var_off);
554 len += 4; 563 len += 4;
555 564
556 if (with_name) { 565 if (with_name) {
557 psiconv_progress(lev+2,off+len, 566 psiconv_progress(config,lev+2,off+len,
558 "Going to read the offset of the Name Section"); 567 "Going to read the offset of the Name Section");
559 name_off = psiconv_read_u32(buf,lev+2,off+len,&res); 568 name_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
560 if (res) 569 if (res)
561 goto ERROR2; 570 goto ERROR2;
562 psiconv_debug(lev+2,off+len,"Offset: %04x",name_off); 571 psiconv_debug(config,lev+2,off+len,"Offset: %04x",name_off);
563 len += 4; 572 len += 4;
564 } 573 }
565 574
566 575
567 psiconv_progress(lev+2,off+len,"Going to read the info section"); 576 psiconv_progress(config,lev+2,off+len,"Going to read the info section");
568 if ((res = psiconv_parse_sheet_info_section(buf,lev+2,info_off,NULL, 577 if ((res = psiconv_parse_sheet_info_section(config,buf,lev+2,info_off,NULL,
569 &(*result)->info))) 578 &(*result)->info)))
570 goto ERROR2; 579 goto ERROR2;
571 580
572 psiconv_progress(lev+2,off+len,"Going to read the variables list"); 581 psiconv_progress(config,lev+2,off+len,"Going to read the variables list");
573 if ((res = psiconv_parse_sheet_variable_list(buf,lev+2,var_off,NULL, 582 if ((res = psiconv_parse_sheet_variable_list(config,buf,lev+2,var_off,NULL,
574 &(*result)->variables))) 583 &(*result)->variables)))
575 goto ERROR3; 584 goto ERROR3;
576 585
577 psiconv_progress(lev+2,off+len,"Going to read the formulas list"); 586 psiconv_progress(config,lev+2,off+len,"Going to read the formulas list");
578 if ((res = psiconv_parse_sheet_formula_list(buf,lev+2,formulas_off,NULL, 587 if ((res = psiconv_parse_sheet_formula_list(config,buf,lev+2,formulas_off,NULL,
579 &(*result)->formulas))) 588 &(*result)->formulas)))
580 goto ERROR4; 589 goto ERROR4;
581 590
582 psiconv_progress(lev+2,off+len,"Going to read the worksheet list"); 591 psiconv_progress(config,lev+2,off+len,"Going to read the worksheet list");
583 if ((res = psiconv_parse_sheet_worksheet_list(buf,lev+2,worksheets_off, 592 if ((res = psiconv_parse_sheet_worksheet_list(config,buf,lev+2,worksheets_off,
584 NULL,&(*result)->worksheets))) 593 NULL,&(*result)->worksheets)))
585 goto ERROR5; 594 goto ERROR5;
586 595
587 if (with_name) { 596 if (with_name) {
588 psiconv_progress(lev+2,off+len,"Going to read the name section"); 597 psiconv_progress(config,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, 598 if ((res = psiconv_parse_sheet_name_section(config,buf,lev+2,name_off,NULL,
591 &(*result)->name))) 599 &(*result)->name)))
592 goto ERROR6; 600 goto ERROR6;
593 } else 601 } else
594 (*result)->name = NULL; 602 (*result)->name = NULL;
595 603
596 if (length) 604 if (length)
597 *length = len; 605 *length = len;
598 606
599 psiconv_progress(lev,off+len-1, 607 psiconv_progress(config,lev,off+len-1,
600 "End of sheet workbook section (total length: %08x)", len); 608 "End of sheet workbook section (total length: %08x)", len);
601 return 0; 609 return 0;
602 610
603ERROR6: 611ERROR6:
604 psiconv_free_sheet_worksheet_list((*result)->worksheets); 612 psiconv_free_sheet_worksheet_list((*result)->worksheets);
… …
609ERROR3: 617ERROR3:
610 psiconv_free_sheet_info_section((*result)->info); 618 psiconv_free_sheet_info_section((*result)->info);
611ERROR2: 619ERROR2:
612 free (*result); 620 free (*result);
613ERROR1: 621ERROR1:
614 psiconv_warn(lev+1,off,"Reading of Sheet Workbook Section failed"); 622 psiconv_warn(config,lev+1,off,"Reading of Sheet Workbook Section failed");
615 if (length) 623 if (length)
616 *length = 0; 624 *length = 0;
617 if (!res) 625 if (!res)
618 return -PSICONV_E_NOMEM; 626 return -PSICONV_E_NOMEM;
619 else 627 else
620 return res; 628 return res;
621} 629}
622 630
623int psiconv_parse_sheet_name_section(const psiconv_buffer buf, int lev, 631int psiconv_parse_sheet_name_section(const psiconv_config config,
632 const psiconv_buffer buf, int lev,
624 psiconv_u32 off, int *length, 633 psiconv_u32 off, int *length,
625 psiconv_sheet_name_section *result) 634 psiconv_sheet_name_section *result)
626{ 635{
627 int res=0; 636 int res=0;
628 psiconv_u32 temp; 637 psiconv_u32 temp;
629 int len=0,leng; 638 int len=0,leng;
630 639
631 psiconv_progress(lev+1,off,"Going to read the sheet name section"); 640 psiconv_progress(config,lev+1,off,"Going to read the sheet name section");
632 if (!(*result = malloc(sizeof(**result)))) 641 if (!(*result = malloc(sizeof(**result))))
633 goto ERROR1; 642 goto ERROR1;
634 643
635 psiconv_progress(lev+2,off+len, 644 psiconv_progress(config,lev+2,off+len,
636 "Going to read the initial byte (%02x expected)",0x02); 645 "Going to read the initial byte (%02x expected)",0x02);
637 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 646 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
638 if (res) 647 if (res)
639 goto ERROR2; 648 goto ERROR2;
640 if (temp != 0x02) { 649 if (temp != 0x02) {
641 psiconv_warn(lev+2,off+len, 650 psiconv_warn(config,lev+2,off+len,
642 "Sheet name section initial byte unknown value (ignored)"); 651 "Sheet name section initial byte unknown value (ignored)");
643 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 652 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
644 } 653 }
645 len ++; 654 len ++;
646 655
647 psiconv_progress(lev+2,off+len, "Going to read the sheet name"); 656 psiconv_progress(config,lev+2,off+len, "Going to read the sheet name");
648 (*result)->name = psiconv_read_string(buf,lev+2,off+len,&leng,&res); 657 (*result)->name = psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
649 if (res) 658 if (res)
650 goto ERROR2; 659 goto ERROR2;
651 len += leng; 660 len += leng;
652 661
653 if (length) 662 if (length)
654 *length = len; 663 *length = len;
655 664
656 psiconv_progress(lev,off+len-1, 665 psiconv_progress(config,lev,off+len-1,
657 "End of sheet name section (total length: %08x)", len); 666 "End of sheet name section (total length: %08x)", len);
658 return 0; 667 return 0;
659 668
660ERROR2: 669ERROR2:
661 free(*result); 670 free(*result);
662ERROR1: 671ERROR1:
663 psiconv_warn(lev+1,off,"Reading of Sheet Name Section failed"); 672 psiconv_warn(config,lev+1,off,"Reading of Sheet Name Section failed");
664 if (length) 673 if (length)
665 *length = 0; 674 *length = 0;
666 if (!res) 675 if (!res)
667 return -PSICONV_E_NOMEM; 676 return -PSICONV_E_NOMEM;
668 else 677 else
669 return res; 678 return res;
670} 679}
671 680
672int psiconv_parse_sheet_info_section(const psiconv_buffer buf, int lev, 681int psiconv_parse_sheet_info_section(const psiconv_config config,
682 const psiconv_buffer buf, int lev,
673 psiconv_u32 off, int *length, 683 psiconv_u32 off, int *length,
674 psiconv_sheet_info_section *result) 684 psiconv_sheet_info_section *result)
675{ 685{
676 int res=0; 686 int res=0;
677 psiconv_u32 temp; 687 psiconv_u32 temp;
678 int len=0; 688 int len=0,leng;
679 689
680 psiconv_progress(lev+1,off,"Going to read the sheet info section"); 690 psiconv_progress(config,lev+1,off,"Going to read the sheet info section");
681 if (!(*result = malloc(sizeof(**result)))) 691 if (!(*result = malloc(sizeof(**result))))
682 goto ERROR1; 692 goto ERROR1;
683 693
684 psiconv_progress(lev+2,off+len, 694 psiconv_progress(config,lev+2,off+len,
685 "Going to read the initial byte (%02x expected)",0x02); 695 "Going to read the initial byte (%02x expected)",0x02);
686 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 696 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
687 if (res) 697 if (res)
688 goto ERROR2; 698 goto ERROR2;
689 if (temp != 0x02) { 699 if (temp != 0x02) {
690 psiconv_warn(lev+2,off+len, 700 psiconv_warn(config,lev+2,off+len,
691 "Sheet info section initial byte unknown value (ignored)"); 701 "Sheet info section initial byte unknown value (ignored)");
692 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 702 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
693 } 703 }
694 len ++; 704 len ++;
695 705
706 psiconv_progress(config,lev+2,off+len, "Going to read an unknown Xint");
707 temp = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
708 if (res)
709 goto ERROR2;
710 psiconv_debug(config,lev+2,off+len,"Value: %d\n",temp);
711 len += leng;
712
696 psiconv_progress(lev+2,off+len, "Going to read the flags byte"); 713 psiconv_progress(config,lev+2,off+len, "Going to read the flags byte");
697 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 714 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
698 if (res) 715 if (res)
699 goto ERROR2; 716 goto ERROR2;
700 (*result)->auto_recalc = temp & 0x01 ? psiconv_bool_true:psiconv_bool_false; 717 (*result)->auto_recalc = temp & 0x01 ? psiconv_bool_true:psiconv_bool_false;
701 psiconv_debug(lev+2,off+len,"Auto recalculation: %02x", 718 psiconv_debug(config,lev+2,off+len,"Auto recalculation: %02x",
702 (*result)->auto_recalc); 719 (*result)->auto_recalc);
703 if ((temp & 0xfe) != 0x02) { 720 if ((temp & 0xfe) != 0x02) {
704 psiconv_warn(lev+2,off+len,"Sheet Info Section flags byte " 721 psiconv_warn(config,lev+2,off+len,"Sheet Info Section flags byte "
705 "contains unknown flags (ignored)"); 722 "contains unknown flags (ignored)");
706 psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp &0xfe); 723 psiconv_debug(config,lev+2,off+len,"Unknown flags: %02x",temp &0xfe);
707 } 724 }
708 725
709 len ++; 726 len ++;
710 727
711 728
712 if (length) 729 if (length)
713 *length = len; 730 *length = len;
714 731
715 psiconv_progress(lev,off+len-1, 732 psiconv_progress(config,lev,off+len-1,
716 "End of sheet info section (total length: %08x)", len); 733 "End of sheet info section (total length: %08x)", len);
717 return 0; 734 return 0;
718 735
719ERROR2: 736ERROR2:
720 free(*result); 737 free(*result);
721ERROR1: 738ERROR1:
722 psiconv_warn(lev+1,off,"Reading of Sheet Name Section failed"); 739 psiconv_warn(config,lev+1,off,"Reading of Sheet Name Section failed");
723 if (length) 740 if (length)
724 *length = 0; 741 *length = 0;
725 if (!res) 742 if (!res)
726 return -PSICONV_E_NOMEM; 743 return -PSICONV_E_NOMEM;
727 else 744 else
728 return res; 745 return res;
729} 746}
730 747
731int psiconv_parse_sheet_formula_list(const psiconv_buffer buf, int lev, 748int psiconv_parse_sheet_formula_list(const psiconv_config config,
749 const psiconv_buffer buf, int lev,
732 psiconv_u32 off, int *length, 750 psiconv_u32 off, int *length,
733 psiconv_formula_list *result) 751 psiconv_formula_list *result)
734{ 752{
735 int res=0; 753 int res=0;
736 int len=0; 754 int len=0;
737 psiconv_u32 temp; 755 psiconv_u32 temp;
738 psiconv_formula formula; 756 psiconv_formula formula;
739 psiconv_u32 listlen,i; 757 psiconv_u32 listlen,i;
740 int leng; 758 int leng;
741 759
742 psiconv_progress(lev+1,off,"Going to read the sheet formula list"); 760 psiconv_progress(config,lev+1,off,"Going to read the sheet formula list");
743 if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s)))) 761 if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s))))
744 goto ERROR1; 762 goto ERROR1;
745 763
746 psiconv_progress(lev+2,off+len, 764 psiconv_progress(config,lev+2,off+len,
747 "Going to read the initial byte (%02x expected)",0x02); 765 "Going to read the initial byte (%02x expected)",0x02);
748 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 766 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
749 if (res) 767 if (res)
750 goto ERROR2; 768 goto ERROR2;
751 if (temp != 0x02) { 769 if (temp != 0x02) {
752 psiconv_warn(lev+2,off+len, 770 psiconv_warn(config,lev+2,off+len,
753 "Sheet formula list initial byte unknown value (ignored)"); 771 "Sheet formula list initial byte unknown value (ignored)");
754 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 772 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
755 } 773 }
756 len ++; 774 len ++;
757 775
758 psiconv_progress(lev+2,off+len, 776 psiconv_progress(config,lev+2,off+len,
759 "Going to read the number of formulas"); 777 "Going to read the number of formulas");
760 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 778 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
761 if (res) 779 if (res)
762 goto ERROR2; 780 goto ERROR2;
763 psiconv_debug(lev+2,off+len,"Number of formulas: %d",listlen); 781 psiconv_debug(config,lev+2,off+len,"Number of formulas: %d",listlen);
764 len += leng; 782 len += leng;
765 783
766 psiconv_progress(lev+2,off+len,"Going to read all formulas"); 784 psiconv_progress(config,lev+2,off+len,"Going to read all formulas");
767 for (i = 0; i < listlen; i++) { 785 for (i = 0; i < listlen; i++) {
768 psiconv_progress(lev+3,off+len,"Going to read formula %d",i); 786 psiconv_progress(config,lev+3,off+len,"Going to read formula %d",i);
769 if ((res = psiconv_parse_formula(buf,lev+3,off+len,&leng,&formula))) 787 if ((res = psiconv_parse_formula(config,buf,lev+3,off+len,&leng,&formula)))
770 goto ERROR2; 788 goto ERROR2;
771 if ((res = psiconv_list_add(*result,formula))) 789 if ((res = psiconv_list_add(*result,formula)))
772 goto ERROR3; 790 goto ERROR3;
791 free(formula);
773 len += leng; 792 len += leng;
774 } 793 }
775 794
776 if (length) 795 if (length)
777 *length = len; 796 *length = len;
778 797
779 psiconv_progress(lev,off+len-1, 798 psiconv_progress(config,lev,off+len-1,
780 "End of sheet formula list (total length: %08x)", len); 799 "End of sheet formula list (total length: %08x)", len);
781 return 0; 800 return 0;
782 801
783ERROR3: 802ERROR3:
784 psiconv_free_formula(formula); 803 psiconv_free_formula(formula);
785ERROR2: 804ERROR2:
786 psiconv_list_free(*result); 805 psiconv_list_free(*result);
787ERROR1: 806ERROR1:
788 psiconv_warn(lev+1,off,"Reading of Sheet Formula list failed"); 807 psiconv_warn(config,lev+1,off,"Reading of Sheet Formula list failed");
789 if (length) 808 if (length)
790 *length = 0; 809 *length = 0;
791 if (!res) 810 if (!res)
792 return -PSICONV_E_NOMEM; 811 return -PSICONV_E_NOMEM;
793 else 812 else
794 return res; 813 return res;
795} 814}
796 815
797int psiconv_parse_sheet_cell(const psiconv_buffer buf, int lev, 816int psiconv_parse_sheet_cell(const psiconv_config config,
817 const psiconv_buffer buf, int lev,
798 psiconv_u32 off, int *length, 818 psiconv_u32 off, int *length,
799 psiconv_sheet_cell *result, 819 psiconv_sheet_cell *result,
800 const psiconv_sheet_cell_layout default_layout, 820 const psiconv_sheet_cell_layout default_layout,
801 const psiconv_sheet_line_list row_default_layouts, 821 const psiconv_sheet_line_list row_default_layouts,
802 const psiconv_sheet_line_list col_default_layouts) 822 const psiconv_sheet_line_list col_default_layouts)
… …
804 int res=0; 824 int res=0;
805 int len=0; 825 int len=0;
806 psiconv_u32 temp; 826 psiconv_u32 temp;
807 psiconv_bool_t has_layout; 827 psiconv_bool_t has_layout;
808 int leng; 828 int leng;
829 char *auxstr;
809 830
810 psiconv_progress(lev+1,off,"Going to read a sheet cell structure"); 831 psiconv_progress(config,lev+1,off,"Going to read a sheet cell structure");
811 if (!(*result = malloc(sizeof(**result)))) 832 if (!(*result = malloc(sizeof(**result))))
812 goto ERROR1; 833 goto ERROR1;
813 834
814 (*result)->layout = NULL; 835 (*result)->layout = NULL;
815 (*result)->type = psiconv_cell_blank; 836 (*result)->type = psiconv_cell_blank;
816 837
817 psiconv_progress(lev+2,off+len,"Going to read the cell position"); 838 psiconv_progress(config,lev+2,off+len,"Going to read the cell position");
818 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 839 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
819 if (res) 840 if (res)
820 goto ERROR2; 841 goto ERROR2;
821 len ++; 842 len ++;
822 temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 8; 843 temp += psiconv_read_u8(config,buf,lev+2,off+len,&res) << 8;
823 if (res) 844 if (res)
824 goto ERROR2; 845 goto ERROR2;
825 len ++; 846 len ++;
826 temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 16; 847 temp += psiconv_read_u8(config,buf,lev+2,off+len,&res) << 16;
827 if (res) 848 if (res)
828 goto ERROR2; 849 goto ERROR2;
829 len ++; 850 len ++;
830 (*result)->column = (temp >> 2) & 0xFF; 851 (*result)->column = (temp >> 2) & 0xFF;
831 (*result)->row = (temp >> 10) & 0x3FFF; 852 (*result)->row = (temp >> 10) & 0x3FFF;
832 psiconv_debug(lev+2,off+len,"Cell position is col:%02x row:%04x", 853 psiconv_debug(config,lev+2,off+len,"Cell position is col:%02x row:%04x",
833 (*result)->column,(*result)->row); 854 (*result)->column,(*result)->row);
834 if (temp & 0x03) { 855 if (temp & 0x03) {
835 psiconv_warn(lev+2,off+len,"Unknown flags in cell position (ignored)"); 856 psiconv_warn(config,lev+2,off+len,"Unknown flags in cell position (ignored)");
836 psiconv_debug(lev+2,off+len,"Flags: %02x",temp & 0x03); 857 psiconv_debug(config,lev+2,off+len,"Flags: %02x",temp & 0x03);
837 } 858 }
838 859
839 psiconv_progress(lev+2,off+len,"Going to read the cell type"); 860 psiconv_progress(config,lev+2,off+len,"Going to read the cell type");
840 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 861 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
841 if (res) 862 if (res)
842 goto ERROR2; 863 goto ERROR2;
843 len ++; 864 len ++;
844 (*result)->type = (temp >> 5) & 0x07; 865 (*result)->type = (temp >> 5) & 0x07;
845 (*result)->calculated = (temp & 0x08)?psiconv_bool_true:psiconv_bool_false; 866 (*result)->calculated = (temp & 0x08)?psiconv_bool_true:psiconv_bool_false;
846 has_layout = (temp & 0x10)?psiconv_bool_true:psiconv_bool_false; 867 has_layout = (temp & 0x10)?psiconv_bool_true:psiconv_bool_false;
847 868
848 psiconv_progress(lev+2,off+len,"Going to read the cell value"); 869 psiconv_progress(config,lev+2,off+len,"Going to read the cell value");
849 if ((*result)->type == psiconv_cell_blank) { 870 if ((*result)->type == psiconv_cell_blank) {
850 psiconv_debug(lev+2,off+len,"Cell type is blank: no value given."); 871 psiconv_debug(config,lev+2,off+len,"Cell type is blank: no value given.");
851 } else if ((*result)->type == psiconv_cell_int) { 872 } else if ((*result)->type == psiconv_cell_int) {
852 psiconv_progress(lev+2,off+len,"Going to read an integer"); 873 psiconv_progress(config,lev+2,off+len,"Going to read an integer");
853 (*result)->data.dat_int = psiconv_read_u32(buf,lev+2,off+len,&res); 874 (*result)->data.dat_int = psiconv_read_u32(config,buf,lev+2,off+len,&res);
854 if (res) 875 if (res)
855 goto ERROR2; 876 goto ERROR2;
856 len += 4; 877 len += 4;
857 psiconv_debug(lev+2,off+len,"Cell contents: %ld",(*result)->data.dat_int); 878 psiconv_debug(config,lev+2,off+len,"Cell contents: %ld",(*result)->data.dat_int);
858 879
859 } else if ((*result)->type == psiconv_cell_bool) { 880 } else if ((*result)->type == psiconv_cell_bool) {
860 psiconv_progress(lev+2,off+len,"Going to read a boolean"); 881 psiconv_progress(config,lev+2,off+len,"Going to read a boolean");
861 if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng, 882 if ((res = psiconv_parse_bool(config,buf,lev+2,off+len,&leng,
862 &(*result)->data.dat_bool))) 883 &(*result)->data.dat_bool)))
863 goto ERROR2; 884 goto ERROR2;
864 psiconv_debug(lev+2,off+len,"Cell contents: %01x",temp); 885 psiconv_debug(config,lev+2,off+len,"Cell contents: %01x",temp);
865 (*result)->data.dat_bool = temp?psiconv_bool_true:psiconv_bool_false; 886 (*result)->data.dat_bool = temp?psiconv_bool_true:psiconv_bool_false;
866 len += leng; 887 len += leng;
867 } else if ((*result)->type == psiconv_cell_error) { 888 } else if ((*result)->type == psiconv_cell_error) {
868 psiconv_progress(lev+2,off+len,"Going to read the error code"); 889 psiconv_progress(config,lev+2,off+len,"Going to read the error code");
869 temp = psiconv_read_u16(buf,lev+2,off+len,&res); 890 temp = psiconv_read_u16(config,buf,lev+2,off+len,&res);
870 if (res) 891 if (res)
871 goto ERROR2; 892 goto ERROR2;
872 if (temp == 0) 893 if (temp == 0)
873 (*result)->data.dat_error = psiconv_sheet_error_none; 894 (*result)->data.dat_error = psiconv_sheet_error_none;
874 else if (temp == 1) 895 else if (temp == 1)
… …
884 else if (temp == 6) 905 else if (temp == 6)
885 (*result)->data.dat_error = psiconv_sheet_error_number; 906 (*result)->data.dat_error = psiconv_sheet_error_number;
886 else if (temp == 7) 907 else if (temp == 7)
887 (*result)->data.dat_error = psiconv_sheet_error_notavail; 908 (*result)->data.dat_error = psiconv_sheet_error_notavail;
888 else { 909 else {
889 psiconv_warn(lev+2,off+len,"Unknown error code (default assumed)"); 910 psiconv_warn(config,lev+2,off+len,"Unknown error code (default assumed)");
890 psiconv_debug(lev+2,off+len,"Error code: %04x",temp); 911 psiconv_debug(config,lev+2,off+len,"Error code: %04x",temp);
891 (*result)->data.dat_error = psiconv_sheet_error_none; 912 (*result)->data.dat_error = psiconv_sheet_error_none;
892 } 913 }
893 psiconv_debug(lev+2,off+len,"Cell contents: %04x", 914 psiconv_debug(config,lev+2,off+len,"Cell contents: %04x",
894 (*result)->data.dat_error); 915 (*result)->data.dat_error);
895 len += 2; 916 len += 2;
896 } else if ((*result)->type == psiconv_cell_float) { 917 } else if ((*result)->type == psiconv_cell_float) {
897 psiconv_progress(lev+2,off+len,"Going to read a float"); 918 psiconv_progress(config,lev+2,off+len,"Going to read a float");
898 (*result)->data.dat_float = 919 (*result)->data.dat_float =
899 psiconv_read_float(buf,lev+2,off+len,&leng,&res); 920 psiconv_read_float(config,buf,lev+2,off+len,&leng,&res);
900 if (res) 921 if (res)
901 goto ERROR2; 922 goto ERROR2;
902 psiconv_debug(lev+2,off+len,"Cell contents: %f",(*result)->data.dat_float); 923 psiconv_debug(config,lev+2,off+len,"Cell contents: %f",(*result)->data.dat_float);
903 len += leng; 924 len += leng;
904 } else if ((*result)->type == psiconv_cell_string) { 925 } else if ((*result)->type == psiconv_cell_string) {
905 psiconv_progress(lev+2,off+len,"Going to read a string"); 926 psiconv_progress(config,lev+2,off+len,"Going to read a string");
906 (*result)->data.dat_string = 927 (*result)->data.dat_string =
907 psiconv_read_string(buf,lev+2,off+len,&leng,&res); 928 psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
908 if (res) 929 if (res)
909 goto ERROR2; 930 goto ERROR2;
931 if (!(auxstr = psiconv_make_printable((*result)->data.dat_string)))
932 goto ERROR2;
910 psiconv_debug(lev+2,off+len,"Cell contents: `%s'", 933 psiconv_debug(config,lev+2,off+len,"Cell contents: `%s'",auxstr);
911 (*result)->data.dat_string); 934 free(auxstr);
912 len += leng; 935 len += leng;
913 } else { 936 } else {
914 psiconv_warn(lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type); 937 psiconv_warn(config,lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type);
915 res = PSICONV_E_PARSE; 938 res = PSICONV_E_PARSE;
916 goto ERROR2; 939 goto ERROR2;
917 } 940 }
918 941
919 if (!((*result)->layout = psiconv_clone_cell_layout( 942 if (!((*result)->layout = psiconv_clone_cell_layout(
… …
922 default_layout, 945 default_layout,
923 (*result)->row, 946 (*result)->row,
924 (*result)->column)))) 947 (*result)->column))))
925 goto ERROR2; 948 goto ERROR2;
926 if (has_layout) { 949 if (has_layout) {
927 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len, 950 if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,
928 &leng,(*result)->layout))) 951 &leng,(*result)->layout)))
929 goto ERROR2; 952 goto ERROR2;
930 len += leng; 953 len += leng;
931 } 954 }
932 955
933 if ((*result)->calculated) { 956 if ((*result)->calculated) {
934 psiconv_progress(lev+2,off+len,"Going to read the cell formula reference"); 957 psiconv_progress(config,lev+2,off+len,"Going to read the cell formula reference");
935 temp = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 958 temp = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
936 if (res) 959 if (res)
937 goto ERROR2; 960 goto ERROR2;
938 psiconv_debug(lev+2,off+len,"Cell formula reference: %d",temp); 961 psiconv_debug(config,lev+2,off+len,"Cell formula reference: %d",temp);
939 len += leng; 962 len += leng;
940 (*result)->ref_formula = temp; 963 (*result)->ref_formula = temp;
941 } 964 }
942 965
943 if (length) 966 if (length)
944 *length = len; 967 *length = len;
945 968
946 psiconv_progress(lev,off+len-1, 969 psiconv_progress(config,lev,off+len-1,
947 "End of sheet cell structure (total length: %08x)", len); 970 "End of sheet cell structure (total length: %08x)", len);
948 return 0; 971 return 0;
949 972
950ERROR2: 973ERROR2:
951 psiconv_free_sheet_cell(*result); 974 psiconv_free_sheet_cell(*result);
952ERROR1: 975ERROR1:
953 psiconv_warn(lev+1,off,"Reading of Sheet Cell Structure failed"); 976 psiconv_warn(config,lev+1,off,"Reading of Sheet Cell Structure failed");
954 if (length) 977 if (length)
955 *length = 0; 978 *length = 0;
956 if (!res) 979 if (!res)
957 return -PSICONV_E_NOMEM; 980 return -PSICONV_E_NOMEM;
958 else 981 else
959 return res; 982 return res;
960} 983}
961 984
962int psiconv_parse_sheet_cell_list(const psiconv_buffer buf, int lev, 985int psiconv_parse_sheet_cell_list(const psiconv_config config,
986 const psiconv_buffer buf, int lev,
963 psiconv_u32 off, int *length, 987 psiconv_u32 off, int *length,
964 psiconv_sheet_cell_list *result, 988 psiconv_sheet_cell_list *result,
965 const psiconv_sheet_cell_layout default_layout, 989 const psiconv_sheet_cell_layout default_layout,
966 const psiconv_sheet_line_list row_default_layouts, 990 const psiconv_sheet_line_list row_default_layouts,
967 const psiconv_sheet_line_list col_default_layouts) 991 const psiconv_sheet_line_list col_default_layouts)
… …
971 psiconv_u32 temp; 995 psiconv_u32 temp;
972 psiconv_sheet_cell cell; 996 psiconv_sheet_cell cell;
973 psiconv_u32 listlen,i; 997 psiconv_u32 listlen,i;
974 int leng; 998 int leng;
975 999
976 psiconv_progress(lev+1,off,"Going to read the sheet cell list"); 1000 psiconv_progress(config,lev+1,off,"Going to read the sheet cell list");
977 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_cell_s)))) 1001 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_cell_s))))
978 goto ERROR1; 1002 goto ERROR1;
979 1003
980 psiconv_progress(lev+2,off+len, 1004 psiconv_progress(config,lev+2,off+len,
981 "Going to read the initial byte (%02x expected)",0x02); 1005 "Going to read the initial byte (%02x expected)",0x02);
982 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1006 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
983 if (res) 1007 if (res)
984 goto ERROR2; 1008 goto ERROR2;
985 if (temp != 0x02) { 1009 if (temp != 0x02) {
986 psiconv_warn(lev+2,off+len, 1010 psiconv_warn(config,lev+2,off+len,
987 "Sheet cell list initial byte unknown value (ignored)"); 1011 "Sheet cell list initial byte unknown value (ignored)");
988 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1012 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
989 } 1013 }
990 len ++; 1014 len ++;
991 1015
992 psiconv_progress(lev+2,off+len, 1016 psiconv_progress(config,lev+2,off+len,
993 "Going to read the initial byte (%02x expected)",0x00); 1017 "Going to read the initial byte (%02x expected)",0x00);
994 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1018 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
995 if (res) 1019 if (res)
996 goto ERROR2; 1020 goto ERROR2;
997 if (temp != 0x00) { 1021 if (temp != 0x00) {
998 psiconv_warn(lev+2,off+len, 1022 psiconv_warn(config,lev+2,off+len,
999 "Sheet cell list initial byte unknown value (ignored)"); 1023 "Sheet cell list initial byte unknown value (ignored)");
1000 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1024 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1001 } 1025 }
1002 len ++; 1026 len ++;
1003 1027
1004 psiconv_progress(lev+2,off+len, 1028 psiconv_progress(config,lev+2,off+len,
1005 "Going to read the number of defined cells"); 1029 "Going to read the number of defined cells");
1006 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 1030 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1007 if (res) 1031 if (res)
1008 goto ERROR2; 1032 goto ERROR2;
1009 psiconv_debug(lev+2,off+len,"Number of defined cells: %d",listlen); 1033 psiconv_debug(config,lev+2,off+len,"Number of defined cells: %d",listlen);
1010 len += leng; 1034 len += leng;
1011 1035
1012 psiconv_progress(lev+2,off+len,"Going to read all cells"); 1036 psiconv_progress(config,lev+2,off+len,"Going to read all cells");
1013 for (i = 0; i < listlen; i++) { 1037 for (i = 0; i < listlen; i++) {
1014 psiconv_progress(lev+3,off+len,"Going to read cell %d",i); 1038 psiconv_progress(config,lev+3,off+len,"Going to read cell %d",i);
1015 if ((res = psiconv_parse_sheet_cell(buf,lev+3,off+len,&leng,&cell, 1039 if ((res = psiconv_parse_sheet_cell(config,buf,lev+3,off+len,&leng,&cell,
1016 default_layout,row_default_layouts, 1040 default_layout,row_default_layouts,
1017 col_default_layouts))) 1041 col_default_layouts)))
1018 goto ERROR2; 1042 goto ERROR2;
1019 if ((res = psiconv_list_add(*result,cell))) 1043 if ((res = psiconv_list_add(*result,cell)))
1020 goto ERROR3; 1044 goto ERROR3;
… …
1023 } 1047 }
1024 1048
1025 if (length) 1049 if (length)
1026 *length = len; 1050 *length = len;
1027 1051
1028 psiconv_progress(lev,off+len-1, 1052 psiconv_progress(config,lev,off+len-1,
1029 "End of sheet cell list (total length: %08x)", len); 1053 "End of sheet cell list (total length: %08x)", len);
1030 return 0; 1054 return 0;
1031 1055
1032ERROR3: 1056ERROR3:
1033 psiconv_free_sheet_cell(cell); 1057 psiconv_free_sheet_cell(cell);
1034ERROR2: 1058ERROR2:
1035 psiconv_free_sheet_cell_list(*result); 1059 psiconv_free_sheet_cell_list(*result);
1036ERROR1: 1060ERROR1:
1037 psiconv_warn(lev+1,off,"Reading of Sheet Cells List failed"); 1061 psiconv_warn(config,lev+1,off,"Reading of Sheet Cells List failed");
1038 if (length) 1062 if (length)
1039 *length = 0; 1063 *length = 0;
1040 if (!res) 1064 if (!res)
1041 return -PSICONV_E_NOMEM; 1065 return -PSICONV_E_NOMEM;
1042 else 1066 else
1043 return res; 1067 return res;
1044} 1068}
1045 1069
1046 1070
1047int psiconv_parse_sheet_worksheet_list( const psiconv_buffer buf, int lev, 1071int psiconv_parse_sheet_worksheet_list(const psiconv_config config,
1072 const psiconv_buffer buf, int lev,
1048 psiconv_u32 off, int *length, 1073 psiconv_u32 off, int *length,
1049 psiconv_sheet_worksheet_list *result) 1074 psiconv_sheet_worksheet_list *result)
1050{ 1075{
1051 psiconv_sheet_worksheet worksheet; 1076 psiconv_sheet_worksheet worksheet;
1052 int res=0; 1077 int res=0;
1053 int len=0; 1078 int len=0;
1054 psiconv_u8 temp; 1079 psiconv_u8 temp;
1055 psiconv_u32 offset; 1080 psiconv_u32 offset;
1056 int leng,i,nr; 1081 int leng,i,nr;
1057 1082
1058 psiconv_progress(lev+1,off,"Going to read the worksheet list"); 1083 psiconv_progress(config,lev+1,off,"Going to read the worksheet list");
1059 if (!(*result = psiconv_list_new(sizeof(*worksheet)))) 1084 if (!(*result = psiconv_list_new(sizeof(*worksheet))))
1060 goto ERROR1; 1085 goto ERROR1;
1061 1086
1062 psiconv_progress(lev+2,off+len, 1087 psiconv_progress(config,lev+2,off+len,
1063 "Going to read the initial bytes (%02x expected)",0x02); 1088 "Going to read the initial bytes (%02x expected)",0x02);
1064 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1089 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1065 if (res) 1090 if (res)
1066 goto ERROR2; 1091 goto ERROR2;
1067 if (temp != 0x02) { 1092 if (temp != 0x02) {
1068 psiconv_warn(lev+2,off+len, 1093 psiconv_warn(config,lev+2,off+len,
1069 "Sheet worksheet list initial byte unknown value (ignored)"); 1094 "Sheet worksheet list initial byte unknown value (ignored)");
1070 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1095 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1071 } 1096 }
1072 len ++; 1097 len ++;
1073 1098
1074 psiconv_progress(lev+2,off+len,"Going to read the list length"); 1099 psiconv_progress(config,lev+2,off+len,"Going to read the list length");
1075 nr = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 1100 nr = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1076 if (res) 1101 if (res)
1077 goto ERROR2; 1102 goto ERROR2;
1078 psiconv_debug(lev+2,off+len,"Length: %02x",nr); 1103 psiconv_debug(config,lev+2,off+len,"Length: %02x",nr);
1079 len += leng; 1104 len += leng;
1080 1105
1081 psiconv_progress(lev+2,off+len,"Going to read the list"); 1106 psiconv_progress(config,lev+2,off+len,"Going to read the list");
1082 for (i=0 ; i < nr; i++) { 1107 for (i=0 ; i < nr; i++) {
1083 psiconv_progress(lev+3,off+len,"Going to read element %d",i); 1108 psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
1084 psiconv_progress(lev+4,off+len, 1109 psiconv_progress(config,lev+4,off+len,
1085 "Going to read the initial byte (%02x expected)",0x00); 1110 "Going to read the initial byte (%02x expected)",0x00);
1086 temp = psiconv_read_u8(buf,lev+4,off+len,&res); 1111 temp = psiconv_read_u8(config,buf,lev+4,off+len,&res);
1087 if (res) 1112 if (res)
1088 goto ERROR2; 1113 goto ERROR2;
1089 if (temp != 0x00) { 1114 if (temp != 0x00) {
1090 psiconv_warn(lev+4,off+len, 1115 psiconv_warn(config,lev+4,off+len,
1091 "Sheet worksheet element initial byte unknown value (ignored)"); 1116 "Sheet worksheet element initial byte unknown value (ignored)");
1092 psiconv_debug(lev+4,off+len,"Initial byte: %02x",temp); 1117 psiconv_debug(config,lev+4,off+len,"Initial byte: %02x",temp);
1093 } 1118 }
1094 len ++; 1119 len ++;
1095 1120
1096 psiconv_progress(lev+4,off+len,"Going to read the worksheet offset"); 1121 psiconv_progress(config,lev+4,off+len,"Going to read the worksheet offset");
1097 offset = psiconv_read_u32(buf,lev+2,off+len,&res); 1122 offset = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1098 if (res) 1123 if (res)
1099 goto ERROR2; 1124 goto ERROR2;
1100 psiconv_debug(lev+4,off+len,"Offset: %08x",offset); 1125 psiconv_debug(config,lev+4,off+len,"Offset: %08x",offset);
1101 len += 4; 1126 len += 4;
1102 1127
1103 if ((res = psiconv_parse_sheet_worksheet(buf,lev+4,offset,NULL, 1128 if ((res = psiconv_parse_sheet_worksheet(config,buf,lev+4,offset,NULL,
1104 &worksheet))) 1129 &worksheet)))
1105 goto ERROR2; 1130 goto ERROR2;
1106 if ((res = psiconv_list_add(*result,worksheet))) 1131 if ((res = psiconv_list_add(*result,worksheet)))
1107 goto ERROR3; 1132 goto ERROR3;
1108 free(worksheet); 1133 free(worksheet);
1109 } 1134 }
1110 1135
1111 if (length) 1136 if (length)
1112 *length = len; 1137 *length = len;
1113 1138
1114 psiconv_progress(lev,off+len-1, 1139 psiconv_progress(config,lev,off+len-1,
1115 "End of worksheet list (total length: %08x)", len); 1140 "End of worksheet list (total length: %08x)", len);
1116 1141
1117 return 0; 1142 return 0;
1118 1143
1119ERROR3: 1144ERROR3:
1120 psiconv_free_sheet_worksheet(worksheet); 1145 psiconv_free_sheet_worksheet(worksheet);
1121ERROR2: 1146ERROR2:
1122 psiconv_free_sheet_worksheet_list(*result); 1147 psiconv_free_sheet_worksheet_list(*result);
1123ERROR1: 1148ERROR1:
1124 psiconv_warn(lev+1,off,"Reading of worksheet list failed"); 1149 psiconv_warn(config,lev+1,off,"Reading of worksheet list failed");
1125 if (length) 1150 if (length)
1126 *length = 0; 1151 *length = 0;
1127 if (!res) 1152 if (!res)
1128 return -PSICONV_E_NOMEM; 1153 return -PSICONV_E_NOMEM;
1129 else 1154 else
1130 return res; 1155 return res;
1131} 1156}
1132 1157
1133int psiconv_parse_sheet_cell_layout(const psiconv_buffer buf, int lev, 1158int psiconv_parse_sheet_cell_layout(const psiconv_config config,
1159 const psiconv_buffer buf, int lev,
1134 psiconv_u32 off, int *length, 1160 psiconv_u32 off, int *length,
1135 psiconv_sheet_cell_layout result) 1161 psiconv_sheet_cell_layout result)
1136 1162
1137{ 1163{
1138 int res=0; 1164 int res=0;
1139 int len=0; 1165 int len=0;
1140 int leng; 1166 int leng;
1141 psiconv_u8 temp; 1167 psiconv_u8 temp;
1142 1168
1143 psiconv_progress(lev+1,off,"Going to read a sheet cell layout"); 1169 psiconv_progress(config,lev+1,off,"Going to read a sheet cell layout");
1144 1170
1145 psiconv_progress(lev+2,off+len, 1171 psiconv_progress(config,lev+2,off+len,
1146 "Going to read the first byte (%02x expected)",0x02); 1172 "Going to read the first byte (%02x expected)",0x02);
1147 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1173 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1148 if (res) 1174 if (res)
1149 goto ERROR1; 1175 goto ERROR1;
1150 if (temp != 0x02) { 1176 if (temp != 0x02) {
1151 psiconv_warn(lev+2,off+len, 1177 psiconv_warn(config,lev+2,off+len,
1152 "Worksheet section initial byte unknown value (ignored)"); 1178 "Worksheet section initial byte unknown value (ignored)");
1153 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1179 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1154 } 1180 }
1155 len ++; 1181 len ++;
1156 1182
1157 psiconv_progress(lev+2,off+len,"Going to read the default formats flag"); 1183 psiconv_progress(config,lev+2,off+len,"Going to read the default formats flag");
1158 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1184 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1159 if (res) 1185 if (res)
1160 goto ERROR1; 1186 goto ERROR1;
1161 len ++; 1187 len ++;
1162 1188
1163 if (temp & 0x01) { 1189 if (temp & 0x01) {
1164 psiconv_progress(lev+3,off+len,"Going to read the default paragraph codes"); 1190 psiconv_progress(config,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, 1191 if ((res = psiconv_parse_paragraph_layout_list(config,buf,lev+3,off+len,&leng,
1166 result->paragraph))) 1192 result->paragraph)))
1167 goto ERROR1; 1193 goto ERROR1;
1168 len += leng; 1194 len += leng;
1169 } 1195 }
1170 1196
1171 if (temp & 0x02) { 1197 if (temp & 0x02) {
1172 psiconv_progress(lev+3,off+len,"Going to read the default character codes"); 1198 psiconv_progress(config,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, 1199 if ((res = psiconv_parse_character_layout_list(config,buf,lev+3,off+len,&leng,
1174 result->character))) 1200 result->character)))
1175 goto ERROR1; 1201 goto ERROR1;
1176 len += leng; 1202 len += leng;
1177 } 1203 }
1178 1204
1179 if (temp & 0x04) { 1205 if (temp & 0x04) {
1180 psiconv_progress(lev+3,off+len, "Going to read the default number format"); 1206 psiconv_progress(config,lev+3,off+len, "Going to read the default number format");
1181 psiconv_parse_sheet_numberformat(buf,lev+3,off+len,&leng, 1207 psiconv_parse_sheet_numberformat(config,buf,lev+3,off+len,&leng,
1182 result->numberformat); 1208 result->numberformat);
1183 len += leng; 1209 len += leng;
1184 } 1210 }
1185 1211
1186 if (length) 1212 if (length)
1187 *length = len; 1213 *length = len;
1188 1214
1189 psiconv_progress(lev,off+len-1, 1215 psiconv_progress(config,lev,off+len-1,
1190 "End of sheet cell layout (total length: %08x)", len); 1216 "End of sheet cell layout (total length: %08x)", len);
1191 1217
1192 return 0; 1218 return 0;
1193 1219
1194ERROR1: 1220ERROR1:
1195 psiconv_warn(lev+1,off,"Reading of sheet cell layout failed"); 1221 psiconv_warn(config,lev+1,off,"Reading of sheet cell layout failed");
1196 if (length) 1222 if (length)
1197 *length = 0; 1223 *length = 0;
1198 if (!res) 1224 if (!res)
1199 return -PSICONV_E_NOMEM; 1225 return -PSICONV_E_NOMEM;
1200 else 1226 else
1201 return res; 1227 return res;
1202} 1228}
1203 1229
1204 1230
1205int psiconv_parse_sheet_worksheet(const psiconv_buffer buf, int lev, 1231int psiconv_parse_sheet_worksheet(const psiconv_config config,
1232 const psiconv_buffer buf, int lev,
1206 psiconv_u32 off, int *length, 1233 psiconv_u32 off, int *length,
1207 psiconv_sheet_worksheet *result) 1234 psiconv_sheet_worksheet *result)
1208{ 1235{
1209 int res=0; 1236 int res=0;
1210 psiconv_u32 temp,cells_off,grid_off,rows_off,cols_off; 1237 psiconv_u32 temp,cells_off,grid_off,rows_off,cols_off,unknown_off;
1211 int len=0; 1238 int len=0;
1212 int leng; 1239 int leng;
1213 1240
1214 psiconv_progress(lev+1,off,"Going to read the sheet worksheet section"); 1241 psiconv_progress(config,lev+1,off,"Going to read the sheet worksheet section");
1215 if (!(*result = malloc(sizeof(**result)))) 1242 if (!(*result = malloc(sizeof(**result))))
1216 goto ERROR1; 1243 goto ERROR1;
1217 1244
1218 psiconv_progress(lev+2,off+len, 1245 psiconv_progress(config,lev+2,off+len,
1219 "Going to read the initial bytes (%02x expected)",0x04); 1246 "Going to read the initial bytes (%02x expected)",0x04);
1220 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1247 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1221 if (res) 1248 if (res)
1222 goto ERROR2; 1249 goto ERROR2;
1223 if (temp != 0x04) { 1250 if (temp != 0x04) {
1224 psiconv_warn(lev+2,off+len, 1251 psiconv_warn(config,lev+2,off+len,
1225 "Worksheet section initial byte unknown value (ignored)"); 1252 "Worksheet section initial byte unknown value (ignored)");
1226 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1253 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1227 } 1254 }
1228 len ++; 1255 len ++;
1229 1256
1230 psiconv_progress(lev+2,off+len, "Going to read the flags byte"); 1257 psiconv_progress(config,lev+2,off+len, "Going to read the flags byte");
1231 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1258 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1232 if (res) 1259 if (res)
1233 goto ERROR2; 1260 goto ERROR2;
1234 psiconv_debug(lev+2,off+len,"Flags byte: %02x",temp); 1261 psiconv_debug(config,lev+2,off+len,"Flags byte: %02x",temp);
1235 (*result)->show_zeros = (temp & 0x01)?psiconv_bool_true:psiconv_bool_false; 1262 (*result)->show_zeros = (temp & 0x01)?psiconv_bool_true:psiconv_bool_false;
1236 if (temp & 0xfe) { 1263 if (temp & 0xfe) {
1237 psiconv_warn(lev+2,off+len, 1264 psiconv_warn(config,lev+2,off+len,
1238 "Worksheet section flags byte unknown bits (ignored)"); 1265 "Worksheet section flags byte unknown bits (ignored)");
1239 } 1266 }
1240 len ++; 1267 len ++;
1241 1268
1242 psiconv_progress(lev+2,off+len,"Going to read the default cell layout"); 1269 psiconv_progress(config,lev+2,off+len,"Going to read the default cell layout");
1243 if (!((*result)->default_layout = psiconv_basic_cell_layout())) 1270 if (!((*result)->default_layout = psiconv_basic_cell_layout()))
1244 goto ERROR2; 1271 goto ERROR2;
1245 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,&leng, 1272 if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,&leng,
1246 (*result)->default_layout))) 1273 (*result)->default_layout)))
1247 goto ERROR3; 1274 goto ERROR3;
1248 len += leng; 1275 len += leng;
1249 1276
1250 psiconv_progress(lev+2,off+len, 1277 psiconv_progress(config,lev+2,off+len,
1251 "Going to read the offset of the row defaults Section"); 1278 "Going to read the offset of the row defaults Section");
1252 rows_off = psiconv_read_u32(buf,lev+2,off+len,&res); 1279 rows_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1253 if (res) 1280 if (res)
1254 goto ERROR3; 1281 goto ERROR3;
1255 psiconv_debug(lev+2,off+len,"Offset: %04x",rows_off); 1282 psiconv_debug(config,lev+2,off+len,"Offset: %04x",rows_off);
1256 len += 4; 1283 len += 4;
1257 1284
1258 psiconv_progress(lev+2,off+len, 1285 psiconv_progress(config,lev+2,off+len,
1259 "Going to read the offset of the column defaults Section"); 1286 "Going to read the offset of the column defaults Section");
1260 cols_off = psiconv_read_u32(buf,lev+2,off+len,&res); 1287 cols_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1261 if (res) 1288 if (res)
1262 goto ERROR3; 1289 goto ERROR3;
1263 psiconv_debug(lev+2,off+len,"Offset: %04x",cols_off); 1290 psiconv_debug(config,lev+2,off+len,"Offset: %04x",cols_off);
1264 len += 4; 1291 len += 4;
1265 1292
1266 psiconv_progress(lev+2,off+len, 1293 psiconv_progress(config,lev+2,off+len,
1267 "Going to read the offset of the Cells List"); 1294 "Going to read the offset of the Cells List");
1268 cells_off = psiconv_read_u32(buf,lev+2,off+len,&res); 1295 cells_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1269 if (res) 1296 if (res)
1270 goto ERROR3; 1297 goto ERROR3;
1271 psiconv_debug(lev+2,off+len,"Offset: %04x",cells_off); 1298 psiconv_debug(config,lev+2,off+len,"Offset: %04x",cells_off);
1272 len += 4; 1299 len += 4;
1273 1300
1274 psiconv_progress(lev+2,off+len, 1301 psiconv_progress(config,lev+2,off+len,
1275 "Going to read the offset of the Grid Section"); 1302 "Going to read the offset of the Grid Section");
1276 grid_off = psiconv_read_u32(buf,lev+2,off+len,&res); 1303 grid_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1277 if (res) 1304 if (res)
1278 goto ERROR3; 1305 goto ERROR3;
1279 psiconv_debug(lev+2,off+len,"Offset: %04x",grid_off); 1306 psiconv_debug(config,lev+2,off+len,"Offset: %04x",grid_off);
1280 len += 4; 1307 len += 4;
1281 1308
1282 psiconv_progress(lev+2,off+len, 1309 psiconv_progress(config,lev+2,off+len,
1283 "Going to read the offset of the 3rd ??? Section"); 1310 "Going to read the offset of the 3rd ??? Section");
1284 temp = psiconv_read_u32(buf,lev+2,off+len,&res); 1311 unknown_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1285 if (res) 1312 if (res)
1286 goto ERROR3; 1313 goto ERROR3;
1287 psiconv_debug(lev+2,off+len,"Offset: %04x",temp); 1314 psiconv_debug(config,lev+2,off+len,"Offset: %04x",unknown_off);
1288 len += 4; 1315 len += 4;
1289 1316
1317 psiconv_progress(config,lev+2,off+len,
1318 "Going to read a long of the 3rd ??? Section "
1319 "(%08x expected)",0x00);
1320 temp = psiconv_read_u32(config,buf,lev+2,unknown_off,&res);
1321 if (res)
1322 goto ERROR3;
1323 if (temp != 0x00) {
1324 psiconv_warn(config,lev+2,unknown_off,
1325 "Unknown worksheet subsection has unknown contents (ignored)");
1326 psiconv_debug(config,lev+2,unknown_off,"Offset: %04x",temp);
1327 }
1328 len += 4;
1329
1290 psiconv_progress(lev+2,off+len,"Going to read the row defaults"); 1330 psiconv_progress(config,lev+2,off+len,"Going to read the row defaults");
1291 if ((res = psiconv_parse_sheet_line_list(buf,lev+2,rows_off,NULL, 1331 if ((res = psiconv_parse_sheet_line_list(config,buf,lev+2,rows_off,NULL,
1292 &(*result)->row_default_layouts, 1332 &(*result)->row_default_layouts,
1293 (*result)->default_layout))) 1333 (*result)->default_layout)))
1294 goto ERROR3; 1334 goto ERROR3;
1295 1335
1296 psiconv_progress(lev+2,off+len,"Going to read the column defaults"); 1336 psiconv_progress(config,lev+2,off+len,"Going to read the column defaults");
1297 if ((res = psiconv_parse_sheet_line_list(buf,lev+2,cols_off,NULL, 1337 if ((res = psiconv_parse_sheet_line_list(config,buf,lev+2,cols_off,NULL,
1298 &(*result)->col_default_layouts, 1338 &(*result)->col_default_layouts,
1299 (*result)->default_layout))) 1339 (*result)->default_layout)))
1300 goto ERROR4; 1340 goto ERROR4;
1301 1341
1302 psiconv_progress(lev+2,off+len,"Going to read the cells list"); 1342 psiconv_progress(config,lev+2,off+len,"Going to read the cells list");
1303 if ((res = psiconv_parse_sheet_cell_list(buf,lev+2,cells_off,NULL, 1343 if ((res = psiconv_parse_sheet_cell_list(config,buf,lev+2,cells_off,NULL,
1304 &(*result)->cells, 1344 &(*result)->cells,
1305 (*result)->default_layout, 1345 (*result)->default_layout,
1306 (*result)->row_default_layouts, 1346 (*result)->row_default_layouts,
1307 (*result)->col_default_layouts))) 1347 (*result)->col_default_layouts)))
1308 goto ERROR5; 1348 goto ERROR5;
1309 1349
1310 1350
1311/* TODO: parse grid section */ 1351 psiconv_progress(config,lev+2,off+len,"Going to read the grid section");
1352 if ((res = psiconv_parse_sheet_grid_section(config,buf,lev+2,grid_off,NULL,
1353 &(*result)->grid)))
1354 goto ERROR6;
1355
1356
1312 1357
1313 if (length) 1358 if (length)
1314 *length = len; 1359 *length = len;
1315 1360
1316 psiconv_progress(lev,off+len-1, 1361 psiconv_progress(config,lev,off+len-1,
1317 "End of sheet worksheet section (total length: %08x)", len); 1362 "End of sheet worksheet section (total length: %08x)", len);
1318 return 0; 1363 return 0;
1319 1364
1365ERROR6:
1366 psiconv_free_sheet_cell_list((*result)->cells);
1320ERROR5: 1367ERROR5:
1321 psiconv_free_sheet_line_list((*result)->col_default_layouts); 1368 psiconv_free_sheet_line_list((*result)->col_default_layouts);
1322ERROR4: 1369ERROR4:
1323 psiconv_free_sheet_line_list((*result)->row_default_layouts); 1370 psiconv_free_sheet_line_list((*result)->row_default_layouts);
1324ERROR3: 1371ERROR3:
1325 psiconv_free_sheet_cell_layout((*result)->default_layout); 1372 psiconv_free_sheet_cell_layout((*result)->default_layout);
1326ERROR2: 1373ERROR2:
1327 free (*result); 1374 free (*result);
1328ERROR1: 1375ERROR1:
1329 psiconv_warn(lev+1,off,"Reading of Sheet Worksheet Section failed"); 1376 psiconv_warn(config,lev+1,off,"Reading of Sheet Worksheet Section failed");
1330 if (length) 1377 if (length)
1331 *length = 0; 1378 *length = 0;
1332 if (!res) 1379 if (!res)
1333 return -PSICONV_E_NOMEM; 1380 return -PSICONV_E_NOMEM;
1334 else 1381 else
1335 return res; 1382 return res;
1336} 1383}
1337 1384
1338int psiconv_parse_sheet_line(const psiconv_buffer buf, int lev, 1385int psiconv_parse_sheet_line(const psiconv_config config,
1386 const psiconv_buffer buf, int lev,
1339 psiconv_u32 off, int *length, 1387 psiconv_u32 off, int *length,
1340 psiconv_sheet_line *result, 1388 psiconv_sheet_line *result,
1341 const psiconv_sheet_cell_layout default_layout) 1389 const psiconv_sheet_cell_layout default_layout)
1342{ 1390{
1343 int res=0; 1391 int res=0;
1344 int len=0; 1392 int len=0;
1345 int leng; 1393 int leng;
1346 1394
1347 1395
1348 psiconv_progress(lev+1,off,"Going to read a sheet line"); 1396 psiconv_progress(config,lev+1,off,"Going to read a sheet line");
1349 if (!(*result = malloc(sizeof(**result)))) 1397 if (!(*result = malloc(sizeof(**result))))
1350 goto ERROR1; 1398 goto ERROR1;
1351 1399
1352 psiconv_progress(lev+2,off+len,"Going to read the line number"); 1400 psiconv_progress(config,lev+2,off+len,"Going to read the line number");
1353 (*result)->position = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 1401 (*result)->position = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1354 if (res) 1402 if (res)
1355 goto ERROR2; 1403 goto ERROR2;
1356 psiconv_debug(lev+2,off+len,"Line number: %d\n",(*result)->position); 1404 psiconv_debug(config,lev+2,off+len,"Line number: %d\n",(*result)->position);
1357 len += leng; 1405 len += leng;
1358 1406
1359 if (!((*result)->layout = psiconv_clone_cell_layout(default_layout))) 1407 if (!((*result)->layout = psiconv_clone_cell_layout(default_layout)))
1360 goto ERROR2; 1408 goto ERROR2;
1361 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len, 1409 if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,
1362 &leng,(*result)->layout))) 1410 &leng,(*result)->layout)))
1363 goto ERROR3; 1411 goto ERROR3;
1364 len += leng; 1412 len += leng;
1365 1413
1366 if (length) 1414 if (length)
1367 *length = len; 1415 *length = len;
1368 1416
1369 psiconv_progress(lev,off+len-1, 1417 psiconv_progress(config,lev,off+len-1,
1370 "End of the sheet line (total length: %08x)", len); 1418 "End of the sheet line (total length: %08x)", len);
1371 return 0; 1419 return 0;
1372 1420
1373ERROR3: 1421ERROR3:
1374 psiconv_free_sheet_cell_layout((*result)->layout); 1422 psiconv_free_sheet_cell_layout((*result)->layout);
1375ERROR2: 1423ERROR2:
1376 free (*result); 1424 free (*result);
1377ERROR1: 1425ERROR1:
1378 psiconv_warn(lev+1,off,"Reading of the sheet line failed"); 1426 psiconv_warn(config,lev+1,off,"Reading of the sheet line failed");
1379 if (length) 1427 if (length)
1380 *length = 0; 1428 *length = 0;
1381 if (!res) 1429 if (!res)
1382 return -PSICONV_E_NOMEM; 1430 return -PSICONV_E_NOMEM;
1383 else 1431 else
1384 return res; 1432 return res;
1385} 1433}
1386 1434
1387 1435
1388int psiconv_parse_sheet_line_list(const psiconv_buffer buf, int lev, 1436int psiconv_parse_sheet_line_list(const psiconv_config config,
1437 const psiconv_buffer buf, int lev,
1389 psiconv_u32 off, int *length, 1438 psiconv_u32 off, int *length,
1390 psiconv_sheet_line_list *result, 1439 psiconv_sheet_line_list *result,
1391 const psiconv_sheet_cell_layout default_layout) 1440 const psiconv_sheet_cell_layout default_layout)
1392{ 1441{
1393 int res=0; 1442 int res=0;
… …
1395 psiconv_u32 temp; 1444 psiconv_u32 temp;
1396 psiconv_sheet_line line; 1445 psiconv_sheet_line line;
1397 psiconv_u32 listlen,i; 1446 psiconv_u32 listlen,i;
1398 int leng; 1447 int leng;
1399 1448
1400 psiconv_progress(lev+1,off,"Going to read the sheet line list"); 1449 psiconv_progress(config,lev+1,off,"Going to read the sheet line list");
1401 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_line_s)))) 1450 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_line_s))))
1402 goto ERROR1; 1451 goto ERROR1;
1403 1452
1404 psiconv_progress(lev+2,off+len, 1453 psiconv_progress(config,lev+2,off+len,
1405 "Going to read the initial byte (%02x expected)",0x02); 1454 "Going to read the initial byte (%02x expected)",0x02);
1406 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1455 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1407 if (res) 1456 if (res)
1408 goto ERROR2; 1457 goto ERROR2;
1409 if (temp != 0x02) { 1458 if (temp != 0x02) {
1410 psiconv_warn(lev+2,off+len, 1459 psiconv_warn(config,lev+2,off+len,
1411 "Sheet line list initial byte unknown value (ignored)"); 1460 "Sheet line list initial byte unknown value (ignored)");
1412 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1461 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1413 } 1462 }
1414 len ++; 1463 len ++;
1415 1464
1416 psiconv_progress(lev+2,off+len, 1465 psiconv_progress(config,lev+2,off+len,
1417 "Going to read the number of defined lines"); 1466 "Going to read the number of defined lines");
1418 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 1467 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1419 if (res) 1468 if (res)
1420 goto ERROR2; 1469 goto ERROR2;
1421 psiconv_debug(lev+2,off+len,"Number of defined lines: %d",listlen); 1470 psiconv_debug(config,lev+2,off+len,"Number of defined lines: %d",listlen);
1422 len += leng; 1471 len += leng;
1423 1472
1424 psiconv_progress(lev+2,off+len,"Going to read all lines"); 1473 psiconv_progress(config,lev+2,off+len,"Going to read all lines");
1425 for (i = 0; i < listlen; i++) { 1474 for (i = 0; i < listlen; i++) {
1426 psiconv_progress(lev+3,off+len,"Going to read line %d",i); 1475 psiconv_progress(config,lev+3,off+len,"Going to read line %d",i);
1427 if ((res = psiconv_parse_sheet_line(buf,lev+3,off+len,&leng,&line, 1476 if ((res = psiconv_parse_sheet_line(config,buf,lev+3,off+len,&leng,&line,
1428 default_layout))) 1477 default_layout)))
1429 goto ERROR2; 1478 goto ERROR2;
1430 if ((res = psiconv_list_add(*result,line))) 1479 if ((res = psiconv_list_add(*result,line)))
1431 goto ERROR3; 1480 goto ERROR3;
1432 free(line); 1481 free(line);
… …
1434 } 1483 }
1435 1484
1436 if (length) 1485 if (length)
1437 *length = len; 1486 *length = len;
1438 1487
1439 psiconv_progress(lev,off+len-1, 1488 psiconv_progress(config,lev,off+len-1,
1440 "End of sheet line list (total length: %08x)", len); 1489 "End of sheet line list (total length: %08x)", len);
1441 return 0; 1490 return 0;
1442 1491
1443ERROR3: 1492ERROR3:
1444 psiconv_free_sheet_line(line); 1493 psiconv_free_sheet_line(line);
1445ERROR2: 1494ERROR2:
1446 psiconv_free_sheet_line_list(*result); 1495 psiconv_free_sheet_line_list(*result);
1447ERROR1: 1496ERROR1:
1448 psiconv_warn(lev+1,off,"Reading of Sheet Line List failed"); 1497 psiconv_warn(config,lev+1,off,"Reading of Sheet Line List failed");
1449 if (length) 1498 if (length)
1450 *length = 0; 1499 *length = 0;
1451 if (!res) 1500 if (!res)
1452 return -PSICONV_E_NOMEM; 1501 return -PSICONV_E_NOMEM;
1453 else 1502 else
1454 return res; 1503 return res;
1455} 1504}
1456 1505
1457int psiconv_parse_sheet_variable(const psiconv_buffer buf, int lev, 1506int psiconv_parse_sheet_variable(const psiconv_config config,
1507 const psiconv_buffer buf, int lev,
1458 psiconv_u32 off, int *length, 1508 psiconv_u32 off, int *length,
1459 psiconv_sheet_variable *result) 1509 psiconv_sheet_variable *result)
1460{ 1510{
1461 int res=0; 1511 int res=0;
1462 int len=0; 1512 int len=0;
1463 psiconv_u32 marker; 1513 psiconv_u32 marker;
1464 int leng; 1514 int leng;
1465 1515
1466 psiconv_progress(lev+1,off,"Going to read a sheet variable"); 1516 psiconv_progress(config,lev+1,off,"Going to read a sheet variable");
1467 if (!(*result = malloc(sizeof(**result)))) 1517 if (!(*result = malloc(sizeof(**result))))
1468 goto ERROR1; 1518 goto ERROR1;
1469 1519
1470 psiconv_progress(lev+2,off+len, "Going to read the variable name"); 1520 psiconv_progress(config,lev+2,off+len, "Going to read the variable name");
1471 (*result)->name = psiconv_read_string(buf,lev+2,off+len,&leng,&res); 1521 (*result)->name = psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
1472 if (res) 1522 if (res)
1473 goto ERROR2; 1523 goto ERROR2;
1474 len += leng; 1524 len += leng;
1475 1525
1476 psiconv_progress(lev+2,off+len,"Going to read the type marker"); 1526 psiconv_progress(config,lev+2,off+len,"Going to read the type marker");
1477 marker = psiconv_read_u8(buf,lev+2,off+len,&res); 1527 marker = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1478 if (res) 1528 if (res)
1479 goto ERROR3; 1529 goto ERROR3;
1480 psiconv_debug(lev+2,off+len,"Marker: %02x",marker); 1530 psiconv_debug(config,lev+2,off+len,"Marker: %02x",marker);
1481 len ++; 1531 len ++;
1482 1532
1483 if (marker == 0x00) { 1533 if (marker == 0x00) {
1484 (*result)->type = psiconv_var_int; 1534 (*result)->type = psiconv_var_int;
1485 psiconv_progress(lev+2,off+len,"Going to read a signed integer"); 1535 psiconv_progress(config,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); 1536 (*result)->data.dat_int = psiconv_read_sint(config,buf,lev+2,off+len,&leng,&res);
1487 if (res) 1537 if (res)
1488 goto ERROR3; 1538 goto ERROR3;
1489 psiconv_debug(lev+2,off+len,"Value: %d",(*result)->data.dat_int); 1539 psiconv_debug(config,lev+2,off+len,"Value: %d",(*result)->data.dat_int);
1490 len += leng; 1540 len += leng;
1491 } else if (marker == 0x01) { 1541 } else if (marker == 0x01) {
1492 (*result)->type = psiconv_var_float; 1542 (*result)->type = psiconv_var_float;
1493 psiconv_progress(lev+2,off+len,"Going to read a floating point number"); 1543 psiconv_progress(config,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, 1544 (*result)->data.dat_float = psiconv_read_float(config,buf,lev+2,off+len,&leng,
1495 &res); 1545 &res);
1496 if (res) 1546 if (res)
1497 goto ERROR3; 1547 goto ERROR3;
1498 psiconv_debug(lev+2,off+len,"Value: %f",(*result)->data.dat_float); 1548 psiconv_debug(config,lev+2,off+len,"Value: %f",(*result)->data.dat_float);
1499 len += leng; 1549 len += leng;
1500 } else if (marker == 0x02) { 1550 } else if (marker == 0x02) {
1501 (*result)->type = psiconv_var_string; 1551 (*result)->type = psiconv_var_string;
1502 psiconv_progress(lev+2,off+len,"Going to read a string"); 1552 psiconv_progress(config,lev+2,off+len,"Going to read a string");
1503 (*result)->data.dat_string = psiconv_read_string(buf,lev+2,off+len,&leng, 1553 (*result)->data.dat_string = psiconv_read_string(config,buf,lev+2,off+len,
1504 &res); 1554 &leng, &res);
1505 if (res) 1555 if (res)
1506 goto ERROR3; 1556 goto ERROR3;
1507 len += leng; 1557 len += leng;
1508 } else if (marker == 0x03) { 1558 } else if (marker == 0x03) {
1509 (*result)->type = psiconv_var_cellref; 1559 (*result)->type = psiconv_var_cellref;
1510 psiconv_progress(lev+2,off+len,"Going to read a cell reference"); 1560 psiconv_progress(config,lev+2,off+len,"Going to read a cell reference");
1511 (*result)->data.dat_cellref = psiconv_read_var_cellref(buf,lev+2,off+len, 1561 (*result)->data.dat_cellref = psiconv_read_var_cellref(config,buf,lev+2,off+len,
1512 &leng, &res); 1562 &leng, &res);
1513 if (res) 1563 if (res)
1514 goto ERROR3; 1564 goto ERROR3;
1515 len += leng; 1565 len += leng;
1516 } else if (marker == 0x04) { 1566 } else if (marker == 0x04) {
1517 (*result)->type = psiconv_var_cellblock; 1567 (*result)->type = psiconv_var_cellblock;
1518 psiconv_progress(lev+2,off+len,"Going to read a cell block reference"); 1568 psiconv_progress(config,lev+2,off+len,"Going to read a cell block reference");
1519 (*result)->data.dat_cellblock = psiconv_read_var_cellblock(buf,lev+2, 1569 (*result)->data.dat_cellblock = psiconv_read_var_cellblock(config,buf,lev+2,
1520 off+len, 1570 off+len,
1521 &leng, &res); 1571 &leng, &res);
1522 if (res) 1572 if (res)
1523 goto ERROR3; 1573 goto ERROR3;
1524 len += leng; 1574 len += leng;
1525 } else { 1575 } else {
1526 psiconv_warn(lev+2,off+len,"Sheet variable unknown type marker"); 1576 psiconv_warn(config,lev+2,off+len,"Sheet variable unknown type marker");
1527 res = -PSICONV_E_PARSE; 1577 res = -PSICONV_E_PARSE;
1528 goto ERROR3; 1578 goto ERROR3;
1529 } 1579 }
1530 1580
1531 psiconv_progress(lev+2,off+len,"Going to read the variable number"); 1581 psiconv_progress(config,lev+2,off+len,"Going to read the variable number");
1532 (*result)->number = psiconv_read_u32(buf,lev+2,off+len,&res); 1582 (*result)->number = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1533 if (res) 1583 if (res)
1534 goto ERROR4; 1584 goto ERROR4;
1535 psiconv_debug(lev+2,off+len,"Number: %08x",(*result)->number); 1585 psiconv_debug(config,lev+2,off+len,"Number: %08x",(*result)->number);
1536 len += 4; 1586 len += 4;
1537 1587
1538 if (length) 1588 if (length)
1539 *length = len; 1589 *length = len;
1540 1590
1541 psiconv_progress(lev,off+len-1, 1591 psiconv_progress(config,lev,off+len-1,
1542 "End of sheet variable (total length: %08x)", len); 1592 "End of sheet variable (total length: %08x)", len);
1543 return 0; 1593 return 0;
1544 1594
1545ERROR4: 1595ERROR4:
1546 if ((*result)->type == psiconv_var_string) 1596 if ((*result)->type == psiconv_var_string)
… …
1548ERROR3: 1598ERROR3:
1549 free((*result)->name); 1599 free((*result)->name);
1550ERROR2: 1600ERROR2:
1551 free (*result); 1601 free (*result);
1552ERROR1: 1602ERROR1:
1553 psiconv_warn(lev+1,off,"Reading of Sheet Variable failed"); 1603 psiconv_warn(config,lev+1,off,"Reading of Sheet Variable failed");
1554 if (length) 1604 if (length)
1555 *length = 0; 1605 *length = 0;
1556 if (!res) 1606 if (!res)
1557 return -PSICONV_E_NOMEM; 1607 return -PSICONV_E_NOMEM;
1558 else 1608 else
1559 return res; 1609 return res;
1560} 1610}
1561 1611
1562 1612
1563int psiconv_parse_sheet_variable_list(const psiconv_buffer buf, int lev, 1613int psiconv_parse_sheet_variable_list(const psiconv_config config,
1614 const psiconv_buffer buf, int lev,
1564 psiconv_u32 off, int *length, 1615 psiconv_u32 off, int *length,
1565 psiconv_sheet_variable_list *result) 1616 psiconv_sheet_variable_list *result)
1566{ 1617{
1567 int res=0; 1618 int res=0;
1568 int len=0; 1619 int len=0;
1569 psiconv_u32 temp; 1620 psiconv_u32 temp;
1570 psiconv_sheet_variable variable; 1621 psiconv_sheet_variable variable;
1571 psiconv_u32 listlen,i; 1622 psiconv_u32 listlen,i;
1572 int leng; 1623 int leng;
1573 1624
1574 psiconv_progress(lev+1,off,"Going to read the sheet variable list"); 1625 psiconv_progress(config,lev+1,off,"Going to read the sheet variable list");
1575 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_variable_s)))) 1626 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_variable_s))))
1576 goto ERROR1; 1627 goto ERROR1;
1577 1628
1578 psiconv_progress(lev+2,off+len, 1629 psiconv_progress(config,lev+2,off+len,
1579 "Going to read the initial byte (%02x expected)",0x02); 1630 "Going to read the initial byte (%02x expected)",0x02);
1580 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1631 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1581 if (res) 1632 if (res)
1582 goto ERROR2; 1633 goto ERROR2;
1583 if (temp != 0x02) { 1634 if (temp != 0x02) {
1584 psiconv_warn(lev+2,off+len, 1635 psiconv_warn(config,lev+2,off+len,
1585 "Sheet variable list initial byte unknown value (ignored)"); 1636 "Sheet variable list initial byte unknown value (ignored)");
1586 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1637 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1587 } 1638 }
1588 len ++; 1639 len ++;
1589 1640
1590 psiconv_progress(lev+2,off+len, 1641 psiconv_progress(config,lev+2,off+len,
1591 "Going to read the number of variables"); 1642 "Going to read the number of variables");
1592 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 1643 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1593 if (res) 1644 if (res)
1594 goto ERROR2; 1645 goto ERROR2;
1595 psiconv_debug(lev+2,off+len,"Number of variables: %d",listlen); 1646 psiconv_debug(config,lev+2,off+len,"Number of variables: %d",listlen);
1596 len += leng; 1647 len += leng;
1597 1648
1598 psiconv_progress(lev+2,off+len,"Going to read all variables"); 1649 psiconv_progress(config,lev+2,off+len,"Going to read all variables");
1599 for (i = 0; i < listlen; i++) { 1650 for (i = 0; i < listlen; i++) {
1600 psiconv_progress(lev+3,off+len,"Going to read variable %d",i); 1651 psiconv_progress(config,lev+3,off+len,"Going to read variable %d",i);
1601 if ((res = psiconv_parse_sheet_variable(buf,lev+3,off+len,&leng,&variable))) 1652 if ((res = psiconv_parse_sheet_variable(config,buf,lev+3,off+len,&leng,&variable)))
1602 goto ERROR2; 1653 goto ERROR2;
1603 if ((res = psiconv_list_add(*result,variable))) 1654 if ((res = psiconv_list_add(*result,variable)))
1604 goto ERROR3; 1655 goto ERROR3;
1605 len += leng; 1656 len += leng;
1606 } 1657 }
1607 1658
1608 if (length) 1659 if (length)
1609 *length = len; 1660 *length = len;
1610 1661
1611 psiconv_progress(lev,off+len-1, 1662 psiconv_progress(config,lev,off+len-1,
1612 "End of sheet variabels list (total length: %08x)", len); 1663 "End of sheet variabels list (total length: %08x)", len);
1613 return 0; 1664 return 0;
1614 1665
1615ERROR3: 1666ERROR3:
1616 psiconv_free_sheet_variable(variable); 1667 psiconv_free_sheet_variable(variable);
1617ERROR2: 1668ERROR2:
1618 psiconv_list_free(*result); 1669 psiconv_list_free(*result);
1619ERROR1: 1670ERROR1:
1620 psiconv_warn(lev+1,off,"Reading of Sheet Variable list failed"); 1671 psiconv_warn(config,lev+1,off,"Reading of Sheet Variable list failed");
1621 if (length) 1672 if (length)
1622 *length = 0; 1673 *length = 0;
1623 if (!res) 1674 if (!res)
1624 return -PSICONV_E_NOMEM; 1675 return -PSICONV_E_NOMEM;
1625 else 1676 else
1626 return res; 1677 return res;
1627} 1678}
1679
1680int psiconv_parse_sheet_grid_section(const psiconv_config config,
1681 const psiconv_buffer buf, int lev,
1682 psiconv_u32 off, int *length,
1683 psiconv_sheet_grid_section *result)
1684{
1685 int res=0,i;
1686 int len=0,leng;
1687 psiconv_u32 temp;
1688
1689 psiconv_progress(config,lev+1,off,"Going to read the sheet grid section");
1690 if (!(*result = malloc(sizeof(**result))))
1691 goto ERROR1;
1692
1693 psiconv_progress(config,lev+2,off+len, "Going to read the first flags byte");
1694 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1695 if (res)
1696 goto ERROR2;
1697 (*result)->show_column_titles = temp&0x01?psiconv_bool_true:
1698 psiconv_bool_false;
1699 psiconv_debug(config,lev+2,off+len,
1700 "Show column titles: %s",
1701 (*result)->show_column_titles?"true":"false");
1702 (*result)->show_row_titles = temp&0x02?psiconv_bool_true:psiconv_bool_false;
1703 psiconv_debug(config,lev+2,off+len,
1704 "Show row titles: %s",
1705 (*result)->show_row_titles?"true":"false");
1706 (*result)->show_vertical_grid = temp&0x04?psiconv_bool_true:
1707 psiconv_bool_false;
1708 psiconv_debug(config,lev+2,off+len,
1709 "Show vertical grid: %s",
1710 (*result)->show_vertical_grid?"true":"false");
1711 (*result)->show_horizontal_grid = temp&0x07?psiconv_bool_true:
1712 psiconv_bool_false;
1713 psiconv_debug(config,lev+2,off+len,
1714 "Show horizontal grid: %s",
1715 (*result)->show_horizontal_grid?"true":"false");
1716 (*result)->freeze_rows = temp&0x80?psiconv_bool_true:psiconv_bool_false;
1717 psiconv_debug(config,lev+2,off+len,
1718 "Freeze rows: %s",
1719 (*result)->freeze_rows?"true":"false");
1720 if ((temp & 0x70) != 0x30) {
1721 psiconv_warn(config,lev+2,off+len,
1722 "Grid section first flag byte has unknown bits (ignored)");
1723 psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0x70,0x30);
1724 }
1725 len ++;
1726
1727 psiconv_progress(config,lev+2,off+len, "Going to read the second flags byte");
1728 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1729 if (res)
1730 goto ERROR2;
1731 (*result)->freeze_columns = temp&0x01?psiconv_bool_true:psiconv_bool_false;
1732 psiconv_debug(config,lev+2,off+len,
1733 "Freeze columns: %s", (*result)->freeze_columns?"true":"false");
1734 if ((temp & 0xfe) != 0x80) {
1735 psiconv_warn(config,lev+2,off+len,
1736 "Grid section second flag byte has unknown bits (ignored)");
1737 psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0xfe,0x80);
1738 }
1739 len ++;
1740
1741 psiconv_progress(config,lev+2,off+len,
1742 "Going to an unknown byte (%02x expected)",0x90);
1743 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1744 if (res)
1745 goto ERROR2;
1746 if (temp != 0x90) {
1747 psiconv_warn(config,lev+2,off+len,
1748 "Grid section third byte unknown value (ignored)");
1749 psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
1750 }
1751 len ++;
1752
1753 psiconv_progress(config,lev+2,off+len, "Going to read the fourth flags byte");
1754 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1755 if (res)
1756 goto ERROR2;
1757 (*result)->show_page_breaks = temp&0x04?psiconv_bool_true:psiconv_bool_false;
1758 psiconv_debug(config,lev+2,off+len,
1759 "Show page breaks: %s",
1760 (*result)->show_page_breaks?"true":"false");
1761 if ((temp & 0xfc) != 0x00) {
1762 psiconv_warn(config,lev+2,off+len,
1763 "Grid section fourth flag byte has unknown bits (ignored)");
1764 psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0xfc,0x00);
1765 }
1766 len ++;
1767
1768 psiconv_progress(config,lev+2,off+len,"Going to read the first visible row");
1769 (*result)->first_row = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1770 if (res)
1771 goto ERROR2;
1772 psiconv_debug(config,lev+2,off+len,"First row: %d",(*result)->first_row);
1773 len += 4;
1774
1775 psiconv_progress(config,lev+2,off+len,"Going to read the first visible column");
1776 (*result)->first_column = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1777 if (res)
1778 goto ERROR2;
1779 psiconv_debug(config,lev+2,off+len,"First column: %d",(*result)->first_column);
1780 len += 4;
1781
1782 psiconv_progress(config,lev+2,off+len,"Going to read the last visible row");
1783 (*result)->last_row = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1784 if (res)
1785 goto ERROR2;
1786 psiconv_debug(config,lev+2,off+len,"Last row: %d",(*result)->last_row);
1787 len += 4;
1788
1789 psiconv_progress(config,lev+2,off+len,"Going to read the last visible column");
1790 (*result)->last_column = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1791 if (res)
1792 goto ERROR2;
1793 psiconv_debug(config,lev+2,off+len,"Last column: %d",(*result)->last_column);
1794 len += 4;
1795
1796 psiconv_progress(config,lev+2,off+len,"Going to read the default row height");
1797 (*result)->default_row_height = psiconv_read_length(config,buf,lev+2,off+len,
1798 &leng,&res);
1799 if (res)
1800 goto ERROR2;
1801 psiconv_debug(config,lev+2,off+len,"Default row height: %f",
1802 (*result)->default_row_height);
1803 len += leng;
1804
1805 psiconv_progress(config,lev+2,off+len,"Going to read the row heights list");
1806 if ((res = psiconv_parse_sheet_grid_size_list(config,buf,lev+2,off+len,&leng,
1807 &(*result)->row_heights)))
1808 goto ERROR2;
1809 len += leng;
1810
1811 psiconv_progress(config,lev+2,off+len,"Going to read the default column height");
1812 (*result)->default_column_width = psiconv_read_length(config,buf,lev+2,off+len,
1813 &leng,&res);
1814 if (res)
1815 goto ERROR3;
1816 psiconv_debug(config,lev+2,off+len,"Default column width: %f",
1817 (*result)->default_column_width);
1818 len += leng;
1819
1820 psiconv_progress(config,lev+2,off+len,"Going to read the column heights list");
1821 if ((res = psiconv_parse_sheet_grid_size_list(config,buf,lev+2,off+len,&leng,
1822 &(*result)->column_heights)))
1823 goto ERROR3;
1824 len += leng;
1825
1826 psiconv_progress(config,lev+2,off+len,
1827 "Going to read an unknown word (%04x expected)",0x00);
1828 temp = psiconv_read_u16(config,buf,lev+2,off+len,&res);
1829 if (res)
1830 goto ERROR4;
1831 if (temp != 0x00) {
1832 psiconv_warn(config,lev+2,off+len,
1833 "Grid section unknown word has unknown value (ignored)");
1834 psiconv_debug(config,lev+2,off+len,"Value: %04x",temp);
1835 }
1836 len += 2;
1837
1838 psiconv_progress(config,lev+2,off+len,"Going to read the row breaks list");
1839 if ((res = psiconv_parse_sheet_grid_break_list(config,buf,lev+2,off+len,&leng,
1840 &(*result)->row_page_breaks)))
1841 goto ERROR4;
1842 len += leng;
1843
1844 psiconv_progress(config,lev+2,off+len,"Going to read the column breaks list");
1845 if ((res = psiconv_parse_sheet_grid_break_list(config,buf,lev+2,off+len,&leng,
1846 &(*result)->column_page_breaks)))
1847 goto ERROR5;
1848 len += leng;
1849
1850
1851 psiconv_progress(config,lev+2,off+len,
1852 "Going to read 22 unknown bytes (%02x expected)",0x00);
1853 for (i = 0; i < 22 ; i++) {
1854 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1855 if (res)
1856 goto ERROR6;
1857 if (temp != 0x00) {
1858 psiconv_warn(config,lev+2,off+len,
1859 "Grid section unknown byte %d has unknown value (ignored)",
1860 i);
1861 psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
1862 }
1863 len += 1;
1864 }
1865
1866 if ((*result)->freeze_rows || (*result)->freeze_columns) {
1867
1868 psiconv_progress(config,lev+2,off+len,"Going to read number of frozen rows");
1869 (*result)->frozen_rows = psiconv_read_u32(config,buf,lev+2,off+len, &res);
1870 if (res)
1871 goto ERROR6;
1872 psiconv_debug(config,lev+2,off+len,"Number of frozen rows: %d",
1873 (*result)->frozen_rows);
1874 len += leng;
1875
1876 psiconv_progress(config,lev+2,off+len,"Going to read number of frozen columns");
1877 (*result)->frozen_columns = psiconv_read_u32(config,buf,lev+2,off+len, &res);
1878 if (res)
1879 goto ERROR6;
1880 psiconv_debug(config,lev+2,off+len,"Number of frozen columns: %d",
1881 (*result)->frozen_columns);
1882 len += leng;
1883
1884 psiconv_progress(config,lev+2,off+len,"Going to read first unfrozen row");
1885 (*result)->first_unfrozen_row_displayed = psiconv_read_u32(config,buf,lev+2,
1886 off+len, &res);
1887 if (res)
1888 goto ERROR6;
1889 psiconv_debug(config,lev+2,off+len,"First row: %d",
1890 (*result)->first_unfrozen_row_displayed);
1891 len += leng;
1892
1893 psiconv_progress(config,lev+2,off+len,"Going to read first unfrozen column");
1894 (*result)->first_unfrozen_column_displayed = psiconv_read_u32(config,buf,lev+2,
1895 off+len,&res);
1896 if (res)
1897 goto ERROR6;
1898 psiconv_debug(config,lev+2,off+len,"First column: %d",
1899 (*result)->first_unfrozen_column_displayed);
1900 len += leng;
1901 } else
1902 (*result)->frozen_rows = (*result)->frozen_columns =
1903 (*result)->first_unfrozen_row_displayed =
1904 (*result)->first_unfrozen_column_displayed = 0;
1905
1906 psiconv_progress(config,lev+2,off+len,
1907 "Going to read 3 unknown bytes (%02x expected)",0xff);
1908 for (i = 0; i < 3 ; i++) {
1909 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1910 if (res)
1911 goto ERROR6;
1912 if (temp != 0xff) {
1913 psiconv_warn(config,lev+2,off+len,
1914 "Grid section unknown byte %d has unknown value (ignored)",
1915 i);
1916 psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
1917 }
1918 len ++;
1919 }
1920
1921 if (length)
1922 *length = len;
1923
1924 psiconv_progress(config,lev,off+len-1,
1925 "End of sheet grid section (total length: %08x)", len);
1926 return 0;
1927
1928ERROR6:
1929 psiconv_free_sheet_grid_break_list((*result)->column_page_breaks);
1930ERROR5:
1931 psiconv_free_sheet_grid_break_list((*result)->row_page_breaks);
1932ERROR4:
1933 psiconv_free_sheet_grid_size_list((*result)->column_heights);
1934ERROR3:
1935 psiconv_free_sheet_grid_size_list((*result)->row_heights);
1936ERROR2:
1937 free(*result);
1938ERROR1:
1939 psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Section failed");
1940 if (length)
1941 *length = 0;
1942 if (!res)
1943 return -PSICONV_E_NOMEM;
1944 else
1945 return res;
1946}
1947
1948
1949int psiconv_parse_sheet_grid_size_list(const psiconv_config config,
1950 const psiconv_buffer buf, int lev,
1951 psiconv_u32 off, int *length,
1952 psiconv_sheet_grid_size_list *result)
1953{
1954 int res=0;
1955 int len=0,i;
1956 int leng,listlen;
1957 psiconv_sheet_grid_size size;
1958
1959 psiconv_progress(config,lev+1,off,"Going to read a sheet grid size list");
1960 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_grid_size_s))))
1961 goto ERROR1;
1962
1963 psiconv_progress(config,lev+2,off+len,
1964 "Going to read the number of elements");
1965 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1966 if (res)
1967 goto ERROR2;
1968 psiconv_debug(config,lev+2,off+len,"Number of elements: %d",listlen);
1969 len += leng;
1970
1971 psiconv_progress(config,lev+2,off+len,"Going to read all elements");
1972 for (i = 0; i < listlen; i++) {
1973 psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
1974 if ((res = psiconv_parse_sheet_grid_size(config,buf,lev+3,off+len,&leng,&size)))
1975 goto ERROR2;
1976 if ((res = psiconv_list_add(*result,size)))
1977 goto ERROR3;
1978 free(size);
1979 len += leng;
1980 }
1981
1982 if (length)
1983 *length = len;
1984
1985 psiconv_progress(config,lev,off+len-1,
1986 "End of sheet grid size list (total length: %08x)", len);
1987 return 0;
1988
1989ERROR3:
1990 psiconv_free_sheet_grid_size(size);
1991ERROR2:
1992 psiconv_list_free(*result);
1993ERROR1:
1994 psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Size List failed");
1995 if (length)
1996 *length = 0;
1997 if (!res)
1998 return -PSICONV_E_NOMEM;
1999 else
2000 return res;
2001}
2002
2003int psiconv_parse_sheet_grid_size(const psiconv_config config,
2004 const psiconv_buffer buf, int lev,
2005 psiconv_u32 off, int *length,
2006 psiconv_sheet_grid_size *result)
2007{
2008 int res=0;
2009 int len=0;
2010 int leng;
2011
2012 psiconv_progress(config,lev+1,off,"Going to read a sheet grid size");
2013
2014 if (!(*result = malloc(sizeof(**result))))
2015 goto ERROR1;
2016
2017 psiconv_progress(config,lev+2,off+len, "Going to read the row or column number");
2018 (*result)->line_number = psiconv_read_u32(config,buf,lev+2,off+len,&res);
2019 if (res)
2020 goto ERROR2;
2021 psiconv_debug(config,lev+2,off+len,"Line number: %d\n",(*result)->line_number);
2022 len += 4;
2023
2024 psiconv_progress(config,lev+2,off+len, "Going to read the row or column height");
2025 (*result)->size = psiconv_read_length(config,buf,lev+2,off+len,&leng,&res);
2026 if (res)
2027 goto ERROR2;
2028 psiconv_debug(config,lev+2,off+len,"Size: %f\n",(*result)->size);
2029 len += leng;
2030
2031 if (length)
2032 *length = len;
2033
2034 psiconv_progress(config,lev,off+len-1,
2035 "End of sheet grid size(total length: %08x)", len);
2036 return 0;
2037
2038ERROR2:
2039 free (*result);
2040ERROR1:
2041 psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Size failed");
2042 if (length)
2043 *length = 0;
2044 if (!res)
2045 return -PSICONV_E_NOMEM;
2046 else
2047 return res;
2048}
2049
2050
2051int psiconv_parse_sheet_grid_break_list(const psiconv_config config,
2052 const psiconv_buffer buf, int lev,
2053 psiconv_u32 off, int *length,
2054 psiconv_sheet_grid_break_list *result)
2055{
2056 int res=0;
2057 int len=0,i;
2058 int leng,listlen;
2059 psiconv_u32 nr;
2060
2061 psiconv_progress(config,lev+1,off,"Going to read a sheet grid break list");
2062 if (!(*result = psiconv_list_new(sizeof(psiconv_u32))))
2063 goto ERROR1;
2064
2065 psiconv_progress(config,lev+2,off+len,
2066 "Going to read the number of elements");
2067 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
2068 if (res)
2069 goto ERROR2;
2070 psiconv_debug(config,lev+2,off+len,"Number of elements: %d",listlen);
2071 len += leng;
2072
2073 psiconv_progress(config,lev+2,off+len,"Going to read all elements");
2074 for (i = 0; i < listlen; i++) {
2075 psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
2076 nr = psiconv_read_u32(config,buf,lev+3,off+len,&res);
2077 if (res)
2078 goto ERROR2;
2079 if ((res = psiconv_list_add(*result,&nr)))
2080 goto ERROR2;
2081 len += leng;
2082 }
2083
2084 if (length)
2085 *length = len;
2086
2087 psiconv_progress(config,lev,off+len-1,
2088 "End of sheet grid break list (total length: %08x)", len);
2089 return 0;
2090
2091ERROR2:
2092 psiconv_list_free(*result);
2093ERROR1:
2094 psiconv_warn(config,lev+1,off,"Reading of Sheet Grid break List failed");
2095 if (length)
2096 *length = 0;
2097 if (!res)
2098 return -PSICONV_E_NOMEM;
2099 else
2100 return res;
2101}
2102
Legend:
Removed from v.129  
changed lines
  Added in v.183
frodo@frodo.looijaard.name
 ViewVC Help
Powered by ViewVC 1.1.26