ບົດແນະ ນຳ ໂດຍຫຍໍ້ກ່ຽວກັບການສ້າງລາຍໄດ້ໃນການພັດທະນາໂປແກຼມໂປຼແກຼມໂປຼແກຼມໂປຼແກຼມໂປຼແກຼມໂປຼແກຼມໂປຼແກຼມໂປຼແກຼມ

GNU Make ແມ່ນປະໂຫຍດດ້ານການພັດທະນາທີ່ ກຳ ນົດພາກສ່ວນຂອງຖານຂໍ້ ກຳ ນົດສະເພາະທີ່ຕ້ອງໄດ້ຮັບການແນະ ນຳ ແລະສາມາດອອກ ຄຳ ສັ່ງເພື່ອ ດຳ ເນີນການປະຕິບັດງານເຫຼົ່ານັ້ນຢູ່ເທິງຖານລະຫັດ. ຜົນປະໂຫຍດໂດຍສະເພາະ ເຮັດ ນີ້ສາມາດ ນຳ ໃຊ້ກັບພາສາການຂຽນໂປແກຼມໃດ ໜຶ່ງ ທີ່ສະ ໜອງ ໃຫ້ການລວບລວມຂໍ້ມູນຂອງພວກມັນສາມາດເຮັດໄດ້ຈາກຫອຍໂດຍການອອກ ຄຳ ສັ່ງ.

ເພື່ອ ນຳ ໃຊ້ GNU Make, ພວກເຮົາຕ້ອງມີກົດລະບຽບບາງຢ່າງທີ່ ກຳ ນົດຄວາມ ສຳ ພັນລະຫວ່າງເອກະສານທີ່ແຕກຕ່າງກັນໃນໂປແກຼມຂອງພວກເຮົາແລະ ຄຳ ສັ່ງ ສຳ ລັບການອັບເດດແຕ່ລະເອກະສານ. ສິ່ງເຫຼົ່ານີ້ຖືກຂຽນໃສ່ໃນເອກະສານພິເສດທີ່ມີຊື່ວ່າ ‘ ສິ່ງທີ່ຕ້ອງເຮັດ ‘. ຄຳ ສັ່ງທີ່ໃຊ້ ເຮັດ 'ໃຊ້ຖານຂໍ້ມູນ' ທຳ ລາຍ 'ແລະເວລາດັດແກ້ຫຼ້າສຸດຂອງເອກະສານເພື່ອຕັດສິນໃຈວ່າເອກະສານທັງ ໝົດ ຈະຖືກປະກອບຄືນ ໃໝ່.

ເນື້ອໃນຂອງ Makefile

ໂດຍທົ່ວໄປແລ້ວ ຮູບຮ່າງ 'ມີ 5 ປະເພດຄື: ກົດລະບຽບທີ່ກ່ຽວຂ້ອງ, ກົດລະບຽບທີ່ຊັດເຈນ, ນິຍາມຕົວປ່ຽນແປງ, ທິດທາງແລະ ຄຳ ເຫັນ.

< ກົດລະບຽບທີ່ຊັດເຈນ ກຳ ນົດວິທີການສ້າງ/ເຮັດເອກະສານຄືນ ໜຶ່ງ ຫຼືຫຼາຍເອກະສານ (ເອີ້ນວ່າເປົ້າ ໝາຍ, ຈະອະທິບາຍໃນພາຍຫຼັງ) ແລະເວລາໃດທີ່ຈະເຮັດແບບດຽວກັນ. ກົດລະບຽບທີ່ສົມມຸດຕິຖານ ກຳ ນົດວິທີເຮັດ/ເຮັດເອກະສານຄືນ ໜຶ່ງ ຫຼືຫຼາຍເອກະສານໂດຍອີງໃສ່ຊື່ຂອງພວກມັນ. ມັນອະທິບາຍວ່າຊື່ເອກະສານເປົ້າ ໝາຍ ມີຄວາມ ສຳ ພັນກັບເອກະສານໃດ ໜຶ່ງ ທີ່ມີຊື່ຄ້າຍຄືກັບເປົ້າ ໝາຍ.

ຂໍ້ມູນທີ່ບອກ ເຮັດ ວິທີການປະມູນລະບົບຄືນ ໃໝ່ ແມ່ນມາຈາກການອ່ານຖານຂໍ້ມູນທີ່ເອີ້ນວ່າ ຜູ້ສ້າງ . ແບບງ່າຍດາຍ ການຜະລິດ ຈະປະກອບດ້ວຍກົດລະບຽບຂອງ syntax ຕໍ່ໄປນີ້:

target ... : prerequisites ... 
	recipe 
... 
...

ເປົ້າ ໝາຍ ຖືກ ກຳ ນົດໃຫ້ເປັນເອກະສານຜົນຜະລິດທີ່ຜະລິດໂດຍໂປແກມ. ມັນຍັງສາມາດເປັນ ເປົ້າ ໝາຍ ສຳ ລັບ ເຊິ່ງຈະອະທິບາຍຢູ່ດ້ານລຸ່ມ. ຕົວຢ່າງຂອງເອກະສານເປົ້າ ໝາຍ ປະກອບມີການປະຕິບັດງານ, ໄຟລ໌ວັດຖຸຫຼືເປົ້າ ໝາຍ ຕ່າງໆເຊັ່ນ ສະອາດ , ຕິດຕັ້ງ , ຖອນການຕິດຕັ້ງ ແລະອື່ນໆ.

ຄວາມຕ້ອງການເບື້ອງຕົ້ນ ແມ່ນເອກະສານທີ່ຖືກ ນຳ ໃຊ້ເປັນສ່ວນປະກອບເພື່ອສ້າງເອກະສານເປົ້າ ໝາຍ.

ສູດ ສູດ ແມ່ນການກະ ທຳ ທີ່ ເຮັດ ສຳ ລັບສ້າງເອກະສານເປົ້າ ໝາຍ ໂດຍອີງໃສ່ເງື່ອນໄຂເບື້ອງຕົ້ນ. ມັນ ຈຳ ເປັນທີ່ຈະຕ້ອງໃສ່ໂຕະກ່ອນ ໜ້າ ສູດແຕ່ລະສູດພາຍໃນ ເຄື່ອງປະດັບ ເວັ້ນເສຍແຕ່ວ່າພວກເຮົາລະບຸຕົວປ່ຽນ '.RECIPEPREFIX' ເພື່ອ ກຳ ນົດຕົວລະຄອນອື່ນເປັນ ຄຳ ນຳ ໜ້າ ໃນສູດ

final: main.o end.o inter.o start.o
	gcc -o final main.o end.o inter.o start.o
main.o: main.c global.h
	gcc -c main.c
end.o: end.c local.h global.h
	gcc -c end.c
inter.o: inter.c global.h
	gcc -c inter.c
start.o: start.c global.h
	gcc -c start.c
clean:
	rm -f main.o end.o inter.o start.o

ໃນຕົວຢ່າງຂ້າງເທິງນີ້ພວກເຮົາໄດ້ ນຳ ໃຊ້ເອກະສານ 4 C ແລະສອງຫົວ ສຳ ລັບການສ້າງ ສຸດທ້າຍ . ນີ້ເອກະສານ“ .o” ແຕ່ລະອັນແມ່ນທັງເປົ້າ ໝາຍ ແລະຄວາມຕ້ອງການເບື້ອງຕົ້ນພາຍໃນ ທີ່ຢູ່ການຜະລິດ . ດຽວນີ້ລອງເບິ່ງຊື່ເປົ້າ ໝາຍ ສຸດທ້າຍ ສະອາດ . ມັນເປັນພຽງການກະ ທຳ ແທນທີ່ຈະເປັນເອກະສານເປົ້າ ໝາຍ.

ເນື່ອງຈາກວ່າປົກກະຕິແລ້ວພວກເຮົາບໍ່ຕ້ອງການສິ່ງນີ້ໃນລະຫວ່າງການລວບລວມ, ມັນບໍ່ໄດ້ຖືກຂຽນໄວ້ເປັນຄວາມຕ້ອງການໃນກົດລະບຽບອື່ນໆ. ເປົ້າ ໝາຍ ທີ່ບໍ່ໄດ້ອ້າງອີງເຖິງເອກະສານແຕ່ເປັນພຽງການກະ ທຳ ທີ່ເອີ້ນວ່າເປົ້າ ໝາຍ phony. ພວກເຂົາຈະບໍ່ມີເງື່ອນໄຂໃດໆເປັນເອກະສານເປົ້າ ໝາຍ ອື່ນໆ.

ໂດຍ ທຳ ມະດາແລ້ວ ເຮັດໃຫ້ ເລີ່ມຕົ້ນດ້ວຍເປົ້າ ໝາຍ ທຳ ອິດໃນ ' ການເຮັດຜິດກົດ ໝາຍ ‘ ແລະຖືກເອີ້ນເປັນ ‘ ເປົ້າ ໝາຍ ເລີ່ມຕົ້ນ ’. ພິຈາລະນາຕົວຢ່າງຂອງພວກເຮົາ, ພວກເຮົາມີ ສຸດທ້າຍ ເປັນເປົ້າ ໝາຍ ທຳ ອິດຂອງພວກເຮົາ. ເນື່ອງຈາກຄວາມຕ້ອງການເບື້ອງຕົ້ນຂອງມັນປະກອບມີເອກະສານວັດຖຸອື່ນໆທີ່ຈະຖືກປັບປຸງກ່ອນທີ່ຈະສ້າງ ສຸດທ້າຍ . ແຕ່ລະຂໍ້ ກຳ ນົດເຫຼົ່ານີ້ແມ່ນ ດຳ ເນີນການຕາມລະບຽບຂອງຕົນເອງ.

Recompilation ເກີດຂື້ນຖ້າມີການດັດແປງເອກະສານແຫຼ່ງຫລືແຟ້ມຫົວຂໍ້ຫລືຖ້າເອກະສານວັດຖຸບໍ່ມີເລີຍ. ຫຼັງຈາກປະກອບເອກະສານວັດຖຸທີ່ ຈຳ ເປັນ, ເຮັດໃຫ້ ຕັດສິນໃຈວ່າຈະກັບຄືນ ສຸດທ້າຍ ຫຼືບໍ່. ສິ່ງນີ້ຕ້ອງເຮັດຖ້າເອກະສານ ສຸດທ້າຍ ບໍ່ມີ, ຫຼືຖ້າມີເອກະສານວັດຖຸໃດ ໜຶ່ງ ໃໝ່ ກວ່າມັນ.

ດັ່ງນັ້ນຖ້າພວກເຮົາປ່ຽນເອກະສານ inter.c , ຫຼັງຈາກນັ້ນການ ດຳ ເນີນງານ ສ້າງ ມັນຈະປະກອບເອກະສານແຫຼ່ງຂໍ້ມູນເພື່ອປັບປຸງເອກະສານວັດຖຸ inter.o ແລະ ຫຼັງຈາກນັ້ນເຊື່ອມຕໍ່ ສຸດທ້າຍ .

ໃນຕົວຢ່າງຂອງພວກເຮົາ, ພວກເຮົາຕ້ອງໄດ້ຈົດທຸກເອກະສານວັດຖຸທັງ ໝົດ ສອງຄັ້ງໃນກົດລະບຽບ ສຳ ລັບ ສຸດທ້າຍ ຕາມທີ່ສະແດງຢູ່ຂ້າງລຸ່ມ.

final: main.o end.o inter.o start.o
	gcc -o final main.o end.o inter.o start.o

ເພື່ອຫລີກລ້ຽງການຊໍ້າຊ້ອນດັ່ງກ່າວ, ພວກເຮົາສາມາດແນະ ນຳ ຕົວແປຕ່າງໆເພື່ອເກັບບັນຊີລາຍຊື່ເອກະສານວັດຖຸທີ່ ກຳ ລັງຖືກ ນຳ ໃຊ້ພາຍໃນ ແຟ້ມເອກະສານ . ໂດຍການໃຊ້ຕົວປ່ຽນແບບ OBJ ຕົວປ່ຽນແປງພວກເຮົາສາມາດຂຽນຄືນຕົວຢ່າງ ຮູບແບບ ທີ່ຄ້າຍຄືກັນກັບຮູບຂ້າງລຸ່ມນີ້.

OBJ = main.o end.o inter.o start.o
final: $(OBJ)
	gcc -o final $(OBJ)
main.o: main.c global.h
	gcc -c main.c
end.o: end.c local.h global.h
	gcc -c end.c
inter.o: inter.c global.h
	gcc -c inter.c
start.o: start.c global.h
	gcc -c start.c
clean:
	rm -f $(OBJ)

.PHONY: clean
clean:
	rm -f $(OBJ)