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

برنامه:

نام

makepp_extending -- نحوه گسترش makepp با استفاده از Perl

شرح

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

سوالات عمومی یادداشت ها on نوشته پرل رمز به کار با makepp
هر makefile در بسته خود زندگی می کند. بنابراین تعاریف در یک فایل ایجاد شده تاثیری ندارد
تعاریف در یک فایل دیگر مجموعه مشترکی از توابع شامل تمام استانداردها
توابع دستکاری متنی هنگام ایجاد بسته به آن وارد می شود.

متغیرهای Makefile به صورت اسکالر پرل در آن بسته ذخیره می شوند. (استثناهایی وجود دارد
این: متغیرهای خودکار و مقدار پیش فرض متغیرهایی مانند CC در واقع هستند
به عنوان توابع بدون آرگومان پیاده سازی شده است. vars خاص، vars خط فرمان و
متغیرهای محیطی به این شکل دیده نمی شوند.) بنابراین هر کد پرلی که بنویسید به همه دسترسی دارد
متغیرهای makefile متغیرهای سراسری در بسته "Mpp::global" ذخیره می شوند. دیدن
برای جزئیات، متغیرها را ایجاد کنید.

هر یک از عبارات (ifperl / ifmakeperl، perl / makeperl، sub / makeub)،
توابع (perl / makeperl، map / makemap) و عمل قانون (perl / makeperl) برای
نوشتن کد پرل به طور مستقیم در فایل میک در دو طعم وجود دارد. اولی کاملاً است
نرمال پرل، به این معنی که شما باید از پیشوند "f_" همانطور که در بخش بعدی توضیح داده شد استفاده کنید
می خواهید توابع makepp را فراخوانی کنید. نوع دوم ابتدا عبارت را ارسال می کند
بسط متغیر Make-style، به این معنی که باید "$" هایی را که می خواهید پرل ببیند دو برابر کنید.

مدیریت پایان خاص است زیرا داده های عظیم makepp (بسته به سیستم ساخت شما) دارد
سازه ها چندین ثانیه طول می کشد تا زباله ها با خروجی معمولی جمع آوری شوند. بنابراین ما یک
خروج بی رحمانه در فرآیند اصلی، همچنان می‌توانید بلوک‌های «END» داشته باشید، اما اگر بلوک‌هایی دارید
دسته‌های فایل جهانی ممکن است پاک نشوند. اما شما باید از واژگان مدرن استفاده کنید
filehandles که با خارج شدن از محدوده به درستی بسته می شوند.

در کد پرل که مستقیماً به عنوان یک قانون اجرا می شود یا از طریق دستوری که تعریف می کنید، آن است
مقابل بلوک‌های «END» اجرا نمی‌شوند، اما فایل‌های جهانی برای شما پاک می‌شوند. در
"DESTROY" از اشیاء جهانی هرگز اجرا نمی شود.

اضافه کردن جدید متن توابع
شما می توانید به سادگی با تعریف زیربرنامه پرل، یک تابع جدید به رپرتوار makepp اضافه کنید
همان نام اما با پیشوند "f_". مثلا:

زیر f_myfunc {
من $argument = &arg; # آرگومان را نام ببرید.
my( undef، $mkfile، $mkfile_line ) = @_; # آرگومان ها را نام ببرید.

... اینجا یه کاری بکن

بازگشت $return_value;
}

XYZ := $( myfunc my func arguments)

اگر تابع شما هیچ آرگومان نمی گیرد، کاری برای انجام دادن وجود ندارد. اگر تابع شما یکی را بگیرد
آرگومان، مانند مثال بالا، برای به دست آوردن آن از Accessor &arg ساده استفاده کنید. اگر شما
انتظار آرگومان های بیشتری را داشته باشید، شما به "args" دسترسی پیچیده تری نیاز دارید که در زیر توضیح داده شده است.

این دسترسی‌ها همان سه پارامتر را پردازش می‌کنند که باید به هر "f_" ارسال شود.
تابع، یعنی آرگومان های تابع، شی makefile و یک توصیفگر خط برای
پیام ها. بنابراین می توانید در حالت اول از فرم کارآمد &arg استفاده کنید.

دسترسی &arg موارد زیر را برای شما انجام می دهد: اگر آرگومان ها قبلاً بودند
گسترش یافته (به عنوان مثال برای یافتن نام تابع در "$(my$(function) arg)" arg است
به صورت رشته گذشت و تازه برگشت. اگر استدلال همچنان نیاز به بسط دارد، این همان است
در حالت معمول، در عوض ارجاع به یک رشته است. دسترسی &arg آن را برای شما گسترش می دهد،
که برای آن به شی makefile به عنوان پارامتر دوم نیاز دارد.

اگر انتظار آرگومان های بیشتری را دارید، احتمالاً در تعداد متغیر، کار توسط "args" انجام می شود.
این Accessor همان 3 پارامتر arg را به همراه پارامترهای اضافی دریافت می کند:

حداکثر: تعداد آرگ ها (پیش فرض 2): ~0 (حداکثر) را برای بی پایان بدهید
min: تعداد آرگ ها (اگر حداکثر ~0 باشد 0 به طور پیش فرض، مانند حداکثر)
only_comma: فضای اطراف کاما را نخورید، که معمولاً برای نام فایل نیست

حداکثر حداکثر، اما حداقل حداقل از کاماهای موجود قبل از بسط برای تقسیم استفاده می شود
استدلال ها چند نمونه از توابع داخلی makepp:

my($prefix, $text ) = args $_[0], $_[1], $_[2], 2, 2, 1; # افزودن پیشوند
برای $cond من (args $_[0], undef, $_[2], ~0 ) ... # و یا
من @args= args $_[0]، $_[1]، $_[2]، ~0، 1، 1; # صدا زدن
my( $filters, $words ) = args $_[0], $_[1], $_[2]; # فیلتر

تابع باید یک رشته اسکالر (نه یک آرایه) را برگرداند که سپس در آن درج می شود
متن در آن نقطه

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

اساساً هیچ محدودیتی در مورد آنچه عملکرد می تواند انجام دهد وجود ندارد. می توانید به فایل دسترسی پیدا کنید، اجرا کنید
دستورات پوسته و غیره

در حال حاضر، عباراتی که در وابستگی ها و در اعمال قانون ظاهر می شوند، گسترش یافته اند
یک بار در حالی که عبارات ظاهر شده در اهداف دو بار گسترش می‌یابند، بنابراین مراقب باشید
تابع دارای عوارض جانبی است و در یک عبارت برای یک هدف وجود دارد.

توجه داشته باشید که محیطی (به ویژه cwd) که تابع در آن ارزیابی می کند، خواهد بود
لزوماً با محیطی که در آن قوانین از Makefile در آن مطابقت ندارد
تابع ارزیابی شد اجرا می شوند. اگر این مشکل برای شماست، پس عملکرد شماست
احتمالاً باید چیزی شبیه به این باشد:

زیر f_foo {
...
chdir $makefile->{CWD};

... و غیره.
}

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

perl {استفاده از mymodule}
پرل {
استفاده از my::module; # put : در یک خط جدید بنابراین به عنوان یک قانون تجزیه نمی شود
}

اگر به هر یک از توابع به طور معمول در یک Makefile (مانند "f_") نیاز دارید
توابع، "arg" یا "args")، باید این خط را در ماژول خود قرار دهید:

استفاده از Mpp::Subs;

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

صدا زدن خارجی پرل اسکریپت
اگر یک اسکریپت پرل خارجی را از طریق "سیستم" یا به عنوان یک قانون فراخوانی کنید، makepp یک را فورک می کند
فرآیند جدید (مگر اینکه آخرین اقدام قانون باشد) و یک مترجم جدید پرل را فعال کنید.
هیچ ایرادی در آن وجود ندارد، به جز اینکه یک راه کارآمدتر وجود دارد:

&فرمان استدلال ...
این می تواند یک اقدام قانون باشد. یک تابع را فراخوانی خواهد کرد فرمان با پیشوند "c_" و
باقیمانده را ارسال کنید (به صورت اختیاری به نقل از سبک makepp -- نه دقیقاً مشابه
پوسته) آرگومان ها. اگر چنین تابعی یافت نشود، تمام رشته ها را به آن ارسال می کند
"اجرا کن".

زیر c_mycmd { @args من = @_; ...}

$(تماس ساختگیcmd):
&mycmd 'arg with space' arg2 "arg3" # c_mycmd را فراخوانی می کند

٪: ٪. در
&myscript -o $(خروجی) $(ورودی) # مای اسکریپت خارجی را فراخوانی می کند

می توانید دستورات خود را در چارچوب داخلی ها بنویسید و به شما امکان استفاده از آن را می دهد
همان گزینه های استانداردی که دارند، و مدیریت ورودی/خروجی که ارائه می دهند.

عملگر بلوک "Mpp::Cmds::frame" توسط یک لیست گزینه تک حرفی دنبال می شود
سازه ها (حداکثر "qw(fi I ​​o O rs)"). حتی اگر گزینه خود را مشخص کنید
با نادیده گرفتن یکی از این موارد، شما همچنان تک حرف گزینه استاندارد را می دهید.

هر گزینه خاص به عنوان "[qw(n name) مشخص شده است. \$ref، ارگ، زیر]". دو تا اول
عناصر نام کوتاه و بلند و به دنبال آن مرجع متغیر و به صورت اختیاری توسط
یک بولی برای اینکه آیا باید استدلال را قبول کرد یا خیر. بدون arg، متغیر است
هر بار که گزینه داده می شود افزایش می یابد، در غیر این صورت مقدار گزینه در آن ذخیره می شود.

sub c_my_ocmd { # مورد معمولی خروجی
محلی @ARGV = @_;
Mpp::Cmds::frame {

... در اینجا با @ARGV چیزی چاپ کنید، با گزینه هایی که قبلاً به طور خودکار حذف شده اند

} 'f', qw(o O);
}

sub c_my_icmd { # مورد ورودی معمولی با 2 گزینه
محلی @ARGV = @_;
my($short, $long );
Mpp::Cmds::frame {

... اینجا با <> کاری انجام دهید

} qw(i I rs)، # s فقط --separator را مشخص می کند نه -s
[qw(s short)، \$short]، # بدون گزینه arg -> $short == 1
[qw(l long), \$long, 1, sub { warn "got arg $long"}];
}

در اینجا یک دستور ساده می آید که فقط اولین کاراکتر هر ورودی را بزرگ می کند
رکورد (معادل "&sed '$$_ = "\u\L$$_"'"):

زیر c_uc {
محلی @ARGV = @_;
Mpp::Cmds::frame {
چاپ "\u\L$_" در حالی که <>;
} 'f', qw(i I o O rs);
}

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

Mpp::Cmds::perform { ... } 'message';

این پیام را با "--verbose" (که هر دستور می پذیرد) در صورتی که
دستور با موفقیت اجرا شد اما اگر بلوک نادرست ارزیابی شود، با آن می میرد
پیام نفی

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

perl { use mylib } # به تمام قوانینی که نیازی به بازنگری آن ندارند، تقسیم می‌شود

٪: ٪. در
makeperl { اجرای qw'myscript -o $(خروجی) $(ورودی)' }

اگر اسکریپت "خروج" را فراخوانی کند، توصیفگرهای استاندارد فایل را می بندد یا به سیستم متکی است
برای پاکسازی بعد از آن (باز کردن فایل‌ها، حافظه...)، این می‌تواند مشکلی با "run" باشد. اگر
شما در دستورات یا تابع perl "run" را صدا می زنید، makepp می تواند مختل شود یا
پاکسازی فقط در پایان makepp اتفاق می افتد.

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

نوشته خود را خود امضا روش
گاهی اوقات می خواهید makepp یک روش امضا را با استفاده از تکنیک دیگری محاسبه کند. برای
به عنوان مثال، فرض کنید یک باینری دارید که به یک کتابخانه مشترک وابسته است. به طور معمول، اگر شما
کتابخانه مشترک را تغییر دهید، لازم نیست فایل های اجرایی که به آن وابسته هستند را دوباره پیوند دهید زیرا
پیوند در زمان اجرا انجام می شود. (با این حال، امکان پیوند مجدد فایل اجرایی وجود دارد
ممکن است ضروری باشد، به همین دلیل است که من این را پیش فرض قرار ندادم.) What you want makepp
انجام این کار این است که امضای یکسانی برای کتابخانه مشترک داشته باشید حتی اگر تغییر کند.

این را می توان به روش های مختلفی انجام داد. ساده ترین راه این است که جدید خود را ایجاد کنید
روش امضا (بیایید آن را "shared_object" بنامیم). شما از این روش امضا استفاده می کنید
فقط در قوانینی که باینری ها را به هم پیوند می دهند، مانند این:

myprogram: *.o lib1/lib1.so lib2/lib2.so
: امضا shared_object
$(CC) $(ورودی ها) -o $(خروجی)

حال باید متد امضا را ایجاد کنیم.

همه متدهای امضا باید کلاس خودشان باشند و کلاس باید شامل چند نوع خاص باشد
اقلام (برای جزئیات بیشتر به Mpp/Signature.pm در توزیع مراجعه کنید). نام کلاس باید باشد
با پیشوند "Mpp::Signature::"، بنابراین در این مورد کلاس ما باید فراخوانی شود
"Mpp::Signature::shared_object". ما باید یک فایل به نام ایجاد کنیم shared_object.pm و بگذار
آن را به یک Mpp::امضا دایرکتوری جایی در مسیر شامل پرل. راحت ترین مکان
ممکن است در Mpp/Signature دایرکتوری در نصب makepp (به عنوان مثال،
/usr/local/share/makepp/MPp/Signature یا هر جا که نصبش کردید).

برای جزئیات دقیق در مورد آنچه در این کلاس باید انجام شود، باید به دقت نگاه کنید
فایل Mpp/Signature.pm و احتمالا همچنین Mpp/Signature/exact_match.pm در آرایش
توزیع اما در مورد ما، تنها کاری که می خواهیم انجام دهیم این است که یک تغییر بسیار کوچک در a ایجاد کنیم
مکانیسم امضای موجود؛ اگر فایل یک کتابخانه مشترک است، می خواهیم یک ثابت داشته باشیم
امضا، در حالی که اگر فایل چیز دیگری باشد، می خواهیم به نرمال makepp تکیه کنیم
مکانیسم امضا بهترین راه برای انجام این کار، ارث بردن از است
"Mpp::Signature::c_compilation_md5"، که روش امضایی است که معمولا انتخاب می شود
وقتی makepp یک فرمان پیوند را تشخیص می دهد.

پس فایل Mpp/Signature/shared_object.pm ممکن است شامل موارد زیر باشد:

سخت استفاده کنید
بسته Mpp::امضا::shared_object;
از Mpp::Signature::c_compilation_md5 استفاده کنید.
@ISA ما = qw(Mpp::امضا::c_compilation_md5); # ارث را نشان دهد.
$shared_object = bless \@ISA; # یک قطعه جادو که به makepp کمک می کند تا پیدا کند
# زیر برنامه های این روش. همه
# روش امضا باید یکی از اینها را داشته باشد.
# مقدار استفاده نمی شود، فقط هر شی.
# حالا در اینجا روشی است که وقتی به امضای نیاز داریم فراخوانی می شود
# هر هدف یا وابستگی که این روش امضا برای آن فعال است:
امضای فرعی {
my ($self, # این همان $shared_object خواهد بود.
$finfo) = @_; # ساختاری خاص که شامل همه چیز است
# makepp از این فایل اطلاع دارد. دیدن
# Mpp/File.pm برای جزئیات.

if ($finfo->{NAME} =~ /\.s[oa]$/) { # آیا نام فایل به .so یا .sa ختم می شود؟
بازگشت $finfo->file_exists ? 'وجود' : '';
# همیشه همان امضا را در صورت فایل برگردانید
# وجود دارد. در این مورد، امضا است
# رشته "وجود دارد".
}

Mpp::Signature::c_compilation_md5::signature;
# اگر فایل به .so یا .sa ختم نمی شد،
# تفویض به روش امضای معمول makepp.
}

این فایل به عنوان نمونه در توزیع makepp به همراه مقداری اضافی ارائه شده است
نظرات.

اتفاقاً چرا این را پیش فرض قرار نمی دهیم؟ خوب، زمان هایی وجود دارد که تغییر یک
کتابخانه مشترک به پیوند مجدد برنامه شما نیاز دارد. اگر روزی یکی از آنها را تغییر دهید
نمادهایی که یک کتابخانه مشترک تعریف می کند، یا نمادهایی که به کتابخانه های دیگر وابسته است
برای، گاهی اوقات ممکن است پیوند مجدد لازم باشد.

به عنوان مثال، فرض کنید که کتابخانه مشترک برخی از برنامه های فرعی را فراخوانی می کند که برنامه شماست
فراهم می کند. به عنوان مثال، فرض کنید که کتابخانه مشترک را تغییر داده اید تا اکنون یک خارجی فراخوانی کند
زیر برنامه "xyz()". مگر اینکه از گزینه "-E" یا "--export-dynamic" برای پیوند دهنده استفاده کنید
(برای binutils گنو؛ پیوند دهنده های دیگر نام گزینه های متفاوتی دارند)، نماد "xyz()" ممکن است نباشد
حتی اگر در برنامه شما وجود داشته باشد، برای پیوند دهنده زمان اجرا قابل دسترسی باشد.

حتی بدتر از آن، فرض کنید "xyz()" را در کتابخانه دیگری تعریف کرده اید (آن را فراخوانی کنید libxyz)، مثل این:

my_program: main.o lib1/lib1.so xyz/libxyz.a

از آنجایی که «libxyz» یک است .a فایل و نه a .بنابراین فایل، سپس "xyz()" ممکن است وارد نشود
به درستی از libxyz.a مگر اینکه باینری خود را دوباره پیوند دهید.

روش های Mpp::Signature همچنین نه تنها رشته ای را که برای تعیین اینکه آیا a استفاده می شود کنترل می کند
فایل تغییر کرده است، اما الگوریتمی که برای مقایسه رشته ها استفاده می شود. به عنوان مثال
روش امضا "target_newer" در توزیع makepp صرفاً مستلزم این است که
اهداف جدیدتر از وابستگی ها هستند، در حالی که روش امضای "exact_match" (و
هر چیزی که به آن بستگی دارد، مانند "md5" و "c_compilation_md5") مستلزم آن است که
فایل دارای امضای مشابه در آخرین ساخت است.

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

· یک روش امضا برای کتابخانه های مشترک که یک جمع کنترلی از تمام موارد صادر شده را برمی گرداند
نمادها و همچنین تمام نمادهایی که از کتابخانه های دیگر نیاز دارد. این حل می کند
با مثال بالا مشکل دارد و یک پیوند صحیح را تحت هر شرایطی تضمین می کند.
تلاشی تجربی برای انجام این کار در توزیع makepp انجام شده است (نگاه کنید به
Mpp/Signature/shared_object.pm، اما فقط با GNU binutils و ELF کار می کند
کتابخانه ها در حال حاضر

· روش امضایی که مهر تاریخ نوشته شده در فایل را نادیده می گیرد. به عنوان مثال، اگر شما
تولید یک .c با استفاده از برنامه ای که اصرار به قرار دادن رشته دارد، به صورت خودکار فایل کنید
به این صورت:

static char * date_stamp = "به طور خودکار در 01 آوریل 2004 توسط هیچ کس ایجاد شد";

می توانید یک روش امضا بنویسید که به طور خاص تغییرات در مهرهای تاریخ را نادیده می گیرد.
بنابراین اگر مهر تاریخ تنها چیزی است که تغییر کرده است، makepp بازسازی نخواهد شد.

· یک روش امضا که امضاها را به روش معمولی محاسبه می کند، اما آن را نادیده می گیرد
وابستگی به معماری هنگام تصمیم گیری برای بازسازی این می تواند مفید باشد
فایل های واقعاً مستقل از معماری. در حال حاضر اگر بر اساس یک معماری بسازید،
makepp اصرار دارد که حتی فایل‌های مستقل از معماری را نیز در زمان تغییر، بازسازی کند
به معماری متفاوت

· یک روش امضا که می داند چگونه نظرات را در فایل های لاتکس نادیده بگیرد
روش "c_compilation_md5" می داند که چگونه نظرات را در فایل های C نادیده بگیرد.

· یک روش امضایی برای استخراج خودکار اسناد که جمع‌های چک فقط به
نظراتی که استخراج کننده اسناد به آن نیاز دارد و سایر تغییرات منبع را نادیده می گیرد
فایل.

ناتمام
این سند هنوز تمام نشده است. باید نحوه نوشتن اسکنرهای خود را برای آن پوشش دهد
شامل فایل ها و مواردی از این دست

با استفاده از خدمات onworks.net از makepp_extending آنلاین استفاده کنید