לכידת אותות סוררים ביוניקס

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

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

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

הבעיה היא שהתעוד יחסית נורא בנושא כאשר מדובר בתכנות למי שהידע שלו בC אינו הכי חד או קיים בכלל.

למשל אם תכתבו בלינוקס :

man 3 signal

על מנת לקבל את המידע התכנותי על הפונקציה, תראו שההגדרה היא כזו:


void (*signal(int sig, void (*func)(int)))(int);

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

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

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

23 מחשבות על “לכידת אותות סוררים ביוניקס

  1. ariel

    מתעללים בשפה ?!?!
    השפה C היא מה שהיא, שפת סף.
    ה־ syntex שהצגת פה זו הדרך היחידה לממש פונקציה כזו.
    מה שמתכנתי C לרוב יעשו זה לנסות ולהקל על הקריאוּת של הקוד. וזה מופיע באותו man page שממנו שלפת את ההגדרה של הפונקציה. שימוש ב־ typedef לפונקציה שמקבלת int ומחזירה void*.

    1. ik_5 מאת

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

      type MyCallBack = procedure(sig : longint);

      ויש. נכון שזה קריא יותר אפילו מ typedef ? יודע מה, בוא נעשה את זה בגישה של C:

      funtction signal(sig : longint; callback : procdure(asig: longint)) : longint;

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

      1. ariel

        אתה טוען טענות ותומך אותן בעובדות שאינן מן העניין.
        יש לך תלונות על ה־ syntex של C ואתה מראה לי דוגמאות "טובות יותר" ב־ Object Pascal ?
        מה הקשר?
        אני מסכים לחלוטין שה־ syntex של כל שפה עילית הוא הרבה יותר קריא וקל למימוש מאשר שפת סף.
        אני מסכים ששפת C מאפשרת לעשות שטויות שלא יאמנו (או גמישות שלא תאמן).
        לקרוא להגדרת הפונקציה ההיא התעללות זה פשוט לא נכון.
        יש לך דרך טובה יותר לממש את הפונקציה ההיא ב־ C ? אם כן אני אשמח ללמוד כי כמו שאמרתי בתגובה הראשונה שלי, "השפה C היא מה שהיא, שפת סף".
        היא נבנתה לפני יותר מ־ 30 שנה והיא מיועדת למכונות יותר מאשר לבני אדם. זה בניגוד לשפות מודרניות שמקדישות יותר משאבים ומאמצים להקל על המפתח כי גם ככה החומרה היום יכולה להתמודד עם כמעט כל מה שיאכילו עליה.

        1. ik_5 מאת

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

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

          1. ariel

            1) למרות שבדרך כלל כשאומרים שפת סף מתכוונים לאסמבלר עדיין C נחשבת לשפת סף (או לפחות לא כל כך רחוקה מלהיות כזו).
            2) הסיכוי לעשות שטויות בשפת C הוא גבוה – אני מסכים.
            3) חוסר קריאוּת ב־ C זה עניין של מיומנות וניסיון
            4) נוחות – כנ"ל (מיומנות וניסיון)
            5) C ו־ pascal פותחו באותו הזמן (69-70) אבל אם אני לא טועה הקוד שלך היה Object Pascal. אני לא יודע מה המרחק ביניהן אבל אם הוא זהה למרחק בין C ל־ C++ אז מדובר בשפות שונות לחלוטין (C++ היא שפה עילית).
            6) "אבל לא כל מה שתעשה עם פסקל תצליח לעשות בC" אין דבר כזה. זה כנראה יקח לי פי כמה וכמה יותר שורות קוד אבל בסופו של דבר זה הכל אותה שפת מכונה. (באיזו שפה כתוב הקומפיילר של pascal?)
            7) מערכות unix כתובות ב־ C. ומדובר בסביבות עם נאמנות גבוהה יחסית למסורת ולתמיכה לאחור בניגוד לכל שאר התחום. מעבר לזה גם לי אין לי מושג. מצד שני המערכות הללו נהנות מאמינות מאוד גבוהה.

          2. ik_5 מאת

            1. השפה של C פותחה כשפה עילית. כיום אנחנו כמובן כבר לא רואים אותה ככזו
            3. חוסר הקריאות של השפה, זה עניין של המתכנת שכתב קוד ולא מיומנות של השפה. יש לך תחוריות C שלמות לכתיבת הקוד הפחות קריא שאפשר ליצור.
            5. הקוד שלי הוא פסקל פרוצדורלי. לא השתמשתי בשום דבר שדורש תכנות מונחה עצמים. המהדר תומך בזה אבל. פסקל מכילה ABI זהה לC במידה ומתכנתים בגישה מסויימת, אשר דרכה אני למשל מיצר binding. בעוד שב ++C זה לא המצב.
            6. הגישה של פסקל שונה מC, אבל האנרגיה של C לרוב גבוהה יותר מאשר האנרגיה שתעשה אותו הדבר בפסקל. השפת מכונה לא מבטיח לך זהות מבחינת מה שאתה מנסה לעשות, אלא רק שהמעבד שלך יבין מה ביקשת. המהדר שאני משתמש בו – FPC כתוב בפסקל מונחה עצמים (יש שם Object Oriented בקוד עצמו), והוא אפילו קוד פתוח. לעומת זאת דלפי כתוב ב ++C, ו gpc כתוב בC.
            7. גם מאק (החדש, הישן היה כתוב בפסקל מונחה עצמים – אפל המציאה את התקן של פסקל מונחה עצמים עבור מערכת ההפעלה הישנה שלהם), וגם Windows כתובות ב C ו ++C, ועדיין הן נכתבו בצורה שקל לפתח בשפות אחרות שהן לא C או ++C.

  2. artyom

    מספר הערות על הקוד:

    1. אי אפשר לתפוס SIGKILL… אתה מת ללא שאלות מיותרות🙂
    2. אסור להשתמש בפונקציות כמו writeln בתוך סיגנלים, למעשה יש מעט מאוד פעולות שניתן לבצע בתוך סיגנן
    3. signal די deprecated כדאי להשתמש ב־sigaction ולקרוא man sigaction

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

    בקיצור עידו הבעיה היא לא "לחבר סיגנל" אלא להבין כיצד להשתמש בהם נכון, למשל אסור לקרוא ל־writeln או printf…

    תקרא man 7 signal שמסביר הרבה דברים חשובים מבחינת עקרונות

    1. ik_5 מאת

      אם היית קורא את הקוד כמו שצריך היית מגלה שאני לא באמת לוכד את sigkill.
      יותר מזה, היית מגלה שאני לא עובד עם הפקודה signal בכלל, אלא הפקודה sigaction.
      לא יודע אם אסור (printf לא זהה ל write או writeln), אבל בman מן הסתם יש רק פקודות של עולם ה C שהן "בטוחות" לשימוש. כמו שאמרתי, המערכת מותאמת מידי לשפת C ולא לשום שפה אחרת.

        1. artyom

          זה לא קשור, strace מקרה לך system calls… זה לא אומר מספיק. למשל דברים שאסור לעשות:

          1. נעילה של mutexים, כי זה יכול לגרום ל־deadlockים
          2. הקצאות זיכרון (כי דורש mutexים)

          אז אם אתה יודע ש־writeln לא מקצא שום דבר אלא כותב את הכל as-is לקובץ ולא עושה דברים אחרים אז זה בסדר… שאלה אם זה נכון (סביר להניח שלא).

          מה שמקובל לעשות זה בד"כ self-pipe-trick ואז להגיב לסיגנל במקום אחר.

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

  3. tomer

    1) מה מעצבן ב-C?
    2) לא הבנתי מי פה מתעלל ב-C (בטח שלא הקריאה SIGNAL).
    3) נו מה לעשות שכשבאים להשתמש במוצר צריך ללמוד את הממשק שלו? אני מבין שאתה מצפה לדעת איך משתמשים במוצר בלי ללמוד שום דבר — גם אם היה מוצר כזה (ואין באמת), LINUX או UNIX הם בטח לא כאלה…
    4) "קוד יותר קריא" – לדעתך כמובן… (ובפרט לא לדעתי)
    5) למי שאינו בקיא בשפה שיחפש דוגמא בגוגל לשימוש בפונקציה ויבין לבד או לחילופין שילמד C או לחילופין שילמד קורס על C. בכל מקרה, הטענה שלך היא בערך "אני לא יודע C ולכן אני *כועס* על מי שגורם לי להשתמש בה".
    6) "פשוט לקרוא את זה" – מעט מאוד דברים בעולם שהם טכניים הם פשוטים לקריאה. עוד לא ראיתי מישהו קורא מאמר מתקדם בביולוגיה ומצליח להסביר אפילו אחד מהמושגים בלי היכרות מוקדמת איתם. זה מה שנקרא incremental knowledge.
    7) אני די בטוח שיש wrappers להמון שפות (למשל בJAVA יש natively, בpython לא בדקתי אבל אני מאמין שיש, ואני מוכן להמר שאם ממש תתאמץ גם תוכל למצוא איזושהי דרך גאונית (אהמ אהמ… עקומה אהמ…) לתפוס סיגנל מתוך סקריפט).

    1. ik_5 מאת

      אני יודע C הרבה יותר ממה שהרבה חושבים. זו הסיבה שאני בוחר לא להשתמש בה כשאני יכול לא לגעת בה. למעשה הרבה פעמים אני זה שמפרש לאחרים קוד שמישהו כתב בC. ומה זה ללמוד C בדיוק ? האם כאשר אתה רואה בקוד משהו כמו __attribute__ זה ללמוד C ? אה לא, זה ללמוד gcc …

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

      7. אני גם יצרתי סוג של wrapper מסויים לקוד אם לא שמת לב.

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

      procedure a_message(…); message wm_user+1024;

      למשל. וזה מבטיח לך שאם יש לך "הודעה" של wm_user+1024 שזה יכנס לשם. אבל זו לא הדרך היחידה לעשות את זה.

      1. ariel

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

      2. Tomer

        למען האמת רק הצצתי בקוד שלך – ואם אתאמץ אני מאמין שאוכל להבין אותו – אבל כיוון שאני לא יודע OBJECT PASCAL (שזה מה שזה מתברר), ולא זוכר PASCAL (מימי התיכון), אני לא מבין כלום…
        אבל זה לא אומר שאני כועס – ברור לי שאם אני רוצה להבין את הקוד אני צריך ללמוד OBJECT PASCAL…
        אבל בכל מקרה, אחרי הצצה שנייה בקוד, לפי מה שאני רואה בקריאה החדשה שלך (AddTrap אם הבנתי נכון), אתה לא נותן למשתמש להגדיר CALLBACK.

        אני לא רואה איך זה יכול להחליף את ה-INTERFACE של LINUX בצורה כזו.
        ד"א המושג של CALLBACK הוא די בסיסי לעולם התוכנה, ואני לא רואה דרך אפשרית להיפטר ממנו. הבעיה היחידה עם C אולי היא ה-SYNTAX, שהוא באמת לא הכי פשוט (במקרה של FUNCTION POINTER) – אבל מצד שני הוא ייתן לך הרבה יותר TYPE SAFETY מסתם POINTER (שגם בו אולי תוכל להשתמש אם ממש תרצה – פשוט תבקש void * ותמיר אותו למה שבא לך).
        בסה"כ מכל השפות לדעתי C היא הפשוטה ביותר. רמת הסיבוכיות ב"שפות עילית" כמו C++ ו-JAVA עולה בצורה אקספוננציאלית ככה שכשאתה עושה משהו ב"קלות", למעשה אין לך מושג מה בכלל קורה… ובגלל זה (לדעתי) הרבה הרבה יותר קשה להיות מומחה ב-C++ מאשר ב-C (אבל לא בג'אווה, כי שם בכלל לא ברור מה קורה – לא מתכוון להעליב, פשוט זו הייתה החוויה שלי משימוש בג'אווה)…

        1. ik_5 מאת

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

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

          המקביל של * void בפסקל יכול להיות מספר דברים. מטיפוס בשם Pointer שהתפקיד שלו בחיים זה רק להחזיק את הכתובת זיכרון. אבל אני יכול גם לתרגם את זה לפרוצדורה/פונקציה ואז זה יהיה callback. הכל תלוי בכוונת המשורר בשביל לדעת איך לתרגם. זו הסיבה שמאוד מעצבן לעשות binding לקוד C. כי אתה צריך להבין את הקוד כאילו אתה כתבת אותו בשביל לדעת את כוונת המשורר.

          ג'אווה ו #C אינן דוגמאות טובות היות והגישה שלהם זהה לגישה של הרבה מתכנתי C שהיא אם יש לך פטיש ביד כל דבר נראה מסמר. OO זה כלי אחד בארסנל, אבל 2 השפות האלו משתמשות בו כדרך תכנות ולא ככלי אחד מתוך קבוצה. ב C מצביעים הפכו להיות פטיש, כי חסרים לך המון כלים מאוד בסיסיים. הבעיה היא שזה מתנקם בכולם. זו הסיבה שיש לך דגלי ריצה שלמים במעבד כיום, אשר מנסים לעזור לך למנוע Buffer Overflow ובעיקר ניצול שלו. בגלל הבעיה שיותר מידי משתמשים ב C, ועושים את זה לא נכון. זה מתחיל מכלים כמו strcpy במקום strncpy למשל, ובכלל בכל דבר שמשתמש במצביעים בהם לא בודקים מספיק לעומק את הקלט שמתקבל ממשתמשים. וזה כל כך נורא, עד שמפרשים שלמים הכתובים ב C גומרים לבאגים בשפות תכנות אחרות שהמפרשים כתובים בהם. למשל ברובי היה באג שיכולתי בעת פרסור stream גדול לגרום ל buffer overflow של המפרש עצמו. היה גם לפרל את זה ולהרבה דפדפנים זה קורה עם JS

          1. Tomer

            1) אני מסכים – לא למדתי PASCAL בתיכון (ואני בטח שלא מתעצבן) – אלא רק את ה-SYNTAX.
            כדי ללמוד שפה צריך נסיון.

            2) לגבי ה-WRAPPER, הוא טוב רק לתכנית שלך. כמשתמש כללי לא תוכל להיעזר בו, ולכן כנראה שהדרך היחידה (ולכן הטובה) לעשות את זה היא הדרך של הקריאה SIGNAL.

            3) אתה תמיד יכול להמיר ל-VOID *… מה שהוא נורא כשלעצמו (בעיני) כיוון שאז אתה מאבד TYPE SAFETY…. אם אתה מחפש גמישות (מבחינת טיפוסים), אז C זה לא המקום הנכון לחפש אותה. נסה SHELL.

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

            ד"א יש דרכים מגוונות להתעלל בתוכנה וזה לא חייב להיות ב-C. הנה דוגמא – במקום שאני עובד, הצוות הקודם חשב שחבל להתאמץ בשביל לפתור באגים – דיבאגר זה בזבוז זמן – במקום זה פשוט שמים WATCHDOG… והיום גם גיליתי שזו מדיניות בצבא דבר כזה (וכצירוף מקרים מצחיק הם היו יוצאי 8200).
            זה היה כל-כך חמור שהם ביקשו מהלקוחות לעשות "סרטיפיקציה" לחומרה.
            במילים אחרות, התוכנה שלהם רצה רק על קונפיגרציות חומרה מסויימות (כן כן, יש לוחות ומס' מעבדים מוגבלים שהיא רצה עליהם). ולמען הסר ספק – אין שום גישה לחומרה בתוכנה, והיא בסה"כ מנהלת כמה מצלמות (מעל LINUX בעזרת GSTREAMER).
            אבל כשרוצים להתעלל בתוכנה – מוצאים דרך.

  4. ariel

    (אי אפשר להגיב ישירות אז אני מגיב פה)

    3) כנראה לא הייתי ברור. ככול שהמפתח יותר מיומן ובעל יותר ניסיון הוא מפיק קוד קריא יותר וגם מסוגל לקרוא קוד ברמות קריאות שונות. (אין זה אומר שאני מצליח לשמור על שלוות נפשי כשאני נתקל בזוועות).
    5) החכמתי.
    6) פה אתה איבדת אותי. מה זה "אבל האנרגיה של C לרוב גבוהה יותר מאשר האנרגיה שתעשה אותו הדבר בפסקל" מה זה? אנרגיה ניו אייג'ית? כמו הצ'אקרה של visual basic? או שאתה בכלל מדבר על על צריכת החשמל של המעבד?

  5. נדב

    "השפה שמימשתי בעצמי, מכילה בדיוק את אותן היכולות של C ועוד הרבה יכולות ש C לא מסוגלת להגיע אליהן לבד (מבחינת low level) ללא עזרה מאסבלר."

    אפשר דוגמאות של מה שבC חייב להשתמש באסמבלר, בעוד פסקל מתמודדת איתם?

    1. ik_5 מאת

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

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

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

      1. נדב

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

        1. ik_5 מאת

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

          למשל המצב הבא:
          type tmynum = 3..5;
          tMyPackedRec = bitpack record
          num : tmynum;
          end;

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

          אני יכול ליצור לך מצב כזה:
          var
          a : longint;
          b : PChar absoulte a;

          המקביל שלו בC זה

          typedef union my_union_t {
          int a;
          char * b
          }

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

          type
          tmy_union = record
          case integer of
          0 : (a : longint; b : char;);
          1 : (c, d : pointer );
          2 : (f : float);
          end;

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

          יש לי enum אמיתי בפסקל, בעוד שC לא תומך בכלל. למעשה enum בC זה בעצם קבוע, אשר חוסך ממך לכתוב כל פעם "=" לערכים, ומאפשר לך לאגד אותם תחת שם אחד.

          יש לי 3 דרכים ליצור בפסקל מערך דינאמי,הראשון קיים לך משנות ה70, השני נכנס בשנות ה80, והשלישי בשנות ה90. ב C יש לך רק 2 דרכים לעשות את זה (2 הראשונות שיש בפסקל).

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

  6. פינגבק: exitproc | לראות שונה

כתיבת תגובה

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

הלוגו של WordPress.com

אתה מגיב באמצעות חשבון WordPress.com שלך. לצאת מהמערכת / לשנות )

תמונת Twitter

אתה מגיב באמצעות חשבון Twitter שלך. לצאת מהמערכת / לשנות )

תמונת Facebook

אתה מגיב באמצעות חשבון Facebook שלך. לצאת מהמערכת / לשנות )

תמונת גוגל פלוס

אתה מגיב באמצעות חשבון Google+ שלך. לצאת מהמערכת / לשנות )

מתחבר ל-%s