ນີ້ແມ່ນຄໍາສັ່ງ makepp_build_algorithm ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍໆບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
makepp_build_algorithm -- ວິທີ makepp ປະຕິບັດ makefile
ລາຍລະອຽດ
ພາຍໃນຂອງ Makepp ແຕກຕ່າງຈາກມາດຕະຖານທີ່ Unix ເຮັດໃນລັກສະນະພື້ນຖານ. ໜ້ານີ້
ອະທິບາຍປັດຊະຍາທີ່ແຕກຕ່າງກັນໂດຍລະອຽດ.
ໄດ້ຢ່າງສິ້ນເຊີງ ທຽບ ໄປຂ້າງຫນ້າ ການສະຫຼຸບ
Makepp ເຮັດວຽກໃນທິດທາງກົງກັນຂ້າມຈາກມາດຕະຖານ Unix ເຮັດ. Unix ແບບດັ້ງເດີມເຮັດໃຫ້
ແມ່ນໃຫ້ເປົ້າຫມາຍທີ່ຈະສ້າງ, ແລະຫຼັງຈາກນັ້ນມັນຊອກຫາກົດລະບຽບທີ່ກົງກັບລັກສະນະໃນ
ຊື່ໄຟລ໌ເປົ້າຫມາຍ. ຖ້າເປົ້າຫມາຍແມ່ນເກົ່າກວ່າການຂຶ້ນກັບກົດລະບຽບໃດໆ, ຫຼັງຈາກນັ້ນມັນ
ຖືກສ້າງໃຫມ່.
ສໍາລັບຕົວຢ່າງ, ພິຈາລະນາກົດລະບຽບຮູບແບບນີ້:
%.o: %.cxx
$(CXX) $(CXXFLAGS) -c $(input) -o $(output)
ເມື່ອຮູ້ວ່າມັນຈໍາເປັນຕ້ອງເຮັດໄຟລ໌ທີ່ເອີ້ນວ່າ "xyz.o", ມັນຄົ້ນຫາຜ່ານບັນຊີລາຍຊື່ຂອງມັນ
ກົດລະບຽບຮູບແບບຈົນກ່ວາມັນເຫັນວ່າ "xyz.o" ກົງກັບຮູບແບບ "%.o", ແລະຫຼັງຈາກນັ້ນມັນໃຊ້
ກົດລະບຽບນີ້.
Makepp ເຮັດວຽກໃນທິດທາງກົງກັນຂ້າມ. ທໍາອິດມັນຄິດໄລ່ໄຟລ໌ທັງຫມົດທີ່ມັນສາມາດເປັນໄປໄດ້
ສ້າງຂຶ້ນໂດຍການໃຊ້ກົດລະບຽບທີ່ກົງກັບຕົວອັກສອນໃນຊື່ໄຟລ໌ທີ່ຂຶ້ນກັບ. ແລ້ວເມື່ອໃດ
ມັນຈໍາເປັນຕ້ອງສ້າງໄຟລ໌, ມັນພຽງແຕ່ເບິ່ງວ່າມັນເປັນໄຟລ໌ຫນຶ່ງທີ່ມັນຮູ້
ວິທີການກໍ່ສ້າງ. ບັນຊີລາຍຊື່ຂອງໄຟລ໌ທີ່ຮູ້ຈັກແມ່ນເກັບຮັກສາໄວ້ໂດຍອີງໃສ່ຊື່ໄຟລ໌ຢ່າງແທ້ຈິງ.
ເມື່ອ makepp ພົບກົດລະບຽບຮູບແບບຂ້າງເທິງ, ມັນຊອກຫາໄຟລ໌ທັງຫມົດໃນໄດເລກະທໍລີ
ກົງກັບຮູບແບບ "%.cxx" (ເຊັ່ນ, "*.cxx"). ສໍາລັບແຕ່ລະໄຟລ໌ເຫຼົ່ານີ້, ຫຼັງຈາກນັ້ນມັນຈື່
ທີ່ມັນສາມາດຜະລິດໄຟລ໌ ".o" ທີ່ສອດຄ້ອງກັນ. ຖ້າຕໍ່ມາ makepp ຄົ້ນພົບມັນ
ສາມາດສ້າງໄຟລ໌ ".cxx" ອື່ນທີ່ບໍ່ມີຢູ່ໃນປັດຈຸບັນ, ກົດລະບຽບນີ້ຈະຖືກນໍາໃຊ້ເຊັ່ນກັນ
ແລະໄຟລ໌ ".o" ທີ່ສອດຄ້ອງກັນຈະຖືກຫມາຍ.
ນີ້ອາດຈະເບິ່ງຄືວ່າບໍ່ມີປະສິດທິພາບບາງຢ່າງ, ແຕ່ມັນເບິ່ງຄືວ່າບໍ່ຊ້າໃນກໍລະນີຫຼາຍທີ່ສຸດ,
ແລະມັນມັກຈະເປັນຄວາມຈິງທີ່ວ່າ virtually ໄຟລ໌ທັງຫມົດທີ່ສາມາດໄດ້ຮັບການສ້າງຂຶ້ນແມ່ນສ້າງຂຶ້ນໃນຄວາມເປັນຈິງ.
ແລະຮູ້ບັນຊີລາຍຊື່ເຕັມຂອງໄຟລ໌ທີ່ສາມາດສ້າງໄດ້ມີຂໍ້ດີຫຼາຍ:
· Wildcards ສາມາດຈັບຄູ່ໄຟລ໌ທີ່ບໍ່ມີຢູ່ແຕ່ສາມາດສ້າງໄດ້.
· ໄຟລ ໌ ຫົວ ທີ່ ໄດ້ ຮັບ ການ ກວດ ພົບ ໂດຍ ເຄື່ອງ ສະ ແກນ ອັດ ຕະ ໂນ ມັດ ບໍ່ ມີ
ມີຢູ່; makepp ຮູ້ບ່ອນທີ່ພວກເຂົາຈະຢູ່. (ການແກ້ໄຂບັນຫານີ້ຫຼາຍທີ່ສຸດ
ສົມມຸດວ່າສ່ວນຫົວທີ່ຍັງບໍ່ທັນມີຢູ່ໃນໄດເລກະທໍລີປະຈຸບັນ.)
· Repositories ແມ່ນງ່າຍດາຍຫຼາຍທີ່ຈະປະຕິບັດນັບຕັ້ງແຕ່ makepp ຮູ້ລ່ວງຫນ້າວ່າໄຟລ໌ໃດ
ສາມາດເຮັດໃຫ້. (ເບິ່ງ makepp_repositories ສໍາລັບລາຍລະອຽດ.)
· ມັນເປັນໄປໄດ້ທີ່ຈະກໍານົດໄດ້ຢ່າງງ່າຍດາຍທີ່ໄຟລ໌ທີ່ສາມາດໄດ້ຮັບການສ້າງ (ເບິ່ງ
ຟັງຊັນ "$(only_targets)".
·ຟັງຊັນ "$(infer_objects)" ຂອງ Makepp ແມ່ນງ່າຍດາຍຫຼາຍໂດຍການຮູ້ວ່າວັດຖຸແມ່ນຫຍັງ
ທີ່ມີຢູ່.
ໄຟ ທຽບ ບົດເລື່ອງ ຮູບແບບການ
ບໍລິສັດຮ່ວມ Makepp ສ້າງຄໍາສັ່ງທີ່ມີໄຟລ໌ເປົ້າຫມາຍ, ບໍ່ແມ່ນຮູບແບບຂໍ້ຄວາມສໍາລັບ a
ຊື່ເອກະສານ. ສະນັ້ນມັນບໍ່ສັບສົນໂດຍຊື່ທີ່ແຕກຕ່າງກັນສໍາລັບໄຟລ໌ດຽວກັນ. ດັ່ງນັ້ນ, ສໍາລັບ
ຕົວຢ່າງ, makepp ຈະຮູ້ວ່າ "./xyz" ແລະ "xyz" ແມ່ນໄຟລ໌ດຽວກັນ, ໃນຂະນະທີ່ອື່ນໆເຮັດໃຫ້
ຜົນປະໂຫຍດອາດຈະບໍ່.
ນີ້ເປັນສິ່ງສໍາຄັນໂດຍສະເພາະເນື່ອງຈາກວ່າ (ບໍ່ເຫມືອນກັບມາດຕະຖານເຮັດໃຫ້) makepp ໂຫຼດ makefiles
ຈາກໄດເລກະທໍລີທີ່ແຕກຕ່າງກັນ. ໃນຄໍາສັ່ງສໍາລັບ makefiles ເປັນເອກະລາດຂ້ອນຂ້າງ, ມີ
ບໍ່ມີຕໍາແຫນ່ງພິເສດໃຫ້ກັບ makefile ລະດັບສູງສຸດ, ແຕ່ລະ makefile ຫມາຍເຖິງໄຟລ໌ທັງຫມົດ
ກ່ຽວຂ້ອງກັບໄດເລກະທໍລີຂອງຕົນເອງ. ດັ່ງນັ້ນຖ້າທ່ານໂຫລດ makefile ຈາກ subdirectory
"other_stuff", ແລະ makefile ນັ້ນຫມາຍເຖິງ "../xyz", makepp ຈະຮັບຮູ້ອີກເທື່ອຫນຶ່ງວ່າມັນແມ່ນ.
ໄຟລ໌ດຽວກັນທີ່ກ່າວເຖິງຂ້າງເທິງ. (ມັນຍັງຈະບໍ່ສັບສົນໂດຍໄດເລກະທໍລີທີ່ເຊື່ອມຕໍ່ແບບອ່ອນໆ
ຊື່.)
ເກັບໄວ້ ການກໍ່ສ້າງ ຂໍ້ມູນຂ່າວສານ
Makepp ເກັບຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບແຕ່ລະໄຟລ໌ທີ່ມັນສ້າງຂຶ້ນນອກເຫນືອຈາກວັນທີ
stamp (ຊຶ່ງແມ່ນທັງຫມົດທີ່ມາດຕະຖານເຮັດໃຫ້ເປັນຫ່ວງກ່ຽວກັບ). ຂໍ້ມູນນີ້ປະກອບມີ:
·ລາຍເຊັນຂອງໄຟລ໌ນີ້ໃນການກໍ່ສ້າງສຸດທ້າຍ, ດັ່ງນັ້ນພວກເຮົາຮູ້ວ່າໄຟລ໌ຂອງມັນເອງມີຫຼືບໍ່
ປ່ຽນແປງ.
· ຊື່ຂອງແຕ່ລະໄຟລ໌ທີ່ອີງໃສ່, ລວມທັງໄຟລ໌ແລະໄຟລ໌ອື່ນໆ inferred
ອັດຕະໂນມັດ. ຖ້າບັນຊີລາຍຊື່ນີ້ມີການປ່ຽນແປງ, ຫຼັງຈາກນັ້ນ makepp ຖືວ່າມັນຈໍາເປັນຕ້ອງສ້າງໃຫມ່.
· ລາຍເຊັນຂອງແຕ່ລະການເພິ່ງພາອາໄສ. ວິທີນີ້, makepp ຮູ້ວ່າຈະສ້າງໃຫມ່ບໍ່ພຽງແຕ່ໃນເວລາທີ່
ການເພິ່ງພາອາໄສແມ່ນໃຫມ່ກວ່າເປົ້າຫມາຍ, ແຕ່ເມື່ອພວກເຂົາປ່ຽນແປງທັງຫມົດ. ນີ້ຍັງເຮັດໃຫ້
ມັນເປັນໄປໄດ້ທີ່ຈະນໍາໃຊ້ປະເພດອື່ນໆຂອງລາຍເຊັນ, ເຊັ່ນ checksums cryptographic, ແທນທີ່ຈະ
ກ່ວາວັນທີໄຟລ໌.
·ຄໍາສັ່ງສ້າງທັງຫມົດ (ແລະ cwd ຂອງມັນ). ວິທີນີ້ຖ້າທ່ານປ່ຽນຄໍາສັ່ງກໍ່ສ້າງ
(ຕົວຢ່າງ, ປ່ຽນຕົວເລືອກ compiler), makepp ຮູ້ວ່າຈະສ້າງໃຫມ່ເຖິງແມ່ນວ່າໄຟລ໌
ເຂົາເຈົ້າບໍ່ໄດ້ປ່ຽນແປງ.
· ຖາປັດຕະຍະ. ຖ້າທ່ານໄດ້ລວບລວມໂປຼແກຼມຂອງທ່ານໃນ Linux ແລະຫຼັງຈາກນັ້ນປ່ຽນເປັນ
Solaris, makepp ອັດຕະໂນມັດຮູ້ທີ່ຈະລວບລວມທຸກສິ່ງທຸກຢ່າງ.
Makepp ສ້າງໄດເລກະທໍລີຍ່ອຍໃນທຸກໄດເລກະທໍລີທີ່ມັນສໍາຜັດເອີ້ນວ່າ ".makepp". ໄດ້
ສ້າງຂໍ້ມູນສໍາລັບໄຟລ໌ ຊື່ເອກະສານ ໃນໄດເລກະທໍລີຖືກເກັບໄວ້ໃນ .makepp/ຊື່ໄຟລ໌ທີ່ຢູ່ ຖ້າຫາກວ່າ
ທ່ານລຶບໄດເລກະທໍລີຍ່ອຍນີ້ຫຼືປ່ຽນແປງໄຟລ໌, makepp ຈະສ້າງໄຟລ໌ທີ່ຖືກກະທົບທັງຫມົດຄືນໃຫມ່.
ສົມບູນແບບ loading
ຖ້າ makepp ພະຍາຍາມສ້າງເປົ້າຫມາຍໃນໄດເລກະທໍລີແລະບໍ່ມີກົດລະບຽບສໍາລັບມັນເທື່ອ,
ຫຼືຖ້າມັນກໍາລັງຊອກຫາໄຟລ໌ທີ່ກົງກັບ wildcard ໃນໄດເລກະທໍລີ, ມັນຈະເບິ່ງຢູ່ໃນນັ້ນ
ໄດເລກະທໍລີເພື່ອເບິ່ງວ່າ makefile ມີຢູ່. ຖ້າເປັນດັ່ງນັ້ນ, makefile ຈະຖືກໂຫລດ
ອັດຕະໂນມັດ.
ນີ້ຫມາຍຄວາມວ່າປົກກະຕິແລ້ວທ່ານບໍ່ຈໍາເປັນຕ້ອງບອກ makepp ຢ່າງຊັດເຈນວ່າຈະຊອກຫາບ່ອນໃດ
makefiles--ທັງໝົດທີ່ເຈົ້າຕ້ອງເຮັດຄືການອ້າງອີງໄຟລ໌ໃນບັນຊີອື່ນ, ແລະ makepp ຈະ
ອັດຕະໂນມັດຄິດວິທີການສ້າງມັນ.
ການໂຫຼດ implicit ຈະເກີດຂຶ້ນພຽງແຕ່ຖ້າໄດເລກະທໍລີແມ່ນຂຽນໄດ້ສໍາລັບທ່ານ. ດັ່ງນັ້ນຖ້າທ່ານຕ້ອງການ
ປ້ອງກັນບໍ່ໃຫ້ makepp ພະຍາຍາມສ້າງຊໍ່ຂອງສິ່ງທີ່ບໍ່ເຄີຍປ່ຽນແປງ, ພຽງແຕ່ເຮັດໃຫ້
ໄດເລກະທໍລີອ່ານເທົ່ານັ້ນ.
ການໂຫຼດ implicit ຈະບໍ່ເກີດຂຶ້ນຖ້າຫາກວ່າທ່ານຢູ່ໃນຕົ້ນໄມ້ພາຍໃຕ້ a RootMakeppfile.mk ແລະ
makefile ອື່ນໆແມ່ນຢູ່ນອກຕົ້ນໄມ້ນັ້ນ. ຖ້າຫາກວ່າທ່ານຕ້ອງການຄັ້ງນີ້, ທ່ານສາມາດໃຫ້ໄດ້
"--do-build=/" ທາງເລືອກທີ່ຈະ makepp, ເພື່ອເຮັດໃຫ້ທຸກສິ່ງທຸກຢ່າງຢູ່ນອກຕົ້ນໄມ້ສາມາດສ້າງໄດ້. ຖ້າເຈົ້າ
ຕ້ອງການມັນສະເຫມີ, ທ່ານສາມາດໃສ່ຄໍາຖະແຫຼງ "load_makefile" ຢູ່ບ່ອນໃດຫນຶ່ງພາຍໃນຕົ້ນໄມ້
ເຊື່ອມຕໍ່ມັນກັບຕົ້ນໄມ້ຢ່າງຈະແຈ້ງ.
ຖ້າການໂຫຼດ implicit ເຂົ້າໄປໃນວິທີການຂອງທ່ານ (ie, makepp ໂຫຼດ makefiles ຫຼາຍເກີນໄປແລະມັນເສຍ
ທີ່ໃຊ້ເວລາ, ຫຼືອື່ນໆທີ່ທ່ານກໍ່ບໍ່ຕ້ອງການທີ່ຈະພະຍາຍາມທີ່ຈະສ້າງໃຫມ່ທັງຫມົດທີ່ອະທິບາຍໃນ
makefiles), ທ່ານສາມາດປິດມັນສໍາລັບໄດເລກະທໍລີທັງຫມົດໂດຍໃຊ້ຄໍາສັ່ງ "--noimplicit_load".
ທາງເລືອກແຖວ, ຫຼືທ່ານສາມາດປິດມັນສໍາລັບໄດເລກະທໍລີທີ່ເລືອກໂດຍໃຊ້ "no_implicit_load"
ຖະແຫຼງການໃນ makefile ຂອງທ່ານ.
ໃຊ້ makepp_build_algorithm ອອນລາຍໂດຍໃຊ້ບໍລິການ onworks.net
