CLI quick reference

Kapitola

Type

Komplexní reference na typ

!Int32

Generický parametr z deklarace typu přístupný pomocí 0-based indexu

!!Int32

Generický parametr z deklarace metody přístupný pomocí 0-based indexu

char

float32

float64

int8

int16

int32

int64

object

string

unsigned int8

unsigned int16

unsigned int32

unsigned int64

native int

native unsigned int

Vestavěné typy

class TypeReference

Reference na uživatelský typ. Viz TypeReference

method CallConv Type \* \(Param [, Param]*\)

Ukazatel na metodu. Viz CallConv

Type&

Managovaný ukazatel na typ. Typ nesmí být managovaný pointer nebo typedref. Managovaný pointer je oznámen garbage collectoru.

Type\*

Nemanagovaný ukazatel na typ. Nemanagovaný pointer není oznámen garbage collectoru a chová se jako neznaménkové celé číslo.

Type <Type [,Type]* [,]*>

Instance generického typu. Generickým parametrem nemohou být managované ukazatele (ByRef), typy jejichž pole ukazují na CIL evaluation stack (jako System.RuntimeArgumentHandle), void. Částečná instanciace není povolena.

Type \[[(\.\.\. | Int32 | Int32 \.\.\. | Int32 \.\.\. Int32) [, (\.\.\. | Int32 | Int32 \.\.\. | Int32 \.\.\. Int32)]*]\]

Pole. Existuje několik deklarací polí.

Type \[\]

Tzv. vektor - jednorozměrné 0-based pole. Vektory mají speciální podporu v CIL - instrukce newarr, ldelem, stelem nebo ldelema. Vektory jsou podtypy třídy System.Array.

Type \[Bound [,Bound]*\]

Pole jsou definovány počtem svých rozměrů. Každý rozměr je definován pomocí Bound (hranic), což může být:

\.\.\.: Dolní a horní hranice nespecifikovány
Int32: Dolní hranice 0 a horní zadané číslo
Int32 \.\.\.: Pouze dolní hranice specifikována
Int32 \.\.\. Int32: Obě hranice specifikovány

Ostatní pole jsou podporovány VES jako podtypy třídy System.Array.

Také lze vytvářet pole polí.

Type modopt \(TypeReference\)

Uživatelský modifikátor (optional modifier), kterému volající nemusí rozumět

Type modreq \(TypeReference\)

Uživatelský modifikátor (required modifier), kterému volající musí rozumět

Modifikátory jsou něco jako uživatelské atributy, ale jsou součástí signatury. Každý modifikátor asociuje referenci na typ s položkou signatury. CLI se chová k povinným (required) a volitelným (optional) modifikátorům stejně. Dvě signatury, které se liší jen uživatelskými modifikátory jsou považovány za různé. Uživatelské modifikátory nemají žádný význam pro VES. To jestli je modifikátor povinný nebo volitelný má význam pro jiné nástroje než CLI (např. analyzátory či kompilátory), které poznají jestli modifikátor má nějakou sémantiku, které musejí rozumět.

Type pinned

Použitelné jen pro lokální proměnné metod.

Pokud je vykonávána metoda, kde se nachází lokální proměnná typu pinned, VES nesmí přesunout objekt na který je proměnná referencí.

Pokud jsou používány nemanagované pointery na managované objekty, tyto objekty by měly být deklarovány pinned.

typedref

Reference na typ (např. System.TypedReference) vytvořená pomocí mkrefany. Používáno instrukcemi refanytype a refanyval.

valuetype TypeReference

Uživatelem definovaný typ typu struktura (neboxovaný).

void

Žádný typ. Povoleno jen jako návratový typ nebo jako část definice nemanagovaného ukazatele void*.

Kapitola

TypeReference

Reference na uživatelem definovaný typ

[ResolutionScope] DotedName [/ DottedName]*

ResolutionScope (ResolutionScope)

Pokud vynechán jedná se o referenci do aktuálního modulu aktuální assembly.

\[\.module FileName\]

Reference do jiného modulu aktuální assembly

FileName (DottedName): Název souboru s modulem. Musí se jednat o modul téže assembly.

\[AssemblyRefName\]

Reference do jiné assembly

AssemblyRefName (DottedName): Název referencované assembly definované pomocí .assembly extern {}

DottedName / DottedName

lomítko je použito k oddělení názvu typu nadřazeného typu vnořenému od názvu typu vnořeného.

Kapitola

TypeSpec

Zjednodušená reference na typ. Umožňuje na jednom místě použít Type, TypeReference a syntaktickou zkratku \[[\.module] DottedName\]. Např místo class System.GC lze použít System.GC.

Kapitola

GenPar

Specifikace generického parametru

(\+ | - | class | valuetype | \.ctor)* [\([Type [, Type]*]\)] Id

+

Kovariantní generický parametr

Kovariance znamená, že když máme typ IA<+T>, je možné provést přiřazení proměnné typu IA`1<A> do proměnné typu IA`<B> za předpokladu, že je možné provést přiřazení proměnné typu A do proměnné typu B. Například následující pseudokód by byl možný:

Interface IA<+T>;
IA`1<System.String> var1;
IA`1<System.Object> var2;
var1 := var2;

Kovariantní generické parametry mohou být použity jako návratové typy metod a mohou být použity ke konstruování kovariantních návratových typů metod.

interface IEnumerator<+T> {
	T Current { get; }
	bool MoveNext();
}
interface IEnumerable<+T> {
	IEnumerator<T> GetEnumerator();
}

Kovariantní generický parametr se může objevit jen v pozici "consumer", "writer" nebo "setter".

-

Kontravariantní generický parametr

Kontravariance je opakem kovariance. Pro typ IB<-T> je možné přiřazení IB`1<B> := IB`1<A>, pokud je možné přiřazení A := B.

Interface IB<-T>;
IB`1<System.String> var1;
IB`1<System.Object> var2;
var2 := var1;

Kontravariantní generické parametry mohou být použity jako typy parametrů metod a mohou být použity ke konstrukci kontravariatních interfaců.

interface IComparer<-T> { 
	bool Compare(T x, T y);
}
interface IKeyComparer<-T> : IComparer<T> {
	bool Equals(T x, T y);
	int GetHashCode(T obj);
}

Kontravariantní generický parametr se může objevit jen v pozici "producer", "reader" a "getter".

Shrnuto:
B → A ⇒ I<+B> → I<+A>
B → A ⇒ I<-A> → I<-B>

+ a - nemohou být použity současně. Pokud není použit ani jeden z nich, jedná se o nevariantní generický parametr. Na použití nevariantních generických parametrů se nevztahují žádná omezení.

Kovariance a kontravariance je použitelná jen pro delegáty a interfacy.

class

Typový parametr musí být referenčního typu (třída, ne struktura)

valuetype

Typový parametr musí být hodnotového typu (struktura, na třída), nesmí být ale System.Nullable<T>

class a valuetype se nesmí kombinovat.

\.ctor

Typový parametr musí být neabstraktní třída (reference type) s veřejným (public) konstruktorem bez parametrů nebo struktura (value type)

Každý z parametrů +, -, class, valuetype a .ctor se smí vyskytnout jen jednou.

Type (Type)

Omezující typy pro generický parametr. Typ dosazený za generický parametr je musí implementovat nebo od ich dědit.

Id (Id)

Název generického parametru.

Kapitola

CallConv

Způsob volání metody

instance: Jedná se o volání instanční metody. Metodě je předán ukazatel na aktuální instanci (tzv. this pointer)
explicit: Volání instanční metody s explicitně předávaným this pointerem. Normálně this pointer není součástí seznamu parametrů volání funkce, protože ho lze odvodit z kontextu. Pokud se jedná o explicitní volání, tak první položka seznamu parametrů volání je this pointer.
default: Výchozí způsob pro volání managovaných metod. Pro managované metody by měl být používán vždy, pokud není potřeba použít vararg.
unmanaged cdecl: Volání používané standardním jazykem C
unmanaged stdcall: Volání používané standardním jazykem C++
unmanaged fastcall: Speciální optimalizovaný způsob volání používaný C++
unmanaged thiscall: C++ volání, které předává this pointer
vararg: Metoda přijímající více argumentů

Existují ještě další volací konvence, které nejsou platformě nezávislé a nejsou ve standardu zmíněny. Jedná se 4 používané konvence, které nejsou platformě nezávislé, 4 rezervované pro budoucí použití a 2 pro nestandardní experimentální použití.

Kapitola

Param

Parametr metody

[\[in\] | \[opt\] | \[out\]]* Type [marshal \([NativeType]\)] [Id]

Id (Id): Nepovinné jméno parametru. Parametry mohou být referovány pomocí svého jména neo 0-based indexu. Do binárního kód se přeloží vždy podle indexu.
in: Vstupní parametr
out: Výstupní parametr; in a out mohou být použity jen pro ukazatelové typy (managované i nemanagované). Pokud není specifikován ani jeden předpokládá se in.; CLI nekontroluje jestli parametry jsou použity jen v deklarovaném směru.
opt: Parametr je volitelný (z pohledu koncového uživatele). Výchozí hodnota je uložena pomocí direktivy .param.; Parametry in, out a opt nejsou součástí signatury metody.
Type (Type): Typ parametru
NativeType (NativeType): Typ použitý při přechodu parametru do nemanagovaného kódu.

Kapitola

NativeType

\[\] (LPArray): Nativní pole. Typ a velikost jsou určeny za běhu.
bool (Bool): Boolean - 4B integer, kde 0 reprezentuje false a cokoliv jiného true
float32 (R4): 4 bytové číslo s plovoucí desetinnou čárkou
float64 (R8): 8 bytové číslo s plovoucí desetinnou čárkou
[unsigned] int (Sys[U]Int): [Ne]znaménkový integer tak velký, aby se do něj vešel ukazatel (pointer) aktuální platformy.
[unsigned] int[8|16|32|64] ((U|I)(1|2|4|8)): [Ne]znaménkový integer příslušné velikosti
lpstr (LPStr): Ukazatel na nullcharem ukončený řetězec ANSI znaků. Kódová stránka záleží na implementaci.
lpwstr (LPWStr): Ukazatel na nullcharem ukončený řetězec Unicode znaků. Kódování záleží na implementaci.
method (FunctionPtr): Ukazatel na funkci
NativeType\[\] (LPArray): Pole nativního typu. Velikost je určena za běhu.
NativeType\[Int32\] (LPArray): Pole nativního typu specifikované délky
NativeType\[\+Int32\] (LPArray): Pole nativního typu s velikostí položky udanou za běhu. Int32 specifikuje parametr aktuální metody (0-based index), který bude za běhu obsahovat velikost elementu pole v bytech. Může být aplikováno jen na metody, nikoliv na proměnné (fields).; Pokud signatura metody má nastaven bit PreserveSig na 1, počítají se parametry od 1 (1-based index).*
NativeType\[Int32\+Int32\] (LPArray): Pole nativního typu s velikostí běhu. První Int32 specifikuje počet elementů pole, druhý parametry aktuální metody (0-based index), který bude za běhu obsahovat počet dodatečných elementů v poli. Může být aplikováno je na metody, nikoliv na proměnné (fields).; Pokud signatura metody má nastaven bit PreserveSig na 1, počítají se parametry od 1 (1-based index).*
as any (AsAny)*: Typ objektu je určen za běhu.
byvalstr (VBByrefStr)*: Řetězec uložený v bufferu s pevnou délkou
custom \(QSTRING,QSTRING\) (CustomMarshaler)*: Vlastní marshalování. První QSTRING je název třídy marshaleru (používá konvenci jako Reflection.Emit k určení assembly a/nebo modulu). Druhý je řetězec poslaný marshaleru za běhu za účelem identifikace způsobu marshalingu.
fixed array [Int32] (ByValArray)*: Pole pevné zadané délky
fixed sysstring [Int32] (ByValTStr)*: Systémový string pevné délky. Může být použit jen na proměnné (filds). Kódování se určí speciálním atributem.
lpstruct (LPStruct)*: Ukazatel na Céčkovou strukturu. Používáno k marshalingu managovaných formátovaných typů.
lpstr (LPTStr)*: Ukazatel na nullcharem ukončené pole platformě závislých znaků (ANSI nebo Unicode). Kódová stránka a kódování závisí na implementaci.
struct (Struct)*: Céčkoá struktura. Používáno k marshalování managovaných formátovaných typů.

Direktiva	Rodiče	Obsah
`.addon`	`.event`
`.assembly {}`	Soubor	`.custom`, `.hash alghoritm`, `.culture`, `.publickey`, `.ver`, `.permissionset`, `.permission`, `.locale`*
`.assembly extern {}`	Soubor	`.hash`, `.custom`, `.culture`, `.publickeytoken`, `.publickey`, `.ver`
`.assembly extern`	`.mresource`
`catch`	`.try`	`handler`, `{}`
`.class {}`	Soubor, `.class`	`.class`, `.custom`, `.data`, `.event`, `.field`, `.method`, `.override`, `.pack`, `.param type`, `.property`, `.size`, `.line`, `.permissionset`, `.permission`
`.class extern {}`	Soubor	`.file`, `.class extern`, `.custom`
`.class extern`	`.class extern`
`.corflags`	Soubor
`.culture`	`.assembly`, `.assembly extern`
`.custom`	Soubor, `.assembly`, `.mresource`, `.assembly extern`, `.class`, `.method`, `{}`, `.property`, `.event`
`.data`, `.data {}`	Soubor, `.class`, `.method`, `{}`	Data
`.emitbyte`	`.method`, `{}`
`.entrypoint`	`.method`, `{}`
`.event {}`
.export⁺	.method
`.class`	`.addon`, `.custom`, `.fire`, `.other`, `.removeon`, `.line`
`fault`	`.try`	`handler`, `{}`
`.field`	Soubor, `.class`
`.file`	Soubor; `.mresource`; `.class extern`
`.file alignment`*	Soubor
`filter`	`.try`	`handler`, `{}`
`finally`	`.try`	`handler`, `{}`
`.fire`	`.event`
`.get`	`.property`
`handler`	`catch`, `fault`, `filter`, `finally`
`.hash`	`.assembly extern`
`.hash alghoritm`	`.assembly`
`.imagebase`*	Soubor
`.language`*	Soubor
`.line` (`#line`)	Soubor, `.class`, `.method`, `{}`, `.property`, `.event`
`.locale`	`.assembly`
`.locals`	`.method`, `{}`
`.maxstack`	`.method`, `{}`
`.method {}`	Soubor, `.class`	`.custom`, `.data`, `.emitbyte`, `.entrypoint`, `.locals`, `.maxstack`, `.override`, `.override method`, `.param`, `.param type`, `.line`, Instrukce, Label, `.permission`, `.permissionset`, `{}`, `.try`
`.module`	Soubor
`.module extern`	Soubor
`.mresource {}`	Soubor	`.assembly extern`, `.custom`, `.file`
`.namespace`*	Soubor
`.other`	`.property`, `.event`
`.override`	`.class`, `.method`, `{}`
`.override method`	`.class`, `.method`, `{}`
`.pack`	`.class`
`.param`	`.method`, `{}`
`.param type`	`.class`, `.method`, `{}`
`.permission`	Soubor, `.assembly`, `.class`, `.method`, `{}`
`.permissionset`	Soubor, `.assembly`, `.class`, `.method`, `{}`
`.property {}`	`.class`	`.custom`, `.get`, `.other`, `.set`, `.line`
`.publickey`	`.assembly`, `.assembly extern`
`.publickeytoken`	`.assembly extern`
`.removeon`	`.event`
`.set`	`.property`
`.size`	`.class`
`.stackreserve`⁺	Soubor
`.subsystem`	Soubor
`.try`	`.method`, `{}`	`{}`, `fault`, `filter`, `finally`, `catch`
`.ver`	`.assembly`, `.assembly extern`
`.vtentry`⁺	`.method`
`.vtfixup`	Soubor
`{}`	`.method`, `{}`, `.try`, `catch`, `fault`, `finally`, `filter`	`.custom`, `.data`, `.emitbyte`, `.entrypoint`, `.locals`, `.maxstack`, `.override`, `.override method`, `.param`, `.param type`, `.line`, Instrukce, Label, `.permission`, `.permission`, `{}`, `.try`
Data	`.data`
Instrukce	`.method`, `{}`
Label	`.method`, `{}`
Soubor		`.assembly`, `.assembly extern`, `.class`, `.class extern`, `.corflags`, `.custom`, `.data`, `.field`, `.file`, `.file alignment`, `.imagebase`, `.language`, `.line`, `.method`, `.module`, `.module extern`, `.mresource`, `.namespace`, `.permission`, `.permissionset`, `.subsystem`

Kapitola

`.assembly {}`

Viz též:
.assembly extern {} | .assembly extern | .module

Popis

Definuje assembly

Rodiče

Soubor

Potomci

.custom, .hash alghoritm, .culture, .publickey, .ver, .permissionset, .permission

ilasm zde nepodporuje .culture, použijte .locale.*

Syntax

\.assembly Name {}

Name (DottedName): Název assembly

Kapitola

`.assembly extern {}`

Viz též:
.assembly extern | .class extern {} | .class extern | .module extern | .assembly {}

Popis

Definuje odkaz na jinou assembly

Rodiče

Soubor

Potomci

.hash, .custom, .culture, .publickeytoken, .publickey, .ver

Syntax


\.assembly extern Name [as Alias] {}

Name (DottedName): Název referencované assembly (musí odpovídat názvu assembly jak je v ní zadán direktivou .assembly)
Alias (DottedName): Název referencované assembly používaný při odkazech na ni. To umožňuje referencovat více assembly se stejným názvem a různou např. verzí či kulturou.

Kapitola

`.class {}`

Viz též:
.class extern {}

Popis

Definuje třídu (nebo strukturu, delegáta, interface)

Rodiče

Soubor, .class

Obsah

.class, .custom, .data, .event, .field, .method, .override, .pack, .param type, .property, .size, .line, .permissionset, .permission

Syntax

\.class Attrs Name [<GenericSpec>] [extends ExtendedType [implements ImplementedTypes]] {}

Attrs (bílým znakem oddělený seznam ClassAttr)

Atributy třídy. Oddělují se mezerou. Ze syntaktického hlediska se mohou vyskytovat vícekrát i ty samé.

abstract: Abstraktní (VB: MustInherit) třída nemůže být instanciována. Pokud obsahuje abstraktní metody musí být abstraktní.
sealed: Od této třídy nelze oddědit (VB: NotInheritable); Třída, které je zároveň abstract a sealed by měla mít jen statické členy (podobné jako standardní modul ve VB)
ansi: Při předávání stringů mezi managovaným a nemanagovaným kódem se použije kódování ANSI
autochar: Při předávání stringů mezi managovaným a nemanagovaným kódem se použije kódování ANSI nebo Unicode (podle platformy)
unicode: Při předávání stringů mezi managovaným a nemanagovaným kódem se použije kódování Unicode; ansi, autochar a unicode definují marshaling stringů z/do nemanagovaného kódu. Nesmí být kombinovány. Výchozí hodnota je ansi.
auto: CLI bude instanční proměnné umisťovat do paměti jak uzná za vhodné
explicit: Instanční proměnné budou řazeny tak jak u nich bude určeno. Není povoleno pro generické typy.
sequential: Instanční proměnné budou řazeny sekvenčně, tak jek se vyskytují v tabulce metadat; auto, explicit a sequential definují řazení instančních proměnných třídy v paměti. Nesmějí být kombinovány. Výchozí je auto.
interface: Definuje že třída je interface
nested assembly: Vnořený typ dostupný jen z assembly, kde je definován (VB: Friend)
nested famandassem: Vnořený typ dostupný jen z assembly, kde je definován a jen z typů, které dědí od obsahujícího typu. Operátorem AND kombinuje nested assembly a nested familly (VB: nedostupné)
nested family: Vnořený typ dostupný jen z typů, které dědí od obsahujícího typu (VB: Protected)
nested famorassem: Vnořený typ dostupný z assembly, kde je definován nebo z typů které dědí od obsahujícího typu. Operátorem OR kombinuje nested assembly a nested familly (VB: Protected Friend)
nested private: Vnořený typ dostupný jen z obsahujícího typu (VB: Private)
nested public: Vnořený typ dostupný všude tam, kde je dostupný obsahující typ (VB: Public)
private: Nevnořený typ viditelný jen z assembly, kde je definován
public: Nevnořený typ viditelný odevšud; nested..., private a public definují viditelnost třídy. Může být použít jen jeden z nich. Pro třídy definované v jiných třídách je nutno použít modifikátory nested..., pro třídy definované na úrovni assembly (top-level) je potřeba použít private nebo public. Výchozí viditelností pro top-level třídy je public, pro vnořené nested private.
beforefieldinit: Instruuje CLI aby před voláním statické metody typu inicializovala statické proměnné.
rtspecialname: Označuje že název typu má speciální význam pro CLI. V současnosti nejsou definována žádná speciální jména typů. Pokud je použit rtspecialname, musí být použit i specialname.; Rezervováno pro budoucí použití.
serializable: Rezervováno pro budoucí použití, kdy budou pole (proměnné) serializovány do datového proudu. Podpora pro serializaci bude poskytována přímo implementací CLI.; Podporováno*.
specialname: Označuje, že název typu má speciální význam pro jiné nástroje než CLI.
import*: typ importován z COM knihovny

Name (Id)

Název třídy

GenericSpecs (čárkou oddělený seznam GenPar)

Specifikace generických parametrů

ExtendedType (TypeSpec)

Typ od kterého třída dědí. Pokud vynechán, předpokládá se System.Object

ImplementedTypes (čárkou oddělený seznam TypeSpec)

Čárkou oddělený seznam typů, které třída implementuje

Typy typů

Definováním vlastních tříd jsou definovány nové typy. Nové typy lze také definovat jako instance generických typů, pole, vektory či ukazatele. Tato subkapitola se zabývá typy deklarovanými pomocí direktivy .class {}.

Referenční typy (refernce types)

Základní typy v CLI. Dědí ot třídy System.Object, nebo od některého z jejích potomků, kromě potomků speciálního typu (viz dále). Nevztahují se na ně žádná dodatečná omezení.

Interfacy (rozhraní; interfaces)

Interface je speciální abstraktní typ definovaný atributem interface. Interface může být implementován jak referenčním tak hodnotovým typem. Pro implementaci interfacu musí třída implementovat veškeré jrho abstraktní metody nebo dědit od metody, která je implementuje. Výjimkou je abstraktní třída, která nemusí tyto metody (všechny) implementovat, protože od ní nelze vytvořit instanci. Metody pak musí být implementovány ve třídě, která od této abstraktní třídy dědí.

Interface může obsahovat jakékoliv statické členy (proměnné, metody, ...). Instančními metody interfaců musí být virtuální a abstraktní. Interfacy nemohou mít instanční proměnné (fields).

Proto, aby by interface implementován nějakým typem nestačí, aby byly implementovány všechny metody. U typu musí být explicitně řečeno, že implementuje daný interface (klauzule implements direktivy .class {}). Pokut třída implementuje nějaký interface, který vyžaduje implementaci jiného interfacu, stačí, když třída explicitně deklaruje, že implementuje specifičtější z obou interfaců (ten, který dědí).

Interface může specifikovat, že vyžaduje implementaci jiného interfacu (dědí od něj).

Pokud má nějaká metoda implementovat metodu interfacu, lze tak učinit:

Podle signatury: Metodou, která má stejný název a signaturu jako příslušná metoda interfacu.
Zděděním: Zdědí se existující implementace interfacu od rodičovské třídy.
Explicitně: Pomocí MethodImpl - direktiva .override

Dokumentace se nezmiňuje o událostech a vlastnostech na úrovni interfacu. Z praxe se však zdá, že se na ně vztahují stejná pravidla jako na metody.

Hodnotové typy (value types)

Hodnotové typy nejsou předávány jako reference ale jako obsahy paměti (při předání jsou kopírovány!). Jsou určeny k uchovávání malého množství dat. Ve vyšších jazycích jsou reprezentovány jako struktury (zatímco referenční typy jsou reprezentovány jako třídy). Vztah hodnotového a referenčního typu v CLI je asi jako vztah mezi strukturou a ukazatelem na strukturu v C++. Typickým hodnotovým typem je například. komplexní číslo, datum atp.

Každý hodnotový typ může být jednoduše převeden na odpovídající referenční typ procesem zvaným boxing (zapouzdření). Takto zaboxovaný hodnotový typ může být převeden zpět deboxováním (vybalením).

Hodnotový typ musí být sealed (nelze od něj dědit) a jeho rodičovskou třídou musí být System.ValueType nebo System.Enum.

Hodnotový typ může implementovat interfacy, ale toto má význam jen v jeho boxované podobě.

Hodnota neboxovaných hodnotových typů nemůže být null a nemůže být porovnána s null. Na hodnotové typy se nepohlíží jako na podtypy jiných typů, takže na ně nelze použít instrukci isinst (lze ji použít na boxovanou podobu).

Layout položek uvnitř hodnotových typů lze kontrolovat stejně jako u referenčních, což se hodí při komunikaci s nativním kódem.

Hodnotový typ nemůže obsahovat proměnnou (field) typu sebe sama ani proměnnou hodnotového typu, který obsahuje proměnnou tohoto typu.

Instanční metody hodnotových typů obdrží hako hodnotu proměnné this managovaný ukazatel na aktuální instanci (zatímco u referenčních typů obdrží přímo hodnotu referenčního typu - tedy referenci).

Výčty (enums)

Výčty jsou používány k definici sady symbolů stejného hodnotového typu. CLI nezaručuje, že hodnota proměnné výčtového typu bude jednou z položek výčtového typu.

Typ může být výčtem jen tehdy, když přímo dědí od System.Enum.

Členy výčtových typů mohou být jen proměnné (fields). Výčtový typ nemůže implementovat žádný interface, musí mít layout typu auto. Výčtový typ musí mít přesně jednu instanční proměnnou, jejíž typ určuje podtyp výčtu. Ostatní proměnné musí být statické literály, které nejsou inicializovány instrukcí initobj. Tyto proměnné jsou typu sebe sama a jejich hodnota je uložena v metadatech pomocí FieldInit (viz .field).

Mezi výčtovým typem a jeho podtypem existuje přímá konverze oběma směry.

Delegáti (delgates)

Objektová managované alternativa k ukazateli na metodu (CLI jej také podporuje).

Delegát je referenční sealed typ, který přímo nebo nepřímo dědí od System.Delegate (delegáti dědí od System.MulticastDelegate*)

Členem delegáta mohou být jen první dvě nebo všechny čtyři z níže uvedených metod. Tyto metody jsou runtime a managed a nemají specifikováno tělo - to poskytne VES automaticky. Další metody, které mohou být na delegáty volány jsou zděděny od bázové třídy.

.ctor: Konstruktor instance delegáta. Má přesně dva parametry (System.Object a System.IntPtr). Do prvního se předá instance třídy deklarující metodu a do druhého ukazatel na metodu.
Invoke: Virtuální metoda vyvolávající metodu, která je tímto delegátem představována. Signatura metody je stejná jako signatura metody, která bude volána.
BeginInvoke: Virtuální metoda vyvolávající delegáta asynchronně. Její signatura je podobná metodě Invoke. Návratovou hodnotou metody je System.IAsyncResult a za parametry stejnými jako u Invoke následují ještě parametry typu System.AsyncCallback a System.Object.
EndInvoke: Virtuální metoda se stejným návratovým typem jako Invoke. Obsahuje ty z parametrů metody Invoke, které jsou typu managovaný pointer (ve stejném pořadí). Za nimi ještě parametr typu System.IAsyncResult.

Pokud není řečeno jinak, standardní delegáti obsahují všechny 4 metody.

Delegáti mohou obsahovat další metody, pokud programátor poskytne implementaci těchto metod (nejsou runtime). Pak ale assembly nebude přenosná.

Kapitola

`.class extern {}`

Viz též:
.assembly extern {} | .assembly extern | .class extern | .module extern | .class

Popis

Používáno v modulu manifestu. Definuje exportovaný typ (viditelný mimo assembly) definovaný v jiném modulu assembly. Typy definované ve stejném modulu assembly, ve kterém je manifest, se takto exportovat nemusí.

Rodiče

Soubor

Obsah

.file, .class extern, .custom

Syntax

\.class extern (public | nested public) Name {}

Name (DottedName): Název třídy
public | nested public: Atribut viditelnosti exportu. Musí odpovídat viditelnosti exportovaného typu.

Kapitola

`.data {}`

Viz též:
.data

Viz .data.

Kapitola

`.event {}`

Viz též:
.property {} | .method {}

Popis

Definuje událost.

Rodiče

.class

Obsah

.addon, .custom, .fire, .other, .removeon, .line

Syntax

\.event [specialname] [rtspecialname] [Type] Name

specialname: Název události by měl být chápán jako speciální nástroji jinými než CLI.
rtspecialname: Název události by měl být chápán jako speciální samotným CLI.; V současnosti nejsou žádné speciální názvy definovány.
Type (TypeSpec): Identifikuje delegáta jehož signatura je stejná jako signatura metody která vyvolává událost (fire). Delegát je typicky přítomen.
Name (Id): Název události

Kapitola

`.method {}`

Viz též:
.property {} | .event{} | .field

Popis

Definuje metodu (funkci, proceduru, konstruktor, accessor, ...)

Rodiče

Soubor, .class

Obsah

.custom, .data, .emitbyte, .entrypoint, .locals, .maxstack, .override, .override method, .param, .param type, .line, Instrukce, Label, .permission, .permissionset, {}, .try

Syntax

\.method MethAttr* [CallingConvention] ReturnType [marshal \([ReturnMarshaling]\)] Name [<GenPar [, GenPar]*>] \([Parameter [, Parameter]*]\) ImplAttr* {}

\.method MethAttr* [CallingConvention] [\[in\] | \[opt\] | \[out\]]* ReturnType [marshal \([ReturnMarshaling]\)] Name [<GenPar [, GenPar]*>] \([Parameter [, Parameter]*]\) ImplAttr* {}

MethAttr (MethAttr)

Atribut metody. Může nabývat následujících hodnot:

abstract

Abstraktní metoda. Musí být také virtuální. Abstraktní metoda neobsahuje implementaci, ta bude poskytnuta odděděným typem. Abstraktní metoda může být jen v abstraktním typu. (VB: MustOverride)

newslot

Metoda obdrží nový slot v tabulce virtuálních metod. Obdrží je vždy, i pokud v nadřazené třídě existuje virtuální metoda s odpovídající signaturou. Pokud není specifikováno, obdrží virtuální metoda nový slot v tabulce virtuálních metod jen pokud se v nadřazeném typu nenachází virtuální metoda se stejnou signaturou. (VB: Shadows, nespecifikováno - Overrides)

final

Virtuální metoda nemůže být přepsána (overriden) v odvozené (derived) třídě. (VB: NotOverridable). Musí být virtuální.

hidebysig

Metoda zastiňuje metodu se stejnou signaturou z typu, od kterého je aktuální třída odvozena. Pokud je vynecháno zastiňuje všechny metody se stejným jménem bez ohledu na signaturu. VES toto nekontroluje. Jedná se o atribut pro nástroje (jako je kompilátor). (VB: Pokud je vynecháno a metoda není virtuální je ve VB označena jako Shadows, ale Shadows ve VB zastiňuje i členy jiného typu než metoda (proměnné, události, typy, ...); viz také newslot).

static

Metoda je statická (neinstanční) (VB: Shared)

virtual

Metoda je virtuální (VB: Overridable)

strict

Kontrolovat dostupnost metody při přepisování (overridingu). Musí být virtuální.

assembly

Metoda je dostupná v rámci assembly (VB: Friend)

famandassem

Kombinace přístupností family a assembly operátorem and (VB: žádný ekvivalent).

family

Metoda je přístupná pro typ, kde je definována a pro typy od něj odvozené. (VB: Protected).

famorassem

Kombinace přístupností family a assembly operátorem OR (VB: Protected Friend).

private

Metoda je dostupná jen pro typ, v němž je deklarována (VB: Private).

public

Metoda je dostupná všude tam, kde je dostupný typ, na jehož úrovni je deklarována (VB: Public).

compilercontrolled

Dostupnost metody kontroluje kompilátor

pinvokeimpl \(QSTRING [as QSTRING] PinvAttr*\)

Metoda je ve skutečnosti implementována nativním kódem aktuální platformy.

rtspecialname

CLI chápe jméno metody jako speciální. Speciální jména jsou:

.ctor: konstruktor třídy
.cctor: Inicializátor typu

specialname

Jméno metody by mělo být chápáno jako spaciální nástroji jinými něž CLI. Takto jsou označeny například metody, které reprezentují accessory vlastností a událostí a které nemají být dostupné jinak než před událost/vlastnost.

unmanagedexp*

Metoda je importována z nemanagovaného kódu pomocí COM interoperability.

reqsecobj*

Metoda volá jinou metodu s bezpečnostními atributy

privatescope*

MS kompilátor ilasm nerozpozná klíčové slovo compilercontrolled. Použijte místo něj privatescope.

Zakázané kombinace atributů metody:

static s kterýmkoliv z final, newslot, virtual

abstract s kterýmkoliv z final, pinvokeimpl

compilercontrolled s kterýmkoliv z final, rtspecialname, specialname, virtual

Pouze jeden z atributů dostupnosti může být aplikován (assembly, compilercontrolled, famandassem, family, famorassem, private, public)

CallingConvention (CallConv)

Způsob volání metody

ReturnType (Type)

Návratový typ metody. Pokud metoda nic nevrací, použije se návratový typ void.

ReturnMarshaling (NativeType)

Definuje způsob předávání návratové hodnoty z nemanagovaného kódu.

Name (MethodName)

Název metody. Jedná se o 'normální' název nebo o speciální název.

\.cctor | \.ctor | DottedName

.cctor: Metoda je inicializátorem typu. Vyžaduje atribut rtspecialname.
.ctor: Metoda je konstruktorem objektu. vyžaduje atribut rtspecialname.

GenPar

Typové parametry metody, pokud jde o generickou metodu.

Parameter (Param)

Parametry metody definující její signaturu.

ImplAttr (ImplAttr)

Implementační atributy metody

cil: Metoda obsahuje 'normální' CIL kód. Pokud metoda není abstraktní musí být určeno její tělo.
native: Metoda obsahuje nativní kód. Nativní metody nemají tělo ale referují na nativní metodu, která jej má typicky pomocí PInvoke.
runtime: Tělo metody není definováno ale automaticky vytvořeno runtimem. Primární použití je pro metody delegátů.; Pouze jeden z atributů cil, native, runtime může být uveden.
managed: Metoda je managovaná - implementovaná pomocí CIL.
unmanaged: Metoda není managovaná - typicky volána přes PInvoke.; managed a unmanaged není možno kombinovat.
forwardref: Tato deklarace nespecifikuje tělo metody. Tzn. tělo metody je specifikováno někde jinde. Tento atribut nemůže být přítomen pokud je assembly načtena do VES. Tento atribut je používán nástroji, jako je linker, aby zkombinovali assembly stávající se z více samostatně kompilovaných modulů a vyřešily dopředné reference.
internalcall: Tělo metody poskytuje samotná CLI. Používáno nízkoúrovňovými metodami v systémové knihovně. Není vhodné používat s metodami, které mají být používány na různých implementacích CLI.; internalclass umožňuje nejnízkoúrovňovějším částem BCL zabalit nemanagovaný kód, který je vestavěn do CLI.*
noinlining: Runtime nesmí expandovat metodu in-line (nahrazení instrukce volání tělem metody). Tzn. tělo metody se nesmí stát součástí místa, odkud je metoda volána, při převodu CIL kódu do nativního. Metoda musí být uchována jako separátní rutina. Toto umožňuje, aby metoda zůstala viditelná pro debuggery a také umožňuje změnit defaultní heuristiku CIL-native překladače.
synchronized: Metoda musí být vykonávány jednovláknovým způsobem. Pokud se jedná o instanční nebo virtuální metodu musí být před vstupem do metody obdržen zámek na objekt. Pokud se jedná o statickou metodu musí být obdržen zámek na uzavřený typ. Volající vlákno nesmí pokračovat, dokud zámek neobdrží (což může způsobit deadlock). Zámek je uvolněn, když je metoda opuštěna - ať již standardně nebo z důvodu výjimky.
preservesig*: Signatura metody je převedena na HRESULT s návratovou hodnotou jako parametrem

\[in\] | \[opt\] | \[out\]

Dokumentace sice uvádí, že je možno mezi [CallingConvention] a ReturnType uvést [ParamAttr]*. Neuvádí ale k čemu je to dobré. Význam jednotlivých modifikátorů při použití na parametr metody je vysvětlen u Param.

Kapitola

`.mresource {}`

Viz též:
.data

Popis

Zdoj manifestu. Pojmenovaná data asociovaná s assembly. Direktiva přidá zdroj manifestu do manifestu assembly.

Rodiče

Soubor

Obsah

.assembly extern, .custom, .file

Syntax

\.mresource [private|public] Name {}

private: Zdroj není exportován, takže je dostupný jen v rámci assembly.
public: Zdroj je exportován a je dostupný i z jiných assembly.
Name (DottedName): Název zdroje

Kapitola

`.property {}`

Viz též:
.method {} | .event{}

Popis

Specifikuje vlastnost typu (property).

Rodiče

.class

Obsah

.custom, .get, .other, .set, .line

Syntax

\.property [specialname] [rtspecialname] CallingConvention Type Name \([Param [,Param]*]\)

specialname: Jméno vlastnosti by mělo být chápáno jako speciální jinými nástroji než je CLI.
rtspecialname: Jméno vlastnosti by mělo být chápáno jako speciální samotným CLI. V současnosti nejsou definována žádná speciální jména vlastností.
CallingConvention (CallConv): Volací konvence vlastnosti
Type (Type): Typ vlastnosti
Param (Param): Parametry vlastnosti, pokud se jedná o indexer.; Signatura vlastnosti (parametry a návratový typ) musí být stejná jako signatura metody implementující getter.

Kapitola

`{}`

Viz též:
try | catch | fault | filter | finally

Popis: Blok kódu se používá k seskupování elementů těla metody dohromady. Používá se také jako tělo handleru výjimky.; Blok kódu (též rozsah platnosti) určuje rozsah, v rámci nějž jsou lokální proměnné dostupné přes svoje jméno. Protože se bloky mohou vnořovat, reference na proměnnou bude určena z nejvnitřnějšího bloku z pohledu místa reference. Deklarace ve vnitřnějším bloku zastiňuje deklaraci z vnějšejšího bloku. Při duplicitních deklaracích (nedoporučeno) bude referováno na první proměnnou toho jména. Rozsahy viditelnosti podle jména neovlivňují životní cyklus proměnné - všechny lokální proměnné jsou vytvořeny (případně i inicializovány) při vstupu do metody a žijí dokud metoda není opuštěna. Proměnné jsou dostupné skrzevá 0-based index kdekoliv v celé metodě. Indexy jsou lokálním proměnným přidělovány v pořadí jejich deklarace (pokud není explicitně určen jiný index).*
Rodiče: .method, {}
Obsah: .custom, .data, .emitbyte, .entrypoint, .locals, .maxstack, .override, .override method, .param, .param type, .line, Instrukce, Label, .permission, .permissionset, {}, .try
Syntax: {}

Kapitola

`.addon`

Viz též:
.removeon | .other | .set | .get | .fire

Popis

Odkazuje na metodu add události (přidání handleru). CLS specifikuje pojmenovávací konvenci, konzistenční omezení a vyžaduje aby metoda add byla označena jako specialname.

Rodiče

.event

Syntax

\.addon CallingConvention Type [TypeSpec::] MethodName \([Param [, Param]*]\)

CallingConvention (CallConv): Volací konvence metody
Type (Type): Návratový typ metody
TypeSpec (TypeSpec): Typ, který metodu deklaruje. Výchozí hodnota je stejný typ jako typ, kde je deklarována událost
MethodName (MethodName): \.cctor | \.ctor | DottedName; Název metody na kterou se odkazuje. Teoreticky se může jednat i o metody .cctor a .ctor.
Param (Param): Parametry určující signaturu odkazované metody.

Kapitola

`.assembly extern`

Viz též:
.assembly extern {} | .class extern {} | .class extern | .module extern

Popis

V rámci zdroje (resource) odkazuje na jinou assembly. Znamená, že zdroj manifestu je externí assembly s uvedeným jménem.

Viz též .assembly extern {}

Rodiče

.mresource

Syntax

\.assembly extern Name

Name (DottedName): Název externí assembly, která je zdrojem zdroje manifestu.

Kapitola

`catch`

Viz též:
fault | filter | finally | Label

Popis

Zachycení výjimky. Blok určuje typ výjimky, která má být zachycena a kód provedený při zachycení.

Rodiče

.try

Obsah

handler, {}

Syntax

catch ExceptionType (handler Label to Label | {})

ExceptionType (TypeReference): typ výjimky k zachycení
handler Label to Label: Rozsah návěští, mezi nimiž je kód, který slouží k zachycení výjimky.; Viz handler
{} (ScopeBlock): Kód, který slouží k zachycení výjimky.; Viz {}

Kapitola

`.class extern`

Viz též:
.assembly extern {} | .assembly extern | .class extern {} | .module extern

Popis

N/A

V dokumentaci není tato direktiva vysvětlena

Rodiče

.class extern

Syntax

\.class extern Name

Name (DottedName): Název třídy

Kapitola

`.corflags`

Viz též:
.emitbyte

Popis

Nastavuje políčko v CLI hlavičce výstupního PE souboru. CLI očekává hodnotu 1 v tomto políčku. Z důvodů zpětné kompatibility jsou 3 LSB rezervovány. Budoucí verze standardu mohou definovaz význam hodnot 8 ÷ 65535. Hodnoty vyšší než 65535 jsou pro experimentální a nestandardní účely.

Rodiče

Soubor

Syntax

\.corflags Value

Value (Int32)

Hodnota pole runtime flags. Flagy jsou definovány (čísla určují masku flagu v binárním čísle, nikoliv hodnotu; flagy mohou mít hodnotu 0 nebo 1):

COMIMAGE_FLAGS_ILONLY = 0x1: Vždy 1
COMIMAGE_FLAGS_32BITREQUIRED = 0x2: Image může být načten jen do 32 bitového procesu. Např. CLI implementace, která má nativní integer 64 bitový, takovouto binárku odmítne načíst.
COMIMAGE_FLAGS_STRONGNAMESIGNED = 0x8: Image má signaturu silného jméno
COMIMAGE_FLAGS_TRACKDEBUGDATA = 0x10000: Vždy 0

Výchozí hodnota je 1.

Kapitola

`.culture`

Viz též:
.locale*

Popis

Určuje že assembly je nastavena pro určitou kulturu.

Rodiče

.assembly, .assembly extern

Syntax

\.culture Culture

Culture (QSTRING): Kultura. Akceptuje stejné stringy jako System.Globalization.CultureInfo.

Kapitola

`.custom`

Viz též:
.param | .param type

Popis

Uživatelský atribut. Uživatelský atribut může být připojen k libovolné položce metadat s výjimkou .custom. Obvyklé je přiřazení uživatelských atributů k assembly, modulu, třídě, interfacu, struktuře, metodě, proměnné (field), vlastnosti (property), generickému parametru a události. Uživatelský atribut je připojen k položce, která mu bezprostředně předchází.

Rodiče

Soubor, .assembly, .mresource, .assembly extern, .class, .method, {}, .property, .event

Syntax

\.custom CallingConvention Type [TypeSpec::] MethodName \([Param [, Param]*]\) [= \(Data\)]

CallingConvention (CallConv)

Volací konvence konstruktoru

Type (Type)

Návratový typ konstruktoru - void

TypeSpec (TypeSpec)

Typ atributu. Ze syntaktického hlediska je nepovinný a defaultní hodnotou je typ na jehož úrovni je atribut použit. Lze jej vynechat jen pokud je atribut použit na úrovni typu a nižší. Pokud jej vynecháte aplikujete atribut sám na sebe nebo na nějakého jeho člena.

MethodName (MethodName)

Vždy .ctor protože je nutno volat konstruktor atributu.

Část aplikace tributu tedy vypadá vždy nějak takto:
instance void myAttribute::.ctor

Param (Param)

Parametry určující signaturu konstruktoru

Data (Bytes)

Blob dat pro konstruktor. Není vyžadováno pokud konstruktor nemá žádné parametry. Pokud konstruktor má parametry, jejich hodnoty jsou udány v poli bytů.

Pole bytů má svoji vnitřní strukturu asi takovouto:
Prolog FixedArg* NumNamed NamedArg*
Veškeré binární hodnoty jsou ukládány jako Little Endian. S výjimkou položek typu PackedLen, které se používají jen jako počty bytů následujícího UTF-8 stringu. Pokud nejsou žádné parametry, vlastnosti ani proměnné (fields) k vyplnění je blob prázdný.

Prolog

Prolog je vždy neznaménkový 16 bitový integer s hodnotou 0x0001.

FixedArg

Tzv. pevné argumenty. Jedná se o argumenty konstruktoru. Jejich počet musí odpovídat počtu argumentů konstruktoru podle signatury. Použití konstruktorů typu vararg není povoleno.

Každý pevný argument má svoji vnitřní strukturu:
(Elem) | (NumElem Elem+)
První syntax se používá pokud argument není tzv. SZARRAY, druhá pokud je.

Elem

Element určuje hodnotu položky a má následující strukturu:
(Val) | (SerString) | (FiledOrPropType Val)

Val

Tato signatura je použita pro hodnoty jednoduchých a výčtových (enum) typů. Tj. bool, char, float32, float64, int8, int16, int32, int64, unsigned int8, unsigned int16, unsigned int32, unsigned int64.

Blob obsahuje binární hodnotu příslušného typu. bool je uložen jako 1 byte s hodnotou 1 nebo 0, char jako 2 byty s Unicode znakem; ostatní typy mají obvyklou binární serializaci. Výčtový typ je uložen jako hodnota jeho integrálního typu.

SerString

Používá se pro hodnoty typu string a System.Type.

Struktura hodnoty typu SerString je následující:
PackedLen Bytes

PackedLen: Jednobytový neznaménkový integer určující počte bytů, které jej následují. Pokud má být hodnota stringu null má PackedLen hodnotu 0xFF a žádné byty jen nenásledují. Pokud má být hodnota prázdný řetězec, má hodnotu 0x00 a žádné byty jej nenásledují.

Pro hodnotu typu System.Type se ukládá serializovaný string obsahující jeho kanonické jméno - celé jméno typu volitelně následované jménem assembly, kde je definován, kulturou a tokenem veřejného klíče. Pokud je assembly vynechána "pátrá" CLI nejdříve v aktuální assembly, pak v systémové knihovně (mscorlib) - to jsou také jediné dva případe, kdy je povoleno jméno assembly, verzi, kulturu a token veřejného klíče vynechat.

FiledOrPropType Val

Používáno pro hodnoty typu Sytem.Object. Uložená hodnota pak reprezentuje uloženou boxovanou instanci nějakého hodnotového typu (value-type).

FiledOrPropType: Typ proměnné nebo vlastnosti. Viz níže pro pojmenované argumenty.
Val: Neboxovaná hodnota argumentu. Nemůže být null. Obsah viz Val pro jednoduché a výčtové typy výše.

NumElem

Přítomnou pouze pokud argument je typu SZARRAY. Jedná se o neznaménkový 32 bitový integer, který určuje počet elementů v SZARRAY. Hodnota 0xFFFFFFFF znamená, že hodnota argumentu je null.

NumNamed

Neznaménkový 16 bitový integer určující počet pojmenovaných vlastností a proměnných (field), jejichž inicializace následuje. Musí být vždy přítomen, i když jeho hodnota je 0.

NamedArg

Inicializace pojmenovaných "argumentů" - proměnných (field) a vlastností (property).

Pojmenovaný argument má scoji vlastní strukturu:
(FIELD | PROPERTY) FieldOrProptype FiedlOrPropName FixedArg

FIELD: Identifikuje inicializaci proměnné. Jeden byte s hodnotou 0x53.
PROPERTY: Identifikuje inicializaci vlastnosti. Jeden byte s hodnotou 0x54.
FieldOrPropType: Určuje typ proměnné nebo vlastnosti.; Musí být jedna z následujících 1 bytových hodnot: ELEMENT_TYPE_BOOLEAN = 0x2, ELEMENT_TYPE_CHAR = 0x3, ELEMENT_TYPE_I1 = 0x4, ELEMENT_TYPE_U1 = 0x5, ELEMENT_TYPE_I2 = 0x6, ELEMENT_TYPE_U2 = 0x7, ELEMENT_TYPE_I4 = 0x8, ELEMENT_TYPE_U4 = 0x9, ELEMENT_TYPE_I8 = 0xA, ELEMENT_TYPE_U8 = 0xB, ELEMENT_TYPE_R4 = 0xC, ELEMENT_TYPE_R8 = 0xD, ELEMENT_TYPE_STRING = 0xE; Pokud je typem jednodimenzionální 0-based indexované pole je hodnota předcházena bytem s hodnotou 0x1D.; Enum (výčet) je specifikován bytem s hodnotou 0x55 následovanou hodnotou typu SerString (viz výše).
FieldOrPropName: Název proměnné nebo vlastnosti uložený jako SerString (viz výše)
FixedArg: Samotná hodnota "argumentu" (proměnné nebo vlastnosti). Viz hodnoty "pevných" argumentů výše.

Celá struktura blobu Data je pak takováto:

Více o uživatelských atributech v kapitole Uživatelské atributy.

Kapitola

`.data`

Viz též:
.mresource {} | .locals | .field .param

Popis

Data vložená do PE souboru. Data je možno vkládat na různých úrovních. Přístup k datům je možný pomocí statické proměnné, které je deklarována jako, že načítá svůj obsah z dat.

Rodiče

Soubor, .class, .method, {}

Obsah

Data

Syntax

\.data [DataLabel = ] (DdItem | { DdItem [, DdItem]* })

DataLabel (Id)

Volitelný název datové položky. Musí být specifikován, pokud data mají být používána z kódu.

DdItem

Jedna datová položka. Pokud mají .data obsahovat více než jednu datovou položku, musí být datové položky uzavřeny ve složených závorkách, jako by se jednalo o blokový element.

& \(Id\) | bytearray \(Bytes\) | char \* \(QSTRING\) | float32 [\(Float64/)][\[Int32\]] | float64 [\(Float64/)][\[Int32\]] | int8 [\(Int32/)][\[Int32\]] | int16 [\(Int32/)][\[Int32\]] | int32 [\(Int32/)][\[Int32\]] | int64 [\(Int64/)][\[Int32\]]

&\(Id\): Adresa labelu
bytearray \(Bytes\): Pole bytů
char \* \(QSTRING\): Pole Unicode znaků
float32 [\(Float64/)][\[Int32\]]: 32 bitové číslo s plovoucí desetinnou čárkou. Může být replikováno.
float64 [\(Float64/)][\[Int32\]]: 64 bitové číslo s plovoucí desetinnou čárkou. Může být replikováno.
int8 [\(Int32/)][\[Int32\]]: 8 bitový integer. Může být replikován.
int16 [\(Int32/)][\[Int32\]]: 16 bitový integer. Může být replikován.
int32 [\(Int32/)][\[Int32\]]: 32 bitový integer. Může být replikován.
int64 [\(Int64/)][\[Int32\]]: 64 bitový integer. Může být replikován.

Kapitola

`.emitbyte`

Viz též:
.corflags

Popis

Vloží jeden byte (neznaménkový 8 bitový integer) přímo do binárního souboru na místo, kde se direktiva vyskytuje.

Rodiče

.method, {}

Syntax

\.emitbyte ByteValue

ByteValue (Int32): Hodnota typu UInt8 (byte), která bude vložena do binárního souboru.

Kapitola

`.entrypoint`

Viz též:
.file

Popis: Označuje aktuální metodu jako vstupní bod aplikace. Metoda musí být statická (může být globální nebo v rámci negenerického typu). VES volá tuto metodu za účelem startu aplikace. Spustitelný soubor musí mít přesně jeden vstupní bod. Metoda označená jako vstupní bod musí být buďto bez parametrů nebo akceptovat vektor řetězců (do kterého budou předány argumenty příkazové řádky od indexu 0). Návratový typ vstupního bodu musí být void, int32 nebo unsigned int32. Integer může být použit pro vrácení návratového kódu aplikace. 0 znamená normální ukončení, nenulové číslo chybu. Dostupnost vstupního bodu může být libovolná (tedy i private) a ve všech ostatních ohledech se jedná o "obyčejnou" metodu.; Výsledkem této direktivy je vložení odkazu na metodu do hlavičky PE souboru.
Rodiče: .method, {}
Syntax: \.entrypoint

Kapitola

`fault`

Viz též:
catch | filter | finally | Label | endfault

Popis

Speciální varianta catch, které zachytává všechny výjimky.

Rodiče

.try

Obsah

handler, {}

Syntax

fault (handler Label to Label | {})

handler Label to Label: Rozsah návěští, mezi nimiž je kód, který slouží k zachycení výjimky.; Viz handler
{} (ScopeBlock): Kód, který slouží k zachycení výjimky.; Viz {}

Kapitola

`.field`

Viz též:
.method | .locals | .param

Popis

Deklarace proměnné (field). Proměnná může být globální, instanční nebo statická. Globální proměnná musí být vždy statická. Globální je taková proměnná, která není definována na úrovni nějakého typu. Statické a instanční proměnné jsou deklarovány na úrovni typů.

Rodiče

Soubor, .class

Syntax

\.field [\[Offset\]] FieldAttr* Type Name [= FieldInit | at DataLabel]?

Offset (Int32)

Volitelný offset určující pozici proměnné (offset v bytech) v rámci instance. Může být specifikován je pro instanční proměnné typů, které mají explicitní (explicit) layout.

FieldAttr (FieldAttr)

Atributy proměnné

assembly | famandassem | family | famorassem | initonly | literal | marshal \(NativeType\) | notserialized | private | compilercontrolled | public | rtspecialname | specialname | static

assembly: Proměnná je dostupná v rámci assembly (VB: Friend)
famandassem: Kombinace přístupností family a assembly operátorem and (VB: žádný ekvivalent).
family: Proměnná je přístupná pro typ, kde je definována a pro typy od něj odvozené. (VB: Protected).
famorassem: Kombinace přístupností family a assembly operátorem OR (VB: Protected Friend).
private: Proměnná je dostupná jen pro typ, v němž je deklarována (VB: Private).
public: Proměnná je dostupná všude tam, kd je dostupný typ, na jehož úrovni je deklarována (VB: Public).
compilercontrolled: Dostupnost proměnné kontroluje kompilátor; Pouze jeden z atributů dostupnosti může být použit.
literal: Definuje konstantu (literál, VB: Const). Takovéto proměnné musí být přiřazena hodnota pomocí FieldInit a za běhu pro ní není rezervováno žádné místo v paměti. Musí být statická. Konstanta se stane součástí metadat, které je nedostupná z kódu. Kompilátor nahradí přístup ke konstantě její hodnotou. Změna hodnoty konstanty tedy vyžaduje rekompilaci všech assembly, které ji využívají.
initonly: Definuje pseudokonstantu (VB: ReadOnly), tedy proměnnou, která je konstantní po té, co je jí přiřazena hodnota. Změna hodnot těchto proměnných je možná jen v konstruktoru (instanční) nebo inicializátoru (statické) příslušného typu. Nemůže být měněna v jiné metodě nebo v konstruktoru zděděné třídy.; Pokud se na pseudokonstantu použije instrukce ldfld nebo ldflda stane se kód neověřitelným. Pro neověřitelný kód VES nemusí kontrolovat jestli je hodnota pseudokonstanty měněna mimo konstruktor, ale pokud ano, je takový kód neplatný.
static: Určuje že proměnná je statická - tedy nepatří k instanci typu ale k celému typu. Její hodnota je společná pro všechny instance a změny v jedné instanci se projeví do ostatních. K proměnné lze přistupovat bez nutnosti instanciace typu.; Hodnota proměnné je platná pro aplikační doménu. Tzn. změna hodnoty proměnné v jedné aplikaci (instanci téže aplikace) se nepromítne do jiné aplikace (instance téže aplikace) využívající tu samou assembly a tu samou proměnnou.
notserialized: Rezervováno pro budoucí použití, kdy se takto bude označovat proměnná, která se nemá serializovat.; Implementováno*; Atributy kontraktu (initonly, literal, static, notserialized) mohou být libovolně kombinovány (s výjimkou: literal musí být static). Výchozím stavem je instanční nekonstantní proměnná, která může být serializována.
marshal \(NativeType\): Marshalovací informace pro předávání proměnné do a přístup k ní z nemanagovaného kódu. Určuje typ z/do jakého bude obsah proměnné přetypován při předávání z/do nemanagovaného kódu. Atribut není vyžadován - každá implementace CLI má sadu defaultních pravidel.
rtspecialname: Určuje že název proměnné má speciální význam pro CLI.; V současnosti nejsou specifikovány žádné speciální názvy proměnných.
specialname: Specifikuje, že název proměnné má speciální význam pro jiné nástroje než je CLI. Může se jedna o název, který má speciální význam pro CLS.

Type (Type)

Typ proměnné

Name (Id)

Název proměnné

FieldInit (FieldInit)

Slouží k inicializaci proměnné. Ukládá inicializační hodnotu proměnné do metadat, odkud může být získána. CLI ale neinicializuje proměnné automaticky!


bool \((true | false)\) |
bytearray \(Bytes\) |
char \( Int32\) |
float32 \(Float64\) |
float32 \(Int32\) |
float64 \(Float64\) |
float64 \(Int32\) |
[unsigned] int8 \(Int32\) |
[unsigned] int16 \(Int32\) |
[unsigned] int32 \(Int32\) |
[unsigned] int64 \(Int64\) |
QSTRING |
nullref

ilasm nerozpoznává modifikátor unsigned u integerů*

bool \((true | false)\): Booleovská hodnota true nebo false
bytearray \(Bytes\): Pole bytů. Může být uloženo s jedním nulovým bytem, aby byl celkový počet sudý.
char \( Int32\): Jeden Unicode znak - 16 bitový neznaménkový integer
float32 \(Float64\) | float32 \(Int32\) | float64 \(Float64\) | float64 \(Int32\): Číslo s plovoucí desetinnou čárkou inicializované buďto číslem s plovoucí desetinnou čárkou nebo integerem.
[unsigned] int8 \(Int32\) | [unsigned] int16 \(Int32\) | [unsigned] int32 \(Int32\) | [unsigned] int64 \(Int64\): Znaménkový nebo neznaménkový integer příslušné velikosti. (ilasm umí jen znaménkový*)
QSTRING: Řetězec Unicode znaků
nullref: Nulová reference na objekt

Není vyžadováno, aby si datový typ proměnné a inicializátoru odpovídaly. Je záležitostí importujícího kompilátoru, aby si poradil s přetypováním.

DataLabel (Id)

Název datové položky asociované s proměnnou. Povinné pro globální proměnné, volitelné pro statické.

Kapitola

`.file`

Viz též:
.module | .entrypoint | .module extern

Popis

Řádková direktiva .file má tři různé syntaxe, podle toho v jakém kontextu se vyskytuje.

Popis

Svazuje assembly s dalším souborem (jako např. dokumentace), který se používá při běhu.

Rodiče

Soubor

Syntax

\.file [nometadata] FileName \.hash = \(Hash\) [\.entrypoint]

nometadata: Znamená že soubor není modulem - tedy může mít libovolný formát.
FileName (DottedName): Název souboru
Hash (Bytes): Hash souboru podle algoritmu specifikovaného .hash alghoritm. VES by měl přepočítat hash před přístupem k souboru. Pokud si hashe nebudou odpovídat je chování nespecifikované.; Klauzule .hash je ze syntaktického hlediska volitelná. Kompilátor ilasm doplní hash při kompilaci, pokud je vynechán. Za běhu v binárním souboru, ale hash být uložen musí!*
.entypoint: Znamená, že vstupní bod vícemodulové assembly se nachází v daném souboru (nemělo by být kombinováno s nometadata).

Popis

Reference na soubor externí třídy. Určuje modul, ve kterém se třída nachází.

Rodiče

.class extern

Syntax

\.file FileName

FileName (DottedName): Název souboru

Popis

Odkaz na soubor se zdrojem manifestu.

Rodiče

.mresource

Syntax

\.file FileName at Offset

FileName (DottedName): Název souboru
Offset (Int32): Offset (v bytech), kde zdroj začíná.

Kapitola

`.file alignment`*

Popis

Nastavuje pole file alignment v PE hlavičce výstupního souboru.

Rodiče

Soubor

Syntax

\.file alignment Alignment

Alignment (Int32): Platné hodnoty jsou násobky 512. Různé části PE souboru jsou na disku zarovnány na specifikovanou hodnoty (v bytech).

Kapitola

`filter`

Viz též:
catch | fault | finally | Label | endfilter

Popis

Rozšížená catch klauzule

Rodiče

.try

Obsah

{}, handler

Syntax

filter (Label | {})(handler Label to Label | {})

Label (Id): Návěští na kterém začíná kód klauzule filtru. Kód klauzule filtru končí v místě, kde začíná kód obsluhy filtru. Tzn. kód obsluhy filtru musí ihned následovat za kódem filtru.
{}: Kód filtru (1. {})
handler Label to Label: Rozsah návěší mezi nimiž je kód sloužící k zachycení filtru.; Viz handler
{}: Kód, který slouží k zachycení filtru (2. {}).; Viz {}

Kapitola

`finally`

Viz též:
catch | fault | filter | Label | endfinally

Popis

Definuje blok kódu, který se vykoná ať již došlo k výjimce nebo ne.

Rodiče

.try

Obsah

handler, {}

Syntax

finally (handler Label to Label | {})

handler Label to Label: Rozsah návěští, mezi nimiž je kód, který bude vykonán.; Viz handler
{} (ScopeBlock): Kód, který bude vykonán.; Viz {}

Kapitola

`.fire`

Viz též:
.removeon | .other | .set | .get | .addon

Popis

Odkazuje na metodu fire události (vyvolání události). CLS specifikuje pojmenovávací konvenci, konzistenční omezení a vyžaduje aby metoda fire byla označena jako specialname.

Rodiče

.event

Syntax

\.fire CallingConvention Type [TypeSpec::] MethodName \([Param [, Param]*]\)

CallingConvention (CallConv): Volací konvence metody
Type (Type): Návratový typ metody
TypeSpec (TypeSpec): Typ, který metodu deklaruje. Výchozí hodnota je stejný typ jako typ, kde je deklarována událost
MethodName (MethodName): \.cctor | \.ctor | DottedName; Název metody na kterou se odkazuje. Teoreticky se může jednat i o metody .cctor a .ctor.
Param (Param): Parametry určující signaturu odkazované metody.

Kapitola

`.get`

Viz též:
.removeon | .other | .set | .addon | .fire

Popis

Odkazuje na metodu get (getter) vlastnosti (property). CLS specifikuje pojmenovávací konvenci, konzistenční omezení a vyžaduje aby metoda get byla označena jako specialname.

Každá vlastnost může obsahovat maximálně jeden getter.

Rodiče

.property

Syntax

\.get CallingConvention Type [TypeSpec::] MethodName \([Param [, Param]*]\)

CallingConvention (CallConv): Volací konvence metody
Type (Type): Návratový typ metody
TypeSpec (TypeSpec): Typ, který metodu deklaruje. Výchozí hodnota je stejný typ jako typ, kde je deklarována událost
MethodName (MethodName): \.cctor | \.ctor | DottedName; Název metody na kterou se odkazuje. Teoreticky se může jednat i o metody .cctor a .ctor.
Param (Param): Parametry určující signaturu odkazované metody.

Kapitola

`handler`

Viz též:
.try | Label

Popis

Definuje rozsah návěští (labelů) pro direktivy catch, fault, filter a finally

Rodiče

catch, fault, filter, finally

Syntax

handler From to To

From (Id nebo Int32*): Návěští, kde se nachází první instrukce bloku.
To (Id nebo Int32*)): Návěští, které se nachází za poslední instrukcí bloku.; Návěští tedy obklopují blok, podobně jako by jej obklopovaly složené závorky, kdyby byla použita alternativní syntaxe {}.; ilasm vyžaduje, aby návěští From a To byla deklarována dříve (v kódu) než jsou použita.*; Obě návěští musí být stejného syntaktického typu - buďto Id nebo Int32.*

Kapitola

`.hash`

Viz též:
.hash alghoritm

Popis

Hash referencované assembly

Rodiče

.assembly extern

Syntax

\.hash = \(Hash\)

Hash (Bytes): Hash referencované vypočtený pomocí hashovacího algoritmu definovaného .hash alghoritm.

Kapitola

`.hash alghoritm`

Viz též:
.hash

Popis

Hashovací algoritmus používaný direktivou .hash. Hashovací algoritmus se používá k výpočtů hashů dalších souborů ze kterých se assembly skládá (pokud se skládá z více souborů) a je pro všechny soubory Stejný.

Rodiče

.assembly

Syntax

\.hash alghoritm Alghoritm

Alghoritm (Int32): Kód použitého algoritmu. Jedinou platnou hodnotou je 0x8004 pro SHA1.

Kapitola

`.imagebase`*

Popis

Nastavuje pole imagebase v PE hlavičce výstupního souboru. Hodnota specifikuje virtuální adresu, na kterou bude PE soubor načten do procesu.

Rodiče

Soubor

Syntax

\.imagebase Address

Address (Int64): Adresa na kterou bude PE soubor načten do procesu.

Kapitola

`.language`*

Popis: N/A; Dokumentace nepopisuje význam toho prvku.
Rodiče: Soubor
Syntax: \.language SQSTRING (, SQSTRING){0,2}

Kapitola

`.line` or `#line`

Popis

Syntaxe assembleru pro uchování informací o lexikálním rozsahu proměnných a mapování zdrojových řádek na řádky assembleru.

Metadata tyto informace neuchovávají. Je potřeba je zakódovat jiným způsobem.

Informace o zdrojové řádce je uchovávána v PDB (portable debug) souboru asociovaném s každým modulem.

Rodiče

Syntax

\.|#line Line [\: Column] [File] | #line Line FileMS*

Line (Int32): Číslo řádky
Column (Int32): Číslo sloupce
File (SQSTRING)
FileMS (QSTRING)*: Soubor, kde se řádek nachází

Kapitola

`.locale`*

Viz též:
.culture

Popis: Používáno na úrovni .assembly {}, protože ilasm tam nepodporuje .culture.; Dokumentace neposkytuje k této direktivě žádné bližší informace
Rodiče: .assembly
Syntax: N/A

Kapitola

Viz též:
.field

`.locals`

Popis

Deklarace jedné nebo více lokálních proměnných pro aktuální metodu.

Rodiče

.method, {}

Syntax

\.locals [init] \([\[LocalNumber\]]* Type [Name] [, [\[LocalNumber\]]* Type [Name]]*\)

init: Proměnné budou inicializovány na výchozí hodnoty jejich typů (referenční na null, číselné na 0).; Ověřitelné metody musí obsahovat init.; Pokud je init specifikován u jedné direktivy .locals, budou se ostatní direktivy .locals ve stejné metodě chovat, jako by měli init specifikováno také, i pokud jej specifikováno nemají.*
Type (Type): Typ proměnné
Name (Id): Nepovinný název proměnné
LocalNumber (Int32)*: ilasm podporuje vnořené rozsahy platnosti proměnných a umožňuje proměnným z vnořeného rozsahu použít stejný slot jako proměnná z nadřazeného rozsahu. Informace o lokálních jménech, rozsazích a překrývání proměnných z různých rozsahů je uložena do PDB souboru místo do PE souboru.*; Explicitně specifikuje číslo slotu, který lokální proměnná obdrží. Sloty jsou číslovány od nuly a každá další deklarovaná proměnná obdrží nový slot. Pokud je však specifikováno číslo slotu, může proměnná s vnitřnějšího bloku {} znovupoužít slot proměnné s vnějšnějšího bloku {} nebo .method {}. Tím proměnná z vnitřního slotu získá přístup k proměnné z vnějšího slotu. Toto se nazývá overlapping (překrývání). Překrývání je možné jen pro proměnné stejného typu.*

Kapitola

`.maxstack`

Popis

Maximální počet položek na zásobníku během běhu metody.

Rodiče

.method, {}

Syntax

\.maxstack Number

Number (Int32): Maximální počet elementů na výpočetním zásobníku během provádění metody.

Kapitola

`.module`

Viz též:
.module extern

Popis

Definice modulu. CIL moduly jsou referencovány pomocí svého názvu uloženého v metadatech místo názvu souboru.

Pokud direktiva .module není přítomna, ilasm ji sám doplní a inicializuje ji na fyzický název souboru (včetně přípony, přípona je velkými písmeny). ilasm také generuje Mvid GUID modulu.*

Rodiče

Soubor

Syntax

\.module Name

Name (DottedName): Logický název modulu.

Kapitola

`.module extern`

Viz též:
.assembly extern {} | .assembly extern | .class extern {} | .class extern | .module | .file

Popis

Reference na modul

Pokud je nějaká položka součástí assembly, ale je součástí jiného modulu než modulu obsahujícího manifest assembly, musí být v manifestu assembly deklarována direktivou .module extern.

Rodiče

Syntax

\.module extern FileName

FileName (DottedName): Název referencovaného modulu. Musí být stejný jako název referencovaného modulu deklarovaný v referencovaném modulu direktivou .module.

Kapitola

`.namespace`*

Popis

N/A

Dokumentace neposkytuje k této direktivě žádný popis.

Rodiče

Soubor

Syntax

\.namespace Name

Name Id: Název

Kapitola

`.other`

Viz též:
.removeon | .addon | .set | .get | .fire

Popis

Odkazuje na další metody, za kterých se vlastnost nebo událost skládá.

Rodiče

.event, .property

Syntax

\.other CallingConvention Type [TypeSpec::] MethodName \([Param [, Param]*]\)

CallingConvention (CallConv): Volací konvence metody
Type (Type): Návratový typ metody
TypeSpec (TypeSpec): Typ, který metodu deklaruje. Výchozí hodnota je stejný typ jako typ, kde je deklarována událost
MethodName (MethodName): \.cctor | \.ctor | DottedName; Název metody na kterou se odkazuje. Teoreticky se může jednat i o metody .cctor a .ctor.
Param (Param): Parametry určující signaturu odkazované metody.

Kapitola

`.override`

Viz též:
.override method

Popis

Řádková direktiva .override má dvě různé syntaxe podle toho jestli je deklarována na úrovní .class {} nebo .method {}.

Popis

Deklaruje, že virtuální metoda je v aktuálním typu implementována jinou virtuální metodou s jiným názvem ale stejnou signaturou. Direktiva může být použita k poskytnutí implementace virtuální metody zděděné od rodičovské třídy nebo metody deklarované v interfacu, který aktuální typ implementuje.

Tato direktiva nepodporuje generické metody. Vizte direktivu .override method s podporou generických typů.

Rodiče

.class

Syntax

\.override BaseType :: OverridenMethod with CallingConvention DerivedType :: OverridingMethod \([Param [, Param]]\)

BaseType (TypeSpec): Typ, z nějž pochází metoda, která jej implementována. Musí se jednat o typ, od kterého aktuální typ dědí, nebo který je aktuálním typem implementován.
OverridenMethod (MethodName): .ctor | .cctor | DottedName; Metoda z typu BaseType, která je implementována (název).
CallingConvention (CallConv): Volací konvence metody OverridingMethod.
DerivedType (TypeSpec): Typ, který obsahuje metodu DerivedType. Správně utvořený program se zde odkazuje na stejný typ, na jehož úrovni se direktiva .override vyskytuje. Metadata zde umožňují popsat něco, co VES nemusí pochopit.
OverridingMethod (MethodName): .ctor | .cctor | DottedName; Název virtuální metody, která implementuje metodu OverridenMethod.
Param (Param): Parametry definující signaturu metod OverridenMethod i OverridingMethod.

Popis

Zjednodušení předchozí syntaxe, pokud je direktiva použita na úrovni metody na místo na úrovni typu.

Rodiče

.method, {}

Syntax

\.override BaseType :: OverridenMethod
Popis viz předchozí syntax.

Kapitola

`.override method`

Viz též:
.override

Popis

Řádková direktiva .override method má dvě různé syntaxe podle toho jesli je deklarována na úrovní .class {} nebo .method {}.

Popis

Jedná se o rozšíření direktivy .override o podporu generických metod.

Rodiče

.class

Syntax

\.override method BaseType :: OverridenMethod [<\[OverrideMethodGenArity\]>] with CallingConvention DerivedType :: OverridingMethod [<\[OverrideMethodGenArity\]>] \([Param [, Param]]\)

BaseType (TypeSpec): Typ, z nějž pochází metoda, která jej implementována. Musí se jednat o typ, od kterého aktuální typ dědí, nebo který je aktuálním typem implementován.
OverridenMethod (MethodName): .ctor | .cctor | DottedName; Metoda z typu BaseType, která je implementována (název).
OverridenMethodGenArity (Int32): Počet generických parametrů metody OverridenMethod.
CallingConvention (CallConv): Volací konvence metody OverridingMethod.
DerivedType (TypeSpec): Typ, který obsahuje metodu DerivedType. Správně utvořený program se zde odkazuje na stejný typ, na jehož úrovni se direktiva .override vyskytuje. Metadata zde umožňují popsat něco, co VES nemusí pochopit.
OverridingMethod (MethodName): .ctor | .cctor | DottedName; Název virtuální metody, která implementuje metodu OverridenMethod.
OverridingMethodGenArity (Int32): Počet generických parametrů metody OverridingMethod.
Param (Param): Parametry definující signaturu metod OverridenMethod i OverridingMethod.

Popis

Zjednodušení předchozí syntaxe, pokud je direktiva použita na úrovni metody na místo na úrovni typu.

Rodiče

.method, {}

Syntax

\.override method BaseType :: OverridenMethod [<\[OverrideMethodGenArity\]>] \([Param [, Param]]\)
Popis viz předchozí syntax.

Kapitola

`.pack`

Viz též:
.size

Popis

Určuje explicitní pozicování proměnných (fields) typu. Proměnné budou zarovnány na adresy, které jsou násobky specifikovaného čísla nebo přirozeně zarovnány podle svého typu, podle toho co je menší. Například .pack 2 umožňuje aby 32 bitové integery byly zarovnány na sudé adresy, zatímco bez této direktivy by byly zarovnány na adresy, které jsou násobkem 4. To neznamená, že se budou překrývat! To znamená, že pokud za sebe umístíte 2 bytový a 4 bytový integer, nebude mezi nimi mezera.

Direktiva nemůže být použita pro typy s explicitní kontrolou pozicování.

Rodiče

.class

Syntax

\.pack Align

Align (Int32): Zarovnání. Musí být 0, 1, 2, 4, 8, 16, 32, 64 nebo 128. 0 indikuje, že se použije výchozí hodnota pro aktuální platformu.

Kapitola

`.param`

Viz též:
.param type | .field

Popis

Uloží do metadat konstantu asociovanou s parametrem metody. Na úrovni CLI to neznamená, parametr může být vynechán, ale nástroje jako kompilátory jej mohou doplnit na hodnotu z metadat, pokud jej vynechá programátor vyššího programovacího jazyka.

CLI nepřikládá žádný význam takto uloženým hodnotám - to jestli implementuje tzv. výchozí hodnoty je čistě na kompilátoru vyššího jazyka.

Pokud chcete připojit uživatelský atribut k parametru metody, připojte jej k této direktivě (tzn. uveďte jej ihned za ní). Pokud chcete připojit uživatelský atribut k návratové hodnotě metody, připojte jej k parametru 0 (viz vysvětlení prvku Number syntaxe).

Rodiče

.class, .method, {}

Syntax

\.pram \[Number\] [= FieldInit]

Number (Int32): 1-based index parametru. 0 je vyhrazena pro návratovou hodnotu funkce.
FieldInit (FieldInit): Inicializace parametru - podobně jako u .field.; Detaily viz .field.

Kapitola

`.param type`

Viz též:
.param

Popis

Placeholder typového parametru umožňujíc aplikovat na něj uživatelské parametry.

Rodiče

.class, .method, {}

Syntax

\.param type \[Number\]

Number (Int32): 1-based index generického parametru třídy/metody, v níž je direktiva umístěna.

Kapitola

`.permission`

Viz též:
.permissionset

Popis

Deklarativní bezpečnostní informace

Kompilátor vyššího jazyka převádí deklarativní bezpečnostní informace do formy XML a ukládá ji do metadat. ilasm potřebuje konverzní informace na svém vstupu.

Rodiče

Soubor, .assembly, .class, .method, {}

Syntax

\.permission SecAction TypeReference \(Key = Value [, Key = Value]*\)

SecAction (SecAction)

Bezpečnostní nastavení

assert: Prohlásit oprávnění tak že jej volající (caller) nepotřebuje
demand: Požadovat po všech volajících oprávnění
deny: Odepřít oprávnění takže kontrola selže
inheritcheck: Požadovat oprávnění po zděděné třídě
linkcheck: Požadovat oprávnění po volajícím
reqopt: Požadovat volitelná dodatečná oprávnění
refuse: Odepřít garantování těchto oprávnění
request: Upozornění, že oprávnění může být vyžadováno
prejitgrant*: Uložené odepření nastavené v před-JIT čase.; Nemicrosoftí implementace CLI může tuto operaci zabezpečení ignorovat.

TypeReference (TypeReference)

Třída oprávnění

Key (SQSTRING)

Value (SQSTRING)

Páry název = hodnota specifikující zabezpečení.

Kapitola

`.permissionset`

Viz též:
.permission

Popis

Sada deklarativního zabezpečení

Kompilátor vyššího jazyka převádí deklarativní bezpečnostní informace do formy XML a ukládá ji do metadat. ilasm potřebuje konverzní informace na svém vstupu.

Rodiče

Soubor, .assembly, .class, .method, {}

Syntax

\.permissionset SecAction \(Data\)

SecAction (SecAction): Viz .permission
Data (Bytes): Data

Kapitola

`.publickey`

Viz též:
.publickeytoken

Popis

Veřejný klíč původce assembly

Zde se ukládá RSA veřejný klíč, který byl použit k výpočtu signatury assembly (ta se vypočte tak, že se spočítá SHA1 hash assembly a ten se zakryptuje pomocí RSA a páru veřejného a soukromého klíče autora assembly).

Rodiče

.assembly, .assembly extern

Syntax

\.publickey = \(PublicKey\)

PublicKey (Bytes): Veřejný klíč

Kapitola

`.publickeytoken`

Viz též:
.publickey

Popis

Token veřejného klíče. Umožňuje uložit pouze token veřejného klíče na místo veřejného klíče celého.

K direktivě .assembly extern je možno uložit veřejný klíč toho, kdo externí assembly podepsal (.publickey) nebo jen jeho token. Ani jedno není povinné. Pokud je uloženo obojí, je token ignorován.

Rodiče

.assembly extern

Syntax

\.publickeytoken = \(Token\)

Token (Bytes): Spodních 8 bytů SHA1 hashe veřejného klíče původce referencované assembly.

Kapitola

`.removeon`

Viz též:
.addon | .other | .set | .get | .fire

Popis

Odkazuje na metodu remove události (odebrání handleru). CLS specifikuje pojmenovávací konvenci, konzistenční omezení a vyžaduje aby metoda remove byla označena jako specialname.

Rodiče

.event

Syntax

\.removeon CallingConvention Type [TypeSpec::] MethodName \([Param [, Param]*]\)

CallingConvention (CallConv): Volací konvence metody
Type (Type): Návratový typ metody
TypeSpec (TypeSpec): Typ, který metodu deklaruje. Výchozí hodnota je stejný typ jako typ, kde je deklarována událost
MethodName (MethodName): \.cctor | \.ctor | DottedName; Název metody na kterou se odkazuje. Teoreticky se může jednat i o metody .cctor a .ctor.
Param (Param): Parametry určující signaturu odkazované metody.

Kapitola

`.set`

Viz též:
.removeon | .other | .addon | .get | .fire

Popis

Odkazuje na metodu set (setter) vlastnosti (property). CLS specifikuje pojmenovávací konvenci, konzistenční omezení a vyžaduje aby metoda set byla označena jako specialname.

Každá vlastnost může obsahovat maximálně jeden setter.

Rodiče

.property

Syntax

\.set CallingConvention Type [TypeSpec::] MethodName \([Param [, Param]*]\)

CallingConvention (CallConv): Volací konvence metody
Type (Type): Návratový typ metody
TypeSpec (TypeSpec): Typ, který metodu deklaruje. Výchozí hodnota je stejný typ jako typ, kde je deklarována událost
MethodName (MethodName): \.cctor | \.ctor | DottedName; Název metody na kterou se odkazuje. Teoreticky se může jednat i o metody .cctor a .ctor.
Param (Param): Parametry určující signaturu odkazované metody.

Kapitola

`.size`

Viz též:
.pack

Popis

Velikost typu

Určuje minimální velikost typu v paměti. Je určena pro padding. Skutečná velikost, kterou typ obsadí v paměti, je maximum z hodnoty této direktivy a skutečné velikosti typu (se všemi paddingy a alignmenty).

Rodiče

.class

Syntax

\.size Size

Size (Int32): Velikost v bytech; Pokud je direktiva použita na hodnotový typ nesmí velikost přesáhnout 1MB.

Kapitola

`.subsystem`

Popis

Typ aplikace

Používá se jen pro assembly, které představují spustitelné aplikace. Specifikuje typ prostředí, který aplikace vyžaduje. Hodnota se ukládá v hlavičce PE souboru.

Rodiče

Soubor

Syntax

\.subsystem SubSystem

SubSystem (Int32)

Životní prostředí

Povolené hodnoty jsou:

2: Grafické uživatelské prostředí
3: Konzole

Kapitola

`.try`

Viz též:
handler | Label

Popis

Odchytávání chyb

Rodiče

.method, {}

Obsah

catch, fault, filter, finally, {}

Syntax

\.try (From to To | {}) ((catch TypeReference | fault | filter (Id | {}) | finally) (handler Id to Id | {}))+

From (Id): Label (návěští), kde se nachází první instrukce tzv. chráněného bloku (try).
To (Id): Label (návěští), který se nachází za poslední instrukcí tzv. chráněného bloku (try).; Návěští From a To tedy "obalují" chráněný blok, tak jako složené závorky v následující syntaxi.; Návěští From a To musí být deklarována v kódu dříve než je na ně odkazováno.; {}; Chráněný blok

Další položky jsou vysvětleny u jednotlivých bloků: catch, fault, filter a finally.

Žádné dva handlery (catch, fault, filter, finally) nesmějí začínat na stejné adrese.

Na počty a pořadí bloků jedntlivých typů se v CLS vztahují další omezení.

Poslední instrukcí bloku try a catch musí být skok za celou konstrukci. Např.:

.try {
    …                                       // chráněné instrukce
    leave exitSEH                           // normální opuštění bloku
} catch [mscorlib]System.FormatException {  // zachycení výjímky
    …                                       // ošetření výjímky
    pop                                     // vyjmutí výjímky ze zásobníku
    leave exitSEH                           // normální opuštění handleru
}
exitSEH:                                    // Pokračování zde

Blok filter těsně předchází svému handleru. Pokud se v něm rozhodne, že má dojít k ošetření výjimky, uloží na zásobník hodnotu EXCEPTION_EXECUTE_HANDLER (i4.1). Poslední instrukcí bloku filter musí být endfilter. V bloku filter nelze zakládat další bloky try.

Poslední instrukcí bloku finally musí být endfinally.

Poslední instrukcí bloku fault musí být endfault.

Kapitola

`.ver`

Popis

Verze

Rodiče

.assembly, .assembly extern

Syntax

\.ver Major:Minor:Build:Revision

Major (Int32)
Minor (Int32)
Build (Int32)
Revision (Int32): Jednotlivé složky čísla verze; Standardizované assembly musí mít Build a Revision rovno 0. Individuální implementátoři by měly alespoň jednu ze složek Build a Revision nastavovat na nenulovou hodnotu, aby se vyhli případné kolizi s pozdější verzí standardu.; Implementace může verzi ignorovat nebo vyžadovat její absolutní shodu, nebo cokoliv mezi tím.

Kapitola

`.vtfixup`

Viz též:
CallConv | .vtentry⁺

Popis

Helper pro volání mezi managovaným a nemanagovaným kódem

Tato direktiva se může vyskytnout vícekrát.

Tato direktiva nemusí být přístupná na všech implementacích.

Tato direktiva řeší věci týkající se způsobu volání metod mezi managovaným a nemanagovaným kódem a také data marshaling.

Tato direktiva deklaruje, že na nějaké pozici v paměti se nachází tabulka obsahující tokeny metadat, které referují na metody a je potřeba je nahradit ukazateli na metody. CLI provede tuto konverzi při načtení souboru s touto direktivou do paměti.

ilasm syntaxe nespecifikuje mechanismus pro vytváření tabulky tokenů. Kompilátor může prostě vytvořit tokeny jako bytové literály do bloku specifikovaného direktivou .data.

Rodiče

Soubor

Syntax

\.vtfixup [Number] [fromunmanaged | int32 | int64 | retainappdomain*]* at DataLabel

Number (Int32): Počet záznamů v tabulce
int32
int64: Šířka záznamu v tabulce. Jen jeden z těchto parametrů smí být použit. int32 je výchozí, pokud není specifikován ani jeden.
fromunmanaged: Instruuje CLI k vygenerování přechodu, který konvertuje nemanagované volání na managované volání a vrátí výsledek do nemanagovaného prostředí. Přechod se postará také o marshaling platformě specifickým způsobem definovaným v platform invoke.
retainappdomain*: Instruuje přechod k tomu, aby volání pro stejné vlákno nemanagovaného kódu přišlo do stejné aplikační domény, v jaké se nacházelo při posledním přechodu, nebo do defaultní domény, pokud je toto první volání.
DataLabel (Id): Datové návěští, kde je tabulka uložena

Kapitola

Label

Viz též:
handler | .try

Popis

Návěští - definuje kódové návěští, alias pro adresu (též CodeLabel)

Rodiče

.method, {}

Syntax

Label :

Label (Id): Název návěští - musí být unikátní přes všechna kódová návěští v rámci procedury.

Také existují datová návěští - DataLabel - jedná se o Id používaná direktivou data.

Ze syntaktického hlediska dále existuje seznam labelů Labels (LabelOrOffset [, LabelOrOffser]*, kde LabelOrOffset je Id (Id | Int32*)

Instrukce podle typu
prefixy	`constrained.` \| `no.` \| `readonly.` \| `tail.` \| `unaligned.` \| `volatile.`
konstanty	`ldc.i4`/`ldc.i8`/`ldc.r4`/`ldc.r8`/`ldc.i4.0`/`ldc.i4.1`/`ldc.i4.2`/`ldc.i4.3`/`ldc.i4.4`/`ldc.i4.5`/`ldc.i4.6`/`ldc.i4.7`/`ldc.i4.8`/`ldc.i4.m1`/`ldc.i4.s` \| `ldnull` \|\| `ldstr`
aritmetické	`add` \| `add.ovf`/`add.ovf.un` \| `div` \| `div.un` \| `mul` \| `mul.ovf`/`mul.ovf.un` \| `rem` \| `rem.un` `sub` \| `sub.ovf`/`sub.ovf.un`
bitové	`and` \| `neg` \| `not` \| `or` \| `shl` \| `shr` \| `shr.un` \| `xor`
testy	`ceq` \| `cgt` \| `cgt.un` \| `clt` \| `clt.un` \| `clt` \| `clt.un` \|\| `ckfinite` \|\|\| `isinst`
skoky	`beq`/`beq.s` \| `bge`/`bge.s` \| `bge.un`/`bge.un.s` \| `bgt`/`bgt.s` \| `bgt.un`/`bgt.un.s` \| `ble`/`ble.s` \| `ble.un`/`ble.un.s` \| `blt`/`blt.s` \| `blt.un`/`blt.un.s` \| `bne.un`/`bne.un.s` \| `brfalse`/`brfalse.s`/`brnull`/`brnull.s`/`brzero`/`brzero.s` \| `brtrue`/`brtrue.s`/`brinst`/`brinst.s` \|\| `br`/`br.s` \|\| `switch`
funkce	`call` \| `calli` \| `jmp` \| `ldftn` \| `ret` \|\| `callvirt` \| `ldvirtftn`
konverze	`conv.i1`/`conv.i2`/`conv.i4`/`conv.i8`/`conv.r4`/`conv.r8`/`conv.u1`/`conv.u2`/`conv.u4`/`conv.u8`/`conv.i`/`conv.u`/`conv.r.un` \| `conv.ovf.i1`/`conv.ovf.i2`/`conv.ovf.i4`/`conv.ovf.i8`/`conv.ovf.u1`/`conv.ovf.u2`/`conv.ovf.u4`/`conv.ovf.u8`/`conv.ovf.i`/`conv.ovf.u` \| `conv.ovf.i1.un`/`conv.ovf.i2.un`/`conv.ovf.i4.un`/`conv.ovf.i8.un`/`conv.ovf.u1.un`/`conv.ovf.u2.un`/`conv.ovf.u4.un`/`conv.ovf.u8.un`/`conv.ovf.i.un`/`conv.ovf.u.un` \|\|\| `castclass`
výjimky	`endfilter` \| `endfault`/`endfinally` \| `leave`/`leave.s` \|\|\| `rethrow` \| `throw`
zásobník	`dup` \| `pop`
paměť	`cpblk` \| `initblk` \| `ldind.i1`/`ldind.i2`/`ldind.i4`/`ldind.i8`/`ldind.u1`/`ldind.u2`/`ldind.u4`/`ldind.r4`/`ldind.u8`/`ldind.r8`/`ldind.i`/`ldind.ref` \| `lolcalloc` \| `stind.i1`/`stind.i2`/`stind.i4`/`stind.i8`/`stind.r4`/`stind.r8`/`stind.i`/`stind.ref` \|\|\| `cpobj` \| `initobj` \| `ldobj` \| `mkrefany` \| `stobj`
proměnné (lokální)	`ldloc`/`ldloc.s`/`ldloc.0`/`ldloc.1`/`ldloc.2`/`ldloc.3` \| `ldloca`/`ldloca.s` \| `stloc`/`stloc.s`/`stloc.0`/`stloc.1`/`stloc.2`/`stloc.3`
parametry	`arglist` \| `ldarg`/`ldarg.s`/`ldarg.0`/`ldarg.1`/`ldarg.2`/`ldarg.3` \| `ldarga`/`ldarga.s` \| `starg`/`starg.s`
proměnné (fields)	`ldfld` \| `ldflda` \| `ldsfld` \| `ldsflda` \| `stfld` \| `stsfld`
pole	`ldelem` \| `ldelem.i1`/`ldelem.i2`/`ldelem.i4`/`ldelem.i8`/`ldelem.u1`/`ldelem.u2`/`ldelem.u4`/`ldelem.u8`/`ldelem.r4`/`ldelem.r8`/`ldelem.i`/`ldelem.ref` \| `ldelema` \| `ldlen` \| `newarr` \| `stelem` \| `stelem.i1`/`stelem.i2`/`stelem.i4`/`stelem.i8`/`stelem.r4`/`stelem.r8`/`stelem.i`/`stelem.ref`
objektové	`box` \| `unbox` \| `unbox.any` \|\| `castclass` \|\| `cpobj` \| `initobj` \| `ldobj` \| `ldtoken` \| `newobj` \| `stobj` \|\| `isinst` \| `sizeof` \|\| `mkrefany` \| `refanytype` \| `refanyval`
řetězce	`ldstr`
různé	`break` \| `nop`

Binární numerické operace (tab. III.2)
a / b	`int32`	`int64`	`native int`	`F`	`&`	`O`
`int32`	`int32`	-	`native int`	-	`&` (`add`)	-
`int64`	-	`int 64`	-	-	-	-
`native int`	`native int`	-	`native int`	-	`&` (`add`)	-
`F`	-	-	-	`F`	-	-
`&`	`&` (`add`, `sub`)	-	`&` (`add`, `sub`)	-	`native int`(`sub`)	-
`O`	-	-	-	-	-	-

Unární numerické operace (tab. III.3)
Operand	`int32`	`int64`	`native int`	`F`	`&`	`O`
Výsledek	`int32`	`int64`	`native int`	`F`	-	-

Binární operace porovnání a podmíněné skoky (tab. III.4)
a / b	`int32`	`int64`	`native int`	`F`	`&`	`O`
`int32`	+	-	+	-	-	-
`int64`	-	+	-	-	-	-
`native int`	+	-	+	-	`beq`, `beq.s`, `bne.un`, `bne.un.s`, `ceq` (vše neověřitelné)	-
`F`	-	-	-	+	-	-
`&`	-	-	`beq`, `beq.s`, `bne.un`, `bne.un.s`, `ceq` (vše neověřitelné)	-	+	-
`O`	-	-	-	-	-	`beq`, `beq.s`, `bne.un`, `bne.un.s`, `ceq`, `cgt.un`

Celočíselné operace (tab. III.5)
a / b	`int32`	`int64`	`native int`	`F`	`&`	`O`
`int32`	`int32`	-	`native int`	-	-	-
`int64`	-	`int 64`	-	-	-	-
`native int`	`native int`	-	`native int`	-	-	-
`F`	-	-	-	`F`	-	-
`&`	-	-	-	-	-	-
`O`	-	-	-	-	-	-

Shifty (tab. III.6)
co / o kolik	`int32`	`int64`	`native int`	`F`	`&`	`O`
`int32`	`int32`	-	`int32`	-	-	-
`int64`	`int64`	-	`int64`	-	-	-
`native int`	`native int`	-	`native int`	-	-	-
`F`	-	-	-	`F`	-	-
`&`	-	-	-	-	-	-
`O`	-	-	-	-	-	-

Přetékání aritmetických operací (tab. III.7)
a / b	`int32`	`int64`	`native int`	`F`	`&`	`O`
`int32`	`int32`	-	`native int`	-	`&` (`add.ovf.un`)	-
`int64`	-	`int 64`	-	-	-	-
`native int`	`native int`	-	`native int`	-	`&` (`add.ovf.un`)	-
`F`	-	-	-	-	-	-
`&`	`&` (`add.ovf.un`, `sub.ovf.un`)	-	`&` (`add.ovf.un`, `sub.ovf.un`)	-	`native int`(`sub.ovf.un`)	-
`O`	-	-	-	-	-	-

Shoda signatur (tab. III.9)
metadata / zásobník	`int32`	`native int`	`int64`	`F`	`&`	`O`
int8	+	+	-	-	-	-
unsigned int 8, bool	+	+	-	-	-	-
int16	+	+	-	-	-	-
unsigned int16, char	+	+	-	-	-	-
int32	+	+	-	-	-	-
unsigned int32	+	+	-	-	-	-
int64	-	-	+	-	-	-
unsigned int64	-	-	+	-	-	-
native int	+ (znaménkové rozšíření)	+	-	-	-	-
native unsigned int	+ (nulové rozšíření)	+ (nulové rozšíření)	-	-	-	-
float32	-	-	-	+	-	-
float64	-	-	-	+	-	-
Class	-	-	-	-	-	+
By-ref	-	+ (neověřitelné, začne používat GC)	-	-	+	-
Ref any	-	-	-	-	-	-

Kapitola

Prefixy instrukcí

Slouží jako prefixy jiných instrukcí a modifikují jejich chování.

Kapitola Prefixy instrukcí

`constrained.` FE16

Volat člena na hodnotě typu proměnné. Účelem je volání instrukce callvirt nezávislé na tom jestli typ je hodnotový nebo referenční.

Syntax

constrained. thisType

Předpona pro

callvirt

Zásobník

..., ptr, arg1, ..., argN → ..., ptr, arg1, ..., argN

ptr: Musí být managovaný ukazatel (&) na thisType; Pokud thisType je referenční ptr je dereferencován a předán jako this-pointer instrukci callvirt.; Pokud thisType je hodnotový typ, který implementuje metodu, ptr je předán instrukci call implementované typem.; Pokud thisType je hodnotový typ a neimplementuje metodu, je ptr zaboxován a předán jako this-pointer instrukci callvirt (může se stát jen pro metody typů System.Object, System.ValueType a System.Enum).

Výjimky

Žádné

Korektní

Následuje instrukce callvirt. thisType musí být platný typedef, typeref nebo typespec token metadat.

Ověřitelné

ptr je managovaný pointer (&) na thisType

Po uvedené transformaci this-pointeru se provede ověření instrukce callvirt

Kapitola Prefixy instrukcí

`no.` FE19

Přeskočit případnou kontrolu selhání. Následující instrukce nemusí provádět určenou kontrolu selhání

Syntax

no.{typecheck|rangecheck|nullcheck}

Předpona pro

typecheck: castclass, unbox, ldelema, stelem; CLI může (neusí) vynechat typovou kontrolu. InvalidCastException může být vyvolána, pokud kontrola není vynechána a selže.
rangecheck: ldelem.*, ldelema, stelem.*; CLI může (nemusí) vynechat kontrolu rozsahu pole. IndexOutOfRangeException může být vyvolána, pokud kontrola nebyla vynechána a selhala.
nullcheck: ldfld, stfld, callvirt, ldvirtftn, ldelem.*, stelem.*, ldelema; CLI může (nemusí) vynechat kontrolu na null. NullReferenceException může být vyvolána, pokud kontrola nebyla vynechána a selhala.

Výjimky

Žádné

Korektní

Je následována některou z instrukcí uvedených výše.

Ověřitelné

nikdy, no. není povoleno.

Kapitola Prefixy instrukcí

`readonly.` FE1E

Následující instrukce vrátí managovaný ukazatel jen ke čtení a nebude provádět typovou kontrolu.

Syntax: readonly.
Předpona pro: ldelema
Výjimky: Žádné
Korektní: Předchází instrukci ldelema
Ověřitelné: S vráceným ukazatelem musí být zacházeno speciálně.

Kapitola Prefixy instrukcí

`tail.` FE14

Následující volání ukončí aktuální metodu. Rámec aktuální metody bude zahozen před voláním. Návratová hodnota volané metody se stane návratovou hodnotou aktuální metody.

Z bezpečnostních důvodů může být ignorována v některých případech. Ignorována v synchronizovaných metodách. Implementace mohou předponu ignorovat i v dalších případech (ale ne vždy).

Syntax: tail.
Předpona pro: call, calli, callvirt
Výjimky: Žádné
Korektní: Následuje jedna z uvedených instrukcí. Další instrukcí metody je ret. Kromě parametrů volané metody se při dosažení instrukce na zásobníku nic nevyskytuje. Není cílem skoku.; Volané metodě není možno předávat managované ukazatele, které ukazují na rámec zásobníku, který bude odstraněn.; Návratový typ volané metody musí být kompatibilní s návratovým typem volající metody.
Ověřitelné: Volané metodě nejsou předávány žádné managované ukazatele.

Kapitola Prefixy instrukcí

`unaligned.` FE12

Následující ukazatelová instrukce může být nezarovnaná (vzhledem k přirozené velikosti typu & nebo nemanagovaného ukazatele native int a následující instrukci).

Syntax

unaligned.alignment

alignment (unsigned int8): Může být 1, 2, 4 a určuje zarovnání

Zásobník

..., addr → ..., addr

Předpona pro

ldind, stind, ldfld, stfld, ldobj, stobj, initblk, cpblk, volatile.

Výjimky

Žádné

Korektní

Ověřitelné

Následující instrukce je jedna z uvedených

Kapitola Prefixy instrukcí

`volatile.` FE13

Následující ukazatel (addr) je nestálý (volatile). Tzn. že čtení z takové adresy nemůže být cachováno a vícenásobná ukládání nemohou být zahozena. Typické použití, je pokud adresa náleží jinému vláknu. Přístup k takovému umístění musí být atomický.

Syntax: volatile.
Zásobník: ..., addr → ..., addr
Předpona pro: ldind, stind, ldfld, stfld, ldobj, stobj, initblk, cpblk, unaligned.
Výjimky: Žádné
Korektní
Ověřitelné: Následující instrukce je jedna z uvedených

Kapitola

Základní instrukce

Instrukce nezávislé na objektovém modelu nebo CTS. Pokrývají základní operace.

instrukce	Logický typ výsledku	Fyzický typ výsledku	Poznámka
`conv.i1`	`int8`	`int32`
`conv.i2`	`int16`	`int32`
`conv.i4`	`int32`	`int32`
`conv.i8`	`int64`	`int64`
`conv.r4`	`float32`	`F`
`conv.r8`	`float64`	`F`
`conv.u1`	`unsigned int8`	`int32`
`conv.u2`	`unsigned int16`	`int32`
`conv.u4`	`unsigned int32`	`int32`
`conv.u8`	`unsigned int64`	`int64`
`conv.i`	`native int`	`native int`
`conv.u`	`native unsigned int`	`native int`
`conv.r.un`	`float32` nebo `float64`	`F`	Převede integer jako neznaménkový

instrukce	Logický typ výsledku	Fyzický typ výsledku
`conv.ovf.i1`	`int8`	`int32`
`conv.ovf.i2`	`int16`	`int32`
`conv.ovf.i4`	`int32`	`int32`
`conv.ovf.i8`	`int64`	`int64`
`conv.ovf.u1`	`unsigned int8`	`int32`
`conv.ovf.u2`	`unsigned int16`	`int32`
`conv.ovf.u4`	`unsigned int32`	`int32`
`conv.ovf.u8`	`unsigned int64`	`int64`
`conv.ovf.i`	`native int`	`native int`
`conv.ovf.u`	`native unsigned int`	`native int`

instrukce	Logický typ výsledku	Fyzický typ výsledku
`conv.ovf.i1.un`	`int8`	`int32`
`conv.ovf.i2.un`	`int16`	`int32`
`conv.ovf.i4.un`	`int32`	`int32`
`conv.ovf.i8.un`	`int64`	`int64`
`conv.ovf.u1.un`	`unsigned int8`	`int32`
`conv.ovf.u2.un`	`unsigned int16`	`int32`
`conv.ovf.u4.un`	`unsigned int32`	`int32`
`conv.ovf.u8.un`	`unsigned int64`	`int64`
`conv.ovf.i.un`	`native int`	`native int`
`conv.ovf.u.un`	`native unsigned int`	`native int`

Typ metadata tokenu	Typ handlu
`methoddef`	`RuntimeMethodHandle`
`methodref`
`methodspec`
`typedef`	`RuntimeTypeHandle`
`typeref`
`typespec`
`fielddef`	`RuntimeFieldHandle`
`fieldref`	`RuntimeFieldHandle`

Vlastnost	CLS - Popis	CLI/CTS	CLS			#
Vlastnost	CLS - Popis	CLI/CTS	Konzument	Rozšiřovatel	Framework	#
CLS kompatibilita	CLS kompatibilita se týká jen toho, co je viditelné ven z definujíc assembly.	netýká se	netýká se	Když během kompilace kontroluje kompatibilitu dělá tak jen u vystavovaných elementů.	Vnitřně může být implementován "jakkoli". Typ je CLS kompatibilní, pokud všechny jeho veřejné části jsou CLS kompatibilní nebo jsou specificky označené jako CLS nekompatibilní (typ pak musí "fungovat" i bez nich).	1
Označení CLS kompatibility	Označuje se atributem `CLSCompliantAttribute`, kterému se předá true nebo false, podle toho jestli element je CLS kompatibilní nebo ne. Pokud je typ označen jako CLS nekompatibilní `CLSCompliantAttribute(False)`, jeho elementy nesmějí být označeny `CLSCompliantAttribute(True)`.	Umožňuje jakýkoliv atribut kdekoliv	Může ignorovat členy, které nejsou díky porušení tohoto pravidla CLS kompatibilní.	Měl by kontrolovat porušení pravidla v době kompilace. Doporučeno je vyžadovat dodržení.	Musí dodržovat toto pravidlo.	2
Boxované hodnotové typy	Nejsou CLS kompatibilní	Umožňuje jejich použití kdekoliv	Nemusí importovat boxované hodnotové typy	Nemusí definovat syntax pro použití nebo definici boxovaných hodnotových typů	Nesmí exportovat boxované hodnotové typy	3
Znaky v názvech	Názvy musí dodržovat Dodatek 7 technické zprávy 15 standartu Unicode 3.0 pro znaky povolené jako začátek a součást názvu identifikátoru. Identifikátory musí být v kanonickém formátu normalizační formy C. Pro CLS účely jsou dva identifikátory shodné, pokud jejich mapování na malá písmena (podle Unicode standardu, lokálně nezávislé, 1:1) jsou stejná. Tedy, aby se dva identifikátory lišily, měly by se lišit více než jen ve velikosti písmen. Ale k přepisování (override) metod je nutná shoda na úrovni kódování s původním názvem (CLI podmínka, kterou CLS nemůže porušit).	Umožňuje jakýkoliv Unicode znak v názvu	Nemusí importovat typy, které toto pravidlo porušují. Musí poskytovat mechanizmus, jak přistupovat k elementu, který se jmenuje stejně, jako se jmenuje klíčové slovo jazyka.	Nemusí umět vytvářet typy, které toto pravidlo porušují, ale musí umět vytvářet typy, které se jmenují stejně jako klíčové slovo jazyka.	Nesmí exportovat typy, které toto pravidlo porušují. Měl by se vyhnout exportování typů, které se nebo jejichž elementy se jmenují stejně jako klíčová slova často používaná v jazycích.	4
Stejná jména	Jména ve stejném rozsahu platnosti musí být různá, s výjimkou přetěžování.	Jména musí být různá v rámci jednotlivých druhů elementů (metoda, proměnná, typ, vlastnost, událost), s výjimkou přetěžování.	Nemusí konzumovat typy, které porušují tato pravidla (po vynechání elementů označených jako CLS nekompatibilní)	Nemusí poskytovat syntax pro definici typů, které tato pravidla porušují.	Nesmí označit typ jako CLS kompatibilní, pokud jsou v rámci jeho CLS kompatibilních položek porušena tato pravidla.	5
Přetěžování	Proměnné (field) a typy musí mít různá jména. Metody, vlastnosti a události, které mají stejná jména se musí lišit více než návratovým typem (s výjimkou pravidla 39).					6
Výčty	Podtyp výčtu musí být vestavěný integrální typ. Název instanční proměnné výčtu musí být `value__` a musí být označen `rtspecialname`.	Neklade nároky na název a atributy instanční proměnné	Akceptuje výčty dodržující toto pravidlo. Může ignorovat `FlagsAttribute`.	Stejné jako konzument. Může ale nemusí umět vytvářet výčty	Nevystavuje výčty, které porušují pravidla a nepředpokládá, že výčty mají jen uvedené hodnoty.	7
Dostupnost při dědění	Při dědění a přepisování (overriding) se dostupnost členů nemění (s výjimkou: při dědění od typu z jiné assembly se `family-or-assembly` změní na `family.`	Povoluje rozšiřování i zužování dostupnosti	Nemusí akceptovat typy, které rozšiřují dostupnost členů	Nemusí poskytovat syntax k rozšiřování dostupnosti členů	Nesmí záviset na schopnosti rozšiřovat dostupnost členů	10
Typy v signaturách a typové parametry	Všechny typy v signaturách musí být CLS kompatibilní. Všechny typy použité k instanciaci generického typu musí být CLS kompatibilní.	Umožňuje použití nekompatibilních typů	Nemusí akceptovat typy, jejich členy porušují tato pravidla	Nemusí poskytovat syntax k porušení těchto pravidel	Nesmí porušovat tato pravidla u vystavovaných typů a jejich členů	11
Typy v signaturách a typové parametry	Typy použité v signaturách a pro instanciaci generických typů musí být dostupné všude tam, kde je dostupná signatura/typ.	Neklade tato omezení	Nemusí akceptovat typy, jejich členy porušují tato pravidla	Nemusí poskytovat syntax k porušení těchto pravidel		12
Typ literálu	CLS kompatibilní literál musí mít v metadatech uloženu hodnotu přesně stejného typu jako je jeho typ (nebo pod typu, pokud je jeho typ výčet)	Neklade omezení. Kompilátor musí provést přetypování.	Musí umět přečíst metadata inicializující statické literály a vložit hodnotu na místo použití literálu. Může předpokládat, že typ literálu a metadat je stejný. Nemusí podporovat konverzi.	Nesmí vytvářet literály, které se inicializují hodnotou jiného typu, než je jejich typ	Musí se vyhnout použití literálů inicializovaných metadaty jiného typu, než je jejich typ. Například: Kompilátor provede konverzi před uložením do metadat.	13
Typovaná reference	Typovaná reference (`System.TypedReference`) není CLS kompatibilní	Lze používat jen pro parametry a lokální proměnné. Nesmí být boxována.	Nemusí tento typ akceptovat	Nemusí umět tento typ produkovat nebo dědit od tříd či implementovat interfacy, které jej používají	Nesmí tento typ vystavovat	14
Volací konvence	Jediná povolená volací konvence je `default`. Ani `vararg` není povolen.	`vararg` stejně jako nemanagované volací konvence jsou povoleny	Nemusí akceptovat metody s proměnným počtem parametrů nebo nemanagovanou volací konvencí	Nemusí poskytovat syntax k vytváření metod s proměnným počtem parametrů nebo nemanagovanou volací konvencí	Metody s nemanagovanou volací konvencí nebo proměnným počtem parametrů nesmí být vystavovány	15
Pole	Prvky polí musí být CLS kompatibilní a všechny spodní meze polí musí být 0. K rozpoznání overloadů stačí skutečnost, že parametr je pole a typ prvku pole.	Podporuje pole s různými začátky a všech možných typů.	Nemusí podporovat pole CLS nekompatibilních typů. Overloading se nemusí zabývat celou komplexitou polí. Pokud syntaxe jazyka nepodporuje pole přímo, musí mít programátor přístup k metodám `Get`, Set a `Address` z `System.Array`.	Nemusí poskytovat syntaxi pro definici polí CLS nekompatibilních typů. Nemusí umět dědit od tříd používajících pole CLS nekompatibilních typů. Musí poskytovat přístup k `System.Array`, ale může předpokládat, že prvky všech polí jsou CLS kompatibilní. Plná syntaxe pole nutná k přepisu (overload) metody nemusí být viditelná programátorovi. Pokud syntaxe jazyka nepodporuje pole přímo, musí mít programátor přístup k metodám `Get`, Set a `Address` z `System.Array`.	Nesmí vystavovat CLS nekompatibilní pole. Pokud možno používat jen jednodimensionální 0-based pole jednoduchých pojmenovaných typů. Pokud možno vyhnout se přetěžování s polovými typy, pokud jej použije, dodržovat omezení.	16
Nemanagované ukazatele	Nejsou CLS kompatibilní	Možno používat	Nemusí umět	Nemusí poskytovat syntax pro jejich definici.	Nesmí být vystavovány	17
Interfacy	Nesmí požadovat implementaci nemanagovaných metod	Může požadovat	Nemusí umět	Nemusí mít mechanizmus k jejich implementaci	Nesmí vystavovat	18
Členy interfaců	Nesmí mít statické metody ani proměnné (fields)	Mohou	Nemusí akceptovat interfacy porušující tato pravidla	Nemusí poskytovat syntaxi pro vytváření interfaců porušujících tato pravidla	Nesmí vystavovat interfacy porušující pravidla	19
Volání konstruktoru báze	Konstruktor referenčního typu musí zavolat konstruktor báze dříve než přistoupí ke zděděným instančním datům.	Není nutné	Musí poskytovat syntaxi pro výběr konstruktoru, který má být zavolán při vytváření instance objektu	Musí poskytovat syntaxi pro definici konstruktorů s různými signaturami. Pokud konstruktor nedodržuje tato pravidla musí dojít k chybě při kompilaci.	Může předpokládat, že vytvoření objektu zahrnuje volání konstruktoru a že žádný objekt není inicializován 2×. `System.Object.MemberwiseClone` a deserializace nepoužívají konstruktory.	21
Volání konstruktoru	Konstruktor nesmí být volán jindy než při inicializaci objektu a objekt nesmí být inicializován dvakrát	Není kontrolováno				22
CLS kompatibilita při dědění	`System.Object` je CLS kompatibilní. CLS kompatibilní typ může dědit jen od CLS kompatibilního typu.	-	-	-	-	23
Getter a setter	Getter a setter vlastnosti musí být označen `specialname`. Musejí dodržovat pojmenovávací konvenci `get_<PropName>` a `set_<PropName>`.	není vyžadováno	Musí ignorovat bit `specialname` při porovnávání jmen a musí dodržovat pravidla pro identifikátory. Žádná další podpora pro vlastnosti není vyžadována. Může vlastnosti nahradit voláním getteru a setteru.	Jako konzument. Nemusí podporovat deklaraci vlastností.	Měl by být designován i pro ty CLS kompatibilní jazyky, které nepoužívají speciální syntaxi pro přístup k vlastnostem.	24
Stejný typ accessorů	Všechny accessory vlastnosti musí být `static`, `virtual` nebo `instance`.	není vyžadováno				26
Typ vlastnosti	Typ vlastnosti musí být stejný jako návratový typ getteru. Typy parametrů vlastnosti musí být stejné jako typy parametrů getteru a až na poslední jako typy parametrů setteru. Typy musí být CLS kompatibilní a nesmí se jednat o managované ukazatele (nesmí být předávány odkazem (VB: `ByRef`)).	není vyžadováno				28
Accessory událostí	Metody, které implementují událost, musí být označeny `specialname`.	není vyžadováno	Musí ignorovat `specialname` při porovnávání jmen. Další podpora pro události není nutná. Mohou se volat jednotlivé accessory	Jako konzument. Nemusí umět definovat události.	Měl by být designován i pro ty CLS kompatibilní jazyky, které nepoužívají speciální syntaxi pro přístup k událostem.	29
Dostupnost accessorů události	Dostupnost accessorů události musí být stejná	není vyžadováno				30
Přítomnost `add` a `remove`	Metody `add` a `remove` musí být buď obě přítomny nebo nepřítomny	není vyžadováno				31
Parametry `add` a `remove`	Obě metody mají jako jediný parametr stejného delegáta	není vyžadováno				32
Jména accessorů události	Accessory událostí musí dodržovat speciální pojmenovávací konvenci (`add_<EventName>,` `remove_<EventName>`, `raise_<EventName>`). Atribut `specialname`, musí být ignorován při porovnávání jmen.	není vyžadováno				33
Typy hodnot atributů	Jen `System.Type`, `System.String`, `System.Char`, `System.Boolean`, `System.Byte`, `System.Int16`, `System.Int32`, `System.Int64`, `System.Single`, `System.Double` a výčty odvozené od CLS kompatibilních typů	Povoluje další (např. neznaménkové) typy	Je schopen číst atributy odpovídající těmto pravidlům	Jako konzument + umí vytvářet nové třídy a atributy a připojovat atributy založené na existujících třídách atributů k libovolným vytvářeným metadatům. Implementuje pravidla pro `System.AttributeUSageAttribute`.	Vystavuje jen CLS kompatibilní atributy, které dodržují `System.AttributeUsageAttribute`.	34
`modreq` a `modopt`	Veřejné `modreq` nejsou povoleny, povoluje veřejné `modopt`, kterým nerozumí.	Povoluje veřejné `modopt` i `modreq`	Čte metadata obsahující volitelné modifikátory a korektně kopíruje signatury, které obsahují. Může tyto modifikátory ignorovat při porovnávání typů a přetěžování. Může ignorovat typy, které zůstanou nejednoznačné při ignorování volitelných modifikátorů a které obsahují povinné modifikátory.	Umí overridovat metody, jejichž signatury obsahují volitelné modifikátory. Musí kopírovat modifikátory z metadat, která importuje. Nemusí podporovat povinné modifikátory a nemusí umět vytvářet metody, které mají jakékoliv modifikátory v signatuře.	Nesmí používat povinné modifikátory ve veřejně viditelných signaturách, pokud nejsou označeny jako CLS nekompatibilní. Nesmí vystavit dva členy, které se liší jen ve volitelných modifikátorech (smí tak učinit v případě, že jen jeden z nich je označen jako CLS kompatibilní).	35
Globální metody a proměnné	Nejsou povoleny	Jsou povoleny	Nemusí podporovat	Nemusí umět vytvářet	Nesmí obsahovat	36
Overloading (přetěžování)	Jen vlastnosti (properties) a metody mohou být přetíženy	vůbec neřeší. přetěžování je záležitostí kompilátoru	Může předpokládat, že jen vlastnosti a metody jsou přetěžovány. Nemusí podporovat přetěžování na základě návratových typů, kromě operátorů přetypování.	Neměl by dovolit vytváření přetížení, které odporují uvedeným pravidlům. Nemusí podporovat přetěžování operátorů.	Nesmí vystavovat přetížení, která neodpovídají uvedeným pravidlům. Autoři by měli mít na paměti, že spousta jazyků nepodporuje přetěžování, přetěžování operátorů ani přetěžování konverzních operátorů.	37
Jak přetěžovat	Jen podle typu a počtu parametrů (s výjimkou `op_Implicit` a `op_Explicit`)	vůbec neřeší. přetěžování je záležitostí kompilátoru				38
Operátory	Unární `op_Decrement` (C++: `--`) Dekrementace `op_Increment` (C++: `++`) Inkrementace `op_UnaryNegation` (C++,VB: `-`) Unární negace `op_UnaryPlus` (C++,VB: `+`) Unární plus `op_LogicalNot` (C++: `!`) Logická negace výrazu `op_True` (VB: `IsTrue`) Má se hodnota interpretovat jako true? `op_False` (VB: `IsFalse`) Má se hodnota interpretovat jako false? `op_AddressOf` (C++: `&`) Refrence `op_OnesComplement` (C++ `~`, VB: `not`) Doplněk, bitová negace `op_PointerDereference` (C++ ``) Dereference ukazatele Binární* `op_Addition` (C++, VB: `+`) Sčítání `op_Subtraction` (C++, VB: `-`) Odčítání `op_Multiply` (C++, VB: ``) Násobení `op_Division` (C++, VB: `/`) Dělení `op_Modulus` (C++: `%`, VB: `Mod`) Zbytek po dělení `op_ExclusiveOr` (C++: `^`, VB: `Xor`) Xor (exkluzivní or) `op_BitwiseAnd` (C++: `&`, VB: `and`) Bitový and `op_BitwiseOr` (C++: `\|`, VB: `Or`) Bitový or `op_LogicalAnd` (C++: `&&`), VB: `AndAlso` Logický and `op_LogicalOr` (C++: `\|\|`, VB: `OrElse`) Logický or `op_Assign` (C++: `=` (není to samé), VB: `=`) Přiřazení `op_LeftShift` (C++, VB: `<<`) Levý posun `op_RightShift` (C++, VB: `>>`) Pravý posun `op_SignedRightShift` Pravý posun se znaménkem `op_UnsignedRightShift` Pravý posun bez znaménka `op_Equality` (C++: `==`, VB: `=`) Porovnání na stejnost `op_GreaterThan` (C++, VB: `>`) Porovnání větší než `op_LessThan` (C++, VB: `<`) Porovnání meněí než `op_Inequality` (C++: `!=`, VB: `<>`) Porovnání na nestejnost `op_GreaterThanOrEqual` (C++, VB: `>=`) Porovnání větší nebo rovno `op_LessThanOrEqual` (C++, VB: `<=`) Porovnání menší nebo rovno `op_UnsignedRightShiftAssignment` Přiřazení neznaménkového pravého posunu `op_MemberSelection` (C++`->`, VB: `.`) Výběr člena `op_RightShifAssignment` (C++, VB: `>>=`) Přiřazení po pravém posunu `op_MultiplicationAssignment` (C++, VB: `=`) Přiřazení po násobení `op_PointerToMemberSelection` (C++: `->`) Ukazatel na vybraného člena `op_SubtractionAssignment` (C++, VB: `-=`) Přiřazení po odčítání `op_ExclusiveOrAssignment` (C++: `^=`) Přiřazení po xoru `op_LeftShiftAssignment` (C++, VB: `<<=`) Přiřazení o levém posunu `op_ModulusAssignment` (C++: `%=`) Přiřazení po zbytku po dělení `op_AditionAssignment` (C++, VB: `+=`) Přiřazení po sčítání `op_BitwiseAndAssignment` (C++: `&=`) Přiřazení po bitovém andu `op_BitwiseOrAssignment` (C++: `\|=`) Přiřazení po bitovém oru `op_Comma` (C++: `,`) Zřetězení výrazů `op_DivisionAssignment` (C++, VB: `/=`) Přiřazení po dělení `op_Concatenate` (VB-specific; není součástí CLS; VB: `&`) Spojení řetězců `op_Exponent`* (VB-specific; není součástí CLS; VB: `^`) Exponent `op_IntegerDivision`* (VB-specific; není součástí CLS; VB: `\`) Celočíslené dělení Konverzní `op_Implicit` (VB: `Widening CType`) Implicitní (rozšiřující) konverze `op_Explicit` (VB: `Narrowing CType`) Explicitní (zužující) konverze	Operátory jsou obyčejné metody	nemusí podporovat	nemusí podporovat
`op_Implicit` vs. `op_Explicit`	Jedná se o různé typy konverze	nezabývá se	Pokud se vůbec podporuje, může je použít k různým způsobům automatického přetypování	Pokud podporuje může je využít k definici metod přetypování na jiný typ / z jiného typu. Měl by poskytovat alternativní metodu přístupu k operátorům - `ToXxx` a `FromXxx`.	Pokud jsou podporovány měly by být dostupné jako `ToXxx` a `FromXxx` a volitelně jako `op_Explicit` a `op_Implicit`.	39
Typ výjimek	Vyhazované (thrown) objekty musí být nebo dědit od System`.Exception`.	není omezeno	Nemusí umět vyhazovat nebo zachytávat výjimky jiných typů	Musí podporovat vyhazování objektů typu `System.Exception` a odděděných. Nemusí podporovat vyhazování ostatních typů.	Nesmí vyhazovat objekty jiného typu než `System.Exception` nebo jeho potomků mimo své hranice.	40
Typ atributů	Atributy musí být typu `System.Attribute` nebo od něj dědit.	není omezeno	Nemusí podporovat atributy jiných typů	Musí podporovat vytváření vlastních atributů	Nesmí veřejně vystavovat atributy jiných typů	41
Vnořený generický typ	Vnořený generický typ musí mít alespoň tolik typových parametrů jako má jeho rodič. Tyto parametry si musí pozičně odpovídat.	není omezeno	Nemusí umět konzumovat typy porušující toto pravidlo	Jako konzument. Pokud bude podporovat typy vnořené v generických typech, musí vyžadovat toto pravidlo pro veřejně dostupné typy.	Nesmí vystavovat typy porušující toto pravidlo.	42
Název generického typu	Název generického typu musí obsahovat počet generických parametrů (za znakem `). Pro vnořené generické typy se jedná o počet parametrů, které mají navíc oproti rodiči.	není vyžadováno	Nemusí konzumovat typy porušující toto pravidlo	Jako konzument. Pokud umí deklarovat generické typy, musí dodržet toto pravidlo.	Nesmí vystavovat typy porušující toto pravidlo	43

CLI Quick reference

.export⁺

.file alignment*

.imagebase*

.language*

.locale*

.namespace*

.stackreserve⁺

.vtentry⁺

Micosoft-specific atributy*

constrained. FE16

no. FE19

readonly. FE1E

tail. FE14

unaligned. FE12

volatile. FE13

add 58

add.ovf D6; add.ovf.un D7

and 5F

arglist FE00

beq 3B; beq.s 2E

bge 3C; bge.s 2F

bge.un 41; bge.un.s 34

bgt 3D; bgt.s 30

bgt.un 42; bgt.un.s 35

ble 3E; ble.s 31

ble.un 43; ble.un.s 36

blt 3F; blt.s 32

blt.un 44; blt.un.s 37

bne.un 40; bne.un.s 33

br 38; br.s 2B

break 01

brfalse 39; brfalse.s 2C; brnull 39; brnull.s 2C; brzero 39; brzero.s 2C

brtrue 3A; brtrue.s 2D; brinst 3A; brinst.s 2D

call 28

calli 29

ceq FE01

cgt FE02

cgt.un FE03

ckfinite C3

clt FE04

clt.un FE05

conv.i1 67; conv.i2 68; conv.i4 69; conv.i8 6A; conv.r4 6B; conv.r8 6C; conv.u1 D2; conv.u2 D1; conv.u4 6D; conv.u8 6E; conv.i D3; conv.u E0; conv.r.un 76

conv.ovf.i1 B3; conv.ovf.i2 B5; conv.ovf.i4 B7; conv.ovf.i8 B9; conv.ovf.u1 B4; conv.ovf.u2 B6; conv.ovf.u4 B8; conv.ovf.u8 BA; conv.ovf.i D4; conv.ovf.u D5;

conv.ovf.i1.un 82; conv.ovf.i2.un 83; conv.ovf.i4.un 84; conv.ovf.i8.un 85; conv.ovf.u1.un 86; conv.ovf.u2.un 87; conv.ovf.u4.un 88; conv.ovf.u8.un 89; conv.ovf.i.un 8A; conv.ovf.u.un 8B;

cpblk FE17

div 5B

div.un 5C

dup 25

endfilter FE11

endfault DC; endfinally DC

initblk FE18

jmp 27

ldarg FE09; ldarg.s 0E; ldarg.0 02; ldarg.1 03; ldarg.2 04; ldarg.3 05;

ldarga FE0A; ldarga.s 0F

ldc.i4 20 ldc.i8 21 ldc.r4 22 ldc.r8 23 ldc.i4.0 16 ldc.i4.1 17 ldc.i4.2 18 ldc.i4.3 19 ldc.i4.4 1A ldc.i4.5 1B ldc.i4.6 1C ldc.i4.7 1D ldc.i4.8 1E ldc.i4.m1 15 ldc.i4.s 1F

ldftn FE06

ldind.i1 46; ldind.i2 48; ldind.i4 4A; ldind.i8 4C; ldind.u1 47; ldind.u2 49; ldind.u4 4B; ldind.r4 4E; ldind.u8 4C; ldind.r8 4F; ldind.i 4D; ldind.ref 50;

ldloc FE0C; ldloc.s 11; ldloc.0 06; ldloc.1 07; ldloc.2 08; ldloc.3 09;

ldloca FE0D; ldloca.s 12

ldnull 14

leave DD; leave.s DE

localloc FE0F

mul 5A

mul.ovf D8; mul.ovf.un D9

neg 65

nop 00

not 66

or 60

pop 26

rem 5D

rem.un 5E

ret 2A

`.export`⁺

`.file alignment`*

`.imagebase`*

`.language`*

`.locale`*

`.namespace`*

`.stackreserve`⁺

`.vtentry`⁺

`constrained.` FE16

`no.` FE19

`readonly.` FE1E

`tail.` FE14

`unaligned.` FE12

`volatile.` FE13

`add` 58

`add.ovf` D6; `add.ovf.un` D7

`and` 5F

`arglist` FE00

`beq` 3B; `beq.s` 2E

`bge` 3C; `bge.s 2F`

`bge.un` 41; `bge.un.s` 34

`bgt` 3D; `bgt.s` 30

`bgt.un` 42; `bgt.un.s` 35

`ble` 3E; `ble.s` 31

`ble.un` 43; `ble.un.s` 36

`blt` 3F; `blt.s` 32

`blt.un` 44; `blt.un.s` 37

`bne.un` 40; `bne.un.s` 33

`br` 38; `br.s` 2B

`break` 01

`brfalse` 39; `brfalse.s` 2C; `brnull` 39; `brnull.s` 2C; `brzero` 39; `brzero.s` 2C

`brtrue` 3A; `brtrue.s` 2D; `brinst` 3A; `brinst.s` 2D

`call` 28

`calli` 29

`ceq` FE01

`cgt` FE02

`cgt.un` FE03

`ckfinite` C3

`clt` FE04

`clt.un` FE05

`conv.i1` 67; `conv.i2` 68; `conv.i4` 69; `conv.i8` 6A; `conv.r4` 6B; `conv.r8` 6C; `conv.u1` D2; `conv.u2` D1; `conv.u4` 6D; `conv.u8` 6E; `conv.i` D3; `conv.u` E0; `conv.r.un` 76

`conv.ovf.i1` B3; `conv.ovf.i2` B5; `conv.ovf.i4` B7; `conv.ovf.i8` B9; `conv.ovf.u1` B4; `conv.ovf.u2` B6; `conv.ovf.u4` B8; `conv.ovf.u8` BA; `conv.ovf.i` D4; `conv.ovf.u` D5;

`conv.ovf.i1.un` 82; `conv.ovf.i2.un` 83; `conv.ovf.i4.un` 84; `conv.ovf.i8.un` 85; `conv.ovf.u1.un` 86; `conv.ovf.u2.un` 87; `conv.ovf.u4.un` 88; `conv.ovf.u8.un` 89; `conv.ovf.i.un` 8A; `conv.ovf.u.un` 8B;

`cpblk` FE17

`div` 5B

`div.un` 5C

`dup` 25

`endfilter` FE11

`endfault` DC; `endfinally` DC

`initblk` FE18

`jmp` 27

`ldarg` FE09; `ldarg.s` 0E; `ldarg.0` 02; `ldarg.1` 03; `ldarg.2` 04; `ldarg.3` 05;

`ldarga` FE0A; `ldarga.s` 0F

`ldc.i4` 20 `ldc.i8` 21 `ldc.r4` 22 `ldc.r8` 23 `ldc.i4.0` 16 `ldc.i4.1` 17 `ldc.i4.2` 18 `ldc.i4.3` 19 `ldc.i4.4` 1A `ldc.i4.5` 1B `ldc.i4.6` 1C `ldc.i4.7` 1D `ldc.i4.8` 1E `ldc.i4.m1` 15 `ldc.i4.s` 1F

`ldftn` FE06

`ldind.i1` 46; `ldind.i2` 48; `ldind.i4` 4A; `ldind.i8` 4C; `ldind.u1` 47; `ldind.u2` 49; `ldind.u4` 4B; `ldind.r4` 4E; `ldind.u8` 4C; `ldind.r8` 4F; `ldind.i` 4D; `ldind.ref` 50;

`ldloc` FE0C; `ldloc.s` 11; `ldloc.0` 06; `ldloc.1` 07; `ldloc.2` 08; `ldloc.3` 09;

`ldloca` FE0D; `ldloca.s` 12

`ldnull` 14

`leave` DD; `leave.s` DE

`localloc` FE0F

`mul` 5A

`mul.ovf` D8; `mul.ovf.un` D9

`neg` 65

`nop` 00

`not` 66

`or` 60

`pop` 26

`rem` 5D

`rem.un` 5E

`ret` 2A