nickle - מקוון בענן

תָכְנִית:

שֵׁם

ניקל - שפת מחשבון שולחני

תַקצִיר

nickle [--help|--usage] [-f file] [-l library] [-e expr] [ script ] [--] [arg ...]

תיאור

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

נוהג

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

האפשרויות הן כדלקמן:

--עזרה,--שימוש
הדפס הודעת עזרה/שימוש וצא. זוהי תכונה מובנית של ניקל
מודול ParseArgs, ולכן יהיה נכון גם לגבי סקריפטים של Nickle שמשתמשים בזה
סִפְרִיָה.

-f,--קובץ פילה
לִטעוֹן פילה לתוך ניקל לפני תחילת הביצוע.

-ל,--ספרייה ספריה
לִטעוֹן ספריה לתוך ניקל לפני תחילת הביצוע. ראה למטה לתיאור
של מתקן הספרייה.

-ה,--expr ביטוי
להעריך ביטוי לפני תחילת הביצוע.

-- צא מניתוח ארגומנטים והעביר את השאר, ללא הערכה, אל argv.

תחביר

כדי להפוך את שפת הקלט לשימושית יותר בהגדרה אינטראקטיבית, שורה חדשה רק מסתיים
הצהרות בזמנים ''סבירים''. שורה חדשה מסיים או ביטויים או יחיד
הצהרות שהוקלדו על ידי המשתמש (למעט כמה הצהרות הדורשות
lookahead: במיוחד if() ו-twixt(), שיש להם חלק אחר אופציונלי). מתחם בפנים
הצהרות או הגדרות פונקציות, רק א ; מפסיק הצהרות. גישה זו היא
נוח ולא נראה גורם לבעיות בשימוש רגיל.

התחביר של תוכניות ניקל הוא כדלקמן. בתיאור זה, שם מציין כל
רצף של אותיות, ספרות ותווים _ שאינם מתחילים בספרה; E מציין כל
ביטוי; S מציין הצהרה כלשהי; ו T מציין כל סוג. התחביר X,X,...,X מציין
X אחד או יותר מופרדים בפסיקים, אלא אם צוין אחרת.

תגובות:

הערות בסגנון C מוקפות ב-/* ו-*/, והערות בסגנון מעטפת מסומנות ב-
מוביל # בתחילת שורה.

אופרנדים:

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

מספר אוקטלי
התחל עם 0 (למשל, 014 זהה ל-12).

מספר הקסדצימלי
התחל עם "0x" (למשל, 0x1a זהה ל-26).

מחרוזת כמו ב-C. קבועי מחרוזת מוקפים במירכאות כפולות. דמויות משוכות לאחור
(כולל מרכאות כפולות) מייצגות את עצמן, למעט "\n" מייצג שורה חדשה,
"\r" עבור החזרת כרכרה, "\b" עבור backspace, "\t" עבור tab ו-"\f" עבור formfeed.

name הפניה למשתנה.

name() name(E,E,...,E)
קריאה לפונקציה עם אפס ארגומנטים או יותר. הפונקציות הן מלאות לפי ערך:
מערכים ומבנים מועתקים במקום להתייחס אליהם כמו ב-C.

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

בנוסף ליכולת לאתחל הגדרה עם ערך ניקל, בסגנון C
מותרות גם הגדרות מערך, מבנה ואיגוד: לדוגמה, ה
הבא
int[*,*] name = {{0,1},{2,3}}
int[2,2] שם = {{0...}...}
מותרים עם הסמנטיקה הברורה. זה ההקשר שבו ה
מימדים בטיפוס עשויים להיות ביטויים: ראה את הדיון על סוגי מערכים לעיל.
ראה את הדיון בערכי מערך ומבנה עבור מערך ומבנה
תחביר אתחול.

מוקדמות

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

ראות:

public כל ביטוי הגדרה (הגדרת פונקציה, הגדרת משתנה, סוג
הגדרה) ניתן לסייג עם הציבור כדי לציין שהשם המוגדר
צריך להיות גלוי מחוץ למרחב השמות הנוכחי, ואמור להיות באופן אוטומטי
מְיוֹבָּא. ראה מרחבי שמות למטה למידע נוסף.

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

לכל החיים:

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

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

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

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

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

מפעילים

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

א[E,E,...,E]
מתייחס לאלמנט E'th של ביטוי המערך A, או E1'th/E2'th/וכו'
אלמנט של מערך רב מימדי. שני מערכי המערכים ala C ו
מערכים רב מימדיים ala NAWK אפשריים.

struct.tag
התייחסות מבנה.

struct->tag
הפניית מצביע מבנה ala C.

=============

++ -- תוספת/ירידה חדה. יכול להיות postfix או קידומת.

- שלילה בלתי רגילה

! E שלילה לוגית.

ה! פקטוריאלי. דורש ארגומנט של מספר שלם לא שלילי.

* הפניית E Pointer.

& E בניית התייחסות.

=============

(U) E בנה ערך מסוג איחוד עם תג U וערך E.

=============

** אקספוננציציה. שני האופרנדים עשויים להיות חלקים. האופרנד השמאלי חייב להיות לא-
שלילי אלא אם האופרנד הימני הוא מספר שלם. סוג התוצאה הוא סוג ה-
אופרנד שמאלי אם האופרנד הימני הוא מספר שלם, וממשי אחרת.

זוהי התכונה הידועה היחידה של ניקל ללא צליל מסוג טיפוס: ביטוי כמו 2 ** -3
יהיה סטטי מסוג מספר שלם, אך באופן דינמי יפיק רציונל
תוֹצָאָה. זה עלול לגרום לשגיאת סוג זמן ריצה בהמשך: שקול
int x = 2 ** -3;

=============

* / // %
זמנים, מחלקים, מחלקים שלמים, והשאר. האופרנד הימני משלושת האחרונים
אופרטורים חייבים להיות לא מאפס. סוג התוצאה של אופרטור החלוקה תמיד יהיה
לפחות רציונלי: סוג התוצאה של אופרטור חלוקת המספרים השלמים תמיד יהיה
int. זוהי סטייה בולטת מ-C, שבה חלוקה שלמים משתמעת על ידי
אופרנדים שלמים. חלוקת מספרים שלמים מוגדרת על ידי
x // y == y > 0 ? קומה (x/y) : ceil(x/y)
השאר תמיד לא שלילי ומוגדר על ידי: על ידי
x % y = x - (x // y) * y

=============

+ - חיבור וחיסור.

=============

<< >> העברה חלקית שמאלה וימינה עם אופרנדים שלמים. אופרנדים ימניים שליליים עובדים
כצפוי. אופרטורים אלה מוגדרים על ידי
x << y = x * 2 ** y
x >> y = x // 2 ** y
דרך נוספת להסתכל על זה היא שאופרנדים שמאליים שליליים נחשבים בפנים
ייצוג אינסוף שניים-משלים (כלומר, סימן-מורחב עד אינסוף), עם
סימן העברה ימני המרחיב את האופרנד השמאלי שלו.

=============

<= >= < >
מפעילים יחסיים.

=============

== != מפעילי שוויון.

=============
לבסוף, לפי סדר עדיפות יורד:

& Bitwise AND. אופרנדים שליליים נחשבים בהשלמה אינסופית של שניים
ייצוג (כלומר, סימן מורחב עד אינסוף).

^ Bitwise XOR. אופרנדים שליליים כמו ב-AND.

| Bitwise OR. אופרנדים שליליים כמו ב-AND.

&& קצר חשמלי AND.

|| קצר חשמלי OR לוגי.

ה? ה: ה
ביטוי מותנה: אם הביטוי הראשון נכון לוגי, הערך הוא שני
ביטוי, אחר שלישי.

fork E צור (והחזר) חוט. ראה שרשור למטה לפרטים.

= += -= *= /= //= %= **= <<= >>= ^= &= |=
מפעילי מטלות. צד שמאל חייב להיות ניתן להקצאה. x = y שווה ערך
ל x = x y

E , E מחזירה ביטוי ימני.

סוגי

תחביר הצהרת הסוג של ניקל דומה יותר לגרסה ה``שמאלית'' של
תחביר Java מאשר תחביר C. בעיקרו של דבר, סוג מורכב מ:

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

חוט סמפור קובץ
גם סוגי בסיס מובנים, אך חלק בלתי נפרד מה-File וה-Thread ADTs: ראה להלן.

עוד אודות סוגים:

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

poly זה מתאר את האיחוד של כל סוגי הנתונים. משתנה עם סוג זה יכול להכיל
כל ערך נתונים.

int מספרים שלמים דיוק שרירותי.

רַצִיוֹנָלִי
מספרים רציונליים דיוק שרירותי.

מספרי נקודה צפה ממשית שרירותית של דיוק מעריך. כמו שהרבה חישובים לא יכולים
להתבצע בדיוק כמספרים רציונליים, ניקל מיישם לא מדויק
אריתמטיקה באמצעות ייצוג בלתי תלוי במכונה עבור נקודה צפה
מספרים. הפונקציה המובנית imprecise(n) יוצרת מספר אמיתי עם 256 סיביות
של דיוק מהמספר n, בעוד שבלתי מדויק(n,p) יוצר מספר ממשי עם p
פיסות דיוק.

T[] מערך מסוג T, בעל מימד אחד או יותר. אין אפס מימד
מערכים בניקל.

T[*] מערך חד מימדי מסוג T. שלא כמו ב-C, המימד של מערך הוא אף פעם
חלק מסוגו בניקל. יתר על כן, מערכים ומצביעים הם סוגים לא קשורים ב
ניקל.

T[*,*,...,*]
מערך דו מימדי או יותר מסוג T. הכוכבים ``*'' אינם אופציונליים. כפי ש
הפסקאות הקודמות מבהירות, ``T[]'' אינו מערך אפס ממדי.

T[E,E,...,E]
בהקשרי הגדרה, ניתן לתת ערכי מספרים שלמים עבור כל מימד של מערך
הֶקשֵׁר. אלה מיועדים אך ורק למטרות יצירת ערך, ואינם חלק מה-
סוּג. סוג מערך נקבע רק לפי סוג הבסיס ומספר הממדים
של המערך.

T0() T0(T,T,...,T)
פונקציה המחזירה סוג T0. פונקציה מקבלת 0 או יותר ארגומנטים.

T0() T0(T,T,...,T ...)
פונקציה שמקבלת אפס או יותר ארגומנטים נדרשים, בתוספת מספר שרירותי של
טיעונים אופציונליים. הרצף השני של שלוש נקודות (אליפסיס) הוא תחביר, לא
metasyntax: ראה את התיאור של פונקציות varargs לפרטים.

*מצביע TA למיקום מסוג T. אריתמטיקה מצביע בניקל פועלת רק עליו
מצביעים למערכים: המצביע חייב להיות מהסוג הנכון, ועלול לעולם לא לסטות
מחוץ לתחום. מצביע יכול להצביע על מיקום כלשהו או להיות ריק (0). כמו ב
C, הקדימות של ``*'' נמוכה מהקדימות של ``[]'' או ``()'': השתמש
סוגריים לפי הצורך.

struct {שם ת'; שם T; ...}
מבנה עם שדות בשם ובסוג הנתונים. הסוגים T הם אופציונליים: in
היעדרם, סוג השדה הוא פולי.

איחוד {שם ט; שם T; ...}
"איחוד מנותק" מהסוגים הנתונים. זה דומה יותר לסוג רשומת הגרסה
של Pascal או סוג הנתונים של ML מאשר סוג האיחוד C: השמות הם תגיות של
סוג נתון, בדיוק אחד מהם חל על ערך נתון בזמן נתון.

(ט) סוגריים לקיבוץ.

Typedef:

כמו ב-C, ניתן ליצור שמות סוגים חדשים עם הצהרת typedef. התחביר הוא
typedef T typename;
כאשר T הוא סוג ניקל. ניתן להשתמש בשם הטיפוס המתקבל בכל מקום שבו צפוי סוג.

ערכים

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

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

מערכים:

[E] יוצר מערך (מבוסס אפס) עם אלמנטים E. E חייב להיות לא שלילי.

[E]{V,V,...,V}
יוצר מערך עם אלמנטים E, מאותחל ל-Vs. אם יש מעט מדי
מאתחלים, הרכיבים הנותרים יישארו לא מאותחלים.

[E]{V,V,...,V...}
האליפסיס השני (שלוש נקודות) הוא תחביר, לא מטא-תחביר. צור מערך עם E
אלמנטים. האלמנטים הראשונים במערך יאותחלו לפי ה-Vs,
כאשר כל האלמנטים הנותרים מקבלים את אותו ערך כמו ה-V האחרון. תחביר זה
ניתן להשתמש בצורה ברורה עם כל אחד ממפתחי המערך למטה.

[*]{V,V,...,V}
יוצר מערך אתחול עם אלמנטים רבים בדיוק כמו מאתחלים. שם
חייב להיות אתחול אחד לפחות.

[E,E,...,E] [*,*,...,*]
יוצר מערכים רב מימדיים. לא ניתן לערבב ביטויים שלמים ו-"*": an
הממדים של המערך מוגדרים לחלוטין או לא מצוינים בהגדרה.
מערכים אלה עשויים להיווצר גם באתחול: ראה את הפסקה הבאה עבור אתחול
תחביר.

(T[E]) (T[E,E,...,E]) (T[E]){E,E,...,E}

(T[E,E,...,E]){{E,...},...,{E,...}}
תחביר חלופי ליצירת מערכים מסוג T. המאתחלים, בסוגריים מסולסלים,
הם אופציונליים. מספר המאתחלים חייב להיות קטן או שווה לנתון
מספר האלמנטים בכל מימד. עבור מערכים רב מימדיים, המתולתל במיוחד
יש צורך בפלטה לכל מימד באתחול; זה בניגוד ל-C, שם הם
הם אופציונליים.

(T[*]){E,E,...,E} (T[*,*,...,*]){{E,...},...,{E,... }}
יוצר מערכים מסוג T, כאשר גודל כל מימד נתון במספר המרבי של
אתחולים בכל תת-מערך בממד זה.

מצביעים:

0 מצביע האפס, בהקשרים שבהם נדרש מצביע.

&V &A[E,E,...,E] &S.N
יוצר מצביע למשתנה הנתון, אלמנט המערך או איבר המבנה. ה
סוג המצביע יהיה *T, כאשר T הוא סוג האובייקט אליו מצביעים.

*P הערך שאליו מצביע המצביע P. ניתן לראות אותו או לשנות אותו כמו ב-C.

פונקציות:

(T func(){S;S;...S;}) (T func(T name,T name,...T name){S;S;...S;})
ביטוי פונקציה: מציין פונקציה של אפס או יותר פרמטרים פורמליים עם ה-
סוגים ושמות נתונים, מחזירה את סוג התוצאה הנתון. גוף הפונקציה נתון
לפי רשימת ההצהרות המתולתלות המצורפת. כל הסוגים הם אופציונליים, וברירת המחדל היא
פולי. כפי שצוין לעיל, פונקציות הן אך ורק קריאה לפי ערך: בפרט, מערכים
ומבנים מועתקים ולא מוזכרים.

שם פונקציה T (שם T, שם T,..., שם T){S;S;...S;}
מגדיר פונקציה של אפס או יותר ארגומנטים. סוכר תחבירי עבור
T(T,T,...T) name = (T func(T name,T name,...T name){S;S;...S;});

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

מבנים:

(struct { T name; T name; ...T name; }){name = E; שם = E; ...name=E;}
צור ערך מסוג מובנה. השדות בעלי השם מאותחלים לנתון
ערכים, כשהשאר לא מאותחל. כפי שצוין, האתחול מתבצע לפי תווית
במקום מיקום כמו ב-C.

איגודים:

(איחוד { T name; T name; ...T name; }.name) E
צור ערך של סוג האיחוד הנתון, הווריאציה הניתנת על ידי .name והערך
נתון על ידי E. E חייב להיות תואם סוג עם השם.

הצהרות

תחביר ההצהרה דומה מאוד לזה של C. יש תחביר נוסף
נוסף כדי לתמוך בפונקציונליות הנוספת של ניקל.

ה; מעריך את הביטוי.

{S ... S}
מבצע את ההצהרות המצורפות לפי הסדר.

אם (ה) ס
מותנה בסיסית.

אם (ה) ס
ביצוע מותנה.

else S Else מותר, עם התחביר והסמנטיקה הרגילים. בפרט, אחר מחייב
ל-if() או twixt() העדכניים ביותר.

בעוד (ה) ס
בעוד לולאה בסגנון C.

לעשות S תוך (E);
לעשות לולאה בסגנון C.

עבור (opt-E; opt-E; opt-E) S
סגנון C עבור לולאה.

switch (E) { case E: S-list case E: S-list ... ברירת מחדל: S-list }
הצהרת מקרה בסגנון C. ביטויי המקרה אינם נדרשים להיות קבועים
ביטויים, אך עשויים להיות שרירותיים. המקרה הראשון בהערכה למתג
ארגומנט נלקח, אחרת ברירת המחדל אם קיימת, אחרת ידלג על גוף המתג.

twixt(opt-E; opt-E) S

twixt(opt-E; opt-E) S else S
אם ביטוי הארגומנט הראשון מוערך כ-true, הגוף של ה-twixt() ולאחר מכן
ביטוי הארגומנט השני יוערך. אם ביטוי הטיעון הראשון
מוערך ל-false, הצהרת else תבוצע אם קיימת. אחרת ה
כל הצהרת twixt() תידלג.

ההצהרה twixt() מבטיחה שכל האירועים הללו יתרחשו במפרט שצוין
סדר ללא קשר לאופן שבו ה-twixt() נכנס (מבחוץ) או יציאה,
כולל חריגים, המשכים והפסקות. (השווה לסעיף ``סוף סוף'' של Java.)

נסה S;

try S catch name (שם T, ...) { S; ... };

try S catch name (שם T, ...) { S; ... } ... ;
בצע את ההצהרה הראשונה S. אם הועלה חריג במהלך הביצוע, וה
שם תואם את השם בבלוק Catch, אגד את הפרמטרים הפורמליים ב-catch
לחסום את הפרמטרים בפועל של החריג, ולבצע את גוף התפיסה
לַחסוֹם. ייתכן שיהיו מספר בלוקים של תפיסה בכל ניסיון. אפס תופסים, למרות שהם חוקיים, כן
חסר תועלת יחסית. לאחר השלמת חסימת תפיסה, הביצוע ממשיך לאחר מכן
סעיף הניסיון. כמו בכל דבר אחר, מלכוד נקשר לניסיון הרלוונטי האחרון-
בלוק לתפוס.

להעלות שם (שם, שם,..., שם)
העלה את החריג בעל השם עם אפס או יותר ארגומנטים.

; הצהרת האפס

לשבור; הפסק את הביצוע של הצהרת המצורפת הקרובה ביותר עבור/do/while/switch/twixt.
ביטוי העזיבה יבוצע כאשר הצהרת twixt תצא.

ממשי
סניף ישירות למבחן המותנה של המתחם הקרוב ל/לעשות/ תוך כדי
הצהרה.

חזרה E;
החזר ערך E מהפונקציה המקיפה הקרובה.

מרחבי שמות:

כמו Java ו-C++ לניקל יש מושג של מרחב שמות, אוסף שמות עם חלקית
ראות מוגבלת. ב-Nickle, מרחבי שמות נוצרים עם ה- מרחב שמות פקודה.

opt-P מרחב שמות N { S ... }
מציב את כל השמות שהוגדרו בהצהרות S לתוך מרחב שמות בשם N. The
הסמכה האופציונלית P עשויה להיות מילת המפתח ציבורית, אך היזהר: זה רק מציין
שהשם N עצמו נראה במקום אחר בהיקף הנוכחי, ואין לו כלום
קשור לנראות של פריטים בתוך מרחב השמות.

להרחיב את מרחב השמות N { S ... }
פתח מחדש את מרחב השמות הנתון N, והרחיב אותו עם השמות המוגדרים כציבוריים ב-
נתנו הצהרות ש.

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

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

BUILTINS

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

הרמה העליונה מבנים:

int printf(string fmt, poly args...)
קורא לקובץ::fprintf(stdout, fmt, args ...) ומחזיר את התוצאה שלו.

פונקציית מחרוזת מקבלת ()
קורא לקובץ::fgets(stdin) ומחזיר את התוצאה שלו.

פונקציית מחרוזת scanf (מחרוזת fmt, *poly args...)
קורא לקובץ::vfscanf(stdin, fmt, args) ומחזיר את התוצאה שלו.

פונקציית מחרוזת vscanf (מחרוזת fmt, (*poly)[*] args)
קורא לקובץ::vfscanf(stdin, fmt, args) ומחזיר את התוצאה שלו.

ממש לא מדויק (ערך רציונלי)
ראה את הדיון בסוג אמיתי למעלה.

ממש לא מדויק (ערך רציונלי, int prec)
ראה את הדיון בסוג אמיתי למעלה.

int string_to_integer(string s)

int atoi(מחרוזת s)
הארגומנט s הוא מחרוזת ספרות בסימן, והתוצאה היא המספר השלם שלה
מייצג. אם המחרוזת s היא תחבירית הקסדצימלית, אוקטלית, בינארית או
קבוע בסיס-10 מפורש, התייחס אליו ככזה.

int string_to_integer(string s, int base)

int atoi(מחרוזת s, int base)
התייחס ל-s כמחרוזת של ספרות בבסיס הנתון. בסיס של 0 פועל כמו ללא בסיס
טַעֲנָה. אחרת, מתעלמים מתחביר מפרט הבסיס במחרוזת.

int putchar(int c)
הצב את התו הנתון על הפלט הסטנדרטי באמצעות File::putc(c, stdout), ו
להחזיר את התוצאה שלו.

int sleep (int msecs)
נסה להשעות את השרשור הנוכחי למשך אלפיות שניות לפחות. החזר 1 על
החזרה מוקדמת, ו-0 אחרת.

int exit(int status)
צא מניקל עם קוד המצב הנתון. אל תחזיר כלום.

int dim(poly[*] a)
בהינתן מערך חד-ממדי a, dim() מחזיר את מספר האלמנטים של a.

int[] dims(poly[] a)
בהינתן מערך שרירותי a, dims() מחזיר מערך של מספרים שלמים נותן את הגודל של
כל מימד של א. לפיכך, dim(dims(a)) הוא מספר הממדים של a.

*poly reference(poly v)
בהינתן ערך שרירותי v, ``box'' את הערך הזה לאחסון והחזיר מצביע אליו
התיבה.

string_to_real(string s) רציונלי

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

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

int floor(real v)
החזר את המספר השלם הגדול ביותר קטן או שווה ל-v. זה ייכשל אם v הוא אמיתי
והדיוק נמוך מדי.

int ceil(real v)
החזר את המספר השלם הקטן ביותר הגדול או שווה ל-v. זה ייכשל אם v הוא a
אמיתי והדיוק נמוך מדי.

int exponent(ריאל v)
החזר את המעריך של הממשי הלא מדויק v.

מנטיס רציונלי (ממשי v)
החזר את המנטיסה של v הממשי הלא מדויק, כ-m רציונלי עם 0 <= m <= 0.5 .

int מונה (רציונלי v)
החזר את המונה של המספר הרציונלי v: כלומר, אם v = n/d בצורה מופחתת,
לחזור נ.

מכנה int (רציונלי v)
החזר את המכנה של המספר הרציונלי v: כלומר, אם v = n/d בצורה מופחתת,
לחזור ד.

int precision (real v)
החזר את מספר סיביות הדיוק של המנטיסה של המספר הממשי הלא מדויק
v.

int sign (real v)
החזר -1 או 1 שכן v הוא שלילי או לא שלילי.

int bit_width(int v)
החזר את מספר הסיביות הנדרשות לייצוג abs(v) פנימי.

int is_int(poly v)
הקלד פרידיקט.

int is_rational(poly v)
פרדיקטים מסוג מספרי כוללים: למשל, הוא_רציונלי(1) מחזיר 1.

int is_number(poly v)
הקלד פרידיקט.

int is_string(poly v)
הקלד פרידיקט.

int is_file(poly v)
הקלד פרידיקט.

int is_thread(poly v)
הקלד פרידיקט.

int is_semaphore(poly v)
הקלד פרידיקט.

int is_continuation(poly v)
הקלד פרידיקט.

int is_array(poly v)
הקלד פרידיקט.

int is_ref(poly v)
פרדיקט סוג: בודק סוג מצביע. ניתן לטעון שזו תכונה שגויה, ועשויה
לשנות.

int is_struct(poly v)
הקלד פרידיקט.

int is_func(poly v)
הקלד פרידיקט.

int is_void(poly v)
הקלד פרידיקט.

int gcd(int p, int q)
החזר את ה-GCD של p ו-q. התוצאה תמיד חיובית.

int xor(int a, int b)
החזר a ^ b . זה בעיקר החזקה מלפני שלניקל היה אופרטור xor.

poly setjmp(המשך *c, poly retval)
הפרימיטיבים setjmp() ו-longjmp() יחד עם סוג ההמשך יוצרים an
ADT שימושי עבור העברות כמעט שרירותיות של זרימת שליטה. ה-setjmp() ו
ה-longjmp() המובנים דומים לאלו של C, אלא שההגבלה ש-longjmp()
תמיד לקפוץ כלפי מעלה מוסר(!): המשך שנשמר באמצעות setjmp() לעולם לא הופך
לא חוקי במהלך חיי התוכנית.

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

void longjmp (המשך c, poly retval)
ה-longjmp() המובנה לעולם לא חוזר לאתר השיחה, אלא חוזר מה-
setjmp() שיצר את ההמשך, עם ערך החזרה שווה לשני
ארגומנט של longjmp().

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

שורת מחרוזת 2
ההנחיה המודפסת במהלך שימוש אינטראקטיבי בעת המתנה לשאר ההצהרה
או ביטוי. ברירת המחדל "+".

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

פורמט מחרוזת
הפורמט printf() להדפסת ערכים ברמה העליונה. ברירת המחדל "%g".

גרסת מחרוזת
מספר הגרסה של יישום Nickle המבוצע כעת.

בניית מחרוזת
תאריך הבנייה של יישום Nickle המבוצע כעת, בטופס
"yyyy/mm/dd", או "?" אם תאריך הבנייה אינו ידוע מסיבה כלשהי.

קובץ סטדין
קשור לזרם הקלט הסטנדרטי.

סטדout קובץ
קשור לזרם הפלט הסטנדרטי.

קובץ stderr
קשור לזרם השגיאות הסטנדרטי.

חריגים:

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

חריגה uninitialized_value(string msg)
נסה להשתמש בערך לא מאותחל.

חריג invalid_argument(string msg, int arg, poly val)
לארגומנט arg-th לפונקציה מובנית היה ערך לא חוקי val.

חריגה readonly_box(string msg, poly val)
נסה לשנות את הערך של כמות לקריאה בלבד ל-val.

חריג invalid_array_bounds(string msg, poly a, poly i)
ניסיון לגשת למערך a במדד i הוא מחוץ לתחום.

חריגה divide_by_zero(הודעה מחרוזת, מספר אמיתי, מאורה אמיתית)
נסה לחלק את המספר במאורה עם den == 0.

חריג invalid_struct_member(הודעה מחרוזת, מבנה פולי, שם מחרוזת)
נסה להתייחס לשם איבר של מבנה האובייקט, שאינו קיים.

חריג invalid_binop_values(string msg, poly arg1, poly arg2)
נסה להעריך אופרטור בינארי עם args arg1 ו- arg2, כאשר לפחות אחד
מהערכים האלה לא חוקי.

חריג invalid_unop_values(string msg, poly arg)
נסה להעריך אופרטור unary עם ארגומנט לא חוקי arg.

מובנה מרחבי שמות:

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

פאי אמיתי
קבוע לא מדויק נותן את הערך של יחס היקף/קוטר של
עיגול לפי דיוק ברירת המחדל של 256 סיביות.

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

real function sqrt(real v)
מחזירה את השורש הריבועי של v.

real function cbrt(real v)
מחזירה את שורש הקובייה של v.

real function exp(real v)
מחזירה e**v.

יומן פונקציות אמיתי (אמיתי א)
מחזירה v כך שe**v == a. זורק חריג invalid_argument אם a אינו-
חיובי.

real function log10(real a)
מחזירה v כך ש-10**v == a. זורק חריג invalid_argument אם a אינו-
חיובי.

real function log2(real a)
מחזירה v כך ש-2**v == a. זורק חריג invalid_argument אם a אינו-
חיובי.

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

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

Real function cos(real a)
מחזירה את היחס בין הצלע הסמוכה לתחתית הזווית a של ימין
משולש, נתון ברדיאנים.

void function sin_cos(real a, *real sinp, *real cosp)
חוזר עם sin(a) ו-cos(a) המאוחסנים במיקומים שאליהם הצביע sinp ו-cosp
בהתאמה. אם אחד המצביעים הוא 0, אל תאחסן במיקום זה. אולי
מעט יותר מהיר מאשר קריאה לשתי פונקציות ההדק בנפרד.

פונקציה אמיתית שיזוף (אמיתי א)
מחזירה את היחס בין הצלע הנגדית לצלע הסמוכה של זווית a של ימין
משולש, נתון ברדיאנים. שים לב ש-tan(pi/2) אינו שגיאה כרגע: היא תהיה
להחזיר מספר גדול מאוד בהתאם לדיוק הקלט שלו.

פונקציה אמיתית asin(ריאל v)
מחזירה כזו שsin(a) == v.

real function acos(real v)
מחזירה כזו ש-cos(a) == v.

פונקציה אמיתית atan(ריאל v)
מחזירה כזו שtan(a) == v.

פונקציה אמיתית atan2(ממשי x, y)
מחזירה כזו ש-tan(a) == x / y. מתמודד בצורה נכונה עם y == 0.

real function pow (real a, real b)
יישום המפעיל **.

קובץ מרחב השמות File מספק פעולות על ערכי קבצים.

int function fprintf(קובץ f, string s, ....)
הדפס ערכים מעוצבים לקובץ, כמו עם ספריית UNIX stdio fprintf(). fprintf()
ו-printf() מקבלים תת-סט סביר של גרסת ספריית stdio: %c, %d, %e,
%x, %o, %f, %s, %g פועלים כצפוי, וכך גם %v להדפסה חכמה של ערך. פוּרמָט
ניתן למקם מתקנים בין סימן האחוז לאות הפורמט לשינוי
עיצוב. ישנם הרבה באגים ידועים עם עיצוב קלט ופלט.

פוּרמָט אותיות:

%c דורש ארגומנט מספר שלם קטן (0..255), ומתעצב כ-ASCII
אופי.

%d דורש ארגומנט של מספר שלם, ומתעצב כמספר שלם.

%x דורש ארגומנט של מספר שלם, ומעצב כבסיס-16 (הקסדצימלי)
מספר שלם.

%o דורש ארגומנט של מספר שלם, ומתעצב כמספר שלם 8 (אוקטלי).

%e דורש ארגומנט מספר ופורמטים בתווים מדעיים.

%f דורש ארגומנט מספר, ופורמטים בסימון נקודה קבועה.

%s דורש ארגומנט מחרוזת, ופולט את המחרוזת פשוטו כמשמעו.

%g דורש מספר, ומנסה לבחור ייצוג מדויק וקריא
לעצב אותו.

פוּרמָט משנה:

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

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

- ערך דיוק המציין דיוק אינסופי.

* הארגומנט הבא ל-fprintf() הוא מספר שלם המציין את רוחב השדה או
דיוק הערך המעוצב.

פונקציית הקובץ string_write()
החזר קובץ שאוסף ערכים כתובים למחרוזת.

int function close(קובץ f)
סגור קובץ f והחזר אינדיקציה להצלחה.

int function flush(קובץ f)
שטפו את המאגרים של קובץ f והחזרו אינדיקציה להצלחה.

int function getc(קובץ f)
קבל את התו הבא מקובץ f והחזר אותו.

int function end(קובץ f)
מחזירה true אם הקובץ f נמצא ב-EOF, אחרת false.

שגיאת פונקציה int (קובץ f)
מחזירה true אם ממתינה שגיאה בקובץ f, אחרת false.

int function clear_error(קובץ f)
מנקה שגיאות ממתינות בקובץ f, ומחזיר אינדיקציה להצלחה.

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

string function string_string(קובץ f)
החזר את המחרוזת שנכתבה קודם לקובץ f, שהיה צריך להיות
נוצר על ידי string_read() או string_write(). ההתנהגות בקבצים אחרים היא כרגע
לא מוגדר.

פונקציית קובץ פתוחה (נתיב מחרוזת, מצב מחרוזת)
פתח את הקובץ בנתיב הנתון עם מחרוזת המצב הנתונה, ala UNIX stdio fopen().
המצבים המותרים הם כמו ב-stdio: "r", "w", "x", "r+", "w+" ו-"x+".

פונקציית מספר שלם fputc(מספר שלם c, קובץ f)
פלט את התו c לקובץ הפלט f, והחזר אינדיקציה להצלחה.

פונקציית מספר שלם ungetc(מספר שלם c, קובץ f)
דחוף את התו c בחזרה לקובץ הקלט f, והחזר אינדיקציה של
הצלחה.

פונקציית מספר שלם setbuf(קובץ f, מספר שלם n)
הגדר את גודל המאגר המשויך לקובץ f ל-n, והחזר את n.

string function fgets (קובץ f)
קבל שורת קלט מקובץ f, והחזר את המחרוזת שהתקבלה.

file function pipe (נתיב מחרוזת, מחרוזת[*] argv, מצב מחרוזת)
הפעל את התוכנית בנתיב הנתון, החזר קובץ שהוא קצה אחד של a
"צינור" לתהליך הנתון. ארגומנט המצב יכול להיות "r" כדי לקרוא מהצינור או
"w" כדי לכתוב לצינור. הארגומנט argv הוא מערך של מחרוזות שנותנות את
טיעונים שיועברו לתוכנית, כאשר argv[0] בדרך כלל הוא
שם התוכנית.

int function print (קובץ f, poly v, string fmt, int base, int width, int prec, string
למלא)
הדפס ערך v לקובץ f בפורמט fmt עם הבסיס, הרוחב, ה-prec והמילוי הנתונים.
בשימוש פנימי על ידי File::fprintf();

int function fscanf(קובץ f, מחרוזת fmt, *poly args...)
מלא את המיקומים עליהם מצביעים מערך args בערכים שנלקחו מקובץ f
לפי מחרוזת fmt. מפרטי הפורמט הם כמו ב-UNIX stdio scanf():
מפרטי "%d", "%e", "%f", "%c" ו-"%s" נתמכים עם הצפוי
משנים.

int function vfscanf (קובץ f, מחרוזת fmt, (*poly)[*] args)
בהינתן הקובץ f, הפורמט fmt ומערך הארגומנטים args, fscanf()
כראוי.

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

מזלג (E)
מקבל ביטוי שרירותי ומעריך אותו בשרשור צאצא חדש.
חוט האב מקבל את השרשור כערך ביטוי המזלג.

שאר פונקציות ה-Thread הן סטנדרטיות למדי.

int function kill (רשימת שרשורים...)
הורג כל שרשור פועל ברשימת המערך. ללא ויכוחים, הורג את
שרשור פועל כרגע. מחזירה את מספר השרשורים שנהרגו.

int function trace (רשימת פולי...)
מציג את המצב של כל שרשור פועל ברשימת המערך. בלי ויכוחים,
עוקב אחר המשך ברירת המחדל. מחזירה את מספר השרשורים שהתחקו אחריהם.

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

פונקציית thread current()
החזר את השרשור הנוכחי.

int function list()
מדווח על השרשור הפועל כעת ל-stdout.

int function get_priority(thread t)
מדווח על העדיפות של השרשור הנתון.

פונקציית thread id_to_thread(int id)
מחזיר את השרשור עם המזהה הנתון, אם נמצא, ו-0 אחרת.

poly function join(thread t)
ממתין שהשרשור t יסתיים, ומחזיר את כל מה שהוא מחזיר.

int function set_priority(thread t, int i)
מנסה להגדיר את העדיפות של thread t לרמה i, ומחזירה את העדיפות החדשה.
סדר עדיפויות גדול יותר אומר יותר זמן ריצה: משימה עם עדיפות גבוהה יותר תמיד תפעל
במקום משימה בעדיפות נמוכה יותר. נושאים בעלי עדיפות שווה ביותר יהיו מראש
ריבוי משימות.

סמפור
מרחב השמות של סמפור מקפל פעולות ב-ADT המובנה בסמפור. א
סמפור משמש לסנכרון חוטים. כל פעולת אות() ב-
סמפור מעורר את השרשור הכי פחות עדכני לחכות() על הסמפור הזה. ה
``ספירה'' של תהליכי המתנה עשויה להיות מוגדרת בזמן יצירת הסמפור.

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

פונקציית סמפור new()
שִׂיחָה סמפור(0) ולהחזיר את התוצאה שלו.

אות int (סמאפור s)
הגדל סמפור s. אם s אינו חיובי, ושרשור כלשהו חסום ב-s,
שחרר את השרשור הפחות חסום. החזר 1 על הצלחה.

int wait (סמאפור s)
הקטנת סמפור s. אם s שלילית, חסום עד לשחרור. החזר 1 על
הצלחה.

מבחן int (סמאפור s)
בדוק אם wait() ב-semaphore s יגרום לחסימת השרשור הנוכחי. אם כך,
החזר 0. אחרת, נסה להפחית את s, והחזר 1 אם תצליח.

String מרחב השמות של String מכיל כמה פעולות בסיסיות במחרוזת ADT.

אורך פונקציית int (מחרוזת s)
מחזירה את מספר התווים ב-s.

פונקציית מחרוזת חדשה (int c)
מחזיר כמחרוזת את התו הבודד c.

פונקציית string new(int cv[*])
מחזירה מחרוזת המורכבת מהתווים של cv.

int function index(מחרוזת t, מחרוזת p)
מחזירה את אינדקס המספרים השלמים של מחרוזת התבנית p במחרוזת היעד t, או -1 if
p אינה מחרוזת משנה של t.

string function substr(string s, int i, int l)
מחזירה את המחרוזת המשנה של המחרוזת s שמתחילה עם התו בהיסט i (אפס-
מבוסס) וממשיך למשך סך של l תווים. אם l שלילי, המחרוזת המשנה
יורכב מתווים הקודמים ולא אחרי i.

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

void function srandom(int s)
אתחול המחולל, תוך שימוש במספר השלם (באופן שרירותי-גדול) בתור זרע.

void function dev_srandom(int nbits)
אתחול המחולל, באמצעות סיביות nbits של אנטרופיה המתקבלות מכמה סבירים
מקור אנטרופיה. במערכות UNIX, מקור זה הוא /dev/urandom. מבקש עוד
אנטרופיה ראשונית מזו שיש למערכת עלולה להוביל לאתחול (כמו ב-UNIX)
או לתליה, אז השתמש בזהירות.

int function randbits(int n)
מחזיר n-קצת מספר פסאודו אקראי, בטווח 0..(2**n)-1. שימושי לדברים
כמו RSA.

int function randint(int n)
מחזירה מספר פסאודו אקראי בטווח 0..n-1.

void function shuffle(*(poly[*]) a)
מבצע עירוב אמיתי במקום יעיל (cf Knuth) של מערך a.

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

string library_path
מכיל את נתיב החיפוש הנוכחי של הספרייה, רשימה מופרדת בנקודתיים של ספריות אל
לחפש קבצי ספרייה.

int function undefine (שם מחרוזת)
מיישם את הפקודה הבלתי מוגדר ברמה העליונה. הסר את השם המסומן בשם המחרוזת
ממרחב השמות. פעולה זו מסירה את כל ההגדרות הגלויות של השם.

int function undefine(string[*] names)
הסר כל אחד מהשמות בשמות המערך ממרחב השמות. זה מסיר הכל
הגדרות גלויות של כל שם.

int function delete (שם מחרוזת)
נסה להסיר את הפקודה עם שם המחרוזת הנתון מהפקודה ברמה העליונה
רשימה, והחזר 1 אם תצליח.

int function lex_file(נתיב מחרוזת)
נסה להפוך את הקובץ בנתיב הנתון למקור הנוכחי של קוד ניקל, ו
החזר 1 אם תצליח. שים לב שזה למעשה ``כולל'' את הקובץ על ידי
דוחפים אותו לערימת קבצים לעיבוד.

int function lex_library(שם קובץ מחרוזת)
כמו lex_file(), אבל מחפש בספריות שניתנו על ידי ה library_path משתנה
עבור הקובץ הראשון עם שם הקובץ הנתון.

int function lex_string(קוד מחרוזת)
ניסיון להפוך את קוד הניקל הכלול בקוד המחרוזת להיות הקלט הבא.

int function edit(string[*] names)
מיישם את פקודת העריכה ברמה העליונה. השמות במערך הם נתיב של
שמות מרחבי שמות המובילים לשם הסמל, שהוא אחרון.

int function new (שם מחרוזת, poly func)
פונקציית ה-Binds פועלת לשם מחרוזת הפקודה ברמה העליונה: כלומר, הופכת אותה לחלק ממנה
אוצר המילים לפיקוד ברמה העליונה.

int function new_names(שם מחרוזת, poly func)
פונקציית ה-Binds פועלת לשם מחרוזת הפקודה ברמה העליונה: כלומר, הופכת אותה לחלק ממנה
אוצר המילים לפיקוד ברמה העליונה. שלא כמו new(), שמות המחרוזות שניתנו ל-func at
הרמה העליונה מועברת ללא הערכה כמערך של שמות מחרוזות או כיחידה
שם מחרוזת.

int function pretty_print(קובץ f, מחרוזת[*] שמות)
מיישם את פקודת ההדפסה ברמה העליונה. כל אחת ממחרוזות השמות שעברו נבדקת
למעלה והקוד המתאים מודפס לקובץ f.

תצוגת פונקציית int (מחרוזת fmt, poly val)
משתמש ב-printf() כדי להציג את הערך val בפורמט fmt.

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

int function show (string fmt)
מיישם את הפקודה ברמה העליונה בהיסטוריה ללא ארגומנטים. הצג את האחרון
ערכי היסטוריה עם פורמט fmt.

int function show (מחרוזת fmt, int count)
מיישם את הפקודה ברמה העליונה בהיסטוריה עם ארגומנט אחד. הצג את הספירה האחרונה
ערכי היסטוריה עם פורמט fmt.

int function show (מחרוזת fmt, int first, int last)
מיישם את הפקודה ברמה העליונה בהיסטוריה עם שני ארגומנטים.

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

מֵסַב
למערכות הפעלה רבות יש מושג כלשהו של ``משתני סביבה'' הסביבה
מרחב השמות מכיל פונקציות לתמרן אלה.

int function check (שם מחרוזת)
מחזירה 1 אם המשתנה עם השם הפרטי נמצא בסביבה, ו-0
אחרת.

פונקציית string get(שם מחרוזת)
ניסיונות לאחזר ולהחזיר את הערך של משתנה הסביבה עם ה-
שם פרטי. זורק חריג invalid_argument אם המשתנה אינו זמין.

int function unset (שם מחרוזת)
מנסה לבטל את ההגדרה של משתנה הסביבה עם השם הנתון, ומחזירה an
אינדיקציה להצלחה.

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

פקודות

לניקל יש קבוצה של פקודות שעשויות להינתן ברמה העליונה.

צא מיציאה ניקל.

צא מ-E צא מניקל עם קוד סטטוס שלם E.

בטל את הגדרת השם {,NAME}
הסר את השמות הללו מהמערכת.

טען E טען קובץ שניתן בשם המחרוזת E.

ספריה E
טען ספרייה הניתנת בשם המחרוזת E. ראה את הדיון ב-NICKLEPATH
משתנה סביבה ב-ENVIRONMENT להלן, והדיון על
Command::library_path למעלה.

E # E הדפס expr1 בבסיס expr2.

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

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

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

היסטוריה E
הצג את ערכי ההיסטוריה העדכניים ביותר של E.

היסטוריה E,E
הצג ערכי היסטוריה מהמספר השלם הראשון E עד השני.

מנפה

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

trace קבל מחסנית אחורה המראה את המצב הנוכחי, כמו בפקודה GDB where.

למעלה עברו למעלה בערימה (כלומר, לכיוון הביטוי ברמה העליונה) אלא GDB.

למטה זז למטה בערימה (כלומר, לכיוון ההקשר הנוכחי) אלא GDB.

בוצע עזוב את מצב ניפוי הבאגים, נטישת הביצוע.

בנוסף, מרחב השמות של Debug נמצא במצב איתור באגים. זה בעיקר
שימוש באיתור באגים של Nickle עצמה.

לאסוף()
הפעל את אוסף האשפה.

dump(פונקציה)
הדפס את קוד הבתים המהודר עבור הפונקציה.

הסביבה

EDITOR העורך המשמש את פקודת העריכה, המתוארת בפקודות למעלה.

NICKLERC
המיקום של קובץ ה-.nicklerc של המשתמש, שייטען בתחילת
ביצוע ניקל אם אפשר.

HOME משמש למציאת ה-.nicklerc של המשתמש אם NICKLERC אינו מוגדר.

NICKLEPATH
נתיב מופרד בנקודתיים שהרכיבים שלו הם ספריות המכילות קוד ניקל. ה
פקודת הספרייה והדגל -l, המתואר לעיל, חפשו בנתיב זה שם קובץ
תואם לקובץ הנתון. נתיב ספריית ברירת המחדל בהיעדר משתנה זה
הוא /usr/share/nickle.

NICKLESTART
שם הקובץ של הקובץ שאמור להיטען כ-bootstrap בהפעלה של Nickle.
ברירת המחדל בהיעדר משתנה זה היא לטעון
/usr/share/nickle/builtin.5c.

דוגמאות

דוגמה (לקוחה מה- bc מדריך ל:

מעריך פונקציה אמיתית (ממש x) {
אמיתי a = 1;
int b = 1;
s אמיתי = 1;
int i = 1;
בעוד (1) {
a = a * x;
b = b * i;
אמיתי c = a / b;
if (abs(c) < 1e-6)
Return s;
s = s + c;
i ++;
}
}

מגדיר פונקציה לחישוב ערך משוער של הפונקציה המעריכית e ** x ו

עבור (i = 1; i < 10; i++)
printf ("%g\n", מעריך (i));

מדפיס ערכים משוערים של הפונקציה המעריכית של עשרת המספרים השלמים הראשונים.

גִרְסָה

מסמך זה מתאר את גרסה 1.99.2 של nickle, כמו גם כמה תכונות חדשות יותר. זה היה
מופץ עם גרסה 2.77 של nickle.

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