makepp_build_algorithm - מקוון בענן

תָכְנִית:

שֵׁם

makepp_build_algorithm -- כיצד makepp מבצע קובץ makepp

תיאור

החלקים הפנימיים של Makepp שונים מהייצור הסטנדרטי של Unix במובנים בסיסיים. הדף הזה
מתאר את הפילוסופיה השונה בפירוט.

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

לדוגמה, שקול את כלל הדפוס הזה:

%.o: %.cxx
$(CXX) $(CXXFLAGS) -c $(קלט) -o $(פלט)

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

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

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

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

· תווים כלליים יכולים להתאים לקבצים שעדיין לא קיימים אך ניתן לבנות אותם.

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

· מאגרים הרבה יותר פשוטים ליישום מכיוון ש-makepp יודע מראש אילו קבצים הם
יכול לעשות. (ראה makepp_repositories לפרטים.)

· ניתן לקבוע בקלות אילו קבצים ניתן לבנות (ראה את
הפונקציה "$(only_targets )".

· הפונקציה "$(infer_objects)" של Makepp מפושטת מאוד על ידי ידיעה מה הם אובייקטים
זמין.

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

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

מאוחסן לִבנוֹת מידע
Makepp מאחסנת הרבה יותר מידע על כל קובץ שהוא בונה מעבר לתאריך בלבד
חותמת (שזה כל מה שדואג ליצרן התקן). מידע זה כולל:

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

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

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

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

· הארכיטקטורה. אם הרכבת את התוכנית שלך ב-Linux ולאחר מכן עבור אל
Solaris, makepp יודע אוטומטית להדר הכל מחדש.

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

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

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

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

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

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

השתמש ב-makepp_build_algorithm באופן מקוון באמצעות שירותי onworks.net