makepp_variables - ออนไลน์ใน Cloud

โครงการ:

ชื่อ

makepp_variables -- วิธีการใช้ตัวแปรใน makepp

DESCRIPTION

?: -
-
-
$<,
-
-
-
=,
-
&=,
-
-
-
- A: อาร์
อาร์ฟลากส์,
เช่น, C: ซีซี,
โคลสแฟลกส์,
"change_dependencies",
change_inputs,
เคอร์ดิร์
ซีเอ็กซ์,
CXFLAGS, D: "การพึ่งพา",
"การพึ่งพา", F: F77,
เอฟซี,
"แต่ละ", I: อินพุต,
ปัจจัยการผลิต, L: แอลดี
เล็กซ์,
ลิบทูล M: ทำ,
ตั้งเป้าหมาย
เมคแฟลกส์,
เมคอินโฟ
MAKEPP_DEBUG
แม๊กพปแฟลกส์,
_ทำ PPFLAGS,
MAKEPP_LN_CP
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat
"makepp_simple_concatenation",
MAKEPP_VERSION O: "เอาท์พุท",
"ผลลัพธ์", P: เพิร์ล
คนพิการ R: อาร์เอ็ม
ราก, S: เปลือก,
"sorted_dependencies",
sorted_inputs,
"ลำต้น", T: เป้า,
เป้าหมาย V: วพท. Y: ปปส

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

ชื่อตัวแปรจะคำนึงถึงขนาดตัวพิมพ์ ตามทฤษฎีแล้ว ชื่อตัวแปรสามารถสร้างขึ้นจากหลาย ๆ ตัวได้
ตัวละคร แต่ makepp คงจะไม่สามารถ grok ได้ถ้าคุณทำอย่างอื่นนอกจาก
อักขระที่เป็นตัวอักษรและตัวเลขคละกัน "_" และ "-"

makefile แต่ละอันมีชุดของตัวแปรของตัวเอง และการตั้งค่าตัวแปรใน makefile เดียว will
ไม่มีผลกับค่าของมันใน makefile อื่น ๆ หากคุณต้องการตั้งค่าตัวแปรเป็น
makefiles จำนวนมาก วิธีที่ดีที่สุดที่จะทำคือให้แต่ละไฟล์มีคำจำกัดความทั่วไป
file (ดูคำสั่ง include) หรือใช้ตัวแปร "global"

ตัวแปร การมอบหมาย
ตัวแปรสามารถสมมติค่าได้หลายวิธี:

· ตัวแปรอาจถูกตั้งค่าไว้ใน makefile มีหลายวิธีที่จะทำ
นี้; ดูด้านล่าง

· ค่าของตัวแปรสามารถระบุได้ในบรรทัดคำสั่งดังนี้:

makepp CFLAGS=-O2 my_program

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

หากจำเป็น makefile จะต้องแทนที่การตั้งค่าบรรทัดคำสั่งอย่างชัดเจน
ความตั้งใจไม่ได้เพิกเฉยต่อสิ่งที่ผู้ใช้ร้องขอ แต่เป็นวิธีแก้ไข
ตัวแก้ไข "แทนที่" อาจนำหน้าคำสั่งการมอบหมายใดๆ แต่ในกรณีของ
คำสำคัญ ลำดับมีความสำคัญ ซึ่งเป็นสาเหตุที่ตัวแปรแทนที่เป็น
แสดงด้านล่างเสมอ ตัวแก้ไข "แทนที่" ใช้เฉพาะกับงานใดๆ ที่มัน
มีอยู่และไม่มีผลต่อการกำหนดตัวแปรในภายหลัง

· หากมีการตั้งค่าตัวแปรในสภาพแวดล้อม ก็สามารถอ้างอิงเป็นตัวแปร makepp ได้
โดยปกติ การกำหนดค่าให้กับตัวแปรภายใน makefile จะแทนที่การตั้งค่าจาก
สภาพแวดล้อม แต่คุณสามารถเปลี่ยนได้โดยใช้ "-e" หรือ "--environment-overrides"
ตัวเลือกบรรทัดคำสั่ง

ตัวแปรถูกกำหนดด้วยนิพจน์การกำหนดอย่างใดอย่างหนึ่งเช่นนี้

X = 1
โมดูล := abcd
ซีซี ?= gcc
CFLAGS += -ผนัง
กำหนด VAR
วาร์สาย1
วาร์สาย2
เอนเดฟ
เส้นทางการส่งออก:= $(PWD):$(PATH)
global MYPROJECT.INFO = ข้อมูลที่จะเห็นใน makefiles ทั้งหมด

ช่องว่างนำหน้าและต่อท้ายรอบค่าจะถูกถอดออกเสมอ

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

ง่าย การมอบหมาย ผู้ประกอบการ

=
VARIABLE = สตริงข้อความ
แทนที่ VARIABLE = สตริงข้อความ

นี่เป็นคำสั่งการมอบหมายตามปกติที่การใช้งานทั้งหมดให้การสนับสนุน ดิ
นิพจน์ทางด้านขวามือจะไม่ถูกประเมินจนกว่าค่าของ "$(VARIABLE)" is
ใช้ที่ไหนสักแห่งจริงๆ ดังนั้น หากคุณทำสิ่งต่อไปนี้:

X = 1
ย = $(X)
X = 2

จากนั้น "$(Y)" ในภายหลังใน makefile จะประเมินเป็น "2"

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

:=
ตัวแปร := expr
แทนที่ VARIABLE := expr

สิ่งนี้เหมือนกับ "VARIABLE = expr" ยกเว้นว่าด้านขวามือจะถูกประเมิน
ครั้งเดียวและตลอดไปในเวลาที่ได้รับมอบหมาย ดังนั้นถ้า

เอ็กซ์ := 1
ใช่ := $(X)
เอ็กซ์ := 2

จากนั้น "$(Y)" ในภายหลังใน makefile จะประเมินเป็น "1" เนื่องจากนั่นคือสิ่งที่ "$(X)" เป็น
เมื่อกำหนด "$(Y)"

;=
ตัวแปร ;= expr
แทนที่ VARIABLE ;= expr

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

VAR1 ;= $ (การคำนวณ Perl ราคาแพง)
VAR2 ;= $(คำสั่งภายนอกของเชลล์)

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

อย่างไรก็ตาม นี่ไม่ใช่วิธีที่ชาญฉลาดในการบังคับลำดับการประเมิน ถ้า
ตัวแปรที่กำหนดเช่นนี้รวมถึงค่าของตัวแปรอีกตัวหนึ่ง และตัวอื่นนั้นด้วย
มีค่าเฉพาะเป้าหมาย และการขยายตัวครั้งแรกสำหรับเป้าหมายนั้น จากนั้น
ค่าเฉพาะเป้าหมายจะติดอยู่กับบริบทอื่นๆ ทั้งหมดเช่นกัน นี่คือข้อผิดพลาดและ
หวังว่าจะได้รับการแก้ไขในอนาคต

+=
ตัวแปร += expr
แทนที่ VARIABLE += expr

ผนวกสตริงต่อท้ายเนื้อหาก่อนหน้าของตัวแปร โดยคั่นด้วยช่องว่าง ถ้า
ก่อนหน้านี้ตัวแปรถูกกำหนดด้วย ":=" จากนั้นประเมินทางด้านขวามือ
ก่อนต่อท้าย

&=
ตัวแปร &= expr
แทนที่ VARIABLE &= expr

นำหน้าสตริงไปยังเนื้อหาก่อนหน้าของตัวแปร โดยคั่นด้วยช่องว่าง
หากก่อนหน้านี้ตัวแปรถูกกำหนดด้วย ":=" ดังนั้นทางด้านขวามือจะเป็น
ประเมินก่อนต่อท้าย

ตัวอย่างเช่น วิธีหนึ่งในการรับประกันว่า "CFLAGS" ไม่ว่าผู้ใช้จะใส่อะไรก็ตาม
เริ่มต้นด้วย "-Wall" เสมอเป็นสองบรรทัดนี้:

CFLAGS = -O2 # อาจถูกแทนที่บนบรรทัดคำสั่ง
แทนที่ CFLAGS &= -Wall # เติมหน้าอย่างไม่มีเงื่อนไข

ใน makefiles แบบเก่า คุณมักจะต้องทำสิ่งนี้ ซึ่งมีด้าน
ผลของการบังคับให้พิมพ์ ":=" เพื่อป้องกันการเรียกซ้ำไม่รู้จบ:

ตัวแปร := expr $(VARIABLE)

?=
ตัวแปร ?= expr
แทนที่ VARIABLE ?= expr # ไร้ประโยชน์ แต่ถูกกฎหมาย

ตั้งค่าของตัวแปร แต่ถ้าไม่ได้ระบุตัวแปรไว้ก่อนหน้าใน
makefile บนบรรทัดคำสั่ง หรือในสภาพแวดล้อม งานข้างต้นคือ
เทียบเท่ากับ

ifndef ตัวแปร
ตัวแปร = expr
endif

!=
ตัวแปร != คำสั่งเชลล์
แทนที่ VARIABLE != คำสั่งเชลล์

รันคำสั่งเชลล์และตั้งค่าตัวแปรให้มีเอาต์พุตมาตรฐานของคำสั่ง
นี่เทียบเท่ากับ

ตัวแปร := $(คำสั่งเชลล์)

มัลติไลน์ ตัวแปร

คำสั่ง "define" เป็นคำสั่งที่เทียบเท่าหลายบรรทัดของข้อความง่ายๆ ด้านบน ดิ
โอเปอเรเตอร์หลังจากตัวแปรเป็นทางเลือก หากไม่มีจะเท่ากับ "define VARIABLE
=". โอเปอเรเตอร์ "&=" และ "+=" แตกต่างกันเล็กน้อยที่นี่เนื่องจากติดกาวนี้ไว้
ค่าเก่าด้วยการขึ้นบรรทัดใหม่แทนที่จะเป็นช่องว่าง ต้องไม่มีอะไรนอกจาก a
แสดงความคิดเห็นหลังคำสั่ง กล่าวคือ ค่าเริ่มต้นในบรรทัดถัดไป

กำหนดตัวแปร :=
บรรทัดแรกของค่าตัวแปร
บรรทัดที่สองของค่าตัวแปร
ค่าตัวแปรบรรทัดที่สาม
เอนเดฟ

แทนที่กำหนด VARIABLE
...
เอนเดฟ

คำหลักก่อน "define" สามารถเป็นการรวมกันของ "export" หรือ "global" และ
"แทนที่".

หากคุณต้องการให้ค่าของตัวแปรมีการขึ้นบรรทัดใหม่ คุณต้องใช้คำสั่ง "define" as
แสดง (หรือคุณสามารถกำหนดค่าโดยตรงใน Perl) ("endef" ถูกเลือกสำหรับ
ความเข้ากันได้กับยี่ห้อ GNU คุณยังสามารถใช้ "enddef") สิ่งนี้มีประโยชน์สำหรับ
"ลำดับคำสั่งกระป๋อง" เช่น สิ่งนี้:

กำหนด COMPILE_C_PROGRAM
@&echo "กำลังรวบรวม $(อินพุต)"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(รวม) -c $(อินพุต) -o $(เอาต์พุต)
เอนเดฟ

จากนั้น คุณสามารถใช้ตัวแปรหลายบรรทัดนี้ได้ในหลายกฎ เช่น

%.o : %.ค
$(COMPILE_C_PROGRAM)

$(ARCH)/%.o : $(ARCH)/%.c
$(COMPILE_C_PROGRAM)

โปรดทราบว่าคุณสามารถบรรลุผลเช่นเดียวกันได้โดยใช้เครื่องหมายอัฒภาคแทนการขึ้นบรรทัดใหม่
เพราะเชลล์ตีความว่าเป็นตัวคั่นคำสั่งด้วย ตัวอย่างเช่น,

COMPILE_C_PROGRAM = @echo "กำลังรวบรวม $(input)"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(รวม) -c $(อินพุต) -o $(เอาต์พุต)

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

มีความพิเศษอย่างหนึ่งเมื่อขยายภายใน "define" เช่น "define X :=" หรือบน a
ตัวแปรที่เป็น ":=", "define X &=" และ "define X +=" แล้ว ในกรณีนี้
"$(shell command ...)" หรือบิวด์อิน "$(&command ...)" ไม่ได้รับการแปลงเป็นบรรทัดใหม่
ช่องว่าง

การส่งออก ตัวแปร ไปยัง กระบวนการย่อย

ส่งออก VAR ...
ส่งออก VAR = ค่า
แทนที่การส่งออก VAR += ค่า

รูปแบบแรกทำเครื่องหมายตัวแปรที่กำหนดสำหรับการส่งออกไปยังกระบวนการย่อยด้วยค่าใด ๆ
ตัวแปรก็มี รูปแบบที่สองซึ่งใช้กับตัวแปรเดียวเท่านั้น นอกจากนี้
กำหนดค่าทันที อนุญาตให้มีการกำหนดรูปแบบต่างๆ ทั้งหมด

ใช้งานร่วมกัน ตัวแปร ข้าม ทำไฟล์

VAR สากล ...
Global VAR = ค่า
แทนที่ global VAR &= value

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

รูปแบบที่สองซึ่งใช้กับตัวแปรเดียวเท่านั้น กำหนดค่าเพิ่มเติม right
ห่างออกไป. อนุญาตให้มีการกำหนดรูปแบบต่างๆ ทั้งหมด โปรดทราบว่า ":=" จะขยายทันที
เป็นค่าใน makefile โลคัล ในทางตรงกันข้าม "=" ตัวแปรจะขยายเป็น
คุณค่า ณ จุดใช้งาน

ตัวแปรส่วนกลางอาจจัดการได้ยาก เนื่องจาก makepp อาจโหลด makefiles ในทุกกรณี
เนื่องจากจำเป็นต้องสร้างเป้าหมายซึ่งไม่มีการโหลดกฎหรือ makefiles
ด้วยเหตุนี้จึงแนะนำให้มี ไฟล์ RootMakepp และให้โหลดทั้งหมดอย่างชัดเจน
อื่น ๆ ที่แก้ไขหรือใช้ตัวแปรด้วย "load-makefile"

Global GLIBLIBS ;= $(shell pkg-config --libs glib-2.0)

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

เฉพาะเป้าหมาย ที่ได้รับมอบหมาย

เป้าหมาย: VARIABLE = string
เป้าหมาย: VARIABLE := string
เป้าหมาย: แทนที่ VARIABLE += string

ตั้งค่าเฉพาะเป้าหมายของตัวแปร ค่าเฉพาะเป้าหมายมีผลบังคับใช้ เพียง
ในการกระทำที่สร้างเป้าหมายที่กำหนด ใช้เป็นหลักสำหรับสิ่งต่าง ๆ เช่น
นี้:

CFLAGS := -O2

my_prog: file1.o file2.o พิเศษ_file.o

special_file.o : CFLAGS := -g

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

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

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

การขยายสัญลักษณ์แทนดำเนินการบนเป้าหมาย ดังนั้นคุณสามารถทำสิ่งนี้ได้:

test_*.o : CFLAGS += -DTEST

เพื่อความเข้ากันได้กับยี่ห้อ GNU อาจใช้ "%" แทน "*"

ตัวแปร การแทน
กฎการแทนที่ตัวแปรของ Makepp นั้นคล้ายคลึงกับกฎของยี่ห้ออื่น แต่ค่อนข้าง
มีพลังมากขึ้น ในทำนองเดียวกัน "$(CC)" หรือ "${CC}" ต่างก็แสดงถึงมูลค่าของ
CC ตัวแปร หากคุณต้องการเครื่องหมายดอลลาร์ ให้ใส่เครื่องหมายดอลลาร์คู่ ($$) เช่น
นี้:

เป้าหมาย: dep1 dep2 dep3 dep4
&rm -f $(เอาต์พุต)
สำหรับไฟล์ใน $(inputs); ทำ cat $$file >> $(output); เสร็จแล้ว

นอกจากนี้ makepp ยังมีไวยากรณ์ "$[VARIABLE]" ซึ่งทำสิ่งเดียวกันกับอีกอัน
สอง แต่ก่อนที่ makepp จะทำอย่างอื่น ซึ่งช่วยให้สามารถใช้สำหรับกฎที่สมบูรณ์
และ/หรือเงื่อนไข:

กำหนด bracket_rule =
ifdef SOME_VAR
วงเล็บ:
&echo นี่คือกฎ -o $(output)
endif
เอนเดฟ

$[วงเล็บ_กฎ]

rc สไตล์ การแทน

โดยค่าเริ่มต้น makepp ใช้การแทนที่แบบ rc (ที่เรียกว่าเพราะเป็นผู้บุกเบิกโดย
เปลือก rc) นี่คือตัวอย่างที่ดีที่สุด:

โมดูล = abcd

mylib.a : module_dir/$(MODULES.o $(OTHER_OBJECTS)
$(CXX) $(การขึ้นต่อกัน) -o $(เป้าหมาย)

คำนำหน้า "module_dir/" ถูกนำหน้าแต่ละคำในโมดูล และส่วนต่อท้าย ".o" คือ
ต่อท้ายแต่ละคำ

คุณยังสามารถใช้การแทนที่แบบ rc ได้โดยไม่ต้องใส่รายการคำลงใน a
ตัวแปร; ไวยากรณ์คือ "$( word1 word2)" สังเกตช่องว่างระหว่างวงเล็บกับ
คำแรก ดังนั้นตัวอย่างข้างต้นจึงเขียนได้ดังนี้

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(การขึ้นต่อกัน) -o $(เป้าหมาย)

ตัวแปรจะให้การแทนที่แบบ rc เมื่อมีคำมากกว่าหนึ่งคำเท่านั้น
บอกได้คำเดียวว่าเหมือนทำแบบเดิมๆ อนิจจา เมื่อตัวแปรว่างเปล่า จะมี a
ขัดแย้ง. ดั้งเดิมทำให้ขยายเป็นสตริงว่าง แต่เมื่อนึกถึง
เป็นรายการที่คุณต้องการให้ "-I$(DIRLIST)" หายไป ไม่ให้ "-I" เหงา ดิ
วิธีแก้ไขคือการรวมไว้ในรายการที่ขึ้นต้นด้วยช่องว่าง: "-I$( $(DIRLIST))" ให้คุณ
มีตัวเลือกให้มากที่สุดเท่าที่มีคำในรายการ

หากคุณใส่ตัวแปรหลายตัวในคำเดียวกันซึ่งขยายเป็นอาร์เรย์ของคำ rc-style
การแทนที่ใช้ผลคูณคาร์ทีเซียนจริง ๆ ดังนั้นคุณสามารถทำสิ่งนี้ได้ if
คุณต้องการ:

DIRS = s1 s2
โมดูล = abc
คำต่อท้าย = .o .c
ไฟล์ := $(DIRS)/$(MODULES)$(SUFFIXES)

และ FILES จะมีสตริง

s1/อ่าว s1/ac s1/บ่อ s1/bc s1/co s1/cc s2/อ่าว s2/ac s2/บ่อ s2/bc s2/co s2/cc

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

ไม่ดี := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
ดี := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

หากการแทนที่ rc-style เข้ามาขวางทาง หรือถ้าคุณต้องการให้มีการขึ้นนำหรือตามหลัง
ช่องว่างในตัวแปร make ของคุณ จากนั้นคุณสามารถปิดการแทนที่ rc-style ได้โดยการตั้งค่า
ตัวแปร "makepp_simple_concatenation=1" คุณสามารถปิดได้ทั่วโลกบนคำสั่ง
บรรทัดหรือเป็นตัวแปรสภาพแวดล้อม หรือบนพื้นฐานต่อ makefile โดยการตั้งค่าตัวแปรใน
makefile ของคุณ คุณควรทำสิ่งนี้ใกล้กับด้านบนของ makefile ไม่เช่นนั้นคุณอาจพบเจอ
สถานการณ์ตลกๆ ที่ใช้การแทนที่ rc-style สำหรับการประเมินบางอย่าง ไม่ใช่อย่างอื่น
(นิพจน์ทั้งหมดที่ประเมินก่อนการมอบหมายจะใช้การแทนที่แบบ rc และ all
นิพจน์ที่ประเมินหลังจากนั้นจะไม่ ตั้งแต่เวลาของการประเมินการแสดงออกใน
makefiles นั้นซับซ้อนและไม่ชัดเจนจากลำดับของคำสั่งใน
makefile ทางที่ดีควรตั้งค่า "makepp_simple_concatenation" ให้เร็วที่สุด) คุณทำได้
แม้แต่ตั้งเป้าหมายเดียว:

เป้าหมาย: makepp_simple_concatenation = 1
เป้า:
&echo before_first$(LIST)after_last -o $(เอาต์พุต)

เนื่องจาก "$[VARIABLE]" ได้รับการประเมินก่อน "$(VARIABLE)" ซึ่งรวมทั้งสองไว้ใน rc-
การเปลี่ยนตัวจะไม่ให้ผลลัพธ์ที่คุณอาจคาดหวัง เว้นแต่คุณจะใส่ไว้ในความชัดเจน
รายการ:

เอ = แอ๊บ
ยังไม่มีข้อความ = 1 2
ไม่ดี := $(A)$[N]
ดี := $(A)$( $[N])

บรรทัดสุดท้ายอ่านว่า

ไม่ดี := $(A)1 2 # a1 b1 2
ดี := $(A)$( 1 2) # a1 a2 b1 b2

การแทน อ้างอิง

การอ้างอิงการแทนที่มีรูปแบบ "$(VAR:A=B)" โดยที่ A คือรูปแบบที่จะจับคู่และ B คือ
รูปแบบที่จะแทนที่ด้วย การอ้างอิงการแทนที่เป็นตัวย่อสำหรับ
ฟังก์ชัน "patsubst" ตัวอย่างเช่น:

source_files = ac bc ซีซี dc
object_files = $(source_files:%.c=%.o)

จะตั้งค่า "$(object_files)" เป็น "ao bo co do" "%" เป็นอักขระพิเศษที่ตรงกัน
สตริงใดก็ได้ หากทั้ง A และ B เริ่มต้นด้วย "%" กรณีทั่วไปเมื่อเปลี่ยน
คำต่อท้ายสามารถละเว้นได้:

object_files = $(source_files:.c=.o)
object_files = $(source_files:c=o) # เหมือนกันเพราะ . ไม่ได้พิเศษ

ช่องว่าง in ตัวแปร

หากคุณต้องการควบคุมช่องว่างในตัวแปร คุณต้องปิดการใช้งาน rc-style . (ปัจจุบัน)
การแทนที่ (โดยการตั้งค่า "makepp_simple_concatenation=1") จากนั้นใช้ไวยากรณ์ดังนี้:

โมฆะ =
T = -o $(โมฆะ)

หรือด้วยการประเมินที่ว่างเปล่า:

T = -o $()

เมื่อคุณทำเช่นนี้ ตัวแปร "T" จะมี "-o" ตามด้วยช่องว่าง

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

กรณีเหล่านี้มักเกิดขึ้นเมื่อผู้คนพยายามใช้กฎเดียวกันสำหรับความแตกต่าง
สถาปัตยกรรมที่ไม่ใช้ไวยากรณ์คำสั่ง Unix ทั่วไป เช่น บางครั้งก็เห็น
สิ่งนี้ใน makefiles:

ifeq ($ (ARCH), ประหลาด)
O := /เอาท์พุท=
อื่น
โมฆะ :=
O := -o $(โมฆะ)
endif

%.o : %.ค
$(คอมไพเลอร์) $(อินพุต) $(O)$(เอาต์พุต)

คุณสามารถทำเช่นนี้กับ makepp ได้หากต้องการ แต่คุณอาจจะพบว่า
makefiles จะอ่านง่ายกว่ามากถ้าคุณมีตัวแปรที่ซับซ้อนน้อยกว่า
การทดแทน เช่น

ifeq ($ (ARCH), ประหลาด)
%.o : %.ค
$(WEIRD_COMPILER) $(อินพุต) /OUTPUT=$(เอาต์พุต)
อื่น
%.o : %.ค
$(CC) -c $(อินพุต) -o $(เอาต์พุต)
endif

ไม่อนุญาตให้เว้นวรรคในชื่อตัวแปร เฉพาะในค่าของตัวแปรเท่านั้น มันต่างกัน
จากการนำไปปฏิบัติบางอย่าง

อัตโนมัติ ตัวแปร
ตัวแปรอัตโนมัติคือตัวแปรที่ถือว่าค่าต่างๆ ขึ้นอยู่กับกฎเกณฑ์ใด
พวกเขาได้รับการประเมิน Makepp รองรับตัวแปรอัตโนมัติส่วนใหญ่ที่อื่น ๆ
รุ่นของการใช้ประโยชน์ นอกจากนี้ยังมีชื่อที่คลุมเครือน้อยกว่าและยาวกว่าสำหรับพวกเขาส่วนใหญ่
ที่คุณสามารถใช้แทนได้ (สำหรับ makefiles ดั้งเดิมที่เกิดขึ้นเพื่อกำหนดชื่อเหล่านี้ใหม่
คำจำกัดความใน makefile จะแทนที่ความหมายเริ่มต้น ตัวอย่างเช่น ถ้าคุณพูดว่า
"target = abc" ใน makefile ของคุณ จากนั้น "$(target)" จะขยายเป็น "abc" เสมอ และจะไม่มี
อีกต่อไปจะเทียบเท่ากับ $@.)

ต่อไปนี้คือรายการตัวแปรอัตโนมัติทั้งหมดที่ makepp รองรับ:

เอาท์พุต
เป้า
$@ เป้าหมายของกฎปัจจุบัน ที่จริงแล้วเนื่องจาก makepp รองรับหลายเป้าหมายสำหรับ
กฎใด ๆ นี่คือ เป็นครั้งแรก เป้า. ตัวอย่างเช่น ในกฎต่อไปนี้

y.tab.c y.tab.h : parser.y
$(YACC) -o $(เอาต์พุต) $(YFLAGS) $(อินพุต)

"$(output)" จะมีค่า y.tab.c. เนื่องจากตัวแปรวิเศษเหล่านี้มีอยู่จริง
คุณยังสามารถส่งดัชนีเป็นอาร์กิวเมนต์ได้ นับจาก 1 หรือย้อนกลับ
ตั้งแต่ -1 ดังนั้น "$(output 2)" หรือ "$(output -1)" จะมีค่า y.tab.h.

แม้ว่าตัวแปรทั้งสามรูปแบบจะมีค่าเท่ากัน แต่ก็มีความแตกต่างใน
การตีความกฎหลายเป้าหมาย หากคุณใช้ชื่อลับแบบเก่า $@
makepp จะตีความว่าเป็นชุดกฎแบบเก่า แทนที่จะเป็นกฎสมัยใหม่ที่
สร้างเป้าหมายเหล่านั้นทั้งหมดในครั้งเดียว:

ab: # จริงๆ: หนึ่งกฎสำหรับ a และ b
แตะ $@

cd: # error: mpp บ่นว่าสิ่งนี้ไม่ได้สร้างd
แตะ $(เอาท์พุท)

เอาท์พุท
เป้าหมาย
เป้าหมายทั้งหมดของกฎปัจจุบัน เหมือนกับ "$(target)" เว้นแต่จะมีมากกว่าหนึ่ง
เป้า. ในตัวอย่างข้างต้น "$(ผลลัพธ์)" จะเป็น y.tab.c y.tab.h คุณสามารถผ่าน
รายการดัชนี ดังนั้น "$(เอาต์พุต 2 1)" จะเป็น y.tab.h y.tab.c

เมืองขึ้น
อินพุต
$< การขึ้นต่อกันอย่างชัดเจนครั้งแรกของกฎ ตัวอย่างเช่น ในกฎนี้

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

"$(input)" จะเป็นชื่อของ .c ไฟล์โดยไม่คำนึงถึงสิ่งที่ .h ไฟล์ makepp
ค้นพบ หากคุณระบุการพึ่งพามากกว่าหนึ่งรายการ คุณสามารถรับได้โดยการส่งคำสั่ง
ดัชนี: "$(input $(INDEX))" เป็นการขึ้นต่อกันของ INDEX

การอ้างอิง
ปัจจัยการผลิต
$^ การพึ่งพาที่ชัดเจนทั้งหมดของเป้าหมาย ไม่รวม .h ไฟล์ที่ค้นพบโดย
makepp_scanning เพื่อรวม

ตัวอย่างเช่น ในกฎ

myprog.o : *.o
$(CC) $(CFLAGS) $(อินพุต) -o $(เอาต์พุต)

"$(inputs)" จะเป็นไฟล์ .o ทั้งหมดในไดเร็กทอรี เลือกได้เฉพาะตัวที่คุณ
ต้องการโดยผ่านรายการดัชนี หากคุณระบุไฟล์ประเภทต่างๆ อย่างชัดเจน
คุณสามารถเลือกได้ใน "$(inputs 2 3 4)" (แต่ด้วย wildcard นี่ก็ไม่เหมือนกัน
มีแนวโน้ม)

sorted_dependency
sorted_inputs
$+ การพึ่งพาทั้งหมดของเป้าหมาย เรียงตามลำดับ โดยลบรายการที่ซ้ำกัน
เทียบเท่ากับ "$(sort $(inputs))"

change_dependencies
change_inputs
$? การพึ่งพาของเป้าหมายที่มีการเปลี่ยนแปลง ซึ่งรวมถึงเฉพาะอย่างชัดเจน
การพึ่งพา (เช่น รายการที่คุณระบุไว้ใน makefile) ไม่ได้ค้นพบโดยปริยาย
การขึ้นต่อกันจากการสแกน (เช่น ไฟล์ .h)

มักใช้ในคำสั่งดังนี้

libmine.a : $(MODULES) : build_check dissolve_action
$(AR) เจอ $@ $?

กล่าวคือ ar บอกให้เปลี่ยนเฉพาะโมดูลที่มีการเปลี่ยนแปลง (หมายเหตุ
กฎการตรวจสอบบิลด์ "ignore_action" หากคุณไม่ระบุสิ่งนี้ makepp จะบังคับ
การดำเนินการที่จะดำเนินการทุกครั้งที่มีการเปลี่ยนแปลง หากไม่มีการเปลี่ยนแปลงการพึ่งพา the
สตริงการกระทำจะเป็น "ar ru libmine.a" ซึ่งอาจแตกต่างจากที่เคยเป็น
ครั้งสุดท้ายที่คุณรันมัน ดังนั้นหากไม่มี "ignore_action" makepp จะดำเนินการมัน ในเรื่องนี้
กรณีไม่มีอันตราย แต่กับคำสั่งอื่นอาจเป็นปัญหาได้ ดู
makepp_build_check สำหรับรายละเอียดเกี่ยวกับ "ignore_action")

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

แง่ง
$* ต้นกำเนิดในกฎรูปแบบ (เช่น อะไรก็ตามที่ '%' ตรงกัน) อีกทางหนึ่งถ้าสิ่งนี้
ไม่ใช่กฎรูปแบบ ส่งคืนชื่อไฟล์โดยไม่มีนามสกุล (เช่น มันคือ
เทียบเท่ากับ "$(basename $(input))"

นี่เป็นส่วนใหญ่สำหรับความเข้ากันได้แบบย้อนหลัง ตัวอย่างเช่น ในเวอร์ชันเก่าของ make the
วิธีเดียวที่จะบอกวิธีการรวบรวมใดๆ .c ไฟล์ลงในไฟล์ที่สอดคล้องกัน .o ไฟล์เป็นเหมือน
นี้:

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

นี่เป็นวิธีที่น่ารังเกียจในการเขียนกฎ การใช้ GNU-make style นั้นชัดเจนกว่ามาก
กฎรูปแบบดังนี้:

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

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

#
# สร้างไฟล์ .c ด้วยตัวประมวลผลล่วงหน้าพิเศษบางประเภท:
#
%.ค : %.เค
$(ตัวประมวลผลล่วงหน้า) $(อินพุต) > $(เอาต์พุต)

#
# รวบรวมไฟล์ .c เป็นไฟล์ .o:
#
%.o : %.ค
$(CC) $(CFLAGS) -c $(อินพุต) -o $(เอาต์พุต)

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

ดูเอกสารประกอบในส่วนคำสั่ง foreach ในกฎสำหรับรายละเอียดและตัวอย่างเพิ่มเติม

$/ ซึ่งเป็นค่าคงที่โดยพื้นฐานแล้ว ไม่ว่าจะเป็น "/" หรือบน Windows "\" ดั้งเดิม คุณต้องการมัน ถ้า
คุณต้องการเริ่มต้นโปรแกรมแบบพกพา เช่น โปรแกรมที่คุณสร้างขึ้นในไดเร็กทอรีปัจจุบัน:

เอาต์พุตของฉัน:
.$/myprog >$(เอาต์พุต)

สำหรับชื่อไฟล์ที่ส่งผ่านเป็นอาร์กิวเมนต์ ไม่จำเป็นเพราะ Windows สามารถจัดการ Unix . ได้
ไวยากรณ์ที่นั่น

ตัวเลือกเสริม (Option) ตัวแปร
คุณสามารถตั้งค่าเหล่านี้ได้ในทุกวิธีที่อธิบายข้างต้น (ยกเว้นหากระบุไว้เป็นอย่างอื่น) เพื่อแก้ไข
บาฮาเวียร์แห่งเมคพพ โดยค่าเริ่มต้น สิ่งเหล่านี้ทั้งหมดไม่ได้กำหนดไว้

MAKEPP_DEBUG
หากคุณส่งออกสิ่งนี้ด้วยค่าจริงก่อนที่จะเรียก makepp คุณจะได้รับการดีบักเพิ่มเติม
ข้อมูล. นี่คือ "RULE_SOURCE" ของไฟล์ที่สร้างขึ้นในขณะที่มีผลบังคับใช้ภายใต้
makeppinfo, mppi และรายละเอียดเกี่ยวกับการขยายตัวแปรและการจับคู่กฎภายใต้
makepplog, mppl. สิ่งนี้จะแสดงให้คุณเห็นด้วยว่า makepp หน่วยความจำไม่เพียงพอหรือแฮงค์
เพราะมันขยายตัวแปรเดียวกันไปเรื่อย ๆ :

A = $A # การประเมินรอการตัดบัญชี ต้องการ :=
ข = $ซี
ค = $บี

ทำให้PP_LN_CP
ดูหมายเหตุภายใต้ &ln.

makepp_percent_subdirs
ตั้งค่านี้เป็นค่าจริง (เช่น 1) เพื่อให้มี "%" ในเป้าหมายหรือการอ้างอิงที่ตรงกัน
ในไดเร็กทอรีมากกว่าหนึ่งไดเร็กทอรี

makepp_require_phony
ตั้งค่านี้เป็นค่าจริง (เช่น 1) เพื่อป้องกันการปลอมแปลงโดยนัย (เช่นถ้า rule
สำเร็จโดยไม่ตั้งเป้าหมาย) ตัวแปรนี้ควรเป็นจริงโดยค่าเริ่มต้น to
ป้องกันโซ่การพึ่งพาที่เสีย แต่นั่นจะทำลายความเข้ากันได้ย้อนหลังกับ
makefiles เลอะเทอะ

makepp_signature_C_flat
นี่คือตัวเลือกในการเซ็นชื่อ C ตั้งค่านี้เป็นค่าจริงบางส่วน (เช่น 1) เพื่อปฏิบัติต่อคุณ
แหล่งที่มาเป็นแบบแบน กล่าวคือขึ้นบรรทัดใหม่ทั้งหมด (ยกเว้นรอบคำสั่งตัวประมวลผลล่วงหน้า) เป็น
ปฏิบัติเหมือนคำสั่งเว้นวรรคและ "#line" จะถูกละเว้น

makepp_simple_concatenation
ตั้งค่านี้เป็นค่าจริง (เช่น 1) เพื่อป้องกัน "การแทนที่สไตล์ rc"

PERL
คุณสามารถตั้งค่านี้เป็น Perl ที่คุณใช้เพื่อเรียกใช้สคริปต์ใน makepp
ชุดและส่งออก สิ่งนี้สามารถช่วยเรียกใช้สคริปต์ย่อยด้วย Perl เดียวกัน นี่คือ
ส่วนใหญ่มีประโยชน์สำหรับชุดทดสอบ การติดตั้ง และสำหรับบิลด์แบบเรียกซ้ำ

วีพาธ
การตั้งค่าตัวแปรนี้เป็นค่าบางค่าโดยปริยายจะเรียก "ค่า vpath %"

ที่กำหนดไว้ล่วงหน้า ตัวแปร
Makepp กำหนดตัวแปรไว้ล่วงหน้าสองสามตัว ซึ่งคุณสามารถแทนที่ได้:

AR ค่าเริ่มต้น: "อาร์".

อาร์ฟแฟลกส์
ค่าเริ่มต้น: "อาร์วี".

AS ค่าเริ่มต้น: "เช่น".

CC ค่าเริ่มต้น: พบครั้งแรกใน "gcc", "egcc", "pgcc", "c89" หรือ "cc" หรือบน Windows
นอกจากนี้ "cl" หรือ "bcc32"

โคลสแฟลกส์
ค่าเริ่มต้น: หาก "$(CC)" เป็นคอมไพเลอร์ GNU "-g -Wall" หากเป็นหนึ่งในสอง Windows
คอมไพเลอร์ไม่มีอะไรอื่น "-g"

เคอร์ดีร์
ไดเร็กทอรีที่มี Makefile ปัจจุบันอยู่

ซีเอ๊กซ์ ค่าเริ่มต้น: พบครั้งแรกใน "g++", "c++", "pg++", "cxx", "C""C" หรือ "aCC" หรือบน
Windows เพิ่มเติมคือ "cl" หรือ "bcc32"

CXFLAGS
ค่าเริ่มต้น: หาก "$(CXX)" เป็นคอมไพเลอร์ GNU "-g -Wall" หากเป็นหนึ่งในสอง Windows
คอมไพเลอร์ไม่มีอะไรอื่น "-g"

F77 ค่าเริ่มต้น: พบครั้งแรกใน "f77", "g77" หรือ "fort77"

FC ค่าเริ่มต้น: "$(F77)".

LD ค่าเริ่มต้น: "แอล".

LEX ค่าเริ่มต้น: พบครั้งแรกในหมู่ "lex" หรือ "flex"

ลิบทูล
ค่าเริ่มต้น: "ลิบทูล"

MAKE
ตัวแปรนี้มีค่าต่างกันสองค่า ขึ้นอยู่กับการมีอยู่หรือไม่ของ
"--ดั้งเดิม-เรียกซ้ำ-make". Makepp รับรู้เมื่อตัวแปรนี้ถูกใช้และ
ปิดคุณสมบัติบางอย่าง แม้กระทั่งก่อนที่การเรียกซ้ำจะเกิดขึ้นจริง นี้สามารถ
ไม่พึงประสงค์ในขณะที่คุณค่อยๆ กำจัดมันออกไป ดังนั้นก่อนอื่นให้แปลงการเรียกเป็น a
makepp เฉพาะ "$((MAKE))" ซึ่งจะไม่ปิดคุณสมบัติ ไม่ควรตั้ง
เพราะนั่นทำให้การเรียกซ้ำที่ชาญฉลาดของเราหยุดทำงาน

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

ค่าเริ่มต้น: ไม่ว่าผู้ใช้จะกำหนดเป้าหมายอย่างชัดเจน (หรือการเรียกซ้ำ) ที่ให้ไว้
ว่างเปล่าเมื่อสร้างเป้าหมายเริ่มต้นโดยปริยาย

ifneq $(กรองเป้าหมายพิเศษ, $(MAKECMDGOALS))
# เป้าหมายพิเศษเป็นหนึ่งในเป้าหมายที่ชัดเจนในปัจจุบัน
อื่น ๆ ifeq $(MAKECMDGOALS)
#ไม่มีเป้าหมายที่ชัดเจน
endif

MAKEFLAGS (ส่งออก)
ตัวเลือกมาตรฐานที่ makepp ถูกเรียก ผู้ที่มีอักษรตัวเดียว
แบบฟอร์มถูกรวมไว้ที่จุดเริ่มต้นโดยไม่มี "-" นำหน้า (สวรรค์รู้ว่าทำไม gmake เลือก
เพื่อวาง "-")

เมคอินโฟ
ค่าเริ่มต้น: "เมคอินโฟ".

MAKEPPFLAGS (ส่งออก)
ค่านี้ถูกกำหนดเป็นค่าเดียวกับ MAKEFLAGS แต่ถ้าตัวแปรนี้มีอยู่ใน
สภาพแวดล้อมของ makepp

_MAKEPPFLAGS (ส่งออก)
ตัวเลือกเฉพาะ makepp ที่จำเป็นสำหรับความเข้ากันได้ของ POSIX/gmake ซึ่ง makepp
ถูกเรียก สิ่งเหล่านี้อยู่ในตัวแปรที่แยกจากกัน ดังนั้น makefile ดั้งเดิมจึงไม่สามารถแตกได้
เข้ากันได้โดยการยกเลิกการตั้งค่า MAKEFLAGS ตั้งค่านี้เฉพาะกับ
"--ดั้งเดิม-เรียกซ้ำ-make".

MAKEPP_VERSION
เวอร์ชันของ makepp ที่คุณใช้งานอยู่ ถ้าเป็นรุ่นเบต้าก็จะมี
ยัติภังค์ตามด้วย YYMMDD บวกกับข้อมูลภายในเพิ่มเติม คุณสามารถใช้สิ่งนี้สำหรับ "ifdef"
เพื่อซ่อนโครงสร้างเฉพาะของ makepp จากยี่ห้ออื่น

ค่าเริ่มต้น: ค่าเดียวกันที่แสดงโดย "makepp --version"

PWD นามแฝงสำหรับ "CURDIR"

RM ค่าเริ่มต้น: "rm -f". สิ่งนี้มีไว้สำหรับ Makefiles รุ่นเก่า สำหรับคนรุ่นใหม่ควรใช้
ในตัว &rm คำสั่งโดยตรง ถ้าจะเขียนกฎปลอมให้ดูที่
คำสั่ง "makeppclean -r" แทน

ROOT
พาธสัมพัทธ์ไปยังรูทของระบบบิลด์ของคุณ เช่น ไดเร็กทอรีต่อไปใน
ซึ่งคุณมี "RootMakeppfile(.mk)" หากคุณไม่มี ตัวแปรนี้คือ
ว่างเปล่า

SHELL
ตัวแปรนี้ใช้ได้เฉพาะเมื่อคุณ "ส่งออก" เท่านั้น ในกรณีนี้คือเชลล์
ซึ่งใช้เพื่อดำเนินการกระทำที่ไม่ได้สร้างขึ้นด้วยอักขระพิเศษบางอย่างในนั้น (ธรรมดา
ที่ดำเนินการโดยตรง) บน Windows Strawberry หรือ ActiveState Perl หากคุณมี
Shell เหมือน Unix คุณต้องตั้งค่าตัวแปร SHELL เป็นค่าที่ลงท้ายด้วย "sh" แทน
หรือ "sh.exe" ก่อน โทร makepp.

ค่าเริ่มต้น: พบครั้งแรกใน "/usr/xpg4/bin/sh" (เช่น Solaris) หรือ "/sbin/xpg4/sh"
(เช่น Reliant Unix) หรือ "bin / sh /".

ปปส
ค่าเริ่มต้น: พบครั้งแรกในหมู่ "bison -y" หรือ "yacc"

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

การเข้าถึงตัวแปรส่วนกลางจาก Perl ทำได้โดยนำหน้าด้วย "Mpp::global"
บรรจุุภัณฑ์. อันที่จริงตัวแปรใด ๆ ที่ยังไม่มีอยู่ใน makefile ปัจจุบันและคุณ
มอบหมายให้ในแพ็คเกจนี้นับจากนี้ไปจะเป็นโกลบอลราวกับว่าคุณเพิ่งออก
คำสั่ง "สากล" สำหรับมัน

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

ด้วยการเข้าถึงโดยตรง คุณยังเลี่ยงการขยายตัวของตัวแปรเหล่านี้ได้ด้วย หากเป็นตัวแปรประเภท
"=" หรือ ";=" ตัวแปรพิเศษเช่น "$(CC)" เริ่มต้นเป็นฟังก์ชัน จนกว่าจะเป็น
ได้รับมอบหมายให้. ดังนั้นในหลายกรณี คุณจะไม่เห็นคุณค่าของมัน

ด้วยเหตุผลเหล่านี้ เป็นการดีกว่าที่จะให้ makepp กำหนดค่าที่ถูกต้อง คุณสามารถใช้
ตัวแปร "makeperl" ซึ่งตัวแปรได้รับการประเมินก่อนที่โค้ด Perl จะได้รับ
ตีความ:

makeperl { $$current_value = '$ (MAKEFILE_VAR)' }

หากคุณต้องการตัวแปรในบล็อก makefile perl สามารถทำได้ผ่านตัวแปร Perl
$makefile ดังนี้:

perl { $current_value = $makefile->expand_variable( 'MAKE_VAR' ) }

ฟังก์ชั่นรับวัตถุ makefile ที่ส่งผ่านเป็นอาร์กิวเมนต์ที่สอง $_[1] เสมอ:

ย่อย f_f { $current_value = $_[1]->expand_variable( 'MAKE_VAR' ) }

คำสั่งควรจะถูกเรียกภายในการดำเนินการของกฎ โดยที่อ็อบเจกต์ makefile เป็น
สามารถเข้าถึงได้ผ่านทาง "$Mpp::Subs::rule->{MAKEFILE}":

ย่อย c_cmd { $current_value = $Mpp::Subs::rule->{MAKEFILE}->expand_variable( 'MAKE_VAR' ) }

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