/[webpac2]/trunk/lib/WebPAC/Input.pm
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/lib/WebPAC/Input.pm

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

revision 636 by dpavlin, Wed Sep 6 19:25:22 2006 UTC revision 860 by dpavlin, Sun May 27 19:10:43 2007 UTC
# Line 7  use blib; Line 7  use blib;
7    
8  use WebPAC::Common;  use WebPAC::Common;
9  use base qw/WebPAC::Common/;  use base qw/WebPAC::Common/;
10  use Data::Dumper;  use Data::Dump qw/dump/;
11  use Encode qw/from_to/;  use Encode qw/from_to/;
12    
13  =head1 NAME  =head1 NAME
# Line 16  WebPAC::Input - read different file form Line 16  WebPAC::Input - read different file form
16    
17  =head1 VERSION  =head1 VERSION
18    
19  Version 0.12  Version 0.18
20    
21  =cut  =cut
22    
23  our $VERSION = '0.12';  our $VERSION = '0.18';
24    
25  =head1 SYNOPSIS  =head1 SYNOPSIS
26    
# Line 43  Perhaps a little code snippet. Line 43  Perhaps a little code snippet.
43    
44          my $db = WebPAC::Input->new(          my $db = WebPAC::Input->new(
45                  module => 'WebPAC::Input::ISIS',                  module => 'WebPAC::Input::ISIS',
                 low_mem => 1,  
46          );          );
47    
48          $db->open( path => '/path/to/database' );          $db->open( path => '/path/to/database' );
# Line 63  Create new input database object. Line 62  Create new input database object.
62    my $db = new WebPAC::Input(    my $db = new WebPAC::Input(
63          module => 'WebPAC::Input::MARC',          module => 'WebPAC::Input::MARC',
64          encoding => 'ISO-8859-2',          encoding => 'ISO-8859-2',
         low_mem => 1,  
65          recode => 'char pairs',          recode => 'char pairs',
66          no_progress_bar => 1,          no_progress_bar => 1,
67    );    );
# Line 75  Optional parametar C<encoding> specify a Line 73  Optional parametar C<encoding> specify a
73  used internally). This should probably be your terminal encoding, and by  used internally). This should probably be your terminal encoding, and by
74  default, it C<ISO-8859-2>.  default, it C<ISO-8859-2>.
75    
 Default is not to use C<low_mem> options (see L<MEMORY USAGE> below).  
   
76  C<recode> is optional string constisting of character or words pairs that  C<recode> is optional string constisting of character or words pairs that
77  should be replaced in input stream.  should be replaced in input stream.
78    
# Line 96  sub new { Line 92  sub new {
92    
93          $log->logconfess("code_page argument is not suppored any more. change it to encoding") if ($self->{lookup});          $log->logconfess("code_page argument is not suppored any more. change it to encoding") if ($self->{lookup});
94          $log->logconfess("lookup argument is not suppored any more. rewrite call to lookup_ref") if ($self->{lookup});          $log->logconfess("lookup argument is not suppored any more. rewrite call to lookup_ref") if ($self->{lookup});
95            $log->logconfess("low_mem argument is not suppored any more. rewrite it to load_row and save_row") if ($self->{low_mem});
96    
97          $log->logconfess("specify low-level file format module") unless ($self->{module});          $log->logconfess("specify low-level file format module") unless ($self->{module});
98          my $module = $self->{module};          my $module_path = $self->{module};
99          $module =~ s#::#/#g;          $module_path =~ s#::#/#g;
100          $module .= '.pm';          $module_path .= '.pm';
101          $log->debug("require low-level module $self->{module} from $module");          $log->debug("require low-level module $self->{module} from $module_path");
   
         require $module;  
         #eval $self->{module} .'->import';  
   
         # check if required subclasses are implemented  
         foreach my $subclass (qw/open_db fetch_rec init/) {  
                 my $n = $self->{module} . '::' . $subclass;  
                 if (! defined &{ $n }) {  
                         my $missing = "missing $subclass in $self->{module}";  
                         $self->{$subclass} = sub { $log->logwarn($missing) };  
                 } else {  
                         $self->{$subclass} = \&{ $n };  
                 }  
         }  
102    
103          if ($self->{init}) {          require $module_path;
                 $log->debug("calling init");  
                 $self->{init}->($self, @_);  
         }  
104    
105          $self->{'encoding'} ||= 'ISO-8859-2';          $self->{'encoding'} ||= 'ISO-8859-2';
106    
         # running with low_mem flag? well, use DBM::Deep then.  
         if ($self->{'low_mem'}) {  
                 $log->info("running with low_mem which impacts performance (<32 Mb memory usage)");  
   
                 my $db_file = "data.db";  
   
                 if (-e $db_file) {  
                         unlink $db_file or $log->logdie("can't remove '$db_file' from last run");  
                         $log->debug("removed '$db_file' from last run");  
                 }  
   
                 require DBM::Deep;  
   
                 my $db = new DBM::Deep $db_file;  
   
                 $log->logdie("DBM::Deep error: $!") unless ($db);  
   
                 if ($db->error()) {  
                         $log->logdie("can't open '$db_file' under low_mem: ",$db->error());  
                 } else {  
                         $log->debug("using file '$db_file' for DBM::Deep");  
                 }  
   
                 $self->{'db'} = $db;  
         }  
   
107          $self ? return $self : return undef;          $self ? return $self : return undef;
108  }  }
109    
# Line 157  sub new { Line 111  sub new {
111    
112  This function will read whole database in memory and produce lookups.  This function will read whole database in memory and produce lookups.
113    
114     my $store;     # simple in-memory hash
115    
116   $input->open(   $input->open(
117          path => '/path/to/database/file',          path => '/path/to/database/file',
118          code_page => 'cp852',          code_page => 'cp852',
119          limit => 500,          limit => 500,
120          offset => 6000,          offset => 6000,
         lookup => $lookup_obj,  
121          stats => 1,          stats => 1,
122          lookup_ref => sub {          lookup_coderef => sub {
123                  my ($k,$v) = @_;                  my $rec = shift;
124                  # store lookup $k => $v                  # store lookups
125          },          },
126          modify_records => {          modify_records => {
127                  900 => { '^a' => { ' : ' => '^b' } },                  900 => { '^a' => { ' : ' => '^b' } },
128                  901 => { '*' => { '^b' => ' ; ' } },                  901 => { '*' => { '^b' => ' ; ' } },
129          },          },
130          modify_file => 'conf/modify/mapping.map',          modify_file => 'conf/modify/mapping.map',
131            save_row => sub {
132                    my $a = shift;
133                    $store->{ $a->{id} } = $a->{row};
134            },
135            load_row => sub {
136                    my $a = shift;
137                    return defined($store->{ $a->{id} }) &&
138                            $store->{ $a->{id} };
139            },
140    
141   );   );
142    
143  By default, C<code_page> is assumed to be C<cp852>.  By default, C<code_page> is assumed to be C<cp852>.
# Line 183  C<limit> is optional parametar to read j Line 148  C<limit> is optional parametar to read j
148    
149  C<stats> create optional report about usage of fields and subfields  C<stats> create optional report about usage of fields and subfields
150    
151  C<lookup_coderef> is closure to call when adding C<< key => 'value' >> combinations to  C<lookup_coderef> is closure to called to save data into lookups
 lookup.  
152    
153  C<modify_records> specify mapping from subfields to delimiters or from  C<modify_records> specify mapping from subfields to delimiters or from
154  delimiters to subfields, as well as oprations on fields (if subfield is  delimiters to subfields, as well as oprations on fields (if subfield is
# Line 194  C<modify_file> is alternative for C<modi Line 158  C<modify_file> is alternative for C<modi
158  (hopefully) simplier sintax than YAML or perl (see L</modify_file_regex>). This option  (hopefully) simplier sintax than YAML or perl (see L</modify_file_regex>). This option
159  overrides C<modify_records> if both exists for same input.  overrides C<modify_records> if both exists for same input.
160    
161    C<save_row> and C<load_row> are low-level implementation of store engine. Calling convention
162    is documented in example above.
163    
164  Returns size of database, regardless of C<offset> and C<limit>  Returns size of database, regardless of C<offset> and C<limit>
165  parametars, see also C<size>.  parametars, see also C<size>.
166    
# Line 209  sub open { Line 176  sub open {
176          $log->logconfess("lookup_coderef must be CODE, not ",ref($arg->{lookup_coderef}))          $log->logconfess("lookup_coderef must be CODE, not ",ref($arg->{lookup_coderef}))
177                  if ($arg->{lookup_coderef} && ref($arg->{lookup_coderef}) ne 'CODE');                  if ($arg->{lookup_coderef} && ref($arg->{lookup_coderef}) ne 'CODE');
178    
179            $log->debug( $arg->{lookup_coderef} ? '' : 'not ', "using lookup_coderef");
180    
181          $log->logcroak("need path") if (! $arg->{'path'});          $log->logcroak("need path") if (! $arg->{'path'});
182          my $code_page = $arg->{'code_page'} || 'cp852';          my $code_page = $arg->{'code_page'} || 'cp852';
183    
# Line 218  sub open { Line 187  sub open {
187                  $self->{$v} = $arg->{$v} if ($arg->{$v});                  $self->{$v} = $arg->{$v} if ($arg->{$v});
188          }          }
189    
190            if ($arg->{load_row} || $arg->{save_row}) {
191                    $log->logconfess("save_row and load_row must be defined in pair and be CODE") unless (
192                            ref($arg->{load_row}) eq 'CODE' &&
193                            ref($arg->{save_row}) eq 'CODE'
194                    );
195                    $self->{load_row} = $arg->{load_row};
196                    $self->{save_row} = $arg->{save_row};
197                    $log->debug("using load_row and save_row instead of in-memory hash");
198            }
199    
200          my $filter_ref;          my $filter_ref;
201          my $recode_regex;          my $recode_regex;
202          my $recode_map;          my $recode_map;
# Line 245  sub open { Line 224  sub open {
224                  $log->debug("using modify_file $p");                  $log->debug("using modify_file $p");
225                  $rec_regex = $self->modify_file_regexps( $p );                  $rec_regex = $self->modify_file_regexps( $p );
226          } elsif (my $h = $arg->{modify_records}) {          } elsif (my $h = $arg->{modify_records}) {
227                  $log->debug("using modify_records ", Dumper( $h ));                  $log->debug("using modify_records ", sub { dump( $h ) });
228                  $rec_regex = $self->modify_record_regexps(%{ $h });                  $rec_regex = $self->modify_record_regexps(%{ $h });
229          }          }
230          $log->debug("rec_regex: ", Dumper($rec_regex)) if ($rec_regex);          $log->debug("rec_regex: ", sub { dump($rec_regex) }) if ($rec_regex);
231    
232            my $class = $self->{module} || $log->logconfess("can't get low-level module name!");
233    
234          my ($db, $size) = $self->{open_db}->( $self,          my $ll_db = $class->new(
235                  path => $arg->{path},                  path => $arg->{path},
236  #               filter => sub {  #               filter => sub {
237  #                       my ($l,$f_nr) = @_;  #                       my ($l,$f_nr) = @_;
# Line 262  sub open { Line 243  sub open {
243                  %{ $arg },                  %{ $arg },
244          );          );
245    
246          unless (defined($db)) {          unless (defined($ll_db)) {
247                  $log->logwarn("can't open database $arg->{path}, skipping...");                  $log->logwarn("can't open database $arg->{path}, skipping...");
248                  return;                  return;
249          }          }
250    
251            my $size = $ll_db->size;
252    
253          unless ($size) {          unless ($size) {
254                  $log->logwarn("no records in database $arg->{path}, skipping...");                  $log->logwarn("no records in database $arg->{path}, skipping...");
255                  return;                  return;
# Line 298  sub open { Line 281  sub open {
281    
282                  $log->debug("position: $pos\n");                  $log->debug("position: $pos\n");
283    
284                  my $rec = $self->{fetch_rec}->($self, $db, $pos, sub {                  my $rec = $ll_db->fetch_rec($pos, sub {
285                                  my ($l,$f_nr) = @_;                                  my ($l,$f_nr,$debug) = @_;
286  #                               return unless defined($l);  #                               return unless defined($l);
287  #                               return $l unless ($rec_regex && $f_nr);  #                               return $l unless ($rec_regex && $f_nr);
288    
289                                    return unless ( defined($l) && defined($f_nr) );
290    
291                                    warn "-=> $f_nr ## |$l|\n" if ($debug);
292                                  $log->debug("-=> $f_nr ## $l");                                  $log->debug("-=> $f_nr ## $l");
293    
294                                  # codepage conversion and recode_regex                                  # codepage conversion and recode_regex
# Line 315  sub open { Line 301  sub open {
301                                          my $c = 0;                                          my $c = 0;
302                                          foreach my $r (@{ $rec_regex->{$f_nr} }) {                                          foreach my $r (@{ $rec_regex->{$f_nr} }) {
303                                                  my $old_l = $l;                                                  my $old_l = $l;
304                                                  eval '$l =~ ' . $r;                                                  $log->logconfess("expected regex in ", dump( $r )) unless defined($r->{regex});
305                                                    eval '$l =~ ' . $r->{regex};
306                                                  if ($old_l ne $l) {                                                  if ($old_l ne $l) {
307                                                          $log->debug("REGEX on $f_nr eval \$l =~ $r\n## old l: [$old_l]\n## new l: [$l]");                                                          my $d = "|$old_l| -> |$l| "; # . $r->{regex};
308                                                            $d .= ' +' . $r->{line} . ' ' . $r->{file} if defined($r->{line});
309                                                            $d .= ' ' . $r->{debug} if defined($r->{debug});
310                                                            $log->debug("MODIFY $d");
311                                                            warn "*** $d\n" if ($debug);
312    
313                                                  }                                                  }
314                                                  $log->error("error applying regex: $r") if ($@);                                                  $log->error("error applying regex: $r") if ($@);
315                                          }                                          }
316                                  }                                  }
317    
318                                  $log->debug("<=- $f_nr ## $l");                                  $log->debug("<=- $f_nr ## |$l|");
319                                    warn "<=- $f_nr ## $l\n" if ($debug);
320                                  return $l;                                  return $l;
321                  });                  });
322    
323                  $log->debug(sub { Dumper($rec) });                  $log->debug(sub { dump($rec) });
324    
325                  if (! $rec) {                  if (! $rec) {
326                          $log->warn("record $pos empty? skipping...");                          $log->warn("record $pos empty? skipping...");
# Line 335  sub open { Line 328  sub open {
328                  }                  }
329    
330                  # store                  # store
331                  if ($self->{low_mem}) {                  if ($self->{save_row}) {
332                          $self->{db}->put($pos, $rec);                          $self->{save_row}->({
333                                    id => $pos,
334                                    row => $rec,
335                            });
336                  } else {                  } else {
337                          $self->{data}->{$pos} = $rec;                          $self->{data}->{$pos} = $rec;
338                  }                  }
# Line 348  sub open { Line 344  sub open {
344                  if ($self->{stats}) {                  if ($self->{stats}) {
345    
346                          # fetch clean record with regexpes applied for statistics                          # fetch clean record with regexpes applied for statistics
347                          my $rec = $self->{fetch_rec}->($self, $db, $pos);                          my $rec = $ll_db->fetch_rec($pos);
348    
349                          foreach my $fld (keys %{ $rec }) {                          foreach my $fld (keys %{ $rec }) {
350                                  $self->{_stats}->{fld}->{ $fld }++;                                  $self->{_stats}->{fld}->{ $fld }++;
# Line 385  sub open { Line 381  sub open {
381          $self->{max_pos} = $to_rec;          $self->{max_pos} = $to_rec;
382          $log->debug("max_pos: $to_rec");          $log->debug("max_pos: $to_rec");
383    
384            # save for dump
385            $self->{ll_db} = $ll_db;
386    
387          return $size;          return $size;
388  }  }
389    
# Line 424  sub fetch { Line 423  sub fetch {
423    
424          my $rec;          my $rec;
425    
426          if ($self->{low_mem}) {          if ($self->{load_row}) {
427                  $rec = $self->{db}->get($mfn);                  $rec = $self->{load_row}->({ id => $mfn });
428          } else {          } else {
429                  $rec = $self->{data}->{$mfn};                  $rec = $self->{data}->{$mfn};
430          }          }
# Line 480  First record in database has position 1. Line 479  First record in database has position 1.
479    
480  sub seek {  sub seek {
481          my $self = shift;          my $self = shift;
482          my $pos = shift || return;          my $pos = shift;
483    
484          my $log = $self->_get_logger();          my $log = $self->_get_logger();
485    
486            $log->logconfess("called without pos") unless defined($pos);
487    
488          if ($pos < 1) {          if ($pos < 1) {
489                  $log->warn("seek before first record");                  $log->warn("seek before first record");
490                  $pos = 1;                  $pos = 1;
# Line 518  sub stats { Line 519  sub stats {
519    
520          my $out = join("\n",          my $out = join("\n",
521                  map {                  map {
522                          my $f = $_ || die "no field";                          my $f = $_;
523                            die "no field in ", dump( $s->{fld} ) unless defined( $f );
524                          my $v = $s->{fld}->{$f} || die "no s->{fld}->{$f}";                          my $v = $s->{fld}->{$f} || die "no s->{fld}->{$f}";
525                          $max_fld = $v if ($v > $max_fld);                          $max_fld = $v if ($v > $max_fld);
526    
# Line 538  sub stats { Line 540  sub stats {
540                          }                          }
541    
542                          $o;                          $o;
543                  } sort { $a cmp $b } keys %{ $s->{fld} }                  } sort { $a <=> $b } keys %{ $s->{fld} }
544          );          );
545    
546          $log->debug( sub { Dumper($s) } );          $log->debug( sub { dump($s) } );
547    
548          return $out;          return $out;
549  }  }
550    
551  =head2 modify_record_regexps  =head2 dump_ascii
552    
553  Generate hash with regexpes to be applied using l<filter>.  Display humanly readable dump of record
554    
555    my $regexpes = $input->modify_record_regexps(  =cut
556                  900 => { '^a' => { ' : ' => '^b' } },  
557                  901 => { '*' => { '^b' => ' ; ' } },  sub dump_ascii {
558    );          my $self = shift;
559    
560            return unless $self->{ll_db};
561    
562            if ($self->{ll_db}->can('dump_ascii')) {
563                    return $self->{ll_db}->dump_ascii( $self->{pos} );
564            } else {
565                    return dump( $self->{ll_db}->fetch_rec( $self->{pos} ) );
566            }
567    }
568    
569    =head2 _get_regex
570    
571    Helper function called which create regexps to be execute on code.
572    
573      _get_regex( 900, 'regex:[0-9]+' ,'numbers' );
574      _get_regex( 900, '^b', ' : ^b' );
575    
576    It supports perl regexps with C<regex:> prefix to from value and has
577    additional logic to skip empty subfields.
578    
579  =cut  =cut
580    
581  sub _get_regex {  sub _get_regex {
582          my ($sf,$from,$to) = @_;          my ($sf,$from,$to) = @_;
583    
584            # protect /
585            $from =~ s!/!\\/!gs;
586            $to =~ s!/!\\/!gs;
587    
588            if ($from =~ m/^regex:(.+)$/) {
589                    $from = $1;
590            } else {
591                    $from = '\Q' . $from . '\E';
592            }
593          if ($sf =~ /^\^/) {          if ($sf =~ /^\^/) {
594                    my $need_subfield_data = '*';   # no
595                    # if from is also subfield, require some data in between
596                    # to correctly skip empty subfields
597                    $need_subfield_data = '+' if ($from =~ m/^\\Q\^/);
598                  return                  return
599                          's/\Q'. $sf .'\E([^\^]*?)\Q'. $from .'\E([^\^]*?)/'. $sf .'$1'. $to .'$2/';                          's/\Q'. $sf .'\E([^\^]' . $need_subfield_data . '?)'. $from .'([^\^]*?)/'. $sf .'$1'. $to .'$2/';
600          } else {          } else {
601                  return                  return
602                          's/\Q'. $from .'\E/'. $to .'/g';                          's/'. $from .'/'. $to .'/g';
603          }          }
604  }  }
605    
606    
607    =head2 modify_record_regexps
608    
609    Generate hash with regexpes to be applied using L<filter>.
610    
611      my $regexpes = $input->modify_record_regexps(
612                    900 => { '^a' => { ' : ' => '^b' } },
613                    901 => { '*' => { '^b' => ' ; ' } },
614      );
615    
616    =cut
617    
618  sub modify_record_regexps {  sub modify_record_regexps {
619          my $self = shift;          my $self = shift;
620          my $modify_record = {@_};          my $modify_record = {@_};
# Line 585  sub modify_record_regexps { Line 632  sub modify_record_regexps {
632                          foreach my $from (keys %{ $modify_record->{$f}->{$sf} }) {                          foreach my $from (keys %{ $modify_record->{$f}->{$sf} }) {
633                                  my $to = $modify_record->{$f}->{$sf}->{$from};                                  my $to = $modify_record->{$f}->{$sf}->{$from};
634                                  #die "no field?" unless defined($to);                                  #die "no field?" unless defined($to);
635                                  $log->debug("transform: |$from| -> |$to|");                                  my $d = "|$from| -> |$to|";
636                                    $log->debug("transform: $d");
637    
638                                  my $regex = _get_regex($sf,$from,$to);                                  my $regex = _get_regex($sf,$from,$to);
639                                  push @{ $regexpes->{$f} }, $regex;                                  push @{ $regexpes->{$f} }, { regex => $regex, debug => $d };
640                                  $log->debug("regex: $regex");                                  $log->debug("regex: $regex");
641                          }                          }
642                  }                  }
# Line 599  sub modify_record_regexps { Line 647  sub modify_record_regexps {
647    
648  =head2 modify_file_regexps  =head2 modify_file_regexps
649    
650  Generate hash with regexpes to be applied using l<filter> from  Generate hash with regexpes to be applied using L<filter> from
651  pseudo hash/yaml format for regex mappings.  pseudo hash/yaml format for regex mappings.
652    
653  It should be obvious:  It should be obvious:
# Line 627  sub modify_file_regexps { Line 675  sub modify_file_regexps {
675    
676          my $regexpes;          my $regexpes;
677    
678          CORE::open(my $fh, $modify_path) || $log->die("can't open modify file $modify_path: $!");          CORE::open(my $fh, $modify_path) || $log->logdie("can't open modify file $modify_path: $!");
679    
680          my ($f,$sf);          my ($f,$sf);
681    
# Line 649  sub modify_file_regexps { Line 697  sub modify_file_regexps {
697                          $log->debug("transform: |$from| -> |$to|");                          $log->debug("transform: |$from| -> |$to|");
698    
699                          my $regex = _get_regex($sf,$from,$to);                          my $regex = _get_regex($sf,$from,$to);
700                          push @{ $regexpes->{$f} }, $regex;                          push @{ $regexpes->{$f} }, {
701                                    regex => $regex,
702                                    file => $modify_path,
703                                    line => $.,
704                            };
705                          $log->debug("regex: $regex");                          $log->debug("regex: $regex");
706                  }                  }
707          }          }
# Line 657  sub modify_file_regexps { Line 709  sub modify_file_regexps {
709          return $regexpes;          return $regexpes;
710  }  }
711    
 =head1 MEMORY USAGE  
   
 C<low_mem> options is double-edged sword. If enabled, WebPAC  
 will run on memory constraint machines (which doesn't have enough  
 physical RAM to create memory structure for whole source database).  
   
 If your machine has 512Mb or more of RAM and database is around 10000 records,  
 memory shouldn't be an issue. If you don't have enough physical RAM, you  
 might consider using virtual memory (if your operating system is handling it  
 well, like on FreeBSD or Linux) instead of dropping to L<DBM::Deep> to handle  
 parsed structure of ISIS database (this is what C<low_mem> option does).  
   
 Hitting swap at end of reading source database is probably o.k. However,  
 hitting swap before 90% will dramatically decrease performance and you will  
 be better off with C<low_mem> and using rest of availble memory for  
 operating system disk cache (Linux is particuallary good about this).  
 However, every access to database record will require disk access, so  
 generation phase will be slower 10-100 times.  
   
 Parsed structures are essential - you just have option to trade RAM memory  
 (which is fast) for disk space (which is slow). Be sure to have planty of  
 disk space if you are using C<low_mem> and thus L<DBM::Deep>.  
   
 However, when WebPAC is running on desktop machines (or laptops :-), it's  
 highly undesireable for system to start swapping. Using C<low_mem> option can  
 reduce WecPAC memory usage to around 64Mb for same database with lookup  
 fields and sorted indexes which stay in RAM. Performance will suffer, but  
 memory usage will really be minimal. It might be also more confortable to  
 run WebPAC reniced on those machines.  
   
   
712  =head1 AUTHOR  =head1 AUTHOR
713    
714  Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>  Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>
Legend:
Removed from v.636  
changed lines
  Added in v.860
  ViewVC Help
Powered by ViewVC 1.1.26