/[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 133 Revision 168
… …
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 %02x expected)", 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 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,
590 &(*result)->name))) 599 &(*result)->name)))
591 goto ERROR6; 600 goto ERROR6;
592 } else 601 } else
593 (*result)->name = NULL; 602 (*result)->name = NULL;
594 603
595 if (length) 604 if (length)
596 *length = len; 605 *length = len;
597 606
598 psiconv_progress(lev,off+len-1, 607 psiconv_progress(config,lev,off+len-1,
599 "End of sheet workbook section (total length: %08x)", len); 608 "End of sheet workbook section (total length: %08x)", len);
600 return 0; 609 return 0;
601 610
602ERROR6: 611ERROR6:
603 psiconv_free_sheet_worksheet_list((*result)->worksheets); 612 psiconv_free_sheet_worksheet_list((*result)->worksheets);
… …
608ERROR3: 617ERROR3:
609 psiconv_free_sheet_info_section((*result)->info); 618 psiconv_free_sheet_info_section((*result)->info);
610ERROR2: 619ERROR2:
611 free (*result); 620 free (*result);
612ERROR1: 621ERROR1:
613 psiconv_warn(lev+1,off,"Reading of Sheet Workbook Section failed"); 622 psiconv_warn(config,lev+1,off,"Reading of Sheet Workbook Section failed");
614 if (length) 623 if (length)
615 *length = 0; 624 *length = 0;
616 if (!res) 625 if (!res)
617 return -PSICONV_E_NOMEM; 626 return -PSICONV_E_NOMEM;
618 else 627 else
619 return res; 628 return res;
620} 629}
621 630
622int 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,
623 psiconv_u32 off, int *length, 633 psiconv_u32 off, int *length,
624 psiconv_sheet_name_section *result) 634 psiconv_sheet_name_section *result)
625{ 635{
626 int res=0; 636 int res=0;
627 psiconv_u32 temp; 637 psiconv_u32 temp;
628 int len=0,leng; 638 int len=0,leng;
629 639
630 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");
631 if (!(*result = malloc(sizeof(**result)))) 641 if (!(*result = malloc(sizeof(**result))))
632 goto ERROR1; 642 goto ERROR1;
633 643
634 psiconv_progress(lev+2,off+len, 644 psiconv_progress(config,lev+2,off+len,
635 "Going to read the initial byte (%02x expected)",0x02); 645 "Going to read the initial byte (%02x expected)",0x02);
636 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 646 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
637 if (res) 647 if (res)
638 goto ERROR2; 648 goto ERROR2;
639 if (temp != 0x02) { 649 if (temp != 0x02) {
640 psiconv_warn(lev+2,off+len, 650 psiconv_warn(config,lev+2,off+len,
641 "Sheet name section initial byte unknown value (ignored)"); 651 "Sheet name section initial byte unknown value (ignored)");
642 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 652 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
643 } 653 }
644 len ++; 654 len ++;
645 655
646 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");
647 (*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);
648 if (res) 658 if (res)
649 goto ERROR2; 659 goto ERROR2;
650 len += leng; 660 len += leng;
651 661
652 if (length) 662 if (length)
653 *length = len; 663 *length = len;
654 664
655 psiconv_progress(lev,off+len-1, 665 psiconv_progress(config,lev,off+len-1,
656 "End of sheet name section (total length: %08x)", len); 666 "End of sheet name section (total length: %08x)", len);
657 return 0; 667 return 0;
658 668
659ERROR2: 669ERROR2:
660 free(*result); 670 free(*result);
661ERROR1: 671ERROR1:
662 psiconv_warn(lev+1,off,"Reading of Sheet Name Section failed"); 672 psiconv_warn(config,lev+1,off,"Reading of Sheet Name Section failed");
663 if (length) 673 if (length)
664 *length = 0; 674 *length = 0;
665 if (!res) 675 if (!res)
666 return -PSICONV_E_NOMEM; 676 return -PSICONV_E_NOMEM;
667 else 677 else
668 return res; 678 return res;
669} 679}
670 680
671int 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,
672 psiconv_u32 off, int *length, 683 psiconv_u32 off, int *length,
673 psiconv_sheet_info_section *result) 684 psiconv_sheet_info_section *result)
674{ 685{
675 int res=0; 686 int res=0;
676 psiconv_u32 temp; 687 psiconv_u32 temp;
677 int len=0,leng; 688 int len=0,leng;
678 689
679 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");
680 if (!(*result = malloc(sizeof(**result)))) 691 if (!(*result = malloc(sizeof(**result))))
681 goto ERROR1; 692 goto ERROR1;
682 693
683 psiconv_progress(lev+2,off+len, 694 psiconv_progress(config,lev+2,off+len,
684 "Going to read the initial byte (%02x expected)",0x02); 695 "Going to read the initial byte (%02x expected)",0x02);
685 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 696 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
686 if (res) 697 if (res)
687 goto ERROR2; 698 goto ERROR2;
688 if (temp != 0x02) { 699 if (temp != 0x02) {
689 psiconv_warn(lev+2,off+len, 700 psiconv_warn(config,lev+2,off+len,
690 "Sheet info section initial byte unknown value (ignored)"); 701 "Sheet info section initial byte unknown value (ignored)");
691 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 702 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
692 } 703 }
693 len ++; 704 len ++;
694 705
695 psiconv_progress(lev+2,off+len, "Going to read an unknown Xint"); 706 psiconv_progress(config,lev+2,off+len, "Going to read an unknown Xint");
696 temp = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 707 temp = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
697 if (res) 708 if (res)
698 goto ERROR2; 709 goto ERROR2;
699 psiconv_debug(lev+2,off+len,"Value: %d\n",temp); 710 psiconv_debug(config,lev+2,off+len,"Value: %d\n",temp);
700 len += leng; 711 len += leng;
701 712
702 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");
703 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 714 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
704 if (res) 715 if (res)
705 goto ERROR2; 716 goto ERROR2;
706 (*result)->auto_recalc = temp & 0x01 ? psiconv_bool_true:psiconv_bool_false; 717 (*result)->auto_recalc = temp & 0x01 ? psiconv_bool_true:psiconv_bool_false;
707 psiconv_debug(lev+2,off+len,"Auto recalculation: %02x", 718 psiconv_debug(config,lev+2,off+len,"Auto recalculation: %02x",
708 (*result)->auto_recalc); 719 (*result)->auto_recalc);
709 if ((temp & 0xfe) != 0x02) { 720 if ((temp & 0xfe) != 0x02) {
710 psiconv_warn(lev+2,off+len,"Sheet Info Section flags byte " 721 psiconv_warn(config,lev+2,off+len,"Sheet Info Section flags byte "
711 "contains unknown flags (ignored)"); 722 "contains unknown flags (ignored)");
712 psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp &0xfe); 723 psiconv_debug(config,lev+2,off+len,"Unknown flags: %02x",temp &0xfe);
713 } 724 }
714 725
715 len ++; 726 len ++;
716 727
717 728
718 if (length) 729 if (length)
719 *length = len; 730 *length = len;
720 731
721 psiconv_progress(lev,off+len-1, 732 psiconv_progress(config,lev,off+len-1,
722 "End of sheet info section (total length: %08x)", len); 733 "End of sheet info section (total length: %08x)", len);
723 return 0; 734 return 0;
724 735
725ERROR2: 736ERROR2:
726 free(*result); 737 free(*result);
727ERROR1: 738ERROR1:
728 psiconv_warn(lev+1,off,"Reading of Sheet Name Section failed"); 739 psiconv_warn(config,lev+1,off,"Reading of Sheet Name Section failed");
729 if (length) 740 if (length)
730 *length = 0; 741 *length = 0;
731 if (!res) 742 if (!res)
732 return -PSICONV_E_NOMEM; 743 return -PSICONV_E_NOMEM;
733 else 744 else
734 return res; 745 return res;
735} 746}
736 747
737int 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,
738 psiconv_u32 off, int *length, 750 psiconv_u32 off, int *length,
739 psiconv_formula_list *result) 751 psiconv_formula_list *result)
740{ 752{
741 int res=0; 753 int res=0;
742 int len=0; 754 int len=0;
743 psiconv_u32 temp; 755 psiconv_u32 temp;
744 psiconv_formula formula; 756 psiconv_formula formula;
745 psiconv_u32 listlen,i; 757 psiconv_u32 listlen,i;
746 int leng; 758 int leng;
747 759
748 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");
749 if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s)))) 761 if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s))))
750 goto ERROR1; 762 goto ERROR1;
751 763
752 psiconv_progress(lev+2,off+len, 764 psiconv_progress(config,lev+2,off+len,
753 "Going to read the initial byte (%02x expected)",0x02); 765 "Going to read the initial byte (%02x expected)",0x02);
754 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 766 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
755 if (res) 767 if (res)
756 goto ERROR2; 768 goto ERROR2;
757 if (temp != 0x02) { 769 if (temp != 0x02) {
758 psiconv_warn(lev+2,off+len, 770 psiconv_warn(config,lev+2,off+len,
759 "Sheet formula list initial byte unknown value (ignored)"); 771 "Sheet formula list initial byte unknown value (ignored)");
760 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 772 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
761 } 773 }
762 len ++; 774 len ++;
763 775
764 psiconv_progress(lev+2,off+len, 776 psiconv_progress(config,lev+2,off+len,
765 "Going to read the number of formulas"); 777 "Going to read the number of formulas");
766 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 778 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
767 if (res) 779 if (res)
768 goto ERROR2; 780 goto ERROR2;
769 psiconv_debug(lev+2,off+len,"Number of formulas: %d",listlen); 781 psiconv_debug(config,lev+2,off+len,"Number of formulas: %d",listlen);
770 len += leng; 782 len += leng;
771 783
772 psiconv_progress(lev+2,off+len,"Going to read all formulas"); 784 psiconv_progress(config,lev+2,off+len,"Going to read all formulas");
773 for (i = 0; i < listlen; i++) { 785 for (i = 0; i < listlen; i++) {
774 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);
775 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)))
776 goto ERROR2; 788 goto ERROR2;
777 if ((res = psiconv_list_add(*result,formula))) 789 if ((res = psiconv_list_add(*result,formula)))
778 goto ERROR3; 790 goto ERROR3;
791 free(formula);
779 len += leng; 792 len += leng;
780 } 793 }
781 794
782 if (length) 795 if (length)
783 *length = len; 796 *length = len;
784 797
785 psiconv_progress(lev,off+len-1, 798 psiconv_progress(config,lev,off+len-1,
786 "End of sheet formula list (total length: %08x)", len); 799 "End of sheet formula list (total length: %08x)", len);
787 return 0; 800 return 0;
788 801
789ERROR3: 802ERROR3:
790 psiconv_free_formula(formula); 803 psiconv_free_formula(formula);
791ERROR2: 804ERROR2:
792 psiconv_list_free(*result); 805 psiconv_list_free(*result);
793ERROR1: 806ERROR1:
794 psiconv_warn(lev+1,off,"Reading of Sheet Formula list failed"); 807 psiconv_warn(config,lev+1,off,"Reading of Sheet Formula list failed");
795 if (length) 808 if (length)
796 *length = 0; 809 *length = 0;
797 if (!res) 810 if (!res)
798 return -PSICONV_E_NOMEM; 811 return -PSICONV_E_NOMEM;
799 else 812 else
800 return res; 813 return res;
801} 814}
802 815
803int 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,
804 psiconv_u32 off, int *length, 818 psiconv_u32 off, int *length,
805 psiconv_sheet_cell *result, 819 psiconv_sheet_cell *result,
806 const psiconv_sheet_cell_layout default_layout, 820 const psiconv_sheet_cell_layout default_layout,
807 const psiconv_sheet_line_list row_default_layouts, 821 const psiconv_sheet_line_list row_default_layouts,
808 const psiconv_sheet_line_list col_default_layouts) 822 const psiconv_sheet_line_list col_default_layouts)
… …
811 int len=0; 825 int len=0;
812 psiconv_u32 temp; 826 psiconv_u32 temp;
813 psiconv_bool_t has_layout; 827 psiconv_bool_t has_layout;
814 int leng; 828 int leng;
815 829
816 psiconv_progress(lev+1,off,"Going to read a sheet cell structure"); 830 psiconv_progress(config,lev+1,off,"Going to read a sheet cell structure");
817 if (!(*result = malloc(sizeof(**result)))) 831 if (!(*result = malloc(sizeof(**result))))
818 goto ERROR1; 832 goto ERROR1;
819 833
820 (*result)->layout = NULL; 834 (*result)->layout = NULL;
821 (*result)->type = psiconv_cell_blank; 835 (*result)->type = psiconv_cell_blank;
822 836
823 psiconv_progress(lev+2,off+len,"Going to read the cell position"); 837 psiconv_progress(config,lev+2,off+len,"Going to read the cell position");
824 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 838 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
825 if (res) 839 if (res)
826 goto ERROR2; 840 goto ERROR2;
827 len ++; 841 len ++;
828 temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 8; 842 temp += psiconv_read_u8(config,buf,lev+2,off+len,&res) << 8;
829 if (res) 843 if (res)
830 goto ERROR2; 844 goto ERROR2;
831 len ++; 845 len ++;
832 temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 16; 846 temp += psiconv_read_u8(config,buf,lev+2,off+len,&res) << 16;
833 if (res) 847 if (res)
834 goto ERROR2; 848 goto ERROR2;
835 len ++; 849 len ++;
836 (*result)->column = (temp >> 2) & 0xFF; 850 (*result)->column = (temp >> 2) & 0xFF;
837 (*result)->row = (temp >> 10) & 0x3FFF; 851 (*result)->row = (temp >> 10) & 0x3FFF;
838 psiconv_debug(lev+2,off+len,"Cell position is col:%02x row:%04x", 852 psiconv_debug(config,lev+2,off+len,"Cell position is col:%02x row:%04x",
839 (*result)->column,(*result)->row); 853 (*result)->column,(*result)->row);
840 if (temp & 0x03) { 854 if (temp & 0x03) {
841 psiconv_warn(lev+2,off+len,"Unknown flags in cell position (ignored)"); 855 psiconv_warn(config,lev+2,off+len,"Unknown flags in cell position (ignored)");
842 psiconv_debug(lev+2,off+len,"Flags: %02x",temp & 0x03); 856 psiconv_debug(config,lev+2,off+len,"Flags: %02x",temp & 0x03);
843 } 857 }
844 858
845 psiconv_progress(lev+2,off+len,"Going to read the cell type"); 859 psiconv_progress(config,lev+2,off+len,"Going to read the cell type");
846 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 860 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
847 if (res) 861 if (res)
848 goto ERROR2; 862 goto ERROR2;
849 len ++; 863 len ++;
850 (*result)->type = (temp >> 5) & 0x07; 864 (*result)->type = (temp >> 5) & 0x07;
851 (*result)->calculated = (temp & 0x08)?psiconv_bool_true:psiconv_bool_false; 865 (*result)->calculated = (temp & 0x08)?psiconv_bool_true:psiconv_bool_false;
852 has_layout = (temp & 0x10)?psiconv_bool_true:psiconv_bool_false; 866 has_layout = (temp & 0x10)?psiconv_bool_true:psiconv_bool_false;
853 867
854 psiconv_progress(lev+2,off+len,"Going to read the cell value"); 868 psiconv_progress(config,lev+2,off+len,"Going to read the cell value");
855 if ((*result)->type == psiconv_cell_blank) { 869 if ((*result)->type == psiconv_cell_blank) {
856 psiconv_debug(lev+2,off+len,"Cell type is blank: no value given."); 870 psiconv_debug(config,lev+2,off+len,"Cell type is blank: no value given.");
857 } else if ((*result)->type == psiconv_cell_int) { 871 } else if ((*result)->type == psiconv_cell_int) {
858 psiconv_progress(lev+2,off+len,"Going to read an integer"); 872 psiconv_progress(config,lev+2,off+len,"Going to read an integer");
859 (*result)->data.dat_int = psiconv_read_u32(buf,lev+2,off+len,&res); 873 (*result)->data.dat_int = psiconv_read_u32(config,buf,lev+2,off+len,&res);
860 if (res) 874 if (res)
861 goto ERROR2; 875 goto ERROR2;
862 len += 4; 876 len += 4;
863 psiconv_debug(lev+2,off+len,"Cell contents: %ld",(*result)->data.dat_int); 877 psiconv_debug(config,lev+2,off+len,"Cell contents: %ld",(*result)->data.dat_int);
864 878
865 } else if ((*result)->type == psiconv_cell_bool) { 879 } else if ((*result)->type == psiconv_cell_bool) {
866 psiconv_progress(lev+2,off+len,"Going to read a boolean"); 880 psiconv_progress(config,lev+2,off+len,"Going to read a boolean");
867 if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng, 881 if ((res = psiconv_parse_bool(config,buf,lev+2,off+len,&leng,
868 &(*result)->data.dat_bool))) 882 &(*result)->data.dat_bool)))
869 goto ERROR2; 883 goto ERROR2;
870 psiconv_debug(lev+2,off+len,"Cell contents: %01x",temp); 884 psiconv_debug(config,lev+2,off+len,"Cell contents: %01x",temp);
871 (*result)->data.dat_bool = temp?psiconv_bool_true:psiconv_bool_false; 885 (*result)->data.dat_bool = temp?psiconv_bool_true:psiconv_bool_false;
872 len += leng; 886 len += leng;
873 } else if ((*result)->type == psiconv_cell_error) { 887 } else if ((*result)->type == psiconv_cell_error) {
874 psiconv_progress(lev+2,off+len,"Going to read the error code"); 888 psiconv_progress(config,lev+2,off+len,"Going to read the error code");
875 temp = psiconv_read_u16(buf,lev+2,off+len,&res); 889 temp = psiconv_read_u16(config,buf,lev+2,off+len,&res);
876 if (res) 890 if (res)
877 goto ERROR2; 891 goto ERROR2;
878 if (temp == 0) 892 if (temp == 0)
879 (*result)->data.dat_error = psiconv_sheet_error_none; 893 (*result)->data.dat_error = psiconv_sheet_error_none;
880 else if (temp == 1) 894 else if (temp == 1)
… …
890 else if (temp == 6) 904 else if (temp == 6)
891 (*result)->data.dat_error = psiconv_sheet_error_number; 905 (*result)->data.dat_error = psiconv_sheet_error_number;
892 else if (temp == 7) 906 else if (temp == 7)
893 (*result)->data.dat_error = psiconv_sheet_error_notavail; 907 (*result)->data.dat_error = psiconv_sheet_error_notavail;
894 else { 908 else {
895 psiconv_warn(lev+2,off+len,"Unknown error code (default assumed)"); 909 psiconv_warn(config,lev+2,off+len,"Unknown error code (default assumed)");
896 psiconv_debug(lev+2,off+len,"Error code: %04x",temp); 910 psiconv_debug(config,lev+2,off+len,"Error code: %04x",temp);
897 (*result)->data.dat_error = psiconv_sheet_error_none; 911 (*result)->data.dat_error = psiconv_sheet_error_none;
898 } 912 }
899 psiconv_debug(lev+2,off+len,"Cell contents: %04x", 913 psiconv_debug(config,lev+2,off+len,"Cell contents: %04x",
900 (*result)->data.dat_error); 914 (*result)->data.dat_error);
901 len += 2; 915 len += 2;
902 } else if ((*result)->type == psiconv_cell_float) { 916 } else if ((*result)->type == psiconv_cell_float) {
903 psiconv_progress(lev+2,off+len,"Going to read a float"); 917 psiconv_progress(config,lev+2,off+len,"Going to read a float");
904 (*result)->data.dat_float = 918 (*result)->data.dat_float =
905 psiconv_read_float(buf,lev+2,off+len,&leng,&res); 919 psiconv_read_float(config,buf,lev+2,off+len,&leng,&res);
906 if (res) 920 if (res)
907 goto ERROR2; 921 goto ERROR2;
908 psiconv_debug(lev+2,off+len,"Cell contents: %f",(*result)->data.dat_float); 922 psiconv_debug(config,lev+2,off+len,"Cell contents: %f",(*result)->data.dat_float);
909 len += leng; 923 len += leng;
910 } else if ((*result)->type == psiconv_cell_string) { 924 } else if ((*result)->type == psiconv_cell_string) {
911 psiconv_progress(lev+2,off+len,"Going to read a string"); 925 psiconv_progress(config,lev+2,off+len,"Going to read a string");
912 (*result)->data.dat_string = 926 (*result)->data.dat_string =
913 psiconv_read_string(buf,lev+2,off+len,&leng,&res); 927 psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
914 if (res) 928 if (res)
915 goto ERROR2; 929 goto ERROR2;
916 psiconv_debug(lev+2,off+len,"Cell contents: `%s'", 930 psiconv_debug(config,lev+2,off+len,"Cell contents: `%s'",
917 (*result)->data.dat_string); 931 (*result)->data.dat_string);
918 len += leng; 932 len += leng;
919 } else { 933 } else {
920 psiconv_warn(lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type); 934 psiconv_warn(config,lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type);
921 res = PSICONV_E_PARSE; 935 res = PSICONV_E_PARSE;
922 goto ERROR2; 936 goto ERROR2;
923 } 937 }
924 938
925 if (!((*result)->layout = psiconv_clone_cell_layout( 939 if (!((*result)->layout = psiconv_clone_cell_layout(
… …
928 default_layout, 942 default_layout,
929 (*result)->row, 943 (*result)->row,
930 (*result)->column)))) 944 (*result)->column))))
931 goto ERROR2; 945 goto ERROR2;
932 if (has_layout) { 946 if (has_layout) {
933 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len, 947 if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,
934 &leng,(*result)->layout))) 948 &leng,(*result)->layout)))
935 goto ERROR2; 949 goto ERROR2;
936 len += leng; 950 len += leng;
937 } 951 }
938 952
939 if ((*result)->calculated) { 953 if ((*result)->calculated) {
940 psiconv_progress(lev+2,off+len,"Going to read the cell formula reference"); 954 psiconv_progress(config,lev+2,off+len,"Going to read the cell formula reference");
941 temp = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 955 temp = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
942 if (res) 956 if (res)
943 goto ERROR2; 957 goto ERROR2;
944 psiconv_debug(lev+2,off+len,"Cell formula reference: %d",temp); 958 psiconv_debug(config,lev+2,off+len,"Cell formula reference: %d",temp);
945 len += leng; 959 len += leng;
946 (*result)->ref_formula = temp; 960 (*result)->ref_formula = temp;
947 } 961 }
948 962
949 if (length) 963 if (length)
950 *length = len; 964 *length = len;
951 965
952 psiconv_progress(lev,off+len-1, 966 psiconv_progress(config,lev,off+len-1,
953 "End of sheet cell structure (total length: %08x)", len); 967 "End of sheet cell structure (total length: %08x)", len);
954 return 0; 968 return 0;
955 969
956ERROR2: 970ERROR2:
957 psiconv_free_sheet_cell(*result); 971 psiconv_free_sheet_cell(*result);
958ERROR1: 972ERROR1:
959 psiconv_warn(lev+1,off,"Reading of Sheet Cell Structure failed"); 973 psiconv_warn(config,lev+1,off,"Reading of Sheet Cell Structure failed");
960 if (length) 974 if (length)
961 *length = 0; 975 *length = 0;
962 if (!res) 976 if (!res)
963 return -PSICONV_E_NOMEM; 977 return -PSICONV_E_NOMEM;
964 else 978 else
965 return res; 979 return res;
966} 980}
967 981
968int psiconv_parse_sheet_cell_list(const psiconv_buffer buf, int lev, 982int psiconv_parse_sheet_cell_list(const psiconv_config config,
983 const psiconv_buffer buf, int lev,
969 psiconv_u32 off, int *length, 984 psiconv_u32 off, int *length,
970 psiconv_sheet_cell_list *result, 985 psiconv_sheet_cell_list *result,
971 const psiconv_sheet_cell_layout default_layout, 986 const psiconv_sheet_cell_layout default_layout,
972 const psiconv_sheet_line_list row_default_layouts, 987 const psiconv_sheet_line_list row_default_layouts,
973 const psiconv_sheet_line_list col_default_layouts) 988 const psiconv_sheet_line_list col_default_layouts)
… …
977 psiconv_u32 temp; 992 psiconv_u32 temp;
978 psiconv_sheet_cell cell; 993 psiconv_sheet_cell cell;
979 psiconv_u32 listlen,i; 994 psiconv_u32 listlen,i;
980 int leng; 995 int leng;
981 996
982 psiconv_progress(lev+1,off,"Going to read the sheet cell list"); 997 psiconv_progress(config,lev+1,off,"Going to read the sheet cell list");
983 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_cell_s)))) 998 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_cell_s))))
984 goto ERROR1; 999 goto ERROR1;
985 1000
986 psiconv_progress(lev+2,off+len, 1001 psiconv_progress(config,lev+2,off+len,
987 "Going to read the initial byte (%02x expected)",0x02); 1002 "Going to read the initial byte (%02x expected)",0x02);
988 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1003 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
989 if (res) 1004 if (res)
990 goto ERROR2; 1005 goto ERROR2;
991 if (temp != 0x02) { 1006 if (temp != 0x02) {
992 psiconv_warn(lev+2,off+len, 1007 psiconv_warn(config,lev+2,off+len,
993 "Sheet cell list initial byte unknown value (ignored)"); 1008 "Sheet cell list initial byte unknown value (ignored)");
994 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1009 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
995 } 1010 }
996 len ++; 1011 len ++;
997 1012
998 psiconv_progress(lev+2,off+len, 1013 psiconv_progress(config,lev+2,off+len,
999 "Going to read the initial byte (%02x expected)",0x00); 1014 "Going to read the initial byte (%02x expected)",0x00);
1000 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1015 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1001 if (res) 1016 if (res)
1002 goto ERROR2; 1017 goto ERROR2;
1003 if (temp != 0x00) { 1018 if (temp != 0x00) {
1004 psiconv_warn(lev+2,off+len, 1019 psiconv_warn(config,lev+2,off+len,
1005 "Sheet cell list initial byte unknown value (ignored)"); 1020 "Sheet cell list initial byte unknown value (ignored)");
1006 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1021 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1007 } 1022 }
1008 len ++; 1023 len ++;
1009 1024
1010 psiconv_progress(lev+2,off+len, 1025 psiconv_progress(config,lev+2,off+len,
1011 "Going to read the number of defined cells"); 1026 "Going to read the number of defined cells");
1012 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 1027 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1013 if (res) 1028 if (res)
1014 goto ERROR2; 1029 goto ERROR2;
1015 psiconv_debug(lev+2,off+len,"Number of defined cells: %d",listlen); 1030 psiconv_debug(config,lev+2,off+len,"Number of defined cells: %d",listlen);
1016 len += leng; 1031 len += leng;
1017 1032
1018 psiconv_progress(lev+2,off+len,"Going to read all cells"); 1033 psiconv_progress(config,lev+2,off+len,"Going to read all cells");
1019 for (i = 0; i < listlen; i++) { 1034 for (i = 0; i < listlen; i++) {
1020 psiconv_progress(lev+3,off+len,"Going to read cell %d",i); 1035 psiconv_progress(config,lev+3,off+len,"Going to read cell %d",i);
1021 if ((res = psiconv_parse_sheet_cell(buf,lev+3,off+len,&leng,&cell, 1036 if ((res = psiconv_parse_sheet_cell(config,buf,lev+3,off+len,&leng,&cell,
1022 default_layout,row_default_layouts, 1037 default_layout,row_default_layouts,
1023 col_default_layouts))) 1038 col_default_layouts)))
1024 goto ERROR2; 1039 goto ERROR2;
1025 if ((res = psiconv_list_add(*result,cell))) 1040 if ((res = psiconv_list_add(*result,cell)))
1026 goto ERROR3; 1041 goto ERROR3;
… …
1029 } 1044 }
1030 1045
1031 if (length) 1046 if (length)
1032 *length = len; 1047 *length = len;
1033 1048
1034 psiconv_progress(lev,off+len-1, 1049 psiconv_progress(config,lev,off+len-1,
1035 "End of sheet cell list (total length: %08x)", len); 1050 "End of sheet cell list (total length: %08x)", len);
1036 return 0; 1051 return 0;
1037 1052
1038ERROR3: 1053ERROR3:
1039 psiconv_free_sheet_cell(cell); 1054 psiconv_free_sheet_cell(cell);
1040ERROR2: 1055ERROR2:
1041 psiconv_free_sheet_cell_list(*result); 1056 psiconv_free_sheet_cell_list(*result);
1042ERROR1: 1057ERROR1:
1043 psiconv_warn(lev+1,off,"Reading of Sheet Cells List failed"); 1058 psiconv_warn(config,lev+1,off,"Reading of Sheet Cells List failed");
1044 if (length) 1059 if (length)
1045 *length = 0; 1060 *length = 0;
1046 if (!res) 1061 if (!res)
1047 return -PSICONV_E_NOMEM; 1062 return -PSICONV_E_NOMEM;
1048 else 1063 else
1049 return res; 1064 return res;
1050} 1065}
1051 1066
1052 1067
1053int psiconv_parse_sheet_worksheet_list( const psiconv_buffer buf, int lev, 1068int psiconv_parse_sheet_worksheet_list(const psiconv_config config,
1069 const psiconv_buffer buf, int lev,
1054 psiconv_u32 off, int *length, 1070 psiconv_u32 off, int *length,
1055 psiconv_sheet_worksheet_list *result) 1071 psiconv_sheet_worksheet_list *result)
1056{ 1072{
1057 psiconv_sheet_worksheet worksheet; 1073 psiconv_sheet_worksheet worksheet;
1058 int res=0; 1074 int res=0;
1059 int len=0; 1075 int len=0;
1060 psiconv_u8 temp; 1076 psiconv_u8 temp;
1061 psiconv_u32 offset; 1077 psiconv_u32 offset;
1062 int leng,i,nr; 1078 int leng,i,nr;
1063 1079
1064 psiconv_progress(lev+1,off,"Going to read the worksheet list"); 1080 psiconv_progress(config,lev+1,off,"Going to read the worksheet list");
1065 if (!(*result = psiconv_list_new(sizeof(*worksheet)))) 1081 if (!(*result = psiconv_list_new(sizeof(*worksheet))))
1066 goto ERROR1; 1082 goto ERROR1;
1067 1083
1068 psiconv_progress(lev+2,off+len, 1084 psiconv_progress(config,lev+2,off+len,
1069 "Going to read the initial bytes (%02x expected)",0x02); 1085 "Going to read the initial bytes (%02x expected)",0x02);
1070 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1086 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1071 if (res) 1087 if (res)
1072 goto ERROR2; 1088 goto ERROR2;
1073 if (temp != 0x02) { 1089 if (temp != 0x02) {
1074 psiconv_warn(lev+2,off+len, 1090 psiconv_warn(config,lev+2,off+len,
1075 "Sheet worksheet list initial byte unknown value (ignored)"); 1091 "Sheet worksheet list initial byte unknown value (ignored)");
1076 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1092 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1077 } 1093 }
1078 len ++; 1094 len ++;
1079 1095
1080 psiconv_progress(lev+2,off+len,"Going to read the list length"); 1096 psiconv_progress(config,lev+2,off+len,"Going to read the list length");
1081 nr = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 1097 nr = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1082 if (res) 1098 if (res)
1083 goto ERROR2; 1099 goto ERROR2;
1084 psiconv_debug(lev+2,off+len,"Length: %02x",nr); 1100 psiconv_debug(config,lev+2,off+len,"Length: %02x",nr);
1085 len += leng; 1101 len += leng;
1086 1102
1087 psiconv_progress(lev+2,off+len,"Going to read the list"); 1103 psiconv_progress(config,lev+2,off+len,"Going to read the list");
1088 for (i=0 ; i < nr; i++) { 1104 for (i=0 ; i < nr; i++) {
1089 psiconv_progress(lev+3,off+len,"Going to read element %d",i); 1105 psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
1090 psiconv_progress(lev+4,off+len, 1106 psiconv_progress(config,lev+4,off+len,
1091 "Going to read the initial byte (%02x expected)",0x00); 1107 "Going to read the initial byte (%02x expected)",0x00);
1092 temp = psiconv_read_u8(buf,lev+4,off+len,&res); 1108 temp = psiconv_read_u8(config,buf,lev+4,off+len,&res);
1093 if (res) 1109 if (res)
1094 goto ERROR2; 1110 goto ERROR2;
1095 if (temp != 0x00) { 1111 if (temp != 0x00) {
1096 psiconv_warn(lev+4,off+len, 1112 psiconv_warn(config,lev+4,off+len,
1097 "Sheet worksheet element initial byte unknown value (ignored)"); 1113 "Sheet worksheet element initial byte unknown value (ignored)");
1098 psiconv_debug(lev+4,off+len,"Initial byte: %02x",temp); 1114 psiconv_debug(config,lev+4,off+len,"Initial byte: %02x",temp);
1099 } 1115 }
1100 len ++; 1116 len ++;
1101 1117
1102 psiconv_progress(lev+4,off+len,"Going to read the worksheet offset"); 1118 psiconv_progress(config,lev+4,off+len,"Going to read the worksheet offset");
1103 offset = psiconv_read_u32(buf,lev+2,off+len,&res); 1119 offset = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1104 if (res) 1120 if (res)
1105 goto ERROR2; 1121 goto ERROR2;
1106 psiconv_debug(lev+4,off+len,"Offset: %08x",offset); 1122 psiconv_debug(config,lev+4,off+len,"Offset: %08x",offset);
1107 len += 4; 1123 len += 4;
1108 1124
1109 if ((res = psiconv_parse_sheet_worksheet(buf,lev+4,offset,NULL, 1125 if ((res = psiconv_parse_sheet_worksheet(config,buf,lev+4,offset,NULL,
1110 &worksheet))) 1126 &worksheet)))
1111 goto ERROR2; 1127 goto ERROR2;
1112 if ((res = psiconv_list_add(*result,worksheet))) 1128 if ((res = psiconv_list_add(*result,worksheet)))
1113 goto ERROR3; 1129 goto ERROR3;
1114 free(worksheet); 1130 free(worksheet);
1115 } 1131 }
1116 1132
1117 if (length) 1133 if (length)
1118 *length = len; 1134 *length = len;
1119 1135
1120 psiconv_progress(lev,off+len-1, 1136 psiconv_progress(config,lev,off+len-1,
1121 "End of worksheet list (total length: %08x)", len); 1137 "End of worksheet list (total length: %08x)", len);
1122 1138
1123 return 0; 1139 return 0;
1124 1140
1125ERROR3: 1141ERROR3:
1126 psiconv_free_sheet_worksheet(worksheet); 1142 psiconv_free_sheet_worksheet(worksheet);
1127ERROR2: 1143ERROR2:
1128 psiconv_free_sheet_worksheet_list(*result); 1144 psiconv_free_sheet_worksheet_list(*result);
1129ERROR1: 1145ERROR1:
1130 psiconv_warn(lev+1,off,"Reading of worksheet list failed"); 1146 psiconv_warn(config,lev+1,off,"Reading of worksheet list failed");
1131 if (length) 1147 if (length)
1132 *length = 0; 1148 *length = 0;
1133 if (!res) 1149 if (!res)
1134 return -PSICONV_E_NOMEM; 1150 return -PSICONV_E_NOMEM;
1135 else 1151 else
1136 return res; 1152 return res;
1137} 1153}
1138 1154
1139int psiconv_parse_sheet_cell_layout(const psiconv_buffer buf, int lev, 1155int psiconv_parse_sheet_cell_layout(const psiconv_config config,
1156 const psiconv_buffer buf, int lev,
1140 psiconv_u32 off, int *length, 1157 psiconv_u32 off, int *length,
1141 psiconv_sheet_cell_layout result) 1158 psiconv_sheet_cell_layout result)
1142 1159
1143{ 1160{
1144 int res=0; 1161 int res=0;
1145 int len=0; 1162 int len=0;
1146 int leng; 1163 int leng;
1147 psiconv_u8 temp; 1164 psiconv_u8 temp;
1148 1165
1149 psiconv_progress(lev+1,off,"Going to read a sheet cell layout"); 1166 psiconv_progress(config,lev+1,off,"Going to read a sheet cell layout");
1150 1167
1151 psiconv_progress(lev+2,off+len, 1168 psiconv_progress(config,lev+2,off+len,
1152 "Going to read the first byte (%02x expected)",0x02); 1169 "Going to read the first byte (%02x expected)",0x02);
1153 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1170 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1154 if (res) 1171 if (res)
1155 goto ERROR1; 1172 goto ERROR1;
1156 if (temp != 0x02) { 1173 if (temp != 0x02) {
1157 psiconv_warn(lev+2,off+len, 1174 psiconv_warn(config,lev+2,off+len,
1158 "Worksheet section initial byte unknown value (ignored)"); 1175 "Worksheet section initial byte unknown value (ignored)");
1159 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1176 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1160 } 1177 }
1161 len ++; 1178 len ++;
1162 1179
1163 psiconv_progress(lev+2,off+len,"Going to read the default formats flag"); 1180 psiconv_progress(config,lev+2,off+len,"Going to read the default formats flag");
1164 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1181 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1165 if (res) 1182 if (res)
1166 goto ERROR1; 1183 goto ERROR1;
1167 len ++; 1184 len ++;
1168 1185
1169 if (temp & 0x01) { 1186 if (temp & 0x01) {
1170 psiconv_progress(lev+3,off+len,"Going to read the default paragraph codes"); 1187 psiconv_progress(config,lev+3,off+len,"Going to read the default paragraph codes");
1171 if ((res = psiconv_parse_paragraph_layout_list(buf,lev+3,off+len,&leng, 1188 if ((res = psiconv_parse_paragraph_layout_list(config,buf,lev+3,off+len,&leng,
1172 result->paragraph))) 1189 result->paragraph)))
1173 goto ERROR1; 1190 goto ERROR1;
1174 len += leng; 1191 len += leng;
1175 } 1192 }
1176 1193
1177 if (temp & 0x02) { 1194 if (temp & 0x02) {
1178 psiconv_progress(lev+3,off+len,"Going to read the default character codes"); 1195 psiconv_progress(config,lev+3,off+len,"Going to read the default character codes");
1179 if ((res = psiconv_parse_character_layout_list(buf,lev+3,off+len,&leng, 1196 if ((res = psiconv_parse_character_layout_list(config,buf,lev+3,off+len,&leng,
1180 result->character))) 1197 result->character)))
1181 goto ERROR1; 1198 goto ERROR1;
1182 len += leng; 1199 len += leng;
1183 } 1200 }
1184 1201
1185 if (temp & 0x04) { 1202 if (temp & 0x04) {
1186 psiconv_progress(lev+3,off+len, "Going to read the default number format"); 1203 psiconv_progress(config,lev+3,off+len, "Going to read the default number format");
1187 psiconv_parse_sheet_numberformat(buf,lev+3,off+len,&leng, 1204 psiconv_parse_sheet_numberformat(config,buf,lev+3,off+len,&leng,
1188 result->numberformat); 1205 result->numberformat);
1189 len += leng; 1206 len += leng;
1190 } 1207 }
1191 1208
1192 if (length) 1209 if (length)
1193 *length = len; 1210 *length = len;
1194 1211
1195 psiconv_progress(lev,off+len-1, 1212 psiconv_progress(config,lev,off+len-1,
1196 "End of sheet cell layout (total length: %08x)", len); 1213 "End of sheet cell layout (total length: %08x)", len);
1197 1214
1198 return 0; 1215 return 0;
1199 1216
1200ERROR1: 1217ERROR1:
1201 psiconv_warn(lev+1,off,"Reading of sheet cell layout failed"); 1218 psiconv_warn(config,lev+1,off,"Reading of sheet cell layout failed");
1202 if (length) 1219 if (length)
1203 *length = 0; 1220 *length = 0;
1204 if (!res) 1221 if (!res)
1205 return -PSICONV_E_NOMEM; 1222 return -PSICONV_E_NOMEM;
1206 else 1223 else
1207 return res; 1224 return res;
1208} 1225}
1209 1226
1210 1227
1211int psiconv_parse_sheet_worksheet(const psiconv_buffer buf, int lev, 1228int psiconv_parse_sheet_worksheet(const psiconv_config config,
1229 const psiconv_buffer buf, int lev,
1212 psiconv_u32 off, int *length, 1230 psiconv_u32 off, int *length,
1213 psiconv_sheet_worksheet *result) 1231 psiconv_sheet_worksheet *result)
1214{ 1232{
1215 int res=0; 1233 int res=0;
1216 psiconv_u32 temp,cells_off,grid_off,rows_off,cols_off,unknown_off; 1234 psiconv_u32 temp,cells_off,grid_off,rows_off,cols_off,unknown_off;
1217 int len=0; 1235 int len=0;
1218 int leng; 1236 int leng;
1219 1237
1220 psiconv_progress(lev+1,off,"Going to read the sheet worksheet section"); 1238 psiconv_progress(config,lev+1,off,"Going to read the sheet worksheet section");
1221 if (!(*result = malloc(sizeof(**result)))) 1239 if (!(*result = malloc(sizeof(**result))))
1222 goto ERROR1; 1240 goto ERROR1;
1223 1241
1224 psiconv_progress(lev+2,off+len, 1242 psiconv_progress(config,lev+2,off+len,
1225 "Going to read the initial bytes (%02x expected)",0x04); 1243 "Going to read the initial bytes (%02x expected)",0x04);
1226 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1244 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1227 if (res) 1245 if (res)
1228 goto ERROR2; 1246 goto ERROR2;
1229 if (temp != 0x04) { 1247 if (temp != 0x04) {
1230 psiconv_warn(lev+2,off+len, 1248 psiconv_warn(config,lev+2,off+len,
1231 "Worksheet section initial byte unknown value (ignored)"); 1249 "Worksheet section initial byte unknown value (ignored)");
1232 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1250 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1233 } 1251 }
1234 len ++; 1252 len ++;
1235 1253
1236 psiconv_progress(lev+2,off+len, "Going to read the flags byte"); 1254 psiconv_progress(config,lev+2,off+len, "Going to read the flags byte");
1237 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1255 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1238 if (res) 1256 if (res)
1239 goto ERROR2; 1257 goto ERROR2;
1240 psiconv_debug(lev+2,off+len,"Flags byte: %02x",temp); 1258 psiconv_debug(config,lev+2,off+len,"Flags byte: %02x",temp);
1241 (*result)->show_zeros = (temp & 0x01)?psiconv_bool_true:psiconv_bool_false; 1259 (*result)->show_zeros = (temp & 0x01)?psiconv_bool_true:psiconv_bool_false;
1242 if (temp & 0xfe) { 1260 if (temp & 0xfe) {
1243 psiconv_warn(lev+2,off+len, 1261 psiconv_warn(config,lev+2,off+len,
1244 "Worksheet section flags byte unknown bits (ignored)"); 1262 "Worksheet section flags byte unknown bits (ignored)");
1245 } 1263 }
1246 len ++; 1264 len ++;
1247 1265
1248 psiconv_progress(lev+2,off+len,"Going to read the default cell layout"); 1266 psiconv_progress(config,lev+2,off+len,"Going to read the default cell layout");
1249 if (!((*result)->default_layout = psiconv_basic_cell_layout())) 1267 if (!((*result)->default_layout = psiconv_basic_cell_layout()))
1250 goto ERROR2; 1268 goto ERROR2;
1251 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,&leng, 1269 if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,&leng,
1252 (*result)->default_layout))) 1270 (*result)->default_layout)))
1253 goto ERROR3; 1271 goto ERROR3;
1254 len += leng; 1272 len += leng;
1255 1273
1256 psiconv_progress(lev+2,off+len, 1274 psiconv_progress(config,lev+2,off+len,
1257 "Going to read the offset of the row defaults Section"); 1275 "Going to read the offset of the row defaults Section");
1258 rows_off = psiconv_read_u32(buf,lev+2,off+len,&res); 1276 rows_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1259 if (res) 1277 if (res)
1260 goto ERROR3; 1278 goto ERROR3;
1261 psiconv_debug(lev+2,off+len,"Offset: %04x",rows_off); 1279 psiconv_debug(config,lev+2,off+len,"Offset: %04x",rows_off);
1262 len += 4; 1280 len += 4;
1263 1281
1264 psiconv_progress(lev+2,off+len, 1282 psiconv_progress(config,lev+2,off+len,
1265 "Going to read the offset of the column defaults Section"); 1283 "Going to read the offset of the column defaults Section");
1266 cols_off = psiconv_read_u32(buf,lev+2,off+len,&res); 1284 cols_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1267 if (res) 1285 if (res)
1268 goto ERROR3; 1286 goto ERROR3;
1269 psiconv_debug(lev+2,off+len,"Offset: %04x",cols_off); 1287 psiconv_debug(config,lev+2,off+len,"Offset: %04x",cols_off);
1270 len += 4; 1288 len += 4;
1271 1289
1272 psiconv_progress(lev+2,off+len, 1290 psiconv_progress(config,lev+2,off+len,
1273 "Going to read the offset of the Cells List"); 1291 "Going to read the offset of the Cells List");
1274 cells_off = psiconv_read_u32(buf,lev+2,off+len,&res); 1292 cells_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1275 if (res) 1293 if (res)
1276 goto ERROR3; 1294 goto ERROR3;
1277 psiconv_debug(lev+2,off+len,"Offset: %04x",cells_off); 1295 psiconv_debug(config,lev+2,off+len,"Offset: %04x",cells_off);
1278 len += 4; 1296 len += 4;
1279 1297
1280 psiconv_progress(lev+2,off+len, 1298 psiconv_progress(config,lev+2,off+len,
1281 "Going to read the offset of the Grid Section"); 1299 "Going to read the offset of the Grid Section");
1282 grid_off = psiconv_read_u32(buf,lev+2,off+len,&res); 1300 grid_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1283 if (res) 1301 if (res)
1284 goto ERROR3; 1302 goto ERROR3;
1285 psiconv_debug(lev+2,off+len,"Offset: %04x",grid_off); 1303 psiconv_debug(config,lev+2,off+len,"Offset: %04x",grid_off);
1286 len += 4; 1304 len += 4;
1287 1305
1288 psiconv_progress(lev+2,off+len, 1306 psiconv_progress(config,lev+2,off+len,
1289 "Going to read the offset of the 3rd ??? Section"); 1307 "Going to read the offset of the 3rd ??? Section");
1290 unknown_off = psiconv_read_u32(buf,lev+2,off+len,&res); 1308 unknown_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1291 if (res) 1309 if (res)
1292 goto ERROR3; 1310 goto ERROR3;
1293 psiconv_debug(lev+2,off+len,"Offset: %04x",unknown_off); 1311 psiconv_debug(config,lev+2,off+len,"Offset: %04x",unknown_off);
1294 len += 4; 1312 len += 4;
1295 1313
1296 psiconv_progress(lev+2,off+len, 1314 psiconv_progress(config,lev+2,off+len,
1297 "Going to read a long of the 3rd ??? Section " 1315 "Going to read a long of the 3rd ??? Section "
1298 "(%08x expected)",0x00); 1316 "(%08x expected)",0x00);
1299 temp = psiconv_read_u32(buf,lev+2,unknown_off,&res); 1317 temp = psiconv_read_u32(config,buf,lev+2,unknown_off,&res);
1300 if (res) 1318 if (res)
1301 goto ERROR3; 1319 goto ERROR3;
1302 if (temp != 0x00) { 1320 if (temp != 0x00) {
1303 psiconv_warn(lev+2,unknown_off, 1321 psiconv_warn(config,lev+2,unknown_off,
1304 "Unknown worksheet subsection has unknown contents (ignored)"); 1322 "Unknown worksheet subsection has unknown contents (ignored)");
1305 psiconv_debug(lev+2,unknown_off,"Offset: %04x",temp); 1323 psiconv_debug(config,lev+2,unknown_off,"Offset: %04x",temp);
1306 } 1324 }
1307 len += 4; 1325 len += 4;
1308 1326
1309 psiconv_progress(lev+2,off+len,"Going to read the row defaults"); 1327 psiconv_progress(config,lev+2,off+len,"Going to read the row defaults");
1310 if ((res = psiconv_parse_sheet_line_list(buf,lev+2,rows_off,NULL, 1328 if ((res = psiconv_parse_sheet_line_list(config,buf,lev+2,rows_off,NULL,
1311 &(*result)->row_default_layouts, 1329 &(*result)->row_default_layouts,
1312 (*result)->default_layout))) 1330 (*result)->default_layout)))
1313 goto ERROR3; 1331 goto ERROR3;
1314 1332
1315 psiconv_progress(lev+2,off+len,"Going to read the column defaults"); 1333 psiconv_progress(config,lev+2,off+len,"Going to read the column defaults");
1316 if ((res = psiconv_parse_sheet_line_list(buf,lev+2,cols_off,NULL, 1334 if ((res = psiconv_parse_sheet_line_list(config,buf,lev+2,cols_off,NULL,
1317 &(*result)->col_default_layouts, 1335 &(*result)->col_default_layouts,
1318 (*result)->default_layout))) 1336 (*result)->default_layout)))
1319 goto ERROR4; 1337 goto ERROR4;
1320 1338
1321 psiconv_progress(lev+2,off+len,"Going to read the cells list"); 1339 psiconv_progress(config,lev+2,off+len,"Going to read the cells list");
1322 if ((res = psiconv_parse_sheet_cell_list(buf,lev+2,cells_off,NULL, 1340 if ((res = psiconv_parse_sheet_cell_list(config,buf,lev+2,cells_off,NULL,
1323 &(*result)->cells, 1341 &(*result)->cells,
1324 (*result)->default_layout, 1342 (*result)->default_layout,
1325 (*result)->row_default_layouts, 1343 (*result)->row_default_layouts,
1326 (*result)->col_default_layouts))) 1344 (*result)->col_default_layouts)))
1327 goto ERROR5; 1345 goto ERROR5;
1328 1346
1329 1347
1330/* TODO: parse grid section */ 1348 psiconv_progress(config,lev+2,off+len,"Going to read the grid section");
1349 if ((res = psiconv_parse_sheet_grid_section(config,buf,lev+2,grid_off,NULL,
1350 &(*result)->grid)))
1351 goto ERROR6;
1352
1353
1331 1354
1332 if (length) 1355 if (length)
1333 *length = len; 1356 *length = len;
1334 1357
1335 psiconv_progress(lev,off+len-1, 1358 psiconv_progress(config,lev,off+len-1,
1336 "End of sheet worksheet section (total length: %08x)", len); 1359 "End of sheet worksheet section (total length: %08x)", len);
1337 return 0; 1360 return 0;
1338 1361
1362ERROR6:
1363 psiconv_free_sheet_cell_list((*result)->cells);
1339ERROR5: 1364ERROR5:
1340 psiconv_free_sheet_line_list((*result)->col_default_layouts); 1365 psiconv_free_sheet_line_list((*result)->col_default_layouts);
1341ERROR4: 1366ERROR4:
1342 psiconv_free_sheet_line_list((*result)->row_default_layouts); 1367 psiconv_free_sheet_line_list((*result)->row_default_layouts);
1343ERROR3: 1368ERROR3:
1344 psiconv_free_sheet_cell_layout((*result)->default_layout); 1369 psiconv_free_sheet_cell_layout((*result)->default_layout);
1345ERROR2: 1370ERROR2:
1346 free (*result); 1371 free (*result);
1347ERROR1: 1372ERROR1:
1348 psiconv_warn(lev+1,off,"Reading of Sheet Worksheet Section failed"); 1373 psiconv_warn(config,lev+1,off,"Reading of Sheet Worksheet Section failed");
1349 if (length) 1374 if (length)
1350 *length = 0; 1375 *length = 0;
1351 if (!res) 1376 if (!res)
1352 return -PSICONV_E_NOMEM; 1377 return -PSICONV_E_NOMEM;
1353 else 1378 else
1354 return res; 1379 return res;
1355} 1380}
1356 1381
1357int psiconv_parse_sheet_line(const psiconv_buffer buf, int lev, 1382int psiconv_parse_sheet_line(const psiconv_config config,
1383 const psiconv_buffer buf, int lev,
1358 psiconv_u32 off, int *length, 1384 psiconv_u32 off, int *length,
1359 psiconv_sheet_line *result, 1385 psiconv_sheet_line *result,
1360 const psiconv_sheet_cell_layout default_layout) 1386 const psiconv_sheet_cell_layout default_layout)
1361{ 1387{
1362 int res=0; 1388 int res=0;
1363 int len=0; 1389 int len=0;
1364 int leng; 1390 int leng;
1365 1391
1366 1392
1367 psiconv_progress(lev+1,off,"Going to read a sheet line"); 1393 psiconv_progress(config,lev+1,off,"Going to read a sheet line");
1368 if (!(*result = malloc(sizeof(**result)))) 1394 if (!(*result = malloc(sizeof(**result))))
1369 goto ERROR1; 1395 goto ERROR1;
1370 1396
1371 psiconv_progress(lev+2,off+len,"Going to read the line number"); 1397 psiconv_progress(config,lev+2,off+len,"Going to read the line number");
1372 (*result)->position = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 1398 (*result)->position = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1373 if (res) 1399 if (res)
1374 goto ERROR2; 1400 goto ERROR2;
1375 psiconv_debug(lev+2,off+len,"Line number: %d\n",(*result)->position); 1401 psiconv_debug(config,lev+2,off+len,"Line number: %d\n",(*result)->position);
1376 len += leng; 1402 len += leng;
1377 1403
1378 if (!((*result)->layout = psiconv_clone_cell_layout(default_layout))) 1404 if (!((*result)->layout = psiconv_clone_cell_layout(default_layout)))
1379 goto ERROR2; 1405 goto ERROR2;
1380 if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len, 1406 if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,
1381 &leng,(*result)->layout))) 1407 &leng,(*result)->layout)))
1382 goto ERROR3; 1408 goto ERROR3;
1383 len += leng; 1409 len += leng;
1384 1410
1385 if (length) 1411 if (length)
1386 *length = len; 1412 *length = len;
1387 1413
1388 psiconv_progress(lev,off+len-1, 1414 psiconv_progress(config,lev,off+len-1,
1389 "End of the sheet line (total length: %08x)", len); 1415 "End of the sheet line (total length: %08x)", len);
1390 return 0; 1416 return 0;
1391 1417
1392ERROR3: 1418ERROR3:
1393 psiconv_free_sheet_cell_layout((*result)->layout); 1419 psiconv_free_sheet_cell_layout((*result)->layout);
1394ERROR2: 1420ERROR2:
1395 free (*result); 1421 free (*result);
1396ERROR1: 1422ERROR1:
1397 psiconv_warn(lev+1,off,"Reading of the sheet line failed"); 1423 psiconv_warn(config,lev+1,off,"Reading of the sheet line failed");
1398 if (length) 1424 if (length)
1399 *length = 0; 1425 *length = 0;
1400 if (!res) 1426 if (!res)
1401 return -PSICONV_E_NOMEM; 1427 return -PSICONV_E_NOMEM;
1402 else 1428 else
1403 return res; 1429 return res;
1404} 1430}
1405 1431
1406 1432
1407int psiconv_parse_sheet_line_list(const psiconv_buffer buf, int lev, 1433int psiconv_parse_sheet_line_list(const psiconv_config config,
1434 const psiconv_buffer buf, int lev,
1408 psiconv_u32 off, int *length, 1435 psiconv_u32 off, int *length,
1409 psiconv_sheet_line_list *result, 1436 psiconv_sheet_line_list *result,
1410 const psiconv_sheet_cell_layout default_layout) 1437 const psiconv_sheet_cell_layout default_layout)
1411{ 1438{
1412 int res=0; 1439 int res=0;
… …
1414 psiconv_u32 temp; 1441 psiconv_u32 temp;
1415 psiconv_sheet_line line; 1442 psiconv_sheet_line line;
1416 psiconv_u32 listlen,i; 1443 psiconv_u32 listlen,i;
1417 int leng; 1444 int leng;
1418 1445
1419 psiconv_progress(lev+1,off,"Going to read the sheet line list"); 1446 psiconv_progress(config,lev+1,off,"Going to read the sheet line list");
1420 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_line_s)))) 1447 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_line_s))))
1421 goto ERROR1; 1448 goto ERROR1;
1422 1449
1423 psiconv_progress(lev+2,off+len, 1450 psiconv_progress(config,lev+2,off+len,
1424 "Going to read the initial byte (%02x expected)",0x02); 1451 "Going to read the initial byte (%02x expected)",0x02);
1425 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1452 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1426 if (res) 1453 if (res)
1427 goto ERROR2; 1454 goto ERROR2;
1428 if (temp != 0x02) { 1455 if (temp != 0x02) {
1429 psiconv_warn(lev+2,off+len, 1456 psiconv_warn(config,lev+2,off+len,
1430 "Sheet line list initial byte unknown value (ignored)"); 1457 "Sheet line list initial byte unknown value (ignored)");
1431 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1458 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1432 } 1459 }
1433 len ++; 1460 len ++;
1434 1461
1435 psiconv_progress(lev+2,off+len, 1462 psiconv_progress(config,lev+2,off+len,
1436 "Going to read the number of defined lines"); 1463 "Going to read the number of defined lines");
1437 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 1464 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1438 if (res) 1465 if (res)
1439 goto ERROR2; 1466 goto ERROR2;
1440 psiconv_debug(lev+2,off+len,"Number of defined lines: %d",listlen); 1467 psiconv_debug(config,lev+2,off+len,"Number of defined lines: %d",listlen);
1441 len += leng; 1468 len += leng;
1442 1469
1443 psiconv_progress(lev+2,off+len,"Going to read all lines"); 1470 psiconv_progress(config,lev+2,off+len,"Going to read all lines");
1444 for (i = 0; i < listlen; i++) { 1471 for (i = 0; i < listlen; i++) {
1445 psiconv_progress(lev+3,off+len,"Going to read line %d",i); 1472 psiconv_progress(config,lev+3,off+len,"Going to read line %d",i);
1446 if ((res = psiconv_parse_sheet_line(buf,lev+3,off+len,&leng,&line, 1473 if ((res = psiconv_parse_sheet_line(config,buf,lev+3,off+len,&leng,&line,
1447 default_layout))) 1474 default_layout)))
1448 goto ERROR2; 1475 goto ERROR2;
1449 if ((res = psiconv_list_add(*result,line))) 1476 if ((res = psiconv_list_add(*result,line)))
1450 goto ERROR3; 1477 goto ERROR3;
1451 free(line); 1478 free(line);
… …
1453 } 1480 }
1454 1481
1455 if (length) 1482 if (length)
1456 *length = len; 1483 *length = len;
1457 1484
1458 psiconv_progress(lev,off+len-1, 1485 psiconv_progress(config,lev,off+len-1,
1459 "End of sheet line list (total length: %08x)", len); 1486 "End of sheet line list (total length: %08x)", len);
1460 return 0; 1487 return 0;
1461 1488
1462ERROR3: 1489ERROR3:
1463 psiconv_free_sheet_line(line); 1490 psiconv_free_sheet_line(line);
1464ERROR2: 1491ERROR2:
1465 psiconv_free_sheet_line_list(*result); 1492 psiconv_free_sheet_line_list(*result);
1466ERROR1: 1493ERROR1:
1467 psiconv_warn(lev+1,off,"Reading of Sheet Line List failed"); 1494 psiconv_warn(config,lev+1,off,"Reading of Sheet Line List failed");
1468 if (length) 1495 if (length)
1469 *length = 0; 1496 *length = 0;
1470 if (!res) 1497 if (!res)
1471 return -PSICONV_E_NOMEM; 1498 return -PSICONV_E_NOMEM;
1472 else 1499 else
1473 return res; 1500 return res;
1474} 1501}
1475 1502
1476int psiconv_parse_sheet_variable(const psiconv_buffer buf, int lev, 1503int psiconv_parse_sheet_variable(const psiconv_config config,
1504 const psiconv_buffer buf, int lev,
1477 psiconv_u32 off, int *length, 1505 psiconv_u32 off, int *length,
1478 psiconv_sheet_variable *result) 1506 psiconv_sheet_variable *result)
1479{ 1507{
1480 int res=0; 1508 int res=0;
1481 int len=0; 1509 int len=0;
1482 psiconv_u32 marker; 1510 psiconv_u32 marker;
1483 int leng; 1511 int leng;
1484 1512
1485 psiconv_progress(lev+1,off,"Going to read a sheet variable"); 1513 psiconv_progress(config,lev+1,off,"Going to read a sheet variable");
1486 if (!(*result = malloc(sizeof(**result)))) 1514 if (!(*result = malloc(sizeof(**result))))
1487 goto ERROR1; 1515 goto ERROR1;
1488 1516
1489 psiconv_progress(lev+2,off+len, "Going to read the variable name"); 1517 psiconv_progress(config,lev+2,off+len, "Going to read the variable name");
1490 (*result)->name = psiconv_read_string(buf,lev+2,off+len,&leng,&res); 1518 (*result)->name = psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
1491 if (res) 1519 if (res)
1492 goto ERROR2; 1520 goto ERROR2;
1493 len += leng; 1521 len += leng;
1494 1522
1495 psiconv_progress(lev+2,off+len,"Going to read the type marker"); 1523 psiconv_progress(config,lev+2,off+len,"Going to read the type marker");
1496 marker = psiconv_read_u8(buf,lev+2,off+len,&res); 1524 marker = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1497 if (res) 1525 if (res)
1498 goto ERROR3; 1526 goto ERROR3;
1499 psiconv_debug(lev+2,off+len,"Marker: %02x",marker); 1527 psiconv_debug(config,lev+2,off+len,"Marker: %02x",marker);
1500 len ++; 1528 len ++;
1501 1529
1502 if (marker == 0x00) { 1530 if (marker == 0x00) {
1503 (*result)->type = psiconv_var_int; 1531 (*result)->type = psiconv_var_int;
1504 psiconv_progress(lev+2,off+len,"Going to read a signed integer"); 1532 psiconv_progress(config,lev+2,off+len,"Going to read a signed integer");
1505 (*result)->data.dat_int = psiconv_read_sint(buf,lev+2,off+len,&leng,&res); 1533 (*result)->data.dat_int = psiconv_read_sint(config,buf,lev+2,off+len,&leng,&res);
1506 if (res) 1534 if (res)
1507 goto ERROR3; 1535 goto ERROR3;
1508 psiconv_debug(lev+2,off+len,"Value: %d",(*result)->data.dat_int); 1536 psiconv_debug(config,lev+2,off+len,"Value: %d",(*result)->data.dat_int);
1509 len += leng; 1537 len += leng;
1510 } else if (marker == 0x01) { 1538 } else if (marker == 0x01) {
1511 (*result)->type = psiconv_var_float; 1539 (*result)->type = psiconv_var_float;
1512 psiconv_progress(lev+2,off+len,"Going to read a floating point number"); 1540 psiconv_progress(config,lev+2,off+len,"Going to read a floating point number");
1513 (*result)->data.dat_float = psiconv_read_float(buf,lev+2,off+len,&leng, 1541 (*result)->data.dat_float = psiconv_read_float(config,buf,lev+2,off+len,&leng,
1514 &res); 1542 &res);
1515 if (res) 1543 if (res)
1516 goto ERROR3; 1544 goto ERROR3;
1517 psiconv_debug(lev+2,off+len,"Value: %f",(*result)->data.dat_float); 1545 psiconv_debug(config,lev+2,off+len,"Value: %f",(*result)->data.dat_float);
1518 len += leng; 1546 len += leng;
1519 } else if (marker == 0x02) { 1547 } else if (marker == 0x02) {
1520 (*result)->type = psiconv_var_string; 1548 (*result)->type = psiconv_var_string;
1521 psiconv_progress(lev+2,off+len,"Going to read a string"); 1549 psiconv_progress(config,lev+2,off+len,"Going to read a string");
1522 (*result)->data.dat_string = psiconv_read_string(buf,lev+2,off+len,&leng, 1550 (*result)->data.dat_string = psiconv_read_string(config,buf,lev+2,off+len,&leng,
1523 &res); 1551 &res);
1524 if (res) 1552 if (res)
1525 goto ERROR3; 1553 goto ERROR3;
1526 len += leng; 1554 len += leng;
1527 } else if (marker == 0x03) { 1555 } else if (marker == 0x03) {
1528 (*result)->type = psiconv_var_cellref; 1556 (*result)->type = psiconv_var_cellref;
1529 psiconv_progress(lev+2,off+len,"Going to read a cell reference"); 1557 psiconv_progress(config,lev+2,off+len,"Going to read a cell reference");
1530 (*result)->data.dat_cellref = psiconv_read_var_cellref(buf,lev+2,off+len, 1558 (*result)->data.dat_cellref = psiconv_read_var_cellref(config,buf,lev+2,off+len,
1531 &leng, &res); 1559 &leng, &res);
1532 if (res) 1560 if (res)
1533 goto ERROR3; 1561 goto ERROR3;
1534 len += leng; 1562 len += leng;
1535 } else if (marker == 0x04) { 1563 } else if (marker == 0x04) {
1536 (*result)->type = psiconv_var_cellblock; 1564 (*result)->type = psiconv_var_cellblock;
1537 psiconv_progress(lev+2,off+len,"Going to read a cell block reference"); 1565 psiconv_progress(config,lev+2,off+len,"Going to read a cell block reference");
1538 (*result)->data.dat_cellblock = psiconv_read_var_cellblock(buf,lev+2, 1566 (*result)->data.dat_cellblock = psiconv_read_var_cellblock(config,buf,lev+2,
1539 off+len, 1567 off+len,
1540 &leng, &res); 1568 &leng, &res);
1541 if (res) 1569 if (res)
1542 goto ERROR3; 1570 goto ERROR3;
1543 len += leng; 1571 len += leng;
1544 } else { 1572 } else {
1545 psiconv_warn(lev+2,off+len,"Sheet variable unknown type marker"); 1573 psiconv_warn(config,lev+2,off+len,"Sheet variable unknown type marker");
1546 res = -PSICONV_E_PARSE; 1574 res = -PSICONV_E_PARSE;
1547 goto ERROR3; 1575 goto ERROR3;
1548 } 1576 }
1549 1577
1550 psiconv_progress(lev+2,off+len,"Going to read the variable number"); 1578 psiconv_progress(config,lev+2,off+len,"Going to read the variable number");
1551 (*result)->number = psiconv_read_u32(buf,lev+2,off+len,&res); 1579 (*result)->number = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1552 if (res) 1580 if (res)
1553 goto ERROR4; 1581 goto ERROR4;
1554 psiconv_debug(lev+2,off+len,"Number: %08x",(*result)->number); 1582 psiconv_debug(config,lev+2,off+len,"Number: %08x",(*result)->number);
1555 len += 4; 1583 len += 4;
1556 1584
1557 if (length) 1585 if (length)
1558 *length = len; 1586 *length = len;
1559 1587
1560 psiconv_progress(lev,off+len-1, 1588 psiconv_progress(config,lev,off+len-1,
1561 "End of sheet variable (total length: %08x)", len); 1589 "End of sheet variable (total length: %08x)", len);
1562 return 0; 1590 return 0;
1563 1591
1564ERROR4: 1592ERROR4:
1565 if ((*result)->type == psiconv_var_string) 1593 if ((*result)->type == psiconv_var_string)
… …
1567ERROR3: 1595ERROR3:
1568 free((*result)->name); 1596 free((*result)->name);
1569ERROR2: 1597ERROR2:
1570 free (*result); 1598 free (*result);
1571ERROR1: 1599ERROR1:
1572 psiconv_warn(lev+1,off,"Reading of Sheet Variable failed"); 1600 psiconv_warn(config,lev+1,off,"Reading of Sheet Variable failed");
1573 if (length) 1601 if (length)
1574 *length = 0; 1602 *length = 0;
1575 if (!res) 1603 if (!res)
1576 return -PSICONV_E_NOMEM; 1604 return -PSICONV_E_NOMEM;
1577 else 1605 else
1578 return res; 1606 return res;
1579} 1607}
1580 1608
1581 1609
1582int psiconv_parse_sheet_variable_list(const psiconv_buffer buf, int lev, 1610int psiconv_parse_sheet_variable_list(const psiconv_config config,
1611 const psiconv_buffer buf, int lev,
1583 psiconv_u32 off, int *length, 1612 psiconv_u32 off, int *length,
1584 psiconv_sheet_variable_list *result) 1613 psiconv_sheet_variable_list *result)
1585{ 1614{
1586 int res=0; 1615 int res=0;
1587 int len=0; 1616 int len=0;
1588 psiconv_u32 temp; 1617 psiconv_u32 temp;
1589 psiconv_sheet_variable variable; 1618 psiconv_sheet_variable variable;
1590 psiconv_u32 listlen,i; 1619 psiconv_u32 listlen,i;
1591 int leng; 1620 int leng;
1592 1621
1593 psiconv_progress(lev+1,off,"Going to read the sheet variable list"); 1622 psiconv_progress(config,lev+1,off,"Going to read the sheet variable list");
1594 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_variable_s)))) 1623 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_variable_s))))
1595 goto ERROR1; 1624 goto ERROR1;
1596 1625
1597 psiconv_progress(lev+2,off+len, 1626 psiconv_progress(config,lev+2,off+len,
1598 "Going to read the initial byte (%02x expected)",0x02); 1627 "Going to read the initial byte (%02x expected)",0x02);
1599 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 1628 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1600 if (res) 1629 if (res)
1601 goto ERROR2; 1630 goto ERROR2;
1602 if (temp != 0x02) { 1631 if (temp != 0x02) {
1603 psiconv_warn(lev+2,off+len, 1632 psiconv_warn(config,lev+2,off+len,
1604 "Sheet variable list initial byte unknown value (ignored)"); 1633 "Sheet variable list initial byte unknown value (ignored)");
1605 psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp); 1634 psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1606 } 1635 }
1607 len ++; 1636 len ++;
1608 1637
1609 psiconv_progress(lev+2,off+len, 1638 psiconv_progress(config,lev+2,off+len,
1610 "Going to read the number of variables"); 1639 "Going to read the number of variables");
1611 listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res); 1640 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1612 if (res) 1641 if (res)
1613 goto ERROR2; 1642 goto ERROR2;
1614 psiconv_debug(lev+2,off+len,"Number of variables: %d",listlen); 1643 psiconv_debug(config,lev+2,off+len,"Number of variables: %d",listlen);
1615 len += leng; 1644 len += leng;
1616 1645
1617 psiconv_progress(lev+2,off+len,"Going to read all variables"); 1646 psiconv_progress(config,lev+2,off+len,"Going to read all variables");
1618 for (i = 0; i < listlen; i++) { 1647 for (i = 0; i < listlen; i++) {
1619 psiconv_progress(lev+3,off+len,"Going to read variable %d",i); 1648 psiconv_progress(config,lev+3,off+len,"Going to read variable %d",i);
1620 if ((res = psiconv_parse_sheet_variable(buf,lev+3,off+len,&leng,&variable))) 1649 if ((res = psiconv_parse_sheet_variable(config,buf,lev+3,off+len,&leng,&variable)))
1621 goto ERROR2; 1650 goto ERROR2;
1622 if ((res = psiconv_list_add(*result,variable))) 1651 if ((res = psiconv_list_add(*result,variable)))
1623 goto ERROR3; 1652 goto ERROR3;
1624 len += leng; 1653 len += leng;
1625 } 1654 }
1626 1655
1627 if (length) 1656 if (length)
1628 *length = len; 1657 *length = len;
1629 1658
1630 psiconv_progress(lev,off+len-1, 1659 psiconv_progress(config,lev,off+len-1,
1631 "End of sheet variabels list (total length: %08x)", len); 1660 "End of sheet variabels list (total length: %08x)", len);
1632 return 0; 1661 return 0;
1633 1662
1634ERROR3: 1663ERROR3:
1635 psiconv_free_sheet_variable(variable); 1664 psiconv_free_sheet_variable(variable);
1636ERROR2: 1665ERROR2:
1637 psiconv_list_free(*result); 1666 psiconv_list_free(*result);
1638ERROR1: 1667ERROR1:
1639 psiconv_warn(lev+1,off,"Reading of Sheet Variable list failed"); 1668 psiconv_warn(config,lev+1,off,"Reading of Sheet Variable list failed");
1640 if (length) 1669 if (length)
1641 *length = 0; 1670 *length = 0;
1642 if (!res) 1671 if (!res)
1643 return -PSICONV_E_NOMEM; 1672 return -PSICONV_E_NOMEM;
1644 else 1673 else
1645 return res; 1674 return res;
1646} 1675}
1676
1677int psiconv_parse_sheet_grid_section(const psiconv_config config,
1678 const psiconv_buffer buf, int lev,
1679 psiconv_u32 off, int *length,
1680 psiconv_sheet_grid_section *result)
1681{
1682 int res=0,i;
1683 int len=0,leng;
1684 psiconv_u32 temp;
1685
1686 psiconv_progress(config,lev+1,off,"Going to read the sheet grid section");
1687 if (!(*result = malloc(sizeof(**result))))
1688 goto ERROR1;
1689
1690 psiconv_progress(config,lev+2,off+len, "Going to read the first flags byte");
1691 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1692 if (res)
1693 goto ERROR2;
1694 (*result)->show_column_titles = temp&0x01?psiconv_bool_true:
1695 psiconv_bool_false;
1696 psiconv_debug(config,lev+2,off+len,
1697 "Show column titles: %s",
1698 (*result)->show_column_titles?"true":"false");
1699 (*result)->show_row_titles = temp&0x02?psiconv_bool_true:psiconv_bool_false;
1700 psiconv_debug(config,lev+2,off+len,
1701 "Show row titles: %s",
1702 (*result)->show_row_titles?"true":"false");
1703 (*result)->show_vertical_grid = temp&0x04?psiconv_bool_true:
1704 psiconv_bool_false;
1705 psiconv_debug(config,lev+2,off+len,
1706 "Show vertical grid: %s",
1707 (*result)->show_vertical_grid?"true":"false");
1708 (*result)->show_horizontal_grid = temp&0x07?psiconv_bool_true:
1709 psiconv_bool_false;
1710 psiconv_debug(config,lev+2,off+len,
1711 "Show horizontal grid: %s",
1712 (*result)->show_horizontal_grid?"true":"false");
1713 (*result)->freeze_rows = temp&0x80?psiconv_bool_true:psiconv_bool_false;
1714 psiconv_debug(config,lev+2,off+len,
1715 "Freeze rows: %s",
1716 (*result)->freeze_rows?"true":"false");
1717 if ((temp & 0x70) != 0x30) {
1718 psiconv_warn(config,lev+2,off+len,
1719 "Grid section first flag byte has unknown bits (ignored)");
1720 psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0x70,0x30);
1721 }
1722 len ++;
1723
1724 psiconv_progress(config,lev+2,off+len, "Going to read the second flags byte");
1725 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1726 if (res)
1727 goto ERROR2;
1728 (*result)->freeze_columns = temp&0x01?psiconv_bool_true:psiconv_bool_false;
1729 psiconv_debug(config,lev+2,off+len,
1730 "Freeze columns: %s", (*result)->freeze_columns?"true":"false");
1731 if ((temp & 0xfe) != 0x80) {
1732 psiconv_warn(config,lev+2,off+len,
1733 "Grid section second flag byte has unknown bits (ignored)");
1734 psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0xfe,0x80);
1735 }
1736 len ++;
1737
1738 psiconv_progress(config,lev+2,off+len,
1739 "Going to an unknown byte (%02x expected)",0x90);
1740 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1741 if (res)
1742 goto ERROR2;
1743 if (temp != 0x90) {
1744 psiconv_warn(config,lev+2,off+len,
1745 "Grid section third byte unknown value (ignored)");
1746 psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
1747 }
1748 len ++;
1749
1750 psiconv_progress(config,lev+2,off+len, "Going to read the fourth flags byte");
1751 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1752 if (res)
1753 goto ERROR2;
1754 (*result)->show_page_breaks = temp&0x04?psiconv_bool_true:psiconv_bool_false;
1755 psiconv_debug(config,lev+2,off+len,
1756 "Show page breaks: %s",
1757 (*result)->show_page_breaks?"true":"false");
1758 if ((temp & 0xfc) != 0x00) {
1759 psiconv_warn(config,lev+2,off+len,
1760 "Grid section fourth flag byte has unknown bits (ignored)");
1761 psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0xfc,0x00);
1762 }
1763 len ++;
1764
1765 psiconv_progress(config,lev+2,off+len,"Going to read the first visible row");
1766 (*result)->first_row = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1767 if (res)
1768 goto ERROR2;
1769 psiconv_debug(config,lev+2,off+len,"First row: %d",(*result)->first_row);
1770 len += 4;
1771
1772 psiconv_progress(config,lev+2,off+len,"Going to read the first visible column");
1773 (*result)->first_column = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1774 if (res)
1775 goto ERROR2;
1776 psiconv_debug(config,lev+2,off+len,"First column: %d",(*result)->first_column);
1777 len += 4;
1778
1779 psiconv_progress(config,lev+2,off+len,"Going to read the last visible row");
1780 (*result)->last_row = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1781 if (res)
1782 goto ERROR2;
1783 psiconv_debug(config,lev+2,off+len,"Last row: %d",(*result)->last_row);
1784 len += 4;
1785
1786 psiconv_progress(config,lev+2,off+len,"Going to read the last visible column");
1787 (*result)->last_column = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1788 if (res)
1789 goto ERROR2;
1790 psiconv_debug(config,lev+2,off+len,"Last column: %d",(*result)->last_column);
1791 len += 4;
1792
1793 psiconv_progress(config,lev+2,off+len,"Going to read the default row height");
1794 (*result)->default_row_height = psiconv_read_length(config,buf,lev+2,off+len,
1795 &leng,&res);
1796 if (res)
1797 goto ERROR2;
1798 psiconv_debug(config,lev+2,off+len,"Default row height: %f",
1799 (*result)->default_row_height);
1800 len += leng;
1801
1802 psiconv_progress(config,lev+2,off+len,"Going to read the row heights list");
1803 if ((res = psiconv_parse_sheet_grid_size_list(config,buf,lev+2,off+len,&leng,
1804 &(*result)->row_heights)))
1805 goto ERROR2;
1806 len += leng;
1807
1808 psiconv_progress(config,lev+2,off+len,"Going to read the default column height");
1809 (*result)->default_column_width = psiconv_read_length(config,buf,lev+2,off+len,
1810 &leng,&res);
1811 if (res)
1812 goto ERROR3;
1813 psiconv_debug(config,lev+2,off+len,"Default column width: %f",
1814 (*result)->default_column_width);
1815 len += leng;
1816
1817 psiconv_progress(config,lev+2,off+len,"Going to read the column heights list");
1818 if ((res = psiconv_parse_sheet_grid_size_list(config,buf,lev+2,off+len,&leng,
1819 &(*result)->column_heights)))
1820 goto ERROR3;
1821 len += leng;
1822
1823 psiconv_progress(config,lev+2,off+len,
1824 "Going to read an unknown word (%04x expected)",0x00);
1825 temp = psiconv_read_u16(config,buf,lev+2,off+len,&res);
1826 if (res)
1827 goto ERROR4;
1828 if (temp != 0x00) {
1829 psiconv_warn(config,lev+2,off+len,
1830 "Grid section unknown word has unknown value (ignored)");
1831 psiconv_debug(config,lev+2,off+len,"Value: %04x",temp);
1832 }
1833 len += 2;
1834
1835 psiconv_progress(config,lev+2,off+len,"Going to read the row breaks list");
1836 if ((res = psiconv_parse_sheet_grid_break_list(config,buf,lev+2,off+len,&leng,
1837 &(*result)->row_page_breaks)))
1838 goto ERROR4;
1839 len += leng;
1840
1841 psiconv_progress(config,lev+2,off+len,"Going to read the column breaks list");
1842 if ((res = psiconv_parse_sheet_grid_break_list(config,buf,lev+2,off+len,&leng,
1843 &(*result)->column_page_breaks)))
1844 goto ERROR5;
1845 len += leng;
1846
1847
1848 psiconv_progress(config,lev+2,off+len,
1849 "Going to read 22 unknown bytes (%02x expected)",0x00);
1850 for (i = 0; i < 22 ; i++) {
1851 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1852 if (res)
1853 goto ERROR6;
1854 if (temp != 0x00) {
1855 psiconv_warn(config,lev+2,off+len,
1856 "Grid section unknown byte %d has unknown value (ignored)",
1857 i);
1858 psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
1859 }
1860 len += 1;
1861 }
1862
1863 if ((*result)->freeze_rows || (*result)->freeze_columns) {
1864
1865 psiconv_progress(config,lev+2,off+len,"Going to read number of frozen rows");
1866 (*result)->frozen_rows = psiconv_read_u32(config,buf,lev+2,off+len, &res);
1867 if (res)
1868 goto ERROR6;
1869 psiconv_debug(config,lev+2,off+len,"Number of frozen rows: %d",
1870 (*result)->frozen_rows);
1871 len += leng;
1872
1873 psiconv_progress(config,lev+2,off+len,"Going to read number of frozen columns");
1874 (*result)->frozen_columns = psiconv_read_u32(config,buf,lev+2,off+len, &res);
1875 if (res)
1876 goto ERROR6;
1877 psiconv_debug(config,lev+2,off+len,"Number of frozen columns: %d",
1878 (*result)->frozen_columns);
1879 len += leng;
1880
1881 psiconv_progress(config,lev+2,off+len,"Going to read first unfrozen row");
1882 (*result)->first_unfrozen_row_displayed = psiconv_read_u32(config,buf,lev+2,
1883 off+len, &res);
1884 if (res)
1885 goto ERROR6;
1886 psiconv_debug(config,lev+2,off+len,"First row: %d",
1887 (*result)->first_unfrozen_row_displayed);
1888 len += leng;
1889
1890 psiconv_progress(config,lev+2,off+len,"Going to read first unfrozen column");
1891 (*result)->first_unfrozen_column_displayed = psiconv_read_u32(config,buf,lev+2,
1892 off+len,&res);
1893 if (res)
1894 goto ERROR6;
1895 psiconv_debug(config,lev+2,off+len,"First column: %d",
1896 (*result)->first_unfrozen_column_displayed);
1897 len += leng;
1898 } else
1899 (*result)->frozen_rows = (*result)->frozen_columns =
1900 (*result)->first_unfrozen_row_displayed =
1901 (*result)->first_unfrozen_column_displayed = 0;
1902
1903 psiconv_progress(config,lev+2,off+len,
1904 "Going to read 3 unknown bytes (%02x expected)",0xff);
1905 for (i = 0; i < 3 ; i++) {
1906 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1907 if (res)
1908 goto ERROR6;
1909 if (temp != 0xff) {
1910 psiconv_warn(config,lev+2,off+len,
1911 "Grid section unknown byte %d has unknown value (ignored)",
1912 i);
1913 psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
1914 }
1915 len ++;
1916 }
1917
1918 if (length)
1919 *length = len;
1920
1921 psiconv_progress(config,lev,off+len-1,
1922 "End of sheet grid section (total length: %08x)", len);
1923 return 0;
1924
1925ERROR6:
1926 psiconv_free_sheet_grid_break_list((*result)->column_page_breaks);
1927ERROR5:
1928 psiconv_free_sheet_grid_break_list((*result)->row_page_breaks);
1929ERROR4:
1930 psiconv_free_sheet_grid_size_list((*result)->column_heights);
1931ERROR3:
1932 psiconv_free_sheet_grid_size_list((*result)->row_heights);
1933ERROR2:
1934 free(*result);
1935ERROR1:
1936 psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Section failed");
1937 if (length)
1938 *length = 0;
1939 if (!res)
1940 return -PSICONV_E_NOMEM;
1941 else
1942 return res;
1943}
1944
1945
1946int psiconv_parse_sheet_grid_size_list(const psiconv_config config,
1947 const psiconv_buffer buf, int lev,
1948 psiconv_u32 off, int *length,
1949 psiconv_sheet_grid_size_list *result)
1950{
1951 int res=0;
1952 int len=0,i;
1953 int leng,listlen;
1954 psiconv_sheet_grid_size size;
1955
1956 psiconv_progress(config,lev+1,off,"Going to read a sheet grid size list");
1957 if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_grid_size_s))))
1958 goto ERROR1;
1959
1960 psiconv_progress(config,lev+2,off+len,
1961 "Going to read the number of elements");
1962 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1963 if (res)
1964 goto ERROR2;
1965 psiconv_debug(config,lev+2,off+len,"Number of elements: %d",listlen);
1966 len += leng;
1967
1968 psiconv_progress(config,lev+2,off+len,"Going to read all elements");
1969 for (i = 0; i < listlen; i++) {
1970 psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
1971 if ((res = psiconv_parse_sheet_grid_size(config,buf,lev+3,off+len,&leng,&size)))
1972 goto ERROR2;
1973 if ((res = psiconv_list_add(*result,size)))
1974 goto ERROR3;
1975 free(size);
1976 len += leng;
1977 }
1978
1979 if (length)
1980 *length = len;
1981
1982 psiconv_progress(config,lev,off+len-1,
1983 "End of sheet grid size list (total length: %08x)", len);
1984 return 0;
1985
1986ERROR3:
1987 psiconv_free_sheet_grid_size(size);
1988ERROR2:
1989 psiconv_list_free(*result);
1990ERROR1:
1991 psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Size List failed");
1992 if (length)
1993 *length = 0;
1994 if (!res)
1995 return -PSICONV_E_NOMEM;
1996 else
1997 return res;
1998}
1999
2000int psiconv_parse_sheet_grid_size(const psiconv_config config,
2001 const psiconv_buffer buf, int lev,
2002 psiconv_u32 off, int *length,
2003 psiconv_sheet_grid_size *result)
2004{
2005 int res=0;
2006 int len=0;
2007 int leng;
2008
2009 psiconv_progress(config,lev+1,off,"Going to read a sheet grid size");
2010
2011 if (!(*result = malloc(sizeof(**result))))
2012 goto ERROR1;
2013
2014 psiconv_progress(config,lev+2,off+len, "Going to read the row or column number");
2015 (*result)->line_number = psiconv_read_u32(config,buf,lev+2,off+len,&res);
2016 if (res)
2017 goto ERROR2;
2018 psiconv_debug(config,lev+2,off+len,"Line number: %d\n",(*result)->line_number);
2019 len += 4;
2020
2021 psiconv_progress(config,lev+2,off+len, "Going to read the row or column height");
2022 (*result)->size = psiconv_read_length(config,buf,lev+2,off+len,&leng,&res);
2023 if (res)
2024 goto ERROR2;
2025 psiconv_debug(config,lev+2,off+len,"Size: %f\n",(*result)->size);
2026 len += leng;
2027
2028 if (length)
2029 *length = len;
2030
2031 psiconv_progress(config,lev,off+len-1,
2032 "End of sheet grid size(total length: %08x)", len);
2033 return 0;
2034
2035ERROR2:
2036 free (*result);
2037ERROR1:
2038 psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Size failed");
2039 if (length)
2040 *length = 0;
2041 if (!res)
2042 return -PSICONV_E_NOMEM;
2043 else
2044 return res;
2045}
2046
2047
2048int psiconv_parse_sheet_grid_break_list(const psiconv_config config,
2049 const psiconv_buffer buf, int lev,
2050 psiconv_u32 off, int *length,
2051 psiconv_sheet_grid_break_list *result)
2052{
2053 int res=0;
2054 int len=0,i;
2055 int leng,listlen;
2056 psiconv_u32 nr;
2057
2058 psiconv_progress(config,lev+1,off,"Going to read a sheet grid break list");
2059 if (!(*result = psiconv_list_new(sizeof(psiconv_u32))))
2060 goto ERROR1;
2061
2062 psiconv_progress(config,lev+2,off+len,
2063 "Going to read the number of elements");
2064 listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
2065 if (res)
2066 goto ERROR2;
2067 psiconv_debug(config,lev+2,off+len,"Number of elements: %d",listlen);
2068 len += leng;
2069
2070 psiconv_progress(config,lev+2,off+len,"Going to read all elements");
2071 for (i = 0; i < listlen; i++) {
2072 psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
2073 nr = psiconv_read_u32(config,buf,lev+3,off+len,&res);
2074 if (res)
2075 goto ERROR2;
2076 if ((res = psiconv_list_add(*result,&nr)))
2077 goto ERROR2;
2078 len += leng;
2079 }
2080
2081 if (length)
2082 *length = len;
2083
2084 psiconv_progress(config,lev,off+len-1,
2085 "End of sheet grid break list (total length: %08x)", len);
2086 return 0;
2087
2088ERROR2:
2089 psiconv_list_free(*result);
2090ERROR1:
2091 psiconv_warn(config,lev+1,off,"Reading of Sheet Grid break List failed");
2092 if (length)
2093 *length = 0;
2094 if (!res)
2095 return -PSICONV_E_NOMEM;
2096 else
2097 return res;
2098}
2099
Legend:
Removed from v.133  
changed lines
  Added in v.168
frodo@frodo.looijaard.name
 ViewVC Help
Powered by ViewVC 1.1.26