create-native-map - Online nel cloud

PROGRAMMA:

NOME

create-native-map - Creatore di mappe C/C#

SINOSSI

crea-mappa-nativa [OPZIONI]* NOME-FILE-ASSEMBLAGGIO PREFISSO-USCITA

VERSIONI

--autoconf-header=INTESTAZIONE
INTESTAZIONE è un nome di file di intestazione nella sintassi tipicamente utilizzata con C #includere
affermazione, ad esempio #includere or #includere "local.h" .

Una macro formattata Autoconf viene generata dal nome include e una #includere
la direttiva è racchiusa in un #ifdef blocco per la macro Autoconf all'interno del
generato .c file.

Per esempio, --autoconf-header= genererebbe il codice:

#ifndef HAVE_STDIO_H
#includere
#endif /* ndef HAVE_STDIO_H */

--autoconf-member=MEMBRO
Specificare che qualsiasi accesso a MEMBRI dovrebbe essere avvolto in un #ifdef HAVE_MEMBER
blocco. MEMBRI può essere sia a nome-campo o nome della classe . nome-campo
combinazione.

Ad esempio, data la dichiarazione C#:

[Mono.Unix.Native.Map ("struct dirent")]
struct Dirent {
pubblico lungo d_off;
}

poi --autoconf-member=d_off genererebbe un codice simile a:

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

--exclude-native-symbol=SIMBOLO
SIMBOLO è un [Importazione DLL] -metodo contrassegnato che dovrebbe non è un avere un prototipo generato
per esso.

--impl-header=INTESTAZIONE
Inserisci un #includere dichiarazione all'interno del generato .c file per INTESTAZIONE .

Per esempio, --impl-header= genera

#includere

--impl-macro=MACRO
Inserisci un #define dichiarazione all'interno del generato .c file. MACRO può contenere un = a
separare il nome della macro dal valore della macro.

Per esempio, --impl-macro=FOO=42 genera

#define FOO 42

--library=LIBRERIA
Creare prototipi per [Importazione DLL] - metodi contrassegnati che fanno riferimento al nativo
biblioteca BIBLIOTECA nel generato .h file.

--public-header=INTESTAZIONE
Inserisci un #includere dichiarazione all'interno del generato .h file per INTESTAZIONE .

Per esempio, --intestazione pubblica= genera

#includere

--public-macro=MACRO
Inserisci un #define dichiarazione all'interno del generato .h file. MACRO può contenere un = a
separare il nome della macro dal valore della macro.

Per esempio, --public-macro=FOO=42 genera

#define FOO 42

--rename-member=DA=A
Questo viene utilizzato quando DA è una macro C e quindi deve essere modificata per poter essere utilizzata
in modo sano. Tutti i riferimenti generati alla rappresentazione gestita utilizzeranno A invece
of DA .

Ad esempio, data la dichiarazione C#:

[Mono.Unix.Native.Map ("struttura stat")]
struttura Stat {
pubblico lungo st_atime;
}

e l'argomento --rename-member=st_atime=st_atime_ , il generato .h il file sarebbe
contenere:

struttura Stat {
gint64 st_atime_;
};

(nota il nome del campo modificato), mentre il generato .c il file conterrebbe:

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

--rename-namespace=DA=A
Per impostazione predefinita, lo "spazio dei nomi" C (prefisso del simbolo) è lo spazio dei nomi C#; i tipi all'interno di
Spazio dei nomi C# Mono.Unix.Native sarebbe nello "spazio dei nomi" C Mono_Unix_Nativo . Utilizzare
--rinomina-spazio dei nomi per modificare l'impostazione predefinita, ad esempio --rinominare-
spazio dei nomi=Mono.Unix.Native=Mono_Posix .

DESCRIZIONE

crea-mappa-nativa è un programma per uno scenario specifico: mantenere il codice che è strettamente
accoppiati tra C e C# in sincronia tra loro, in base ai tipi C#.

Platform Invoke è utile solo se il codice gestito conosce i tipi esatti e il layout di tutti
strutture non gestite che utilizza. Questo è solitamente il caso su Windows, ma è non è un il caso
su Unix. Ad esempio, struct stat utilizza tipi con dimensioni che variano da
da piattaforma a piattaforma (o anche in base alle macro del compilatore definite!). Ad esempio, off_t
è solitamente un intero a 32 bit con segno sulle piattaforme ILP32, ma può essere un intero a 64 bit con segno
sulle piattaforme LP64, ma può anche essere un intero con segno a 64 bit sulle piattaforme ILP32 se
_FILE_OFFSET_BITS la macro ha il valore 64. In breve, tutto è flessibile all'interno di Unix,
e il codice gestito non può gestire tale flessibilità.

Quindi, la nicchia per crea-mappa-nativa : si presuppone un'ABI fissa a cui il codice gestito può indirizzarsi,
e generare codice per "thunk" le rappresentazioni gestite al nativo corrispondente
rappresentazioni. Questo deve essere fatto per ogni cosa che può variare tra le piattaforme e
flag del compilatore, dai valori di enumerazione ( SIGBUS ha il valore 10 su FreeBSD ma 7 su
Linux) per strutturare i membri (quanto è grande off_t ?).

crea-mappa-nativa ispezionerà NOME-FILE-ASSEMBLAGGIO e generare i seguenti file:

PREFISSO-OUTPUT.h
Contiene valori di enumerazione, dichiarazioni di classi e strutture, delegati
dichiarazioni e [Importazione DLL] -metodi contrassegnati (dalla libreria specificata da
--biblioteca ) all'interno dell'assemblea NOME-FILE-ASSEMBLAGGIO .

PREFISSO-OUTPUT.c
Contiene l'implementazione dell'enumerazione e della conversione della struttura
funzioni.

OUTPUT-PREFIX.cs
Contiene una classe parziale NativeConvert contenente la traduzione dell'enumerazione
metodi.

PREFISSO-OUTPUT.xml
Genera stub di documentazione XML ECMA per la traduzione dell'enumerazione
metodi in OUTPUT-PREFIX.cs .

crea-mappa-nativa cerca principalmente Attributo mappa -tipi decorati e utilizza due
Attributo mappa proprietà:

Tipo nativo
Contiene il tipo C corrispondente. Utile solo se applicato alle classi,
strutture e campi.

Sopprimi Flag
Quando specificato su un membro di enumerazione di un [Bandiere] -enumerazione decorata
Digitare, disattiva il normale supporto del generatore di codice per l'enumerazione con mascheramento dei bit
tipi.

Ciò è utile quando le informazioni bitmask e non bitmask sono memorizzate all'interno
stesso tipo e il controllo della maschera di bit non dovrebbe essere utilizzato per la maschera di bit non
valori. Esempio: Mono.Unix.Native.FilePermissions.S_IFREG , che non è un
valore della maschera di bit, mentre la maggior parte di Permessi file è costituito da valori di maschera di bit (
Permessi file.S_IRUSR , Permessi file.S_IWUSR , Ecc.).

. Attributo mappa l'attributo può essere specificato su classi, strutture, delegati, campi e
enumerazioni.

I delegati
La generazione del codice per i delegati ignora il MapAttribute.NativeType proprietà e
genera un puntatore a funzione typedef che meglio corrisponde alla dichiarazione del delegato
nella .h file.

Per esempio,

spazio dei nomi Foo {
[Carta geografica]
stringa delegata MyCallback (stringa s);
}

genera il typedef :

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

Classi e strutture
A [Carta geografica] -la classe o la struttura decorata riceverà una dichiarazione di struttura C all'interno di
.h file:

[Carta geografica]
struct Foo {
pubblico int i;
}

diventa

struct Foo {
pubblico int i;
};

Se l' MapAttribute.NativeType la proprietà è impostata, allora le funzioni di conversione saranno
dichiarato all'interno del .h file e creato all'interno del .c file:

spazio dei nomi Foo {
[Mappa ("struct stat")]
struttura Stat {
pubblico uint st_uid;
}
}

diventa

/* Il file .h */
struct Foo_Stat {
intero senza segno st_uid;
};
int
Foo_FromStat (struct Foo_Stat *from, struct stat *to);
int
Foo_ToStat (struct stat *to, sxtruct Foo_Stat *to);

/* Il file .c */
int
Foo_FromStat (struct Foo_Stat *da, struct stat *a)
{
memset (a, 0, sizeof(*to);
a->st_uid = da->st_uid;
0 ritorno;
}

int
Foo_ToStat (struct stat *to, sxtruct Foo_Stat *to)
{
memset (a, 0, sizeof(*to);
a->st_uid = da->st_uid;
0 ritorno;
}

Per le classi, le funzioni di conversione copieranno solo i campi dichiarati nella classe
stesso. I campi dichiarati nelle classi padre non verranno copiati. (Questo perché
crea-mappa-nativa non sa come l'ereditarietà è implementata in C. Pertanto
la copia dei campi dalle classi padre è lasciata al chiamante della conversione
funzioni.)

Campi Se un campo (1) ha il Attributo mappa attributo, e (2) ha il
MapAttribute.NativeType set di proprietà, verrà utilizzato il tipo nativo specificato
per il controllo degli overflow. Ad esempio:

spazio dei nomi Foo {
[Mappa ("struct stat")]
struttura Stat {
[Mappa ("off_t")] public long st_size;
}
}

genera

/* Il file .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);

/* Il file .c */
int
Foo_FromStat (struct Foo_Stat *da, struct stat *a)
{
_cnm_return_val_if_overflow (off_t, from->st_size, -1);

memset (a, 0, sizeof(*to);
a->dimensione_st = da->dimensione_st;
0 ritorno;
}

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

memset (a, 0, sizeof(*to);
a->dimensione_st = da->dimensione_st;
0 ritorno;
}

Ciò è utile per un migliore controllo degli errori all'interno delle funzioni di conversione.
MapAttribute.NativeType è necessario per questo poiché non c'è altro modo per sapere cosa
il tipo nativo è (senza analizzare i file di intestazione del sistema...).

Enumerazioni
Genera un'enumerazione C e macro per ciascuno dei membri all'interno di
enumerazione. A e Da le funzioni sono dichiarate anche in .h di file e
implementato nel .c file.

Per esempio,

spazio dei nomi Foo {
[Carta geografica]
enum Errno {
EINVAL
}
}

genererebbe quanto segue nel .h file:

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

e genera quanto segue nel .c file:

int
Foo_FromErrno (int da, int *a)
{
*a = 0;
se (da == Foo_Errno_EPERM)
#ifdef EINVAL
{*to = EINVAL;}
#else
{errno = EINVAL; restituisci -1;}
#endif
0 ritorno;
}

int
Foo_ToErrno (int da, int *a)
{
*a = 0;
#ifdef EINVAL
se (da == EINVAL)
{*to = Foo_Errno_EPERM; restituisci 0;}
#endif
return -1;
}

Verrà generato un codice diverso se l'enum gestito è un [Bandiere] -decorato
enumerazione (per tenere conto dei flag bit a bit), ma questa è l'idea di base.

MAILING LISTE

Visita http://lists.ximian.com/mailman/listinfo/mono-devel-list per i dettagli.

WEB SITO

Visita http://www.mono-project.com per dettagli

crea-mappa-nativa(1)

Utilizzare create-native-map online utilizzando i servizi onworks.net