https://solvnet.synopsys.com/dow_retrieve/latest/dg/ptolh/Default.htm#rules/GeneralDesignRules.htm%3FTocPath%3DPrimeTime%2520Constraint%2520Consistency%2520Rules%7C_____1
Sunday, February 24, 2019
Tuesday, July 3, 2018
perl cook book
perl
cookbook:
1. Removing
leading & trailing white spaces from string:
$string =
trim($string);
@many = trim
(@many);
sub trim {
my @out = @_;
foreach (@out) {
s/^\s+//;
s/\s+$//;
}
return ((@out==1) ? $out[0] : @out);
}
sub trim {
my @out = @_;
my $cond;
foreach (@out) {
s/^\s+//;
s/\s+$//;
}
$cond = scalar (@out);
if ($cond == 1) {
return $out[0];
} else if ($cond >1) {
return @out;
} else {
print "ERROR:
Nothing is parsed to the subroutine\n";
}
}
================================================================
2. Checking
PVT has the PffV1300Tm40, PttV1200T025, PssV1100T125
chomp $_;
warn "
Please enter valid PVT corner" unless /^P(\w+)V(\d+)Tm?(\d+)$/;
================================================================
3. Finding
today's date:
use
Time::localtime;
$tm
=localtime;
($DAY,
$MONTH, $YEAR) = ($tm->mday, $tm->mon, $tm->year);
================================================================
4. Day in a
Week/Month/Year OR Week Number:
page 99
================================================================
5. Sleep
function: (sleep less than a second)
use
Time::HiRes;
while
(<>) {
sleep(0.25);
}
================================================================
6. Printing
all Environment variables used by perl:
#!/usr/bin/perl
-w
foreach my $var (sort keys %ENV) {
print "$var =
$ENV{$var}\n";
}
================================================================
7. Default
variable = $_ and Default array = @_;
while
() {
chomp;
foreach (split) { ## $_ is split on whitespace,
stores into @_
$_ = reverse;
print;
}
}
================================================================
8. Iterating
over an Array by reference:
@fruits =
("apple" , "orange");
$ref =
\@fruits; # Taking the reference to an
array
foreach $fruit
(@$ref) { ## $ref is the reference; @$ref is an array by reference
print " $fruit
\n";
}
for ($i =0;
$i < $#@$ref; $i++) {
print " $ref->[$i] \n";
}
================================================================
9.
Extracting Unique elements from a list:
a)
Straightforward:
%seen = ( );
@uniq = ( );
foreach (@uniq) {
unless ($seen{$_}) {
$seen{$_} = 1; ## If we get here, we have not
seen it before
push (@uniq, $_); ## push that element to array
}
}
b) Faster:
%seen = ( );
foreach $item (@list) {
push (@uniq, $item )
unless $seen{$item}++; ## It creates a
new entry in the hash everytime it sees an element that hasn't seen before
}
c) Faster
but different:
%seen = ( );
foreach $item (@list) {
$seen{$item} ++;
}
@uniq = keys %seen;
d) Faster:
%seen = ( );
@uniq = grep (! $seen{$_}++ } @list;
## merges the construction of hash & extraction of unique elements
==> same as 1st approach
================================================================
10. Find the
elements in @A that aren't in @B:
i.e., unique elements in A compared
to B array
Solution:
1. Mark all B array elements by
creating %seen hash
2. If that element is not seen in A
array, move to @Aonly
a)
Straightforward Implementation:
%seen = ( );
@Aonly = ( );
foreach $item (@B) {
%seen{$item} = 1;
}
foreach $item (@A) {
unless ( $seen{$item} )
{
push
(@Aonly, $item);
}
}
b) Merging
the code:
%seen = ( );
@Aonly = ( );
@seen{@B} = ( ); ## Marking the B array elements =
undef. Below we are checking only the existance of the key not the logical
truth or definedness of the value
foreach $item (@A) {
push ( @Aonly, $item)
unless ( exists $seen{$item} ); ##
Move to Aonly array if the element is not matching with B array
}
c) Loopless
version:
1. Mark all A array elements by
creating %seen hash
2. Delete the B array element if any
from that hash
3. print the keys of the hash ==>
Aonly array elements.
%seen = ( );
@seen {@A} = ( );
delete @seen {@B};
@Aonly = keys %seen;
================================================================
11.
Computing Intersection, Union, Difference of Unique lists A & B:
Algo:
1. Mark all elements of array A by
creating %seen hash.
2. Traverse all the elements of
array B.
- Mark the elements if
already seen in list A and mark them by create isect hash.
- Continue marking if
not seen in seen in list A.
- union = keys of %seen
- isect = keys of %isect
a)
Straightforward solution:
@A = (1,3,5,7.8) ;
@B = (2,3,5,7,9);
@union = @isect = @diff = ( );
%union = %isect = ( );
foreach $item (@A) {
%seen{$item} = 1;
}
foreach $item (@B) {
if ( $seen{$item} ) {
%isect{$item}
= 1;
}
%seen{$item} = 1;
}
@union = keys %union;
@isect = keys %isect;
b) More
idiomatic version:
1. The First time through it won't
be in the union, which makes the first part of the && false,
so the second part is consequently ignored.
2. The second time that we encounter
the same element, it's is already in the union, so we put in
in the intersection.
foreach $e (@A,
@B) {
$union {$e}++ &&
$isect{$e}++
}
@union = keys %union;
@isect = keys %isect;
c) Another
approach:
1. Mark all elements by creating
hash. Increment by 1 if occurs more than once.
2. If it occurs more than once =>
put in the insection array otherwise put in the difference array.
3. keys of above hash = > unique
elements in two arrays => union array.
%count = ( );
@union = @diff = @isect = ( );
foreach $e ($a,
$b) {
$count{$e}++;
}
@union = keys %count;
foreach $e (keys %count) {
if ( $count{$e} > 1 )
{
push
(@isect, $e );
} else {
push (@diff,
$e);
}
}
d) Using
conditional operator (?:)
foreach $e (keys %count) {
push @{ ($count{$e} >1) ? \@isect : \@diff },
$e; ## array by reference
}
================================================================
12. Using
Splice function in the array:
Splicing
Arrays:
Useful when you want to copy and
remove elements from the middle.
This process
is called splicing and is handled by the splice function.
splice
ARRAY, OFFSET, LENGTH, LIST
splice
ARRAY, OFFSET, LENGTH
splice
ARRAY, OFFSET
Return
value:
The return value in every case is
the list of elements extracted/removed from the array in
the order
that they appeared in the original.
Arguments:
1. The first argument, ARRAY,
is the array that you want to remove elements from.
2. The second argument is the index
number of ARRAY that you want to
start extracting elements from.
--> At which index,
you want to do this remove the element.
3. The LENGTH, if specified, removes
that number of elements from the array. If you don’t specify LENGTH,
it
removes all elements to the end of the array. If LENGTH is
negative, it leaves that number of elements on the end of the array.
---> How many
elements you want to remove here.
4. Finally, you can replace the
elements removed with a different list of elements, using the values of LIST.
Note that this will
replace any number of elements with the new LIST, irrespective of the
number of elements removed or replaced. The array will
shrink or grow as necessary.
---> Do you want to
replace the removed elements by list? If yes, specify the LIST.
Example:
For example,
in the following code, the middle of the list of users is replaced with a new
set, putting the removed users into a new list:
@users =
qw/Bob Martin Phil Dave Alan Tracy/;
@newusers =
qw/Helen Dan/;
@oldusers =
splice @users, 1, 4, @newusers;
This sets @users
to
Bob Helen Dan Tracy
and @oldusers
to
Martin Phil Dave Alan
a) Removing
$N elements from the front of @ARRAY:
@FRONT = splice
(@ARRAY, 0, $N);
--> This is
equivalent to write shift(@ARRAY) $N times and assigning the shifted values to
@FRONT array.
b) Removing
$N elements from the end of @ARRAY:
@END = splice (@ARRAY,
0, -$N);
---> This is
equivalent to writing pop(@ARRAY) $N times and assigning the poped values to
@END array.
c) Direct
Method Splice
Equivalent
push (@A, $x, $y) splice(@A,
@A, 0, $x, $y); ## second
argument => index = at the end of the array
pop (@A) splice
(@A, -1) OR splice (@A, ($#@A - 1), 1)
shift (@A) splice
(@A, 0, 1)
unshift(@A, $x, $y) splice (@A, 0,0,$x,$y);
$A[$x] = $y splice
(@A, $x, 1, $y);
@A = ( ) splice
(@A)
$ref = \@A;
@removed =
shift2 ( @{$ref} );
sub shift2
(\@) { sub
shift2 (\@) {
$a = shift (@{$_[0]}); return
splice ( @{$_[0]}, 0, 2 );
$b = shift (@{$_[0]}); }
return ($a,$b);
}
================================================================
13. Finding
the First List Element that passes a Test:
a)
Straightforward Approach:
foreach $item
(@list) {
if ($item =~
/CRITERION/) {
$match =
$item;
$found = 1;
last;
}
}
b) Using
built in functions:
use List::Util qw (first);
$match = first {CRITERION } @list;
================================================================
14. Finding
all the elements in an array matching certain criteria:
a)
Starightforward Approach:
@matching = ( );
foreach (@list) {
push ( @matched,
$_) if
TEST ($_) ;
b)
@matching = grep { TEST ($_) } @list;
Example 1: Find the
elements of Array ARRAY whose value is greater than 1000.
@matching = grep { $_ > 1000 }
@ARRAY;
Example 2:
@SDF_array = grep {
/sdf_cond/ } @LIB;
================================================================
15. Using
"map" function in the arrays:
The map function performs an
expression or block expression on each element within a
list. This
enables you to bulk modify a list without the need to explicitly use a loop.
Syntax:
map EXPR, LIST
map BLOCK LIST
Return
value:
The individual elements of the list
are supplied to a locally scoped $_, and the
modified
array is returned as a list to the caller.
Example:
1. Convertt
all the elements of an array to lowercase:
@lcarray = map { lc } @array;
It is
equivalent to the following:
foreach (@array)
{
push
@lcarray,lc($_);
}
Note that
because $_ is used to hold each element of the array, it can also modify
an array in
place, so you don’t have to manually assign the modified array to a new
one.
However,
this isn’t supported, so the actual results are not guaranteed. This is
especially
true if you are modifying a list directly rather than a named array, such as:
@new = map
{lc} keys %hash;
================================================================
15.
Randomizing an array:
use List::Util
qw(shuffle);
@array = shuffle (@array );
================================================================
LOOP CONTROL
STATEMENTS:
================================================================
last => break
next => continue
exit => exit
================================================================
HASHES:
================================================================
1. Adding an
element to HASH.
%HASH = ( );
$HASH {$KEY} = $VALUE;
================================================================
2. Testing
for the presence of a key in Hash:
if (exists $HASH
{$KEY}) {
### it exists
}
else {
## it doesn't
}
================================================================
3. Deleting
an element from HASH:
delete ($HASH {$KEY} );
================================================================
4. Creating a Hash with Immutable keys or
values:
Hash keys or values can't be altered
once set.
================================================================
5. Traversing a Hash:
a) Using
while loop:
while ( ($key, $value) = each
(%HASH) ) {
## print " $key
=> $value \n";
}
b) Using
foreach loop:
foreach $key (keys
%HASH) {
$value = $HASH{$key};
}
foreach $value (values
%HASH) {
##
}
c) Using map
function:
print map { $_ =>
$HASH{$_} } (keys %HASH) ;
================================================================
6. Hashes with Multiple values per Key:
- how to store more than one value
per key.
a) Solution:
Store an array
reference in $HASH{$KEY}, then put the values into the referenced array.
The value associated with each key
in the array is "Reference to Array"
"file" is the
output of the who command in UNIX.
---------------------------------------------
%ttys = ( );
open (WHO, "
while() {
($user, $tty) = split;
push ( @{$ttys{$user}} ,
$tty );
}
foreach $user (sort keys %ttys) {
print "$user: @{$ttys{$user}}\n";
}
================================================================
7. Inverting a Hash:
%REVERSE =
reverse %HASH;
================================================================
8. Merging 2 Hashes:
%merged = (%A, %B);
================================================================
9. Finding
common & different keys in 2 hashes:
@common = @different = ( );
foreach ($keys %HASH1) {
push (@common, $_) if
exists $HASH2{$_};
}
foreach ($keys %HASH1) {
push (@common, $_)
unless exists $HASH2{$_};
}
================================================================
10. (5.13
Hashing Referenes??)
================================================================
PATTERN
MATCHING:
================================================================
1. Copying
& Substituting simultaneously:
Example 1:
$dst = $src;
===> equivalent to ($dst = $src) =~ s/this/that/ ;
$dst =~
s/this/that/;
Example 2:
The above technique can be extended to arrays also.
@bindirs = qw( /usr/bin /bin
/usr/local/bin );
for (@libdirs =
@bindirs) { s/bin/lib }
print "@libdirs\n";
Example 3:
($a = $b) =~ s/x/y/g; # copy $b and then change $a;
$a = ($b =~
s/x/y/g) ; # change
$b and then assign to $a;
$a = $b =~
s/x/y/g; # same as 2.
changes will happen for $a, $b at the same time.
2. Checking
whether the word is purely alphabetic or not:
if (/^[^\W\d_]+$/) {
print "$_ :
alphabetic \n";
} else {
print "$_ :
non-alphabet \n";
}
3. Matching
words:
/\b([A-Za-z]+)\b/ ### \b -> boundary of
the word
4. Matching
-ve or +ve floating or integers:
/^\s*[-+]?\d+\.?\d*\s*/ ## matches even -123.34 or -123
or +123 or 123.23
5. Finding
the Nth occurence of a Match:
$string = " one fish two fish
red fish blue fish ";
print " Enter N value:";
print " Enter N value:";
$N = ;
@colors = ($string =~
/^\s*(\w+)\s*fish\b/gi); (OR) $color = ($string =~
/^\s*(\w+)\s*fish\b/gi)[$N-1];
$color = $colors[$N-1];
================================================================
6. Explore
(6.8 Extracting a Range of lines):
================================================================
================================================================
FILES:
================================================================
1. Printing
to Many Filehandles simultaneouly:
foreach $FH (@file_handles) {
print FH $line;
}
(OR)
open (MANY,
" | tee file1 file2 file3 > /dev/null ) or die $!;
print MANY
"$line\n";
close
(MANY):
2. Reading a
File Backward by Line or paragraph:
Solution: Read all the lines into an array, then process
that array from the end of the start.
@lines =
while ($line
= pop @lines) {
# do something here
}
@lines =
reverse
foreach
$line (@lines) {
# do something here
}
3. Removing
last line of the file:
a) Using
built-in functions:
use Tie::File;
tie @lines, Tie::File, $file or die
"can't update $file: $!";
delete $lines[-1];
b) Removing
'N' lines from the end of the file:
@lines =
;
pop(@lines); #### Do this N times OR use splice function here.
foreach $line (@lines) {
print OUT
"$line\n";
}
================================================================
SubRoutines:
================================================================
1. Write a
subroutine to trim the strings.
- Removing leading & trailing
spaces of the string.
2. Understand the INIT block.
- (Perl Cookbook - 10.3 section)
LOW lights:
10.4 section
================================================================
3. Passing
arrays and hashes by Reference:
Need:
You want to pass more
than one array or hash and have each remain distinct.
sub
add_array (@a, @b);
The above statement passes 2 arrays
as one array i.e. @_ = (@a, @b) and these
two can't be
remain distinct.
Solution:
Send the references of 2 arrays as
arguments. Since each reference to an array is an scalar (address),
it can be
treated in the subroutine as follows.
sub add_array (\@a, \@b);
The above statement passes 2 arrays references as one array (i.e., @_ = (reference to array A, reference to array B).
You
dereference these 2 to make it as distince arrays.
KEY MESSAGE:
If you want to play
with more than one array or hash in subroutines, YOU SHOULD USE
REFERENCES
ONLY.
================================================================
4. Write a
subroutine to add 2 arrays of same size passed as arguments:
#!/usr/local/bin
-w
use strict;
our (@A,
@B,@c);
@A = [ 1, 3,
5];
@B = [2, 4,
6];
@c=add_2_arrays
(\@A, \@B);
sub
add_2_arrays {
our ($x, $y) = @_;
my @result;
my $i;
for
($i=0; $i< @$x; $i++) {
$result[$i] =
$x->[$i] + $y->[$i];
}
return (@result);
}
================================================================
4. Detecting
Return Context:
V. IMP: Section 10.6
Solution: Use wantarray() function.
================================================================
5.Passing by
named parameter:
================================================================
6. Returning
more than one hash or array
sub fun {
return (\%A, \%B,
\%C); ==> equivalent to return \(%A, %B, %C);
================================================================
7. Check
programming perl book (chapter 29)
=================================================================
1.
If
you want to replace set of words with other words. Create hash with the
following
key= present word, value = word to be replaced
with.
Advantage: Without changing
the code, you can add/remove other words.
Ex: Would like to change the
Mega, Giga => 1e6, 1e9 etc
2.
Adacond
changes:
1.
Input
files:
a.
Synopsys
.lib file
b.
Adaconds
file
i.
ii. Ex: “adacond_D” “D”
==================================================================
Classes,
Objects:
An object is a variable that belongs to a
class.
Methods are functions associated with a class.
In
perl,
Class ó Package
or module (.pm file)
Object ó reference
to something associated with a class
Once associated with a class, something is said
to be blessed into that class.
Blessing merely associates a referent with a class, this is done
using bless function.
Bless function takes 2 arguments.
1. Reference
to the thing you want to associated with the class. i.e., refence to an object
2. Package with
which to make the association. i.e., package/module name
Example:
$object = { }; ##hash reference to the object
bless($object,
“Data::Encoder”); ## create the object reference for
Data::Encoder class
bless($object); ###
bless generated $object into current
package/module
key
messages:
Generally, objects are implemented as blessed
hash references as they allow arbitrarily named data fields in an object.
Purpose
of blessing (Associating a package with a referent):
Perl
can determine the package namespace in which to find functions when you invoke methods against an object.
Examples:
$encoded =
Data::encoder->encode(“data”);
(OR)
$object = { };
Bless($object, “Data::encoder”);
Bless($object);
$encoded = $object -> encode(“data”);
Here,
$object
is called method’s invocant. (A
invocant as the entity on whose behalf the method is called)
Method
name: encode
Invoking
a method calls the function in the corresponding class, implicitly passing its
invocant as the initial argument to that function.
Constructor
methods:
Most
classes provide constructor methods, which return new objects.
Example:
$object
= Classname->new();
Sub new {
My
$class = shift;
My
$selft = { };
Bless
($self, $class);
Return
($self);
}
The first argument to new function: Name of the class i.e., $class = Classname
==================================================================
13.1 Constructing an Object:
Constructor
is a method that allocates and initializes a new object.
Reference is not an object unless bless has
been called on it.
Inherit = acquire, get, have, receive
- Obtain
from someone after their death.
- I
inherited a castle (palace) from my French grand parents
- Receive
from a predecessor.
- The
new chairman inherited many problems from the previous chair.
- Receive
by genetic transmission
- I
inherited my good eyesight from my mother.
Inheritance
means allowing one class to piggyback on
the top of another so you don’t have to write the same code again and again
Piggyback = ride on someone’s shoulder or back
-
She carried her child
piggyback.
Heed = pay the close attention
-
Heed the advice of the old
man.
How
the constructor is inherited by a derived class:
Have the constructor heed its first argument.
-
For a class method, this is
the package name. Pass the class name as the second argument
to bless.
Example:
###
Calling the constructor
$object
= Classname->new();
###
Typical constructor used as a class method looks like this
sub
new {
my
$classname = shift; ## what class we are constructing??
my
$self = { }; ##Allocate
new memory => defining anonymous hash
bless
($self, $classname); ### reference has become object and marking it
of type $classname
###Initialization of data
fields
$self->{START}
= time();
$self->{AGE}
= 0;
####Returning the constructed
object
Return
$self;
}
==================================================================
Example2:
Separate the memory allocation and blessing step from the instance data
initialization step.
sub
new {
my
$classname = shift;
my
$self = { };
bless($self,
$classname);
$self->_init(@_);
return
$self;
}
sub _init
{
my
$self = shift; ### implicit
argument = object name
$self->{START}
= time();
$self->{AGE}
= 0;
###If
any other data fields are passed as arguments, then
if(@_)
{
my
%extra = @_;
@self{keys
%extra} = values %extra;
}
}
my %dramatis_personae = (
humans => [ 'hamnet', 'shakespeare',
'robyn', ],
faeries => [ 'oberon', 'titania',
'puck', ],
other => [ 'morpheus, lord of dreams' ],
);
Access it like this:
foreach my $group (keys
%dramatis_personae) {
print "The members of $group
are\n";
foreach (@{$dramatis_personae{$group}}) {
print "\t$_\n";
}
}
$value = $expr ? $true : $false;
Size
of an array:
Difference
b/w $#array and scalar @array:
$#array ->
gives the maximum index of the array
Scalar @array
-> size of the array (max index + 1)
The size of an
array can be determined using scalar context on the array—the returned
value will be the
number of elements in the array:
===========================================================================
@array = (1,2,3);
print "Size:
",scalar @array,"\n";
The value returned
will always be the physical size of the array, not the number of
valid elements.
You can demonstrate this, and the difference between scalar
@array
and $#array, using
this fragment:
@array = (1,2,3);
$array[50] = 4;
print "Size:
",scalar @array,"\n";
print "Max Index:
", $#array,"\n";
===========================================================================
This should return
Size: 51
Max Index: 50
Printing
the hash:
foreach $key (%ages)
{
print "$key is
$ages{$key} years old\n";
}
while (($key, $value) =
each %ages)
{
print "$key is
$ages{$key} years old\n";
}
Checking
for existence:
if (exists($ages{$name}))
{
print "$name if
$ages{$name} years old\n";
}
else
{
print "I don't know
the age of $name\n";
}
Size
of the hash:
You get the
size—that is, the number of elements—from a hash by using scalar context on
either keys or values:
print "Hash size: ",scalar keys
%hash,"\n";
Selecting
List Elements from Function Calls
We can even use
list notation on the return value from a function call. For example, the
localtime function
returns a list of time values (hours, minutes, days, and so on), and
we can extract
just the elements we want:
($hours,$minutes) =
(localtime())[2..3];
Note that the
parentheses go around the expression that returns the list, to imply
list context on
the overall expression. The following are all examples of how not to
extract individual
elements from a function that returns a list:
$hours = localtime()[2];
$hours,$minutes =
localtime()[2..3];
($hours,$minutes) = localtime()[2..3];
The defined
Function and the Undefined Value
The undefined
value, undef, is an alternative to the null value used
in C. In essence,
undef means
that the variable has had no value assigned. This is useful if you want to
create an
undefined variable—one that has no value. Compare the undefined value with
an integer with a
value of 0 or an empty string, both of which indicate valid values.
The undefined
value will always evaluate to false if used in an expression, for
example the test
in this fragment:
$value = undef;
if ($value)
{
...
will always fail.
It will also raise an error because you’ve tried to access the contents of
an undefined
value. In these situations, you can use the defined function
to check the
value of a scalar.
The defined function returns true if the scalar
contains a valid value,
or false if the
scalar contains undef:
if (defined($value))
{
...
Just to confuse
you, defined will return false if a variable has never
been named or
created, and also
false if the variable does exist but has the undef value.
Note that the same
rules apply to the scalar components of arrays or hashes: they
can contain the
undefined value, even though the index or key is valid. This can cause
problems if you
only use defined on a hash element. For example:
$hash{one} = undef;
print "Defined!\n"
if (defined($hash{one}));
print
"Exists!\n" if (defined($hash{one}));
This will only print “Exists!,” since the
element’s value remains
undefined.
Special
variables:
Perl keeps an
internal list of special variables that supply information and data about
the current
scripts environment. The subsections that follow include standard variables
built into the
interpreter, variables that have special meanings to core modules (such as
pragmas and Exporter), and
also the special filehandles used for communicating with
the outside world.
Note that Perl
uses a combination of special characters and names to refer to the
individual
variables. To use the long (named) variables, you must include the English
module by placing
use
English;
at the top of your
program. By including this module, you arrange that the longer
names will be
aliased to the shortened versions. Although there is no standard for
using either
format, because the shortened versions are the default, you will see them
used more widely.
See Web Appendix A for a listing of the variables and their English
module
equivalents. The named examples are given here for reference.
Some of the
variables also have equivalent methods that are supported by the IO::*
range of modules.
The format of these method calls is method HANDLE EXPR (you
can also use HANDLE->method(EXPR)),
where HANDLE is the filehandle you want
the change to
apply to, and EXPR is the value to be supplied to the method.
_
(underscore) The underscore represents the special filehandle used to cache
information from the last successful stat,
lstat, or file test operator.
$0
$PROGRAM_NAME
The
name of the file containing the script currently being
executed.
$1..$xx
The
numbered variables $1, $2, and
so on are the variables used to hold the
contents of group matches both inside and
outside of regular expressions.
$_
$ARG The $_
and $ARG variables represent the default input and pattern searching
spaces. For many
functions and operations, if no specific variable is specified, the
default input
space will be used. For example,
$_ = "Hello
World\n";
print;
would print the
“Hello World” message. The same variable is also used in regular
expression substitution and pattern
matches.
Perl will automatically
use the default space in the following situations even if you
do not specify it:
_ Unary
functions, such as ord and int.
_ All
file tests except -t, which defaults
to STDIN.
_ Most of
the functions that support lists as arguments (see Appendix A).
_ The
pattern matching operations, m//, s///, and tr///, when
used without an
=~ operator.
_ The
default iterator variable in a for or foreach loop,
if no other variable
is supplied.
_ The
implicit operator in map and grep functions.
_ The default place
to store an input record when reading from a filehandle.
$&
$MATCH The
string matched by the last successful pattern match.
$`
$PREMATCH The
string preceding the information matched by the last pattern match.
$’
$POSTMATCH The
string following the information matched by the last pattern match.
$+
$LAST_PARENT_MATCH The last bracket match by the last regular expression
search pattern.
$* Set to
1 to do multiline pattern matching within a string. The default value is 0. The
use of
this variable has been superseded by the /s and /m modifiers to regular expressions.
$.
$NR
$INPUT_LINE_NUMBER The current input line number of the last file from which
you read. This can be either the keyboard or an external file
or other filehandle (such as
a network socket). Note that it’s based not on what the real
lines are, but more what the
number
of the last record
was
according to the setting of the $/ variable.
$/
$RS
$INPUT_RECORD_SEPARATOR The current input record separator. This is
newline by default, but it can be set to any string to enable
you to read in delimited
text files that use one or more special characters to separate
the records. You can also
undefine the variable, which will allow you to read in an
entire file, although this is
best done using local
within a block:
{
local
$/;
$file
= ;
}
@ISA The
array that contains a list of other packages to look through when a method
call on an object cannot be found within the current package.
The @ISA array is used
as the
list of base classes for the current package.
$|
$AUTOFLUSH
$OUTPUT_AUTOFLUSH
autoflush HANDLE EXPR By default all output is buffered (providing the OS
supports it). This means all information to be written is
stored temporarily in memory
and periodically flushed, and the value of $| is set to zero. If it is set to non-zero, the
filehandle (current, or specified) will be automatically
flushed after each write operation.
It has
no effect on input buffering.
$,
$OFS
$OUTPUT_FIELD_SEPARATOR The default output separator for the print series of
functions. By default, print outputs the comma-separated fields
you specify without
any delimiter. You can set this variable to commas, tabs, or
any other value to insert a
different delimiter.
$\
$ORS
$OUTPUT_RECORD_SEPARATOR The default output record separator. Ordinarily,
print outputs
individual records without a standard separator, and no trailing newline
or other record separator is output. If you set this value,
then the string will be appended
to the end of every print statement.
%OVERLOAD
Set by the overload pragma to implement operator overloading.
$!
$ERRNO
$OS_ERROR Returns
the error number or error string of the last system call
operation. This is equivalent to the errno value and can be used to print the error
number
or error string when a particular system or function call has failed.
$[ The
index of the first element in an array or of the first character in a
substring.
The default is zero, but this can be set to any value. In
general, this is useful only when
emulating
awk, since functions and other constructs can
emulate the same functionality.
$]
$OLD_PERL_VERSION The old version + patchlevel/1000 of the Perl interpreter.
This can be used to determine the version number of Perl being
used, and therefore
what functions and capabilities the current interpreter
supports. The $^V variable
holds a
UTF-8 representation of the current Perl version.
$a The
variable used by the sort function to hold the first of each pair of
values being
compared. The variable is actually a reference to the real
variable so that you can modify
it, but
you shouldn’t—see Chapter 8 for information on usage.
@_
@ARG Within
a subroutine (or function), the @_
array contains the list of parameters
supplied
to the function.
ARGV The
special filehandle that iterates over command line filenames in @ARGV.
Most
frequently called using the null filehandle in the angle operator <>.
$ARGV The
name of the current file when reading from the default filehandle <>.
@ARGV The @ARGV array contains the list of the command line arguments
supplied to the script. Note that the first value, at index
zero, is the first argument,
not the name of the script.
ARGVOUT The
special filehandle used to send output to a new file when processing
the ARGV filehandle under the -i switch.
$b The
variable supplied as the second value to compare when using sort, along
with
the $a variable.
$?
$CHILD_ERROR The
status returned by the last external command (via backticks
or system) or the last pipe close. This is the
value returned by wait, so the true return
value is $?
>> 8, and $? & 127 is the
number of the signal received by the process, if
appropriate.
%ENV The
list of variables as supplied by the current environment. The key is the
name of the environment variable, and the corresponding value
is the variable’s value.
Setting
a value in the hash changes the environment variable for child processes.
@EXPORT The
list of functions and variables to be exported as normal from a
module
when using the standard Exporter
module.
@INC The
list of directories that Perl should examine when importing modules via
the do, require, or use construct.
%INC Contains
a list of the files that have been included via do, require, or use. The
key is
the file you specified, and the value is the actual location of the imported
file.
$^P
$PERLDB
The internal
variable used for enabling the Perl debugger.
goto
BASIC programmers will be immediately happy when they realize
that Perl has a goto
statement. For purists, goto is a
bad idea, and in many cases it is actually a dangerous
option when subroutines and functions are available. There are
three basic forms: goto
LABEL, goto EXPR, and goto
&NAME.
In each case, execution is moved from the current location to
the destination. In the
case of goto
LABEL, execution stops at the current point and
resumes at the point of
the label specified. It cannot be used to jump to a point
inside a block that needs
initialization, such as a subroutine or loop. However, it can
be used to jump to any
other point within the current or parent block, including
jumping out of subroutines.
As has already been stated, the use of goto should be avoided, as there are generally
much better ways to achieve what you want. It is always possible
to use a control flow
statement (next, redo,
etc.), function, or subroutine to achieve the same result without
any of the dangers.
The second form is essentially just an extended form of goto LABEL. Perl expects
the expression to evaluate dynamically at execution time to a
label by name. This
allows for computed gotos
similar to those available in FORTRAN, but like goto
LABEL, its
use is deprecated.
The goto
&NAME statement is more complex. It allows you
to replace the
currently executing subroutine with a call to the specified
subroutine instead.
This allows you to automatically call a different subroutine
based on the current
environment and is used by the autoload mechanism (see the Autoload module in
Appendix B) to dynamically select alternative routines. The
statement works such
that even the caller will be unable to tell whether the
requested subroutine or the
one
specified by goto
was
executed first.
Subroutines:
sub add
{
my $result;
while(@_)
{
$result += shift;
}
print "Result:
$result\n";
}
Now we can call
the function with any number of arguments,
add(1);
add(1,2);
add(1,2,3,4,5,6,7,8,9,10,11);
Or a list:
add(@values);
Dispalying hash:
sub
display_hash
{
my
(%hash) = @_;
foreach
(%hash)
{
print
"$_ => $hash{$_}\n";
}
}
Returning value:
sub
myfunc
{
if
(@_)
{
return
$_[0]+$_[1];
}
else
{
return
0;
}
}
When called, return immediately terminates the current
subroutine and returns the
value
to the caller—if you don’t specify a value then the return value is undef.
Special
Blocks:
Perl has reserved
a number of specially named blocks that provide some additional
control over the
execution of your script—although these are more complex topics,
we’ll cover them
here, as their execution will help you to understand how modules
and importing and
exporting objects works.
The four blocks
are BEGIN, CHECK, INIT, and END, and
they are executed in
that order. When
you execute a Perl script, any BEGIN blocks are
executed during
the parsing
process—that is, as soon as the statements within a BEGIN block
have
been parsed and
verified. The CHECK block is executed as soon as the parsing
and
compilation stages
have been completed, but before the actual execution of the script.
The INIT block
runs before the main flow of the program starts. The END blocks
execute
when the program
terminates.
If you specify
more than one of these blocks in your script, they are executed in the
order in which
they are parsed in the case of BEGIN and CHECK, and
in reverse order
in the case of INIT and END, and
still in the overall order given above. You can see
this better using
a simple script:
print "Now in the
main script\n";
die "Script
abnormally terminated!\n";
CHECK { print "1st
declared CHECK block\n" }
CHECK { print "2nd
declared CHECK block\n" }
END { print "1st
declared END block\n" }
BEGIN { print "1st
declared BEGIN block\n" }
INIT { print "1st
declared INIT block\n" }
BEGIN { print "2nd
declared BEGIN block\n" }
END { print "2nd
declared END block\n" }
INIT { print "2nd
declared INIT block\n" }
When executed, the
script generates the following:
1st declared BEGIN block
2nd declared BEGIN block
2nd declared CHECK block
1st declared CHECK block
1st declared INIT block
2nd declared INIT block
Now in the main script
Script abnormally
terminated!
2nd declared END block
1st declared END block
Note that the
execution also applies to individual packages and modules. Here, the
BEGIN and END blocks
can act as initializers and finalizers for the package. They are
defined like this:
BEGIN { print
"Start!\n" };
END { print
"End!\n" };
A BEGIN block
is executed as soon as possible after it has been defined. This overrides
the parsing of the
rest of the package. You can have multiple BEGIN blocks
that
are executed in
the order they were defined. You can use a BEGIN block
to import
functions and
values from other modules so that the objects required by the rest of
the package are
defined at the point the block is parsed. This can be especially useful
if you are using
the function prototyping and declarations seen earlier in this chapter.
If a function has
been defined such that it is interpreted as an operator, or with a specific
prototyping
format, then it will need to exist before Perl interprets the rest of the
package.
An END routine
is the opposite: it is executed as late as possible. In practice, this
means that an END block
is executed at the point the parser and interpreter are about
to exit to the
calling process. This is the case, even if the reason for the failure is a die
function or the
result of an exception raised due to the nonexistence of a required system
call. You can use
this facility to help print error messages or close filehandles cleanly in
the event of an
error. Of course, in a well-written Perl script, you should be able to find
cleaner ways of
handling exceptions and errors.
END blocks
are executed in reverse order—that is, the last END block
specified
will be the first
to be executed. The following program doesn’t do quite what we want,
although it’s
pretty close:
BEGIN { print
"Eanie\n" }
die "Meanie\n";
END { print
"Miney\n" }
END { print
"Mo\n" }
You should not
assume that the main program code has been executed in an END
block. Care is needed to ensure you don’t
try to use a variable or function in an END
block that has not
otherwise been defined, although you should be doing this kind of
checking in the main body of the script
anyway.
FILES:
while(<>)
{
if(eof())
{
print
"Running out of data!!\n";
}
...
}
Subscribe to:
Posts (Atom)