makepp_command - מקוון בענן

תָכְנִית:

שֵׁם

makepp -- תחביר שורת הפקודה עבור makepp

תיאור

?: -?, A: -א,
--args-file,
--קובץ טיעונים,
--מניח-חדש,
--נניח ישן, B: -ב,
--build-cache,
---build-check,
--שיטת בדיקת בנייה, C: -ג,
-ג, D: --דחה-כלול,
--מַדרִיך,
--עשה-בנה,
--אל תבנה,
--אל תקרא,
--לעשות לקרוא,
--ריצה יבשה,
--dump-makefile,
--dump-makeppfile, E: ,
--עקיפות-סביבה,
--env-עקיפות, F: -ו,
-ו,
--קוֹבֶץ,
--חוקים סופיים בלבד,
---force-copy-from-bc,
--לסרוק מחדש, G: --פֶּתִי, H: -ח,
--עֶזרָה,
--היברידי,
--רקורסיה היברידית,
--היברידי-רקורסיבי-מייק, I: -אני,
--implicit-load-makeppfile-only,
--לִכלוֹל,
--include-dir,
--בארגז חול,
--בתוך ארגז חול, J: -י,
--מקומות תעסוקה,
--רק-להדפיס, K: -ק,
--תמשיך ללכת, L: --כללי הזדמנות אחרונה,
--טען-makefile,
--load-makeppfile,
--עֵץ,
--קובץ לוג,
--לוּלָאָה, M: -M,
--makefile,
$MAKEFLAGS,
$MAKEPP_CASE_SENSITIVE_FILENAMES,
--makeppfile,
$MAKEPPFLAGS,
--md5-bc,
--md5-check-bc, N: -נ,
--קובץ חדש,
--אין כללים מובנים,
--no-cache-scaninfos,
--לא-עומס-מרומז,
--ללא יומן,
--ללא-נתיב-ניתן להפעיל-תלות,
--no-path-exe-dep,
--no-populate-bc,
--no-print-directory,
--ללא קבצים מחודשים,
--לא אזהרה, O: -או,
--קובץ ישן,
--מחוץ לארגז החול,
--עקיפה-חתימה,
--שיטה-ביטול-חתימה, P: --populate-bc-only,
--פּרוֹפִיל, Q: --שֶׁקֶט, R: -ר,
-ר,
--סיור בשטח אויב,
--הסר-מעופש,
--הסר קבצים מיושנים,
--מאגר,
--rm-sttale,
--root-dir,
---root-directory, S: -ס,
--ארגז חול,
--ארגז חול-אזהרה,
--אזהרת ארגז חול,
--חֲתִימָה,
--שיטה-חתימה,
--שקט,
--תפסיק,
--עצור-אחרי-טעינה,
--עצור-לפני-בנייה,
--עצור במירוץ,
--עצור-מרוץ,
--symlink-in-rep-as-file,
--symlink-in-repository-as-file, T: --מָסוֹרתִי,
--מסורתי-רקורסיה,
--ייצור מסורתי-רקורסיבי, V: -V,
-ב,
--מִלוּלִי,
--גִרְסָה,
--ארגז חול וירטואלי, W: -W,
--מה אם

makepp [ אוֹפְּצִיָה ... ] [ VAR=ערך ] [ יעד ... ]

mpp [ אוֹפְּצִיָה ... ] [ VAR=ערך ] [ יעד ... ]

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

אתה יכול להקצות משתנים בשורת הפקודה אשר יעקוף כל הקצאה או
משתנה סביבה בכל Makefile שנטען, למשל,

makepp CFLAGS=-O2

אפשרויות תקפות הן רוב אפשרויות הייצור הסטנדרטיות, בתוספת כמה חדשות:

-A שם הקובץ
--args-file=שם הקובץ
--arguments-file=שם הקובץ
קרא את הקובץ ונתח אותו כאפשרות לציטוטים עם רווח לבן ו/או מופרד בשורה חדשה
אפשרויות.

-b בספרייה
--build-cache=בספרייה
מציין את הנתיב למטמון בנייה. ראה makepp_build_cache לפרטים. המבנה
המטמון חייב כבר להתקיים; ראה "כיצד לנהל מטמון בנייה" ב-makepp_build_cache עבור
איך לעשות את זה מלכתחילה. בניית מטמונים המוגדרים בשורת הפקודה עשויים להיות
עוקף על ידי משפט build_cache ב-makefile או משנה כלל :build_cache.
אם אתה עובד עם כמה מבנים שונים, זה עשוי להיות שימושי להגדיר את הסביבה
המשתנה "MAKEPPFLAGS" יכיל את "--buil""d-cache=/path/to/build/cache" כך שכל
מהבונים שלך ינצלו את מטמון הבנייה כברירת מחדל.

--build-check=שיטה
--build-check-method=שיטה
השם של שיטת בדיקת בנייה לשימוש כדי להחליט אם יש לבנות מחדש קבצים.
ערכים אפשריים הם "target_newer", "exact_match", ראה makepp_build_check עבור
מידע על שיטות בדיקת בנייה.

-C בספרייה
--directory=בספרייה
תקליטור לספרייה הנתונה לפני טעינת ה-makefile וניסיון לבנות את המטרות.
זה דומה לציון ספרייה עם "-F", פרט לכך ש-"-C" הבא,
אפשרויות "-f", "-F", "-I" ו-"-R" מתפרשות ביחס לספרייה החדשה,
ולא הישן.

-c
--root-dir
---root-directory
CD עד לספרייה המכילה קובץ RootMakepp.

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

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

לדוגמה,

% cc -g -DSPECIAL_DEBUG -c xc -o xo # אוסף מיוחד ביד
% makepp
cc -g -O2 -c xc -o xo # Makepp פשוט גברה על האוסף שלך כאן!
cc xo yo -o my_program # קישורים מחדש.
% cc -g -DSPECIAL_DEBUG -c xc -o xo # עשה זאת שוב.
% makepp --dont-build xo # אמור ל-makepp לא לבנות מחדש את xo גם אם הוא רוצה.
cc xo yo -o my_program # כעת הוא מתחבר מחדש ללא הידור מחדש.

אם אתה רוצה אפשרויות קומפילציה מיוחדות עבור מודול אחד בלבד, לעתים קרובות קל יותר לערוך
ה-makefile מאשר להדר ביד כמו בדוגמה זו; ראה "יעד ספציפי
assignments" ב-makepp_variables לדרך קלה לעשות זאת.

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

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

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

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

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

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

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

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

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

-F Makeppfile
--makeppfile=Makeppfile
טוען את ה-Makefile שצוין או, אם תציין ספריה, את קובץ Makefile שם,
במקום זה בספרייה הנוכחית -- כל יעד שצוין מימין ל
אפשרות זו מתפרשת ביחס לספרייה המכילה את ה-Makefile. בשביל ה
פרטים על תיק המדריך ו RootMakeppfile ראה את ההסבר הבא
אוֹפְּצִיָה.

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

makepp -F /your/source/dir/top

וזה יעבוד לא משנה מה המדריך הנוכחי שלך.

מכיוון שהאפשרות הזו לא משפיעה על הספרייה היחסית לה "-C",
האפשרויות "-f", "-F", "-I" ו-"-R" מצוינות, אתה יכול ליצור יעדים ביחס ל-
הספרייה הנוכחית כך:

makepp -F /foo/bar -C . המטרה שלי

-f קובץ Makefile
--קובץ=קובץ Makefile
--makefile=קובץ Makefile
טוען את ה-Makefile שצוין או, אם תציין ספריה, את קובץ Makefile שם,
במקום זה בספרייה הנוכחית. אם לא תציין את האפשרות "-f" או
האפשרות "-F", makepp מחפש תחילה קובץ בספרייה הנוכחית (או
הספרייה המצוינת על ידי האפשרות "-C" הכי ימנית, אם בכלל) נקראת, אז
RootMakeppfile.mk, Makeppfile, לאחר מכן Makeppfile.mk, לאחר מכן קובץ מיידי, לאחר מכן קובץ Makefile.
ניתן לציין אפשרויות "-F" ו-"-f" מרובות.

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

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

---force-copy-from-bc
בעת שימוש ב-build caches, תמיד העתק קבצים פנימה והחוצה של המטמון, גם אם המקור
והמטרה נמצאים באותה מערכת קבצים. זה שימושי בעיקר לבדיקה (אימולציה)
המקרה שבו הם לא.

--סרוק מחדש בכוח
אל תשתמש בתוצאות סורק מאוחסנות מהרצות קודמות.

--פֶּתִי
האמינו שהכללים יוצרים את מה שהם מצהירים, ולא בודקים. זה
מהיר יותר, אבל לא תופס באגים בכללים.

-?
-h
- עזרה
הדפס סיכום קצר של האפשרויות.

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

אם תשתמשו באפשרות זו, תקבלו קבצי יומן בכל ספרייה לאחר החזרה
התרחשו ב. כדי להיפטר מהם בלבד השתמש ב-"makeppclean --logs --recurse" או "mppc
-lr".

-I בספרייה
--include=בספרייה
--include-dir=בספרייה
חפש בספרייה הנתונה עבור קבצי makefile הכלולים.

--implicit-load-makeppfile-only
אם טעינה מרומזת של makefile מופעלת, אז טען אוטומטית רק קובץ
נקרא RootMakeppfile, RootMakeppfile.mk, Makeppfile, או Makeppfile.mk, ו לֹא
קובץ מיידי or קובץ Makefile. זה שימושי אם ל-makepp יש תלות שנוצרות על ידי
טעם אחר של תוצרת, ו-makepp לא יכול לקרוא את ה-makefiles של הטעם הזה באופן כללי.
(אתה רוצה להימנע מהמצב הזה אם אפשר, אבל הוא נוטה להתעורר בזמן שאתה נמצא בפנים
התהליך של העברה של מערכת בנייה מדור קודם ל-makepp.) אין לזה השפעה אם
טעינה מרומזת מושבתת.

-j n
--משרות=n
מפרש את הטיעון n כמספר פקודות המעטפת שניתן לבצע בהן
מַקְבִּיל. כברירת מחדל, makepp לא מבצע פקודות במקביל.

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

Perls מקוריים של Windows (כלומר Strawberry ו-ActiveState), מכיוון שהם אינם תומכים
פרדיגמת Unix fork/exec, אל תאפשרו את האפשרות הזו (Cygwin עובד מצוין!). כ
החלפה חלקית, אתה יכול להשתמש באפשרות --sandbox שם, אם כי זה הרבה פחות
נוח.

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

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

--load-makefile=קובץ Makefile
--load-makeppfile=קובץ Makefile
טוען את ה-makefile שצוין לפני כל קובץ makefile אחר, למעט RootMakeppfile, או
RootMakeppfile.mk מעליו, אך אל תשקול אפשרות זו למטרות
קביעת יעד ברירת המחדל. אם לא צוין קובץ makefile אחר, אז מחפשים אחד כזה
באמצעות הכללים הרגילים. אם ה-makefile שצוין הוא אותו makefile שנמצא
באמצעות הכללים הרגילים, אז לאפשרות זו אין השפעה.

--log=שם קובץ log
--log-file=שם קובץ log
משנה את שם קובץ היומן לשם המצוין. כברירת מחדל, קובץ היומן הוא
נקרא ‎.makepp/log. קובץ זה ניתן לקריאה עם makepplog, mppl.

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

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

אם אתה משתמש ב-"prebuild" או "$(make)", בסיבוב הראשון זה יפסיק כשהוא יגיע ל
הנקודה ההיא.

-m שיטה
--חתימה=שיטה
--שיטה-חתימה=שיטה
מציין את שיטת החתימה המוגדרת כברירת מחדל לשימוש עבור כללים שאין להם את
משנה ":signature" בקבצי makefile שאין להם הצהרת "חתימה". עושה
לא לעקוף את הבחירה שנעשתה על ידי מנתחי פקודות, למשל מהדרים של C/C++. אפשרי
הערכים הם "md5", "C" או "c_compilation_md5", "xml" ו-"xml-space". לעוד
פרטים, ראה makepp_signatures.

--md5-bc
--md5-check-bc
בעת ייבוא ​​ממטמון בנייה, דחה יעדים מאוחסנים במטמון אלא אם ה-MD5_SUM קיים
ותואם את היעד המיובא. בעת אכלוס מטמון בנייה, חשב ואחסן
ה-MD5_SUM בפרטי הבנייה אם הוא לא קיים כבר. זה איטי יותר ומוביל ל
יותר בונים מחדש, אבל זה מבטיח שיעדים מיובאים וקובצי מידע בנייה מתאימים
בדיוק.

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

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

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

לדוגמה, נניח שאתה יוצר א .h קובץ דרך איזשהו מעבד קדם. זֶה
יכול לקרות בהרבה דרכים שונות. למען הקונקרטיות, נניח שאתה אוטומטית
צור רשימה של אבות טיפוס עבור פונקציות המוגדרות בכל מודול C (ראה
<http://cproto.sourceforge.net/> לאופן פעולת היישום "cproto" או
<http://www.lemoda.net/c/cfunctions/> עבור הפונקציות הדומות).

prototypes.h : *.c
cproto $(CPPFLAGS) $(תשומות) > $(פלט)

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

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

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

prototypes.h : $(wildcard *.c) # טכניקה שנפרצה אינה נחוצה עבור makepp
cproto $(CPPFLAGS) $(תשומות) > junk.h
if cmp -s junk.h prototypes.h; לאחר מכן \
rm junk.h; \
אחר \
mv junk.h prototypes.h; \
fi

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

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

--no-cache-scaninfos
אל תרשום את תוצאות הסריקה, ותאלץ לבצע אותה מחדש בפעם הבאה makepp
רץ.

--לא-עומס-מרומז
אל תטען אוטומטית קבצי make-מספריות שאליהן מתייחסים (ראה "טעינה מרומזת"
ב-makepp_build_algorithm). כברירת מחדל, makepp טוען אוטומטית קובץ makepp מ
כל ספרייה שמכילה תלות של מטרה כלשהי שהיא צריכה לבנות, וממנה
כל ספרייה שנסרקת באמצעות תו כללי. עם זאת, לפעמים זה גורם ל-
בעיה, מכיוון ש-makefiles צריכים להיטען עם משתני שורת פקודה שונים או
אפשרויות, ואם הן נטענות באופן מרומז לפני שהן נטענות במפורש על ידי א
הפצת make רקורסיבית או הצהרת "load_makefile", makepp מבטל עם an
שְׁגִיאָה. אתה יכול גם לכבות את טעינת קבצי make על בסיס ספרייה לפי ספרייה על ידי
באמצעות ההצהרה "no_implicit_load" באחד מקבצי ה-makefile שלך.

--ללא יומן
אל תטרחו לכתוב תיאור מפורט של מה שנעשה לקובץ היומן. על ידי
ברירת המחדל, makepp כותב הסבר על כל קובץ שהוא ניסה לבנות, ו
למה הוא בנה אותו או לא בנה אותו, לקובץ שנקרא ‎.makepp/log, קריא עם
makepplog, mppl. זה יכול להיות בעל ערך רב עבור ניפוי באגים של makefile--makepp
אומר לך מה הוא חשב שכל התלות, ואיזה מהן הוא חשב
השתנה. עם זאת, זה לוקח קצת זמן CPU נוסף, ואולי לא תרצה לטרוח.

--no-path-exe-dep
--ללא-נתיב-תלות-ניתנות להפעלה
אל תוסיף תלות מרומזת בקובצי הפעלה שנאספו מחיפוש הפקודות
נָתִיב. אם אפשרות זו צוינה, אז makepp מניח שכל קובץ הפעלה שלו
התנהגות עשויה להשתנות עם גרסה חדשה תצוין בשם המכיל א
קו נטוי.

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

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

--לא-ספריית הדפסה
כבה את הכניסה או היציאה של הודעות ספרייה.

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

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

-o שם הקובץ
--נניח-ישן=שם הקובץ
--old-file=שם הקובץ
מעמיד פנים שהקובץ שצוין לא השתנה, גם אם כן. כל מטרה לזה
תלוי בקובץ זה לא ייבנה מחדש בגלל הקובץ הזה, למרות שהם עשויים להיות
נבנה מחדש אם השתנתה גם תלות אחרת. הקובץ עצמו יכול או לא
להיבנות מחדש, תלוי אם הוא לא מעודכן ביחס לתלות שלו.
(כדי למנוע זאת, השתמש ב---dont-build).

--דרוס-חתימה=שיטה
---override-signature-method=שיטה
זהה ל-"--signature-method", אבל אפילו עוקף את הבחירה שנעשתה על ידי מנתחי פקודות.

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

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

--populate-bc-only
אל תייבא ממטמון הבנייה. זה שימושי כאשר אתה רוצה לתרום מטרות
המטמון, אבל אינך רוצה להסתמך על תוכן המטמון (למשל למשימה-
מבנים קריטיים).

--פּרוֹפִיל
פלט חותמות זמן גולמיות לפני ואחרי כל פעולה.

-R בספרייה
--repository=בספרייה
ציין את הספרייה הנתונה כמאגר (ראה makepp_repositories לפרטים).
מאגרים מתווספים בסדר המצוין בשורת הפקודה, אז הראשון
שאתה מציין יש עדיפות. כל הקבצים בספרייה (וכל ספריות המשנה שלה)
מקושרים אוטומטית לספרייה הנוכחית (ולספריות המשנה) אם כן
נָחוּץ.

אם אתה רק מציין ספרייה אחרי "-R", התוכן שלה מקושר לזרם
מַדרִיך. אתה יכול לקשר את התוכן שלו לכל מקום שרירותי במערכת הקבצים על ידי
ציון המיקום לפני סימן שוויון, למשל,
"-R subdir1/subdir2=/users/joe/joes_nifty_library".

-r
--לא-כללים מובנים
אל תטען את ערכות כלל ברירת המחדל. אם אפשרות זו לא צוינה, והמשתנה
"makepp_no_builtin" אינו מוגדר בקובץ makepp, אז קבוצה של כללים להידור
קוד C, C++ ו-Fortran נטען עבור כל ספרייה.

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

לדוגמה, נניח שיש xc קובץ שנראה כך:

#include "xh"
int main() { return X; }

שקול את ה-makefile הזה:

$(ברירת מחדל מזויפת): x
xh:
&echo "#define X 1" -o $@

בשלב מסוים, אתה משנה את ה-makefile כך שייראה כך:

CFLAGS := -אידיר
$(ברירת מחדל מזויפת): x
dir/xh:
&mkdir -p $(dir $@)
&echo "#define X 2" -o $@

עכשיו אם אתה בונה מנקי, x יוצא עם סטטוס 2, אבל אם אתה בונה בעוד הישן
./xh הקובץ עדיין קיים ואתה לא מציין "--rm-stale", אז x יוצאים עם סטטוס
1, כי הוראת include קולטת את קובץ הכותרת המעופש שנוצר.

אם אתה בונה עם "--rm-stale", אז ./xh מוסר, והתוצאה זהה ל
זה של מבנה נקי, וזה כמעט תמיד דבר טוב.

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

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

-s
--שֶׁקֶט
--שקט
אין להדהד פקודות ואל תדפיס הודעות מידע כמו "סריקה" או "טוען
makefile".

--ארגז חול=בספרייה
--in-sandbox=בספרייה
--inside-sandbox=בספרייה
רסן את המופע הזה של makepp לעץ משנה של עץ גדול יותר בדרך כלל. לִרְאוֹת
חלוקה לארגזי חול.

--ארגז חול-להזהיר
--אזהרת ארגז חול
שדרג לאחור את ההפרות של "בארגז חול" ו"אל תקרא" לאזהרות במקום לשגיאות.
ראה חלוקה לארגזי חול.

--עצור-מרוץ
--עצור במירוץ
צא בטעות במקום להתריע רק על התנגשות גישה ל-build מטמון שיכולה להיות
מתוקן.

--symlink-in-rep-as-file
--symlink-in-repository-as-file
אם מאגר מכיל קישור סמלי, אז כברירת מחדל, קישור סמלי זה הוא
מיובא כקישור, כלומר היעד של הקישור המיובא לא חייב להיות
זהה למטרה של הקישור הסמלי במאגר. אם ה
האפשרות "--symlink-in-repository-as-file" מצוינת, ואז הקישור הסמלי הוא
מיובא כקובץ היעד שלו, כלומר הקישור המיובא מצביע לאותו הדבר
קובץ היעד בתור הקישור הסמלי במאגר. זה שימושי אם הסמלית
הקישור במאגר נועד לקבל את הסמנטיקה בזמן הבנייה של עותק.

--מָסוֹרתִי
--מסורתי-רקורסיה
--ייצור מסורתי-רקורסיבי
אפשרות זו קיימת כדי לאפשר ל-makepp לעבוד עם קבצי makepp ישנים המשתמשים ברקורסיבי
לעשות בהרחבה, במיוחד עם אפשרויות שונות. כברירת מחדל, יוצר רקורסיבי הוא
מיושם על ידי תת-תהליך שמתקשר עם תהליך האב; המבנה הוא
נעשה בפועל על ידי תהליך ההורה. זה מאפשר כמה מהתכונות הנחמדות של makepp כמו
מאגרים לעבודה עם קריאות יצירת רקורסיביות. עם זאת, טכניקה זו תעשה זאת
לא יעבוד אם אתה משתמש באפשרויות שונות של שורת פקודה על הפעלות שונות של
לעשות רקורסיבי. לפני שתשתמש בזה, נסה "--hybrid-recursive-make".

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

אם תשתמשו באפשרות זו, תקבלו קבצי יומן שנערמים בספריות השונות
זה משתנה ל. כדי להיפטר מהם בלבד השתמש ב-"makeppclean --logs --recurse" או "mppc
-lr".

-v
--מִלוּלִי
מצב מילולי. מסביר מה הוא מנסה לבנות ולמה כל קובץ נבנה.
זה יכול להיות שימושי אם אתה חושב שקובץ נבנה מחדש לעתים קרובות מדי.

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

-V
--גִרְסָה
הדפס את מספר הגרסה.

--וירטואלי-ארגז חול
אל תכתוב מחדש פרטי בנייה של קבצים שלא נוצרו בתהליך ה-makepp הזה. לִרְאוֹת
חלוקה לארגזי חול.

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

הסביבה

Makepp מחפש כלפי מעלה קובץ בשם .makepprc כאשר מתחילים ושוב אחרי כל
אפשרות "-C" או "-c". בכל פעם שהוא מוצא קובץ כזה, אבל רק פעם אחת לכל קובץ, הוא יקרא
את הקובץ ולנתח אותו כאפשרויות מצוטטות אולי בשורה אחת או כמה. לא כמו ה
אפשרות "-A", האפשרויות ינותחו ביחס לספרייה שבה נמצא הקובץ.

Makepp בוחן את משתני הסביבה הבאים:

$MAKEFLAGS
כל הדגלים במשתנה סביבה זה מתפרשים כאפשרויות שורת פקודה לפני כן
כל אפשרויות מפורשות. כל הארגומנטים של שורת הפקודה מוכנסים למשתנה זה

שימו לב שגם ה-make המסורתי משתמש במשתנה הזה, אז אם עליכם להשתמש בשניהם
make ו-makepp, אולי כדאי לשקול להשתמש ב-"MAKEPPFLAGS".

$MAKEPPFLAGS
זהה ל"MAKEFLAGS" מבחינת makepp. אם משתנה זה אינו ריק,
אז מתעלמים מ-"MAKEFLAGS". לפעמים זה שימושי במקום "MAKEFLAGS" אם אתה
צריך להשתמש גם ב-make וגם ב-makepp, ואתה צריך להפריד בין האפשרויות.

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

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

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

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