1: #! /usr/bin/perl
2: #
3: # LinuxDocTools.pm
4: #
5: # $Id: LinuxDocTools.pm,v 1.1.1.1 2019/10/21 16:03:57 misho Exp $
6: #
7: # LinuxDoc-Tools driver core. This contains all the basic functionality
8: # we need to control all other components.
9: #
10: # © Copyright 1996, Cees de Groot.
11: # © Copyright 2000, Taketoshi Sano
12: #
13: # THIS VERSION HAS BEEN HACKED FOR BIRD BY MARTIN MARES
14: #
15: package LinuxDocTools;
16:
17: require 5.004;
18: use strict;
19:
20: =head1 NAME
21:
22: LinuxDocTools - SGML conversion utilities for LinuxDoc DTD.
23:
24: =head1 SYNOPSIS
25:
26: use LinuxDocTools;
27: LinuxDocTools::init;
28: @files = LinuxDocTools::process_options ($0, @ARGV);
29: for $curfile (@files) {
30: LinuxDocTools::process_file ($curfile);
31: }
32:
33: =head1 DESCRIPTION
34:
35: The LinuxDocTools package encapsulates all the functionality offered by
36: LinuxDoc-Tools. It is used, of course, by LinuxDoc-Tools;
37: but the encapsulation should provide for a simple interface for other users as well.
38:
39: =head1 FUNCTIONS
40:
41: =over 4
42:
43: =cut
44:
45: use DirHandle;
46: use File::Basename;
47: use File::Find;
48: use File::Copy;
49: use FileHandle;
50: use IPC::Open2;
51: use Cwd;
52: use LinuxDocTools::Lang;
53: use LinuxDocTools::Utils qw(process_options usage cleanup trap_signals remove_tmpfiles create_temp);
54: use LinuxDocTools::Vars;
55:
56: sub BEGIN
57: {
58: #
59: # Make sure we're always looking here. Note that "use lib" adds
60: # on the front of the search path, so we first push dist, then
61: # site, so that site is searched first.
62: #
63: use lib "$main::DataDir/dist";
64: use lib "$main::DataDir/site";
65: }
66:
67: =item LinuxDocTools::init
68:
69: Takes care of initialization of package-global variables (which are actually
70: defined in L<LinuxDocTools::Vars>). The package-global variables are I<$global>,
71: a reference to a hash containing numerous settings, I<%Formats>, a hash
72: containing all the formats, and I<%FmtList>, a hash containing the currently
73: active formats for help texts.
74:
75: Apart from this, C<LinuxDocTools::init> also finds all distributed and site-local
76: formatting backends and C<require>s them.
77:
78: =cut
79:
80: sub init
81: {
82: trap_signals;
83:
84: #
85: # Register the ``global'' pseudoformat. Apart from the global settings,
86: # we also use $global to keep the global variable name space clean;
87: # everything that we need to provide to other modules is stuffed
88: # into $global.
89: #
90: $global = {};
91: $global->{NAME} = "global";
92: $global->{HELP} = "";
93: $global->{OPTIONS} = [
94: { option => "backend", type => "l",
95: 'values' => [ "html", "info", "latex",
96: "lyx", "rtf", "txt", "check" ],
97: short => "B" },
98: { option => "papersize", type => "l",
99: 'values' => [ "a4", "letter" ], short => "p" },
100: { option => "language", type => "l",
101: 'values' => [ @LinuxDocTools::Lang::Languages ], short => "l" },
102: { option => "charset", type => "l",
103: 'values' => [ "latin", "ascii", "nippon", "euc-kr" ], short => "c" },
104: { option => "style", type => "s", short => "S" },
105: { option => "tabsize", type => "i", short => "t" },
106: # { option => "verbose", type => "f", short => "v" },
107: { option => "debug", type => "f", short => "d" },
108: { option => "define", type => "s", short => "D" },
109: { option => "include", type => "s", short => "i" },
110: { option => "pass", type => "s", short => "P" }
111: ];
112: $global->{backend} = "linuxdoc";
113: $global->{papersize} = "a4";
114: $global->{language} = "en";
115: $global->{charset} = "ascii";
116: $global->{style} = "";
117: $global->{tabsize} = 8;
118: $global->{verbose} = 0;
119: $global->{define} = "";
120: $global->{debug} = 0;
121: $global->{include} = "";
122: $global->{pass} = "";
123: $global->{InFiles} = [];
124: $Formats{$global->{NAME}} = $global; # All formats we know.
125: $FmtList{$global->{NAME}} = $global; # List of formats for help msgs.
126:
127: # automatic language detection: disabled by default
128: # {
129: # my $lang;
130: # foreach $lang (@LinuxDocTools::Lang::Languages)
131: # {
132: # if (($ENV{"LC_ALL"} =~ /^$lang/i) ||
133: # ($ENV{"LC_CTYPE"} =~ /^$lang/i) ||
134: # ($ENV{"LANG"} =~ /^$lang/i)) {
135: # $global->{language} = Any2ISO($lang);
136: # }
137: # }
138: # }
139:
140: #
141: # Used when the format is "global" (from sgmlcheck).
142: #
143: $global->{preNSGMLS} = sub {
144: $global->{NsgmlsOpts} .= " -s ";
145: $global->{NsgmlsPrePipe} = "cat $global->{file}";
146: };
147:
148: #
149: # Build up the list of formatters.
150: #
151: my $savdir = cwd;
152: my %Locs;
153: chdir "$main::DataDir/dist";
154: my $dir = new DirHandle(".");
155: die "Unable to read directory $main::DataDir/dist: $!" unless defined($dir);
156: foreach my $fmt (grep(/^fmt_.*\.pl$/, $dir->read()))
157: {
158: $Locs{$fmt} = "dist";
159: }
160: $dir->close();
161: chdir "$main::DataDir/site";
162: $dir = new DirHandle(".");
163: die "Unable to read directory $main::DataDir/site: $!" unless defined($dir);
164: foreach my $fmt (grep(/^fmt_.*\.pl$/, $dir->read()))
165: {
166: $Locs{$fmt} = "site";
167: }
168: $dir->close();
169: foreach my $fmt (keys %Locs)
170: {
171: require $fmt;
172: }
173: chdir $savdir;
174: }
175:
176: =item LinuxDocTools::process_options ($0, @ARGV)
177:
178: This function contains all initialization that is bound to the current
179: invocation of LinuxDocTools. It looks in C<$0> to deduce the backend that
180: should be used (ld2txt activates the I<txt> backend) and parses the
181: options array. It returns an array of filenames it encountered during
182: option processing.
183:
184: As a side effect, the environment variables I<SGMLDECL> and
185: I<SGML_CATALOG_FILES> are modified.
186:
187: =cut
188:
189: sub process_options
190: {
191: my $progname = shift;
192: my @args = @_;
193:
194: #
195: # Deduce the format from the caller's file name
196: #
197: my ($format, $dummy1, $dummy2) = fileparse ($progname, "");
198: $global->{myname} = $format;
199: $format =~ s/sgml2*(.*)/$1/;
200:
201: #
202: # check the option "--backend / -B"
203: #
204: if ($format eq "linuxdoc") {
205: my @backends = @args;
206: my $arg;
207: while (@backends) {
208: $arg = shift @backends;
209: if ($arg eq "-B") {
210: $arg = shift @backends;
211: $format = $arg;
212: last;
213: }
214: if ( $arg =~ s/--backend=(.*)/$1/ ) {
215: $format = $arg;
216: last;
217: }
218: }
219: }
220:
221: $format = "global" if $format eq "check";
222: usage ("") if $format eq "linuxdoc";
223: $format = "latex2e" if $format eq "latex";
224: $FmtList{$format} = $Formats{$format} or
225: usage ("$global->{myname}: unknown format");
226: $global->{format} = $format;
227:
228: #
229: # Parse all the options.
230: #
231: my @files = LinuxDocTools::Utils::process_options (@args);
232: $global->{language} = Any2ISO ($global->{language});
233: #
234: # check the number of given files
235: $#files > -1 || usage ("no filenames given");
236:
237: #
238: # Setup the SGML environment.
239: # (Note that Debian package rewrite path to catalog of
240: # iso-entities using debian/rules so that it can use
241: # entities from sgml-data pacakge. debian/rules also
242: # removes iso-entites sub directory after doing make install.)
243: #
244: $ENV{SGML_CATALOG_FILES} .= (defined $ENV{SGML_CATALOG_FILES} ? ":" : "") .
245: "$main::prefix/share/sgml/sgml-iso-entities-8879.1986/catalog:" .
246: "$main::prefix/share/sgml/entities/sgml-iso-entities-8879.1986/catalog";
247: $ENV{SGML_CATALOG_FILES} .= ":$main::DataDir/linuxdoc-tools.catalog";
248: $ENV{SGML_CATALOG_FILES} .= ":$main::/etc/sgml.catalog";
249: if (-f "$main::DataDir/dtd/$format.dcl")
250: {
251: $ENV{SGMLDECL} = "$main::DataDir/dtd/$format.dcl";
252: }
253: elsif (-f "$main::DataDir/dtd/$global->{style}.dcl")
254: {
255: $ENV{SGMLDECL} = "$main::DataDir/dtd/$global->{style}.dcl";
256: }
257: elsif (-f "$main::DataDir/dtd/sgml.dcl")
258: {
259: $ENV{SGMLDECL} = "$main::DataDir/dtd/sgml.dcl";
260: }
261:
262: #
263: # OK. Give the list of files we distilled from the options
264: # back to the caller.
265: #
266: return @files;
267: }
268:
269: =item LinuxDocTools::process_file
270:
271: With all the configuration done, this routine will take a single filename
272: and convert it to the currently active backend format. The conversion is
273: done in a number of steps in tight interaction with the currently active
274: backend (see also L<LinuxDocTools::BackEnd>):
275:
276: =over
277:
278: =item 1. Backend: set NSGMLS options and optionally create a pre-NSGMLS pipe.
279:
280: =item 2. Here: Run the preprocessor to handle conditionals.
281:
282: =item 3. Here: Run NSGMLS.
283:
284: =item 4. Backend: run pre-ASP conversion.
285:
286: =item 5. Here: Run SGMLSASP.
287:
288: =item 6. Backend: run post-ASP conversion, generating the output.
289:
290: =back
291:
292: All stages are influenced by command-line settings, currently active format,
293: etcetera. See the code for details.
294:
295: =cut
296:
297: sub process_file
298: {
299: my $file = shift (@_);
300: my $saved_umask = umask;
301:
302: print "Processing file $file\n";
303: umask 0077;
304:
305: my ($filename, $filepath, $filesuffix) = fileparse ($file, "\.sgml");
306: my $tmpnam = $filepath . '/' . $filename;
307: $file = $tmpnam . $filesuffix;
308: -f $file || $file =~ /.*.sgml$/ || ($file .= '.sgml');
309: -f $file || ($file = $tmpnam . '.SGML');
310: -f $file || die "Cannot find $file\n";
311: $global->{filename} = $filename;
312: $global->{file} = $file;
313: $global->{filepath} = $filepath;
314:
315: my $tmp = new FileHandle "<$file";
316: my $dtd;
317: while ( <$tmp> )
318: {
319: tr/A-Z/a-z/;
320: # check for [<!doctype ... system] type definition
321: if ( /<!doctype\s*(\w*)\s*system/ )
322: {
323: $dtd = $1;
324: last;
325: }
326: # check for <!doctype ... PUBLIC ... DTD ...
327: if ( /<!doctype\s*\w*\s*public\s*.*\/\/dtd\s*(\w*)/mi )
328: {
329: $dtd = $1;
330: last;
331: }
332: # check for <!doctype ...
333: # PUBLIC ... DTD ...
334: # (multi-line version)
335: if ( /<!doctype\s*(\w*)/ )
336: {
337: $dtd = "precheck";
338: next;
339: }
340: if ( /\s*public\s*.*\/\/dtd\s*(\w*)/ && $dtd eq "precheck" )
341: {
342: $dtd = $1;
343: last;
344: }
345: }
346: $tmp->close;
347: if ( $global->{debug} )
348: {
349: print "DTD: " . $dtd . "\n";
350: }
351: $global->{dtd} = $dtd;
352:
353: # prepare temporary directory
354: my $tmpdir = $ENV{'TMPDIR'} || '/tmp';
355: $tmpdir = $tmpdir . '/' . 'linuxdoc-dir-' . $$;
356: mkdir ($tmpdir, 0700) ||
357: die " - temporary files can not be created, aborted - \n";
358:
359: my $tmpbase = $global->{tmpbase} = $tmpdir . '/sgmltmp.' . $filename;
360: $ENV{"SGML_SEARCH_PATH"} .= ":$filepath";
361:
362: #
363: # Set up the preprocessing command. Conditionals have to be
364: # handled here until they can be moved into the DTD, otherwise
365: # a validating SGML parser will choke on them.
366: #
367: # check if output option for latex is pdf or not
368: if ($global->{format} eq "latex2e")
369: {
370: if ($Formats{$global->{format}}{output} eq "pdf")
371: {
372: $global->{define} .= " pdflatex=yes";
373: }
374: }
375: #
376:
377: local $ENV{PATH} = "$ENV{PATH}:/usr/lib/linuxdoc-tools";
378: my($precmd) = "|sgmlpre output=$global->{format} $global->{define}";
379:
380: #
381: # You can hack $NsgmlsOpts here, etcetera.
382: #
383: $global->{NsgmlsOpts} .= "-D $main::prefix/share/sgml -D $main::DataDir";
384: $global->{NsgmlsOpts} .= "-i$global->{include}" if ($global->{include});
385: $global->{NsgmlsPrePipe} = "NOTHING";
386: if ( defined $Formats{$global->{format}}{preNSGMLS} )
387: {
388: $global->{NsgmlsPrePipe} = &{$Formats{$global->{format}}{preNSGMLS}};
389: }
390:
391: #
392: # Run the prepocessor and nsgmls.
393: #
394: my ($ifile, $writensgmls);
395:
396: if ($global->{NsgmlsPrePipe} eq "NOTHING")
397: {
398: $ifile = new FileHandle $file;
399: }
400: else
401: {
402: $ifile = new FileHandle "$global->{NsgmlsPrePipe}|";
403: }
404:
405: create_temp("$tmpbase.1");
406: $writensgmls = new FileHandle
407: "$precmd|$main::progs->{NSGMLS} $global->{NsgmlsOpts} $ENV{SGMLDECL} >\"$tmpbase.1\"";
408: if ($global->{charset} eq "latin")
409: {
410: while (<$ifile>)
411: {
412: # Outline these commands later on - CdG
413: #change latin1 characters to SGML
414: #by Farzad Farid, adapted by Greg Hankins
415: s/À/\À/g;
416: s/Á/\Á/g;
417: s/Â/\Â/g;
418: s/Ã/\Ã/g;
419: s/Ä/\Ä/g;
420: s/Å/\Å/g;
421: s/Æ/\Æ/g;
422: s/Ç/\Ç/g;
423: s/È/\È/g;
424: s/É/\É/g;
425: s/Ê/\Ê/g;
426: s/Ë/\Ë/g;
427: s/Ì/\Ì/g;
428: s/Í/\Í/g;
429: s/Î/\Î/g;
430: s/Ï/\Ï/g;
431: s/Ñ/\Ñ/g;
432: s/Ò/\Ò/g;
433: s/Ó/\Ó/g;
434: s/Ô/\Ô/g;
435: s/Õ/\Õ/g;
436: s/Ö/\Ö/g;
437: s/Ø/\Ø/g;
438: s/Ù/\Ù/g;
439: s/Ú/\Ú/g;
440: s/Û/\Û/g;
441: s/Ü/\Ü/g;
442: s/Ý/\Ý/g;
443: s/Þ/\Þ/g;
444: s/ß/\ß/g;
445: s/à/\à/g;
446: s/á/\á/g;
447: s/â/\â/g;
448: s/ã/\ã/g;
449: s/ä/\ä/g;
450: s/å/\å/g;
451: s/æ/\æ/g;
452: s/ç/\ç/g;
453: s/è/\è/g;
454: s/é/\é/g;
455: s/ê/\ê/g;
456: s/ë/\ë/g;
457: s/ì/\ì/g;
458: s/í/\í/g;
459: s/î/\î/g;
460: s/ï/\ï/g;
461: s/µ/\μ/g;
462: s/ð/\ð/g;
463: s/ñ/\ñ/g;
464: s/ò/\ò/g;
465: s/ó/\ó/g;
466: s/ô/\ô/g;
467: s/õ/\õ/g;
468: s/ö/\ö/g;
469: s/ø/\ø/g;
470: s/ù/\ù/g;
471: s/ú/\ú/g;
472: s/û/\û/g;
473: s/ü/\ü/g;
474: s/ý/\ý/g;
475: s/þ/\þ/g;
476: s/ÿ/\ÿ/g;
477: print $writensgmls $_;
478: }
479: }
480: else
481: {
482: while (<$ifile>)
483: {
484: print $writensgmls $_;
485: }
486: }
487: $ifile->close;
488: $writensgmls->close;
489:
490: #
491: # Special case: if format is global, we're just checking.
492: #
493: $global->{format} eq "global" && cleanup;
494:
495: #
496: # If the output file is empty, something went wrong.
497: #
498: ! -e "$tmpbase.1" and die "can't create file - exiting";
499: -z "$tmpbase.1" and die "SGML parsing error - exiting";
500: if ( $global->{debug} )
501: {
502: print "Nsgmls stage finished.\n";
503: }
504:
505: #
506: # If a preASP stage is defined, let the format handle it.
507: #
508: # preASP ($inhandle, $outhandle);
509: #
510: my $inpreasp = new FileHandle "<$tmpbase.1";
511: my $outpreasp = new FileHandle "$tmpbase.2",O_WRONLY|O_CREAT|O_EXCL,0600;
512: if (defined $Formats{$global->{format}}{preASP})
513: {
514: &{$Formats{$global->{format}}{preASP}}($inpreasp, $outpreasp) == 0 or
515: die "error pre-processing $global->{format}.\n";
516: }
517: else
518: {
519: copy ($inpreasp, $outpreasp);
520: }
521: $inpreasp->close;
522: $outpreasp->close;
523: ! -e "$tmpbase.2" and die "can't create file - exiting";
524:
525: if ( $global->{debug} )
526: {
527: print "PreASP stage finished.\n";
528: }
529:
530: #
531: # Run sgmlsasp, with an optional style if specified.
532: #
533: # Search order:
534: # - datadir/site/<dtd>/<format>
535: # - datadir/dist/<dtd>/<format>
536: # So we need to fetch the doctype from the intermediate.
537: #
538: # Note: this is a very simplistic check - but as far as I know,
539: # it is correct. Am I right?
540: #
541: my $tmp = new FileHandle "<$tmpbase.2";
542: my $dtd;
543: while ( ($dtd = <$tmp>) && ! ( $dtd =~ /^\(/) ) { };
544: $tmp->close;
545: $dtd =~ s/^\(//;
546: $dtd =~ tr/A-Z/a-z/;
547: chop $dtd;
548: $global->{dtd} = $dtd;
549:
550: my $style = "";
551: if ($global->{style})
552: {
553: $style = "$main::DataDir/site/$dtd/$global->{format}/$global->{style}mapping";
554: -r $style or
555: $style = "$main::DataDir/dist/$dtd/$global->{format}/$global->{style}mapping";
556: }
557: my $mapping = "$main::DataDir/site/$dtd/$global->{format}/mapping";
558: -r $mapping or $mapping = "$main::DataDir/dist/$dtd/$global->{format}/mapping";
559:
560: $global->{charset} = "nippon" if ($global->{language} eq "ja");
561: #
562: # we don't have Korean groff so charset should be latin1.
563: #
564: if ($global->{language} eq "ko")
565: {
566: if ($global->{format} eq "groff")
567: {
568: $global->{charset} = "latin1";
569: }
570: else
571: {
572: $global->{charset} = "euc-kr";
573: }
574: }
575:
576: if ($global->{format} eq "groff" or $global->{format} eq "latex2e")
577: {
578: if ($dtd eq "linuxdoctr")
579: {
580: $mapping = "$main::DataDir/dist/$dtd/$global->{format}/tr-mapping";
581: }
582: }
583:
584: create_temp("$tmpbase.3");
585: system ("$main::progs->{SGMLSASP} $style $mapping <\"$tmpbase.2\" |
586: expand -$global->{tabsize} >\"$tmpbase.3\"");
587: ! -e "$tmpbase.3" and die "can't create file - exiting";
588:
589:
590: if ( $global->{debug} )
591: {
592: print "ASP stage finished.\n";
593: }
594:
595: #
596: # If a postASP stage is defined, let the format handle it.
597: # It should leave whatever it thinks is right based on $file.
598: #
599: # postASP ($inhandle)
600: #
601: umask $saved_umask;
602: my $inpostasp = new FileHandle "<$tmpbase.3";
603: if (defined $Formats{$global->{format}}{postASP})
604: {
605: &{$Formats{$global->{format}}{postASP}}($inpostasp) == 0 or
606: die "error post-processing $global->{format}.\n";
607: }
608: $inpostasp->close;
609:
610: if ( $global->{debug} )
611: {
612: print "postASP stage finished.\n";
613: }
614:
615: #
616: # All done, remove the temporaries.
617: #
618: if( !$global->{debug} ) {
619: remove_tmpfiles($tmpbase);
620: }
621: }
622:
623: =pod
624:
625: =back
626:
627: =head1 SEE ALSO
628:
629: Documentation for various sub-packages of LinuxDocTools.
630:
631: =head1 AUTHOR
632: SGMLTools are written by Cees de Groot, C<E<lt>cg@cdegroot.comE<gt>>,
633: and various SGML-Tools contributors as listed in C<CONTRIBUTORS>.
634: Taketoshi Sano C<E<lt>sano@debian.org<gt>> rename to LinuxDocTools.
635:
636: =cut
637: 1;
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to LinuxDocTools.pm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / doc