mcs/class/referencesource/mscorlib/system/reflection/methodbody.cs

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6 // <OWNER>[....]</OWNER>
   7 //
   8
   9 using System;
  10 using System.Globalization;
  11 using System.Collections.Generic;
  12 using System.Diagnostics.Contracts;
  13
  14 namespace System.Reflection
  15 {
  16     [Flags()]
  17     [System.Runtime.InteropServices.ComVisible(true)]
  18     public enum ExceptionHandlingClauseOptions: int
  19     {
  20         Clause = 0x0,
  21         Filter = 0x1,
  22         Finally = 0x2,
  23         Fault = 0x4,
  24     }
  25 #if !MONO
  26     [System.Runtime.InteropServices.ComVisible(true)]
  27     public class ExceptionHandlingClause
  28     {
  29         #region costructor
  30         // This class can only be created from inside the EE.
  31         protected ExceptionHandlingClause() { }
  32         #endregion
  33
  34         #region Private Data Members
  35         private MethodBody m_methodBody;
  36         [ContractPublicPropertyName("Flags")]
  37         private ExceptionHandlingClauseOptions m_flags;
  38         private int m_tryOffset;
  39         private int m_tryLength;
  40         private int m_handlerOffset;
  41         private int m_handlerLength;
  42         private int m_catchMetadataToken;
  43         private int m_filterOffset;
  44         #endregion
  45
  46         #region Public Members
  47         public virtual ExceptionHandlingClauseOptions Flags { get { return m_flags; } }
  48         public virtual int TryOffset { get { return m_tryOffset; } }
  49         public virtual int TryLength { get { return m_tryLength; } }
  50         public virtual int HandlerOffset { get { return m_handlerOffset; } }
  51         public virtual int HandlerLength { get { return m_handlerLength; } }
  52
  53         public virtual int FilterOffset
  54         {
  55             get
  56             {
  57                 if (m_flags != ExceptionHandlingClauseOptions.Filter)
  58                     throw new InvalidOperationException(Environment.GetResourceString("Arg_EHClauseNotFilter"));
  59
  60                 return m_filterOffset;
  61             }
  62         }
  63
  64         public virtual Type CatchType
  65         {
  66             get
  67             {
  68                 if (m_flags != ExceptionHandlingClauseOptions.Clause)
  69                     throw new InvalidOperationException(Environment.GetResourceString("Arg_EHClauseNotClause"));
  70
  71                 Type type = null;
  72
  73                 if (!MetadataToken.IsNullToken(m_catchMetadataToken))
  74                 {
  75                     Type declaringType = m_methodBody.m_methodBase.DeclaringType;
  76                     Module module = (declaringType == null) ? m_methodBody.m_methodBase.Module : declaringType.Module;
  77                     type = module.ResolveType(m_catchMetadataToken, (declaringType == null) ? null : declaringType.GetGenericArguments(),
  78                         m_methodBody.m_methodBase is MethodInfo ? m_methodBody.m_methodBase.GetGenericArguments() : null);
  79                 }
  80
  81                 return type;
  82             }
  83         }
  84         #endregion
  85
  86         #region Object Overrides
  87         public override string ToString()
  88         {
  89             if (Flags == ExceptionHandlingClauseOptions.Clause)
  90             {
  91                 return String.Format(CultureInfo.CurrentUICulture,
  92                     "Flags={0}, TryOffset={1}, TryLength={2}, HandlerOffset={3}, HandlerLength={4}, CatchType={5}",
  93                     Flags, TryOffset, TryLength, HandlerOffset, HandlerLength, CatchType);
  94             }
  95
  96             if (Flags == ExceptionHandlingClauseOptions.Filter)
  97             {
  98                 return String.Format(CultureInfo.CurrentUICulture,
  99                     "Flags={0}, TryOffset={1}, TryLength={2}, HandlerOffset={3}, HandlerLength={4}, FilterOffset={5}",
 100                     Flags, TryOffset, TryLength, HandlerOffset, HandlerLength, FilterOffset);
 101             }
 102
 103             return String.Format(CultureInfo.CurrentUICulture,
 104                 "Flags={0}, TryOffset={1}, TryLength={2}, HandlerOffset={3}, HandlerLength={4}",
 105                 Flags, TryOffset, TryLength, HandlerOffset, HandlerLength);
 106
 107         }
 108         #endregion
 109     }
 110
 111     [System.Runtime.InteropServices.ComVisible(true)]
 112     public class MethodBody
 113     {
 114         #region costructor
 115         // This class can only be created from inside the EE.
 116         protected MethodBody() { }
 117         #endregion
 118
 119         #region Private Data Members
 120         private byte[] m_IL;
 121         private ExceptionHandlingClause[] m_exceptionHandlingClauses;
 122         private LocalVariableInfo[] m_localVariables;
 123         internal MethodBase m_methodBase;
 124         private int m_localSignatureMetadataToken;
 125         private int m_maxStackSize;
 126         private bool m_initLocals;
 127         #endregion
 128
 129         #region Public Members
 130         public virtual int LocalSignatureMetadataToken { get { return m_localSignatureMetadataToken; } }
 131         public virtual IList<LocalVariableInfo> LocalVariables { get { return Array.AsReadOnly(m_localVariables); } }
 132         public virtual int MaxStackSize { get { return m_maxStackSize; } }
 133         public virtual bool InitLocals { get { return m_initLocals; } }
 134         public virtual byte[] GetILAsByteArray() { return m_IL; }
 135         public virtual IList<ExceptionHandlingClause> ExceptionHandlingClauses { get { return Array.AsReadOnly(m_exceptionHandlingClauses); } }
 136         #endregion
 137     }
 138
 139     [System.Runtime.InteropServices.ComVisible(true)]
 140     public class LocalVariableInfo
 141     {
 142         #region Private Data Members
 143         private RuntimeType m_type;
 144         private int m_isPinned;
 145         private int m_localIndex;
 146         #endregion
 147
 148         #region Constructor
 149         protected LocalVariableInfo() { }
 150         #endregion
 151
 152         #region Object Overrides
 153         public override string ToString()
 154         {
 155             string toString = LocalType.ToString() + " (" + LocalIndex + ")";
 156
 157             if (IsPinned)
 158                 toString += " (pinned)";
 159
 160             return toString;
 161         }
 162         #endregion
 163
 164         #region Public Members
 165         public virtual Type LocalType { get { Contract.Assert(m_type != null, "type must be set!"); return m_type; } }
 166         public virtual bool IsPinned { get { return m_isPinned != 0; } }
 167         public virtual int LocalIndex { get { return m_localIndex; } }
 168         #endregion
 169     }
 170 #endif
 171 }
 172