perlmod über BEGIN-Blöcke

Hallo,

ich lese gerade permod. Darin kommt (in Zusammenhang mit BEGIN-
Blöcken) folgender Absatz vor:

'It should be noted that "BEGIN" code blocks are executed inside string
"eval()"'s. The "CHECK" and "INIT" code blocks are not executed inside a
string eval, which e.g. can be a problem in a mod_perl environment.'

Meine Frage: was ist damit gemeint? Wo kann im Zusammenhang mit
mod_perl ein Problem liegen? Und worin liegt der Unterschied, ob
jetzt ein Block innerhalb von string-evals()ausgeführt wird, oder nicht?

LG, Ferry

--
Ing Ferry Bolhar
Magistrat der Stadt Wien - MA 14
A-1010 Wien
E-Mail: bol@adv.magwien.gv.at

Re: perlmod ber BEGIN-Blcke

On 2007-07-12 09:34, Ferry Bolhar wrote:
> ich lese gerade permod. Darin kommt (in Zusammenhang mit BEGIN-
> Blcken) folgender Absatz vor:
>
> 'It should be noted that "BEGIN" code blocks are executed inside string
> "eval()"'s. The "CHECK" and "INIT" code blocks are not executed inside a
> string eval, which e.g. can be a problem in a mod_perl environment.'
>
> Meine Frage: was ist damit gemeint? Wo kann im Zusammenhang mit
> mod_perl ein Problem liegen?

mod_perl verwendet vermutlich String-evals um Code-Blöcke zu
compilieren (mir fällt auch gar keine andere Methode ein, wie das zur
Laufzeit gehen sollte). Das heißt aber, dass Code, der in einer
mod_perl-Umgebung ausgeführt werden soll, keine CHECK und INIT Blöcke
enthalten darf, weil die einfach ignoriert werden:

hrunkner:~/tmp 13:40 193% cat foo
#!/usr/bin/perl
use warnings;
use strict;


my $code = < BEGIN { print "in BEGIN\n" }
CHECK { print "in CHECK\n" }
INIT { print "in INIT\n" }
print "in body\n";
1;
EOF

eval $code;
hrunkner:~/tmp 13:40 194% ./foo
in BEGIN
Too late to run CHECK block at (eval 1) line 4.
Too late to run INIT block at (eval 1) line 6.
in body


> Und worin liegt der Unterschied, ob jetzt ein Block innerhalb von
> string-evals()ausgefhrt wird, oder nicht?

Code der ausgeführt wird, tut was. Code der nicht ausgeführt wird tut
nichts. Was sonst sollte der Unterschied sein? Ich verstehe Deine Frage
nicht.


hp


--
_ | Peter J. Holzer | I know I'd be respectful of a pirate
|_|_) | Sysadmin WSR | with an emu on his shoulder.
| | | hjp@hjp.at |
__/ | http://www.hjp.at/ | -- Sam in "Freefall"

Re: perlmod ber BEGIN-Blcke

Peter J. Holzer:

>> Meine Frage: was ist damit gemeint? Wo kann im Zusammenhang mit
>> mod_perl ein Problem liegen?
>
> mod_perl verwendet vermutlich String-evals um Code-Blöcke zu
> compilieren (mir fällt auch gar keine andere Methode ein, wie das zur
> Laufzeit gehen sollte). Das heißt aber, dass Code, der in einer
> mod_perl-Umgebung ausgeführt werden soll, keine CHECK und INIT Blöcke
> enthalten darf, weil die einfach ignoriert werden:

BEGIN-Blöcke sind aber erlaubt und werden nicht ignoriert?
Das passt doch nicht zusammen.

> my $code = < > BEGIN { print "in BEGIN\n" }
> CHECK { print "in CHECK\n" }
> INIT { print "in INIT\n" }
> print "in body\n";
> 1;
> EOF
>
> eval $code;

Setzt man diesen Code als Ganzes nochmals in einen
BEGIN-Block, so erhält man:

in BEGIN
in body
in CHECK
in INIT

Hier wird also der Body-Code _VOR_ den CHECK und INIT-
Blöcken abgearbeitet? Jetzt verstehe ich gar nichts mehr.

> > Und worin liegt der Unterschied, ob jetzt ein Block innerhalb von
> > string-evals()ausgefhrt wird, oder nicht?
>
> Code der ausgeführt wird, tut was. Code der nicht ausgeführt wird tut
> nichts. Was sonst sollte der Unterschied sein? Ich verstehe Deine Frage
> nicht.

Ich habe die Frage scheinbar ungenau gestellt. Worin liegt der
Unterschied, ob Code innerhalb von string-evals() ausgeführt
wird, oder außerhalb davon bzw. in block-evals()? Abgesehen
vom Compilierzeitpunkt sollte doch zwischen den beiden eval-
Formen kein Unterschied sein.

Meine Frage bezog sich eben auf den zitierten Text:

'It should be noted that "BEGIN" code blocks are executed inside string
> "eval()"'s. The "CHECK" and "INIT" code blocks are not executed
> inside a string eval

den ich so verstanden habe, dass innerhalb von string-evals()
manche Dinge - welche, geht eben aus dem Text nicht hervor -
anders ablaufen als außerhalb davon.

LG, Ferry

--
Ing Ferry Bolhar
Magistrat der Stadt Wien - MA 14
A-1010 Wien
E-Mail: bol@adv.magwien.gv.at

Re: perlmod ber BEGIN-Blcke

Ferry Bolhar wrote:

> Meine Frage bezog sich eben auf den zitierten Text:
>
>>'It should be noted that "BEGIN" code blocks are executed inside string
>>"eval()"'s. The "CHECK" and "INIT" code blocks are not executed
>>inside a string eval
>
> den ich so verstanden habe, dass innerhalb von string-evals()
> manche Dinge - welche, geht eben aus dem Text nicht hervor -
> anders ablaufen als außerhalb davon.

In dem Text steht nicht "manche Dinge", sondern dass CHECK- und
INIT-Blöcke nicht ausgeführt werden. Das erscheint mir auch
logisch, so wie sie definiert sind. Zum Zeitpunkt eines
String-Eval ist die Phase, in der sie ausgeführt werden
sollten, nämlich längst vorbei. Siehe Definition.

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: perlmod ber BEGIN-Blcke

Ferry Bolhar wrote:
>
> BEGIN-Blöcke sind aber erlaubt und werden nicht ignoriert?
> Das passt doch nicht zusammen.

Lies Dir mal ganz gründlich die Definitionen durch.

> Jetzt verstehe ich gar nichts mehr.

Das ist schade ;-)

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: perlmod ber BEGIN-Blcke

On 2007-07-12 15:02, Ferry Bolhar wrote:
> Peter J. Holzer:
>>> Meine Frage: was ist damit gemeint? Wo kann im Zusammenhang mit
>>> mod_perl ein Problem liegen?
>>
>> mod_perl verwendet vermutlich String-evals um Code-Blcke zu
>> compilieren (mir fllt auch gar keine andere Methode ein, wie das zur
>> Laufzeit gehen sollte). Das heit aber, dass Code, der in einer
>> mod_perl-Umgebung ausgefhrt werden soll, keine CHECK und INIT Blcke
>> enthalten darf, weil die einfach ignoriert werden:
>
> BEGIN-Blcke sind aber erlaubt und werden nicht ignoriert?

Ja. Die braucht man auch.


> Das passt doch nicht zusammen.

Stimmt, das war von mir schlampig formuliert. Der Satz in perlmod ist
klarer:

| The "CHECK" and "INIT" code blocks are not executed *inside*
| a string eval

(Hervorhebung von mir). CHECK und INIT-Blocks werden genauso wie
END-Blocks gesammelt und in der entsprechenden Phase des Programmablaufs
durchgeführt. Also nicht *im* String-Eval, sondern am Ende der
Compile-Phase, am Anfang der Execution-Phase bzw. am Ende des Programms.
Das ist vollkommen konsistent.

Nur werden String-Evals (wenn sie nicht gerade in einem BEGIN-Block
vorkommen, wie in Deinem Beispiel unten) normalerweise erst während der
Execution-Phase ausgeführt, und da ist es zu spät für CHECK und
INIT-Blocks.

>> my $code = < >> BEGIN { print "in BEGIN\n" }
>> CHECK { print "in CHECK\n" }
>> INIT { print "in INIT\n" }
>> print "in body\n";
>> 1;
>> EOF
>>
>> eval $code;
>
> Setzt man diesen Code als Ganzes nochmals in einen
> BEGIN-Block, so erhlt man:
>
> in BEGIN
> in body
> in CHECK
> in INIT

Ah, exzellentes Beispiel. Danke.


> Hier wird also der Body-Code _VOR_ den CHECK und INIT-
> Blcken abgearbeitet? Jetzt verstehe ich gar nichts mehr.

Die Reihenfolge ist doch in dem von Dir zitierten Kapitel von perlmod
beschrieben:

| A "BEGIN" code block is executed as soon as possible, that is, the
| moment it is completely defined, even before the rest of the containing
| file (or string) is parsed.
[...]
| "CHECK" code blocks are run just after the initial Perl compile phase
| ends and before the run time begins, in LIFO order.
[...]
| "INIT" blocks are run just before the Perl runtime begins execution, in
| "first in, first out" (FIFO) order.

Da Du das ganze in einen BEGIN-Block gegeben hast, wird es ausgeführt,
sobald der Parser die abschließende } des Blocks erreicht hat. Das
eval $code parsed, compiliert und interpretiert den Code innerhalb von
$code. Dabei findet es zunächst einen BEGIN-Block, der wird sofort
ausgeführt. Dann findet es einen CHECK-Block. Da das Ende der "initial
Perl compile phase" noch nicht erreicht ist, wird dieser Block auf den
Stack von CHECK-Blöcken geworfen. Dann findet es einen INIT-Block, der
kommt in die Queue der INIT-Blöcke. dann kommt "normaler" Code, der wird
compiliert und schließlich ausgeführt, nachdem $code vollständig
compiliert wurde.

Nach dem äußeren BEGIN-Block ist auch das Ende des Files erreicht. Somit
endet jetzt die "initial Perl compile phase", und es werden die CHECK-
und INIT-Blöcke abgearbeitet und danach mit der "normalen" Exekution
begonnen.

>> > Und worin liegt der Unterschied, ob jetzt ein Block innerhalb von
>> > string-evals()ausgefhrt wird, oder nicht?
>>
>> Code der ausgefhrt wird, tut was. Code der nicht ausgefhrt wird tut
>> nichts. Was sonst sollte der Unterschied sein? Ich verstehe Deine Frage
>> nicht.
>
> Ich habe die Frage scheinbar ungenau gestellt. Worin liegt der
> Unterschied, ob Code innerhalb von string-evals() ausgefhrt
> wird, oder auerhalb davon bzw. in block-evals()? Abgesehen
> vom Compilierzeitpunkt sollte doch zwischen den beiden eval-
> Formen kein Unterschied sein.

Block-evals sind ganz etwas anderes als String-evals und haben mit der
Frage hier überhaupt nichts zu tun.

Der Unterschied zwischen einem CHECK-Block in einem Perl-Script und in
einem String-eval ist eben gerade der Compilierzeitpunkt.


> Meine Frage bezog sich eben auf den zitierten Text:
>
> 'It should be noted that "BEGIN" code blocks are executed inside string
>> "eval()"'s. The "CHECK" and "INIT" code blocks are not executed
>> inside a string eval
>
> den ich so verstanden habe, dass innerhalb von string-evals()
> manche Dinge - welche, geht eben aus dem Text nicht hervor -
> anders ablaufen als auerhalb davon.

Mir scheint, es hier ziemlich genau beschrieben, wie sich BEGIN, CHECK,
INIT (und END einen Absatz weiter unten) verhalten. Ob es noch
irgendwelche anderen Unterschiede gibt, steht hier nicht, aber das
Kapitel heißt auch "BEGIN, CHECK, INIT and END" und nicht "String eval",
also würde ich das hier auch nicht erwarten.

hp

--
_ | Peter J. Holzer | I know I'd be respectful of a pirate
|_|_) | Sysadmin WSR | with an emu on his shoulder.
| | | hjp@hjp.at |
__/ | http://www.hjp.at/ | -- Sam in "Freefall"

Re: perlmod ber BEGIN-Blcke

Peter J. Holzer:

> Da Du das ganze in einen BEGIN-Block gegeben hast, wird es ausgeführt,
> sobald der Parser die abschließende } des Blocks erreicht hat. Das
> eval $code parsed, compiliert und interpretiert den Code innerhalb von
> $code. Dabei findet es zunächst einen BEGIN-Block, der wird sofort
> ausgeführt. Dann findet es einen CHECK-Block. Da das Ende der "initial
> Perl compile phase" noch nicht erreicht ist, wird dieser Block auf den
> Stack von CHECK-Blöcken geworfen. Dann findet es einen INIT-Block, der
> kommt in die Queue der INIT-Blöcke. dann kommt "normaler" Code, der wird
> compiliert und schließlich ausgeführt, nachdem $code vollständig
> compiliert wurde.
>
> Nach dem äußeren BEGIN-Block ist auch das Ende des Files erreicht. Somit
> endet jetzt die "initial Perl compile phase", und es werden die CHECK-
> und INIT-Blöcke abgearbeitet und danach mit der "normalen" Exekution
> begonnen.

Ich danke dir für diese Erklärung. Mein Miß- bzw. Unverständnis dürfte
sich vom Begriff "Initial Compiler Phase" ableiten. Ich hätte vermutet, dass
in Code:

BEGIN {
eval "BEGIN {...}; CHECK{...}; INIT{...}; print 'Hallo'";
}

das äußere BEGIN als Einheit angesehen und daher die Reihenfolge
der Abarbeitung von BEGIN/CHECK/INIT _innerhalb_ des BEGINS
genauso abläuft wie in Hauptcode.

Da es aber natürlich nur jeweils _einen_ globalen Stack für CHECK
und INIT-Blöcke (intern sind's eigentlich Arrays, deren Elemente die
jeweiligen Codewerte enthalten; sie heißen PL_checkav und PL_initav.
Es gibt übrigens auch ein PL_beginav Array, wozu eigentlich)? gibt, ist
diese Annahme falsch. Der Stack für CHECK bzw. für INIT-Blöcke
wird natürlich nur einmal abgearbeitet, und zwar dann, wenn im
_gesamten_ Programm der jeweilige Zeitpunkt erreicht ist, im Falle
von CHECK daher dann, wenn der _gesamte_ Programmcode
fertig kompiliert wurde; bei INIT dann, wenn die Laufzeitphase des
gesamten Programms beginnt (d.h., wenn intern perl_run() aufgerufen
wird).

Aus diesen Überlegungen heraus wird jetzt auch die mit

eval "CHECK {...}" bzw. eval {"INIT {...}"

ausgebene "Too late to run..." Meldung klar - die beiden Arrays
sind zu diesem Zeitpunkt längst abgearbeitet; es macht keinen
Sinn mehr, neue Blöcke darin aufzunehmen. BEGIN-Blöcke
hingegen, die ja sofort nach dem Kompilieren loslaufen und erst
gar nicht in das entsprechende Array aufgenommen werden
(obwohl es, wie gesagt, auch ein PL_beginav Array gibt),
können auch in einem String-eval noch loslaufen.

Immer noch nicht ganz klar ist mir, wieso die Tatsache, dass
CHECK- und INIT-Blöcke nicht in string-evals()'s ablaufen,
in mod_perl ein Problem darstellt. Ich glaube nämlich, dass
diese Aussage nicht stimmt - das dürfte wohl das "Problem"
sein. Das Nachladen des Codes kann man sich ja eigentlich
als ein globales String-eval() vorstellen. Wenn z.B. mod_perl
die Datei mein_modul.pm nachladen soll, wird - in etwa -
Folgendes ablaufen:

{
local $/;
open my $fh,'mein_modul.pm';
my $code = <$fh>;
close $fh;
eval $code;
write_to_errorlog($@) if $@;
}

d.h., auch hier läuft ein String-eval ab. Nehmen wir an,
dass $code nun einen CHECK oder INIT-Block enthält,
dann passiert eben genau das weiter oben Beschriebene.
Daher verstehe ich, wieso die Tatsache, dass CHECK und
INIT-Blöcke nicht in string-evals() ablaufen, für mod_perl
ein Problem ist - sie laufen sehr wohl in string-evals() ab!
Oder steckt hier auch noch der Wurn drin?

Übrigens noch eine Frage: da BEGIN-Blöcke sofort nach
dem Kompilieren loslaufen: kann ich den kompilierten Codetree
hinterher nicht mehr ansprechen (zB. mit dem B-Modul)?
Oder könnte das der Zweck von PL_beginav sein - das
Aufnehmen des Codes, damit der Codetree im Nachhinein
ansprechbar bleibt?

Nochmals vielen Dank für deine Erklärung!

LG, Ferry

--
Ing Ferry Bolhar
Magistrat der Stadt Wien - MA 14
A-1010 Wien
E-Mail: bol@adv.magwien.gv.at

Re: perlmod ber BEGIN-Blcke

On 2007-07-13 07:00, Ferry Bolhar wrote:
> Immer noch nicht ganz klar ist mir, wieso die Tatsache, dass
> CHECK- und INIT-Blcke nicht in string-evals()'s ablaufen,
> in mod_perl ein Problem darstellt. Ich glaube nmlich, dass
> diese Aussage nicht stimmt - das drfte wohl das "Problem"
> sein. Das Nachladen des Codes kann man sich ja eigentlich
> als ein globales String-eval() vorstellen. Wenn z.B. mod_perl
> die Datei mein_modul.pm nachladen soll, wird - in etwa -
> Folgendes ablaufen:
>
> {
> local $/;
> open my $fh,'mein_modul.pm';
> my $code = <$fh>;
> close $fh;
> eval $code;
> write_to_errorlog($@) if $@;
> }
>
> d.h., auch hier luft ein String-eval ab. Nehmen wir an,
> dass $code nun einen CHECK oder INIT-Block enthlt,
> dann passiert eben genau das weiter oben Beschriebene.
> Daher verstehe ich, wieso die Tatsache, dass CHECK und
> INIT-Blcke nicht in string-evals() ablaufen, fr mod_perl
> ein Problem ist

Also was jetzt? Verstehst Du es, oder verstehst Du es nicht?

> - sie laufen sehr wohl in string-evals() ab!

Obiger Code-Block wird zur Laufzeit abgearbeitet, da ist es für CHECK-
und INIT-Blöcke zu spät. Der einzige Effekt wird eine "Too late to run
...."-Meldung im errorlog sein. Ein Modul, das aus irgendeinem Grund wichtigen
Initialisierungscode in einem CHECK- oder INIT-Block hat, wird daher mit
mod_perl nicht korrekt funktionieren (wenn ich die mod_perl2 Doku
richtig verstehe, kann man solche Module aber mit PerlModule oder
PerlLoadModule laden).

hp


--
_ | Peter J. Holzer | I know I'd be respectful of a pirate
|_|_) | Sysadmin WSR | with an emu on his shoulder.
| | | hjp@hjp.at |
__/ | http://www.hjp.at/ | -- Sam in "Freefall"

Re: perlmod ber BEGIN-Blcke

Peter J. Holzer:

> > Daher verstehe ich, wieso die Tatsache, dass CHECK und
> > INIT-Blcke nicht in string-evals() ablaufen, fr mod_perl
> > ein Problem ist
>
> Also was jetzt? Verstehst Du es, oder verstehst Du es nicht?

Entschuldige - ich meinte natürlich, ich verstehe es NICHT.

Ich vermute, der Text ist unglücklich formuliert. Nach dem heute
Gesagtem ist klar, dass Code, der im Nachhinein - also zur Laufzeit,
sei es jetzt durch String-evals() oder durch do/require - zugeladen
und kompiliert wird, keine CHECK und INIT-Blöcke enthalten
kann (es wird die "Too late" Meldung" ausgegeben). Die in perlmod
getroffene Aussage

"The "CHECK" and "INIT" code blocks are not executed inside a
string eval, which e.g. can be a problem in a mod_perl environment"

halte ich daher nach dem heute Gesagten für falsch bzw. ungenau
formuliert. Aber das wäre ja nicht das erste mal, dass so etwas
in der perl-Doku vorkommt.

> Ein Modul, das aus irgendeinem Grund wichtigen
> Initialisierungscode in einem CHECK- oder INIT-Block hat, wird daher mit
> mod_perl nicht korrekt funktionieren (wenn ich die mod_perl2 Doku
> richtig verstehe, kann man solche Module aber mit PerlModule oder
> PerlLoadModule laden).

Wo hast du das in der mod_perl2 Doku gelesen (dass Module mit
CHECK- und INIT-Blocks mittels Perl[Load]Module korrekt
geladen werden können)?

LG, Ferry

--
Ing Ferry Bolhar
Magistrat der Stadt Wien - MA 14
A-1010 Wien
E-Mail: bol@adv.magwien.gv.at

Re: perlmod ber BEGIN-Blcke

On 2007-07-13 15:52, Ferry Bolhar wrote:
> Peter J. Holzer:
>
> "The "CHECK" and "INIT" code blocks are not executed inside a
> string eval, which e.g. can be a problem in a mod_perl environment"
>
> halte ich daher nach dem heute Gesagten fr falsch bzw. ungenau
> formuliert.

Ungenau formuliert, ja. Dass man den Satz so auslegen kann, dass er der
Realität entspricht, habe ich ja schon in einem früheren Posting
gezeigt, aber auf die Auslegung kommt man wohl erst, wenn man schon
weiß, wie es funktioniert.

>> Ein Modul, das aus irgendeinem Grund wichtigen Initialisierungscode
>> in einem CHECK- oder INIT-Block hat, wird daher mit mod_perl nicht
>> korrekt funktionieren (wenn ich die mod_perl2 Doku richtig verstehe,
>> kann man solche Module aber mit PerlModule oder PerlLoadModule
>> laden).
>
> Wo hast du das in der mod_perl2 Doku gelesen (dass Module mit
> CHECK- und INIT-Blocks mittels Perl[Load]Module korrekt
> geladen werden knnen)?

Aus diversen Stücken zusammengereimt. Es wird explizit darauf
hingewiesen, dass CHECK- und INIT-Blocks nur beim Start des Interpreters
ausgeführt werden. Perl[Load]Module Direktiven stehen in der
Apache-Config, stehen also beim Start des Interpreters bereits zur
Verfügung. Der Rest ist wilde Spekulation.

hp


--
_ | Peter J. Holzer | I know I'd be respectful of a pirate
|_|_) | Sysadmin WSR | with an emu on his shoulder.
| | | hjp@hjp.at |
__/ | http://www.hjp.at/ | -- Sam in "Freefall"

Re: perlmod ber BEGIN-Blcke

Peter J. Holzer wrote:
> On 2007-07-13 15:52, Ferry Bolhar wrote:
>>Peter J. Holzer:
>>
>>"The "CHECK" and "INIT" code blocks are not executed inside a
>>string eval, [...]
>>
>>halte ich daher nach dem heute Gesagten fr falsch bzw. ungenau
>>formuliert.
>
> Ungenau formuliert, ja. Dass man den Satz so auslegen kann, dass er der
> Realität entspricht, habe ich ja schon in einem früheren Posting
> gezeigt, aber auf die Auslegung kommt man wohl erst, wenn man schon
> weiß, wie es funktioniert.

In voller Allgemeinheit genommmen, ist obiger Satz nicht nur ungenau,
sondern falsch, denn für String-Evals innerhalb von BEGIN-Blöcken
trifft er nicht zu. Mit dem Konstrukt String-Eval hat die Geschichte
im Grunde nichts zu tun, sondern mit dem Zeitpunkt der Kompilierung
des betreffenden Code, der ja auch bei anderen Konstrukten
zu beachten ist, wo CHECK und INIT ggf. ebenfalls wirkungslos sind.

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: perlmod ber BEGIN-Blcke

On 2007-07-13 19:10, Frank Seitz wrote:
> Peter J. Holzer wrote:
>> On 2007-07-13 15:52, Ferry Bolhar wrote:
>>>"The "CHECK" and "INIT" code blocks are not executed inside a
>>>string eval, [...]
>>>
>>>halte ich daher nach dem heute Gesagten fr falsch bzw. ungenau
>>>formuliert.
>>
>> Ungenau formuliert, ja. Dass man den Satz so auslegen kann, dass er der
>> Realität entspricht, habe ich ja schon in einem früheren Posting
>> gezeigt, aber auf die Auslegung kommt man wohl erst, wenn man schon
>> weiß, wie es funktioniert.
>
> In voller Allgemeinheit genommmen, ist obiger Satz nicht nur ungenau,
> sondern falsch, denn für String-Evals innerhalb von BEGIN-Blöcken
> trifft er nicht zu.

Doch, er trifft auch auf die zu. Auch hier wird nämlich der CHECK- oder
INIT-Block nicht *im* String-eval ausgeführt, sondern aufgehoben und
nach der Compile-Phase ausgeführt.

Vergleiche dazu die Erklärung zum END-Block:

| Note that "END" code blocks are not executed at the end of a
| string "eval()":

Allerdings wird hier nicht nur gesagt, wo sie nicht ausgeführt werden,
sondern auch, wo sie ausgeführt werden:

| if any "END" code blocks are created in a string "eval()",
| they will be executed just as any other "END" code block of that
| package in LIFO order just before the interpreter is being
| exited.

was das ganze doch sehr viel verständlicher macht. Ein solcher Zusatz
fehlt bei CHECK und INIT.

hp

--
_ | Peter J. Holzer | I know I'd be respectful of a pirate
|_|_) | Sysadmin WSR | with an emu on his shoulder.
| | | hjp@hjp.at |
__/ | http://www.hjp.at/ | -- Sam in "Freefall"

Re: perlmod ber BEGIN-Blcke

Peter J. Holzer wrote:
> On 2007-07-13 19:10, Frank Seitz wrote:

>>>>"The "CHECK" and "INIT" code blocks are not executed inside a
>>>>string eval, [...]
>>
>>In voller Allgemeinheit genommmen, ist obiger Satz nicht nur ungenau,
>>sondern falsch, denn für String-Evals innerhalb von BEGIN-Blöcken
>>trifft er nicht zu.
>
> Doch, er trifft auch auf die zu. Auch hier wird nämlich der CHECK- oder
> INIT-Block nicht *im* String-eval ausgeführt, sondern aufgehoben und
> nach der Compile-Phase ausgeführt.

Ja, das ist ja offenbar grundsätzlich so, das hat mit dem String-Eval ja
nichts zu tun. CHECK und INIT beziehen sich auf das Hauptprogramm,
egal wo sie vorkommen.

Wenn mit dem "inside" gemeint sein soll (was ich nicht so
verstehe), dass CHECK und INIT im String-Eval sich nicht auf den
Übergang Compile->Ausführungsphase des Eval-Code beziehen (was
man durchaus annehmen kann, wenn man die Definition nicht
exakt kennt), hätte man das meines Erachtens noch ganz anders
ausdrücken müssen.

> Vergleiche dazu die Erklärung zum END-Block:
>
> | Note that "END" code blocks are not executed at the end of a
> | string "eval()":
>
> Allerdings wird hier nicht nur gesagt, wo sie nicht ausgeführt werden,
> sondern auch, wo sie ausgeführt werden:
>
> | if any "END" code blocks are created in a string "eval()",
> | they will be executed just as any other "END" code block of that
> | package in LIFO order just before the interpreter is being
> | exited.
>
> was das ganze doch sehr viel verständlicher macht. Ein solcher Zusatz
> fehlt bei CHECK und INIT.

Der direkte Bezug zum Sting-Eval ist nicht da, sonst finde
ich die Definition darunter okay. Zumindest habe ich sie nach einmaligem
Lesen verstanden. Hoffentlich richtig, CHECK und INIT habe ich
selbst noch nie genutzt.

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel