create-native-map - ഓൺലൈനിൽ ക്ലൗഡിൽ

പട്ടിക:

NAME

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

സിനോപ്സിസ്

സൃഷ്ടിക്കുക-നേറ്റീവ്-മാപ്പ് [ഓപ്ഷനുകൾ]* അസംബ്ലി-ഫയൽ-നാമം ഔട്ട്പുട്ട്-പ്രിഫിക്സ്

ഓപ്ഷനുകൾ

--autoconf-header=HEADER
ഹെഡർ C-യ്‌ക്കൊപ്പം സാധാരണയായി ഉപയോഗിക്കുന്ന വാക്യഘടനയിലെ ഒരു ഹെഡ്ഡർ ഫയൽ നാമമാണ് # ഉൾപ്പെടുത്തുക
പ്രസ്താവന, ഉദാ # ഉൾപ്പെടുത്തുക or # ഉൾപ്പെടുത്തുക "local.h" .

ഉൾപ്പെടുത്തിയിരിക്കുന്ന പേരിൽ നിന്നും ഒരു Autoconf-ഫോർമാറ്റ് ചെയ്ത മാക്രോ ജനറേറ്റ് ചെയ്യപ്പെടുന്നു, കൂടാതെ a # ഉൾപ്പെടുത്തുക
നിർദ്ദേശം a ഉള്ളിൽ പൊതിഞ്ഞിരിക്കുന്നു #ifdef അതിനുള്ളിലെ Autoconf മാക്രോയ്‌ക്കായി തടയുക
സൃഷ്ടിച്ചു .c ഫയൽ.

ഉദാഹരണത്തിന്, --autoconf-header= കോഡ് സൃഷ്ടിക്കും:

#ifndef HAVE_STDIO_H
#ഉൾപ്പെടുന്നു
#endif /* ndef HAVE_STDIO_H */

--autoconf-member=അംഗം
ഇതിലേക്കുള്ള ഏതെങ്കിലും ആക്സസ് വ്യക്തമാക്കുക അംഗം a ഉള്ളിൽ പൊതിയണം #ifdef HAVE_MEMBER
തടയുക. അംഗം ഒന്നുകിൽ a ആകാം ഫീല്ഡിന്റെ പേര് അല്ലെങ്കിൽ ക്ലാസ്-നാമം . ഫീല്ഡിന്റെ പേര്
കോമ്പിനേഷൻ.

ഉദാഹരണത്തിന്, C# ഡിക്ലറേഷൻ നൽകിയിരിക്കുന്നു:

[Mono.Unix.Native.Map ("struct dirent")]
സ്ട്രക്റ്റ് ഡയറന്റ് {
പബ്ലിക് ലോംഗ് ഡി_ഓഫ്;
}

അപ്പോള് --autoconf-member=d_off ഇതുപോലുള്ള കോഡ് സൃഷ്ടിക്കും:

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=SYMBOL
SYMBOL ഒരു ആണ് [DllImport] - എന്ന് അടയാളപ്പെടുത്തിയ രീതി അല്ല ഒരു പ്രോട്ടോടൈപ്പ് സൃഷ്ടിച്ചു
ഇതിനുവേണ്ടി.

--impl-header=HEADER
ഒരു തിരുകുക # ഉൾപ്പെടുത്തുക സൃഷ്ടിച്ചതിനുള്ളിലെ പ്രസ്താവന .c എന്നതിനായുള്ള ഫയൽ ഹെഡർ .

ഉദാഹരണത്തിന്, --impl-header= സൃഷ്ടിക്കുന്നു

#ഉൾപ്പെടുന്നു

--impl-macro=MACRO
ഒരു തിരുകുക # നിർവചിക്കുക സൃഷ്ടിച്ചതിനുള്ളിലെ പ്രസ്താവന .c ഫയൽ. മാക്രോ a അടങ്ങിയിരിക്കാം = ലേക്ക്
മാക്രോ മൂല്യത്തിൽ നിന്ന് മാക്രോ നാമം വേർതിരിക്കുക.

ഉദാഹരണത്തിന്, --impl-macro=FOO=42 സൃഷ്ടിക്കുന്നു

#FOO 42 നിർവ്വചിക്കുക

--library=LIBRARY
ഇതിനായി പ്രോട്ടോടൈപ്പുകൾ സൃഷ്ടിക്കുക [DllImport] സ്വദേശിയെ പരാമർശിക്കുന്ന അടയാളപ്പെടുത്തിയ രീതികൾ
ലൈബ്രറി ലൈബ്രറി സൃഷ്ടിച്ചതിലേക്ക് .h ഫയൽ.

--public-header=HEADER
ഒരു തിരുകുക # ഉൾപ്പെടുത്തുക സൃഷ്ടിച്ചതിനുള്ളിലെ പ്രസ്താവന .h എന്നതിനായുള്ള ഫയൽ ഹെഡർ .

ഉദാഹരണത്തിന്, --public-header= സൃഷ്ടിക്കുന്നു

#ഉൾപ്പെടുന്നു

--public-macro=MACRO
ഒരു തിരുകുക # നിർവചിക്കുക സൃഷ്ടിച്ചതിനുള്ളിലെ പ്രസ്താവന .h ഫയൽ. മാക്രോ a അടങ്ങിയിരിക്കാം = ലേക്ക്
മാക്രോ മൂല്യത്തിൽ നിന്ന് മാക്രോ നാമം വേർതിരിക്കുക.

ഉദാഹരണത്തിന്, --public-macro=FOO=42 സൃഷ്ടിക്കുന്നു

#FOO 42 നിർവ്വചിക്കുക

--rename-member=FROM=TO
എപ്പോഴാണ് ഇത് ഉപയോഗിക്കുന്നത് FROM ഒരു സി മാക്രോ ആണ്, അതിനാൽ ഉപയോഗിക്കുന്നതിന് മാറ്റം വരുത്തണം
സുബോധത്തോടെ. നിയന്ത്രിത പ്രാതിനിധ്യത്തിലേക്കുള്ള എല്ലാ ജനറേറ്റഡ് റഫറൻസുകളും ഉപയോഗിക്കും TO പകരം
of FROM .

ഉദാഹരണത്തിന്, C# ഡിക്ലറേഷൻ നൽകിയിരിക്കുന്നു:

[Mono.Unix.Native.Map ("struct stat")]
ഘടന സ്ഥിതി {
പൊതു നീണ്ട st_atime;
}

വാദവും --rename-member=st_atime=st_atime_ , സൃഷ്ടിച്ചത് .h ഫയൽ ചെയ്യും
അടങ്ങിയിട്ടുണ്ട്:

ഘടന സ്ഥിതി {
gint64 st_atime_;
};

(മാറ്റപ്പെട്ട ഫീൽഡ് പേര് ശ്രദ്ധിക്കുക), ജനറേറ്റ് ചെയ്യുമ്പോൾ .c ഫയലിൽ അടങ്ങിയിരിക്കും:

ടോസ്റ്റാറ്റ് (സ്‌ട്രക്റ്റ് സ്റ്റാറ്റ് * മുതൽ, സ്‌ട്രക്റ്റ് സ്റ്റാറ്റ് * വരെ)
{
to->st_atime_ = from->st_atime;
}

--rename-namespace=FROM=TO
സ്ഥിരസ്ഥിതിയായി, C "നെയിംസ്പേസ്" (ചിഹ്ന ഉപസർഗ്ഗം) C# നെയിംസ്പേസ് ആണ്; ഉള്ളിലെ തരങ്ങൾ
C# നെയിംസ്പേസ് Mono.Unix.Native സി "നെയിംസ്പേസിൽ" ആയിരിക്കും Mono_Unix_Native . ഉപയോഗിക്കുക
--നാംസ്പേസ് പുനർനാമകരണം ചെയ്യുക സ്ഥിരസ്ഥിതി പരിഷ്കരിക്കുന്നതിന്, ഉദാ --പേരുമാറ്റുക-
നെയിംസ്പേസ്=Mono.Unix.Native=Mono_Posix .

വിവരണം

സൃഷ്ടിക്കുക-നേറ്റീവ്-മാപ്പ് ഒരു നിർദ്ദിഷ്‌ട സാഹചര്യത്തിനുള്ള ഒരു പ്രോഗ്രാമാണ്: കോഡ് കർശനമായി സൂക്ഷിക്കുക
C# തരങ്ങളെ അടിസ്ഥാനമാക്കി C, C# എന്നിവയ്ക്കിടയിൽ പരസ്പരം സമന്വയിപ്പിക്കുന്നു.

മാനേജ് ചെയ്യുന്ന കോഡിന് എല്ലാവരുടേയും കൃത്യമായ തരങ്ങളും ലേഔട്ടും അറിയാമെങ്കിൽ മാത്രമേ പ്ലാറ്റ്‌ഫോം ഇൻവോക്ക് ഉപയോഗപ്രദമാകൂ
അത് ഉപയോഗിക്കുന്ന കൈകാര്യം ചെയ്യാത്ത ഘടനകൾ. ഇത് സാധാരണയായി വിൻഡോസിൽ സംഭവിക്കുന്നു, പക്ഷേ അങ്ങനെയാണ് അല്ല കേസ്
Unix-ൽ. ഉദാഹരണത്തിന്, സ്ട്രക്റ്റ് അറിഞ്ഞുകൂടാത്തപിശകുനിലസ്റ്റാറ്റ് വ്യത്യസ്ത വലിപ്പത്തിലുള്ള തരങ്ങൾ ഉപയോഗിക്കുന്നു
പ്ലാറ്റ്ഫോം മുതൽ പ്ലാറ്റ്ഫോം വരെ ഉദാഹരണത്തിന്, ഓഫ്_ടി
ILP32 പ്ലാറ്റ്‌ഫോമുകളിൽ സാധാരണയായി സൈൻ ചെയ്‌ത 32-ബിറ്റ് പൂർണ്ണസംഖ്യയാണ്, എന്നാൽ സൈൻ ചെയ്‌ത 64-ബിറ്റ് പൂർണ്ണസംഖ്യയായിരിക്കാം
LP64 പ്ലാറ്റ്‌ഫോമുകളിൽ, എന്നാൽ ILP64 പ്ലാറ്റ്‌ഫോമുകളിൽ 32-ബിറ്റ് ഒപ്പിട്ട പൂർണ്ണസംഖ്യയായിരിക്കാം.
_FILE_OFFSET_BITS മാക്രോയ്ക്ക് 64 മൂല്യമുണ്ട്. ചുരുക്കത്തിൽ, Unix-നുള്ളിൽ എല്ലാം വഴക്കമുള്ളതാണ്,
നിയന്ത്രിത കോഡിന് അത്തരം വഴക്കം കൈകാര്യം ചെയ്യാൻ കഴിയില്ല.

അങ്ങനെ, അതിനുള്ള മാടം സൃഷ്ടിക്കുക-നേറ്റീവ്-മാപ്പ് : നിയന്ത്രിത കോഡ് ലക്ഷ്യമാക്കാൻ കഴിയുന്ന ഒരു നിശ്ചിത എബിഐ അനുമാനിക്കുക,
കൈകാര്യം ചെയ്യുന്ന പ്രാതിനിധ്യങ്ങളെ ബന്ധപ്പെട്ട നേറ്റീവ് എന്നതിലേക്ക് "തങ്ക്" ചെയ്യുന്നതിനായി കോഡ് സൃഷ്ടിക്കുക
പ്രാതിനിധ്യങ്ങൾ. ഇതിനായി ചെയ്യേണ്ടത് ആവശ്യമാണ് സകലതും പ്ലാറ്റ്‌ഫോമുകൾക്കിടയിൽ അത് വ്യത്യാസപ്പെടാം
കംപൈലർ ഫ്ലാഗുകൾ, എണ്ണൽ മൂല്യങ്ങളിൽ നിന്ന് ( സിഗ്ബസ് FreeBSD-യിൽ മൂല്യം 10 ​​ആണ്, എന്നാൽ 7 ഓൺ
Linux) അംഗങ്ങളുടെ ഘടനയിലേക്ക് (എത്ര വലുതാണ് ഓഫ്_ടി ?).

സൃഷ്ടിക്കുക-നേറ്റീവ്-മാപ്പ് പരിശോധിക്കും അസംബ്ലി-ഫയൽ-നാമം കൂടാതെ ഇനിപ്പറയുന്ന ഫയലുകൾ ഔട്ട്പുട്ട് ചെയ്യുക:

ഔട്ട്പുട്ട്-PREFIX.h
എണ്ണൽ മൂല്യങ്ങൾ, ക്ലാസ്, ഘടന പ്രഖ്യാപനങ്ങൾ, പ്രതിനിധി എന്നിവ അടങ്ങിയിരിക്കുന്നു
പ്രഖ്യാപനങ്ങൾ, ഒപ്പം [DllImport] അടയാളപ്പെടുത്തിയ രീതികൾ (ലൈബ്രറിയിൽ നിന്ന് വ്യക്തമാക്കിയത്
--പുസ്തകശാല ) അസംബ്ലിക്കുള്ളിൽ അസംബ്ലി-ഫയൽ-നാമം .

ഔട്ട്പുട്ട്-PREFIX.c
എണ്ണലും ഘടന പരിവർത്തനവും നടപ്പിലാക്കുന്നത് അടങ്ങിയിരിക്കുന്നു
പ്രവർത്തനങ്ങൾ.

ഔട്ട്പുട്ട്-PREFIX.cs
ഒരു ഭാഗിക ക്ലാസ് അടങ്ങിയിരിക്കുന്നു നേറ്റീവ് പരിവർത്തനം എണ്ണൽ വിവർത്തനം അടങ്ങിയിരിക്കുന്നു
രീതികൾ.

ഔട്ട്പുട്ട്-PREFIX.xml
എണ്ണൽ വിവർത്തനത്തിനായി ECMA XML ഡോക്യുമെന്റേഷൻ സ്റ്റബുകൾ സൃഷ്ടിക്കുന്നു
ലെ രീതികൾ ഔട്ട്പുട്ട്-PREFIX.cs .

സൃഷ്ടിക്കുക-നേറ്റീവ്-മാപ്പ് പ്രാഥമികമായി തിരയുന്നു മാപ്പ് ആട്രിബ്യൂട്ട് - അലങ്കരിച്ച തരങ്ങൾ, രണ്ടെണ്ണം ഉപയോഗിക്കുന്നു
മാപ്പ് ആട്രിബ്യൂട്ട് പ്രോപ്പർട്ടികൾ:

നേറ്റീവ് തരം
അനുബന്ധ C തരം അടങ്ങിയിരിക്കുന്നു. ക്ലാസുകളിൽ പ്രയോഗിച്ചാൽ മാത്രം ഉപയോഗപ്രദമാണ്,
ഘടനകൾ, ഫീൽഡുകൾ.

പതാകകൾ അടിച്ചമർത്തുക
എ യുടെ എണ്ണൽ അംഗത്തിൽ വ്യക്തമാക്കുമ്പോൾ [പതാകകൾ] - അലങ്കരിച്ച കണക്കെടുപ്പ്
തരം, പ്രവർത്തനരഹിതമാക്കുന്നു ബിറ്റ്-മാസ്‌കിംഗ് എൻയുമറേഷനുള്ള സാധാരണ കോഡ് ജനറേറ്റർ പിന്തുണ
തരങ്ങൾ.

ബിറ്റ്മാസ്ക്, നോൺ-ബിറ്റ്മാസ്ക് വിവരങ്ങൾ എന്നിവയിൽ സൂക്ഷിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്
ഒരേ തരം, കൂടാതെ ബിറ്റ്മാസ്ക് പരിശോധനകൾ നോൺ-ബിറ്റ്മാസ്കിനായി ഉപയോഗിക്കരുത്
മൂല്യങ്ങൾ. ഉദാഹരണം: Mono.Unix.Native.FilePermissions.S_IFREG , ഏത് എ
ബിറ്റ്മാസ്ക് മൂല്യം, അതേസമയം മിക്കതും ഫയൽ അനുമതികൾ ബിറ്റ്മാസ്ക് മൂല്യങ്ങൾ ഉൾക്കൊള്ളുന്നു (
ഫയൽഅനുമതികൾ.S_IRUSR , ഫയൽഅനുമതികൾ.S_IWUSR , തുടങ്ങിയവ.).

ദി മാപ്പ് ആട്രിബ്യൂട്ട് ക്ലാസുകൾ, ഘടനകൾ, പ്രതിനിധികൾ, ഫീൽഡുകൾ എന്നിവയിൽ ആട്രിബ്യൂട്ട് വ്യക്തമാക്കാം
കണക്കുകൾ.

പ്രതിനിധികൾ
പ്രതിനിധികൾക്കുള്ള കോഡ് സൃഷ്ടിക്കൽ അവഗണിക്കുന്നു MapAttribute.NativeType സ്വത്ത്, ഒപ്പം
ഒരു ഫംഗ്ഷൻ പോയിന്റർ സൃഷ്ടിക്കുന്നു ടൈപ്പ്ഡ് അത് ഡെലിഗേറ്റ് ഡിക്ലറേഷനുമായി നന്നായി യോജിക്കുന്നു
കടന്നു .h ഫയൽ.

ഉദാഹരണത്തിന്,

നെയിംസ്പേസ് ഫൂ {
[മാപ്പ്]
ഡെലിഗേറ്റ് സ്ട്രിംഗ് MyCallback (സ്ട്രിംഗ് s);
}

സൃഷ്ടിക്കുന്നു ടൈപ്പ്ഡ് :

ടൈപ്പ്ഡെഫ് ചാർ* (*Foo_MyCallback) (const char *s);

ക്ലാസുകളും ഘടനകളും
A [മാപ്പ്] -അലങ്കരിച്ച ക്ലാസിനോ ഘടനയ്ക്കോ ഉള്ളിൽ ഒരു സി ഘടന പ്രഖ്യാപനം ലഭിക്കും
.h ഫയൽ:

[മാപ്പ്]
struct Foo {
പൊതു int i;
}

മാറുന്നു

struct Foo {
പൊതു int i;
};

എങ്കില് MapAttribute.NativeType പ്രോപ്പർട്ടി സജ്ജീകരിച്ചിരിക്കുന്നു, തുടർന്ന് പരിവർത്തന പ്രവർത്തനങ്ങൾ ആയിരിക്കും
ഉള്ളിൽ പ്രഖ്യാപിച്ചു .h ഫയലിനുള്ളിൽ സൃഷ്ടിച്ചു .c ഫയൽ:

നെയിംസ്പേസ് ഫൂ {
[മാപ്പ് ("സ്ട്രക്റ്റ് സ്റ്റാറ്റ്")]
ഘടന സ്ഥിതി {
പൊതു uint st_uid;
}
}

മാറുന്നു

/* .h ഫയൽ */
struct Foo_stat {
ഒപ്പിടാത്ത 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 (struct Foo_Stat * from, struct stat * to)
{
മെംസെറ്റ് (to, 0, sizeof(*to);
to->st_uid = from->st_uid;
തിരികെ വരുക;
}

int
Foo_ToStat (struct stat *to, sxtruct Foo_Stat *to)
{
മെംസെറ്റ് (to, 0, sizeof(*to);
to->st_uid = from->st_uid;
തിരികെ വരുക;
}

ക്ലാസുകൾക്കായി, പരിവർത്തന പ്രവർത്തനങ്ങൾ ക്ലാസിൽ പ്രഖ്യാപിച്ച ഫീൽഡുകൾ മാത്രമേ പകർത്തൂ
തന്നെ. പാരന്റ് ക്ലാസുകളിൽ പ്രഖ്യാപിച്ച ഫീൽഡുകൾ പകർത്തില്ല. (ഈ കാരണം ആണ്
സൃഷ്ടിക്കുക-നേറ്റീവ്-മാപ്പ് സിയിൽ എങ്ങനെയാണ് പാരമ്പര്യം നടപ്പിലാക്കുന്നത് എന്ന് അറിയില്ല
പാരന്റ് ക്ലാസുകളിൽ നിന്ന് ഫീൽഡുകൾ പകർത്തുന്നത് പരിവർത്തനം ചെയ്യുന്നയാൾക്ക് വിട്ടുകൊടുക്കുന്നു
പ്രവർത്തനങ്ങൾ.)

ഫീൽഡുകൾ ഒരു ഫീൽഡിൽ (1) ഉണ്ടെങ്കിൽ മാപ്പ് ആട്രിബ്യൂട്ട് ആട്രിബ്യൂട്ട്, കൂടാതെ (2) ഉണ്ട്
MapAttribute.NativeType പ്രോപ്പർട്ടി സെറ്റ്, തുടർന്ന് നിർദ്ദിഷ്ട നേറ്റീവ് തരം ഉപയോഗിക്കും
ഓവർഫ്ലോ പരിശോധനയ്ക്കായി. ഉദാഹരണത്തിന്:

നെയിംസ്പേസ് ഫൂ {
[മാപ്പ് ("സ്ട്രക്റ്റ് സ്റ്റാറ്റ്")]
ഘടന സ്ഥിതി {
[മാപ്പ് ("ഓഫ്_ടി")] പൊതുവായ നീളമുള്ള വലുപ്പം;
}
}

സൃഷ്ടിക്കുന്നു

/* .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 (struct Foo_Stat * from, struct stat * to)
{
_cnm_return_val_if_overflow (off_t, from->st_size, -1);

മെംസെറ്റ് (to, 0, sizeof(*to);
to->st_size = from->st_size;
തിരികെ വരുക;
}

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

മെംസെറ്റ് (to, 0, sizeof(*to);
to->st_size = from->st_size;
തിരികെ വരുക;
}

കൺവേർഷൻ ഫംഗ്‌ഷനുകളിൽ മികച്ച പിശക് പരിശോധിക്കുന്നതിന് ഇത് ഉപയോഗപ്രദമാണ്.
MapAttribute.NativeType എന്താണെന്നറിയാൻ മറ്റ് മാർഗങ്ങളില്ലാത്തതിനാൽ ഇതിന് ആവശ്യമാണ്
നേറ്റീവ് തരം (സിസ്റ്റം ഹെഡർ ഫയലുകൾ പാഴ്‌സ് ചെയ്യാതെ...).

കണക്കുകൾ
അതിനുള്ളിലെ ഓരോ അംഗത്തിനും വേണ്ടി ഒരു സി എൻയുമറേഷനും മാക്രോകളും സൃഷ്ടിക്കുന്നു
എണ്ണൽ. ലേക്ക് ഒപ്പം മുതൽ പ്രവർത്തനങ്ങളും പ്രഖ്യാപിച്ചിട്ടുണ്ട് .h ഫയലും
ൽ നടപ്പിലാക്കി .c ഫയൽ.

ഉദാഹരണത്തിന്,

നെയിംസ്പേസ് ഫൂ {
[മാപ്പ്]
enum Errno {
EINVAL
}
}

എന്നതിൽ ഇനിപ്പറയുന്നവ സൃഷ്ടിക്കും .h ഫയൽ:

enum Foo_Errno {
Foo_Errno_EINVAL = 0,
#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;
എങ്കിൽ (== Foo_Errno_EPERM ൽ നിന്ന്)
#ifdef EINVAL
{* to = EINVAL;}
# കൂടാതെ
{errno = EINVAL; മടക്കം -1;}
#അവസാനം
തിരികെ വരുക;
}

int
Foo_ToErrno (int from, int *to)
{
* to = 0;
#ifdef EINVAL
എങ്കിൽ (== EINVAL മുതൽ)
{* to = Foo_Errno_EPERM; തിരികെ 0;}
#അവസാനം
മടക്കം -1;
}

നിയന്ത്രിത enum a ആണെങ്കിൽ വ്യത്യസ്ത കോഡ് ജനറേറ്റുചെയ്യും [പതാകകൾ] - അലങ്കരിച്ച
എണ്ണൽ (ബിറ്റ്‌വൈസ് ഫ്ലാഗുകൾ കണക്കാക്കാൻ), എന്നാൽ ഇതാണ് അടിസ്ഥാന ആശയം.

മെയിലിംഗ് ലിസ്റ്റുകൾ

സന്ദര്ശനം http://lists.ximian.com/mailman/listinfo/mono-devel-list വിവരങ്ങൾക്ക്.

വെബ് SITE,

സന്ദര്ശനം http://www.mono-project.com വിശദാംശങ്ങൾക്കായി

സൃഷ്ടിക്കുക-നേറ്റീവ്-മാപ്പ്(1)

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് ക്രിയേറ്റ്-നേറ്റീവ്-മാപ്പ് ഓൺലൈനായി ഉപയോഗിക്കുക