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

โครงการ:

ชื่อ

makepp_rules -- วิธีบอกให้ makepp สร้างบางสิ่ง

DESCRIPTION

?: &,
-,
@, B: :build_cache,
:build_check, D: :จัดส่ง, E: :env, I: "ignore_error",
:รวม, L: :โอกาสสุดท้าย, M: ช่างแต่งหน้า, N: "โนเอโกะ", P: :พาร์เซอร์,
"เพิร์ล", S: :ลายเซ็น

กฎคือสิ่งที่บอกให้ makepp สร้างไฟล์หรือคลาสของไฟล์ Makepp สนับสนุน
ไวยากรณ์กฎเดียวกันกับการใช้งาน make อื่นๆ บวกกับการเพิ่มเติมบางอย่างของตัวเอง

กฎมีรูปแบบทั่วไป

target_expression : dependency_expression [ : อาร์กิวเมนต์ที่เป็นตัวเลือก]
การปฏิบัติ

รายการเป้าหมายต้องไม่มีตัวแปรอัตโนมัติ (ยกเว้น "$(foreach)") ดิ
รายการการพึ่งพาอาจมีเฉพาะตัวแปรอัตโนมัติที่อ้างอิงถึงเป้าหมาย (เช่น
"$(output)", "$(outputs)" หรือคำพ้องความหมาย) การดำเนินการอาจมีอัตโนมัติ
ตัวแปร

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

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

· บรรทัดการดำเนินการแรกต้องเยื้องมากกว่าบรรทัดที่มีเป้าหมาย

· หากเว้นบรรทัดด้วยอักขระแท็บเดียวหรือ 8 ช่องว่างขึ้นไป จะถือว่า
สายการดำเนินการ

· บรรทัดว่างหรือบรรทัดแสดงความคิดเห็นที่มีอักขระ "#" ที่ระยะขอบด้านขวาจะสิ้นสุด
เว้นแต่บรรทัดที่ไม่เว้นว่างถัดไปจะเยื้องเกิน 8 ช่องว่าง (หรือมากกว่าหนึ่ง
แท็บ)

· หากบรรทัดถูกเยื้องมากหรือมากกว่าบรรทัดการดำเนินการแรก แสดงว่าเป็น
ถือเป็นแนวปฏิบัติเพิ่มเติม

มีรายการการกระทำพิเศษสองสามรายการ:

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

ซึ่งช่วยให้เรียกใช้คำสั่งในตัว ที่ให้มากับ makefile หรือคำสั่งภายนอกได้อย่างมีประสิทธิภาพ
มีการเลือกคำนำหน้า "&" เนื่องจากเป็นตัวเรียกใช้ฟังก์ชันใน Perl และเนื่องจาก
ในตอนเริ่มต้นถือว่าผิดกฎหมายในเชลล์

$(รูท)/รวม/%.h: %.h
&ln $(อินพุต) $(เอาต์พุต)

โนเอโช
@ โดยปกติ แต่ละคำสั่งเชลล์จะถูกพิมพ์เมื่อดำเนินการ แต่ถ้าคำแรก
ของการกระทำคือ "noecho" (หรือถ้ามันขึ้นต้นด้วยอักขระ "@") แล้วคำสั่ง
ไม่ได้พิมพ์ ตัวอย่างเช่น,

%.o: %.cxx
noecho $(LIBTOOL) --mode=compile $(CC) -c $(อินพุต)

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

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

$(การกระจายปลอม):
ละเว้น rm -r my_program-$(VERSION) # กำจัดขยะก่อนหน้า
&mkdir my_program-$(VERSION)
&cp $(FILES) my_program-$(VERSION)
tar cf my_program-$(เวอร์ชัน).tar my_program-$(เวอร์ชัน)

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

Perl
ช่างแต่งหน้า
โดยพื้นฐานแล้วจะเหมือนกับคำสั่ง Perl แต่จะดำเนินการทุกครั้งที่
เรียกใช้กฎ ไม่ใช่เมื่ออ่าน makefile ตัวแปรแรกคือ Perl . ธรรมดา
รหัสในขณะที่ตัวแปรที่สองส่งคำสั่งผ่านตัวแปร Make-style ก่อน
การขยายตัว

สำหรับความเป็นไปได้สองประการในการใส่เหล็กดัดของร่างกาย ให้ดูคำอธิบายที่
"perl_perlcode" ใน makepp_statements โปรดทราบว่าตัวแปรที่สามอธิบายไว้ที่นั่น
ไม่มีเหตุผลที่นี่เพราะต้องเยื้องบรรทัดการกระทำทั้งหมด คุณต้องส่งสัญญาณ
ความล้มเหลวในคำสั่ง Perl โดยการเรียก "die"

ตามกฎแล้ว คำสั่ง Perl จะถูกประเมินในกระบวนการย่อยทั่วไป ยกเว้น on
วินโดว์. นั่นหมายความว่าพวกเขาสามารถอ่านได้เฉพาะตัวแปร makefile เท่านั้น ยังเป็น
กระบวนการที่ดำเนินการที่ไม่ใช่ Perl ดังนั้นการเรียก exec หรือ exit จะสับสน
แต่งหน้า แต่สิ่งนี้อาจเปลี่ยนแปลงได้ในอนาคต สำหรับวิธีการโทรหา Perl . อย่างมีประสิทธิภาพ
สคริปต์ ดูรายการก่อนหน้า "&" หรือ "เรียกใช้"

$(เวอร์ชั่นปลอม):
noecho perl {{ # $(target) & $(VERSION) จาก Perl:
พิมพ์ "นี่คือ ".f_target()" $VERSION\n";
}}
echo คุณสามารถผสมสิ่งนี้กับคำสั่งเชลล์
-makeperl { พิมพ์ "นี่คือ $(เป้าหมาย) $(เวอร์ชัน)\n" }

มีกฎหลายประเภท แต่ละประเภทมีวัตถุประสงค์ที่แตกต่างกัน

ชัดเจน กฎระเบียบ
target1 target2: การพึ่งพา 1 การพึ่งพา2 ...
การกระทำที่ต้องทำ

วากยสัมพันธ์นี้ระบุว่าเพื่อที่จะทำอย่างใดอย่างหนึ่ง target1 or target2, ไฟล์ทั้งหมด
การพึ่งพา1, การพึ่งพา2ฯลฯ ต้องทำมาแล้ว แล้วการกระทำที่ให้คือ
ดำเนินการโดยเชลล์เพื่อสร้างเป้าหมาย

กฎที่ชัดเจนข้อแรกในไฟล์คือเป้าหมายเริ่มต้น และสร้างขึ้นหากคุณไม่ระบุ
เป้าหมายใด ๆ บนบรรทัดคำสั่ง

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

y.tab.c y.tab.h : parser.y
$(YACC) -d parser.y

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

· การดำเนินการตามกฎกล่าวถึงตัวแปรอัตโนมัติ $@ (คำพ้องความหมาย "$(output)" หรือ
"$(target)" ไม่ทริกเกอร์การทำงานนี้)

· การดำเนินการตามกฎไม่ได้กล่าวถึงตัวแปรอัตโนมัติ "$(ผลลัพธ์)" (หรือคำพ้องความหมาย
"$(เป้าหมาย)")

· นี่ไม่ใช่กฎรูปแบบ และไม่มีส่วนคำสั่งล่วงหน้า

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

ทดสอบการติดตั้งทั้งหมด:
สำหรับ subdir ใน $(SUBDIRS); ทำ cd $$subdir && $(MAKE) $@; ซีดี ..; เสร็จแล้ว

เป็นสำนวนทั่วไปใน makefiles และ makepp รองรับ (โปรดทราบว่าคุณไม่ควรใช้
recursive make ใน makefiles ใหม่ที่คุณเขียน - ใช้คำสั่ง "load_makefile" หรือ
การโหลด makefile โดยนัยแทน)

หากคุณต้องการให้มีการดำเนินการกฎเดียวกันหนึ่งครั้งสำหรับแต่ละเป้าหมาย (เช่น เนื่องจากเป้าหมาย
มีคำสั่งที่คล้ายกัน) ควรใช้กฎรูปแบบ (ดูด้านล่าง) หรือ a
ประโยค "foreach" ตัวอย่างเช่น หากใช้โปรแกรม make แบบดั้งเดิม คุณจะเขียน:

เอบีซีดี:
do_something เพื่อสร้าง $@ > $@

ใน makepp คุณอาจต้องการเขียนดังนี้:

$(foreach) : : foreach abcd
do_something เพื่อสร้าง $(output) > $(output)

ปลอม เป้าหมาย

A ปลอม เป้า เป็นเป้าหมายที่ไม่เคยมีอยู่ในระบบไฟล์จริงๆ มันเป็นเพียง
วิธีรับ makepp เพื่อสร้างเป้าหมายและอาจรันคำสั่งเพิ่มเติมบางอย่าง

เป้าหมายปลอมทั่วไปคือ "ทั้งหมด" ซึ่งมักจะใช้เพื่อทำให้ทุกสิ่งที่สามารถทำได้
สร้างเพื่อสร้างดังนี้

ทั้งหมด: prog1 prog2 subdir/prog3 subdir2/libmine.a
@&echo "เสร็จแล้ว!"

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

เพื่อป้องกันไม่ให้ makepp คาดหวังไฟล์ ./ทั้งหมด ในการออกต้องบอกก่อนว่าเป็น
เป้าหมายปลอม เพียงใส่บรรทัดต่อไปนี้ใน makefile ของคุณ (มันไม่สร้างความแตกต่าง
ที่ไหน):

.PHONY: ทั้งหมด

ทางเลือกที่เทียบเท่ากันซึ่งบางครั้งสะดวกกว่าคือการใช้ "$(phony )"
ฟังก์ชั่นเช่นนี้:

$(ปลอมทั้งหมด): prog1 prog2 subdir/prog3 subdir2/libmine.a

เป้าหมายปลอมใน makefile หนึ่งสามารถอ้างถึงเป้าหมายปลอมใน makefile อื่น นี่คือ
มักทำด้วยเป้าหมาย "สะอาด" เช่นนี้

# makefile ระดับบนสุด:
#กติกาและของแถมมากมาย
-
$(ลอกเลียนแบบ): subdir1/clean subdir2/clean
&rm -fm my_program

จากนั้นในไดเร็กทอรีย่อย makefiles อาจอ่านดังนี้:

# Makefile ในไดเรกทอรีย่อย
-
$(ปลอมสะอาด):
&rm -fm $(สัญลักษณ์แทน *.o *.a)

แต่ทุกวันนี้ คุณจะใช้คำสั่ง "makeppclean" แทนที่จะเป็นเป้าหมายที่สะอาด

สัญลักษณ์แทน

การระบุไวด์การ์ดในรายการการขึ้นต่อกันนั้นปลอดภัย สัญลักษณ์แทนจับคู่ไม่เฉพาะไฟล์
ที่มีอยู่ แต่ไฟล์ที่สามารถสร้างได้ตามกฎใน makefile ตัวอย่างเช่น,
ในการสร้างไลบรารีจากไฟล์ .o ทั้งหมดในไดเร็กทอรี คุณสามารถเขียนสิ่งนี้:

libmine.a: *.o
&rm -f $(เอาต์พุต)
ar cr $(เอาต์พุต) $(อินพุต)

การดำเนินการนี้จะใช้ได้แม้ว่าจะยังไม่มีการสร้างไฟล์ ".o" เนื่องจาก makepp's
สัญลักษณ์แทนตรงกับไฟล์ที่ยังไม่มี แต่สามารถสร้างได้ นี้แม้จะรับ
ไฟล์ที่มีการค้นพบกฎในภายหลัง (ใน makefile เดียวกัน หรือไฟล์ที่ยังไม่ได้อ่าน) ในเรื่องนี้
จุดสุดท้ายมันแตกต่างจากฟังก์ชั่น "ตัวแทน" ซึ่ง จำกัด เฉพาะกฎที่รู้จัก
เนื่องจากจะต้องส่งคืนผลลัพธ์เมื่อมีการขยาย

Makepp รองรับสัญลักษณ์แทนเชลล์ปกติทั้งหมด ("*", "?" และ "[]") นอกจากนี้ยังมี
wildcard "**" ซึ่งตรงกับไดเร็กทอรีที่แทรกแซงจำนวนเท่าใดก็ได้ (ไอเดียนี้ถูกขโมยไป
จาก zsh.) ตัวอย่างเช่น "**/*.c" จะจับคู่ . ทั้งหมด .c ไฟล์ในแผนผังต้นทางทั้งหมด
"objects/**/*.o" ตรงกับ .o ไฟล์ที่อยู่ในไดเร็กทอรีย่อย วัตถุ
หรือไดเรกทอรีย่อยใด ๆ หรือไดเรกทอรีย่อยใด ๆ สัญลักษณ์แทน "**" จะไม่
ติดตามซอฟต์ลิงก์ไปยังไดเร็กทอรีในทุกระดับ นอกจากนี้ยังจะไม่คืนเป้าหมายปลอม

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

การยืนยันเบื้องต้นคือสิ่งนี้ปลอดภัย นี่เป็นเพราะว่ามันใช้งานได้หรือไม่
ไฟล์มีอยู่แล้วหรือจำเป็นต้องสร้างก่อน อย่างไรก็ตามในที่นี้ไม่ปลอดภัย
ว่าจะยังคงจับคู่ไฟล์ที่สร้างโดย makepp แต่ไม่มีกฎอีกต่อไป (เช่น
คุณลบ .c ไฟล์ แต่ .o ไฟล์ยังคงอยู่) เพื่อป้องกันสิ่งนี้ ให้ใช้ปุ่ม
ตัวเลือก "--rm-stale"

แบบแผน กฎระเบียบ
กฎรูปแบบคือกฎที่ใช้โดยยึดตามรูปแบบข้อความบางส่วน ใช้เพื่อ
ใช้กฎเดียวกันกับไฟล์ทั้งคลาส ไวยากรณ์เหมือนกับ GNU make's
กฎรูปแบบ:

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

นี่บอกว่าไฟล์ใดๆ ในไดเร็กทอรีปัจจุบันที่ตรงกับ "*.c" สามารถแปลงเป็น
ไฟล์ .o ที่เกี่ยวข้องโดยใช้คำสั่งที่กำหนด

โปรดทราบว่าอาจมีการจัดหาการพึ่งพารูปแบบหลายอย่าง ตัวอย่างเช่น ถ้าคุณ xyz.o ไฟล์
ขึ้นอยู่กับที่สอดคล้องกัน xyz.cpp ไฟล์และในไฟล์ชื่อ moc_xyz.cflags ที่
มีตัวเลือกคอมไพเลอร์ซึ่งสามารถแสดงด้วย:

%.o: %.cpp %.cflags
$(CXX) `cat $(ต้นกำเนิด).cflags` -c $(อินพุต) -o $(เอาต์พุต)

คุณอาจมีเป้าหมายรูปแบบหลายแบบ ตัวอย่างเช่น,

%.tab.h %.tab.c : %.y
yacc -d $(อินพุต)
&mv y.tab.h $(stem).tab.h
&mv y.tab.c $(stem).tab.c

โดยปกติ กฎของรูปแบบจะค้นหาเฉพาะไฟล์ในไดเร็กทอรีปัจจุบันเท่านั้น บังคับได้
เพื่อค้นหาในไดเร็กทอรีปัจจุบันและไดเร็กทอรีทั้งหมดที่อยู่ด้านล่างโดยการตั้งค่า

makepp_percent_subdirs := 1

ก่อนกฎรูปแบบแรกใน makefile ของคุณหรือบนบรรทัดคำสั่งเป็นต้น

มีความแตกต่างที่ชัดเจนระหว่าง "%" และสัญลักษณ์แทน "*" แม้ว่าทั้งคู่จะตรงกันทุกประการ
string: wildcard ส่งคืนรายการไฟล์ที่ใช้อย่างสมบูรณ์ ณ จุดนั้น ดังนั้น
ขึ้นอยู่กับทั้งหมด .o ไฟล์ที่สร้างได้ที่นี่:

โปรแกรม: *.o
$(LD) $(LDFLAGS) $(อินพุต) -o $(เอาต์พุต)

ไม่สามารถทำได้โดยแทนที่ "*" ด้วย "%" เพราะอันหลังมีไว้สำหรับทีละตัว
การจับคู่ของอินพุตกับเอาต์พุต ทำให้เกิดกฎภายในหนึ่งกฎสำหรับต้นกำเนิดที่ตรงกันแต่ละอัน

คงที่ Belt hold กฎระเบียบ
กฎรูปแบบคงที่คือกฎรูปแบบที่ใช้กับชุดไฟล์ที่จำกัดเท่านั้น:

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

สิ่งนี้บอกว่ากฎรูปแบบใช้กับไฟล์ใน "$(SPECIAL_MODULES).o" เท่านั้น

นี่เป็นส่วนใหญ่สำหรับความเข้ากันได้กับ GNU make; กฎ foreach (ดูด้านล่าง) มีมากกว่า
วิธีที่มีประสิทธิภาพในการทำสิ่งเดียวกัน

แต่ละ กฎระเบียบ
ไวยากรณ์กฎรูปแบบด้านบนมีประสิทธิภาพเพียงพอที่จะรองรับบิลด์เกือบทั้งหมด แต่
บางครั้งจำเป็นต้องทำอะไรที่ซับซ้อนกว่านี้ Makepp ให้ more
ไวยากรณ์ที่มีประสิทธิภาพ: ส่วนคำสั่ง ":foreach" สำหรับกฎ

target_expression : dependency_expression : สำหรับแต่ละรายการไฟล์
การปฏิบัติ

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

# นี่คือกฎที่ใช้กับทุกสิ่ง:
%.o : %.ค
$(CC) $(CFLAGS) -c $(อินพุต) -o $(เอาต์พุต)

%.o : %.c : สำหรับแต่ละ $(SPECIAL_MODULES)
$(CC) $(SPECIAL_CFLAGS) -c $(อินพุต) -o $(เอาต์พุต)

การใช้กฎ foreach ที่ทรงพลังยิ่งกว่านั้นใช้ประโยชน์จากข้อเท็จจริงที่ว่าตัวแปร
"$(foreach)" ถูกกำหนดให้แต่ละไฟล์ตรงกับรายการไฟล์และเป้าหมายและ
มีการประเมินนิพจน์การพึ่งพา รายการไฟล์อาจมีอักขระตัวแทน และไฟล์เหล่านี้
จับคู่ไฟล์ที่ยังไม่มี แต่สามารถสร้างได้ (ดู "สัญลักษณ์แทน" ใน
makepp_rules)

นี่เป็นไวยากรณ์ที่เทอะทะ แต่มีความยืดหยุ่นสูง เนื่องจากตัวแปร "$(foreach)"
อาจปรากฏในลักษณะใดก็ได้ในนิพจน์ ประการแรก โปรดทราบว่ากฎของรูปแบบเป็นจริง a
กรณีพิเศษของกฎ foreach; กฎรูปแบบ

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

เทียบเท่ากับ:

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

(อันที่จริง มันถูกแปลงเป็นค่าประมาณนั้นภายใน)

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

# กฎสำหรับไฟล์ .c ธรรมดา:
%.o : %.ค
$(CC) $(CFLAGS) -c $(อินพุต) -o $(เอาต์พุต)

# กฎในการสร้างไฟล์ .c จากไฟล์ .k:
%.ค : %.เค
$(ตัวประมวลผลล่วงหน้า) $(อินพุต) > $(เอาต์พุต)

# กฎการสร้างพิเศษสำหรับไฟล์ .c ซึ่งสร้างจากไฟล์ .k:
$(foreach:%.k=%.o) : $(foreach:%.c=%.k) : foreach *.k
$(CC) $(SPECIAL_CFLAGS) -c $(อินพุต) -o $(เอาต์พุต)

(สิ่งนี้ใช้ไวยากรณ์อ้างอิงการแทนที่ที่กระชับกว่าเล็กน้อยมากกว่าการเรียก
"patsubst" อย่างชัดเจน)

โปรดทราบว่าหากคุณต้องการเปลี่ยนค่าของตัวแปร ("CFLAGS" ในนี้ .)
กรณี) บางครั้งก็สะดวกกว่าที่จะใช้ตัวแปรเฉพาะเป้าหมาย

มรดก วิภัตติ กฎระเบียบ
สำหรับความเข้ากันได้แบบย้อนหลัง makepp รองรับกฎส่วนต่อท้ายแบบเก่า

.suffix1.suffix2:
การปฏิบัติ

เทียบเท่ากับ

%.คำต่อท้าย2: %.คำต่อท้าย1
การปฏิบัติ

แต่จำยากกว่ามาก (คำต่อท้ายใดมาก่อน) โดยปกติกฎจะปรากฏขึ้น
ใน makefile ดั้งเดิมเช่นนี้:

.co:
$(CC) $(CFLAGS) -c $*.c -o $*.o

ซึ่งเทียบเท่ากับ

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

ขัดแย้ง กฎระเบียบ
เมื่อมีมากกว่าหนึ่งวิธีในการสร้างไฟล์ makepp จะใช้ขั้นตอนง่าย ๆ เพื่อ
กำหนดกฎที่จะใช้

· เป็นข้อผิดพลาดที่จะมีกฎเกณฑ์ที่ชัดเจนที่ขัดแย้งกันสำหรับการสร้างไฟล์

· กฎรูปแบบและกฎ foreach ที่มีสัญลักษณ์แทนจะไม่แทนที่กฎที่ชัดเจน ดังนั้น
กฎที่ชัดเจนสามารถใช้เพื่อระบุข้อยกเว้นสำหรับกฎรูปแบบ (โปรดทราบว่าเพียง
การใช้ประโยค ":foreach" ไม่ได้สร้างกฎรูปแบบ มันต้องมี
wildcard (เช่น "*" หรือ "?") ซึ่งเป็นส่วนหนึ่งของชื่อไฟล์ในส่วน ":foreach" ถ้ามันเป็น
เพียงรายการไฟล์ที่ชัดเจน จะถือว่าเป็นกฎที่ชัดเจนสำหรับแต่ละไฟล์เหล่านั้น
ไฟล์.)

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

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

%.o : %.c : ข้างหน้า **/*.c
$(CC) $(CFLAGS) -c $(อินพุต) -o $(เอาต์พุต)

และคุณสามารถมี makefile ในไดเร็กทอรีย่อยที่ระบุว่า:

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

· กฎรูปแบบที่มีการอนุมานที่สั้นกว่าเป็นที่นิยมมากกว่ารูปแบบอื่น
กฎ. ตัวอย่างเช่น หากคุณมีกฎดังต่อไปนี้ (ตามตัวอย่างจาก
เคอร์เนลลินุกซ์):

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

%.o: %.s
$(AS) $(อินพุต) -o $(เอาต์พุต)

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

หากเราจำเป็นต้องสร้าง "xyz.o" เราสามารถสร้างไฟล์ ".s" ระดับกลางได้ จากนั้นจึง
เรียกใช้ผ่านแอสเซมเบลอร์โดยใช้กฎสองข้อแรกหรือเราอาจไปที่a .โดยตรง
ไฟล์ ".o" โดยใช้กฎสุดท้าย แนะนำให้ใช้กฎข้อสุดท้ายเพราะมีน้อยกว่า
ขั้นตอนในการอนุมาน (หนึ่งแทนที่จะเป็นสอง)

· กฎรูปแบบในภายหลังใน makefile แทนที่กฎรูปแบบที่เก่ากว่า (นี่คือ
ย้อนกลับจาก GNU make.) ซึ่งหมายความว่าคุณควรใส่กฎทั่วไปเพิ่มเติมของคุณ
ก่อนหน้านี้และกฎเฉพาะของคุณในภายหลัง ตัวอย่างเช่น,

%.o: %.c # กฎการรวบรวมทั่วไป
การกระทำ

special_%.o: special_%.c # กฎพิเศษสำหรับไฟล์ที่มี a
การกระทำที่แตกต่างกัน # คำนำหน้า "special_"

กฎ ตัวเลือก
บางครั้งจำเป็นต้องจัดหาตัวเลือกเพิ่มเติมเพื่อแก้ไขวิธีที่ makepp ดำเนินการ
กฎ. ตัวเลือกเหล่านี้ถูกระบุเป็น ":optionname value" ไม่ว่าจะอยู่ในบรรทัดที่มี
การขึ้นต่อกันหรือในบรรทัดถัดไป

การจัดหาตัวเลือกแยกกันอาจทำให้คุณใช้ตัวเลือกเดียวกันได้
makefile ด้วย makepp และ make แบบดั้งเดิม ตัวอย่างเช่น,

เป้าหมาย : การพึ่งพา
: ลายเซ็น target_newer
การปฏิบัติ

จะทำงานได้ดีกับการสร้าง Unix แบบดั้งเดิมเพราะมันตีความบรรทัด ": ลายเซ็น"
เป็นคำสั่งเชลล์และคำสั่งที่ขึ้นต้นด้วยโคลอนไม่ทำอะไรเลย

:build_cache /path/to/build/cache
เป้าหมาย : การพึ่งพา
: build_cache /put/cache/files/over/there
การปฏิบัติ

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

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

:build_check build_check_method
เป้าหมาย : การพึ่งพา
: build_check target_newer
การปฏิบัติ

สิ่งนี้จะบอก makepp ว่าจะใช้อัลกอริธึมใดในการตัดสินใจว่าต้องสร้างเป้าหมายใหม่หรือไม่
ดู makepp_build_check สำหรับรายละเอียดเพิ่มเติม สิ่งนี้จะแทนที่ผลกระทบของ
คำสั่ง "build_check" หรือตัวเลือกบรรทัดคำสั่ง "--build-check-method" หากมี สำหรับ
กฎนี้

:env ตัวแปร ...
เพิ่มการพึ่งพาค่าของตัวแปรสภาพแวดล้อมที่มีชื่อ ถ้าอย่างใดอย่างหนึ่ง
แตกต่างจากรุ่นก่อนหน้า เป้าหมายจะถือว่าล้าสมัย หาก
build_check วิธีดังนั้นบอก (วิธีการตรวจสอบบิลด์ในตัวทั้งหมดยกเว้นสำหรับ
target_newer เคารพสิ่งนี้)

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

: จัดส่ง คำสั่ง ...
ใส่แต่ละการกระทำของเชลล์ (แต่ไม่ใช่การกระทำของ Perl หรือคำสั่ง Perl) ใน "sh -c '...'"
และนำหน้าด้วยคำสั่ง แต่สมมติว่าเป้าหมายไม่ขึ้นอยู่กับคำสั่ง
สิ่งนี้มีประโยชน์หากคุณต้องการส่งการดำเนินการไปยังระบบคิวงาน แต่ผลลัพธ์คือ
ถือว่าเป็นอิสระจากพารามิเตอร์การจัดคิว เช่นเดียวกับว่าการจัดคิว
ใช้ระบบเลย

:รวม file_or_pattern
กฎแตกต่างกันไปขึ้นอยู่กับคอมไพเลอร์:

%.o : %.ค
: รวม %.d : ลายเซ็น C
gcc -MD -ค ...

%.o : %.ค
: รวม %.u : ลายเซ็น C # IBM ใช้ส่วนต่อท้ายที่แตกต่างกัน
xlc -M -c ...

ย่อยขึ้นอยู่กับ { # เปลี่ยนการพูดคุยของ Microsoft ให้เป็นรูปแบบที่มีประโยชน์
s/\$/\$\$/g;
s/(หมายเหตุ: รวมทั้งไฟล์: *)?(.+?)\r?\n/$1 ? "'$2' " : "'".f_output()."': "/e;
}
%.o : %.ค
: รวม %.d : ลายเซ็น C
cl -showIncludes -c ... >$(stem).d
&sed &พึ่งพา -o +<$(ต้นกำเนิด).d

คอมไพเลอร์บางตัว (icc ของ Intel เช่นเดียวกับ gcc ด้านบนหรือ xlc ของ IBM) สามารถสร้างการพึ่งพาได้
ไฟล์ได้ทันที นั่นคือในขณะที่คอมไพล์พวกเขาเขียน makefile ที่ makepp can
รวม. ข้อดีเหนือเครื่องสแกนของ makepp คือรับประกันได้ 100%
ถูกต้องที่เราจะเข้าใกล้เท่านั้น

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

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

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

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

หากคุณสร้างในที่เก็บของคุณ makepp จะรับไฟล์การพึ่งพาจาก
ที่เก็บ 1 ที่มีหนึ่ง ซึ่งไม่เหมือนกับไฟล์อื่นๆ ที่ต้องใช้ 1st
พร้อมลายเซ็นที่คาดหวัง สิ่งนี้ดีกว่าการสร้างแคชซึ่งขาด
ลายเซ็น มันหาไฟล์ไม่เจอ

:โอกาสสุดท้าย
เปิดใช้งานกฎปลายเปิด เช่น

%.foo foo%.bar: :last_chance
&สะท้อน $@ -o $@
&cp $(ผลลัพธ์)

เนื่องจากกฎเช่นนี้สามารถสร้างเป้าหมายได้ไม่จำกัดจำนวน
เป้าหมายของกฎนี้จะไม่ตรงกับฟังก์ชัน $(wildcard) หรือกฎรูปแบบ เว้นแต่
อย่างอื่นได้ยกตัวอย่างกฎแล้วโดยอ้างอิงเป้าหมายโดยเฉพาะ
นอกจากนี้ หากระบุ "--rm-stale" เป้าหมายจะเหลือจากค่าก่อนหน้า
makepp run จะดูเก่าถ้าวิธีเดียวที่จะสร้างมันผ่านกฎ last_chance
ที่ยังไม่ได้อินสแตนซ์สำหรับเป้าหมายซึ่งเป็นพฤติกรรมที่พึงประสงค์เพราะ
บิลด์จะล้มเหลวอย่างสม่ำเสมอมากขึ้นเมื่ออาศัยไวด์การ์ดไปยัง
จับคู่เป้าหมายจากการวิ่งครั้งก่อน

ตัวเลือก ":last_chance" มีวัตถุประสงค์เพื่อเรียกความสนใจไปที่พฤติกรรมพิเศษของ
กฎที่เกี่ยวกับการจับคู่สัญลักษณ์แทน

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

%.o: %.เอบีซี
: โปรแกรมแยกวิเคราะห์ c_compilation
การกระทำที่นี่

สิ่งนี้ทำให้ makepp ทำการแยกวิเคราะห์และสแกนแบบเดียวกันกับที่ทำกับ C/C++
คำสั่ง build แม้ว่าจะไม่รู้จักการกระทำเป็นการรวบรวม C

parser เริ่มต้นขึ้นอยู่กับคำสั่ง หากคุณไม่ได้ระบุตัวเลือก ":parser"
จากนั้นตรวจสอบคำแรกของแต่ละคำสั่ง ตัวอย่างเช่นสำหรับคอมไพล์หรือลิงค์
คำสั่ง makepp จะใช้ตัวแยกวิเคราะห์ "c_compilation" หรือถ้าคำสั่งดูเหมือน
ตัวแปร GNU "gcc_compilation" หากไม่พบ parser จะใช้ parser "ไม่มี" สำหรับ
รายละเอียดเพิ่มเติมเกี่ยวกับเรื่องนี้ หรือหากต้องการเขียน parser ของคุณเองหรือเปลี่ยน makepp's
ตัวแยกวิเคราะห์เริ่มต้น โปรดดูที่ makepp_scanning

โปรดทราบว่าสิ่งนี้ใช้ได้กับทุกคำสั่งในกฎ ซึ่งอาจไม่ใช่สิ่งที่คุณต้องการ:

%.o: %.c : parser c-รวบรวม
@echo 'กำลังสร้าง $ (เอาต์พุต)'
@ตลก_ซีซี ...

สิ่งนี้จะตีความ "echo" เป็นคอมไพเลอร์และอนุมานอาร์กิวเมนต์ 'Building
mymodule.o' เป็นการพึ่งพาโดยปริยาย ซึ่งจะนำไปสู่การร้องเรียนว่า
ไม่ทราบวิธีการสร้างไฟล์ดังกล่าว ในกรณีนี้คุณน่าจะดีกว่าด้วย
"register_parser" คุณจะพบคำอธิบายว่า parser สามารถให้ได้ทั้งเป็น a
classname หรือเป็นชื่อฟังก์ชัน

:ลายเซ็น Signature_method
เป้าหมาย : การพึ่งพา
: ลายเซ็น md5
การปฏิบัติ

สิ่งนี้จะบอก makepp ว่าจะใช้อัลกอริธึมใดในการพิจารณาว่าการขึ้นต่อกันมีการเปลี่ยนแปลงหรือไม่
ดู makepp_signatures สำหรับรายละเอียดเพิ่มเติม วิธีการลงลายมือชื่อที่มาพร้อมกับ
การกระจาย makepp คือ "ธรรมดา", "md5", "C" หรือ "c_compilation_md5" และ
"shared_object". สิ่งนี้จะแทนที่วิธีการลงนามใด ๆ ที่ระบุด้วย "-m" หรือ
ตัวเลือกบรรทัดคำสั่ง "--signature-method" หรือด้วยคำสั่ง "signature"

พิเศษ อักขระ
Makepp รองรับชื่อไฟล์ที่มีอักขระพิเศษ เช่น ทวิภาคหรือเว้นวรรค
สมมติว่าคุณต้องการสร้างไฟล์ชื่อ "a:thing" จากไฟล์ "b:thing"
คุณไม่สามารถเขียนกฎด้วยวิธีนี้:

a:thing : b:thing # นี่เป็นข้อผิดพลาดทางไวยากรณ์
&cat $(อินพุต) -o $(เอาต์พุต)

เพราะ makepp จะไม่ทราบว่าทวิภาคใดแยกเป้าหมายออกจากการขึ้นต่อกันและอันไหน
ส่วนหนึ่งของชื่อไฟล์ ให้ใส่ชื่อในเครื่องหมายคำพูดแทนดังนี้:

"a:thing" : "b:สิ่ง"
&cat $(อินพุต) -o $(เอาต์พุต)

ตอนนี้กฎมีความชัดเจน

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

a\:thing : 'b:thing'
&cat $(อินพุต) -o $(เอาต์พุต)

สมมุติว่าชื่อไฟล์ของคุณคือ "'"!;\$" ทีนี้ทำไมคุณถึงต้องการชื่อไฟล์แบบนั้น
ฉันไม่รู้ แต่คุณสามารถระบุให้เป็น makepp (และเชลล์ได้หลายวิธี):

\"'"!;\$$'
"'\"!;\\$$"

ให้ความสนใจว่าเมื่อ makepp ถอดเครื่องหมายคำพูดเมื่อใดและเมื่อใดที่เปลือกทำ Makepp มองไปที่
ราคาเฉพาะในกรณีต่อไปนี้:

·ในการทดสอบตระกูล "ifeq"

· ก่อนและหลังเครื่องหมายทวิภาค

·ในคำสั่ง makepp ในตัว

· ในฟังก์ชั่นที่เกี่ยวข้องกับไฟล์

ไม่เหมือนกับเชลล์ตรงที่ makepp ไม่ขยายเครื่องหมายคำพูดขณะกำหนดให้กับตัวแปร ดังนั้น
กฎต่อไปนี้เหมือนกัน:

FILE = 'ชื่อที่มีช่องว่าง'
x := $(print $(FILE)) # เพื่อตรวจสอบว่ายังมีเครื่องหมายคำพูดอยู่
$(FILE): # เครื่องหมายคำพูดรอบไฟล์เดียวที่ถอดโดย makepp
&echo สวัสดี -o$(FILE) # เครื่องหมายคำพูดรอบไฟล์เดียวที่ถอดโดย makepp
เสียงสะท้อนที่นั่น >>$(FILE) # เครื่องหมายคำพูดรอบ ๆ ไฟล์เดียวที่ Shell . ถอดออก
'ชื่อที่มีช่องว่าง':
&echo สวัสดี -o'name พร้อมเว้นวรรค'
echo นั่น >>'$(output)' # เครื่องหมายคำพูดถูกถอดด้านบน เพิ่มอีกครั้ง

โปรดทราบว่าตัวแปร (ไม่เหมือนกับเชลล์) ที่ขึ้นต้นด้วย "$" จะถูกขยายแม้จะอยู่ใน single
คำพูด สัญญาณดอลลาร์ไม่สามารถป้องกันด้วยเครื่องหมายคำพูดหรือแบ็กสแลช เพื่อให้ได้ตัวอักษร
เครื่องหมายดอลลาร์ ใช้เครื่องหมายดอลลาร์คู่ เช่น

$(ปลอมทั้งหมด):
@&echo นี่คือเครื่องหมายดอลลาร์: $$
@ สำหรับวาลใน abcd; ทำ echo $$val; เสร็จแล้ว

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

เมื่อใส่ชื่อเป้าหมายหรือการอ้างอิงลงในตัวแปรอัตโนมัติเช่น "$(output)" แล้ว
เครื่องหมายคำพูดและแบ็กสแลชจะถูกถอดออก ซึ่งหมายความว่าหากคุณต้องการอ้างอิงถึง
filename ในการดำเนินการ คุณอาจจะต้องอ้างอิงอีกครั้งดังนี้:

"ชื่อไฟล์ที่มีช่องว่าง":
echo "เนื้อหาพิเศษ" > "$@"

หากคุณไม่ใส่เครื่องหมายคำพูดรอบ $@ เชลล์จะเห็นคำสั่ง

echo "เนื้อหาพิเศษ" > ชื่อไฟล์ที่มีช่องว่าง

ซึ่งเขียนสตริง "ชื่อไฟล์เนื้อหาพิเศษที่มีช่องว่าง" ลงในไฟล์ชื่อ a.
นี่อาจไม่ใช่สิ่งที่คุณต้องการ

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