/[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 103 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
294static psiconv_string_t psiconv_read_sheet_string(const psiconv_buffer buf,
295 int lev,
296 psiconv_u32 off,int *length, int *status)
297{
298 int stringlen,i,len,localstatus;
299 psiconv_string_t result;
300 char *res_copy;
301
302 psiconv_progress(lev+1,off,"Going to read a sheet string");
303
304 stringlen = psiconv_read_u8(buf,lev+2,off,&localstatus);
305 if (localstatus)
306 goto ERROR1;
307 psiconv_debug(lev+2,off,"Length: %i",stringlen);
308 len = 1;
309
310 result = malloc(stringlen + 1);
311 if (!result)
312 goto ERROR1;
313 for (i = 0; (i < stringlen) && !localstatus; i++)
314 result[i] = psiconv_read_u8(buf,lev,off+i+len,&localstatus);
315 if (localstatus)
316 goto ERROR2;
317 result[stringlen] = 0;
318 len += stringlen;
319
320 res_copy = psiconv_make_printable(result);
321 if (!res_copy)
322 goto ERROR2;
323 psiconv_debug(lev+2,off,"Contents: `%s'",res_copy);
324 free(res_copy);
325
326 if (length)
327 *length = len;
328
329 if (status)
330 *status = 0;
331
332 psiconv_progress(lev+1,off+len-1,"End of sheet string (total length: %08x)",
333 len);
334
335 return result;
336
337
338ERROR2:
339 free(result);
340ERROR1:
341 psiconv_warn(lev+1,off,"Reading of sheet string failed");
342 if (status)
343 *status = localstatus;
344 if (length)
345 *length = 0;
346 return NULL;
347}
348
349
350static 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,
351 psiconv_u32 off, int *length, 298 psiconv_u32 off, int *length,
352 psiconv_sheet_ref_t *result) 299 psiconv_sheet_ref_t *result)
353{ 300{
354 int res; 301 int res;
355 psiconv_u16 temp; 302 psiconv_u16 temp;
356 303
357 psiconv_progress(lev+1,off,"Going to read a sheet ref"); 304 psiconv_progress(config,lev+1,off,"Going to read a sheet ref");
358 psiconv_progress(lev+2,off,"Going to read the offset encoding"); 305 psiconv_progress(config,lev+2,off,"Going to read the offset encoding");
359 temp = psiconv_read_u16(buf,lev+2,off,&res); 306 temp = psiconv_read_u16(config,buf,lev+2,off,&res);
360 if (res) { 307 if (res) {
361 if (length) 308 if (length)
362 *length = 0; 309 *length = 0;
363 return res; 310 return res;
364 } 311 }
365 psiconv_debug(lev+2,off,"Encoded word: %04x",temp); 312 psiconv_debug(config,lev+2,off,"Encoded word: %04x",temp);
366 result->absolute = (temp & 0x4000)?psiconv_bool_true:psiconv_bool_false; 313 result->absolute = (temp & 0x4000)?psiconv_bool_true:psiconv_bool_false;
367 result->offset = (temp & 0x3fff) * ((temp & 0x8000)?-1:1); 314 result->offset = (temp & 0x3fff) * ((temp & 0x8000)?-1:1);
368 psiconv_debug(lev+2,off,"Reference: %s offset %d", 315 psiconv_debug(config,lev+2,off,"Reference: %s offset %d",
369 result->absolute?"absolute":"relative",result->offset); 316 result->absolute?"absolute":"relative",result->offset);
370 if (length) 317 if (length)
371 *length = 2; 318 *length = 2;
372 return 0; 319 return 0;
373} 320}
374 321
375static 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,
376 psiconv_u32 off, int *length, 324 psiconv_u32 off, int *length,
377 psiconv_sheet_cell_reference_t *result) 325 psiconv_sheet_cell_reference_t *result)
378{ 326{
379 int len = 0; 327 int len = 0;
380 int leng,res; 328 int leng,res;
381 psiconv_u8 temp; 329 psiconv_u8 temp;
382 330
383 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");
384 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");
385 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)))
386 goto ERROR; 334 goto ERROR;
387 len += leng; 335 len += leng;
388 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");
389 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)))
390 goto ERROR; 338 goto ERROR;
391 len += leng; 339 len += leng;
392 340
393 psiconv_progress(lev+2,off+len, 341 psiconv_progress(config,lev+2,off+len,
394 "Going to read the trailing byte (%02x expected)",0); 342 "Going to read the trailing byte (%02x expected)",0);
395 temp = psiconv_read_u8(buf,lev+2,off+len,&res); 343 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
396 if (res) 344 if (res)
397 goto ERROR; 345 goto ERROR;
398 if (temp != 0) { 346 if (temp != 0) {
399 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");
400 psiconv_debug(lev+2,off+len,"Trailing byte: %02x",temp); 348 psiconv_debug(config,lev+2,off+len,"Trailing byte: %02x",temp);
401 } 349 }
402 len ++; 350 len ++;
403 psiconv_progress(lev,off+len-1, 351 psiconv_progress(config,lev,off+len-1,
404 "End of cell reference (total length: %08x)", len); 352 "End of cell reference (total length: %08x)", len);
405 if (length) 353 if (length)
406 *length = len; 354 *length = len;
407 return 0; 355 return 0;
408ERROR: 356ERROR:
409 if (length) 357 if (length)
410 *length = 0; 358 *length = 0;
411 return res; 359 return res;
412} 360}
413 361
414static 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,
415 psiconv_u32 off, int *length, 364 psiconv_u32 off, int *length,
416 psiconv_sheet_cell_block_t *result) 365 psiconv_sheet_cell_block_t *result)
417{ 366{
418 int len = 0; 367 int len = 0;
419 int leng,res; 368 int leng,res;
420 369
421 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");
422 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");
423 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,
424 &result->first))) 373 &result->first)))
425 goto ERROR; 374 goto ERROR;
426 len += leng; 375 len += leng;
427 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");
428 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,
429 &result->last))) 378 &result->last)))
430 goto ERROR; 379 goto ERROR;
431 len += leng; 380 len += leng;
432 psiconv_progress(lev,off+len-1, 381 psiconv_progress(config,lev,off+len-1,
433 "End of cell block (total length: %08x)", len); 382 "End of cell block (total length: %08x)", len);
434 if (length) 383 if (length)
435 *length = len; 384 *length = len;
436 return 0; 385 return 0;
437ERROR: 386ERROR:
438 if (length) 387 if (length)
439 *length = 0; 388 *length = 0;
440 return res; 389 return res;
441} 390}
442 391
443int psiconv_parse_formula(const psiconv_buffer buf, int lev, 392static int psiconv_parse_formula_element_list(const psiconv_config config,
393 const psiconv_buffer buf, int lev,
444 psiconv_u32 off, int *length, 394 psiconv_u32 off, int *length,
445 psiconv_formula *result) 395 psiconv_formula *result,
396 psiconv_u32 maxlen)
446{ 397{
447 int res=0; 398 int res=0;
448 int len=0; 399 int len=0;
449 int leng; 400 int leng;
450 int eof = 0; 401 int eof = 0;
451 psiconv_u8 marker; 402 psiconv_u8 marker,submarker,submarker2;
452 psiconv_u32 bytelen;
453 psiconv_formula_list formula_stack; 403 psiconv_formula_list formula_stack;
454 psiconv_formula formula,subformula1,subformula2,subformula3,subformula4; 404 psiconv_formula formula,subformula,subformula1,subformula2,
405 subformula3,subformula4;
406 psiconv_u16 temp,nr_of_subs;
455 407
456 psiconv_progress(lev+1,off,"Going to read a formula"); 408 psiconv_progress(config,lev+1,off,"Going to read a formula element list");
457 if (!(*result = malloc(sizeof(**result)))) 409 if (!(*result = malloc(sizeof(**result))))
458 goto ERROR1; 410 goto ERROR1;
459 if (!(formula_stack = psiconv_list_new(sizeof(struct psiconv_formula_s)))) 411 if (!(formula_stack = psiconv_list_new(sizeof(struct psiconv_formula_s))))
460 goto ERROR2; 412 goto ERROR2;
461 if (!(formula = malloc(sizeof(*formula)))) 413 if (!(formula = malloc(sizeof(*formula))))
… …
473 subformula3->type = psiconv_formula_unknown; 425 subformula3->type = psiconv_formula_unknown;
474 if (!(subformula4 = malloc(sizeof(*subformula4)))) 426 if (!(subformula4 = malloc(sizeof(*subformula4))))
475 goto ERROR7; 427 goto ERROR7;
476 subformula4->type = psiconv_formula_unknown; 428 subformula4->type = psiconv_formula_unknown;
477 429
478 psiconv_progress(lev+2,off+len,
479 "Going to read the formula byte length");
480 bytelen = psiconv_read_S(buf,lev+2,off+len,&leng,&res);
481 if (res)
482 goto ERROR8;
483 psiconv_debug(lev+2,off+len,"Formula byte length: %d",bytelen);
484 len += leng;
485 bytelen += len;
486
487 psiconv_progress(lev+2,off+len,"Going to read the formula items");
488 while (!eof && len < bytelen) { 430 while (!eof && len+off < maxlen) {
489 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");
490 marker = psiconv_read_u8(buf,lev+2,off+len,&res); 432 marker = psiconv_read_u8(config,buf,lev+2,off+len,&res);
491 if (res) 433 if (res)
492 goto ERROR8; 434 goto ERROR8;
493 psiconv_debug(lev+3,off+len,"Marker: %02x (%s)",marker, 435 psiconv_debug(config,lev+3,off+len,"Marker: %02x (%s)",marker,
494 formula_elements[marker].name); 436 formula_elements[marker].name);
495 len ++; 437 len ++;
496 438
497 if (formula_elements[marker].formula_type == psiconv_formula_unknown) { 439 if (formula_elements[marker].formula_type == psiconv_formula_unknown) {
498 psiconv_warn(lev+3,off+len,"Unknown formula marker found!"); 440 psiconv_warn(config,lev+3,off+len,"Unknown formula marker found!");
499 goto ERROR8; 441 goto ERROR8;
500 } else if (formula_elements[marker].formula_type == 442 } else if ((formula_elements[marker].formula_type ==
501 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--;
502 psiconv_progress(lev+3,off+len,"End of formula"); 449 psiconv_progress(config,lev+3,off+len,"End of this formula list");
503 eof = 1; 450 eof = 1;
504 } else if (formula_elements[marker].formula_type == 451 } else if (formula_elements[marker].formula_type ==
505 psiconv_formula_dat_int) { 452 psiconv_formula_dat_int) {
506 psiconv_progress(lev+3,off+len,"Next item: an integer"); 453 psiconv_progress(config,lev+3,off+len,"Next item: an integer");
507 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);
508 if (res) 455 if (res)
509 goto ERROR8; 456 goto ERROR8;
510 formula->type = formula_elements[marker].formula_type; 457 formula->type = formula_elements[marker].formula_type;
511 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);
512 len += 4; 459 len += 4;
513 if ((res = psiconv_list_add(formula_stack,formula))) 460 if ((res = psiconv_list_add(formula_stack,formula)))
514 goto ERROR8; 461 goto ERROR8;
515 formula->type = psiconv_formula_unknown; 462 formula->type = psiconv_formula_unknown;
516 } else if (formula_elements[marker].formula_type == 463 } else if (formula_elements[marker].formula_type ==
517 psiconv_formula_dat_float) { 464 psiconv_formula_dat_float) {
518 psiconv_progress(lev+3,off+len,"Next item: a float"); 465 psiconv_progress(config,lev+3,off+len,"Next item: a float");
519 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,
520 &res); 467 &res);
521 if (res) 468 if (res)
522 goto ERROR8; 469 goto ERROR8;
523 formula->type = formula_elements[marker].formula_type; 470 formula->type = formula_elements[marker].formula_type;
524 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);
525 len += leng; 472 len += leng;
526 if ((res = psiconv_list_add(formula_stack,formula))) 473 if ((res = psiconv_list_add(formula_stack,formula)))
527 goto ERROR8; 474 goto ERROR8;
528 formula->type = psiconv_formula_unknown; 475 formula->type = psiconv_formula_unknown;
529 } else if (formula_elements[marker].formula_type == 476 } else if (formula_elements[marker].formula_type ==
530 psiconv_formula_dat_cellref) { 477 psiconv_formula_dat_cellref) {
531 psiconv_progress(lev+3,off+len,"Next item: a cell reference"); 478 psiconv_progress(config,lev+3,off+len,"Next item: a cell reference");
532 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,
533 &formula->data.dat_cellref))) 480 &formula->data.dat_cellref)))
534 goto ERROR8; 481 goto ERROR8;
535 formula->type = formula_elements[marker].formula_type; 482 formula->type = formula_elements[marker].formula_type;
536 len += leng; 483 len += leng;
537 if ((res = psiconv_list_add(formula_stack,formula))) 484 if ((res = psiconv_list_add(formula_stack,formula)))
538 goto ERROR8; 485 goto ERROR8;
539 formula->type = psiconv_formula_unknown; 486 formula->type = psiconv_formula_unknown;
540 } else if (formula_elements[marker].formula_type == 487 } else if ((formula_elements[marker].formula_type ==
488 psiconv_formula_dat_cellblock) ||
489 (formula_elements[marker].formula_type ==
541 psiconv_formula_dat_cellblock) { 490 psiconv_formula_dat_vcellblock)) {
542 psiconv_progress(lev+3,off+len,"Next item: a cell block"); 491 psiconv_progress(config,lev+3,off+len,"Next item: a cell block");
543 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,
544 &formula->data.dat_cellblock))) 493 &formula->data.dat_cellblock)))
545 goto ERROR8; 494 goto ERROR8;
546 formula->type = formula_elements[marker].formula_type; 495 formula->type = formula_elements[marker].formula_type;
547 len += leng; 496 len += leng;
548 if ((res = psiconv_list_add(formula_stack,formula))) 497 if ((res = psiconv_list_add(formula_stack,formula)))
549 goto ERROR8; 498 goto ERROR8;
550 formula->type = psiconv_formula_unknown; 499 formula->type = psiconv_formula_unknown;
551 } else if (formula_elements[marker].formula_type == 500 } else if (formula_elements[marker].formula_type ==
552 psiconv_formula_dat_string) { 501 psiconv_formula_dat_string) {
553 psiconv_progress(lev+3,off+len,"Next item: a string"); 502 psiconv_progress(config,lev+3,off+len,"Next item: a string");
554 formula->data.dat_string = 503 formula->data.dat_string =
555 psiconv_read_sheet_string(buf,lev+2,off+len,&leng,&res); 504 psiconv_read_short_string(config,buf,lev+2,off+len,&leng,&res);
556 if (res) 505 if (res)
557 goto ERROR8; 506 goto ERROR8;
558 formula->type = formula_elements[marker].formula_type; 507 formula->type = formula_elements[marker].formula_type;
559 len += leng; 508 len += leng;
560 if ((res = psiconv_list_add(formula_stack,formula))) 509 if ((res = psiconv_list_add(formula_stack,formula)))
561 goto ERROR8; 510 goto ERROR8;
562 formula->type = psiconv_formula_unknown; 511 formula->type = psiconv_formula_unknown;
563 } else if ((formula_elements[marker].formula_type == 512 } else if ((formula_elements[marker].formula_type ==
564 psiconv_formula_dat_var) || 513 psiconv_formula_dat_var)) {
565 (formula_elements[marker].formula_type == 514 psiconv_progress(config,lev+3,off+len,"Next item: a variable reference");
566 psiconv_formula_dat_string) || 515 formula->data.dat_variable = psiconv_read_u32(config,buf,lev+2,off+len,&res);
567 (formula_elements[marker].formula_type == 516 if (res)
568 psiconv_formula_dat_vcellblock) ||
569 (formula_elements[marker].formula_type ==
570 psiconv_formula_mark_opsep) ||
571 (formula_elements[marker].formula_type ==
572 psiconv_formula_mark_opend)) {
573 psiconv_warn(lev+3,off+len,"Not yet supported formula mark!");
574 goto ERROR8; 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;
575 } else if (formula_elements[marker].number_of_args == -1) { 523 } else if (formula_elements[marker].number_of_args == -1) {
576 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);
577 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;
578 } else { 597 } else {
579 if (formula_elements[marker].number_of_args > 0) 598 if (formula_elements[marker].number_of_args > 0)
580 if ((res = psiconv_list_pop(formula_stack,subformula1))) 599 if ((res = psiconv_list_pop(formula_stack,subformula1)))
581 goto ERROR8; 600 goto ERROR8;
582 if (formula_elements[marker].number_of_args > 1) 601 if (formula_elements[marker].number_of_args > 1)
… …
608 goto ERROR8; 627 goto ERROR8;
609 subformula4->type = subformula3->type = subformula2->type = 628 subformula4->type = subformula3->type = subformula2->type =
610 subformula1->type = formula->type = psiconv_formula_unknown; 629 subformula1->type = formula->type = psiconv_formula_unknown;
611 } 630 }
612 } 631 }
613 if ((len != bytelen) || !eof) { 632 if ((len+off > maxlen) || !eof) {
614 psiconv_warn(lev+2,off+len,"Formula corrupted!"); 633 psiconv_warn(config,lev+2,off+len,"Formula corrupted!");
615 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",
616 bytelen,len); 635 maxlen,len+off);
617 goto ERROR8; 636 goto ERROR8;
618 } 637 }
619 if ((psiconv_list_length(formula_stack)) != 1) { 638 if ((psiconv_list_length(formula_stack)) != 1) {
620 psiconv_warn(lev+2,off+len,"Formula corrupted!"); 639 psiconv_warn(config,lev+2,off+len,"Formula corrupted!");
621 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)",
622 psiconv_list_length(formula_stack)); 641 psiconv_list_length(formula_stack));
623 goto ERROR8; 642 goto ERROR8;
624 } 643 }
625 if ((res = psiconv_list_pop(formula_stack,*result))) 644 if ((res = psiconv_list_pop(formula_stack,*result)))
626 goto ERROR8; 645 goto ERROR8;
… …
628 free(formula); 647 free(formula);
629 648
630 if (length) 649 if (length)
631 *length = len; 650 *length = len;
632 651
633 psiconv_progress(lev,off+len-1, 652 psiconv_progress(config,lev,off+len-1,
634 "End of formula (total length: %08x)", len); 653 "End of formula element list (total length: %08x)", len);
635 return 0; 654 return 0;
636 655
637ERROR8: 656ERROR8:
638 psiconv_free_formula(subformula4); 657 psiconv_free_formula(subformula4);
639ERROR7: 658ERROR7:
… …
647ERROR3: 666ERROR3:
648 psiconv_free_formula_list(formula_stack); 667 psiconv_free_formula_list(formula_stack);
649ERROR2: 668ERROR2:
650 free (*result); 669 free (*result);
651ERROR1: 670ERROR1:
652 psiconv_warn(lev+1,off,"Reading of formula failed"); 671 psiconv_warn(config,lev+1,off,"Reading of formula element list failed");
653 if (length) 672 if (length)
654 *length = 0; 673 *length = 0;
655 if (!res) 674 if (!res)
656 return -PSICONV_E_NOMEM; 675 return -PSICONV_E_NOMEM;
657 else 676 else
658 return res; 677 return res;
659} 678}
660 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.103  
changed lines
  Added in v.168
frodo@frodo.looijaard.name
 ViewVC Help
Powered by ViewVC 1.1.26