นี่คือคำสั่ง makepp_functions ที่สามารถเรียกใช้ในผู้ให้บริการโฮสติ้งฟรีของ OnWorks โดยใช้หนึ่งในเวิร์กสเตชันออนไลน์ฟรีของเรา เช่น Ubuntu Online, Fedora Online, โปรแกรมจำลองออนไลน์ของ Windows หรือโปรแกรมจำลองออนไลน์ของ MAC OS
โครงการ:
ชื่อ
makepp_functions -- ฟังก์ชันใน makepp
DESCRIPTION
A: ชื่อไฟล์แน่นอน
Absolute_filename_nolink,
แอบสพาธ,
เพิ่มคำนำหน้า,
คำต่อท้าย
และ, B: ชื่อฐาน C: เรียก, D: ผบ.
dir_noslash, E: ข้อผิดพลาด F: ไฟล์ย่อย,
กรอง,
กรองออก,
filter_out_dirs,
ค้นหาไฟล์,
find_first_upwards,
find_โปรแกรม,
ไฟน์สตริง
find_upwards,
first_available,
คำแรก
แต่ละ, I: ถ้า,
ถ้าเป็นจริง,
infer_linker,
อนุมาน_วัตถุ,
ข้อมูล, J: เข้าร่วม M: ทำ,
แผนที่,
ช่างแต่งหน้า,
แผนที่,
"mktemp", N: นอตเดียร์ O: สร้างขึ้นเท่านั้น,
only_nontargets,
only_phony_targets,
เท่านั้น_เก่า,
only_targets,
หรือ
ต้นทาง, P: แพตซับสท์,
เพิร์ล
ปลอม,
สร้างล่วงหน้า,
พิมพ์, R: เส้นทางจริง,
ญาติ_ชื่อไฟล์,
เกี่ยวข้องกับ, S: เปลือก,
เรียงลำดับ
แถบ
ย่อย
คำต่อท้าย T: ชั่วคราว, W: คำเตือน,
ตัวแทน,
คำ,
รายการคำศัพท์
คำ, X: xargs
นิพจน์ของรูปแบบ "$(name)" โดยที่ "name" ไม่ใช่ชื่อของตัวแปรหรือ
"$(name arg1 arg2 arg3)" ถูกตีความว่าเป็นการเรียกใช้ฟังก์ชัน ชื่ออาจมีตัวอักษร
ขีดล่างหรือยัติภังค์; เพื่อหลีกเลี่ยงความสับสน คุณอาจใช้ขีดกลางหรือขีดล่าง
สลับกันได้ เนื่องจากยัติภังค์ภายในถูกแปลงเป็นขีดล่าง การประเมินดังกล่าว
นิพจน์เพียงเรียกใช้รูทีนย่อย Perl หาก "name" นำหน้าด้วย "&" จะเรียกใช้
คำสั่ง builtin หรือสคริปต์ของชื่อนั้นภายในกระบวนการ makepp และส่งคืน standard
เอาท์พุท สิ่งนี้ต้องการ Perl ที่จะสร้างสำหรับ PerlIO ถ้าชื่อไม่ได้ตั้งชื่อฟังก์ชัน
มันถูกเปลี่ยนเป็นการเรียกร้องของการโทร
เช่นเดียวกับตัวแปร คุณมีตัวเลือก "$(name ...)" หรือ "${name ...}" ถ้าคุณต้องการ
ใส่วงเล็บเดียวกัน ต้องจับคู่ วงเล็บอื่นไม่สำคัญ: "$(name
...(){..." หรือ "${name ...{}(...}". (อย่างไรก็ตาม สำหรับ map และ perl paren ปิดแรกจะสิ้นสุดลง
นิพจน์) การเสแสร้งช่วยให้อาร์กิวเมนต์ครอบคลุมหลายบรรทัด ขึ้นบรรทัดใหม่คือ
แล้วถือว่าเป็นช่องว่าง ยกเว้นใน "กำหนด" นอกจากนี้ยังมีไวยากรณ์ "$[name ...]"
หรือ $[[name ...]] ซึ่งได้รับการประเมินขณะอ่าน makefile ก่อนที่จะบ่นกฎ
และโครงสร้างอื่นๆ
Makepp มีฟังก์ชันในตัวหลายอย่างที่อาจเป็นประโยชน์ รองรับเกือบทั้งหมดของ
ฟังก์ชันข้อความของ GNU make (ดูเอกสารประกอบของ GNU สำหรับรายละเอียด) และบางส่วนของ
เป็นเจ้าของ. คุณสามารถกำหนดรูทีนย่อย Perl เพื่อทำสิ่งที่คุณต้องการ ดูคำสั่งย่อย
และส่วนการขยาย makepp สำหรับรายละเอียดเพิ่มเติม
เงื่อนไข ฟังก์ชั่น
และ เงื่อนไข1[,เงื่อนไข2[,เงื่อนไข3...]]
ฟังก์ชัน and ให้ "การลัดวงจร" AND การทำงาน อาร์กิวเมนต์แต่ละข้อคือ
ขยายออกไปตามลำดับ หากอาร์กิวเมนต์ขยายเป็นสตริงว่าง การประมวลผลจะหยุดและ
ผลลัพธ์ของการขยายคือสตริงว่าง หากอาร์กิวเมนต์ทั้งหมดขยายเป็น
สตริงว่างแล้วผลของการขยายคือการขยายตัวของอาร์กิวเมนต์สุดท้าย
if สตริง ผลลัพธ์ถ้าสตริงไม่ว่าง [, ผลลัพธ์ถ้าสตริงว่าง]
ถ้าเป็นจริง สตริง ผลลัพธ์ถ้าสตริงจริง[, ผลลัพธ์ถ้าสตริงเป็นเท็จ]
ทางเลือกแทนคำสั่ง "ifeq" เป็นต้น หากสตริงไม่ว่าง (เช่น the
เงื่อนไขเป็นจริง) อาร์กิวเมนต์ที่สอง (ส่วนคำสั่ง "แล้ว") จะถูกส่งกลับ (หลัง
การขยายตัวแปร); ถ้าสตริงว่าง อาร์กิวเมนต์ที่สาม (ส่วนคำสั่ง "อื่น") คือ
กลับ
ตัวอย่างเช่น
CFLAGS := $(if $(กรอง gcc egcc, $(CC)), -g -Wall, -g)
กำหนด CFLAGS ให้เป็น "-g -Wall" หากตัวแปร CC เป็น "gcc" หรือ "egcc" และ "-g"
มิฉะนั้น. (นี่คือสิ่งที่กฎการสร้างเริ่มต้นทำ)
"iftrue" คล้ายกับ "if" ยกเว้นว่าสตริง 0 จะถือว่าเป็นค่าว่าง
or เงื่อนไข1[,เงื่อนไข2[,เงื่อนไข3...]]
ฟังก์ชัน or ให้การทำงาน OR "ลัดวงจร" แต่ละอาร์กิวเมนต์ถูกขยาย
ตามลำดับ หากอาร์กิวเมนต์ขยายเป็นสตริงที่ไม่ว่าง การประมวลผลจะหยุดและ
ผลลัพธ์ของการขยายคือสตริงนั้น ถ้าหลังจากขยายข้อโต้แย้งทั้งหมดแล้ว . ทั้งหมด
เป็นเท็จ (ว่าง) จากนั้นผลลัพธ์ของการขยายจะเป็นสตริงว่าง
เนื้อไม่มีมัน และ ชื่อไฟล์ ฟังก์ชั่น
Absolute_filename ไฟล์
แอบสพาธ ไฟล์
แปลงชื่อไฟล์สัมพัทธ์เป็นค่าสัมบูรณ์โดยไม่ต้อง . or ... ตัวอย่างเช่น
"$(absolute_filename xyz.c)" อาจส่งคืน "/usr/src/our_project/subdir/xyz.c"
Absolute_filename_nolink ไฟล์
เส้นทางจริง ไฟล์
เช่นเดียวกับ Absolute_filename แต่รับรองว่าลิงก์สัญลักษณ์ได้รับการแก้ไขแล้ว
ชื่อฐาน ชื่อไฟล์
ชื่อฐานคือชื่อไฟล์ทั้งหมด (พร้อมไดเร็กทอรี) ลบข้อความหลัง and
รวมทั้งช่วงสุดท้าย เช่น "$(basename myfile/version-1.0-module.c)" คือ
"myfile/version-1.0-module"
dir ชื่อไฟล์
แยกส่วนไดเร็กทอรีของแต่ละไฟล์ในรายการชื่อไฟล์ รวมถึงส่วนท้าย
เฉือน ส่งกลับ "./" หากไม่มีไดเร็กทอรีในชื่อไฟล์
dir_noslash ชื่อไฟล์
เช่นเดียวกับ "$(dir )" ยกเว้นว่าจะไม่ส่งคืนเครื่องหมายทับต่อท้าย
ไฟล์ย่อย รูปแบบ ทดแทน, คำ
ดำเนินการแทนที่รูปแบบในชื่อไฟล์ สิ่งนี้แตกต่างจาก patsubst ในเรื่องนั้น
มันจะทำงานอย่างถูกต้องเมื่อให้ชื่ออื่นสำหรับไดเร็กทอรี (ตราบใดที่
อยู่ข้างหน้าเครื่องหมายเปอร์เซ็นต์) ตัวอย่างเช่น,
$(filesubst ./src/%.c, %.o, $(ไวด์การ์ด src/*.c))
จะทำงานกับ filesubst แต่ไม่ใช่กับ patsubst
filter_out_dirs ชื่อไฟล์
ส่งกลับชื่อไฟล์ทั้งหมดที่ไม่ได้อ้างถึงไดเร็กทอรี
ค้นหาไฟล์ ชื่อไฟล์, เส้นทาง
ค้นหาไฟล์ในพาธที่ระบุ หรือในตัวแปรสภาพแวดล้อม PATH หากไม่มีสิ่งใดเป็น
ระบุไว้ ซึ่งจะเป็นประโยชน์ในการค้นหาไบนารีหรือรวมไฟล์ ตัวอย่างเช่น,
TCL_INCLUDE := -I$(dir_noslash $(ค้นหาไฟล์ tcl.h, \
/usr/local/stow/tcl-8.4.5-nothread/include \
/usr/include/tcl8.4 /usr/include/tcl \
/net/na1/tcl8.4a3/include /net/na1/tcl8.4a3/include))
นี่หาตำแหน่งไฟล์ ทีซีแอล.เอช โดยการค้นหาไดเร็กทอรีข้างต้นทั้งหมด ความสัมบูรณ์
เส้นทางไปยังไฟล์จะถูกส่งกลับ จากนั้น "$(dir_noslash )" จะแตกไดเร็กทอรีนั้นและมัน
ถูกใส่เข้าไปในเส้นทางรวม
find_โปรแกรม ชื่อ
ส่งคืนโปรแกรมแรกในรายการที่สามารถพบได้ใน PATH มีประโยชน์
เมื่อมีโปรแกรมเทียบเท่าหลายโปรแกรมที่อาจใช้และคุณเพียงแค่ต้องการ
เลือกหนึ่งในนั้น ตัวอย่างเช่น นี่คือคำจำกัดความเริ่มต้นของ common . หลายตัว
ตัวแปรที่ makepp ให้มาหากคุณไม่ได้ใส่ไว้ใน makefile ของคุณ:
CC = $(find_program gcc egcc pgcc c89 cc) # และอื่นๆ ขึ้นอยู่กับเครื่อง
F77 = $(โปรแกรมค้นหา f77 g77 fort77)
CXX = $(find_program g++ c++ pg++ cxx CC aCC)
หากไม่พบโปรแกรมใด ๆ "$(find_program )" จะส่งกลับสตริงที่ไม่พบและ
บันทึกสิ่งที่ไม่พบ โดยปกติจะไม่ส่งผลให้ makefile ทำงานได้ แต่
มีแนวโน้มที่จะทำให้ข้อความแสดงข้อผิดพลาดดีขึ้น ตัวอย่างเช่น ถ้าคุณทำบางอย่างเช่น
นี้:
%.o : %.ค
$(CC) $(อินพุต) -o $(เอาต์พุต)
และ makepp ไม่พบคอมไพเลอร์ C ในรายการด้านบน มันจะแทนที่ไม่พบ
มิฉะนั้นเชลล์จะพยายามรันไฟล์ต้นฉบับและเกิดข้อผิดพลาด
ข้อความอาจจะแปลกจริงๆ
find_upwards ชื่อไฟล์
ค้นหาไฟล์ของชื่อที่ระบุในไดเร็กทอรี ., .., ..---ฯลฯ
จนกว่าจะพบไฟล์หรือถึงไดเร็กทอรีรากหรือไดเร็กทอรีอยู่
ในระบบไฟล์อื่น (ข้อกำหนดสุดท้ายนี้คือการป้องกันปัญหากับ
automounters หรือระบบไฟล์เครือข่ายที่หยุดทำงาน) หากคุณมี ไฟล์ RootMakeppนั่นก็คือ
อุปสรรคที่ขัดขวางการค้นหาที่สูงขึ้น
ตัวอย่างเช่น หากคุณมีโปรเจ็กต์ที่มีไดเร็กทอรีย่อยหลายระดับ คุณสามารถ
รวมส่วนย่อยทั่วไปนี้ใน makefiles ทั้งหมด (เช่น โดยใช้ "รวม"
คำแถลง):
TOP_LEVEL_INCLUDE_DIR := $(รวมfind_upwards)
# ค้นหาไดเรกทอรีที่มี
# รวมถึงไดเรกทอรีย่อย
%.o : %.ค
$(CC) $(CFLAGS) -I$(TOP_LEVEL_INCLUDE_DIR) -c $(อินพุต) -o $(เอาต์พุต)
ปัญหาอื่นที่ "find_upwards" สามารถช่วยแก้ไขได้คือการค้นหาไดเรกทอรีระดับบนสุด
ของงานสร้าง มักจะมีประโยชน์ในการกำหนดตัวแปรดังนี้:
ท็อป := ..-
หากคุณมีข้อมูลสำคัญอยู่ในไดเร็กทอรีระดับบนสุดเท่านั้น แต่
รักษายากเพราะจำนวน ".." ต่างกันในแต่ละระดับ
ของแผนผังไดเร็กทอรี คุณสามารถใช้ "find_upwards" เพื่อค้นหาไฟล์ที่เป็น
ทราบว่ามีอยู่ในไดเร็กทอรีระดับบนสุดเท่านั้น สมมุติว่า
ไฟล์ "LICENSE" อยู่ในไดเร็กทอรีระดับบนสุดเท่านั้น จากนั้นคุณสามารถทำได้:
ด้านบน := $(dir_noslash $(find_upwards LICENSE))
"$(find_upwards LICENSE)" ส่งคืนเส้นทางแบบเต็มของไฟล์ใบอนุญาต
"$(dir_noslash ...)" ลบชื่อไฟล์ออก ส่งคืนเฉพาะไดเร็กทอรี
(โปรดทราบว่าคำสั่ง "รวม" จะค้นหาไฟล์ขึ้นไปโดยอัตโนมัติ ดังนั้น
ไม่จำเป็นต้องทำอะไรแบบนี้:
รวม $(find_upwards top_level_rules.mk)
คุณก็ทำได้
รวม top_level_rules.mk
และมันจะได้ผลเช่นกัน)
หากไม่พบไฟล์ "find_upwards" จะยกเลิกบิลด์ด้วยข้อความแสดงข้อผิดพลาด
หากคุณระบุมากกว่าหนึ่งไฟล์ find_upwards จะค้นหาไฟล์แรก จากนั้น
อันที่สองเป็นต้น กล่าวอีกนัยหนึ่ง
$(find_upwards ไฟล์1 ไฟล์2)
เทียบเท่ากับ
$(find_upwards file1) $(find_upwards ไฟล์2)
หากคุณต้องการค้นหาไฟล์ใดไฟล์หนึ่ง ให้ใช้ "find_first_upwards" แทน
find_first_upwards file1 file2 ...
ฟังก์ชันนี้ทำงานเหมือน "find_upwards" ยกเว้นว่าจะส่งกลับไฟล์แรกของ any
ไฟล์ในรายการที่พบ โดยเฉพาะจะตรวจสอบไดเรกทอรีปัจจุบันสำหรับ
ไฟล์ใด ๆ ในรายการ และส่งคืนไฟล์แรกที่มีอยู่หรือสามารถสร้างได้
หากไม่มีไฟล์ใดอยู่หรือสามารถสร้างในไดเร็กทอรีนั้นได้ จะตรวจสอบ ..แล้ว
..-ฯลฯ จนกว่าจะถึงไดเร็กทอรีรากหรือไดเร็กทอรีที่เป็น
อยู่ในระบบไฟล์อื่น
first_available file1 file2 ...
ส่งคืนไฟล์แรกในรายการที่มีอยู่หรือสร้างได้ สิ่งนี้มีประโยชน์สำหรับ
ปรับ makefile ของคุณให้ทำงานบนเครื่องหรือเครือข่ายต่างๆ โดยที่
ไฟล์สำคัญอาจอยู่ในที่ต่างๆ ตัวอย่างเช่น นี่คือบรรทัดจาก
หนึ่งใน makefiles ของฉัน:
TCL_LIB = $ (first_available \
/usr/local/stow/tcl-8.4.5-nothread/lib/libtcl8.4.so \
/usr/lib/libtcl8.4.so /usr/lib/libtcl.so \
/net/na1/tcl8.4a3/lib/libtcl8.4.a \
/net/na1/tcl8.4a3/lib/libtcl8.4.sl)
สายนี้จะตรวจสอบห้องสมุด Tcl ในทุกสถานที่ข้างต้นโดยหยุดที่
อันแรกที่พบ คำสั่ง link รวม $(TCL_LIB) ดังนั้นเราจึงได้
ห้องสมุด Tcl ที่เหมาะสม
infer_linker file1 file2 ...
ให้รายชื่อไฟล์อ็อบเจ็กต์ก่อนสร้างไฟล์เหล่านี้หากยังไม่ได้สร้าง แล้วหา
ไม่ว่าพวกเขาจะขึ้นอยู่กับแหล่งที่มาของ Fortran, C ++ หรือ C และส่งคืนที่สอดคล้องกัน
คอมไพเลอร์ (ซึ่งรู้วิธีเชื่อมโยงได้ดีกว่า "ld")
infer_objects file1 file2 ... Belt hold
$(infer_objects object1.o object2.o, *.o)
หากคุณใช้ข้อตกลงมาตรฐานเกี่ยวกับชื่อไฟล์ส่วนหัว makepp จะมีความสามารถ
เดาว่าไฟล์ ".o" หรือ ".lo" ใดที่จำเป็นต้องเชื่อมโยงกับโปรแกรมของคุณ ฉันใช้สิ่งนี้เพื่อ
เลือกไฟล์จากไดเร็กทอรีไลบรารีซึ่งมีโมดูลที่ใช้ในต่างๆ มากมาย
โปรแกรม แทนที่จะสร้างไฟล์ไลบรารี ".a" และให้ตัวลิงก์เลือกไฟล์
โมดูลที่เกี่ยวข้อง makepp สามารถเลือกโมดูลที่เกี่ยวข้องสำหรับคุณ ทางนี้เท่านั้น
โมดูลที่เกี่ยวข้องได้รับการรวบรวม
อัลกอริธึมของ Makepp สำหรับการอนุมานการพึ่งพาอ็อบเจ็กต์ขึ้นอยู่กับแบบแผนนั้น
การใช้งานคลาสหรือฟังก์ชันทั้งหมดที่กำหนดไว้ในไฟล์ส่วนหัว "xyz.h" เป็น
คอมไพล์เป็นไฟล์อ็อบเจ็กต์ชื่อ "xyz.o" (หรือ "xyz.lo") ดังนั้นอัลกอริทึมของ makepp สำหรับ
การอนุมานการอ้างอิงอ็อบเจ็กต์เริ่มต้นด้วยออบเจ็กต์หนึ่งหรือสองสามอ็อบเจ็กต์ที่เรารู้ว่าต้องเป็น
เชื่อมโยงกับโปรแกรม ดูว่าไฟล์ใดบ้างที่รวมอยู่ใน "#include" ใน
แหล่งที่มาเหล่านั้น และพยายามค้นหาไฟล์อ็อบเจ็กต์ที่เกี่ยวข้องสำหรับแต่ละไฟล์ include
ไฟล์
ต้องระบุ "$(infer_objects )" ในรายการการพึ่งพาของโปรแกรม เช่น
นี้:
myprog: $(infer_objects main.o another_object.o, \
**/*.o /other/library/dirs/**/*.o)
$(CXX) $(อินพุต) -o $(เอาต์พุต) $(LIBS)
ฟังก์ชัน "$(infer_objects)" รับสองอาร์กิวเมนต์ (คั่นด้วยเครื่องหมายจุลภาค ดังที่แสดง)
ไฟล์แรกคือไฟล์ออบเจ็กต์หนึ่งหรือสองสามไฟล์ที่ทราบว่าจำเป็นต้องใช้ (สัญลักษณ์แทนคือ
อนุญาตที่นี่) อันที่สองคือรายการของอ็อบเจ็กต์ที่เป็นไปได้ (โดยปกติ คุณจะใช้ a
สัญลักษณ์แทนที่นี่) ที่สามารถเชื่อมโยงได้หากจำเป็น ผลตอบแทนจากสิ่งนี้
ฟังก์ชั่นคือรายการที่มีวัตถุทั้งหมดเป็นอันดับแรกในอาร์กิวเมนต์แรกและ
หลังจากนั้นวัตถุเพิ่มเติมทั้งหมดที่มีอยู่ในอาร์กิวเมนต์ที่สอง
ที่อ็อบเจกต์ต้องการในอาร์กิวเมนต์แรก
ตัวอย่างเช่น สมมติว่า "main.o" มาจาก "main.cpp" ซึ่งรวมถึง "my_class.h"
"$(infer_objects)" ค้นหาไฟล์ชื่อ "my_class.o" ถ้าอย่างใดอย่างหนึ่งเช่น
พบไฟล์มันถูกเพิ่มลงในรายการ (หากพบไฟล์อ็อบเจ็กต์ "my_class.o" สองไฟล์
ในไดเร็กทอรีต่าง ๆ ข้อความเตือนจะถูกพิมพ์) "infer_objects" ด้วย
ตรวจสอบ "my_class.cpp" เพื่อดูว่ามีอะไรบ้าง และไฟล์อ็อบเจ็กต์เพิ่มเติมคืออะไร
โดยนัย
mktemp
mktemp อุปสรรค
mktemp อุปสรรคXXX
เอ็มเคเท็มป์ /
ส่งกลับชื่อไฟล์ชั่วคราวที่คาดเดาไม่ได้ ซึ่งปัจจุบันไม่มีอยู่ ไม่มีชื่อ
การชี้ไปที่ไฟล์เดียวกันจะถูกส่งคืนสองครั้ง แม้จะมีเส้นทางที่สัมพันธ์กันต่างกัน
ภายใน makepp หนึ่งรัน (ยกเว้นอาจมีการเรียกซ้ำแบบเดิม หรือถ้า Perl
รหัสที่ทำงานภายในการดำเนินการกฎเรียก "f_mktemp") ในตอนท้ายของ makepp ให้เรียกใช้ทั้งหมด
ไฟล์ที่ส่งคืนโดยฟังก์ชันนี้จะถูกลบ หากมี (อีกครั้งยกเว้นไฟล์เหล่านั้น
ส่งคืนโดยฟังก์ชันนี้ในโค้ด Perl ที่ทำงานภายในกฎ)
ตัว "X" ตัวพิมพ์ใหญ่จำนวนเท่าใดก็ได้ที่ส่วนท้ายของอาร์กิวเมนต์นั้น จะถูกแทนที่ด้วยหลายตัวนั้น
ตัวอักษรและตัวเลขสุ่ม ยิ่งมีมากก็ยิ่งมีโอกาสชนกันน้อยลง
กับกระบวนการอื่น ๆ ดังนั้นหากคุณให้คำนำหน้าเช่น "/tmp/abc"คุณควรจะพอ
"เอ็กซ์" หากมีมากกว่าหนึ่ง X อักขระตัวแรกจะมาจากรหัสกระบวนการ ถ้า
ไม่มี ก็เหมือนมีสิบ ซึ่งพอเดาได้ (8.4e17
ความเป็นไปได้หรือ 3.7e15 บน Windows) หากไม่มีอาร์กิวเมนต์ คำนำหน้าจะมีค่าเริ่มต้นเป็น
"ทีเอ็มพี" ในไดเร็กทอรีปัจจุบัน
โปรดทราบว่าคุณไม่ต้องการให้ชื่อดังกล่าวเป็นเป้าหมายของกฎและการอ้างอิง NS
ผลลัพธ์จะถูกต้อง แต่จะถูกสร้างขึ้นใหม่ทุกครั้งที่คุณเรียกใช้ makepp
นอกจากนี้ เนื่องจากจะแตกต่างกันเสมอ คุณควรใช้สิ่งนี้ในการทำงานของกฎก็ต่อเมื่อคุณใช้
":build_check forget_action":
TMPFILE ;= $(mktemp) # 1 โทร; "=" จะหมายถึง 3 สาย: 3 ไฟล์
นับ A นับ B: :build_check ละเว้น_action
ผลิต-As-and-Bs >$(TMPFILE)
&grep -c /A/ $(TMPFILE) -o A-count
&grep -c /B/ $(TMPFILE) -o B-count
หรือคุณควรส่งออกและให้เชลล์ประเมิน:
ส่งออก TMPFILE ;= $ (mktemp)
A-นับ B-นับ:
ผลิต-As-and-Bs >$$TMPFILE # makepp ไม่เห็นค่า var
fgrep -c A $$TMPFILE >A-count
fgrep -c B $$TMPFILE >B-count
รูปแบบสุดท้ายจะคืนค่าที่ส่งกลับก่อนหน้านี้ซ้ำ ดังนั้นคุณสามารถใช้ในกฎรูปแบบได้:
%.x: %.y
&grep foo $(อินพุต) -o $(mktemp)
&sed bar $(mktemp /) -o $(output) # ดำเนินการกับผลลัพธ์ของ &grep
นอตดีร์ ชื่อไฟล์
ส่งคืนส่วนที่ไม่ใช่ไดเร็กทอรีของชื่อไฟล์ เช่น ทุกอย่างที่อยู่หลังส่วนสุดท้าย
ทับถ้ามีอย่างใดอย่างหนึ่งหรือชื่อไฟล์ทั้งหมดเป็นอย่างอื่น
only_generated ชื่อไฟล์
ส่งกลับเฉพาะชื่อไฟล์เหล่านั้นในรายการที่สร้างโดย makepp ไม่ใช่ตั้งแต่
แก้ไขตามไฟล์ข้อมูลบิลด์
ฟังก์ชันนี้มีประโยชน์ในกฎเป้าหมายที่ชัดเจน (แม้ว่าแน่นอนว่า "makeppclean" คือ
รุ่นที่ต้องการ):
$(ปลอมสะอาด):
&rm -f $(only_generated **/*)
only_nontargets ชื่อไฟล์
ส่งกลับเฉพาะชื่อไฟล์ในรายการที่ไม่ใช่เป้าหมายของกฎใดๆ (
กฎที่ชัดเจนหรือรูปแบบ) คุณสามารถระบุไวด์การ์ด (ดูที่ "$(wildcard )"
ฟังก์ชันสำหรับรายละเอียดเพิ่มเติมเกี่ยวกับสัญลักษณ์แทนของ makepp) สามารถใช้สำหรับสร้าง a
เป้าหมายการจัดจำหน่าย เช่น
.PHONY: การกระจาย
การกระจาย:
&mkdir our_product-$(VERSION)
&cp $(ตัวกรอง %~, $(only_nontargets *)) our_product-$(VERSION)
tar cf - our_product-$(VERSION) | gzip -9c > our_product-$(VERSION).tar.gz
ในกรณีนี้ "$(only_nontargets *)" จะคืนค่าทุกไฟล์ในไดเร็กทอรีปัจจุบัน
นั่นไม่ใช่เป้าหมายของกฎบางอย่าง "$(filter_out %~, ...)" ลบตัวแก้ไข
การสำรองข้อมูล
คล้ายกับ "only_targets" (ดูด้านบน) "only_nontargets" เท่านั้นที่รู้เกี่ยวกับเป้าหมายที่
ถูกกำหนดไว้แล้ว นี่เป็นเพียงปัญหาหากคุณใช้เพื่อกำหนดตัวแปร
ด้วยการมอบหมาย ":="; ถ้าคุณใช้ในรายการการพึ่งพาหรือในเนื้อหาของa
กฎเกณฑ์อื่น ๆ ทั้งหมดจะได้เห็นแล้ว
only_stale ชื่อไฟล์
ส่งกลับเฉพาะชื่อไฟล์เหล่านั้นในรายการที่สร้างโดย makepp ไม่ใช่ตั้งแต่
แก้ไขตามไฟล์ข้อมูลบิวด์ แต่ไม่มีเป้าหมายของกฎใดๆ อีกต่อไป
ฟังก์ชันนี้มีประโยชน์เพื่อให้แน่ใจว่าไม่มีการพึ่งพาไฟล์ดังกล่าว
โดยไม่บังคับให้สร้างเป้าหมายทั้งหมดอย่างสมบูรณ์:
$(ฟลัชปลอม):
&rm -f $(only_stale **/*)
อันที่จริง มันอาจจะดีกว่าที่จะเขียนสคริปต์ที่เรียก makepp เพื่อสร้าง
รายการไฟล์ที่เก่าแล้วให้สคริปต์นั้นลบไฟล์ที่อยู่ในรายการทั้งหมดที่
ไม่ได้อยู่ภายใต้การควบคุมแหล่งที่มาในขณะนี้ ในกรณีที่ไฟล์ที่สร้างขึ้นกลายเป็นแหล่งที่มา
ไฟล์. Makepp ไม่มีฟังก์ชันดังกล่าวในตัวเนื่องจาก makepp เป็น (และอาจจะ
ควรจะยังคงอยู่) ไม่เชื่อเรื่องพระเจ้าเกี่ยวกับการควบคุมแหล่งที่มา
only_targets ชื่อไฟล์
ส่งกลับเฉพาะชื่อไฟล์ในรายการที่เป็นเป้าหมายของกฎบางอย่างจริงๆ
(ทั้งกฎที่ชัดเจนหรือรูปแบบ) คุณอาจระบุไวด์การ์ด (รวมถึง makepp's
สัญลักษณ์พิเศษ "**") ในชื่อไฟล์ (ดูฟังก์ชัน "$(wildcard )" สำหรับ more
รายละเอียด. สามารถใช้กับเป้าหมายที่สะอาดได้ ตัวอย่างเช่น
.PHONY: สะอาด
สะอาด
&rm -f $(only_targets *)
ตอนนี้ถ้าคุณพิมพ์ "makepp clean" มันจะลบทุกอย่างที่รู้วิธีสร้าง แต่
อย่าสร้างเป้าหมายที่ชัดเจน ให้ใช้ "makeppclean" แทน!
อีกที่หนึ่งที่อาจเป็นประโยชน์คือการหลีกเลี่ยงไม่เหม็นอับ .o ไฟล์ในของคุณ
สร้าง. ตัวอย่างเช่น หากคุณสร้างห้องสมุดในลักษณะนี้:
mylib.a: *.o
&rm -f $(เอาต์พุต)
$(AR) cr $(เอาต์พุต) $(อินพุต)
จากนั้นคุณลบไฟล์ต้นฉบับบางไฟล์ แต่ลืมลบไฟล์ที่เกี่ยวข้อง .o ไฟล์,
.o ไฟล์จะยังคงอยู่รอบๆ ซึ่งหมายความว่าจะยังคงรวมอยู่ใน
ห้องสมุดทั้งๆ ที่มันไม่มีประโยชน์อีกต่อไปแล้ว หากคุณแก้ไข .ของคุณ
กฎเช่นนี้:
mylib.a: $(only_targets *.o)
&rm -f $(เอาต์พุต)
$(AR) cr $(เอาต์พุต) $(อินพุต)
ปัญหานี้จะไม่เกิดขึ้น
โปรดทราบว่านี่หมายถึงเฉพาะไฟล์ที่ทราบว่าเป็นเป้าหมาย at เวลา เธอ
วิงวอน "เฉพาะเป้าหมาย". หาก "only_targets" ปรากฏในการอ้างอิงหรือการดำเนินการของ a
กฎ จากนั้นเป้าหมายที่เป็นไปได้ทั้งหมดจะเป็นที่รู้จักเนื่องจากการพึ่งพาและการกระทำไม่ได้
ประเมินจนกว่าจะมีการดำเนินการกฎ แต่ถ้าประเมินก็ลองประเมินดู
ก่อนหน้าใน makefile ด้วยตัวแปร ":=" ดังนี้:
ALL_TARGETS := $(only_targets *)
เป้าหมาย1: การพึ่งพา1
การปฏิบัติ
เป้าหมาย2: การพึ่งพา2
การปฏิบัติ
ดังนั้น "only_targets" จะไม่ทราบเกี่ยวกับกฎที่ตามมา
ในทำนองเดียวกัน "only_targets" ไม่รู้เกี่ยวกับเป้าหมายที่สร้างใน makefiles ที่
เต็มไปด้วยการเรียกซ้ำ (แต่คุณไม่ควรใช้ recursive make อยู่ดี use
ใช้คำสั่ง "load_makefile" หรือการโหลด makefile โดยนัยแทน)
ญาติ_ชื่อไฟล์ file1 file2 ไฟล์3[, เฉือน]
ส่งกลับชื่อของไฟล์เหล่านั้นที่สัมพันธ์กับไดเร็กทอรีปัจจุบัน (อันที่
makefile อยู่ใน) นอกจากนี้ยังสามารถใช้เพื่อล้าง "./" ที่ไม่จำเป็นและขยะอื่นๆ จาก
เส้นทาง:
ผบ. := .
ตำบล := ..
FNAME := $(DIR)/../otherdir/$(SUBDIR)/files
X := $(relative_filename $(FNAME))
If เฉือน เป็นจริง (โดยปกติ 1) ชื่อไฟล์ที่ส่งคืนรับประกันว่ามีเครื่องหมายทับ
โดยการเติม "./" ไว้ข้างหน้าถ้าจำเป็น เพื่อให้คุณใช้เป็นชื่อเรียกทำงานได้โดยไม่ต้องใช้
กังวลเกี่ยวกับเส้นทางการค้นหาคำสั่งแทนที่ตำแหน่งไดเรกทอรี
หากพาธไปตามไดเร็กทอรีรูท พาเรนต์ของโฮมไดเร็กทอรีของคุณหรือ
"$(ROOT)" ของระบบบิลด์ของคุณ หรือรูทของไดรฟ์บน Windows (ขึ้นอยู่กับ
สิ่งแวดล้อม สิ่งนี้ก็เกิดขึ้นสำหรับ /cygdrive/ค or /c) เส้นทางสัมบูรณ์จะเป็น
กลับมาแทน
เกี่ยวข้องกับ file1 file2 ไฟล์3[, ไดเรกทอรี]
ส่งกลับชื่อของไฟล์เหล่านั้นที่สัมพันธ์กับไดเร็กทอรีที่ระบุ นี่คือ
โดยทั่วไปจะมีประโยชน์เมื่อคุณต้องรันคำสั่งจากa .ด้วยเหตุผลใดก็ตาม
ไดเร็กทอรีอื่น (ไดเร็กทอรีปัจจุบันเริ่มต้น):
source_backup.tar:
cd .. && tar cf $(relative_to $(output), ..) $(relative_to ., ..)
วิภัตติ ชื่อ...
แยกส่วนต่อท้ายของแต่ละชื่อไฟล์ในชื่อ หากชื่อไฟล์มีจุด
คำต่อท้ายคือทุกอย่างที่เริ่มต้นด้วยช่วงเวลาสุดท้าย มิฉะนั้น คำต่อท้ายคือ
สตริงที่ว่างเปล่า ซึ่งบ่อยครั้งหมายความว่าผลลัพธ์จะว่างเปล่าเมื่อไม่มีชื่อ
และถ้าชื่อมีหลายชื่อไฟล์ ผลลัพธ์อาจมีชื่อไฟล์น้อยลง
ตัวอย่างเช่น
$(ส่วนต่อท้าย src/foo.c src-1.0/bar.c hacks)
สร้างผลลัพธ์ ".c .c"
ชั่วคราว คำ
ให้ makepp รู้ว่าเป้าหมายที่ระบุอาจถูกลบโดยกฎที่สร้าง
พวกเขา. คล้ายกับ "ของปลอม" ยกเว้นว่า makepp คาดหวังว่าไฟล์จริงของชื่อนั้น
อาจจะได้รับผลกระทบจากกฎ กฎจะไม่ถูกดำเนินการหากเป็นเพียงชั่วคราว
เป้าหมายล้าสมัย
สัญลักษณ์แทน Belt hold
ส่งกลับชื่อที่เรียงลำดับของไฟล์ทั้งหมดที่ตรงกับรูปแบบที่กำหนดที่มีอยู่หรือที่
ไฟล์ที่ยังไม่มี แต่สามารถสร้างได้ตามกฎที่ makepp รู้
เกี่ยวกับจุดที่ประเมินนิพจน์ ในข้อสุดท้ายนี้มันแตกต่าง
จากสัญลักษณ์แทนการป้อนกฎ ซึ่งใช้กับไฟล์ที่สร้างโดยกฎที่พบในภายหลัง
Makepp รองรับสัญลักษณ์แทนเชลล์ปกติทั้งหมด ("*", "?" และ "[]") นอกจากนี้ยังมี
wildcard "**" ซึ่งตรงกับไดเร็กทอรีที่แทรกแซงจำนวนเท่าใดก็ได้ (ความคิดนี้คือ
ถูกขโมยจาก zsh.) ตัวอย่างเช่น "**/*.c" จะจับคู่ . ทั้งหมด .c ไฟล์ในแหล่งที่มาทั้งหมด
ต้นไม้. "objects/**/*.o" ตรงกับ .o ไฟล์ที่มีอยู่ในที่ใดก็ได้ใน
ไดเรกทอรีย่อย วัตถุ หรือไดเรกทอรีย่อยใด ๆ หรือไดเรกทอรีย่อยใด ๆ NS
ไวด์การ์ด "**" จะไม่ติดตามซอฟต์ลิงก์ไปยังไดเร็กทอรีในทุกระดับและจะไม่เป็นเช่นนั้น
พยายามเข้าสู่ไดเร็กทอรีที่มีอยู่แต่ไม่สามารถอ่านได้ ยังไฟล์และ
ไดเร็กทอรีที่มีอยู่แต่ไม่สามารถอ่านได้จะไม่ถูกส่งกลับโดย "$(wildcard )"
เชือก ฟังก์ชั่น
เพิ่มคำนำหน้า คำนำหน้า, คำ
นำหน้าสตริงคำนำหน้าแต่ละคำ นี่เป็นส่วนใหญ่สำหรับ GNU make
ความเข้ากันได้; โดยใช้การขยายแบบ rc สิ่งนี้สามารถทำได้ในรูปแบบที่อ่านง่ายขึ้น
อย่างนี้:
โมดูล := abcd
X_OLD_STYLE := $(เพิ่มคำนำหน้า $(OBJDIR)/, $(เพิ่มคำต่อท้าย .o, $(MODULES)))
X_NEW_STYLE := $(OBJDIR)/$(MODULES).o # มันอ่านง่ายกว่าเหรอ?
เพิ่มคำต่อท้าย คำต่อท้าย คำ
ต่อท้ายสตริงต่อท้ายคำแต่ละคำ นี่เป็นส่วนใหญ่สำหรับ GNU make
ความเข้ากันได้; โดยใช้การขยายแบบ rc สิ่งนี้สามารถทำได้ในรูปแบบที่อ่านง่ายขึ้น
อย่างนี้:
X_OLD_STYLE := $(เพิ่มคำต่อท้าย .o, $(MODULES))
X_NEW_STYLE := $(โมดูล).o
โทรศัพท์ ตัวแปร[, คำ]...
ฟังก์ชัน "เรียก" มีลักษณะเฉพาะที่สามารถใช้เพื่อพิจารณา ตัวแปร เป็น
ฟังก์ชันพารามิเตอร์ คุณสามารถกำหนดนิพจน์ที่ซับซ้อนให้กับ ตัวแปร และการใช้งาน
"เรียก" เพื่อขยายเนื้อหาไปสู่ค่าต่าง ๆ ที่กำหนดโดย คำ หลังจากนั้น. ใน
ระบบทำอื่น ๆ ตัวแปรที่ใช้เป็นหลักเพื่อขยายผ่าน
"โทร" เรียกว่า แมโคร.
ในระหว่างการขยายมาโคร ตัวแปรชั่วคราว $1, $2, "... " อ้างถึงไฟล์
อาร์กิวเมนต์ที่กำหนดให้ "โทร" ระหว่างการเรียก ตัวแปร $0 จะขยายเป็น
ชื่อของมาโคร (เช่น ตัวแปร) ที่กำลังขยาย "การโทร"
ไม่มีการจำกัดจำนวนอาร์กิวเมนต์ที่แมโครสามารถ "เรียก" ด้วยหรือจำนวน
พารามิเตอร์ที่แมโครอาจคาดหวัง หากคุณส่งอาร์กิวเมนต์เพิ่มเติมเพื่อ "เรียก" เป็นมาโคร
ต้องการ อาร์กิวเมนต์ที่เกินทั้งหมดจะถูกยกเลิก หากคุณผ่านอาร์กิวเมนต์น้อยกว่า a
มาโครคาดหวัง พารามิเตอร์ที่เกินทั้งหมดจะยุบลงในสตริงว่าง
อย่างแรกคือตัวอย่างง่ายๆ:
ส่วนที่เหลือ = $(รายการคำ 2, $(คำ $(1)),$(1))
รายการ = ABCDE
butfirst := $(โทรส่วนที่เหลือ,$(รายการ))
ในที่นี้ ตัวแปร "$(butfirst)" จะมีรายการ "BCDE"
และตอนนี้สำหรับตัวอย่างที่ซับซ้อนมากขึ้นเพื่อแสดงสิ่งที่เป็นไปได้:
ส่วนที่เหลือ = $(รายการคำ 2,$(คำ $(1)),${1})
mymap = $(ถ้า $2,$(โทร $1,$(คำแรก $2)) $(โทร $0,$1,$(โทรส่วนที่เหลือ,$2)))
ดาวน์เคส = ${makeperl lc("$1")}
UCWORDS = คำเหล่านี้ทั้งหมดเป็นค่าสูง
DCWORDS := $(โทร mymap, downcase,$(UCWORDS))
ตอนนี้ "$(DCWORDS)" มี "คำเหล่านี้เป็นตัวพิมพ์ใหญ่" โดยวิธีการ: มันทำให้ไม่
ความแตกต่างไม่ว่าเราจะเข้าถึงข้อโต้แย้งผ่าน $1, "${1}" or "$(1)" ภายในมาโคร
คุณสามารถใช้ตัวแปรโดยตรงราวกับว่ามันเป็นฟังก์ชัน ถ้าไม่มี
หน้าที่ของชื่อนั้น สิ่งนี้ถูกแปลงเป็นการภายในเป็น "การโทร" ดังนั้นสิ่งเหล่านี้คือ
เทียบเท่า:
การสนทนา = $0 กลายเป็น $1 $2
โดยตรง = $(อภิปราย an,argument)
เรียกว่า = $(โทรอภิปราย,ข้อโต้แย้ง)
อาจดูเหมือนเป็นที่ถกเถียงกันว่า "$[call]" ควรขยาย "$[]" ของมาโครด้วยหรือไม่
นิพจน์หรือว่าฟังก์ชันควรทำสิ่งเดียวกันเสมอไม่ว่าจะอย่างไร
ถูกเรียก. หลังถูกเลือกเพราะด้วยไวยากรณ์ make ปกติ มันจะเป็น
เป็นไปไม่ได้ที่จะรับ "$[1], $[2]..." ลงในตัวแปร (จะไม่มีอะไรมาแทนที่
ก่อนที่การมอบหมายจะเกิดขึ้น) ดังนั้น หากคุณมีมาโครสำหรับกำหนด a
กฎ คุณต้องการให้นิพจน์เช่น "$(output)" ปรากฏเมื่อกฎได้รับการแยกวิเคราะห์ ดังนั้น
คุณต้องปกป้องพวกเขาจากการ "โทร":
กำหนด myrule
$2: $1
mycommand $$(อินพุต) -o $$(เอาต์พุต)
เอนเดฟ
$[ไมรูล myinput,myoutput]
กรอง รูปแบบ คำ
ส่งกลับคำทั้งหมดในรายการที่ตรงกับรูปแบบ รูปแบบอาจเป็นอย่างอื่นก็ได้
คำหรือสัญลักษณ์แทนชื่อไฟล์ (เช่น "*", "?" และ "[az]") หรืออาจ
มีอักขระ "%" ซึ่งหมายถึงการจับคู่สตริงใดๆ ณ จุดนั้น (เหมือนกับ "*")
กรองออก รูปแบบ คำ
ส่งกลับคำทั้งหมดในรายการที่ไม่ตรงกับรูปแบบ รูปแบบอาจเป็น
คำอื่นๆ หรือสัญลักษณ์แทนชื่อไฟล์ (เช่น "*", "?" และ "[az]" เป็นที่รู้จัก) หรือ
พวกเขาอาจมีอักขระ "%" ซึ่งหมายถึงการจับคู่สตริงใด ๆ ที่จุดนั้น (เหมือนกับ
"*")
ตัวอย่างเช่น:
libproduction.a: $(filter_out test_*, $(สัญลักษณ์แทน *.o))
จะใส่ทั้งหมด .o ไฟล์ที่มีอยู่หรือสร้างได้ ยกเว้นไฟล์ที่ขึ้นต้นด้วย ทดสอบ_,
เข้าไป libproduction.a.
ค้นหาสตริง หา, in
บริการรถส่ง พบ, ถ้าเป็นสตริงย่อยของ in.
คำแรก คำ
กลับคำแรก
แผนที่ คำ, เพิร์ลโค้ด
ทำแผนที่ คำ, เพิร์ลโค้ด
เช่นเดียวกับแผนที่ของ Perl ใช้ เพิร์ลโค้ด ในแต่ละคำและส่งคืน
ผลลัพธ์. ตัวแปรแรกเป็นรหัส Perl ธรรมดา ในขณะที่ตัวแปรที่สองผ่านก่อน
perlcode ผ่านการขยายตัวแปร Make-style มีการขยายคำในทั้งสอง
กรณี
คำที่อยู่ใน $_ และจะถูกส่งกลับเว้นแต่คุณจะ undef $_ นี้มีไว้สำหรับ
การปรับเปลี่ยนที่ไม่จัดการง่ายโดย "patsubst" เฉพาะเครื่องหมายจุลภาคแรกเท่านั้นที่เป็นตัวคั่น
อื่นใดที่ถือว่าเป็นส่วนหนึ่งของ เพิร์ลโค้ด.
#เปลี่ยนคำ. parens สองเท่า เพื่ออนุญาต parens ใน perlcode หรือใช้ ${}:
X = $((แผนที่ $(VALUES), s/(.+)-(.+)/$2-$1/))
# คุณสามารถใช้ make expressions ได้ แต่คุณต้องใช้ $$ สำหรับ Perl $:
Y = $(makemap $(VALUES), tr/$(OLDCHARS)/$(NEWCHARS)/ หรือ $$_ = 'ล้มเหลว')
# คุณสามารถกำจัดผู้สมัคร:
Y = $(แผนที่ $(VALUES), undef $_ if /no_good/)
ร่วม คำ1, คำ2
ทำการรวมคู่ของคำแรกและคำที่สอง
ซับส รูปแบบ ทดแทน, คำ
ทำการแทนที่ในแต่ละคำในรายการคำ อักขระ "%" ตรงกับอักขระใดๆ
สตริง นี่คือตัวอย่างที่ดีที่สุด:
OBJS = $(patsubst %.c, object_dir/%.o, $(C_SOURCES))
รับทุกไฟล์ใน C_SOURCES และส่งคืนชื่อของไฟล์อ็อบเจ็กต์ใน object_dir
บางครั้งก็กระชับกว่าถ้าใช้การอ้างอิงการแทนที่ เช่น can . ด้านบน
ถูกเขียนว่า
OBJS = $(C_SOURCES:%.c=object_dir/%.o)
ประเภท word1 word2 word3 ...
เรียงลำดับคำศัพท์และลบคำที่ซ้ำกัน
เพิก เชือก
ลบช่องว่างนำหน้าและต่อท้ายออกจากสตริงและแทนที่แต่ละช่องภายใน
ลำดับของอักขระช่องว่างตั้งแต่หนึ่งตัวขึ้นไปที่มีช่องว่างเดียว ดังนั้น "$(แถบ ab
c )" ให้ผลลัพธ์เป็น "abc"
คำนาม จากไปข้อความ
ดำเนินการแทนที่ข้อความในข้อความ: แทนที่แต่ละรายการของ from
โดยที่ ผลลัพธ์จะถูกแทนที่สำหรับการเรียกใช้ฟังก์ชัน ตัวอย่างเช่น,
$(subst ee,EE,ฟุต บนถนน)
แทนที่สตริง "fEEt บน strEEt"
word n,ข้อความ
ส่งกลับไฟล์ nคำของ ข้อความ. ค่านิยมที่ถูกต้องตามกฎหมายของ n เริ่มจาก 1 ที่จุดเริ่มต้น
หรือย้อนกลับจาก -1 ในตอนท้าย ถ้า n มากกว่าจำนวนคำใน ข้อความที่
ค่าว่างเปล่า
รายการคำศัพท์ รายการดัชนี คำ
รายการคำศัพท์ ดัชนีแรก ดัชนีล่าสุด คำ
ในรูปแบบแรก คุณระบุรายการดัชนี (นับจาก 1 ที่จุดเริ่มต้นหรือ
ย้อนกลับจาก -1 ในตอนท้าย) เพื่อเลือกคำที่คุณต้องการ ในรูปแบบที่สองคุณ
ระบุช่วงของคำที่คุณต้องการส่งคืน
คำ ข้อความ
ส่งกลับจำนวนคำใน ข้อความ.
เบ็ดเตล็ด ฟังก์ชั่น
แต่ละ var รายการ ข้อความ
สองอาร์กิวเมนต์แรก, คือ และ รายการถูกขยายก่อนที่จะทำอย่างอื่น บันทึก
ว่าอาร์กิวเมนต์สุดท้าย ข้อความ ไม่ถูกขยายในเวลาเดียวกัน แล้วสำหรับแต่ละคำของ
ค่าที่ขยายของรายการ ตัวแปรที่ตั้งชื่อโดยค่าที่ขยายของ var ถูกตั้งค่าเป็น
คำนั้นและข้อความถูกขยาย น่าจะเป็นข้อความที่มีการอ้างอิงถึงตัวแปรนั้น
ดังนั้นการขยายตัวจะแตกต่างกันในแต่ละครั้ง
ตัวอย่างง่ายๆ นี้กำหนดตัวแปร ไฟล์ ไปที่รายการไฟล์ทั้งหมดในไฟล์
ไดเรกทอรีในรายการ dirs:
dirs := abcd
ไฟล์ := $(foreach dir,$(dirs),$(wildcard $(dir)/*))
ข้อความในที่นี้คือ "$(wildcard $(dir)/*)" การทำซ้ำครั้งแรกพบค่า "a" สำหรับ dir
ดังนั้นจึงให้ผลลัพธ์เหมือนกับ "$(wildcard a/*)"; การทำซ้ำครั้งที่สองก่อให้เกิด
ผลลัพธ์ของ "$(ไวลด์การ์ด b/*)"; และอันที่สาม ของ "$(wildcard c/*)"
ตัวอย่างนี้มีผลลัพธ์เหมือนกัน (ยกเว้นการตั้งค่า "dirs") กับตัวอย่างต่อไปนี้:
ไฟล์ := $(ตัวแทน a/* b/* c/* d/*)
เมื่อข้อความมีความซับซ้อน คุณสามารถปรับปรุงความสามารถในการอ่านได้ด้วยการตั้งชื่อโดยใช้ an
ตัวแปรเพิ่มเติม:
find_files = $(สัญลักษณ์แทน $(dir)/*)
dirs := abcd
ไฟล์ := $(foreach dir,$(dirs),$(find_files))
ที่นี่เราใช้ตัวแปร find_files ด้วยวิธีนี้ เราใช้ "=" ธรรมดาเพื่อกำหนด a
ตัวแปรขยายซ้ำ ๆ เพื่อให้ค่าของมันมีการเรียกใช้ฟังก์ชันจริงถึง
ถูกขยายใหม่ภายใต้การควบคุมของ foreach; ตัวแปรที่ขยายอย่างง่ายจะไม่ทำ
เนื่องจากไวด์การ์ดจะถูกเรียกเพียงครั้งเดียวในขณะที่กำหนด find_files
หมายเหตุ: อย่าสับสนกับตัวแปรพิเศษ "$(foreach)"
ข้อมูล ข้อความ
คำเตือน ข้อความ
ความผิดพลาด ข้อความ
ข้อความที่ส่งออกกลับไม่มีอะไร อันแรกไปที่ STDOUT อันที่สองไปที่ STDERR
ที่สามยกเลิกการประมวลผลเพิ่มเติม
สร้างล่วงหน้า เป้าหมาย
ทำ เป้าหมาย
ส่งคืนอาร์กิวเมนต์แบบคำต่อคำ แต่ก่อนอื่น ให้สร้างไฟล์ทั้งหมดที่อยู่ในรายการ มีประโยชน์
เมื่อจำเป็นต้องใช้ไฟล์ที่กำหนดเมื่อประเมินการแสดงออก สิ่งนี้มักจะเกิดขึ้น
เมื่อคุณมีบิลด์ที่ชุดของไฟล์ที่เกี่ยวข้องถูกคำนวณโดยเชลล์บางตัว
คำสั่ง ตัวอย่างเช่น,
file_list :
#คำสั่งเชลล์คำนวณรายการไฟล์ที่จะใส่ลงในโปรแกรม
my_program : $(&cat $(prebuild file_list))
หากคุณต้องการรายการมากกว่าหนึ่งกฎ การใช้ an . จะมีประสิทธิภาพมากกว่า
ขยายสูงสุดหนึ่งครั้ง ตัวแปร:
file_list ;= $(&cat $(prebuild file_list))
my_program1 : ao $(file_list)
my_program2 : bo $(file_list)
หากคุณระบุเพียง "$(&cat file_list)" แทน makepp จะไม่บังคับ
file_list ให้เป็นปัจจุบันก่อนที่จะรันคำสั่งเชลล์ ใช้ "$(prebuild )"
เป็นวิธีที่ดีที่สุดในการแก้ปัญหานี้ คุณอาจถูกล่อลวงให้ลองทำอย่างอื่น เช่น
นี้:
my_program : file_list $(&cat file_list)
แต่มันใช้ไม่ได้เพราะ "$(&cat file_list)" ได้รับการประเมินก่อนที่ makepp จะพยายาม
สร้าง "file_list"
only_phony_targets ชื่อ
ส่งกลับเฉพาะชื่อเหล่านั้นในรายการที่เป็นเป้าหมายปลอมของกฎบางอย่าง (
กฎที่ชัดเจนหรือรูปแบบ) คุณสามารถระบุไวด์การ์ด (รวมถึงพิเศษของ makepp
สัญลักษณ์แทน "**") ในชื่อไฟล์ (ดูฟังก์ชัน "$(wildcard )" สำหรับรายละเอียดเพิ่มเติม
ใช้สำหรับจัดกลุ่มเป้าหมายได้ เช่น
$(การทดสอบปลอม): $(only_phony_targets */**/tests)
ที่มา ตัวแปร
ระบุชื่อของตัวแปร บอกคุณว่าค่าของมันมาจากไหน
Perl เพิร์ลโค้ด
ช่างแต่งหน้า เพิร์ลโค้ด
ประเมิน perlcode ในบล็อกและส่งคืนผลลัพธ์ ตัวแปรแรกคือ Perl . ธรรมดา
โค้ด ในขณะที่ตัวแปรที่สองส่ง perlcode ผ่าน Make-style variable ก่อน
การขยายตัว
โปรดทราบว่า เช่นเดียวกับฟังก์ชันทั้งหมด ตัวคั่นฟังก์ชันที่ใช้อาจไม่ปรากฏอยู่ภายใน
perlcode นอกสตริงที่ยกมาเดี่ยวหรือคู่ แต่คุณสามารถเพิ่มเป็นสองเท่าใน
ตัวอย่างสุดท้าย:
วีเออาร์ = 1
VAR1 = ${เพิร์ล ($VAR + 1) * 3}
VAR2 = $(perl do { $VAR *= 3; return $VAR + 1 } ถ้า $VAR)
VAR3 = $(makeperl $(VAR1) * 3 + $$VAR) # หนึ่ง Make var และหนึ่ง Perl var
VAR = $((perl ถ้า( ... ) { ... }))
ปลอม คำ
ระบุว่ารายการคำเป็นเป้าหมายปลอมและส่งคืนรายการ
เป้าหมาย มีวัตถุประสงค์เพื่อใช้ในลักษณะนี้:
$(ปลอมทั้งหมด): my_program
$(ปลอมสะอาด):
&rm -f *.o my_program
นอกจากนี้คุณยังสามารถประกาศเป้าหมายอย่างน้อยหนึ่งรายการว่าเป็นของปลอมด้วยบรรทัดแบบนี้ได้ทุกที่ใน
makefile ของคุณ:
.PHONY: ทั้งหมดสะอาด
พิมพ์ ข้อความ
แสดงผลข้อความและส่งคืน ซึ่งส่วนใหญ่จะมีประโยชน์สำหรับการดีบัก เมื่อคุณไม่ทำ
เข้าใจว่าทำไมการแทนที่ตัวแปรจึงมีผลเช่นนั้น ตัวอย่างเช่น,
XYZ := $(พิมพ์ $(patsubst %.c, %o, $(SOURCE_FILES)))
จะพิมพ์ผลลัพธ์ของการเรียก "patsubst"
XYZ := $(patsubst %.c, %o, $(พิมพ์ $(SOURCE_FILES)))
จะพิมพ์อาร์กิวเมนต์สุดท้ายไปยังการโทร "patsubst"
เปลือก เชลล์-คำสั่ง
ส่งคืนผลลัพธ์จากคำสั่งเชลล์ที่กำหนด โดยมีการขึ้นบรรทัดใหม่ด้วยการเว้นวรรค
โปรดทราบว่า เช่นเดียวกับฟังก์ชันทั้งหมด ตัวคั่นฟังก์ชันที่ใช้อาจไม่ปรากฏอยู่ภายใน
คำสั่งเชลล์นอกสตริงที่ยกมาเดี่ยวหรือคู่ แต่คุณสามารถเพิ่มเป็นสองเท่าได้
ดังในตัวอย่างที่สอง:
date = $(shell date) # ดีกว่า: $(perl scalar localtime)
VAR = ${{เชลล์ f() { echo สวัสดี; }; NS}}
xargs คำสั่ง,ข้อโต้แย้ง[,คำต่อท้าย[,ความยาว]]
ส่งคืนรายการคำสั่งที่คั่นด้วยการขึ้นบรรทัดใหม่ซึ่งแต่ละรายการเริ่มต้นด้วยการระบุ
คำสั่งและลงท้ายด้วยองค์ประกอบของรายการให้ได้มากที่สุดโดยไม่ต้องข้าม
ความยาว (ค่าเริ่มต้น 1000) อักขระ
จุดประสงค์คือเพื่อหลีกเลี่ยงไม่ให้เกินขีดจำกัดความยาวคำสั่งในระบบของคุณ
ตัวอย่างเช่น หากมีไฟล์ที่สร้างขึ้นจำนวนมาก คุณอาจต้องการให้คุณ
เป้าหมายที่สะอาด (ที่คุณไม่ควรมีเพราะ "makeppclean" มีประสิทธิภาพมากกว่า) ถึง
มีลักษณะดังนี้:
$(ปลอมสะอาด):
$(xargs $(RM), $(only_targets **/*))
นอกจากนี้ยังมีผลข้างเคียงที่ไม่มีการสร้างคำสั่งใด ๆ หากรายการ
เกิดขึ้นจะว่างเปล่า แต่ในกรณีนี้ จะดีกว่าถ้าใช้ตัว &rm,
เนื่องจากอาร์กิวเมนต์ของคำสั่งบิวด์อินถูกจำกัดโดยหน่วยความจำของ Perl เท่านั้น:
$(ปลอมสะอาด):
&rm -f $(only_targets **/*)
หากมีการระบุอาร์กิวเมนต์ที่สาม อาร์กิวเมนต์จะถูกใช้เพื่อ postfix แต่ละคำสั่ง นี่คือ
มีประโยชน์สำหรับการระบุตัวเปลี่ยนเส้นทาง เช่น (แม้ว่าที่นี่อีกครั้ง & echo จะช่วยได้):
รายการ:
&rm -f $@
&แตะ $@
$(xargs echo, $(only_nontargets **/*), >> $@)
เอกสารนี้บางส่วนอ้างอิงจากเอกสารประกอบของ GNU
โปรดทราบว่าหากมีการเรียกใช้ฟังก์ชันระหว่างการเริ่มต้น makefile เช่น
การขยายตัวแปรการส่งออก ข้อผิดพลาด หรือข้อความเตือนจะรายงานบรรทัดที่ 0
ใช้ makepp_functions ออนไลน์โดยใช้บริการ onworks.net
