create-native-map - En ligne dans le Cloud

PROGRAMME:

Nom

create-native-map - Créateur de mappage C/C#

SYNOPSIS

créer-native-map [OPTIONS]* ASSEMBLY-FILE-NAME SORTIE-PREFIX

OPTIONS

--autoconf-header=EN-TÊTE
ENTÊTE est un nom de fichier d'en-tête dans la syntaxe généralement utilisée avec le C #comprendre
déclaration, par exemple #comprendre or #comprendre "local.h" .

Une macro au format Autoconf est générée à partir du nom d'inclusion, et un #comprendre
la directive est enveloppée dans un #ifdef bloc pour la macro Autoconf dans le
généré .c fichier.

Par exemple, --autoconf-header= générerait le code :

#ifndef HAVE_STDIO_H
#inclut
#endif /* ndef HAVE_STDIO_H */

--autoconf-member=MEMBRE
Précisez que tout accès à doit être enveloppé dans un #ifdef HAVE_MEMBER
bloque. Peut être soit un nom de domaine ou nom du cours . nom de domaine
combinaison.

Par exemple, étant donné la déclaration C# :

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

puis --autoconf-member=d_off générerait le code similaire à :

int
ToDirent (struct 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=SYMBOLE
SYMBOLE est une [DllImporter] -méthode marquée qui devrait ne sauraient avoir un prototype généré
pour elle.

--impl-header=EN-TÊTE
Insérer un #comprendre déclaration dans le généré .c fichier pour ENTÊTE .

Par exemple, --impl-header= génère

#inclure

--impl-macro=MACRO
Insérer un #define déclaration dans le généré .c fichier. MACRO peut contenir un = à
séparez le nom de la macro de la valeur de la macro.

Par exemple, --impl-macro=FOO=42 génère

#définir FOO 42

--library=BIBLIOTHÈQUE
Créer des prototypes pour [DllImporter] -méthodes marquées qui référencent le natif
bibliothèque BIBLIOTHÈQUE dans le généré .h fichier.

--public-header=EN-TÊTE
Insérer un #comprendre déclaration dans le généré .h fichier pour ENTÊTE .

Par exemple, --public-header= génère

#inclure

--public-macro=MACRO
Insérer un #define déclaration dans le généré .h fichier. MACRO peut contenir un = à
séparez le nom de la macro de la valeur de la macro.

Par exemple, --public-macro=FOO=42 génère

#définir FOO 42

--rename-member=DE=VERS
Ceci est utilisé lorsque De est une macro C, et doit donc être modifiée pour être utilisée
sainement. Toutes les références générées à la représentation gérée utiliseront À plutôt ;
of De .

Par exemple, étant donné la déclaration C# :

[Mono.Unix.Native.Map ("struct stat")]
structure Stat {
longue durée publique ;
}

et l'argumentation --rename-member=st_atime=st_atime_ , la génération .h fichier serait
contenir:

structure Stat {
gint64 st_atime_;
};

(notez le nom du champ modifié), tandis que le .c fichier contiendrait :

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

--rename-namespace=DE=À
Par défaut, l'"espace de noms" C (préfixe du symbole) est l'espace de noms C# ; types au sein de la
Espace de noms C# Mono.Unix.Natif serait dans le C "espace de noms" Mono_Unix_Natif . utilisation
--rename-espace de noms pour modifier la valeur par défaut, par exemple --Renommer-
espace de noms=Mono.Unix.Native=Mono_Posix .

DESCRIPTION

créer-native-map est un programme pour un scénario spécifique : garder un code qui est étroitement
couplé entre C et C# en synchronisation les uns avec les autres, sur la base des types C#.

Platform Invoke n'est utile que si le code managé connaît les types et la disposition exacts de tous
structures non gérées qu'il utilise. C'est généralement le cas sous Windows, mais il est ne sauraient le cas
sur Unix. Par exemple, struct état utilise des types avec des tailles qui varient de
plate-forme à plate-forme (ou même basée sur les macros du compilateur définies !). Par exemple, off_t
est généralement un entier 32 bits signé sur les plates-formes ILP32, mais peut être un entier 64 bits signé
sur les plates-formes LP64, mais peut également être un entier signé 64 bits sur les plates-formes ILP32 si le
_FILE_OFFSET_BITS macro a la valeur 64. Bref, tout est flexible sous Unix,
et le code managé ne peut pas gérer une telle flexibilité.

Ainsi, le créneau de créer-native-map  : supposons une ABI fixe que le code managé peut cibler,
et générer du code pour "thunker" les représentations gérées vers le natif correspondant
représentations. Cela doit être fait pour peut qui peut varier entre les plates-formes et
drapeaux du compilateur, à partir des valeurs d'énumération ( SIGBUS a la valeur 10 sur FreeBSD mais 7 sur
Linux) pour structurer les membres (quelle est la taille off_t ?).

créer-native-map inspectera NOM-FICHIER-ASSEMBLAGE et générer les fichiers suivants :

SORTIE-PREFIX.h
Contient des valeurs d'énumération, des déclarations de classe et de structure, un délégué
déclarations, et [DllImporter] -méthodes marquées (de la bibliothèque spécifiée par
--une bibliothèque ) au sein de l'assemblée NOM-FICHIER-ASSEMBLAGE .

PREFIXE-SORTIE.c
Contient la mise en œuvre de l'énumération et de la conversion de structure
fonctions.

SORTIE-PREFIX.cs
Contient une classe partielle ConversionNative contenant la traduction d'énumération
méthodes.

SORTIE-PREFIX.xml
Génère des talons de documentation ECMA XML pour la traduction de l'énumération
méthodes dans SORTIE-PREFIX.cs .

créer-native-map recherche principalement MapAttribute -types décorés, et utilise deux
MapAttribute Propriétés:

TypeNatif
Contient le type C correspondant. Uniquement utile si appliqué aux classes,
structures et champs.

Supprimer les drapeaux
Lorsqu'il est spécifié sur un membre d'énumération d'un [Drapeaux] -énumération décorée
Type, désactive la prise en charge normale du générateur de code pour l'énumération par masquage de bits
les types.

Ceci est utile lorsque des informations de masque de bits et non de masque de bits sont stockées dans le
même type, et la vérification du masque de bits ne doit pas être utilisée pour le non-masque de bits
valeurs. Exemple: Mono.Unix.Native.FilePermissions.S_IFREG , qui n'est pas un
valeur du masque de bits, tandis que la plupart des Autorisations de fichier se compose de valeurs de masque de bits (
FilePermissions.S_IRUSR , FilePermissions.S_IWUSR , Etc).

La MapAttribute L'attribut peut être spécifié sur les classes, les structures, les délégués, les champs et
énumérations.

Les délégués
La génération de code pour les délégués ignore le MapAttribute.NativeType propriété, et
génère un pointeur de fonction typedef qui correspond le mieux à la déclaration du délégué
into the .h fichier.

Par exemple,

espace de noms Foo {
[Carte]
déléguer la chaîne MyCallback (chaîne s);
}

génère le typedef :

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

Cours et structures
A [Carte] -la classe ou la structure décorée obtiendra une déclaration de structure C dans le
.h fichier:

[Carte]
structure Foo {
public int je ;
}

devient

structure Foo {
public int je ;
};

Si la MapAttribute.NativeType la propriété est définie, alors les fonctions de conversion seront
déclaré dans le .h fichier et créé dans le .c fichier:

espace de noms Foo {
[Carte ("struct stat")]
structure Stat {
public uint st_uid ;
}
}

devient

/* Le fichier .h */
struct Foo_Stat {
int st_uid non signé ;
};
int
Foo_FromStat (struct Foo_Stat *from, struct stat *to);
int
Foo_ToStat (struct stat *à, sxtruct Foo_Stat *à) ;

/* Le fichier .c */
int
Foo_FromStat (struct Foo_Stat *from, struct stat *to)
{
memset (à, 0, sizeof(*to);
to->st_uid = from->st_uid;
0 revenir;
}

int
Foo_ToStat (struct stat *à, sxtruct Foo_Stat *à)
{
memset (à, 0, sizeof(*to);
to->st_uid = from->st_uid;
0 revenir;
}

Pour les classes, les fonctions de conversion ne copieront que les champs déclarés dans la classe
lui-même. Les champs déclarés dans les classes parentes ne seront pas copiés. (Ceci est dû au fait
créer-native-map ne sait pas comment l'héritage est implémenté en C. Par conséquent
la copie des champs des classes parentes est laissée à l'appelant de la conversion
les fonctions.)

Champs Si un champ (1) a le MapAttribute attribut, et (2) a le
MapAttribute.NativeType jeu de propriétés, le type natif spécifié sera utilisé
pour le contrôle de débordement. Par exemple:

espace de noms Foo {
[Carte ("struct stat")]
structure Stat {
[Map ("off_t")] public long st_size;
}
}

génère

/* Le fichier .h */
struct Foo_Stat {
gint64 st_size;
};
int
Foo_FromStat (struct Foo_Stat *from, struct stat *to);
int
Foo_ToStat (struct stat *à, sxtruct Foo_Stat *à) ;

/* Le fichier .c */
int
Foo_FromStat (struct Foo_Stat *from, struct stat *to)
{
_cnm_return_val_if_overflow (off_t, from->st_size, -1);

memset (à, 0, sizeof(*to);
to->st_size = from->st_size;
0 revenir;
}

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

memset (à, 0, sizeof(*to);
to->st_size = from->st_size;
0 revenir;
}

Ceci est utile pour une meilleure vérification des erreurs dans les fonctions de conversion.
MapAttribute.NativeType est nécessaire pour cela car il n'y a pas d'autre moyen de savoir ce que
le type natif est (sans analyser les fichiers d'en-tête système...).

Énumérations
Génère une énumération C et des macros pour chacun des membres dans le
énumération. À et À partir d' les fonctions sont également déclarées dans le .h déposer et
mis en œuvre dans le .c fichier.

Par exemple,

espace de noms Foo {
[Carte]
enum Errno {
EINVAL
}
}

générerait ce qui suit dans le .h fichier:

énumération Foo_Errno {
Foo_Errno_EINVAL = 0,
#define Foo_Errno_EINVAL Foo_Errno_EINVAL
};
int Foo_FromErrno (int de, int * à);
int Foo_ToErrno (int de, int * à);

et génère ce qui suit dans le .c fichier:

int
Foo_FromErrno (int de, int * à)
{
*à = 0;
si (de == Foo_Errno_EPERM)
#ifdef EINVAL
{*à = EINVAL;}
#else
{errno = EINVAL; retour -1;}
#endif
0 revenir;
}

int
Foo_ToErrno (int de, int * à)
{
*à = 0;
#ifdef EINVAL
si (de == EINVAL)
{*to = Foo_Errno_EPERM; renvoie 0 ;}
#endif
retour -1 ;
}

Un code différent sera généré si l'énumération gérée est un [Drapeaux] -décoré
énumération (pour tenir compte des drapeaux au niveau du bit), mais c'est l'idée de base.

ENVOI POSTAL LISTE

Visitez le http://lists.ximian.com/mailman/listinfo/mono-devel-list pour en savoir plus.

WEB SITE

Visitez le http://www.mono-project.com pour information

créer-native-map(1)

Utilisez create-native-map en ligne à l'aide des services onworks.net