tag:blogger.com,1999:blog-2899601674425673382010-01-02T03:38:45.586-08:00The amazing world of perl for engineers!Murugavel Ganesanmurugavelganesan@gmail.comBlogger45125tag:blogger.com,1999:blog-289960167442567338.post-24648402194801750162009-10-29T03:06:00.000-07:002009-10-29T03:09:13.182-07:00

Having examined the import mechanism from the side of the importer, we can take a look at how modules handle import requests. From the module’s perspective of course, this is exporting. The Exporter module provides a generic import subroutine for modules to configure to their own particular tastes. It handles almost all the possible issues that a module needs to consider, and for many modules it

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-60198395892764593462009-10-29T03:08:00.001-07:002009-10-29T03:08:50.094-07:00

One advantage of the Exporter module is that the import method it provides is well developed and handles many different situations for us. Even if we decide to provide our own import subroutine we may want to use Exporter too, just for the richness of the features it provides. For example, it accepts regular expressions as well as literal symbol names, which means that we can define a collection

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-66594025350271071252009-10-29T03:04:00.001-07:002009-10-29T03:04:53.686-07:00

Perl’s mechanism for importing symbols is simple, elegant, and shockingly ad hoc, all at the same time. In a nutshell, we call a subroutine called import in the package that we want to import symbols from. The import stage is a secondary stage beyond actually reading and compiling a module file, so it is not handled by the require directive; instead, it is a separate explicit step: require My::

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-58745435479694223662009-04-29T22:29:00.000-07:002009-04-29T22:30:21.688-07:00

The term ‘importing’ is used for the process of taking symbols from another package and adding them to our own. From the perspective of the module being imported from, it is ‘exporting’, of course. Either way, the process consists of taking a symbol visible in the namespace of one package and making it visible, without qualification, in another. For example, even if we can see it we would rather

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-11831562159825753072009-04-29T22:26:00.000-07:002009-04-29T22:28:44.588-07:00

For most purposes, Perl uses a fast and simple reference-based garbage collection system. For this reason, there's an extra dereference going on at some level, so if you haven't built your Perl executable using your C compiler's -O flag, performance will suffer. If you have built Perl with cc -O, then this probably won't matter.A more serious concern is that unreachable memory with a non-zero

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-7795600913657562772009-04-29T22:24:00.001-07:002009-04-29T22:24:46.237-07:00

When the last reference to an object goes away, the object is automatically destroyed. (This may even be after you exit, if you've stored references in global variables.) If you want to capture control just before the object is freed, you may define a DESTROY method in your class. It will automatically be called at the appropriate moment, and you can do any extra cleanup you need to do. Perl

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-92139474224316542172009-04-29T22:22:00.000-07:002009-04-29T22:23:25.119-07:00

There are two ways to invoke a method, one of which you're already familiar with, and the other of which will look familiar. Perl 4 already had an ``indirect object'' syntax that you use when you say print STDERR "help!!!\n";This same syntax can be used to call either class or instance methods. We'll use the two methods defined above, the class method to lookup an object reference and the

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-92133904751828610262009-04-29T22:21:00.000-07:002009-04-29T22:22:14.422-07:00

Unlike say C++, Perl doesn't provide any special syntax for method definition. (It does provide a little syntax for method invocation though. More on that later.) A method expects its first argument to be the object (reference) or package (string) it is being invoked on. There are just two types of methods, which we'll call class and instance. (Sometimes you'll hear these called static and

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-29050090919383597702009-04-29T22:19:00.000-07:002009-04-29T22:21:05.053-07:00

Unlike say C++, Perl doesn't provide any special syntax for class definitions. You use a package as a class by putting method definitions into the class. There is a special array within each package called @ISA, which says where else to look for a method if you can't find it in the current package. This is how Perl implements inheritance. Each element of the @ISA array is just the name of another

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-53659096980068188172008-01-26T06:16:00.000-08:002009-04-29T03:16:01.843-07:00

We all know that when faced with a job to do, we usually tend to reach for the most familiar tool in our belt. And while perl is certainly a versatile tool, it isn't the right tool for every job.Perl is the granddaddy of the open-source scripting languages, with the 1.0 release seeing the light of day way back in 1987. By comparison, PHP wasn't released until 1994, and Python didn't have its 0.9

Technology Freaknoreply@blogger.com1tag:blogger.com,1999:blog-289960167442567338.post-20557442064480920542008-12-09T05:19:00.000-08:002009-04-29T03:12:16.061-07:00

Before release 5 of Perl it was difficult to represent complex data structures, because all references had to be symbolic--and even then it was difficult to refer to a variable instead of a symbol table entry. Perl now not only makes it easier to use symbolic references to variables, but also lets you have ``hard'' references to any piece of data or code. Any scalar may hold a hard reference.

Technology Freaknoreply@blogger.com0tag:blogger.com,1999:blog-289960167442567338.post-62554299276204920012008-12-09T05:25:00.001-08:002009-04-29T03:11:23.684-07:00

References can be created in several ways. Three of them are as follows. By using the backslash operator on a variable, subroutine, or value. (This works much like the & (address-of) operator in C.) This typically creates another reference to a variable, because there's already a reference to the variable in the symbol table. But the symbol table reference might go away, and you'll still have the

Technology Freaknoreply@blogger.com0tag:blogger.com,1999:blog-289960167442567338.post-43816529932551980022007-12-28T02:00:00.002-08:002009-04-29T03:06:34.430-07:00

All numbers and strings are scalars. Scalar variable names start with a dollar sign.Perl converts automatically between numbers and strings as required, so that$a = 2;$b = 6;$c = $a . $b; # The "." operator concatenates two#strings$d = $c / 2;print $d;yields the result 13This example involves converting two integers into strings, concatenating the strings into a new string variable, converting

Technology Freaknoreply@blogger.com0tag:blogger.com,1999:blog-289960167442567338.post-76161485393818804072009-04-15T22:30:00.000-07:002009-04-15T22:32:24.512-07:00

Unlike say C++, Perl doesn't provide any special syntax for constructors. A constructor is merely a subroutine that returns a reference to something ``blessed'' into a class, generally the class that the subroutine is defined in. Here is a typical constructor: package Critter; sub new { bless {} }That word new isn't special. You could have written a construct this way, too: package

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-83803934690130392442009-04-15T22:29:00.000-07:002009-04-15T22:30:10.307-07:00

The next series of posts are on Object Oriented Perl!

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-3248997201081426262009-02-23T20:04:00.000-08:002009-02-23T20:12:44.906-08:00

There is no special class syntax in Perl, but a package may act as a class if it provides subroutines to act as methods. Such a package may also derive some of its methods from another class (package) by listing the other package name(s) in its global @ISA array (which must be a package global, not a lexical). package Module; # assumes Module.pm use strict; use warnings; BEGIN {

Murugavel Ganesanmurugavelganesan@gmail.com1tag:blogger.com,1999:blog-289960167442567338.post-23047215141586966102009-02-05T21:04:00.000-08:002009-02-05T21:05:32.661-08:00

Four special subroutines act as package constructors and destructors. These are the BEGIN, CHECK, INIT, and DESTROY routines. The sub is optional for these routines.A BEGIN subroutine is executed as soon as possible, that is, the moment it is completely defined, even before the rest of the containing file is parsed. You may have multiple BEGIN blocks within a file--they will execute in order of

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-7637809845371517152009-02-05T21:01:00.000-08:002009-02-05T21:03:27.947-08:00

Perl provides a mechanism for alternative namespaces to protect packages from stomping on each other's variables. In fact, there's really no such thing as a global variable in Perl. The package statement declares the compilation unit as being in the given namespace.A module is just a set of related function in a library file a Perl package with the same name as the file. It is specifically

Murugavel Ganesanmurugavelganesan@gmail.com0tag:blogger.com,1999:blog-289960167442567338.post-70721513887603732452009-01-05T02:09:00.000-08:002009-01-05T02:10:03.413-08:00

The undefined value is a curious entity, being neither a scalar, list, hash, nor any other data type, which is essentially the point. Although it isn’t strictly speaking a datatype, it can be helpful to think of it as a special datatype with only one possible value (NULL). The concept of a ‘value that is not a value’ is common to many languages. In Perl, the undef function returns an undefined

Technology Freaknoreply@blogger.com0tag:blogger.com,1999:blog-289960167442567338.post-11978750818249474502009-01-05T02:06:00.000-08:002009-01-05T02:08:20.539-08:00

The typeglob is a composite data type that contains one instance of each other data types. It is an amalgam of all Perl’s data types, from which it gets its name. It is a sort of ‘super reference’ whose value is not a single reference to something but six slots that can contain six different references, all at once: a.scalar – A reference to scalarb.array – A reference to arrayc.hash – A

Technology Freaknoreply@blogger.com0tag:blogger.com,1999:blog-289960167442567338.post-56432457390460969882009-01-05T02:01:00.000-08:002009-01-05T02:05:24.303-08:00

Combining lists and hashes with references allows us to create arbitrarily complex data structures such as list of lists, hashes of hashes, and lists of hashes of lists of lists and so on. However, Perl lacks the ability to explicitly declare things like multidimensional arrays, because lists and hashes can only contain scalar values. Example 1:# List of list references@arr = ( [1,2], [3,4,5], [

Technology Freaknoreply@blogger.com0tag:blogger.com,1999:blog-289960167442567338.post-70477006165682732902007-12-28T02:00:00.001-08:002009-01-05T01:56:23.784-08:00

Perl has a small number of data types. There are only two data types: scalars and arrays. There is also a very special kind of array called an associative array that merits a section all to itself.

Technology Freaknoreply@blogger.com0tag:blogger.com,1999:blog-289960167442567338.post-23668736158967033312007-12-28T01:58:00.000-08:002009-01-05T01:55:35.126-08:00

Practical Extraction Reporting Language is a 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).

Technology Freaknoreply@blogger.com0tag:blogger.com,1999:blog-289960167442567338.post-5152390080448550852008-12-09T05:26:00.001-08:002009-01-05T00:19:25.596-08:00

That's it for creating references. By now you're probably dying to know how to use references to get back to your long-lost data. There are several basic methods. 1. Anywhere you'd put an identifier (or chain of identifiers) as part of a variable or subroutine name, you can replace the identifier with a simple scalar variable containing a reference of the correct type: $bar = $$scalarref;

Technology Freaknoreply@blogger.com0tag:blogger.com,1999:blog-289960167442567338.post-40776944709083029532008-12-09T05:27:00.001-08:002009-01-05T00:17:24.133-08:00

The value of the scalar is taken to be the name of a variable, rather than a direct link to a (possibly) anonymous value. $name = "foo"; $$name = 1; # Sets $foo ${$name} = 2; # Sets $foo ${$name x 2} = 3; # Sets $foofoo $name->[0] = 4; # Sets $foo[0] @$name = (); # Clears @foo &$name(); # Calls &foo() (as in

Technology Freaknoreply@blogger.com0