create-native-map - מקוון בענן

תָכְנִית:

שֵׁם

create-native-map - C/C# Mapping Creator

תַקצִיר

צור מפה מקומית [אפשרויות]* ASSEMBLY-FILE-NAME Output-PREFIX

אפשרויות

--autoconf-header=HEADER
HEADER הוא שם קובץ כותרת בתחביר המשמש בדרך כלל עם ה-C #include
הצהרה, למשל #include or #include "local.h" .

מאקרו בפורמט Autoconf נוצר מהשם include, ו-a #include
ההנחיה עטופה בתוך א #ifdef בלוק עבור המאקרו Autoconf בתוך
נוצר .c קובץ.

לדוגמה, --autoconf-header= ייצור את הקוד:

#ifndef HAVE_STDIO_H
#לִכלוֹל
#endif /* ndef HAVE_STDIO_H */

--autoconf-member=MEMBER
ציין כי כל גישה ל חבר צריך להיות עטוף בתוך א #ifdef HAVE_MEMBER
לַחסוֹם. חבר יכול להיות או שם שדה או שם כיתה . שם שדה
שילוב.

לדוגמה, בהינתן הצהרת C#:

[Mono.Unix.Native.Map ("struct dirent")]
struct Dirent {
ציבורי ארוך d_off;
}

אז --autoconf-member=d_off יפיק את הקוד בדומה ל:

int
ToDirent (מבנה dirent *from, struct Dirent *to)
{
#ifdef HAVE_STRUCT_DIRENT_D_OFF
to->d_off = from->d_off;
#endif /* ndef HAVE_STRUCT_DIRENT_D_OFF */
}

--exclude-native-symbol=SYMBOL
סמל הוא [DllImport] שיטה מסומנת שצריך לֹא ליצור אב טיפוס
בשביל זה.

--impl-header=HEADER
הכנס א #include הצהרה בתוך המופק .c עבור HEADER .

לדוגמה, --impl-header= מייצר

#לִכלוֹל

--impl-macro=MACRO
הכנס א #define הצהרה בתוך המופק .c קובץ. מקרו יכול להכיל א = ל
להפריד בין שם המאקרו לבין ערך המאקרו.

לדוגמה, --impl-macro=FOO=42 מייצר

#define FOO 42

--library=LIBRARY
צור אבות טיפוס עבור [DllImport] שיטות מסומנות המתייחסות לליד
ספריה סִפְרִיָה לתוך שנוצר .h קובץ.

--public-header=HEADER
הכנס א #include הצהרה בתוך המופק .h עבור HEADER .

לדוגמה, --public-header= מייצר

#לִכלוֹל

--public-macro=MACRO
הכנס א #define הצהרה בתוך המופק .h קובץ. מקרו יכול להכיל א = ל
להפריד בין שם המאקרו לבין ערך המאקרו.

לדוגמה, --public-macro=FOO=42 מייצר

#define FOO 42

--rename-member=FROM=TO
זה משמש כאשר מן הוא מאקרו C, ולכן יש לשנותו כדי להשתמש בו
בשפיות. כל ההפניות שנוצרו לייצוג המנוהל ישתמשו ל במקום
of מן .

לדוגמה, בהינתן הצהרת C#:

[Mono.Unix.Native.Map ("סטט struct")]
struct Stat {
זמן ציבורי ארוך;
}

והטיעון --rename-member=st_atime=st_atime_ , הנוצר .h הקובץ היה
לכלול:

struct Stat {
gint64 st_atime_;
};

(שימו לב לשם השדה שהשתנה), בזמן שנוצר .c הקובץ יכיל:

ToStat (struct stat *from, struct Stat *to)
{
to->st_atime_ = from->st_atime;
}

--rename-namespace=FROM=TO
כברירת מחדל, מרחב השמות C (קידומת סמל) הוא מרחב השמות C#; סוגים בתוך
מרחב השמות של C# Mono.Unix.Native יהיה במרחב C "שם" Mono_Unix_Native . להשתמש
--rename-namespace כדי לשנות את ברירת המחדל, למשל --שנה שם-
namespace=Mono.Unix.Native=Mono_Posix .

תיאור

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

Platform Invoke שימושי רק אם הקוד המנוהל יודע את הסוגים והפריסה המדויקים של כולם
מבנים לא מנוהלים שבהם הוא משתמש. זה בדרך כלל המקרה ב-Windows, אבל זה כן לֹא המקרה
על יוניקס. לדוגמה, מבנה stat עושה שימוש בסוגים עם גדלים שישתנו מ
פלטפורמה לפלטפורמה (או אפילו על סמך פקודות המאקרו של המהדר שהוגדרו!). לדוגמה, off_t
הוא בדרך כלל מספר שלם של 32 סיביות חתום בפלטפורמות ILP32, אך עשוי להיות מספר שלם של 64 סיביות חתום
בפלטפורמות LP64, אך עשוי להיות גם מספר שלם חתום ב-64 סיביות בפלטפורמות ILP32 אם
_FILE_OFFSET_BITS למאקרו יש את הערך 64. בקיצור, הכל גמיש בתוך יוניקס,
וקוד מנוהל לא יכול להתמודד עם גמישות כזו.

לפיכך, הנישה עבור צור מפה מקומית : נניח ABI קבוע שקוד מנוהל יכול לכוון אליו,
וליצור קוד כדי "לפתות" את הייצוגים המנוהלים למקור המתאים
ייצוגים. זה צריך להיעשות עבור הכל שיכול להשתנות בין פלטפורמות ו
דגלי מהדר, מתוך ערכי ספירה ( SIGBUS יש את הערך 10 ב- FreeBSD אבל 7 ב-
לינוקס) למבנה חברים (כמה גדול זה off_t ?).

צור מפה מקומית יבדוק ASSEMBLY-FILE-NAME ופלט את הקבצים הבאים:

OUTPUT-PREFIX.h
מכיל ערכי ספירה, הצהרות מחלקות ומבנה, נציג
הצהרות, ו [DllImport] שיטות מסומנות (מהספרייה שצוינה על ידי
--סִפְרִיָה ) בתוך ההרכבה ASSEMBLY-FILE-NAME .

OUTPUT-PREFIX.c
מכיל יישום של ספירה והמרת מבנה
פונקציות.

OUTPUT-PREFIX.cs
מכיל מחלקה חלקית NativeConvert המכיל תרגום ספירה
שיטות.

OUTPUT-PREFIX.xml
יוצר בדלי תיעוד ECMA XML עבור תרגום הספירה
שיטות ב OUTPUT-PREFIX.cs .

צור מפה מקומית מחפש בעיקר MapAttribute -סוגים מעוצבים, ועושה שימוש בשניים
MapAttribute נכסים:

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

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

זה שימושי כאשר מידע bitmask ומידע שאינו bitmask מאוחסן בתוך
אותו סוג, ובדיקת bitmask לא אמורה לשמש עבור הלא-bitmask
ערכים. דוגמא: Mono.Unix.Native.FilePermissions.S_IFREG , שאינו א
ערך bitmask, בעוד שרוב FilePermissions מורכב מערכי bitmask (
FilePermissions.S_IRUSR , FilePermissions.S_IWUSR , וכו ').

השמיים MapAttribute ניתן לציין תכונה במחלקות, מבנים, נציגים, שדות ו
ספירות.

נציגים
יצירת הקוד לנציגים מתעלמת מה- MapAttribute.NativeType רכוש, ו
יוצר מצביע פונקציה typedef התואם בצורה הטובה ביותר את הצהרת הנציג
אל .h קובץ.

לדוגמה,

מרחב שמות Foo {
[מַפָּה]
מחרוזת נציג MyCallback (מחרוזת s);
}

יוצר את typedef :

typedef char* (*Foo_MyCallback) (const char *s);

שיעורים ומבנים
A [מַפָּה] -מחלקה או מבנה מעוטרים יקבלו הצהרת מבנה C בתוך
.h קובץ:

[מַפָּה]
struct Foo {
public int i;
}

הופך להיות

struct Foo {
public int i;
};

אם MapAttribute.NativeType המאפיין מוגדר, ואז פונקציות ההמרה יהיו
הכריז בתוך ה .h קובץ ונוצר בתוך .c קובץ:

מרחב שמות Foo {
[מפה ("סטט struct")]
struct Stat {
public uint st_uid;
}
}

הופך להיות

/* קובץ ה-.h */
struct Foo_Stat {
unsigned int st_uid;
};
int
Foo_FromStat (struct Foo_Stat *from, struct stat *to);
int
Foo_ToStat (struct stat *to, sxtruct Foo_Stat *to);

/* קובץ ה-.c */
int
Foo_FromStat (מבנה Foo_Stat *from, struct stat *to)
{
memset (to, 0, sizeof(*to);
to->st_uid = from->st_uid;
0 לחזור;
}

int
Foo_ToStat (struct stat *to, sxtruct Foo_Stat *to)
{
memset (to, 0, sizeof(*to);
to->st_uid = from->st_uid;
0 לחזור;
}

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

שדות אם לשדה (1) יש את MapAttribute תכונה, ו-(2) יש את
MapAttribute.NativeType הגדרת מאפיינים, אז ישמש הסוג המקורי שצוין
לבדיקת הצפה. לדוגמה:

מרחב שמות Foo {
[מפה ("סטט struct")]
struct Stat {
[מפה ("off_t")] public long st_size;
}
}

מייצר

/* קובץ ה-.h */
struct Foo_Stat {
gint64 st_size;
};
int
Foo_FromStat (struct Foo_Stat *from, struct stat *to);
int
Foo_ToStat (struct stat *to, sxtruct Foo_Stat *to);

/* קובץ ה-.c */
int
Foo_FromStat (מבנה Foo_Stat *from, struct stat *to)
{
_cnm_return_val_if_overflow (off_t, from->st_size, -1);

memset (to, 0, sizeof(*to);
to->st_size = from->st_size;
0 לחזור;
}

int
Foo_ToStat (struct stat *to, sxtruct Foo_Stat *to)
{
_cnm_return_val_if_overflow (gint64, from->st_size, -1);

memset (to, 0, sizeof(*to);
to->st_size = from->st_size;
0 לחזור;
}

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

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

לדוגמה,

מרחב שמות Foo {
[מַפָּה]
enum Errno {
EINVAL
}
}

ייצור את הדברים הבאים ב- .h קובץ:

enum Foo_Errno {
Foo_Errno_EINVAL = 0,
#define Foo_Errno_EINVAL Foo_Errno_EINVAL
};
int Foo_FromErrno (int from, int *to);
int Foo_ToErrno (int from, int *to);

ומייצר את הדברים הבאים ב- .c קובץ:

int
Foo_FromErrno (int from, int *to)
{
*to = 0;
if (מ == Foo_Errno_EPERM)
#ifdef EINVAL
{*to = EINVAL;}
#else
{errno = EINVAL; החזר -1;}
#endif
0 לחזור;
}

int
Foo_ToErrno (int from, int *to)
{
*to = 0;
#ifdef EINVAL
if (מ == EINVAL)
{*to = Foo_Errno_EPERM; החזר 0;}
#endif
return -1;
}

קוד שונה ייווצר אם ה-enum המנוהל הוא א [דגלים] -מְעוּטָר
ספירה (כדי לתת את הדעת על דגלים סיביים), אבל זה הרעיון הבסיסי.

דואר רשימות

לְבַקֵר http://lists.ximian.com/mailman/listinfo/mono-devel-list לקבלת פרטים.

WEB אֲתַר

לְבַקֵר http://www.mono-project.com לפרטים

צור מפה מקומית(1)

השתמש ב- create-native-map מקוון באמצעות שירותי onworks.net