[8249] in Perl-Users-Digest
Perl-Users Digest, Issue: 1867 Volume: 8
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Wed Feb 11 21:17:29 1998
Date: Wed, 11 Feb 98 17:01:28 -0800
From: Perl-Users Digest <Perl-Users-Request@ruby.OCE.ORST.EDU>
To: Perl-Users@ruby.OCE.ORST.EDU (Perl-Users Digest)
Perl-Users Digest Wed, 11 Feb 1998 Volume: 8 Number: 1867
Today's topics:
SOURCE: grep through netscape history file <tchrist@mox.perl.com>
SOURCE: recursive du summary <tchrist@mox.perl.com>
SOURCE: tcgrep <tchrist@mox.perl.com>
SOURCE: tee clone for process teeing <tchrist@mox.perl.com>
Substitution : \n with space <thanasis@uclink4.berkeley.edu>
Re: Un crypt (Martien Verbruggen)
Digest Administrivia (Last modified: 8 Mar 97) (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: 11 Feb 1998 23:56:55 GMT
From: Tom Christiansen <tchrist@mox.perl.com>
Subject: SOURCE: grep through netscape history file
Message-Id: <6btds7$2c4$10@csnews.cs.colorado.edu>
Here's another useful program. It greps through your
history database that netscape keeps in Berkeley DB file.
You'll need the DB_File module properly installed for this
to work. I suppose one could use the new Netscape::History
modules, but this still works fine.
--tom
#!/usr/bin/perl -w
require 5.001;
if (sprintf("%5.3f", $]) < 5.002) { # darned floats
warn "Version $] may not run properly -- see BUGS; continuing";
}
$VERSION = $VERSION || 2.000; # LINTHAPPINESS
$USAGE = <<EO_COMPLAINT;
usage: $0 [-database dbfilename] [-help]
[-epochtime | -localtime | -gmtime]
[ [-regexp] pattern] | href ... ]
EO_COMPLAINT
use Getopt::Long;
($opt_database, $opt_epochtime, $opt_localtime, # LINTHAPPINESS
$opt_gmtime, $opt_regexp, $opt_help,
$pattern, ) = (0) x 7;
usage() unless GetOptions qw{ database=s
regexp=s
epochtime localtime gmtime
help
};
if ($opt_help) { print $USAGE; exit; }
usage("only one of localtime, gmtime, and epochtime allowed")
if $opt_localtime + $opt_gmtime + $opt_epochtime > 1;
if ( $opt_regexp ) {
$pattern = $opt_regexp;
} elsif (@ARGV && $ARGV[0] !~ m(://)) {
$pattern = shift;
}
usage("can't mix URLs and explicit patterns")
if $pattern && @ARGV;
if ($pattern && !eval { '' =~ /$pattern/; 1 } ) { # '' is LINTHAPPINESS
$@ =~ s/ at \w+ line \d+\.//;
die "$0: bad pattern $@";
}
require DB_File; DB_File->import(); # delay loading until runtime
$| = 1; # eager pagers
$dotdir = $ENV{HOME} || $ENV{LOGNAME};
$HISTORY = $opt_database || "$dotdir/.netscape/history.db";
%hist_db = %hist_db; # LINTHAPPINESS
die "no netscape history dbase in $HISTORY: $!" unless -e $HISTORY;
die "can't dbmopen $HISTORY: $!" unless dbmopen %hist_db, $HISTORY, 0644;
$add_nulls = (ord(substr(each %hist_db, -1)) == 0);
$nulled_href = "";
$byte_order = "V"; # should be "N", ya nimrods! haven't you ever
# heard of standard network byte order? see the
# htonl() macros in <netinet/in.h> for starters
# and then go read a networking book. sheesh,
# i thought we freed ourselves from the provicial
# "all the world's a vax" worldview years ago. :-(
if (@ARGV) {
foreach $href (@ARGV) {
$nulled_href = $href . ($add_nulls && "\0");
unless ($binary_time = $hist_db{$nulled_href}) {
warn "$0: No history entry for HREF $href\n";
next;
}
$epoch_secs = unpack($byte_order, $binary_time);
$stardate = $opt_epochtime ? $epoch_secs
: $opt_gmtime ? gmtime $epoch_secs
: localtime $epoch_secs;
print "$stardate $href\n";
}
} else {
while ( ($href, $binary_time) = each %hist_db ) {
chop $href if $add_nulls;
$epoch_secs = unpack($byte_order, $binary_time);
$stardate = $opt_epochtime ? $epoch_secs
: $opt_gmtime ? gmtime $epoch_secs
: localtime $epoch_secs;
print "$stardate $href\n" unless $pattern && $href !~ /$pattern/o;
}
}
sub usage {
print STDERR "@_\n" if @_;
die $USAGE;
}
__END__
=head1 NAME
ggh - grovel global history (for Netscape v2.0)
=head1 SYNOPSYS
ggh [ B<-database> I<dbfilename> ] [ B<-help> ]
[ B<-epochtime> | B<-localtime> | B<-gmtime> ]
[ [ B<-regexp> ] I<pattern> ] | I<href> ... ]
Options may be abbreviated.
=head1 DESCRIPTION
B<ggh> is a program to divulge the contents of Netscape v2.0's fancy new
F<history.db> file. It can be called with full URLs or with a (single)
pattern. If called without arguments, it just cats the whole history
file.
Each line is the date of access and the URL stored there. The date is
converted into localtime() representation with B<-localtime>, gmtime()
representation with B<-gmtime> -- or left in its raw form with
B<-epochtime>, which is useful for sorting by date.
If you give one single argument, and it doesn't have a C<://> in it,
then this will be taken to be a perl regexp to match against.
=head1 EXAMPLES
To look up one or more URLs, just supply them as arguments:
% ggh http://www.perl.com/index.html
To find out a link you don't quite recall, use a regular expression
(a single argument without a colon + double slash is a pattern):
% ggh perl
To find out all the people you've mailed:
% ggh mailto:
To find out the FAQ sites you've visited using snazzy perl patterns
and an explicit switch i case you want a double slash in the pattern:
% ggh -regexp '(?i)\bfaq\b'
If you don't want the internal date converted to localtime, use B<-epoch>:
% ggh -epoch http://www.perl.com/perl/
If you prefer gmtime to localtime, use B<-gm>:
% ggh -gmtime http://www.perl.com/perl/
To look at the whole file, give no arguments, but perhaps
redirect to a pager:
% ggh | less
If you want the output sorted by date, make sure to use the B<-epoch> flag:
% ggh -epoch | sort -rn | less
If you want it sorted by date into your local timezone format,
use a more sophisticated pipeline:
% ggh -epoch | sort -rn | perl -pe 's/\d+/localtime $&/e' | less
=head1 FILES
The F<~/.netscape/history.db> file is used, unless the B<-database>S< >I<file>
option is given.
=head1 NOTES
The Netscape release notes claim that they're using NDBM format. This is
misleading: they're actually using Berkeley DB format, which is why we
require DB_File (not supplied standard with Perl) instead of NDBM_File
(which is). If you need Berkeley DB by Keith Bostic, get it from a
standard CPAN archive (see http://perl.com/ or ftp://perl.com/ for
pointers), or else from ftp://ftp.cs.berkeley.edu/ucb/4bsd/db.tar.gz .
The current version appears to be 1.85 as of this writing.
=head1 DOCUMENTATION
This is a self-contained program, including not only its complete source
code but also its own documentation within itself. It's easy to convert,
though--to turn this program (or rather, its podpage) into a manpage
% pod2man ggh > ggh.man
or to print use
% pod2man ggh | psroff -man -
To convert it into a text file, use
% pod2text ggh > ggh.txt
To convert it into a webpage, run
% pod2html ggh > ggh.html
=head1 BUGS
Under SunOS, you may get a coredump in the Berkeley DB routines. If so,
see the patches on
ftp://ftp.perl.com/pub/perl/src/patches/dbfile-5.001n.patch for a fix.
These have been fixed in the version 5.002 release of Perl.
=head1 AUTHOR
Tom Christiansen
tchrist@perl.com
=head1 COPYRIGHT
Copyright (c) 1995-1996 Tom Christiansen.
Permission granted to freely redistribute this program in
source form. If you change something, please document this
in the HISTORY section.
=head1 HISTORY
Last update: 17 January 1996
--
Tom Christiansen tchrist@jhereg.perl.com
If you've seen one redwood, you've seen them all.
--Ronald Reagan
------------------------------
Date: 12 Feb 1998 00:02:59 GMT
From: Tom Christiansen <tchrist@mox.perl.com>
Subject: SOURCE: recursive du summary
Message-Id: <6bte7j$2c4$12@csnews.cs.colorado.edu>
Here's the dutree program. It presents a graphic summary of disk space
used by filtering the output of the standard du program (which you may
feed the -a option, etc.).
For example:
jhereg(tchrist)% pwd
/home/tchrist/TUTS/CS-Talk
jhereg(tchrist)% dutree
468 .
| 330 source
| | 104 dstructs
| | | 56 trees
| | | | 45 .
| | | | 11 CLR
| | | | | 10 Tree
| | | | | 1 .
| | | 20 queues
| | | | 11 strpris
| | | | 9 .
| | | 16 ties
| | | | 10 .
| | | | 6 Tie
| | | 6 stacks
| | | 5 lists
| | | 1 .
| | 65 sysadmin
| | 57 web
| | | 44 .
| | | 13 Proxy
| | 35 tools
| | 26 iostuff
| | 19 strhack
| | 8 tk
| | 8 networking
| | 5 perlscript
| | 2 modules
| | | 1 timers
| | | 1 .
| | 1 .
| 137 slides
| 1 .
It is interesting in that it is a perl4 program that uses recursive
data structures.
--tom
#!/usr/bin/perl
# dutree - tchrist@perl.com
@lines = `du @ARGV`;
chop(@lines);
&input($top = pop @lines);
&output($top);
exit;
sub input {
local($root, *kid, $him) = @_[0,0];
while (@lines && &childof($root, $lines[$#lines])) {
&input($him = pop(@lines));
push(@kid, $him);
}
if (@kid) {
local($mysize) = ($root =~ /^(\d+)/);
for (@kid) { $mysize -= (/^(\d+)/)[0]; }
push(@kid, "$mysize .") if $size != $mysize;
}
@kid = &sizesort(*kid);
}
sub output {
local($root, *kid, $prefix) = @_[0,0,1];
local($size, $path) = split(' ', $root);
$path =~ s!.*/!!;
$line = sprintf("%${width}d %s", $size, $path);
print $prefix, $line, "\n";
$prefix .= $line;
$prefix =~ s/\d /| /;
$prefix =~ s/[^|]/ /g;
local($width) = $kid[0] =~ /(\d+)/ && length("$1");
for (@kid) { &output($_, $prefix); };
}
sub sizesort {
local(*list, @index) = shift;
sub bynum { $index[$b] <=> $index[$a]; }
for (@list) { push(@index, /(\d+)/); }
@list[sort bynum 0..$#list];
}
sub childof {
local(@pair) = @_;
for (@pair) { s/^\d+\s+//g; s/$/\//; }
index($pair[1], $pair[0]) >= 0;
}
--
Tom Christiansen tchrist@jhereg.perl.com
A penny saved is ridiculous.
------------------------------
Date: 11 Feb 1998 23:54:51 GMT
From: Tom Christiansen <tchrist@mox.perl.com>
Subject: SOURCE: tcgrep
Message-Id: <6btdob$2c4$9@csnews.cs.colorado.edu>
Here's the long-lost version 1.3 of my tcgrep program,
an improved grep that while slower, is much more featureful
than the standard one. Not the least part of which is that
it supports perl regular expressions.
Standard grep options:
i case insensitive
n number lines
c give count of lines matching
C ditto, but >1 match per line possible
w word boundaries only
s silent mode
x exact matches only
v invert search sense (lines that DON'T match)
h hide filenames
e expression (for exprs beginning with -)
f file with expressions
l list filenames matching
Specials:
1 1 match per file
H highlight matches
u underline matches
r recursive on directories or dot if none
t process directories in `ls -t` order
p paragraph mode (default: line mode)
P ditto, but specify separator, e.g. -P '%%\\n'
a all files, not just plain text files
q quiet about failed file and dir opens
T trace files as opened
--tom
#! /usr/bin/perl
#
# tcgrep: tom christiansen's rewrite of grep
# tchrist@perl.com
# see usage for features
# yet to implement: -f
# v1.0: Thu Sep 30 16:24:43 MDT 1993
# v1.1: Fri Oct 1 08:33:43 MDT 1993
#
# Revision by Greg Bacon <gbacon@cs.uah.edu>
# Fixed up highlighting for those of us trapped in terminfo
# implemented -f
# v1.2: Fri Jul 26 13:37:02 CDT 1996
#
# Revision by Greg Bacon <gbacon@cs.uah.edu>
# Avoid super-inefficient matching (almost twice as fast! :-)
# v1.3: Sat Aug 30 14:21:47 CDT 1997
&init;
&parse_args;
&matchfile(@ARGV);
exit(2) if $Errors;
exit(0) if $Grand_Total;
exit(1);
######################################
sub init {
($me = $0) =~ s!.*/!!;
$Errors = $Grand_Total = 0;
$| = 1;
%Compress = (
'z', 'gzcat',
'gz', 'gzcat',
'Z', 'zcat',
);
}
sub matchfile {
local($_,$file);
local(@list);
local($matches);
local($total);
FILE: while (defined ($file = shift(@_))) {
if (-d $file) {
if (-l $file && @ARGV != 1) {
warn "$me: \"$file\" is a symlink to a directory\n"
if $opt_T;
next FILE;
}
if (!$opt_r) {
warn "$me: \"$file\" is a directory, but no -r given\n"
if $opt_T;
next FILE;
}
if (!opendir(DIR, $file)) {
unless ($opt_q) {
warn "$me: can't opendir $file: $!\n";
$Errors++;
}
next FILE;
}
@list = ();
for (readdir(DIR)) {
push(@list, "$file/$_") unless /^\.{1,2}$/;
}
closedir(DIR);
if ($opt_t) {
local(@dates);
for (@list) { push(@dates, -M) }
@list = @list[sort { $dates[$a] <=> $dates[$b] } 0..$#dates];
} else {
@list = sort @list;
}
&matchfile(@list);
next FILE;
}
if ($file eq '-') {
warn "$me: reading from stdin\n" if -t STDIN && !$opt_q;
$name = '<STDIN>';
} else {
$name = $file;
unless (-f $file || $opt_a) {
warn qq($me: skipping non-plain file "$file"\n) if $opt_T;
next FILE;
}
($ext) = $file =~ /\.([^.]+)$/;
if ( $Compress{$ext} ) {
$file = "$Compress{$ext} <$file |";
} elsif (! (-T $file || $opt_a)) {
warn qq($me: skipping binary file "$file"\n) if $opt_T;
next FILE;
}
}
warn "$me: checking $file\n" if $opt_T;
if (!open(FILE, $file)) {
unless ($opt_q) {
warn "$me: $file: $!\n";
$Errors++;
}
next FILE;
}
$total = 0;
$matches = 0;
LINE: while (<FILE>) {
$matches = 0;
if ($] < 5) {
eval $match_code;
}
else {
&{$matcher}();
}
next LINE unless $matches;
$total += $matches;
if ($opt_p || $opt_P) {
local($*);
s/\n{2,}$/\n/ if $opt_p;
s,$/$,,o if $opt_P;
}
print("$name\n"), next FILE if $opt_l;
$opt_s || print $mult && "$name:",
$opt_n ? "$.:" : "",
$_,
($opt_p||$opt_P) && ('-' x 20)."\n";
next FILE if $opt_1;
}
} continue {
print $mult && "$name:", $total, "\n" if $opt_c;
}
$Grand_Total += $total;
}
sub usage {
die <<EOF
usage: $me [flags] [files]
Standard grep options:
i case insensitive
n number lines
c give count of lines matching
C ditto, but >1 match per line possible
w word boundaries only
s silent mode
x exact matches only
v invert search sense (lines that DON'T match)
h hide filenames
e expression (for exprs beginning with -)
f file with expressions
l list filenames matching
Specials:
1 1 match per file
H highlight matches
u underline matches
r recursive on directories or dot if none
t process directories in `ls -t` order
p paragraph mode (default: line mode)
P ditto, but specify separator, e.g. -P '%%\\n'
a all files, not just plain text files
q quiet about failed file and dir opens
T trace files as opened
EOF
}
sub parse_args {
require 'getopts.pl';
if ($_ = $ENV{TCGREP}) {
s/^[^\-]/-$&/;
unshift(@ARGV, $_);
}
## hush the warnings
$opt_n = 0;
$opt_t = 0;
$opt_v = 0;
$opt_w = 0;
$opt_x = 0;
$opt_e = 0;
$opt_h = 0;
$opt_i = 0;
&Getopts("inqcClsue:f:xwhva1pHtrT-P:") || &usage;
if ($opt_f) {
open(PATFILE, $opt_f) || die qq($me: Can't open '$opt_f': $!);
# make sure perl is down with these patterns...
while (defined($pattern = <PATFILE>)) {
chop $pattern;
eval { /$pattern/, 1 } || die "$me: $opt_f:$.: bad pattern: $@";
push @Patterns, $pattern;
}
close PATFILE;
} else {
$pattern = $opt_e || shift(@ARGV) || &usage;
eval { /$pattern/, 1 } || die "$me: bad pattern: $@";
@Patterns = ($pattern);
}
if ($opt_H || $opt_u) {
$ospeed = 0; # hush little warnings..
$ospeed = 13; # bogus but shouldn't hurt; means 9600
require 'termcap.pl';
local($term) = ($ENV{TERM} || 'vt100');
&Tgetent($term);
($SO, $SE) = $opt_H ? @TC{'so','se'} : @TC{'us','ue'};
unless ($SO || $SE) {
($SO, $SE) = $opt_H
?
(`tput -T $term smso`, `tput -T $term rmso`)
:
(`tput -T $term smul`, `tput -T $term rmul`);
}
}
if ($opt_i) {
if ($] < 5) {
@Patterns = grep(s/\w/[\u$&\l$&]/gi, @Patterns);
} else {
@Patterns = grep($_ = "(?i)$_", @Patterns);
}
}
$opt_p && ($/ = '', $* = 1);
$opt_P && ($/ = eval(qq("$opt_P")), $*=1); # for -P '%%\n'
$opt_w && (@Patterns = grep($_ = '\b' . $_ . '\b', @Patterns));
$opt_x && (@Patterns = grep($_ = "^$_\$", @Patterns));
$mult = 1 if ($opt_r || (@ARGV > 1) || -d $ARGV[0]) && !$opt_h;
$opt_1 += $opt_l;
$opt_H += $opt_u;
$opt_c += $opt_C;
$opt_s += $opt_c;
$opt_1 += $opt_s && !$opt_c;
@ARGV = ($opt_r ? '.' : '-') unless @ARGV;
$opt_r = 1 if !$opt_r && grep(-d, @ARGV) == @ARGV;
## try to speed things up a bit
$match_code = '';
$match_code .= 'study;' if @Patterns > 5;
if ($opt_H) {
foreach $Pattern (@Patterns) {
$match_code .= "\$matches += s/$Pattern/${SO}\$&${SE}/g;";
}
}
elsif ($opt_v) {
foreach $Pattern (@Patterns) {
$match_code .= "\$matches += !/$Pattern/;";
}
}
elsif ($opt_C) {
foreach $Pattern (@Patterns) {
$match_code .= "\$matches++ while /$Pattern/g;";
}
}
else {
foreach $Pattern (@Patterns) {
$match_code .= "\$matches++ if /$Pattern/;";
}
}
if ($] >= 5) {
$matcher = eval "sub { $match_code }";
die if $@;
}
}
--
Tom Christiansen tchrist@jhereg.perl.com
That means I'll have to use $ans to suppress newlines now.
Life is ridiculous.
--Larry Wall in Configure from the perl distribution
------------------------------
Date: 12 Feb 1998 00:10:53 GMT
From: Tom Christiansen <tchrist@mox.perl.com>
Subject: SOURCE: tee clone for process teeing
Message-Id: <6btemd$2c4$14@csnews.cs.colorado.edu>
Did you know that if you write a filter that processes
<ARGV>, (same as <>), that you can write command lines like:
perl filter f1 "c1|" f2 - f3 "c2|c3|" f4 "c5 2>&1|"
and have everything work out automatically? It's true. The open()
function is full of cool magic.
To come at this from the other direction, the open() magic can also be
wonderful for output. Consider:
cmd | perltee f1 "|c1" ">>f2" f3 - "|c2|c3 > f4" f5
Yup: you can now tee into many processes at once, control which
files are appended and which clobbered, etc. Here's the ancient
program I wrote to do this.
--tom "We don't need no steenking IO::Handles :-)" christiansen
#!/usr/bin/perl
#
# tee clone that groks process tees (should work even with old perls)
# Tom Christiansen <tchrist@convex.com>
# 6 June 91
while ($ARGV[0] =~ /^-(.+)/ && (shift, ($_ = $1), 1)) {
next if /^$/;
s/i// && (++$ignore_ints, redo);
s/a// && (++$append, redo);
s/u// && (++$unbuffer, redo);
s/n// && (++$nostdout, redo);
die "usage tee [-aiun] [filenames] ...\n";
}
if ($ignore_ints) {
for $sig ('INT', 'TERM', 'HUP', 'QUIT') { $SIG{$sig} = 'IGNORE'; }
}
$SIG{'PIPE'} = 'PLUMBER';
$mode = $append ? '>>' : '>';
$fh = 'FH000';
unless ($nostdout) {
%fh = ('STDOUT', 'standard output'); # always go to stdout
}
$| = 1 if $unbuffer;
for (@ARGV) {
if (!open($fh, (/^[^>|]/ && $mode) . $_)) {
warn "$0: cannot open $_: $!\n"; # like sun's; i prefer die
$status++;
next;
}
select((select($fh), $| = 1)[0]) if $unbuffer;
$fh{$fh++} = $_;
}
while (<STDIN>) {
for $fh (keys %fh) {
print $fh $_;
}
}
for $fh (keys %fh) {
next if close($fh) || !defined $fh{$fh};
warn "$0: couldn't close $fh{$fh}: $!\n";
$status++;
}
exit $status;
sub PLUMBER {
warn "$0: pipe to \"$fh{$fh}\" broke!\n";
$status++;
delete $fh{$fh};
}
--
Tom Christiansen tchrist@jhereg.perl.com
Remember why the good Lord made your eyes -- Pla-gi-a-rize! --Tom Lehrer
------------------------------
Date: Wed, 11 Feb 1998 16:28:09 -0800
From: thanasis bothos <thanasis@uclink4.berkeley.edu>
Subject: Substitution : \n with space
Message-Id: <34E24218.B2A35E8C@uclink4.berkeley.edu>
I am trying to substitute new lines embedded in a scalar ($DESCRIPTION)
with space.
I tried: $DESCRIPTION =~ s/(\n)/ /g;
This takes the NL's out, but messes up the result.
I also tried:
$_=$DESCRIPTION;
s/(\n)/ /g;
$DESC1=$`;
$DESC2=$';
print "$DESC1 $DESC2 \n";
same difference...
What am i doing wrong?
Thanks for your help
Thanasis Bothos
------------------------------
Date: 11 Feb 1998 23:28:11 GMT
From: mgjv@comdyn.com.au (Martien Verbruggen)
Subject: Re: Un crypt
Message-Id: <6btc6b$46k$5@comdyn.comdyn.com.au>
In article <34E20650.EC2@eg-web.com>,
Edward Harris <Webmaster@eg-web.com> writes:
> If anyone has a good formula for uncrypting information previously
> crypted using perls "crypt" command, I would appreciate knowing it.
Hi Ed,
There is no such thing. Crypt is a one-way street.
Martien
--
Martien Verbruggen | My friend has a baby. I'm writing down
Webmaster www.tradingpost.com.au | all the noises the baby makes so later
Commercial Dynamics Pty. Ltd. | I can ask him what he meant - Steven
NSW, Australia | Wright
------------------------------
Date: 8 Mar 97 21:33:47 GMT (Last modified)
From: Perl-Request@ruby.oce.orst.edu (Perl-Users-Digest Admin)
Subject: Digest Administrivia (Last modified: 8 Mar 97)
Message-Id: <null>
Administrivia:
The Perl-Users Digest is a retransmission of the USENET newsgroup
comp.lang.perl.misc. For subscription or unsubscription requests, send
the single line:
subscribe perl-users
or:
unsubscribe perl-users
to almanac@ruby.oce.orst.edu.
To submit articles to comp.lang.perl.misc (and this Digest), send your
article to perl-users@ruby.oce.orst.edu.
To submit articles to comp.lang.perl.announce, send your article to
clpa@perl.com.
To request back copies (available for a week or so), send your request
to almanac@ruby.oce.orst.edu with the command "send perl-users x.y",
where x is the volume number and y is the issue number.
The Meta-FAQ, an article containing information about the FAQ, is
available by requesting "send perl-users meta-faq". The real FAQ, as it
appeared last in the newsgroup, can be retrieved with the request "send
perl-users FAQ". Due to their sizes, neither the Meta-FAQ nor the FAQ
are included in the digest.
The "mini-FAQ", which is an updated version of the Meta-FAQ, is
available by requesting "send perl-users mini-faq". It appears twice
weekly in the group, but is not distributed in the digest.
For other requests pertaining to the digest, send mail to
perl-users-request@ruby.oce.orst.edu. Do not waste your time or mine
sending perl questions to the -request address, I don't have time to
answer them even if I did know the answer.
------------------------------
End of Perl-Users Digest V8 Issue 1867
**************************************
