makepp - ออนไลน์ในคลาวด์

โครงการ:

ชื่อ

makepp -- เข้ากันได้แต่ได้รับการปรับปรุงสำหรับ make

เรื่องย่อ

แต่งหน้า [ -e ] [ -ค dir ] [ -NS ทำไฟล์] [ -NS makefile_or_dir ]
[ -NS n] [ -k ] [ -ม วิธี ] [ --noremake-makefiles ]
[ --ตอนนี้ ] [ -q ] [ -R dir] [ --ดั้งเดิม-เรียกซ้ำ-ทำ ]
[ -v ] [ --รุ่น ] [ VAR=ค่า - เป้า -

เอ็มพีพี [-ตัวเลือก] [ VAR=ค่า - เป้า -

DESCRIPTION

Makepp โปรแกรมบิลด์ที่มีคุณสมบัติหลายอย่างที่ช่วยให้บิลด์เชื่อถือได้และ
ไฟล์บิลด์ที่ง่ายกว่า เป็นการแทนที่แบบดรอปอินสำหรับ GNU make รองรับเกือบทั้งหมดของ
ไวยากรณ์ที่ GNU รองรับและสามารถใช้กับ makefiles ที่สร้างโดยยูทิลิตี้เช่น
เป็นออโต้เมค เรียกว่า มาเปป (หรือ ทำ++) เพราะได้รับการออกแบบด้วยการสนับสนุนพิเศษ
สำหรับ C++ ซึ่งได้ขยายไปยังภาษาอื่นๆ เช่น Swig หรือ SQL แบบฝัง อีกด้วย
ความสัมพันธ์กับ ทำ คล้ายกับความสัมพันธ์ของ C++ กับ C: เกือบ 100%
เข้ากันได้แบบย้อนหลัง แต่เพิ่มคุณสมบัติใหม่จำนวนหนึ่งและวิธีเขียนที่ดีกว่ามาก
makefiles

Makepp ผ่านชุดทดสอบที่ครอบคลุม และถูกใช้ในโครงการใหญ่ๆ หลายโครงการ ถ้าคุณมี
ปัญหาใด ๆ กับ CVS เวอร์ชันล่าสุด ตะโกนและเราจะพยายามแก้ไขอย่างรวดเร็ว Makepp
ทำงานกับ Perl เวอร์ชันใดก็ได้ตั้งแต่ 5.8.

หน้าคู่มือต่อไปนี้มีข้อมูลเพิ่มเติมเกี่ยวกับวิธีใช้ makepp:

การกวดวิชา
วิธีเขียน makefile.js ส่วนใหญ่มีไว้สำหรับผู้ที่มีน้อยหรือไม่มี
มีประสบการณ์ในการใช้งาน make

รวบรวมบทช่วยสอน
คำสั่งการคอมไพล์ Unix ทำอะไร

หมายเหตุรีลีส
สิ่งที่เปลี่ยนไปในแต่ละรุ่น

เข้ากันไม่ได้
GNU make และ makepp ทำงานต่างกันอย่างไร

speedup
เคล็ดลับต่างๆ ในการทำให้ makepp ทำงานเร็วขึ้นมาก

ประสิทธิภาพ Perl
เคล็ดลับต่าง ๆ สำหรับการเขียนโปรแกรม Perl (ภายใน makefiles ของคุณและที่อื่น ๆ ) go
ได้เร็วขึ้น

หนังสือสอนทำอาหาร
คำตอบด่วนสำหรับ "ฉันจะ ... ได้อย่างไร" หรือ "วิธีที่ดีที่สุดในการ ... คืออะไร"

คำถามที่พบบ่อย คำตอบด่วนสำหรับคำถามที่ผู้คนสะดุด

สร้างอัลกอริทึม
วิธีที่อัลกอริธึม build ของ makepp แตกต่างไปจากวิธีการพื้นฐานจากยี่ห้อดั้งเดิม

สร้างแคช
แคชของบิลด์คือไดเร็กทอรีที่เก็บผลลัพธ์ของบิลด์ก่อนหน้าในกรณีที่เป็น
ต้องการอีกครั้งในไดเร็กทอรีเดียวกัน หรือในบิลด์ที่แยกจากกันในไดเร็กทอรีอื่น

สร้างวิธีการตรวจสอบ
makepp ตัดสินใจว่าจะสร้างเมื่อใด

คำสั่งในตัว
คำสั่งที่มีประสิทธิภาพและทรงพลังพร้อมใช้งานได้ทุกที่ที่ makepp 2.0 หรือใหม่กว่านั้น

กฎในตัว
สำหรับโปรแกรมธรรมดาๆ คุณไม่จำเป็นต้องมี makefile เลย! เหล่านี้คือสิ่งที่สร้างขึ้น
กฎเกณฑ์ที่เมคพ็อปรู้

ความเข้ากันได้
Perl makepp ทำงานที่ไหนและด้วยเวอร์ชันใด

ขยาย
วิธีเพิ่มฟังก์ชันให้กับ makepp โดยการเขียนโค้ด Perl ของคุณเอง

ฟังก์ชั่น
ฟังก์ชันสำหรับการจัดการข้อความและวัตถุประสงค์อื่นๆ

คลัง
Repositories เป็นเทคนิคที่ทำให้ทั้งการสร้างตัวแปรและการรักษาส่วนกลางง่ายขึ้น
ชุดของแหล่งที่มา

กฎระเบียบ
การระบุกฎในการสร้างไฟล์

เรียงราย
การใช้แซนด์บ็อกซ์เพื่อแบ่งพาร์ติชันบิลด์

การสแกน
makepp สแกนหาการพึ่งพาเช่นรวมไฟล์อย่างไร

ลายเซ็น
makepp ตัดสินใจอย่างไรเมื่อไฟล์มีการเปลี่ยนแปลง

งบ
คำสั่งเพิ่มเติมเพื่อควบคุม makepp

ตัวแปร
การใช้ตัวแปรเพื่อลดความซับซ้อนของกฎ

เมพพพพพพพพพพพพพพพพพพพพพพพพพพ
ไวยากรณ์บรรทัดคำสั่งของยูทิลิตี้หลัก

เมคอัพคลีน, mppc
สคริปต์การล้างข้อมูลแบบสแตนด์อโลนที่มีประสิทธิภาพเพื่อลบไฟล์ที่สร้างโดย makepp

เมคอัพกราฟ, mppg
ยูทิลิตี้แบบสแตนด์อโลนเพื่อวิเคราะห์การพึ่งพาแบบกราฟิกและสาเหตุของa
สร้างใหม่

makeppinfo, mppi
ยูทิลิตีแบบสแตนด์อโลนเพื่อดัมพ์ข้อมูลบิวด์ที่ makepp จดจำเกี่ยวกับแต่ละรายการได้
ไฟล์

makepplog, mppl
ยูทิลิตีแบบสแตนด์อโลนเพื่อวิเคราะห์การพึ่งพาและสาเหตุของการสร้างใหม่

แต่งหน้าเล่น, mppr
ยูทิลิตี้แบบสแตนด์อโลนเพื่อทำซ้ำสิ่งที่ makepp ทำ แต่เร็วกว่ามาก

ดัชนี
คีย์เวิร์ด ฟังก์ชัน และตัวดำเนินการทั้งหมดใน makepp

คุณสมบัติ
การสแกนอัตโนมัติเพื่อรวมไฟล์
Makepp สแกนโดยอัตโนมัติเพื่อรวมไฟล์ สิ่งนี้จะขจัดความต้องการเครื่องมือเช่น
ทำให้พึ่งพา เครื่องสแกนของ Makepp ทำงานได้แม้ว่าจะยังไม่มีไฟล์ที่รวมอยู่แต่
จะต้องมีการสร้าง (สิ่งนี้เป็นจริงไม่ว่าพวกเขาจะมาจากไหนก็ตาม
ไม่เหมือนกับโปรแกรมที่ขึ้นอยู่กับตัวเลือก "-MM -MG" ของ gcc) Makepp มีระบบที่ยืดหยุ่น
สำหรับการทำเช่นนี้ซึ่งขึ้นอยู่กับการสแกนคำสั่ง build; คุณสามารถปรับให้เข้ากับ
ภาษาอื่นหรือสร้างคำสั่งโดยการเขียนรูทีนย่อย Perl

ระบบที่ดีกว่าสำหรับการสร้างแบบลำดับชั้น
Makepp มีระบบที่ดีกว่าในการจัดการบิลด์ที่เกี่ยวข้องกับหลายไดเร็กทอรีและ
makefiles หลายรายการ เทคนิคดั้งเดิมคือการเรียกตัวเอง
ซ้ำในแต่ละไดเร็กทอรี ขึ้นอยู่กับความซับซ้อนของการพึ่งพาอาศัยกัน
เป็นบางครั้งจำเป็นต้องมีการเรียกซ้ำหลายครั้ง สิ่งนี้ทำให้ makefiles มาก
ซับซ้อนหากรับประกันการสร้างที่ถูกต้อง ปัญหาที่แท้จริงคือเว้นแต่
การพึ่งพาอาศัยกันเป็นเรื่องเล็กน้อย (เช่น ไฟล์ไลบรารีเพียงไฟล์เดียว) แทบจะเป็นไปไม่ได้เลยที่จะ
แสดงการพึ่งพาเป้าหมายอย่างแม่นยำใน makefile เดียวในแง่ของเป้าหมายจาก
makefile อื่น ๆ Unix make ไม่ฉลาดพอที่จะรู้ว่าเป้าหมายในหนึ่งเดียว
makefile ขึ้นอยู่กับไฟล์ที่เป็นเป้าหมายใน makefile ระดับล่าง; มันรับไม่ได้
สร้างคำสั่งจาก makefile ระดับล่างในขณะที่พยายามสร้างเป้าหมายใน
makefile ระดับบน ดังนั้น ทางออกปกติคือการสร้างทุกอย่างที่สามารถทำได้
สร้างด้วย makefiles ระดับล่าง หวังว่าจะเพียงพอที่จะสร้างทุกอย่าง
ที่จำเป็นสำหรับ makefile ระดับบน

Makepp โหลด makefiles ที่จำเป็นทั้งหมดในครั้งเดียว ดังนั้นจึงไม่มีปัญหาในการจัดการ
สถานการณ์ที่ไฟล์จาก makefile หนึ่งขึ้นอยู่กับไฟล์ที่สร้างโดยที่แตกต่างกัน
เมคไฟล์ Makepp cd โดยอัตโนมัติไปยังไดเร็กทอรีที่มี makefile ก่อน
รันคำสั่งจาก makefile ดังนั้นแต่ละ makefile จึงสามารถเขียนได้อย่างอิสระ
โดยไม่มีความรู้เกี่ยวกับไดเร็กทอรีบิลด์ระดับบนสุด แต่ถ้าเข้าถึงรูทของคุณ
โครงสร้างต้นไม้มีความสำคัญ (เช่น เนื่องจากเป็นที่ที่ไดเร็กทอรีรวมของคุณอยู่)
คุณสามารถตั้งชื่อ makefile ในไดเร็กทอรีนั้นโดยเฉพาะ จากนั้น makepp จะให้เส้นทางแก่คุณ
ไปยังไดเร็กทอรีนั้นในตัวแปร

Makepp ยังสามารถค้นหาได้ว่า makefiles ทั้งหมดสำหรับโครงการทั้งหมดอยู่ที่ไหนโดยไม่มี
ถูกบอกว่าถ้าแต่ละ makefile อยู่ในไดเร็กทอรีเดียวกันกับไฟล์ที่มันควรจะเป็น
ผลิต. สิ่งนี้ยังสามารถทำให้ makefiles ง่ายขึ้นอย่างมาก

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับการสร้างที่มีหลายไดเร็กทอรี โปรดดู "เคล็ดลับสำหรับหลาย ๆ
ไดเรกทอรี" ใน makepp_cookbook

สัญลักษณ์ตัวแทนที่เชื่อถือได้
Makefiles สามารถใช้ไวด์การ์ดได้อย่างน่าเชื่อถือ เนื่องจากไวด์การ์ดตรงกับไฟล์ใดไฟล์หนึ่งที่
มีอยู่, or ไฟล์ที่ยังไม่มี แต่ makepp รู้วิธีสร้าง ดังนั้นแม้แต่สำหรับ a
โปรแกรมที่มีโมดูลหลายสิบโมดูล makefile ทั้งหมดของคุณสามารถอ่านบางอย่างเช่น
นี้:

CXX = ก.++
CXXFLAGS = -ก

%.o : %.ค
$(CXX) $(CXXFLAGS) -c $(อินพุต) -o $(เอาต์พุต)

my_program: *.o
$(CXX) $(อินพุต) -o $(เอาต์พุต)

และจะใช้งานได้แม้ว่าจะยังไม่มีการสร้างไฟล์ ".o" เลย

บิลด์ที่เชื่อถือได้: จดจำคำสั่งบิลด์
Makepp ติดตามคำสั่ง build ดังนั้นหากตัวเลือกการคอมไพล์เปลี่ยนไป files
ถูกสร้างขึ้นใหม่โดยอัตโนมัติ นี่เป็นสิ่งสำคัญในการรับประกันการสร้างที่ถูกต้อง (ความคิดนี้
ถูกนำมาจากยูทิลิตี้ "ข้อเสีย" ของ Bob Sidebothem ซึ่งอธิบายไว้ใน Perl
วารสารในปี 1998 และสามารถหาได้จาก CPAN)

เพื่อแสดงให้เห็นว่าเหตุใดสิ่งนี้จึงสำคัญ ให้พิจารณาคำนิยามโครงสร้างต่อไปนี้:

คลาสเอบีซี {
intx;
#ifndef พิเศษ_OPTION
อินท์ วาย;
#เอนดิฟ
อินท์ซี;
};

ตอนนี้ สมมติว่าคุณตัดสินใจเปิดตัวเลือก "SPECIAL_OPTION" โดยเพิ่ม
"-DSPECIAL_OPTION" ไปยังบรรทัดคำสั่ง จำเป็นต้องมีการคอมไพล์ใหม่ทุกอย่าง แต่
Unix แบบดั้งเดิมจะไม่ตรวจพบสิ่งนี้ และจะคอมไพล์ไฟล์ต้นฉบับใหม่เท่านั้น
ที่เปลี่ยนไปแล้วจริงๆ เป็นผลให้บางโมดูลของคุณจะถูกรวบรวมด้วย
-DSPECIAL_OPTION และคนอื่นจะไม่ทำ หลังจากช่วงการดีบักที่น่าผิดหวัง คุณ
จะพบว่าสิ่งที่ต้องทำคือการสร้างใหม่ทั้งหมด แล้วคุณจะ
สร้างคำสาปและหวังว่าจะเปลี่ยนไปใช้การปรับปรุงให้ดีขึ้นเช่น makepp ที่
อย่างน้อยนั่นคือสิ่งที่ฉันทำ

อีกตัวอย่างหนึ่ง สมมติว่าคุณกำลังทำงานในโครงการที่ค่อนข้างดี
ดีบั๊กจึงมักจะคอมไพล์ด้วย "-O2" ตอนนี้คุณพบข้อผิดพลาดที่คุณต้องการ
เพื่อดูในดีบักเกอร์ โค้ดที่คอมไพล์ด้วยการเพิ่มประสิทธิภาพนั้นยากต่อการตรวจสอบ
ในดีบักเกอร์ ดังนั้นคุณต้องการคอมไพล์โค้ดของคุณใหม่เพื่อให้คุณสามารถดูได้ ถ้า
makefile ของคุณถูกตั้งค่าให้เก็บตัวเลือกคอมไพเลอร์ในตัวแปรปกติ คุณสามารถ
เพียงแค่ทำสิ่งนี้:

makepp CFLAGS=-g CXXFLAGS=-g

และ makepp จะรู้ว่าบรรทัดคำสั่งมีการเปลี่ยนแปลงสำหรับโมดูลทั้งหมด แล้วเมื่อไหร่
คุณพบข้อบกพร่องของคุณแล้ว เพียงพิมพ์

แต่งหน้า

และจะถูกคอมไพล์ใหม่ด้วยการเพิ่มประสิทธิภาพ ไม่ต้องพิมพ์คำว่า make clean เมื่อ
คุณเปลี่ยนตัวเลือกการสร้าง

makefiles บางตัว (เช่น สำหรับ Linux kernel) ต้องใช้ความพยายามอย่างมาก
คอมไพล์ใหม่เมื่อคำสั่งคอมไพล์เปลี่ยนไป กับเมคพพดูแล
โดยอัตโนมัติ คุณไม่จำเป็นต้องดำเนินการใดๆ

การสร้างที่เชื่อถือได้: การจับคู่ลายเซ็นที่ถูกต้อง
โดยค่าเริ่มต้น makepp ไม่เพียงแต่ทำให้แน่ใจว่าเป้าหมายทั้งหมดใหม่กว่าทั้งหมด
การพึ่งพาอาศัยกัน; หากคุณแทนที่การพึ่งพาด้วยไฟล์ที่เก่ากว่า makepp รู้ว่ามี
เพื่อสร้างเป้าหมายใหม่ เพียงเพราะว่าไฟล์อินพุตมีการเปลี่ยนแปลง นี่ก็อีก
คุณลักษณะสำคัญในการรับประกันการสร้างที่ถูกต้องซึ่งนำมาจากยูทิลิตี้ "ข้อเสีย"

การคำนวณลายเซ็นอัจฉริยะ
การแก้ไขไฟล์ต้นฉบับบางอย่างไม่จำเป็นต้องสร้างใหม่ ตัวอย่างเช่น if
คุณเพียงแค่เปลี่ยนบรรทัดความคิดเห็น หรือหากคุณยืนยันรหัสบางอย่างอีกครั้ง จะไม่มีการระบุโดยเฉพาะ
เหตุผลที่บังคับให้มีการรวบรวม สำหรับการคอมไพล์ C/C++ makepp กำหนดว่า a
file ต้องการการคอมไพล์ใหม่โดยคำนวณการตรวจสอบการเข้ารหัสของเนื้อหาของไฟล์
ละเว้นความคิดเห็นและช่องว่าง แทนที่จะดูเวลาของไฟล์

สิ่งนี้มีประโยชน์อย่างยิ่งหากคุณมีไฟล์ที่สร้างโดยไฟล์ที่
เปลี่ยนแปลง แต่ไฟล์ที่สร้างขึ้นเองนั้นแทบไม่มีการเปลี่ยนแปลง สมมติว่าคุณ
มีไวยากรณ์ yacc ที่ซับซ้อนในโปรแกรมของคุณ โดยมีกฎการสร้างดังนี้:

y.tab.c y.tab.h: parser.y
yacc -d parser.y

โดยปกติ ทุกครั้งที่คุณทำการเปลี่ยนแปลงเล็กน้อยใน "parser.y" ทุกๆ ไฟล์ที่
ขึ้นอยู่กับ "y.tab.h" จะต้องสร้างใหม่เนื่องจากเวลาไฟล์ของ "y.tab.h" เปลี่ยนไป
อย่างไรก็ตาม การเปลี่ยนแปลงส่วนใหญ่ใน "parser.y" จะไม่เปลี่ยนเนื้อหาของ "y.tab.h"
(ยกเว้นอาจเป็นความคิดเห็น) ดังนั้นการคอมไพล์ใหม่ทั้งหมดจึงไม่จำเป็น

คลัง
Makepp สามารถรวมไฟล์จากแผนผังไดเร็กทอรีอื่นได้โดยอัตโนมัติ (the
"repository") ลงในแผนผังการสร้างปัจจุบันตามต้องการ (แนวคิดนี้นำมาจาก
โปรแกรม "ข้อเสีย") สิ่งนี้มีประโยชน์หลายประการ:

การสร้างตัวแปร
สมมติว่าคุณได้คอมไพล์โปรแกรมของคุณโดยเปิดการเพิ่มประสิทธิภาพและแก้ไขจุดบกพร่อง
ปิด. ตอนนี้มีข้อผิดพลาดเกิดขึ้นและคุณต้องคอมไพล์ทุกอย่างใหม่ด้วยการดีบัก
เปิดใช้งาน เมื่อคุณพบจุดบกพร่องแล้ว คุณจะปิดการดีบักและ
การปรับให้เหมาะสมอีกครั้ง และด้วยโปรแกรม make ส่วนใหญ่ คุณจะต้องคอมไพล์ใหม่ทั้งหมด
แหล่งที่มาอีกครั้งแม้แต่แหล่งที่ไม่เปลี่ยนแปลง ขั้นตอนจะมีลักษณะ
อย่างนี้:

% makepp CFLAGS=-O2 # รวบรวมทุกอย่าง
# อ๊ะ พบจุดบกพร่องที่นี่
% makepp CFLAGS=-g # คอมไพล์ทุกอย่างใหม่อีกครั้ง
gdb my_program
# ... หาจุดบกพร่อง
% makepp CFLAGS=-O2 # คอมไพล์ทุกอย่างใหม่เป็นครั้งที่สาม

ด้วย makepp คุณสามารถ cd ไปยังไดเร็กทอรีว่าง และระบุต้นฉบับของคุณ
ไดเร็กทอรีเป็นที่เก็บ สิ่งนี้จะสร้างไฟล์วัตถุใหม่ในช่องว่าง
ไดเร็กทอรีในขณะที่ปล่อยให้ไฟล์อ็อบเจ็กต์เก่าของคุณไม่เสียหาย ตอนนี้คุณสามารถหาข้อผิดพลาด
ในไดเร็กทอรีที่คอมไพล์ด้วยการดีบัก ให้แก้ไขในแหล่งข้อมูลดั้งเดิมของคุณ แล้วไป
กลับไปที่ไดเร็กทอรีเดิมของคุณ ตอนนี้มีเพียงไม่กี่ไฟล์ที่คุณเปลี่ยนจริง ๆ
จำเป็นต้องเรียบเรียงใหม่

ขั้นตอนทั้งหมดจะมีลักษณะดังนี้:

% makepp CFLAGS=-O2 # รวบรวมทุกอย่าง
# อ๊ะ พบจุดบกพร่องที่นี่
% mkdir การดีบัก
% การดีบักซีดี
% makepp -R .. CFLAGS=-g # คอมไพล์โดยเปิดใช้งานการดีบัก แต่
# ใส่วัตถุใน subdir การดีบัก
% gdb my_program
# ... หาจุดบกพร่อง
% cd .. # กลับสู่ไดเร็กทอรีเดิม
% makepp CFLAGS=-O2 # คอมไพล์ใหม่เฉพาะไฟล์เหล่านั้น
#ที่คุณเปลี่ยนไป

ซึ่งจะช่วยประหยัดเวลาได้อย่างมากหากมีโมดูลจำนวนมาก

ทีมพัฒนาที่มีแหล่งที่มาร่วมกัน
สมมติว่าคุณมีทีมนักพัฒนาซอฟต์แวร์ที่ทำงานเกี่ยวกับชุดแหล่งข้อมูลมาตรฐาน แต่ละ
นักพัฒนาซอฟต์แวร์กำลังทำการเปลี่ยนแปลงโดยอิสระ แต่ไม่จำเป็นต้องมีสำเนาของ
ต้นไม้ต้นทางทั้งหมด การใช้ที่เก็บของ makepp คุณสามารถให้นักพัฒนาแต่ละคนมี
คัดลอกเฉพาะไฟล์ที่เขาเปลี่ยน Makepp จะโดยอัตโนมัติและ
สร้างลิงก์สัญลักษณ์ชั่วคราวสำหรับไฟล์อื่นๆ ที่ยังไม่ได้เปลี่ยนแปลง
ไปยังไฟล์ที่เกี่ยวข้องในที่เก็บ มันสามารถทำเช่นนี้สำหรับวัตถุ
ไฟล์ที่มีอยู่ในที่เก็บและไม่จำเป็นต้องคอมไพล์ใหม่ใน
ไดเร็กทอรีส่วนบุคคลของผู้พัฒนา

รับประกันกติกาที่ถูกต้อง
หากกฎของคุณทำสิ่งที่คุณไม่ได้บอก makepp เกี่ยวกับที่เก็บข้อมูล
กลไกจะไม่รู้ว่าจะดึงสิ่งเหล่านั้น ดังนั้นสิ่งที่สร้างได้ตามปกติ
แต่ล้มเหลวจากที่เก็บจะบอกให้คุณแก้ไขกฎของคุณ

การอนุมานอัตโนมัติของไฟล์ ".o" ที่จำเป็น
Makepp มักจะสามารถอนุมานได้ว่าสิ่งของใดที่จำเป็นจริง ๆ โดยปราศจาก
บอกอย่างชัดเจน หากคุณใช้คุณสมบัตินี้ ถ้าไฟล์ต้นทางของคุณมี
"xx.h" แล้วมีไฟล์ชื่อ "xx.o" ที่ makepp รู้วิธีสร้าง แล้วก็ makepp
เพิ่ม "xx.o" ลงในบรรทัดคำสั่งลิงก์ ตอนนี้ฉันไม่ได้ใช้ห้องสมุดที่ไม่แชร์ในหลาย ๆ ที่
สถานที่ที่ฉันเคยไป เพราะ makepp สามารถเลือกโมดูลที่ฉันต้องการได้โดยอัตโนมัติ

การจัดการนามแฝงสำหรับไดเร็กทอรี
Makepp จะไม่สับสนกับซอฟต์ลิงก์ไปยังไดเร็กทอรีหรือโดยญาติต่างกัน
ชื่อไฟล์ที่อ้างถึงไฟล์เดียวกัน รู้จักเส้นทางไดเรกทอรีทั้งหมดไปยังไฟล์
รวมทั้ง foo, ./ฟู, ../src/foo, /auto_mnt/somedisk/bob/src/fooและ
/users/bob/src/foo.

ชื่อไฟล์ที่มีอักขระพิเศษ
Makepp สามารถรองรับชื่อไฟล์ที่มีโคลอนหรือช่องว่างหรืออักขระพิเศษอื่นๆ ที่
ทำให้เกิดปัญหากับการผลิตแบบดั้งเดิม เพียงล้อมรอบชื่อไฟล์ด้วยเครื่องหมายคำพูด (ดู
"อักขระพิเศษ" ใน makepp_rules เพื่อดูรายละเอียด)

ฟังก์ชันการแทนที่ข้อความแบบขยายได้
Makepp สามารถใช้รูทีนย่อย Perl ที่กำหนดเองสำหรับการแทนที่ข้อความใน makefile
หากคุณรู้จัก Perl คุณจะไม่ถูกจำกัดด้วยชุดของ buildin ของ makepp
ฟังก์ชั่นการจัดการข้อความ

คุณยังสามารถเขียนโค้ด Perl ใน makefile ของคุณได้อีกด้วย คุณสามารถจัดการ Make
ตัวแปรที่มีอำนาจเต็มของภาษา Perl ทั้งหมด ดู makepp_variables สำหรับ
รายละเอียด

การบันทึกการตัดสินใจสร้าง
โดยค่าเริ่มต้น makepp จะทำให้ล็อกไฟล์สามารถดูได้ด้วย makepplog, mppl ที่มี a
คำอธิบายของทุกไฟล์ที่พยายามสร้าง ใช้กฎอะไรในการสร้าง อะไร
มันขึ้นอยู่กับ และ (ถ้าไฟล์ถูกสร้างขึ้นใหม่) ทำไม สิ่งนี้มีประโยชน์อย่างมากสำหรับ
การดีบัก makefile - หากคุณสงสัยว่าเหตุใด makepp จึงตัดสินใจสร้างไฟล์ใหม่ หรือเพราะเหตุใด
ไม่ได้ คุณสามารถดูได้ในล็อกไฟล์ที่อธิบายการตัดสินใจ

ปรับปรุงการรองรับบิลด์คู่ขนาน
Makepp รองรับการคอมไพล์แบบขนาน แต่ (ไม่เหมือนกับการนำไปใช้งานอื่น ๆ ) มัน
จะไม่ผสมเอาท์พุตจากกระบวนการที่แยกจากกันซึ่งทำงานพร้อมกัน

คำพ้องความหมายสำหรับตัวแปรที่คลุมเครือ
Makepp รองรับคำพ้องความหมายที่ง่ายต่อการจดจำสำหรับตัวแปร make ที่เป็นความลับ $@, $^ และ
$< ดู makepp_variables สำหรับรายละเอียด

ใช้ makepp ออนไลน์โดยใช้บริการ onworks.net