Grutatxt.pm

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