JezK
Edit File: subs.pl
#! /usr/bin/perl # grog - guess options for groff command # Inspired by doctype script in Kernighan & Pike, Unix Programming # Environment, pp 306-8. # Source file position: <groff-source>/src/roff/grog/subs.pl # Installed position: <prefix>/lib/grog/subs.pl # Copyright (C) 1993-2018 Free Software Foundation, Inc. # This file was split from grog.pl and put under GPL2 by # Bernd Warken <groff-bernd.warken-72@web.de>. # The macros for identifying the devices were taken from Ralph # Corderoy's 'grog.sh' of 2006. # Last update: 10 Sep 2015 # This file is part of 'grog', which is part of 'groff'. # 'groff' is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # 'groff' is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # You can get the license text for the GNU General Public License # version 2 in the internet at # <http://www.gnu.org/licenses/gpl-2.0.html>. ######################################################################## require v5.6; use warnings; use strict; use File::Spec; # printing of hashes: my %hash = ...; print Dumper(\%hash); use Data::Dumper; # for running shell based programs within Perl; use `` instead of # use IPC::System::Simple qw(capture capturex run runx system systemx); $\ = "\n"; # my $Sp = "[\\s\\n]"; # my $Sp = qr([\s\n]); # my $Sp = '' if $arg eq '-C'; my $Sp = ''; # from 'src/roff/groff/groff.cpp' near 'getopt_long' my $groff_opts = 'abcCd:D:eEf:F:gGhiI:jJkK:lL:m:M:n:No:pP:r:RsStT:UvVw:W:XzZ'; my @Command = (); # stores the final output my @Mparams = (); # stores the options '-m*' my @devices = (); # stores -T my $do_run = 0; # run generated 'groff' command my $pdf_with_ligatures = 0; # '-P-y -PU' for 'pdf' device my $with_warnings = 0; my $Prog = $0; { my ($v, $d, $f) = File::Spec->splitpath($Prog); $Prog = $f; } my %macros; my %Groff = ( # preprocessors 'chem' => 0, 'eqn' => 0, 'gperl' => 0, 'grap' => 0, 'grn' => 0, 'gideal' => 0, 'gpinyin' => 0, 'lilypond' => 0, 'pic' => 0, 'PS' => 0, # opening for pic 'PF' => 0, # alternative opening for pic 'PE' => 0, # closing for pic 'refer' => 0, 'refer_open' => 0, 'refer_close' => 0, 'soelim' => 0, 'tbl' => 0, # tmacs # 'man' => 0, # 'mandoc' => 0, # 'mdoc' => 0, # 'mdoc_old' => 0, # 'me' => 0, # 'mm' => 0, # 'mom' => 0, # 'ms' => 0, # requests 'AB' => 0, # ms 'AE' => 0, # ms 'AI' => 0, # ms 'AU' => 0, # ms 'NH' => 0, # ms 'TH_later' => 0, # TH not 1st command is ms 'TL' => 0, # ms 'UL' => 0, # ms 'XP' => 0, # ms 'IP' => 0, # man and ms 'LP' => 0, # man and ms 'P' => 0, # man and ms 'PP' => 0, # man and ms 'SH' => 0, # man and ms 'OP' => 0, # man 'SS' => 0, # man 'SY' => 0, # man 'TH_first' => 0, # TH as 1st command is man 'TP' => 0, # man 'UR' => 0, # man 'YS' => 0, # man # for mdoc and mdoc-old # .Oo and .Oc for modern mdoc, only .Oo for mdoc-old 'Oo' => 0, # mdoc and mdoc-old 'Oc' => 0, # mdoc 'Dd' => 0, # mdoc ); # end of %Groff # for first line check my %preprocs_tmacs = ( 'chem' => 0, 'eqn' => 0, 'gideal' => 0, 'gpinyin' => 0, 'grap' => 0, 'grn' => 0, 'pic' => 0, 'refer' => 0, 'soelim' => 0, 'tbl' => 0, 'geqn' => 0, 'gpic' => 0, 'neqn' => 0, 'man' => 0, 'mandoc' => 0, 'mdoc' => 0, 'mdoc-old' => 0, 'me' => 0, 'mm' => 0, 'mom' => 0, 'ms' => 0, ); my @filespec; my $tmac_ext = ''; ######################################################################## # err() ######################################################################## sub err { my $text = shift; print STDERR $text; } ######################################################################## # handle_args() ######################################################################## sub handle_args { my $double_minus = 0; my $was_minus = 0; my $was_T = 0; my $optarg = 0; # globals: @filespec, @Command, @devices, @Mparams foreach my $arg (@ARGV) { if ( $optarg ) { push @Command, $arg; $optarg = 0; next; } if ( $double_minus ) { if (-f $arg && -r $arg) { push @filespec, $arg; } else { print STDERR __FILE__ . ' ' . __LINE__ . ': ' . "grog: $arg is not a readable file."; } next; } if ( $was_T ) { push @devices, $arg; $was_T = 0; next; } ####### handle_args() unless ( $arg =~ /^-/ ) { # file name, no opt, no optarg unless (-f $arg && -r $arg) { print 'unknown file name: ' . $arg; } push @filespec, $arg; next; } # now $arg starts with '-' if ($arg eq '-') { unless ($was_minus) { push @filespec, $arg; $was_minus = 1; } next; } if ($arg eq '--') { $double_minus = 1; push(@filespec, $arg); next; } &version() if $arg =~ /^--?v/; # --version, with exit &help() if $arg =~ /--?h/; # --help, with exit if ( $arg =~ /^--r/ ) { # --run, no exit $do_run = 1; next; } if ( $arg =~ /^--wa/ ) { # --warnings, no exit $with_warnings = 1; next; } ####### handle_args() if ( $arg =~ /^--(wi|l)/ ) { # --ligatures, no exit # the old --with_ligatures is only kept for compatibility $pdf_with_ligatures = 1; next; } if ($arg =~ /^-m/) { push @Mparams, $arg; next; } if ($arg =~ /^-T$/) { $was_T = 1; next; } if ($arg =~ s/^-T(\w+)$/$1/) { push @devices, $1; next; } if ($arg =~ /^-(\w)(\w*)$/) { # maybe a groff option my $opt_char = $1; my $opt_char_with_arg = $opt_char . ':'; my $others = $2; if ( $groff_opts =~ /$opt_char_with_arg/ ) { # groff optarg if ( $others ) { # optarg is here push @Command, '-' . $opt_char; push @Command, '-' . $others; next; } # next arg is optarg $optarg = 1; next; ####### handle_args() } elsif ( $groff_opts =~ /$opt_char/ ) { # groff no optarg push @Command, '-' . $opt_char; if ( $others ) { # $others is now an opt collection $arg = '-' . $others; redo; } # arg finished next; } else { # not a groff opt print STDERR __FILE__ . ' ' . __LINE__ . ': ' . 'unknown argument ' . $arg; push(@Command, $arg); next; } } } @filespec = ('-') unless (@filespec); } # handle_args() ######################################################################## # handle_file_ext() ######################################################################## sub handle_file_ext { # get tmac from file name extension # output number of found single tmac # globals: @filespec, $tmac_ext; foreach my $file ( @filespec ) { # test for each file name in the arguments unless ( open(FILE, $file eq "-" ? $file : "< $file") ) { print STDERR __FILE__ . ' ' . __LINE__ . ': ' . "$Prog: can't open \'$file\': $!"; next; } next unless ( $file =~ /\./ ); # file name has no dot '.' ##### handle_file_ext() # get extension my $ext = $file; $ext =~ s/^ .* \. ([^.]*) $ /$1/x; next unless ( $ext ); ##### handle_file_ext() # these extensions are correct, but not based on a tmac next if ( $ext =~ /^( chem| eqn| g| grap| grn| groff| hdtbl| pdfroff| pic| pinyin| ref| roff| t| tbl| tr| www )$/x ); ##### handle_file_ext() # extensions for man tmac if ( $ext =~ /^( [1-9lno]| man| n| 1b )$/x ) { # 'man|n' from 'groff' source # '1b' from 'heirloom' # '[1-9lno]' from man-pages if ( $tmac_ext && $tmac_ext ne 'man' ) { # found tmac is not 'man' print STDERR __FILE__ . ' ' . __LINE__ . ': ' . '2 different file name extensions found ' . $tmac_ext . ' and ' . $ext; $tmac_ext = ''; next; } ##### handle_file_ext() $tmac_ext = 'man'; next; } if ( $ext =~ /^( mandoc| mdoc| me| mm| mmse| mom| ms| $)/x ) { if ( $tmac_ext && $tmac_ext ne $ext ) { # found tmac is not identical to former found tmac ##### handle_file_ext() print STDERR __FILE__ . ' ' . __LINE__ . ': ' . '2 different file name extensions found ' . $tmac_ext . ' and ' . $ext; $tmac_ext = ''; next; } $tmac_ext = $ext; next; } print STDERR __FILE__ . ' ' . __LINE__ . ': ' . 'Unknown file name extension '. $file . '.'; next; } # end foreach file 1; } # handle_file_ext() ######################################################################## # handle_whole_files() ######################################################################## sub handle_whole_files { # globals: @filespec foreach my $file ( @filespec ) { unless ( open(FILE, $file eq "-" ? $file : "< $file") ) { print STDERR __FILE__ . ' ' . __LINE__ . ': ' . "$Prog: can't open \'$file\': $!"; next; } my $line = <FILE>; # get single line unless ( defined($line) ) { # empty file, go to next filearg close (FILE); next; } if ( $line ) { chomp $line; unless ( &do_first_line( $line, $file ) ) { # not an option line &do_line( $line, $file ); } } else { # empty line next; } while (<FILE>) { # get lines by and by chomp; &do_line( $_, $file ); } close(FILE); } # end foreach } # handle_whole_files() ######################################################################## # do_first_line() ######################################################################## # As documented for the 'man' program, the first line can be # used as a groff option line. This is done by: # - start the line with '\" (apostrophe, backslash, double quote) # - add a space character # - a word using the following characters can be appended: 'egGjJpRst'. # Each of these characters means an option for the generated # 'groff' command line, e.g. '-t'. sub do_first_line { my ( $line, $file ) = @_; # globals: %preprocs_tmacs # For a leading groff options line use only [egGjJpRst] if ( $line =~ /^[.']\\"[\segGjJpRst]+&/ ) { # this is a groff options leading line if ( $line =~ /^\./ ) { # line is a groff options line with . instead of ' print "First line in $file must start with an apostrophe \ " . "instead of a period . for groff options line!"; } if ( $line =~ /j/ ) { $Groff{'chem'}++; } if ( $line =~ /e/ ) { $Groff{'eqn'}++; } if ( $line =~ /g/ ) { $Groff{'grn'}++; } if ( $line =~ /G/ ) { $Groff{'grap'}++; } if ( $line =~ /i/ ) { $Groff{'gideal'}++; } if ( $line =~ /p/ ) { $Groff{'pic'}++; } if ( $line =~ /R/ ) { $Groff{'refer'}++; } if ( $line =~ /s/ ) { $Groff{'soelim'}++; } ####### do_first_line() if ( $line =~ /t/ ) { $Groff{'tbl'}++; } return 1; # a leading groff options line, 1 means yes, 0 means no } # not a leading short groff options line return 0 if ( $line !~ /^[.']\\"\s*(.*)$/ ); # ignore non-comments return 0 unless ( $1 ); # for empty comment # all following array members are either preprocs or 1 tmac my @words = split '\s+', $1; my @in = (); my $word; for $word ( @words ) { if ( $word eq 'ideal' ) { $word = 'gideal'; } elsif ( $word eq 'gpic' ) { $word = 'pic'; } elsif ( $word =~ /^(gn|)eqn$/ ) { $word = 'eqn'; } if ( exists $preprocs_tmacs{$word} ) { push @in, $word; } else { # not word for preproc or tmac return 0; } } for $word ( @in ) { $Groff{$word}++; } } # do_first_line() ######################################################################## # do_line() ######################################################################## my $before_first_command = 1; # for check of .TH sub do_line { my ( $line, $file ) = @_; return if ( $line =~ /^[.']\s*\\"/ ); # comment return unless ( $line =~ /^[.']/ ); # ignore text lines $line =~ s/^['.]\s*/./; # let only a dot as leading character, # remove spaces after the leading dot $line =~ s/\s+$//; # remove final spaces return if ( $line =~ /^\.$/ ); # ignore . return if ( $line =~ /^\.\.$/ ); # ignore .. if ( $before_first_command ) { # so far without 1st command if ( $line =~ /^\.TH/ ) { # check if .TH is 1st command for man $Groff{'TH_first'} = 1 if ( $line =~ /^\.\s*TH/ ); } if ( $line =~ /^\./ ) { $before_first_command = 0; } } # split command $line =~ /^(\.\w+)\s*(.*)$/; my $command = $1; $command = '' unless ( defined $command ); my $args = $2; $args = '' unless ( defined $args ); ###################################################################### # soelim if ( $line =~ /^\.(do)?\s*(so|mso|PS\s*<|SO_START).*$/ ) { # '.so', '.mso', '.PS<...', '.SO_START' $Groff{'soelim'}++; return; } if ( $line =~ /^\.(do)?\s*(so|mso|PS\s*<|SO_START).*$/ ) { # '.do so', '.do mso', '.do PS<...', '.do SO_START' $Groff{'soelim'}++; return; } ####### do_line() ###################################################################### # macros if ( $line =~ /^\.de1?\W?/ ) { # this line is a macro definition, add it to %macros my $macro = $line; $macro =~ s/^\.de1?\s+(\w+)\W*/.$1/; return if ( exists $macros{$macro} ); $macros{$macro} = 1; return; } # if line command is a defined macro, just ignore this line return if ( exists $macros{$command} ); ###################################################################### # preprocessors if ( $command =~ /^(\.cstart)|(begin\s+chem)$/ ) { $Groff{'chem'}++; # for chem return; } if ( $command =~ /^\.EQ$/ ) { $Groff{'eqn'}++; # for eqn return; } if ( $command =~ /^\.G1$/ ) { $Groff{'grap'}++; # for grap return; } if ( $command =~ /^\.Perl/ ) { $Groff{'gperl'}++; # for gperl return; } if ( $command =~ /^\.pinyin/ ) { $Groff{'gpinyin'}++; # for gperl return; } if ( $command =~ /^\.GS$/ ) { $Groff{'grn'}++; # for grn return; } if ( $command =~ /^\.IS$/ ) { $Groff{'gideal'}++; # preproc gideal for ideal return; } if ( $command =~ /^\.lilypond$/ ) { $Groff{'lilypond'}++; # for glilypond return; } ####### do_line() # pic can be opened by .PS or .PF and closed by .PE if ( $command =~ /^\.PS$/ ) { $Groff{'pic'}++; # normal opening for pic return; } if ( $command =~ /^\.PF$/ ) { $Groff{'PF'}++; # alternate opening for pic return; } if ( $command =~ /^\.PE$/ ) { $Groff{'PE'}++; # closing for pic return; } if ( $command =~ /^\.R1$/ ) { $Groff{'refer'}++; # for refer return; } if ( $command =~ /^\.\[$/ ) { $Groff{'refer_open'}++; # for refer open return; } if ( $command =~ /^\.\]$/ ) { $Groff{'refer_close'}++; # for refer close return; } if ( $command =~ /^\.TS$/ ) { $Groff{'tbl'}++; # for tbl return; } if ( $command =~ /^\.TH$/ ) { unless ( $Groff{'TH_first'} ) { $Groff{'TH_later'}++; # for tbl } return; } ###################################################################### # macro package (tmac) ###################################################################### ########## # modern mdoc if ( $command =~ /^\.(Dd)$/ ) { $Groff{'Dd'}++; # for modern mdoc return; } ####### do_line() # In the old version of -mdoc 'Oo' is a toggle, in the new it's # closed by 'Oc'. if ( $command =~ /^\.Oc$/ ) { $Groff{'Oc'}++; # only for modern mdoc return; } ########## # old and modern mdoc if ( $command =~ /^\.Oo$/ ) { $Groff{'Oo'}++; # for mdoc and mdoc-old return; } ########## # old mdoc if ( $command =~ /^\.(Tp|Dp|De|Cx|Cl)$/ ) { $Groff{'mdoc_old'}++; # true for old mdoc return; } ########## # for ms ####### do_line() if ( $command =~ /^\.AB$/ ) { $Groff{'AB'}++; # for ms return; } if ( $command =~ /^\.AE$/ ) { $Groff{'AE'}++; # for ms return; } if ( $command =~ /^\.AI$/ ) { $Groff{'AI'}++; # for ms return; } if ( $command =~ /^\.AU$/ ) { $Groff{'AU'}++; # for ms return; } if ( $command =~ /^\.NH$/ ) { $Groff{'NH'}++; # for ms return; } if ( $command =~ /^\.TL$/ ) { $Groff{'TL'}++; # for ms return; } if ( $command =~ /^\.XP$/ ) { $Groff{'XP'}++; # for ms return; } ########## # for man and ms if ( $command =~ /^\.IP$/ ) { $Groff{'IP'}++; # for man and ms return; } if ( $command =~ /^\.LP$/ ) { $Groff{'LP'}++; # for man and ms return; } ####### do_line() if ( $command =~ /^\.P$/ ) { $Groff{'P'}++; # for man and ms return; } if ( $command =~ /^\.PP$/ ) { $Groff{'PP'}++; # for man and ms return; } if ( $command =~ /^\.SH$/ ) { $Groff{'SH'}++; # for man and ms return; } if ( $command =~ /^\.UL$/ ) { $Groff{'UL'}++; # for man and ms return; } ########## # for man only if ( $command =~ /^\.OP$/ ) { # for man $Groff{'OP'}++; return; } if ( $command =~ /^\.SS$/ ) { # for man $Groff{'SS'}++; return; } if ( $command =~ /^\.SY$/ ) { # for man $Groff{'SY'}++; return; } if ( $command =~ /^\.TP$/ ) { # for man $Groff{'TP'}++; return; } if ( $command =~ /^\.UR$/ ) { $Groff{'UR'}++; # for man return; } if ( $command =~ /^\.YS$/ ) { # for man $Groff{'YS'}++; return; } ####### do_line() ########## # me if ( $command =~ /^\.( [ilnp]p| sh )$/x ) { $Groff{'me'}++; # for me return; } ############# # mm and mmse if ( $command =~ /^\.( H| MULB| LO| LT| NCOL| P\$| PH| SA )$/x ) { $Groff{'mm'}++; # for mm and mmse if ( $command =~ /^\.LO$/ ) { if ( $args =~ /^(DNAMN|MDAT|BIL|KOMP|DBET|BET|SIDOR)/ ) { $Groff{'mmse'}++; # for mmse } } elsif ( $command =~ /^\.LT$/ ) { if ( $args =~ /^(SVV|SVH)/ ) { $Groff{'mmse'}++; # for mmse } } return; } ####### do_line() ########## # mom if ( $line =~ /^\.( ALD| DOCTYPE| FAMILY| FT| FAM| LL| LS| NEWPAGE| PAGE| PAPER| PRINTSTYLE| PT_SIZE| T_MARGIN )$/x ) { $Groff{'mom'}++; # for mom return; } } # do_line() ######################################################################## # sub make_groff_device ######################################################################## my @m = (); my @preprograms = (); my $correct_tmac = ''; sub make_groff_device { # globals: @devices # default device is 'ps' when without '-T' my $device; push @devices, 'ps' unless ( @devices ); ###### make_groff_device() for my $d ( @devices ) { if ( $d =~ /^( # suitable devices dvi| html| xhtml| lbp| lj4| ps| pdf| ascii| cp1047| latin1| utf8 )$/x ) { ###### make_groff_device() $device = $d; } else { next; } if ( $device ) { push @Command, '-T'; push @Command, $device; } } ###### make_groff_device() if ( $device eq 'pdf' ) { if ( $pdf_with_ligatures ) { # with --ligature argument push( @Command, '-P-y' ); push( @Command, '-PU' ); } else { # no --ligature argument if ( $with_warnings ) { print STDERR <<EOF; If you have trouble with ligatures like 'fi' in the 'groff' output, you can proceed as one of - add 'grog' option '--with_ligatures' or - use the 'grog' option combination '-P-y -PU' or - try to remove the font named similar to 'fonts-texgyre' from your system. EOF } # end of warning } # end of ligature } # end of pdf device } # make_groff_device() ######################################################################## # make_groff_preproc() ######################################################################## sub make_groff_preproc { # globals: %Groff, @preprograms, @Command # preprocessors without 'groff' option if ( $Groff{'lilypond'} ) { push @preprograms, 'glilypond'; } if ( $Groff{'gperl'} ) { push @preprograms, 'gperl'; } if ( $Groff{'gpinyin'} ) { push @preprograms, 'gpinyin'; } # preprocessors with 'groff' option if ( ( $Groff{'PS'} || $Groff{'PF'} ) && $Groff{'PE'} ) { $Groff{'pic'} = 1; } if ( $Groff{'gideal'} ) { $Groff{'pic'} = 1; } ###### make_groff_preproc() $Groff{'refer'} ||= $Groff{'refer_open'} && $Groff{'refer_close'}; if ( $Groff{'chem'} || $Groff{'eqn'} || $Groff{'gideal'} || $Groff{'grap'} || $Groff{'grn'} || $Groff{'pic'} || $Groff{'refer'} || $Groff{'tbl'} ) { push(@Command, '-s') if $Groff{'soelim'}; push(@Command, '-R') if $Groff{'refer'}; push(@Command, '-t') if $Groff{'tbl'}; # tbl before eqn push(@Command, '-e') if $Groff{'eqn'}; push(@Command, '-j') if $Groff{'chem'}; # chem produces pic code push(@Command, '-J') if $Groff{'gideal'}; # gideal produces pic push(@Command, '-G') if $Groff{'grap'}; push(@Command, '-g') if $Groff{'grn'}; # gremlin files for -me push(@Command, '-p') if $Groff{'pic'}; } } # make_groff_preproc() ######################################################################## # make_groff_tmac_man_ms() ######################################################################## sub make_groff_tmac_man_ms { # globals: @filespec, $tmac_ext, %Groff # 'man' requests, not from 'ms' if ( $Groff{'SS'} || $Groff{'SY'} || $Groff{'OP'} || $Groff{'TH_first'} || $Groff{'TP'} || $Groff{'UR'} ) { $Groff{'man'} = 1; push(@m, '-man'); $tmac_ext = 'man' unless ( $tmac_ext ); &err('man requests found, but file name extension ' . 'was: ' . $tmac_ext) unless ( $tmac_ext eq 'man' ); $tmac_ext = 'man'; return 1; # true } ###### make_groff_tmac_man_ms() # 'ms' requests, not from 'man' if ( $Groff{'1C'} || $Groff{'2C'} || $Groff{'AB'} || $Groff{'AE'} || $Groff{'AI'} || $Groff{'AU'} || $Groff{'BX'} || $Groff{'CD'} || $Groff{'DA'} || $Groff{'DE'} || $Groff{'DS'} || $Groff{'ID'} || $Groff{'LD'} || $Groff{'NH'} || $Groff{'TH_later'} || $Groff{'TL'} || $Groff{'UL'} || $Groff{'XP'} ) { $Groff{'ms'} = 1; push(@m, '-ms'); $tmac_ext = 'ms' unless ( $tmac_ext ); &err('ms requests found, but file name extension ' . 'was: ' . $tmac_ext) unless ( $tmac_ext eq 'ms' ); $tmac_ext = 'ms'; return 1; # true } ###### make_groff_tmac_man_ms() # both 'man' and 'ms' requests if ( $Groff{'P'} || $Groff{'IP'} || $Groff{'LP'} || $Groff{'PP'} || $Groff{'SH'} ) { if ( $tmac_ext eq 'man' ) { $Groff{'man'} = 1; push(@m, '-man'); return 1; # true } elsif ( $tmac_ext eq 'ms' ) { $Groff{'ms'} = 1; push(@m, '-ms'); return 1; # true } return 0; } } # make_groff_tmac_man_ms() ######################################################################## # make_groff_tmac_others() ######################################################################## sub make_groff_tmac_others { # globals: @filespec, $tmac_ext, %Groff # mdoc if ( ( $Groff{'Oo'} && $Groff{'Oc'} ) || $Groff{'Dd'} ) { $Groff{'Oc'} = 0; $Groff{'Oo'} = 0; push(@m, '-mdoc'); return 1; # true } if ( $Groff{'mdoc_old'} || $Groff{'Oo'} ) { push(@m, '-mdoc_old'); return 1; # true } # me if ( $Groff{'me'} ) { push(@m, '-me'); return 1; # true } ##### make_groff_tmac_others() # mm and mmse if ( $Groff{'mm'} ) { push(@m, '-mm'); return 1; # true } if ( $Groff{'mmse'} ) { # Swedish mm push(@m, '-mmse'); return 1; # true } # mom if ( $Groff{'mom'} ) { push(@m, '-mom'); return 1; # true } } # make_groff_tmac_others() ######################################################################## # make_groff_line_rest() ######################################################################## sub make_groff_line_rest { my $file_args_included; # file args now only at 1st preproc unshift @Command, 'groff'; if ( @preprograms ) { my @progs; $progs[0] = shift @preprograms; push(@progs, @filespec); for ( @preprograms ) { push @progs, '|'; push @progs, $_; } push @progs, '|'; unshift @Command, @progs; $file_args_included = 1; } else { $file_args_included = 0; } ###### make_groff_line_rest() foreach (@Command) { next unless /\s/; # when one argument has several words, use accents $_ = "'" . $_ . "'"; } ###### make_groff_line_rest() ########## # -m arguments my $nr_m_guessed = scalar @m; if ( $nr_m_guessed > 1 ) { print STDERR __FILE__ . ' ' . __LINE__ . ': ' . 'argument for -m found: ' . @m; } my $nr_m_args = scalar @Mparams; # m-arguments for grog my $last_m_arg = ''; # last provided -m option if ( $nr_m_args > 1 ) { # take the last given -m argument of grog call, # ignore other -m arguments and the found ones $last_m_arg = $Mparams[-1]; # take the last -m argument print STDERR __FILE__ . ' ' . __LINE__ . ': ' . $Prog . ": more than 1 '-m' argument: @Mparams"; print STDERR __FILE__ . ' ' . __LINE__ . ': ' . 'We take the last one: ' . $last_m_arg; } elsif ( $nr_m_args == 1 ) { $last_m_arg = $Mparams[0]; } ###### make_groff_line_rest() my $final_m = ''; if ( $last_m_arg ) { my $is_equal = 0; for ( @m ) { if ( $_ eq $last_m_arg ) { $is_equal = 1; last; } next; } # end for @m if ( $is_equal ) { $final_m = $last_m_arg; } else { print STDERR __FILE__ . ' ' . __LINE__ . ': ' . 'Provided -m argument ' . $last_m_arg . ' differs from guessed -m args: ' . @m; print STDERR __FILE__ . ' ' . __LINE__ . ': ' . 'The argument is taken.'; $final_m = $last_m_arg; } ###### make_groff_line_rest() } else { # no -m arg provided if ( $nr_m_guessed > 1 ) { print STDERR __FILE__ . ' ' . __LINE__ . ': ' . 'More than 1 -m arguments were guessed: ' . @m; print STDERR __FILE__ . ' ' . __LINE__ . ': ' . 'Guessing stopped.'; exit 1; } elsif ( $nr_m_guessed == 1 ) { $final_m = $m[0]; } else { # no -m provided or guessed } } push @Command, $final_m if ( $final_m ); push(@Command, @filespec) unless ( $file_args_included ); ######### # execute the 'groff' command here with option '--run' if ( $do_run ) { # with --run print STDERR __FILE__ . ' ' . __LINE__ . ': ' . "@Command"; my $cmd = join ' ', @Command; system($cmd); } else { print "@Command"; } exit 0; } # make_groff_line_rest() ######################################################################## # sub help ######################################################################## sub help { print <<EOF; usage: grog [option]... [--] [filespec]... "filespec" is either the name of an existing, readable file or "-" for standard input. If no 'filespec' is specified, standard input is assumed automatically. All arguments after a '--' are regarded as file names, even if they start with a '-' character. 'option' is either a 'groff' option or one of these: -h|--help print this uasge message and exit -v|--version print version information and exit -C compatibility mode --ligatures include options '-P-y -PU' for internal font, which preserves the ligatures like 'fi' --run run the checked-out groff command --warnings display more warnings to standard error All other options should be 'groff' 1-character options. These are then appended to the generated 'groff' command line. The '-m' options will be checked by 'grog'. EOF exit 0; } # help() ######################################################################## # sub version ######################################################################## sub version { our %at_at; print "Perl version of GNU $Prog " . "in groff version " . $at_at{'GROFF_VERSION'}; exit 0; } # version() 1; ######################################################################## ### Emacs settings # Local Variables: # mode: CPerl # End: