create-native-map - Online in de cloud

PROGRAMMA:

NAAM

native-map maken - C/C# Mapping Creator

KORTE INHOUD

native-map maken [OPTIES]* MONTAGE-BESTANDSNAAM UITGANG-PREFIX

OPTIES

--autoconf-header=KOP
HEADER is een header-bestandsnaam in de syntaxis die gewoonlijk wordt gebruikt met de C #include
verklaring, bijv #include or #include "local.h" .

Een Autoconf-geformatteerde macro wordt gegenereerd op basis van de include-naam, en a #include
richtlijn is verpakt in a #ifdef blok voor de Autoconf-macro binnen de
gegenereerde .c bestand.

Bijvoorbeeld --autoconf-header= zou de code genereren:

#ifndef HAVE_STDIO_H
# omvat
#endif /* ndef HAVE_STDIO_H */

--autoconf-lid=LID
Geef aan dat elke toegang tot: LID moet worden verpakt binnen een #ifdef HAVE_LID
blok. LID kan een van beide zijn veldnaam of naam van de klasse . veldnaam
combinatie.

Bijvoorbeeld, gegeven de C#-declaratie:

[Mono.Unix.Native.Map ("structeur")]
structuur Dirent {
openbare lange d_off;
}

harte --autoconf-lid=d_off zou de code genereren die lijkt op:

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

--exclude-native-symbol=SYMBOOL
SYMBOOL is een [DllImporteren] -gemarkeerde methode die zou moeten niet een prototype laten maken
voor.

--impl-header=KOP
Voeg een #include verklaring binnen de gegenereerde .c bestand voor HEADER .

Bijvoorbeeld --impl-header= genereert

#inclusief

--impl-macro=MACRO
Voeg een #define verklaring binnen de gegenereerde .c bestand. MACRO kan een bevatten = naar
scheid de macronaam van de macrowaarde.

Bijvoorbeeld --impl-macro=FOO=42 genereert

#definieer FOO 42

--bibliotheek=BIBLIOTHEEK
Maak prototypes voor [DllImporteren] -gemarkeerde methoden die verwijzen naar de native
bibliotheek BIBLIOTHEEK in de gegenereerde .h bestand.

--public-header=KOP
Voeg een #include verklaring binnen de gegenereerde .h bestand voor HEADER .

Bijvoorbeeld --public-header= genereert

#inclusief

--public-macro=MACRO
Voeg een #define verklaring binnen de gegenereerde .h bestand. MACRO kan een bevatten = naar
scheid de macronaam van de macrowaarde.

Bijvoorbeeld --public-macro=FOO=42 genereert

#definieer FOO 42

--rename-member=VAN=NAAR
Dit wordt gebruikt wanneer: NU is een C-macro en moet dus worden gewijzigd om te kunnen worden gebruikt
verstandig. Alle gegenereerde verwijzingen naar de beheerde representatie gebruiken TO verkrijgen in plaats daarvan
of NU .

Bijvoorbeeld, gegeven de C#-declaratie:

[Mono.Unix.Native.Map ("struct stat")]
structuur Stat {
openbare lange tijd;
}

en het argument --rename-member=st_atime=st_atime_ , de gegenereerde .h bestand zou
bevatten:

structuur Stat {
gint64 st_atime_;
};

(let op de gewijzigde veldnaam), terwijl de gegenereerde .c bestand zou bevatten:

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

--rename-namespace=FROM=NAAR
Standaard is de C "naamruimte" (symboolprefix) de C#-naamruimte; typen binnen de
C# naamruimte Mono.Unix.Native zou in de C "naamruimte" zijn Mono_Unix_Native . Gebruiken
--naamruimte hernoemen om de standaard te wijzigen, bijv --hernoem-
naamruimte=Mono.Unix.Native=Mono_Posix .

PRODUCTBESCHRIJVING

native-map maken is een programma voor een specifiek scenario: code behouden die strak is
gekoppeld tussen C en C# synchroon met elkaar, op basis van de C#-typen.

Platform Invoke is alleen nuttig als de beheerde code de exacte typen en lay-out van alles kent
onbeheerde structuren die het gebruikt. Dit is meestal het geval op Windows, maar het is: niet Bij
op Unix. Bijvoorbeeld, struct staat maakt gebruik van soorten met afmetingen die variëren van
platform naar platform (of zelfs op basis van de gedefinieerde compilermacro's!). Bijvoorbeeld, uit_t
is meestal een ondertekend 32-bits geheel getal op ILP32-platforms, maar kan een ondertekend 64-bits geheel getal zijn
op LP64-platforms, maar kan ook een 64-bits geheel getal zijn op ILP32-platforms als de
_FILE_OFFSET_BITS macro heeft de waarde 64. Kortom, alles is flexibel binnen Unix,
en beheerde code kan zo'n flexibiliteit niet aan.

Dus de niche voor native-map maken : ga uit van een vaste ABI waarop beheerde code zich kan richten,
en genereer code om de beheerde representaties te "thunken" naar de overeenkomstige native
voorstellingen. Dit moet worden gedaan voor alles die kan variëren tussen platforms en
compilervlaggen, van opsommingswaarden ( SIGBUS heeft de waarde 10 op FreeBSD maar 7 op
Linux) om leden te structureren (hoe groot is? uit_t ?).

native-map maken zal inspecteren MONTAGE-BESTANDSNAAM en voer de volgende bestanden uit:

UITVOER-PREFIX.h
Bevat opsommingswaarden, klasse- en structuurdeclaraties, gedelegeerde
verklaringen, en [DllImporteren] -gemarkeerde methoden (uit de bibliotheek gespecificeerd door
--bibliotheek ) binnen de vergadering MONTAGE-BESTANDSNAAM .

OUTPUT-VOORBEELD.c
Bevat de implementatie van opsomming en structuurconversie
functies.

OUTPUT-PREFIX.cs
Bevat een gedeeltelijke klasse NativeConverteren met opsomming vertaling
werkwijzen.

UITVOER-PREFIX.xml
Genereert ECMA XML-documentatiestubs voor de opsommingsvertaling
methoden in OUTPUT-PREFIX.cs .

native-map maken zoekt in de eerste plaats Kaartkenmerk -versierde types, en maakt gebruik van twee
Kaartkenmerk eigendommen:

NativeType
Bevat het bijbehorende C-type. Alleen nuttig indien toegepast op klassen,
structuren en velden.

Onderdruk vlaggen
Indien gespecificeerd op een opsommingslid van a [Vlaggen] -versierde opsomming
type, schakelt de normale ondersteuning van de codegenerator voor het opsommen van bitmaskers
types.

Dit is handig wanneer informatie over bitmaskers en niet-bitmaskers is opgeslagen in de
hetzelfde type, en bitmaskercontrole mag niet worden gebruikt voor het niet-bitmasker
waarden. Voorbeeld: Mono.Unix.Native.FilePermissions.S_IFREG , wat niet een
bitmaskerwaarde, terwijl de meeste van Bestandsmachtigingen bestaat uit bitmaskerwaarden (
Bestandsmachtigingen.S_IRUSR , FilePermissions.S_IWUSR , Enz.).

De Kaartkenmerk attribuut kan worden gespecificeerd op klassen, structuren, gedelegeerden, velden en
opsommingen.

afgevaardigden
Code generatie voor afgevaardigden negeert de MapAttribute.NativeType eigendom, en
genereert een functieaanwijzer typedef die het beste past bij de gedelegeerde verklaring
in de .h bestand.

Bijvoorbeeld

naamruimte Foo {
[Kaart]
gemachtigde string MyCallback (string s);
}

genereert de typedef :

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

Klassen en structuren
A [Kaart] -versierde klasse of structuur krijgt een C-structuurverklaring binnen de
.h file:

[Kaart]
structuur Foo {
openbaar int i;
}

wordt

structuur Foo {
openbaar int i;
};

Indien de MapAttribute.NativeType eigenschap is ingesteld, dan zijn conversiefuncties
verklaard binnen de .h bestand en gemaakt binnen de .c file:

naamruimte Foo {
[Kaart ("struct stat")]
structuur Stat {
openbare uint st_uid;
}
}

wordt

/* Het .h-bestand */
struct Foo_Stat {
niet-ondertekende int st_uid;
};
int
Foo_FromStat (struct Foo_Stat *from, struct stat *to);
int
Foo_ToStat (struct stat *naar, sxtruct Foo_Stat *naar);

/* Het .c-bestand */
int
Foo_FromStat (struct Foo_Stat *from, struct stat *to)
{
memset (naar, 0, groottevan(*naar);
to->st_uid = van->st_uid;
0 terug;
}

int
Foo_ToStat (struct stat *to, sxtruct Foo_Stat *to)
{
memset (naar, 0, groottevan(*naar);
to->st_uid = van->st_uid;
0 terug;
}

Voor klassen zullen de conversiefuncties alleen velden kopiëren die in de klasse zijn gedeclareerd
zelf. Velden gedeclareerd in bovenliggende klassen worden niet gekopieerd. (Dit is zo omdat
native-map maken weet niet hoe de overerving is geïmplementeerd in C. Daarom
het kopiëren van velden van bovenliggende klassen wordt overgelaten aan de beller van de conversie
functies.)

Velden Als een veld (1) de . heeft Kaartkenmerk attribuut, en (2) heeft de
MapAttribute.NativeType property set, dan wordt het gespecificeerde native type gebruikt
voor overloopcontrole. Bijvoorbeeld:

naamruimte Foo {
[Kaart ("struct stat")]
structuur Stat {
[Kaart ("off_t")] openbare lange st_size;
}
}

genereert

/* Het .h-bestand */
struct Foo_Stat {
gint64 st_grootte;
};
int
Foo_FromStat (struct Foo_Stat *from, struct stat *to);
int
Foo_ToStat (struct stat *naar, sxtruct Foo_Stat *naar);

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

memset (naar, 0, groottevan(*naar);
to->st_size = from->st_size;
0 terug;
}

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

memset (naar, 0, groottevan(*naar);
to->st_size = from->st_size;
0 terug;
}

Dit is handig voor een betere foutcontrole binnen de conversiefuncties.
MapAttribute.NativeType is hiervoor vereist, omdat er geen andere manier is om te weten wat
het native type is (zonder de systeemheaderbestanden te ontleden...).

Opsommingen
Genereert een C-opsomming en macro's voor elk van de leden binnen de
opsomming. Naar en Vanaf functies worden ook gedeclareerd in de .h file en
geïmplementeerd in de .c bestand.

Bijvoorbeeld

naamruimte Foo {
[Kaart]
opsomming Errno {
EINVAL
}
}

zou het volgende genereren in de .h file:

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

en genereert het volgende in de de .c file:

int
Foo_FromErrno (int van, int *to)
{
*tot = 0;
als (van == Foo_Errno_EPERM)
#ifdef EINVAL
{*tot = EINVAL;}
#anders
{errno = EINVAL; retour -1;}
#stop als
0 terug;
}

int
Foo_ToErrno (int van, int *to)
{
*tot = 0;
#ifdef EINVAL
als (van == EINVAL)
{*to = Foo_Errno_EPERM; retourneer 0;}
#stop als
retour -1;
}

Er wordt een andere code gegenereerd als de beheerde opsomming a . is [Vlaggen] -versierd
opsomming (om rekening te houden met bitsgewijze vlaggen), maar dit is het basisidee.

MAILEN LIJSTEN

Bezoek http://lists.ximian.com/mailman/listinfo/mono-devel-list voor meer info.

WEB SITE

Bezoek http://www.mono-project.com voor details

native-map maken(1)

Gebruik create-native-map online met onworks.net-services