makepp_extending - מקוון בענן

תָכְנִית:

שֵׁם

makepp_extending -- כיצד להרחיב את makepp באמצעות Perl

תיאור

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

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

משתני Makefile מאוחסנים כסקלרים של Perl בחבילה זו. (יש יוצאים מהכלל
זה: משתנים אוטומטיים וערך ברירת המחדל של משתנים כמו CC הם למעשה
מיושם כפונקציות ללא ארגומנטים. כוון לוורס ספציפיות, וורס בשורת הפקודה ו
סביבת vars לא נראים כך.) לכן לכל קוד Perl שאתה כותב יש גישה לכל
משתני makefile. משתנים גלובליים מאוחסנים בחבילת "Mpp::global". לִרְאוֹת
משתני Makefile לפרטים.

כל אחת מההצהרות (ifperl / ifmakeperl, perl / makeperl, sub / makesub),
פונקציות (perl / makeperl, map / makemap) ופעולת הכלל (perl / makeperl) עבור
כתיבת קוד Perl ישירות ב-makefile מגיע בשני טעמים. הראשון הוא לחלוטין
Perl רגיל, כלומר עליך להשתמש בקידומת "f_" כפי שהוסבר בסעיף הבא, if
אתה רוצה לקרוא לפונקציות makepp. הגרסה השנייה תחילה מעביר את ההצהרה
הרחבת משתנה בסגנון הפוך, כלומר אתה צריך להכפיל את ה-"$" שאתה רוצה ש-Perl יראה.

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

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

מוסיף חדש טקסטואלית פונקציות
אתה יכול להוסיף פונקציה חדשה לרפרטואר של makepp פשוט על ידי הגדרת תת שגרת Perl של
אותו שם אבל עם קידומת "f_". לדוגמה:

sub f_myfunc {
$argument שלי = &arg; # תן שם לארגומנט.
my( undef, $mkfile, $mkfile_line ) = @_; # תן שם לארגומנטים.

... לעשות משהו כאן

החזר $return_value;
}

XYZ := $(myfunc my func arguments)

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

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

מנגנון &arg מטפל בפעולות הבאות עבורך: אם הטיעונים כבר היו
מורחב (למשל כדי למצוא את שם הפונקציה ב-"$(my$(function) arg)" ה-arg הוא
עבר כמחרוזת ורק חזר. אם הטיעון עדיין זקוק להרחבה, זה ה
במקרה רגיל, זה במקום זאת הפניה למחרוזת. העזר &arg מרחיב אותו עבורך,
עבורו הוא צריך את האובייקט makefile בתור הפרמטר השני שלו.

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

מקסימום: מספר args (ברירת מחדל 2): תן ~0 (maxint) עבור אינסופי
min: מספר args (ברירת מחדל 0 אם המקסימום הוא ~0, אחרת זהה למקסימום)
only_comma: אל תאכל רווח סביב פסיקים, רגיל עבור שאינו שם קובץ

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

my( $prefix, $text ) = args $_[0], $_[1], $_[2], 2, 2, 1; # addprefix
עבור $cond שלי ( args $_[0], undef, $_[2], ~0 ) ... # ו, או
my @args= args $_[0], $_[1], $_[2], ~0, 1, 1; שיחה אחת
my( $filters, $words) = args $_[0], $_[1], $_[2]; מסנן #

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

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

למעשה אין מגבלות על מה שהפונקציה יכולה לעשות; אתה יכול לגשת לקובץ, הרץ
פקודות מעטפת וכו'.

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

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

sub f_foo {
...
chdir $makefile->{CWD};

... וכו '
}

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

perl { השתמש ב- mymodule }
perl {
השתמש ב::module שלי; # לשים : בשורה חדשה אז זה לא מנותח ככלל
}

אם אתה זקוק לאחת מהפונקציות הזמינות בדרך כלל ב-Makefile (כמו ה-"f_"
פונקציות, "arg" או "args"), עליך להכניס את השורה הזו למודול שלך:

השתמש ב-Mpp::Subs;

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

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

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

sub c_mycmd { my @args = @_; ... }

$(phony callcmd):
&mycmd 'arg with space' arg2 "arg3" # קורא ל-c_mycmd

%.out: %.in
&myscript -o $(output) $(input) # קורא ל-myscript חיצוני

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

אופרטור הבלוק "Mpp::Cmds::frame" מלווה ברשימת אפשרויות של אותיות בודדות
הרכיבים המובנים (מקסימום "qw(fi I ​​o O rs)"). גם אם תציין אפשרות משלך
אם תעקוף אחד מאלה, אתה עדיין נותן את האות הבודדת של האפשרות הסטנדרטית.

כל אפשרות משלו מצוינת בתור "[qw(n name), \$ref, ארג, תַת]". השניים הראשונים
האלמנטים הם שם קצר וארוך, ואחריו הפניה למשתנה ולפי אופציה על ידי
בוליאני אם לקחת ויכוח. ללא arg, המשתנה הוא
גדל בכל פעם שהאפשרות ניתנת, אחרת ערך האופציה מאוחסן בה.

sub c_my_ocmd { # מקרה פלט טיפוסי
מקומי @ARGV = @_;
Mpp::Cmds::frame {

... להדפיס משהו כאן עם @ARGV, עם אפשרויות שכבר הוסרו אוטומטית

} 'f', qw(o O);
}

sub c_my_icmd { # מקרה קלט טיפוסי עם 2 אפשרויות
מקומי @ARGV = @_;
my( $short, $long );
Mpp::Cmds::frame {

... תעשה משהו כאן עם <>

} qw(i I rs), # s מציין רק --מפריד, לא -s
[qw(s short), \$short], # No option arg -> $short == 1
[qw(l long), \$long, 1, sub { warn "got arg $long"}];
}

כאן מגיעה פקודה פשוטה אשר מעלה רק את התו הראשון של כל קלט
רשומה (שווה ל-"&sed '$$_ = "\u\L$$_"'"):

sub c_uc {
מקומי @ARGV = @_;
Mpp::Cmds::frame {
הדפס "\u\L$_" בזמן <>;
} 'f', qw(i I o O rs);
}

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

Mpp::Cmds::perform { ... } 'הודעה';

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

לָרוּץ תסריט ויכוחים ...
זוהי פונקציית Perl רגילה שתוכל להשתמש בה בכל הקשר של Perl בתוך ה-makefile שלך.
זה דומה לצורת המערכת מרובת טיעונים, אבל הוא מריץ את הסקריפט של Perl בתוכו
התהליך הנוכחי. עבור הצהרות makepp, פונקציית perl או פונקציות משלך
זה התהליך שמריץ makepp. אבל עבור כלל זה תהליך המשנה שמבצע
זה. התסריט מנותח כמה פעמים שהוא נקרא, אבל אתה יכול לשים את האמיתי
לעבוד לתוך lib, כפי שעושה pod2html. אז lib זה יכול להתרגל ברמה העליונה, אז
שזה כבר קיים:

perl { use mylib } # מתפצל לכל הכללים שאינם צריכים לשנות את זה

%.out: %.in
makeperl { הרץ qw'myscript -o $(פלט) $(קלט)' }

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

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

כתיבה שֶׁלְךָ שֶׁלוֹ חֲתִימָה שיטות
לפעמים אתה רוצה ש-makepp יחשב שיטת חתימה בטכניקה אחרת. ל
לדוגמה, נניח שיש לך קובץ בינארי שתלוי בספרייה משותפת. בדרך כלל, אם אתה
לשנות את הספרייה המשותפת, אינך צריך לקשר מחדש קובצי הפעלה שתלויים בה מכיוון
הקישור נעשה בזמן ריצה. (עם זאת, ייתכן שקישור מחדש של קובץ ההפעלה
ייתכן שיהיה צורך, וזו הסיבה שלא הפכתי את זה לברירת המחדל.) מה שאתה רוצה makepp
לעשות הוא לקבל את אותה חתימה עבור הספרייה המשותפת גם אם היא משתנה.

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

myprogram: *.o lib1/lib1.so lib2/lib2.so
: חתימה shared_object
$(CC) $(inputs) -o $(output)

כעת עלינו ליצור את שיטת החתימה.

כל שיטות החתימה חייבות להיות מחלקה משלהן, והמחלקה חייבת להכיל כמה מיוחדים
פריטים (ראה Mpp/Signature.pm בהפצה לפרטים). שם הכיתה חייב להיות
עם קידומת "Mpp::Signature::", אז במקרה זה יש לקרוא לכיתה שלנו
"Mpp::Signature::shared_object". עלינו ליצור קובץ בשם shared_object.pm ושים
זה לתוך א Mpp::חתימה ספרייה איפשהו ב-Perl include path; המקום הכי קל
עשוי להיות ב MPP/חתימה ספרייה בהתקנת makepp (למשל,
/usr/local/share/makepp/Mpp/Signature או היכן שהתקנת אותו).

לפרטים מדויקים על מה שצריך לעבור בשיעור זה, כדאי לבדוק היטב
הקובץ Mpp/Signature.pm וכנראה גם Mpp/Signature/exact_match.pm במייקאפ
הפצה. אבל במקרה שלנו, כל מה שאנחנו רוצים לעשות הוא לעשות שינוי קטן מאוד ל-
מנגנון חתימה קיים; אם הקובץ הוא ספרייה משותפת, אנו רוצים שיהיה קבוע
חתימה, בעוד שאם הקובץ הוא משהו אחר, אנחנו רוצים להסתמך על הרגיל של makepp
מנגנון חתימה. הדרך הטובה ביותר לעשות זאת היא לרשת מ
"Mpp::Signature::c_compilation_md5", שהיא שיטת החתימה שנבחרת בדרך כלל
כאשר makepp מזהה פקודת קישור.

אז הקובץ Mpp/Signature/shared_object.pm עשוי להכיל את הדברים הבאים:

השתמש מחמירים;
חבילה Mpp::Signature::shared_object;
השתמש ב-Mpp::Signature::c_compilation_md5;
@ISA = qw(Mpp::Signature::c_compilation_md5); # ציין ירושה.
$shared_object שלנו = ברכה \@ISA; # פיסת קסם שעוזרת ל-makepp למצוא
# תתי השגרות לשיטה זו. את כל
# שיטות חתימה חייבות להיות אחת מאלה.
# הערך אינו בשימוש, רק בכל אובייקט.
# עכשיו הנה השיטה שנקראת כשאנחנו צריכים את החתימה של
# כל יעד או תלות שעבורם שיטת החתימה הזו פעילה:
חתימת משנה {
my ($self, # זה יהיה זהה ל-$shared_object.
$finfo) = @_; # מבנה מיוחד שמכיל הכל
# makepp יודע על הקובץ הזה. לִרְאוֹת
# Mpp/File.pm לפרטים.

if ($finfo->{NAME} =~ /\.s[oa]$/) { # האם שם הקובץ מסתיים ב-.so או .sa?
להחזיר $finfo->file_exists ? 'קיים' : '';
# תמיד החזר את אותה חתימה אם הקובץ
# קיים. במקרה זה, החתימה היא
מחרוזת אחת "קיימת".
}

Mpp::Signature::c_compilation_md5::signature;
# אם הקובץ לא הסתיים ב-.so או .sa,
# נציג לשיטת החתימה הרגילה של makepp.
}

קובץ זה מסופק כדוגמה בהפצת makepp, עם כמה נוספים
תגובות.

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

נניח, למשל, שהספרייה המשותפת מפעילה כמה תתי שגרות שהתוכנית שלך
מספק. לדוגמה, נניח שאתה משנה את הספרייה המשותפת כך שהיא תתקשר כעת לספרייה חיצונית
תת שגרת "xyz()". אלא אם כן אתה משתמש באפשרות "-E" או "--export-dynamic" לקישור
(עבור GNU binutils; למקשרים אחרים יש שמות אפשרויות שונים), ייתכן שהסמל "xyz()" לא
להיות נגיש למקשר של זמן הריצה גם אם הוא קיים בתוכנית שלך.

גרוע מכך, נניח שהגדרת "xyz()" בספרייה אחרת (קרא לזה libxyz), ככה:

my_program: main.o lib1/lib1.so xyz/libxyz.a

מכיוון ש"libxyz" הוא א .a קובץ ולא א .לכן קובץ, אז אולי "xyz()" לא יימשך פנימה
נכון מ libxyz.a אלא אם כן תקשר מחדש את הבינארי שלך.

Mpp::שיטות חתימה גם שולטות לא רק במחרוזת המשמשת כדי לקבוע אם א
הקובץ השתנה, אבל האלגוריתם המשמש להשוואת המחרוזות. לדוגמה, ה
שיטת החתימה "target_newer" בהפצת makepp רק דורשת שה-
היעדים יהיו חדשים יותר מהתלות, בעוד ששיטת החתימה "exact_match" (and
כל מה שתלוי בו, כגון "md5" ו-"c_compilation_md5") מחייב את ה-
לקובץ יש את אותה חתימה כמו ב-build האחרון.

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

· שיטת חתימה לספריות משותפות המחזירה סכום ביקורת של כל המיוצאים
סמלים, וגם את כל הסמלים שהוא צריך מספריות אחרות. זה פותר את
בעיה עם הדוגמה שלמעלה, ומבטיחה קישור נכון בכל הנסיבות.
נעשה ניסיון ניסיוני לעשות זאת בהפצת makepp (ראה
Mpp/Signature/shared_object.pm), אבל זה יעבוד רק עם GNU binutils ו-ELF
ספריות כרגע.

· שיטת חתימה שמתעלמת מחותמת תאריך שנכתבת בקובץ. למשל, אם אתה
ליצור א .c קובץ אוטומטי באמצעות תוכנה כלשהי שמתעקשת לשים מחרוזת
בצורה כזו:

static char * date_stamp = "נוצר אוטומטית ב-01 באפריל 2004 על ידי אף אחד";

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

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

· שיטת חתימה שיודעת להתעלם מהערות בקבצי לטקס, כמו ה
שיטת "c_compilation_md5" יודעת להתעלם מהערות בקבצי C.

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

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

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