Linux membuat Perintah dengan Contoh

Pendahuluan

Linux make command adalah utilitas yang umum digunakan oleh sysadmin dan pengembang. Perintah membantu dalam proses kompilasi dan merupakan alat yang harus dimiliki untuk membangun aplikasi besar. Utilitas ini memotong pengulangan dan mempercepat kompilasi, menghemat waktu.

Artikel ini akan menunjukkan cara menggunakan make Linux perintah dengan contoh.

Prasyarat

• Akses ke terminal.
• make fungsi terpasang.
• Editor teks.

Catatan: Jika make tidak tersedia di sistem, gunakan sudo apt install make .

Bagaimana cara kerja perintah make?

make perintah mengkompilasi potongan program yang berbeda dan membangun executable akhir. Tujuan make adalah mengotomatiskan kompilasi file, membuat prosesnya lebih sederhana dan tidak memakan waktu lama.

Perintah ini bekerja dengan bahasa pemrograman apa pun selama kompiler dapat dieksekusi dengan perintah shell.

Kompilasi sangat mudah ketika bekerja dengan beberapa file. Oleh karena itu, prosesnya termasuk memanggil kompiler dan mencantumkan nama file.

Misalnya, untuk mengkompilasi program C dari tiga file (file1.c , file2.c , file3.h ):

Panggil kompiler dengan:

gcc file1.c file2.c file3.h

gcc perintah membuat a.out file, yang merupakan standar kompilasi yang dapat dieksekusi.

Namun, mengubah salah satu file sumber memerlukan kompilasi ulang semuanya, yang bahkan lebih rumit saat bekerja dengan aplikasi besar. make perintah mengotomatiskan proses, memungkinkan pengguna untuk memperbarui hanya bagian yang perlu diubah tanpa mengkompilasi ulang setiap file.

make perintah menggunakan file yang dibuat pengguna, Makefile, untuk mengkompilasi potongan program. Saat dijalankan untuk pertama kalinya, make mencari instruksi Makefile, misalnya, deskripsi file dan waktu modifikasi. Berdasarkan data yang tersedia, make memutuskan file mana yang perlu diperbarui dan mengeluarkan perintah yang diperlukan.

Apa itu Makefile?

Makefile adalah file teks yang berisi seperangkat aturan yang menginstruksikan make cara membuat aplikasi. Aturan terdiri dari tiga bagian:target , dependensi , dan perintah .

Sintaks dasar Makefile adalah:

target: dependencies
<TAB> commands

Bagian dari sintaks adalah:

• Target . Nama file yang akan dibuat atau diperbarui setelah menjalankan make .
• Ketergantungan . Nama file (dipisahkan dengan spasi) dari mana target dibuat.
• Perintah . Aturan yang menjelaskan cara membuat atau memperbarui target saat dependensi berubah.

Satu Makefile memiliki beberapa set aturan. Aturan pertama adalah aturan default dan menyatakan bagaimana executable akhir (target) dibuat dari file objek yang belum dibuat (dependensi):

Sintaks dalam hal ini adalah:

EXECUTABLE: Object file 1, Object file 2
<TAB> commands

Catatan: Perintah di Makefiles selalu muncul setelah TAB kunci. Jika tidak, perintah tidak akan berfungsi.

Setelah menetapkan aturan satu, pengguna menambahkan instruksi tentang cara membuat file objek:

make perintah bekerja dengan mengkompilasi file sumber ke dalam file objek dan kemudian mengkompilasi file objek ke dalam file target, yang dapat dieksekusi terakhir. Sintaks Makefile dengan tiga aturan yang disebutkan di atas adalah:

EXECUTABLE: Object file 1, Object file 2
<TAB> commands

Object file 1: Source file 1, Source file 2
<TAB> commands

Object file 2: Source file 2
<TAB> commands

Linux membuat Sintaks Perintah

make dasar sintaks terlihat seperti ini:

make [OPTIONS]

Saat dieksekusi tanpa argumen, make membangun target pertama dari Makefile.

Linux membuat Opsi Perintah

make Perintah banyak digunakan karena keefektifannya, variasinya, dan kemampuannya untuk melakukan tindakan tertentu. Sementara perintah mencetak hasil saat dijalankan tanpa opsi, menambahkan argumen akan memperluas make kegunaan.

Berikut adalah opsi yang paling sering digunakan:

Perintah	Deskripsi
-B , --always-make	Mengkompilasi semua target tanpa syarat.
-d , --debug[=FLAGS]	Mencetak informasi debug.
-C dir , --directory=dir	Mengubah direktori sebelum menjalankan Makefile.
-f file , --file=file , --Makefile=FILE	Menggunakan file tertentu sebagai Makefile.
-i , --ignore-errors	Mengabaikan semua kesalahan dalam perintah.
-I dir , --include-dir=dir	Menentukan direktori untuk mencari Makefile yang ditentukan.
-j [jobs] , --jobs[=jobs]	Menentukan jumlah pekerjaan yang dijalankan secara bersamaan.
-k , --keep-going	Terus menjalankan make selama mungkin setelah mendapatkan kesalahan.
-l [load] , --load-average[=load]	Menentukan bahwa tidak ada tugas baru yang harus dimulai jika tugas lain ada dalam antrian.
-n , --dry-run , --just-print , --recon	Mencetak keluaran yang diharapkan tanpa menjalankan make .
-o file , --old-file=file , --assume-old=file	Memastikan bahwa make tidak membuat ulang file meskipun lebih lama dari dependensinya.
-p , --print-data-base	Mencetak database yang dihasilkan setelah membaca Makefile.
-q , --question	Mengaktifkan mode Pertanyaan, di mana make tidak menjalankan perintah apa pun tetapi mengembalikan status keluar nol jika target sudah dikompilasi.
-r , --no-builtin-rules	Menghilangkan aturan implisit bawaan.
-s , --silent , --quiet	Membatasi pencetakan perintah saat dijalankan.
-S , --no-keep-going , --stop	Berhenti "-k , --keep-going " perintah.
-t , --touch	Menyentuh file alih-alih menjalankan perintah.
--trace	Melacak disposisi setiap target.
-W file , --what-if=file , --new-file=file , --assume-new=file	Mengabaikan fakta bahwa file target telah dimodifikasi.
--warn-undefined-variables	Memperingatkan bahwa variabel yang tidak diketahui direferensikan.

Linux membuat Contoh Perintah

Cara terbaik untuk memahami make dan Makefiles adalah dengan menjalankan perintah dan opsi yang berbeda pada program sederhana.

Misalnya, untuk membuat file yang dapat dieksekusi yang mencetak pesan "Pelajari tentang Makefile" , ikuti langkah-langkah berikut:

1. Buat direktori bernama Uji .

2. Buat tiga file sumber main.c , text.c , dan text.h :

• main.c - adalah file dengan fungsi utama (int main ) yang memanggil fungsi dari file lain.

• text.c - adalah file yang ingin Anda cetak "Pelajari tentang Makefile!".

• text.h - adalah file header dengan deklarasi untuk fungsi. Header disertakan dalam kedua c file dengan #include argumen, yang memiliki tujuan yang sama dengan menyalin/menempelkan konten header.

Bagian berikut mengilustrasikan beberapa kasus penggunaan umum make dan Makefiles pada tiga file yang disebutkan di atas.

Catatan: Contoh berikut ditulis dalam bahasa C.

Buat Program

Ada dua cara untuk membuat program:

• Mengkompilasi file dengan cara standar dengan memanggil compiler gcc. Metode ini cocok untuk program yang lebih kecil.
• Menggunakan make dan Makefile.

Buat Program dengan Gcc Compiler

Gunakan kompiler gcc hanya untuk program sederhana. Jika tidak, gunakan Makefiles saat bekerja dengan banyak file.

Untuk membuat program dengan compiler:

1. Buka terminal dan arahkan ke direktori yang berisi file.

2. Aktifkan gcc compiler dan ketik nama keduanya c file. Header tidak dikompilasi karena sudah disertakan dalam c file.

gcc main.c text.c

3. Buat daftar semua file di direktori saat ini dengan ls perintah:

ls

Terminal menunjukkan bahwa a.out yang baru dapat dieksekusi file dibuat. Eksekusi juga terlihat melalui file explorer:

Untuk menguji apakah kompilasi berhasil, aktifkan file yang dapat dieksekusi dengan:

./a.out

Terminal menunjukkan bahwa executable bekerja dengan baik.

Buat Program dengan Make dan Makefile

Mengkompilasi file dengan make dan Makefiles lebih sederhana daripada menggunakan compiler. Mulailah dengan membuat dokumen teks baru di direktori yang sama dan beri nama Makefile atau makefile .

Buka file dan gunakan sintaks dasar Makefile sebagai pedoman:

1. Ketik nama executable baru sebagai target, misalnya my_app.

2. Tambahkan file objek main.o dan text.o sebagai dependensi. make perintah mengkompilasi ulang target setiap kali file objek berubah.

3. Tekan TAB dan aktifkan gcc compiler untuk file objek:

<TAB> gcc main.o text.o

4. Tambahkan -o tandai dan beri nama target my_app.

Setelah menulis aturan pertama, Makefile terlihat seperti ini:

my_app: main.o text.o
<TAB> gcc main.o text.o -o my_app

Selanjutnya, instruksikan Makefile tentang cara membuat main.o :

1. Setel main.o sebagai target.

2. Ketik main.c sebagai ketergantungan. main.c berfungsi untuk membuat dan memperbarui main.o .

3. Tulis perintah berikut untuk memperbarui main.o setiap kali main.c perubahan:

gcc -c main.c

4. Tambahkan -c flag untuk menginstruksikan Makefile agar tidak membuat executable baru tetapi hanya membaca kode dan mengkompilasi file objek.

main.o: main.c
<TAB> gcc -c main.c

Untuk membuat text.o , tetapkan file itu sebagai target, dan tambahkan keduanya text.c dan text.h sebagai dependensi. Namun, gcc perintah hanya mengkompilasi text.c file, karena header tidak pernah dikompilasi:

text.o: text.c text.h
<TAB> gcc -c text.c

Simpan Makefile dan ketik make di terminal.

make perintah membuat dua file objek (main.o dan text.o ) dan yang dapat dieksekusi (aplikasi_saya ).

Untuk memverifikasi bahwa membuat file baru, jalankan ls lagi:

Terminal menunjukkan bahwa menjalankan perintah membuat my_app . Untuk menjalankan aplikasi_saya file, ketik:

./my_app

Perbarui Program

Ketika satu file sumber diubah, make hanya memperbarui file objek tergantung pada file sumber itu. Misalnya, untuk mengubah teks yang ditampilkan saat menjalankan aplikasi_saya dari "Pelajari tentang Makefiles " ke "Di mana saya ?":

1. Buka text.c di editor teks:

2. Ubah teks menjadi "Di mana saya?" :

3. Simpan file, buka terminal, dan jalankan make :

make perintah mendeteksi perubahan di text.c dan hanya mengkompilasi ulang file itu.

Untuk memverifikasi perubahan, jalankan file yang dapat dieksekusi:

./my_app

Kompilasi Semua File

Untuk mengkompilasi semua file dan tidak hanya file yang diubah, gunakan -B atau --always-make pilihan.

Misalnya, untuk mengubah teks di text.c file kembali ke "Pelajari tentang Makefile" dan simpan file, masukkan:

make -B

Keluarannya menunjukkan bahwa make mengkompilasi semua file dalam folder, bahkan yang belum diubah.

Bersihkan File Objek

Saat pengguna menjalankan make untuk pertama kalinya, perintah membuat file objek dan dapat dieksekusi. Oleh karena itu, untuk mendeklarasikan folder sumber dan membersihkan file objek, tambahkan clean fungsi ke Makefile:

clean:
<TAB> rm *.o my_app

Perintahnya terdiri dari:

• Target bersih tanpa ketergantungan - target selalu dianggap ketinggalan zaman dan selalu dieksekusi.
• Yang rm perintah - menghapus objek tertentu.
• *.o bagian - mencocokkan file dengan o ekstensi dan membersihkan file objek dan aplikasi_saya .

Untuk membersihkan file objek, jalankan:

make clean

Setelah menjalankan ls lagi, terminal menunjukkan bahwa file objek dan aplikasi_saya telah dihapus.

Jalankan make dalam Mode Debug

Jalankan make dalam mode debug untuk mencetak info tambahan tentang proses kompilasi. Jalankan make dengan -d opsi untuk menampilkan output debug:

make -d

Gunakan File Berbeda sebagai Makefile

Secara default, make mencari file bernama Makefile atau makefile di direktori saat ini. Untuk menggunakan file lain, jalankan:

make -f [file_name]

Misalnya, jika Makefile bernama my_file , jalankan:

make -f my_file

Gunakan Variabel

Variabel di Makefiles mewakili beberapa nama file, argumen, target, dependensi, perintah, direktori sumber, atau item lainnya. Selanjutnya, variabel didefinisikan dengan nama dan mewakili string teks yang disebut nilai variabel.

Untuk mendefinisikan variabel, gunakan = . Misalnya, ganti gcc dengan variabel C.

C=gcc

my_app: main.o text.o
<TAB> $ (C) main.o text.o -o my_app

main.o:main.c
<TAB> $ (C) -c main.c
        
text.o: text.c text.h
<TAB> $ (C) -c text.c

Saat menjalankan make di terminal, perintah membaca C variabel sebagai gcc :

Kesimpulan

Setelah melalui contoh dalam tutorial ini, Anda tahu cara menggunakan make perintah di Linux dan cara kerjanya.

Selanjutnya, unduh lembar contekan perintah Linux untuk mempelajari perintah Linux penting lainnya.