• my
declare a local variable
 
• our
declare a global variable
 
• local
redefine a variable name to be local to the current block
 
• undef
undefine a variable
undef $foobar;
since its returns an undefined value, it can be used to initialize a variable:
$a = undef;
 
• defined
test if a variable is defined
 
• exists
test if a hash element, array element or subroutine exists (but it can be undefined)
 
• delete
remove the element of a hash or of an array

quoted strings
 

single quoted literal string	''	q{}	no interpolation
double quoted literal string	""	qq{}	interpolation
command	``	qx{}	interpolation unless '' is delimiter
word list		qw{}	no interpolation
pattern match	//	m{}	interpolation unless '' is delimiter
pattern		qr{}	interpolation unless '' is delimiter
substitution		s{}{}	interpolation unless '' is delimiter
transliteration		tr{}{}	no interpolation except for the first escape sequences (up to named char)

bracketing characters may be:

• the same character at the beginning and the end
• one of the four bracket types: round, angle, square, curly

• lc
return a lowercased string
 
• lcfirst
return the string with the first letter lowercased
 
• uc
return a uppercased string
 
• ucfirst
return the string with the first letter uppercased
 
• chr
return the character coded by an integer in the current character set (ASCII, except if use utf8, in this case Unicode)
 
• ord
return the integer coding the first character of a string in the current character set
 
• substr
  extract a substring of a string
  
  
• split
put the two first words and the remainder of a string into three variables
my ($a,$b,$c)= split(/ +/,$string,3);
 
• hex
  translate a string representing an integer in hexadecimal form into the integer
  if ( $address =~ /(..):(..):(..):(..):(..):(..)/ )

{
      $b0 = hex("0x".$1);
      $b1 = hex("0x".$2);
      $b2 = hex("0x".$3);
      $b3 = hex("0x".$4);
      $b4 = hex("0x".$5);
      $b5 = hex("0x".$6);
}
else
{
    die "incorrect mac address\n"
}

• oct
  translate a string representing an integer in octal form into the integer
  
  
• vec
  get/set element in a string considered as an array of bitsets (the considered bitset can be bits, duos, nibles, octets, half-words, words...)
  

tests

if/elsif/else:

if ( $o_verb =~ /oyer/ )
{
    die "error in $line" if $o_verb =~ /envoyer$/;
    $n_group = "36";
}
elsif ( $o_verb =~ /oyer/ )
{
    $n_group = "35";
}
else
{
    die "error in $line";
}
 

if/unless:

die "..." if ...
die "..." unless ...
 

switch case:

SW_GROUP: {
    if ( $o_group eq "6" )
    {
        ...
        last SW_GROUP;
    }
    if ( $o_group eq "7" )
    {
        ...
        last SW_GROUP;
    }
    ...
    die "unknown group: $o_group";
}
or
while ( <$inputFile> ) {
  SWITCH: {
    /^homme : ([^ ]*) (.*)$/ && do {
        $homme{'prenom'} = $1;
        $homme{'nom'} = $2;
        last SWITCH;
    };
    /^femme : ([^ ]*) (.*)$/ && do {
        $femme{'prenom'} = $1;
        $femme{'nom'} = $2;
        last SWITCH;
    };
    print "unknown parameter: $_";
  }
}

loops

• for:
  for (my $i = 1; $i < 10; $i++) {
      ...
  }
  

loop  on a list content:

@letters = (a,b,c,d,e,f);
foreach my $l ( @letters ) {
    ...
}
 

continue

a continue block after a  block (typically a while or foreach loop)  is executed before the condition is evaluated once again
 

next

go to the end of the block, execute the continue block and start the next iteration
with a label, go to the end of the labelled loop
 

last

exit the block
with a label, exit the labelled block
 

redo

restart the block without executing the continue block and evaluating the conditional
with a label, redo the labelled block

while (EXPR) {
  # redo always comes here
  do_something;
} continue {
  # next always comes here
  do_something_else;
  # then back the top to re-check EXPR
}
# last always comes here

error handling

die

exit the script with an error message
 

warn

display an error message and continue
warn "incorrect value [".$value."]";

subroutines

• the parameters are transmitted as a list (@_)
sub foobar {
  my ($ar1, $var2) = @_;
  ...
}

• the keyword sub is optionnal
 
• BEGIN
executed as soon as it is read (before the remainder of the file is parsed)
once executed, it is removed from memory and cannot be called
 
• END
execute when the program exits (execept when exec is used or a signal is received)
 
• INIT
executes just before the runtime execution starts
 
• CHECK
executes just after the compilation finishes and before execution starts

• m/pattern/cgimosx
/pattern/cgimosx search a string for a patttern match
if the separator is /, m is optional
if the separator is ?, the match only once rule of ?pattern? applies
if the separator is ', no interpolation is performed on pattern
 
• ?pattern? matches only once (deprecated)
reset has to be called to authorize further matches
 
• *      Match 0 or more times
  +      Match 1 or more times
  ?      Match 1 or 0 times
  {n}    Match exactly n times
  {n,}   Match at least n times
  {n,m}  Match at least n but not more than m times
  
  
• ? set the subpattern to match the minimum length instead of the maximum (i.e. non-greedy search)
  
 
• test a pattern matching and retrieve the matching parts
  if ( $line =~ /^SPR # :  (.....)(.....)/ )
  {
      $idorg = $1;
      $idnum = $2;
  }
 
• remove the space at the end of a variable value
$l =~ s/^(.*?) *$/$1/;
 
• store a pattern in a variable
$pattern = qr/^\(0x0010,0x0010\)/;
 
• pos
return the position of the end of the last m//g match
 
• use
• $& to get the full matching string
• $` to get the preceding part of the string
• $' to get the following part
$line =~ s~(((BUC|CTC|GSA|IIS|MRI|NPS|XRY)ge)|(YMSmr))[0-9][0-9][0-9][0-9][0-9]~<AHREF="http://3.45.12.26/ddts/ddts_main?LastForm=DumpBug\&bug_id=$& "TARGET="_blank">$&</A>~g;
 
• character classes

\w	match a word character (alphanumeric or _)
\W	match a non word character
\s	match a whitespace character
\S	match a non whitespace character
\d	match a digit character
\D	match a non-digit character

• zero-width assertions

^	match the beginning of the line (may have multiply matches if /m modifier is used)
$	match the end of the line (may have multiply matches if /m modifier is used)
\A	match at beginning of string
\Z	match at end of string or before new line
\z	match at end of string
\b	match a word boundary
\B	match a non word boundary
\G	match only at pos (i.e. end of match position of last m//g)

• modifiers

/g	specify global pattern matching in list context, return all the matching patterns in scalar context, each call finds the next match and returns true if there is one, false if there is none
/s	treat the string as a single line (i.e. . also matches \n)
/m	treat the string as multi line (i.e. ^ and $ matches the start and end of any line in the string, instead of the beginning and end of the string)
/i	case-insensitive pattern matching
/x	use extended regular expressions
/e	evaluate the right side as an expression (e.g. use $1, $2... instead of \1,\2...)
/o	compile pattern only once
/c	do not reset position on a failed match when /g is in effect

• extended patterns

(?=pattern)	zero-width positive look ahead assertion
(?!pattern)	zero-width negative look ahead assertion
(?<=pattern)	zero-width positive look behind expression
(?<!pattern)	zero-width negative look behind expression

predefined variables
use english; is used to allow the long variables names

$_ $ARG	default input and pattern-searching space
$1, $2,...	sub-parts matching in the last perfomed pattern matching
$&	last string matched by the last succesful pattern match
$`	string preceding the string matching the last successful pattern match
$'	string following the string matching the last successful pattern match
$. $NR	line number in the last read file
$/ $RS	input record separator or size of the input records
$, $OFS	output field separator
$\ $ORS	ouput record separator
$"	output separator used for arrays and slices interpolated into a double-quoted string
$|	force a flush after each write
$@	error message from the last eval operator
$! $ERRNO	errno ou text describing the last system call error
$^E	more meaningfull description of the last system call error (this is identical to $! on most OSs)
$?	status of the last exited child process (system, wait, paitpid or for a pipe close)
$SIG	signal, warn and die handlers
$0	name of the script being executed (if assigned, will change the argument in ps on some OSs)
@ARGV	arguments passed to the script
$$ $PID	process id of the process
$< $UID	real user id of the process
$> $EUID	effective user id of the process
$( $GID	real group id of the process
$) $EGID	effective group id of the process
$^X	name of the Perl binary
@_	arguments passed to the subroutine
@INC	path of the scripts files
$]	version + patchlevel/1000 deprecated, use $^V instead
$^V	version with the format chr(revision).chr(version).chr(subversion) can be compared with a literal of the form v5.6.1
$;	subscript separator for multidimensional array emulation
$[	index of the first element in an array do not use
$^W	current value of the warning switch, either TRUE or FALSE

pragmas
 

strict	unauthorize unsafe constructs
warnings	warn about dangerous constructions
diagnostics	display a full explanation of the compilation error messages
vars	predeclare global variable names
utf8	enable UTF8 in code
constant	define a constant use constant PI => 22/7; with Perl 5.8.0, it is allowed to write use constant {                SUNDAY    => 0,                MONDAY    => 1,                TUESDAY   => 2,                WEDNESDAY => 3,                THURSDAY  => 4,                FRIDAY    => 5,                SATURDAY  => 6,              }; in a context that allow barewords, use the syntax FOOBAR() or +FOOBAR since FOOBAR would not work, for example: $hash{CONSTANT()} or $hash{+CONSTANT} instead of $hash{CONSTANT} CONSTANT() => 'value' instead of CONSTANT => 'value'

 

arrays/lists

• $#array is the index of the last element of @array
  
• push
push the values of a list on an array (equivalent to $array[++$#array] = $value; i.e. push will create $array[1] if the array is empty)
push @array, $value;
 
• pop
return and remove the last value in an array
 
• unshift
prepend the value of a list at the beginning of the array
 
• shift
return and remove the first value of an array
 
• quick and dirty print
$, = ",";
print @list;
 
• revert
in list context,return a list which in in reversed order of the input string
in scalar context, concatenate the elements of the input list and return the resulting string in reversed character order
 
• map
return a list which is the evaluation of an expression or block on each element of an input list
 
• sort
return a list which is the sorted elements of an input list according to a given block or subroutine
 
• grep
return the list of the members of a list for which an expression or a block is true


• join
  join the separate strings of a list into a single string with fields separated by a given value
  
  
• intersection and union of two lists
  @a = (1, 3, 5, 6, 7, 8);
  @b = (2, 3, 5, 7, 9);
  @union = @isect = ();
  %union = %isect = ();
  foreach $e (@a) { $union{$e} = 1 }
  foreach $e (@b) {
      if ( $union{$e} ) { $isect{$e} = 1 }
      $union{$e} = 1;
  }
  @union = keys %union;
  @isect = keys %isect;
  
  
• extract the elements of lista which are not in listb
foreach my $s ( @lista ) {
  if ( ! ( grep $s eq $_, @listb ) ) {
    print $s;
  }
}

• using split, map and join to loop on the letters of a string
  sub escape_char {
     my $txt = shift;
     return $txt if ( $txt =~ /[A-Za-z0-9_]/ );
     return ( sprintf "%%%02x", ord $txt );
  }
  
  sub escape_string {
     my $txt = shift;
     return ( join '', map { escape_char $_ } split(//,$txt) );
  }
  

hashes

• keys
return the key list
in a scalar environment, return the number of keys

• values
return the value list
 
• each
loop on a hash table elements
while ( my ($key,$value) = each %h )
{
    print "$key=$value\n";
}
 

each iterator (there is a single one for each each of a given hash) is not reset autmatically
this can be a source of bug if used inside a loop
use keys or values to reset it
my %changedFields = (
                     "case A" , qr/^\(0x0001\)/,
                     "case B" , qr/^\(0x0002\)/,
                     "case C" , qr/^\(0x0003\)/,
                     "case D" , qr/^\(0x0004\)/,
                    );
sub checkOtherFields {
  open(IFILE,$initialFileDump) or die("cannot open file $initialFileDump ($!)");
  open(AFILE,$anonFileDump) or die("cannot open file $anonFileDump ($!)");
  my $iline = <IFILE>;
  my $aline = <AFILE>;
  THELOOP: while ( $aline && $iline ) {
      while ( my ($key,$value) = each %changedFields ) {
          if ( $iline =~ $value and $aline =~ $value ) {
              $iline = <IFILE>;
              $aline = <AFILE>;
              keys(%changedFields);
              next THELOOP;
           }
      }
}
 

• merge several hashes
foreach $h ( \%hash1, \%hash2 ) {
  while (($k, $v) = each %$h) {
    if (exists $hashm{$k}) {
      print "Warning: $k seen twice.  Using the first definition.\n";
      next;
    }
    $hashm{$k} = $v;
  }
}
 
• sort a hash keys according to the values
foreach my $k ( sort { $value{$a} <=> $value{$b} } keys %value ) {
   ...
}

array of hashes

• to push a hash on the array
$myhash{'mykey'} = 'myvalue';
push @myarray { %myhash };
 
• to retrieve the data
my $incr = 0;
while ( $incr <= $#myarray ) {
    print $myarray[$incr]{'mykey'});
}

references

ref returns the type if its argument is a reference (SCALAR, ARRAY, HASH, CODE, REF, GLOB, LVALUE or package name if the reference has been blessed

return false if the argument is not a reference
 

bless declares a reference as being referencing an object of a given class

 

pass a hash reference to a subroutine:

  sub bar
  {
      my($h) = @_;
      $k = keys(%$h);
      ...
      print $$h{mykey};
      ...
  }
  ...
  bar(\%myhash);

objects

• declare the superclass:
our @ISA;
@ISA = ("FooBar");
 
• call a method of the superclass:
sub parse {
    my $self = shift;
    my $inputFile = shift;
    my $inputLine = shift;
    return self->SUPER::parse($self,$inputFile,$inputLine);
}

date

localtime

return the local time
in a scalar context, return the ctime string
$now = localtime();
print(FILEHDL "------------------------\n".
              $now.
              "\n------------------------\n");
in a list context, return the integer values
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);

• compute the number of days between two dates:
  use Time::Local;
  $date1 = timegm(0, 0, 0, $day1, $month1-1, $year1);
  $date2 = timegm(0, 0, 0, $day2, $month2-1, $year2);
  return ($date2-$date1)/(24*60*60);

file handling

• <...> return an undefined value if there is no more line to be read
 
• loop on the file content
open(FILE,"verb.txt") or die("cannot open file ($!)");
while ( my $line = <FILE> )
{
...
}
close(FILE);
 
• open(DATE,"bugval -i $s Resolved_on |") or die("failed to get resolution date of $s ($!)");
  ( $resol_date{$s} = <DATE> ) or die("failed to get resolution date of $s");
  close(DATE);
  will generate a message
  Value of <HANDLE> construct can be "0"; test with defined() at extract_metrics.pl line 231.
  use instead:
  open(DATE,"bugval -i $s Resolved_on |") or die("failed to get resolution date of $s ($!)");
  defined( $resol_date{$s} = <DATE> ) or die("failed to get resolution date of $s");
  close(DATE);
  
  
• open a file in write mode
open(NFILE,'>'.$nfile) or die("cannot open file $nfile ($!)");
 
• open a file in append mode
$collect = 'C:\WINDOWS\BUREAU\collect.txt';
open(COLLECT,'>>',$collect) or die("cannot open $collect ($!)");
...
close(COLLECT);
 
• open a file in rw-rw-r-- mode
use POSIX;
my $mask = umask();
umask(0002);
sysopen(LOG, $logfile, O_WRONLY|O_CREAT|O_APPEND) or die("cannot open logfile $logfile");
umask $mask;
 
• open a UTF8 file
  open(INFILE,"<:utf8",$input)
  
  
• to avoid that Perl replaces \n by \r\n on DOS when using print
open(FILE,">",$file) or die("Cannot open $file ($!)");
binmode FILE;
 
• load the whole content of file in a variable
undef $/;
$input = <INFILE>;
 
• test if a directory exists
( -d $dir ) or die("directory $dir does not exist");
• test if a file is executable
die("missing executable $dcmgen -- ") unless -x $dcmgen;


• file tests

-r	is readable by effective uid/gid.
-w	is writable by effective uid/gid.
-x	is executable by effective uid/gid
-u	has setuid bit set
-g	has setgid bit set
-k	has sticky bit set
-o	is owned by effective uid
-e	exists
-z	has zero size
-s	has nonzero size (returns size)
-f	is a plain file
-d	is a directory
-l	is a symbolic link

• create a directory
mkdir($outdir) or die("failed to create directory $outdir: $!");

• delete a directory
rmdir($outdir) or die("failed to delete directory $outdir: $!");

• list the content of a directory
$dir = 'C:\Mes documents\a ecrire';
opendir(DIR,$dir) or die ("cannot open directory $dir ($!)");
while ( $d = readdir(DIR) ) {
    print $d,"\n";
}
closedir(DIR) or die("cannot close directory $dir ($!)");
 
• recursively walk through the directories
sub scan_dir {
   my $file = shift;
   if ( -d $file ) {
       opendir(DIR,$file);
       my @list = readdir(DIR);
       closedir(DIR);
       foreach( @list ) {
           scan_dir("$file/$_") if ( $_ ne "." && $_ ne ".." );
       }
   }
   elsif ( -f $file ) {
       print "$file\n";
   }
}
scan_dir($file);
 
• select set the default output filehandle and return the old one
 
• use quote strings to facilitate multiline and quote handling
print $outputFile qq[function _display_$name() {
    return _openwin("_foobar_$name","$title","$text");
    }\n];
 
• rename a file
rename $oldfilename, $newfilename;
 
• destroy a file (more precisely a link to a file)
unlink $file or die("failed to remove file $file ($!) --")
 
• change the access right of a file
chmod 0700,$file or die("cannot chmod file $file ($!) --");


• get the file descriptor of a filehandle (return undefined if the filehandle is not open)
  fileno FILEHANDLE
  
  
• get the modification date of a file
  use File::stat;
  $d = stat($file)->mtime;
  

interaction with the shell

get an environment variable

$ENV{"FOOBAR"}
 

modify the path so commands can be called directly

$ENV{"PATH"} .= ":/ddts/bin";
 

glob

syntax to use if we are sure that there is a single file (we must use a list, otherwise the next call to glob would return undefined)
my ($anonFile) = glob("$tempdir/*");
 

fork and exec a command

my $command = $ENV{"SDC_BIN"}."/browser";
my $p = fork();
if (!defined($p)) {
    log_mess("Can't fork: $!");
} elsif ( $p == 0 ) {
    exec $command;
}
 

handle signals

sub catch_signal {
  my $sig = shift;
  log_mess("signal $sig catched");
  my $p = get_browser_pid();
  kill "USR1",$p;
}
$SIG{"INT"} =  \&catch_signal;
$SIG{"QUIT"} =  \&catch_signal;
 

get the pid of a process on Solaris

sub get_browser_pid {
  open(PS,"ps -e -o pid,comm |");
  while ( <PS> ) {
    chomp;
    my ( $pid, $process ) = split;
    if ( $process eq "myprocess" ) {
        close(PS);
        return $pid;
    }
  }
  close(PS);
  return 0;
}
 

get the output of a shell command

open(BUGVAL,"/ddts/bin/bugval -i $spr Headline |") or die("failed to get headline of $spr ($!)");
my $headline = <BUGVAL> or die("failed to get headline of $spr");
print HTML to_html($headline);
close(BUGVAL);
 

execute a command and wait for its status

@cmds = ("netscape", "-remote", "file:".$htmlfile);
system(@cmds) == 0 or die("failed to communicate with Netscape ($!) --");
or
system("netscape -remote file:$htmlfile") == 0 or die("failed to communicate with Netscape ($!) --");
 

execute a grep

system("/usr/xpg4/bin/grep","-w","-q",$str,glob("*.c")) and print "$str is not used\n";

predefined functions

print

print a message on stdout
print "message\n";
print a message on stderr
print STDERR "message\n";

printf

print a formatted string

sprintf

return a formatted string
$s = sprintf "%04d%02d%02d", $year, $month, $day;
 

chop

remove the last character of a string and return it
chop($line);
 

chomp

removes the end of a string if it is $/
chomp($line);
 

crypt

password encryption
$crpwd = crypt($pwd,$salt);
 

do

execute a script file (in order to load its routines)
 

require

require Foo::Bar;
load a module (i.e. execute the script Foo/Bar.pm, we can also write require Foo/Bar.pm)
 

use

use Foo::Bar;
load a module and call its import routine (this works only with a bareword)

Internet

• retrieve a HTML page on Internet
my $proxy = "http://3.231.200.25:88";
# Create a user agent object
use LWP::UserAgent;
my $ua = new LWP::UserAgent;
$ua->agent("AgentName/0.1 " . $ua->agent);
$ua->proxy('http', $proxy);
# Create a request
my $req = new HTTP::Request GET => "http://www.foobar.com/";
# Pass request to the user agent and get a response back
my $res = $ua->request($req);
# Check the outcome of the response
if (!$res->is_success) {
  die $req->as_string()," failure: ",$res->message(),"\n";
}
# Dump the data
print $res->content();

• test if a user is defined
• local
( getpwnam($user) ) or die("$user is an unknown user");
• NIS
open(USER,"ypcat passwd |") or die("cannot open NIS passwd");
my $found = 0;
my $u;
while ( $u = <USER> ) {
    $found = 1 if ( $u =~ /^$user:/ );
}
( $found == 1 ) or die("$user is an unknown user");
close(USER);

one-liners

• managing the quotes with the shell
#> perl -e 'print "select * from foo where bar ='\''a3'\''\n"';
#> perl -e 'print "select * from foo where bar =".chr(39)."a3".chr(39)."\n"';
#> perl -e 'print qq#select * from foo where bar ="a3"\n#';
 
• summing the number of occurences
#> ./foobar | perl -e 'while (<>) { chomp; $a{$_}++;}; while ( ($w,$i)=each %a ) { print "$w\t$i\n"; }'

• uppercase the input
  #> echo foobar | perl -p -e 's/(.*)/\U\1\E/'
  
  
• replace the $variables by the value of the corresponding environment variables in a file
  #> perl -p -e 's/\$([A-Za-z_][A-Za-z0-9_]*)/$ENV{$1}/ge' <$infile >$outfile
  
  
• quickly check for a buffer overflow in foobar
  #> foobar `perl -e '{ print "A" x "9999" }'`
  

command line flags

• -w enable warnings
  -W enable warnings regardless of no warnings or $^W
  -X disable warnings regardless of use warnings or $^W
  
  
• -c check the syntax of the progam but does not run it (except the BEGIN blocks, CHECK blocks and use statements)
 
• -e commandline execute the command line
several -e options can be given to execute a multiline command


• The -n switch wraps a while loop around your program.
while (<>) {
<-e argument>
<-e argument>
}

The -p switch does the same thing and prints the value of $_ at the end of each iteration.
while (<>) {
<-e argument>
<-e argument>
print;
}

-i edit the files in place
 
• -Idir prepends the directory dir to @INC
 
• -mmodule execute a use module (); before the program
-Mmodule execute a use module; before the program
'-Mmodule qw(foo bar)' execute a use module qw(foo bar); before the program


• -a
  turns on autosplit mode when used with a -n or -p. An implicit split command to the @F array is done as the first thing inside the implicit while loop produced by the -n or -p.
  perl -ane 'print pop(@F), "\n";'
  is equivalent to
      while (<>) {
          @F = split(' ');
          print pop(@F), "\n";
      }
  
  
• -Fpattern
  specifies the pattern to split on if -a is also in effect. The pattern may be surrounded by //, "", or '', otherwise it will be put in single quotes.
  
  
• -h
  prints a summary of the options.
  


Unix scripting

• first line
  #!/usr/bin/perl -w
  
  
Windows scripting
• create a batch file which will support the drag 'n drop:

@rem = '--*-Perl-*-- @echo off D:\perl\bin\perl "C:\Mes documents\a ecrire\mailer.pl" %1

then, use $ARGV[0] in the script to get the name of the file, e.g.:


use strict; use warnings; die("syntax: $0 <xml_file>") if ( $#ARGV != 0 ); my ( $infile, $outfile ); $infile = $ARGV[0]; ( $outfile = $infile ) =~ s/\.htm$/.xml/; open(INFILE,'<',$infile) or die("cannot input open file ($infile): $!"); open(OUTFILE,'>',$outfile) or die("cannot output open file ($outfile): $!"); undef $/; my $content = <INFILE>; $content =~ s{^.*<html>.*<title>(.*)</title>.*<body>(.*)</body>.*</html>$}              {<PAGE><TITLE>$1</TITLE><CONTENT>$2</CONTENT></PAGE>}is; print OUTFILE $content; close(INFILE) or die("cannot input close file ($infile): $!"); close(OUTFILE) or die("cannot output close file ($outfile): $!"); my @cmds = ("C:/Program Files/Microsoft Office/Office10/WINWORD.EXE", $outfile); system(@cmds) == 0 or die("failed to start Word: $!");

Last update: March 7^th, 2006 - Laurent