makepp_rules - מקוון בענן

תָכְנִית:

שֵׁם

makepp_rules -- איך לומר ל-makepp לבנות משהו

תיאור

?: &,
-,
@, B: :build_cache,
:build_check, D: :לְשַׁגֵר, E: :env, I: "התעלם_שגיאה",
:לִכלוֹל, L: :ההזדמנות האחרונה, M: מייפרל, N: "נאקו", P: :מנתח,
"פרל", S: :חֲתִימָה

כלל הוא מה שאומר ל-makepp איך לבנות קובץ או מחלקה של קבצים. Makepp תומך ב
אותו תחביר כללים כמו יישומים אחרים של make, בתוספת כמה תוספות משלו.

לכלל יש את הפורמט הכללי

target_expression : dependency_expression [ : ארגומנטים אופציונליים]
פעולות

רשימת היעדים עשויה שלא להכיל משתנים אוטומטיים (למעט "$(foreach)"). ה
רשימת התלות עשויה להכיל רק משתנים אוטומטיים המתייחסים ליעד (כלומר,
"$(פלט)", "$(פלטים)", או המילים הנרדפות שלהם). הפעולה עשויה להכיל כל אוטומטי
משתנים.

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

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

· יש להזין את שורת הפעולה הראשונה יותר מהשורה המכילה את המטרה.

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

· שורה ריקה או שורת הערה עם התו "#" בשוליים הימניים מסיימת את
כלל, אלא אם השורה הלא ריקה הבאה מוזחת יותר מ-8 רווחים (או יותר מאחד
לשונית).

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

יש כמה פריטי פעולה מיוחדים:

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

זה מאפשר לקרוא ביעילות לפקודה מובנית, מסופקת ב-makefile או חיצונית.
הקידומת "&" נבחרה מכיוון שהיא מעוררת הפונקציות ב- Perl, ומשום
בהתחלה זה לא חוקי ב-Shell.

$(ROOT)/include/%.h: %.h
&ln $(קלט) $(פלט)

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

%.o: %.cxx
noecho $(LIBTOOL) --mode=compile $(CC) -c $(input)

זה אומר שכאשר הפקודה libtool מבוצעת, היא לא מודפסת. (Libtool
עצמו בדרך כלל מדפיס את הפקודה ששונתה שהיא מבצעת, אז זה מיותר
להדפיס אותו פעמיים.)

התעלם_שגיאה
- בדרך כלל, אם פקודת המעטפת מחזירה סטטוס שאינו אפס, אז makepp מבטל בגלל
הפקודה נכשלה. עם זאת, תוכניות מסוימות הגדירו באופן שגוי את המצב ביציאה, או
ייתכן שיש שגיאה שבאמת אינה קטלנית ואסור לבטל את כולו
הַהדָרָה. אתה יכול לגרום ל-makepp להתעלם מסטטוס ההחזרה על ידי ציון
"ignore_error" בתור המילה הראשונה של שורת הפקודה (או "-" בתור התו הראשון).
לדוגמה,

$(הפצה מזויפת):
ignore_error rm -r my_program-$(VERSION) # היפטר מהזבל הקודם.
&mkdir my_program-$(VERSION)
&cp $(FILES) my_program-$(VERSION)
tar cf my_program-$(VERSION).tar my_program-$(VERSION)

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

פרל
makeperl
זה בעצם זהה להצהרת perl, אבל זה מבוצע בכל פעם כאשר
הפעלת הכלל, לא בעת קריאת ה-makefile. הגרסה הראשונה היא פרל רגיל
קוד, בעוד שהוריאנט השני מעביר תחילה את ההצהרה דרך המשתנה Make-style
הַרחָבָה.

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

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

$(גרסה מזויפת):
noecho perl {{ # $(target) & $(VERSION) מ- Perl:
print "זהו ".f_target()." $VERSION\n";
}}
echo אתה יכול לערבב את זה עם פקודות Shell
-makeperl { הדפס "זהו $(מטרה) $(גרסה)\n" }

ישנם מספר סוגים שונים של כללים, שלכל אחד מהם מטרות שונות.

מְפוֹרָשׁ חוקי
target1 target2: dependency1 dependency2 ...
פעולות שיש לבצע

תחביר זה מציין את זה על מנת לעשות או TargetXNX or TargetXNX, כל הקבצים
תלות 1, תלות 2וכו', בטח כבר נעשו. אז הפעולות הנתונות הן
הוצא להורג על ידי הפגז כדי ליצור את המטרות.

הכלל המפורש הראשון בקובץ הוא יעד ברירת המחדל, והוא נעשה אם לא תציין
יעדים כלשהם בשורת הפקודה.

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

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

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

· פעולת הכלל מזכירה את המשתנה האוטומטי $@. (המילים הנרדפות "$(פלט)" או
"$(target)" לא מפעיל התנהגות זו.)

· פעולת הכלל אינה מזכירה את המשתנה האוטומטי "$(פלטים)" (או המילה הנרדפת שלו
"$(יעדים)").

· זה לא כלל דפוס, ואין פסקת foreach.

לדוגמה,

כל התקנות בדיקה:
עבור subdir ב-$(SUBDIRS); עשה cd $$subdir && $(MAKE) $@; תקליטור..; בוצע

הוא ניב נפוץ ב-makefiles, ו-makepp תומך בו. (שים לב שאסור לך להשתמש
מותג רקורסיבי בכל קובץ makefile חדש שאתה כותב - השתמש במשפט "load_makefile", או
טעינת קובץ makefile במקום זאת.)

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

א ב ג ד:
do_something כדי לבנות $@ > $@

ב-makepp, סביר להניח שתרצה לכתוב את זה כך:

$(foreach): : foreach abcd
do_something כדי לבנות $(פלט) > $(פלט)

מזויף מטרות

A מְזוּיָף יעד הוא יעד שלעולם לא יתקיים בפועל במערכת הקבצים; זה רק א
דרך לגרום ל-makepp לבנות כמה מטרות ואולי לבצע כמה פקודות נוספות.

יעד מזויף טיפוסי הוא "הכל", שבדרך כלל משמש כדי לגרום לכל מה שיכול להיות
נבנה כדי להיבנות, כך:

הכל: prog1 prog2 subdir/prog3 subdir2/libmine.a
@&echo "הכל נעשה!"

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

כדי למנוע מ-makepp לצפות לקובץ ./את כל כדי לצאת, אתה צריך להגיד לו שזה א
מטרה מזויפת. פשוט שים שורה כמו הבאה ב-makefile שלך ​​(זה לא משנה
איפה):

.PHONY: הכל

חלופה מקבילה שלעיתים נוחה יותר היא להשתמש ב-"$(phony )"
פונקציה, כך:

$(phony all): prog1 prog2 subdir/prog3 subdir2/libmine.a

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

# Makefile ברמה העליונה:
# הרבה חוקים ודברים כאן
#....
$(phony clean): 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 תומך בכל תווי הפגז הרגילים ("*", "?" ו-"[]"). יש לו גם א
תו כללי "**" שמתאים לכל מספר של ספריות מתערבות. (הרעיון הזה נגנב
מ-zsh.) לדוגמה, "**/*.c" מתאים לכל ה- .c קבצים בכל עץ המקור.
"objects/**/*.o" תואם את כל .o קבצים הכלולים בכל מקום בספריית המשנה אובייקטים
או כל אחת מספריות המשנה שלה או כל אחת מספריות המשנה שלהן. התו הכללי "**" לא יעשה זאת
עקוב אחר קישורים רכים לספריות בכל רמה. זה גם לעולם לא יחזיר מטרות מזויפות.

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

הקביעה הראשונית הייתה שזה בטוח. זה במובן שזה עובד אם
הקבצים כבר קיימים, או שצריך לבנות קודם. עם זאת, זה לא בטוח במובן
שזה עדיין יתאים לקבצים שנבנו על ידי makepp, אבל אין להם עוד כלל (למשל
הסרת את .c קובץ, אבל ה .o הקובץ עדיין קיים.) כדי למנוע זאת, השתמש ב-
אפשרות "--rm-stale".

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

%.o: %.c
$(CC) -c $(input) -o $(output)

זה אומר שניתן להמיר כל קובץ בספרייה הנוכחית שתואם ל-"*.c".
קובץ .o המתאים באמצעות הפקודה הנתונה.

שים לב שיכולות להיות מסופקות מספר תלות דפוס. לדוגמה, אם שלך xyz.o פילה
תלוי במתאים xyz.cpp קובץ, וגם על קובץ שנקרא moc_xyz.cflags אשר
מכיל את אפשרויות המהדר, זה יכול להתבטא ב:

%.o: %.cpp %.cflags
$(CXX) `cat $(stem).cflags` -c $(inputs) -o $(output)

ייתכן שיש לך גם מספר יעדי דפוס. לדוגמה,

%.tab.h %.tab.c : %.y
yacc -d $(קלט)
&mv y.tab.h $(סטם).tab.h
&mv y.tab.c $(stem).tab.c

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

makepp_percent_subdirs := 1

לפני כלל הדפוס הראשון ב-makefile שלך ​​או בשורת הפקודה למשל.

יש הבדל ברור בין "%" לבין התו הכללי "*", אם כי שניהם תואמים לכל
string: התו הכללי מחזיר רשימה של קבצים שנמצאים בשימוש מלא באותה נקודה. לכן
זה תלוי בכולם .o קבצים שניתן לבנות כאן:

פרוג: *.o
$(LD) $(LDFLAGS) $(כניסות) -o $(פלט)

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

סטטי דפוס כללי
כלל דפוס סטטי הוא כלל דפוס המוחל רק על קבוצה מוגבלת של קבצים:

$(SPECIAL_MODULES).o : %.o : %.cpp
$(CXX) -c $(קלט) -o $(פלט)

זה אומר שכלל הדפוס חל רק על הקבצים ב-"$(SPECIAL_MODULES).o".

זה בעיקר בשביל תאימות עם GNU make; כללים מקדימים (ראה להלן) הם עוד
דרך עוצמתית לעשות את אותו הדבר.

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

target_expression: dependency_expression: עבור רשימת קבצים
פעולות

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

# הנה הכלל שחל על הכל:
%.o : %.c
$(CC) $(CFLAGS) -c $(קלט) -o $(פלט)

%.o : %.c : foreach $(SPECIAL_MODULES)
$(CC) $(SPECIAL_CFLAGS) -c $(קלט) -o $(פלט)

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

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

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

שווה בדיוק ל:

$(patsubst %.c, %.o, $(foreach)) : $(foreach) : foreach *.c
$(CC) $(CFLAGS) -c $(קלט) -o $(פלט)

(למעשה, זה הומר בערך לזה פנימי.)

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

# כלל עבור קבצי ‎.c רגילים:
%.o : %.c
$(CC) $(CFLAGS) -c $(קלט) -o $(פלט)

# כלל ליצור קבצי .c מקבצי .k:
%.c : %.k
$(קדם מעבד) $(קלט) > $(פלט)

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

(זה משתמש בתחביר ההתייחסות להחלפה מעט יותר תמציתית במקום קורא
"patsubst" במפורש.)

שים לב שאם כל מה שאתה רוצה לעשות הוא לשנות את הערך של משתנה ("CFLAGS" בזה
במקרה) לפעמים נוח יותר להשתמש במשתנים ספציפיים ליעד.

מוֹרֶשֶׁת סִיוֹמֶת כללי
עבור תאימות לאחור, makepp תומך בכללי הסיומת בסגנון הישן.

.suffix1.suffix2:
פעולות

שווה

%.suffix2: %.suffix1
פעולות

אבל הרבה יותר קשה לזכור. (איזו סיומת קודם?) בדרך כלל יופיע כלל
ב-makefile מדור קודם כמו זה:

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

שמקביל בדיוק ל

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

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

· זוהי שגיאה שיש כללים מפורשים סותרים לבניית קובץ.

· חוקי דפוס וכללים מקדימים עם תווים כלליים לעולם אינם עוקפים כללים מפורשים. לכן
ניתן להשתמש בכללים מפורשים כדי לציין חריגים עבור כללי דפוס. (שים לב שפשוט
שימוש בסעיף ":foreach" אינו הופך משהו לכלל דפוס. חייב להיות בו א
תו כללי (כמו "*" או "?") כחלק משם הקובץ בסעיף ":foreach". אם זה
רק רשימה מפורשת של קבצים, היא מטופלת ככלל מפורש עבור כל אחד מהם
קבצים.)

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

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

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

ויכול להיות לך קובץ makefile באחת מתיקיות המשנה שאומר:

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

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

%.s: %.c
$(CC) -s $(input) -o $(output)

%.o: %.s
$(AS) $(input) -o $(output)

%.o: %.c
$(CC) -c $(input) -o $(output)

אם אנחנו צריכים לבנות "xyz.o", נוכל לבנות את קובץ הביניים ".s" ואז
הפעל את זה דרך האסמבלר באמצעות שני הכללים הראשונים, או שנוכל ללכת ישירות ל-a
קובץ ".o" באמצעות הכלל האחרון. הכלל האחרון עדיף כי יש פחות
שלבים בשרשרת ההסקה (אחד במקום שניים).

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

%.o: %.c # כלל קומפילציה כללי.
פעולה

special_%.o: special_%.c # כלל מיוחד לקבצים עם a
פעולה שונה # קידומת "special_".

כלל אפשרויות
לפעמים יש צורך לספק אפשרויות נוספות כדי לשנות את האופן שבו makepp מבצע את
כְּלָל. אפשרויות אלו מצוינות כ-":optionname value", בשורה המכילה
התלות, או בשורה הבאה.

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

יעד: תלות
: חתימה target_newer
פעולות

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

:build_cache /path/to/build/cache
יעד: תלות
: build_cache /put/cache/files/over/there
פעולות

מציין את הנתיב למטמון בנייה שישמש עבור קבצים המיוצרים על ידי כלל זה. זֶה
עוקף את ההשפעה של המשפט "build_cache" או הפקודה "--build-cache".
אפשרות קו, אם בכלל, עבור כלל זה. ראה makepp_build_cache לפרטים על build
מטמונים.

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

: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" (במרכאות), ובמקרה זה
יעדים נחשבים לא מעודכנים אם הספרייה הראשונה מהנקודתיים מופרדת
הערך של PATH_VARIABLE שבו קיים שם הקובץ שונה מהמבנה האחרון.
זה יכול לשמש כדי להימנע מבנייה מחדש של היעדים כאשר PATH_VARIABLE משתנה ב-
דרך לא רלוונטית.

:לְשַׁגֵר הפקודה ...
סגור כל פעולת מעטפת (אך לא פעולות Perl וגם לא פקודות Perl) ב-"sh -c '...'"
ותקדימו אותו בפקודה, אך נניח שהמטרה אינה תלויה בפקודה.
זה שימושי אם ברצונך לשלוח פעולות למערכת תור עבודה, אך התוצאה היא
ההנחה היא שאינה תלויה בפרמטרים של תור, כמו גם אם התור
המערכת משמשת בכלל.

:לִכלוֹל file_or_pattern
הכלל משתנה בהתאם למהדר:

%.o : %.c
: כוללים %.d : חתימה C
gcc -MD -c ...

%.o : %.c
: include %.u : signature C # IBM משתמשת בסיומת אחרת
xlc -M -c ...

sub dependify { # הפוך את הפטפוט של מיקרוסופט לפורמט שימושי
s/\$/\$\$/g;
s/(הערה: כולל קובץ: *)?(.+?)\r?\n/$1 ? "'$2' " : "'".f_output()."': "/e;
}
%.o : %.c
: כוללים %.d : חתימה C
cl -showIncludes -c ... >$(stem).d
&sed &dependify -o +<$(stem).d

כמה מהדרים (icc של אינטל בדיוק כמו gcc למעלה, או xlc של יבמ) יכולים לייצר תלות
קבצים תוך כדי תנועה. כלומר, בזמן שהם קומפילים, הם כותבים makefile ש-makepp יכול
לִכלוֹל. היתרון על הסורק של makepp הוא שהוא מובטח ב-100%
נכון, איפה שרק נתקרב.

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

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

יש מלכוד כאשר אתה מסיר משפט "#include". ו הקובץ המתאים:
זה עדיין יוזכר בקובץ התלות מהפעם האחרונה, כשהיא הייתה
נָחוּץ. במקרה כזה עליך לערוך את קובץ התלות כדי להסיר את התלות
שכבר לא ניתן למימוש.

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

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

:ההזדמנות האחרונה
אפשר כלל פתוח, כגון

%.foo foo%.bar: :last_chance
&echo $@ -o $@
&cp $(פלטים)

מכיוון שכלל כזה יכול ליצור מספר אינסופי של מטרות,
יעד של כלל זה לא יתאים לפונקציה $(תו כללי) או כלל דפוס אלא אם כן
משהו אחר כבר ביצע את הכלל על ידי הפניה ספציפית למטרה.
יתר על כן, אם צוין "--rm-stale", אז מטרה שנשארה מקודמתה
makepp run ייראה מעופש אם הדרך היחידה לבנות אותו היא באמצעות כלל last_chance
שעדיין לא בוצע עבור היעד, וזו התנהגות רצויה מכיוון
ה-build ייכשל באופן עקבי יותר כאשר הוא מסתמך בטעות על תווים כלליים לחיפוש
להתאים יעדים מריצה קודמת.

האפשרות ":last_chance" נועדה להסב תשומת לב להתנהגות המיוחדת של ה-
כלל ביחס לתווים כלליים תואמים.

: מנתח מנתח
זה אומר ל-makepp כיצד לנתח את הפקודה לזיהוי (כלול) קבצים. בְּדֶרֶך כְּלַל,
makepp מנחש כיצד לעשות זאת על סמך המילים בפקודה עצמה (ראה
makepp_scanning לפרטים). עם זאת, אם makepp מנחש לא נכון, אולי כדאי
ציין במפורש את המנתח, כך:

%.o: %.abc
: מנתח c_compilation
פעולה כאן

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

מנתח ברירת המחדל תלוי בפקודה. אם לא תציין אפשרות ":parser",
לאחר מכן נבדקת המילה הראשונה של כל פקודה. למשל לקומפילציה או קישור
הפקודה, makepp ישתמש במנתח "c_compilation"; או אם הפקודה נראית כמו
גרסה של GNU, "gcc_compilation". אם לא נמצא מנתח הוא משתמש במנתח "ללא". ל
פרטים נוספים על זה, או אם אתה רוצה לכתוב מנתח משלך או לשנות את ה-makepp
מנתחי ברירת מחדל, ראה makepp_scanning.

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

%.o: %.c: מנתח c-קומפילציה
@echo 'בניית $(פלט)'
@funny_cc...

זה גם יפרש את "הד" כקומפיילר ויסיק את הטיעון שלו 'בניין
mymodule.o' כתלות מרומזת. זה יוביל לתלונה שזה
לא יודע איך לבנות קובץ כזה. במקרה זה עדיף לך
"register_parser". שם אתה מוצא הסבר איך מנתח ניתן לתת גם בתור א
שם כיתה או כשם פונקציה.

:חֲתִימָה חתימה_שיטה
יעד: תלות
: חתימה md5
פעולות

זה אומר ל-makepp באיזה אלגוריתם להשתמש כדי לקבוע אם התלות השתנו.
ראה makepp_signatures לפרטים נוספים. שיטות חתימה הכלולות ב-
הפצת makepp הם "רגיל", "md5", "C" או "c_compilation_md5", וכן
"אובייקט_משותף". זה עוקף כל שיטת חתימה שצוינה עם ה-"-m" או
אפשרויות שורת הפקודה "--signature-method", או עם הצהרת "חתימה".

מיוחד תווים
Makepp יכול לתמוך בשמות קבצים שיש בהם תווים מיוחדים כמו נקודתיים או רווח.
נניח, למשל, אתה רוצה ליצור קובץ בשם "a:thing" מהקובץ "b:thing".
אתה לא יכול לכתוב את הכלל כך:

a:thing : b:thing # זוהי שגיאת תחביר
&cat $(קלט) -o $(פלט)

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

"a:thing" : "b:thing"
&cat $(קלט) -o $(פלט)

כעת הכלל חד משמעי.

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

a\:thing : 'b:thing'
&cat $(קלט) -o $(פלט)

נניח, למשל, ששם הקובץ שלך הוא "'"!;\$". עכשיו למה אתה רוצה שם קובץ כזה
אני לא יודע, אבל הנה כמה דרכים שאתה יכול לציין את זה ל-makepp (והקליפה):

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

שימו לב מתי makepp רצועות ציטוטים ומתי הקליפה עושה זאת. מייקאפ מסתכל
ציטוטים רק במקרים הבאים:

· במשפחת המבחנים "ifeq".

· לפני ואחרי נקודתיים הכלל

· בפקודה מובנית של makepp

· בפונקציה הנוגעת לקבצים

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

FILE = 'שם עם רווחים'
x := $(הדפס $(FILE)) # רק כדי לבדוק שהמרכאות עדיין שם
$(FILE): # מרכאות סביב קובץ בודד שהוסר על ידי makepp
&echo hello -o$(FILE) # מרכאות סביב קובץ בודד שהוסר על ידי makepp
echo there >>$(FILE) # מרכאות סביב קובץ בודד שהוסר על ידי Shell
'שם עם רווחים':
&echo hello -o'name with spaces'
echo there >>'$(output)' # מרכאות הופשטו למעלה, הוסף אותם שוב

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

$(כל מזויף):
@&echo זהו סימן דולר: $$
@for val in abcd; do echo $$val; בוצע

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

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

"שם קובץ עם רווחים":
echo "תוכן מיוחד" > "$@"

אם לא תציב את המירכאות סביב $@, המעטפת תראה את הפקודה

echo "תוכן מיוחד" > שם קובץ עם רווחים

שכותבת את המחרוזת "שם קובץ תוכן מיוחד עם רווחים" לקובץ שנקרא a.
זה כנראה לא מה שאתה רוצה.

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