خط فرمان لینوکسlinuxcommandline.ir
فهرست مطالب
فارسی
PDFدریافت PDF
Esc
    بخش سوم: وظایف رایج و ابزارهای ضروری

    فصل ۲۳: کامپایل نرم‌افزار

    • زمان مطالعه: ۲۵ دقیقه
    • فصل ۲۳ از ۳۶

    در این فصل، فرآیند تولید نرم‌افزار از طریق کامپایل کردن کد منبع (Source Code) را بررسی خواهیم کرد. دسترسی آزاد به کد منبع، همان آزادی بنیادینی را تشکیل می‌دهد که موجودیتِ لینوکس بر پایه‌ی آن معنا می‌یابد؛ چرا که کل زیست‌بوم توسعه در این سیستم‌عامل، بر بستر تبادل آزاد میان توسعه‌دهندگان شکل گرفته است. برای بسیاری از کاربران دسکتاپ، کامپایل کردن اکنون به هنری فراموش‌شده بدل گشته؛ در گذشته، این فرآیند کاربردی بسیار رایج داشت، اما امروزه توسعه‌دهندگان توزیع‌ها مخازن عظیمی از بسته‌های باینری (Binary) پیش‌کامپایل‌شده را نگهداری می‌کنند که آماده‌ی دریافت و نصب آنی هستند.

    در زمان نگارش این متن، مخزن دبیان — که از بزرگ‌ترین مخازن در میان توزیع‌های لینوکس به شمار می‌رود — بالغ بر ۶۸,۰۰۰ بسته‌ی نرم‌افزاری را در خود جای داده است. با این اوصاف، چرا باید نرم‌افزار را شخصاً کامپایل کنیم؟ این کار عمدتاً به دو دلیل انجام می‌شود:

    1. دسترسی (Availability): با وجود تعدد بسته‌های پیش‌کامپایل شده در مخازن، ممکن است برنامه‌ی مورد نظر شما در مخازن رسمی توزیع‌تان موجود نباشد. در چنین شرایطی، تنها راه دستیابی به آن برنامه، کامپایل کردن کد منبع است.
    2. به‌روز بودن (Timeliness): در حالی که برخی توزیع‌ها بر ارائه‌ی بروزترین نسخه (Bleeding Edge) متمرکز هستند، بسیاری دیگر بر پایداری تأکید دارند و نسخه‌های قدیمی‌تر را ارائه می‌دهند. برای بهره‌مندی از آخرین قابلیت‌های یک نرم‌افزار، اغلب ناگزیر به کامپایل آن هستید.

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

    در این بخش، یک ابزار حیاتی جدید را معرفی می‌کنیم:

    • make: ابزاری قدرتمند برای مدیریت فرآیند ساخت و نگهداری نرم‌افزارها.

    مفهوم کامپایل و فرآیند ترجمه کد #

    به بیان ساده، کامپایل (Compilation) فرآیند ترجمه‌ی کد منبع (Source Code) — که توصیفی قابل درک برای انسان و نوشته شده توسط برنامه‌نویس است — به زبان بومی پردازنده‌ی کامپیوتر است.

    واحد پردازش مرکزی (CPU) در پایین‌ترین سطح خود، برنامه‌ها را به‌زبانی به نام «زبان ماشین» (Machine Language) اجرا می‌کند. این زبان شامل کدهای عددی است که عملیات‌های بسیار خرد نظیر «جمع این بایت»، «ارجاع به این موقعیت از حافظه» یا «کپی این بایت» را توصیف می‌کند. هر یک از این دستورالعمل‌ها در قالب باینری (رقم‌های صفر و یک) بیان می‌شوند. در سال‌های آغازین علوم کامپیوتر، برنامه‌ها مستقیماً با همین کدهای عددی نوشته می‌شدند؛ موضوعی که چالش‌های ذهنی و دشواری‌های بسیاری برای برنامه‌نویسان آن دوران به همراه داشت.

    با ظهور «زبان اسمبلی» (Assembly Language)، این چالش تا حدی مرتفع گشت. اسمبلی کدهای عددی را با دستورات یادآور (Mnemonics) که استفاده از آن‌ها ساده‌تر بود، جایگزین کرد؛ مفاهیمی نظیر CPY برای کپی کردن و MOV برای انتقال داده. برنامه‌های نوشته‌شده به زبان اسمبلی، توسط برنامه‌ای به نام «اسمبلر» (Assembler) به زبان ماشین تبدیل می‌شوند. امروزه زبان اسمبلی همچنان در حوزه‌های تخصصی مانند توسعه‌ی درایورهای سخت‌افزاری و سیستم‌های نهفته (Embedded Systems) مورد استفاده قرار می‌گیرد.

    در مرتبه‌ی بالاتر، با «زبان‌های برنامه‌نویسی سطح بالا» (High-level Programming Languages) مواجه هستیم. علت این نام‌گذاری آن است که زبان‌های مذکور برنامه‌نویس را از درگیری با جزئیات فنی پردازنده رها کرده و تمرکز او را بر حل منطقی مسئله معطوف می‌کنند. نخستین زبان‌های سطح بالا که در دهه‌ی ۱۹۵۰ توسعه یافتند، شامل FORTRAN (برای محاسبات علمی) و COBOL (برای کاربردهای تجاری) بودند که هر دو هنوز به‌صورت محدود در سیستم‌های قدیمی مورد استفاده قرار می‌گیرند.

    اگرچه امروزه زبان‌های محبوب متعددی وجود دارند، اما دو زبان C و ++C همچنان در دنیای سیستم‌عامل‌های مدرن غالب هستند. در نمونه‌های آتی، ما یک برنامه‌ی نوشته‌شده به زبان C را کامپایل خواهیم کرد.

    برنامه‌های سطح بالا توسط ابزاری به نام «کامپایلر» (Compiler) به زبان ماشین ترجمه می‌شوند. برخی کامپایلرها ابتدا دستورات را به زبان اسمبلی ترجمه کرده و سپس از طریق یک اسمبلر، مرحله‌ی نهایی تبدیل به زبان ماشین را به انجام می‌رسانند.

    فرآیند دیگری که معمولاً هم‌گام با کامپایل انجام می‌پذیرد، پیوند دادن یا لینک کردن (Linking) نام دارد. بسیاری از عملیات‌های متداول، مانند باز کردن یک فایل، در اکثر برنامه‌ها مشترک هستند. منطقی نیست که هر برنامه کد اختصاصی خود را برای این کارهای تکراری داشته باشد؛ در عوض، این وظایف در قالب مجموعه‌هایی به نام «کتابخانه» (Library) متمرکز شده و میان برنامه‌ها به اشتراک گذاشته می‌شوند. با بررسی دایرکتوری‌های /lib و /usr/lib می‌توان به محل استقرار این کتابخانه‌ها پی برد. ابزاری به نام «پیونددهنده» (Linker) وظیفه دارد میان خروجی کامپایلر و کتابخانه‌های مورد نیاز برنامه ارتباط برقرار کند. محصول نهایی این فرآیند، یک «فایل اجرایی» (Executable) است که آماده‌ی بهره‌برداری می‌باشد.

    تمامی نرم‌افزارها نیاز به کامپایل دارند؟ #

    خیر. همان‌طور که پیش‌تر مشاهده کردیم، دسته‌ای از برنامه‌ها مانند اسکریپت‌های پوسته (Shell Scripts) بدون نیاز به فرآیند کامپایل و به‌طور مستقیم اجرا می‌شوند. این برنامه‌ها به زبان‌هایی نگاشته شده‌اند که در ادبیات برنامه‌نویسی به آن‌ها زبان‌های اسکریپتی (Scripting Languages) یا تفسیری (Interpreted) گفته می‌شود. این زبان‌ها که در سال‌های اخیر به محبوبیت چشم‌گیری دست یافته‌اند، شامل نمونه‌هایی چون Perl، Python، PHP، Ruby و موارد متعدد دیگر هستند.

    زبان‌های تفسیری توسط ابزار ویژه‌ای به نام مفسر (Interpreter) اجرا می‌شوند. مفسر، فایل منبع را به عنوان ورودی دریافت کرده و تک‌تک دستورات موجود در آن را به ترتیب خوانده و در لحظه اجرا می‌کند. به‌طور کلی، سرعت اجرای برنامه‌های تفسیری نسبت به نمونه‌های کامپایل‌شده به‌مراتب کمتر است؛ چرا که در یک زبان تفسیری، هر دستور کد منبع در هر بار اجرا باید مجدداً ترجمه شود، در حالی که در برنامه‌های کامپایل‌شده، این ترجمه تنها یک بار انجام گرفته و به صورت دائمی در قالب کد ماشین در فایل اجرایی ذخیره شده است.

    با این اوصاف، علت محبوبیت فزاینده‌ی زبان‌های تفسیری چیست؟ در بسیاری از کاربردهای نرم‌افزاری، سرعت اجرای این زبان‌ها در سطح «قابل قبول» ارزیابی می‌شود، اما مزیت کلیدی آن‌ها در سرعت و سهولت فرآیند توسعه نهفته است. تولید نرم‌افزار معمولاً در یک چرخه‌ی تکرار‌شونده شامل «کدنویسی، کامپایل و آزمون» صورت می‌گیرد. با حجیم شدن پروژه‌ها، مرحله‌ی کامپایل می‌تواند بسیار زمان‌بر شود. زبان‌های تفسیری با حذف این مرحله، سرعت توسعه و بازبینی برنامه را به‌طور قابل توجهی افزایش می‌دهند.

    کامپایل برنامه C #

    در این بخش، فرآیند عملی کامپایل یک برنامه را آغاز می‌کنیم. پیش از هر چیز، به ابزارهای کلیدی نظیر کامپایلر، پیونددهنده و make نیاز داریم. در دنیای لینوکس، کامپایلر استاندارد و غالب برای زبان C، ابزار gcc (مخفف GNU C Compiler) است که در ابتدا توسط ریچارد استالمن توسعه یافت. لازم به ذکر است که اکثر توزیع‌های لینوکس به‌صورت پیش‌فرض gcc را نصب نمی‌کنند. برای بررسی وضعیت نصب این ابزار در سیستم خود، می‌توانید دستور زیر را اجرا کنید:

    [me@linuxbox ~]$ which gcc
    /usr/bin/gcc

    خروجی فوق نشان‌دهنده‌ی نصب بودن کامپایلر در مسیر مشخص شده است.

    نکته: بسیاری از توزیع‌های لینوکس دارای یک متا-پکیج (Meta-package) اختصاصی هستند که مجموعه‌ای از ابزارهای ضروری برای توسعه‌ی نرم‌افزار را به‌صورت یکجا ارائه می‌دهد (مانند build-essential در دبیان و اوبونتو). اگر قصد دارید به‌طور مستمر به کامپایل برنامه‌ها بپردازید، نصب این بسته‌ی جامع توصیه می‌شود. در صورتی که توزیع شما فاقد چنین متا-پکیجی است، نصب مجزای بسته‌های gcc و make برای انجام تمرینات این فصل کفایت می‌کند.

    دریافت کد منبع #

    برای تمرین فرآیند کامپایل، پروژه‌ای از مجموعه‌ی GNU به نام diction را برگزیده‌ایم. این بسته، شامل دو برنامه‌ی کاربردی diction و style است. برنامه‌ی diction، عبارت‌های پرتکرار و اشتباهات رایج را در یک متن شناسایی می‌کند. در مقابل، برنامه‌ی style، ویژگی‌های سطحی متن مانند طول جملات و شاخص‌های خوانایی (readability) را مورد تحلیل قرار می‌دهد. انتخاب این پروژه به دلیل حجم کم و سهولت در فرآیند ساخت (Build) آن است.

    طبق روال معمول در محیط‌های لینوکسی، ابتدا یک دایرکتوری اختصاصی به نام src برای نگهداری کدهای منبع ایجاد کرده و سپس از طریق پروتکل FTP، فایل مورد نظر را دریافت می‌کنیم:

    [me@linuxbox ~]$ mkdir src
    [me@linuxbox ~]$ cd src
    [me@linuxbox src]$ ftp ftp.gnu.org
    Connected to ftp.gnu.org.
    220 GNU FTP server ready.
    Name (ftp.gnu.org:me): anonymous
    230 Login successful.
    Remote system type is UNIX.
    Using binary mode to transfer files.
    ftp> cd gnu/diction
    250 Directory successfully changed.
    ftp> ls
    200 PORT command successful. Consider using PASV.
    150 Here comes the directory listing.
    -rw-r--r--    1 1003   65534      68940 Aug 28  1998 diction-0.7.tar.gz
    -rw-r--r--    1 1003   65534      90957 Mar 04  2002 diction-1.02.tar.gz
    -rw-r--r--    1 1003   65534     141062 Sep 17  2007 diction-1.11.tar.gz
    226 Directory send OK.
    ftp> get diction-1.11.tar.gz
    local: diction-1.11.tar.gz remote: diction-1.11.tar.gz
    200 PORT command successful. Consider using PASV.
    150 Opening BINARY mode data connection for diction-1.11.tar.gz (141062 bytes).
    226 File send OK.
    141062 bytes received in 0.16 secs (847.4 kB/s)
    ftp> bye
    221 Goodbye.
    [me@linuxbox src]$ ls
    diction-1.11.tar.gz

    همان‌طور که مشاهده می‌شود، کد منبع در قالب یک فایل فشرده با پسوند .tar.gz (که اصطلاحاً Tarball نامیده می‌شود) دریافت شده است. این فرمت استاندارد توزیع کد منبع در دنیای متن‌باز محسوب می‌شود.

    اگرچه در مثال پیشین از پروتکل سنتی FTP استفاده کردیم، روش‌های مدرن‌تری نیز برای دریافت کد منبع وجود دارد. برای نمونه، پروژه‌ی GNU امکان دانلود از طریق پروتکل امن HTTPS را نیز فراهم کرده است. ما می‌توانیم بسته‌ی نرم‌افزاری diction را با ابزار قدرتمند curl دریافت کنیم:

    [me@linuxbox ~]$ curl -O https://ftp.gnu.org/gnu/diction/diction-1.11.tar.gz
       % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                     Dload  Upload   Total   Spent    Left  Speed
      0     0    0     0    0     0      0      0 --:--:--  0:00:01 --:--:--     0
    نکته: از آنجا که در فرآیند کامپایل، ما به‌عنوان «نگهدارنده» (Maintainer) این کد عمل می‌کنیم، فایل‌ها را در دایرکتوری شخصی ~/src قرار می‌دهیم. به‌طور معمول، کدهای منبعی که توسط مدیر بسته‌ی توزیع نصب می‌شوند در مسیر /usr/src و کدهایی که قرار است توسط مدیر سیستم برای استفاده‌ی تمامی کاربران نگهداری شوند، در مسیر /usr/local/src مستقر می‌گردند.

    همان‌طور که ملاحظه می‌کنید، کدهای منبع غالباً در قالب یک فایل tar فشرده عرضه می‌شوند. این فایل حاوی «ساختار درختی کد منبع» (Source Tree) یا همان ساختار سلسله‌مراتبی دایرکتوری‌ها و فایل‌های تشکیل‌دهنده‌ی پروژه است. ما پس از اتصال به سرور، آخرین نسخه‌ی موجود را شناسایی کرده و با دستور get به سیستم محلی منتقل کردیم.

    پس از اتمام دانلود، نوبت به استخراج محتویات فایل tar می‌رسد. این عملیات با استفاده از فرمان tar انجام می‌پذیرد:

    [me@linuxbox src]$ tar xzf diction-1.11.tar.gz
    [me@linuxbox src]$ ls
    diction-1.11  diction-1.11.tar.gz

    با اجرای این دستور، دایرکتوری جدیدی به نام diction-1.11 ایجاد می‌شود که تمامی فایل‌های منبع پروژه را در خود جای داده است.

    نکته: برنامه‌ی diction همانند تمامی نرم‌افزارهای تحت پروژه‌ی GNU، از استانداردهای سخت‌گیرانه‌ای برای بسته‌بندی کد منبع پیروی می‌کند؛ استانداردی که اکثر پروژه‌های اکوسیستم لینوکس نیز به آن پایبند هستند. بر اساس این قاعده، هنگام استخراج فایل tar، دایرکتوری جدیدی با الگوی project-x.xx (ترکیب نام پروژه و شماره نسخه) ایجاد می‌شود که ساختار درختی کد منبع را در خود جای می‌دهد. این ساختار مدیریتی، نصب و نگهداری هم‌زمان چندین نسخه از یک نرم‌افزار را تسهیل می‌کند.

    با این حال، توصیه می‌شود همواره پیش از استخراج قطعی فایل، ساختار درختی آن را بازبینی کنید. برخی پروژه‌ها برخلاف استاندارد مذکور، دایرکتوری ریشه ایجاد نکرده و فایل‌ها را مستقیماً در دایرکتوری جاری رها می‌کنند که منجر به بی‌نظمی در محیط src شما می‌شود. برای پیشگیری از این وضعیت، می‌توانید با ترکیب دستور زیر، محتوای بسته‌ی tar را پیش‌نمایش کنید:

    tar tzvf tarfile | head

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

    تحلیل ساختار درختی کد منبع (Source Tree) #

    استخراج فایل tar منجر به ایجاد دایرکتوری جدیدی تحت عنوان diction-1.11 می‌شود که حاوی ساختار درختی کد منبع (Source Tree) پروژه است. محتویات این دایرکتوری را بازبینی می‌کنیم:

    [me@linuxbox src]$ cd diction-1.11
    [me@linuxbox diction-1.11]$ ls
    config.guess      diction.c         getopt.c          nl
    config.h.in       diction.pot       getopt.h          nl.po
    config.sub        diction.spec      getopt_int.h      README
    configure         diction.spec.in   INSTALL           sentence.c
    configure.in      diction.texi.in   install-sh        sentence.h
    COPYING           en                Makefile.in       style.1.in
    de                en_GB             misc.c            style.c
    de.po             en_GB.po          misc.h            test
    diction.1.in      getopt1.c         NEWS

    در این فهرست، فایل‌های متعددی به چشم می‌خورد. پروژه‌های تحت نظر GNU و بسیاری دیگر از پروژه‌های متن‌باز، به‌طور استاندارد فایل‌های مستنداتی نظیر README، INSTALL، NEWS و COPYING را ارائه می‌دهند. این مستندات شامل شرح کلی نرم‌افزار، دستورالعمل‌های گام‌به‌گام برای پیکربندی، ساخت و نصب، و همچنین شرایط مجوز (License) و کپی‌رایت هستند. اکیداً توصیه می‌شود پیش از شروع فرآیند ساخت، فایل‌های README و INSTALL را برای آگاهی از نیازمندی‌ها و وابستگی‌های احتمالی به‌دقت مطالعه نمایید.

    سایر فایل‌های کلیدی در این دایرکتوری، فایل‌هایی با پسوند .c و .h هستند:

    [me@linuxbox diction-1.11]$ ls *.c
    diction.c  getopt1.c  getopt.c  misc.c  sentence.c  style.c
    [me@linuxbox diction-1.11]$ ls *.h
    getopt.h  getopt_int.h  misc.h  sentence.h

    فایل‌های .c در واقع پیاده‌سازی اصلی دو برنامه‌ی موجود در این بسته (diction و style) هستند که به‌صورت ماژولار (Modular) طراحی شده‌اند. در پروژه‌های بزرگ، تقسیم کد به قطعات کوچک‌تر و قابل مدیریت امری متداول است. از آنجا که فایل‌های کد منبع (Source Code) ماهیت متنی دارند، می‌توان محتوای آن‌ها را با ابزارهایی نظیر less بازبینی کرد:

    [me@linuxbox diction-1.11]$ less diction.c

    فایل‌های با پسوند .h تحت عنوان فایل‌های سرآیند یا هِدِر (Header Files) شناخته می‌شوند. این فایل‌ها نیز متنی بوده و حاوی تعاریف و توصیفاتی از روال‌ها (Routines) و توابعی هستند که در فایل‌های منبع یا کتابخانه‌ها به کار رفته‌اند. جهت برقراری پیوند صحیح میان ماژول‌های مختلف، کامپایلر نیازمند دسترسی به تعاریف تمامی اجزای موردنیاز برای تکمیل ساختار برنامه است که این اطلاعات از طریق فایل‌های هدر تأمین می‌شود. در ابتدای فایل diction.c با عبارت زیر مواجه می‌شویم:

    #include "getopt.h"

    این دستور به کامپایلر ابلاغ می‌کند که هنگام پردازش فایل منبع diction.c، محتوای getopt.h را نیز فراخوانی کند تا نسبت به تعاریف موجود در getopt.c آگاهی یابد. فایل getopt.c دربرگیرنده‌ی روال‌های (Routines) مشترکی است که هر دو برنامه‌ی style و diction از آن‌ها بهره می‌برند.

    پیش از عبارت فوق، مجموعه‌ای از دستورات #include دیگر نیز به چشم می‌خورند؛ مانند:

    #include <regex.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>

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

    [me@linuxbox diction-1.11]$ ls /usr/include

    فایل‌های هدر موجود در این مسیر، هم‌زمان با نصب کامپایلر یا سرآیندهای توسعه (development headers) در دایرکتوری‌های استاندارد سیستم مستقر می‌شوند.

    فرآیند ساخت نرم‌افزار #

    بسیاری از برنامه‌ها با اجرای یک توالی استاندارد شامل دو دستور زیر ساخته می‌شوند:

    ./configure
    make

    برنامه‌ی configure یک اسکریپت پوسته (Shell Script) است که به همراه ساختار درختی کد منبع ارائه می‌شود. وظیفه‌ی اصلی این اسکریپت، تحلیل و ارزیابی «محیط ساخت» (Build Environment) است. اغلب کدهای منبع به گونه‌ای طراحی شده‌اند که «قابل حمل» (Portable) باشند؛ به این معنا که قابلیت کامپایل و اجرا بر روی انواع مختلف سیستم‌های شبه‌یونیکس را داشته باشند. با این حال، برای تحقق این هدف، ممکن است کد منبع در زمان ساخت نیازمند اعمال تغییرات جزئی جهت سازگاری با تفاوت‌های ساختاری میان سیستم‌عامل‌ها باشد. علاوه بر این، configure بررسی می‌کند که آیا تمامی ابزارها و وابستگی‌های (Dependencies) مورد نیاز در سیستم نصب شده‌اند یا خیر.

    اجازه دهید دستور configure را اجرا کنیم. از آنجا که فایل configure در مسیرهای پیش‌فرض پوسته (PATH) قرار ندارد، باید مکان دقیق آن را به‌طور صریح برای سیستم مشخص کنیم؛ این کار با استفاده از پیشوند ./ انجام می‌شود تا به پوسته اعلام گردد که برنامه در دایرکتوری کاری فعلی مستقر است:

    [me@linuxbox diction-1.11]$ ./configure

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

    checking libintl.h presence... yes
    checking for libintl.h... yes
    checking for library containing gettext... none required
    configure: creating ./config.status
    config.status: creating Makefile
    config.status: creating diction.1
    config.status: creating diction.texi
    config.status: creating diction.spec
    config.status: creating style.1
    config.status: creating test/rundiction
    config.status: creating config.h
    [me@linuxbox diction-1.11]

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

    مشاهده می‌کنیم که اسکریپت configure چندین فایل جدید در دایرکتوری منبع ایجاد کرده است که در میان آن‌ها، فایل Makefile حیاتی‌ترین نقش را ایفا می‌کند. Makefile در واقع یک فایل پیکربندی است که دستورالعمل‌های لازم برای ساخت برنامه را در اختیار ابزار make قرار می‌دهد. در صورت نبود این فایل، ابزار make قادر به اجرای فرآیند کامپایل نخواهد بود.

    فایل Makefile یک فایل متنی استاندارد است و می‌توان محتوای آن را جهت تحلیل بازبینی کرد:

    [me@linuxbox diction-1.11]$ less Makefile

    ابزار make این فایل را به عنوان ورودی دریافت کرده و بر اساس تعاریف موجود در آن، روابط و وابستگی‌های (Dependencies) میان اجزای مختلف پروژه‌ی نهایی را درک می‌کند.

    بخش نخست Makefile به تعریف متغیرهایی اختصاص دارد که در مراحل بعدی جایگزین می‌شوند. به عنوان نمونه، عبارت زیر را در نظر بگیرید:

    CC=               gcc

    این خط، کامپایلر مورد استفاده را gcc تعیین می‌کند. در بخش‌های عملیاتی Makefile، نحوه بهره‌برداری از این متغیر به شرح زیر است:

    diction:        diction.o sentence.o misc.o getopt.o getopt1.o
    	          $(CC) -o $@ $(LDFLAGS) diction.o sentence.o misc.o \
    	          getopt.o getopt1.o $(LIBS)

    در زمان اجرا، یک فرآیند جایگزینی (Substitution) صورت گرفته و عبارت $(CC) به gcc تبدیل می‌شود.

    بخش اعظم یک Makefile از تعاریف «هدف» (Target) تشکیل شده است؛ در این مثال، فایل اجرایی diction یک هدف محسوب می‌شود. خطوط بعدی دستوراتی را بیان می‌کنند که برای تولید این هدف از روی اجزای سازنده‌اش ضروری هستند. مطابق قطعه‌ی کد بالا، فایل اجرایی diction (خروجی نهایی) به مجموعه‌ای از فایل‌های شیء (Object Files) وابسته است که شامل diction.o، sentence.o، misc.o، getopt.o و getopt1.o می‌شود.

    در ادامه‌ی محتوای Makefile، تعاریف مربوط به هر یک از این فایل‌ها را در قالب «هدف» (Target) مشاهده می‌کنیم:

    diction.o:       diction.c config.h getopt.h misc.h sentence.h
    getopt.o:        getopt.c getopt.h getopt_int.h
    getopt1.o:       getopt1.c getopt.h getopt_int.h
    misc.o:          misc.c config.h misc.h
    sentence.o:      sentence.c config.h misc.h sentence.h
    style.o:         style.c config.h getopt.h misc.h sentence.h

    نکته‌ی قابل توجه این است که برای این اهداف، دستور اجرایی مستقیمی قید نشده است. این فرآیند توسط یک «قاعده‌ی الگویی» (Pattern Rule) که در بخش‌های ابتدایی فایل تعریف شده، مدیریت می‌شود؛ قاعده‌ای که دستور لازم برای تبدیل هر فایل منبع .c به فایل شیء .o را تعیین می‌کند:

    .c.o:
                	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<

    شاید این رویکرد در ابتدا بسیار پیچیده به نظر برسد و این پرسش مطرح شود که چرا تمامی مراحل ساخت به‌صورت صریح و مجزا فهرست نمی‌شوند؟ پاسخ این پرسش در بهینه‌سازی فرآیند ساخت نهفته است که به‌زودی به آن خواهیم پرداخت. در حال حاضر، برای آغاز عملیات ساخت و تولید برنامه‌ها، دستور make را اجرا می‌کنیم:

    [me@linuxbox diction-1.11]$ make

    با اجرای این فرمان، ابزار make با پیروی از منطق تعریف‌شده در Makefile، مجموعه‌ای از گزارش‌های عملیاتی را در خروجی نمایش می‌دهد.

    پس از تکمیل فرآیند، مشاهده خواهیم کرد که تمامی اهداف (Targets) تعیین شده اکنون در دایرکتوری جاری ایجاد شده‌اند:

    [me@linuxbox diction-1.11]$ ls

    جدول ۱-۲۳: دسته‌بندی فایل‌های پس از کامپایل

    دسته‌بندی فایل‌ها
    فایل‌های اجرایی (Binary)
    diction, style
    فایل‌های شیء (Object)
    diction.o, getopt.o, getopt1.o, misc.o, sentence.o
    پیکربندی و ساخت
    Makefile, config.h, config.status, config.log, configure
    مستندات و متفرقه
    README, INSTALL, NEWS, COPYING, diction.1, style.1

    در میان انبوه فایل‌ها، دو فایل اجرایی diction و style به‌چشم می‌خورند؛ این‌ها همان خروجی‌های نهایی هستند که هدف اصلی ما از فرآیند ساخت بودند. شما با موفقیت نخستین برنامه‌های خود را مستقیماً از روی کد منبع در محیط لینوکس کامپایل کردید. اما صرفاً از روی کنجکاوی، بیایید بار دیگر دستور make را اجرا کنیم:

    [me@linuxbox diction-1.11]$ make
    make: Nothing to be done for `all'.

    تنها همین پیام کوتاه تولید می‌شود. چه اتفاقی افتاده است؟ چرا فرآیند ساخت مجدداً تکرار نشد؟ پاسخ در هوشمندی ابزار make نهفته است. این ابزار به‌جای بازسازی کل پروژه، تنها مؤلفه‌هایی را می‌سازد که نیاز به نوسازی دارند. با توجه به حضور تمامی اهداف (Targets) در دایرکتوری، make تشخیص داد که نیازی به اقدام مجدد نیست.

    می‌توانیم این مکانیزم را با حذف یکی از فایل‌های شیء و اجرای دوباره‌ی دستور مشاهده کنیم:

    [me@linuxbox diction-1.11]$ rm getopt.o
    [me@linuxbox diction-1.11]$ make

    مشاهده می‌کنیم که make بلافاصله فایل حذف شده را بازسازی کرده و سپس برنامه‌های diction و style را دوباره «پیوندزنی» (Link) می‌کند؛ چرا که این فایل‌های اجرایی به ماژول حذف‌شده وابسته بودند.

    این رفتار، یکی از کلیدی‌ترین ویژگی‌های ابزار make را آشکار می‌سازد: به‌روز نگه‌داشتن اهداف. make بر این قاعده استوار است که هر «هدف» باید از نظر زمانی، جدیدتر از «وابستگی‌های» خود باشد. این منطق کاملاً کاربردی است؛ چرا که برنامه‌نویسان اغلب تنها بخش کوچکی از کد منبع را ویرایش کرده و سپس از make برای تولید نسخه‌ی جدید محصول نهایی استفاده می‌کنند. در این حالت، make تضمین می‌کند که فقط و فقط اجزای متأثر از تغییرات کد، دوباره کامپایل و ساخته شوند.

    با بهره‌گیری از فرمان touch برای به‌روزرسانی صوری زمان یکی از فایل‌های منبع، می‌توانیم این سازوکار را در عمل مشاهده کنیم:

    [me@linuxbox diction-1.11]$ ls -l diction getopt.c
    -rwxr-xr-x 1 me me 37164 2009-03-05 06:14 diction
    -rw-r--r-- 1 me me 33125 2007-03-30 17:45 getopt.c
    [me@linuxbox diction-1.11]$ touch getopt.c
    [me@linuxbox diction-1.11]$ ls -l diction getopt.c
    -rwxr-xr-x 1 me me 37164 2009-03-05 06:14 diction
    -rw-r--r-- 1 me me 33125 2009-03-05 06:23 getopt.c
    [me@linuxbox diction-1.11]$ make

    پس از اجرای مجدد make، ملاحظه می‌شود که هدف (Target) به‌گونه‌ای بازسازی شده است که برچسب زمانی آن جدیدتر از وابستگی‌هایش باشد:

    [me@linuxbox diction-1.11]$ ls -l diction getopt.c
    -rwxr-xr-x 1 me me 37164 2009-03-05 06:24 diction
    -rw-r--r-- 1 me me 33125 2009-03-05 06:23 getopt.c

    توانمندی ابزار make در تشخیص هوشمندانه‌ی بخش‌هایی که منحصراً نیاز به بازسازی دارند، مزیتی کلیدی برای توسعه‌دهندگان محسوب می‌شود. اگرچه صرفه‌جویی در زمان در پروژه‌ی محدودی نظیر این مثال ممکن است چندان ملموس نباشد، اما این قابلیت در پروژه‌های عظیم اهمیت حیاتی می‌یابد.

    به‌عنوان نمونه، هسته‌ی لینوکس (Kernel) را در نظر بگیرید که به‌طور مستمر در حال توسعه و تکامل است و شامل میلیون‌ها خط کد منبع است؛ در چنین ابعادی، کامپایل مجدد کل پروژه با هر تغییر کوچک، فرآیندی بسیار زمان‌بر و غیربهینه خواهد بود.

    استقرار نرم‌افزار در سیستم (Installation) #

    یک بسته‌ی کد منبع استاندارد، معمولاً هدف ویژه‌ای به نام install را در فایل Makefile پیش‌بینی می‌کند. وظیفه‌ی این هدف، انتقال فایل اجرایی نهایی به دایرکتوری‌های سیستمی است تا برنامه از هر نقطه‌ای در محیط پوسته قابل فراخوانی باشد.

    به‌طور معمول، مسیر /usr/local/bin به عنوان محل استاندارد برای استقرار نرم‌افزارهای ساخته‌شده توسط کاربر (Locally Built Software) در نظر گرفته می‌شود.

    از آنجا که کاربران عادی مجاز به نوشتن در دایرکتوری‌های سیستمی نیستند، فرآیند نصب مستلزم برخورداری از امتیازات ابرکاربر (Superuser) است. به همین منظور، دستور را با پیشوند sudo اجرا می‌کنیم:

    [me@linuxbox diction-1.11]$ sudo make install

    پس از اتمام فرآیند، می‌توانیم صحت نصب و در دسترس بودن برنامه را با استفاده از ابزارهای زیر ارزیابی کنیم:

    [me@linuxbox diction-1.11]$ which diction
    /usr/local/bin/diction
    [me@linuxbox diction-1.11]$ man diction

    چنانچه دستور which مسیر صحیح فایل اجرایی را بازگرداند و فرمان man صفحه‌ی راهنمای نرم‌افزار را نمایش دهد، به این معناست که عملیات نصب با موفقیت به پایان رسیده است.

    جمع‌بندی #

    در این فصل آموختیم که چگونه با اجرای یک توالی استاندارد شامل سه دستور زیر، می‌توان اکثر بسته‌های کد منبع را پیکربندی، ساخت و مستقر کرد:

    ./configure
    make
    sudo make install

    علاوه بر این، نقش کلیدی ابزار make را در مدیریت هوشمند و بازسازی هدفمند پروژه‌ها بررسی کردیم. شایان ذکر است که کاربرد make صرفاً به کامپایل کد منبع محدود نمی‌شود؛ بلکه این ابزار قدرتمند برای اتوماسیون هر سیستمی که بر پایه‌ی روابط هدف/وابستگی (Target/Dependency) بنا شده باشد، قابل استفاده است.

    منابع مطالعه تکمیلی #

    برای درک عمیق‌تر مفاهیم، مطالعه مقالات زیر از ویکی‌پدیا درباره کامپایلرها و ابزار make توصیه می‌شود:

    راهنمای ابزار GNU Make: