Grutatxt.pm

   1 #####################################################################
   2 #
   3 #   Grutatxt - A text to HTML (and other things) converter
   4 #
   5 #   Copyright (C) 2000/2007 Angel Ortega <angel@triptico.com>
   6 #
   7 #   This program is free software; you can redistribute it and/or
   8 #   modify it under the terms of the GNU General Public License
   9 #   as published by the Free Software Foundation; either version 2
  10 #   of the License, or (at your option) any later version.
  11 #
  12 #   This program is distributed in the hope that it will be useful,
  13 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #   GNU General Public License for more details.
  16 #
  17 #   You should have received a copy of the GNU General Public License
  18 #   along with this program; if not, write to the Free Software
  19 #   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20 #
  21 #   http://www.triptico.com
  22 #
  23 #####################################################################
  24
  25 package Grutatxt;
  26
  27 use locale;
  28
  29 $VERSION = '2.0.14-dev';
  30
  31 =pod
  32
  33 =head1 NAME
  34
  35 Grutatxt - Text to HTML (and other formats) converter
  36
  37 =head1 SYNOPSIS
  38
  39  use Grutatxt;
  40
  41  # create a new Grutatxt converter object
  42  $grutatxt = new Grutatxt();
  43
  44  # process a Grutatxt format string
  45  @output = $grutatxt->process($text);
  46
  47  # idem for a file
  48  @output2 = $grutatxt->process_file($file);
  49
  50 =head1 DESCRIPTION
  51
  52 Grutatxt is a module to process text documents in
  53 a special markup format (also called Grutatxt), very
  54 similar to plain ASCII text. These documents can be
  55 converted to HTML, troff or man.
  56
  57 The markup is designed to be fairly intuitive and
  58 straightforward and can include headings, bold and italic
  59 text effects, bulleted, numbered and definition lists, URLs,
  60 function and variable names, preformatted text, horizontal
  61 separators and tables. Special marks can be inserted in the
  62 text and a heading-based structural index can be obtained
  63 from it.
  64
  65 A comprehensive description of the markup is defined in
  66 the README file, included with the Grutatxt package (it is
  67 written in Grutatxt format itself, so it can be converted
  68 using the I<grutatxt> tool to any of the supported formats).
  69 The latest version (and more information) can be retrieved
  70 from the Grutatxt home page at:
  71
  72  http://www.triptico.com/software/grutatxt.html
  73
  74 =head1 FUNCTIONS AND METHODS
  75
  76 =head2 B<new>
  77
  78  $grutatxt = new Grutatxt([ "mode"  => $mode, ]
  79                         [ "title" => \$title, ]
  80                         [ "marks" => \@marks, ]
  81                         [ "index" => \@index, ]
  82                         [ "abstract" => \$abstract, ]
  83                         [ "strip-parens" => $bool, ]
  84                         [ "strip-dollars" => $bool, ]
  85                         [ %driver_specific_arguments ] );
  86
  87 Creates a new Grutatxt object instance. All parameters are
  88 optional.
  89
  90 =over 4
  91
  92 =item I<mode>
  93
  94 Output format. Can be HTML, troff or man. HTML is used if not specified.
  95
  96 =item I<title>
  97
  98 If I<title> is specified as a reference to scalar, the first
  99 level 1 heading found in the text is stored inside it.
 100
 101 =item I<marks>
 102
 103 Marks in the Grutatxt markup are created by inserting the
 104 string <-> alone in a line. If I<marks> is specified as a
 105 reference to array, it will be filled with the subscripts
 106 (relative to the output array) of the lines where the marks
 107 are found in the text.
 108
 109 =item I<index>
 110
 111 If I<index> is specified as a reference to array, it will
 112 be filled with strings in the format
 113
 114  level,heading
 115
 116 This information can be used to build a table of contents
 117 of the processed text.
 118
 119 =item I<strip-parens>
 120
 121 Function names in the Grutatxt markup are strings of
 122 alphanumeric characters immediately followed by a pair
 123 of open and close parentheses. If this boolean value is
 124 set, function names found in the processed text will have
 125 their parentheses deleted.
 126
 127 =item I<strip-dollars>
 128
 129 Variable names in the Grutatxt markup are strings of
 130 alphanumeric characters preceded by a dollar sign.
 131 If this boolean value is set, variable names found in
 132 the processed text will have the dollar sign deleted.
 133
 134 =item I<abstract>
 135
 136 The I<abstract> of a Grutatxt document is the fragment of text
 137 from the beginning of the document to the end of the first
 138 paragraph after the title. If I<abstract> is specified as a
 139 reference to scalar, it will contain (after each call to the
 140 B<process()> method) the subscript of the element of the output
 141 array that marks the end of the subject.
 142
 143 =back
 144
 145 =cut
 146
 147 sub new
 148 {
 149         my ($class, %args) = @_;
 150         my ($gh);
 151
 152         $args{'mode'} ||= 'HTML';
 153
 154         $class .= "::" . $args{'mode'};
 155
 156         $gh = new $class(%args);
 157
 158         return $gh;
 159 }
 160
 161
 162 sub escape
 163 # escapes special characters, ignoring passthrough code
 164 {
 165         my ($gh, $l) = @_;
 166
 167         # splits between << and >>
 168         my (@l) = split(/(<<|>>)/, $l);
 169
 170         @l = map {
 171                         my $l = $_;
 172
 173                         # escape only text outside << and >>
 174                         unless ($l eq '<<' .. $l eq '>>') {
 175                                 $l = $gh->_escape($l);
 176                         }
 177
 178                         $_ = $l;
 179                 } @l;
 180
 181         # join again, stripping << and >>
 182         $l = join('', grep(!/^(<<|>>)$/, @l));
 183
 184         return $l;
 185 }
 186
 187
 188 =head2 B<process>
 189
 190  @output = $grutatxt->process($text);
 191
 192 Processes a text in Grutatxt format. The result is returned
 193 as an array of lines.
 194
 195 =cut
 196
 197 sub process
 198 {
 199         my ($gh, $content) = @_;
 200         my ($p);
 201
 202         # clean output
 203         @{$gh->{'o'}} = ();
 204
 205         # clean title and paragraph numbers
 206         $gh->{'-title'} = '';
 207         $gh->{'-p'} = 0;
 208
 209         # clean marks
 210         @{$gh->{'marks'}} = () if ref($gh->{'marks'});
 211
 212         # clean index
 213         @{$gh->{'index'}} = () if ref($gh->{'index'});
 214
 215         # reset abstract line
 216         ${$gh->{'abstract'}} = 0 if ref($gh->{'abstract'});
 217
 218         # insert prefix
 219         $gh->_prefix();
 220
 221         $gh->{'-mode'} = undef;
 222
 223         foreach my $l (split(/\n/,$content)) {
 224                 # inline data (passthrough)
 225                 if ($l =~ /^<<$/ .. $l =~ /^>>$/) {
 226                         $gh->_inline($l);
 227                         next;
 228                 }
 229
 230                 # marks
 231                 if ($l =~ /^\s*<\->\s*$/) {
 232                         push(@{$gh->{'marks'}},scalar(@{$gh->{'o'}}))
 233                                 if ref($gh->{'marks'});
 234
 235                         next;
 236                 }
 237
 238                 # escape possibly dangerous characters
 239                 $l = $gh->escape($l);
 240
 241                 # empty lines
 242                 $l =~ s/^\r$//ge;
 243                 if ($l =~ s/^$/$gh->_empty_line()/ge) {
 244                         # mark the abstract end
 245                         if ($gh->{'-title'}) {
 246                                 $gh->{'-p'}++;
 247
 248                                 # mark abstract if it's the
 249                                 # second paragraph from the title
 250                                 ${$gh->{'abstract'}} = scalar(@{$gh->{'o'}})-1
 251                                         if $gh->{'-p'} == 2;
 252                         }
 253                 }
 254
 255                 if ($gh->{'-process-urls'}) {
 256                         # URLs followed by a parenthesized phrase
 257                         $l =~ s/(https?:\/\/\S+)\s+\(([^\)]+)\)/$gh->_url($1,$2)/ge;
 258                         $l =~ s/(ftps?:\/\/\S+)\s+\(([^\)]+)\)/$gh->_url($1,$2)/ge;
 259                         $l =~ s/(file:\/?\S+)\s+\(([^\)]+)\)/$gh->_url($1,$2)/ge;
 260                         $l =~ s|(\s+)\./(\S+)\s+\(([^\)]+)\)|$1.$gh->_url($2,$3)|ge;
 261                         $l =~ s|^\./(\S+)\s+\(([^\)]+)\)|$gh->_url($1,$2)|ge;
 262
 263                         # URLs without phrase
 264                         $l =~ s/([^=][^\"])(https?:\/\/\S+)/$1.$gh->_url($2)/ge;
 265                         $l =~ s/([^=][^\"])(ftps?:\/\/\S+)/$1.$gh->_url($2)/ge;
 266                         $l =~ s/([^=][^\"])(file:\/?\S+)/$1.$gh->_url($2)/ge;
 267                         $l =~ s|(\s+)\./(\S+)|$1.$gh->_url($2)|ge;
 268
 269                         $l =~ s/^(https?:\/\/\S+)/$gh->_url($1)/ge;
 270                         $l =~ s/^(ftps?:\/\/\S+)/$gh->_url($1)/ge;
 271                         $l =~ s/^(file:\/?\S+)/$gh->_url($1)/ge;
 272                         $l =~ s|^\./(\S+)|$gh->_url($1)|ge;
 273                 }
 274
 275                 # change '''text''' and *text* into strong emphasis
 276                 $l =~ s/\'\'\'([^\'][^\'][^\']*)\'\'\'/$gh->_strong($1)/ge;
 277                 $l =~ s/\*(\S[^\*]+\S)\*/$gh->_strong($1)/ge;
 278                 $l =~ s/\*(\S+)\*/$gh->_strong($1)/ge;
 279
 280                 # change ''text'' and _text_ into emphasis
 281                 $l =~ s/\'\'([^\'][^\']*)\'\'/$gh->_em($1)/ge;
 282                 $l =~ s/\b_(\S[^_]*\S)_\b/$gh->_em($1)/ge;
 283                 $l =~ s/\b_(\S+)_\b/$gh->_em($1)/ge;
 284
 285                 # change `text' into code
 286                 $l =~ s/`([^\']*)\'/$gh->_code($1)/ge;
 287
 288                 # enclose function names
 289                 if ($gh->{'strip-parens'}) {
 290                         $l =~ s/(\w+)\(\)/$gh->_funcname($1)/ge;
 291                 }
 292                 else {
 293                         $l =~ s/(\w+)\(\)/$gh->_funcname($1."()")/ge;
 294                 }
 295
 296                 # enclose variable names
 297                 if ($gh->{'strip-dollars'}) {
 298                         $l =~ s/\$([\w_\.]+)/$gh->_varname($1)/ge;
 299                 }
 300                 else {
 301                         $l =~ s/(\$[\w_\.]+)/$gh->_varname($1)/ge;
 302                 }
 303
 304                 #
 305                 # main switch
 306                 #
 307
 308                 # definition list
 309                 if ($l =~ /^\s\*\s+/ && $l =~ s/^\s\*\s+([^:\.,;]+)\:\s+/$gh->_dl($1)/e) {
 310                         $gh->{'-mode-elems'} ++;
 311                 }
 312
 313                 # unsorted list
 314                 elsif ($gh->{'-mode'} ne 'pre' and
 315                      ($l =~ s/^(\s+)\*\s+/$gh->_unsorted_list($1)/e or
 316                       $l =~ s/^(\s+)\-\s+/$gh->_unsorted_list($1)/e)) {
 317                         $gh->{'-mode-elems'} ++;
 318                 }
 319
 320                 # sorted list
 321                 elsif ($gh->{'-mode'} ne 'pre' and
 322                      ($l =~ s/^(\s+)\#\s+/$gh->_ordered_list($1)/e or
 323                       $l =~ s/^(\s+)1\s+/$gh->_ordered_list($1)/e)) {
 324                         $gh->{'-mode-elems'} ++;
 325                 }
 326
 327                 # quoted block
 328                 elsif ($l =~ s/^\s\"/$gh->_blockquote()/e) {
 329                 }
 330
 331                 # table rows
 332                 elsif ($l =~ s/^\s*\|(.*)\|\s*$/$gh->_table_row($1)/e) {
 333                         $gh->{'-mode-elems'} ++;
 334                 }
 335
 336                 # table heading / end of row
 337                 elsif ($l =~ s/^\s*(\+[-\+\|]+\+)\s*$/$gh->_table($1)/e) {
 338                 }
 339
 340                 # preformatted text
 341                 elsif ($l =~ s/^(\s.*)$/$gh->_pre($1)/e) {
 342                 }
 343
 344                 # anything else
 345                 else {
 346                         # back to normal mode
 347                         $gh->_new_mode(undef);
 348                 }
 349
 350                 # 1 level heading
 351                 $l =~ s/^(=+)\s*$/$gh->_process_heading(1,$1)/e;
 352
 353                 # 2 level heading
 354                 $l =~ s/^(-+)\s*$/$gh->_process_heading(2,$1)/e;
 355
 356                 # 3 level heading
 357                 $l =~ s/^(~+)\s*$/$gh->_process_heading(3,$1)/e;
 358
 359                 # change ------ into hr
 360                 $l =~ s/^----*$/$gh->_hr()/e;
 361
 362                 # push finally
 363                 $gh->_push($l) if $l;
 364         }
 365
 366         # flush
 367         $gh->_new_mode(undef);
 368
 369         # postfix
 370         $gh->_postfix();
 371
 372         # set title
 373         ${$gh->{'title'}} = $gh->{'-title'} if ref($gh->{'title'});
 374
 375         # set abstract, if not set
 376         ${$gh->{'abstract'}} = scalar(@{$gh->{'o'}})
 377                 if ref($gh->{'abstract'}) and not ${$gh->{'abstract'}};
 378
 379         # travel all lines again, post-escaping
 380         @{$gh->{'o'}} = map { $_ = $gh->_escape_post($_); } @{$gh->{'o'}};
 381
 382         return @{$gh->{'o'}};
 383 }
 384
 385
 386 =head2 B<process_file>
 387
 388  @output = $grutatxt->process_file($filename);
 389
 390 Processes a file in Grutatxt format.
 391
 392 =cut
 393
 394 sub process_file
 395 {
 396         my ($gh, $file) = @_;
 397
 398         open F, $file or return(undef);
 399
 400         my ($content) = join('',<F>);
 401         close F;
 402
 403         return $gh->process($content);
 404 }
 405
 406
 407 sub _push
 408 {
 409         my ($gh, $l) = @_;
 410
 411         push(@{$gh->{'o'}},$l);
 412 }
 413
 414
 415 sub _process_heading
 416 {
 417         my ($gh, $level, $hd) = @_;
 418         my ($l);
 419
 420         $l = pop(@{$gh->{'o'}});
 421
 422         if ($l eq $gh->_empty_line()) {
 423                 $gh->_push($l);
 424                 return $hd;
 425         }
 426
 427         # store title
 428         $gh->{'-title'} = $l if $level == 1 and not $gh->{'-title'};
 429
 430         # store index
 431         if (ref($gh->{'index'})) {
 432                 push(@{$gh->{'index'}},"$level,$l");
 433         }
 434
 435         return $gh->_heading($level,$l);
 436 }
 437
 438
 439 sub _calc_col_span
 440 {
 441         my ($gh, $l) = @_;
 442         my (@spans);
 443
 444         # strip first + and all -
 445         $l =~ s/^\+//;
 446         $l =~ s/-//g;
 447
 448         my ($t) = 1; @spans = ();
 449         for (my $n = 0; $n < length($l); $n++) {
 450                 if (substr($l, $n, 1) eq '+') {
 451                         push(@spans, $t);
 452                         $t = 1;
 453                 }
 454                 else {
 455                         # it's a colspan mark:
 456                         # increment
 457                         $t++;
 458                 }
 459         }
 460
 461         return @spans;
 462 }
 463
 464
 465 sub _table_row
 466 {
 467         my ($gh, $str) = @_;
 468
 469         my @s = split(/\|/,$str);
 470
 471         for (my $n = 0; $n < scalar(@s); $n++) {
 472                 ${$gh->{'-table'}}[$n] .= ' ' . $s[$n];
 473         }
 474
 475         push(@{$gh->{'-table-raw'}}, $str);
 476
 477         return '';
 478 }
 479
 480
 481 sub _pre
 482 {
 483         my ($gh, $l) = @_;
 484
 485         # if any other mode is active, add to it
 486         if ($gh->{'-mode'} and $gh->{'-mode'} ne 'pre') {
 487                 $l =~ s/^\s+//;
 488
 489                 my ($a) = pop(@{$gh->{'o'}})." ".$l;
 490                 $gh->_push($a);
 491                 $l = '';
 492         }
 493         else {
 494                 # tabs to spaces if a non-zero tabsize is given (only in LaTex)
 495                 $l =~ s/\t/' ' x $gh->{'tabsize'}/ge if $gh->{'tabsize'} > 0;
 496
 497                 $gh->_new_mode('pre');
 498         }
 499
 500         return $l;
 501 }
 502
 503
 504 sub _multilevel_list
 505 {
 506         my ($gh, $str, $ind) = @_;
 507         my (@l,$level);
 508
 509         @l = @{$gh->{$str}};
 510         $ind = length($ind);
 511         $level = 0;
 512
 513         if ($l[-1] < $ind) {
 514                 # if last level is less indented, increase
 515                 # nesting level
 516                 push(@l, $ind);
 517                 $level++;
 518         }
 519         elsif ($l[-1] > $ind) {
 520                 # if last level is more indented, decrease
 521                 # levels until the same is found (or back to
 522                 # the beginning if not)
 523                 while (pop(@l)) {
 524                         $level--;
 525                         last if $l[-1] == $ind;
 526                 }
 527         }
 528
 529         $gh->{$str} = \@l;
 530
 531         return $level;
 532 }
 533
 534
 535 sub _unsorted_list
 536 {
 537         my ($gh, $ind) = @_;
 538
 539         return $gh->_ul($gh->_multilevel_list('-ul-levels', $ind));
 540 }
 541
 542
 543 sub _ordered_list
 544 {
 545         my ($gh, $ind) = @_;
 546
 547         return $gh->_ol($gh->_multilevel_list('-ol-levels', $ind));
 548 }
 549
 550
 551 # empty stubs for falling through the superclass
 552
 553 sub _inline { my ($gh, $l) = @_; $l; }
 554 sub _escape { my ($gh, $l) = @_; $l; }
 555 sub _escape_post { my ($gh, $l) = @_; $l; }
 556 sub _empty_line { my ($gh) = @_; ''; }
 557 sub _url { my ($gh, $url, $label) = @_; ''; }
 558 sub _strong { my ($gh, $str) = @_; $str; }
 559 sub _em { my ($gh, $str) = @_; $str; }
 560 sub _code { my ($gh, $str) = @_; $str; }
 561 sub _funcname { my ($gh, $str) = @_; $str; }
 562 sub _varname { my ($gh, $str) = @_; $str; }
 563 sub _new_mode { my ($gh, $mode) = @_; }
 564 sub _dl { my ($gh, $str) = @_; $str; }
 565 sub _ul { my ($gh, $level) = @_; ''; }
 566 sub _ol { my ($gh, $level) = @_; ''; }
 567 sub _blockquote { my ($gh, $str) = @_; $str; }
 568 sub _hr { my ($gh) = @_; ''; }
 569 sub _heading { my ($gh, $level, $l) = @_; $l; }
 570 sub _table { my ($gh, $str) = @_; $str; }
 571 sub _prefix { my ($gh) = @_; }
 572 sub _postfix { my ($gh) = @_; }
 573
 574 ###########################################################
 575
 576 =head1 DRIVER SPECIFIC INFORMATION
 577
 578 =cut
 579
 580 ###########################################################
 581 # HTML Driver
 582
 583 package Grutatxt::HTML;
 584
 585 @ISA = ("Grutatxt");
 586
 587 =head2 HTML Driver
 588
 589 The additional parameters for a new Grutatxt object are:
 590
 591 =over 4
 592
 593 =item I<table-headers>
 594
 595 If this boolean value is set, the first row in tables
 596 is assumed to be the heading and rendered using <th>
 597 instead of <td> tags.
 598
 599 =item I<center-tables>
 600
 601 If this boolean value is set, tables are centered.
 602
 603 =item I<expand-tables>
 604
 605 If this boolean value is set, tables are expanded (width 100%).
 606
 607 =item I<dl-as-dl>
 608
 609 If this boolean value is set, definition lists will be
 610 rendered using <dl>, <dt> and <dd> instead of tables.
 611
 612 =item I<header-offset>
 613
 614 Offset to be summed to the heading level when rendering
 615 <h?> tags (default is 0).
 616
 617 =item I<class-oddeven>
 618
 619 If this boolean value is set, tables will be rendered
 620 with an "oddeven" CSS class, and rows alternately classed
 621 as "even" or "odd". If it's not set, no CSS class info
 622 is added to tables.
 623
 624 =back
 625
 626 =cut
 627
 628 sub new
 629 {
 630         my ($class, %args) = @_;
 631         my ($gh);
 632
 633         bless(\%args, $class);
 634         $gh = \%args;
 635
 636         $gh->{'-process-urls'} = 1;
 637
 638         return $gh;
 639 }
 640
 641
 642 sub _inline
 643 {
 644         my ($gh, $l) = @_;
 645
 646         # accept unnamed and HTML inlines
 647         if ($l =~ /^<<$/ or $l =~ /^<<\s*html$/i) {
 648                 $gh->{'-inline'} = 'HTML';
 649                 return;
 650         }
 651
 652         if ($l =~ /^>>$/) {
 653                 delete $gh->{'-inline'};
 654                 return;
 655         }
 656
 657         if ($gh->{'-inline'} eq 'HTML') {
 658                 $gh->_push($l);
 659         }
 660 }
 661
 662
 663 sub _escape
 664 {
 665         my ($gh, $l) = @_;
 666
 667         $l =~ s/&/&amp;/g;
 668         $l =~ s/</&lt;/g;
 669         $l =~ s/>/&gt;/g;
 670
 671         return $l;
 672 }
 673
 674
 675 sub _empty_line
 676 {
 677         my ($gh) = @_;
 678
 679         return('<p>');
 680 }
 681
 682
 683 sub _url
 684 {
 685         my ($gh, $url, $label) = @_;
 686
 687         $label = $url unless $label;
 688
 689         return "<a href = '$url'>$label</a>";
 690 }
 691
 692
 693 sub _strong
 694 {
 695         my ($gh, $str) = @_;
 696         return "<strong>$str</strong>";
 697 }
 698
 699
 700 sub _em
 701 {
 702         my ($gh, $str) = @_;
 703         return "<em>$str</em>";
 704 }
 705
 706
 707 sub _code
 708 {
 709         my ($gh, $str) = @_;
 710         return "<code class = 'literal'>$str</code>";
 711 }
 712
 713
 714 sub _funcname
 715 {
 716         my ($gh, $str) = @_;
 717         return "<code class = 'funcname'>$str</code>";
 718 }
 719
 720
 721 sub _varname
 722 {
 723         my ($gh, $str) = @_;
 724         return "<code class = 'var'>$str</code>";
 725 }
 726
 727
 728 sub _new_mode
 729 {
 730         my ($gh, $mode, $params) = @_;
 731
 732         if ($mode ne $gh->{'-mode'}) {
 733                 my $tag;
 734
 735                 # clean list levels
 736                 if ($gh->{'-mode'} eq 'ul') {
 737                         $gh->_push('</ul>' x scalar(@{$gh->{'-ul-levels'}}));
 738                 }
 739                 elsif ($gh->{'-mode'} eq 'ol') {
 740                         $gh->_push('</ol>' x scalar(@{$gh->{'-ol-levels'}}));
 741                 }
 742                 elsif ($gh->{'-mode'}) {
 743                         $gh->_push("</$gh->{'-mode'}>");
 744                 }
 745
 746                 # send new one
 747                 $tag = $params ? "<$mode $params>" : "<$mode>";
 748                 $gh->_push($tag) if $mode;
 749
 750                 $gh->{'-mode'} = $mode;
 751                 $gh->{'-mode-elems'} = 0;
 752
 753                 # clean previous lists
 754                 $gh->{'-ul-levels'} = undef;
 755                 $gh->{'-ol-levels'} = undef;
 756         }
 757 }
 758
 759
 760 sub _dl
 761 {
 762         my ($gh, $str) = @_;
 763         my ($ret) = '';
 764
 765         if ($gh->{'dl-as-dl'}) {
 766                 $gh->_new_mode('dl');
 767                 $ret .= "<dt><strong class = 'term'>$str</strong><dd>";
 768         }
 769         else {
 770                 $gh->_new_mode('table');
 771                 $ret .= "<tr><td valign = 'top'><strong class = 'term'>$1</strong>&nbsp;&nbsp;</td><td valign = 'top'>";
 772         }
 773
 774         return $ret;
 775 }
 776
 777
 778 sub _ul
 779 {
 780         my ($gh, $levels) = @_;
 781         my ($ret);
 782
 783         $ret = '';
 784
 785         if ($levels > 0) {
 786                 $ret .= '<ul>';
 787         }
 788         elsif ($levels < 0) {
 789                 $ret .= '</ul>' x abs($levels);
 790         }
 791
 792         $gh->{'-mode'} = 'ul';
 793
 794         $ret .= '<li>';
 795
 796         return $ret;
 797 }
 798
 799
 800 sub _ol
 801 {
 802         my ($gh, $levels) = @_;
 803         my ($ret);
 804
 805         $ret = '';
 806
 807         if ($levels > 0) {
 808                 $ret = '<ol>';
 809         }
 810         elsif ($levels < 0) {
 811                 $ret = '</ol>' x abs($levels);
 812         }
 813
 814         $gh->{'-mode'} = 'ol';
 815
 816         $ret .= '<li>';
 817
 818         return $ret;
 819 }
 820
 821
 822 sub _blockquote
 823 {
 824         my ($gh) = @_;
 825
 826         $gh->_new_mode('blockquote');
 827         return "\"";
 828 }
 829
 830
 831 sub _hr
 832 {
 833         my ($gh) = @_;
 834
 835         return "<hr size = '1' noshade = 'noshade'>";
 836 }
 837
 838
 839 sub _heading
 840 {
 841         my ($gh, $level, $l) = @_;
 842
 843         # creates a valid anchor
 844         my ($a) = lc($l);
 845
 846         $a =~ s/[\"\'\/]//g;
 847         $a =~ s/\s/_/g;
 848         $a =~ s/<[^>]+>//g;
 849
 850         $l = sprintf("<a name = '%s'></a>\n<h%d class = 'level$level'>%s</h%d>",
 851                 $a, $level+$gh->{'header-offset'},
 852                 $l, $level+$gh->{'header-offset'});
 853
 854         return $l;
 855 }
 856
 857
 858 sub _table
 859 {
 860         my ($gh, $str) = @_;
 861
 862         if ($gh->{'-mode'} eq 'table') {
 863                 my ($class) = '';
 864                 my (@spans) = $gh->_calc_col_span($str);
 865
 866                 # calculate CSS class, if any
 867                 if ($gh->{'class-oddeven'}) {
 868                         $class = "class = '" . ($gh->{'-tbl-row'} & 1) ? "odd'" : "even'";
 869                 }
 870
 871                 $str = "<tr $class>";
 872
 873                 # build columns
 874                 for (my $n = 0; $n < scalar(@{$gh->{'-table'}}); $n++) {
 875                         my ($i,$s);
 876
 877                         $i = ${$gh->{'-table'}}[$n];
 878                         $i = "&nbsp;" if $i =~ /^\s*$/;
 879
 880                         $s = " colspan = '$spans[$n]'" if $spans[$n] > 1;
 881
 882                         if ($gh->{'table-headers'} and $gh->{'-tbl-row'} == 1) {
 883                                 $str .= "<th $class $s>$i</th>";
 884                         }
 885                         else {
 886                                 $str .= "<td $class $s>$i</td>";
 887                         }
 888                 }
 889
 890                 $str .= '</tr>';
 891
 892                 @{$gh->{'-table'}} = ();
 893                 $gh->{'-tbl-row'}++;
 894         }
 895         else {
 896                 # new table
 897                 my ($params);
 898
 899                 $params = "border = '1'";
 900                 $params .= " width = '100\%'" if $gh->{'expand-tables'};
 901                 $params .= " align = 'center'" if $gh->{'center-tables'};
 902                 $params .= " class = 'oddeven'" if $gh->{'class-oddeven'};
 903
 904                 $gh->_new_mode('table', $params);
 905
 906                 @{$gh->{'-table'}} = ();
 907                 $gh->{'-tbl-row'} = 1;
 908                 $str = '';
 909         }
 910
 911         return $str;
 912 }
 913
 914
 915 ###########################################################
 916 # troff Driver
 917
 918 package Grutatxt::troff;
 919
 920 @ISA = ("Grutatxt");
 921
 922 =head2 troff Driver
 923
 924 The troff driver uses the B<-me> macros and B<tbl>. A
 925 good way to post-process this output (to PostScript in
 926 the example) could be by using
 927
 928  groff -t -me -Tps
 929
 930 The additional parameters for a new Grutatxt object are:
 931
 932 =over 4
 933
 934 =item I<normal-size>
 935
 936 The point size of normal text. By default is 10.
 937
 938 =item I<heading-sizes>
 939
 940 This argument must be a reference to an array containing
 941 the size in points of the 3 different heading levels. By
 942 default, level sizes are [ 20, 18, 15 ].
 943
 944 =item I<table-type>
 945
 946 The type of table to be rendered by B<tbl>. Can be
 947 I<allbox> (all lines rendered; this is the default value),
 948 I<box> (only outlined) or I<doublebox> (only outlined by
 949 a double line).
 950
 951 =back
 952
 953 =cut
 954
 955 sub new
 956 {
 957         my ($class, %args) = @_;
 958         my ($gh);
 959
 960         bless(\%args,$class);
 961         $gh = \%args;
 962
 963         $gh->{'-process-urls'} = 0;
 964
 965         $gh->{'heading-sizes'} ||= [ 20, 18, 15 ];
 966         $gh->{'normal-size'} ||= 10;
 967         $gh->{'table-type'} ||= "allbox"; # box, allbox, doublebox
 968
 969         return $gh;
 970 }
 971
 972
 973 sub _prefix
 974 {
 975         my ($gh) = @_;
 976
 977         $gh->_push(".nr pp $gh->{'normal-size'}");
 978         $gh->_push(".nh");
 979 }
 980
 981
 982 sub _inline
 983 {
 984         my ($gh,$l) = @_;
 985
 986         # accept only troff inlines
 987         if ($l =~ /^<<\s*troff$/i) {
 988                 $gh->{'-inline'} = 'troff';
 989                 return;
 990         }
 991
 992         if ($l =~ /^>>$/) {
 993                 delete $gh->{'-inline'};
 994                 return;
 995         }
 996
 997         if ($gh->{'-inline'} eq 'troff') {
 998                 $gh->_push($l);
 999         }
1000 }
1001
1002
1003 sub _escape
1004 {
1005         my ($gh,$l) = @_;
1006
1007         $l =~ s/\\/\\\\/g;
1008         $l =~ s/^'/\\&'/;
1009
1010         return $l;
1011 }
1012
1013
1014 sub _empty_line
1015 {
1016         my ($gh) = @_;
1017
1018         return '.lp';
1019 }
1020
1021
1022 sub _strong
1023 {
1024         my ($gh, $str) = @_;
1025         return "\\fB$str\\fP";
1026 }
1027
1028
1029 sub _em
1030 {
1031         my ($gh, $str) = @_;
1032         return "\\fI$str\\fP";
1033 }
1034
1035
1036 sub _code
1037 {
1038         my ($gh, $str) = @_;
1039         return "\\fI$str\\fP";
1040 }
1041
1042
1043 sub _funcname
1044 {
1045         my ($gh, $str) = @_;
1046         return "\\fB$str\\fP";
1047 }
1048
1049
1050 sub _varname
1051 {
1052         my ($gh, $str) = @_;
1053         return "\\fI$str\\fP";
1054 }
1055
1056
1057 sub _new_mode
1058 {
1059         my ($gh, $mode, $params) = @_;
1060
1061         if ($mode ne $gh->{'-mode'}) {
1062                 my $tag;
1063
1064                 # flush previous list
1065                 if ($gh->{'-mode'} eq 'pre') {
1066                         $gh->_push('.)l');
1067                 }
1068                 elsif ($gh->{'-mode'} eq 'table') {
1069                         chomp($gh->{'-table-head'});
1070                         $gh->{'-table-head'} =~ s/\s+$//;
1071                         $gh->_push($gh->{'-table-head'} . '.');
1072                         $gh->_push($gh->{'-table-body'} . '.TE\n.sp 0.6');
1073                 }
1074                 elsif ($gh->{'-mode'} eq 'blockquote') {
1075                         $gh->_push('.)q');
1076                 }
1077
1078                 # send new one
1079                 if ($mode eq 'pre') {
1080                         $gh->_push('.(l L');
1081                 }
1082                 elsif ($mode eq 'blockquote') {
1083                         $gh->_push('.(q');
1084                 }
1085
1086                 $gh->{'-mode'} = $mode;
1087         }
1088 }
1089
1090
1091 sub _dl
1092 {
1093         my ($gh, $str) = @_;
1094
1095         $gh->_new_mode('dl');
1096         return ".ip \"$str\"\n";
1097 }
1098
1099
1100 sub _ul
1101 {
1102         my ($gh) = @_;
1103
1104         $gh->_new_mode('ul');
1105         return ".bu\n";
1106 }
1107
1108
1109 sub _ol
1110 {
1111         my ($gh) = @_;
1112
1113         $gh->_new_mode('ol');
1114         return ".np\n";
1115 }
1116
1117
1118 sub _blockquote
1119 {
1120         my ($gh) = @_;
1121
1122         $gh->_new_mode('blockquote');
1123         return "\"";
1124 }
1125
1126
1127 sub _hr
1128 {
1129         my ($gh) = @_;
1130
1131         return '.hl';
1132 }
1133
1134
1135 sub _heading
1136 {
1137         my ($gh, $level, $l) = @_;
1138
1139         $l = '.sz ' . ${$gh->{'heading-sizes'}}[$level - 1] . "\n$l\n.sp 0.6";
1140
1141         return $l;
1142 }
1143
1144
1145 sub _table
1146 {
1147         my ($gh, $str) = @_;
1148
1149         if ($gh->{'-mode'} eq 'table') {
1150                 my ($h, $b);
1151                 my (@spans) = $gh->_calc_col_span($str);
1152
1153                 # build columns
1154                 $h = '';
1155                 $b = '';
1156                 for (my $n = 0; $n < scalar(@{$gh->{'-table'}}); $n++) {
1157                         my ($i);
1158
1159                         if ($gh->{'table-headers'} and $gh->{'-tbl-row'} == 1) {
1160                                 $h .= 'cB ';
1161                         }
1162                         else {
1163                                 $h .= 'l ';
1164                         }
1165
1166                         # add span columns
1167                         $h .= 's ' x ($spans[$n] - 1) if $spans[$n] > 1;
1168
1169                         $b .= '#' if $n;
1170
1171                         $i = ${$gh->{'-table'}}[$n];
1172                         $i =~ s/^\s+//;
1173                         $i =~ s/\s+$//;
1174                         $i =~ s/(\s)+/$1/g;
1175                         $b .= $i;
1176                 }
1177
1178                 # add a separator
1179                 $b .= "\n_" if $gh->{'table-headers'} and
1180                              $gh->{'-tbl-row'} == 1 and
1181                              $gh->{'table-type'} ne "allbox";
1182
1183                 $gh->{'-table-head'} .= "$h\n";
1184                 $gh->{'-table-body'} .= "$b\n";
1185
1186                 @{$gh->{'-table'}} = ();
1187                 $gh->{'-tbl-row'}++;
1188         }
1189         else {
1190                 # new table
1191                 $gh->_new_mode('table');
1192
1193                 @{$gh->{'-table'}} = ();
1194                 $gh->{'-tbl-row'} = 1;
1195
1196                 $gh->{'-table-head'} = ".TS\n$gh->{'table-type'} tab (#);\n";
1197                 $gh->{'-table-body'} = '';
1198         }
1199
1200         $str = '';
1201         return $str;
1202 }
1203
1204
1205 sub _postfix
1206 {
1207         my ($gh) = @_;
1208
1209         # add to top headings and footers
1210         unshift(@{$gh->{'o'}},".ef '\%' ''");
1211         unshift(@{$gh->{'o'}},".of '' '\%'");
1212         unshift(@{$gh->{'o'}},".eh '$gh->{'-title'}' ''");
1213         unshift(@{$gh->{'o'}},".oh '' '$gh->{'-title'}'");
1214 }
1215
1216
1217 ###########################################################
1218 # man Driver
1219
1220 package Grutatxt::man;
1221
1222 @ISA = ("Grutatxt::troff", "Grutatxt");
1223
1224 =head2 man Driver
1225
1226 The man driver is used to generate Unix-like man pages. Note that
1227 all headings have the same level with this output driver.
1228
1229 The additional parameters for a new Grutatxt object are:
1230
1231 =over 4
1232
1233 =item I<section>
1234
1235 The man page section (see man documentation). By default is 1.
1236
1237 =item I<page-name>
1238
1239 The name of the page. This is usually the name of the program
1240 or function the man page is documenting and will be shown in the
1241 page header. By default is the empty string.
1242
1243 =back
1244
1245 =cut
1246
1247 sub new
1248 {
1249         my ($class, %args) = @_;
1250         my ($gh);
1251
1252         bless(\%args,$class);
1253         $gh = \%args;
1254
1255         $gh->{'-process-urls'} = 0;
1256
1257         $gh->{'section'} ||= 1;
1258         $gh->{'page-name'} ||= "";
1259
1260         return $gh;
1261 }
1262
1263
1264 sub _prefix
1265 {
1266         my ($gh) = @_;
1267
1268         $gh->_push(".TH \"$gh->{'page-name'}\" \"$gh->{'section'}\" \"" . localtime() . "\"");
1269 }
1270
1271
1272 sub _inline
1273 {
1274         my ($gh, $l) = @_;
1275
1276         # accept only man markup inlines
1277         if ($l =~ /^<<\s*man$/i) {
1278                 $gh->{'-inline'} = 'man';
1279                 return;
1280         }
1281
1282         if ($l =~ /^>>$/) {
1283                 delete $gh->{'-inline'};
1284                 return;
1285         }
1286
1287         if ($gh->{'-inline'} eq 'man') {
1288                 $gh->_push($l);
1289         }
1290 }
1291
1292
1293 sub _empty_line
1294 {
1295         my ($gh) = @_;
1296
1297         return ' ';
1298 }
1299
1300
1301 sub _new_mode
1302 {
1303         my ($gh,$mode,$params) = @_;
1304
1305         if ($mode ne $gh->{'-mode'}) {
1306                 my $tag;
1307
1308                 # flush previous list
1309                 if ($gh->{'-mode'} eq 'pre' or
1310                    $gh->{'-mode'} eq 'table') {
1311                         $gh->_push('.fi');
1312                 }
1313
1314                 if ($gh->{'-mode'} eq 'blockquote') {
1315                         $gh->_push('.RE');
1316                 }
1317
1318                 if ($gh->{'-mode'} eq 'ul') {
1319                         $gh->_push(".RE\n" x scalar(@{$gh->{'-ul-levels'}}));
1320                 }
1321
1322                 if ($gh->{'-mode'} eq 'ol') {
1323                         $gh->_push(".RE\n" x scalar(@{$gh->{'-ol-levels'}}));
1324                 }
1325
1326                 # send new one
1327                 if ($mode eq 'pre' or $mode eq 'table') {
1328                         $gh->_push('.nf');
1329                 }
1330
1331                 if ($mode eq 'blockquote') {
1332                         $gh->_push('.RS 4');
1333                 }
1334
1335                 $gh->{'-mode'} = $mode;
1336         }
1337 }
1338
1339
1340 sub _dl
1341 {
1342         my ($gh, $str) = @_;
1343
1344         $gh->_new_mode('dl');
1345         return ".TP\n.B \"$str\"\n";
1346 }
1347
1348
1349 sub _ul
1350 {
1351         my ($gh, $levels) = @_;
1352         my ($ret) = '';
1353
1354         if ($levels > 0) {
1355                 $ret = ".RS 4\n";
1356         }
1357         elsif ($levels < 0) {
1358                 $ret = ".RE\n" x abs($levels);
1359         }
1360
1361         $gh->_new_mode('ul');
1362         return $ret . ".TP 4\n\\(bu\n";
1363 }
1364
1365
1366 sub _ol
1367 {
1368         my ($gh, $levels) = @_;
1369         my $l = @{$gh->{'-ol-levels'}};
1370         my $ret = '';
1371
1372         $gh->{'-ol-level'} += $levels;
1373
1374         if ($levels > 0) {
1375                 $ret = ".RS 4\n";
1376
1377                 $l[$gh->{'-ol-level'}] = 1;
1378         }
1379         elsif ($levels < 0) {
1380                 $ret = ".RE\n" x abs($levels);
1381         }
1382
1383         $gh->_new_mode('ol');
1384         $ret .= ".TP 4\n" . $l[$gh->{'-ol-level'}]++ . ".\n";
1385
1386         return $ret;
1387 }
1388
1389
1390 sub _hr
1391 {
1392         my ($gh) = @_;
1393
1394         return '';
1395 }
1396
1397
1398 sub _heading
1399 {
1400         my ($gh, $level, $l) = @_;
1401
1402         # all headers are the same depth in man pages
1403         return ".SH \"" . uc($l) . "\"";
1404 }
1405
1406
1407 sub _table
1408 {
1409         my ($gh, $str) = @_;
1410
1411         if ($gh->{'-mode'} eq 'table') {
1412                 foreach my $r (@{$gh->{'-table-raw'}}) {
1413                         $gh->_push("|$r|");
1414                 }
1415         }
1416         else {
1417                 $gh->_new_mode('table');
1418         }
1419
1420         @{$gh->{'-table'}} = ();
1421         @{$gh->{'-table-raw'}} = ();
1422
1423         $gh->_push($str);
1424
1425         return '';
1426 }
1427
1428
1429 sub _postfix
1430 {
1431 }
1432
1433
1434 ###########################################################
1435 # latex Driver
1436
1437 package Grutatxt::latex;
1438
1439 @ISA = ("Grutatxt");
1440
1441 =head2 LaTeX Driver
1442
1443 The additional parameters for a new Grutatxt object are:
1444
1445 =over 4
1446
1447 =item I<docclass>
1448
1449 The LaTeX document class. By default is 'report'. You can also use
1450 'article' or 'book' (consult your LaTeX documentation for details).
1451
1452 =item I<papersize>
1453
1454 The paper size to be used in the document. By default is 'a4paper'.
1455
1456 =item I<encoding>
1457
1458 The character encoding used in the document. By default is 'latin1'.
1459
1460 =back
1461
1462 Note that you can't nest further than 4 levels in LaTeX; if you do,
1463 LaTeX will choke in the generated code with a 'Too deeply nested' error.
1464
1465 =cut
1466
1467 sub new
1468 {
1469         my ($class, %args) = @_;
1470         my ($gh);
1471
1472         bless(\%args,$class);
1473         $gh = \%args;
1474
1475         $gh->{'-process-urls'} = 0;
1476
1477         $gh->{'-docclass'} ||= 'report';
1478         $gh->{'-papersize'} ||= 'a4paper';
1479         $gh->{'-encoding'} ||= 'latin1';
1480
1481         return $gh;
1482 }
1483
1484
1485 sub _prefix
1486 {
1487         my ($gh) = @_;
1488
1489         $gh->_push("\\documentclass[$gh->{'-papersize'}]{$gh->{-docclass}}");
1490         $gh->_push("\\usepackage[$gh->{'-encoding'}]{inputenc}");
1491
1492         $gh->_push("\\begin{document}");
1493 }
1494
1495
1496 sub _inline
1497 {
1498         my ($gh, $l) = @_;
1499
1500         # accept only latex inlines
1501         if ($l =~ /^<<\s*latex$/i) {
1502                 $gh->{'-inline'} = 'latex';
1503                 return;
1504         }
1505
1506         if ($l =~ /^>>$/) {
1507                 delete $gh->{'-inline'};
1508                 return;
1509         }
1510
1511         if ($gh->{'-inline'} eq 'latex') {
1512                 $gh->_push($l);
1513         }
1514 }
1515
1516
1517 sub _escape
1518 {
1519         my ($gh, $l) = @_;
1520
1521         $l =~ s/ _ / \\_ /g;
1522         $l =~ s/ ~ / \\~ /g;
1523         $l =~ s/ & / \\& /g;
1524
1525         return $l;
1526 }
1527
1528
1529 sub _escape_post
1530 {
1531         my ($gh, $l) = @_;
1532
1533         $l =~ s/ # / \\# /g;
1534         $l =~ s/^\\n$//g;
1535         $l =~ s/([^\s_])_([^\s_])/$1\\_$2/g;
1536
1537         return $l;
1538 }
1539
1540
1541 sub _empty_line
1542 {
1543         my ($gh) = @_;
1544
1545         return "\\n";
1546 }
1547
1548
1549 sub _strong
1550 {
1551         my ($gh, $str) = @_;
1552         return "\\textbf{$str}";
1553 }
1554
1555
1556 sub _em
1557 {
1558         my ($gh, $str) = @_;
1559         return "\\emph{$str}";
1560 }
1561
1562
1563 sub _code
1564 {
1565         my ($gh, $str) = @_;
1566         return "{\\tt $str}";
1567 }
1568
1569
1570 sub _funcname
1571 {
1572         my ($gh, $str) = @_;
1573         return "{\\tt $str}";
1574 }
1575
1576
1577 sub _varname
1578 {
1579         my ($gh, $str) = @_;
1580
1581         $str =~ s/^\$/\\\$/;
1582
1583         return "{\\tt $str}";
1584 }
1585
1586
1587 sub _new_mode
1588 {
1589         my ($gh, $mode, $params) = @_;
1590
1591         # mode equivalences
1592         my %latex_modes = (
1593                 'pre'           =>      'verbatim',
1594                 'blockquote'    =>      'quote',
1595                 'table'         =>      'tabular',
1596                 'dl'            =>      'description',
1597                 'ul'            =>      'itemize',
1598                 'ol'            =>      'enumerate'
1599         );
1600
1601         if ($mode ne $gh->{'-mode'}) {
1602                 # close previous mode
1603                 if ($gh->{'-mode'} eq 'ul') {
1604                         $gh->_push("\\end{itemize}" x scalar(@{$gh->{'-ul-levels'}}));
1605                 }
1606                 elsif ($gh->{'-mode'} eq 'ol') {
1607                         $gh->_push("\\end{enumerate}" x scalar(@{$gh->{'-ol-levels'}}));
1608                 }
1609                 elsif ($gh->{'-mode'} eq 'table') {
1610                         $gh->_push("\\end{tabular}\n");
1611                 }
1612                 else {
1613                         $gh->_push("\\end{" . $latex_modes{$gh->{'-mode'}} . "}")
1614                         if $gh->{'-mode'};
1615                 }
1616
1617                 # send new one
1618                 $gh->_push("\\begin{" . $latex_modes{$mode} . "}" . $params)
1619                         if $mode;
1620
1621                 $gh->{'-mode'} = $mode;
1622
1623                 $gh->{'-ul-levels'} = undef;
1624                 $gh->{'-ol-levels'} = undef;
1625         }
1626 }
1627
1628
1629 sub _dl
1630 {
1631         my ($gh, $str) = @_;
1632
1633         $gh->_new_mode('dl');
1634         return "\\item[$str]\n";
1635 }
1636
1637
1638 sub _ul
1639 {
1640         my ($gh, $levels) = @_;
1641         my ($ret);
1642
1643         $ret = '';
1644
1645         if ($levels > 0) {
1646                 $ret .= "\\begin{itemize}\n";
1647         }
1648         elsif ($levels < 0) {
1649                 $ret .= "\\end{itemize}\n" x abs($levels);
1650         }
1651
1652         $gh->{'-mode'} = 'ul';
1653
1654         $ret .= "\\item\n";
1655
1656         return $ret;
1657 }
1658
1659
1660 sub _ol
1661 {
1662         my ($gh, $levels) = @_;
1663         my ($ret);
1664
1665         $ret = '';
1666
1667         if ($levels > 0) {
1668                 $ret .= "\\begin{enumerate}\n";
1669         }
1670         elsif ($levels < 0) {
1671                 $ret .= "\\end{enumerate}\n" x abs($levels);
1672         }
1673
1674         $gh->{'-mode'} = 'ol';
1675
1676         $ret .= "\\item\n";
1677
1678         return $ret;
1679 }
1680
1681
1682 sub _blockquote
1683 {
1684         my ($gh) = @_;
1685
1686         $gh->_new_mode('blockquote');
1687         return "``";
1688 }
1689
1690
1691 sub _hr
1692 {
1693         my ($gh) = @_;
1694
1695         return "------------\n";
1696 }
1697
1698
1699 sub _heading
1700 {
1701         my ($gh, $level, $l) = @_;
1702
1703         my @latex_headings = ( "\\section*{", "\\subsection*{",
1704                 "\\subsubsection*{");
1705
1706         $l = "\n" . $latex_headings[$level - 1] . $l . "}";
1707
1708         return $l;
1709 }
1710
1711
1712 sub _table
1713 {
1714         my ($gh,$str) = @_;
1715
1716         if ($gh->{'-mode'} eq 'table') {
1717                 my ($class) = '';
1718                 my (@spans) = $gh->_calc_col_span($str);
1719                 my (@cols);
1720
1721                 $str = '';
1722
1723                 # build columns
1724                 for (my $n = 0; $n < scalar(@{$gh->{'-table'}}); $n++) {
1725                         my ($i, $s);
1726
1727                         $i = ${$gh->{'-table'}}[$n];
1728                         $i = "&nbsp;" if $i =~ /^\s*$/;
1729
1730 #                       $s = " colspan='$spans[$n]'" if $spans[$n] > 1;
1731
1732                         # multispan columns
1733                         $i = "\\multicolumn{$spans[$n]}{|l|}{$i}"
1734                                 if $spans[$n] > 1;
1735
1736                         $i =~ s/\s{2,}/ /g;
1737                         $i =~ s/^\s+//;
1738                         $i =~ s/\s+$//;
1739
1740                         push(@cols, $i);
1741                 }
1742
1743                 $str .= join('&', @cols) . "\\\\\n\\hline";
1744
1745 #               $str .= "\n\\hline" if $gh->{'-tbl-row'} == 1;
1746
1747                 @{$gh->{'-table'}} = ();
1748                 $gh->{'-tbl-row'}++;
1749         }
1750         else {
1751                 # new table
1752
1753                 # count the number of columns
1754                 $str =~ s/[^\+]//g;
1755                 my $params = "{" . "|l" x (length($str) - 1) . "|}\n\\hline";
1756
1757                 $gh->_push();
1758                 $gh->_new_mode('table', $params);
1759
1760                 @{$gh->{'-table'}} = ();
1761                 $gh->{'-tbl-row'} = 1;
1762                 $str = '';
1763         }
1764
1765         return $str;
1766 }
1767
1768
1769 sub _postfix
1770 {
1771         my ($gh) = @_;
1772
1773         $gh->_push("\\end{document}");
1774 }
1775
1776
1777 =head1 AUTHOR
1778
1779 Angel Ortega angel@triptico.com
1780
1781 =cut
1782
1783 1;