זוהי הפקודה metaconfig שניתן להפעיל בספק האירוח החינמי של OnWorks באמצעות אחת מתחנות העבודה המקוונות המרובות שלנו, כגון Ubuntu Online, Fedora Online, אמולטור מקוון של Windows או אמולטור מקוון של MAC OS
תָכְנִית:
שֵׁם
metaconfig - מחולל סקריפט Configure
תַקצִיר
metaconfig [ -dhkmostvwGMV ] [ -L dir ]
תיאור
Metaconfig היא תוכנית המייצרת סקריפטים של Configure. אם אתה לא יודע מה א
הגדר את הסקריפט הוא, אנא דלג אל הדרכה חלק בדף המדריך הזה. אם אתה רוצה
תיאור מלא (רשמי) של דרך השימוש metaconfig והיחידות שלו, נא להסתכל על
הפניה סָעִיף. להלן מבוא מהיר והתייחסות לבעלי ידע
משתמשים.
Metaconfig פועל מסט של יחידות שמגדירים את כל מה שמטאקונפיג יודע עליו
הִטַלטְלוּת. כל יחידה עומדת בפני עצמה, ואינה חייבת להירשם בשום מקום
מלבד הכללה בספריית U הציבורית או בספריית U הפרטית שלך. אם
חבילת dist (ש-metaconfig היא חלק ממנה) מותקנת ב-LIB, ולאחר מכן ה-U הציבורי
הספרייה היא LIB/dist/mcon/U. במחשב זה, ספריית LIB היא /usr/share/dist. שֶׁלְךָ
ספריית U פרטית, אם יש לך כזו, נמצאת בספרייה ברמה העליונה של החבילה שלך.
לפני שאתה יכול לרוץ metaconfig עליך לעשות מספר דברים:
· צור קובץ .package בספריית הרמה העליונה של החבילה על ידי הפעלה packinit.
תוכנית זו תשאל אותך על החבילה שלך ותזכור מה אתה אומר לה כך
כל תוכניות ה-Dist יכולות להיות חכמות.
· עיין במילון המונחים (ב-LIB/dist/mcon) וכתוב את סקריפטי המעטפת ותוכניות C שלך
מבחינת הסמלים ש-metaconfig יודעת להגדיר. אתה לא צריך לספר
metaconfig באילו סמלים השתמשת, מכיוון ש-metaconfig תבין את זה בשבילך.
· צור כל סקריפטים .SH הדרושים לכתיבת Makefiles או סקריפטים של מעטפת שיהיו תלויים
על ערכים שהוגדרו על ידי Configure. יש תוכנית שנקראת makeSH זה יעזור לך
המרת סקריפט רגיל לתבנית script.SH; עדיין יהיה צורך בעריכה מסוימת
בוצע על קובץ ה-.SH שהתקבל כדי להעביר את חלק התצורה המשתנה ב-
החלק העליון של התסריט (ראה הערות מוטבעות שנוצרו על ידי makeSH בתוך ה-.SH שלך
קובץ).
· צור קובץ MANIFEST.new בספרייה ברמה העליונה שלך שמפרטת את כל הקבצים
החבילה שלך. קובץ זה יישאר פרטי ולא יהיה חלק מהגמר
הפצה. (מטעמי נוחות, קובץ MANIFEST ישמש את metaconfig if
אין עדיין קובץ MANIFEST.new.) שם הקובץ צריך להיות השדה הראשון בכל אחד מהם
קַו. לאחר רווח לבן אתה יכול להוסיף הערה קצרה המתארת את הקובץ שלך. רק
קבצי מקור צריכים להיות רשומים שם. הקובץ המיוחד patchlevel.h (שהוא
מטופל ומתוחזק על ידי כלי התיקון -- ראה טפיחה(1)) צריך להיות חלק מה-
הקובץ MANIFEST.new, אך ייתכן שחלק מהכלים יתעלמו ממנו בשקט. ככלל אצבע,
רק קבצים המתוחזקים על ידי RCS צריכים להיות רשומים שם, ה patchlevel.h הוויית קובץ
חריג אחד חשוב.
· לחלופין, ייתכן שתרצה ליצור קובץ MANIFEST, שיהיה גרסה מיוצאת
של ה-MANIFEST.new שלך. קובץ זה חייב להיות חלק מההפצה, כלומר רשום בשניהם
MANIFEST.new שלך ו-MANIFEST עצמו. אחד מ metaconfig יחידות יודעות על זה
קובץ ויאלץ את Configure לבצע בדיקת שחרור, תוך הבטחת כל הקבצים
הרשומים שם הם חלק מההפצה. הקבצים MANIFEST ו-MANIFEST.new צריכים
להיות מובחן, לא קישורים.
· העתק כל קבצי .U שברצונך לשנות לספריית U הפרטית שלך. כל קבצי .U
במדריך ה-U הפרטי שלך ישמש עדיפות לזו שב-U הציבורי
מַדרִיך. לדוגמה, אחת הדרכים לכפות הכללה של יחידה כלשהי היא להעתיק את ה- End.U
הקובץ לספריית .U שלך והוסף את שם היחידה שאתה רוצה כתלות בה
סוף קו ?MAKE:. ניתן לכפות יחידות מסוימות רק בדרך זו, כלומר
אלה של הצורה Warn_*.U ו-Chk_*.U. אתה יכול גם להתאים אישית ברירת מחדל מסוימת
הגדר משתנים על ידי העתקת Myinit.U לספריית U הפרטית של החבילה שלך ו
הגדרת המשתנים באותה יחידה.
עכשיו אתה מוכן לרוץ metaconfig. זה יצור א גדר קובץ, ובאופן אופציונלי א
config_h.SH קובץ (אם המקורות שלך עושים שימוש כלשהו בסמלי C). הקבצים שנוצרו יהיו
יתווסף אוטומטית ל-MANIFEST.new שלך במידת הצורך. אל תשכח לעדכן את שלך
עם זאת, קובץ MANIFEST.
כדי ליצור יחידות חדשות, בצע את הפעולות הבאות:
· העתק יחידה דומה לקובץ .U חדש. השם שתבחר צריך להיות השם של א
משתנה שנוצר על ידי היחידה, למרות שזה רק נוחות עבורך, לא א
דְרִישָׁה. זה צריך להיות 12 או פחות תווים כדי למנוע חיתוך שם הקובץ.
למעשה, זה כנראה צריך להיות 10 או פחות כך שמי שרוצה להשתמש ב-RCS יוכל לקבל
a .U,v בסוף בלי לחתוך. Metaconfig משתמשת באותיות גדולות של האות הראשונה ל
קבע אם משתנה כלשהו מופק בפועל על ידי היחידה הזו, אז אל תשתמש באותיות גדולות
שם היחידה אם היא אמורה לייצר משתנה מעטפת.
ערוך את קובץ ה-U החדש כדי לעשות מה שאתה רוצה. הקו הראשון ?MAKE: מציין את
תלות; לפני נקודתיים הרשימה הסופית כל המשתנים שהיחידה הזו מגדירה, ו
לאחר המעי הגס הסופי כל המשתנים (או יחידות אחרות) שבהם תלויה יחידה זו.
חשוב מאוד שרשימות אלו יהיו מדויקות. אם תלות היא אופציונלית וא
ניתן להשתמש בערך ברירת המחדל, עליך להוסיף את התלות בסימן '+'. ה
היחידה המתאימה לא תיטען כדי לחשב את הסמל, אלא אם כן נדרש
על ידי יחידה אחרת.
· במידת האפשר, קבע פרמטרים ליחידה שלך בהתבסס על משתנה מעטפת שהוגדר על
?INIT: קווים. זה יעביר את הגדרות המשתנים למעלה ליחידת Init.U, שם
ניתן לעקוף אותם על ידי הגדרות ב-Myinit.U, הנכללת אחרי Init.U.
· הוסף את ההגדרה של כל סימני C הרצויים כ-?H: קווים. שורה שמתחילה ב
?H:?%<: בקובץ .U יתווסף לקובץ config.h הסופי אם ורק אם
metaconfig מחליטה שהיחידה הזו נחוצה. ה-%< מייצג את שם היחידה,
שזה במקרה גם שם הקובץ (ללא .U) אם עקבת אחר ה-
אֲמָנָה. שים תמיד הערה על כל שורה ?H: במקרה של אחד מהמשתנה
החלפות מוקדם יותר על הקו מתחילות הערה מבלי לסיים אותה. כל קליפה
משתנה שמתחיל ב-d_ עשוי לעשות זאת, אז היזהר. אם תשמיט את ה-?%<:, אז
metaconfig תנסה לחוש את הסמל שהגדרתו נחוצה לפני כל
הכללה ב-config.h.
· הוסף הגדרות מילון מונחים כ-?S: שורות למשתני מעטפת ו-?C: קווים עבור C
משתני קדם-מעבד. ראה יחידה נוכחית לדוגמאות. זה מאוד חשוב
התחל כל ערך בשם סמל שמאלי, וסיים כל ערך עם ?C:. אוֹ
?S:. קַו. האלגוריתם שמתרגם ערכי סמל C preprocessor עבור ה-
מילון מונחים להערות עבור config.h תלוי בזה.
· לוודא את הסדר של כל שלך? קווים צודקים. הסדר הנכון הוא:
?RCS: ו?X: בעצם רק הערות
עשה: תלות ב-metaconfig
Y: הנחיית פריסת יחידה
?S: הגדרות מעטפת מילון מונחים
?C: מילון מונחים C הגדרות
?H: הגדרות config.h
?M: confmagic.h הגדרות
?W: סמלים מבוקשים
?V: סמלים גלויים
?F: קבצים שנוצרו על ידי יחידה זו
?T: נעשה שימוש בסמלי מעטפת זמניים
?D: ערך ברירת מחדל של תלות אופציונלית
?O: משמש לסימון יחידות מיושנות
מוך: רמזים למטאלינט
?INIT: אתחולים של סמלי מעטפת
להלן דוגמה להצגת סדר השורות והפורמטים השונים המותרים:
?RCS: $RCS-Id$
?RCS: מידע על זכויות יוצרים
?RCS: $RCS-Log$
?איקס:
?X: דוגמה מתוכננת
?איקס:
?MAKE:d_one two: three + four Five
?MAKE: -בחר הוסף $@ %<
?Y:DEFAULT
?S:d_one:
?S: סמל הקליפה הראשון, מגדיר ONE באופן מותנה.
?S:.
?S:two:
?S: סמל פגז שני, ערך עבור TWO.
?S:.
?קוֹנוּס:
?C: סמל C ראשון.
?C:.
?C:TWO:
?C: סמל C שני.
?C:.
?H:#$d_one ONE /**/
?H:#define TWO "$two"
?H:#$d_one ONE_TWO "$two"
?H:.
?M:flip: HAS_FLIP
?M:#ifndef HAS_FLIP
?M:#define flip(x) flop(x)
?M:#endif
?M:.
?W:%<:one_two
?V:p_one p_two:p_three
?F:file ./ftest !tmp
?T:tmp var
?D:two='undef'
?LINT: שנה שלוש
?INIT:two_init='2'
: קוד מעטפת המיישם את היחידה כדלקמן
p_one='one'
p_two='two'
p_three=""
הרשו לי לציין זאת פעם נוספת: הגדרת היחידה לעיל היא א מְזוּיָף אחד רק להראות את
אפשרויות שונות. יחידה כזו תשרת מעט מטרה בכל מקרה... עוד כמה
תכונות מתקדמות אינן מתוארות כאן. אנא עיין ב הפניה סעיף לעוד
מידע מלא.
· הכנס את היחידה למדריך U הציבורי או הפרטי לפי הצורך.
· שידור חוזר metaconfig.
· שלח את היחידה שלך אל [מוגן בדוא"ל] (רפאל מנפרדי) להכללה בעותק המאסטר,
אם אתה חושב שזה עניין כללי.
על מנת להוסיף תוכנית חדשה שתמצא:
· ערוך את Loc.U והוסף את שם התוכנית לשורה ?MAKE: (בין ה-
שני נקודתיים) וגם ל-loclist או trylist (תלוי אם התוכנית כן
חובה או לא).
· הפעל מחדש את המטא-קונפיגורציה.
· שלח לי את היחידה שלך להכללה בעותק האב, אם אתה חושב שהיא כללית
עניין.
הערות לכתיבת קובצי .U:
* השתמש תמיד ב-"rm -f" כי יש מערכות שבהן rm הוא אינטראקטיבי כברירת מחדל.
* אל תשתמש ב-"set -- ..." כי '--' לא עובד עם כל מעטפת. השתמש ב-"set x ...;
מִשׁמֶרֶת".
* אל תשתמש ב-"unset ENV" מכיוון שה-unset אינו נייד לחלוטין. אמור "ENV=''" במקום זאת.
* השתמש תמיד בהד " " (עם רווח) בגלל מערכות Eunice.
* שימוש בלבד מבחן עם -r, -w, -f או -d מכיוון שאלו המתגים הניידים היחידים. ב
במיוחד, הימנע מ"מבחן -x".
* השתמש רק בתוכנות שהגיעו עם V7, כדי שתדע שלכולם יש אותן.
* השתמש ב-$contains כאשר אתה רוצה לבצע grep באופן מותנה, מכיוון שלא כל greps מחזירות a
מצב סביר. הקפד להפנות את הפלט אל /dev/null, באמצעות '>/dev/null
2>&1'.
* השתמש ב"אם מבחן" ולא "אם [...]" מכיוון שלא כל ש' מכיר את המבנה האחרון.
* השתמש בסקריפט myread עבור קלט כדי שיוכלו לבצע escapes של מעטפת וברירת מחדל
הַעֲרָכָה. הצורה הכללית היא
במקרה "$grimmble" פנימה
'') dflt=452;;
*) dflt="$grimble";;
esac
rp='כמה גרימבלים יש לך?'
. ./myread
grimble="$ans"
* השתמש בסקריפט getfile כאשר אתה מבקש שם נתיב לקובץ כדי שיהיה אופציונלי
~ הרחבת שם ובדיקות שפיות. עיין ביחידת Getfile.U לתיאור מלא.
* תמיד לשים א
$startsh
בראש כל סקריפט שנוצר שעתיד להיות מושק או מקורו על ידי
גדר.
* לעולם אל תניח מערכות UNIX נפוצות כמו העובדה שקובץ אובייקט מסתיים ב-a .o ו
ששם ספרייה מסתיים בו .a. להשתמש ב $_o ו $_a משתנים במקום זאת (ראה
Unix.U).
* בעת ביצוע מבחן הידור-קישור-ביצוע, כתוב אותו תמיד כך:
$cc $ccflags $ldflags try.c -o try $libs
מכיוון שמערכות מסוימות דורשות שדגלים מקשרים יצוינו לפני הקומפילציה
יעד (למעט ספריות מקשרות נגררות).
* הנפק הודעות חשובות על מתאר קובץ מס' 4, באמצעות '>&4' כדי להפנות את הפלט.
רק הודעות אלו יופיעו כאשר -s מתג ניתן ל גדר על
שורת הפקודה (מצב שקט).
* נסה תמיד לקבוע אם תכונה קיימת בצורה הספציפית ביותר - אל תעשה זאת
אמור "if bsd" כאשר אתה יכול להפעיל grep libc. יש הרבה מערכות היברידיות בחוץ, ו
כל תכונה צריכה לעמוד או ליפול מעצמה.
* נסה תמיד לקבוע אם תכונה קיימת בצורה הכללית ביותר, כך
חבילות אחרות יכולות להשתמש ביחידה שלך.
* במקרה של ספק, הגדר ברירת מחדל ושאל. אל תניח כלום.
* אם אתה חושב שהמשתמש טועה, הרשה לעובדה שהוא צודק. ל
למשל, יכול להיות שהוא מריץ את Configure במערכת אחרת ממה שהוא הולך להשתמש
המוצר הסופי על.
Metaconfig שומרת את השמות הבאים בספרייה שלך, ואם אתה משתמש בשם כזה היא
עלול להסתבך או להיות בעל השפעות בלתי צפויות אחרות:
.MT/*
גדר
רצה
מְיוּשָׁן
להגדיר
config_h.SH
confmagic.h
U/*
MANIFEST.חדש
בנוסף, Configure עשויה לקטוף את השמות האלה בספרייה שבה היא מופעלת:
UU/*
config.sh
config.h
אפשרויות
האפשרויות הבאות מזוהות על ידי metaconfig:
-d הפעל את מצב ניפוי באגים. לא ממש שימושי אלא אם כן אתה מנקה באגים metaconfig
עצמו.
-h הדפס הודעת עזרה וצא.
-k שמור ספרייה זמנית, כדי שתוכל לבחון את קבצי העבודה שבהם השתמש
metaconfig לבנות שלך גדר תַסרִיט. שימושי רק בעת איתור באגים של
יחידות.
-m קחו הרבה זיכרון והחליפו מקום. זה יאיץ את חיפוש הסמלים פנימה
קבצי מקור בכמות משמעותית של זמן, על חשבון הזיכרון
צְרִיכָה...
-o מפה סמלים מיושנים על סמלים חדשים. השתמש במתג זה אם עדיין יש לך כמה
סמלים מיושנים בקוד המקור שלך ואינם רוצים (או לא יכולים) להסירם
אותם לעת עתה. אחרת מתעלמים מהסמלים המיושנים, למרות זאת
ייתן לך אזהרה מ metaconfig.
-s הפעל מצב שקט.
-t עקבו אחר סמלים כפי שהם נמצאים.
-v הפעל מצב מילולי.
-w נניח שהקובץ מבוקש מעודכן. זה ידלג על הזמן והזיכרון
שלב הצריכה של סריקת קוד המקור, מחפש סמלים ידועים. תשתמש בזה
רק כאשר אתה יודע שקובץ המקור שלך לא השתנה ביחס ל-
מאגר של metaconfig סמלים בשימוש.
-G ספק גם GNU להגדירכמו קצה קדמי ליצירת גדר
תסריט, שייכלל גם בהפצה. זו רק עטיפה
מסביב גדר תסריט באופן טבעי, אבל הוא מאפשר לאנשים להכיר את
כלי GNU שלא ילך לאיבוד כאשר עומדים בפני הפצה חדשה.
-L dir עוקף את מיקום ברירת המחדל של הספרייה. בדרך כלל שימושי רק עבור metaconfig
מתחזקים להשתמש מקומית ביחידות המפותחות במקום ב
זמינים לציבור. ה dir שצוין הוא זה שמכיל את היחידות
U במדריך.
-M אפשר ייצור של א confmagic.h קובץ למיפוי אוטומטי של כמה טוב-
סמלים ידועים לאיזו חלופה אחרת, כמו bcopy() מסומן מחדש
בשקיפות ל memcpy() כאשר אינו זמין. אפשרות זו מופעלת
אוטומטית כאשר א confmagic.h הקובץ קיים בספרייה ברמה העליונה.
כל שעליך לעשות הוא להסיר את הקובץ אם ברצונך להשבית אפשרות זו לצמיתות.
-V הדפס מספר גרסה וצא.
הדרכה
החלק (הארוך) הזה הוא הקדמה ל metaconfig, שבה נלמד את כל
יסודות. אם אתה כבר יודע איך להשתמש metaconfig, תוכל לדלג בבטחה אל הבא
סָעִיף.
סקירה כללית
בדרך כלל כאשר אתה רוצה לקבל חבילת מקור כלשהי להידור בפלטפורמה נתונה שיש לך
כדי לערוך את ה-Makefile הראשי (בהנחה שיש אחד!), בחר מהדר C, ודא שאתה
להחזיק את הספריות המתאימות, ולאחר מכן לפטר את לעשות פקודה. אם החבילה סבירה
כתוב היטב, זה יקמפל (בלי שאזהרה תהיה אופציה :-). כשלעצמו, האחרון
המשפט הוא ביצוע אמיתי, שכן בהתחשב במגוון פלטפורמות UNIX הזמינות כיום
והמגוון של הטעמים, זה אומר שמחבר החבילה נכנס לעומק
קשה להבין את הבחירות הנכונות בהתחשב בניסיון סטנדרטי, ניחושים ובלגן
מסביב עם המערכת כוללת וסוגים.
עם זאת, למרות כל הכישרון שלו, המחבר לא יכול לדעת שלמערכת כלשהי יש א
קריאת מערכת שבורה, או שמבנה מערכת כלשהו חסר שדה אחד סטנדרטי אחרת, או
פשוט אם קיים קובץ include נתון או לא. ואני לא מחשיב את המרומז
הנחות, כמו הסוג המוחזר על ידי ה malloc () פונקציה או נוכחות של
שנה שם () קריאת מערכת למנות כמה. אבל הידע הזה נחוץ כדי להשיג אמיתי
הִטַלטְלוּת.
עכשיו בואו לא נתעלל בעצמנו. השימוש במידע הזה דורש מיומנויות גדולות יותר, אך הוא יכול
להוביל לתוכנות ניידות יותר מכיוון שהיא נכתבת אז באופן תלוי מערכת
ומסתמך רק על העובדה שהנחה כלשהי היא נכונה או שקרית במערכת מסוימת,
כל הנחה אינה קשורה זו לזו. כלומר, אנחנו לא אומרים: אנחנו על א
מערכת BSD או שאנחנו על מערכת USG. ממילא זה מטושטש מדי בימינו. לא, אנחנו רוצים
אמור לקוד המקור: למערכת הזו אין את שנה שם () שיחת מערכת ו malloc ()
מחזירה א (בָּטֵל *) ערך.
Metaconfig הוא כלי שיאפשר לך לעשות בדיוק את זה, עם היתרון הנוסף של לא
צריך לערוך ביד את Makefile אם הכל הולך כשורה. על ידי ריצה metaconfig, אתה יוצר a
סקריפט מעטפת בשם גדר. מאמצים רבים הוקדשו לתסריט Configure
פנימיות כדי להבטיח שהוא יפעל על 99% מהקונכיות הקיימות הזמינות נכון לעכשיו
כְּתִיבָה. Configure תחקור את מערכת היעד, ישאל שאלות כאשר יש ספק ו
אסוף את כל התשובות בקובץ מעטפת אחד, אשר בתורו ניתן להשתמש בו
ליצור באופן אוטומטי קבצי Makefiles ו-C include קבצים.
יש רק קבוצה מוגבלת (אך די גדולה) של סמלים זמינה עבור סקריפטי המעטפת שלך
ותוכניות C. כולם מתועדים בקובץ מילון המונחים. כל מה שאתה צריך לעשות זה ללמוד
עליהם ולהתחיל להשתמש בהם כדי לטפל בבעיות ניידות ותצורה. לאחר מכן,
על ידי ריצה metaconfig, ייווצר סקריפט Configure מתאים עבור החבילה שלך.
הסקריפט Configure בנוי ממספר יחידות (יותר מ-300), כל יחידה היא
אחראי על הגדרת מספר קטן של סמלי מעטפת ו/או C. יחידות מורכבות
ביחד בשלב הסופי, מכבדים את גרף התלות (ייתכן שיחידה אחת תזדקק לתוצאה
של מספר יחידות אחרות אשר לאחר מכן ממוקמות לפני בתסריט).
סמלים
סמלים הם הדבר החשוב ביותר ב metaconfig עוֹלָם. הם הקטנים ביותר
ישות מוכרת, בדרך כלל מילה, וניתן להעניק לה ערך בסוף ה-Configure
ביצוע. לדוגמה, סמל ה-C pre-processor HAS_RENAME הוא metaconfig מסמל את זה
מובטח להיות מוגדר אם, ורק אם, ה שנה שם () קיימת קריאת מערכת. כְּמוֹ כֵן,
מה היא $ranlib משתנה shell יוגדר ל-':' או 'ranlib' בהתאם ל-
להתקשר אל ranlib יש צורך בתוכנית כדי להזמין קובץ ספרייה. איך זה עובד זה לא
חשוב לעת עתה, מה שחשוב הוא להבין שלסמלים אלה ניתן א חיים
(כלומר ערך) על גדר ביצוע.
השימוש בסמלים הוא פשוט יחסית. בקובץ מקור C, אתה פשוט משתמש בסמל
ערך, כהוראת קדם-מעבד (לדוגמה: #ifdef HAS_RENAME) או, אם הסמל
הערך הוא מחרוזת, ישירות כפי שהיית משתמש במאקרו ב-C. ובקובץ מעטפת או a
Makefile, אתה יכול להפנות ישירות לסמל מעטפת.
למעשה, אני משקר, כי זה לא לגמרי קסם כמו הפסקה הקודמת
יכול להישמע. בקובץ C, עליך לכלול את ה-Configure-produced config.h קובץ, ו
עליך לעטוף את סקריפט המעטפת או Makefile שלך בקובץ .SH ותוכל להפנות למעטפת
סמל רק בחלק החלפת המשתנה של קובץ ה-SH. עוד על כך בהמשך.
מָקוֹר קבצים
סמלים עשויים להופיע רק בקבוצה מוגבלת של קובצי מקור, מכיוון metaconfig יהיה רק
סרוק אותם כאשר אתה מחפש סמלים ידועים, מנסה להבין אילו יחידות הוא יצטרך.
אתה יכול להשתמש בסמלי C בקבצי מקור C, כלומר קבצים עם a .c, .h, .y or .l סיומת, ו
מחפשים סמלי מעטפת רק בקבצי SH.
כדי לקבל את הערך של סמל, קובץ C צריך לכלול את המיוחד config.h
קובץ, אשר מופק על ידי גדר כאשר קיימים סימני C. וקובצי .SH מופעלים
דרך מעטפת, הפקת קובץ חדש. עם זאת, בחלק העליון של קובץ ה-.SH, ה-
מיוחד config.sh קובץ (מופק גם על ידי הפעלה גדר) מקורו ומשתנה
חלים תחליפים. בעצם, config.h מופק על ידי הפעלת ה metaconfig-מיוצר
config_h.SH קובץ, שוב באמצעות החלפת משתנה. אז אנחנו הולכים להסתכל על זה א
קצת יותר מקרוב מכיוון שזהו הלב של השלם תצורה תָכְנִית...
מִשְׁתַנֶה החלפה
יש מבנה מעטפת שנקרא כאן מסמך מה שמאפשר לפקודה לקחת קלט
שצוין בתוך התסריט עצמו. הקלט הזה מתפרש על ידי המעטפת ככפול
מחרוזת מצוטטת או מחרוזת מצוטטת בודדת בהתאם לצורת המסמך כאן
מפרט.
כדי לציין מסמך כאן, נעשה שימוש באסימון '<<', ואחריו מזהה יחיד. מ
לאחר מכן, שאר שורות הסקריפט יוצרות את הקלט עבור הפקודה, עד לכאן
המסמך נמצא על שורה בפני עצמה. החלפת מעטפת (כולל משתנה מעטפת
החלפות) מתבצעת אלא אם המזהה מוקף במירכאות בודדות. לדוגמה:
var='first'
tar='second'
echo "--> מסמך ראשון כאן:"
חתול <<EOM
var='$var'
tar='$tar'
EOM
echo "--> שני כאן מסמך:"
חתול <<'EOM'
echo $var
echo $tar
EOM
echo "--> סוף."
יפיק, כאשר רץ דרך מעטפת:
--> מסמך ראשון כאן:
var='first'
tar='second'
--> מסמך שני כאן:
echo $var
echo $tar
--> סוף.
למסמך הראשון כאן יש את התוכן שלו מתפרש בעוד שהשני מופק כפי שהוא.
שניהם שימושיים בסקריפט .SH, כפי שאנו עומדים לראות.
שימוש .SH סקריפטים
סקריפט .SH מופק בדרך כלל על ידי הפעלת ה- MakeSH סקריפט אחר קובץ קיים,
הפיכה פילה אל file.SH. ניקח דוגמה אחת. הנה תסריט קטן
(בואו נקרא לזה אינטסייז) שמדפיס הודעה בודדת, בגודל של int סוג נתונים ב-C.
למרבה הצער, יש לו את הערך שקשור בו, ובכך:
#!/ Bin / sh
intsize='4'
echo "במכונה זו, סוג int הוא $intsize bytes"
בוא נרוץ makeSH על זה על ידי הקלדת 'makeSH אינטסייז'. אנחנו מקבלים סינגל intsize.SH תייק את זה
נראה ככה:
מקרה $CONFIG ב
'')
if test -f config.sh; ואז TOP=.;
elif test -f ../config.sh; ואז TOP=..;
elif test -f ../../config.sh; ואז TOP=../ ..;
elif test -f ../../../config.sh; ואז TOP=../../..;
elif test -f ../../../../config.sh; ואז TOP=../../../..;
אחר
echo "לא ניתן למצוא config.sh."; יציאה 1
fi
. $TOP/config.sh
;;
esac
: זה מאלץ קבצי SH ליצור יעד באותה ספרייה כמו קובץ SH.
: זאת כדי ש-make depend תמיד יודע היכן למצוא נגזרות SH.
מקרה "$ 0" ב
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
esac
echo "חילוץ אינטסייז (עם החלפות משתנות)"
: בחלק זה של הקובץ יבוצעו החלפות משתנות.
: העבר כל דבר שזקוק ל-subs config מ-!NO!SUBS! קטע ל-!GROK!THIS!.
: הגן על כל סימני דולר וסימנים לאחור שאתה לא רוצה שיתפרשו
: על ידי הצבת קו נטוי קדמי. אתה יכול למחוק תגובות אלה.
$spitshell >intsize <
$startsh
!גרוק!זה!
: בדולרים הבאים ו-backticks לא צריך את ההלוכסן האחורי הנוסף.
$spitshell >>intsize <<'!NO!SUBS!'
intsize='4'
echo "במכונה זו, סוג int הוא $intsize bytes"
!לא!סאבים!
chmod 755 intsize
$eunicefix intsize
החלק הראשון של התסריט הזה (ב- מקרה statement) מנסה לאתר את config.sh
קובץ, על מנת לספק לו מקור. ה $CONFIG המשתנה הוא false כברירת מחדל, לפי true when
config.sh המקור כבר בוצע (מה שיקרה אם הקובץ הזה הופעל מ
בתוך גדר עצמו, אבל בואו לא נבלבל את הנושא כאן).
פעם אחת config.sh הקובץ היה מקורות, כל סמלי הקליפה מוגדרים על ידי גדר יש לו
מַעֲרֶכֶת. אנו יודעים להגיע למשפט מקרה שני, המשמש לשינוי הספרייה הנוכחית צריך א
נתיב ישמש כדי להגיע לתוכנית זו (לדוגמה אם אמרנו 'sh ../scripts/intsize.SH', אנחנו
היה רץ קודם 'cd ../סקריפטיםלפני שתמשיך). אם אתה לא מבין את זה, אל תבין
לדאוג לזה.
הנה באים הדברים המעניינים. סקריפט זה משתמש ב- $שריון משתנה, וזה לא
משהו שאנחנו יודעים עליו...עדיין. אם תסתכל בקובץ מילון המונחים, תראה את זה
זהו משתנה המוכר על ידי metaconfig. אם תהפוך את הקובץ הזה לחלק מההפצה שלך
(על ידי הכללתו בקובץ MANIFEST.new, נחזור לזה בהמשך) והפעל
metaconfig, אז ה גדר script יקבע ערך מתאים למשתנה זה
וזה ייקבע config.sh. כנ"ל לגבי $startsh והמסתורי $eunicefix at
הסוף. על מערכת סבירה, החלק הרלוונטי של config.sh ייראה כך:
ספיטשל='חתול'
startsh='#!/ Bin / sh'
eunicefix=':'
אה! אנחנו מגיעים לשם. עכשיו זה נראה מוכר. אנחנו עומדים מול רווק חתול פקודה של מי
הקלט מגיע ממסמך עם אינטרפולציה לכאן ושהפלט שלו מופנה אליו
אינטסייז. הערך יהיה זה של $startsh, כלומר '#!/ Bin / sh'. בסדר עד כה.
ואז נגיע להרחבת המסמך השנייה כאן, כדי לקבל את שאר התסריט. זֶה
זמן, סמל המסמך כאן מוקף במירכאות בודדות כך שהתוכן יהיה
צורף מילה במילה ל אינטסייז קוֹבֶץ. אז, על ידי ריצה 'sh intsize.SH', אנחנו מקבלים את
הפלט הבא:
חילוץ אינטסייז (עם החלפות משתנות)
ועל ידי התבוננות בקובץ intsize שהופק, אנו רואים:
#!/ Bin / sh
intsize='4'
echo "במכונה זו, סוג int הוא $intsize bytes"
וזה בדיוק מה שהיה לנו בהתחלה. עד כה, זה נוהל ללא ניתוח...
אבל, כמה נפלא! כך קורה (צירוף מקרים, תאמין לי!), כך metaconfig יודע
על $intsize סמל קליפה. על ידי העברת האתחול של intsize למשתנה-
אזור אינטרפולציה של סקריפט .SH ואתחולו באמצעות ה- גדר-ערך מחושב,
והסרת ההערות חסרות התועלת שנוספו על ידי makeSH, אנחנו מקבלים:
מקרה $CONFIG ב
'')
if test -f config.sh; ואז TOP=.;
elif test -f ../config.sh; ואז TOP=..;
elif test -f ../../config.sh; ואז TOP=../ ..;
elif test -f ../../../config.sh; ואז TOP=../../..;
elif test -f ../../../../config.sh; ואז TOP=../../../..;
אחר
echo "לא ניתן למצוא config.sh."; יציאה 1
fi
. $TOP/config.sh
;;
esac
מקרה "$ 0" ב
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
esac
echo "חילוץ אינטסייז (עם החלפות משתנות)"
$spitshell >intsize <
$startsh
intsize='$intsize'
!גרוק!זה!
$spitshell >>intsize <<'!NO!SUBS!'
echo "במכונה זו, סוג int הוא $intsize bytes"
!לא!סאבים!
chmod 755 intsize
$eunicefix intsize
כמובן שהפעלת סקריפט זה דרך מעטפת תפיק שוב את אותו סקריפט. אבל אם
אנחנו רצים גדר במכונה שבה א int מאוחסן ככמות של 64 סיביות, config.sh יצטרך
סט אינטסייז עד 8 וה- אינטסייז הסקריפט ישא את הערך הנכון ויודפס:
במכונה זו, סוג int הוא 8 בתים
מה שנכון. מזל טוב! זה עתה הגדרנו סקריפט מעטפת!!
הפקה config.h
כעת נוכל להסתכל על הדרך config.h מיוצר מתוך config_h.SH. אנחנו יודעים את זה
ריצה גדר מייצר א config.sh סקריפט (איך בדיוק זה נעשה זה לא בקפדנות
רלוונטי כאן, אבל לסקרנים, זה עוד החלפת מסמך כאן
גדר עצמו). ה config_h.SH עצמו נבנה על ידי metaconfig באותו הזמן
גדר הוא, בתנאי שאתה משתמש בסמל C אחד לפחות בתוך המקורות שלך.
בואו נסתכל על חלק אקראי config_h.SH קובץ כדי לראות מה באמת קורה:
מקרה $CONFIG ב
'')
if test -f config.sh; ואז TOP=.;
elif test -f ../config.sh; ואז TOP=..;
elif test -f ../../config.sh; ואז TOP=../ ..;
elif test -f ../../../config.sh; ואז TOP=../../..;
elif test -f ../../../../config.sh; ואז TOP=../../../..;
אחר
echo "לא ניתן למצוא config.sh."; יציאה 1
fi
. $TOP/config.sh
;;
esac
מקרה "$ 0" ב
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
esac
echo "חילוץ config.h (עם החלפות משתנות)"
sed config.h -e 's!^#undef!/define!' -e 's!^#un-def!#undef!'
/*
* קובץ זה הופק על ידי הפעלת הסקריפט config_h.SH, אשר
* מקבל את הערכים שלו מ-config.sh, המופק בדרך כלל על ידי
* הפעלת Configure.
*
* אל תהסס לשנות כל זה ככל שעולה הצורך. שים לב, עם זאת,
* שהפעלת config.h.SH שוב תמחק את כל השינויים שביצעת.
* לשינוי קבוע יותר ערוך את config.sh והפעל מחדש את config.h.SH.
*/
/* זמן תצורה: $cf_time
* הוגדר על ידי: $cf_by
* מערכת יעד: $myuname
*/
#ifndef _config_h_
#define _config_h_
/* bcopy:
* סמל זה ממופה ל-memcpy אם השגרה bcopy() אינה כזו
* זמין להעתקת מחרוזות.
*/
/* HAS_BCOPY:
* סמל זה מוגדר אם השגרה bcopy() זמינה עבור
* העתק בלוקים של זיכרון. אתה לא צריך להשתמש בסמל זה מתחת
* נסיבות רגילות והשתמש ב-bcopy() ישירות במקום, אשר
* ימופה ל- memcpy() אם bcopy אינו זמין.
*/
#$d_bcopy HAS_BCOPY /**/
#ifndef HAS_BCOPY
#ifdef bcopy
# un-def bcopy
#endif
#define bcopy(s,d,l) memcpy((d),(s),(l)) /* ממופה ל-memcpy */
#endif
/* HAS_DUP2:
* סמל זה, אם מוגדר, מציין כי שגרת dup2 היא
* זמין לשכפול מתארי קבצים.
*/
#$d_dup2 HAS_DUP2 /**/
/* I_STRING:
* סמל זה, אם מוגדר, מציין לתוכנית C שהוא צריך
* כולל (מערכות USG) במקום (מערכות BSD).
*/
#$i_string I_STRING /**/
#endif
!גרוק!זה!
בחלק העליון של הקובץ, אנו מזהים את מבנה ה-.SH הסטנדרטי שכבר יש לנו
למד בפירוט. לאחר מכן מגיע החילוץ של הקובץ עצמו, באמצעות מסמך כאן עם
החלפות משתנות. עם זאת, כאן איננו משתמשים במישור חתול אבל א צמא במקום זאת, מאז
אנחנו צריכים לעשות עוד עריכה תוך כדי תנועה. נראה למה בהמשך, אז בואו נשכח
על זה כרגע.
כעת אנו מגיעים להערה המובילה, והקובץ מתויג עם זמן ההגדרה, ה
מערכת יעד וכו'... (המשתנים האלה מגיעים מהמקור config.sh הקובץ היו
הוגדר על ידי גדר). כותרת התגובה הזו מלווה בהגנה '#ifndef' לשמירה
נגד הכללות מרובות של קובץ זה. ואז מגיע לב הקובץ...
זה עוזר לדעת את זה $d_* ו $i_* משתנים מוגדרים ל'לְהַגדִיר'או'undef' על ידי
גדר, תלוי אם קיימת פונקציה או קובץ include במערכת או
לֹא. כלומר:
#$d_bcopy HAS_BCOPY /**/
השורה יורחב לאחד מהשניים:
#define HAS_BCOPY /**/
אם המשתנה $d_bcopy מוגדר ל-'define' או:
#undef HAS_BCOPY /**/
אם $d_bcopy הוגדר ל'undef', כי התכונה לא הייתה שם. עם זאת, זה לא
מה נכתב ב config.h קובץ בגלל ה צמא מסנן שכבר ראינו,
מה שיהפוך את הצורה השנייה ל:
/*#define HAS_BCOPY /**/
זה טופס שימושי לעריכה מאוחרת יותר של config.h כי אתה רק צריך להסיר את
מוביל '/*' אם ברצונך לעקוף גדרהבחירה של. כמו כן, אתה יכול להוסיף סינגל
'/*' בתחילת שורת '#define' כדי להימנע מההגדרה של סמל מסוים.
זו הסיבה שכל הגדרת סמל מוגנת על ידי '/**/' נגרר, כדי לסגור את הסמל המוביל
הערה נפתחת על ידי '/*' (ההערות אינן מקוננות ב-C).
עכשיו להפוך את '#undef' ל-'/*#define' זה נחמד, אבל אם אנחנו רוצים לכתוב א
'#undef', אנחנו תקועים... אלא אם כן נכתוב את זה בתור '#un-def' ונאפשר צמא תקן את זה ל-'#undef'
תוך כדי ייצור config.h, וזה מה שנעשה כאן בפועל.
אותו סוג של נימוקים חל על שתי השורות הללו:
#$d_dup2 HAS_DUP2 /**/
#$i_string I_STRING /**/
ובהנחה config.sh מגדיר:
d_dup2='להגדיר'
i_string='undef'
ניכנס למיוצר config.h:
#define HAS_DUP2 /**/
/*#define I_STRING /**/
צלולים כמו מים זורמים? טוֹב!
עכשיו זה צריך להיות ברור שעל ידי הכללה config.h בכל קבצי מקור ה-C שלך, אתה מגיע
יודע מה גדר ניחש על המערכת שלך. למעשה, על ידי שימוש בסמלים אלה, אתה
כתיבת קוד C מוגדר, מאז metaconfig תדע שאתה צריך את הסמלים והרצון האלה
ליצור מתאים config_h.SH קובץ כמו גם את כל הקוד הדרוש ב גדר ל
לחשב ערך מתאים עבורם (על ידי הקצאת ערכים למשתני מעטפת משויכים).
ריצה Metaconfig
בואו נתמקד ב metaconfig תוכנית לזמן מה כדי להבין כיצד היא משתמשת ביחידות שלה ו
קוד המקור שלך כדי לייצר את כל קבצי התצורה הדרושים. אם אתה מתכוון לכתוב חדש
יחידות, אתה צריך להבין טוב את התוכנית כולה.
אם אין קובץ MANIFEST.new, metaconfig ינסה להשתמש בקובץ MANIFEST במקום זאת,
לנוחות. בכל מקום בו אנו מזכירים את MANIFEST.new, ניתן להבין זאת כ-MANIFEST
בתנאי שלא נמצא קובץ MANIFEST.new בשורש החבילה שלך.
בהנחה שהקובץ MANIFEST.new שלך מוגדר כהלכה ומפרט את כל קבצי המקור שאתה רוצה
להגדיר, וכי הפעלת packint בספריית מקור השורש שלך כדי ליצור א
חבילה קובץ, אתה יכול להפעיל metaconfig ותקבל את הדברים הבאים:
$ metaconfig
איתור יחידות...
מחלץ רשימות תלות מ-312 יחידות...
מחלץ שמות קבצים (*.[chyl] ו-*.SH) מ-MANIFEST.new...
בניית קובץ מבוקש...
סורק קבצי .[chyl] לאיתור סמלים...
סורק קבצי .SH לאיתור סמלים...
מחשוב גרף תלות אופטימלי...
בניית קובץ יצירה פרטי...
קביעת יחידות הניתנות לטעינה...
מעדכן את קובץ ה-make...
קביעת הסדר הנכון ליחידות...
יוצר תצורה...
בוצע.
השלב הראשון מחפש את כל קבצי היחידות (מסתיימים ב-.U) בספרייה הציבורית
ראשית, אחר כך בפרטי שלך. אם אתה מעתיק קובץ ציבורי בספריית U הפרטית שלך
(כלומר ספרייה בשם U ברמה העליונה של החבילה שלך), היא תעקוף את הציבור
גִרְסָה. ברגע שיש לו רשימה של כל היחידות הזמינות, הוא מנתח אותן ומחלץ את כולן
את השורות ?MAKE: לדעת על התלות ועל סמלי הקליפה הידועים. זה גם
מתמקד בקווי ?H: כדי ללמוד על סמלי C ואיזה סמלי מעטפת צריכים להיות
מחושב כדי לקבל ערך תקין עבור אותו סמל C (כך שיש לנו רמה נוספת של תלות
כאן).
לאחר מכן, שמות הקבצים המתאימים נשלפים מהקבצים MANIFEST.new ו-a רצה קובץ הוא
בנוי: הקובץ הזה מפרט את כל סמלי ה-C וסמלי המעטפת הדרושים לאותה חבילה. אָנוּ
תחילה סרוק את הקבצים מסוג C עבור סמלי C, ולאחר מכן הפצת את התלות שלהם
סמלי מעטפת קשורים (נאספים מ-?H: קווים). קבצי ה-.SH הבאים נסרקים ולבסוף
כל סמלי הקליפה ידועים.
Makefile זמני נבנה ומטה-קונפייג' מנסה לעשות זאת לעשות כל סמלי הקליפה לראות
אילו פקודות (המפורטות בשורות ?MAKE: השניות) מבוצעות, וכך אילו יחידות הן
באמת נחוץ. יחידות אופציונליות שלא נדרשות אחרת מוסרות ו-Makefile שני
נוצר. הפעם, אנו יודעים על כל היחידות והסדרים שלהן, אופציונלי
יחידות שהוסרו וערכי ברירת מחדל חושבו עבור סמלי המעטפת שלהן. ה
גדר לאחר מכן ניתן ליצור סקריפט, יחד עם config_h.SH. אנחנו סיימנו.
אמנות
יש לעקוב אחר מוסכמות נכונות כדי לגרום לכל התהליך להישמע. יש מקרה
מוסכמה ליחידות ומוסכמה של שמות משתנה.
כל היחידות צריכות לכלול את האות הראשונה שלהן באותיות קטנות, אלא אם הן יחידות מיוחדות. על ידי
מיוחד, אנחנו מתכוונים שהם לא ממש מגדירים משתני מעטפת חדשים שיכולים לשמש את ה-
משתמש בקבצי ה-.SH שלו, אלא יחידות המייצרות סקריפטים או משתני מעטפת שנועדו
להיות בשימוש פנימי על ידי גדר תַסרִיט. דוגמאות אופייניות הן ה Init.U קובץ שהוא
אתחול המשתנה הראשי, או Myread.U אשר מייצרת את קראתי סקריפט בשימוש כמעט
בכל מקום בפנים גדר כאשר יש לשאול שאלה למשתמש.
לאחר מכן יחידות לא מיוחדות מתחלקות לשתי קבוצות נפרדות: יחידות שמגדירות משתנים
הקשורים לסמל C וליחידות המגדירים משתני מעטפת משלהם. הקבוצה הראשונה
מחולק עוד יותר במשתנים הקשורים ל-include files (השם שלהם מתחיל ב i_) ו
משתנים הקשורים להגדרות אחרות (שם שמתחיל ב d_). לקבוצה השנייה יש
שמות העומדים בפני עצמם, למשל cc.U מגדיר את $cc משתנה מעטפת שהערך שלו הוא
מהדר C שיש להשתמש בו.
יחידות מיוחדות שומרות לעצמן לפעמים משתנה מוגדר מראש ומחזירות "תוצאות"
במשתנים ידועים אחרים. למשל, ה קראתי תסריט שהופק על ידי Myread.U
מצפה להודעה $rp, תשובת ברירת המחדל ב $dflt ומכניס את תשובת המשתמש $נס.
זה לא מתועד בדף המדריך הזה: אתה צריך ללכת ולהסתכל על היחידה עצמה
להבין באילו משתנים משתמשים וכיצד יש להשתמש ביחידה.
שימוש אל האני מילון מונחים
קובץ מילון המונחים מופק אוטומטית על ידי ה מבריק script, אשר מחלץ את
מידע מ-?S:, ?C: ו-?MAKE: קווים ומעצב אותם מחדש בסדר אלפביתי
מילון מונחים ממוין. חשוב לקרוא את מילון המונחים כדי לדעת על הסמלים שאתה
מותר להשתמש. עם זאת, מילון המונחים לא יגיד לך כיצד להשתמש בהם. בדרך כלל, זה
תלוי בך.
יום אחד, כנראה תכתוב יחידות משלך ותדע מספיק על metaconfig
לעשות זאת במהירות וביעילות. עם זאת, לעולם אל תשכח לתעד כראוי את עבודתך
הקווים ?S: ו-?C:, או שאנשים אחרים לא יוכלו לעשות בהם שימוש חוזר. זכור לגבי ה
זמן שבו היה לך רק את מילון המונחים ואת דף המדריך הזה כדי להתחיל.
סיכום
עכשיו שאתה יודע את metaconfig יסודות, כדאי לקרוא את תיאור סעיף, אם כן
דלג אל הפניה כדי ללמוד על כל הפרטים העגומים כמו המותר
תחביר עבור קווי בקרת יחידה (שורות המתחילות ב-'?') או פקודות MAKE הייחודיות
מותר לך להשתמש.
הפניה
סעיף זה מתעד את החלק הפנימי של metaconfig, בעצם תחביר היחידה, המיוחד
יחידות שכדאי לדעת עליהן וקובצי הרמז.
כללי יחידה תחביר
יחידת metaconfig מחולקת לשני חלקים נפרדים. קטע הכותרת (השורות מתחילות
עם '?') וקטע מעטפת (קוד שייכלל ב- גדר תַסרִיט). זה
אפשר להוסיף הערות '?X:' בכל מקום ביחידה, אבל האחרים '?' קווים (גם
נקרא לִשְׁלוֹט קווים) יש מדיניות הזמנות קפדנית.
אם קו בקרה ארוך מדי, אפשר להשתמש בהמשך על ידי בריחה מהגמר
שורה חדשה עם קו נטוי אחורי והמשך בשורה הבאה (שיש להכניס אותה
לפי רווחים או טאבים).
להלן תיאור רשמי של כל אחד מקווי הבקרה. אלא אם כן נאמר
אחרת, הסדר של מצגת זו הוא הסדר לשימוש ביחידה.
?RCS: חופשי טֶקסט
לשימוש להערות RCS, בחלק העליון של היחידה.
?איקס: כל טֶקסט
הערות למטרה כללית. עשוי להופיע בכל מקום ביחידה אך יש להשאירו מוצדק.
להערות RCS, אנא השתמש בטופס ?RCS: תגובה.
?עשה:סמל רשימה: התלות רשימה [+אופציונלי]
זהו קו התלות הראשון. הראשון סמל רשימה צריך לרשום את כל הסמלים
נבנה על ידי יחידה זו (כלומר שהערך שלה מחושב על ידי קטע המעטפת של היחידה).
סמלים צריכים להיות מופרדים מרווחים. אם סמל מוגדר מיועד לשימוש פנימי בלבד ו
לא אמור להופיע בקובץ שנוצר config.sh קובץ, אז יש להקדים אותו ב-a
'+' (אין לבלבל עם תלות אופציונלית המוגדרת להלן). השני
חלק מהרשימה (אחרי ':' האמצעי) הוא התלות ביחידה. זה צריך לרשום הכל
היחידות המיוחדות הדרושות, כמו גם כל הסמלים המשמשים את הקליפה
יישום. אם יש צורך בסמל אבל ערך התצורה שלו אינו קריטי, זה
ניתן להקדים אותו ב-'+', ובמקרה זה נקרא תלות מותנית: שלה
היחידה המתאימה תיטען אם, ורק אם, הסמל הזה באמת שונה
מבוקש; אחרת ישמש ערך ברירת המחדל.
?עשה:כרטיסייה הפקודה
יכולות להיות שורת פקודה אחת או יותר בעקבות שורות התלות הראשוניות. הָהֵן
הפקודות יבוצעו כאשר היחידה תרצה לטעון אותן גדר. לראות
הפיסקה על יצירת פקודות לקבלת מידע נוסף. שימו לב שהמוביל כרטיסייה
נדרש תו לפני ה- הפקודה.
?Y:פריסה
הכריז על הנחיית פריסה עבור יחידה זו. הנחיה זו עשויה להיות אחת מהמחרוזות
חלק עליון, ברירת מחדל or תחתית (המקרה לא משנה, הסגנון המומלץ הוא לאיית אותם
באותיות רישיות). אם מושמט, ברירת מחדל מניחים.
הנחיה זו נדרשת רק אם ברצונך לכפות יחידה בחלק העליון או התחתון
של הנוצר גדר סקריפט, כפי שתלות יחידה מאפשרת זאת. חָשׁוּב
שאלות עשויות להיות מאולצות בהתחלה. בתוך אותה מחלקת פריסה, יחידות
ממוינים בסדר אלפביתי עם שני מקרים מיוחדים עבור יחידות d_* ו-i_*, מאולץ
בהתאמה בחלק העליון והתחתון של הכיתות שלהם (אך אלה צריכים להיות שייכים ל-
מחלקת ברירת מחדל).
זה אתה כופה בראש יחידה שהתלות שלה מחייבת את כל היחידה האחרת
לפני זה, אתה לא משיג שום דבר מעניין. לכן, ההנחיה הזו באמת צריכה
לשמש להגדלת העדיפות של כמה יחידות אינטראקטיביות שאינן תלויות ברבים
סמלים אחרים גלויים למשתמש, כמו שאלות הקשורות לנתיב.
?S:symbol_name [(מְיוּשָׁן סמל רשימה)]:
מציג סמל מעטפת. שורה ראשונה זו נותנת שם לסמל, ואחריו אופציונלי א
רשימה מוקפת בין סוגריים ומתן המקבילה המיושנת. אלה מיושנים
הסמלים יופנו מחדש לחדש symbol_name אם -o ניתנת אפשרות ל
metaconfig.
?S:כל טקסט, ל מילון מונחים
בעצם הערה המתארת את סמל המעטפת, אשר יחולץ על ידי מבריק
לתוך קובץ מילון המונחים.
?S:. סוגר את הערת סמל הקליפה.
?C:symbol_name [~ כינוי] [(מְיוּשָׁן סמל רשימה)]:
מציג סמל C חדש. ה כינוי שם הוא השם שתחתיו יהיה סמל C
להיות נשלט, כלומר אם כינוי סמל מבוקש, אז סמל C הזה ייכתב
ב config_h.SH קוֹבֶץ. בדרך כלל, הכינוי הוא רק '%<' (מייצג את שם היחידה)
ויש גם קו ?W: הממפה סמל C ל- כינוי. גם החלקים הרלוונטיים
של השורות ?H: מוגנות במפורש על ידי תנאי '?%<'. ראה את הסמל
פסקה כינוי לפרטים נוספים. שאר הקו הוא אופציונלי
מְיוּשָׁן סמל רשימה, המפרט מקבילות ישנות לחדש symbol_name.
?C:כל טקסט, ל מילון מונחים ו config_h.SH
בעצם הערה המתארת את סמל C, אשר יחולץ על ידי מבריק
לתוך קובץ מילון המונחים ועל ידי metaconfig אל config_h.SH קובץ אם הסמל הוא
רצוי (או אם הכינוי שלו מבוקש כאשר משתמשים בכינוי סמל).
?C:. סוגר את הערת סמל C.
?H:?סמל:config_h.SH דברים
זוהי בקשת ההכללה הכללית לתוך config_h.SH. השורה נכתבת רק מתי
השמירה סמל מבוקש באמת. צורה כללית זו נחוצה כאשר סמל C
נעשה שימוש בכינוי. אחרת, אם אתה משתמש באחת מהצורות ה"סטנדרטיות" האחרות, ה
השמירה מתבצעת אוטומטית על ידי metaconfig עצמו.
?H:#$d_var VAR "$ var"
מגדיר באופן מותנה את VAR סמל C לתוך $ var מתי מוגדר ל'לְהַגדִיר'. מרמז על א
'?VAR:' מצב שמירה, ו metaconfig קישורים אוטומטיים VAR לשתי הקליפות שלו
תלות משתנים (כלומר שניהם $d_var ו $ var יסומן כ רציתי if VAR is
בשימוש במקורות C).
?H:#define VAR [אופציונלי טֶקסט]
תמיד מגדיר את VAR סמל C לערך כלשהו. מרמז על '?VAR:' מצב שמירה.
תלות קליפה אוטומטית נעשית ליחידה עצמה.
?H:#define VAR(x,y,z) $ var
תמיד מגדיר את המאקרו VAR להיות הערך של $ var מִשְׁתַנֶה. זה תלוי ב
יחידה להבטיח $ var בעל ערך הגיוני. תלות אוטומטית בין ה-C
מאקרו VAR ומשתנה הקליפה נקבע, וכל הקו נשמר על ידי an
משתמע '?VAR:'.
?H:#$d_var VAR
מגדיר באופן מותנה VAR if $d_var נקבע ל 'לְהַגדִיר'. מרמז על '?VAR:' שמירה
מַצָב. נוצרת תלות מעטפת אוטומטית לקראת $d_war.
?H:#define VAR "$ var"
מקצה ערך מוגדר ל- VAR סמל C. מרמז על '?VAR:' מצב אמון.
נוצרת תלות מעטפת אוטומטית לקישור VAR ו $ var.
?H:. סוגר את config_h.SH בקשות הכללה.
?M:C סמל: C תלות
מציג הגדרת קסם הנוגעת לסמל C, עבור confmagic.h, ומגדיר את ה
סמל שמירה עבור ההגדרות הנותרות של ?M:. השורה הזו מרמזת בשקט
'?W:%<:C סמל', כלומר היחידה תיטען ל-Configure אם יופיע סמל C
בתוך מקורות C, בין אם נעשה שימוש בקסם או לא. התלות ב-C מופעלות
כאשר משתמשים בקסם, כדי להכריח את ההגדרה שלהם פנימה config_h.SH. לעומת זאת, אם
קסם הוא לֹא בשימוש אך סמל C מופיע במקור ללא ה-C הדרוש
תלות, תקבל אזהרה בכל פעם שקובץ ה- Wanted נבנה, שכן ייתכן
בעיית ניידות (וגם בגלל שהיחידה נטענת ללא תנאי
הגדר בכל פעם שמשתמשים בסמל C, ללא קשר לקווי ?C: האחרים מה-
יחידה).
?M:cpp defs
מגדיר את מיפוי ה-cpp הקסום שיוצג ב-confmagic.h בכל פעם שהדבר הנוגע בדבר
נעשה שימוש בסמל. יש '?SYM' שומרים איפה SYM הוא שם הסמל
מוגדר על ידי קו ?M: המוביל.
?M:. סוגר את confmagic.h בקשת הכללה.
?W:פָּגָז סמל רשימה:C סמל רשימה
קושר את גורלם של סמלי הקליפה עם זה של סמלי ה-C: אם אחד מה-C
הסמלים הרשומים מבוקשים, ואז כל סמלי הקליפה מסומנים כרצויים. שימושי ל
כוח הכללת יחידה (רשימת סמלי מעטפת מוגדרת ל-'%<') כאשר נוכחות של C
סמל מזוהה. רשימת סמלי המעטפת עשויה להישאר ריקה, כדי ליהנות מהצד
השפעת מיקום סמל C בתוך המעבד המובנה מראש (היות סמל מוגדר
עבור אותו מעבד מראש אם הוא נמצא במקור). לחפש דפוסים עם רווח
בהם, עליך לצטט את סמלי C בתוך מרכאות פשוטות, כמו ב'struct
אזור זמן'.
?V:לקריאה בלבד סמלים:לקרוא-לכתוב סמלים
זה metalint רמז ויש להשתמש בו רק ביחידות מיוחדות המייצאות מעטפת כלשהי
משתנים. המשתנים לפני ה-':' האמצעי מיוצאים לקריאה בלבד (בשינוי שלהם
יוציא אזהרה), בעוד שסמלים אחרים עשויים להיקרא ולשנות בחופשיות.
?F:קבצים נוצר
קו זה משרת שתי מטרות: הוא א metalint רמז, וגם מציין מיקום עבור
עתיד jmake להשתמש. זה חייב לרשום שלושה סוגים של קבצים: הזמני שהם
נוצרו לבדיקה, אלו הפרטיים של UU שנוצרו בספריית UU למועד מאוחר יותר
עיון, והציבוריים שנותרו בספריית השורש של החבילה. זמני
קבצים חייבים להיות רשומים עם '!' קודם לכן תו (כלומר "לא! אין בהם שימוש חוזר
מאוחר יותר!"), יש להקדים את קובצי UU פרטיים ב-'./' (כלומר: כדי להשתמש בהם, נניח
./קוֹבֶץ, לא רק פילה), ויש לקרוא לציבוריים כפי שהם.
?T:פָּגָז זמניות
אחר metalint רֶמֶז. שורה זו מפרטת את כל משתני המעטפת המשמשים כזמניים
בתוך חלק המעטפת של יחידה זו.
?D:סמל='ערך'
ערך אתחול עבור סמלים המשמשים כתלות מותנית. אם לא? D: קו הוא
נמצא, אז נעשה שימוש בערך null במקום זאת. ה metalint התוכנית תזהיר אותך אם א
סמל משמש לפחות פעם אחת כתלות מותנית ואין לו תקין
?D: אתחול. זה מנהג טוב להוסיף את השורות האלה אפילו עבור ריק
אתחול מכיוון שהוא מדגיש את האופי האופציונלי של סמל.
?O:כל הודעה אתה רוצה
הנחיה זו מציינת כי יחידה זו מיושנת כמכלול. בכל פעם שימוש בכל
מהסמלים שלו נעשה (או שימוש עקיף באמצעות תלות), ההודעה מופצת ב-
המסך (על stderr). אתה יכול לשים שורה אחת או יותר, ובמקרה זה כל שורה תהיה
להיות מודפס, לפי הסדר.
?מוֹך:metalint רמזים
ראה metalint דף מדריך להסבר על הרמזים המובהקים שיכולים להיות
מְשׁוּמָשׁ.
?INIT:אתחול קוד
קוד האתחול שצוין בשורה זו ייטען בחלק העליון של
גדר סקריפט בתנאי שהיחידה נחוצה.
C סמל כינוי
לפעמים אי אפשר לסמוך עליו metaconfigבחירת ברירת המחדל של עצמו עבור config_h.SH
הערות והגדרת סמל C. זה המקום שבו הכינוי נכנס לתמונה. מכיוון שזה יותר נכון
מסובך להסביר, נלמד דוגמה כדי להבין את המנגנון הבסיסי.
היחידה d_const.U מנסה לקבוע אם מהדר ה-C שלך ידוע על ה- const
מילת מפתח. אם לא, אנחנו רוצים למפות מחדש את מילת המפתח למחרוזת null, כדי לאפשר את
קומפילציה של תוכנית. יתר על כן, אנו רוצים להפעיל אוטומטית את הבדיקה כאשר const מילה
משמש.
להלן החלקים הרלוונטיים של יחידת d_const.U:
?MAKE:d_const: cat cc ccflags Setvar
?MAKE: -בחר הוסף $@ %<
?S:d_const:
?S: משתנה זה מגדיר באופן מותנה את סמל HASCONST, אשר
?S: מציין לתוכנית C כי מהדר C זה יודע על
?S: סוג const.
?S:.
?C:HASCONST ~ %<:
?C: סמל זה, אם מוגדר, מציין שהמהדר C הזה יודע על
?C: סוג ה-const. אין צורך באמת לבדוק את הסמל הזה
?C: בתוך התוכניות שלך. עצם השימוש במילת המפתח "const" יעשה זאת
?C: הפעל את הבדיקות הדרושות.
?C:.
?H:?%<:#$d_const HASCONST /**/
?H:?%<:#ifndef HASCONST
?H:?%<:#define const
?H:?%<:#endif
?H:.
?W:%<:const
?LINT:set d_const
?LINT:קונסט ידוע ידוע
: בדוק את מילת המפתח const
הד ""
echo 'בודק אם מהדר C שלך יודע על "const"...' >&4
/bin/cat >const.c <<'EOCP'
עיקרי ()
{
const char *foo;
}
EOCP
if $cc -c $ccflags const.c >/dev/null 2>&1 ; לאחר מכן
val="$define"
הד "כן, זה כן."
אחר
val="$undef"
הד "לא, זה לא."
fi
set d_const
eval $setvar
ראשית אנו מבחינים בשימוש בקו ?W:, שאומר בעצם: "היחידה הזו מבוקשת כאשר
const מילת מפתח משמשת בקובץ C." על מנת למפות מחדש באופן מותנה const עד אפס
מחרוזת config.h, בחרתי להגדיר בתנאי HASCONST באמצעות $d_const.
עם זאת, זה מעורר בעיה, כי HASCONST הסמל לא ישמש ב-
מקורות, רק את const אסימון הוא. והקו ?H: מגדיר HASCONST הוא באופן מרומז
נשמר על ידי '?HASCONST'. לכן, עלינו להוסיף את האילוץ המפורש '?%<' כדי לספר
metaconfig שיש לכלול את השורות האלה config_h.SH בכל פעם שהסמל '%<'
מבוקש (%< מתייחס לשם היחידה, כאן d_const).
זה כמעט מושלם, כי הקו ?W: ירצה d_const בכל פעם const משמש, אם כן
קווי ה-?H: ייכללו ב- config_h.SH קוֹבֶץ. עם זאת, ההערה המובילה (?C:
קווים) מחוברים HASCONST הוא עצמו גם נשמר באמצעות HASCONST, כלומר יש לו מרומז
אילוץ '?HASCONST'. מכאן הצורך ב כינוס מה היא HASCONST סמל ל'%<'.
החלק הנותר של היחידה (חלק המעטפת) הוא ממש פשוט. זה פשוט
מנסה להרכיב תוכנית C לדוגמה באמצעות ה const מילת מפתח. אם זה יכול, אז זה יהיה
לְהַגדִיר $d_const באמצעות $setvar פונקציה (מוגדרת על ידי Setvar.U יחידה). ראה את הפסקה
על יחידות מיוחדות לפרטים נוספים.
לעשות פקודות
בשורת הפקודה ?MAKE:, תוכל לכתוב פקודת מעטפת שתתבצע כפי שהיא או א
מיוחד -לִבחוֹר פקודה אשר לכודה על ידי metaconfig ונתח כדי לראות מה צריך להיות
בוצע. ה'-' המוביל נמצא שם רק כדי למנוע לעשות מכשל כאשר הפקודה חוזרת
מצב שאינו אפס -- זה לא ממש נחוץ מכיוון שאנו משתמשים ב-לעשות -n' כדי לפתור את
תלות, אבל אני ממליץ לך לשמור אותו למקרה שהוא יהפוך לחובה בגרסאות עתידיות.
התחביר של לבחור הפקודה היא:
-לִבחוֹר cmd $@ קובץ מטרה
איפה $@ הוא המאקרו הסטנדרטי בתוך Makefiles המייצג את היעד הנוכחי (השם
של היחידה הנבנית, כשהסיומת .U הסופית הופשטה). ה cmd החלק הוא ה
ממשי metaconfig הפקודה להפעלה, וה- קובץ מטרה הוא עוד פרמטר, של מי
הפרשנות תלויה ב cmd עצמו. יש לו גם סיומת .U הסופית שלו מופשטת ו
בדרך כלל מתייחס לקובץ יחידה, אלא אם הוא מתחיל ב-'./' ובמקרה זה מתייחס לקובץ אחד
של metaconfig שליטה בקבצים ב'.MT במדריך.
הפקודות הזמינות הן:
הוסף מוסיף את קובץ מטרה ל גדר.
add.Config_sh
ממלא את החלק הזה של גדר ייצור הייצור config.sh קוֹבֶץ. בשימוש בלבד
מתווספים משתנים, מותנים (מתלות מותנית).
דילג.
add.Null מוסיף את הקטע המאתחל את כל משתני המעטפת המשמשים למחרוזת ריקה.
c_h_weed מייצר את config_h.SH קוֹבֶץ. רק השורות הדרושות מודפסות.
cm_h_weed מייצר את confmagic.h קוֹבֶץ. רק השורות הדרושות מודפסות. זֶה
הפקודה מופעלת רק כאשר -M מתג ניתן, או כאשר א confmagic.h פילה
כבר קיים.
close.Config_sh
מוסיף את הסמל הסופי 'EOT' בשורה בפני עצמה כדי לסיים את המסמך כאן
לבנות לייצר את config.sh קובץ.
prepend מקיף את תוכן היעד ל- קובץ מטרה אם הקובץ לא ריק.
עשב מוסיף את היחידה ל גדר כמו להוסיף פקודה, אבל בצע כמה בדיקות נוספות
להסיר את ה'?סמל' ו'%סמל' שורות מה קובץ מטרה אם הסמל
אינו רצוי או מבוקש על תנאי. הטופס '%' נמצא בשימוש פנימי רק על ידי
metaconfig תוך הפקת קבצי .U משלו ב-'.MTספריה.
מחק אותו דבר כמו להוסיף באמת, אבל מבצע החלפת מאקרו נוספת. ה
פקודות מאקרו זמינות מתוארות ב- קשיח מאקרו פסקה.
כהערה צדדית, metaconfig מייצר א -מצב פקודה פנימית להתמודד עם מותנה
תלות. אתה לא צריך להשתמש בו לבד, אבל אתה תראה אותו אם תסרוק את
נוצר קובץ Makefile ב .MT במדריך.
קשיח מאקרו
פקודות המאקרו הבאות מזוהות על ידי נגב פקודה והחליפו לפני הכללה ב
גדר:
מספר גרסת הבסיס של החבילה, נגזר מ חבילה.
התאריך הנוכחי.
כתובת הדואר האלקטרוני של המתחזק של חבילה זו, נגזרת ממך
חבילה.
שם החבילה, כפי שנגזר ממך חבילה קובץ.
רמת התיקון של metaconfig תוכנית (הוצא משימוש לטובת ).
רמת הגרסה של SVN של metaconfig תכנית.
מספר הגרסה של ה- metaconfig תכנית.
פקודות המאקרו הללו משמשות בעיקר לזיהוי metaconfig גרסה שיצרה א
מסוים גדר סקריפט ועבור איזו חבילה זה נעשה. כתובת הדואר האלקטרוני של
מתחזקת מקושרת בהוראות המובילות ש גדר מודפס בעת ההפעלה.
אחרון metaconfig גרסאות מבינות תחביר כללי הרבה יותר של הצורה:
אשר מוחלף בזמן יצירת Configure בערך של משתנה נלקח ממך
חבילה קוֹבֶץ. בסופו של דבר, פורמט המאקרו הקשיח הישן ייעלם, ו
יחליף את בכל היחידות שסופקו.
מיוחד יחידות
היחידות המיוחדות הבאות משמשות לחלוקת קוד לגורמים ולספק רמה גבוהה יותר
פונקציונליות. הם מייצרים סקריפט מעטפת שניתן למקור או מעטפת
משתנה שיכול להיות הערכה'אד. העברת פרמטרים נעשית גם באמצעות משתנים ידועים
שם או אנונימי כמו $1, $2 וכו'... (שניתן להגדיר בקלות דרך המעטפת סט
מַפעִיל). מתי גדר מבצע, הוא יוצר ונכנס לתוך א UU ספרייה, אז כל
הסקריפט שהופק נמצא שם ואינו מפריע לקבצים מהחבילה שלך.
להלן היחידות המיוחדות שכדאי לדעת עליהן, והדרך להשתמש בהן.
Cppsym.U
יחידה זו מייצרת סקריפט מעטפת הנקרא Cppsym, שבו ניתן להשתמש כדי לקבוע
האם סמל כלשהו ברשימה מוגדר על ידי מעבד הקדם C או המהדר C שברשותך
נָקוּב. זה יכול לקבוע את הסטטוס של כל סמל, אם כי הסמלים ב
(רשימת תכונות) נקבעים בקלות רבה יותר.
Csym.U
זה מגדיר את משתנה מעטפת $csym, בשימוש פנימי על ידי גדר לבדוק האם א
סמל C נתון מוגדר או לא. שימוש טיפוסי הוא:
הגדר תוצאת סמל [-fva] [קודם]
eval $csym
זה יקבע את תוצאה משתנה ל-'true' אם הפונקציה [-f], משתנה [-v] או
מערך [-a] מוגדר, 'false' אחרת. אם ניתן ערך קודם וה- -r
מתג סופק ל גדר (ראה גדר אפשרויות פסקה), ואז זה
נעשה שימוש חוזר בערך ללא שאלה.
הדרך שבה חישוב זה מתבצע תלויה בתשובה שהמשתמש נותן לשאלה
גדר ישאל אם זה צריך לבצע an nm מיצוי או לא. אם ה
חילוץ בוצע, היחידה פשוט מסתכלת ברשימת הסמלים, אחרת
הוא מבצע בדיקת קישור קומפילציה, אלא אם כן -r ניתן לשימוש חוזר במחושב הקודם
ערך, באופן טבעי...
End.U
על ידי העתקת יחידה זו לפרטי שלך U ספרייה והוספה של תלות ב-
?עשה: קו, אתה יכול לאלץ יחידה נתונה להיטען לתוך גדר גם אם זה לא
מבוקש אחרת. יחידות מסוימות עשויות להיאלץ רק בכוח גדר בצורה זו.
Filexp.U
יחידה זו מייצרת סקריפט מעטפת filexp שירחיב את שמות הקבצים שמתחילים ב
טילדס. שימוש טיפוסי הוא:
exp_name=`./filexp $name`
כדי להקצות את שם הקובץ המורחב exp_name.
Findhdr.U
יחידה זו מייצרת א findhdr סקריפט המשמש לאיתור קבצי הכותרת ב
$usrinc או מקומות זרים אחרים המשתמשים ביכולות cpp. לתסריט ניתן an
כלול שם בסיס קובץ כמו 'stdio.h' או 'sys/file.h' והוא מחזיר את הנתיב המלא של
קובץ inlcude ומצב אפס אם נמצא, או מחרוזת ריקה ומצב שאינו אפס
אם לא ניתן היה לאתר את הקובץ.
Getfile.U
יחידה זו מייצרת מעט קוד מעטפת שחייב להיות מקורו כדי לקבל קובץ
שם ותבצע כמה בדיקות שפיות. לחלופין, מתבצעת הרחבת ~name.
כדי להשתמש ביחידה זו, $rp ו $dflt חייב להחזיק את השאלה ואת תשובת ברירת המחדל, אשר
יועבר כפי שהוא ל- קראתי תסריט (ראה בקרוב Myread.U). $fn
משתנה שולט בפעולה והתוצאה מוחזרת לתוך $נס.
כדי לאתר קובץ או ספרייה, הכנס 'f' או 'd' f~/. אם מופיע '~', אז ~שם
החלפה מותרת. אם מופיע '/', רק שמות נתיבים מוחלטים מתקבלים ו
~ החלפות שמות תמיד מורחבות לפני החזרה. אם מצוין '+',
בדיקות קיום מדלגות. אם 'n' מופיע בפנים $fn, אז המשתמש רשאי לעשות זאת
לענות 'אף אחד'.
בדרך כלל, אלא אם ביקשת ניידות, החלפת שם ~ מתרחשת כאשר מתבקש.
עם זאת, יש פעמים שאתה רוצה לעקוף את הניידות ולאלץ את
החלפה. אתה יכול להשתמש באות 'e' (להרחיב) כדי לעשות זאת.
אם נעשה שימוש בסוג 'l' (איתור) המיוחד, אזי $fn המשתנה חייב להסתיים ב-':',
ואחריו שם בסיס קובץ. אם התשובה היא ספרייה, שם הבסיס של הקובץ יהיה
מצורף לפני בדיקת קיום הקובץ. זה שימושי בשאלות בסגנון איתור
ככה:
dflt='~news/lib'
: אין צורך לציין 'd' או 'f' כאשר נעשה שימוש ב-'l'
fn='l~:active'
rp='איפה הקובץ הפעיל?'
. ./getfile
active="$ans"
בנוסף, האות 'p' (נתיב) עשויה לשמש בשילוב עם 'l' כדי לספר
getfile שיש לקבל תשובה ללא '/' בה, בהנחה שכן
להיות ב-PATH של כולם בזמן שבו יהיה צורך בערך זה.
שימושית גם היא האפשרות לציין רשימה של תשובות שיש לקבל
מילה במילה, עוקף את כל הבדיקות. רשימה זו חייבת להיות בתוך סוגריים ופריטים
חייב להיות מופרד בפסיק, ללא רווחים משלבים. אל תשכח לצטט את
המחרוזת המתקבלת מכיוון שסוגריים הם בעלי משמעות לקליפה. לדוגמה:
dflt='/bin/install'
fn='/fe~(install,./install)'
rp='להשתמש באיזו תוכנית התקנה?'
. ./getfile
install="$ans"
יאפשר למשתמש לציין רק נתיבים מלאים המתייחסים לקבצים קיימים,
אבל עדיין אפשר את התשובות המיוחדות "install" ו-"./install" כפי שהן (בהנחה של
כמובן שמשהו יטפל בהם במיוחד בהמשך השרשרת מכיוון שהם עושים זאת
לא תואם את המסגרת הכללית הצפויה).
אם התשובה לשאלה היא 'אין', אזי מדלגים על בדיקות הקיום ו
המחרוזת הריקה מוחזרת. שימו לב שמאז getfile שיחות קראתי פנימית, הכל
התכונות הזמינות עם קראתי להחיל כאן ל.
אם יש צורך בערך מורחב לחלוטין (למשל ב-Makefile), אתה יכול להשתמש
מה היא $ansexp משתנה אשר תמיד מוגדר כראוי על ידי getfile כמו המורחב
גרסה של $נס. כמובן, זה לא ירחיב את ~name אם לא אפשרת זאת ב-
מקום ראשון ב $fn משתנה
Inhdr.U
יחידה זו מייצרת את $inhdr משתנה מעטפת, בשימוש פנימי על ידי גדר כדי לבדוק את
אם קיימת קבוצה של כותרות או לא. שימוש טיפוסי הוא:
set header i_header [ header2 i_header2 ... ]
eval $inhdr
זה ידפיס הודעה שאומרת אם הכותרת נמצאה או לא ותגדיר את
i_header משתנה בהתאם. אם צוין יותר מכותרת אחת והראשונה
הכותרת לא נמצאה, ננסה את הבא, עד שהרשימה תתרוקן או שתמצא אחת.
Inlibc.U
יחידה זו מייצרת את $inlibc משתנה מעטפת, בשימוש פנימי על ידי גדר כדי לבדוק את
אם פונקציית C נתונה מוגדרת או לא. שימוש טיפוסי הוא:
הגדר את הפונקציה d_func
eval $inlibc
זה ידפיס הודעה, האומרת אם הפונקציה נמצאה או לא והוגדרה
$d_func בהתאם לכך. באופן פנימי, הוא השתמש ב- $csym שגרה.
Loc.U
יחידה חשובה זו מייצרת סקריפט מעטפת loc שניתן להשתמש בו כדי לגלות היכן
ברשימה של ספריות נמצא קובץ נתון. הארגומנט הראשון מציין את הקובץ ל
להיות ממוקם, הארגומנט השני הוא מה שיוחזר אם החיפוש ייכשל, וה-
ארגומנטים reamining הם רשימה של ספריות שבהן יש לחפש את הקובץ. ל
למשל:
dflt=`./loc sendmail.cf X / Usr / lib /var/lib/sendmail / lib`
היה קובע $dflt ל X אם לא sendmail.cf הקובץ נמצא תחת הספריות הרשומות,
או משהו כמו /usr/lib/sendmail.cf במערכות מסוימות. ראה גם Getfile.U.
MailAuthor.U
יחידה זו צריכה להיכלל בקו ?MAKE: של End.U פרטי משלך לעשות
זה לתוך גדר. הוא מציע למשתמש לרשום את עצמו למחבר, אופציונלי
קבלת הודעה כשמגיעים תיקונים חדשים או קבלתם אוטומטית בעת ההנפקה.
עליך להתקין סוכן דואר לעשות זאת (לפחות גרסה 3.0).
MailList.U
יחידה זו צריכה להיכלל בקו ?MAKE: של End.U פרטי משלך לעשות
זה לתוך גדר. הוא מציע למשתמש להירשם או לבטל את הרישום לרשימת תפוצה
היכן מתקיים דיון הקשור לחבילה. אתה צריך לרוץ packinit
וענה על השאלות הקשורות לרשימת התפוצה כדי להגדיר את המשתנים הנכונים שלך
חבילה לפני שהיחידה הזו תפעל.
Myinit.U
העתק את היחידה הזו לפרטי שלך U ספרייה כדי להוסיף ערכי ברירת מחדל משלך לכמה
משתנים פנימיים. יחידה זו נטענת לתוך גדר אחרי הכל ברירת המחדל
אתחולים נעשו.
Myread.U
יחידה זו מייצרת את קראתי סקריפט shell שחייב להיות מקורו כדי לבצע א
לקרוא. זה מאפשר בריחת מעטפת, הקצאת ברירת מחדל והערכת פרמטרים, כמו
מתועד ביחידת Instruct.U. זה גם מאפשר הגדרה דינמית של -d אוֹפְּצִיָה,
אשר ישמש את יתרת ביצוע הסקריפט.
כדי להשתמש ביחידה זו, $rp חייב להחזיק את השאלה ו $dflt צריך להכיל את ברירת המחדל
תשובה. השאלה תודפס על ידי התסריט עצמו, והתוצאה תוחזר
ב $נס משתנה
הנה שימוש טיפוסי:
dflt='y'
rp='שאלה?'
. ./myread
value="$ans"
עיין ביחידה עצמה למידע נוסף.
Oldconfig.U
יחידה זו חייבת להיות חלק מהשורה התלות שלך ?MAKE: כאשר חלק מהיחידות שלך מנסים
לעשות שימוש חוזר בערך סמל ישן. יחידה זו אחראית לקבל את התשובות הישנות
החל מ- config.sh או מתן רמזים שימושיים בעת הפעלה על פלטפורמה נתונה עבור
פעם ראשונה. ראה את גדר רמזים פסקה למידע נוסף על רמזים.
Prefixit.U
מטרת יחידה זו היא לזהות שינויים בספריית קידומת ההתקנה אל
לחשב מחדש אוטומטית ברירות מחדל מתאימות מתשובות קודמות. זה מסתמך על
ערך ה- $oldprefix משתנה המחזיק את ספריית הקידומת הקודמת כאשר הוא
שונה, והוא ריק אחרת. לדוגמה, אם הקידומת שונתה מ / opt ל
/ usr / local, ואז ספריית ההתקנה הבינארית הקודמת תשתנה מ
/opt/bin ל / usr / local / bin, או יישאר ללא שינוי אם זה היה, למשל, / סל.
אתה צריך להתקשר סט לפני הנפקת הערכה on $prefixit, כגון:
set dflt var [dir]
eval $prefixit
אשר יקבע $dflt ל $ var or $prefix/dir תלוי אם הקידומת נשארה
אותו דבר או לא. אם dir הוא המחרוזת אף לא אחד, ערך רווח בודד ב $dflt נשמר כמו-
הוא, גם כאשר הקידומת משתנה. אם dir מושמט, אם כן $dflt מוגדר לריק
מחרוזת אם הקידומת השתנתה, ל $ var אחרת.
Prefixup.U
הכוונה של היחידה הזו דומה לזו של Prefixit.U, כלומר היא עוזרת לתקן את
מחרוזת ברירת מחדל כדי להתאים לשינויים בקידומת. עם זאת, משתנה המעטפת $prefixup,
כאשר הוא מוערך, ישחזר רק הרחבות ~שם, אם הקידומת תשתמש ב-escape כזה
מַנגָנוֹן. השתמש בו בתור:
הגדר dflt
eval $prefixup
לפני הנחיה דרך getfile לדוגמה. אם הקידומת לא עושה שימוש ב-~name
הרחבה, אז האמור לעיל יהיה ללא הפעלה על y משתנה, באופן טבעי.
Typedef.U
יחידה זו מייצרת את $typedef משתנה מעטפת, בשימוש פנימי על ידי גדר כדי לבדוק את
בין אם קיים typedef או לא. שימוש טיפוסי הוא:
set typedef val_t default [ כולל ]
eval $typedef
זה יגדיר את המשתנה val_t לערך של ברירת מחדל אם ה-typedef לא נמצא
בין הרשומים כוללים קבצים, או ל typedef אם נמצא. אם אין קבצים כוללים
שצוין, היחידה מסתכלת פנימה רק. אם תציין כמה כולל, בלבד
מסתכלים עליהם.
Unix.U
מטרת יחידה זו היא להגדיר כמה מה-UNIX-איזמים הנפוצים ביותר באמצעות משתנים
אשר ניתן לשנות משורת הפקודה או באמצעות קבצי רמז מתאימים. באופן מיוחד,
$_exe, $_o ו $_a מוכנים. יש להתייחס לכל היחידות $_o ולא ל .o באופן ישיר.
ה '.' הוא חלק מהמשתנים הללו.
Setvar.U
יחידה זו מייצרת את המשתנה, שבו נעשה שימוש פנימי על ידי גדר להגדיר א
לְהַגדִירערך /undef לסמל נתון, פולט אזהרה כאשר הוא משתנה לפתע
מערך קודם. לדוגמה:
val="$define"
הגדר d_variable
eval $setvar
אם הקודם $d_variable הערך לא היה ריק ו $val הוא שונה, "וואו"
מונפקת אזהרה.
Whoa.U
יחידה זו מייצרת את נו תסריט, שפולט אזהרה כאשר ה ערך במשתנה
ששמו $ var אינו זהה לערך הקודם הישן שלו $היה. עַל
לחזור, $td ו $tu להחזיק בערך הראוי ל לְהַגדִיר or undef המשתנה. לִרְאוֹת
דוגמאות ב Inlibc.U.
מובנה מעבד מראש
כל יחידה להיכלל בה גדר מופעל דרך מעבד קדם מובנה. מִרֹאשׁ-
הצהרות מעבד מוצגות על ידי התו '@' ('#' היא הערת המעטפת
אופי). הוא מתפקד רק כפי שפועל מראש המעבד C אך מאפשר מעטפת ו-perl
בורח. להלן הפונקציות הזמינות:
@אם ביטוי
If ביטוי נכון, המשך לטעון את הקוד עד @end, @elsif או @else.
@elsif ביטוי
בחירה חלופית. אם ביטוי נכון, המשך לטעון את הקוד עד @end,
@elsif או @else אחר.
@else קוד ברירת מחדל לטעינה אם ה-@if ביטוי היה שקרי ואף אחד מה
אופציונלי תואם @elsif. טען עד @end.
@end סגור את הצהרת הטעינה המותנית שנפתחה על ידי @if.
@לְהַגדִיר סמל
אומר את זה למעבד הקדם סמל מוגדר מעתה ואילך.
המותנה ביטוי יכול לכלול שמות סמלים (הערך נכון אם סמל מבוקש או
מוגדר באמצעות @לְהַגדִיר או בריחת פגז/פרל. ניתן לשלב את האטומים הללו באמצעות ה
אופרטורים בוליאניים מסורתיים '!' עבור שלילה, '&&' עבור לוגי ו, ו-'||' עבור הגיוני
או.
טקסט מוקף בתוך סוגריים בודדים הוא בדיקת מעטפת, בעוד טקסט בין סוגריים כפולים כן
מבחן perl. כלומר הביטויים:
{ פָּגָז טֶקסט }
{{ פרל טֶקסט }}
מתורגמים ל:
if פָּגָז טֶקסט >/dev/null 2>&1; ואז צא מ-0; אחרת יציאה 1; fi
אםפרל טֶקסט) {יציאה 0;} אחרת {יציאה 1;}
ומצב היציאה משמש בדרך הסטנדרטית כדי לקבל ערך בוליאני, כלומר 0 הוא נכון ו
כל השאר שקרי. שימו לב שניתן לבטא רק תנאים פשוטים ב-perl, עד
ניתן לטעון בתוכו קוד מורכב כלשהו metaconfig והוצאה להורג.
ניתן להשתמש במעבד המקדים המובנה לכוונון עדין של יחידות מסוימות (ראה d_gethname.U עבור
דוגמה מורכבת) בהתאם לסמלים המשמשים בפועל את התוכנית או הקבצים
נוכח בהפצה. למשל, ה Oldconfig.U משתמש בבדיקה כמו:
@if {test -d ../hints}
ו גדר יכיל קוד תלוי רמז רק אם יש א רמזים מדריך בספרייה
הספרייה ברמה העליונה של החבילה. שימו לב שהבדיקות מתבצעות מתוך ה-'.MT'ספרייה,
מכאן ה-'../' הדרוש במבחן.
ניתן להשתמש במעבד המוקדם גם כדי להימנע מהכנסת קוד חסר תועלת כאשר סמל אינו
מוּגדָר. ניתן להגן כך על יחידות שמגדירות יותר מסמל אחד (מכיוון שהיחידה היא
נטען כמכלול) על ידי איסוף קוד תלוי סמל בתוך זוג @if/@end. ל
למשל:
@if I_TIME || I_SYS_TIME || I_SYS_TIME_KERNEL
need_time_h='true'
@אַחֵר
need_time_h='false'
@סוֹף
יבדוק אם קוד המקור עושה שימוש כלשהו באחד משלושת הסמלים השולטים
מה היא זמן or sys/time.h הכללה והגדר את סמל הקליפה בהתאם. זה נותן
גדר משוב על מה שהמקורות צריכים ולהימנע מהחיסרון של תיקון
יחידות קפואות.
באמצעות שורות '?W:', אתה יכול לקבל שילובים מעניינים. למשל, ה i_time.U יחידה
צריך לדעת אם מקורות C עושים שימוש כלשהו ב- מבנה אזור זמן סוּג. לָכֵן,
השורה:
?W::zone time
משמש לתופעת הלוואי שלו של הגדרת הסמל אזור זמן עבור המעבד המקדים. ה
קוד יחידה יכול לומר אז:
@if אזור זמן
עבור s_timezone ב-'-DS_TIMEZONE' ''; לַעֲשׂוֹת
@אַחֵר
s_timezone=''
@סוֹף
... קוד באמצעות s_timezone ...
@if אזור זמן
עשה
@סוֹף
ויש לו לולאה נוספת שמנסה שני ערכים עוקבים עבור ה s_timezone משתנה, אבל רק
במידת צורך.
מְיוּשָׁן סמלים
סמלים מיושנים נשמרים כדי להקל על המעבר עם ישנים יותר metaconfig יחידות. אֶלָא אִם
מה היא -o מתג מועבר ל metaconfig יתעלמו מהם. עם זאת, א מְיוּשָׁן קובץ יהיה
להיווצר, ולומר לך אילו קבצים עושים שימוש באותם סמלים מיושנים ובמה
הם הסמלים החדשים שיש להשתמש בהם.
משך החיים של סמלים מיושנים הוא גרסה אחת מלאה, כלומר הם יוסרו כאשר
הגרסה הבאה של הבסיס מונפקת (שדרוגי תיקון לא נחשבים כמובן). לכן, זה
חכם לתרגם את המקורות שלך ולהתחיל להשתמש בסמלים החדשים בהקדם האפשרי.
גדר רמזים
יכול לקרות שהלוגיקת התצורה הפנימית עושה את הבחירות השגויות. ל
למשל, בפלטפורמה כלשהי, ה vfork () קריאת המערכת קיימת אך פגומה, אז היא צריכה
לא לשמש. לא ניתן לכלול את הידע הזה ביחידות עצמן, כי
זו עשויה להיות בעיה זמנית שהספק יתקן בסופו של דבר, או משהו כזה
הוצג על ידי שדרוג מערכת הפעלה חדש.
בכל מקרה, עבור כל הבעיות הקטנות האלה שהן ספציפיות מדי למערכת, metaconfig
מספק תמיכה בקבצי רמז. כדי להשתמש בו, עליך ליצור א רמזים מדריך בספרייה
הספרייה ברמה העליונה של החבילה, וקבל אותה כשאתה רץ metaconfig. זה יטען את
חלק הקשור לרמז מ Oldconfig.U.
מכאן ואילך, תוכל להגדיר מראש כמה ממשתני המעטפת גדר משתמש במערכת הפעלה ספציפית
קובץ .sh. יש קוד בפנים Oldconfig.U שמנסה לנחש באילו קבצי רמז נחוצים
מחשוב שם סטנדרטי המבוסס על שם מערכת ההפעלה של המערכת, שם הליבה, המהדורה
מספר וכו'... מכיוון שסביר להניח שמידע זה ישתנה במהירות, אני לא מתעד אותו
כאן. אתה צריך להנדס לאחור את הקוד מ Oldconfig.U.
כאשר אתה משחרר לראשונה את החבילה שלך, ספריית קבצי הרמז שלך צריכה להיות ריקה. אם ה
משתמשים בחבילה שלך מתלוננים שיש להם בעיה עם גדר ברירת מחדל על א
מערכת מסוימת, אתה צריך לראות אם זו בעיה ספציפית לפלטפורמה או א
כללית. במקרה הקודם, הגיע הזמן להציג קובץ רמז חדש, בעוד ב-
אחרון, יש לתקן את היחידה המתאימה.
לדוגמה, ידוע כי מערכות SGI נשברו vfork () שיחת מערכת, נכון לעכשיו
כְּתִיבָה. ושם קובץ הרמז המתאים הוא sgi.sh. אז כל מה שאתה צריך לעשות זה ליצור
a hints/sgi.sh קובץ שבו אתה כותב:
d_vfork="$define"
שתמיד ימפה מחדש vfork on מזלג (ראה d_vfork.U). כאשר פועל על מערכות SGI עבור
פעם ראשונה, גדר יזהה שיש hints/sgi.sh קובץ, ושאנחנו נמצאים
מכונת IRIX (שם הליבה הוא לעתים קרובות /irix), לכן היא תציע sgi בתור
רמז אפשרי. אם המשתמש מקבל את זה, ומאז ה $d_vfork הערך משתנה באמצעות
$setvar להתקשר, א נו! ייפלט כדי להזהיר שאנו עומדים לעקוף את הערך
מחושב על ידי גדר.
שימו לב שאתם לא חייבים לספק את כל הרמזים הידועים על ידי Oldconfig.U. אם קובץ רמז הוא
חסר, הוא לא יוצע כבחירה אפשרית. המבחנים ההיוריסטים רצו לחישוב
המועמדים הרמזים האפשריים הם רעועים. אם יש לך ערכים חדשים או בדיקות שונות, בבקשה
שלח אותם אליי...
מגבילים מבחר
אם אתה יוצר config.over קובץ בספרייה ברמה העליונה, גדר ישאל אותך אם אתה
רוצה לטעון אותו כדי לעקוף את ערכי ברירת המחדל. זה נעשה לפני יצירה של
config.sh קובץ, כך שהוא נותן לך הזדמנות לתקן את הערכים המאוחסנים שם.
זה נבדל מגישת הרמזים בכך שזהו קובץ מקומי, שהמשתמש הוא
חופשי ליצור לשימוש שלו. אתה לא צריך לספק קובץ כזה בעצמך, אלא לתת את
המשתמש יודע על אפשרות זו.
גדר אפשרויות
אל האני גדר ניתן לקרוא לסקריפט עם כמה אפשרויות שצוינו בשורת הפקודה, to
לשנות מעט את התנהגותו. להלן האפשרויות המותרות:
-d השתמש בברירות המחדל עבור כל התשובות.
-e המשך בלי לשאול מעבר להפקה של config.sh.
-f פילה השתמש בקובץ שצוין כתצורת ברירת מחדל. אם מתג זה אינו בשימוש,
התצורה נלקחה מ config.sh, כאשר נוכח.
-h הדפס הודעת עזרה וצא.
-r השתמש מחדש בערך סמלי C אם אפשר. זה ידלג על היקר nm סמל
הוֹצָאָה. אם נעשה בו שימוש בפעם הראשונה (ללא קובץ תצורה קודם),
גדר ינסה להדר ולקשר תוכנית קטנה על מנת לדעת על
נוכחות של סמל, או היעדרו.
-s מצב שקט. רק מחרוזות המודפסות על מתאר קובץ מס' 4 יראו ב-
מסך (זה ההודעות החשובות). לא ניתן לכבות לחלוטין
כל פלט, אבל אתה יכול להשתמש ב'גדר -דרס > / dev / null 2> & 1' שיהיה מלא
ריצה אצווה ללא פלט וללא צורך באינטראקציה של המשתמש.
-D סמל=ערך
מגדיר מראש סמל לשאת את המפורט ערך. אפשר גם להשתמש ב'-D
סמל' שישתמש בערך ברירת מחדל של 'הגדר'.
-E עצור בסוף שאלות התצורה, לאחר שהפקת א
config.sh. זה לא יבצע שום 'לעשות לסמוךחילוץ קבצי ' או .SH.
-K משתמש בעל ידע. כאשר אתה משתמש באפשרות זו, אתה יודע מה אתה עושה ו
לכן ה config.sh הקובץ תמיד יטופל כאילו הוא נועד להיות
בשימוש חוזר, למרות שייתכן שהוא נוצר על מערכת חייזרים. זה גם
מונע הפלה מתי גדר מזהה מהדר C לא שמיש או קבוצה שגויה
של דגלי C. קיצורי דרך נוספים עשויים להיות מופעלים על ידי אפשרות זו גם ב-
עתיד. אפשרות זו מתועדת ב- גדר הודעת שימוש, כדי להזכיר לנו
על קיומו, אך מקווים שהתיאור הנתון יהיה מספיק סתמי.
:-)
-O אפשר ערכים שצוינו באמצעות א -D or -U כדי לעקוף הגדרות מכל טעון
קובץ תצורה. זו אינה התנהגות ברירת המחדל מאחר והצוואה העוקפת
לא יופץ למשתנים שנגזרו מאלה שאתה משנה כעת.
באופן טבעי, בלי -O, ההגדרה מתבצעת רק כאשר אין קובץ תצורה
נטען, וזה בטוח מכיוון שמשתנים נגזרים עדיין לא חושבו...
-S בצע החלפת משתנים בכל קבצי ה-.SH. אתה יכול לשלב את זה עם
-f לעבור כדי להפיץ כל תצורה שתרצה.
-U סמל=
הגדרות מראש סמל לשאת ערך ריק. אפשר גם להשתמש ב'-U סמל'
אשר יקבע סמל ל'undef'.
-V הדפס את מספר הגרסה של metaconfig שיצר את זה גדר תסריט
ויציאה.
ריצה סביבה
עם ההתחלה, גדר יוצר מקומי UU ספרייה ופועל משם. המדריך
מוסר כאשר Configure מסתיים, אבל זה אומר שעליך להפעיל את הסקריפט ממקום שבו
אתה יכול לכתוב, כלומר לא ממערכת קבצים לקריאה בלבד.
אתה יכול לרוץ גדר עם זאת מרחוק, כמו ב:
../package/Configure
כדי להגדיר מקורות שאינם קיימים באופן מקומי. כל הקבצים שנוצרו יוכנסו
הספרייה שממנה אתה מפעיל את הסקריפט. הקסם הזה נעשה הודות ל-src.U
יחידה, אשר מגדירה את $src ו $rsrc משתנים כדי להצביע על מקורות החבילה. זֶה
הנתיב מלא או יחסי, תלוי אם גדר הופעל באמצעות מלא או
נתיב יחסי.
מבפנים UU ספריית משנה, אתה יכול להשתמש $rsrc כדי לגשת לקבצי המקור (יחידות
בהתייחסות לקבצי מקור רמזים לקישור ישתמשו תמיד במנגנון זה ולא יניחו את
הקובץ קיים בספריית האב). כל ה-Makefiles צריכים להשתמש במשתנה $src
כמצביע למקורות מהחלק העליון של ספריית ה-build (היכן גדר רץ),
ישירות או דרך הגדרת VPATH.
כשאתה רץ גדר מרחוק, קבצי ה-.SH מחולצים בספריית ה-build, לא
בעץ המקור. עם זאת, זה דורש סוג של א לעשות תמיכה כדי להיות מסוגל להדר
דברים בספריית build בעוד המקורות נמצאים במקום אחר.
שימוש קסם הגדרות מחדש
על ידי שימוש ב- -M מתג, ייתכן שיתרחשו כמה היפוך קסם בתוך א confmagic.h
קוֹבֶץ. יש לכלול את הקובץ הזה לאחר מכן config.h, כמובן, אבל גם אחרי הכל
נדרשים אחרים כוללים קבצים. כלומר:
#include "config.h"
...
... אַחֵר הכללות ...
...
#include "confmagic.h"
בדרך כלל, confmagic.h ינסה למפות מחדש bcopy() on memcpy() אם לא bcopy() is
זמין באופן מקומי, או להפוך vfork אל תוך מזלג כאשר יש צורך, ומכאן עושה את זה חסר תועלת
להתעסק ב HAS_VFORK סמל.
קסם התצורה הזה מתועד בקובץ מילון המונחים.
יחידה תבניות
יש קבוצה של תבניות יחידה ב- metaconfig ספריית מקור, אשר נועדו
לשמש תוכנית (עדיין לא נכתבה) כדי לייצר במהירות יחידות חדשות עבור סוגים שונים של
מצבים. אין תיעוד לפרויקט הלא גמור הזה, אבל חשבתי שאזכיר אותו
בדף המדריך למקרה שתרצה לעשות זאת בעצמך ולאחר מכן לתרום את זה...
מחברים
לארי וול[מוגן בדוא"ל]> לגרסה 2.0.
הרלן סטן[מוגן בדוא"ל]> להרחבות יחידות חשובות.
רפאל מנפרדי[מוגן בדוא"ל]>.
תורמים רבים אחרים עבור metaconfig יחידות. עיין בקובץ האשראי לרשימה.
השתמש ב-metaconfig באופן מקוון באמצעות שירותי onworks.net
