cgmNCARG - מקוון בענן

תָכְנִית:

שֵׁם

CGM_open, CGM_close, CGM_lseek, CGM_read, CGM_write, CGM_directory, CGM_freeDirectory,
CGM_printDirectory, CGM_getInstr, CGM_flushGetInstr, CGM_putInstr, CGM_flushOutputInstr,
CGM_initMetaEdit, CGM_termMetaEdit, CGM_copyFrames, CGM_deleteFrames, CGM_mergeFrames
CGM_moveFrames, CGM_readFrames, CGM_valid, CGM_writeFile, CGM_writeFrames,
CGM_appendFrames - פעולות Metafile של מחשב גרפיקה

תחביר

#include

Cgm_fd CGM_open(metafile, גודל, דגלים, מצב)
char *metafile;
לא חתום גודל;
int דגלים;
int מצב;

int CGM_close(cgm_fd)
Cgm_fd cgm_fd;

int CGM_lseek(cgm_fd, לְקַזֵז)
Cgm_fd cgm_fd;
int לְקַזֵז;

int CGM_read(cgm_fd, buff)
Cgm_fd cgm_fd;
לא חתום char *באף;

int CGM_write(cgm_fd, buff)
Cgm_fd cgm_fd;
לא חתום char *באף;

מַדרִיך *CGM_directory(cgm_fd)
Cgm_fd cgm_fd;

לבטל את CGM_freeDirectory(dir)
מַדרִיך *dir;

לבטל את CGM_printDirectory(dir)
מַדרִיך *dir;

int CGM_getInstr(cgm_fd, instr)
Cgm_fd cgm_fd;
מכשירים *instr;

לבטל את CGM_flushGetInstr(cgm_fd)
Cgm_fd cgm_fd;

int CGM_putInstr(cgm_fd, instr)
Cgm_fd cgm_fd;
מכשירים *instr;

int CGM_flushOutputInstr(cgm_fd)
Cgm_fd cgm_fd;

מַדרִיך *CGM_initMetaEdit (מטאפיל, גודל)
char *metafile;
לא חתום int גודל;

int CGM_termMetaEdit()

מַדרִיך *CGM_copyFrames(התחל, מספר, יעד )
לא חתום int הַתחָלָה;
int מספר;
לא חתום int יַעַד;

מַדרִיך *CGM_deleteFrames(התחל, מספר)
לא חתום int להתחיל,
מספר;

מַדרִיך *CGM_mergeFrames(תחתונה, חלק עליון)
לא חתום בתחתית, חלק עליון;

מַדרִיך *CGM_moveFrames (הַתחָלָה, מספר, יַעַד)
לא חתום int להתחיל, מספר, יַעַד;

מַדרִיך *CGM_readFrames(metafile, להתחיל, מספר, יעד, גודל)
char *metafile;
לא חתום int הַתחָלָה;
int מספר;
לא חתום int יעד, גודל;

int *CGM_validCGM(מטאפיל)
char *metafile;

int CGM_writeFile(מטאפיל)
char *metafile;

int CGM_writeFrames(metafile, להתחיל, מספר)
char *metafile;
לא חתום להתחיל, מספר;

int CGM_appendFrames(metafile, להתחיל, מספר)
char *metafile;
לא חתום להתחיל, מספר;

תיאור

הוויכוח cgm_fd מתייחס לתיאור קובץ חוקי שנוצר לקריאה או כתיבה, כמו
מתאים על ידי CGM_open. CGM_read, CGM_directory, CGM_getInstr ו CGM_flushGetInstr
דורש מתאר קובץ פתוח לקריאה. CGM_write, CGM_getInstr,CGM_flushGetInstr ו
CGM_flushOutputInstr דורש א Cgm_fd פתוח לכתיבה. CGM_סגור ו CGM_lseek יצטרך
לקבל כל תקף Cgm_fd.

השמיים גודל ארגומנט מתייחס לגודל רשומת CGM בבתים. עבור NCAR CGM ערך זה הוא
1440.

buf הוא מצביע לזיכרון בגודל שהוקצה למשתמש גודל. אחסון זה ישמש עבור
חציצה קלט ופלט של CGM_read ו CGM_write בהתאמה.

השמיים dir טיעון הוא מצביע על א מַדרִיך מבנה שנוצר עם CGM_directory or
CGM_initMetaEdit. dir הוא משאב פרטי שצריך לא להיות שונה ישירות על ידי
מִשׁתַמֵשׁ. קבוצה של פקודות מאקרו נוחות מסופקת למטרה זו ב cgm_tools.h.

השמיים התחלה, NUM ו יעד ארגומנטים משמשים כדי להתייחס למספרי מסגרת בישות מטא-קובץ
נערך באחת מהפקודות: CGM_copyFrames, CGM_deleteFrames, CGM_readFrames,
CGM_moveFrames, CGM_writeFrames ו CGM_mergeFrames. ה התחלה הטיעון הוא הראשון
מסגרת ברצף של NUM מסגרות לביצוע פעולת העריכה. יעד דומה
ל התחלה והוא משמש על ידי פקודות הדורשות שתי כתובות מסגרת כגון העתק. פְּנִיָה
מתחיל באפס.

CGM_open
פקודה זו מעוצבת לפי ה-Unix לפתוח פקודה. זה יפתח CGM לקריאה
או כתיבה כמפורט על ידי דגלים טיעון והחזר א Cgm_fd מתאר קבצים.
השמיים דגלים ו לפתוח הפרמטרים מועברים ישירות למערכת לפתוח פקודה.
להסבר מפורט של שני טיעונים אלה ראה לפתוח(2).

CGM_סגור
מחק מתאר קובץ. ההפך של CGM_open. לראות close(2).

CGM_read
CGM_read ניסיונות לקרוא גודל בתים מהאובייקט שאליו יש הפניה דרך ה-
מתאר cgm_fd. גודל נקבע ביצירתו של cgm_fd by CGM_open. CGM_read
מחזירה את מספר הבתים שנקראו בהצלחה. אפס מוחזר על EOF ו-a
מספר שלילי מרמז על אירעה שגיאה. קריאת מערכת יוניקס לקרוא נקרא על ידי
CGM_read. לראות לקרוא(2).

CGM_write
ניסיונות לכתוב רשומה בודדת של גודל בתים מ buf מהאובייקט אליו מתייחסים
by cgm_edit איפה גודל הוא פרמטר גודל הרשומה שסופק בעת יצירת
cgm_fd. לכתוב מחזירה את מספר הבתים שנכתבו בהצלחה. תשואה שלילית
מספר מרמז על אירעה שגיאה. קריאת מערכת יוניקס לכתוב נקרא על ידי
CGM_write. לראות לכתוב(2).

CGM_lseek
הקדם את מצביע הקובץ של cgm_fd ל לקזז בתים. עם סיום מוצלח של
היסט מצביע הקובץ הנוכחי מוחזר. ערך החזר שלילי הוא שגיאה. ה
שיחת מערכת יוניקס מבקש נקרא על ידי CGM_lseek. לראות מבקש(2).

CGM_directory
צור תוכן עניינים עבור המטא-קובץ שאליו מתייחס cgm_fd. החזר מצביע
לטבלה מסוג זה מַדרִיך. התוכן של הספרייה כולל מספר של
metafiles, מספר פריימים, היסט רשומה עבור כל פריים, אורך פריימים ברשומות,
תיאור מסגרת אופציונלי ומצב מטא-קובץ. שדות אלו מיועדים לקריאה
רק ויש להתייחס אליהם רק על ידי פקודות המאקרו הנוחות המפורטות ב
cgm_tools.h. מצביע NULL מוחזר במקרה של כשל.

CGM_freeDirectory
זיכרון פנוי שהוקצה לספרייה שנוצרה על ידי CGM_directory or CGM_initMetaEdit.

CGM_printDirectory
הדפס את התוכן של ספרייה שהצביע עליה dir לפלט הסטנדרטי.

CGM_getInstr,
אחזר את ההוראה הבאה בקובץ שאליו מתייחסים cgm_edit ולהמיר אותו ל-a
פורמט שמיש שהצביע עליו instr. CGM_getInstr מספק ממשק ל
metafile לחילוץ יסודות CGM. המשתמש לא צריך להיות מודאג עם
פורמט בינארי של המטא-קובץ. השדות של ה מכשירים הם כמתואר ב
cgm_tools.h. המשתמש צריך לשים לב שאורך הנתונים המרבי המותר הוחזר
בהזמנה בודדת הוא 32760 בתים. תקן CGM מאפשר עד 32767 בתים
להיות מאוחסן בהוראה אחת. אבל 32767 הוא לא מספר נחמד לעבוד איתו.
אם אורך הנתונים של הוראת CGM יעלה על 32760 בתים, המצוין על ידי
בוליאני יותר דגל, הקריאה הבאה של CGM_getInstr יחזיר את הנותר
נתונים עד אותו הגבול וכו'. CGMgetInstr דורש תקף Cgm_fd פתוח עבור
קריאה. לתיאור על CGM עיין בתקן ANSI.

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

CGM_putInstr
האנלוגי ל CGM_getInstr. פונקציה זו מאחסנת הוראות CGM שיש לכתוב אליהן
CGM שמופנה על ידי cgm_fd. שוב המשתמש לא צריך להיות מודאג מהבינארי
פורמט הקובץ. הכתיבה מתבצעת ברצף בגודל שיא גודל as
שצוין במהלך היצירה של cgm_fd. אותם אילוצי אורך נתונים שהם
ממוקם ב CGM_getInstr להחזיק מעמד CGM_putInstr. אם המשתמש רוצה להפיק פלט
הוראות עם אורך נתונים גדול מ-32760 בתים אז הנתונים חייבים להיות
מפורקים לבלוקים שאינם גדולים מגודל זה. המשתמש חייב גם להגדיר את הבוליאנית
יותר דגל ב מכשירים. cgm_fd חייב להיות מתאר קובץ חוקי פתוח לכתיבה.
לתיאור השדות של ה מכשירים לראות את הקובץ cgm_tools.h.

CGM_flushOutputInstr
רוק את מאגר הפלט בשימוש על ידי CGM_putInstr עבור הקובץ שאליו מתייחס cgm_fd. זה
הכרחי כדי לשטוף במפורש את מאגר הפלט שבו נעשה שימוש CGM_putInstr לפני
הקובץ נסגר או כל גישה אקראית מבוצעת. אחרת לא כל האלמנטים של CGM
ייכתב בפועל.

CGM_initMetaEdit
אתחול מטא-קובץ לעריכה. זוהי שגרת האתחול עבור
שגרות עריכה ברמה גבוהה יותר הכלולות בחבילה זו: CGM_copyFrames,
CGM_deleteFrames, CGM_readFrames, CGM_moveFrames, CGM_writeFile, CGM_writeFrames,
ו CGM_mergeFrames. שגרות אלה פועלות רק על מטא-קובץ אחד בכל פעם (האחד
שמו ב CGM_initMetaEdit. להפעיל את השגרה הזו בפעם השנייה בלי
שמירה מפורשת של כל שינוי תהיה השפעה של טעינת קובץ חדש ו
ביטול כל השינויים שבוצעו בקובץ הקודם. CGM_initMetaEdit וכל
ממשיך בעריכת פונקציות כי לעשות שינויים בקובץ מחזירים מצביע ל-a
מַדרִיך כנוחות המאפשרת למשתמש לבחון את מצב הקובץ.
התוכן של הספרייה הוא פרטי ואין לשנותו על ידי המשתמש. א
סט פקודות מאקרו מסופק ב cgm_tools.h כדי לשמש לאחזור של הספרייה
תוכן. הערות: לא מתבצעים בפועל שינויים בקובץ העריכה אלא אם כן
הוחלפו במפורש עם אחד מהם CGM_writeFile or CGM_writeFrames.

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

CGM_copyFrames
העתק NUM מסגרות שמתחילות ב התחלה למסגרת שפונה על ידי יעד. אם יעד is
כבר תפוס אז מסגרות המקור מוכנסות במקומן בזמן שהמטרה
המסגרת, וכל הפריימים המתקדמים, מתקדמים. CGM_copy פועל על הקובץ
מאותחל על ידי CGM_initMetaEdit (קובץ העריכה). בסיום מוצלח מצביע
לספרייה הנוכחית מוחזר. בשגיאה מוחזר מצביע NULL.

CGM_deleteFrames
מחק NUM מסגרות מקובץ העריכה המתחיל ב-frame התחלה. על מוצלח
השלמה מוחזר מצביע לספרייה הנוכחית. בשגיאה מצביע NULL
מוחזר.

CGM_mergeFrames
החלף את תוכן המסגרת המופנית תחתית עם האיחוד של המסגרת ב
מיקום תחתית והמסגרת במקום חלק עליון. ההשפעה של פקודה זו היא
שווה ערך לציור את חלק עליון מסגרת על גבי ה תחתית מִסגֶרֶת. זה לא איגוד
במובן האמיתי של המילה. בסיום מוצלח מצביע על הזרם
הספרייה מוחזרת. בשגיאה מוחזר מצביע NULL.

CGM_moveFrames
הזז בלוק של NUM מסגרות מקובץ העריכה שמתחיל ב-frame התחלה אל ה
מיקום תפוס על ידי מסגרת יעד בסיום מוצלח מצביע על הזרם
הספרייה מוחזרת. בשגיאה מוחזר מצביע NULL.

CGM_readFrames
חומר עיוני NUM מסגרות מ-metafile פילה מתחיל עם מסגרת התחלה. הכנס את המסגרות ב
כתובת יעד בקובץ העריכה. בסיום מוצלח מצביע על הזרם
הספרייה מוחזרת. בשגיאה מוחזר מצביע NULL.

CGM_validCGM
קבע אם קובץ הוא NCAR CGM חוקי או לא. פונקציה זו מבצעת כמה
אבחון פשוט במאמץ לקבוע אם קובץ נתון נמצא ב-NCAR
פורמט CGM. הבדיקות שבוצעו אינן קפדניות ואפשר להעלות על הדעת כי
המידע שאוחזר אינו נכון. החזרה של 1 מציינת NCAR CGM חוקי. א
החזרה של 0 מציינת שהקובץ אינו NCAR CGM. החזרה של -1 מציינת שגיאה
התרחש והמשתנה הגלובלי `errno' מוגדר בהתאם.

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

CGM_writeFrames
כתוב בלוק של NUM מסגרות שמתחילות עם מסגרת התחלה ל פילה. מסגרות המקור
מגיעים מקובץ העריכה. הערה: מסגרות CGM כלולות בעטיפה המורכבת מ
CGM מפריד אלמנטים. הקובץ שנוצר על ידי CGM_writeFrames ישתמש ב- עֲטִיפָה
מסופק על ידי קובץ העריכה הנוכחי. כך אם קובץ Foo מכיל n מסגרות שהן
לקרוא לתוך סשן עריכה עם קובץ גו ואז אותם מסגרות נכתבות
לצאת לקובץ זיד, זיד יכול להיות זהה למקור או לא Foo.
CGM_writeFrames מחזיר את המספר השלם אחד על הצלחה ומספר שלילי על
כישלון.

CGM_appendFrames
הוסף בלוק של NUM מסגרות שמתחילות עם מסגרת התחלה ל פילה. פילה חייב כבר
להתקיים ולהיות NCAR CGM חוקי. CGM_appendFrames מחזיר את המספר השלם על הצלחה
ומספר שלילי על כישלון.

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