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

โครงการ:

ชื่อ

makepp_statements -- คำสั่งต่างๆ ใน ​​makefile

DESCRIPTION

A: โหลดอัตโนมัติ, B: build_cache,
build_ตรวจสอบ, D: "กำหนด", E: ส่งออก, G: ทั่วโลก I: ถ้าดีเฟ,
ไอเฟค,
ถ้าเมคเพิร์ล,
ถ้าเกิด,
อิฟเน็ก
ไอฟินซิส,
ถ้าจริง,
อิฟเพิร์ล,
ไอซิส
ถ้าเป็นจริง,
-รวม,
รวม,
_รวม, L: load_makefile, M: ทำ,
ช่างแต่งหน้า,
เมคซับ, N: "no_implicit_load", P: เพิร์ล
"perl_begin",
สร้างล่วงหน้า, R: register_command_parser
register_input_suffix,
register_parser,
ที่เก็บ
รันไทม์, S: ลายเซ็น,
"ย่อย", V: วีพาธ

คำสั่งคือบรรทัดใดๆ ที่ขึ้นต้นด้วยคำที่ไม่มี ":" อยู่ในนั้น (ลำไส้ใหญ่
แสดงว่าบรรทัดนั้นเป็นกฎ) ตัวอย่างเช่น นี่คือคำสั่ง:

รวม extra_rules.mk
load_makefile คำบรรยายย่อย

Makepp มีคำสั่งในตัวจำนวนหนึ่งซึ่งคุณอาจจำเป็นต้องใช้เป็นครั้งคราว

โปรดทราบว่าทุกที่ที่คุณเห็นขีดล่าง คุณอาจใช้ขีดกลางได้เช่นกัน เนื่องจาก makepp converts
ขีดกลางเพื่อขีดเส้นใต้ในชื่อคำสั่ง

เงื่อนไข
Conditionals คือคำสั่งพิเศษ ซึ่งควบคุมว่าบรรทัดใดของ Makeppfile
เห็นจริง. รูปแบบที่ง่ายที่สุด (โดยที่ "ifxxx" หมายถึงเงื่อนไขใด ๆ
ข้อความที่บันทึกไว้ด้านล่าง) คือ:

อิฟxxx ...
เส้นที่เห็นถ้าคำสั่งประเมินเป็นจริง
endif

หรือ:

อิฟxxx ...
เส้นที่เห็นถ้าคำสั่งประเมินเป็นจริง
อื่น
เส้นที่เห็นถ้าคำสั่งประเมินเป็นเท็จ
endif

มีความเป็นไปได้ที่จะทำชุดค่าผสมที่ซับซ้อนเช่นนี้:

อิฟxxx ...
และ ifxxx ...
และ ifxxx ...
หรือ ifxxx ...
และ ifxxx ...
เส้นที่เห็นถ้าคำสั่งรวมประเมินว่าเป็นจริง
ifxxx ...
หรือ ifxxx ...
และ ifxxx ...
เส้นที่เห็นถ้าชุดค่าผสมแรกประเมินว่าเป็นเท็จ
และข้อความที่รวมกันเหล่านี้ประเมินว่าเป็นจริง
อื่น
เส้นที่เห็นถ้าข้อความข้างต้นประเมินว่าเป็นเท็จ
endif

ตามที่ได้แนะนำไว้ว่า "และ" มีความสำคัญสูงกว่า "หรือ". กล่าวอีกนัยหนึ่ง
an "หรือ" เลือกระหว่างสองกลุ่มของ "และ"`s. อาจมี "และ ifxxx" จำนวนเท่าใดก็ได้
"หรือ ifxxx" และ "else ifxxx" อื่น

คำสั่งเงื่อนไข "ifxxx" นั้นไม่ซ้ำกัน โดยอาจเกิดขึ้นตรงกลางกฎ
การกระทำดังในตัวอย่างข้างต้นโดยไม่กระทบต่อกฎ

ไอเฟค สตริง1, string2
ถ้าจำเป็น สตริง1, string2
ถ้าเฟค ($(STR1),$(STR2))
makefile บรรทัดถ้าเป็นจริง
อื่น
makefile บรรทัดถ้าเป็นเท็จ
endif

หากสองสตริงตรงกันทุกประการ (ยกเว้นช่องว่างนำหน้าหรือต่อท้าย) แสดงว่า
ใช้เส้นชุดแรก มิฉะนั้นจะใช้ที่สอง ประโยคอื่นคือ
ไม่จำเป็น.

มีอีกสองรูปแบบที่ยอมรับได้สำหรับคำสั่ง "ifeq" และ "ifneq":

ifeq สตริง 1, สตริง 2
ifeq สตริง 1 สตริง 2

ซึ่งเทียบเท่า แน่นอน คุณสามารถอ้างอิงสตริงได้ตามต้องการ

"ifeq" และเพื่อน "ifneq", "ifdef", "ifndef", "ifperl", "ifmakeperl", "ifsys" และ
"iftrue" มีประโยชน์เป็นหลักเมื่อคุณต้องสร้างโปรแกรมภายใต้หลาย ๆ ตัว
เงื่อนไข. ตัวอย่างเช่น,

BUILD_TYPE := debug # "debug" หรือ "production"

ifeq ($(BUILD_TYPE) ดีบัก)
CFLAGS := -g
อื่น
CFLAGS := -O2
endif

โปรแกรม : *.o
$(CC) $(CFLAGS) $(อินพุต) -o $(เอาต์พุต) $(LIBS)
ifeq ($(BUILD_TYPE) การผลิต)
แถบ $(เอาท์พุท)
endif

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

หากนี่คือบิลด์ที่ใช้งานจริง ไฟล์ทั้งหมดจะถูกคอมไพล์ด้วยตัวเลือก "-O2" แทน
ตัวเลือก "-g" นอกจากนี้โปรแกรม "แถบ" จะทำงานบนไบนารีผลลัพธ์ (in
กรณีที่คุณเชื่อมโยงกับไลบรารีบางตัวที่คอมไพล์ในโหมดแก้ไขข้อบกพร่อง)

บางครั้งการใช้ฟังก์ชัน "$(if)" หรือฟังก์ชัน "$(perl)" อาจง่ายกว่า
แทนที่จะเป็นคำสั่ง "ifeq"

หากคุณต้องการดูว่าสัญลักษณ์ว่างเปล่าหรือไม่ คุณเพียงแค่ใส่ a
อาร์กิวเมนต์เดียวเช่นนี้:

ถ้าจำเป็น $(EXE_SUFFIX)
# จะทำอย่างไรถ้า $(EXE_SUFFIX) ไม่ว่างเปล่า
endif

ถ้า ตัวแปร ...
ifndef ตัวแปร ...
คำสั่งเหล่านี้ทำงานคล้ายกับคำสั่ง "ifeq" และ "ifneq" ยกเว้นว่า
พวกเขาทดสอบว่าตัวแปรใดถูกกำหนดหรือไม่มีค่าใด ๆ (กล่าวคือไม่มี is
กำหนดไว้) ตัวแปรถูกกำหนดหาก:

· ได้รับค่าด้วยการมอบหมายก่อนหน้านี้ใน makefile ดู
makepp_variables สำหรับรายละเอียด

· ได้รับค่าเป็นตัวแปร Perl ในบล็อก "perl_begin"

· ตัวแปรมีอยู่ในสภาพแวดล้อม

· ตัวแปรมีอยู่ในบรรทัดคำสั่ง เช่น เพื่อเรียกใช้ makefile ของคุณ คุณ
พิมพ์

makepp CFLAGS=-O2

ตัวอย่างเช่น

ifndef CFLAGS
CFLAGS := -g
endif

ในกรณีนี้ "CFLAGS" จะถูกตั้งค่าเป็น "-g" หากยังไม่ได้กำหนดไว้ สังเกตว่า
คำสั่งนี้สามารถเขียนได้ง่ายๆ โดยใช้การมอบหมาย "?=" เช่น
นี้:

CFLAGS ?= -ก

ถ้าเพิร์ล เพิร์ลโค้ด
ifmakeperl เพิร์ลโค้ด
คำสั่งเหล่านี้ทำงานคล้ายกับคำสั่ง "ifeq" และ "ifneq" ยกเว้นว่า
การทดสอบอยู่ใน Perl ตัวแปรแรกเป็นรหัส Perl ธรรมดา ในขณะที่ตัวแปรที่สอง
ก่อนส่งคำสั่งผ่านการขยายตัวแปร Make-style

รุ่น := 3.0
# VERSION เป็นตัวแปร Perl โดยอัตโนมัติด้วย:
ifperl $VERSION <= 2
CPPFLAGS := -DNEW
endif
# ราคาที่จำเป็นสำหรับ CFLAGS เนื่องจาก Perl เห็นเฉพาะค่า:
ifmakeperl $$x ของฉัน = '$(CFLAGS)'; $$x =~ /-g/
CFLAGS := -g -O2
endif

ถ้าใช่ สัญลักษณ์แทน ...
อิฟฟินซิส สัญลักษณ์แทน ...
ทดสอบว่า makepp ระบบปัจจุบันกำลังทำงานตรงกับ wildcard หรือไม่
ใด ๆ (เช่นไม่มี)

ifsys ฉัน[3-6]86
และ ifsys Linux SunOS
... # แพลตฟอร์ม Intel พร้อม Linux หรือ Solaris
อื่น ifnsys พลังสปาร์ก*
... # Nor Sparc หรือ PowerPC
endif

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

perl -MConfig -e'print "$^O @Config{qw(archname myarchname)} "'; uname -mps

ถ้าเป็นจริง การแสดงออก
ถ้าไม่จริง การแสดงออก
ทดสอบว่านิพจน์ประเมินค่าอื่นที่ไม่ใช่ศูนย์หรือสตริงว่างหรือไม่

อื่นๆ มัลติไลน์ งบ
Conditionals อาจควบคุมคำสั่ง multiline ทั้งหมด แต่ไม่สามารถอยู่ภายใน a . ได้
คำแถลง

กำหนด
{ส่งออก|ทั่วโลก|แทนที่}*กำหนด
กำหนด VARIABLE [assign-operator]
บรรทัดค่าตัวแปร 1
บรรทัดค่าตัวแปร 2
เอนเดฟ

กำหนดค่าของ $(VARIABLE) ให้เป็นเส้นตรงทั้งหมดระหว่างคำสั่ง "define" และ the
คำสั่ง "endef" ดูตัวแปรหลายบรรทัด คำหลัก "ส่งออก" และ "ทั่วโลก" อาจ
ไม่ให้พร้อมกัน

perl_begin
สิ่งนี้เหมือนกับ "perl" แต่การใช้ GNU สร้างไวยากรณ์คำสั่งสไตล์ คำสั่งนี้
แนะนำบล็อกของรหัสที่ตีความทุกคำโดย Perl มีประโยชน์
สำหรับการกำหนดฟังก์ชัน แต่คุณสามารถทำสิ่งนี้ให้กระชับยิ่งขึ้นด้วยคำสั่ง "ย่อย"
บล็อกของรหัส Perl ใน makefile ของคุณจะเป็นประโยชน์ในการดำเนินการที่ง่ายกว่า
ใน Perl มากกว่าด้วยฟังก์ชันและกฎของ makepp

ส่วนที่เหลือของบรรทัดต่อจากคำสั่ง "perl_begin" จะถูกละเว้น ข้อความทั้งหมด
จนถึงบรรทัดที่เริ่มต้นที่ระยะขอบซ้ายด้วย "perl_end" ทุกคำที่ส่งไปยัง
ล่าม Perl ต้องไม่มีช่องว่างก่อน "perl_end"

ตัวอย่างหนึ่งที่ฉันใช้สิ่งนี้คือการสร้างไดเร็กทอรีที่อาจไม่จำเป็น
มีอยู่. เป็นเรื่องปกติใน makefiles ที่จะใส่ไฟล์ .o ทั้งหมดในไดเร็กทอรีย่อย (เช่น a
ไดเรกทอรีที่มีชื่อ i386หรือ สปาร์กหรือบางอย่างขึ้นอยู่กับประเภทเครื่อง)
แต่ถ้ายังไม่มีไดเร็กทอรีล่ะ? คุณสามารถทำให้ไฟล์ .o แต่ละไฟล์ขึ้นอยู่กับไฟล์
ไดเร็กทอรีย่อย และใส่กฎในการสร้างไดเร็กทอรีย่อย แต่มันง่ายกว่ามากเพียงแค่
เพื่อทำสิ่งนี้:

OBJDIR := $(ARCH) # ที่เราใส่ไฟล์ .o
perl_begin
-d $OBJDIR หรือ mkdir $OBJDIR; # ตรวจสอบให้แน่ใจว่ามีไดเรกทอรีอยู่
perl_end

ด้วยวิธีนี้ ทุกครั้งที่รัน makefile ไดเร็กทอรีย่อยจะถูกสร้างขึ้นถ้าไม่
ไม่มีอยู่

การดำเนินการบางอย่างแสดงได้ดีกว่าในรูปของนิพจน์ทั่วไปมากกว่า makepp's
ฟังก์ชั่นข้อความ ตัวอย่างเช่น,

perl_begin
if ($ARCH =~ /^i[56]86/) { # คุณสามารถทำได้ด้วย: ifsys i[56]86
$CFLAGS = '-O6 -malign-double'; # บนเครื่อง intel > 486 มี
#เป็นโทษความเร็วที่สำคัญ
#สำหรับดับเบิ้ลที่ไม่ใช่ควอดเวิร์ด
#จัดจ้าน.
} else {
$CFLAGS = '-O6';
}
perl_end

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

ตัวแปร make ใดๆ สามารถเข้าถึงได้โดยตรงเป็น Perl scalar ในกรณีนี้เราได้ตั้งค่า
ค่าของ "CFLAGS" แตกต่างกันไปตามนิพจน์ทั่วไปที่ตรงกันบน
ธงสถาปัตยกรรม

เป็นตัวอย่างสุดท้าย ข้อมูลบางส่วนเข้าถึงได้โดยตรงจาก Perl . ได้ง่ายขึ้น
กว่าจาก makepp ตัวอย่างเช่น คุณสามารถเข้าถึงข้อมูลการกำหนดค่าทั้งหมดได้
ที่ Perl รู้เกี่ยวกับระบบของคุณ รวมถึงวิธีสร้างไลบรารีที่ใช้ร่วมกัน ฯลฯ
(พิมพ์ "perldoc Config" หากคุณต้องการดูข้อมูลการกำหนดค่า Perl มี
มีอยู่.)

perl_begin

ใช้การกำหนดค่า;

$ARCH = $Config{'archname'}; # ใช้ความรู้ของ Perl เกี่ยวกับสถาปัตยกรรม
$CC = $Config{'cc'}; # ใช้คอมไพเลอร์ C เดียวกันกับ Perl
$SHARED_OBJ_CFLAGS = $Config{'cccdlflags'};
# แฟล็กที่จำเป็นในการรวบรวมวัตถุที่จะ
# ไปที่ห้องสมุดที่ใช้ร่วมกัน
$SHARED_OBJ_LDFLAGS = $Config{'ccdlflags'} . " " . $Config{'lddlflags'};
# Linker ตั้งค่าสถานะเพื่อสร้างไลบรารีที่ใช้ร่วมกัน
$SHARED_CC_LINK = $Config{'ld'}; # คำสั่งในการผลิตไลบรารีที่ใช้ร่วมกัน

$SHARED_EXTENSION = $Config{'dlext'}; # ส่วนขยายของไลบรารีที่ใช้ร่วมกัน
perl_end

%.o: %.ค
$(CC) $(CFLAGS) $(SHARED_OBJ_CFLAGS) -c $(อินพุต) -o $(เอาต์พุต)

libmylib.$(DLEXT): *.o
$(SHARED_CC_LINK) $(อินพุต) -o $(เอาต์พุต) $(SHARED_OBJ_LDFLAGS)

สังเกตว่าเรากำหนดกลุ่มตัวแปรในบล็อก Perl อย่างไร จากนั้นเราใช้ตัวแปรเหล่านั้น
หลังจากนั้นในส่วนที่เหลือของ makefile คุณสามารถใช้พลังของ perl . ได้อย่างเต็มที่
ล่ามเพื่อตั้งค่าตัวแปรของคุณด้วยวิธีที่ซับซ้อนโดยพลการ คุณสามารถเรียกใช้เชลล์
คำสั่งจากโค้ด Perl ของคุณ เข้าถึงฐานข้อมูล หรืออะไรก็ได้ที่คุณต้องการ

Perl เพิร์ลโค้ด
ช่างแต่งหน้า เพิร์ลโค้ด
สิ่งนี้เหมือนกับ "perl_begin" แต่ใช้เครื่องหมายปีกกาแบบ Perl ตัวแปรแรกคือ
รหัส Perl ธรรมดาในขณะที่ตัวแปรที่สองส่งคำสั่งผ่าน Make- ก่อน
การขยายตัวแปรสไตล์ โปรดทราบว่าความยากลำบากในการแยกวิเคราะห์เครื่องมือจัดฟันของ Perl มีสารตะกั่ว
เป็นฮิวริสติกอย่างง่ายต่อไปนี้:

· หากพบวงเล็บปีกกาเปิดสองครั้งในบรรทัดเดียวกันหรือถัดไป ให้ปิดสองครั้ง
วงเล็บปีกกาจะยุติการบล็อก จะต้องอยู่ที่ต้นบรรทัด แต่อาจจะเป็น
นำหน้าด้วยช่องว่าง

· มิฉะนั้น หากวงเล็บปีกกาปิดอยู่ที่ส่วนท้ายสุดของบรรทัด "perl" นี่คือหนึ่ง
ซับใน

· มิฉะนั้น วงเล็บปีกกาจะต้องอยู่ต้นบรรทัดถัดไป
คือไม่มีช่องว่างชั้นนำ

สำหรับวิธีที่มีประสิทธิภาพในการเรียกสคริปต์ Perl โปรดดูที่ "เรียกใช้" ไม่เหมือนกับฟังก์ชัน "$(perl)"
ค่าส่งคืนของบล็อกนี้จะถูกละเว้น

perl { พิมพ์ "ผ่านจุดนี้ใน makefile\n" }

Perl
{
พิมพ์ "และอันนี้ด้วย\n";
}

ifdef มีเสียงดัง
เพิร์ล {{
พิมพ์ "เช่นเดียวกับอันนี้\n"
}}
endif

คุณสามารถใช้ดีบักเกอร์ Perl สำหรับโค้ดฝังตัวของคุณ โดยเรียกใช้ makepp เองใน
ดีบักเกอร์ โดยที่ ... เป็นอาร์กิวเมนต์ หากมี คุณมักจะผ่าน:

perl -d -S mpp ...

เป็นการยากที่จะตั้งค่าเบรกพอยต์ในโค้ด Perl ที่ยังไม่ได้โหลด คุณทำงานได้
โดยใส่บรรทัดนี้ลงใน Perl ที่ฝังไว้ก่อนหน้าที่คุณต้องการ
ที่จะทำลาย:

$DB::เดี่ยว = 1;

จากนั้นคุณสามารถพิมพ์ "c" ที่ข้อความแจ้งของดีบักเกอร์เพื่อดำเนินการต่อจนถึงจุดนั้น

ด้านล่าง
แต่งหน้า
คำสั่งนี้มีวิธีการกำหนดรูทีนย่อย Perl ภายใน makefile ของคุณ NS
ตัวแปรแรกเป็นรหัส Perl ธรรมดา ในขณะที่ตัวแปรที่สองส่งคำสั่งก่อน
ผ่านการขยายตัวแปร Make-style ไวยากรณ์เหมือนกับของPerl
คำสั่งย่อย ยกเว้นว่าต้นแบบไม่มีความหมาย

สำหรับความเป็นไปได้ XNUMX ประการในการใส่เหล็กจัดฟัน ดูคำอธิบายได้ที่
คำสั่ง "perl"

รูทีนย่อย Perl ถูกเรียกใช้เมื่อใดก็ตามที่เห็นคำสั่งหรือเมื่อนิพจน์เช่น
เห็น "$(ชื่อคำ)" ตัวอย่างเช่น สมมติว่าคุณต้องโหลดด้วยเหตุผลบางอย่าง
เนื้อหาของไฟล์เป็นตัวแปร make (คุณสามารถทำได้โดยพูดว่า
"$(ชื่อไฟล์ของเชลล์ cat)" แต่สามารถทำได้โดยไม่ต้องเรียกใช้เชลล์เลย)
สามารถทำได้โดยวางสิ่งต่อไปนี้ใน makefile ของคุณ:

ย่อย f_file_contents {
ของฉัน ($ file) = @_; # ตั้งชื่ออาร์กิวเมนต์
เปิด $fh, $file or die "$file: $!\n";
ท้องถิ่น $/ = undef; # ไฟล์ Slurp ในการอ่านครั้งเดียว
<$fh>;
}

ifdef NEWSUB
สร้างซับ f_VAR2
{{
$(วีเออาร์) * 2;
}}
endif

เมคอัพ f_VAR1 { $(VAR) + 1 }

ด้วยการกำหนดฟังก์ชันนี้ คุณสามารถเขียน

X = $(file_contents ชื่อไฟล์) # เทียบเท่ากับ $(&cat filename) ในตัว

และตัวแปร "$(X)" จะดึงเนื้อหาของไฟล์ที่กำหนดทุกครั้งที่ได้รับ
ขยาย. ใช้ ":=" เพื่อทำสิ่งนี้เพียงครั้งเดียว หรือใช้ ";=" เพื่อทำสิ่งนี้พร้อมกันมากที่สุด

ดู makepp_extending สำหรับรายละเอียดเพิ่มเติมและตัวอย่าง

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

ตัวอย่างเช่น ของคุณ Makeppfile อาจมีลักษณะดังนี้:

rule-to-build-files-that-otherdir/x-depends-on

more_rules.makeppfile:otherdir/x
การดำเนินการเพื่อสร้าง more_rules.makeppfile

โหลดไฟล์ more_rules.makepp อัตโนมัติ

โปรดทราบว่าเราไม่สามารถแทนที่ "autoload" ด้วย "include" ได้อย่างน่าเชื่อถือเพราะ if
สิ่งอื่นที่ไม่ใช่กฎสำหรับ more_rules.makeppfile พยายามสร้าง อื่นๆdir/x
ก่อนจากนั้น more_rules.makeppfile คงจะล้มเหลวเพราะ อื่นๆdir/x จะไม่มีอยู่จริง
แต่เนื่องจากมีความพยายามที่จะสร้างมันขึ้นมาแล้วเมื่อ Makeppfile is
โหลดโดยปริยายในนามของมัน

คำเตือน: ระวังให้มากเกี่ยวกับการทำสิ่งต่าง ๆ ใน makefile ที่โหลดอัตโนมัติที่เปลี่ยน
พฤติกรรมของกฎใน makefile อื่นของไดเร็กทอรี เนื่องจากสิ่งนี้จะทำให้
พฤติกรรมขึ้นอยู่กับว่าเป้าหมายที่สร้างไว้ก่อนหน้านี้ทำให้ makefile เป็น .หรือไม่
จะถูกโหลดอัตโนมัติ

build_cache /path/to/build/cache
[ทั่วโลก] build_cache /path/to/build/cache
ระบุพาธไปยังบิลด์แคช ดู makepp_build_cache สำหรับรายละเอียด การก่อสร้าง
แคชต้องมีอยู่แล้ว ดู "วิธีจัดการบิลด์แคช" ใน makepp_build_cache สำหรับ
วิธีทำในครั้งแรก คำสั่ง "build_cache" ใน makefile แทนที่
ตัวเลือกบรรทัดคำสั่ง "--build-cache" สำหรับกฎใน makefile แต่อาจเป็น
แทนที่โดยตัวแก้ไขกฎ ":build_cache" ต่อกฎ

คำหลัก "global" อาจนำหน้าคำสั่งนี้โดยมีผลเช่นเดียวกับคำสั่ง
ตัวเลือกบรรทัด เช่น แคชของบิวด์จะมีผลกับทุก makefile นี้ควรจะดีที่สุด
ให้ใน ไฟล์ RootMakepp เพื่อให้แน่ใจว่าจะได้เห็นแต่เนิ่นๆ

ระบุ "ไม่มี" แทนเส้นทางไปยังไดเร็กทอรี หากคุณต้องการปิดใช้งาน build cache
สำหรับกฎทั้งหมดใน makefile นี้

build_check build_check_method
[ทั่วโลก] build_check build_check_method
ระบุวิธีการตรวจสอบบิลด์เริ่มต้นสำหรับกฎทั้งหมดใน makefile นี้ ดู
makepp_build_check สำหรับรายละเอียด คำสั่ง "build_check" จะแทนที่
ตัวเลือกบรรทัดคำสั่ง "--build-check-method" สำหรับกฎทั้งหมดใน makefile แต่อาจเป็น
แทนที่โดยตัวแก้ไข ":build_check" ต่อกฎ

คำหลัก "global" อาจนำหน้าคำสั่งนี้โดยมีผลเช่นเดียวกับคำสั่ง
ตัวเลือกบรรทัด เช่น วิธีการตรวจสอบบิลด์ใช้กับทุก makefile ที่ไม่ได้
ระบุเป็นของตัวเอง ควรให้สิ่งนี้ดีที่สุดใน a ไฟล์ RootMakepp เพื่อให้แน่ใจว่ามันคือ
เห็นแต่เนิ่นๆ

ระบุ "build_check default" แทนชื่อ หากคุณต้องการกลับสู่ค่าเริ่มต้น
ด้วยคีย์เวิร์ด "global" หมายถึงเมธอด "exact_match" ไม่เช่นนั้นจะคืนค่า
makefile ปัจจุบันไม่มีวิธีการเฉพาะของตัวเอง

ส่งออก VAR ...
ส่งออก การมอบหมาย
เส้นทางการส่งออก:= $(PWD):$(PATH)

ทำเครื่องหมายตัวแปรที่กำหนดสำหรับการส่งออกไปยังกระบวนการย่อย ดูการตั้งค่าตัวแปร

ทั่วโลก VAR ...
ทั่วโลก การมอบหมาย
global MYPROJECT.INFO = ข้อมูลที่จะเห็นใน makefiles ทั้งหมด

ทำเครื่องหมายตัวแปรที่กำหนดให้เป็นโกลบอลสำหรับ makefile ทั้งหมด ดูการตั้งค่าตัวแปร

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

"รวม" ก่อนจะพิจารณาไดเร็กทอรีปัจจุบัน จากนั้นเป็นพาเรนต์ของ current
ไดเร็กทอรีจากนั้นก็พาเรนต์ ฯลฯ จะหยุดพิจารณาไดเร็กทอรีเมื่อถึง
รูทของระบบไฟล์หรือเมื่อ ID อุปกรณ์ของระบบไฟล์เปลี่ยนแปลง (หมายความว่า
จะไม่พบไฟล์ที่อยู่ในการต่อเชื่อม NFS อื่น ทั้งนี้เพื่อป้องกันปัญหากับ
ระบบไฟล์เครือข่ายหรือ automounters และเซิร์ฟเวอร์ที่ไม่ทำงาน) หากไม่พบไฟล์ของ
ชื่อที่กำหนดเมื่อหยุดการค้นหา จากนั้นจะดูใน makepp data
ไดเรกทอรี (/usr/local/share/makepp หากคุณติดตั้ง makepp ใน / usr / local) สำหรับหนึ่งใน
รวมไฟล์ที่มาพร้อมกับ makepp

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

รวม standard_definitions.mk

แทนที่จะเป็นสิ่งที่ซับซ้อนกว่านี้:

รวม ../../../standard_definitions.mk # นี่คือจำนวนที่ถูกต้องของ ..?

คุณสามารถระบุไฟล์ได้มากเท่าที่คุณต้องการ และอนุญาตให้ใช้ตัวแปรได้:

รวม file1 file2 file3 $(other_include_files)

หากคุณกำลังทำงานกับบิลด์ที่ต้องทำงานกับทั้ง GNU make และ makepp
บางครั้งก็สะดวกที่จะมี makefile ที่เหมือนกันทุกประการ แต่จะมี include ที่แตกต่างกัน
ไฟล์. ตัวอย่างเช่น makefiles ทั้งหมดของคุณอาจมีบรรทัดดังนี้:

รวม $(TOPDIR)/standard_rules.mk

และคุณต้องการ standard_rules.mk เพื่อให้แตกต่างสำหรับ GNU make และ makepp เพื่ออำนวยความสะดวก
นี้ "รวม" คำสั่ง เป็นครั้งแรก ค้นหาไฟล์ที่มีคำต่อท้าย .makepp ก่อน
ค้นหาไฟล์ที่คุณขอ ในกรณีนี้ อันดับแรกจะค้นหาไฟล์
ที่เรียกว่า standard_rules.mk.makeppและถ้ามีอยู่ก็จะโหลดแทน
standard_rules.mk. ด้วยวิธีนี้ เมื่อคุณรัน makefile ด้วย GNU make มันจะโหลด
standard_rules.mkแต่ด้วย makepp มันโหลดได้ standard_rules.mk.makepp.

เนื่องจากไฟล์ดั้งเดิมจำนวนมากวางกฎไว้เพื่อสร้างไฟล์รวมหลังไฟล์ include
คำสั่ง makepp จะเลื่อนการตัดสินใจเกี่ยวกับสิ่งที่ไม่มีอยู่หรือค้างอยู่จนจบ
ของการโหลด makefile นั่นคือ เว้นแต่จะเรียกใช้ด้วย "--rm-stale" สำหรับหลาย ๆ คน
ครั้งเมื่อสถานการณ์ดีขึ้นในขณะนั้น (เพราะกฎปรากฏ) makepp will
รีโหลด makefile ซึ่งอาจทำให้กฎดังกล่าวปรากฏขึ้นอีกครั้ง นี่มันชัดๆ
วิธีโหลด makefiles ที่ไม่มีประสิทธิภาพ ดังนั้นพยายามหลีกเลี่ยงสิ่งนั้น ที่แย่กว่านั้น ถ้า makefile ของคุณ
การโหลดมีผลข้างเคียง (เช่นต่อท้ายตัวแปรส่วนกลางหรือบรรทัดเช่น
"do_it_now := $(shell cat a >>b)" หรือเทียบเท่า makepp "&cat a -o>>b") พวกเขาจะ
เกิดขึ้นได้มากเท่าที่จำเป็นต้องโหลด makefile ดังนั้น พยายามหลีกเลี่ยงสิ่งนั้นอีกครั้ง!

_รวม ทำไฟล์
- รวม ทำไฟล์
ตัวแปรย่อยใน "รวม" คำสั่ง "_include" จะรวมไฟล์หากมีอยู่
แต่ไม่ก่อให้เกิดข้อผิดพลาดร้ายแรงหากไม่ทำ คำสั่ง "_include" ใช้เพื่อ
มีความสำคัญสำหรับการรวมการสแกนไฟล์ด้วยการสร้าง GNU แต่มีประโยชน์น้อยกว่าสำหรับ makepp

load_makefile /some/directory/somewhere/Makefile
load_makefile ผู้บังคับบัญชา
load_makefile VAR1=ค่า1 VAR2=ค่า2 ผู้บังคับบัญชา
คำสั่งนี้ทำให้ makepp cd ไปยังไดเร็กทอรีที่มี makefile และ load
กฎลงในฐานข้อมูลภายในของ makepp หากคุณระบุเพียงไดเร็กทอรีแทน
makefile, "load_makefile" จะค้นหา "Makeppfile", "makefile" หรือ "Makefile" ในนั้น
ไดเรกทอรี

ตัวแปรใดๆ ที่คุณระบุด้วยไวยากรณ์ "VAR=value" (หรือ "VAR="value1 value2"") คือ
ส่งผ่านไปยัง makefiles ที่โหลด พวกเขาแทนที่การตั้งค่าใด ๆ ใน makefile เหล่านั้นเพียง
ราวกับว่าคุณได้พิมพ์ลงในบรรทัดคำสั่ง

การใช้ "load_makefile" ต่างจากคำสั่ง

รวม dir/makefile

ในสองวิธี ก่อนอื่น "load_makefile" จะไม่ถ่ายโอนตัวแปรใด ๆ จากด้านบน-
ระดับ makefile ใน makefile รอง; แต่ละ makefile มีอยู่ในตัวของมันเอง
เนมสเปซ makefile รองไม่สามารถมีอิทธิพลต่อตัวแปรในระดับบนสุด
makefile ในทางใดทางหนึ่ง

ประการที่สอง แต่ละคำสั่ง build จะถูกแท็กด้วยไดเร็กทอรีของ makefile ที่มา
จาก. เมื่อ makepp เรียกใช้กฎจาก makefile อื่น มันก่อน cd ไปที่
ไดเร็กทอรีที่มี makefile นั้นก่อนที่จะรันคำสั่ง Makefiles ซึ่งเป็น
ที่เห็นด้วยคำสั่ง "รวม" จะถือว่าเป็นส่วนหนึ่งของ makefile that
รวมไว้ด้วย ดังนั้นกฎของพวกเขาจะไม่ถูกแท็กด้วยไดเร็กทอรีอื่น

โดยปกติคุณไม่จำเป็นต้องโหลด makefile อย่างชัดเจน เว้นแต่จะมีชื่อผิดปกติ
หรือมีเป้าหมายที่ไม่มีอยู่ในไดเร็กทอรีเดียวกันกับ makefile
เอง หรือคุณได้ปิดใช้งานการโหลด makefile โดยปริยาย โดยค่าเริ่มต้น ถ้า makepp เป็น
พยายามสร้างไฟล์และไม่มีกฎเกณฑ์ในการสร้างหรือหากเป็นการประเมิน a
ชื่อไฟล์ไวด์การ์ดในไดเร็กทอรี มันจะพยายามโหลด makefile . โดยอัตโนมัติ
จากไดเร็กทอรีนั้น ดู "เคล็ดลับสำหรับหลายไดเรกทอรี" ใน makepp_cookbook สำหรับข้อมูล
ในการสร้างที่มีหลายไดเร็กทอรี

คุณไม่สามารถใช้ "load_makefile" เพื่อโหลด makefile หลายไฟล์ที่ใช้กับไฟล์เดียวกันได้
ไดเร็กทอรี ใช้ "include" สำหรับ makefile หลายๆ ชิ้นที่ใช้กับไฟล์เดียวกัน
ไดเร็กทอรี และ "load_makefile" สำหรับ makefile ที่ใช้กับไดเร็กทอรีต่างๆ

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

no_implicit_load dir1 dir2/*

คำสั่งข้างต้นจะปิดการโหลดโดยนัยสำหรับ makefiles ใน "dir1" และ ทั้งหมด of
ของมัน ไดเรกทอรีย่อย. นอกจากนี้ยังจะเปลี่ยนการโหลด makefile โดยนัยสำหรับทุกคน
ไดเรกทอรีย่อยของ "dir2" (และไดเรกทอรีย่อยทั้งหมด) แต่ไม่ใช่สำหรับ "dir2" เอง

คุณสามารถใช้สัญลักษณ์แทนในคำสั่งได้ ไฟล์ที่ไม่ใช่ไดเรกทอรีที่ตรงกับอักขระตัวแทน
จะถูกละเลย คุณยังสามารถใช้ฟังก์ชันเพื่อระบุไดเร็กทอรีที่คุณ
ที่สนใจ เช่น

no_implicit_load $(ตัวกรอง dir1 dir2, *)

จะปิดการโหลดโดยนัยสำหรับไดเรกทอรีย่อยทั้งหมดยกเว้น ผบ. 1 และ ผบ. 2 ของพวกเขาและ
ไดเรกทอรีย่อย

สร้างล่วงหน้า เป้า
ทำ เป้า
อาร์กิวเมนต์ (ซึ่งผ่านการขยายตัวแปร Make-style) จะถูกสร้างขึ้นทันที
สิ่งนี้มีประโยชน์เมื่อรายการเป้าหมายที่ Makefile สามารถสร้างได้ขึ้นอยู่กับa
สร้างไฟล์ในไดเร็กทอรีอื่น

ปัจจุบัน การสร้างเป้าหมายจะไม่สำเร็จอย่างเงียบๆ หากมีการวนซ้ำการพึ่งพาระหว่าง
เป้าหมายที่สร้างไว้ล่วงหน้าและ Makefiles ที่ต้องโหลดเพื่อสร้างมัน แต่นั่น
ควรถือเป็นความผิดพลาด

register_command_parser command_word parser
register_parser command_word parser
เมื่อวิเคราะห์การดำเนินการของกฎโดยใช้คำศัพท์ ให้ใช้ parser สำหรับ command_wordซึ่งอาจจะเป็น
เส้นทางแบบเต็มหรือเพียงแค่ชื่อฐาน ชื่อฐานมักจะเพียงพอเพราะ lexer
พยายามทั้งสองอย่าง

การขอ parser อาจเป็นชื่อชั้นที่มีหรือไม่มีนำหน้าก็ได้
"Mpp::CommandParser::". คลาสดังกล่าวต้องมีฟังก์ชันสมาชิกที่เรียกว่า "factory"
ที่ส่งคืนวัตถุของคลาสนั้น หากชื่อคลาสมีโคลอน จะต้องเป็น
อ้างเพื่อไม่ให้บรรทัดนี้ดูเหมือนกฎ

หรือเนื่องจากคลาสนั้นมักจะยังไม่ได้โหลด ฟังก์ชันของโรงงานอาจ
อยู่ในเนมสเปซ Makefile ฟังก์ชันเหล่านี้มีคำนำหน้า "p_" ซึ่งต้อง
ไม่ให้ นี่เป็นกรณีของตัวแยกวิเคราะห์ในตัว

เอฟเฟกต์เปรียบได้กับตัวเลือกกฎ ":parser" แต่สำหรับกฎหลายคำสั่ง
นี่เป็นวิธีที่ดีกว่า

register_input_suffix command_word วิภัตติ ...
เพิ่ม "ส่วนต่อท้าย" ... ลงในรายการส่วนต่อท้ายไฟล์อินพุตที่รู้จักเมื่อมีการกระทำ
เริ่มต้นด้วย "command_word" แยกวิเคราะห์ ปกติ parser จะรับสิ่งนี้ผ่าน
Mpp::CommandParser::input_filename_regexp แต่อาจเพิกเฉยต่อสิ่งนี้ทั้งหมดแทน

ปกติ Parsers จะไม่รับอาร์กิวเมนต์ทั้งหมดที่ไม่รู้จักเป็นตัวเลือก
เพราะอาจเป็นข้อโต้แย้งของตัวเลือกที่ไม่รู้จัก (ตัวอย่างเช่น, ไอ386วี is ไม่
ไฟล์อินพุตของคำสั่ง "gcc -b i386v foo.c".) แต่จะรับเฉพาะ
อาร์กิวเมนต์ตำแหน่งที่ดูเหมือนชื่อไฟล์อินพุต

ไม่ใช่เรื่องแปลกที่จะใช้เครื่องมือมาตรฐานที่มีส่วนต่อท้ายที่ไม่เป็นมาตรฐานเฉพาะไซต์ใน
เพื่อแสดงว่าไฟล์เหล่านั้นต้องการการจัดการพิเศษ เช่น คำสั่งต่างๆ
ตัวเลือกและ/หรือขั้นตอนหลังการประมวลผล ตัวอย่างเช่น:

register_input_suffix cpp .vpp
%.v: %.vpp
cpp $< > $@

กรุ ไดเรกทอรี
กรุ destdir=srcdir
ระบุไดเร็กทอรีที่เก็บตั้งแต่หนึ่งไดเร็กทอรี ที่เก็บข้อมูลแรกที่ระบุมี
มีความสำคัญเหนือกว่าไฟล์อื่น ๆ หากไฟล์เดียวกันมีอยู่ในที่เก็บหลายแห่งและที่นั่น
ไม่มีคำสั่งสร้างสำหรับมัน ดู makepp_repositories สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับ
ที่เก็บ

หากคุณระบุเพียงไดเร็กทอรีหลัง "repository" เนื้อหาของไดเร็กทอรีจะถูกเชื่อมโยงไปยัง
ไดเรกทอรีปัจจุบัน คุณสามารถเชื่อมโยงเนื้อหาไปยังตำแหน่งใดก็ได้ในไฟล์
ระบบโดยระบุตำแหน่งก่อนเครื่องหมายเท่ากับ เช่น

ที่เก็บ subdir1/subdir2=/users/joe/joes_nifty_library

คุณควรวางคำสั่ง repository ไว้ใกล้ด้านบนสุดของ makefile ก่อน any
กฎเกณฑ์ที่อาจต้องใช้

รันไทม์ โปรแกรมห้องสมุด
จัดเก็บ "ไลบรารี" เป็นการพึ่งพารันไทม์ของ "โปรแกรม" ทั้ง "โปรแกรม" และ "ห้องสมุด"
อาจมีหลายคำ ซึ่งในกรณีนี้แต่ละคำใน "ห้องสมุด" จะถูกจัดเก็บเป็น a
การพึ่งพารันไทม์ของแต่ละคำใน "โปรแกรม" เมื่อเพิ่ม "โปรแกรม" โดยอัตโนมัติ
เป็นการพึ่งพาคำสั่งที่เรียกใช้งานได้โดยคลาสพื้นฐาน "Mpp::CommandParser"
เพิ่มการพึ่งพารันไทม์ (ถ้ามี) ด้วย เพื่อให้สิ่งนี้เกิดขึ้น
ต้องระบุ "โปรแกรม" ในกฎด้วยคอมโพเนนต์ไดเร็กทอรีและไม่มี
อักขระเมตาเชลล์ จุดประสงค์ของคำสั่งนี้คือเพื่อรวบรวมการพึ่งพา
ไลบรารีและไฟล์เรียกทำงานอื่นๆ ที่โปรแกรมมักจะโหลดโดยไม่ต้องมี
เพื่อระบุอย่างชัดเจนเป็นการขึ้นต่อกันของแต่ละกฎที่เรียกใช้ "โปรแกรม" หรือ to
สแกน "โปรแกรม" เพื่อกำหนดการอ้างอิงเหล่านั้น (ซึ่งอาจเป็นการห้าม
ยาก.)

การขึ้นต่อกันของรันไทม์จะถูกข้ามผ่านแบบวนซ้ำ ดังนั้นหาก "a" มีการพึ่งพารันไทม์บน
"b" และ "b" มีการพึ่งพารันไทม์บน "c" ดังนั้นกฎใดๆ ที่ใช้ "./a" จะมี
การพึ่งพาโดยนัยทั้ง "b" และ "c" (เว้นแต่จะใช้พิเศษ
คลาส "Mpp::CommandParser" ที่แทนที่การทำงานนี้)

โปรดทราบว่าคุณไม่จำเป็นต้องเพิ่มการพึ่งพาที่ขาดหายไปหลังจากที่คุณเพิ่มคำสั่งนี้
ไปยัง makefile เว้นแต่จะมีการสแกนกฎอีกครั้ง ใช้บรรทัดคำสั่ง "--force-rescan"
ตัวเลือกเพื่อให้แน่ใจว่าสิ่งนี้จะเกิดขึ้น

ลายเซ็น พร้อมชื่อ
[ทั่วโลก] [แทนที่] ลายเซ็น พร้อมชื่อ
ลายเซ็น md5
ลายเซ็น C
ลายเซ็น c_compilation_md5
ลายเซ็น xml
ลายเซ็น xml-space
ลายเซ็นเริ่มต้น

ตั้งค่าวิธีการลงนามสำหรับกฎทั้งหมดตามคำสั่ง "ลายเซ็น" ซึ่ง
ไม่มี parser คำสั่งเลือกวิธีการ คุณสามารถแทนที่สิ่งนี้สำหรับกฎแต่ละข้อด้วย
ตัวแก้ไขกฎ ":signature"

หากคุณเพิ่มคำหลัก "แทนที่" วิธีการนี้จะแทนที่แม้แต่ตัวเลือก
สร้างโดยตัวแยกวิเคราะห์คำสั่ง แต่ไม่ใช่ที่ระบุด้วยตัวแก้ไขกฎ ":signature"
หากคุณเพิ่มคำหลัก "สากล" ผลจะมีผลกับกฎทั้งหมดที่ยังไม่ได้อ่าน
เว้นแต่ makefile ของพวกเขาจะมีคำสั่ง "signature" ของตัวเองด้วย ซึ่งเทียบเท่ากับ
ตัวเลือกบรรทัดคำสั่ง "--signature" หากกำหนดไว้ก่อนที่จะอ่านกฎใดๆ เช่น ใน a
ไฟล์ RootMakepp เพื่อให้แน่ใจว่าจะได้เห็นแต่เนิ่นๆ ในทำนองเดียวกัน คำหลัก "global
override" สำหรับคำสั่งนี้เทียบเท่ากับบรรทัดคำสั่ง "--override-signature"
ตัวเลือก

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

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทำลายเซ็น โปรดดูที่ makepp_signatures

วีพาธ Belt hold ไดเรกทอรี ...
ดึงไฟล์ทั้งหมดที่ตรงกับรูปแบบจากไดเร็กทอรีที่กำหนด รูปแบบอาจมีที่
ไวลด์การ์ด "%" มากที่สุด XNUMX ตัว สิ่งนี้ใช้กลไกการจัดเก็บแบบโปร่งใส (ต่างจาก gmake
ซึ่งเขียนชื่อไฟล์ใหม่) แต่จะไม่เรียกซ้ำในไดเรกทอรีย่อย

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

เช่นเดียวกับข้อความทั้งหมด จะถือว่าเป็นเช่นนั้น หากมีการเยื้องน้อยกว่า
การกระทำของกฎก่อนหน้าถ้ามี

สามารถใช้สำหรับข้อความที่จะส่งออกขณะอ่าน makefile:

&echo ค่าของ $$(VAR) คือ $(VAR)

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

ifperl !-d 'รวม'
&mkdir -p รวม # สร้างก็ต่อเมื่อไม่มีอยู่
endif

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