The Common Language Infrastructure Annotated Standard (Microsoft. NET Development Series)

This section contains only informative text.

This Annex shows two complete examples written using ilasm.

ANNOTATION

To illustrate how CIL maps to high-level languages, these examples are annotated with near-equivalent programs in high-level languages. The program in section B.1 was written in Microsoft C#, and the program in section B.2 was written in Visual Basic.

B.1 Mutually Recursive Program (with tail. Calls)

The following is an example of a mutually recursive program that uses tail. calls. The methods below determine whether a number is even or odd.

.assembly extern mscorlib { } .assembly test.exe { } .class EvenOdd { .method private static bool IsEven(int32 N) cil managed { .maxstack 2 ldarg.0 // N ldc.i4.0 bne.un NonZero ldc.i4.1 ret NonZero: ldarg.0 ldc.i4.1 sub tail. call bool EvenOdd::IsOdd(int32) ret } // end of method "EvenOdd::IsEven" .method private static bool IsOdd(int32 N) cil managed { .maxstack 2 // Demonstrates use of argument names and labels // Notice that the assembler does not convert these // automatically to their short versions ldarg N ldc.i4.0 bne.un NonZero ldc.i4.0 ret NonZero: ldarg N ldc.i4.1 sub tail. call bool EvenOdd::IsEven(int32) ret } // end of method "EvenOdd::IsOdd" .method public static void Test(int32 N) cil managed { .maxstack 1 ldarg N call void [mscorlib]System.Console::Write(int32) ldstr " is " call void [mscorlib]System.Console::Write(string) ldarg N call bool EvenOdd::IsEven(int32) brfalse LoadOdd ldstr "even" Print: call void [mscorlib]System.Console::WriteLine(string) ret LoadOdd: ldstr "odd" br Print } // end of method "EvenOdd::Test" } // end of class "EvenOdd" //Global method .method public static void main() cil managed { .entrypoint .maxstack 1 ldc.i4.5 call void EvenOdd::Test(int32) ldc.i4.2 call void EvenOdd::Test(int32) ldc.i4 100 call void EvenOdd::Test(int32) ldc.i4 1000001 call void EvenOdd::Test(int32) ret } // end of global method "main"

ANNOTATION

The following code simulates in C# the operations of the above program, although C# does not generate tail. for the calls, so the program fails on the final line with an out-of-stack exception.

class EvenOdd { private static bool IsEven(int N) { if (N==0) return true; else return IsOdd(N-1); /* Should be tail. call */ } private static bool IsOdd(int N) { if (N==0) return false; else return IsEven(N-1); /* Should be tail. call */ } public static void Test(int N) { System.Console.Write(N); System.Console.Write(" is "); System.Console.WriteLine(EvenOdd.IsEven(N) ? "even" : "odd"); } static void Main(string[] args) { EvenOdd.Test(5); EvenOdd.Test(2); EvenOdd.Test(100); EvenOdd.Test(1000001); } }

B.2 Using Value Types

The following program shows how rational numbers can be implemented using value types.

.assembly extern mscorlib { } .assembly rational.exe { } .class private sealed Rational extends [mscorlib]System.ValueType implements [mscorlib]System.IComparable { .field public int32 Numerator .field public int32 Denominator .method virtual public int32 CompareTo(object o) // Implements IComparable::CompareTo(Object) { ldarg.0 // "this" as a managed pointer ldfld int32 value class Rational::Numerator ldarg.1 // "o" as an object unbox value class Rational ldfld int32 value class Rational::Numerator beq.s TryDenom ldc.i4.0 ret TryDenom: ldarg.0 // "this" as a managed pointer ldfld int32 value class Rational::Denominator ldarg.1 // "o" as an object unbox value class Rational ldfld int32 class Rational::Denominator ceq ret } .method virtual public string ToString() // Implements Object::ToString { .locals init (class [mscorlib]System.Text.StringBuilder SB, string S, object N, object D) newobj void [mscorlib]System.Text.StringBuilder::.ctor() stloc.s SB ldstr "The value is: {0}/{1}" stloc.s S ldarg.0 // managed pointer to self dup ldfld int32 value class Rational::Numerator box [mscorlib]System.Int32 stloc.s N ldfld int32 value class Rational::Denominator box [mscorlib]System.Int32 stloc.s D ldloc.s SB ldloc.s S ldloc.s N ldloc.s D call instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::AppendFormat(string, object, object) callvirt instance string [mscorlib]System.Object::ToString() ret } .method public value class Rational Mul(value class Rational) { .locals init (value class Rational Result) ldloca.s Result dup ldarg.0 // "this" ldfld int32 value class Rational::Numerator ldarga.s 1 // arg ldfld int32 value class Rational::Numerator mul stfld int32 value class Rational::Numerator ldarg.0 // "this" ldfld int32 value class Rational::Denominator ldarga.s 1 // arg ldfld int32 value class Rational::Denominator mul stfld int32 value class Rational::Denominator ldloc.s Result ret } } .method static void main() { .entrypoint .locals init (value class Rational Half, value class Rational Third, value class Rational Temporary, object H, object T) // Initialize Half, Third, H, and T ldloca.s Half dup ldc.i4.1 stfld int32 value class Rational::Numerator ldc.i4.2 stfld int32 value class Rational::Denominator ldloca.s Third dup ldc.i4.1 stfld int32 value class Rational::Numerator ldc.i4.3 stfld int32 value class Rational::Denominator ldloc.s Half box value class Rational stloc.s H ldloc.s Third box value class Rational stloc.s T // WriteLine(H.IComparable::CompareTo(H)) // Call CompareTo via interface using boxed instance ldloc H dup callvirt int32 [mscorlib]System.IComparable::CompareTo(object) call void [mscorlib]System.Console::WriteLine(bool) // WriteLine(Half.CompareTo(T)) // Call CompareTo via value type directly ldloca.s Half ldloc T call instance int32 value class Rational::CompareTo(object) call void [mscorlib]System.Console::WriteLine(bool) // WriteLine(Half.ToString()) // Call virtual method via value type directly ldloca.s Half call instance string class Rational::ToString() call void [mscorlib]System.Console::WriteLine(string) // WriteLine(T.ToString) // Call virtual method inherited from Object, via boxed instance ldloc T callvirt string [mscorlib]System.Object::ToString() call void [mscorlib]System.Console::WriteLine(string) // WriteLine((Half.Mul(T)).ToString()) // Mul is called on two value types, returning a value type // ToString is then called directly on that value type // Note that we are required to introduce a temporary variable // since the call to ToString requires // a managed pointer (address) ldloca.s Half ldloc.s Third call instance value class Rational Rational::Mul(value class Rational) stloc.s Temporary ldloca.s Temporary call instance string Rational::ToString() call void [mscorlib]System.Console::WriteLine(string) ret }

ANNOTATION

An interesting part of this example is its use of boxing and unboxing. In the method CompareTo, the third and fourth instructions are ldarg and unbox. That's because ldarg.1 is the argument o, which is a boxed object. To be able to use the ldfld instruction, you need the value type contained in the boxed object, so you need to call unbox to get a reference to the value type. If what you were passing were not of type Rational, unbox would give you an exception; otherwise it would give you the unboxed value and you could fetch the field out of it. Similarly, after the label TryDenom, there's another unbox, to get the denominator.

Next, in the method ToString, there are two boxed int32s. We have loaded the numerator and denominator fields, which are 32-bit integers, Then we want to store the numerator in the variable N and the denominator in the variable D, which are of type object, so we have to box them.

The next box operations are in main(). We want to take the Rational value Half and store it in H, which is of type object, so it must be boxed. Similarly, the Rational value Third must be boxed to store it in the object type T.

In a high-level language, boxing and unboxing are handled by the compiler, as shown in the following equivalent Visual Basic code:

Option Explicit On Option Strict On Module Module1 Private Structure Rational Implements System.IComparable Public Numerator As Integer Public Denominator As Integer Public Function CompareTo(ByVal o As Object) As Integer _ Implements System.IComparable.CompareTo 'Return 0 if I'm different from o, 1 if we're the same 'Assumes that rationals are stored in a canonical format If Me.Numerator <> CType(o, Rational).Numerator Then Return 0 If Me.Denominator <> CType(o, Rational).Denominator Then Return 0 Return 1 End Function Public Overrides Function ToString() As String Dim SB As New System.Text.StringBuilder, S As String, N As Object, D As Object S = "The value is: {0}/{1}" N = Me.Numerator D = Me.Denominator SB.AppendFormat(S, N, D) Return SB.ToString() End Function Public Function Mul(ByVal R As Rational) As Rational 'Multiplies two rationals, but does NOT put into canonical form Dim Result As Rational Result.Numerator = Me.Numerator * R.Numerator Result.Denominator = Me.Denominator * R.Denominator Return Result End Function End Structure Sub Main() Dim Half As Rational, Third As Rational, Temporary As Rational Dim H As Object, T As Object Half.Numerator = 1 Half.Denominator = 2 Third.Numerator = 1 Third.Denominator = 3 H = Half T = Third System.Console.WriteLine(CBool(CType(H, Rational) .CompareTo(H))) System.Console.WriteLine(CBool(Half.CompareTo(T))) System.Console.WriteLine(Half.ToString()) System.Console.WriteLine(T.ToString()) Temporary = Half.Mul(Third) System.Console.WriteLine(Temporary.ToString()) End Sub End Module

Related

Категории