-will
http://www.wgunther.tk
(the above message is double rot13 encoded for security reasons)

Most Useful Perl Modules
-strict
-warnings
-Devel::DProf
-Benchmark
-B::Deparse
-Data::Dumper
-Clone
-Perl::Tidy
-Beautifier
-DBD::SQLite

[snip file contents, they're posted below]

Hello Jorge,
This code will do what you want. You may also want to check:

For the 'm' modifier
perldoc perlretut (see using character classes)
perldoc perlre

Could not find docs for the 'g' modifier. Maybe someone else could point
out where it is best explained.

Chris

#!/usr/bin/perl
use strict;
use warnings;

{
local $/; # undefine input record separator - read in whole file as
1 line ($file).
my $file = <DATA>;
# m modifier allows ^ to match immediately after a newline, and $ to
match preceding a newline
# g modifier is for a progressive match - start next match immediately
after end of previous one
while ($file =~ /^s+(d+).+n(.+)$/mg) {
print $1 unless $2 =~ /extractStat/;
}
}

__DATA__
1 Chaque L Ma Me J V S D 00:20
D:muselotusnotesextractStat.exe StatA090 j
2 Chaque L Ma Me J V S D 00:21
D:muselotusnotesextractStat.exe StatA090 m
3 Chaque L Ma Me J V S D 00:22
D:muselotusnotesextractStat.exe StatA090 h
4 Chaque L Ma Me J V S D 00:23
D:muselotusnotesextractStat.exe StatB090 j
5 Chaque L Ma Me J V S D 00:27
D:muselotusnotesextractStat.exe StatPMF090 m
6 Chaque L Ma Me J V S D 00:28
D:muselotusnotesextractStat.exe StatPMF090 h
7 Aujourd'hui 20:00
D:muse3test.exe
8 Chaque L Ma Me J V S D 00:28
D:muselotusnotesextractStat.exe StatPMF090 h

<regex suggestion snipped>

I did understand your response as if you implied the latter. My
apologies if I was wrong.

I would say that nobody can learn regular expressions without serious
own efforts. To somebody who is seriously trying to learn, I believe
that a finished regex *can* be helpful in the learning process, since
it serves the purpose of pointing the questioner in the right
direction. Personally I learned regexes basically by studying finished
Perl programs while using the docs to figure out what was happening.

When helping somebody understand regexes, it's often pretty easy to
simply show how a problem can be solved. Adding comments that explain
every single detail is harder and much more time-consuming. If
somebody wants to do it, it's excellent, but the point I was trying to
make is that you can't expect that. The natural way IMO is that the
questioner seeks the explanations in the docs. (A pointer to relevant
docs is always a good idea, though.)

Yes, I did. I was assuming that one single fish will only still his
hunger temporarily, and that he realises that he needs to learn how to
fish. ;-)

--
Gunnar Hjalmarsson
Email: http://www.gunnar.cc/cgi-bin/contact.pl

No, it does not even compile. :(

You always need the /g modifier when using the m// operator that way
in a while loop. In this case you also need the /m modifier. Check out

perldoc perlop

about what those modifiers are doing.

while ($file =~ /^s+(d+).(.+)$/gm) {

Let's first correct the compilation error (something you should have
done before posting, btw).

print "$1n" if $2 =~ /extractStat/;

But now the script just outputs "uninitialized" warnings.

It's time to consider the program logic. $1, $2 etc. contain what was
captured in the last successful match. This would make the program
logic appear more clearly:

if ($2 =~ /extractStat/) {
print "$1n";
}

The point with that is to show that when the program comes to print
"$1n", the last successful match is no longer the m// operator in the
while loop, but it's $2 =~ /extractStat/. Since nothing was captured
there, $1 is undefined, which explains the warning messages.

This is one way to deal with it:

my $tmp = $1;
print "$tmpn" if $2 =~ /extractStat/;

HTH

--
Gunnar Hjalmarsson
Email: http://www.gunnar.cc/cgi-bin/contact.pl

Use the Email::Valid module from CPAN. If you are curious about how
complex an email address can truly get check out the source for the
module. I believe it is mostly taken from the regex provided in the
appendix of the Mastering Regular Expressions O'Reilly book. It will
truly blow your mind...

http://danconia.org

realize I need to open the process as a file handle for parallel
operations. Called a "piped open". (page 201 Oreilly Learning Perl).

I'll check it out.

Thanks!

Correct.

perldoc -f exec

For more.

So once you do that, Perl is gone. System

Yes, alternatively you can use fork+exec to have a forked process that
is non-blocking, the reason to use pipes is so that the two can
communicate more easily, this isn't always desired.

perldoc perlipc
perldoc perlfork
perldoc IPC::Open3

Explains most of this, much better than I can.

http://danconia.org

Correct.

perldoc -f exec

For more.

So once you do that, Perl is gone. System

Yes, alternatively you can use fork+exec to have a forked process that
is non-blocking, the reason to use pipes is so that the two can
communicate more easily, this isn't always desired.

perldoc perlipc
perldoc perlfork
perldoc IPC::Open3

Explains most of this, much better than I can.

http://danconia.org

--
To unsubscribe, e-mail: [Email Removed]
For additional commands, e-mail: [Email Removed]
<http://learn.perl.org/> <http://learn.perl.org/first-response>

DBSMITH> from what I remember reading and was told as a best practice using exec
DBSMITH> /.../..../ was recommended over system. For this reason exec does not
DBSMITH> create a child and therefore does not have to wait. the perl process
DBSMITH> itself runs the command or program. what are the pros and cons of each?

Well, the difference is whether a goto or a subroutine call will work
for you.

system() creates a kid, makes the kid do the work. Then you get
to resume doing what you are doing.

exec() sends you to do the work, and there's no returning.

Each has its place and purpose.

If the *very last* thing you're doing is system(), you can probably
replace that with exec(), and it'd be better. But otherwise, they
are clearly not interchangable.

--
Randal L. Schwartz - Stonehenge Consulting Services, Inc. - +
<[Email Removed]> <URL:http://www.stonehenge.com/merlyn/>
Perl/Unix/security consulting, Technical writing, Comedy, etc. etc.
See PerlTraining.Stonehenge.com for onsite and open-enrollment Perl training!

*** Since it's a common mistake to use "exec" instead
of "system", Perl warns you if there is a following
statement which isn't "die", "warn", or "exit" ***

I've pretty much decided it's either system or a filehande process for
me. I don't see myself using exec too often :-)

I get the impression that fork may not be a good idea. Perldoc suggests
it "could" leave zombie child processes hanging around. It also gives a
suggestion how to fix this ($SIG(CHLD)). Not sure this really is a
great idea. It would affect not just Perl but other system processes
running. Might not want to set it to ignore. Also, it makes the
presumption the system has that handy.

The thing I really like about Perl, there is always another way to do
something :-)

This exercise has really helped my understanding BTW. I appreciate the
help!!!

It's dangerous to make blanket statements like this. Each is a tool that
should be understood and applied in the right manner. That is why it is
more important to understand the concepts of process execution,
parallelism, blocking, etc. rather than any one particular function.
'system' is really just a combination of a fork+exec+waitpid model that
is easy to use, the backticks are similar to the open pipe model, but
generally easier to use as well, the open pipe model is really just a
fancy version of the same fork+exec+waitpid model. So some would claim
you should use fork+exec+waitpid, because 'system' really just uses
them, others would say that is the beauty of Perl, 'system' provides a
very good shortcut, assuming it accomplishes the goal.

Bottom line is that it is really the situation that will dictate which
is "best". And "more ideal for most situations" really becomes a
function of the type of job you are in, the type of code you usually
find yourself working on, and what you consider to be "production" level
of quality.

Just a couple of cents,

http://danconia.org

my Perl programs. However exec has it's place like any tool.

process?

I guess it really depends on what we are kicking off and whether it
exists cleanly.

Theoretically any process that starts a subprocess can result in the
creation of zombies. 'system' *should* be protected from this (read: I
don't really know because I am definitely not an internals expert)
because of either how waitpid is written or because it can temporarily
adjust the CHLD sig handler. I am unclear about exactly how this stuff
works, again not an internals person.

Essentially you are correct, though the important part is how the parent
exits, not the child. zombies are created when the parent exits before
all of its children (at least those that are not auto reaped),
essentially no process is then 'waiting' for them. I suspect the
thinking is that if you know enough of how to create sub processes, then
you should know enough of how to deal with them correctly, aka reading
exit codes, doing IPC, waiting for them to clean up, etc. Not having to
know all of this yourself, is why 'system', backticks, piped opens, and
POE are so nice.

Just for the archives, I have never had a problem of zombies being left
over by a program calling either 'system' or a piped open. (The problem
only seems to present itself when I write my own forking code ;-)).

http://danconia.org

Pearl", but can't do the exercises because I only have access to
'Windows' machines that do not have Perl installed at all. Is there a
way to use Perl on-line from such a machine? Is Perl small enough to be
installed on a floppy disk that can be moved from machine to machine?

As the others have pointed out, you can install Perl on windows. You
*might* be able to get it to run from a CD provided the drive letter was
the same (but this is very theoretical, and might prove difficult). If
you are at school there is bound to be a unix box of some sort around
that will have it installed, ask around and see if you can get an
account to play with Perl. If not at school, you could certainly get a
cheap hosting account at an online hoster, pick one with shell access,
and practice up your Perl that way, of course that would be more
expensive than just buying a computer these days eventually. You could
probably get a computer on Ebay for less than $200 and install Linux to
avoid the M$ tax.....

You might also visit a local Perl Mongers group and ask one of the
members if you could have access to their machine, one of them is bound
to have a server accessible from the internet and would consider giving
another member an account provided you didn't abuse it.

http://danconia.org

....or finally you can try with a linux-live distribution like knoppix:
http://www.knoppix.org/
It comes with perl like every linux... and a lot of other stuff and...
no configuration problems.
You don't need to install anithing, you need only the 'permissions' to
reboot the computer from cd and play with it until the end of the day!

Remo

Go to http://www.activestate.com/Products/ActivePerl/ and install ActivePerl
(free).

Nope. It may have at one time.
http://www.perldoc.com/perl5.8.0/pod/perlhist.html

The ActiveState .msi installation image _will_ fit on a CD.

Not really. There are various ways of "bundling" an application for
deployment on a target machine without having to install Perl separately.
You can also install Perl on a network share and run it that way I guess.

__________________________________
Do you Yahoo!?
Yahoo! Mail is new and improved - Check it out!
http://promotions.yahoo.com/new_mail

use strict;

my $file = shift; (the traditional idiom)

use File::Basename;
my ($name, $path) = fileparse($file); (more portable)

substr($name, 0, 1) = 'c'; (no need for regex)

use File::Spec
print "Original name: ", $file,
" Changed name: ", File::Spec->catfile($path, $name), "n";

You might also have a look at the ubiquitous (and ancient) perl "rename"
script: http://www.cpan.org/scripts/nutshell/ch6/rename

Hi. Real names appreciated.

Somebody has mucked with the server configuration.

Not the issue.

That should be fine.

You need to disable index generation. It's not a permission issue. It's also
not a Perl issue. Read the docs for your web server.

HTH

Probably you should adjust the code at the 'split' time in anticipation
of your future needs, the need for two arrays that are then combined is
an indication of a design flaw. Post more code to have that looked over...

in arrays),i want this output in an array @mapped.

I am assuming the arrays are the same size...

my @c;
foreach my $index (0 .. $#element) {
$c[$index] = "$element[$index] : $size[$index]";
}

works?

http://danconia.org

<snip old posts>

Only that CGI be installed. Have you tried running the script from the
command line and checking its output? Are the Perl versions, and CGI.pm
versions identical? Generally the error you state is caused by either
failure to execute the script at all, or something being printed before
a proper header. If you try to run the script from the command line be
sure to do it as the user the web server runs as, and note that the
environment when logged in at a shell will be different than that of the
web server's environment.

See if you can provide more info,

http://danconia.org

Hi...Ok I think I figured it out, without having any test files.
Below is the code.

What I did was go into your do_while sub and first count the total
lines by looping thru the filehandles, then I rewound the filehandles
to the beginning so they could be processed. Then as you process them,
I increment the progressbar by ( 100 / $linetotal ).

It seems to work, but I don't know what you are doing for sure.
In my testing, I create the test error file, then click each checkbox
and select a txt file. Then click the toets button.

Also I added a few select(undef,undef,undef,.01) statements
to slow down the files for testing. You can remove them for your
big files.


#!/usr/bin/perl
use Tk;
use IO::File;
use diagnostics;
use warnings;
use Tk::Balloon;

# added these lines
use Fcntl qw(:seek);
use Tk::ProgressBar;
my $linetotal = 0;
my $progressbar;
#

use vars qw(@c @bs @cb_value @i $sfile_val $newline @bt);
my $sfile = "";
my $file = "";
my $FILE0 = "";
my $FILE1 = "";
my $FILE2 = "";
my $FILE3 = "";
my $FILE4 = "";
my $FILE5 = "";
my $FILE6 = "";

# MAINWINDOW
my $main = new MainWindow();
drawInterface();
Tk::MainLoop();


# INTERFACE FOR USER <BUTTONS, CHECKBOX, ETC>
sub drawInterface {
$main->title("Check For Errors");
$main->configure( -background => 'gray' );
$main->geometry("300x300");

# MAAK FRAMES
my $opsFrm = $main->Frame( -background => 'gray' )->pack( -side =>
'top' );
my $keuseFrm = $main->Frame( -background => 'gray' );
my $opbtFrm =
$main->Frame( -background => 'gray' )->pack( -side => 'bottom'
);

# MAAK KEUSE VIR DIE SAVE LEER
$main->Label(
-text => "Create a file to save errors to",
-background => 'gray',
-font => "Helvetica -15 bold"
)->pack();
$main->configure( -background => 'gray' );
$main->Button(
-text => 'Create',
-width => 7,
-height => 1,
-command => sub { &do_save($main) }
)->pack( -pady => 3 );

# KEUSE BY TIPE LEERS
my $keuse = $keuseFrm->Label(
-text => "Maak 'n keuse",
-font => "Helvetica -15 bold"
)->pack( -side => 'top', -pady => 20 );
$keuse->configure( -background => 'gray' );
$keuseFrm->pack( -side => 'top', -fill => 'x' );

# CHECKBOX VIR LEERS WAT GEKIES WORD
$c[0] = $keuseFrm->Checkbutton(
-variable => $cb_value[0],
-offvalue => 0,
-onvalue => 1,
-text => "Dialects Upper",
-background => 'gray',
-command => sub {
if ( $cb_value[0] == 1 ) {
&do_get( $main, $c[0] = 0 );
}
}
)->pack( -side => 'top', -anchor => 'w', -padx => 20 );

$c[1] = $keuseFrm->Checkbutton(
-variable => $cb_value[1],
-offvalue => 0,
-onvalue => 1,
-text => "Dialects Lower",
-background => 'gray',
-command => sub {
if ( $cb_value[1] == 1 ) {
&do_get( $main, $c[1] = 1 );
}
}
)->pack( -side => 'top', -anchor => 'w', -padx => 20 );

$c[2] = $keuseFrm->Checkbutton(
-variable => $cb_value[2],
-offvalue => 0,
-onvalue => 1,
-text => "Coffensive Upper",
-background => 'gray',
-command => sub {
if ( $cb_value[2] == 1 ) {
&do_get( $main, $c[2] = 2 );
}
}
)->pack( -side => 'top', -anchor => 'w', -padx => 20 );

#DOEN EN EXIT BUTTONS

$bt[0] = $opbtFrm->Button(
-text => 'Toets',
-width => 8,
-height => 1,
-command => sub { &do_while }
)->pack( -side => 'left' );

$bt[1] = $opbtFrm->Button(
-text => 'Exit',
-width => 8,
-height => 1,
-command => sub { exit }
)->pack( -side => 'right' );
}

# SKEP FILE
sub processfile {
my $retval = 0;

if ( open SFILE, "> $sfile" ) {
print SFILE "n" if ($newline);
close(SFILE);
}
return $sfile;
}

# SAVE FILE WAT GESKEP IS
sub do_save {
my ($save) = @_;
my @types = (
[ "Text files", [qw/.txt .doc/] ],
[ "Text files", "", "TEXT" ],
[ "All files", "*" ]
);
$sfile = $main->getSaveFile(
-filetypes => @types,
-initialfile => 'test',
-defaultextension => '.txt'
);
print qq{You chose to save as "$sfile"n};
processfile();
}

# KRY FILE GEBRUIK GAAN WORD
sub do_get {
my ( $get, $get1 ) = @_;
my @types = (
[ "Text files", [qw/.txt .doc/] ],
[ "Text files", "", "TEXT" ],
[ "All files", "*" ]
);
$file = $main->getOpenFile(
-filetypes => @types,
-defaultextension => '.txt'
);
print qq{"jy het $file "n};
&kyk( $file, $get1 );
}

# SIT DIE OOP GEMAAKTE LEER IN SY PLEK
sub kyk {
my ( $kyk, $kyk1 ) = @_;
SWITCH: {
if ( $kyk1 == 0 ) {
$FILE0 = $file;
print qq{" file0 = $FILE0 "n};
my $op0 = $FILE0;
open( FILE0, "<$op0" ) or die "$!: $op0n yap0";
return $FILE0;
last SWITCH;
}
if ( $kyk1 == 1 ) {
$FILE1 = $file;
print qq{" file1 = $FILE1 "n};
my $op1 = $FILE1;
open( FILE1, "<$op1" ) or die "$!: $op1n yap1";
return $FILE1;
last SWITCH;
}
if ( $kyk1 == 2 ) {
$FILE2 = $file;
print qq{" file2 = $FILE2 "n};
my $op2 = $FILE2;
open( FILE2, "<$op2" ) or die "$!: $op2n yap2";
return $FILE2;
last SWITCH;
}
}
&do_while($file);
}

sub do_while {

#count lines and rewind
while(<FILE0>){$linetotal++}
seek FILE0, 0, SEEK_SET or die "Cannot rewind file: $!";

while(<FILE1>){$linetotal++}
seek FILE1, 0, SEEK_SET or die "Cannot rewind file: $!";

while(<FILE2>){$linetotal++}
seek FILE2, 0, SEEK_SET or die "Cannot rewind file: $!";

print "$linetotaln";

$progressbar = $main->ProgressBar(
-length => 200, # Actually width
-width => 20, # Actually height
-gap => 0,
-value => 0,
-colors => [0, 'pink'],
)->pack(-pady => 5, -padx => 5);

while (<FILE0>) {
my $line = $_;
chomp($line);
do_opt0($line);
if ( $line ne $token ) {
print SFILE "$token";
}
$progressbar->value($progressbar->value + (100/$linetotal) );
$main->update;
select(undef,undef,undef,.01);
}

while (<FILE1>) {
my $line = $_;
chomp($line);
do_opt1($line);
if ( $line ne $token ) {
print SFILE "$token";
}
$progressbar->value($progressbar->value + (100/$linetotal) );
$main->update;
select(undef,undef,undef,.01);
}

while (<FILE2>) {
my $line = $_;
chomp($line);
do_opt2($line);
if ( $line ne $token ) {
print SFILE "$token";
}
$progressbar->value($progressbar->value + (100/$linetotal) );
$main->update;
select(undef,undef,undef,.01);
}
}

# OPTIONS WAT GEMAAK IS ??????????
sub do_opt0 {

my $op0 ||= 0;
my $class;
my $print = 0;
my $word = $_[0];

my $sfil = $sfile;
$op0 = $FILE0;

print " $sfile ";

open( SFILE, ">>$sfil" ) or die "$!: $sfiln";

if ( $word =~ /^(.*)(s)(.*)/ ) {
$token = "$wordttt$op0n";
return $token;
} #spasies
if ( $word =~ /^(.*)(n)(n)(.*)/ ) {
$token = "$wordttt$op0n";
return $token;
} #dubbel enters
if ( $word =~ /^([a-z]+)([A-Z]+)([a-z]+)/ ) {
$token = "$wordttt$op0n";
return $token;
} #kleinHOOFklein
if ( $word =~ /^([A-Z])(.*)/ ) {
$token = "$wordttt$op0n";
return $token;
} #HOOF
if ( $word =~ /^((.*)[?|!|#|_|.](.*))/ ) {
$token = "$wordttt$op0n";
return $token;
} #vraagteken,#uitroepteken,#underscore,#iets,#iets
if ( $word =~ /^('-')(.*)/ ) {
$token = "$wordttt$op0n";
return $token;
} #koppelteken aan begin van woord
if ( $word =~ /^(.*)('-')$/ ) {
$token = "$wordttt$op0n";
return $token;
} #koppelteken aan einde van woord
if ( $word =~
/^(.*)(@|\|/|{|}|=|+|*|&|^|:|;|<|>|(|)|`|~|%|"|,)(.*)$/
)
{
$token = "$wordttt$op0n";
return $token;
} #weird leestekens
}

sub do_opt1 {

my $op0 ||= 0;
my $class;
my $print = 0;
my $word = $_[0];

my $sfil = $sfile;
$op1 = $FILE1;

print " $sfile ";

open( SFILE, ">>$sfil" ) or die "$!: $sfiln";

if ( $word =~ /^(.*)(s)(.*)/ ) {
$token = "$wordttt$op1n";
return $token;
} #spasies
if ( $word =~ /^(.*)(n)(n)(.*)/ ) {
$token = "$wordttt$op1n";
return $token;
} #dubbel enters
if ( $word =~ /^([a-z]+)([A-Z]+)([a-z]+)/ ) {
$token = "$wordttt$op1n";
return $token;
} #kleinHOOFklein
if ( $word =~ /^([A-Z])(.*)/ ) {
$token = "$wordttt$op1n";
return $token;
} #HOOF
if ( $word =~ /^((.*)[?|!|#|_|.](.*))/ ) {
$token = "$wordttt$op1n";
return $token;
} #vraagteken,#uitroepteken,#underscore,#iets,#iets
if ( $word =~ /^('-')(.*)/ ) {
$token = "$wordttt$op1n";
return $token;
} #koppelteken aan begin van woord
if ( $word =~ /^(.*)('-')$/ ) {
$token = "$wordttt$op1n";
return $token;
} #koppelteken aan einde van woord
if ( $word =~
/^(.*)(@|\|/|{|}|=|+|*|&|^|:|;|<|>|(|)|`|~|%|"|,)(.*)$/
)
{
$token = "$wordttt$op1n";
return $token;
} #weird leestekens
}

sub do_opt2 {

my $op0 ||= 0;
my $class;
my $print = 0;
my $word = $_[0];

my $sfil = $sfile;
$op2 = $FILE2;

print " $sfile ";

open( SFILE, ">>$sfil" ) or die "$!: $sfiln";

if ( $word =~ /^(.*)(s)(.*)/ ) {
$token = "$wordttt$op2n";
return $token;
} #spasies
if ( $word =~ /^(.*)(n)(n)(.*)/ ) {
$token = "$wordttt$op2n";
return $token;
} #dubbel enters
if ( $word =~ /^([a-z]+)([A-Z]+)([a-z]+)/ ) {
$token = "$wordttt$op2n";
return $token;
} #kleinHOOFklein
if ( $word =~ /^([A-Z])(.*)/ ) {
$token = "$wordttt$op2n";
return $token;
} #HOOF
if ( $word =~ /^((.*)[?|!|#|_|.](.*))/ ) {
$token = "$wordttt$op2n";
return $token;
} #vraagteken,#uitroepteken,#underscore,#iets,#iets
if ( $word =~ /^('-')(.*)/ ) {
$token = "$wordttt$op2n";
return $token;
} #koppelteken aan begin van woord
if ( $word =~ /^(.*)('-')$/ ) {
$token = "$wordttt$op2n";
return $token;
} #koppelteken aan einde van woord
if ( $word =~
/^(.*)(@|\|/|{|}|=|+|*|&|^|:|;|<|>|(|)|`|~|%|"|,)(.*)$/
)
{
$token = "$wordttt$op2n";
return $token;
} #weird leestekens
}

close(SFILE);
close(FILE0);
close(FILE1);
close(FILE2);

# SPASIE
sub do_spasie { }

# DUBBLE ENTRIES
sub do_ent { }

# KLEINHOOFKLEIN
sub do_khk { }

# HOOF
sub do_hoof { }

# KLEIN
sub do_klein { }

# VREEMDE
sub do_vr { }

# KOPPEL TEKEN BEGIN
sub do_kopb { }

# KOPPELTEKEN EINDE
sub do_kope { }

# WEIRD LEESTEKENS
sub do_weird { }
__END__





















--
I'm not really a human, but I play one on earth.
http://zentara.net/japh.html

--
To unsubscribe, e-mail: [Email Removed]
For additional commands, e-mail: [Email Removed]
<http://learn.perl.org/> <http://learn.perl.org/first-response>

There's a comma missing here.

What platform and what version of Perl and IO::Socket? If I fix the missing
comma, it times out properly for me with Perl 5.6.1 on FreeBSD 4.10

That code is still missing a comma and won't compile. Sorry I don't
understand why it isn't timing out on your system.

There's really a tremendous amount of stuff that goes into writing an http
client. I would try to script an ftp client session since you have telnet
access to the systems. Or, if possible, configure the systems to accept ftp
transfers originated from your central system.

Remember this is open source so you are free to check for yourself.
Net::SMTP inherits from Net::Cmd. Which means you can check the error
message, code, or status from the object itself through the inherited
methods, 'message', 'code', 'status'.

perldoc Net::Cmd for more

This is generally for methods that are causing some network interaction.
For other methods most likely catching an error is for an obvious
reason, if you have a question about a particular method check the
source or ask for that specific method and one of the gurus will check
what it can return...

http://danconia.org

p.s. I am not entirely sure whether no one is replying, the list is
slow, or my e-mail is busted, so if this is the 43rd reply to this post
sorry for the noise...

Methinks that stuff is illegally posted copyrighted information.

I thought you might be unaware, so wanted to warn you. Evidently, that's not
the case.

Several people responded individually with comments like this. If the authors
care, shouldn't they contact the ISP? I mean, I can't police the internet
single-handedly. And I think O'Reilly has probably already made enough take
on this particular snippet...

Online versions of many books do appear from time to time on various
sites. They generally move around. I've found this out by stumbling
across them during google searches, and then going back to that link a
day or two later and finding it gone.

Anyway, it is illegal. It is obviously so. You don't have to police the
internet. You only have to police your own behaviour.

Randy.

Perl> Several people responded individually with comments like this.
Perl> If the authors care, shouldn't they contact the ISP? I mean, I
Perl> can't police the internet single-handedly.

No, but you can have enough sense that if the ENTIRE WORKS of authors
like me are *online*, someone is doing something wrong.

Please, don't tell me you sat there and had ABSOLUTELY NO CLUE.
What color is the sky on the planet where you come from?

So, even if you don't want to forward that to [Email Removed] (the
proper thing to do), the second best thing is REMOVE THAT LINK FROM
YOUR BOOKMARKS, and NOT SHARE IT?

Get it?

Stop taking money out of my pocket. You offend me.

--
Randal L. Schwartz - Stonehenge Consulting Services, Inc. - +
<[Email Removed]> <URL:http://www.stonehenge.com/merlyn/>
Perl/Unix/security consulting, Technical writing, Comedy, etc. etc.
See PerlTraining.Stonehenge.com for onsite and open-enrollment Perl training!

For making Windows services, see Win32::Daemon and Win32::Daemon::Simple on
CPAN.

What the Q E /ox in the regex does ?

HTH,

Rod




__________________________________
Do you Yahoo!?
Yahoo! Mail is new and improved - Check it out!
http://promotions.yahoo.com/new_mail

If the base class constructor is written properly, it should be inheritable.
If not, you'll have to write one.

Inheritable:

sub new {
my $class = shift;
bless {}, $class;
}

Not inheritable:

sub new {
bless {};
}

also not inheritable:

sub new {
bless {}, 'My::Class';
}

package Bar;

@ISA = qw/Foo/;

sub new {
my $class = shift;
bless Foo->new(@_), $class;
}

No.

Wouldn't you want this instead?

package Bar;

@ISA = qw/Foo/;

sub new
{
my $s = shift;
my $class = ref($s) || $s;
my $self = $class->SUPER::new();
bless $self, $class;
return $self;
}

In the specific case of multiple inheritence, how do you know what SUPER even
is though? I mean, is it just the first entry in @ISA?

Why not the straightforward:

use FindBin;
use lib "$FindBin::Bin/../lib";

(lifted directly from the FindBin docs)

Or why not allow the sysadmin to place the libs wherever he wants and use a
SetEnv directive in the web server config to pass PERL5LIB to the CGI
scripts and forego use lib altogether?

This is obviously a case of me trying to make this too complex. Thank you
Bob for showing me that simpler is always better. My "ass"umption was that
$FindBin::Bin was going to locate a directory BELOW cgi-bin/test. The
straight forward method worked just fine.

Thank you.

When Perl sees the ${ blah } notation, it's usually expecting "blah" to be a
scalar reference that you're dereferencing. But you're not doing that;
you're just giving the name of a symbol. You should just write it as
$DBI::errstr and leave the braces off.

It's only a warning, because Perl lets you use this notation inside double
quotes where you need to delimit the symbol name. Consider:

my $package = 'DBI';

print "The error is $package::errstrn"; # oops, doesn't work
print "The error is ${package}::errstrn"; # that does it

The latter can also be written as:

print "The error is $package::errstrn";

Bottom line is: you only need the braces inside double quotes, and even then
you don't usually need them. They are only used to tell Perl where your
identifier ends. If the identifier name is followed by a character that
can't be part of an identifier name (e.g. the backslash above), it will stop
there and no braces are needed.

Not really, because of autoloading. See perldoc perlsub under the heading
"Autoloading".

You can take a reference to a subroutine that doesn't yet exist! Consider:

$x = &foo; # reference to non-existant sub

print "$x is a reference to ", ref($x), "n";
eval { &$x }; # try to call the sub
warn $@ if $@;

eval qq[sub foo { print "Foo is here now!n" }]; # define the sub
&$x; # you can call it now

Outputs:

$x is a reference to CODE
Undefined subroutine &main::foo called at foo.pl line 4.
Foo is here now!

There's probably a module somewhere with such a function. You can also write
one simply.

I usually use the following:

s/^s+//, s/s+$// for $variable;

I like that form because you can list a bunch of variables and trim them
all.

A more traditional trim() function could be:

sub trim { local $_ = shift; s/^s+//, s/s+$//; $_ }