eperl - ออนไลน์ในคลาวด์

โครงการ:

ชื่อ

ePerl - Embedded Perl 5 ภาษา

VERSION

@วี@

เรื่องย่อ

เพิร์ล [-d พร้อมชื่อ=ความคุ้มค่า] [-D พร้อมชื่อ=ความคุ้มค่า] [-B start_delimiter] [-E end_delimiter] [-i] [-m
โหมด] [-o ไฟล์เอาต์พุต] [-k] [-I ไดเรกทอรี] [-P] [-C] [-L] [-x] [-T] [-w] [-c] [ไฟล์อินพุต]

เพิร์ล [-r] [-l] [-v] [-V]

DESCRIPTION

นามธรรม
ePerl ตีความไฟล์ ASCII ที่มีคำสั่งโปรแกรม Perl 5 โดยการประเมิน
รหัส Perl 5 ขณะส่งข้อมูล ASCII ธรรมดา สามารถทำงานได้หลายวิธี: As
ตัวกรอง Unix แบบสแตนด์อโลนหรือโมดูล Perl 5 แบบรวมสำหรับงานสร้างไฟล์ทั่วไป
และเป็นภาษาสคริปต์เว็บเซิร์ฟเวอร์ที่มีประสิทธิภาพสำหรับการเขียนโปรแกรมหน้า HTML แบบไดนามิก

บทนำ
เค้ก เพิร์ล โปรแกรมเป็น ที่ฝัง Perl 5 ภาษา ล่าม. นี้มันเต็มรูปแบบจริงๆ -
นำเสนอล่าม Perl 5 แต่มีสภาพแวดล้อมการโทรและไฟล์ต้นทางที่แตกต่างกัน
เลย์เอาต์มากกว่าตัวแปล Perl เริ่มต้น (โดยปกติคือไฟล์ปฏิบัติการ Perl or เพิร์ล5 ส่วนใหญ่
ระบบ) มันถูกออกแบบมาสำหรับการสร้างไฟล์ ASCII ทั่วไปด้วยปรัชญาของ
การฝัง รหัสโปรแกรม Perl 5 ลงในข้อมูล ASCII แทนวิธีปกติที่คุณ
ฝังข้อมูล ASCII ลงในโปรแกรม Perl 5 (โดยปกติโดยการอ้างอิงข้อมูลและใช้งานผ่าน
คำสั่ง "พิมพ์") ดังนั้นแทนที่จะเขียนสคริปต์ Perl ธรรมดาเช่น

#!/path/to/perl
พิมพ์ "foo bar\n";
พิมพ์ "baz quux\n";
สำหรับ ($i = 0; $i < 10; $i++) { พิมพ์ "foo #${i}\n"; }
พิมพ์ "foo bar\n";
พิมพ์ "baz quux\n";

คุณสามารถเขียนตอนนี้เป็นสคริปต์ ePerl:

#!/path/to/eperl
ฟูบาร์
บาซ คูซ์
<: สำหรับ ($i = 0; $i < 10; $i++) { พิมพ์ "foo #${i}\n"; } :>
ฟูบาร์
บาซ คูซ์

แม้ว่าตัวแปร ePerl จะมีเลย์เอาต์ไฟล์ต้นฉบับต่างกัน แต่ความหมายก็เหมือนกัน
กล่าวคือ สคริปต์ทั้งสองสร้างข้อมูลผลลัพธ์ที่เหมือนกันทุกประการใน "STDOUT"

ความตั้งใจ
ePerl เป็นเพียงโค้ดกาวที่รวมพลังการเขียนโปรแกรมของล่าม Perl 5
ห้องสมุดด้วยเทคนิคการฝังที่ยุ่งยาก เคล็ดลับการฝังคือ: มันแปลง
ไฟล์ต้นฉบับลงในสคริปต์ Perl ที่ถูกต้องซึ่งจะได้รับ อย่างสิ้นเชิง ประเมินเพียงคนเดียว
อินสแตนซ์ภายในของล่าม Perl 5 เพื่อให้บรรลุสิ่งนี้ ePerl แปลทั้งหมดล้วน
รหัสเป็น (หนี) Perl 5 สตริงวางลงใน พิมพ์ สร้างขึ้นในขณะที่ผ่านทั้งหมด
ฝังโค้ด Perl 5 ดั้งเดิม อย่างที่คุณเห็น ePerl เองก็ทำเช่นเดียวกัน
ภายในโปรแกรมเมอร์โง่ ๆ ต้องทำเมื่อเขียนสคริปต์การสร้าง Perl ธรรมดา

เนื่องจากลักษณะของรหัสที่มีขนแปรงเช่นนี้ ePerl จึงเป็นความพยายามที่ดีกว่าเมื่อ
ข้อมูล ASCII ที่สร้างขึ้นนั้นมีข้อมูลแบบคงที่มากกว่าแบบไดนามิก หรืออีกนัยหนึ่ง: ใช้
อีเพิร์ล if เธอ ต้องการ ไปยัง เก็บ มากที่สุด of สร้าง ASCII ข้อมูล in ธรรมดา รูป ในขณะที่ เพียงแค่
การเขียนโปรแกรม บาง ขนแปรง สิ่ง อย่าใช้เมื่อสร้างข้อมูลไดนามิกบริสุทธิ์ นั่นมัน
ไม่ได้นำข้อได้เปรียบมาสู่โค้ดโปรแกรมธรรมดาของสคริปต์ Perl ธรรมดา ดังนั้น ค่าคงที่
ส่วนหนึ่งควรมีอย่างน้อย 60% มิฉะนั้นความได้เปรียบจะกลายเป็นข้อเสีย

ePerl เดิมได้รับการออกแบบสำหรับสถานการณ์ที่รุนแรง: ในฐานะเว็บเซิร์ฟเวอร์
ภาษาสคริปต์สำหรับการสร้างหน้า HTML แบบทันที ที่นี่คุณมีกรณีทั่วไป
ซึ่งโดยปกติ 90% ของข้อมูลประกอบด้วยแท็ก HTML แบบคงที่แท้และ ASCII ธรรมดาในขณะที่เพียง
ส่วนที่เหลืออีก 10% เป็นโครงสร้างการเขียนโปรแกรมซึ่งสร้างโค้ดมาร์กอัปเพิ่มเติมแบบไดนามิก
นี่คือเหตุผลที่ ePerl ข้างโหมดรันไทม์การกรอง Unix มาตรฐานยังรองรับ
อินเทอร์เฟซ CGI/1.1 และ NPH-CGI/1.1

ที่ฝัง Perl วากยสัมพันธ์
ในทางปฏิบัติ คุณสามารถใส่โครงสร้าง Perl ที่ถูกต้องภายใน ePerl บล็อก Perl 5 . ที่ใช้
ห้องสมุดล่ามสามารถประเมิน แต่มีจุดสำคัญที่คุณควรเสมอ
จดจำและไม่มีวันลืมเมื่อใช้ ePerl:

1. ตัวคั่น เป็น เสมอ ทิ้ง
เล็กน้อยที่จะพูด แต่ควรกล่าวถึงอย่างน้อยหนึ่งครั้ง ตัวคั่นบล็อก ePerl
จะถูกละทิ้งเสมอและจำเป็นสำหรับ ePerl เพื่อรับรู้ Perl . ที่ฝังอยู่เท่านั้น
โครงสร้าง พวกเขาจะไม่ถูกส่งต่อไปยังผลลัพธ์สุดท้าย

2. สร้าง เนื้อหา มี ไปยัง go ไปยัง "STDOUT".
แม้ว่าคุณสามารถกำหนดรูทีนย่อย คำนวณข้อมูลบางอย่าง ฯลฯ ภายใน ePerl blocks
เฉพาะข้อมูลที่เขียนอย่างชัดเจนไปยังการจัดการไฟล์ "STDOUT" เท่านั้นที่จะถูกขยาย ในอื่นๆ
คำ: เมื่อบล็อก ePerl ไม่สร้างเนื้อหาใน "STDOUT" จะเป็นทั้งหมด
แทนที่ด้วยสตริงว่างในผลลัพธ์สุดท้าย แต่เมื่อเนื้อหาถูกสร้างขึ้นมันเป็น
วางที่จุดบล็อก ePerl ในผลลัพธ์สุดท้าย โดยปกติเนื้อหาจะถูกสร้างขึ้น
ผ่านโครงสร้าง "พิมพ์" ล้วนๆ ซึ่งใช้ "STDOUT" โดยปริยาย เมื่อไม่มีการจัดการไฟล์

3. สร้าง เนื้อหา on "STDERR" เสมอ นำไปสู่ ไปยัง an ความผิดพลาด
เมื่อใดก็ตามที่สร้างเนื้อหาบนการจัดการไฟล์ "STDERR" ePerl จะแสดงข้อผิดพลาด
(รวมถึงเนื้อหา STDERR) ใช้สิ่งนี้เพื่อออกจากข้อผิดพลาดขณะส่งข้อผิดพลาดจาก
ePerl บล็อกสภาพแวดล้อมการโทร

4. นามสกุล อัฒภาค.
เนื่องจากข้อ 6 (ดูด้านล่าง) และข้อเท็จจริงที่ผู้ใช้ส่วนใหญ่ไม่
มีการแปลบล็อก ePerl ภายในในใจ ePerl ฉลาดเกี่ยวกับสิ่งสุดท้าย
อัฒภาค. โดยปกติทุกบล็อกของ ePerl จะต้องลงท้ายด้วยเครื่องหมายอัฒภาคของตัวสุดท้าย
คำสั่ง

<: cmd; ...; ซม. :>

แต่เมื่อไม่มีอัฒภาคสุดท้าย ePerl จะเพิ่มเข้าไปโดยอัตโนมัติ เช่น

<: cmd; ...; cmd :>

เป็นไวยากรณ์ที่ถูกต้องด้วย แต่บางครั้งก็จำเป็นต้องบังคับ ePerl ไม่ เพื่อเพิ่มไฟล์
อัฒภาค. จากนั้นคุณสามารถเพิ่ม ``"_"'' (ขีดล่าง) เป็นช่องว่างสุดท้ายที่ไม่ใช่ช่องว่าง
อักขระในบล็อกเพื่อบังคับให้ ePerl ออกจากอัฒภาคสุดท้าย ใช้สิ่งนี้เพื่อ
โครงสร้างดังต่อไปนี้

<: if (...) { _:>
foo
<: } อื่นๆ { _:>
บาร์
<: } :>

ที่คุณต้องการกระจายคำสั่ง Perl ผ่านบล็อก ePerl เพิ่มเติม

5. ชวเลข สำหรับ "พิมพ์"-เท่านั้น บล็อก
เนื่องจากเวลาส่วนใหญ่ ePerl ถูกใช้เพียงเพื่อสอดแทรกตัวแปร เช่น

<: พิมพ์ $VARIABLE; :>

เป็นประโยชน์ในการจัดเตรียมทางลัดสำหรับโครงสร้างประเภทนี้ ดังนั้น ePerl จึงมี a
ทางลัดโดยใช้อักขระ '=' เมื่อมันทันที (ไม่อนุญาตให้มีช่องว่างที่นี่)
ตามตัวคั่นเริ่มต้นของบล็อก ePerl คำสั่ง "พิมพ์" โดยปริยาย
สร้างขึ้น กล่าวคือบล็อกข้างต้นเทียบเท่ากับ

<:=$VARIABLE:>

โปรดสังเกตว่าเครื่องหมายอัฒภาคถูกลบที่นี่ด้วยเพราะจะถูกเพิ่มโดยอัตโนมัติ
(ดูด้านบน).

6. พิเศษ End Of Line ทิ้ง คำสั่ง สำหรับ อีเพิร์ล บล็อก
ePerl มีคำสั่งละทิ้งพิเศษชื่อ ``"//"'' ซึ่งจะละทิ้งข้อมูลทั้งหมดไม่เกิน
และรวมถึงอักขระขึ้นบรรทัดใหม่ต่อไปนี้เมื่อตาม end block . โดยตรง
ตัวคั่น โดยปกติเมื่อคุณเขียน

foo
<: $x = 1; :>
คูซ์

ผลลัพธ์คือ

foo

คูซ์

เพราะ ePerl จะเก็บโค้ดไว้รอบๆ บล็อก ePerl เสมอ แม้กระทั่งการขึ้นบรรทัดใหม่ แต่เมื่อ
ที่คุณเขียน

foo
<: $x = 1; :>//
คูซ์

ผลลัพธ์คือ

foo
คูซ์

เพราะ ``"//"'' ลบทุกอย่างไปจนสุดบรรทัด รวมทั้ง ขึ้นบรรทัดใหม่

7. ข้อ จำกัด in การแยกวิเคราะห์
ทุกโปรแกรมมีข้อจำกัด ePerl เช่นกัน แต้มต่อของมันคือ Perl ไม่ใช่แค่ a
ภาษาที่ร่ำรวยมันเป็นภาษาที่น่ากลัวตามการแยกวิเคราะห์โครงสร้างของมัน บางทีคุณ
รู้จักคำว่า ,,Only Perl แยกวิเคราะห์ได้ Perl''. คิดเกี่ยวกับมัน ความหมายของสิ่งนี้
คือ ePerl ไม่เคยพยายามแยกวิเคราะห์บล็อก ePerl เอง มันทั้งหมดขึ้นอยู่กับ
ไลบรารีล่าม Perl เพราะเป็นอินสแตนซ์เดียวที่สามารถทำได้โดยไม่ต้อง
ข้อผิดพลาด แต่ปัญหาคือ ePerl อย่างน้อยต้องรู้จักจุดเริ่มต้นและจุดสิ้นสุด
ตำแหน่งของบล็อก ePerl เหล่านั้น

มีสองวิธี: สามารถค้นหาตัวคั่นสิ้นสุดขณะแยกวิเคราะห์ แต่ที่
รู้จักสตริงที่ยกมาน้อยที่สุด (โดยที่ตัวคั่นท้ายถือว่าเป็นข้อมูลที่บริสุทธิ์) หรือ
ก็สามารถเคลื่อนไปข้างหน้าไปยังตัวคั่นปลายทางถัดไปและบอกว่ามันไม่ได้เกิดขึ้น
ภายใน Perl สร้าง ใน ePerl 2.0 อันที่สองถูกใช้ ในขณะที่ ePerl 2.1 นั้น
อันแรกถูกถ่ายเพราะผู้ใช้จำนวนมากต้องการให้เป็นแบบนี้ในขณะที่ใช้ปลายไม่ดี
ตัวคั่นเช่น ``">"'' แต่จริงๆแล้วผู้เขียนได้แก้ไขความเห็นอีกครั้งและ
ในที่สุดก็ตัดสินใจใช้วิธีที่สองซึ่งใช้ตั้งแต่ ePerl 2.2 ในตอนนี้ เพราะ
ในขณะที่อันแรกอนุญาตให้มีตัวคั่นเล็กน้อยมากขึ้น (ซึ่งตัวมันเองไม่ดีจริงๆ
ความคิด) มันล้มเหลวเมื่อมีการใช้โครงสร้างเช่น ``"m |"[^"]+"|"'' ฯลฯ ภายใน ePerl
บล็อก และง่ายกว่าที่จะหลีกเลี่ยงตัวคั่นปลายทางภายในโครงสร้าง Perl (เช่น
ผ่านแบ็กสแลชในสตริงที่ยกมา) กว่าเขียนโครงสร้าง Perl ที่ซับซ้อนใหม่เพื่อใช้คู่
จำนวนคำพูด

ดังนั้นเมื่อใดก็ตามที่ตัวคั่นปลายทางของคุณเกิดขึ้นภายใน Perl โครงสร้างคุณต้องหลบหนี
มันในทางใดทางหนึ่ง

8. HTML เอกลักษณ์ การแปลง
เนื่องจากหนึ่งในการใช้งานของ ePerl เป็นภาษาสคริปต์ฝั่งเซิร์ฟเวอร์สำหรับหน้า HTML
มีปัญหาทั่วไปร่วมกับโปรแกรมแก้ไข HTML พวกเขาไม่รู้จัก ePerl
บล็อค ดังนั้นเมื่อคุณเข้าสู่บล็อคเหล่านั้นภายในตัวแก้ไข พวกมันมักจะเข้ารหัสบางส่วน
อักขระที่มีเอนทิตี HTML ที่เกี่ยวข้อง ปัญหาคือการเข้ารหัสนี้
นำไปสู่รหัส Perl ที่ไม่ถูกต้อง ePerl มีตัวเลือกให้ -C สำหรับการถอดรหัสเอนทิตีเหล่านี้
ซึ่งจะเปิดโดยอัตโนมัติในโหมด CGI ดูคำอธิบายด้านล่างภายใต้ตัวเลือก -C
.

Runtime โหมด
ePerl สามารถทำงานได้ในโหมดรันไทม์ที่แตกต่างกันสามโหมด:

แบบสแตนด์อโลน ยูนิกซ์ กรอง โหมด
นี่เป็นโหมดการทำงานเริ่มต้นเมื่อใช้เป็นเครื่องมือสร้างจาก Unix shell
หรือเป็นเครื่องมือประมวลผลแบบกลุ่มจากภายในโปรแกรมหรือสคริปต์อื่น:

$ eperl [ตัวเลือก] - < inputfile > outputfile
$ eperl [ตัวเลือก] inputfile > outputfile
$ eperl [ตัวเลือก] -o outputfile - < inputfile
$ eperl [ตัวเลือก] -o outputfile inputfile

อย่างที่คุณเห็น ePerl สามารถใช้กับ STDIO และไฟล์ภายนอกร่วมกันได้
นอกจากนี้ยังมีรูปแบบที่น่าสนใจสองแบบสำหรับการใช้โหมดนี้ ก่อนอื่นคุณสามารถใช้
ePerl ร่วมกับ Unix shebang เทคนิคมายากลโดยปริยายเลือกเป็น
ล่ามสำหรับสคริปต์ของคุณคล้ายกับที่คุณคุ้นเคยกับ Perl . ธรรมดา
ล่าม:

#!/path/to/eperl [ตัวเลือก]
foo
<: พิมพ์ "แถบ"; :>
คูซ์

ประการที่สอง คุณสามารถใช้ ePerl ร่วมกับ Bourne-Shell Here เอกสาร เทคนิค
จากภายในคุณเชลล์สคริปต์:

#!bin / sh /
...
eperl [ตัวเลือก] - <
foo
<: พิมพ์ "quux"; :>
คูซ์
EOS
...

หากคุณต้องการสร้างเชลล์หรือสคริปต์อื่นๆ ด้วย ePerl เช่น คุณต้องมี shebang
บรรทัดในผลลัพธ์ของ eperl คุณต้องเพิ่มบรรทัด shebang ที่มีเช่น
"#!/usr/bin/eperl" ก่อน เพราะ eperl จะตัดบรรทัดแรกออกจากอินพุตหาก
เป็นสาย shebang ตัวอย่าง:

#!/usr/bin/eperl
#!bin / sh /
echo <: พิมพ์ "quux"; :>

จะส่งผลให้ผลลัพธ์ต่อไปนี้:

#!bin / sh /
เสียงก้อง quux

หรือคุณสามารถเพิ่มความคิดเห็นของตัวประมวลผลล่วงหน้าในบรรทัดแรกได้ เช่น:

#c นี่คือความคิดเห็นเพื่อรักษาบรรทัด shebang ในบรรทัดต่อไปนี้
#!bin / sh /
echo <: พิมพ์ "quux"; :>

และสุดท้าย คุณสามารถใช้ ePerl ได้โดยตรงจากภายในโปรแกรม Perl โดยใช้ปุ่ม
แยกวิเคราะห์::อีเพิร์ล(3) แพ็คเกจ (สมมติว่าคุณติดตั้งสิ่งนี้ด้วย ดูไฟล์ ติดตั้ง
ภายในการแจกจ่าย ePerl สำหรับรายละเอียดเพิ่มเติม):

#!/path/to/perl
...
ใช้ Parse::ePerl;
...
$script = <
foo
<: พิมพ์ "quux"; :>
คูซ์
EOT
...
$result = แยกวิเคราะห์::ePerl::ขยาย ({
สคริปต์ => $สคริปต์,
ผลลัพธ์ => \$ผลลัพธ์
});
...
พิมพ์ผลลัพธ์ $;
...

ดู แยกวิเคราะห์::อีเพิร์ล(3) สำหรับรายละเอียดเพิ่มเติม

CGI / 1.1 ไม่ขัดขืน อินเตอร์เฟซ โหมด
นี่คือโหมดรันไทม์ที่ ePerl ใช้อินเทอร์เฟซ CGI/1.1 ของเว็บเซิร์ฟเวอร์เมื่อ
ใช้เป็น ฝั่งเซิร์ฟเวอร์ การเขียนสคริปต์ ภาษา บนเว็บ ePerl เข้าสู่โหมดนี้
โดยอัตโนมัติเมื่อตั้งค่าตัวแปรสภาพแวดล้อม CGI/1.1 "PATH_TRANSLATED" และ
หรือชื่อไฟล์สคริปต์ไม่ ไม่ เริ่มต้นด้วยคำนำหน้า NPH ``เอ็นพีเอช-''. ในรันไทม์นี้
โหมดนำหน้าข้อมูลผลลัพธ์ด้วย HTTP/1.0 (ค่าเริ่มต้น) หรือ HTTP/1.1 (หากระบุ
โดยเว็บเซิร์ฟเวอร์) บรรทัดส่วนหัวการตอบสนองที่สอดคล้อง

ePerl ยังรู้จักบรรทัดส่วนหัว HTTP ที่จุดเริ่มต้นของสคริปต์ที่สร้างขึ้น
ข้อมูล เช่น คุณสามารถสร้างส่วนหัว HTTP ของคุณเองได้ เช่น

<? $url = "..";
พิมพ์ "ตำแหน่ง: $url\n";
พิมพ์ "URI: $url\n\n"; !>

...

แต่โปรดสังเกตว่าในขณะที่คุณสามารถส่งออกส่วนหัวได้ตามอำเภอใจ เว็บเซิร์ฟเวอร์ส่วนใหญ่จำกัด
ส่วนหัวที่ยอมรับผ่านอินเทอร์เฟซ CGI/1.1 โดยปกติคุณสามารถให้ a . เท่านั้น
ส่วนหัว HTTP เฉพาะบางรายการ เช่น "ตำแหน่ง" หรือ "สถานะ" หากคุณต้องการการควบคุมมากกว่านี้
ต้องใช้โหมดอินเทอร์เฟซ NPH-CGI/1.1

นอกจากนี้ ePerl ยังมีคุณสมบัติที่มีประโยชน์ในโหมดนี้: สามารถสลับ UID/GID . ได้
ถึงเจ้าของสคริปต์หากทำงานเป็น Unix ตั้งค่าUID โปรแกรม (ดูด้านล่างภายใต้
ความปลอดภัยและตัวเลือก ``u+s'' ของ chmod(พ.ศ. 1)).

มีสองวิธีที่รู้จักกันทั่วไปในการใช้โหมดอินเทอร์เฟซ CGI/1.1 นี้บนเว็บ
ขั้นแรก คุณสามารถใช้เพื่อแปลงไฟล์ HTML ธรรมดาให้เป็นสคริปต์ CGI/1.1 ได้อย่างชัดเจน
เมื่อ shebang เทคนิค (ดูด้านบน) สำหรับเว็บเซิร์ฟเวอร์ Apache เพียงใส่สิ่งต่อไปนี้
บรรทัดเป็นบรรทัดแรกของไฟล์:

#!/path/to/eperl -mc

จากนั้นเปลี่ยนชื่อสคริปต์จาก ไฟล์.html ไปยัง ไฟล์.cgi และตั้งค่าบิตการดำเนินการผ่าน

$mv file.html file.cgi
$chmod a+rx ไฟล์.cgi

ตอนนี้ตรวจสอบให้แน่ใจว่า Apache ยอมรับ ไฟล์.cgi เป็นโปรแกรม CGI โดยเปิดใช้งาน CGI รองรับ
สำหรับไดเร็กทอรีที่ ไฟล์.cgi อาศัยอยู่ สำหรับสิ่งนี้ให้เพิ่มบรรทัด

ตัวเลือก +ExecCGI

ไป .htaccess ไฟล์ในไดเร็กทอรีนี้ สุดท้ายตรวจสอบให้แน่ใจว่า Apache จริงๆ
ตระหนักถึงนามสกุล .ซีจีไอ. บางทีคุณอาจต้องเพิ่มบรรทัดต่อไปนี้เพิ่มเติม
เพื่อคุณ httpd.conf ไฟล์:

AddHandler cgi-สคริปต์ .cgi

ตอนนี้คุณสามารถใช้ ไฟล์.cgi แทน ไฟล์.html และใช้ประโยชน์จากความสำเร็จ
ความสามารถในการเขียนโปรแกรมโดย bristling ไฟล์.cgi ด้วยบล็อก Perl ของคุณ (หรือ
การแปลงเป็นสคริปต์ CGI จะไม่มีประโยชน์)

อีกทางหนึ่ง (หรือแม้แต่เพิ่มเติม) ผู้ดูแลเว็บสามารถเปิดใช้งานการสนับสนุน ePerl ในรูปแบบ more
วิธีที่ราบรื่นโดยการกำหนดค่า ePerl เป็นภาษาสคริปต์ฝั่งเซิร์ฟเวอร์โดยนัยที่แท้จริง
ทำได้โดยการกำหนดประเภท MIME ให้กับนามสกุลไฟล์ ePerl ที่ถูกต้องและ
บังคับให้ไฟล์ทั้งหมดที่มีประเภท MIME นี้ถูกประมวลผลภายในผ่าน ePerl
ล่าม. คุณสามารถทำสิ่งนี้ให้สำเร็จสำหรับ Apache โดยเพิ่มสิ่งต่อไปนี้ใน your
httpd.conf ไฟล์

แอปพลิเคชัน AddType/x-httpd-eperl .phtml .eperl .epl
แอปพลิเคชันการดำเนินการ/x-httpd-eperl /internal/cgi/eperl
ScriptAlias ​​/internal/cgi /path/to/apache/cgi-bin

และสร้างสำเนาของ เพิร์ล โปรแกรมในไดเรกทอรี CGI ของคุณ:

$ cp -p /path/to/eperl /path/to/apache/cgi-bin/eperl

ตอนนี้ไฟล์ทั้งหมดที่มีนามสกุล .phtml, .eperl และ .epl จะถูกประมวลผลโดยอัตโนมัติ
โดยล่าม ePerl ไม่จำเป็นต้องมี shebang สายหรือเปิดใช้งานในเครื่องใด ๆ
โหมดซีจี

คำใบ้สุดท้าย: เมื่อต้องการทดสอบสคริปต์ของคุณแบบออฟไลน์ ให้รันสคริปต์ด้วยการบังคับ
โหมด CGI/1.1 จากเชลล์ของคุณ แต่ให้แน่ใจว่าคุณเตรียมตัวแปรสภาพแวดล้อมทั้งหมดของคุณ
ขึ้นอยู่กับสคริปต์ เช่น "QUERY_STRING" หรือ "PATH_INFO"

$ ส่งออก QUERY_STRING="key1=value1&key2=value2"
$eperl -mc file.phtml

NPH-CGI/1.1 ไม่ขัดขืน อินเตอร์เฟซ โหมด
โหมดรันไทม์นี้เป็นตัวแปรพิเศษของโหมดอินเทอร์เฟซ CGI/1.1 เนื่องจากส่วนใหญ่
เว็บเซิร์ฟเวอร์ (เช่น Apache) จัดให้เพื่อวัตถุประสงค์พิเศษ เป็นที่รู้จักกันในนาม ไม่แยกวิเคราะห์-
ส่วนหัว (NPH) โหมด CGI/1.1 และมักจะใช้โดยเว็บเซิร์ฟเวอร์เมื่อชื่อไฟล์ของ
โปรแกรม CGI นำหน้าด้วย ``"nph-"'' ในโหมดนี้ เว็บเซิร์ฟเวอร์ไม่
การประมวลผลบนส่วนหัวการตอบสนอง HTTP และไม่มีการบัฟเฟอร์ของข้อมูลผลลัพธ์ เช่น
โปรแกรม CGI จะต้องให้การตอบสนอง HTTP ที่สมบูรณ์ด้วยตัวมันเอง ข้อได้เปรียบ
คือโปรแกรมสามารถสร้างส่วนหัว HTTP โดยพลการหรือ multi-block . ที่เข้ารหัส MIME
ข้อความ

ดังนั้นด้านบนเราได้เปลี่ยนชื่อไฟล์เป็น ไฟล์.cgi ซึ่งจำกัดเราไว้เล็กน้อย เมื่อไหร่
หรือเราจะเปลี่ยนชื่อ ไฟล์.html ไปยัง nph-file.cgi และบังคับอินเทอร์เฟซ NPH-CGI/1.1
โหมดผ่านตัวเลือก -ม จากนั้นไฟล์นี้จะกลายเป็นโปรแกรมที่สอดคล้องกับ NPH-CGI/1.1 ภายใต้
Apache และเว็บเซิร์ฟเวอร์อื่นๆ ตอนนี้สคริปต์ของเราสามารถให้การตอบสนอง HTTP ของตัวเองได้ (จำเป็นต้อง
ไม่ใช่เพราะเมื่อไม่มี ePerl ให้ค่าเริ่มต้นไว้)

#!/path/to/bin/eperl -mn
<? พิมพ์ "HTTP/1.0 200 ตกลง\n";
พิมพ์ "X-MyHeader: Foo Bar Quux\n";
พิมพ์ "ประเภทเนื้อหา: text/html\n\n";

...

ตามที่คุณคาดหวังสิ่งนี้สามารถใช้กับภาษาสคริปต์ฝั่งเซิร์ฟเวอร์โดยนัย
เทคนิค. ใส่

แอปพลิเคชัน AddType/x-httpd-eperl .phtml .eperl .epl
แอปพลิเคชันการดำเนินการ/x-httpd-eperl /internal/cgi/nph-eperl
ScriptAlias ​​/internal/cgi /path/to/apache/cgi-bin

เป็นของคุณ httpd.conf และรันคำสั่ง

$ cp -p /path/to/eperl /path/to/apache/cgi-bin/nph-eperl

จากเปลือกของคุณ แจกันดอกไม้โรแมนติกนี้ is ที่ต้องการ ทาง of ด้วย อีเพิร์ล as a ฝั่งเซิร์ฟเวอร์ การเขียนสคริปต์
ภาษา, เพราะ it ให้ มากที่สุด ความยืดหยุ่น.

⁠ความปลอดภัย
เมื่อคุณติดตั้ง ePerl เป็นโปรแกรมที่สอดคล้องกับ CGI/1.1 หรือ NPH-CGI/1.1 (ดูด้านบนสำหรับ
คำอธิบายโดยละเอียดของโหมดเหล่านี้) via

$ cp -p /path/to/eperl /path/to/apache/cgi-bin/eperl
$ chown รูต /path/to/apache/cgi-bin/eperl
$ chmod u+s /path/to/apache/cgi-bin/eperl

or

$ cp -p /path/to/eperl /path/to/apache/cgi-bin/nph-eperl
$ chown รูต /path/to/apache/cgi-bin/nph-eperl
$ chmod u+s /path/to/apache/cgi-bin/nph-eperl

เช่นกับ ตั้งค่าUID บิตที่เปิดใช้งานสำหรับ ราก ผู้ใช้ ePerl สามารถสลับไปที่ UID/GID ของ
สคริปต์ เจ้าของ. แม้ว่านี่จะเป็นคุณสมบัติที่มีประโยชน์มากสำหรับโปรแกรมเมอร์สคริปต์ (เพราะหนึ่ง
ไม่จำเป็นต้องสร้างไฟล์เสริมที่อ่านได้ทั่วโลกและไฟล์ชั่วคราวอีกต่อไป
เขียนได้!) อาจมีความเสี่ยงสำหรับคุณเมื่อคุณหวาดระแวงเกี่ยวกับความปลอดภัยของ SetUID
โปรแกรม ถ้าเป็นเช่นนั้นอย่าเพิ่งติดตั้ง ePerl ด้วย SetUID bit ที่เปิดใช้งาน! นี่คือเหตุผลว่าทำไม
ePerl ได้รับการติดตั้งตามค่าเริ่มต้นเป็นตัวกรอง Unix แบบสแตนด์อะโลนซึ่งไม่ต้องการสิ่งนี้
ลักษณะ

สำหรับพวกเราที่ตัดสินใจว่าคุณสมบัตินี้จำเป็นสำหรับพวกเขา ePerl พยายามจริงๆ
ยากที่จะทำให้ปลอดภัย ต้องผ่านขั้นตอนต่อไปนี้ให้สำเร็จก่อน ePerl
จริง ๆ แล้วสลับ UID/GID (ตามลำดับนี้):

1. สคริปต์ต้องตรงกับส่วนขยายต่อไปนี้:
.html, .phtml, .ephtml, .epl, .pl, .cgi
2. UID ของกระบวนการโทรต้องเป็น UID ที่ถูกต้อง
คือจะต้องพบในไฟล์รหัสผ่านของระบบ
3. UID ของกระบวนการโทรต้องตรงกับ
ผู้ใช้ที่ติดตาม: รูท, ไม่มีคน
4. UID ของเจ้าของสคริปต์ต้องเป็น UID ที่ถูกต้อง
คือจะต้องพบในไฟล์รหัสผ่านของระบบ
5. GID ของกลุ่มสคริปต์ต้องเป็น GID ที่ถูกต้อง
คือจะต้องพบในไฟล์กลุ่มระบบ
6. สคริปต์ต้องอยู่ด้านล่างหรือใน homedir ของเจ้าของ

IF เพียง ONE OF เหล่านี้ ขั้นตอน ล้มเหลว, NO UID / GID การสลับ ใช้เวลา สถานที่!. นอกจากนี้ (ถ้า
"DO_ON_FAILED_STEP" ถูกกำหนดเป็น "STOP_AND_ERROR" ใน eperl_security.h - ไม่ใช่ตามค่าเริ่มต้น
กำหนดด้วยวิธีนี้!) ePerl สามารถหยุดการประมวลผลโดยสิ้นเชิงและแสดงหน้าข้อผิดพลาด นี่คือ
สำหรับเว็บมาสเตอร์ที่หวาดระแวงจริงๆ ตามค่าเริ่มต้นเมื่อขั้นตอนใด ๆ ล้มเหลวในการสลับ UID/GID
ถูกปิดใช้งาน แต่ ePerl ดำเนินการต่อไป หรือคุณสามารถปิดการใช้งานบาง
ขั้นตอนในเวลารวบรวม ดู eperl_security.h.

Also จำ ที่ อีเพิร์ล เสมอ ขจัด มีประสิทธิภาพ UID/จีไอดี, อิสระ of
รันไทม์ โหมด และ อิสระ if อีเพิร์ล มี เปลี่ยน ไปยัง UID / GID of เจ้าของ. ใช้เพื่อการ
ความปลอดภัย เหตุผล มีประสิทธิภาพ UID / GID is เสมอ ทำลาย ก่อน ต้นฉบับ is ดำเนินการ

อีเพิร์ล ตัวประมวลผลล่วงหน้า
ePerl มีตัวประมวลผลล่วงหน้าของตัวเองที่คล้ายกับ CPP ในรูปแบบที่เปิดใช้งานอย่างใดอย่างหนึ่ง
ด้วยตนเองผ่าน option -P หรือโดยอัตโนมัติเมื่อ ePerl ทำงานในโหมด (NPH-)CGI ต่อไปนี้
รองรับคำสั่ง:

"#รวมเส้นทาง"
คำสั่งนี้เป็นคำสั่งรวม ซึ่งสามารถใช้เพื่อรวมสิ่งใด ๆ จริงๆ
แต่จริงๆ แล้วได้รับการออกแบบมาเพื่อใช้รวมไฟล์ต้นฉบับ ePerl อื่นๆ ดิ เส้นทาง สามารถ
เป็นพาธสัมพัทธ์หรือพาธสัมบูรณ์สำหรับระบบไฟล์ในเครื่องหรือเป็นพาธที่มีคุณสมบัติครบถ้วน
URL HTTP

ในกรณีของพาธสัมบูรณ์ ไฟล์ถูกเข้าถึงโดยตรงบนระบบไฟล์ ในขณะที่
เส้นทางสัมพัทธ์ถูกค้นหาครั้งแรกในไดเร็กทอรีการทำงานปัจจุบันและจากนั้นในทั้งหมด
ไดเร็กทอรีที่ระบุผ่าน option -I. ในกรณีที่สาม (HTTP URL) ไฟล์ is
ดึงข้อมูลผ่านคำขอ HTTP/1.0 บนเครือข่าย ที่นี่ HTTP เปลี่ยนเส้นทาง (รหัสตอบกลับ
รองรับ 301 และ 302) ด้วย

หมายเหตุ: ในขณะที่ ePerl รักษาหมายเลขบรรทัดอย่างเคร่งครัดเมื่อแปลขนแปรง
รูปแบบ ePerl เป็นรูปแบบ Perl ธรรมดา ตัวประมวลผลล่วงหน้าของ ePerl ไม่สามารถทำได้ (เนื่องจากเป็น
ก่อนโปรเซสเซอร์ที่ขยาย) สำหรับคำสั่งนี้ ดังนั้น เมื่อใดก็ตามที่คุณใช้ "#include"
โปรดจำไว้ว่าหมายเลขบรรทัดในข้อความแสดงข้อผิดพลาดนั้นไม่ถูกต้อง

สังเกตประเด็นด้านความปลอดภัยที่สำคัญอย่างหนึ่งด้วย: เนื่องจากคุณสามารถรวมสิ่งต่างๆ ตามที่เป็นอยู่ได้
ให้มากับคำสั่งนี้ ใช้สำหรับสิ่งที่อยู่ภายใต้คำสั่งของคุณเท่านั้น
ควบคุม. อย่าใช้คำสั่งนี้เพื่อรวมข้อมูลต่างประเทศ อย่างน้อยก็ไม่ใช่จากภายนอก
เว็บเซิร์ฟเวอร์ ตัวอย่างเช่น สมมติว่าคุณมีหน้า ePerl ที่มี "#include
http://www.foreigner.com/nice-page.html" และตามคำขอถัดไปของหน้านี้ your
ระบบไฟล์หาย! ทำไม? เพราะฝรั่งรับรู้ว่าคุณรวมเพจของเขาด้วย
และกำลังใช้ ePerl และใส่ ``" ง่ายๆ "'' ในของเขา
หน้าหนังสือ. คิดเกี่ยวกับมัน ไม่เคย ใช้ #รวม สำหรับ ใด ๆ DATA ที่ IS ไม่ สังกัด ของคุณ เอง
ควบคุม. ให้ใช้ "#sinclude" แทนในสถานการณ์เช่นนี้

"#ไม่รวมเส้นทาง"
นี่คือรูปแบบที่ปลอดภัยของ "#include" โดยหลังจากอ่านข้อมูลจาก เส้นทาง ทั้งหมด
ePerl ตัวคั่นเริ่มต้นและสิ้นสุดจะถูกลบออก บล็อก ePerl ที่มีความเสี่ยงจึงสูญเสียความหมายไป
และถูกแปลงเป็นข้อความธรรมดา ใช้คำสั่งนี้เสมอเมื่อคุณต้องการรวม
ข้อมูลที่ไม่ได้อยู่ภายใต้การควบคุมของคุณเอง

"#if expr", "#elsif expr", "#else", "#endif"
สิ่งเหล่านี้ใช้โครงสร้าง "#if-[#else-]#endif" สไตล์ CPP แต่มีความหมาย Perl
ในขณะที่คำสั่งอื่น ๆ เป็นคำสั่งตัวประมวลผลล่วงหน้าจริงซึ่งได้รับการประเมินที่
ขั้นตอนก่อนการประมวลผล โครงสร้างนี้จริง ๆ แล้วเพิ่งเปลี่ยนเป็น ePerl . ระดับต่ำ
สร้างจึงเป็นเช่นนั้น ไม่ ประเมินจริงในขั้นตอนก่อนการประมวลผล มันเป็นแค่เ
ทางลัดที่สะดวกสำหรับสิ่งต่อไปนี้ (โดยที่ BD เป็นตัวคั่นเริ่มต้นที่ใช้อยู่ในปัจจุบันและ
ED ตัวคั่นท้าย):

``#if expr'' -> ``BD if (expr) { _ ED//''
``#elsif expr'' -> ``BD } elsif (expr) { _ ED//''
``#else'' -> ``BD } อื่น { _ ED//''
``#endif'' -> ``BD } _ ED//''

ข้อดีของแนวทางที่ไม่ธรรมดานี้คือเงื่อนไข if นั้นสามารถเป็นจริงได้ทุกอย่าง
นิพจน์ Perl ซึ่งให้ความยืดหยุ่นสูงสุด ข้อเสียคือคุณ
ไม่สามารถใช้ if-construct เพื่อทำการตัดสินใจก่อนการประมวลผลที่แท้จริงได้ อย่างที่คุณเห็น
เป้าหมายการออกแบบเป็นเพียงเพื่อให้ชวเลขสำหรับโครงสร้าง Perl ที่ซับซ้อนมากขึ้น

"#ค"
นี่คือคำสั่งความคิดเห็นซึ่งเพิ่งทิ้งข้อมูลทั้งหมดจนถึงและรวมถึง
อักขระขึ้นบรรทัดใหม่ ใช้สิ่งนี้เพื่อแสดงความคิดเห็นเกี่ยวกับสิ่งต่าง ๆ แม้แต่ตัวประมวลผลล่วงหน้าอื่น ๆ
แนวทาง

ภาพถ่าย ฟังก์ชั่น
กว่าจะรู้ว่าคุณเข้าใจว่า ePerl มีสิ่งอำนวยความสะดวกที่ดีในการฝังโค้ด Perl ลงใน
ข้อมูล ASCII ใดๆ แต่ตอนนี้ คำถามทั่วไปคือ: รหัส Perl ใดที่สามารถใส่ลงในสิ่งเหล่านี้ได้
ePerl บล็อกและ ePerl มีฟังก์ชันพิเศษภายในบล็อก ePerl เหล่านี้หรือไม่

คำตอบคือ อันดับแรก ให้คุณใส่จริงๆ ใด รหัส Perl ลงในบล็อก ePerl ซึ่งเป็น
ใช้ได้กับล่าม Perl ที่เชื่อมโยงกับ ePerl ประการที่สอง ePerl ทำ ไม่ ให้ใดๆ
ฟังก์ชันพิเศษภายในบล็อก ePerl เหล่านี้ เนื่องจาก Perl มีความซับซ้อนอยู่แล้ว
เพียงพอ ;-)

ความหมายของสิ่งนี้คือ: เนื่องจากคุณสามารถใช้รหัส Perl ที่ถูกต้องใด ๆ ที่คุณสามารถใช้ได้
โมดูล Perl 5 ที่มีอยู่ทั้งหมด แม้กระทั่งโมดูลที่ใช้วัตถุที่ใช้ร่วมกัน (เพราะ ePerl is a
ล่าม Perl รวมถึงการสนับสนุน DynaLoader) ดังนั้น เรียกดู Perl . ที่ครอบคลุม
Archive Network (CPAN) ผ่าน http://www.perl.com/perl/CPAN และคว้าแพ็คเกจที่คุณชื่นชอบ
ที่สามารถทำให้ชีวิตของคุณง่ายขึ้น (ทั้งจากภายในสคริปต์ Perl ธรรมดา และ สคริปต์ ePerl)
และเพียงแค่ใช้โครงสร้าง ``"use name;"'' ในบล็อก ePerl ใด ๆ เพื่อใช้จากภายใน
อีเมลล์

เมื่อใช้ ePerl เป็นภาษาสคริปต์ฝั่งเซิร์ฟเวอร์ ฉันแนะนำให้คุณติดตั้งที่
อย่างน้อยแพ็คเกจ CGI.น (ปัจจุบันเป็นเวอร์ชั่น 2.36) HTML-สตรีม (1.40) ลิบเน็ต (1.0505) และ
libwww-perl (5.08). เมื่อคุณต้องการสร้างภาพแบบทันทีทันใดเช่นกัน ผมแนะนำคุณ
ติดตั้งเพิ่มเติมอย่างน้อย GD (1.14) และ ขนาดรูปภาพ (2.3) ล่าม ePerl ใน
ร่วมกับโมดูล Perl 5 ที่ซับซ้อนจริงๆ เหล่านี้จะช่วยให้คุณได้รับสูงสุด
ความยืดหยุ่นและการทำงาน กล่าวอีกนัยหนึ่ง: ทำ ใช้ of สูงสุด ซอฟต์แวร์ เงินกู้เพื่อการลงทุน (Leverage) สูงสุด in
แฮกเกอร์ โลก of Perl as ยิ่งใหญ่ as เป็นไปได้.

OPTIONS

-d พร้อมชื่อ=ความคุ้มค่า
ตั้งค่าตัวแปร Perl ในแพ็คเกจ "main" ซึ่งสามารถอ้างอิงได้ผ่าน $name หรือ more
อย่างชัดเจนผ่าน $main::name คำสั่ง

eperl -d ชื่อ=ค่า ..

เท่ากับมี



at the beginning of ไฟล์อินพุต. ตัวเลือกนี้สามารถเกิดขึ้นได้มากกว่าหนึ่งครั้ง

-D พร้อมชื่อ=ความคุ้มค่า
ตั้งค่าตัวแปรสภาพแวดล้อมซึ่งสามารถอ้างอิงได้ผ่าน $ENV{'variable'} ภายใน
บล็อก Perl คำสั่ง

eperl -D ชื่อ=ค่า ..

เท่ากับ

ชื่อการส่งออก=ค่า; เอิร์ล ...

แต่ข้อดีของตัวเลือกนี้คือไม่ควบคุมผู้โทร
สิ่งแวดล้อม. ตัวเลือกนี้สามารถเกิดขึ้นได้มากกว่าหนึ่งครั้ง

-B start_delimiter
ตั้งค่าบล็อก Perl เริ่มต้นสตริงตัวคั่น ใช้สิ่งนี้ร่วมกับ "-E" เพื่อตั้งค่า
ตัวคั่นที่แตกต่างกันเมื่อใช้ ePerl เป็นภาษาสร้าง HTML แบบออฟไลน์ในขณะที่ยังคง
ใช้เป็นภาษาสคริปต์ HTML ออนไลน์ ตัวคั่นเริ่มต้นคือ " "
สำหรับโหมด CGI และ "<:" และ ":>" สำหรับโหมดการกรอง Unix แบบสแตนด์อโลน

คุณสามารถเลือกรูปแบบต่างๆ ได้มากมาย: ""<:"" และ "":>"" (the
ตัวคั่นโหมดการกรองแบบสแตนด์อโลน ePerl เริ่มต้น), "" "" (ค่าเริ่มต้น
ตัวคั่นโหมดอินเทอร์เฟซ ePerl CGI), "" "" and "" ""
(รูปแบบภาษาสคริปต์ HTML มาตรฐาน), "" "" and
"" "" (HTML3.2+ หรือรูปแบบ Cougar ที่กำลังจะเปิดตัว), "" "" และ "" ""
(สไตล์เหมือน HTML), "" "" (สไตล์ NeoScript และ SSI) หรือ
สม่ำเสมอ "" "" (รูปแบบ PHP/FI แต่ไม่แนะนำอีกต่อไปเพราะสามารถทำได้
นำไปสู่ปัญหาการแยกวิเคราะห์ ควรใช้สำหรับความเข้ากันได้ย้อนหลังกับ ePerl . รุ่นเก่าเท่านั้น
รุ่น 1.x)

ตัวคั่นเริ่มต้นและสิ้นสุดจะค้นหาตัวพิมพ์เล็กและตัวพิมพ์ใหญ่

-E end_delimiter
ตั้งค่าสตริงตัวคั่นสิ้นสุดบล็อก Perl ดูตัวเลือกเพิ่มเติม -B.

-i บังคับให้ตัวคั่นเริ่มต้นและสิ้นสุดเพื่อค้นหาตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ใช้สิ่งนี้เมื่อ
คุณกำลังใช้ตัวคั่นเช่น ``" "..." "'' หรือข้อความอื่นๆ

-m โหมด
สิ่งนี้บังคับให้ ePerl ดำเนินการในโหมดรันไทม์เฉพาะ ดูรายละเอียดด้านบน
คำอธิบายของสามโหมดที่เป็นไปได้: ตัวกรองแบบสแตนด์อโลน (โหมด="f" เช่น ตัวเลือก
-MF), โหมดอินเตอร์เฟส CGI/1.1 (โหมด="c" เช่นตัวเลือก -mc) หรืออินเทอร์เฟซ NPH-CGI/1.1
โหมด (โหมด="n" เช่น ตัวเลือก -ม).

-o ไฟล์เอาต์พุต
บังคับให้เขียนผลลัพธ์ไปยัง ไฟล์เอาต์พุต แทน STDOUT. ใช้ตัวเลือกนี้เมื่อ
โดยใช้ ePerl เป็นตัวกรอง ไฟล์เอาต์พุต ``-'' ชุด STDOUT เป็นตัวจัดการเอาต์พุต
อย่างชัดเจน โปรดสังเกตว่าไฟล์นี้สัมพันธ์กับไดเร็กทอรีไฟล์ต้นทางเมื่อไฟล์
โหมดรันไทม์ถูกบังคับให้เป็น CGI หรือ NPH-CGI

-k บังคับให้ ePerl เก็บไดเร็กทอรีการทำงานปัจจุบันจากจุดเริ่มต้น ต่อ
ePerl เริ่มต้นจะเปลี่ยนเป็นไดเร็กทอรีที่ไฟล์ที่จะดำเนินการอยู่ นี้
ตัวเลือกจะมีประโยชน์หากคุณใช้ ePerl เป็นตัวกรองออฟไลน์ในไฟล์ชั่วคราว

-x ตั้งค่าโหมดแก้ไขข้อบกพร่องที่ ePerl ส่งออกสคริปต์ Perl ที่สร้างขึ้นภายในไปยัง
คอนโซล (/dev/tty) ก่อนดำเนินการ สำหรับการดีบักปัญหากับ inputfile . เท่านั้น
การแปลง

-I ไดเรกทอรี
ระบุไดเร็กทอรีที่ใช้สำหรับคำสั่ง "#include" และ "#sinclude" ของ
ตัวประมวลผลล่วงหน้า ePerl และเพิ่มลงใน @INC ภายใต้รันไทม์ ตัวเลือกนี้สามารถเกิดขึ้นได้มากกว่านี้
มากกว่าหนึ่งครั้ง

-P เปิดใช้งานตัวประมวลผลล่วงหน้า ePerl พิเศษด้วยตนเอง (ดูด้านบน) เปิดใช้งานตัวเลือกนี้แล้ว
สำหรับโหมด CGI ทั้งหมดโดยอัตโนมัติ

-C สิ่งนี้ทำให้สามารถแปลงเอนทิตี HTML สำหรับบล็อก ePerl ตัวเลือกนี้เป็นไปโดยอัตโนมัติ
บังคับในโหมด CGI

ปัญหาที่แก้ไขได้มีดังต่อไปนี้: เมื่อคุณใช้ ePerl เป็นฝั่งเซิร์ฟเวอร์-
ภาษาสคริปต์สำหรับหน้า HTML และคุณแก้ไขไฟล์ต้นฉบับ ePerl ผ่าน HTML
บรรณาธิการ มีโอกาสสูงที่โปรแกรมแก้ไขของคุณจะแปลอักขระบางตัวที่ป้อนเป็น HTML
เอนทิตี เช่น ``"<"'' ถึง ``"<"'' สิ่งนี้นำไปสู่รหัส Perl ที่ไม่ถูกต้องภายใน
ePerl บล็อก เนื่องจากตัวแก้ไข HTML ไม่มีความรู้เกี่ยวกับบล็อก ePerl ใช้สิ่งนี้
ตัวเลือก parser ePerl จะแปลงเอนทิตีทั้งหมดที่พบในบล็อค ePerl โดยอัตโนมัติ
กลับไปเป็นอักขระธรรมดา ดังนั้นตัวแปล Perl จึงได้รับบล็อกโค้ดที่ถูกต้องอีกครั้ง

-L ซึ่งจะทำให้อักขระต่อบรรทัด ``"\"'' (แบ็กสแลช) อยู่นอกบล็อก ePerl
ด้วยตัวเลือกนี้ คุณสามารถกระจายข้อมูลแบบบรรทัดเดียวไปหลายบรรทัดได้ แต่ใช้ด้วยความระมัดระวัง: นี่
ตัวเลือกเปลี่ยนข้อมูลของคุณ (นอกบล็อก ePerl) โดยปกติ ePerl จะผ่านจริงๆ
ข้อมูลโดยรอบทั้งหมดเป็นข้อมูลดิบ ด้วยตัวเลือกนี้ การขึ้นบรรทัดใหม่จะกลายเป็นความหมายใหม่

-T สิ่งนี้เปิดใช้งาน Perl's เทนติ้ง โหมด โดยที่ล่าม Perl ใช้ความระมัดระวังเป็นพิเศษ
เรียกว่า การตรวจสอบมลทิน เพื่อป้องกันกับดักที่ชัดแจ้งและละเอียดอ่อน ดู เพิร์ล(1) สำหรับเพิ่มเติม
รายละเอียด

-w สิ่งนี้เปิดใช้งานการเตือนโดยที่ล่าม Perl สร้างการวินิจฉัยที่น่ารัก ดู
ยอดเยี่ยม(1) สำหรับรายละเอียดเพิ่มเติม

-c สิ่งนี้จะเรียกใช้การตรวจสอบไวยากรณ์ล้วนๆ ซึ่งคล้ายกับ ``"perl -c"''

-r สิ่งนี้จะพิมพ์ไฟล์ ePerl README ภายในไปยังคอนโซล

-l สิ่งนี้จะพิมพ์ไฟล์ ePerl LICENSE ภายในไปยังคอนโซล

-v สิ่งนี้จะพิมพ์ข้อมูลเวอร์ชัน ePerl ไปยังคอนโซล

-V เช่นเดียวกับตัวเลือก -v แต่แสดงพารามิเตอร์การคอมไพล์ Perl เพิ่มเติม

และพวกเรา

เคย ตัวแปร
"PATH_TRANSLATED"
ตัวแปร CGI/1.1 นี้ใช้เพื่อกำหนดซอร์สไฟล์เมื่อ ePerl ทำงานเป็นa
โปรแกรม NPH-CGI/1.1 ภายใต้สภาวะแวดล้อมของเว็บเซิร์ฟเวอร์

ภาพถ่าย ตัวแปร
"SCRIPT_SRC_PATH"
ชื่อพาธสัมบูรณ์ของสคริปต์ ใช้สิ่งนี้เมื่อคุณต้องการเข้าถึง .โดยตรง
สคริปต์จากภายในตัวมันเอง เช่น ทำ "stat()" และการเรียกอื่นๆ

"SCRIPT_SRC_PATH_DIR"
ส่วนไดเร็กทอรีของ "SCRIPT_SRC_PATH" ใช้อันนี้เมื่อคุณต้องการเข้าถึงโดยตรง
ไฟล์อื่นๆ ที่อยู่ในไดเร็กทอรีเดียวกันกับสคริปต์ เช่น อ่าน config
ไฟล์ ฯลฯ

"SCRIPT_SRC_PATH_FILE"
ส่วนชื่อไฟล์ของ "SCRIPT_SRC_PATH" ใช้อันนี้เมื่อคุณต้องการชื่อของ
สคริปต์ เช่น การอ้างอิงตนเองแบบสัมพัทธ์ผ่าน URL

"SCRIPT_SRC_URL"
URL ที่มีคุณสมบัติครบถ้วนของสคริปต์ ใช้สิ่งนี้เมื่อคุณต้องการ URL สำหรับตนเอง
การอ้างอิง

"SCRIPT_SRC_URL_DIR"
ส่วนไดเรกทอรีของ "SCRIPT_SRC_URL" ใช้อันนี้เมื่อคุณต้องการเข้าถึงโดยตรง
ไฟล์อื่นๆ ที่อยู่ในไดเร็กทอรีเดียวกันกับสคริปต์ผ่านเว็บ เช่น to
ภาพอ้างอิง ฯลฯ

"SCRIPT_SRC_URL_FILE"
ส่วนชื่อไฟล์ของ "SCRIPT_SRC_URL" ใช้อันนี้เมื่อคุณต้องการชื่อของ
สคริปต์ เช่น การอ้างอิงตนเองแบบสัมพัทธ์ผ่าน URL จริงๆแล้วเหมือนกับ
"SCRIPT_SRC_PATH_FILE" แต่ให้ไว้เพื่อความสอดคล้อง

"SCRIPT_SRC_SIZE"
ขนาดไฟล์ของสคริปต์ หน่วยเป็นไบต์

"SCRIPT_SRC_MODIFIED"
เวลาแก้ไขล่าสุดของสคริปต์ หน่วยเป็นวินาทีตั้งแต่ 0 ชั่วโมง 0 นาที 0
วินาที 1 มกราคม 1970 เวลาสากลเชิงพิกัด

"SCRIPT_SRC_MODIFIED_CTIME"
เวลาแก้ไขล่าสุดของสคริปต์ ใน เวลา(3) รูปแบบ (``WDAY MMM DD HH:MM:SS
ปปปป\n'')

"SCRIPT_SRC_MODIFIED_ISOTIME"
เวลาแก้ไขล่าสุดของสคริปต์ ในรูปแบบ ISO (``DD-MM-YYYY HH:MM'')

"SCRIPT_SRC_OWNER"
ชื่อผู้ใช้ของเจ้าของสคริปต์

"VERSION_INTERPRETER"
สตริงการระบุ ePerl

"VERSION_LANGUAGE"
สตริงการระบุของไลบรารีล่าม Perl ที่ใช้

ภาพถ่าย Built-In ภาพ
รูปภาพในตัวต่อไปนี้สามารถเข้าถึงได้ผ่าน URL "/url/to/nph-eperl/"ชื่อ".gif":

"logo.gif"
โลโก้ ePerl มาตรฐาน โปรดอย่ารวมสิ่งนี้ไว้ในเว็บไซต์ของคุณ

"powered.gif"
``ขับเคลื่อน by อีเพิร์ล 2.2'' โลโก้ รู้สึกอิสระที่จะใช้สิ่งนี้บนเว็บไซต์ของคุณ

ใช้ eperl ออนไลน์โดยใช้บริการ onworks.net