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

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

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

Revision 129 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
31
27 32
28struct formula_element 33struct formula_element
29{ 34{
30 psiconv_formula_type_t formula_type; 35 psiconv_formula_type_t formula_type;
31 int number_of_args; 36 int number_of_args;
… …
286 {psiconv_formula_unknown,0,"*UNKNOWN*"}, 291 {psiconv_formula_unknown,0,"*UNKNOWN*"},
287 {psiconv_formula_unknown,0,"*UNKNOWN*"}, 292 {psiconv_formula_unknown,0,"*UNKNOWN*"},
288 {psiconv_formula_unknown,0,"*UNKNOWN*"}, 293 {psiconv_formula_unknown,0,"*UNKNOWN*"},
289 {psiconv_formula_unknown,0,"*UNKNOWN*"}}; 294 {psiconv_formula_unknown,0,"*UNKNOWN*"}};
290 295
291static int psiconv_parse_sheet_ref(const psiconv_buffer buf,int lev, 296static int psiconv_parse_sheet_ref(const psiconv_config config,
297 const psiconv_buffer buf,int lev,
292 psiconv_u32 off, int *length, 298 psiconv_u32 off, int *length,
293 psiconv_sheet_ref_t *result) 299 psiconv_sheet_ref_t *result)
294{ 300{
295 int res; 301 int res;
296 psiconv_u16 temp; 302 psiconv_u16 temp;
297 303
298 psiconv_progress(lev+1,off,"Going to read a sheet ref"); 304 psiconv_progress(config,lev+1,off,"Going to read a sheet ref");
299 psiconv_progress(lev+2,off,"Going to read the offset encoding"); 305 psiconv_progress(config,lev+2,off,"Going to read the offset encoding");
300 temp = psiconv_read_u16(buf,lev+2,off,&res); 306 temp = psiconv_read_u16(config,buf,lev+2,off,&res);
301 if (res) { 307 if (res) {
302 if (length) 308 if (length)
303 *length = 0; 309 *length = 0;
304 return res; 310 return res;
305 } 311 }
306 psiconv_debug(lev+2,off,"Encoded word: %04x",temp); 312 psiconv_debug(config,lev+2,off,"Encoded word: %04x",temp);
307 result->absolute = (temp & 0x4000)?psiconv_bool_true:psiconv_bool_false; 313 result->absolute = (temp & 0x4000)?psiconv_bool_true:psiconv_bool_false;
308 result->offset = (temp & 0x3fff) * ((temp & 0x8000)?-1:1); 314 result->offset = (temp & 0x3fff) * ((temp & 0x8000)?-1:1);
309 psiconv_debug(lev+2,off,"Reference: %s offset %d", 315 psiconv_debug(config,lev+2,off,"Reference: %s offset %d",
310 result->absolute?"absolute":"relative",result->offset); 316 result->absolute?"absolute":"relative",result->offset);
311 if (length) 317 if (length)
312 *length = 2; 318 *length = 2;
313 return 0; 319 return 0;
314} 320}
315 321
316static int psiconv_parse_sheet_cell_reference(const psiconv_buffer buf,int lev, 322static int psiconv_parse_sheet_cell_reference(const psiconv_config config,
323 const psiconv_buffer buf,int lev,
317 psiconv_u32 off, int *length, 324 psiconv_u32 off, int *length,
318 psiconv_sheet_cell_reference_t *result) 325 psiconv_sheet_cell_reference_t *result)
319{ 326{
320 int len = 0; 327 int len = 0;
321 int leng,res; 328 int leng,res;
322 psiconv_u8 temp; 329 psiconv_u8 temp;
323 330
324 psiconv_progress(lev+1,off+len,"Going to read a sheet cell reference"); 331 psiconv_progress(config,lev+1,off+len,"Going to read a sheet cell reference");
325 psiconv_progress(lev+2,off+len,"Going to read the row reference"); 332 psiconv_progress(config,lev+2,off+len,"Going to read the row reference");
326 if ((res = psiconv_parse_sheet_ref(buf,lev+2,off+len,&leng,&result->row))) 333 if ((res = psiconv_parse_sheet_ref(config,buf,lev+2,off+len,&leng,&result->row)))
327 goto ERROR; 334 goto ERROR;
328 len += leng; 335 len += leng;
329 psiconv_progress(lev+2,off+len,"Going to read the column reference"); 336 psiconv_progress(config,lev+2,off+len,"Going to read the column reference");
330 if ((res = psiconv_parse_sheet_ref(buf,lev+2,off+len,&leng,&result->column))) 337 if ((res = psiconv_parse_sheet_ref(config,buf,lev+2,off+len,&leng,&result->column)))
331 goto ERROR; 338 goto ERROR;
332 len += leng; 339 len += leng;
333 340
334 psiconv_progress(lev+2,off+len, 341 psiconv_progress(config,lev+2,off+len,
335 "Going to read the trailing byte (%02x expected)",0); 342 "Going to read the trailing byte (%02x expected)",0);
336 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 343 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
337 if (res) 344 if (res)
338 goto ERROR; 345 goto ERROR;
339 if (temp != 0) { 346 if (temp != 0) {
340 psiconv_warn(lev+2,off+len,"Unknown byte in cell reference (ignored"); 347 psiconv_warn(config,lev+2,off+len,"Unknown byte in cell reference (ignored");
341 psiconv_debug(lev+2,off+len,"Trailing byte: %02x",temp); 348 psiconv_debug(config,lev+2,off+len,"Trailing byte: %02x",temp);
342 } 349 }
343 len ++; 350 len ++;
344 psiconv_progress(lev,off+len-1, 351 psiconv_progress(config,lev,off+len-1,
345 "End of cell reference (total length: %08x)", len); 352 "End of cell reference (total length: %08x)", len);
346 if (length) 353 if (length)
347 *length = len; 354 *length = len;
348 return 0; 355 return 0;
349ERROR: 356ERROR:
350 if (length) 357 if (length)
351 *length = 0; 358 *length = 0;
352 return res; 359 return res;
353} 360}
354 361
355static int psiconv_parse_sheet_cell_block(const psiconv_buffer buf,int lev, 362static int psiconv_parse_sheet_cell_block(const psiconv_config config,
363 const psiconv_buffer buf,int lev,
356 psiconv_u32 off, int *length, 364 psiconv_u32 off, int *length,
357 psiconv_sheet_cell_block_t *result) 365 psiconv_sheet_cell_block_t *result)
358{ 366{
359 int len = 0; 367 int len = 0;
360 int leng,res; 368 int leng,res;
361 369
362 psiconv_progress(lev+1,off+len,"Going to read a sheet cell block"); 370 psiconv_progress(config,lev+1,off+len,"Going to read a sheet cell block");
363 psiconv_progress(lev+2,off+len,"Going to read the first cell"); 371 psiconv_progress(config,lev+2,off+len,"Going to read the first cell");
364 if ((res = psiconv_parse_sheet_cell_reference(buf,lev+2,off+len,&leng, 372 if ((res = psiconv_parse_sheet_cell_reference(config,buf,lev+2,off+len,&leng,
365 &result->first))) 373 &result->first)))
366 goto ERROR; 374 goto ERROR;
367 len += leng; 375 len += leng;
368 psiconv_progress(lev+2,off+len,"Going to read the last cell"); 376 psiconv_progress(config,lev+2,off+len,"Going to read the last cell");
369 if ((res = psiconv_parse_sheet_cell_reference(buf,lev+2,off+len,&leng, 377 if ((res = psiconv_parse_sheet_cell_reference(config,buf,lev+2,off+len,&leng,
370 &result->last))) 378 &result->last)))
371 goto ERROR; 379 goto ERROR;
372 len += leng; 380 len += leng;
373 psiconv_progress(lev,off+len-1, 381 psiconv_progress(config,lev,off+len-1,
374 "End of cell block (total length: %08x)", len); 382 "End of cell block (total length: %08x)", len);
375 if (length) 383 if (length)
376 *length = len; 384 *length = len;
377 return 0; 385 return 0;
378ERROR: 386ERROR:
379 if (length) 387 if (length)
380 *length = 0; 388 *length = 0;
381 return res; 389 return res;
382} 390}
383 391
384static int psiconv_parse_formula_element_list(const psiconv_buffer buf, int lev, 392static int psiconv_parse_formula_element_list(const psiconv_config config,
393 const psiconv_buffer buf, int lev,
385 psiconv_u32 off, int *length, 394 psiconv_u32 off, int *length,
386 psiconv_formula *result, 395 psiconv_formula *result,
387 psiconv_u32 maxlen) 396 psiconv_u32 maxlen)
388{ 397{
389 int res=0; 398 int res=0;
… …
394 psiconv_formula_list formula_stack; 403 psiconv_formula_list formula_stack;
395 psiconv_formula formula,subformula,subformula1,subformula2, 404 psiconv_formula formula,subformula,subformula1,subformula2,
396 subformula3,subformula4; 405 subformula3,subformula4;
397 psiconv_u16 temp,nr_of_subs; 406 psiconv_u16 temp,nr_of_subs;
398 407
399 psiconv_progress(lev+1,off,"Going to read a formula element list"); 408 psiconv_progress(config,lev+1,off,"Going to read a formula element list");
400 if (!(*result = malloc(sizeof(**result)))) 409 if (!(*result = malloc(sizeof(**result))))
401 goto ERROR1; 410 goto ERROR1;
402 if (!(formula_stack = psiconv_list_new(sizeof(struct psiconv_formula_s)))) 411 if (!(formula_stack = psiconv_list_new(sizeof(struct psiconv_formula_s))))
403 goto ERROR2; 412 goto ERROR2;
404 if (!(formula = malloc(sizeof(*formula)))) 413 if (!(formula = malloc(sizeof(*formula))))
… …
417 if (!(subformula4 = malloc(sizeof(*subformula4)))) 426 if (!(subformula4 = malloc(sizeof(*subformula4))))
418 goto ERROR7; 427 goto ERROR7;
419 subformula4->type = psiconv_formula_unknown; 428 subformula4->type = psiconv_formula_unknown;
420 429
421 while (!eof && len+off < maxlen) { 430 while (!eof && len+off < maxlen) {
422 psiconv_progress(lev+3,off+len,"Going to read a formula item marker"); 431 psiconv_progress(config,lev+3,off+len,"Going to read a formula item marker");
423 marker = psiconv_read_u8(buf,lev+2,off+len,&res); 432 marker = psiconv_read_u8(config,buf,lev+2,off+len,&res);
424 if (res) 433 if (res)
425 goto ERROR8; 434 goto ERROR8;
426 psiconv_debug(lev+3,off+len,"Marker: %02x (%s)",marker, 435 psiconv_debug(config,lev+3,off+len,"Marker: %02x (%s)",marker,
427 formula_elements[marker].name); 436 formula_elements[marker].name);
428 len ++; 437 len ++;
429 438
430 if (formula_elements[marker].formula_type == psiconv_formula_unknown) { 439 if (formula_elements[marker].formula_type == psiconv_formula_unknown) {
431 psiconv_warn(lev+3,off+len,"Unknown formula marker found!"); 440 psiconv_warn(config,lev+3,off+len,"Unknown formula marker found!");
432 goto ERROR8; 441 goto ERROR8;
433 } else if ((formula_elements[marker].formula_type == 442 } else if ((formula_elements[marker].formula_type ==
434 psiconv_formula_mark_eof) || 443 psiconv_formula_mark_eof) ||
435 (formula_elements[marker].formula_type == 444 (formula_elements[marker].formula_type ==
436 psiconv_formula_mark_opend) || 445 psiconv_formula_mark_opend) ||
437 (formula_elements[marker].formula_type == 446 (formula_elements[marker].formula_type ==
438 psiconv_formula_mark_opsep)) { 447 psiconv_formula_mark_opsep)) {
439 len--; 448 len--;
440 psiconv_progress(lev+3,off+len,"End of this formula list"); 449 psiconv_progress(config,lev+3,off+len,"End of this formula list");
441 eof = 1; 450 eof = 1;
442 } else if (formula_elements[marker].formula_type == 451 } else if (formula_elements[marker].formula_type ==
443 psiconv_formula_dat_int) { 452 psiconv_formula_dat_int) {
444 psiconv_progress(lev+3,off+len,"Next item: an integer"); 453 psiconv_progress(config,lev+3,off+len,"Next item: an integer");
445 formula->data.dat_int = psiconv_read_u32(buf,lev+2,off+len,&res); 454 formula->data.dat_int = psiconv_read_u32(config,buf,lev+2,off+len,&res);
446 if (res) 455 if (res)
447 goto ERROR8; 456 goto ERROR8;
448 formula->type = formula_elements[marker].formula_type; 457 formula->type = formula_elements[marker].formula_type;
449 psiconv_debug(lev+3,off+len,"Value: %08x",formula->data.dat_int); 458 psiconv_debug(config,lev+3,off+len,"Value: %08x",formula->data.dat_int);
450 len += 4; 459 len += 4;
451 if ((res = psiconv_list_add(formula_stack,formula))) 460 if ((res = psiconv_list_add(formula_stack,formula)))
452 goto ERROR8; 461 goto ERROR8;
453 formula->type = psiconv_formula_unknown; 462 formula->type = psiconv_formula_unknown;
454 } else if (formula_elements[marker].formula_type == 463 } else if (formula_elements[marker].formula_type ==
455 psiconv_formula_dat_float) { 464 psiconv_formula_dat_float) {
456 psiconv_progress(lev+3,off+len,"Next item: a float"); 465 psiconv_progress(config,lev+3,off+len,"Next item: a float");
457 formula->data.dat_float = psiconv_read_float(buf,lev+2,off+len,&leng, 466 formula->data.dat_float = psiconv_read_float(config,buf,lev+2,off+len,&leng,
458 &res); 467 &res);
459 if (res) 468 if (res)
460 goto ERROR8; 469 goto ERROR8;
461 formula->type = formula_elements[marker].formula_type; 470 formula->type = formula_elements[marker].formula_type;
462 psiconv_debug(lev+3,off+len,"Value: %f",formula->data.dat_float); 471 psiconv_debug(config,lev+3,off+len,"Value: %f",formula->data.dat_float);
463 len += leng; 472 len += leng;
464 if ((res = psiconv_list_add(formula_stack,formula))) 473 if ((res = psiconv_list_add(formula_stack,formula)))
465 goto ERROR8; 474 goto ERROR8;
466 formula->type = psiconv_formula_unknown; 475 formula->type = psiconv_formula_unknown;
467 } else if (formula_elements[marker].formula_type == 476 } else if (formula_elements[marker].formula_type ==
468 psiconv_formula_dat_cellref) { 477 psiconv_formula_dat_cellref) {
469 psiconv_progress(lev+3,off+len,"Next item: a cell reference"); 478 psiconv_progress(config,lev+3,off+len,"Next item: a cell reference");
470 if ((res = psiconv_parse_sheet_cell_reference(buf,lev+2,off+len,&leng, 479 if ((res = psiconv_parse_sheet_cell_reference(config,buf,lev+2,off+len,&leng,
471 &formula->data.dat_cellref))) 480 &formula->data.dat_cellref)))
472 goto ERROR8; 481 goto ERROR8;
473 formula->type = formula_elements[marker].formula_type; 482 formula->type = formula_elements[marker].formula_type;
474 len += leng; 483 len += leng;
475 if ((res = psiconv_list_add(formula_stack,formula))) 484 if ((res = psiconv_list_add(formula_stack,formula)))
… …
477 formula->type = psiconv_formula_unknown; 486 formula->type = psiconv_formula_unknown;
478 } else if ((formula_elements[marker].formula_type == 487 } else if ((formula_elements[marker].formula_type ==
479 psiconv_formula_dat_cellblock) || 488 psiconv_formula_dat_cellblock) ||
480 (formula_elements[marker].formula_type == 489 (formula_elements[marker].formula_type ==
481 psiconv_formula_dat_vcellblock)) { 490 psiconv_formula_dat_vcellblock)) {
482 psiconv_progress(lev+3,off+len,"Next item: a cell block"); 491 psiconv_progress(config,lev+3,off+len,"Next item: a cell block");
483 if ((res = psiconv_parse_sheet_cell_block(buf,lev+2,off+len,&leng, 492 if ((res = psiconv_parse_sheet_cell_block(config,buf,lev+2,off+len,&leng,
484 &formula->data.dat_cellblock))) 493 &formula->data.dat_cellblock)))
485 goto ERROR8; 494 goto ERROR8;
486 formula->type = formula_elements[marker].formula_type; 495 formula->type = formula_elements[marker].formula_type;
487 len += leng; 496 len += leng;
488 if ((res = psiconv_list_add(formula_stack,formula))) 497 if ((res = psiconv_list_add(formula_stack,formula)))
489 goto ERROR8; 498 goto ERROR8;
490 formula->type = psiconv_formula_unknown; 499 formula->type = psiconv_formula_unknown;
491 } else if (formula_elements[marker].formula_type == 500 } else if (formula_elements[marker].formula_type ==
492 psiconv_formula_dat_string) { 501 psiconv_formula_dat_string) {
493 psiconv_progress(lev+3,off+len,"Next item: a string"); 502 psiconv_progress(config,lev+3,off+len,"Next item: a string");
494 formula->data.dat_string = 503 formula->data.dat_string =
495 psiconv_read_short_string(buf,lev+2,off+len,&leng,&res); 504 psiconv_read_short_string(config,buf,lev+2,off+len,&leng,&res);
496 if (res) 505 if (res)
497 goto ERROR8; 506 goto ERROR8;
498 formula->type = formula_elements[marker].formula_type; 507 formula->type = formula_elements[marker].formula_type;
499 len += leng; 508 len += leng;
500 if ((res = psiconv_list_add(formula_stack,formula))) 509 if ((res = psiconv_list_add(formula_stack,formula)))
501 goto ERROR8; 510 goto ERROR8;
502 formula->type = psiconv_formula_unknown; 511 formula->type = psiconv_formula_unknown;
503 } else if ((formula_elements[marker].formula_type == 512 } else if ((formula_elements[marker].formula_type ==
504 psiconv_formula_dat_var)) { 513 psiconv_formula_dat_var)) {
505 psiconv_progress(lev+3,off+len,"Next item: a variable reference"); 514 psiconv_progress(config,lev+3,off+len,"Next item: a variable reference");
506 formula->data.dat_variable = psiconv_read_u32(buf,lev+2,off+len,&res); 515 formula->data.dat_variable = psiconv_read_u32(config,buf,lev+2,off+len,&res);
507 if (res) 516 if (res)
508 goto ERROR8; 517 goto ERROR8;
509 formula->type = formula_elements[marker].formula_type; 518 formula->type = formula_elements[marker].formula_type;
510 len += 4; 519 len += 4;
511 if ((res = psiconv_list_add(formula_stack,formula))) 520 if ((res = psiconv_list_add(formula_stack,formula)))
512 goto ERROR8; 521 goto ERROR8;
513 formula->type = psiconv_formula_unknown; 522 formula->type = psiconv_formula_unknown;
514 } else if (formula_elements[marker].number_of_args == -1) { 523 } else if (formula_elements[marker].number_of_args == -1) {
515 psiconv_progress(lev+3,off+len,"Going to parse a vararg function"); 524 psiconv_progress(config,lev+3,off+len,"Going to parse a vararg function");
516 if (!(formula->data.fun_operands = 525 if (!(formula->data.fun_operands =
517 psiconv_list_new(sizeof(*formula)))) 526 psiconv_list_new(sizeof(*formula))))
518 goto ERROR8; 527 goto ERROR8;
519 formula->type = formula_elements[marker].formula_type; 528 formula->type = formula_elements[marker].formula_type;
520 nr_of_subs = 0; 529 nr_of_subs = 0;
521 do { 530 do {
522 nr_of_subs ++; 531 nr_of_subs ++;
523 psiconv_progress(lev+4,off+len,"Going to read vararg argument %d", 532 psiconv_progress(config,lev+4,off+len,"Going to read vararg argument %d",
524 nr_of_subs); 533 nr_of_subs);
525 if ((res = psiconv_parse_formula_element_list(buf,lev+4,off+len,&leng, 534 if ((res = psiconv_parse_formula_element_list(config,buf,lev+4,off+len,&leng,
526 &subformula,maxlen))) 535 &subformula,maxlen)))
527 goto ERROR8; 536 goto ERROR8;
528 len += leng; 537 len += leng;
529 if ((res = psiconv_list_add(formula->data.fun_operands,subformula))) { 538 if ((res = psiconv_list_add(formula->data.fun_operands,subformula))) {
530 psiconv_free_formula(subformula); 539 psiconv_free_formula(subformula);
531 goto ERROR8; 540 goto ERROR8;
532 } 541 }
533 free(subformula); 542 free(subformula);
534 psiconv_progress(lev+4,off+len,"Going to read the next marker"); 543 psiconv_progress(config,lev+4,off+len,"Going to read the next marker");
535 submarker = psiconv_read_u8(buf,lev+4,off+len,&res); 544 submarker = psiconv_read_u8(config,buf,lev+4,off+len,&res);
536 len ++; 545 len ++;
537 if (res) 546 if (res)
538 goto ERROR8; 547 goto ERROR8;
539 submarker2 = psiconv_read_u8(buf,lev+4,off+len,&res); 548 submarker2 = psiconv_read_u8(config,buf,lev+4,off+len,&res);
540 if (res) 549 if (res)
541 goto ERROR8; 550 goto ERROR8;
542 } while ((formula_elements[submarker].formula_type 551 } while ((formula_elements[submarker].formula_type
543 == psiconv_formula_mark_opsep) && 552 == psiconv_formula_mark_opsep) &&
544 (formula_elements[submarker2].formula_type 553 (formula_elements[submarker2].formula_type
… …
550 submarker=submarker2; 559 submarker=submarker2;
551 len++; 560 len++;
552 } 561 }
553 if (formula_elements[submarker].formula_type 562 if (formula_elements[submarker].formula_type
554 != psiconv_formula_mark_opend) { 563 != psiconv_formula_mark_opend) {
555 psiconv_warn(lev+3,off+len,"Formula corrupted!"); 564 psiconv_warn(config,lev+3,off+len,"Formula corrupted!");
556 psiconv_debug(lev+3,off+len,"Found unexpected marker %02x",submarker); 565 psiconv_debug(config,lev+3,off+len,"Found unexpected marker %02x",submarker);
557 goto ERROR8; 566 goto ERROR8;
558 } 567 }
559 psiconv_progress(lev+3,off+len,"Going to read the repeated marker %02x", 568 psiconv_progress(config,lev+3,off+len,"Going to read the repeated marker %02x",
560 marker); 569 marker);
561 submarker = psiconv_read_u8(buf,lev+3,off+len,&res); 570 submarker = psiconv_read_u8(config,buf,lev+3,off+len,&res);
562 if (res) 571 if (res)
563 goto ERROR8; 572 goto ERROR8;
564 if (submarker != marker) { 573 if (submarker != marker) {
565 psiconv_warn(lev+3,off+len,"Formula corrupted!"); 574 psiconv_warn(config,lev+3,off+len,"Formula corrupted!");
566 psiconv_debug(lev+3,off+len,"Expected marker %02x, found %02x", 575 psiconv_debug(config,lev+3,off+len,"Expected marker %02x, found %02x",
567 marker,submarker); 576 marker,submarker);
568 goto ERROR8; 577 goto ERROR8;
569 } 578 }
570 len++; 579 len++;
571 psiconv_progress(lev+3,off+len, 580 psiconv_progress(config,lev+3,off+len,
572 "Going to read the number of arguments (%d expected)", 581 "Going to read the number of arguments (%d expected)",
573 nr_of_subs); 582 nr_of_subs);
574 temp = psiconv_read_u16(buf,lev+3,off+len,&res); 583 temp = psiconv_read_u16(config,buf,lev+3,off+len,&res);
575 if (res) 584 if (res)
576 goto ERROR8; 585 goto ERROR8;
577 if (temp != nr_of_subs) { 586 if (temp != nr_of_subs) {
578 psiconv_warn(lev+3,off+len,"Formula corrupted!"); 587 psiconv_warn(config,lev+3,off+len,"Formula corrupted!");
579 psiconv_debug(lev+3,off+len, 588 psiconv_debug(config,lev+3,off+len,
580 "Read %d arguments, but formula says there are %d", 589 "Read %d arguments, but formula says there are %d",
581 nr_of_subs,temp); 590 nr_of_subs,temp);
582 goto ERROR8; 591 goto ERROR8;
583 } 592 }
584 len += 2; 593 len += 2;
… …
619 subformula4->type = subformula3->type = subformula2->type = 628 subformula4->type = subformula3->type = subformula2->type =
620 subformula1->type = formula->type = psiconv_formula_unknown; 629 subformula1->type = formula->type = psiconv_formula_unknown;
621 } 630 }
622 } 631 }
623 if ((len+off > maxlen) || !eof) { 632 if ((len+off > maxlen) || !eof) {
624 psiconv_warn(lev+2,off+len,"Formula corrupted!"); 633 psiconv_warn(config,lev+2,off+len,"Formula corrupted!");
625 psiconv_debug(lev+2,off+len,"Expected end: %04x, found end: %04x", 634 psiconv_debug(config,lev+2,off+len,"Expected end: %04x, found end: %04x",
626 maxlen,len+off); 635 maxlen,len+off);
627 goto ERROR8; 636 goto ERROR8;
628 } 637 }
629 if ((psiconv_list_length(formula_stack)) != 1) { 638 if ((psiconv_list_length(formula_stack)) != 1) {
630 psiconv_warn(lev+2,off+len,"Formula corrupted!"); 639 psiconv_warn(config,lev+2,off+len,"Formula corrupted!");
631 psiconv_debug(lev+2,off+len,"More than one item left on the stack (%d)", 640 psiconv_debug(config,lev+2,off+len,"More than one item left on the stack (%d)",
632 psiconv_list_length(formula_stack)); 641 psiconv_list_length(formula_stack));
633 goto ERROR8; 642 goto ERROR8;
634 } 643 }
635 if ((res = psiconv_list_pop(formula_stack,*result))) 644 if ((res = psiconv_list_pop(formula_stack,*result)))
636 goto ERROR8; 645 goto ERROR8;
… …
638 free(formula); 647 free(formula);
639 648
640 if (length) 649 if (length)
641 *length = len; 650 *length = len;
642 651
643 psiconv_progress(lev,off+len-1, 652 psiconv_progress(config,lev,off+len-1,
644 "End of formula element list (total length: %08x)", len); 653 "End of formula element list (total length: %08x)", len);
645 return 0; 654 return 0;
646 655
647ERROR8: 656ERROR8:
648 psiconv_free_formula(subformula4); 657 psiconv_free_formula(subformula4);
… …
657ERROR3: 666ERROR3:
658 psiconv_free_formula_list(formula_stack); 667 psiconv_free_formula_list(formula_stack);
659ERROR2: 668ERROR2:
660 free (*result); 669 free (*result);
661ERROR1: 670ERROR1:
662 psiconv_warn(lev+1,off,"Reading of formula element list failed"); 671 psiconv_warn(config,lev+1,off,"Reading of formula element list failed");
663 if (length) 672 if (length)
664 *length = 0; 673 *length = 0;
665 if (!res) 674 if (!res)
666 return -PSICONV_E_NOMEM; 675 return -PSICONV_E_NOMEM;
667 else 676 else
… …
669} 678}
670 679
671 680
672 681
673 682
674int psiconv_parse_formula(const psiconv_buffer buf, int lev, 683int psiconv_parse_formula(const psiconv_config config,
684 const psiconv_buffer buf, int lev,
675 psiconv_u32 off, int *length, 685 psiconv_u32 off, int *length,
676 psiconv_formula *result) 686 psiconv_formula *result)
677{ 687{
678 int res=0; 688 int res=0;
679 int len=0; 689 int len=0;
680 int leng; 690 int leng;
681 psiconv_u32 bytelen,formula_end; 691 psiconv_u32 bytelen,formula_end;
682 psiconv_u8 temp; 692 psiconv_u8 temp;
683 693
684 psiconv_progress(lev+1,off,"Going to read a formula"); 694 psiconv_progress(config,lev+1,off,"Going to read a formula");
685 695
686 psiconv_progress(lev+2,off+len, 696 psiconv_progress(config,lev+2,off+len,
687 "Going to read the formula byte length"); 697 "Going to read the formula byte length");
688 bytelen = psiconv_read_S(buf,lev+2,off+len,&leng,&res); 698 bytelen = psiconv_read_S(config,buf,lev+2,off+len,&leng,&res);
689 if (res) 699 if (res)
690 goto ERROR1; 700 goto ERROR1;
691 psiconv_debug(lev+2,off+len,"Formula byte length: %d",bytelen); 701 psiconv_debug(config,lev+2,off+len,"Formula byte length: %d",bytelen);
692 len += leng; 702 len += leng;
693 bytelen += len; 703 bytelen += len;
694 formula_end = off + bytelen; 704 formula_end = off + bytelen;
695 705
696 psiconv_progress(lev+2,off+len,"Going to read the formula elements list"); 706 psiconv_progress(config,lev+2,off+len,"Going to read the formula elements list");
697 if ((res = psiconv_parse_formula_element_list(buf,lev+2,off+len,&leng, 707 if ((res = psiconv_parse_formula_element_list(config,buf,lev+2,off+len,&leng,
698 result,formula_end))) 708 result,formula_end)))
699 goto ERROR1; 709 goto ERROR1;
700 len += leng; 710 len += leng;
701 711
702 psiconv_progress(lev+2,off+len,"Going to read the eof marker"); 712 psiconv_progress(config,lev+2,off+len,"Going to read the eof marker");
703 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 713 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
704 if (res) 714 if (res)
705 goto ERROR2; 715 goto ERROR2;
706 if (formula_elements[temp].formula_type != psiconv_formula_mark_eof) { 716 if (formula_elements[temp].formula_type != psiconv_formula_mark_eof) {
707 psiconv_warn(lev+2,off+len,"Formula corrupted!"); 717 psiconv_warn(config,lev+2,off+len,"Formula corrupted!");
708 psiconv_debug(lev+2,off+len,"Expected marker: %02x, found byte: %02x", 718 psiconv_debug(config,lev+2,off+len,"Expected marker: %02x, found byte: %02x",
709 0x15,temp); 719 0x15,temp);
710 goto ERROR2; 720 goto ERROR2;
711 } 721 }
712 len ++; 722 len ++;
713 723
714 if (off+len != formula_end) { 724 if (off+len != formula_end) {
715 psiconv_warn(lev+2,off+len,"Formula corrupted!"); 725 psiconv_warn(config,lev+2,off+len,"Formula corrupted!");
716 psiconv_debug(lev+2,off+len,"Expected end: %04x, found end: %04x", 726 psiconv_debug(config,lev+2,off+len,"Expected end: %04x, found end: %04x",
717 formula_end,len+off); 727 formula_end,len+off);
718 goto ERROR2; 728 goto ERROR2;
719 } 729 }
720 730
721 if (length) 731 if (length)
722 *length = len; 732 *length = len;
723 733
724 psiconv_progress(lev,off+len-1, 734 psiconv_progress(config,lev,off+len-1,
725 "End of formula (total length: %08x)", len); 735 "End of formula (total length: %08x)", len);
726 return 0; 736 return 0;
727 737
728ERROR2: 738ERROR2:
729 psiconv_free_formula(*result); 739 psiconv_free_formula(*result);
730ERROR1: 740ERROR1:
731 psiconv_warn(lev+1,off,"Reading of formula failed"); 741 psiconv_warn(config,lev+1,off,"Reading of formula failed");
732 if (length) 742 if (length)
733 *length = 0; 743 *length = 0;
734 if (!res) 744 if (!res)
735 return -PSICONV_E_NOMEM; 745 return -PSICONV_E_NOMEM;
736 else 746 else
Legend:
Removed from v.129  
changed lines
  Added in v.168
frodo@frodo.looijaard.name
 ViewVC Help
Powered by ViewVC 1.1.26