makepp_incompatibilities - מקוון בענן

תָכְנִית:

שֵׁם

makepp_incompatibilities -- אי התאמה בין makepp ל-GNU make

תיאור

Makepp תוכנן להיות קרוב ככל האפשר ליצרן GNU
(<http://www.gnu.org/software/make/manual/make.html>). כלים אוטומטיים של GNU
(<http://www.gnu.org/software/automake/manual/automake.html>), CMake
(<http://www.cmake.org/>), Premake (http://industriousone.com/premake> וראה הערה
להלן) או מערכות בנייה מדור קודם בעבודת יד צריכות להיות ניתנות לבנייה עם makepp. זה כל כך
אתה יכול להעביר פרויקטים ללא מאמץ. או אם אתה לא רוצה ליהנות מכל זה
היתרונות של makepp (למשל כדי שאחרים עדיין יוכלו לבנות את הפרויקט שלך עם GNU make) בזמן שאתה
להרוויח מיתרון האמינות עבור הפיתוח שלך.

עם זאת, בגלל ההבדל בפילוסופיה, חלק מתוצרת GNU או POSIX מייצרת
(<http://pubs.opengroup.org/onlinepubs/009695399/utilities/make.html>) תכונות לא יכולות להיות
נתמך. כמה לא יושמו כי לא היה לנו זמן. רוב ה
ההבדלים מ-GNU הם די טכניים ורק לעתים רחוקות גורמים לבעיות. אבוי ה
דרכים לעקיפת החסרונות של הייצור המסורתי הופכים מורכבים יותר ויותר,
ועושים למייקאפ תקופה קשה.

בקיצור, אם זה לא בנוי מהקופסה, נסה:

makepp --no-warn makepp_simple_concatenation=1 makepp_percent_subdirs=1 \
--build-check=target_newer -- last-chance-rules --no-remake-makefiles

אם זה יצליח, אתה יכול לנסות לחסל את הטיעונים האלה אחד אחד. אבל אם זה לא יצליח,
נסה להוסיף:

--ייצור מסורתי-רקורסיבי

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

מכריח יותר POSIX or גנה לעשות תאימות

הנה כמה אפשרויות של שורת פקודה כדי לגרום למערכות בנייה מדור קודם לעבוד
ללא שינוי. הם גורמים ל-makepp לחקות את ההתנהגות של GNU make בדיוק.

תְאִימוּת באמצעות מה היא אפשרות: "--build-check=target_newer"
כברירת מחדל, makepp ינסה לבנות מחדש את כל היעדים אם יש לאחת מהתלות
השתנה מאז הבנייה האחרונה, או אם הפקודה השתנתה (ראה makepp_build_check for
פרטים). זה בדרך כלל מה שאתה רוצה. עם זאת, לפעמים אתה לא רוצה את המטרה
להיבנות מחדש אם הוא השתנה מלבד השליטה של ​​makepp (למשל, על ידי עריכה
זה, או על ידי הפעלת תוכנית ידנית כדי ליצור את הקובץ). אתה יכול לאלץ את makepp להשתמש ב-
אלגוריתם יצרן מסורתי, אשר נבנה מחדש רק אם אחד מהמטרות חדש יותר מהיעדים
תלות, על ידי הוספת אפשרות זו לשורת הפקודה.

תְאִימוּת באמצעות מה היא אפשרות: "--dont-build=config.status"
יש חבילות שמנסות להגדיר את עצמן אוטומטית, או לעשות דברים אחרים, שיוצרים
מתעלם אלא אם מתבקש, כמו:

config.status : תצורה
./config.status --בדוק מחדש

configure : configure.in aclocal.m4
קונפוקציה אוטומטית

לרוב האנשים אפילו לא מותקן "אוטוקונפ", אז עושים הכל במצפון
הכללים, כפי שעושה makepp, ייכשלו. אפשרות זו מונעת זאת, אם תבין מה
לא לבנות.

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

תְאִימוּת באמצעות מה היא אפשרות: "--לא-זהיר"
זה לא משפר את התוצאה. Makepp תמסור הודעות אזהרה לגבי דברים רבים
שה-Unix המסורתי מקבלת בלי להירתע. זה בגלל שיש
דרכים טובות יותר לעשות אותם עם makepp. אם האזהרות האלה מעצבנות אותך, אתה יכול לכבות אותן
עם אפשרות זו.

תְאִימוּת באמצעות מה היא אפשרות: "--היברידית-רקורסיבית-ייצור"
קריאות רקורסיביות ליצירת נחשבות לרוב כתרגול לא בטוח (ראה "טוב יותר
מערכת לבנייה היררכית" ב-makepp לפרטים), אבל הם נפוצים מאוד ב
קבצי makefile קיימים. Makepp תומך ב-make רקורסיבי להתאמה לאחור; לחדש
makefiles, עדיף להשתמש בהצהרה "load_makefile", או בהצהרה המשתמעת של makepp
מנגנון טעינת makefile.

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

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

יעד: תלות
$(MAKE) -f other_makefile targets

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

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

יעד: תלות
cd subdir && $(MAKE) -f other_makefile targets

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

להוספת אפשרות זו לשורת הפקודה יש ​​את תופעות הלוואי הלא רצויות הבאות:

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

· תהליכי יצירה רקורסיביים אינם יודעים דבר על מאגרים.

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

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

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

A הכנה מוקדמת נוצר קובץ Makefile הוא רק עטיפה מצחיקה לקריאת תת-יוצר באותו
מַדרִיך. אם יש לך יעד פרויקט כלשהו XYZ תהיה לו שורה כמו

@${MAKE} --no-print-directory -C . -f XYZ.make

במקרה זה אתה יכול להימנע מהאופציה "--traditional-recursive-make" על ידי הפעלת ישירות
makepp עם זה "-f XYZ.make" אוֹפְּצִיָה.

תְאִימוּת לְלֹא מה היא אפשרות: "--עבודות=n"
קבצי makefile מדור קודם לא יפרטו את כל התלות, בהסתמך על הסדר של
ביצוע כדי ליצור אותם בזמן. במצב זה makepp עשוי להצליח לקרוא חוק לפני
התלות שלו נעשתה כולן. אז התוצאות עשויות להיות טובות יותר עם פחות, או אפילו לא
ביצוע מקביל.

תְאִימוּת באמצעות מה היא מִשְׁתַנֶה: "makepp_simple_concatenation=1"
החלפה בסגנון Rc היא דרך ברירת המחדל של makepp מבצעת החלפת משתנים לטקסט
מחרוזות מכיוון שלעתים רחוקות היא שוברת קבצי makefile מדור קודם ולעתים קרובות שימושית בחדשים
makefiles. עם זאת, הוא מציג מדי פעם אי התאמה בהחלפת
משתנים שאינם מוקפים ברווחים. לדוגמה,

INCLUDE_PREFIX := -I/some/include/dir -I
כולל := $(INCLUDE_PREFIX)/other/include/dir

יגדיר את "INCLUDES" ל-"-I/some/include/dir/other/include/dir -I/other/include/dir" אם rc-
החלפת סגנון מופעלת, בעוד ש-GNU make תגדיר זאת
"-I/some/include/dir -I/other/include/dir". למשל, בעת הידור Redis 2.6.5 הוא מנסה לעשות זאת
הפעל את "printfgcc". שרשור כל כך מצחיק של שתי פקודות מעיד על כך
משתנה זה נחוץ כדי ליפול לאחור כדי ליצור סמנטיקה.

יש גם חוסר תאימות בטיפול ברווח לבן במשתנה:

null :=
T := -o $(null) # T מכיל -o ואחריו רווח אחד.
OUTFILE = $(T)outfile

יגדיר את "OUTFILE" ל-"-ooutfile" אם החלפה בסגנון rc מופעלת, בעוד ש-GNU עושה
יגדיר אותו ל-"-o outfile".

שתי אי ההתאמה הללו מוסרות על ידי הגדרת "makepp_simple_concatenation"
מִשְׁתַנֶה. שים לב, עם זאת, שאפילו עם "makepp_simple_concatenation", makepp עדיין
מטפל ברווח לבן באופן לא תואם במצבים מסוימים:

T := -o # אל תמחק את ההערה הזו.

GNU הופך את "T" להכיל "-o" ואחריו רווח, בעוד ש-makepp מוציא את
חלל נגרר בכל מקרה. אם אתה רוצה את החלל הנגרר, עליך להגדיר
"makepp_simple_concatenation" וגם הגדר "T" באמצעות הטכניקה הכוללת דמה
משתנה כגון "null", כפי שמוצג לעיל.

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

תְאִימוּת באמצעות מה היא מִשְׁתַנֶה: "makepp_percent_subdirs=1"
כברירת מחדל, "%" בכלל דפוס אינו תואם ספריות. זה אומר שכלל כמו
זֶה:

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

לא יוחל על קבצים כמו "../shared/xyz.c". אם אתה רוצה שזה יתאים לקבצים ב
גם ספריות משנה, ואז הגדר את המשתנה "makepp_percent_subdirs=1" בשורת הפקודה
או סמוך לתחילתו של makefile.

תְאִימוּת באמצעות מה היא סביבה מִשְׁתַנֶה: $MAKEPP_IGNORE_OPTS
לפעמים קריאות רקורסיביות מדור קודם עוברות אפשרויות ש-makepp לא מבינה.
אני מקווה שהאופציה לא חשובה, אבל היא מונעת מ-makepp לפעול. עם זה
משתנה סביבה אתה יכול לבקש מ-makep להתעלם בשקט מאפשרויות מסוימות. הערך
תהיה רשימה מופרדת ברווחים של אפשרויות, שיכולה להגיע ב-4 גרסאות:

--ארוך=x
אפשרות ארוכה שמצפה לוויכוח. עובדה זו חייבת להיות מוצהרת באמצעות השווים
סימן, אם כי השימוש בפועל עשוי גם להיות מופרד על ידי רווח לבן, או "--long=bla" או
"-- ארוך בלה".

--ארוך
אפשרות ארוכה ללא ויכוח.

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

-s אפשרות קצרה ללא ויכוח.

למשל, לעקוף את אפשרות ה-R של makepp באחת ללא טיעון וקבל את ניפוי הבאגים של gmake
אפשרות עם ארגומנט:

ייצוא MAKEPP_IGNORE_OPTS='-R --debug=x'

אי תאימות זֶה לדרוש קובץ Makefile שינויים

· Makefiles שקוראים במפורש make מונעים מ-makep לבנות הכל בעצמו.
אבוי, "ExtUtils::MakeMaker" של פרל עצמו מבצע את השני מבין שתי הצורות הבאות של
טעות זו עד גרסה 6.56 (Perl 5.12.1):

subdir:
cd subdir; עשה

MAKE = לעשות

· הגדרת המשתנה "VPATH" לערך כלשהו קורא באופן מרומז ל-"vpath % value". "vpath"
ההצהרות מוחקות עם מנגנון המאגר. אז, איפה gmake תחליפים
את הנתיב לקובץ שנמצא ב-vpath, makepp במקום זאת יקשר אותו באופן סמלי
איפה זה נחוץ. כך makepp יספק מחרוזת ללא שינוי, וזה בדרך כלל
לא בעיה.

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

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

· סט הכללים המובנים המובנים שונה במקצת מאלה של GNU,
למרות ששמות המשתנים תואמים במידה רבה. הכללים המובנים צריכים
להדר בהצלחה תוכניות C/C++/Fortran, ולמעשה עשוי להיות מסוגל לנחש את
גם ספריות מתאימות במקרים מסוימים. תמיכה ב-Modula-2 וב-RatFor ועוד נדירים
שפות בכוונה לא קיימת, כי כל הזמן נתקלתי בבעיות עם GNU
כללי make's כאשר השתמשתי מחדש בטעות בתוספות עבור השפות הללו.

· קידומת פעולה של "+" מתעלמת בשקט.

· חברי ארכיון אינם נתמכים, וגם לא המשתנים האוטומטיים הקשורים
$%, "$(%D)", ו-"$(%F)".

· אין תמיכת SCCS.

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

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

· כרגע מתעלמים חלקית מהמשתנה "SHELL". Makepp תמיד משתמש / Bin / sh
אלא אם כן /usr/xpg4/bin/sh or /sbin/xpg4/sh נמצא או אלא אם אתה מייצא את ה-"SHELL"
משתנה ב-makefile שלך. אבל אם תעשה זאת, ייתכן שמנתח הפקודות לא יהיה מלא
להבין מה עושה פקודת המעטפת שלך. ב-Windows Strawberry או ActiveState Perl
במקום זאת עליך להגדיר את המשתנה SHELL שלך לפני קורא makepp.

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

· קבצי ביניים אינם נמחקים. (כי makepp מתעקש להחזיק את כל הקובץ
התאריכים יהיו זהים לאלו שהיו ב-build האחרון, קבצי הביניים חייבים להיות כולם
הווה או שיתרחשו בנייה מחדש.) אין מעמד מיוחד שניתן
קבצי ביניים.

· היעד המיוחד היחיד שנתמך הוא ".PHONY" ובחלקו ".SUFFIXES". ה
הנותרים פשוט נבלעים.

באופן ספציפי, ל-GNU make יש את המטרות המיוחדות הבאות:

.SUFFIXES
Makepp מתעלם מ-".SUFFIXES" למעט המקרה המיוחד של ".SUFFIXES" ללא
תלות, כמו זה:

.SUFFIXES:

מה שאומר לו לא לטעון אף אחד מכללי ברירת המחדל שלו.

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

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

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

.DELETE_ON_ERROR
.EXPORT_ALL_VARIABLES
.NOEXPORT
.POSIX
תקלות
יעדים אלה אינם נתמכים ופשוט מתעלמים מהם.

· ה-GNU הופך את הפונקציות "eval", "flavor" ו-"value" אינן נתמכות כרגע. אתה
יכול להשיג את אותו הדבר כמו eval בצורה פשוטה יותר עם "$[...]"
משתנה או הרחבת פונקציה.

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

א:: ב
&cat b -oa

# מאוחר יותר ב-makefile שלך:
a :: ג
&cat c -o >>a

זה בדיוק אותו דבר כאילו היית כותב

א ב ג
&cat b -oa
&cat c -o >>a

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

· הפונקציה "$(wildcard )" מתאימה לא רק לקבצים שקיימים, אלא גם לקבצים שקיימים
עדיין לא קיימים, אבל יש להם כלל ש-makepp ראה בזמנו
הפונקציה "$(Wildcard )" מוערכת.

· ההצהרה "הגדר" נתמכת, אך הטיפול ב-"@" לפניה נעשה
באופן שונה. כרגע ב-makepp, "@" לפני משתנה שיש לו רב-קו
הערך ידכא רק הד של השורה הראשונה. לדוגמה,

להגדיר הד-קווים
&echo line1 -o $@
&echo line2 -o>>$@
endef

x:
@$(הד קווים)

לא ידכא הדפסה של "&echo line2" כפי שהוא עושה ב-GNU make; זה יהיה רק
לדכא הדפסה של "&echo line1".

· Makepp אינו תומך במשתני הסביבה הבאים (הוא אינו מגדיר אותם,
וזה פשוט מתעלם מהם):

מהפך
MFLAGS

אי תאימות in להזמין of ביטוי הרחבה
· ב-makepp, פעולות הכלל מורחבות לפני שכל התלות מובטחת
נבנה. אתה יכול לעקוף את זה על ידי שינוי כללים כגון זה:

פו בר
genfoo < $(Shell cat bar)

לזה:

פו בר
genfoo < `cat bar`

או זה, שיעשה את הקובץ במהלך ההרחבה:

פו בר
genfoo < $(&cat $(make bar))

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

· למרות שלא ראיתי את זה בשימוש, GNU make מאפשר את הדברים הבאים:

נקודתיים = :
a$(קולון) ב
הד $^

Makepp מרחיב את "$(קולון)" מאוחר מדי כדי שזה יעבוד. עם זאת הוא מציע את
תחביר "$[colon]" חלופי, שיכול לעשות הרבה יותר ממה ש-GNU מייצר, כי הוא כן
התרחב מוקדם מאוד.

"$(MAKE)" אולי לכלול רווחים
ב-makepp שלא הותקן או אם נראה שהפלטפורמה לא תומכת בהתחלת סקריפט של Perl
לפי מספר קסם או עם "--traditional-recursive-make" משתנה זה יכלול לפחות
חלל אחד. זו לא בעיה כאשר משתמשים בו כפקודה. אבל כשמעבירים את זה בתור an
פרמטר לא מצוטט לסקריפט (כפי שעושה מערכת הבנייה של Perl 5.14.0), הוא יקרע אותו
נפרדים לפרמטרים נפרדים, מה שמוביל לבלבול. אז בתור פרמטר זה בטוח יותר
ציטוט את זה בתור '$(MAKE)'. מה שלא שובר תאימות לאחור.

ספציפי למטרה הקצאות לא להפיץ
המשתנים הספציפיים למטרה של Makepp שונים במקצת מתוצרת GNU בכך שהם
חל רק על הכלל עבור הקובץ האחד הנזכר, ולא על מי מקודמיו; לִרְאוֹת
משימות ספציפיות למטרה.

סוגריים or פלטות לא קן
Makepp מסיים ביטויים בסוגריים או בסוגריים התואמים הראשונים. במקום זה

$(איזושהי פונקציה ... ( ) ...) # GNU לעשות סגנון

עליך להשתמש באחד מאלה

${somefunction ... ( ) ...} # GNU להפוך לתואם
$((איזושהי פונקציה ... ( ) ...)) # סיומת Makepp

זה כנראה יתוקן בגרסה 2.1, אולי אופציונלי.

קטין נקודות
תלות דפוס אינה תואמת יעדים מזויפים
%.a: %.b; ...
$(phony xb): ; ... # אינו מספק דרך לבנות xa

לתגובות אין שורות המשך
# זה \
לא הערה בת 2 שורות

פיקוד קו חוסר תאימות

Makepp תומך בכמה אפשרויות שימושיות יותר של שורת הפקודה של make. אולם הדברים הבאים,
אינם נתמכים:

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

-i
-l או --load-average או --max-load
האפשרות "-m" של -m Makepp קשורה לבחירת שיטת חתימה, בעוד ש-GNU עושה
מתעלם -מ.

-p או --print-data-base
-q או --שאלה
-R או --no-builtin-variables
אפשרות ה-"-R" של Makepp למעשה עושה משהו אחר לגמרי.

-S --לא-להמשיך או --עצור
האפשרות "--stop" מפסיקה (מרדימה) את המייקאפ לאחר לימוד כל הכללים, אז אתה
יכול להמשיך לערוך.

-t או --touch
-w או --print-directory
זה קורה אוטומטית.

--זהיר-משתנים-לא מוגדרים

ניתן לתמוך בקלות בכמה מאלה אם למישהו אכפת.

מִשְׁתַנֶה חוסר תאימות

Makepp מחפש ב-$PATH פקודה תואמת להחזיר עבור משתנים כמו "$(CC)" או
"$(CXX)", בעוד של-GNU make יש ברירות מחדל סטטיות. גם makepp נותן עדיפות ל"gcc" ו
"g++" בעוד שבאופן מפתיע GNU מחזירה "cc" עבור הראשון, אבל זהה עבור
אַחֲרוֹן. אתה יכול לעקוף אותם ב-makefile, בשורת הפקודה או על ידי ייצוא א
משתנה בעל אותו שם לפני הפעלת makepp.

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