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