1. The Standard Channels

There are three standard channels in Perl, for basic input and output. Each has a predefined file handle, and they are:

file handle	description	default
STDOUT	The standard output channel	terminal in which Perl script is running
STDERR	The standard error channel	terminal in which Perl script is running
STDIN	The standard input channel	characters from the keyboard

The file handle is rather like another Perl data type; by convention (but not essentially) it is written in uppercase. As the term suggests, it gives us a handle on a file, either for reading in data, or writing out. But what is written to/read from need not only be a file; it could be a process, or a network connection.

When we print in Perl, by default we are printing to STDOUT. To put it another way, the following two statements are equivalent,

    print "Run of $0 at ", scalar(localtime), "\n"; 
    print STDOUT "Run of $0 at ", scalar(localtime), "\n"; 

Another example is provided by error messages; when a script dies, the die message goes to STDERR, which by default is the window or terminal from which the script was run. The defaults can be overridden; all the standard filehandles can be redirected. In a CGI context, they all change anyway. STDOUT becomes the client browser - in other words, if you print "Content-type: text/plain\n\n"; in a CGI script, you are printing it to STDOUT, and that means sending it back down the wire to the browser. STDERR is typically the web server's error log, and STDIN takes in html form data submitted by the post method.

In reading from STDIN, we typically use the angle brackets line-reading operator. In scalar context, angled brackets around any filehandle will read one line from it; that is, if we assign the result to a scalar:

    $line = <STDIN>;

Start a new script io.pl, enter and try out the following:

    print STDOUT "Enter your full name: ";
    $name = <STDIN>; 
    print STDOUT "Hello $name!"; 

Notice what happens when you run this: the exclamation mark appears on a new line. This is precisely because the line reading operator included the carriage return, which was therefore held in the variable $name. To overcome this, Perl provides the chomp function. So -

    chomp($name = <STDIN>); 

which is equivalent to reading in $name first (as above), and then doing chomp($name). chomp is a "soft" operation: it only removes a new line if there is one at the end, otherwise it leaves its argument unchanged. For a hard "chop off the last character regardless", there is the chop function. Add a chomp to your program and observe the change.

Set up a while loop to keep reading lines entered from the keyboard. Echo the text back to user, unless they type "quit" or "bye" etc., in which case, terminate the loop.

2. I/O to Files

File I/O is very straightforward in Perl; we use the open function, with two arguments: the file handle we are going to use, and the name of the file. The name can be prefixed by a mode operator, which indicates whether the file is being opened for read or write. Some examples:

example	mode	notes
open LOGFILE, 'log.txt';	input	file must exist
open LOGFILE, '< log.txt';	input	same as above; mode made explicit
open OUTPUT, "> $file";	output	create $file if it doesn't exist; overwrite it if it does
open STDERR, ">> logs/error.log";	append	create error.log if it doesn't exist; don't overwrite: add new text at the end
open FILE, '+< data.log';	update	open for reading and writing

Notice that the appending example redirects STDERR. If a run of a script containing that redirect dies, the message from die will be appended to the logs/error.log file. (In the other examples, the file handles are whatever we want them to be: FILE, OUTPUT, etc. are not reserved file handles.) It is not essential to have the space between the chevron mode operator and the file name path; however in some operating systems "<file" is a valid file name, so it is a good policy for safety to put the space in.

Where the file name includes a directory path, that path must be valid or the operation will fail. (It is perfectly possible to create directories from within a Perl script, but open requires that the directory exists.) Moreover, on unix, the Perl script must have the appropriate permissions to access the directory and file. This could be a problem for a CGI script that needs to write to its own log file - you may need to perform an operation like chmod 0666 on the file.

In Windows, there is a minor problem created by the fact that the directory separator is a backslash, given that in Perl, the backslash is interpreted within double quoted strings. However, you can use backslash within single quotes, or a unix-style forwards slash even for a Windows path. So both of these are OK:

    open (LOGFILE, '> C:\apache\logs\error.log') or die "Can't open error.log: $!"; 
    open (LOGFILE, "> C:/apache/logs/error.log") or die "Can't open error.log: $!"; 

Once we have successfully opened a file handle for writing, we can print to it. (If the > is omitted, an error will be generated if an attempt is made to print to the file.) As soon as we have finished with the file, it is good practice to close it (although all file handles will be automatically closed when the script finishes),

    print LOGFILE "Log at ", scalar(localtime), "\n"; 
    close LOGFILE; 

    open (LOGFILE, '>> C:/apache/logs/script.log') or die "Can't open script.log: $!';
    select LOGFILE; 
    print "Log at ", scalar(localtime), "\n";  

To read in from a file, the standard practice is to use the angle operator in the context of a while loop, reading it line by line. Using the angle operator in array context - as in, assigning it to an array variable @lines = <INPUT>; - would read the whole thing in at once, making each line of the INPUT file an element of the array. This is not recommended - if there is any prospect of the file being large, this could place an impossible burden on memory.

The example below reads from one file and writes to another. If you work a lot with both unix and dos files, you will be familiar with the carriage returns of one OS not being formatted properly in the other - at least with simple text editors like Notepad. This simple script can be used to strip out the carriage returns in a file, and re-write it, this time with the carriage returns of the current OS. (If you are in Windows, and want to run it, try the file unix.txt; opening this in Notepad will reveal the unix carriage returns.)

    $in = "unix.txt";
    $out = "$in.dos";

    open(OLD, "< $in");
    open(NEW, "> $out");

    while ($line = <OLD>) {
        chomp $line; 
        print NEW "$line\n";
    }

    close NEW;
    close OLD;

A. Perl has a special variable to hold any arguments passed in at the command line to a script: @ARGV (much as e.g. Java has the String[] args in a main() method.) Modify the above code so that the name of the input file is passed in at the command line; that is, if we call the script strip.pl, it might be invoked

prompt> perl strip.pl inputfile

B. In fact there is also a file handle ARGV, which is used on the assumption that all the arguments passed in at the command line are file names, and behaves like a file handle on all those files, as if they were all concatenated together. In other words, a while($line = <ARGV>) reads every line from all the files specified at the command line, silently passing from one to the next. Another variable, $ARGV, keeps track of the name of the file currently being processed.

Modify the script so that it uses ARGV and $ARGV, to generate a new file which joins all these files into one: winter, horse, conscience and sylvia. At each point when it passes on to the next file, have it print a message to the standard output like "Now dealing with file: horse".

C. Colouring within html files is achieved like this: <td bgcolor="#003366">, where this example gives a background colour to a table cell. In this case, the 00 represents the red component of the colour, the 33 its green component, and 66 the blue component. Any values in the range 00 to FF are permissible, but only certain values combine to make colours which are considered to be "browser safe". Those values are 00, 33, 66, 99, CC and FF. Write a Perl script to iterate through these values, to create an html file which holds a colour chart like the one below.
Hints

• first get your script working to generate the 'shell' of the html file, with just the html header 'Table of browser safe colours' included.
• create an array of strings holding the values '00', '33' etc.; create three nested loops, each of which iterates through that array, the innermost loop being the one which prints one coloured table cell.
• concentrate on generating the core table of colours, not the additional legend around the sides. Since there are three components to a colour, R, G and B, there are three dimensions to the colour table, but here we only have the two dimensions of the page to display it on. So what we can do is spread 'slices' of the 3rd dimension across one of the other two dimensions - either as shown below, or in this alternative.

Table of browser safe colours

3. I/O to Processes

Those familiar with unix will be used to 'piping' processes to together - combining commands so that the results of one are fed in to the next. This requires the vertical bar, |, the pipe bar:

prompt> ls -l /etc | more
prompt> ps -aux | grep httpd

In piping two commands together, one process generates an output, and the other takes an input. When opening a file handle on a process in Perl, we can make that handle output to the other process, or receive input from it; simply by placing the pipe bar appropriately:

    open OUTPUT, "| process";    # this Perl script outputs to process
    open INPUT, "process |";     # this Perl script receives input from process

To give a very simple illustation of this, here is a Perl script which achieves the same as the second of the unix examples above, by opening a file handle PS on the ps -aux command. We read in from PS in just the same way as if it were a file, line by line. The ps command puts variable amounts of whitespace between the items of information on each process, so each line is split with the regular expression /\s+/ - "one or more whitespace". The results of the split are read into an array, the last member of which details the actual command. This is checked against the string httpd, and if it matches, the whole ps line is printed out:

open (PS, "ps -aux |");

while ($line = <PS>) {
  ($user, $pid, $cpu, $mem, $vsz, $rss, $tty, $stat, $start, $time, $cmd) 
       = split(/\s+/, $line);
  print "$line" if $cmd =~ /httpd/;
}
close PS;

© INGENIO.co.uk