perlfilterp - آنلاین در ابر

برنامه:

نام

perlfilter - فیلترهای منبع

شرح

این مقاله در مورد ویژگی کمتر شناخته شده پرل به نام است منبع فیلترها برای تصفیه آب. فیلترهای منبع
متن برنامه یک ماژول را قبل از اینکه پرل ببیند، تغییر دهید، دقیقاً همانطور که یک پیش پردازنده C تغییر می دهد
متن منبع یک برنامه C قبل از اینکه کامپایلر آن را ببیند. این مقاله بیشتر به شما می گوید
در مورد اینکه فیلترهای منبع چیست، چگونه کار می کنند و چگونه فیلترهای خود را بنویسید.

هدف اصلی فیلترهای منبع این بود که به شما اجازه دهند منبع برنامه خود را رمزگذاری کنید
جلوگیری از دزدی دریایی اتفاقی این تنها کاری نیست که آنها می توانند انجام دهند، همانطور که به زودی یاد خواهید گرفت. اما ابتدا،
اصول اولیه

مفاهیم

قبل از اینکه مفسر Perl بتواند یک اسکریپت Perl را اجرا کند، ابتدا باید آن را از یک فایل بخواند
به حافظه برای تجزیه و کامپایل. اگر خود آن اسکریپت شامل اسکریپت های دیگری با
یک عبارت "استفاده" یا "نیاز"، سپس هر یک از آن اسکریپت ها باید از روی آنها خوانده شود
فایل های مربوطه نیز

اکنون هر ارتباط منطقی بین تجزیه کننده پرل و یک فایل جداگانه را به عنوان یک در نظر بگیرید
منبع جریان. هنگامی که تجزیه کننده Perl یک فایل را باز می کند، یک جریان منبع ایجاد می شود و ادامه می یابد
زمانی که کد منبع در حافظه خوانده می‌شود وجود داشته باشد، و پس از پایان پرل از بین می‌رود
تجزیه فایل اگر تجزیه کننده در یک منبع با عبارت "require" یا "use" مواجه شود
stream، یک جریان جدید و متمایز فقط برای آن فایل ایجاد می شود.

نمودار زیر یک جریان منبع منفرد را نشان می دهد که جریان منبع از یک Perl است
فایل اسکریپت در سمت چپ به تجزیه کننده پرل در سمت راست. پرل به طور معمول اینگونه است
عمل می کند

فایل -------> تجزیه کننده

دو نکته مهم را باید به خاطر بسپارید:

1. اگرچه در هر زمان ممکن است تعداد زیادی جریان منبع وجود داشته باشد،
فقط یکی فعال خواهد بود

2. هر جریان منبع فقط با یک فایل مرتبط است.

فیلتر منبع نوع خاصی از ماژول پرل است که منبع را رهگیری و تغییر می دهد
جریان قبل از اینکه به تجزیه کننده برسد. یک فیلتر منبع، نمودار ما را به صورت زیر تغییر می دهد:

فایل ----> فیلتر ----> تجزیه کننده

اگر چندان منطقی نیست، تشبیه خط لوله فرمان را در نظر بگیرید. بگو داری
یک پوسته اسکریپت ذخیره شده در فایل فشرده trial.gz. دستور ساده خط لوله زیر
اسکریپت را بدون نیاز به ایجاد یک فایل موقت برای نگهداری فایل فشرده نشده اجرا می کند.

gunzip -c trial.gz | ش

در این مورد، جریان داده از خط لوله را می توان به صورت زیر نشان داد:

trial.gz ----> gunzip ----> sh

با فیلترهای منبع، می توانید متن اسکریپت خود را به صورت فشرده ذخیره کنید و از یک منبع استفاده کنید
فیلتر کنید تا آن را برای تجزیه کننده پرل از حالت فشرده خارج کنید:

گیره فشرده
برنامه پرل ---> فیلتر منبع ---> تجزیه کننده

استفاده كردن فیلتر

بنابراین چگونه می توان از یک فیلتر منبع در اسکریپت پرل استفاده کرد؟ بالا گفتم فیلتر سورس هست
فقط یک نوع خاص از ماژول. مانند همه ماژول های پرل، یک فیلتر منبع با یک فراخوانی می شود
استفاده از بیانیه

فرض کنید می خواهید منبع Perl خود را قبل از اجرا از طریق پیش پردازنده C منتقل کنید. همانطور که آن را
اتفاق می افتد، توزیع فیلترهای منبع با یک ماژول فیلتر پیش پردازنده C به نام ارائه می شود
فیلتر::cpp.

در زیر یک برنامه نمونه، "cpp_test" است که از این فیلتر استفاده می کند. شماره خطوط
اضافه شده اند تا به خطوط خاصی به راحتی ارجاع داده شوند.

1: استفاده از Filter::cpp;
2: #define TRUE 1
3: $a = TRUE;
4: چاپ "a = $a\n"؛

هنگامی که این اسکریپت را اجرا می کنید، پرل یک جریان منبع برای فایل ایجاد می کند. قبل از تجزیه کننده
هر یک از خطوط فایل را پردازش می کند، جریان منبع به شکل زیر است:

cpp_test ---------> تجزیه کننده

خط 1، "use Filter::cpp"، شامل و ماژول فیلتر "cpp" را نصب می کند. همه منبع
فیلترها به این صورت عمل می کنند. دستور use در زمان کامپایل، قبل از آن، کامپایل و اجرا می شود
هر فایل دیگری خوانده می شود و فیلتر cpp را به جریان منبع پشت سر متصل می کند
صحنه. حالا جریان داده به این صورت است:

cpp_test ----> فیلتر cpp ----> تجزیه کننده

همانطور که تجزیه کننده خطوط دوم و بعدی را از جریان منبع می خواند، آنها را تغذیه می کند
خطوط را قبل از پردازش از فیلتر منبع "cpp" عبور دهید. فیلتر "cpp" به سادگی
هر خط را از پیش پردازنده واقعی C عبور می دهد. خروجی از پیش پردازنده C است
سپس توسط فیلتر دوباره به جریان منبع وارد می شود.

.-> cpp --.
| |
| |
| <-'
cpp_test ----> فیلتر cpp ----> تجزیه کننده

سپس تجزیه کننده کد زیر را می بیند:

از فیلتر::cpp;
$ a = 1؛
چاپ "a = $a\n"؛

بیایید در نظر بگیریم که چه اتفاقی می‌افتد وقتی کد فیلتر شده شامل ماژول دیگری با استفاده باشد:

1: استفاده از Filter::cpp;
2: #define TRUE 1
3: از فرد استفاده کنید.
4: $a = TRUE;
5: چاپ "a = $a\n"؛

فیلتر "cpp" برای متن ماژول Fred اعمال نمی شود، فقط به متن مربوط می شود
فایلی که از آن استفاده کرده است ("cpp_test"). اگر چه دستور use در خط 3 از طریق
فیلتر cpp، ماژولی که شامل می شود ("فرد") نمی شود. جریان های منبع به نظر می رسد
این بعد از تجزیه خط 3 و قبل از تجزیه خط 4:

cpp_test ---> فیلتر cpp ---> تجزیه کننده (غیر فعال)

Fred.pm ----> تجزیه کننده

همانطور که می بینید جریان جدیدی برای خواندن منبع از "Fred.pm" ایجاد شده است. این
تا زمانی که تمام "Fred.pm" تجزیه نشود، جریان فعال باقی خواهد ماند. جریان منبع برای
"cpp_test" همچنان وجود خواهد داشت، اما غیر فعال است. هنگامی که تجزیه کننده خواندن را به پایان رساند
Fred.pm، جریان منبع مرتبط با آن از بین خواهد رفت. جریان منبع برای
سپس "cpp_test" دوباره فعال می شود و تجزیه کننده خط 4 و خطوط بعدی را از
"cpp_test".

شما می توانید از بیش از یک فیلتر منبع در یک فایل استفاده کنید. به طور مشابه، شما می توانید دوباره استفاده کنید
همان فیلتر در هر تعداد فایلی که دوست دارید.

به عنوان مثال، اگر یک فایل منبع uuencod شده و فشرده دارید، می توانید a را پشته کنید
فیلتر uudecode و فیلتر غیر فشرده سازی مانند زیر:

استفاده از Filter::uudecode; استفاده از Filter::uncompress;
M'XL(".H<US4''V9I;F%L')Q;>7/;1I;_>_I3=&E=%:F*I"T?22Q/
M6]9*
...

هنگامی که خط اول پردازش شد، جریان به شکل زیر خواهد بود:

فایل ---> uudecode ---> فشرده سازی ---> تجزیه کننده
فیلتر فیلتر

داده ها از طریق فیلترها به همان ترتیبی که در فایل منبع ظاهر می شوند جریان می یابد. uudcode
فیلتر قبل از فیلتر غیرفشرده ظاهر شده است، بنابراین فایل منبع قبلا uudecode می شود
فشرده نشده است

نوشتن A SOURCE FILTER

سه راه برای نوشتن فیلتر منبع خود وجود دارد. می توانید آن را به زبان C بنویسید، از an استفاده کنید
برنامه خارجی به عنوان فیلتر، یا فیلتر را در Perl بنویسید. من دو مورد اول را پوشش نمی دهم
هر جزئیات عالی، بنابراین من آنها را از سر راه اول. نوشتن فیلتر در پرل است
راحت ترین، بنابراین من بیشترین فضا را به آن اختصاص خواهم داد.

نوشتن A SOURCE FILTER IN C

اولین مورد از سه تکنیک موجود نوشتن فیلتر به طور کامل در C. The است
ماژول خارجی مستقیماً با قلاب های فیلتر منبع ارائه شده توسط، رابط ایجاد می کنید
پرل.

مزیت این تکنیک این است که شما کنترل کاملی بر اجرا دارید
از فیلتر شما عیب بزرگ افزایش پیچیدگی مورد نیاز برای نوشتن است
فیلتر - نه تنها باید قلاب های فیلتر منبع را درک کنید، بلکه به یک
دانش معقول از Perl guts. یکی از معدود دفعاتی است که ارزش رفتن به این دردسر را دارد
هنگام نوشتن یک درهم کننده منبع است. فیلتر "رمزگشایی" (که منبع را از حالت رمزگشایی خارج می کند
قبل از اینکه پرل آن را تجزیه کند) همراه با توزیع فیلتر منبع مثالی از یک C است
فیلتر منبع (به فیلترهای رمزگشایی، در زیر مراجعه کنید).

رمزگشایی فیلترها
همه فیلترهای رمزگشایی بر اساس اصل "امنیت از طریق ابهام" کار می کنند.
صرف نظر از اینکه چقدر فیلتر رمزگشایی را خوب می نویسید و رمزگذاری چقدر قوی است
الگوریتم این است که هرکس به اندازه کافی مصمم باشد می تواند کد منبع اصلی را بازیابی کند. را
دلیل آن بسیار ساده است - زمانی که فیلتر رمزگشایی منبع را به آن بازگرداند
شکل اصلی آن، قطعاتی از آن به عنوان Perl در حافظه کامپیوتر ذخیره می شود
آن را تجزیه می کند. منبع ممکن است فقط برای مدت کوتاهی در حافظه باشد، اما هر کسی
داشتن یک دیباگر، مهارت و صبر زیاد در نهایت می تواند شما را بازسازی کند
برنامه است.

با این حال، تعدادی گام وجود دارد که می توان برای سخت کردن زندگی برای آنها انجام داد
کراکر بالقوه مهمترین چیز: فیلتر رمزگشایی خود را با C و بنویسید
به صورت ایستا ماژول رمزگشایی را به باینری پرل پیوند دهید. برای راهنمایی بیشتر
زندگی سخت برای کرکر بالقوه، فایل را ببینید رمزگشایی.pm در منبع
توزیع فیلترها

پدید آوردن A SOURCE FILTER AS A جداگانه، مجزا قابل اجرا

جایگزینی برای نوشتن فیلتر در C این است که یک فایل اجرایی جداگانه در آن ایجاد کنید
زبان انتخابی شما فایل اجرایی جداگانه از ورودی استاندارد می خواند، هر کاری را انجام می دهد
پردازش ضروری است و داده های فیلتر شده را در خروجی استاندارد می نویسد. "Filter::cpp" است
نمونه ای از یک فیلتر منبع که به عنوان یک فایل اجرایی جداگانه پیاده سازی شده است - قابل اجرا همان است
پیش پردازنده C همراه با کامپایلر C شما.

توزیع فیلتر منبع شامل دو ماژول است که این کار را ساده می کند:
"Filter::exec" و "Filter::sh". هر دو به شما امکان می دهند هر فایل اجرایی خارجی را اجرا کنید. هر دو از a استفاده می کنند
پردازش مشترک برای کنترل جریان داده ها به داخل و خارج از فایل اجرایی خارجی. (برای
جزئیات مربوط به فرآیندهای مشترک، به استفنز، WR، "برنامه نویسی پیشرفته در یونیکس" مراجعه کنید
محیط زیست." Addison-Wesley, ISBN 0-210-56317-7, pages 441-445.) تفاوت بین
آنها این است که "Filter::exec" دستور خارجی را مستقیما تولید می کند، در حالی که "Filter::sh"
یک پوسته برای اجرای دستور خارجی ایجاد می کند. (یونیکس از پوسته Bourne استفاده می کند، NT از پوسته استفاده می کند
پوسته cmd.) تخم ریزی یک پوسته به شما امکان می دهد از متاکاراکترهای پوسته و
امکانات تغییر مسیر

در اینجا یک نمونه اسکریپت است که از "Filter::sh" استفاده می کند:

استفاده از Filter::sh 'tr XYZ PQR';
$ a = 1؛
چاپ "XYZ a = $a\n"؛

خروجی که هنگام اجرای اسکریپت دریافت خواهید کرد:

PQR a = 1

نوشتن یک فیلتر منبع به عنوان یک فایل اجرایی جداگانه خوب کار می کند، اما عملکرد کمی دارد
جریمه شده است به عنوان مثال، اگر مثال کوچک بالا را اجرا کنید، یک جداگانه
فرآیند فرعی برای اجرای دستور "tr" یونیکس ایجاد خواهد شد. هر استفاده از فیلتر نیاز دارد
فرآیند فرعی خودش اگر ایجاد فرآیندهای فرعی برای سیستم شما گران است، ممکن است بخواهید
یکی از گزینه های دیگر برای ایجاد فیلترهای منبع را در نظر بگیرید.

نوشتن A SOURCE FILTER IN PERL

ساده ترین و قابل حمل ترین گزینه موجود برای ایجاد فیلتر منبع خود این است که
آن را به طور کامل در پرل بنویسید. برای تمایز این روش از دو تکنیک قبلی، این کار را انجام می دهم
آن را فیلتر منبع پرل بنامید.

برای کمک به درک نحوه نوشتن فیلتر منبع پرل، به یک مثال برای مطالعه نیاز داریم. اینجاست
یک فیلتر منبع کامل که رمزگشایی rot13 را انجام می دهد. (Rot13 یک رمزگذاری بسیار ساده است
طرحی که در پست های یوزنت برای پنهان کردن محتوای پست های توهین آمیز استفاده می شود. هر حرکت می کند
سیزده مکان به جلو، به طوری که A تبدیل به N، B تبدیل به O، و Z تبدیل به M می شود.)

بسته Rot13;

از Filter::Util::Call;

واردات فرعی {
من (نوع $) = @_;
من ($ref) = [];
filter_add(bless $ref);
}

فیلتر فرعی {
من ($self) = @_;
my ($status);

tr/n-za-mN-ZA-M/a-zA-Z/
اگر ($status = filter_read()) > 0;
$status;
}

1;

تمام فیلترهای سورس پرل به صورت کلاس های پرل پیاده سازی می شوند و ساختار اولیه یکسانی دارند
به عنوان مثال بالا

ابتدا ماژول "Filter::Util::Call" را اضافه می کنیم که تعدادی توابع را صادر می کند.
را وارد فضای نام فیلتر خود کنید. فیلتر نشان داده شده در بالا از دو مورد از این عملکردها استفاده می کند.
"filter_add()" و "filter_read()".

در مرحله بعد، شی فیلتر را ایجاد می کنیم و با تعریف عبارت، آن را با جریان منبع مرتبط می کنیم
تابع "واردات". اگر پرل را به اندازه کافی بشناسید، می دانید که «واردات» نامیده می شود
به طور خودکار هر بار که یک ماژول با عبارت use اضافه می شود. این باعث "واردات" می شود
مکان ایده آل برای ایجاد و نصب یک شی فیلتر.

در فیلتر مثال، شی ($ref) مانند هر شیء پرل دیگری برکت است. ما
مثال از یک آرایه ناشناس استفاده می کند، اما این یک الزام نیست. چون این مثال
نیازی به ذخیره هیچ اطلاعات زمینه ای نیست، می توانستیم از اسکالر یا هش استفاده کنیم
مرجع به همین خوبی. بخش بعدی داده های زمینه را نشان می دهد.

ارتباط بین شی فیلتر و جریان منبع با
تابع "filter_add()". این یک شی فیلتر را به عنوان پارامتر می گیرد (در این مورد $ref) و
آن را در جریان منبع نصب می کند.

در نهایت، کدی وجود دارد که در واقع فیلتر کردن را انجام می دهد. برای این نوع منبع پرل
فیلتر، تمام فیلترها به روشی به نام "filter()" انجام می شود. (این امکان نیز وجود دارد
یک فیلتر منبع پرل با استفاده از یک بسته بنویسید. صفحه راهنمای "Filter::Util::Call" را ببینید
جزئیات بیشتر.) هر بار که تجزیه کننده Perl به خط دیگری از منبع نیاز دارد، فراخوانی می شود
روند. متد "filter()" به نوبه خود خطوطی را از جریان منبع با استفاده از آن می خواند
تابع "filter_read()".

اگر خطی از جریان منبع در دسترس بود، "filter_read()" یک مقدار وضعیت را برمی‌گرداند
بزرگتر از صفر است و خط را به $_ اضافه می کند. مقدار وضعیت صفر نشان دهنده پایان
فایل، کمتر از صفر به معنای خطا است. انتظار می رود که خود تابع فیلتر آن را برگرداند
وضعیت را به همین ترتیب، و خط فیلتر شده ای را که می خواهد در جریان منبع نوشته شود قرار دهید
$_. استفاده از $_ برای مختصر بودن بیشتر فیلترهای منبع Perl است.

برای استفاده از فیلتر rot13، به روشی برای رمزگذاری فایل منبع نیاز داریم
فرمت rot13. اسکریپت زیر، "mkrot13" دقیقاً این کار را انجام می دهد.

بمیرید "usage mkrot13 filename\n" مگر اینکه @ARGV;
من $in = $ARGV[0];
my $out = "$in.tmp";
open(IN، "<$in") یا die "فایل $in باز نمی شود: $!\n";
open(OUT, ">$out") یا die "فایل $out باز نمی شود: $!\n";

چاپ کنید "استفاده از Rot13;\n"؛
در حالی که ( ) {
tr/a-zA-Z/n-za-mN-ZA-M/;
چاپ کردن؛
}

بستن IN
بستن
لغو پیوند $in;
تغییر نام $out، $in;

اگر این را با "mkrot13" رمزگذاری کنیم:

چاپ "Hello Fred \n";

نتیجه این خواهد بود:

از Rot13 استفاده کنید.
cevag "uryyb serq\a";

با اجرای آن این خروجی تولید می شود:

سلام فرید

استفاده كردن متن نوشته: L' اشکال زدایی FILTER

مثال rot13 یک مثال بی اهمیت بود. در اینجا تظاهرات دیگری است که چند مورد را نشان می دهد
ویژگی های بیشتر

فرض کنید می‌خواهید در حین توسعه، تعداد زیادی کد اشکال زدایی را در اسکریپت Perl خود وارد کنید،
اما شما نمی خواستید در محصول منتشر شده موجود باشد. فیلترهای منبع راه حلی را ارائه می دهند.
برای ساده نگه داشتن مثال، فرض کنید می خواهید خروجی اشکال زدایی باشد
توسط یک متغیر محیطی، "DEBUG" کنترل می شود. کد اشکال زدایی در صورتی فعال می شود که متغیر باشد
وجود دارد، در غیر این صورت غیرفعال است.

دو خط نشانگر ویژه کد اشکال زدایی را در براکت قرار می دهند، مانند این:

## DEBUG_BEGIN
اگر ($year > 1999) {
هشدار "اشکال زدایی: اشکال هزاره در سال $year\n"؛
}
## DEBUG_END

فیلتر تضمین می‌کند که Perl کد را بین کدها تجزیه می‌کند و "DEBUG_END"
نشانگرها فقط زمانی که متغیر محیطی "DEBUG" وجود داشته باشد. این بدان معناست که وقتی "اشکال زدایی"
وجود دارد، کد بالا باید بدون تغییر از فیلتر عبور داده شود. خطوط نشانگر
همچنین می توان آن را همانطور که هست منتقل کرد، زیرا تجزیه کننده Perl آنها را به عنوان خطوط نظر می بیند.
هنگامی که "DEBUG" تنظیم نشده است، به راهی برای غیرفعال کردن کد اشکال زدایی نیاز داریم. یک راه ساده برای رسیدن به
یعنی خطوط بین دو نشانگر را به کامنت تبدیل کنید:

## DEBUG_BEGIN
#if ($year > 1999) {
# warn "اشکال زدایی: اشکال هزاره در سال $year\n"؛
#}
## DEBUG_END

این فیلتر کامل Debug است:

اشکال زدایی بسته;

سخت استفاده کنید
استفاده از هشدارها؛
از Filter::Util::Call;

استفاده از ثابت TRUE => 1;
استفاده از ثابت FALSE => 0;

واردات فرعی {
من (نوع $) = @_;
من (%context) = (
فعال => $ENV{DEBUG} تعریف شده،
InTraceBlock => FALSE،
نام فایل => (تماس گیرنده)[1]،
خط شماره => 0،
LastBegin => 0،
);
filter_add(bless \%context);
}

زیر مرگ {
my ($self) = shift;
my ($message) = shift;
my ($line_no) = shift || $self->{LastBegin};
die "$message در $self->{Filename} خط $line_no.\n"
}

فیلتر فرعی {
من ($self) = @_;
my ($status);
$status = filter_read();
++ $self->{LineNo};

# ابتدا با EOF/error مقابله کنید
if ($status <= 0) {
$self->Die ("DEBUG_BEGIN DEBUG_END ندارد")
اگر $self->{InTraceBlock};
بازگشت وضعیت $;
}

if ($self->{InTraceBlock}) {
if (/^\s*##\s*DEBUG_BEGIN/ ) {
$self->Die ("DEBUG_BEGIN تودرتو"، $self->{LineNo})
} elif (/^\s*##\s*DEBUG_END/) {
$self->{InTraceBlock} = FALSE;
}

وقتی فیلتر غیرفعال است، خطوط اشکال زدایی را نظر دهید
s/^/#/ اگر ! $self->{فعال};
} elif ( /^\s*##\s*DEBUG_BEGIN/ ) {
$self->{InTraceBlock} = TRUE;
$self->{LastBegin} = $self->{LineNo};
} elif ( /^\s*##\s*DEBUG_END/ ) {
$self->Die("DEBUG_END DEBUG_BEGIN ندارد"، $self->{LineNo});
}
بازگشت وضعیت $;
}

1;

تفاوت بزرگ این فیلتر با مثال قبلی استفاده از داده های زمینه است
در شی فیلتر شی فیلتر بر اساس یک مرجع هش است و برای نگهداری استفاده می شود
بخش های مختلف اطلاعات زمینه بین تماس های تابع فیلتر. همه به جز دو تا
از فیلدهای هش برای گزارش خطا استفاده می شود. اولین مورد از آن دو، Enabled، توسط استفاده می شود
فیلتر برای تعیین اینکه آیا کد اشکال زدایی باید به تجزیه کننده Perl داده شود یا خیر. در
دوم، InTraceBlock، زمانی درست است که فیلتر با خط "DEBUG_BEGIN" روبرو شود، اما
هنوز با خط زیر "DEBUG_END" روبرو نشده است.

اگر تمام خطاهای بررسی بیشتر کدها را نادیده بگیرید، اصل فیلتر است
به شرح زیر است:

فیلتر فرعی {
من ($self) = @_;
my ($status);
$status = filter_read();

# ابتدا با EOF/error مقابله کنید
اگر $status <= 0;
if ($self->{InTraceBlock}) {
if (/^\s*##\s*DEBUG_END/) {
$self->{InTraceBlock} = FALSE
}

وقتی فیلتر غیرفعال است، خطوط اشکال زدایی را نظر دهید
s/^/#/ اگر ! $self->{فعال};
} elif ( /^\s*##\s*DEBUG_BEGIN/ ) {
$self->{InTraceBlock} = TRUE;
}
بازگشت وضعیت $;
}

هشدار داده شود: همانطور که پیش پردازنده C C را نمی شناسد، فیلتر Debug نیز Perl را نمی شناسد.
به راحتی می توان آن را فریب داد:

چاپ <
##DEBUG_BEGIN
EOM

به کنار چنین چیزهایی، می توانید ببینید که با مقدار کمی کد می توان به چیزهای زیادی دست یافت.

نتیجه گیری

اکنون درک بهتری از چیستی فیلتر منبع دارید و حتی ممکن است یک فیلتر منبع داشته باشید
استفاده ممکن برای آنها اگر دوست دارید با فیلترهای منبع بازی کنید اما به کمی نیاز دارید
در اینجا چند ویژگی اضافی وجود دارد که می توانید به فیلتر Debug اضافه کنید.

اول، یکی آسان. به جای داشتن کد اشکال زدایی که همه یا هیچ است، می تواند باشد
بسیار مفیدتر است که بتوانید کنترل کنید کدام بلوک های خاص کد اشکال زدایی دریافت می شود
مشمول. سعی کنید سینتکس بلوک های اشکال زدایی را گسترش دهید تا امکان شناسایی هر کدام را فراهم کنید. در
سپس می توان از محتویات متغیر محیطی "DEBUG" برای کنترل اینکه کدام بلوک دریافت می شود استفاده کرد
گنجانده شده است.

هنگامی که بتوانید تک تک بلوک ها را شناسایی کنید، سعی کنید به آنها اجازه دهید تو در تو باشند. این نیست
دشوار است.

در اینجا یک ایده جالب وجود دارد که شامل فیلتر Debug نمی شود. در حال حاضر پرل
زیر روال ها پشتیبانی نسبتاً محدودی از لیست پارامترهای رسمی دارند. می توانید مشخص کنید
تعداد پارامترها و نوع آنها، اما همچنان باید آنها را به صورت دستی از آن خارج کنید
@_ خود را آرایه کنید. یک فیلتر منبع بنویسید که به شما امکان می دهد لیست پارامترهای نامگذاری شده داشته باشید.
چنین فیلتری این را تبدیل می کند:

زیر MySub ($first، $second، @rest) { ... }

به این:

زیر MySub ($$@) {
my ($first) = shift;
my ($second) = shift;
من (@rest) = @_;
...
}

در نهایت، اگر احساس می‌کنید یک چالش واقعی هستید، سعی کنید یک ماکرو پرل کامل بنویسید
پیش پردازنده به عنوان فیلتر منبع ویژگی های مفید را از پیش پردازنده C قرض بگیرید و
هر پردازنده ماکرو دیگری که می شناسید. نکته دشوار انتخاب میزان دانش است
سینتکس پرل که می خواهید فیلتر شما داشته باشد.

محدودیت ها

فیلترهای منبع فقط در سطح رشته کار می کنند، بنابراین توانایی آن بسیار محدود است
تغییر کد منبع در پرواز این نمی تواند نظرات، رشته های نقل قول شده، هردوک را تشخیص دهد
بدون جایگزینی برای تجزیه کننده واقعی تنها استفاده پایدار برای فیلترهای منبع هستند
رمزگذاری، فشرده سازی، یا بایت لودر، برای ترجمه کد باینری به کد منبع.

برای مثال محدودیت‌های Switch را ببینید که از فیلترهای منبع استفاده می‌کند، و بنابراین چنین نیست
کار در داخل یک eval رشته، وجود رجکس با خطوط جدید تعبیه شده که هستند
با جداکننده های خام "/.../" مشخص شده و اصلاح کننده "//x" ندارند.
غیر قابل تشخیص از تکه های کد که با عملگر تقسیم "/" شروع می شود. به عنوان یک
راه حل شما باید از "m/.../" یا "m?...?" برای چنین الگوهایی همچنین حضور
رجکس‌های مشخص شده با خام "?...?" تعیین کننده ها ممکن است باعث خطاهای مرموز شوند. راه حل
استفاده از "m؟...?" بجای. دیدنhttp://search.cpan.org/perldoc?Switch#LIMITATIONS>

در حال حاضر محتوای بلوک "__DATA__" فیلتر نشده است.

در حال حاضر طول بافر داخلی فقط به 32 بیت محدود شده است.

چیزها به نگاه OUT برای

برخی از فیلترها دسته "DATA" را زیر و رو می کنند
برخی از فیلترهای منبع از دسته "DATA" برای خواندن برنامه تماس استفاده می کنند. هنگام استفاده از
این فیلترهای منبع را نمی‌توانید بر این دسته تکیه کنید و انتظار نوع خاصی از آن را نداشته باشید
رفتار هنگام عمل بر روی آن فیلترها بر اساس Filter::Util::Call (و بنابراین
Filter::Simple) فایل "DATA" را تغییر ندهید، اما از طرف دیگر کاملاً
متن بعد از "__DATA__" را نادیده بگیرید.

الزامات

توزیع فیلتر منبع در CPAN در دسترس است

CPAN / ماژول / توسط ماژول / فیلتر

شروع از Perl 5.8 Filter::Util::Call (بخش اصلی فیلترهای منبع
توزیع) بخشی از توزیع استاندارد پرل است. همچنین شامل دوستانه تر است
رابطی به نام Filter::Simple، توسط Damian Conway.

از perlfilterp به صورت آنلاین با استفاده از خدمات onworks.net استفاده کنید