icmun - מקוון בענן

תָכְנִית:

שֵׁם

icmake - תוכנית תחזוקה (לעשות) שירות באמצעות א C-כמו דקדוק

תַקצִיר

icmake [אפשרויות] מקור[.im] [dest[.bim]] [-- [ארגס]]

icmun bimfile

תיאור

Icmake(1) יכול לשמש כחלופה ל לעשות(1). במצב הפעולה הסטנדרטי שלו, זה
קורא לתוכניות הבאות:

o icm-pp כדי לעבד מראש את קובץ icmake

o icm-comp כדי להדר את קוד בתים icmake s

o icm-exec כדי להפעיל את קובץ ה-byte-code

Icmake מאפשר למתכנתים להשתמש בשפת תכנות (הדומה מאוד למוכר
C-שפת תכנות) כדי להגדיר את הפעולות הכרוכות בתוכנית (מורכבת).
תחזוקה. לזה, icmake מציע מפעילים מיוחדים שונים כמו גם מערכת תמיכה
פונקציות שהוכחו כמועילות בתחזוקת התוכנית.

התכנית icmun(1) ניתן להשתמש כדי לפרק את קובץ ה-byte-code (.bim). איקמון
משמש בעיקר להמחשה, חינוך וניפוי באגים.

כלי עזר מסורתיים מהדרים מחדש מקורות לאחר שינוי קבצי כותרת. בתוך ה
הקשר של C + + פיתוח תוכנית זה לרוב רעיון רע, כמו הוספת חבר חדש ל-a
הכיתה בדרך כלל לא דורשת ממך להדר מחדש את מקורות הכיתה. לטפל בכיתה
תלות icmbuld(1) רשאי לבדוק שיעורים קבצים שניתן להשתמש בהם כדי להגדיר תלות
בין הכיתות. כברירת מחדל, תלות מחלקה אינה מתפרשת. עיין ב icmconf(7)
דף אדם לפרטים נוספים.

אפשרויות

Icmake משתמש בקבצים ובאפשרויות הבאות:

o מָקוֹר: icmake קובץ מקור הסקריפט (סיומת ברירת המחדל: .I).

o dest: בינארי icmake קובץ סקריפט (ברירת מחדל: `מקור'.bim, שנקרא `.bim file'
להלן).

o --: icmake מפריד ארגומנטים icmake טיעונים מתוך טיעונים שעברו
לקובץ ‎.bim filen() טוען: טיעונים הבאים -- מועברים לקובץ .bim
כפי שהוא, וזמינים מה- רשימה argv פרמטר המוגדר כ- icmake
של התסריט ראשי הפרמטר השני של הפונקציה (ראה להלן בסעיף משתמש מוּגדָר
פונקציות). עבור כמה אפשרויות (ראה להלן) את -- מפריד אינו נדרש.

Icmake תומך באפשרויות שונות, המתואר בהמשך. ה -h האפשרות גוברת על כל השאר
אפשרויות, ה -a האופציה גוברת על כל האפשרויות האחרות למעט -h. מהפעולה שנותרה
אפשרויות (-ב, -ג, , -אני, -p ו -t) ניתן לציין רק אחד:

o -a
להראות מידע על icmake, נשלט על ידי -h;

o -b
הופסק: השתמש באפשרות -e במקום זאת;

o -c
מה היא icmake קובץ המקור מורכב ומייצר קובץ .bim;

o -e
לבצע את icmake קובץ .bim, ניתן בתור icmakeארגומנט הקובץ הראשון של. כל תוספת
ארגומנטים מועברים לקובץ .bim כפי שהם, ו -- אין לציין;

o -F
שמות הקבצים והדגלים וכן סקירה כללית של כל הפעולות שיש לבצע על ידי
icmake מוצגים בזרם הפלט הסטנדרטי;

o -h
לספק מידע שימוש ולסיים icmake;

o -i
הטיעון הראשון הוא ה icmake קובץ המקור, קובץ ברירת המחדל הבינארי הוא
נבנה במידת הצורך. כל ארגומנט נוסף מועבר לקובץ .bim
כפי שהוא, ו -- אין לציין;

o -p
מה היא icmake קובץ המקור מעובד מראש בלבד, והקובץ המעובד מראש נכתב
ל icmakeארגומנט הקובץ השני של (כברירת מחדל `מקור'.pim);

o -q
התעלמו, יוסר בעתיד icmake גִרְסָה;

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

בעקבות השם של קובץ ה-bim הזמני, השם של ה- icmake תסריט מקור
יש לציין. כל ארגומנט נוסף מועבר לקובץ .bim כפי שהוא, ו
-- אין לציין; לאחר הגדרת דגל ההפעלה של קובץ סקריפט המקור
(chmod +x תסריט), ומספקים לו שורה ראשונית כזו:

#!/usr/bin/icmake -t.

מה היא icmake ניתן לקרוא ישירות לסקריפט:

סקריפט arg1 arg2

במקרה זה ה icmake תסריט 'תסריט' מבוצע בזמן שהוא מקבל את
טיעונים תסריט arg1 arg2.

o -T
אפשרות זו חייבת להיות מסופקת עם שם ספרייה המשמשת לאחסון
קבצים זמניים. למשל, בעת קומפילציה של an icmake script, הפלט של icmake"S
מעבד קדם הוא קובץ זמני אשר מוסר ביציאה. כברירת מחדל / Tmp משמש,
אלא אם כן / Tmp אינו ספרייה ניתנת לכתיבה, ובמקרה זה של המשתמש הנוכחי $ HOME
נעשה שימוש בספרייה. שמות קבצים זמניים מרומזים מתחילים תמיד במזהה התהליך של
הנוכחי icmake התהליך.

o -v
תצוגה icmakeמספר הגרסה של, וסוף icmake, נשלט על ידי -h

איקמון:

bimfile: בינארי icmake קובץ סקריפט.

מעבד מקדים הוראות

הנחיות הקדם-מעבד הבאות זמינות:

o תגובה:
תֶקֶן C הערה (הכל בין /* ו */) וכן הערה לסוף השורה (הכל
תוכן השורה הבא //) מתעלמים.

o אתחול מעטפת: השורה הראשונה של icmake-script עשוי להתחיל עם #!נָתִיב, שם
נתיב מגדיר את המיקום המוחלט של icmake תכנית. על ידי יצירת התסריט
בר הפעלה, ניתן לקרוא לו מבלי להתקשר במפורש icmake.

לדוגמה, אם השורה הראשונה של icmakefile (ניתן להפעלה) 'icm' (ללא סיומת)
מכיל

#!/usr/bin/icmake -i

אז ICM ניתן להנפיק כפקודה, ובכך לבצע

/usr/bin/icmake -i icm ...

לחלופין,

#!/usr/bin/icmake -t /tmp/icm

עשוי לשמש, וכתוצאה מכך ביצוע של

#!/usr/bin/icmake -t /tmp/icm icm ...

במקרה זה הקובץ הבינארי מוסר ביציאה.

o #include "שם קובץ"
הקובץ שם הקובץ נכלל במיקום ההנחיה

o #include
הקובץ שם הקובץ נכלל במיקום של #include הוֹרָאָה; שם הקובץ
מתבצע חיפוש בספריות המופרדות בנקודתיים שצוינו על ידי IM סביבה
מִשְׁתַנֶה. ההתרחשות הראשונה של שם הקובץ בספריות שצוינו על ידי IM
נעשה שימוש במשתנה סביבה.

o #define מזהה [הַגדָרָה]
הטקסט מזהה יוחלף על ידי הגדרה. ההגדרה עשויה להכיל
הפניות למזהים שהוגדרו כבר, תוך שימוש ב- ${identifier} פוּרמָט. אם ה
${identifier} לא הוגדר (עדיין), הטקסט ${identifier} ממש נשמר.
כדי למנוע רקורסיה אינסופית לכל היותר 100 ${identifier} מותרים תחליפים.

ההגדרות ממשיכות בשורה הבאה אם ​​התו האחרון בשורה הוא a
נטוי אחורי (\). (שלא נכלל בהגדרה). המעבד המקדים
משרשרת מחרוזות במירכאות כפולות, ויתכן שמחרוזות במירכאות כפולות לא ימשכו מרובות
שורות. ריקים מרובים (מחוץ למחרוזות במירכאות כפולות) בהגדרות הן
מכווץ לחלל ריק אחד.

ההגדרה בעקבות ה #define's המזהה הוא אופציונלי. אם מושמט, ה
מאקרו מוגדר, כך שניתן להשתמש בו ב #if(n)def הנחיות (ראה להלן), אבל הן
לא מוחלפים בשום טקסט ב icmake הצהרות קוד.

o #ifdef מזהה
אם מזהה מאקרו הוגדר בלוק הקוד הבא (עד התאמה #else
or #endif ההוראה נקראה) מורכבת בתים. אחרת, גוש הקוד הוא
התעלם.

o #ifndef מזהה
אם מזהה מאקרו היה לֹא הגדיר את גוש הקוד הבא (עד התאמה
#else or #endif זוהתה ההנחיה) מורכבת בתים. אחרת, הבלוק של
מתעלמים מהקוד.

o #else
מסתיים א #ifdef ו #ifndef הוראה, ביטול החלטת הקבלה לגבי
הקוד הבא. רק אחד #else הנחיה יכולה להיות קשורה #if(n)def
הוראות.

o #endif
מסיים את בלוק הקדם-מעבד החל מההתאמה #ifdef, #ifndef or #else
הוֹרָאָה. ה #endif ספרייה והתאמתה #if(n)def הנחיה חייבת להיות
שצוין באותו קובץ.

o #undef מזהה
להסיר מזהה מקבוצת הסמלים המוגדרים. זה לא משפיע על
מפרט של כל סמל שהוגדר קודם לכן שבו של מזהה הגדרה
שומש. אם מזהה לא הוגדר אזהרה.

נתונים סוגי

Icmake תומך בסוגי הנתונים הבאים:

o ASCII אופי קבוע
קבועי תו ASCII מורכבים מתו אחד, מוקף ביחיד או כפול
ציטוטים. תווים בודדים (למשל, 'א') מייצגים את הדמות עצמה. תֶקֶן
רצפי בריחה (למשל, '\n') נתמכים ומייצגים את הסטנדרט שלהם שהומר
ערך (למשל, '\n' מייצג ערך ascii 10 (עשרוני)). בריחה לא סטנדרטית
רצפים (למשל, '\איקס') מייצגים את תו ascii בעקבות תו הבריחה
(לכן '\איקס' שווים 'איקס'). מייצגים רצפי בריחה המורכבים משלוש ספרות אוקטליות
תו ascii המתאים לערך האוקטלי modulo 256 (למשל, '\123').
רצפי בריחה המורכבים מ-x ואחריו שתי ספרות הקסדצימליות מייצגים
תו ascii המתאים לערך ההקסדצימלי (למשל, '\xa4').

o int
ערכים אינטגרליים, החל מ -0x8000 דרך 0x7ff. int קבועים עשויים להיות
מצוין כמספרים עשרוניים (החל בספרות 1 עד 9), מספרים אוקטליים
(החל מ-0, ואחריו ספרה אוקטלית אחת או יותר) מספרים הקסדצימליים
(החל מ-0x, ואחריו ספרה הקסדצימלית אחת או יותר) או כ ASCII
קבועי אופי.

o מחרוזת
משתני טקסט. קבועי מחרוזת מופרדים במירכאות כפולות. מחרוזת מרובת
קבועים עשויים להיות משורשרים, אבל קבוע מחרוזת בודד לא יכול להשתרע על מרובים
שורות. קבועי מחרוזת מופרדים ברווח לבן בלבד (כלומר, ריקים, שורות חדשות,
comment) משורשרים ומייצגים קבוע מחרוזת אחת. כדי לציין א
סוף שורה במחרוזת קבוע להשתמש ב \n רצף בריחה.

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

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

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

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

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

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

מוגדר מראש קבועים

הקבועים הבאים מוגדרים מראש על ידי icmake. כולם קבועים int ערכים:

─────────────────────────────────
ערך סמל המיועד
─────────────────────────────────
O_ALL 8 רשימה
רשימת מותגים של O_DIR 2
O_FILE 1
O_SUBDIR 4
─────────────────────────────────
OFF 0 הד
ON 1 הד
─────────────────────────────────
P_CHECK 0 שיחות מערכת
P_NOCHECK 1 קריאות מערכת
─────────────────────────────────
S_IEXEC 32 סטט
S_IFCHR 1 נתון
נתון S_IFDIR 2
S_IFREG 4 סטט
S_IREAD 8 סטט
S_IWRITE 16 סטט
─────────────────────────────────

הקבועים הבאים תלויים בארכיטקטורה:

────────────────────────────────────────────────── ────────────
סמל 1 כשהוא מוגדר בפלטפורמה, אחרת 0
────────────────────────────────────────────────── ────────────
unix Unix, בדרך כלל עם מהדר gcc של GNU
UNIX עשוי להיות זמין לחלופין
linux x86 עם לינוקס (בדרך כלל עם gcc)
LINUX עשוי להיות זמין לחלופין
M_SYSV, M_UNIX x86 עם SCO/Unix
_POSIX _SOURCE Unix עם מהדר תואם Posix
__hpux HP-UX, עם המהדר המקורי של HP
────────────────────────────────────────────────── ────────────

מפעילים

כתובה אינט אופרנד(ים):

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

מודפס מחרוזת אופרנד(ים):

בעד מחרוזת סוג משתנים ו/או קבועים האופרטורים הבאים זמינים (a ו b
לייצג מחרוזת משתנים או קבועים):

o a + b: מחזירה חדש מחרוזת ערך המכיל את השרשור של מחרוזת ערכים a
ו b. שים לב ש מחרוזת קבועים עשויים להיות משולבים ישירות (מבלי להשתמש ב- +
אופרטור), למשל, שתי השורות הבאות מגדירות את המחרוזת "שלום עוֹלָם":

"שלום עולם"
"שלום" + "עולם"

o a += b: a חייב להיות מחרוזת משתנה, שאליו ה מחרוזת משתנה או ערך b is
צורף.

o השוואות מחרוזות: אופרטורים == != <= >= < > != ו == יכול להיות מיושם על מחרוזת
ערכים או משתנים, מחזירים 1 אם ההשוואה מצליחה, אחרת 0.
ההשוואה היא תלוית רישיות, ועוקבת אחר הסדר או התווים כפי שהוגדרו
ב ASCII מערך תווים.

o !a: הבוליאני ! (לא) המפעיל מחזיר 1 אם מחרוזת a ריק, אחרת 0 הוא
חזר.

o a צעיר יותר b, a חדש יותר b: מחזיר 1 if file a עדכני יותר מהקובץ b. לְמָשָׁל,
"source.cc" חדש יותר "source.o". הקבצים a ו b לא חייב להתקיים: אם שניהם לא
קיים 0 מוחזר; אם b לא קיים, 1 מוחזר; אם a לא קיים 0 הוא
חזר; אם הם ישנים באותה מידה 0 מוחזר. (ה קיים () פונקציה מוגדרת מראש
(ראה להלן, סעיף מוגדר מראש פונקציות) ניתן להשתמש כדי לבדוק במפורש אם א
הקובץ קיים).

o a מבוגר b: הופך 1 if file a ישן יותר מהקובץ b. לְמָשָׁל, "libprog.a" מבוגר
"source.o". הקבצים a ו b לא חייב להתקיים: אם שניהם לא קיימים 0 הוא
חזר; אם a לא קיים, 1 מוחזר; אם b לא קיים מוחזר 0; אם
הם ישנים באותה מידה 0 מוחזר.

o []: אופרטור האינדקס מאחזר תו ממשתנה מחרוזת או קבוע: it
מחזיר מחרוזת בתור an ערך. לכן, ההצהרה הבאה מסדרת אישור:

// נניח ש-str1 ו-str2 הם מחרוזות
str1 = str2[3];

אבל ההצהרה הבאה לא תתאים:

str2[3] = "a";

מחרוזת ריקה מוחזרת אם מסופק ערך אינדקס לא חוקי.

o אופרטור ה-'backtick' (`מחרוזת cmd`)
מחרוזת הממוקמת בין שני נקודות אחוריות מבוצעת על ידי ה פופ(3) פונקציה. ה
פלט סטנדרטי שנוצר על ידי הפקודה המאוחסנת בארגומנט המחרוזת הוא
הוחזר כרשימה. רשימה ריקה מציינת שלא ניתן היה לבצע את הפקודה.
פקודה שניתן לבצע אך לא הפיקה פלט כלשהו מחזירה רשימה
המכיל אלמנט אחד ריק. פלט זרם השגיאה הסטנדרטי של הפקודה אינו
נאסף על ידי מפעיל ה-backtick. עם זאת, ניתוב מחדש של מעטפת יכול להיות
משמש לאיסוף הפלט של זרם השגיאות הסטנדרטי. דוגמא:

printf(`"ls"`); // מדפיס את האלמנטים ב
// הספרייה הנוכחית

הפונקציה המוגדרת מראש eval(string cmd) מתנהג בדיוק כמו ה-backtick
מפעיל: הן מילים נרדפות.

מוקלדת ברשימה אופרנד(ים):

בעד רשימה סוג משתנים ו/או ערכים, האופרטורים הבאים זמינים:

o a + b: מחזירה חדש רשימה ערך המכיל את השרשור של רשימה ערכים a ו
b. זה לֹא פעולת סט: אם אלמנט מופיע שניהם ב a וגם b, הם י
מופיעים פעמיים ברשימה המתקבלת (הוספה של סט מסופקת על ידי המובנה
פונקציה listunion).

o a - b: מחזירה חדש רשימה ערך המכיל את האלמנטים ב a שאינם נוכחים
in b. זֶה is פעולת set-difference: הרשימה המוחזרת מכילה את כל האלמנטים
in a שאינם מרכיבים של b.

o a += b: אלמנטים ב b מתווספים לאלמנטים ב a, שחייב להיות א רשימה
מִשְׁתַנֶה. זה לֹא פעולה מוגדרת.

o a -= b: אלמנטים ב b מוסרים מהאלמנטים ב a, שחייב להיות א רשימה
מִשְׁתַנֶה. זֶה is פעולה מוגדרת: כל האלמנטים של a שנמצאים ב b יש לו
הוסר מ a.

o רשימת השוואות שוויון: מפעילים != ו == יכול להיות מיושם על רשימה ערכים או
משתנים. מַפעִיל == מחזירה 1 אם לשתי הרשימות יש אלמנט אחר אלמנט זהה
אלמנטים, אחרת 0 מוחזר. מַפעִיל != הופך את התוצאה של ==.

o !a: הבוליאני ! המפעיל מחזיר 1 אם רשימה a ריק, אחרת 0 הוא
חזר.

o []: אופרטור האינדקס מאחזר אלמנט רשימה ממשתנה רשימה: הוא מחזיר a
מחרוזת כ-an ערך. לכן, ההצהרה הבאה מסדרת אישור:

// נניח ש-lst היא רשימה, str היא מחרוזת
str = lst[3];

אבל ההצהרה הבאה לא תתאים:

lst[3] = str;

מחרוזת ריקה מוחזרת אם מסופק ערך אינדקס לא חוקי.

ליהוק:

ניתן לבצע הטיפוסים באמצעות התקן C מפעיל שחקנים ללהקה:

o מחרוזות ל-ints ולהיפך ((int)"123", (מחרוזת)55)

o מחרוזות לרשימות (רשימה lst = (רשימה)"שלום")

FLOW בקרה לפני ואחרי הטיפול

Icmake מציע את קבוצת המשנה הבאה של Cההצהרות של. ניתן להשתמש בהם כמו ב C
שפת תכנות.

o ביטוי ;
הצהרת הביטוי הפשוט;

o ההצהרה המורכבת
ניתן להגדיר ולאתחל משתנים מכל סוג בכל מקום בתוך כל מתחם
הַצהָרָה. ה ראות של משתנה מתחיל בנקודת ההגדרה שלו.

o if (מַצָב) הצהרה
בתוך התנאי ניתן להגדיר ולאתחל משתנה. לְמָשָׁל,

if (string str = getText())
process(str);

בדוגמה זו, תהליך לא נקרא אם getText () מחזיר מחרוזת ריקה. ה
משתנה str לא קיים לפני או אחרי if הצהרה.

o if (מַצָב) הצהרה אחר הצהרה
כמו בהצהרה הקודמת, בתוך התנאי ניתן להגדיר משתנה ו
מאותחל.

o ל (init; מַצָב; תוֹסֶפֶת) הצהרה
ניתן לאתחל (ואופציונלי להגדיר) משתנים (מסוג בודד) ב-
init סָעִיף. ה init, מצב ו תוֹסֶפֶת חלקים עשויים להישאר ריקים. ה
קטע מצב ריק מתפרש כ'תמיד נָכוֹן".

o בזמן (מַצָב) הצהרה
בתוך התנאי ניתן להגדיר ולאתחל משתנה.
משלים do ... בזמן () הצהרה אינה זמינה. שימו לב שהגדרת א
משתנה, שימוש בביטוי אתחול פירושו שהאתחול
הביטוי מבוצע בכל איטרציה של ה בזמן הַצהָרָה. אז הבא
המשפט לעולם לא יסתיים, ויציג זרם בלתי נגמר של ערכים 10:

while (int x = 10)
printf(x--, "\n");

o לחזור;, ו לַחֲזוֹר ביטוי;
מישור לַחֲזוֹר ניתן להשתמש בהצהרות ב לבטל את פונקציות, ו לַחֲזוֹר ביטוי
הצהרות משמשות בסוגים אחרים של פונקציות. הפונקציה ראשי בעל סוג החזרה
לבטל את וכן פנימה ראשי רק רגיל לַחֲזוֹר ניתן להשתמש בהצהרות. כברירת מחדל an icmake
ערך היציאה של הסקריפט שווה ל-0. השתמש בפונקציה המובנית יציאה (ראה להלן) כדי לציין
כל ערך יציאה אחר.

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

o לשבור
עוזב ל ו בזמן הצהרות, תוך ביטול מצב ההצהרה.

o להמשיך
ממשיך עם האיטרציה הבאה של a ל or בזמן הצהרה.

o יציאה (ביטוי)
מסיים את הביצוע של an icmake-תַסרִיט. ה ביטוי חייב להעריך ל- an int
ערך, שהופך לערך היציאה של הסקריפט.

מוגדר מראש פונקציות

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

o לבטל את arghead(string h)
פונקציית עוזר של exec () (ראה גם להלן ב exec ()): מגדיר את 'ראש הטיעון',
לשימוש עם exec (). כברירת מחדל, 'ראש הטיעון' הוא מחרוזת ריקה.

o לבטל את זנב ארגז (חוּט t)
פונקציית עוזר של exec () (ראה גם להלן ב exec ()): מגדיר את 'זנב הוויכוח',
לשימוש עם exec (). כברירת מחדל, 'זנב הוויכוח' הוא מחרוזת ריקה.

o int ascii(string s)
מחזירה את התו הראשון של s בתור int; לְמָשָׁל, ascii("א") מחזירה 65;

o מחרוזת ascii(int i)
החזרים i כמחרוזת, למשל, ASCII(65) מחזירה את המחרוזת "ל";

o מחרוזת change_base(string קובץ, מחרוזת newbase)
משנה את שם הבסיס של פילה, מחזירה את השם שהשתנה. לְמָשָׁל,
change_base("/path/demo.im", "הַחוּצָה") החזרות "/path/out.im";

o מחרוזת change_ext(string קובץ, מחרוזת newext)
משנה את ההרחבה של פילה, מחזירה את השם שהשתנה. לְמָשָׁל,
rss_changeExt("source.cc", "או") החזרות "source.o";

o מחרוזת change_path(string קובץ, מחרוזת דרך חדשה)
משנה את מפרט הנתיב של פילה, מחזירה את השם שהשתנה. לְמָשָׁל,
change_path("tmp/binary", "/ usr / bin") החזרות "/usr/bin/binary". שים לב כי
/-מפריד מוכנס במידת הצורך.

o מחרוזת chdir(string newdir)
משנה את ספריית העבודה של הסקריפט, מחזיר את ה-dir הקודם כאבסולוט
נתיב.

השתמש chdir(".") כדי להשיג את ספריית העבודה הנוכחית, chdir("") עשוי להיות רגיל ל
השג את ספריית העבודה של ההפעלה (פונקציונליות זו נשברה במהדורות
לפני השעה 7.00, אך הוא כעת פעיל). הפונקציה מסיימת את
icmake-script אם המצוין newdir לא קיים.

o מחרוזת chdir(int בודק, מחרוזת newdir)
אותה פונקציונליות כמו הפונקציה הקודמת, אבל על ידי ציון בדיקה as
P_NOCHECK. הפונקציה לא תסיים את הסקריפט. במקום זאת, זה יחזיר את
ספריית העבודה הנוכחית של הסקריפט.

o cmdhead(string h)
פונקציית עוזר של exec () (ראה גם להלן ב exec ()): מגדיר 'ראש פקודה', ל
לשמש עם exec (). כברירת מחדל, 'ראש הפקודה' הוא מחרוזת ריקה.

o cmdtail(string t)
פונקציית עוזר של exec () (ראה גם להלן ב exec ()): מגדיר 'זנב פקודה', ל
לשמש עם exec (). כברירת מחדל, 'זנב הפקודה' הוא מחרוזת ריקה.

o echo(int העדיף)
שולט בהדהוד של תוכניות שנקראו (והארגומנטים שלהן), ציין כבוי אם מהדהד
לא מתבקש. כברירת מחדל echo(ON) משמש.

o מחרוזת element(int אינדקס, רשימה (אוֹ חוּט) var)
פועל זהה לאופרטור האינדקס: עיין באינדקס ([]) מפעיל ב-
סעיף מפעילים.

o רשימה eval(string str)
פונקציה זו פועלת באופן זהה לאופרטור ה-backtick. הדוגמה שסופקה עם
אופרטור ה-backtick יכול היה להיכתב כך:

printf(eval("ls")); // מדפיס את האלמנטים בזרם
// ספרייה

o exec(string cmd, ...)
מבצע פקודה עם ארגומנטים. כל ארגומנט יקבל את הקדמת arghead()"S
טיעון ופוסט-תיקון על ידי argtail()הטיעון של. שימו לב שלא הוכנסו ריקים
בֵּין arghead()התוכן של, הטיעון עצמו, ו argtail()הטיעון של. את כל
לכן ארגומנטים שהשתנו משורשרים, הפעם מופרדים על ידי ריקים בודדים, ו
אז cmdhead()התוכן של מוכנס בין הפקודה לארגומנט הראשון
(משני צדדים מופרדים בחסר בודד) ו cmdtail()התוכן של מצורף
לארגומנטים (שוב, מופרדים על ידי ריק בודד). נתיב מחפשים לאתר
cmd. 0 מוחזר.

o exec(int checkcmd, מחרוזת cmd, ...)
אותה פונקציונליות כמו הפונקציה הקודמת, אבל על ידי ציון בדיקה as
לא בדוק הפונקציה לא תסיים את הסקריפט. במקום זאת, זה יחזיר את
נקרא מצב היציאה של הפקודה, או 0x7f00 אם הפקודה לא נמצאה.

o execute(string cmd, מחרוזת cmdhd, מחרוזת ארג'ד, ..., מחרוזת ארגל, מחרוזת cmdtl)
כמו exec (), אך יש לציין ראש/זנב פקודה וראש/זנב ארגומנט.

הפקודה שבוצעה בפועל מתחילה ב- cmd, ואחריו cmdhd. הבא היא סדרה
להלן של טיעונים, כל אחד מוקף ב ארג'ד ו argtl. הפקודה מסתיימת עם
cmdtl. 0 מוחזר

o execute(int בודק, מחרוזת cmd, מחרוזת cmdhd, מחרוזת ארג'ד, ..., מחרוזת ארגל,
מחרוזת cmdtl)
אותה פונקציונליות כמו הפונקציה הקודמת, אבל על ידי ציון בדיקה as
לא בדוק הפונקציה לא תסיים את הסקריפט. במקום זאת, זה יחזיר את
נקרא מצב היציאה של הפקודה, או 0x7f00 אם הפקודה לא נמצאה.

o int קיים(מחרוזת קוֹבֶץ)
מחזירה ערך שאינו אפס if פילה קיים, אחרת 0 מוחזר.

o רשימה fgets(string קובץ, רשימה לְקַזֵז)
הערה: in icmake גרסה 8.00.00 מאב הטיפוס של פונקציה זו שונה
רשימה fgets(string קובץ, int לְקַזֵז) ל רשימה fgets(string קובץ, רשימה לְקַזֵז).

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

הוא מחזיר רשימה המכילה כמרכיב הראשון את תוכן שורת הקריאה
(בלי ה \n מסיים קו), כמרכיב השני שלו מסיים הקו `\n"
(אם נתקל), וכאלמנט השלישי שלו המחרוזת OK אם קו הצליח
לקרוא, FAIL אם הקריאה מהקובץ נכשלה. כשקוראים ב-EOF רשימה ריקה היא
חזר. הרשימה המוחזרת עשויה להכיל אלמנטים נוספים, שהם פנימיים
בשימוש על ידי fgets בעת קריאת השורה הבאה.

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

הנה דוגמה שמראה כיצד לקרוא קובץ שלם:

רשימת ret;
בזמן (1)
{
ret = fgets("שם קובץ", ret);
אם (!ret)
לשבור;
process(ret[0], ret[1]);
}

o int fprintf(string שם קובץ, ...)
מוסיף את כל הארגומנטים (מופרדים בפסיק) לקובץ שם הקובץ. מחזירה את המספר של
טיעונים מודפסים.

o int fprintf(string שם קובץ, מחרוזת פוּרמָט, ...)
מוסיף את כל הארגומנטים (מופרדים בפסיק) לקובץ שם הקובץ. מחזירה את המספר של
טיעונים מודפסים.

If פוּרמָט מכיל מצייני מיקום %1 .. %n הפלט מעוצב (ראה גם
strformat). שימו לב שבמקרה זה ספירת הארגומנטים מתחילה (גם) מעבר ל-
מחרוזת פורמט: הארגומנט הראשון הבא פוּרמָט מתייחס אלינו %1.

o מחרוזת get_base(string קוֹבֶץ)
מחזירה את שם הבסיס של פילה. שם הבסיס הוא הקובץ ללא קידומת הנתיב שלו
וללא הרחבה שלו. ההרחבה היא כל המידע החל מהגמר
נקודה בשם הקובץ. אם לא נמצאה נקודה סופית, שם הקובץ הוא שם הבסיס.
למשל, שם הבסיס של ab שווים a, שם הבסיס של א ב ג שווים ab, הבסיס
שם של א ב ג שווים c.

o מחרוזת getch ()
מחזירה את המקש הבא שנלחץ כמחרוזת (אין צורך בלחיצה על 'Enter').

o מחרוזת get_dext(string קוֹבֶץ)
מחזירה את ההרחבה של פילה, כולל הנקודה המפרידה. ההרחבה היא הכל
מידע שמתחיל בנקודה האחרונה של שם הקובץ.

אם לא נמצאה נקודה סופית, מוחזרת מחרוזת ריקה.

o רשימה getenv(string envvar)
מחזירה את הערך של משתנה הסביבה envvar ברשימה המכילה שני אלמנטים:

האלמנט הראשון מציין אם משתנה הסביבה הוגדר (value
"1") או לא (ערך "0");
האלמנט השני מציין את הערך של משתנה הסביבה.

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

o מחרוזת get_ext(string קוֹבֶץ)
מחזירה את ההרחבה של פילה, למעט הנקודה המפרידה. ההרחבה היא הכל
מידע שמתחיל בנקודה האחרונה בשם הקובץ.

אם לא נמצאה נקודה סופית, מוחזרת מחרוזת ריקה.

o int getpid()
מחזירה את ה-process-id של מתורגמן הקוד icmake byte icm-exec.

o מחרוזת מקבל ()
מחזירה את השורה הבאה שנקראה מהמקלדת בתור א מחרוזת. הקו נכנס ב-
יש לסיים את המקלדת על ידי מקש 'Enter', אשר אינו מאוחסן במקלדת המוחזרת
מחרוזת.

o מחרוזת get_path(string קוֹבֶץ)
מחזירה את קידומת הנתיב של פילה. קידומת הנתיב היא כל המידע עד (ו
כולל) מפריד הספריות הסופי (שזה, תלוי בהפעלה
מערכת, קו נטוי קדימה או אחורי).

אם לא נמצא נתיב, מוחזרת מחרוזת ריקה.

o int listfind(list קודם כל, מחרוזת str)
מחזירה את המדד הראשון פנימה lst היכן המחרוזת str נמצא, או -1 אם lst לא
להכיל str.

o int listlen(רשימה l)
מחזירה את מספר האלמנטים ב רשימה.

o רשימה listunion(list LHS, רשימה rhs)
מחזירה רשימה המכילה את האיחוד של האלמנטים ב לה ו rhs.

o רשימה listunion(list קודם כל, מחרוזת str)
מחזירה רשימה המכילה את האיחוד של האלמנטים ב lst ו str.

o רשימה makelist(string מסכה)
מחזירה רשימה של כל הקבצים התואמים מסכה. לְמָשָׁל, makelist("*.c") מחזיר רשימה
המכיל את כל הקבצים המסתיימים ב .c.

o רשימה makelist(סוג, מחרוזת מסכה)
זהה לפונקציה הקודמת, אבל הסוג של רכיבי הספרייה עשוי להיות
צוין כטיעון הראשון שלו:

משמעות הסמל
IS_ALL השג את כל ערכי הספרייה
IS_DIR השג את כל הספריות, כולל . ו..
IS_FILE השג רשימה של קבצים
IS_SUBDIR השג את כל ספריות המשנה

שימו לב שהתבנית * לא יתאים לערכים נסתרים תחת הפעלה מסוג Unix
מערכות. להשתמש .* בשביל זה.

o רשימה makelist(string מסכה, חדש יותר, מחרוזת השוואה)
מחזירה רשימה של כל הקבצים התואמים מסכה שהם חדשים יותר מהמסיכה שסופקה
השוואה. מַפעִיל צעיר יותר ניתן להשתמש במקום חדש יותר. שים לב ש חדש יותר ו
צעיר יותר הם אופרטורים, לא מחרוזות.

o רשימה makelist([int = IS_FILE,] מחרוזת מסכה, חדש יותר, מחרוזת השוואה)
זהה לפונקציה הקודמת, אבל סוג ניתן לציין כמו ב רשימה makelist(סוג,
מחרוזת מסכה).

o makelist(string מסכה, מבוגר, מחרוזת השוואה)
ראה לעיל; מחזירה רשימה של קבצים ישנים יותר מ-comparefile.

o makelist(סוג, מחרוזת מסכה, מבוגר, מחרוזת השוואה)
זהה לפונקציה הקודמת, אבל סוג ניתן לציין כמו ב רשימה makelist(סוג,
מחרוזת מסכה).

o int printf(...)
מציג את כל הארגומנטים (מופרדים בפסיק) למסך (כלומר, זרם הפלט הסטנדרטי).
מחזירה את מספר הארגומנטים המודפסים.

o int printf(string פוּרמָט, ...)
מציג את כל הארגומנטים (מופרדים בפסיק) למסך (כלומר, זרם הפלט הסטנדרטי).
מחזירה את מספר הארגומנטים המודפסים (ה פוּרמָט מחרוזת נחשבת כארגומנט אחד).

If פוּרמָט מכיל מצייני מיקום %1 .. %n הפלט מעוצב (ראה גם
strformat).

o int putenv(string envvar)
מוסיף envvar אל הנוכחי (icmake) סביבת השתמש בפורמט: "VAR=value".
מחזירה 0.

o מחרוזת שנה גודל (מחרוזת str, int newlength) מחזיר עותק של מחרוזת str, שינה את הגודל ל
newlength דמויות. אם newlength הוא שלילי אז מוחזרת מחרוזת ריקה,
if newlength עולה str's אורך ולאחר מכן אתחול התווים החדשים שנוספו
לרווחים ריקים.

o int sizeof(רשימה l)
הוצא משימוש: שימוש ליסלן.

o int sizeoflist(רשימה l)
הוצא משימוש: שימוש ליסלן.

o רשימה stat(string כְּנִיסָה)
החזרים stat(2) מידע על הזנת הספרייה כניסה בתור רשימה. הרשימה שהוחזרה
יש שני אלמנטים: אלמנט 0 הוא ה תכונה ערך, רכיב 1 מכיל את הגודל של
הקובץ.

תכונות מוחזרות כדגלי סיביות, המורכבות מההגדרות הבאות
קבועים:

S_IFCHR S_IFDIR S_IFREG
S_IREAD S_IWRITE S_IEXEC

ראה stat(2) דף ידני למשמעויות הקבועים הללו.

o רשימה stat(בודק, מחרוזת כְּנִיסָה)
זהה לפונקציה הקודמת, אבל על ידי ציון בדיקה as P_NOCHECK הפונקציה
לא יסיים את הסקריפט. במקום זאת, זה חוזר statערך ההחזרה של (2).

o int strchr(string str, מחרוזת תווים)
מחזירה את המדד הראשון פנימה str איפה כל אחת מהדמויות טנקים נמצא, או -1
if str אינו מכיל אף אחד מהתווים ב טנקים.

o int strlen(string str)
מחזירה את מספר התווים ב str (לא סופר את ה-0 הסופי).

o int strfind(string עֲרֵמַת שַׁחַת, מחרוזת מַחַט)
מחזיר אינדקס ב עֲרֵמַת שַׁחַת איפה מחט נמצא, או -1 אם מחט אינו מכיל
in עֲרֵמַת שַׁחַת.
זֶה פונקציה היה נקרא strstr () in גירסאות לפני 7.00.

o int strformat(string פוּרמָט,...)
מחזירה מחרוזת מעוצבת באמצעות מצייני מיקום %1 .. %2 כדי לטפל בארגומנטים
הפורמט הבא.
דוגמא:

void main ()
{
int i = 10;
int j = 20;
מחרוזת s1;
מחרוזת s2;
// גישה מסורתית:
s1 = (string)i + " " + (string)j + " " + (string)i;
// באמצעות strformat:
s2 = strformat("%1 %2 %1", i, j);
printf("s1 = %1, s2 = %2\n", s1, s2);
}

o מחרוזת strlwr(string s)
מחזירה כפילות באותיות קטנות של s.

o רשימה strtok(string str, מחרוזת מפרידים)
מחזירה רשימה המכילה את כל מחרוזות המשנה של str מופרדים על ידי אחד או יותר
תווים (רצופים) ב מפרידים. לְמָשָׁל, strtok("שלום icmake's+world", " +")
מחזירה את הרשימה המכילה את שלוש המחרוזות "שלום", "של icmake", ו "עוֹלָם".

o מחרוזת strupr(string s)
מחזירה כפילות באותיות רישיות של s.

o מחרוזת substr(string טקסט, int לְקַזֵז, int לספור)
מחזירה מחרוזת משנה של טֶקסט, מתחיל ב לקזז, בהיקף של לספור דמויות. אם
לקזז חורג (או שווה) לגודל המחרוזת או אם לספור <= 0, ואז מחרוזת ריקה
מוחזר. אם לקזז הוא פחות מ-0 ואז נעשה שימוש ב-0.

o int system(מחרוזת הפקודה)
מוציאים להורג הפקודה. ערך ההחזרה מציין את ערך היציאה של הפקודה המבוצעת. ה
מחרוזת הפקודה עשוי להכיל תווים להפניה מחדש ו/או תווי צנרת.

o int system(int בודק, מחרוזת הפקודה)
אותה פונקציונליות כמו הפונקציה הקודמת, אבל על ידי ציון בדיקה as
לא בדוק הפונקציה לא תסיים את הסקריפט. במקום זאת, זה יחזיר את
נקרא מצב היציאה של הפקודה, או 0x7f00 אם הפקודה לא נמצאה.

o מחרוזת trim(string s)
מחזיר עותק של s ללא רווחים לבנים מובילים ונגררים.

o מחרוזת trimleft(string str)
מחזיר עותק של s בלי להוביל חללים לבנים.

o מחרוזת trim(string s)
מחזיר עותק של s ללא רווחים לבנים נגררים.

משתמש מוּגדָר פונקציות

לבטל את ראשי

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

void main(int argc, list argv, list envp)

In עיקרי (),

o טען מייצג את מספר האלמנטים ב argv;

o argv מכיל את הארגומנטים, כאשר אלמנט 0 שווה לשם של ה-.bim
קוֹבֶץ;

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

void main(int argc, list argv)
{
רשימה לקומפילציה;
int idx;

if (argc == 1)
usage(element(0, argv));

if (toCompile = altered("*.cc"))
{
for (idx = length(toCompile); idx--; )
compile(element(idx, toCompile));

if (getenv("dryrun")[0] == "0")
linking(element(2, argv));
}
}

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

בנוסף מוגדר המשתמש פונקציות

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

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

o סוג ההחזרה של הפונקציה, אשר חייב להיות אחד בָּטֵל, אינט, מחרוזת or רשימה. שם
אינו סוג ברירת מחדל.

o שם הפונקציה, למשל, לעבד.

o רשימת פרמטרים, המגדירה אפס או יותר פרמטרים מופרדים בפסיקים. הפרמטרים
עצמם מורכבים משם סוג (אינט, מחרוזת, או רשימה) ואחריו ה
המזהה של הפרמטר. לְמָשָׁל, (חוּט outfile, מחרוזת מקור).

o א גוּף מוקף בזוג פלטה מתולתלת ({ ו }).

גופי פונקציה עשויים להכיל (אופציונלי אתחול) הגדרות משתנים. מִשְׁתַנֶה
הגדרות מתחילות בשם סוג, ואחריו מופרדים בפסיק אחד או יותר (אופציונלי
אתחול) מזהי משתנים. אם משתנה לא מאותחל במפורש הוא כן
אתחול כברירת מחדל. כברירת מחדל an int המשתנה מאותחל ל-0, א מחרוזת is
אתחול למחרוזת ריקה ("") ו רשימה מאותחל לרשימה של אפס אלמנטים.

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

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

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