رتبه موضوع:
  • 1 رای - 5 میانگین
  • 1
  • 2
  • 3
  • 4
  • 5
نحوه استفاده از Makefile ها
#1
makefile پروسه کامپایل و لینک و install رو خودکار میکنه . میتونی بدون داشتن makefile هم هر پروژه ای رو بسازی و استفاده کنی اما وقتی تعداد فایلهای زیاد بشه کار خیلی خیلی سخت میشه . بعد از اینکه همهء بسته های لازم برای کامپایل و لینک و همینطور کتابخانه های استاندارد و make و ...را نصب کردی (*) کافی است که وارد دایرکتوری ای بشی که makefile ات اونجاست و دستور make رو اجرا کنی . البته اغلب اوقات makefile دارای مراحل مختلفی است که با خوندنش میتونی اینو بفهمی : مثلا گاهی اجرای make برای کامپایل و لینک و تولید باینری کافی است ، و گاهی ترجیح میدهند که مثلا make compile فایلها را کامپایل کند و make linkthem لینک کند و make checkinstalled بررسی کند که اگر قبلا نصب شده از حالت نصب خارجش کند و make install هم نصبش کند . برای دستوراتی که بعد از make در مثالی که نوشتم میبینی محدودیتی وجود نداره و این مساله کاملا اختیاری است و به نویسنده makefile بستگی داره . برای اینکه بفهمی روند صحیح ساختن و نصب پروژه چطور است کافیه makefile رو باز کنی و مرور کنی ، با یک نگاه سریع کل مساله رو میفهمی . معمولا هم یک راهنمای ساخت و نصب همراه هر پروژه ای هست که روند صحیح رو توضیح میده . به عنوان مثال برای کامپایل کردن کرنل لازمه اول یک فایل تنظیمات داشته باشی که مشخص میکنه عناصر کرنل به چه صورت ساخته بشن ، برای ساختن این فایل تنظیمات دستوری مثل این استفاده میشه : make menuconfig که یک برنامه جانبی رو کامپایل و اجرا میکنه که صرفا وظیفه اش ساختن فایل تنظیمات است ، و وقتی این فایل ساخته شد ، اجرای make باعث میشه کرنل "کامپایل" بشه ، make modules باعث میشه ماژولهای کرنل ساخته و لینک بشن ، و make install باعث میشه کرنل نصب بشه و تنظیمات مربوط به Boot Loader و غیره انجام بشن . گاهی اوقات در کنار این دستورات ، بسته به توزیع مورد استفاده از برنامه های جانبی برای ساختن Package آماده انتشار استفاده میشه . مثلا" بجای اجرای مستقیم make و make modules و make install ، میشه از دستوری مانند make-kpackage --revission=sample0.9 kernel_image برای ساختن یک بستهء deb. ( بستهء استاندارد توزیعهای مبتنی بر دبیان ) کامل استفاده کرد که تمام مراحل قبلی به علاوه ساختن deb رو خودکار میکنه .

در هر حال عموما" یک README همراه هر پروژه هست که توضیحاتش کافیه .

منبع
[عکس: <a href=www.Mojsazan.com.gif]" class="mycode_img" />
پاسخ
سپاس شده توسط مهدی ابراهیمی ، aliva ، worm ، علیرضا حر ، Beni_Vanda ، digicom ، m_gh
#2
در توسعه نرم‌افزار، make ابزاری برای ساختن اتوماتیک فایلهای اجرایی از کد منبع است. فایلی که Makefile خوانده می‌شود روند کامپایل قطعات پروژه را بر اساس پیش‌نیازهای آن معلوم می‌کند.

مقدمه

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

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

در یک نگاه کلی، make فقط برای کامپایل برنامه‌ها استفاده نمی‌شود. شما می‌توانید در هر کاری که در آن نیاز به بروزرسانی بعضی فایل‌ها متناسب با تغییر در فایل‌های دیگر است از make استفاده کنید.

بطور مثال معمولاً در یک برنامه رایانه‌ای نیاز است از کدهای منبع فایل‌های آبجکت و سپس از این فایل‌های آبجکت، فایل اجرایی ساخته شود. وقتی شما برنامه‌ای می‌نویسید، باید برای آن یک Makefile هم درست کنید و سپس برای کامپایل و نصب آن از Make کمک می‌گیرید.

make بطور خودکار تشخیص می‌دهد چه قسمت‌هایی از یک برنامهٔ بزرگ به چه صورت باید کامپایل شوند. همچنین می‌توان از آن برای کامپایل برنامه‌ها به هر زبانی که نوشته شده‌اند استفاده کرد، به‌شرط آنکه کامپایلر آن زبان توانایی اجرا از طریق پوسته (Shell) را داشته‌باشد.

ابزار make بطور گسترده‌ای به‌خصوص در سیستم‌های مبتنی بر یونیکس استفاده می‌شود.
قابلیت‌های Make

* Make این امکان را برای کاربر نهایی فراهم می‌کند که حتی بدون داشتن اطلاعات فنی زیاد بتواند برنامه را کامپایل و نصب کند. زیرا شما جزئیات کامپایل و نصب برنامه را در Makefile نوشته‌اید.


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


* Make وابسته به زبان برنامه‌نویسی خاصی نیست. برای ساخت فایل‌های مورد نیاز برای اجرای برنامه، در Makefile دستوری قرار دارد که در پوسته (Shell) اجرا می‌شود. بطور مثال این دستورات می‌توانند کامپایلری را برای ایجاد فایل آبجکت، لینکر را برای تولید فایل اجرایی، ar را برای به روز کردن یک کتابخانه (Library) یا صفحه‌آرایی مستندات بوسیله TeX یا Makeinfo اجرا کنند.


* Make فقط برای ساخت یک برنامه به کار نمی‌رود. می‌توان از آن برای کنترل روند نصب یا حذف یک برنامه نیز استفاده کرد.

نگاهی دقیق تر به Makefile
محتویات Makefile

Makefileها شامل پنج چیز مختلف‌اند. قوانین صریح ، قوانین غیرصریح ، متغیرها ، رهنمون‌ها و توضیحات .


* یک قانون صریح ( Explicit Rule ) معلوم می‌کند چه‌وقت و چطور، فایل یا فایلها باید ساخته شوند. به فایلهایی که باید ساخته شوند هدف ( Target ) گفته می‌شود و ممکن است وابسته به فایل(های) دیگری باشد. همچنین دستوراتی برای ساخت فایل هدف نوشته می‌شوند.


* قوانین غیرصریح ( Implicit Rule ) معلوم می‌کنند چه وقت و چطور باید دسته‌ای از فایلها که بر اساس نامشان دسته‌بندی شده‌اند ساخته شوند.


* متغیرها برای نسبت دادن مقادیر متنی به نامی مشخص است. و برای رجوع به آن مقدار متنی، می‌توان از نام متغیر استفاده کرد. یک مثال نوشتن نام تمام فایلهای آبجکت مورد استفاده در برنامه درون یک متغیر با نام objects است. ( برای رجوع ساده‌تر )


* رهنمون‌ها فرامینی هستند برای اجرای کارهای خاص که در هنگام پردازش Makefile مورد استفاده قرار می‌گیرند. مانند :

-- خواندن محتویات Makefile دیگری در دل یک Makefile .

-- تصمیم‌گیری ( بر اساس مقدار درون یک متغیر ) برای پردازش کردن یا نکردن قسمتی از Makefile .

-- مقدار دهی به متغیرها از طریق متنی که شامل چندین خط است .


* با نوشتن کارکتر # می‌توان توضیحاتی در Makefile نوشت که عملاً پردازش نمی‌شوند و فقط برای خواناتر شدن Makefile برای انسان خواهند شد.


Rule‌ها

Rule‌ها در Makefile مشخص می‌کنند که برای ساخت یک Target چه دستوراتی باید اجرا شود. همچنین می‌توان برای ساخت هدف، فهرستی از پیش‌نیازها (Dependencies) را نیز تعریف کرد. در این فهرست باید تمام فایل‌های مورد نیاز (کدمنبع یا هر نوع فایل دیگری) که برای ساخت هدف مورد نیاز است تعریف شود.

# Comments use the hash symbol

target: dependencies
command 1
command 2
.
.
.
command n

معمولاً Target نام فایلی است که قرار است توسط یک برنامه ایجاد شود. مثلاً فایل‌های آبجکت یا اجرایی. همچنین می‌تواند نام کاری باشد که قرار است اجرا شود. مثل تمیز کردن یک پروژه (Clean)

پیش‌نیازها (Dependencies) فایل‌های ورودی‌ای هستند که برای ساختن هدف مورد نیازند که به هر تعدادی می‌توانند باشند. در صورت تغییر در هر یک از این پیش‌نیازها، هدف باید دوباره ساخته شود. البته هدف‌هایی هم هستند که نیاز به پیش‌نیازی ندارند. بطور مثال هدفی مانند Clean که باید بعضی از فایل‌ها را پاک کند.

فرمان‌های (Command) هم کارهایی هستند که Make برای ساخت هدف انجام خواهد داد. برای ساخت یک هدف ممکن است چندین دستور نیاز باشد که باید در خطوط جداگانه نوشته شوند. توجه کنید که حتماً باید در ابتدای دستورات یک کارکتر تب (TAB) قرار دهید.
متغیرها کارها را ساده می‌کنند.

مثال زیر را در نظر بگیرید:

edit : main.o kbd.o command.o display.o insert.o search.o files.o utils.o
cc -o edit main.o kbd.o command.o display.o insert.o search.o files.o utils.o

چنین قواعدی در Makefile، به‌شدت مستعد خطا هستند. اگر نیاز به اضافه کردن فایل آبجکت جدیدی به پروژه باشد، ما باید در تمام مکان‌های مورد نیاز آنرا اضافه کنیم. می‌توان بوسیلهٔ متغیرها این کار را ساده‌تر و مطمئن‌تر انجام داد. متغیرها این امکان را می‌دهند تا بتوانیم متنی را در آن‌ها ذخیره کنیم و در چندین مکان مورد استفاده قرار دهیم.

تقریباً تمام Makefile‌ها متغیری با نامی شبیه به objects ، OBJECTS ، objs ، OBJS ، obj یا OBJ دارند که فهرستی از نام تمام آبجکت‌های مورد نیاز در پروژه را در خود نگه داشته‌است.

ما می‌توانیم برای مثال خود متغیری بنام objects را با نوشتن چنین خطی در Makefile تعریف کنیم:

objects = main.o kbd.o command.o display.o insert.o search.o files.o utils.o

از این به بعد هر کجا نیاز به نوشتن فهرستی از فایل‌های آبکجت مورد استفاده بود، می‌توان از متغیر تعریف شده بصورت (objects)$ استفاده کرد.

edit : $(objects)
cc -o edit $(objects)

Makefile چطور پردازش می‌شود؟

بطور پیش‌فرض، Make با اولین Target موجود در Makefile شروع می‌کند (اولین هدفی که با نقطه شروع نشده است). این هدف Default Goal نامیده می‌شود. (می‌توان این هدف پیش‌فرض را توسط خط فرمان تغییر داد.)

وقتی شما دستور make را در خط فرمان می‌نویسید، برنامهٔ Make در دایرکتوری فعلی‌ای که در آن قرار دارید فایلی به‌نام Makefile را می‌خواند و شروع به پردازش اولین هدف موجود در آن می‌کند (Default Goal). اما قبل از اینکه دستورات موجود در این هدف اجرا شوند، Make باید تمام پیش‌نیازهای مربوط به آن هدف را پردازش کند. هر یک از این پیش‌نیازها نیز برای خود Rule دارند که برای ساخت آن‌ها پردازش خواهد شد.

بطور مثال در یک برنامه کامپایل دوباره یک فایل آبجکت زمانی اتفاق می‌افتد که فایل سورس یا هیدر مربوط به آن بعد از ساخت فایل آبجکت تغییر کرده باشند یا اساساً فایل آبجکت هنوز ساخته نشده‌باشد.

به این ترتیب است که قواعد (Rules) دیگر موجود در Makefile پردازش و اجرا می‌شوند. زیرا آن‌ها پیش‌نیازهای ساخت هدف اصلی هستند. روشن است که اگر یک قاعده جزء پیش‌نیازهای هدف اصلی نباشد پردازش نخواهد شد. مگر اینکه بطور صریح از Make بخواهید آن را پردازش کند (مثلاً با دستور make target-name)

منبع
[عکس: <a href=www.Mojsazan.com.gif]" class="mycode_img" />
پاسخ
سپاس شده توسط مهدی ابراهیمی ، worm
#3
آشنایی با ابزار GNU make


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

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

اگر بخواهیم کمی تخـصـصی صحبت کنیم، make جزء دسـته نرم افزارهایی کـه بـا نام سیستم‌هـای خبـره[۱] شـناخته می‌شوند، قرار می‌گیرد.

مقدمه

make در سـال ۱۹۷۷ توسط استوارت فلدمن[۲] در آزمایشگاه های بل[۳] ساخته شد. در سال ۲۰۰۳ دکتر فلدمن برای ابداع این ابزار مفید جایزه [۴] ACM را دریافت کرد.
هم اکنون ابزارهای make زیادی وجود دارند که بعضی ها با استفاده از همان make اولیه نوشته شده اند و بعضی دیگر از ابتدا دوباره طراحی شده اند.
در این مقـاله قصد داریم ابزار GNU make را که توسط ریچارد استالمن[۵] و رونالد مک گراث[۶] پیاده سـازی و از نسـخه ۳.۷۶ به بعد توسط پاول اسمیت[۷] توسعه یافته است معرفی کنیم.

آماده سازی و راه اندازی make

برای استفاده از این ابزار باید فایلی با نام Makefile وجود داشته باشد تا به وابستگی بین فایل ها و نحوه به روز رسانی آنها را مشخص کند. این فایل می تـوانـد نـام های دیـگری نـیـز داشـته باشـد. GNU make به تــرتـیـب فایلی با یـکی از نـام‌های Makefile, makefile, GNUmakefile را جستـجو می کـنـد. به صـورت مـعمـول بـهتر است شما یکی از نـام‌های makefile و یا Makefile را انـتـخاب کنید. (نام دوم به خاطر آغاز شـدن با حـرف بـزرگ ارجحیت دارد زیـرا در کنـار فایل‌های مهم دیگری مانند README و COPYING قرار خواهد گرفت) هـر چند شـما می توانید نام GNUmakefile را نیز برای این فایل در نظر بگیرید اما این نام توصیه نمی‌شود. به این دلیل که توسط دیگر نسخه‌های make قابل شناسایی نیست.
در صورت وجود یک Makefile شما می‌توانید به راحتی وارد دایرکتوری که Makefile در آن وجود دارد شده و دستور make را در خط فرمان صادر نمایید. البته با ارسال پارامتر f- و نام فایل نیز می‌توانید این کار را خارج از آن دایرکتوری انجام دهید. یک makefile ساده می تواند به شکل زیر تعریف شود:
Target ... : prerequisites ...
Command ...
...

Target فایـلی اسـت کـه بـاید به روز رسـانی شـود. (از این به بعد آن را هدف خواهیم نامید) در یک برنامه سی معمولا هدف یک فایـل object است کـه پـس از کامپایل شـدن به فایل های دیگر link می‌شود. prerequisites لیستی از پیش نیاز های Target است و command دستـور یا دستوراتی است کـه برای به روز رسانی Target استفاده می‌شود. دقت کنید که قبل از نوشتن هر دستور باید از کاراکتر Tab استفاده کنید. با یک مثال مطلب را بیشتر روشن می کنیم.
فرض کنید در حال طراحی نرم افزاری بـه زبـان سی با نام sample هستـیـم. فایل‌های این نرم افزار عبارتند از utils.cpp defs.h و main.cpp فایـل utils.cpp از توابعی کـه در defs.h تعریف شده استـفاده می‌کـند. بنابراین utils.cpp به defs.h وابسته است یا به عبارت دیگر defs.h پیش نیاز utils.cpp است. Makefile می‌تواند به شکل زیر باشد:
sample: main.o utils.o
gcc main.o utils.o -o sample

main.o: utils.o main.cpp
gcc -c main.cpp

utils.o: utils.cpp defs.h
gcc -c utils.cpp
همانطور که مشاهده می‌کنید فایل utils.o به دو فایل defs.h و utils.cpp وابسته است. علت اینکه ما فایل utils.cpp را به عنوان پیش نیاز خودش ذکر کرده ایم این است که با تغییر این فایل نیز ما باید دوباره دستور کامپایل را اجرا کنیم.
همانطور که متوجه شده‌اید هدف main.o به utils.o که خود نیز یک هدف است وابسته می‌باشد. در این حـالت با تغییر هر یـک از پیش نـیـازهای utils.o هر دو هدف main.o و utils.o نـیز باید بـه روز رسانی شوند. در واقع می تـوان گفت که پیش نیازهای utils.o پـیـش نیاز main.o نیز می‌باشـند. در پایان هر دو این object ها به یکدیگر link شده و فایل اجرایی sample را می‌سازند.
شاید تعجب کنید که چرا ترتیب کامپایل شدن این نرم افزار نمونه به صورت معکوس در Makefile نوشته شده است؟
دلیل آن نـحوه خوانـدن این فایـل تـوسـط make اسـت. make اولیـن هـدف را در Makefile می خـواند و سـعی در بـه روز رسانی آن (با توجه به پیش نیازها) می‌کند. در فایل نمونهٔ ما اولین هدف sample است که به دو فایل main.o و utils.o وابسته است. اگر پیش نیازها به روز نبودند، make به دنبال هدفی می‌گردد که به روز رسانی آنها را انجام می‌دهد.
برای این کار Makefile را از بـالا بـه پایین برای یافتـن این اهداف جستجو می کند. به این ترتیب می توانید مطمئن شوید که با هربار اجرای دستور make فایل sample و تمام پیش نیازهای آن در صورت لزوم به روز رسانی خواهند شد.
اهداف می توانند به صورت پارامتر نیز برای make ارسـال شونـد. بـه عنـوان مثال اکثر Makefile ها شامـل هدفی به نام clean هستند که کلیه object ها و فایل‌های باینری ساخته شده را پاک می کند.
clean:
rm *.o
rm sample
در این مثال دو دستور برای clean در نظر گرفته شده است. و همانطور که مشاهده می‌کنید هدف clean به هیچ هدف یا فایل دیگری وابسته نیست. بنابراین همیشه قابل اجرا است. به این معنی کـه برای اجرا شدن شـرایط خاصی (مانند تغییر در پیش نیازها) نیاز ندارد. و از آنـجایی که هدفی به clean وابسـته نیست به صورت خودکار فراخوانده نخواهد شد. برای پاک کردن فایل های کامپایل شده می توانید دستور زیر را صادر کنید:
$make clean
پارامتر clean باعث می‌شود که make به جای به روز رسانی اولین هدف سعی در به روز رسانی clean نمایـد که منجر به پاک شدن کلیه فایل‌های object و فایل sample خواهد شد.

متغیرها در Makefile

همانطور که گفتـیـم ابزار make بـرای خـودکـار سازی فرآیـنـدها به کـار گـرفته می شود. بـنابراین طبیعی است که در آن امکاناتی مانند متغییرها، حلقه ها، شرط ها و ... قرار گرفته باشد. خطوط زیر را در یک Makefile در نظر بگیرید:
main.o: utils.o main.cpp
gcc $(CFLAGS) -c main.cpp
CFLAGS یک متغیـیـر محیطی اسـت و به دو روش قابـل مقدار دهی است. اول اینکه قبل از صدور دستور make آن را به عنوان یک متغییر محیطی تعریف و مقدار دهی کنیم. به عنوان مثال با صادر کردن دستور زیر:
$ export CFLAGS=-O2
حـال بـا صـادر کـردن دستـور make، عبارت (CFLAGS)$ با O2- جایـگزین خواهـد شد. و اگر به دستـوری کـه در Makefile نـمونـه نـوشته شده تـوجه کنـیـد متوجه می شـویـد که O2- به عنوان یـک پـارامتـر به gcc ارسال می‌شود. (O2- بـاعث optimize شـدن فایـل خـروجی می‌گردد.) روش دوم مـقدار دهی این متـغیـیـر، ارسـال آن بـه عـنـوان پـارامتـر بـه make می‌باشد:
$ make CFLAGS=-O2
این دستور معادل دستور بالا است.
علاوه بر این متغییرهای محیطی، make قابلیت تعریف متغییر درونی را نیز در اختیار کاربر قرار می‌دهـد. از آنجایی که کار با متغییرها در make مبحثی گسترده می‌باشد، به تعریف تعدادی از متغییرهای ویژه بسنده کرده و برای اطلاعات بیشتر شما را به راهنماهای make ارجاع می دهیم.
فرض کنـیـد تـعدادی فایل در دایرکـتـوری‌های مختلف داریم که پـیـش نیاز دیگر فایل‌ها می‌باشنـد. Makefile زیـر را در نظر بگیرید:
main.o: main.cpp include/defs.h structure/list.h
gcc -c include/defs.h structure/list.h main.cpp
ایـن طرز نوشتـن فـایل علاوه بر ناخـوانا نمودن آن باعث بـه وجـود آمدن اشـکالات زیادی نیز خواهد شد چرا که به خـاطر سپردن تمام وابستـگی‌ها و دایـرکتـوری حاوی آنها مشکل اسـت. هـمچنین شما مجبور به تکرار دوباره پیش نیازها برای دستور کامپایل هستـیـد که خود باعث بروز اشتـبـاه خـواهد شد. make برای ایـن کـار راه حلی را ارائه نـموده است و آن استفاده از متغییر‌های خاص می باشد. با استفاده از این متغییر‌ها Makefile به این صورت در خواهد آمد:
VPATH = include:structure

main.o: main.cpp defs.h list.h
&nbspgcc -c $^ -o $@
ایـن طرز نوشتـن فـایل علاوه بر ناخـوانا نمودن آن باعث بـه وجـود آمدن اشـکالات زیادی نیز خواهد شد چرا که به خـاطر سپردن تمام وابستـگی‌ها و دایـرکتـوری حاوی آنها مشکل اسـت. هـمچنین شما مجبور به تکرار دوباره پیش نیازها برای دستور کامپایل هستـیـد که خود باعث بروز اشتـبـاه خـواهد شد. make برای ایـن کـار راه حلی را ارائه نـموده است و آن استفاده از متغییر‌های خاص می باشد. با استفاده از این متغییر‌ها Makefile به این صورت در خواهد آمد:

نویسنده: آیدین غریب نواز
aidin.vf@gmail.com

پانویسها:
[۱] Expert Systems
[۲] Stuart Feldman
[۳] Bell Labs
[۴] Association for Computer Machinery
[۵] Richard Stallman
[۶] Roland McGrath
[۷] Paul D.Smith
[۸] http://www.gnu.org/make/manual/make.html

مجوز: GNU/FDL

منبع
[عکس: <a href=www.Mojsazan.com.gif]" class="mycode_img" />
پاسخ
سپاس شده توسط مهدی ابراهیمی ، worm
#4
کامپایل یه برنامه ساده تک فایلی
در زیر روش کامپایل یک برنامه با نام hi را از فایلی به نام hi.cpp توضیح می دهم
کد برنامه hi.cpp
#include <iostream>
using std::cout;
int main()
{
cout<<”hi”;
return 0;
}
حال دستور زیر را برای کامپایل برنامه در g++ وارد می کنم
G++ -o hi hi.cpp
شما با این کار برنامه به نام hi را از فایلی به نام hi.cpp ایجاد نموده اید برای اجرای برنامه کافیست در خط فرمان دستور زیر را وارد کنید
./hi
در لینوکس برنامه ها پسوند خاصی ندارند ولی برای اطلاع بیشتر پسوند برنامه شما .out است که برای اجرای برنامه خود لازم نیست انرا بنویسید . روش دیگری نیز برای کامپایل برنامه وجود دارد که در این روش شما ابتدا فایل ابجکت برنامه را ایجاد می کنید یعنی ابتدا انرا به زبان ماشین تبدیل می کنید سپس فایل ابجکت خود را کامپایل می کنید
g++ -c hi.cpp
g++ hi.o -o hi

در واقع روش دوم نیز نتیجه ای مانند روش اول می دهد با این تفاوت که در روش دوم شما ابتدا برنامه خود را به زبان ماشین تبدیل می کنید و سپس فایل ایجاد شده را به کتابخانه سیستم لینک می کنید ولی در این روش فایلی مانند hi.o نیز در سیستم شما ایجاد می شود ولی روش اول در ضمن کامپایل این فایل را ایجاد سپس پاک می نماید.
توجه : اگر شما عبارت –o hi را فراموش کنید نام پیش فرض برنامه شما a.out می شود.

نحوه کامپایل برنامه هایی که از چند فایل تشکیل شده اند
من می خوام برنامه ای رو کامپایل کنم نامش hamid هست و از دو فایل h1.cpp و h2.cpp تشکیل شده برای اینکار دستور زیر را در کنسول وارد می کنم
g++ h1.cpp h2.cpp -o hamid
همین نتیجه رو میشه با وارد کردن سه خط دستور به دست اورد
g++ -c h1.cpp
g++ -c h2.cpp
g++ h1.o h2.o -o hamid
مزیت روش دوم نسبت به روش اول این هست که ما هر کدام از فایل های برنامه رو بصورت جدا کامپایل می کنیم نه بصورت یکجا اهمیت این مسئله در اینجاست که اگه شما یه روزی خواستید برنامه خودتون رو اپدیت کنید نیاز ندارید دوباره همه فایل ها رو کامپایل کنید مثلا من h1.cpp رو تغییر می دم و حال دستور زیر را برای کامپایل شان وارد می کنم
g++ -c h1.cpp
g++ h1.o h2.o -o hamid
روش دیگرنیز برای کامپایل برنامه هایی که از چند فایل تشکیل شده اند وجود دارد
روش دوم
استفاده از دستور make و ساخت makefile
MAKEFILE همون فايليه كه به كامپايلر مي گه از يه تعدادي فايل سورس چه طوري بايد يه فايل اجرايي بسازه. اگه موقع توسعه يه نرم افزار واسه كامپايل اون MAKEFILE ننويسين، اونوقت مجبورين دستور كامپايل هر فايل سورس رو جداگانه صادر كنين و خودتون يادتون باشه كه كدوم فايل بعد از آخرين كامپايل تغيير كرده و نياز به كامپايل مجدد داره و كلي مصائب ديگه، ولي اگه MAKEFILE نوشته باشين فقط كافيه كه برنامه make رو اجرا كنين و اون خودش واستون كار كامپايل رو انجام مي ده (البته اگه MAKEFILE رو درست نوشته باشين). شما وقتي تو محيط يه IDE هم برنامه مي نويسين، اون IDE كار ساختن MAKEFILE رو در پس زمينه واستون انجام مي ده و بعد كامپايلر رو صدا مي زنه
زمانی که ما برنامه های بزرگ می نویسیم استفاده از ابزار make برای کامپایل برنامه بسیار عالی است.
Make از دستورات makefile که از سورس ها ساخته شده برای ساخت برنامه استفاده می کنه.
Makefile شامل لیستی از عبارت ها و جمله هاست که باید برای ساخت برنامه انجام بشه . به عنوان مثال من برای برنامه hi یک makefile ایجاد می کنم
hi: hi.o
g++ -o hi hi.o

hi.o: hi.cpp
g++ -c -o hi.o hi.cpp
که این رو باید با پسوند Makefile.hi ذخیره کنید
که به make میگه برای ساخت یک برنامه اجرایی hi وابسته هست به hi.o که با نوشتن این دستور در خط فرمان ایجاد میشه g++ -o hi hi.o و hi.o وابسته هست به hi.cpp که با استفاده از دستور
g++ -c -o hi.o hi.cpp ایجاد میشه ( -c به کامپایلر میگه بعد از اجرای این مرحله متوقف بشه)
برای اجرای دستور make من فایل hi.cpp و Makefile.hi رو در مسیر زیر کپی می کنم
/home/hamid
خوب حالا دستور زیر رو برای ساخت برنامه می دم
Make -f /home/hamid/Makefile.hi
در همون دایرکتوری ( /home/hamid ) برام برنامه hi رو درست میکنه که برای اجراش دستور زیر را وارد می کنم
/home/hamid/hi
منابع
http://hepwww.ph.qmul.ac.uk/sim/gcclinux.html?desc=
Compiling+and+Running+C%2B%2B+programs+on+Linux&fi le=gcclinux.html

http://galton.uchicago.edu/~gosset/Compdocs/gcc.html

در پست های بعدی در این مورد بیشتر مثال میزنم
__________________
[عکس: <a href=www.Mojsazan.com.gif]" class="mycode_img" />
پاسخ
سپاس شده توسط مهدی ابراهیمی ، worm ، Beni_Vanda
#5
لینک های مفید در این ضمینه

http://www.cs.duke.edu/~ola/courses/prog...files.html
[عکس: <a href=www.Mojsazan.com.gif]" class="mycode_img" />
پاسخ
سپاس شده توسط مهدی ابراهیمی
#6
با سلام و خسته نباشید
سوالی که داشتم اینکه از makefile ها فقط در لینوکس بایستی استفاده شود.پروژه ای که در مورد asift در پست قبل گذاشته بودن یک فایل make داره که نمی تونم اجراش کنم .
و اگر در لینوکس اجرا می شه چی کار باید بکنم چه دستوری بنویسم.
ممنون می شم اکه راهنماییم کنید
پاسخ
سپاس شده توسط
#7
با سلام خدمت شما دوست عزیز

make file نسخه ویندوزی دارد http://gnuwin32.sourceforge.net/packages/make.htm

توی لینوکس دستور make را به اینصورت
apt-get install make

البته توی دبیان بیس ها
موفق باشید
[عکس: <a href=www.Mojsazan.com.gif]" class="mycode_img" />
پاسخ
سپاس شده توسط
#8
با سلام و خسته نباشید
دوستان من در لینوکس اوبونتو می خوام برنامه ای که قبلا نوشته شده را اجرا کنم قبلا تولینوکس کامپایلر g++ و make را نصب کردم .برنامه ای که می خوام اجراش کنم یک Makefile بدون هیچ نوع پسوندی و یک cmakefile با پسوند txtداره .دستوری که بایستی بنویسم تا make file زو اجراش کنم رو نمی دونم.خواهشا دراین زمینه به من کمک کنید
اگه سریع جواب سوالم رو بدید ممنون می شم
پاسخ
سپاس شده توسط
#9
(05-03-2012, 06:56 PM)yusefnejad نوشته: با سلام و خسته نباشید
دوستان من در لینوکس اوبونتو می خوام برنامه ای که قبلا نوشته شده را اجرا کنم قبلا تولینوکس کامپایلر g++ و make را نصب کردم .برنامه ای که می خوام اجراش کنم یک Makefile بدون هیچ نوع پسوندی و یک cmakefile با پسوند txtداره .دستوری که بایستی بنویسم تا make file زو اجراش کنم رو نمی دونم.خواهشا دراین زمینه به من کمک کنید
اگه سریع جواب سوالم رو بدید ممنون می شم

احتمالا این برنامه داره از cmake برای کامپایل استفاده می‌کنه. باید فایلی به اسم CMakeLists.txt در شاخه اصلی برنامه باشه (یا در یه پوشه به اسم cmake با دستور

کد:
cmake CMakeLists.txt

برنامه رو کامپایل می‌کنید (درست یادم نیست این دستور برنامه رو کامپایل می‌کرد یا MakeFile می‌ساخت ولی در حال فرق زیادی نداره.

موفق باشید.
پاسخ
سپاس شده توسط مهرداد عباسی ، worm
#10
سلام من برنامه ای رو گرفتم که کلی فولدر داره و داخل هر فولدر پسوند .h و .c هست و make file.

ویندوزم سون هست 64 بیت . واقعا مشکل دارم نمی دونم چه طوری این برنامه اجرا میشه.خواهشا یکی راهنمایی ام کنید.
پاسخ
سپاس شده توسط


موضوعات مشابه ...
موضوع نویسنده پاسخ بازدید آخرین ارسال
Information نحوه کامپایل و اجرای یک برنامه به زبان ++C در eclipse مهدی ابراهیمی 3 10,145 08-01-2014, 01:25 AM
آخرین ارسال: mk3000
  اجرای تابع با استفاده از آدرس آن مهدی ابراهیمی 0 2,812 06-09-2013, 09:04 AM
آخرین ارسال: مهدی ابراهیمی
  include چیست ؟ چگونه بنویسیم و چگونه از آن استفاده کنیم؟ alamdar_313 4 8,809 04-28-2012, 10:30 PM
آخرین ارسال: alamdar_313
  چرا از یک GUI-TOOLKIT استفاده کنیم؟ مهرداد عباسی 0 3,326 08-21-2010, 12:05 AM
آخرین ارسال: مهرداد عباسی
  آموزش نحوه برنامه نویسی و اجرا c++ در لینوکس مهدی ابراهیمی 0 6,485 08-18-2010, 10:13 AM
آخرین ارسال: مهدی ابراهیمی

پرش به انجمن:


کاربران در حال بازدید این موضوع: 1 مهمان