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