eperl - Online in de Cloud

PROGRAMMA:

NAAM

ePerl - Ingebedde Perl 5-taal

VERSIE

@V@

KORTE INHOUD

eperl [-d naam=waarde] [-D naam=waarde] [-B begin_delimiter] [-E eind_scheidingsteken] [-i] [-m
mode] [-o uitvoerbestand] [-k] [-I directory] [-P] [-C] [-L] [-x] [-T] [-w] [-c] [Invoer bestand]

eperl [-r] [-l] [-v] [-V]

PRODUCTBESCHRIJVING

Abstract
ePerl interpreteert een ASCII-bestand vol Perl 5-programma-instructies door de
Perl 5-code tijdens het doorgeven van de gewone ASCII-gegevens. Dit kan op verschillende manieren:
een stand-alone Unix-filter of geïntegreerde Perl 5-module voor algemene bestandsgeneratietaken
en als een krachtige webserver-scripttaal voor dynamische HTML-paginaprogrammering.

Introductie
De eperl programma is de Embedded Perl 5 Taal tolk. Dit is echt een volwaardige
aanbevolen Perl 5-interpreter, maar met een andere aanroepomgeving en bronbestand
lay-out dan de standaard Perl-interpreter (meestal het uitvoerbare bestand perl or perl5 op de meeste
systemen). Het is ontworpen voor algemene ASCII-bestandsgeneratie met de filosofie van
inbedding de Perl 5-programmacode in de ASCII-gegevens in plaats van de gebruikelijke manier waarop u
de ASCII-gegevens in een Perl 5-programma insluiten (meestal door de gegevens te citeren en ze te gebruiken via
"print" statements). Dus in plaats van een eenvoudig Perl-script te schrijven zoals

#!/pad/naar/perl
print "foo bar\n";
print "baz quux\n";
voor ($i = 0; $i < 10; $i++) { print "foo #${i}\n"; }
print "foo bar\n";
print "baz quux\n";

Je kunt het nu schrijven als een ePerl-script:

#!/pad/naar/eperl
foo-bar
baz quux
<: voor ($i = 0; $i < 10; $i++) { print "foo #${i}\n"; } :>
foo-bar
baz quux

Hoewel de ePerl-variant een andere bronbestandsindeling heeft, is de semantiek hetzelfde,
dat wil zeggen dat beide scripts exact dezelfde resulterende gegevens op "STDOUT" creëren.

Bedoeling
ePerl is simpelweg een lijmcode die de programmeerkracht van de Perl 5-interpreter combineert
bibliotheek met een lastige embeddingtechniek. De embeddingtruc is deze: het converteert de
bronbestand in een geldig Perl-script dat vervolgens geheel beoordeeld door slechts één
interne instantie van de Perl 5-interpreter. Om dit te bereiken, vertaalt ePerl alle platte tekst.
code in (ontsnapte) Perl 5 strings geplaatst in print constructies terwijl ze door alle
ingebedde native Perl 5-code. Zoals u kunt zien, doet ePerl zelf precies hetzelfde.
intern wat een domme programmeur moest doen bij het schrijven van een eenvoudig Perl-generatiescript.

Vanwege de aard van dergelijke code met borstelige randen is ePerl echt de betere poging als het gaat om
Gegenereerde ASCII-gegevens bevatten eigenlijk meer statische dan dynamische gegevens. Of met andere woorden: Gebruik
ePerl if helpen willen naar houden the meest of the gegenereerde ASCII gegevens in vlakte formaat en voor slechts
programmering sommige haren stuff. Gebruik het niet bij het genereren van puur dynamische gegevens.
levert geen voordeel op voor de gewone programmacode van een eenvoudig Perl-script. Dus de statische
Het aandeel moet minimaal 60% zijn, anders wordt het voordeel een nadeel.

ePerl is oorspronkelijk ontworpen voor een extreme situatie: als webserver
scripttaal voor het direct genereren van HTML-pagina's. Hier ziet u het typische geval.
dat doorgaans 90% van de gegevens bestaat uit pure statische HTML-tags en gewone ASCII, terwijl
De resterende 10% zijn programmeerconstructies die dynamisch meer markup-code genereren.
Dit is de reden waarom ePerl naast de standaard Unix-filtering ook de runtime-modus ondersteunt
de CGI/1.1- en NPH-CGI/1.1-interfaces.

Embedded Perl Syntaxis
In de praktijk kun je alle geldige Perl-constructies in de ePerl-blokken plaatsen die Perl 5 gebruiken
De tolkenbibliotheek kan evalueren. Maar er zijn een paar belangrijke punten waar u altijd rekening mee moet houden.
onthoud en vergeet nooit bij het gebruik van ePerl:

1. delimiters zijn altijd weggegooid.
Triviaal om te zeggen, maar het moet minstens één keer genoemd worden. De ePerl-blokscheidingstekens
worden altijd weggegooid en zijn alleen nodig zodat ePerl de ingebedde Perl herkent
constructies. Ze worden nooit doorgegeven aan de uiteindelijke uitvoer.

2. Vernieuwd content heeft naar go naar "STDOUT".
Hoewel u subroutines kunt definiëren, bepaalde gegevens kunt berekenen, enz. binnen ePerl-blokken
Alleen gegevens die expliciet naar de "STDOUT"-bestandshandle zijn geschreven, worden uitgevouwen. In andere
woorden: Wanneer een ePerl-blok geen inhoud genereert op "STDOUT", is het volledig
vervangen door een lege string in de uiteindelijke uitvoer. Maar wanneer de inhoud wordt gegenereerd, wordt deze
Plaats de inhoud op de plaats van het ePerl-blok in de uiteindelijke uitvoer. Meestal wordt de inhoud gegenereerd.
via pure "print"-constructies die impliciet "STDOUT" gebruiken als er geen filehandle is opgegeven.

3. Vernieuwd content on "STDERR" altijd leidt naar an fout.
Wanneer er inhoud wordt gegenereerd op de "STDERR"-bestandshandle, geeft ePerl een foutmelding weer
(inclusief de STDERR-inhoud). Gebruik dit om bij fouten af ​​te sluiten terwijl fouten worden doorgegeven van
ePerl blokkeert de aanroepende omgeving.

4. Achternaam* puntkomma.
Vanwege het volgende punt 6 (zie hieronder) en het feit dat de meeste gebruikers niet
Houd rekening met de interne ePerl-blokvertalingen, ePerl is slim met het laatste
puntkomma. Normaal gesproken moet elk ePerl-blok eindigen met de puntkomma van het laatste
opdracht.

<:cmd; ...; cmd; :>

Maar als de laatste puntkomma ontbreekt, wordt deze automatisch door ePerl toegevoegd, d.w.z.

<:cmd; ...; cmd :>

is ook de juiste syntaxis. Maar soms is het nodig om ePerl te forceren niet om de. toe te voegen
puntkomma. Vervolgens kunt u een ``"_"'' (onderstrepingsteken) toevoegen als laatste niet-spatie
teken in het blok om ePerl te dwingen de laatste puntkomma te laten staan. Gebruik dit voor
constructies zoals de volgende

<: als (...) { _:>
foo
<: } anders { _:>
bars
<: } :>

waar u een Perl-richtlijn over meerdere ePerl-blokken wilt verspreiden.

5. steno voor alleen "afdrukken" blokken.
Omdat ePerl meestal alleen wordt gebruikt om variabelen te interpoleren, bijvoorbeeld

<: print $VARIABELE; :>

Het is handig om een ​​snelkoppeling te bieden voor dit soort constructies. Zo biedt ePerl een
Snelkoppeling via het teken '='. Wanneer het direct wordt uitgevoerd (geen spaties toegestaan)
volgt de begin-delimiter van een ePerl-blok, een "print"-statement is impliciet
gegenereerd, dwz het bovenstaande blok is equivalent aan

<:=$VARIABELE:>

Let op dat de puntkomma hier ook is verwijderd, omdat deze automatisch wordt toegevoegd
(zie hierboven).

6. Speciaal Einde van de regel afdanken commando voor ePerl blokken.
ePerl biedt een speciale verwijderopdracht met de naam ``"//"'' die alle gegevens tot en met
en inclusief het volgende nieuwe regelteken wanneer het direct gevolgd wordt door een eindblok
scheidingsteken. Meestal als je schrijft

foo
<: $x = 1; :>
Quux

het resultaat is

foo

Quux

omdat ePerl altijd code rond ePerl-blokken bewaart, zelfs alleen nieuwe regels. Maar wanneer
jij schrijft

foo
<: $x = 1; :>//
Quux

het resultaat is

foo
Quux

omdat de ``"//"'' alle dingen tot het einde van de regel verwijderde, waaronder de nieuwe regel.

7. Beperkingen in ontleden.
Elk programma heeft zijn beperkingen, ePerl ook. Het nadeel is dat Perl niet alleen een
rijke taal, het is een vreselijke taal volgens de interpretatie ervan. Misschien jij
ken de uitdrukking ,,Alleen perl kan parsen Perl''Denk er eens over na. De implicatie hiervan
is dat ePerl nooit zelf probeert de ePerl-blokken te parseren. Het is volledig afhankelijk van de
Perl-interpreterbibliotheek, omdat dit de enige instantie is die dit kan doen zonder
fouten. Maar het probleem is dat ePerl op zijn minst het begin en einde moet herkennen
posities van die ePerl-blokken.

Er zijn twee manieren: Het kan tijdens het parsen naar het eindscheidingsteken zoeken, maar
herkennen op zijn minst aanhalingstekens (waarbij het eindscheidingsteken als pure data wordt behandeld). Of
het kan gewoon doorgaan naar de volgende eindafbakening en zeggen dat het niet is voorgekomen
binnen Perl-constructies. In ePerl 2.0 werd de tweede gebruikt, terwijl in ePerl 2.1 de
de eerste is genomen omdat veel gebruikers het op deze manier wilden terwijl ze bad end gebruikten
scheidingstekens zoals ``">"''. Maar eigenlijk heeft de auteur zijn mening opnieuw herzien en
besloten uiteindelijk de tweede aanpak te gebruiken die nu al sinds ePerl 2.2 wordt gebruikt. Omdat
terwijl de eerste meer triviale afbakeningen toestaat (wat op zichzelf niet echt een goede manier is)
idee) mislukt het wanneer constructies zoals ``"m|"[^"]+"|"'' etc. worden gebruikt binnen ePerl
blokken. En het is gemakkelijker om eindafbakeningen binnen Perl-constructies te ontsnappen (bijvoorbeeld
via backslashes in aanhalingstekens) dan complexe Perl-constructies herschrijven om zelfs
aantal citaten.

Dus wanneer uw eindafbakening ook voorkomt in Perl-constructies, moet u escapen
het op welke manier dan ook.

8. HTML entiteit conversie.
Omdat ePerl onder andere wordt gebruikt als server-side scripttaal voor HTML-pagina's,
Er is een veelvoorkomend probleem met HTML-editors: ze kunnen ePerl niet herkennen.
blokken, dus wanneer u die blokken in de editors invoert, coderen ze meestal een aantal
tekens met de bijbehorende HTML-entiteiten. Het probleem is dat deze codering
leidt tot ongeldige Perl-code. ePerl biedt de mogelijkheid -C voor het decoderen van deze entiteiten
die automatisch wordt ingeschakeld in CGI-modi. Zie de beschrijving hieronder onder optie -C
voor meer details.

Runtime Modes
ePerl kan in drie verschillende runtime-modi werken:

Stand-alone Unix filter mode
Dit is de standaardwerkingsmodus wanneer het wordt gebruikt als generatietool vanuit de Unix-shell
of als batchverwerkingstool vanuit andere programma's of scripts:

$ eperl [opties] - <invoerbestand> uitvoerbestand
$ eperl [opties] invoerbestand > uitvoerbestand
$ eperl [opties] -o outputfile - < inputfile
$ eperl [opties] -o outputfile inputfile

Zoals u kunt zien, kan ePerl in elke combinatie van STDIO en externe bestanden worden gebruikt.
Daarnaast zijn er twee interessante varianten van deze modus. Ten eerste kun je
ePerl in combinatie met Unix Keet magische techniek om het impliciet te selecteren als
de interpreter voor uw script, vergelijkbaar met de manier waarop u gewend bent van de gewone Perl
tolk:

#!/pad/naar/eperl [opties]
foo
<: print "balk"; :>
Quux

Ten tweede kunt u ePerl gebruiken in combinatie met de Bourne-Shell Here Document techniek
vanuit je shell scripts:

#!/ Bin / sh
...
eperl [opties] - <
foo
<: print "quux"; :>
Quux
EOS
...

Als u shell- of andere scripts met ePerl moet genereren, hebt u een shebang nodig
regel in de uitvoer van eperl, moet je een shebang-regel toevoegen die bijvoorbeeld bevat
"#!/usr/bin/eperl" eerst, omdat eperl de eerste regel uit de invoer zal verwijderen als het
is een shebang-regel. Voorbeeld:

#!/usr/bin/eperl
#!/ Bin / sh
echo <: print "quux"; :>

resulteert in de volgende uitvoer:

#!/ Bin / sh
echo quux

U kunt er ook voor kiezen om een ​​preprocessoropmerking aan de eerste regel toe te voegen, bijvoorbeeld zoals deze:

#c Dit is een opmerking om de shebang-regel in de volgende regel te behouden
#!/ Bin / sh
echo <: print "quux"; :>

En ten slotte kunt u ePerl rechtstreeks vanuit Perl-programma's gebruiken door gebruik te maken van de
Parsen::ePerl(3) pakket (ervan uitgaande dat u dit ook hebt geïnstalleerd; zie bestand INSTALL
(zie de ePerl-distributie voor meer details):

#!/pad/naar/perl
...
gebruik Parse::ePerl;
...
$script = <
foo
<: print "quux"; :>
Quux
EOT
...
$resultaat = Parse::ePerl::Expand({
Script => $script,
Resultaat => \$resultaat,
});
...
print $resultaat;
...

Bekijk Parsen::ePerl(3) voor meer details.

CGI / 1.1 compliant interface mode
Dit is de runtime-modus waarbij ePerl de CGI/1.1-interface van een webserver gebruikt wanneer
gebruikt als een Server-kant Scripting Taal op het web. ePerl gaat in deze modus
automatisch wanneer de CGI/1.1-omgevingsvariabele "PATH_TRANSLATED" is ingesteld en de
of de scriptsbestandsnaam doet niet beginnen met het NPH-voorvoegsel ``nph-''. In deze runtime
modus voegt het de resulterende gegevens toe als voorvoegsel HTTP/1.0 (standaard) of HTTP/1.1 (indien geïdentificeerd)
door de webserver) compatibele antwoordheaderregels.

ePerl herkent ook HTTP-headerregels aan het begin van de gegenereerde scripts
gegevens, u kunt bijvoorbeeld uw eigen HTTP-headers genereren zoals

<? $url = "..";
print "Locatie: $url\n";
afdrukken "URI: $url\n\n"; !>

...

Maar houd er rekening mee dat u weliswaar willekeurige headers kunt uitgeven, maar dat de meeste webservers de
headers die worden geaccepteerd via de CGI/1.1-interface. Meestal kunt u alleen een
een paar specifieke HTTP-headers zoals "Locatie" of "Status". Als u meer controle nodig heeft,
moet u de NPH-CGI/1.1-interfacemodus gebruiken.

Bovendien biedt ePerl in deze modus een nuttige functie: het kan zijn UID/GID wisselen
aan de eigenaar van het script als het als Unix draait SetUID programma (zie hieronder onder
Veiligheid en de optie ``u+s'' van chmod(1)).

Er zijn twee algemeen bekende manieren om deze CGI/1.1-interfacemodus op het web te gebruiken.
Ten eerste kunt u het gebruiken om expliciet gewone HTML-bestanden om te zetten in CGI/1.1-scripts
via de Keet techniek (zie hierboven). Voor een Apache webserver zet je gewoon het volgende
regel als de eerste regel van het bestand:

#!/pad/naar/eperl -mc

Hernoem vervolgens het script van bestand.html naar bestand.cgi en stel de uitvoeringsbit in via

$ mv-bestand.html-bestand.cgi
$ chmod a+rx bestand.cgi

Zorg er nu voor dat Apache het accepteert bestand.cgi als een CGI-programma door CGI-ondersteuning mogelijk te maken
voor de directory waar bestand.cgi woont. Voeg hiervoor de regel toe

Opties +ExecCGI

aan de .htaccess bestand in deze map. Controleer ten slotte of Apache echt
herkent de extensie .cgiMisschien moet je ook de volgende regel toevoegen
aan jouw httpd.conf file:

AddHandler cgi-script .cgi

Nu kunt u gebruiken bestand.cgi in plaats van bestand.html en profiteer van het behaalde resultaat
programmeervermogen door borstelen bestand.cgi met je Perl-blokken (of de
(omzetting naar een CGI-script zou nutteloos zijn).

Als alternatief (of zelfs aanvullend) kan een webmaster ePerl-ondersteuning inschakelen op een meer
naadloze manier door ePerl te configureren als een echte impliciete server-side scriptingtaal.
Dit wordt gedaan door een MIME-type toe te wijzen aan de verschillende geldige ePerl-bestandsextensies en
het forceren van alle bestanden met dit MIME-type om intern verwerkt te worden via ePerl
interpreter. U kunt dit voor Apache bereiken door het volgende toe te voegen aan uw
httpd.conf filet

AddType-toepassing/x-httpd-eperl .phtml .eperl .epl
Actie application/x-httpd-eperl /internal/cgi/eperl
ScriptAlias ​​/internal/cgi /pad/naar/apache/cgi-bin

en een kopie maken van de eperl programma in uw CGI-map:

$ cp -p /pad/naar/eperl /pad/naar/apache/cgi-bin/eperl

Nu alle bestanden met de extensies .phtml, .eperl en .epl worden automatisch verwerkt
door de ePerl-interpreter. Er is geen Keet lijn of een lokaal ingeschakelde
CGI-modus.

Een laatste tip: als u uw scripts offline wilt testen, voer ze dan gewoon uit met geforceerde
CGI/1.1-modus vanuit je shell. Zorg er wel voor dat je alle omgevingsvariabelen voorbereidt.
script is afhankelijk van bijvoorbeeld "QUERY_STRING" of "PATH_INFO".

$ export QUERY_STRING="key1=waarde1&key2=waarde2"
$ eperl -mc bestand.phtml

NPH-CGI/1.1 compliant interface mode
Deze runtime-modus is een speciale variant van de CGI/1.1-interfacemodus, omdat de meeste
webservers (bijv. Apache) bieden het voor speciale doeleinden aan. Het staat bekend als Niet-geparseerd-
Voorvoegsel (NPH) CGI/1.1-modus en wordt meestal gebruikt door de webserver wanneer de bestandsnaam van
Het CGI-programma wordt voorafgegaan door ``"nph-"''. In deze modus doet de webserver niets
verwerking op de HTTP-antwoordheaders en geen buffering van de resulterende gegevens, d.w.z.
Het CGI-programma moet zelf een volledig HTTP-antwoord leveren. Het voordeel
is dat het programma willekeurige HTTP-headers of MIME-gecodeerde multi-block kan genereren
berichten.

Dus hierboven hebben we het bestand hernoemd naar bestand.cgi wat ons een beetje beperkte. Toen
we hernoemen alternatief bestand.html naar nph-bestand.cgi en de NPH-CGI/1.1-interface forceren
modus via optie - mn dan wordt dit bestand een NPH-CGI/1.1-compatibel programma onder
Apache en andere webservers. Nu kan ons script zijn eigen HTTP-respons leveren (het heeft
niet, want als die ontbreekt, biedt ePerl er een standaardversie voor.

#!/pad/naar/bin/eperl -mn
<? print "HTTP/1.0 200 Ok\n";
afdrukken "X-MyHeader: Foo Bar Quux\n";
afdrukken "Inhoudstype: tekst/html\n\n";

...

Zoals je verwacht kan dit ook gebruikt worden met de impliciete Server-Side Scripting Language
techniek. Zet

AddType-toepassing/x-httpd-eperl .phtml .eperl .epl
Actie application/x-httpd-eperl /internal/cgi/nph-eperl
ScriptAlias ​​/internal/cgi /pad/naar/apache/cgi-bin

in uw httpd.conf en voer het commando uit

$ cp -p /pad/naar/eperl /pad/naar/apache/cgi-bin/nph-eperl

uit je schulp. In deze is the bij voorkeur weg of gebruik ePerl as a Server-kant Scripting
Taal, omdat it biedt meest flexibiliteit.

Security
Wanneer u ePerl installeert als een CGI/1.1- of NPH-CGI/1.1-compatibel programma (zie hierboven voor
gedetailleerde beschrijving van deze modi) via

$ cp -p /pad/naar/eperl /pad/naar/apache/cgi-bin/eperl
$ chown root /pad/naar/apache/cgi-bin/eperl
$ chmod u+s /pad/naar/apache/cgi-bin/eperl

or

$ cp -p /pad/naar/eperl /pad/naar/apache/cgi-bin/nph-eperl
$ chown root /pad/naar/apache/cgi-bin/nph-eperl
$ chmod u+s /pad/naar/apache/cgi-bin/nph-eperl

ie met SetUID bit ingeschakeld voor de wortel gebruiker, ePerl kan overschakelen naar de UID/GID van de
scripts eigenaarHoewel dit een zeer nuttige functie is voor scriptprogrammeurs (omdat één
het is niet langer nodig om hulpbestanden wereldwijd leesbaar te maken en tijdelijke bestanden wereldwijd
schrijfbaar!), kan het te riskant voor u zijn als u paranoïde bent over de beveiliging van SetUID
programma's. Installeer ePerl dan gewoon niet met ingeschakelde SetUID-bit! Dit is de reden waarom
ePerl wordt standaard alleen geïnstalleerd als een stand-alone Unix-filter die dit nooit nodig heeft
kenmerk.

Voor degenen onder ons die besloten dat deze functie essentieel voor hen is, probeert ePerl echt
Moeilijk om het veilig te maken. De volgende stappen moeten succesvol worden doorlopen voordat ePerl
wisselt feitelijk zijn UID/GID om (in deze volgorde):

1. Het script moet voldoen aan de volgende extensies:
.html, .phtml, .ephtml, .epl, .pl, .cgi
2. De UID van het aanroepende proces moet een geldige UID zijn,
dwz het moet gevonden worden in het wachtwoordbestand van het systeem
3. De UID van het aanroepende proces moet overeenkomen met de
volgende gebruikers: root, niemand
4. De UID van de scripteigenaar moet een geldige UID zijn,
dwz het moet gevonden worden in het wachtwoordbestand van het systeem
5. De GID van de scriptgroep moet een geldige GID zijn,
dwz het moet gevonden worden in het systeemgroepbestand
6. Het script moet onder of in de homedirectory van de eigenaar blijven

IF EEN OF DIE STAPPEN MISLUKKING, NEE UID/GID SCHAKELEN NEEMT PLAATS!. Bovendien (indien
"DO_ON_FAILED_STEP" werd gedefinieerd als "STOP_AND_ERROR" in eperl_security.h - niet standaard
(op deze manier gedefinieerd!) kan ePerl de verwerking volledig stoppen en zijn foutpagina weergeven. Dit is
Voor de echt paranoïde webmasters. Standaard, wanneer een stap mislukt, wordt de UID/GID-omschakeling uitgevoerd.
is gewoon uitgeschakeld, maar ePerl gaat door met verwerken. Je kunt ook een aantal
stappen tijdens het compileren. Zie eperl_security.h.

ook niet vergeten uit die ePerl altijd elimineert the effectief UID/GID, onafhankelijk of the
runtime mode en onafhankelijk if ePerl heeft geschakelde naar the UID/GID of the eigenaar. Voor
veiligheid redenen, the effectief UID/GID is altijd vernietigd vaardigheden the script is uitgevoerd.

ePerl preprocessor
ePerl biedt een eigen preprocessor die vergelijkbaar is met CPP in stijl die ofwel ingeschakeld is
handmatig via optie -P of automatisch wanneer ePerl in (NPH-)CGI-modus draait. De volgende
richtlijnen worden ondersteund:

"#include pad"
Deze richtlijn is een include-richtlijn die kan worden gebruikt om werkelijk alle dingen op te nemen,
maar was eigenlijk ontworpen om te worden gebruikt om andere ePerl-bronbestanden op te nemen. De pad blikje
een relatief of absoluut pad zijn voor het lokale bestandssysteem of een volledig gekwalificeerd pad
HTTP-URL.

In het geval van het absolute pad wordt het bestand rechtstreeks op het bestandssysteem benaderd, terwijl
het relatieve pad wordt eerst in de huidige werkmap gezocht en vervolgens in alle
mappen opgegeven via optie -IIn het derde geval (HTTP URL) is het bestand
wordt opgehaald via een HTTP/1.0-verzoek op het netwerk. Hier worden HTTP-redirects (responscodes) gebruikt.
301 en 302) worden ook ondersteund.

Let op: Hoewel ePerl de regelnummers strikt behoudt bij het vertalen van de borstelige
ePerl-formaat naar gewoon Perl-formaat, de ePerl-preprocessor kan dit niet doen (omdat het een
preprocessor (die uitbreidt) voor deze richtlijn. Dus wanneer u "#include" gebruikt,
Houd er rekening mee dat de regelnummers in foutmeldingen onjuist zijn.

Let ook op een belangrijk beveiligingsaspect: omdat u alle spullen kunt opnemen zoals ze zijn,
voorzien van deze richtlijn, gebruik deze alleen voor zaken die onder uw directe verantwoordelijkheid vallen
controle. Gebruik deze richtlijn niet om externe gegevens op te nemen, tenminste niet van externe bronnen.
webservers. Stel dat je een ePerl-pagina hebt met "#include
http://www.foreigner.com/nice-page.html"en bij het volgende verzoek van deze pagina uw
bestandssysteem is verloren! Waarom? Omdat de buitenlander ziet dat je zijn pagina hebt opgenomen
en gebruiken ePerl en plaatsen gewoon een eenvoudig ``" '' in zijn
pagina. Denk er eens over na. NOOIT GEBRUIK #ERBIJ BETREKKEN VOOR ENIGE GEGEVENS WELKE IS NIET ONDER JOUW EIGEN
CONTROLGebruik in plaats daarvan altijd "#sinclude" voor dergelijke situaties.

"#sinclude pad"
Dit is de veilige variant van "#include" waarbij na het lezen van de gegevens van pad allen
De begin- en eindafbakening van ePerl is verwijderd. Risicovolle ePerl-blokken verloren dus hun betekenis.
en worden omgezet naar platte tekst. Gebruik deze richtlijn altijd wanneer u
gegevens waarover u geen controle heeft.

"#als expr", "#elsals expr", "#else", "#endif"
Deze implementeren een CPP-stijl "#if-[#else-]#endif" constructie, maar met een Perl-semantiek.
Terwijl de andere richtlijnen echte preprocessor-opdrachten zijn die op het moment van de implementatie worden geëvalueerd,
preprocessing stap, dit construct wordt eigenlijk gewoon omgezet in een low-level ePerl
construeren, dus het is niet daadwerkelijk geëvalueerd tijdens de pre-processing stap. Het is slechts een
handige snelkoppeling voor het volgende (waarbij BD het momenteel gebruikte beginscheidingsteken is en
ED (het eindscheidingsteken):

``#als expr'' -> ``BD als (expr) { _ ED//''
``#elsif expr'' -> ``BD } elsif (expr) { _ ED//''
``#else'' -> ``BD } anders { _ED//''
``#endif'' -> ``BD } _ ED//''

Het voordeel van deze ongebruikelijke aanpak is dat de if-voorwaarde werkelijk elke geldige kan zijn
Perl-expressie die maximale flexibiliteit biedt. Het nadeel is dat je
kan de if-constructie niet gebruiken om echte preprocessingbeslissingen te nemen. Zoals u kunt zien,
Het ontwerpdoel was om een ​​korte beschrijving te geven van de ingewikkeldere Perl-constructies.

"#C"
Dit is de commentaarrichtlijn die alle gegevens tot en met de
newline-teken. Gebruik dit om alles uit te commentariëren, zelfs andere preprocessors.
richtlijnen.

mits Functionaliteit
Tot nu toe heb je begrepen dat ePerl een mooie mogelijkheid biedt om Perl-code in te sluiten
alle ASCII-gegevens. Maar nu is de typische vraag: welke Perl-code kan in deze
ePerl-blokken en biedt ePerl speciale functionaliteit binnen deze ePerl-blokken?

De antwoorden zijn: Ten eerste kun je echt elke Perl-code in de ePerl-blokken die zijn
geldig voor de Perl-interpreter waarmee ePerl was gekoppeld. Ten tweede doet ePerl dat niet voorzien van enige
speciale functionaliteit binnen deze ePerl-blokken, omdat Perl al geavanceerd is
genoeg ;-)

De implicatie hiervan is: Omdat u elke geldige Perl-code kunt gebruiken, kunt u gebruik maken van
alle beschikbare Perl 5-modules, zelfs die welke gedeelde objecten gebruiken (omdat ePerl is a
Perl-interpreter, inclusief DynaLoader-ondersteuning). Blader dus naar de uitgebreide Perl-interpreter.
Archiefnetwerk (CPAN) via http://www.perl.com/perl/CPAN en pak je favoriete pakketten
die uw leven gemakkelijker kunnen maken (zowel vanuit eenvoudige Perl-scripts als vanuit eenvoudige Perl-scripts) en ePerl-scripts)
en gebruik gewoon de constructie ``"use name;"'' in elk ePerl-blok om ze van binnenuit te gebruiken
ePerl.

Wanneer u ePerl als server-side scripting-taal gebruikt, raad ik u ten zeerste aan om het te installeren op
tenminste de pakketten CGI.pm (momenteel versie 2.36), HTML-stream (1.40) libnet (1.0505) en
libwww-perl (5.08). Als u ook on-the-fly afbeeldingen wilt genereren, raad ik u aan
om minimaal aanvullend te installeren GD (1.14) en Afbeeldingsgrootte (2.3). De ePerl-interpreter in
in combinatie met deze echt geavanceerde Perl 5-modules krijgt u maximale
Flexibiliteit en functionaliteit. Met andere woorden: Merk . of maximaal Software Hefboomwerking in
the Hackers wereld of Perl as groot as mogelijk.

OPTIES

-d naam=waarde
Stelt een Perl-variabele in het pakket "main" in, waarnaar verwezen kan worden via $name of meer
expliciet via $main::name. De opdracht

eperl -d naam=waarde ..

is eigenlijk gelijk aan het hebben van



begin Invoer bestandDeze optie kan meer dan één keer voorkomen.

-D naam=waarde
Stelt een omgevingsvariabele in waarnaar kan worden verwezen via $ENV{'variabele'} in de
Perl-blokken. Het commando

eperl -D naam=waarde ..

is eigenlijk gelijk aan

export naam=waarde; eperl ...

maar het voordeel van deze optie is dat het de bellers niet manipuleert
omgeving. Deze optie kan meer dan één keer voorkomen.

-B begin_delimiter
Stelt de begin-scheidingstekenreeks van het Perl-blok in. Gebruik dit in combinatie met "-E" om
verschillende scheidingstekens bij het gebruik van ePerl als offline HTML-creatietaal terwijl
Het wordt gebruikt als een online HTML-scripttaal. Standaard scheidingstekens zijn " "
voor CGI-modi en "<:" en ":>" voor de zelfstandige Unix-filtermodus.

Er zijn veel mogelijke variaties waaruit u kunt kiezen: ""<:"" en "":>"" (de
standaard ePerl stand-alone filtermodus scheidingstekens) "" "" (de standaard
ePerl CGI-interfacemodus-afbakeningstekens), "" "" and "" ""
(standaard HTML-scripttaalstijl), "" "" and
"" "" (binnenkort HTML3.2+ aka Cougar-stijl), "" "" En "" ""
(HTML-achtige stijl), "" "" (NeoScript en SSI-stijl) of
zelfs "" "" (PHP/FI-stijl; maar dit wordt niet langer aanbevolen omdat het kan
leiden tot parsingproblemen. Mag alleen worden gebruikt voor achterwaartse compatibiliteit met oude ePerl-versies.
versies 1.x).

Er wordt niet hoofdlettergevoelig gezocht naar de begin- en eindafbakeningen.

-E eind_scheidingsteken
Stelt de scheidingstekenreeks voor het Perl-blokeinde in. Zie ook optie -B.

-i Dwingt dat de begin- en eindscheidingstekens hoofdletterongevoelig worden doorzocht. Gebruik dit wanneer
Je gebruikt scheidingstekens zoals ``" "..." '' of andere, meer tekstuele.

-m mode
Dit dwingt ePerl om in een specifieke runtime-modus te werken. Zie hierboven voor een gedetailleerde beschrijving.
beschrijving van de drie mogelijke modi: Stand-alone filter (mode="f", d.w.z. optie
-MF), CGI/1.1-interfacemodus (mode="c", d.w.z. optie -mc) of de NPH-CGI/1.1-interface
modus (mode="n", d.w.z. optie - mn).

-o uitvoerbestand
Dwingt de uitvoer om naar te schrijven uitvoerbestand in plaats van STDOUTGebruik deze optie wanneer
ePerl gebruiken als filter. Het uitvoerbestand ``-'' sets STDOUT als de uitvoerhandgreep
expliciet. Merk op dat dit bestand relatief is ten opzichte van de bronbestandsdirectory wanneer de
runtime-modus wordt gedwongen naar CGI of NPH-CGI.

-k Dwingt ePerl om de huidige werkdirectory te behouden vanaf waar het is gestart.
Standaard zal ePerl veranderen naar de directory waar het uit te voeren bestand zich bevindt.
Deze optie is handig als u ePerl gebruikt als offline filter op een tijdelijk bestand.

-x Hiermee wordt de debugmodus ingesteld, waarbij ePerl het intern gemaakte Perl-script naar de server stuurt.
console (/dev/tty) voordat u het uitvoert. Alleen voor het debuggen van problemen met de invoerbestand
conversie.

-I directory
Geef een directory op die zowel wordt gebruikt voor de richtlijnen "#include" en "#sinclude" van
de ePerl-preprocessor en toegevoegd aan @INC tijdens runtime. Deze optie kan vaker voorkomen.
dan één keer

-P Schakelt handmatig de speciale ePerl-preprocessor in (zie hierboven). Deze optie is ingeschakeld.
automatisch voor alle CGI-modi.

-C Hiermee wordt de conversie van HTML-entiteiten voor ePerl-blokken ingeschakeld. Deze optie wordt automatisch
gedwongen in CGI-modi.

Het opgeloste probleem hier is het volgende: Wanneer u ePerl als Server-Side-
Scripttaal voor HTML-pagina's en u bewerkt uw ePerl-bronbestanden via een HTML
editor, is de kans groot dat uw editor een aantal ingevoerde tekens naar HTML vertaalt
entiteiten, bijvoorbeeld ``"<"'' naar ``"<"''. Dit leidt tot ongeldige Perl-code binnen
ePerl-blokken, omdat de HTML-editor geen kennis heeft van ePerl-blokken. Met behulp van deze
optie converteert de ePerl-parser automatisch alle entiteiten die zich in ePerl-blokken bevinden
terug naar gewone tekens, zodat de Perl-interpreter weer geldige codeblokken ontvangt.

-L Hiermee wordt het regelvoortzettingsteken ``"\"'' (backslash) buiten ePerl-blokken ingeschakeld.
Met deze optie kunt u gegevens van één regel over meerdere regels verdelen. Maar gebruik dit met zorg:
optie wijzigt uw gegevens (buiten ePerl-blokken). Meestal gaat ePerl echt door
Alle omliggende gegevens als ruwe data. Met deze optie worden de nieuwe regels nieuwe semantiek.

-T Dit maakte Perl's bederven mode waar de Perl-interpreter speciale voorzorgsmaatregelen neemt
zogenaamde taint checks om zowel voor de hand liggende als subtiele vallen te voorkomen. Zie perlsec(1) voor meer
details.

-w Dit maakt waarschuwingen mogelijk waarbij de Perl-interpreter een aantal mooie diagnostische gegevens produceert. Zie
perldiag(1) voor meer details.

-c Hiermee wordt een zuivere syntaxiscontrole uitgevoerd, vergelijkbaar met ``"perl -c"''.

-r Hiermee wordt het interne ePerl README-bestand naar de console afgedrukt.

-l Hiermee wordt het interne ePerl LICENSE-bestand naar de console afgedrukt.

-v Hiermee wordt ePerl-versie-informatie naar de console gestuurd.

-V Hetzelfde als optie -v maar toont daarnaast ook de Perl-compilatieparameters.

MILIEU

Gebruikt Variabelen
"PAD_VERTAALD"
Deze CGI/1.1-variabele wordt gebruikt om het bronbestand te bepalen wanneer ePerl als een
NPH-CGI/1.1-programma in de omgeving van een webserver.

mits Variabelen
"SCRIPT_SRC_PAD"
De absolute padnaam van het script. Gebruik dit wanneer u direct toegang wilt tot het script.
script vanuit zichzelf, bijvoorbeeld om "stat()" en andere aanroepen uit te voeren.

"SCRIPT_SRC_PAD_DIR"
Het directorygedeelte van "SCRIPT_SRC_PATH". Gebruik dit wanneer u direct toegang wilt tot
andere bestanden die zich in dezelfde directory bevinden als het script, bijvoorbeeld om de configuratie te lezen
bestanden, enz.

"SCRIPT_SRC_PAD_BESTAND"
Het bestandsnaamgedeelte van "SCRIPT_SRC_PATH". Gebruik dit wanneer u de naam van de
script, bijvoorbeeld voor relatieve zelfverwijzingen via URL's.

"SCRIPT_SRC_URL"
De volledig gekwalificeerde URL van het script. Gebruik dit wanneer u een URL nodig hebt voor zelfstudie.
referentie.

"SCRIPT_SRC_URL_DIR"
Het directorygedeelte van "SCRIPT_SRC_URL". Gebruik dit wanneer u direct toegang wilt tot
andere bestanden die zich in dezelfde directory bevinden als het script via het web, bijvoorbeeld om
referentiebeelden, enz.

"SCRIPT_SRC_URL_BESTAND"
Het bestandsnaamgedeelte van "SCRIPT_SRC_URL". Gebruik dit wanneer u de naam van de
script, bijvoorbeeld voor relatieve zelfreferenties via URL's. Eigenlijk hetzelfde als
"SCRIPT_SRC_PATH_FILE", maar opgegeven voor consistentie.

"SCRIPT_SRC_GROOTTE"
De bestandsgrootte van het script, in bytes.

"SCRIPT_SRC_GEWIJZIGD"
De laatste wijzigingstijd van het script, in seconden sinds 0 uur, 0 minuten, 0
seconden, 1 januari 1970, Gecoördineerde Universele Tijd.

"SCRIPT_SRC_GEWIJZIGDE_CTIJD"
De laatste wijzigingstijd van het script, in ctime(3) formaat (``WDAG MMM DD UU:MM:SS
JJJJ\n'').

"SCRIPT_SRC_GEWIJZIGDE_ISOTIJD"
De laatste wijzigingstijd van het script, in ISO-formaat (``DD-MM-JJJJ UU:MM'').

"SCRIPT_SRC_EIGENAAR"
De gebruikersnaam van de scripteigenaar.

"VERSIE_INTERPRETER"
De ePerl-identificatiereeks.

"VERSIE_TAAL"
De identificatiestring van de gebruikte Perl-interpreterbibliotheek.

mits Ingebouwd Afbeeldingen
De volgende ingebouwde afbeeldingen zijn toegankelijk via URL "/url/to/nph-eperl/"NAAM".gif":

"logo.gif"
Het standaard ePerl-logo. Plaats dit logo niet op uw website.

"aangedreven.gif"
De ``aangedreven by ePerl 2.2'' logo. U mag dit gerust op uw website gebruiken.

Gebruik eperl online met behulp van onworks.net-services