PERL FAQ
ERC Systems Administration Home Page
To Table of Contents
A programming language, by Larry Wall <lwall@netlabs.com>.
Here's the beginning of the description from the man page:
Perl is an interpreted language optimized for scanning arbitrary text
files, extracting information from those text files, and printing reports
based on that information. It's also a good language for many system
management tasks. The language is intended to be practical (easy to use,
efficient, complete) rather than beautiful (tiny, elegant, minimal). It
combines (in the author's opinion, anyway) some of the best features of C,
sed, awk, and sh, so people familiar with those languages should have
little difficulty with it. (Language historians will also note some
vestiges of csh, Pascal, and even BASIC-PLUS.) Expression syntax
corresponds quite closely to C expression syntax. Unlike most Unix
utilities, Perl does not arbitrarily limit the size of your data--if
you've got the memory, Perl can slurp in your whole file as a single
string. Recursion is of unlimited depth. And the hash tables used by
associative arrays grow as necessary to prevent degraded performance.
Perl uses sophisticated pattern matching techniques to scan large amounts
of data very quickly. Although optimized for scanning text, Perl can also
deal with binary data, and can make dbm files look like associative arrays
(where dbm is available). Setuid Perl scripts are safer than C programs
through a dataflow tracing mechanism which prevents many stupid security
holes. If you have a problem that would ordinarily use sed or awk or sh,
but it exceeds their capabilities or must run a little faster, and you
don't want to write the silly thing in C, then Perl may be for you. There
are also translators to turn your sed and awk scripts into Perl scripts.
1.2) Is Perl hard to learn?
No, Perl is easy to learn for two reasons.
The first reason is that most of Perl is derived from existing tools
and languages, ones that many people who turn to Perl already have
some familiarity with. These include the C programming language, the
UNIX C library, the UNIX shell, sed, and awk. If you already know
these somewhat, Perl should be very easy for you.
The second reason that Perl is easy to learn is that you don't have to
know every thing there is to know about it in order to get good use
out of it. In fact, just a very small subset, mostly borrowed from C,
the shell, and sed, will be enough for most tasks. As you feel the
need or desire to use more sophisticated features (such as C
structures or networking), you can learn these as you go. The
learning curve for Perl is not a steep one, especially if you have
the headstart of having a background in UNIX. Rather, its learning
curve is gentle and gradual, but it *is* admittedly rather long.
If you don't know C or UNIX at all, it'll be a steeper learning curve,
but what you then learn from Perl will carry over into other areas,
like using the C library, UNIX system call, regular expressions, and
associative arrays, just to name a few. To know Perl is to know
UNIX, and vice versa.
To Table of Contents
Of course not. You should choose the appropriate tool for the task at
hand. While it's true that the answer to the question "Can I do (some
arbitrary task) in Perl?" is almost always "yes", that doesn't mean
this is necessarily a good thing to do. For many people, Perl serves
as a great replacement for shell programming. For a few people, it
also serves as a replacement for most of what they'd do in C. But
for some things, Perl just isn't the optimal choice, such as tasks
requiring very complex data structures.
To Table of Contents
From any comp.sources.misc archive. Initial sources were posted to
Volume 18, Issues 19-54 at patchlevel 3. The Patches 4-10 were posted
to Volume 20, Issues 56-62. You can use the archie server
(see the alt.sources FAQ in news.answers) for ways to find these.
These machines, at the very least, definitely have it available for
anonymous FTP:
ftp.uu.net 137.39.1.2
ftp.netlabs.com 192.94.48.152
coombs.anu.edu.au 150.203.76.2
archive.cis.ohio-state.edu 128.146.8.52
jpl-devvax.jpl.nasa.gov 128.149.1.143
prep.ai.mit.edu 18.71.0.38
ftp.cs.ruu.nl 131.211.80.17 (Europe)
Larry's machine is the netlabs one, and the biggest Perl archive
is on coombs.
To Table of Contents
If you are in Europe, you might using the following site. (I'm still
looking for a domestic site.) This information thanks to "Henk P.
Penning" <henkp@cs.ruu.nl>: One automated fashion is as follows:
Email: Send a message to 'mail-server@cs.ruu.nl' containing:
begin
path your_email_address
send help
send PERL/INDEX
end
The path-line may be omitted if your message contains a normal From:-line.
You will receive a help-file and an index of the directory that contains
the Perl stuff.
If all else fails, mail to Larry usually suffices.
To Table of Contents
You can get it from the site osu-cis; here is the appropriate info,
thanks to J Greely <jgreely@cis.ohio-state.edu> or <osu-cis!jgreely>.
E-mail contact:
osu-cis!uucp
Get these two files first:
osu-cis!~/GNU.how-to-get.
osu-cis!~/ls-lR.Z
Current Perl distribution:
osu-cis!~/perl/4.0/kits@10/perl.kitXX.Z (XX=01-37)
How to reach osu-cis via uucp(L.sys/Systems file lines):
#
# Direct Trailblazer
#
osu-cis Any ACU 19200 1-614-292-5112 in:--in:--in: Uanon
#
# Direct V.32 (MNP 4)
# dead, dead, dead...sigh.
#
#osu-cis Any ACU 9600 1-614-292-1153 in:--in:--in: Uanon
#
# Micom port selector, at 1200, 2400, or 9600 bps.
# Replace ##'s below with 12, 24, or 96 (both speed and phone number).
#
osu-cis Any ACU ##00 1-614-292-31## "" \r\c Name? osu-cis nected \c GO \d\r\d\r\d\r in:--in:--in:
Uanon
Modify as appropriate for your site, of course, to deal with your
local telephone system. There are no limitations concerning the hours
of the day you may call.
Another possibility is to use UUNET, although they charge you
for it. You have been duly warned. Here's the advert:
Anonymous Access to UUNET's Source Archives
1-900-GOT-SRCS
UUNET now provides access to its extensive collection of UNIX
related sources to non- subscribers. By calling 1-900-468-7727
and using the login "uucp" with no password, anyone may uucp any
of UUNET's on line source collection. Callers will be charged 40
cents per minute. The charges will appear on their next tele-
phone bill.
The file uunet!/info/help contains instructions. The file
uunet!/index//ls-lR.Z contains a complete list of the files available
and is updated daily. Files ending in Z need to be uncompressed
before being used. The file uunet!~/compress.tar is a tar
archive containing the C sources for the uncompress program.
This service provides a cost effective way of obtaining
current releases of sources without having to maintain accounts
with UUNET or some other service. All modems connected to the
900 number are Telebit T2500 modems. These modems support all
standard modem speeds including PEP, V.32 (9600), V.22bis (2400),
Bell 212a (1200), and Bell 103 (300). Using PEP or V.32, a 1.5
megabyte file such as the GNU C compiler would cost $10 in con-
nect charges. The entire 55 megabyte X Window system V11 R4
would cost only $370 in connect time. These costs are less than
the official tape distribution fees and they are available now
via modem.
UUNET Communications Services
3110 Fairview Park Drive, Suite 570
Falls Church, VA 22042
+1 703 876 5050 (voice)
+1 703 876 5059 (fax)
info@uunet.uu.net
To Table of Contents
We'll cover five areas here: USENET (where you're probably reading
this), publications, the reference guide, examples on the Internet,
and Perl instructional courses.
A. USENET
You should definitely read the USENET comp.lang.perl newsgroup or
mailing list for all sorts of discussions regarding the language,
bugs, features, history, humor, and trivia. In this respect, it
functions both as a comp.lang.* style newsgroup and also as a user
group for the language; in fact, there's a mailing list called
``perl-users'' that is bidirectionally gatewayed to the newsgroup; see
question #38 for details. Larry Wall is a very frequent poster here,
as well as many (if not most) of the other seasoned Perl programmers.
It's the best place for the very latest information on Perl.
B. PUBLICATIONS
If you've been dismayed by the ~80-page troffed Perl man page (or is
that man treatise?) you should look to ``the Camel Book'', written by
Larry and Randal Schwartz <merlyn@ora.com>, published as a Nutshell
Handbook by O'Reilly & Associates and entitled _Programming Perl_.
Besides serving as a reference guide for Perl, it also contains
tutorial material and is a great source of examples and cookbook
procedures, as well as wit and wisdom, tricks and traps, pranks and
pitfalls. The code examples contained therein are available via
anonymous FTP from ftp.uu.net in
/published/oreilly/nutshell/perl/perl.tar.Z for your retrieval.
Corrections and additions to the book can be found in the Perl man
page right before the BUGS section under the heading ERRATA AND
ADDENDA.
If you can't find the book in your local technical bookstore, the book
may be ordered directly from O'Reilly by calling 1-800-998-9938 if in
North America and 1-707-829-0515. The book's ISBN is 0-937175-64-1.
Autographed copies are *NO LONGER* available from TECHbooks --
you'll have to nab the authors in person if you want one. Larry
routinely carries around a camel stamp for just such an occasion.
Reasonably substantiated rumor has it that there will be another Perl
book out pretty soon, this one aimed more at beginners. Look for it
from ORA towards the beginning of 93.
Another ORA book by Randal Schwartz is scheduled for imminent
release. It is entitled _Learning Perl_ (``The LLama Book'') and
covers the basics of Perl in a tutorial fashion.
Larry Wall has published a 3-part article on perl in Unix World
(August through October of 1991), and Rob Kolstad also had a 3-parter
in Unix Review (May through July of 1990). Tom Christiansen also has
a brief overview article in the trade newsletter Unix Technology
Advisor from November of 1989. You might also investigate "The Wisdom
of Perl" by Gordon Galligher from SunExpert magazine; April 1991
Volume 2 Number 4. The Dec 92 Computer Language magazine also
contains a cover article on Perl, "Perl: the Programmers Toolbox".
Many other articles on Perl have been recently published. If you
have references, especially on-line copies, please mail them to
the FAQ maintainer for inclusion is this notice.
The USENIX LISA (Large Installations Systems Administration) Conference
have for several years now included many papers of tools written in
Perl. Old proceedings of these conferences are available; look in
your current issue of ";login:" or send mail to office@usenix.org
for further information.
C. INTERNET
For other examples of Perl scripts, look in the Perl source directory in
the eg subdirectory.
The site with the biggest repository of Perl scripts right now
seems to be coombs.anu.edu.au [150.203.76.2]. That directory
has an INDEX with over 300 lines in it, each describing what
the script does. This is maintained by mark@coombs.anu.edu.au .
Note: European users please use the mirror site on
src.doc.ic.ac.uk[149.169.2.1 in
/pub/computing/programming/languages/perl/coombs-scripts
The link speed would be a lot better for all. Contact
L.McLoughlin@doc.ic.ac.uk for more information. It is updated daily.
Another source for examples, currently only for anonymous FTP, is on
convex.com [130.168.1.1]. This contains, amongst other things,
a copy of the newsgroup up through Aug 91, a text retrieval database
for the newsgroup, a rather old and short troff version of Tom Christiansen's
perl tutorial (this was the version presented at Washington DC USENIX),
and quite a few of Tom's scripts. You can look at the INDEX file
in /pub/perl/INDEX for a list of what's in that directory.
The Convex and Ohio State archives are mirrored on uunet
in /languages/perl/scripts-{convex,osu}.
There's also a #Perl channel on IRC (Internet Relay Chat) where
Tom and Randal have been known to hang out. That's real-time,
free Perl support. What more can you ask? :-)
D. REFERENCE GUIDE
A nice reference guide by Johan Vromans <jv@mh.nl> is also available;
It is distributed in LaTeX (source) and PostScript (ready to
print) forms. Obsolete versions may still be available in TeX and troff
forms, although these don't print as nicely. The official kit
includes both LaTeX and PostScript forms, and can be FTP'd from
ftp.cs.ruu.nl [131.211.80.17], file /pub/DOC/perlref-4.035.tar.Z.
The reference guide comes with the O'Reilly book in a nice, glossy
card format.
E. PERL COURSES
Various technical conferences, including USENIX, LISA, SUG, WCSAS, AUUG,
FedUnix, and Europen have been sponsoring tutorials of varying lengths
on Perl at their system administration and general conferences. You
might consider attending one of these. These public classes are
typically taught by Tom Christiansen <tchrist@usenix.com>. Both Tom
and Randal Schwartz <merlyn@ora.com> also teach Perl at customer
sites. Classes can run from one day up to a week ranging over a wide
range of subject matter (most are two or three days), and can include
lab time if you want; having lab time with exercises is generally of
great benefit. Send us mail if your organization is interested in
having a Perl class taught at your site, or if you'd like to know when
the next public appearances are.
To Table of Contents
"Perl-Users" is the mailing list version of the comp.lang.perl
newsgroup. If you're not lucky enough to be on USENET you can post to
comp.lang.perl by sending to one of the following addresses. Which one
will work best for you depends on which nets your site is hooked into.
Ask your local network guru if you're not certain.
Internet: PERL-USERS@VIRGINIA.EDU
Perl-Users@UVAARPA.VIRGINIA.EDU
BitNet: Perl@Virginia
uucp: ...!uunet!virginia!perl-users
The Perl-Users list is bidirectionally gatewayed with the USENET
newsgroup comp.lang.perl. This means that VIRGINIA functions as a
reflector. All traffic coming in from the non-USENET side is
immediately posted to the newsgroup. Postings from the USENET side are
periodically digested and mailed out to the Perl-Users mailing list. A
digest is created and distributed at least once per day, more often if
traffic warrants.
All requests to be added to or deleted from this list, problems,
questions, etc., should be sent to:
Internet: Perl-Users-Request@Virginia.EDU
Perl-Users-Request@uvaarpa.Virginia.EDU
BitNet: Perl-Req@Virginia
uucp: ...!uunet!virginia!perl-users-request
Coordinator: Marc Rouleau <mer6g@VIRGINIA.EDU>
To Table of Contents
Yes, although they're poorly organized. You can get them from the
host ftp.ugcs.caltech.edu (131.215.128.204) to the file
/pub/comp.lang.perl.tar.Z; this file was last modified on February 15,
1992, and is 8.9 megabytes long. Obviously, it's considerably out of
date.
These are currently stored in news- or MH-style format; there are
subdirectories named things like "arrays", "programs", "taint", and
"emacs". Unfortunately, only the first ~1600 or so messages have been
so categorized, and we're now up to almost 15000. Furthermore, even
this categorization was haphazardly done and contains errors.
Both Larry and I have maintained archives of the nearly 19,000
messages the newsgroup has seen since its inception. I'm currently
looking for a home for them. It'll take about 100 megabytes, although
I'm on a 16k/2k filesystem, and that might be reduced somewhat by one
with smaller frags. Or perhaps I'll just get myself a new disk.
They're just stored as regular files the way news does, so it's
somewhat unmanageable.
A more sophisticated query and retrieval mechanism is desirable.
Preferably one that allows you to retrieve article using a fast-access
indices, keyed on at least author, date, subject, thread (as in "trn")
and probably keywords. Right now, the MH pick command works for this,
but it is very slow to select on 18000 articles.
If you're serious about this, your best bet is probably to retrieve
the compressed tarchive and play with what you get. Any suggestions
how to better sort this all out are extremely welcome.
If you have a special request for a query on the old newsgroup
postings, and make nice noises in my direction, I can run the query
and send them to you. Algebraic queries are like "find me anything
about this and that and the other thing but not this or whozits". I
hope to put this in the form of a mailserver. Donated software would
be fine. :-)
The fast text-retrieval query system for this I'm currently using is
Liam Quin's excellent lqtext system, available from ftp.cs.toronto.edu
in /pub/lq-text* .
To Table of Contents
Rumor has it that there are WAIS servers out there for comp.lang.perl
these days, but I haven't used them. Kevin Gardner <gardner@zinc.csb.yale.edu>
offers the following: For WAIS server info, check on the gopher hole
at mudhoney.micro.umn.edu, port 70. They've got a rather extensive
list of WAIS servers at this gopher->WAIS gateway, including a c.l.p.
archive server. I don't know how up to date the server actually is,
as the articles I pulled up from there were all dated from '91.
Bill Middleton <wjm@feenix.metronet.com> offers this:
"I have setup a perl script retrieval service and WaisSearch here at
feenix. To check it out, just point your gopher at us, and select the
appropriate menu option. The WaisSearch is of the iubio type, which
means you can do boolean searching. Thus you might try something
like:
caller
ioctl and fcntl
grep and socket not curses
and other things to see examples of how other folks have done this
or that. This service is still under construction, but I'd like to
get feedback, if you have some time.
There's also a WaisSearch into all the RFC's and some other fairly
nifty stuff."
To Table of Contents
Probably. Perl already runs on virtually all UNIX machines as well as
quite a few non-UNIX ones. Chances are that if you're running a UNIX
box, you simply need to run Configure and everything will be taken
care of for you. For most UNIX machines, no porting is required.
Perl comes with an elaborate auto-configuration script that allows Perl
to be painlessly ported to a wide variety of platforms, including many
non-UNIX ones. Amiga and MS-DOS binaries are available on
jpl-devvax.jpl.nasa.gov [128.149.1.143] for anonymous FTP. Try to bring
Perl up on your machine, and if you have problems, examine the README
file carefully, and if all else fails, post to comp.lang.perl with
a cross-posting to comp.sys.whatever; probably someone out there has
run into your problem and will be able to help you.
In the perl archive on coombs.anu.edu.au, you can consult the file
/pub/perl/misc/perl.code.sources for information not contained below.
It may also be more up-to-date as well.
In particular, since they're so often asked about, here's some information
for the MacIntosh from Matthias Ulrich Neeracher <neeri@iis.ethz.ch>:
The most recent version of Perl for the Apple Macintosh using the
MPW C compiler is available in:
nic.switch.ch [130.59.1.40] software/mac/src/mpw_c
ftp.eunet.ch [146.228.10.15] software/mac/perl
The current version is 4.0.7 (despite the "7", it corresponds to
patchlevel 36 in the Unix version) and is available in the above
directories as
Mac_Perl_407_src.sit.bin Sources
Mac_Perl_407_tool.sit.bin MPW Tool
Mac_Perl_407_appl.sit.bin Standalone Application (See below)
There is a mailing list for discussing Macintosh Perl which can be
reached at mpw-perl-request@iis.ee.ethz.ch
Here's more, from Timothy Murphy <tim@maths.tcd.ie >
I ported perl to the Mac, using Think C, a while ago. I've
used it quite a lot since without problems.
It is available from ftp.maths.tcd.ie in pub/Mac/perl.hqx .
The source (as diffs from the standard source) is in the
subdirectory pub/Mac/perl-4.035 .
A Mac version of patch is also available in pub/Mac/patch.hqx
with source in pub/Mac/patch-2.0 . Various other Mac ports of
GNU programs can be found in the same place.
They all use a small "ThinkCPosix" library containing various
Unix-like functions, which again can be found in the same
place.
And here's some VMS information from Rao V. Akella
<rao@moose.cccs.umn.edu>: (this appears to be an old port)
You can pick up Perl for VMS (version 3.0.1.1 patchlevel 4) via
anonymous ftp from ftp.pitt.edu [130.49.253.1] in the
software/vms/perl subdirectory (there are two files there:
perl-pl18.bck and perl-pl4.bck).
There is also a v3.018 on info.rz.uni-ulm.de [134.60.1.125] or
vms.huji.ac.il [128.139.4.3] in /pub/VMS/misc (information courtesy
of Anders Rolff <rolff@scotty.eurokom.ie>).
And here is a recent version for MS-DOS from Budi Rahardjo
<rahard@ee.UManitoba.CA>, who says:
I am collecting MS-DOS Perl(s) in ftp.ee.umanitoba.ca directory
/pub/msdos/perl. Currently I received three versions of Perl v4.019
and one of 4.010. (Tommy Thorn <tthorn@daimi.aau.dk> and Len Reed
<holos0!lbr@gatech.edu>)
There is now a 4.035 for 386 [DOS], Hitoshi Doi <doi@jrd.december.com>
port, is available ftp.ee.umanitoba.ca as /pub/msdos/perl/perl386.zoo .
Please contact the porters directly in case of questions about
these ports.
A new version of "bigperl4" has been uploaded to Simtel20 and mirror
sites:
pd1:<msdos.perl>
BPERL2X.ZIP 32-bit Perl 4.0pl36 w/VM & Win 3.1 supt. (exe)
BPERL2S1.ZIP 32-bit Perl 4.0pl36 w/VM & Win supt. (src 1/2)
BPERL2S2.ZIP 32-bit Perl 4.0pl36 w/VM & Win supt. (src 2/2)
For those of you who don't know what "bigperl4" is, here's the
short description:
BIGPERL4 is Perl 4.0pl36 that has been compiled using the Watcom C/386
compiler (a 32-bit, flat-memory model C compiler), which gives this
version the following features:
* Up to 32MB of memory can be used.
* Supports virtual memory.
* Works under Windows 3.1 (however, a second copy of perl cannot
be spawned under Windows).
* The perl debugger can be used.
* Contains GDBM support.
A 386/486 with at least 4MB RAM is required, and a third-party memory
manager such as QEMM is strongly recommended.
BIGPERL4 also passes those perl tests that do not depend on Unix-isms.
Full sources are included (including GDBM 1.5). Freeware and copylefted
(in the case of GDBM 1.5).
For a version that works on NT, FTP to rhino.microsoft.com
(131.107.1.121) the port of Perl there purportedly works well and
includes support for sockets from perl. The source builds out of the
box and contains some NT specific tests.
To Table of Contents
John Lees <lees@pixel.cps.msu.edu> reports:
I have built perl on Solaris 2.1, 2.2 beta, and 2.2 FCS. Take /usr/ucb
out of your path and do not use any BSD/UCB libraries. Only -lsocket,
-lnsl, and -lm are needed. You can use the hint for Solaris 2.0, but
the one for 2.1 is wrong. Do not use vfork. Do not use
-I/usr/ucbinclude. The result works fine for me, but of couse does
not support a couple of BSDism's.
Casper H.S. Dik <casper@fwi.uva.nl> reports
You must remove all the references to /usr/ucblib AND
/usr/ucbinclude. And ignore the Solaris_2.1 hints. They are wrong.
The undefining of vfork() probably ahs to do with the confusion it
gives to the compilers. If you use cc, you mustn't compile
util.c/tutil.c with -O. I only used the following libs: -lsocket
-lnsl -lm (there is a problem with -lmalloc)
Michael D'Errico <mike@software.com> reports:
If you are using Solaris 2.x, the signal handling is broken. If you set
up a signal handler such as 'ripper' it will be forgotten after the first
time the signal is caught. To fix this, you need to recompile Perl. Just
add '#define signal(x,y) sigset((x),(y))' after the '#include <signal.h>'
directive in each file that it occurs, then make it again.
To Table of Contents
Bill Eldridge <bill@cognet.ucla.edu> reports:
To get perl to compile on Nexts, you need to combine the
ansi and bsd headers:
cd /usr/include
mkdir ansibsd
cd ansibsd
ln -s ../ansi
ln -s ../bsd
Then follow the configuration instructions for Nexts, *replacing*
all mention of -I/usr/include/ansi or -I/usr/include/bsd with
-I/usr/include/ansibsd.
(There might be more elegant solutions, but this is how I
did it, and it's quick and so far painless).
To Table of Contents
Numerous database-oriented extensions to Perl have been written.
These amount to using the usub mechanism (see the usub/ subdirectory
in the distribution tree) to link in a database library, allowing
embedded calls to Informix, Interbase, Oracle, Ingres, and Sybase.
There is currently a project underway, organized by Buzz Moschetti
<buzz@toxicavenger.bear.com>, to create a higher level interface
(DBperl) that will allow you to write your queries in a
database-independent fashion. If you're interested, send
mail to <perldb-interest-request@vix.com> and ask to be placed on the
perldb-interest@vix.com mailing list.
Meanwhile, here are the authors of the various extensions:
What Target DB Who
-------- ----------- ----------------------------------------
Infoperl Informix Kurt Andersen (kurt@hpsdid.sdd.hp.com)
Interperl Interbase Buzz Moschetti (buzz@bear.com)
Oraperl Oracle Kevin Stock (kstock@encore.com)
Sqlperl Ingres Ted Lemon (mellon@ncd.com)
Sybperl Sybase Michael Peppler (mpeppler@itf.ch)
Here's a bit of advertising from Buzz:
Perl is an interpreted language with powerful string, scalar, and array
processing features developed by Larry Wall that "nicely bridges the
functionality gap between sh(1) and C." Since relational DB operations
are typically textually oriented, perl is particularly well-suited to
manage the data flows. The C source code, which is available free of
charge and runs on many platforms, contains a user-defined function entry
point that permits a developer to extend the basic function set of the
language. The DBperl Group seeks to exploit this capability by creating a
standardized set of perl function extensions (e.g. db_fetch(), db_attach())
based the SQL model for manipulating a relational DB, thus providing a
portable perl interface to a variety of popular RDMS engines including
Sybase, Oracle, Ingres, Informix, and Interbase. In theory, any DB engine
that implements a dynamic SQL interpreter in its HLI can be bolted onto
the perl front end with predicatable results, although at this time
backends exist only for the aforementioned five DB engines.
A copy of the latest sybperl (patch level 6) can be found in the DBperl
archives on ftp.demon.co.uk:/pub/perl/db/sybperl
This archive also contains ports for Ingres, Oracle, Sybase, Informix,
Unify, Postgres, and Interbase, as well as rdb and shql; it's the home
of the evolving DBperl API Specification.
To Table of Contents
snmperl was written by Guy Streeter (streeter@ingr.com), and was
posted in late February 1993 to comp.protocols.snmp. The author has
not made it available for anonymous ftp, archie only reported one site:
Host liasun3.epfl.ch
Location: /pub/net/snmp
FILE -rw-rw-r-- 3407 Aug 11 1992 snmperl.README
FILE -rw-r--r-- 17678 Aug 11 1992 snmperl.tar.Z
Here is the gist of the README:
README $Revision: 1.1 $
This directory contains the source code to add callable C subroutines
to perl. The subroutines implement the SNMP functions "get",
"getnext", and "set". They use the freely-distributable SNMP package
(version 1.1b) from CMU.
USE:
There are four subroutines defined in the callable interface:
snmp_get, snmp_next, snmp_set, and snmp_error.
snmp_get and snmp_next implement the GET and GETNEXT operations,
respectively. The first two calling arguments are the hostname and
Community string. The IP address of the host, as a dotted-quad ASCII
string, may be used as the hostname. The rest of the calling
arguments are a list of variables. See the CMU package documentation
for how variables may be specified.
snmp_set also takes hostname and Community string as arguments. The
remaining arguments are a list of triples consisting of variable name,
variable type, and value. The variable type is a string, such as
"INTEGER" or "IpAddress".
snmp_get, snmp_next, and snmp_set return a list containing
alternating variables and values. snmp_get and snmp_next will simply
omit non-existent variables on return. snmp_set will fail completely
if one of the specified variables does not exist (or is read-only).
snmp_error will return a text string containing some error
information about the most recent snmp_get|next|set call, if it had an
error.
OTHER NOTES:
I didn't find all the places where the CMU library writes to stderr
or calls exit() directly.
The changes I made to mib.c involve the formatting of variable values
for return to the caller. I took out the descriptive prefix so the
string contains only the value.
Enumerated types are returned as a string containing the symbolic
representation followed in parentheses by the numeric.
DISTRIBUTION and OWNERSHIP
perl and the CMU SNMP package have their own statements. Read them.
The work I've done is free and clear. Just don't say you wrote it if
you didn't, and don't say I wrote it if you change it.
Guy Streeter
streeter@ingr.com
April 1, 1992 (not a joke!)
To Table of Contents
Because the Pascal people would be upset that we stole their name. :-)
The dynamic nature of Perl's do and eval operators (and remember that
constructs like s/$mac_donald/$mac_gregor/eieio count as an eval) would
make this very difficult. To fully support them, you would have to put
the whole Perl interpreter into each compiled version for those scripts
using them. This is what undump does right now, if your machine has it.
If what you're doing will be faster in C than in Perl, maybe it should
have been written in C in the first place. For things that ought to be
written in Perl, the interpreter will be just about as fast, because the
pattern matching routines won't work any faster linked into a C program.
Even in the case of simple Perl programs that don't do any fancy evals, the
major gain would be in compiling the control flow tests, with the rest
still being a maze of twisty, turny subroutine calls. Since these are not
usually the major bottleneck in the program, there's not as much to be
gained via compilation as one might think.
To Table of Contents
The undump program comes from the TeX distribution. If you have TeX, then
you may have a working undump. If you don't, and you can't get one,
*AND* you have a GNU emacs working on your machine that can clone itself,
then you might try taking its unexec() function and compiling Perl with
-DUNEXEC, which will make Perl call unexec() instead of abort(). You'll
have to add unexec.o to the objects line in the Makefile. If you succeed,
post to comp.lang.perl about your experience so others can benefit from it.
If you have a version of undump that works with Perl, please submit
its anon-FTP whereabouts to the FAQ maintainer.
To Table of Contents
In the perl4.0 source directory, you'll find a directory called
"emacs", which contains several files that should help you.
1.19) How can I use Perl interactively?
The easiest way to do this is to run Perl under its debugger.
If you have no program to debug, you can invoke the debugger
on an `empty' program like this:
perl -de 0
(The more positive amongst us prefer "perl -de 1". :-)
Now you can type in any legal Perl code, and it will be immediately
evaluated. You can also examine the symbol table, get stack
backtraces, check variable Values, and if you want to, set
breakpoints and do the other things you can do in a symbolic debugger.
1.20) Is there a Perl shell?
Not really. Perl is a programming language, not a command
interpreter. There is a very simple one called "perlsh"
included in the Perl source distribution. It just does this:
$/ = ''; # set paragraph mode
$SHlinesep = "\n";
while ($SHcmd = <>) {
$/ = $SHlinesep;
eval $SHcmd; print $@ || "\n";
$SHlinesep = $/; $/ = '';
}
Not very interesting, eh?
Daniel Smith <dansmith@autodesk.com> is working on an interactive Perl
shell called SoftList. It's currently at version 3.0beta. SoftList
3.0 has tcsh-like command line editing, can let you define a file of
aliases so that you can run chunks of perl or UNIX commands, and so
on. You can send mail to him for further information and availability.
To Table of Contents
While there isn't one included with the perl source distribution (yet)
various folks have written packages that allow you to do at least some
sort of profiling. The strategy usually includes modifying the perl
debugger to handle profiling. Authors of these packages include
Wayne Thompson <me@anywhere.EBay.Sun.COM>
Ray Lischner <lisch@sysserver1.mentor.com>
Kresten Krab Thorup <krab@iesd.auc.dk>
The original articles by these folks containing their
profilers are available on convex.com in
/pub/perl/information/profiling.shar via anon ftp.
To Table of Contents
Yes!! It's a version of Berkeley yacc that outputs Perl code instead
of C code! You can get this from ftp.sterling.com [192.124.9.1] in
/local/perl-byacc1.8.1.tar.Z, or send the author mail for details.
To Table of Contents
One way is to build a curseperl binary by linking in your C curses
library as described in the usub subdirectory of the perl sources.
This requires a modicum of work, but it will be reasonably fast
since it's all in C (assuming you consider curses reasonably fast. :-)
Programs written using this method require the modified curseperl,
not vanilla perl, to run. While this is something of a disadvantage,
experience indicates that it's better to use curseperl than to
try to roll your own using termcap directly.
For a good example of using curseperl, you might want to pick up a
copy of Steven L Kunz's <skunz@iastate.edu> "perl menus" package
("menu.pl") via anonymous FTP from "ftp.iastate.edu". It's in the
/pub/perl as
menu.pl.v1.4.shar
menu.pl.v2.0.shr1
menu.pl.v2.0.shr2
menu.pl.v2.0.tar.Z
menus.pl is a complete menu front-end for curseperl and demonstates
a lot of things (plus it is useful to boot if you want full-screen
menu selection ability).
Another possibility is to use Henk Penning's cterm package, a curses
emulation library written in perl. cterm is actually a separate
program with which you communicate via a pipe. It is available from
ftp.cs.ruu.nl [131.211.80.17] via anonymous ftp. in the directory
pub/PERL. You may also acquire the package via email in compressed,
uuencoded form by sending a message to mail-server@cs.ruu.nl
containing these lines:
begin
send PERL/cterm.shar.Z
end
See the question on retrieving perl via mail for more information on
how to get retrieve other items of interest from the mail server
there.
To Table of Contents
Right now, you have several choices. You can wait for perl5, use
the WAFE or STDWIN packages, or try to make your own usub bindings.
Perl5 is anticipated to be released with bindings for X, called
guiperl. An exciting prototype for this, written by Jon Biggar
<jon@netlabs.com>, Larry's *other* brother-in-law and officemate,
is already up and running inside of Netlabs. This program addresses
the same dynamic gui-building problem space as does tcl/tk.
If you can't wait or don't think that guiperl will do what you want,
a stab at Motif bindings was begun by Theodore C. Law
<TEDLAW@TOROLAB6.VNET.IBM.COM> area. His article about this is
on convex.com in /pub/perl/info/motif for anon ftp.
STDWIN is a library written by Guido van Rossum <guido@cwi.nl>
(author of the Python programming language) that is portable
between Mac, Dos and X11. One could write a Perl agent to
speak to this STDWIN server.
WAFE is a package that implements a symbolic interface to the Athena
widgets (X11R5). A typical Wafe application consists in our framework
of two parts: the front-end (we call it Wafe for Widget[Athena]front
end) and an application program running typically as separate process.
The application program can be implemented in an arbitrary programming
language and talks to the front-end via stdio. Since Wafe (the
front-end) was developed using the extensible TCL shell (cite John
Ousterhout), an application program can dynamically submit requests to
the front-end to build up the graphical user interface; the
application can even down-load application specific procedures into
the front-end. The distribution contains sample application programs
in Perl, GAWK, Prolog, TCL, and C talking to the same Wafe binary.
Many of the demo applications are implemented in Perl. Wafe 0.9 can
be obtained via anonymous ftp from
ftp.wu-wien.ac.at:pub/src/X11/wafe-0.9.tar.Z
(for people without name server: the ip address is 137.208.3.5)
Alternatively, you could use wish from tcl.
#!/usr/local/bin/perl
#####################################################################
# An example of calling wish as a subshell under Perl and
# interactively communicating with it through sockets.
#
# The script is directly based on Gustaf Neumann's perlwafe script.
#
# Dov Grobgeld dov@menora.weizmann.ac.il
# 1993-05-17
#####################################################################
$wishbin = "/usr/local/bin/wish";
die "socketpair unsuccessful: $!!\n" unless socketpair(W0,WISH,1,1,0);
if ($pid=fork) {
select(WISH); $| = 1;
select(STDOUT);
# Create some TCL procedures
print WISH 'proc echo {s} {puts stdout $s; flush stdout}',"\n";
# Create the widgets
print WISH <<TCL;
# This is a comment "inside" wish
frame .f -relief raised -border 1 -bg green
pack append . .f {top fill expand}
button .f.button-pressme -text "Press me" -command {
echo "That's nice."
}
button .f.button-quit -text quit -command {
echo "quit"
}
pack append .f .f.button-pressme {top fill expand} \\
.f.button-quit {top expand}
TCL
;
# Here is the main loop which receives and sends commands
# to wish.
while (<WISH>) {
chop;
print "Wish sais: <$_>\n";
if (/^quit/) { print WISH "destroy .\n"; last; }
}
wait;
} elsif (defined $pid) {
open(STDOUT, ">&W0");
open(STDIN, ">&W0");
close(W0);
select(STDOUT); $| = 1;
exec "$wishbin --";
} else {
die "fork error: $!\n";
}
To Table of Contents
The answer to what is perl4 is nearly anything you might otherwise
program in shell or C. The answer to what is perl5 is basically
Perl: the Next Generation. In fact, it's essentially a complete
rewrite of perl from the bottom up, and back again. It's available
in alpha form (alpha-2 now, alpha-3 soon). The only docs for this stuff
is what you're about to read, and what's in the t/op/ref.t file.
Here are the things which are already done:
a faster, tighter, more flexible interpreter
new token "=>" as synonym for ","; this makes
tables look nicer
%T = ( OC => $red,
TOF => "\f",
);
and provides for named argument passing:
&some_func( OC => $red, TOF => "\f");
recursive lists and tables:
[a, b, [c, d], e] has 4 elts, the 3rd being itself a list
$r->[3]->{PEANUT}; $r is a reference to a list
of references to tables
typed pointers (references) and generalized indirection:
like @{$aptr} or &{$fptr} or &{ $table[$index] . "func" }().
merging of list operator and function calling syntax:
split /pat/, $string;
the ref operator to find out what something is a reference to
object oriented programming:
$o->func(); # call the func member function of whatever class $o is
inheritance of object types through the @ISA array
much improved -w checking
lexical scoping with the my operator
safe global variables through package statements
forces variable declarations, but only if you want it
per-package END functions triggered at die() or exit()
embeddable Perl code in C code: cc prog.c -lperl
oo syntactic extensions:
$dog->give($bone);
is like
give $dog $bone;
and
$STDOUT->flush(1);
is like
flush $STDOUT 1;
multiple co-resident perl interpreters:
Here is what is hoped to be done for production, but might not:
very easy GUI Perl applications using high-level X bindings ("guiperl")
subroutines without &'s: myfunc($arg);
mnemonic aliases for $<punctuation> variables
file handle objects: $STDOUT->flush(1);
cleanup (namespace pollution) and documentation
(eg. man 3pl getopt) of libraries
addition of several new libraries (atexit, autoload, etc.)
update h2ph and c2ph
misc perl development tools
a perl profiler
POSIX compatibility
Here is what is hope to eventually be done but very probably not in
the first production release:
generalization of dbm binding for assoc arrays to handle
any generic fetch/store/open/close/flush package.
(thus allowing both dbm and gdbm at once)
dynamic loading of C libraries for systems that can
byte-compiled code for speed and maybe security
And here are the things that will no longer work that used to:
open FILE || die;
$c = shift @a + 1;
It's tempting to want this stuff soon, since the sooner it comes
out the sooner we can all build really cool applications. But the
longer Larry works on it, the more items from this list will actually
get done, and the more robust the release will be. So let's not
ask him about it too often. Larry says (slightly edited):
I've put a tar of my current Perl 5 directory onto
ftp.netlabs.com, in pub/outgoing/perl5.0/perl5a2.tar.Z.
Now's your chance to check out all the bugs I said I fixed in
Perl 5. :-)
Before you get all twitterpated, this is unsupported "alpha 2"
code. There is no Configure, only a makefile. It will
probably only work on a Sun4. The compiler and interpreter are
still very much unoptimized (though it already runs as fast or
faster than Perl 4). It doesn't do everything that I want it
to yet. It doesn't have "my" yet (though it's got the innards
for it). It doesn't have a debugger.
Like the Alpha 1 prerelease, this is an unsupported code. It is
expected to work only on a Sparc architecture machine. No
Configure support is provided. In fact, if you succeed in
configuring and making a new makefile, you'll probably overwrite
the only makefile that works. (Note that a Sparc executable comes
with the kit, so you may not need to compile at all.) There is
no list of new features yet, but if you look at t/op/ref.t
you'll see some of them in use. perl -Dxst is also fun.
But it does have references, and you can play with them. The
object oriented stuff is there too. See the op/ref.t file for
how to use them.
I smell some new JAPHs coming...
I don't want to get stuck "supporting" this, but if you want to
run your favorite scripts past it and see which ones toss their
salad, you may. If you can come up with a decent bug report
with a small test case, I'll certainly be glad to look at it.
I'm not really interested in obscure core dumps at the moment.
I'm still getting plenty of those on my own.
I'm not yet interested in memory leak reports either.
I can tell you that no program that uses the old autoloading
mechanism will run, since there is no visibility into the
symbol table pointers currently. You ought to be able to
redefine a subroutine while it's running, though. (I haven't
tested that in several months, however. There oughta be a
regression test for that...)
Don't bother trying to diff Perl 4 with Perl 5. Everything is
different. All names have been regularized. Here's a key, if
you're brave and want to peek at the sources:
SV scalar value
AV array value
HV hash value
GV glob value
CV code value
RV reference value
PV pointer value
NV numeric value
IV integer value
To Table of Contents
REXX is an interpreted programming language first seen on IBM systems,
and TCL is John Ousterhout's embeddable command language. TCL's most
intriguing feature for many people is the tcl/tk toolset that allows
for interpreted X-based tools.
To avoid any flamage, if you really want to know the answer to this
question, probably the best thing to do is try to write equivalent
code to do a set of tasks. All three have their own newsgroups in
which you can learn about (but hopefully not argue about) these
languages.
To find out more about these or other languages, you might also check
out David Muir Sharnoff <muir@tfs.com>'s posting on "Catalog of
compilers, interpreters, and other language tools" which he posts to
comp.lang.misc, comp.sources.d, comp.archives.admin, and the
news.answers newsgroups. It's a comprehensive treatment of many
different languages. (Caveat lector: he considers Perl's syntax
"unappealing".) This list is archived on convex.com in
/pub/perl/info/lang-survey.shar .
To Table of Contents
Certainly. :-)
Current UNIX parlance holds that anything interpreted
is a script, and anything compiled into native machine
code is a program. However, others hold that a program
is a program is a program: after all, one seldom discusses
scripts written in BASIC or LISP. Larry considers it
a program if it's set in stone and you can't change it,
whereas if you go in and hack on it, then it's a script.
But doesn't really matter. The terms are generally
interchangeable today.
To Table of Contents
32 :-) [ ord('p') - ord('P') ]
Larry now uses "Perl" to signify the language proper and "perl" the
implementation of it, i.e. the current interpreter. Hence tchrist's quip
that "Nothing but perl can parse Perl."
On the other hand, the aesthetic value of casewise parallelism
in "awk", "sed", and "perl" as much require the lower-case
version as "C", "Pascal", and "Perl" require the
upper-case version. It's also easier to type "Perl" in
typeset print than to be constantly switching in Courier. :-)
In other words, it doesn't matter much, especially if all
you're doing is hearing someone talk about the language;
case is hard to distinguish aurally.
To Table of Contents
At this time, the known list of companies that ship Perl includes at
least the following, although some have snuck it into /usr/contrib
or its moral equivalent:
BSDI
Comdisco Systems
CONVEX Computer Corporation
Crosspoint Solutions
Dell
DRD Corporation
Intergraph
Kubota Pacific
Netlabs
Univel
Furthermore, the following vendors are reported to begin shipping perl
standard with their systems in the very near future:
Sun
SGI
Some companies ship it on their "User Contributed Software Tape",
such as DEC and HP. Apple Computer has shipped the MPW version of
Macintosh Perl on one of their Developer CDs (Essentials*Tools*Objects
#11) (and they included it under "Essentials" :-)
Many other companies use Perl internally for purposes of tools
development, systems administration, installation scripts, and test
suites. Rumor has it that the large workstation vendors (the TLA set)
are seriously looking into shipping Perl with their standard systems
"soon".
People with support contracts with their vendors are actively
encouraged to submit enhancement requests that Perl be shipped
as part of their standard system. It would, at the very least,
reduce the FTP load on the Internet. :-)
If you know of any others, please send them in.
To Table of Contents
Not really. Although perl is included in the GNU distribution, at
last check, Cygnus does not offer support for it. However, it's
unclear whether they've ever been offered sufficient financial
incentive to do so.
On the other hand, you do have comp.lang.perl as a totally gratis
support mechanism. As long as you ask "interesting" questions,
you'll probably get plenty of help. :-)
While some vendors do ship Perl with their platforms, that doesn't
mean they support it on arbitrary other platforms. And in fact, all
they'll probably do is forward any bug reports on to Larry. In
practice, this is far better support than you could hope for from
nearly any vendor.
The companies who won't use something unless they can pay money
for it will be left out. Often they're motivated by wanting
someone whom they could sue. If all they want is someone to help
them out with Perl problems, there's always the net. And if they
really want to pay someone for that help, well, Tom and Randal are
always looking for a job. :-)
If companies want "commercial support" for it badly enough, speak
up -- something might be able to be arranged.
To Table of Contents
These are the "just another perl hacker" signatures that
some people sign their postings with. About 100 of the
of the earlier ones are on convex.com in /pub/perl/info/japh.
To Table of Contents
Over a hundred quips by Larry, from postings of his or source code,
can be found on convex.com in /pub/perl/info/lwall-quotes.
To Table of Contents
That depends on what you mean. If you want something
that works like vgrind on Perl programs, then the answer
is "yes, nearly". Here's a vgrind entry for perl:
PERL|perl|Perl:\
:pb=^\d?(sub|package)\d\p\d:\
:bb={:be=}:cb=#:ce=$:sb=":se=\e":lb=':\
:le=\e':tl:\
:id=_:\
:kw=\
if for foreach unless until while continue else elsif \
do eval require \
die exit \
defined delete reset \
goto last redo next dump \
local undef return \
write format \
sub package
It doesn't actually do everything right; in particular,
things like $#, $', s#/foo##, and $foo'bar all confuse it.
David Levine uses this:
# perl 4.x David Levine <levine@ics.uci.edu> 05 apr 1993
# Derived from Tom Christiansen's perl vgrindef. I'd like to treat all of
# perl's built-ins as keywords, but vgrind fields are limited to 1024
# characters and the built-ins overflow th