makepp_variables - מקוון בענן

תָכְנִית:

שֵׁם

makepp_variables -- כיצד להשתמש במשתנים ב-makepp

תיאור

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAGS,
כפי ש, C: זֶרֶם יָשָׁר,
CLLAGS,
"changed_dependencies",
שינויים_כניסות,
קורדיר,
CXX,
CXXFLAGS, D: "תלות",
"תלות", F: F77,
FC,
"לכל אחד", I: קלט,
תשומות, L: LD,
לקס,
LIBTOOL, M: עשה,
MAKECMDGOALS,
MAKEFLAGS,
MAKEINFO,
MAKEPP_DEBUG,
MAKEPPFLAGS,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "תְפוּקָה",
"פלטים", P: PERL,
PWD, R: RM,
שורש, S: צדף,
"סידור_תלות",
מסודר_תשומות,
"גֶזַע", T: יעד,
יעדים, V: VPATH, Y: YACC

Makefiles משתמשים בדרך כלל במשתנים במקומות רבים. סיבה אחת חשובה לשימוש
משתנים זה להבטיח שמידע כלול רק במקום אחד בקובץ makefile, אז
שאם ישתנה, אין סכנה ששני עותקי המידע ייצאו מהם
סינכרון.

שמות משתנים הם תלויי רישיות. בתיאוריה, שמות משתנים יכולים להיות מורכבים מרבים
דמויות, אבל סביר להניח ש-makepp לא יוכל לגרוף את זה אם תעשה משהו מלבד
תווים אלפאנומריים, "_", ו-"-".

לכל makefile יש קבוצה משלו של משתנים, והגדרת משתנה בקובץ makefile אחד יהיה
אין השפעה על הערך שלו בשום makefile אחר. אם אתה רוצה להגדיר משתנים
קבצי makefile רבים, הדרך הטובה ביותר לעשות זאת היא שכל אחד מהם יכלול הגדרות משותפות
קובץ (ראה הצהרת include) או השתמש במשתנים "גלובליים".

מִשְׁתַנֶה משימה
משתנה יכול להניח ערך בכמה דרכים שונות:

· ניתן להגדיר משתנה בתוך makefile. ישנן מספר דרכים שונות לעשות
זֶה; ראה למטה.

· ניתן לציין ערך של משתנה בשורת הפקודה, כך:

makepp CFLAGS=-O2 my_program

אם נטען יותר מקובץ makefile אחד, המשתנה CFLAGS מופץ לכל ה-
makefiles. משתנים המוגדרים בשורת הפקודה עוקפים אוטומטית כל הגדרה של
המשתנה בכל אחד מה-makefiles.

אם יהיה צורך אי פעם, ה-makefile חייב בתורו לעקוף במפורש את הגדרות שורת הפקודה.
הכוונה היא לא להתעלם ממה שהמשתמש מבקש, אלא דרך לשנות זאת.
השינוי "עקוף" עשוי להקדים כל הצהרת הקצאה. אבל במקרה של
הצהרות מילות מפתח, הסדר חשוב, וזו הסיבה לכך שוריאנט ההחלפה הוא
תמיד מוצג למטה. השינוי "עקוף" חל רק על כל ההקצאות שבהן
קיים ואינו משפיע על הקצאות מאוחרות יותר למשתנה.

· אם משתנה מוגדר בסביבה, ניתן להתייחס אליו כמשתנה makepp.
בדרך כלל הקצאות למשתנים בתוך makefile עוקפות הגדרות מה-
סביבה, אבל אתה יכול לשנות זאת באמצעות "-e" או "--environment-overrides"
אפשרות שורת הפקודה.

משתנים מוקצים עם אחד מכמה ביטויי הקצאה, כמו זה

X = 1
מודולים := abcd
CC ?= gcc
CFLAGS += -קיר
להגדיר VAR
var שורה 1
var שורה 2
enddef
ייצוא PATH := $(PWD):$(PATH)
global MYPROJECT.INFO = מידע שניתן לראות בכל קבצי המייקאפ

רווח לבן מוביל ונמשך סביב ערכים תמיד נמחק.

למפעילי ההקצאה השונים יש משמעויות שונות במקצת.

פָּשׁוּט משימה מפעילי

=
VARIABLE = מחרוזת טקסט
לעקוף את VARIABLE = מחרוזת טקסט

זוהי הצהרת ההקצאה הרגילה שכל ההטמעות של תומך. ה
הביטוי בצד ימין אינו מוערך עד שהערך של "$(VARIABLE)" הוא
ממש בשימוש איפשהו. לפיכך, אם תעשה את הפעולות הבאות:

X = 1
Y = $(X)
X = 2

ואז "$(Y)" מאוחר יותר בקובץ המייקאפ יוערך ל-"2".

באופן כללי, אתה בדרך כלל רוצה להשתמש ב-":=" (ראה להלן) במקום "=" כי זה
מספק הערכת משתנים צפויה יותר. עם זאת, יש מקרים שבהם אתה צריך
כדי לדחות את הערכת המשתנה. כמו כן, אם אתה כותב makefile זה חייב להיות
תואם לאחור עם גרסה כלשהי של make מלבד GNU make, אז אין לך
בחירה: אתה יכול להשתמש רק ב-=".

:=
משתנה := expr
לעקוף משתנה := expr

זה זהה ל-"VARIABLE = expr" פרט לכך שהצד הימני מוערך
אחת ולתמיד בזמן המשימה. לפיכך אם

X := 1
Y := $(X)
X := 2

ואז "$(Y)" מאוחר יותר בקובץ המייקאפ יוערך ל-"1" מכיוון שזה מה ש-"$(X)" היה
כאשר "$(Y)" הוגדר.

;=
משתנה ;= expr
לעקוף משתנה ;= expr

זה זהה ל-"VARIABLE := expr" פרט לכך שהצד הימני מוערך
רק בזמן השימוש הראשון ולאחר מכן נזכר. זה שימושי עבור יקר
פקודות, אשר תמיד מחזירות את אותו הערך, אך אינך רוצה לבצע מתי
בניית יעדים לא קשורים:

VAR1 ;= $(חישובים יקרים perl)
VAR2 ;= $(פקודה חיצונית של מעטפת)

שימו לב ש-makefiles ישנים ישתמשו בדרך כלל ב-":=" כאן, לפחות לעשות זאת פעם אחת בלבד.
אבל עם המפעיל הזה אתה יכול אפילו בנוסף לא לעשות את זה, אם אתה לא עושה את זה כרגע
צריך את הערך. עבור ערכים זהים במספר ספריות, אתה יכול
בצע אופטימיזציה נוספת עם "גלובלי", הנדון להלן.

עם זאת, זה לא נועד כדרך חכמה לכפות סדר הערכה. אם
משתנה המוגדר כך כולל את הערך של משתנה אחר, ושל משתנה אחר
יש ערך ספציפי ליעד, וההרחבה הראשונה היא עבור היעד הזה, ואז ה-
ערך יעד ספציפי יישאר גם עבור כל ההקשרים האחרים. זה באג ו
בתקווה יתוקן בעתיד.

+=
משתנה += expr
לעקוף משתנה += expr

מוסיף את המחרוזת לתוכן הקודם של המשתנה, מופרד ברווח. אם
המשתנה הוקצה בעבר עם ":=", ואז הצד הימני מוערך
לפני ההוספה.

&=
משתנה &= expr
לעקוף משתנה &= expr

מקדים את המחרוזת לתוכן הקודם של המשתנה, מופרד ברווח.
אם המשתנה הוקצה בעבר עם ":=", אז הצד הימני הוא
מוערך לפני ההוספה.

למשל דרך אחת להבטיח ש"CFLAGS", כל מה שהמשתמש יוכל להכניס,
תמיד מתחיל ב-"-Wall" הן שתי השורות הבאות:

CFLAGS = -O2 # אולי נדחק בשורת הפקודה
לעקוף CFLAGS &= -Wall # מוקף מראש ללא תנאי

ב-makefiles ישנים בדרך כלל היית צריך לעשות משהו כזה, שיש לו את הצד
השפעה של אילוץ הסוג ל":=" כדי למנוע חזרה אינסופית:

משתנה := expr $(VARIABLE)

?=
משתנה ?= expr
override VARIABLE ?= expr # חסר תועלת, אבל חוקי

מגדיר את הערך של המשתנה, אך רק אם המשתנה לא צוין קודם לכן
ה-makefile, בשורת הפקודה או בסביבה. המשימה לעיל היא
שווה בדיוק ל

ifndef משתנה
משתנה = expr
ח

!=
VARIABLE != פקודת מעטפת
לעקוף פקודת VARIABLE != פגז

מפעיל את פקודת ה- shell ומגדיר את המשתנה כך שיכיל את הפלט הסטנדרטי של הפקודה.
זה בדיוק שווה ערך ל

VARIABLE := $(פקודה shell)

רב קו משתנים

המשפט "הגדר" הוא המקבילה מרובת שורות של ההצהרות הפשוטות לעיל. ה
אופרטור אחרי המשתנה הוא אופציונלי. אם חסר, זה שווה ערך ל"הגדר VARIABLE
=". האופרטורים "&=" ו-"+=" שונים במקצת כאן, בכך שהם מדביקים את זה
הערך הישן עם קו חדש, ולא רווח. אסור שיהיה שום דבר מלבד א
תגובה אחרי ההצהרה, כלומר הערך מתחיל בשורה הבאה.

הגדר משתנה :=
שורה ראשונה של ערך המשתנה
שורה שנייה של ערך המשתנה
שורה שלישית של ערך המשתנה
endef

לעקוף הגדרת VARIABLE
...
enddef

מילות מפתח לפני "הגדיר" יכולות להיות שילובים של "ייצוא" או "גלובלי" ו
"עקוף".

אם אתה צריך שערך של משתנה יכיל שורות חדשות, עליך להשתמש במשפט "הגדר" כ
מוצג (או שאתה יכול להקצות את הערך ישירות בפרל). ("endef" נבחר עבור
תאימות ליצרן GNU. אתה יכול גם להשתמש ב-"enddef".) זה שימושי בעיקר עבור
"רצפי פקודות משומרים", למשל, משהו כזה:

הגדר COMPILE_C_PROGRAM
@&echo "קומפילציה של $(קלט)"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDES) -c $(קלט) -o $(פלט)
endef

אז אתה יכול להשתמש במשתנה מרובה שורות זה בכמה כללים, כמו זה:

%.o : %.c
$(COMPILE_C_PROGRAM)

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

שימו לב שלעיתים קרובות תוכלו להשיג את אותו אפקט על ידי שימוש בנקודה-פסיק במקום בשורה חדשה,
כי הקליפה מפרשת את זה גם כמחוון פקודה. לדוגמה,

COMPILE_C_PROGRAM = @echo "קומפילציה של $(קלט)";
$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDES) -c $(קלט) -o $(פלט)

יהיה אותו אפקט, פרט לכך שהנקודה-פסיק מאלץ את פרל להעביר אותו לקליפה,
במקום לבצע את הפקודה בצורה ישירה ויעילה יותר. אתה גם צריך לשים כל אחד
מובנה על קו משלו, כלומר אתה צריך לעבור להד החיצוני ב-
מקרה נקודה-פסיק.

יש התמחות אחת כאשר מתרחבים בתוך "הגדיר", כלומר "הגדר X :=" או על a
משתנה שכבר היה ":=", "define X &=" ו-"define X +=". במקרה זה ה
"$(פקודה של מעטפת ...)" או "$(&command ...)" המובנית לא יהפכו את שורות חדשות ל
רווחים.

יצוא משתנים ל תהליכי משנה

ייצוא VAR...
ייצוא VAR = ערך
לעקוף את ערך VAR += הייצוא

הטופס הראשון מסמן את המשתנים הנתונים לייצוא לתהליכי משנה, בכל ערך
למשתנה יש אז. הצורה השנייה, החלה רק על משתנה אחד, בנוסף
מקצה ערך מיד. כל גרסאות ההקצאה מותרות.

שיתוף משתנים לרוחב makefiles

VAR גלובלי...
VAR גלובלי = ערך
לעקוף את ערך VAR &= העולמי

הטופס הראשון מסמן את המשתנים הנתונים כגלובליים לכל ה-makefiles. אם מישהו מהם
כבר היה ערך, הערך הזה מועבר מהמשתנה המקומי makefile למשתנה הגלובלי
אחד. עם זאת, אם, בזמן ההצהרה הזו, לכל makefile אחר כבר היה א
ערך עבור כל אחד מהם, אז הקבצים האלה לא יראו את הגלובלי.

הצורה השנייה, החלה רק על משתנה אחד, מקצה בנוסף זכות ערך
רָחוֹק. כל גרסאות ההקצאה מותרות. שים לב ש":=" יתרחב מיד
לערכים ב-makefile המקומי. להיפך משתני "=" יתרחבו ל-
ערכים בנקודת השימוש.

משתנים גלובליים יכולים להיות מסובכים להתמודדות, מכיוון ש-makepp עשוי לטעון קבצי makep בכל
סדר, ככל שעולה הצורך לבנות מטרה כלשהי שעבורה לא נטען כלל או makefile.
מסיבה זו מומלץ להחזיק א RootMakeppfile וכדי לטעון את כולם במפורש
אחרים שמשנים או משתמשים במשתנה עם "load-makefile".

גלובלי GLIBLIBS ;= $(shell pkg-config --libs glib-2.0)

כמו כן, שים לב שהפרויקט שלך עשוי יום אחד להיבנות יחד עם פרויקטים אחרים. לזה
הסיבה לכך שמומלץ תמיד להפוך את שם הפרויקט לחלק מכל שם משתנה גלובלי.

ספציפי למטרה הקצאות

יעד: VARIABLE = מחרוזת
target: VARIABLE := מחרוזת
יעד: לעקוף מחרוזת += VARIABLE

מגדיר ערך ספציפי ליעד של המשתנה. קיים ערך ספציפי ליעד רק
בפעולה אשר מייצרת את המטרה הנתונה. זה משמש בעיקר לדברים כמו
זֶה:

CFLAGS := -O2

my_prog: file1.o file2.o special_file.o

special_file.o : CFLAGS := -g

%.o: %.c
$(CC) $(CFLAGS) -c $(קלט) -o $(פלט)

מה שקורה כאן הוא שכל קבצי ".c" יורכבו עם אופטימיזציה ("-O2") אלא
"special_file.c", אשר הידור במצב ניפוי באגים ("-g"). זוהי דרך נוחה לעשות זאת
ציין אפשרויות קומפילציה שונות עבור מספר קבצים בלבד.

הקצאות של משתנים ספציפיים למטרה כמו זו חלות רק על הפעולות של הכלל; הֵם
אינם בתוקף בעת הערכת היעדים או התלות של כלל. אם כלל
יש יותר מיעד אחד, הקצאות משתנים ספציפיות ליעד נלקחות רק מה-
ראשון יַעַד. שים לב גם שהמשתנים הספציפיים ליעד של makepp שונים במקצת
מ-GNU make's בכך שהם חלים רק על הכלל עבור הקובץ האחד שהוזכר, ולא על
כל אחד מקודמיו.

הרחבת תווים כלליים מבוצעת על היעד, אז אתה יכול לעשות משהו כזה:

test_*.o : CFLAGS += -DTEST

לצורך תאימות עם מותג GNU, ניתן להשתמש ב-"%" במקום "*".

מִשְׁתַנֶה החלפה
כללי ההחלפה המשתנים של Makepp דומים לאלה של יצרנים אחרים, אבל במידת מה
חזק יותר. כמו בכל היצרנים, "$(CC)" או "${CC}" שניהם מייצגים את הערך של ה-
משתנה CC. אם אתה צריך סימן דולר מילולי, הכנס סימן דולר כפול ($$), כמו
זֶה:

יעד: dep1 dep2 dep3 dep4
&rm -f $(פלט)
עבור קובץ ב-$(כניסות); do cat $$file >> $(פלט); בוצע

בנוסף ל-makepp יש תחביר "$[VARIABLE]", שעושה את אותו הדבר כמו השני
שניים, אבל לפני שמייקפ גרוק כל דבר אחר. זה מאפשר להשתמש בו עבור כללים מלאים
ו/או תנאים:

הגדר Bracket_rule =
ifdef SOME_VAR
סוֹגֵר:
&echo זה כלל -o $(פלט)
ח
enddef

$[bracket_rule]

בסגנון rc החלפה

כברירת מחדל, makepp משתמש בהחלפה בסגנון rc (נקרא כך מכיוון שהוא היה חלוץ על ידי
מעטפת rc). זה מומחש בצורה הטובה ביותר על ידי דוגמה:

MODULES = abcd

mylib.a : module_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(dependencies) -o $(target)

הקידומת "module_dir/" מוצמדת לפני כל מילה ב-MODULES, והסיומת ".o" היא
מצורף לכל מילה.

אתה יכול גם להשתמש בהחלפה בסגנון rc אפילו בלי להכניס את רשימת המילים לתוך a
מִשְׁתַנֶה; התחביר הוא "$( word1 word2)". שימו לב לרווח בין הסוגריים ל-
מילה ראשונה. אז הדוגמה שלמעלה הייתה יכולה להיכתב כך:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(dependencies) -o $(target)

משתנה ייתן החלפה בסגנון rc רק כאשר יש בו יותר ממילה אחת.
במילה אחת זה כמו תוצרת מסורתית. אבוי, כאשר המשתנה ריק, יש א
סְתִירָה. יצרנים מסורתיים פשוט מרחיבים אותו למחרוזת הריקה. אבל כשחושבים על
זה בתור רשימה, היית רוצה ש-"-I$(DIRLIST)" ייעלם, לא יתן "-I בודד". ה
הפתרון הוא לעטוף אותו ברשימה שמתחילה ברווח: "-I$( $(DIRLIST))" נותן לך
בדיוק כמו הרבה אפשרויות, כמו שיש מילים ברשימה.

אם תשים כמה משתנים באותה מילה שמתרחבים למערכים של מילים, בסגנון rc
החלפה למעשה לוקחת את המוצר הקרטזיאני, אז אתה יכול לעשות משהו כזה אם
אתה רוצה:

DIRS = s1 s2
MODULES = abc
SUFFIXES = .o .c
קבצים := $(DIRS)/$(מודולים)$(SUFFIXES)

ו-FILES יכיל את המחרוזת

s1/ao s1/ac s1/bo s1/bc s1/co s1/cc s2/ao s2/ac s2/bo s2/bc s2/co s2/cc

מלבד רווח לבן, החלפה בסגנון rc נעצרת בכל ציטוט, כל עגול, מתולתל או מרובע
סוגריים, וכל אחד מ", : ; = # @". שימו לב שזה עשוי להיות מפתיע, ושוב צריך
רשימה מפורשת. נניח שאתה רוצה לחפש כותרות לפי תו כללי בכל הספריות
מתחיל באות גדולה:

BAD := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
GOOD := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

אם חילוף בסגנון rc מפריע, או אם אתה צריך להוביל או נגרר
רווח לבן במשתני ה-make שלך, ואז תוכל לבטל את ההחלפה בסגנון rc על ידי הגדרה
המשתנה "makepp_simple_concatenation=1". אתה יכול לכבות אותו באופן גלובלי בפקודה
קו או כמשתנה סביבה. או על בסיס לכל קובץ על ידי הגדרת המשתנה ב
ה-makefile שלך. אתה צריך לעשות זאת ליד החלק העליון של ה-makefile, אחרת אתה עלול להיתקל
מצבים מצחיקים שבהם נעשה שימוש בהחלפה בסגנון rc עבור הערכות מסוימות ולא אחרות.
(כל הביטויים שהוערכו לפני המטלה ישתמשו בהחלפות בסגנון rc, והכל
ביטויים שהוערכו לאחר לא. מאז זמן ההערכה של ביטויים ב
makefiles הוא מסובך ולא תמיד ברור מסדר ההצהרות ב-
makefile, עדיף להגדיר "makepp_simple_concatenation" מוקדם ככל האפשר.) אתה יכול
אפילו הגדר אותו רק למטרה אחת:

יעד: makepp_simple_concatenation = 1
יַעַד:
&echo before_first$(LIST)after_last -o $(output)

מכיוון ש-"$[VARIABLE]" מוערך מוקדם יותר מ-"$(VARIABLE)", שילוב השניים ב- rc-
החלפה לא תיתן את התוצאה שאתה עשוי לצפות, אלא אם תעטוף אותה במפורש
רשימה:

א = אב
N = 1 2
BAD := $(A)$[N]
טוב := $(A)$( $[N])

השורות האחרונות נקראות בתור

BAD := $(A)1 2 # a1 b1 2
GOOD := $(A)$( 1 2) # a1 a2 b1 b2

החלפה הפניות

להפניה להחלפה יש את הצורה "$(VAR:A=B)", כאשר A הוא תבנית להתאים ו-B הוא
תבנית להחלפה. הפניות להחלפה הן קיצור של
פונקציית "patsubst". לדוגמה:

source_files = ac bc cc 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
החלפה (על ידי הגדרת "makepp_simple_concatenation=1") ולאחר מכן השתמש בתחביר כמו זה:

null =
T = -o $(null)

או, עם הערכה ריקה:

T = -o $()

כאשר אתה עושה זאת, המשתנה "T" מכיל "-o" ואחריו רווח.

סוג זה של טכניקה לטיפול ברווח לבן אינו מומלץ. אם אתה צריך משתנים
ב-makefile שלך ​​כדי להכיל רווחים, עליך לחשוב ברצינות על מה שאתה עושה.
אם אתה צריך לטפל ברווחים, זה בדרך כלל הרבה יותר טוב להכניס קוד Perl לתוך שלך
makefile לטפל בו (באמצעות ההצהרות "perl_begin" או "תת"), או לטפל בו
בהצהרות מעטפת בפעולות של כללים.

מקרים אלה מופיעים בדרך כלל כאשר אנשים מנסים להשתמש באותם כללים עבור שונים
ארכיטקטורות שאינן משתמשות בתחביר פקודות Unix טיפוסי. למשל, לפעמים רואים
דברים כמו זה ב-makefiles:

ifeq ($(ARCH),weirdarch)
O := /OUTPUT=
אחר
null :=
O := -o $(null)
ח

%.o : %.c
$(COMPILER) $(input) $(O)$(output)

אתה יכול לעשות את זה עם makepp אם אתה באמת רוצה, אבל אתה כנראה תגלה שזה שלך
makefiles קריאים יותר במידה ניכרת אם יש לך משתנה פחות מסובך
החלפה, למשל,

ifeq ($(ARCH),weirdarch)
%.o : %.c
$(WEIRD_COMPILER) $(קלט) /OUTPUT=$(פלט)
אחר
%.o : %.c
$(CC) -c $(input) -o $(output)
ח

רווח לבן לעולם אינו מותר בשמות משתנים, רק בערכים שלהם. זה שונה
מכמה יישומים.

מכני עם סלילה אוטומטית משתנים
משתנים אוטומטיים הם משתנים המניחים ערכים שונים בהתאם לאיזה כלל
הם מוערכים ב. Makepp תומך ברוב המשתנים האוטומטיים אחרים
גרסאות של לעשות שימוש. בנוסף, יש לו שמות פחות קריפטיים וארוכים לרובם
שאתה יכול להשתמש בו במקום. (עבור קבצים מדור קודם שבמקרה מגדירים מחדש את השמות האלה, ה
ההגדרה ב-makefile עוקפת את משמעות ברירת המחדל. למשל, אם אתה אומר
"target = abc" בקובץ ה-makefile שלך, ואז "$(target)" תמיד יתרחב ל-"abc", ולא
יותר להיות שווה ערך ל$@.)

להלן רשימה מלאה של כל המשתנים האוטומטיים שתומך בהם makepp:

תפוקה
יעד
$@ היעד של הכלל הנוכחי. למעשה, מאז makepp תומך במספר יעדים עבור
כל כלל, זה ה ראשון יַעַד. למשל, בכלל הבא

y.tab.c y.tab.h : parser.y
$(YACC) -o $(פלט) $(YFLAGS) $(קלט)

"$(פלט)" יכיל את הערך y.tab.c. מאז משתני קסם אלה הם למעשה
פונקציות, אתה יכול גם להעביר אינדקס כארגומנט. זה נחשב מ-1 או אחורה
מ - 1. אז "$(פלט 2)" או "$(פלט -1)" יכילו את הערך y.tab.h.

בעוד שלכל שלוש הצורות של משתנה זה יש ערך זהה, יש הבדל ב
פרשנות לחוקי ריבוי מטרות. אם אתה משתמש בשם החשוף בסגנון הישן $@,
makepp יפרש את זה כמערכת חוקים בסגנון ישן, ולא כחוק מודרני
מייצר את כל המטרות הללו במכה אחת:

ab: # באמת: כלל אחד כל אחד עבור a ו-b
גע ב-$@

cd: # שגיאה: mpp מתלונן שזה לא נבנה את d
גע ב-$(פלט)

פלטים
מטרות
כל המטרות של הכלל הנוכחי. זהה ל-"$(target)" אלא אם כן יש יותר מאחד
יַעַד. בדוגמה שלמעלה, "$(פלטים)" יהיה y.tab.c y.tab.h. אתה יכול לעבור א
רשימת אינדקס, אז "$(פלטים 2 1)" יהיה y.tab.h y.tab.c.

התלות
קלט
$< התלות המפורשת הראשונה של הכלל. למשל, בכלל זה

%.o : %.c
$(CC) $(CFLAGS) -c $(קלט) -o $(פלט)

"$(קלט)" יהיה השם של .c קובץ, בלי קשר למה .h קבצים makepp
מגלה. אם אתה מציין יותר מתלות אחת, אתה יכול לקבל אותם על ידי העברת
index: "$(קלט $(INDEX))" היא התלות של INDEX.

תלות
תשומות
$^ כל התלות המפורשת של היעד, לא כולל .h קבצים שהתגלו על ידי
makepp_scanning for include.

למשל, בכלל

myprog.o : *.o
$(CC) $(CFLAGS) $(כניסות) -o $(פלט)

"$(כניסות)" יהיו כל קבצי ה-.o בספריה. אתה יכול לבחור רק את אלה שאתה
רוצה על ידי העברת רשימת אינדקס. אם אתה מציין במפורש סוגים שונים של קבצים,
אתה יכול לבחור אותם כמו ב"$(כניסות 2 3 4)" (אבל עם תו כללי זה לא מדי
מַבְטִיחַ).

מיון_תלות
ממוינים_כניסות
$+ כל התלות של היעד, בסדר ממוין, כשהכפילויות הוסרו.
שווה ערך ל-"$(מיין $(תשומות))".

תלויות_שינוי
שינו_כניסות
$? התלות של היעד שהשתנו. זה כולל רק מפורש
תלות (כלומר, אלה שאתה מפרט בקובץ makefile), שלא התגלו במרומז
תלות מסריקה (כגון קבצי .h).

זה משמש בדרך כלל בפקודות כמו אלה:

libmine.a : $(מודולים) : build_check ignore_action
$(AR) ru $@ $?

כלומר, ar נאמר להחליף רק את המודולים שהשתנו. (שימו לב ל
כלל בדיקת הבנייה "ignore_action". אם לא תציין זאת, makepp יאלץ את
פעולה שתתבצע בכל פעם שהיא משתנה. אם לא השתנו תלות, ה
מחרוזת הפעולה תהיה "ar ru libmine.a" שהיא כנראה שונה ממה שהייתה
בפעם האחרונה שהרצת את זה, אז בלי "ignore_action" makepp יבצע את זה. בזה
במקרה, זה לא מזיק, אבל עם פקודות אחרות, זה יכול להיות בעיה. לִרְאוֹת
makepp_build_check לקבלת פרטים על "ignore_action".)

בניית ארכיונים כזו היא לא רעיון טוב כי זה יפחית את הבנייה שלך
אָמִין. הבעיה עם זה היא שאם אתה בונה את הארכיון, אז הסר אחד מהם
המודולים מרשימת המודולים, המודולים עדיין יהיו בארכיון ו
makepp

גזע
$* הגזע בכלל דפוס (כלומר, לא משנה מה ה-'%' תואם). לחילופין, אם זה
אינו כלל דפוס, מחזיר את שם הקובץ ללא הסיומת (כלומר, זה
שווה ערך ל-"$(basename $(input))".

זה בעיקר בשביל תאימות לאחור. לדוגמה, בגרסאות ישנות של make the
הדרך היחידה לומר לו איך להרכיב כל .c קובץ לתוך המתאים .o הקובץ היה כמו
זֶה:

.שיתוף:
$(CC) $(CFLAGS) -c $*.c -o $*.o

זו דרך עלובה לכתוב את הכלל. הרבה יותר ברור להשתמש בסגנון של GNU
כללי דפוס, כמו זה:

%.o : %.c
$(CC) $(CFLAGS) -c $(קלט) -o $(פלט)

foreach
שם הקובץ הנוכחי מסעיף "foreach". לעתים רחוקות נעשה שימוש בסעיפים של "foreach",
אבל הם הסוג הכללי ביותר של כלל דפוסים ש-makepp תומך בו. ל
דוגמא,

#
# בנה קבצי .c עם סוג של מעבד קדם מיוחד:
#
%.c : %.k
$(קדם מעבד) $(קלט) > $(פלט)

#
# הידור קבצי .c לקבצי .o:
#
%.o : %.c
$(CC) $(CFLAGS) -c $(קלט) -o $(פלט)

#
# דגלי הידור חלופיים מיוחדים עבור קבצי .c שנגזרו
# מקבצי ‎.k:
#
$(foreach:%k=%.o) : $(foreach:%k=%.c) :foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(קלט) -o $(פלט)

ראה את התיעוד על הסעיף הקדמי בכללים לפרטים נוספים ודוגמאות.

$/ זהו בעצם קבוע, או "/", או ב-Windows מקורי "\". אתה צריך את זה, אם
אתה רוצה להפעיל תוכנית בצורה ניידת, למשל אחת שבנית בספרייה הנוכחית:

פלט שלי:
.$/myprog >$(פלט)

עבור שמות קבצים שהועברו כארגומנטים זה לא כל כך הכרחי מכיוון ש-Windows יכול להתמודד עם Unix
תחביר שם.

אפשרות משתנים
אתה יכול להגדיר אותם בכל הדרכים שהוסבר לעיל (למעט אם צוין אחרת) כדי לשנות
ההתנהגות של מייקל. כברירת מחדל, כולם לא מוגדרים.

MAKEPP_DEBUG
אם אתה מייצא את זה עם ערך אמיתי לפני שאתה קורא ל-makepp, אתה מקבל יותר ניפוי באגים
מידע. זהו "RULE_SOURCE" של קבצים שנבנו בזמן שזה בתוקף תחת
makeppinfo, mppi ופרטים על הרחבת משתנים והתאמת כללים תחת
makepplog, mppl. זה גם יראה לך אם למייקאפ נגמר הזיכרון או נתקע,
כי זה מרחיב בלי סוף את אותם משתנים:

A = $A # הערכה נדחית, צריך :=
B = $C
C = $B

MAKEPP_LN_CP
ראה את ההערה תחת &ln.

makepp_percent_subdirs
הגדר את זה לערך אמיתי כלשהו (כמו 1) כדי שיהיה "%" בהתאמה של יעדים או תלות
על פני יותר ממדריך אחד.

makepp_require_phony
הגדר את זה לערך אמיתי כלשהו (כמו 1) כדי למנוע זיוף מרומז (כלומר אם כלל
מצליח בלי לייצר את המטרה שלו). משתנה זה צריך להיות נכון כברירת מחדל, ל
למנוע שרשראות תלות שבירות, אבל זה ישבור את התאימות לאחור עם
קבצים מרושלים.

makepp_signature_C_flat
זוהי אפשרות לחתימה C. הגדר את זה לערך אמיתי כלשהו (כמו 1) כדי להתייחס אליו
מקורות כשטחים, כלומר כל השורות החדשות (למעט הצהרות קדם-מעבד) הן
מתעלמים מההוראות כמו רווח לבן ו-"#line".

makepp_simple_concatenation
הגדר את זה לערך אמיתי כלשהו (כמו 1) כדי למנוע "החלפה בסגנון rc".

פרל
אתה יכול להגדיר את זה לפרל המדויק שבו אתה משתמש כדי להפעיל את הסקריפטים ב-makepp
חבילה, ולייצא אותה. זה יכול לעזור להפעיל סקריפטים משנה עם אותו perl. זה
שימושי בעיקר עבור חבילת הבדיקה, ההתקנה ובנייה רקורסיבית.

VPATH
הגדרת משתנה זה לערך כלשהו קורא באופן מרומז ל-"vpath % value".

מוגדר מראש משתנים
Makepp מגדיר מראש כמה משתנים, אותם אתה יכול לעקוף:

AR ברירת מחדל: "אר".

ARFLAGS
ברירת מחדל: "rv".

AS ברירת מחדל: "כפי ש".

CC ברירת מחדל: הראשון שנמצא בין "gcc", "egcc", "pgcc", "c89" או "cc", או ב-Windows
בנוסף "cl" או "bcc32".

CFLAGS
ברירת מחדל: אם "$(CC)" הוא מהדר GNU "-g -Wall", אם זה אחד משני ה-Windows
מהדרים כלום, אחרת "-g".

CURDIR
הספרייה שבה נמצא ה-Makefile הנוכחי.

CXX ברירת מחדל: הראשון שנמצא בין "g++", "c++", "pg++", "cxx", "C""C" או "aCC", או ב
Windows בנוסף "cl" או "bcc32".

CXXFLAGS
ברירת מחדל: אם "$(CXX)" הוא מהדר GNU "-g -Wall", אם זה אחד משני ה-Windows
מהדרים כלום, אחרת "-g".

F77 ברירת מחדל: הראשון שנמצא בין "f77", "g77" או "fort77".

FC ברירת מחדל: "$(F77)".

LD ברירת מחדל: "ld".

LEX ברירת מחדל: הראשון שנמצא בין "לקס" או "פלקס".

LIBTOOL
ברירת מחדל: "libtool".

MAKE
למשתנה זה שני ערכים שונים, תלוי בנוכחותו או לא
"--מסורתי-רקורסיבי-עשה". Makepp מזהה מתי נעשה שימוש במשתנה זה ו
מכבה כמה תכונות, עוד לפני שהרקורסיה מתרחשת בפועל. זה יכול להיות
לא רצוי בזמן שאתה מחסל אותו בהדרגה, אז תחילה המר את השיחות ל-a
makepp ספציפי "$((MAKE))", אשר לא יכבה תכונות. אתה לא צריך להגדיר את זה
כי זה שובר את עבודת הרקורסיה החכמה שלנו.

MAKECMDGOALS
משתנה זה מוגדר אך אינו בשימוש על ידי makepp. אתה יכול לבקש ממנו לעשות משהו רק אם
התבקשה מטרה מסוימת.

ברירת מחדל: כל מיקוד מפורש שסיפק המשתמש (או קריאה רקורסיבית).
ריק בעת בניית יעד ברירת מחדל באופן מרומז.

ifneq $(מסנן יעד מיוחד, $(MAKECMDGOALS))
# special-target הוא אחד מהיעדים המפורשים הנוכחיים
else ifeq $(MAKECMDGOALS)
# ללא יעדים מפורשים
ח

MAKEFLAGS (מיוצאים)
האפשרויות הסטנדרטיות שאיתן נקרא makepp. אלה שיש להם אות אחת
הטופס משולבים בהתחלה ללא "-" מוביל (השמים יודעים למה gmake בחרה
כדי לשחרר את ה-"-").

MAKEINFO
ברירת מחדל: "makeinfo".

MAKEPPFLAGS (מיוצאים)
זה מוגדר לאותו ערך כמו MAKEFLAGS, אבל רק אם משתנה זה קיים ב
הסביבה של makepp.

_MAKEPPFLAGS (מיוצא)
האפשרויות הספציפיות של makepp הדרושות לתאימות POSIX/gmake, איתה makepp
נקרא. אלה נמצאים במשתנה נפרד כך שקובץ makefile מדור קודם לא יכול להישבר
תאימות על ידי ביטול ההגדרה של MAKEFLAGS. זה מוגדר רק עם
"--מסורתי-רקורסיבי-עשה".

MAKEPP_VERSION
הגרסה של makepp שאתה פועל איתה. אם זו גרסת בטא, יהיה לה א
מקף ואחריו YYMMDD ועוד כמה נתונים פנימיים. אתה יכול להשתמש בזה עבור "ifdef"
להסתיר מבנים ספציפיים של makepp מיצרנים אחרים.

ברירת מחדל: אותו ערך שמוצג על ידי "makepp --version"

PWD כינוי ל"CURDIR".

RM ברירת מחדל: "rm -f". זה מיועד ל-Makefiles מדור קודם. לחדשים רצוי להשתמש
הפקודה המובנית &rm ישירות. אם אתה רוצה לכתוב כלל נקי מזויף, תסתכל על
הפקודה "makeppclean -r" במקום זאת.

שורש
הנתיב היחסי לשורש מערכת ה-build שלך, כלומר הספרייה יותר למעלה
שיש לך "RootMakeppfile(.mk)". אם אין לך אחד, המשתנה הזה הוא
ריק.

SHELL
משתנה זה מכבד רק אם אתה "ייצא" אותו. במקרה כזה זה המעטפת
המשמש לביצוע פעולות לא מובנות עם אופי מיוחד כלשהו (רגיל
אלה שמתבצעים ישירות). ב-Windows Strawberry או ActiveState Perl, אם יש לך
מעטפת דמוית יוניקס, עליך להגדיר את משתנה ה-SHELL שלך לערך המסתיים ב-"sh"
או "sh.exe" לפני קורא makepp.

ברירת מחדל: הראשון שנמצא בין "/usr/xpg4/bin/sh" (למשל Solaris) או "/sbin/xpg4/sh"
(למשל Reliant Unix) או "/ Bin / sh".

YACC
ברירת מחדל: הראשון נמצא בין "ביסון -y" או "yacc".

משתנים ו פרל
ערכי משתנים מאוחסנים כסקלרים רגילים של Perl, כך שתוכל לגשת אליהם ישירות
קוד Perl אם אתה צריך לעשות איתם מניפולציות מסובכות; ראה makepp_extending
לקבלת פרטים.

גישה למשתנים גלובליים מ-Perl מושגת על ידי הקדמת "Mpp::global"
חֲבִילָה. למעשה כל משתנה, שעדיין לא קיים בקובץ ה-makefile הנוכחי, ואשר אתה
assign to בחבילה זו תהיה מעתה גלובלית, כאילו זה עתה הנפקת את
הצהרה "גלובלית" לכך.

אולם גישה ישירה זו מועדת לשגיאות! ייתכן שהמשתמש דרס את המשתנים הללו
בשורת הפקודה או דרך הסביבה. איזה makefile אחר נטען לפני זה
ייתכן שאחד מהם הפך את המשתנה לגלובלי או ליעד ספציפי. במקרים אלו לא תעשה זאת
למצוא את הערך של המשתנה, או בעת הקצאתו, עלול לקחת ממנו את המאפיין שלו
(שווה ערך לשינוי "עקיפה", למעט פרטי יעד).

עם גישה ישירה אתה גם עוקף את הרחבת המשתנים הללו, אם הם מסוג
"=" או ";=". משתנים מיוחדים כמו "$(CC)" מתחילים כפונקציות, עד שהם כן
שהוקצה ל. אז במקרים רבים לא תראה את הערך שלהם.

מסיבות אלו עדיף לתת ל-makepp לקבוע את הערך הנכון. אתה יכול להשתמש ב
וריאנט "makeperl", שבו המשתנה הוערך לפני שהקוד Perl מקבל
פירשתי:

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

אם אתה צריך משתנה בלוקים של makefile perl זה מושג באמצעות המשתנה Perl
$makefile באופן הבא:

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

פונקציות תמיד מקבלות את האובייקט makefile מועבר בתור הארגומנט השני $_[1]:

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

פקודות אמורות להיקרא בתוך פעולת כלל, היכן שהאובייקט makefile נמצא
נגיש דרך "$Mpp::Subs::rule->{MAKEFILE}":

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

השתמש ב-makepp_variables באינטרנט באמצעות שירותי onworks.net