mcs/ilasm/codegen/Method.cs

   1 // Method.cs
   2 // (C) Sergey Chaban (serge@wildwestsoftware.com)
   3
   4 using System;
   5 using System.Collections;
   6 using System.Reflection;
   7 using System.Reflection.Emit;
   8
   9 namespace Mono.ILASM {
  10
  11
  12         public class MethodName {
  13                 private static int methodCount = 0;
  14
  15                 private bool isCtor;
  16                 private string name;
  17
  18                 /// <summary>
  19                 /// </summary>
  20                 public MethodName () : this ("M_" + (methodCount++))
  21                 {
  22                 }
  23
  24                 /// <summary>
  25                 /// </summary>
  26                 /// <param name="name"></param>
  27                 public MethodName (string name) : this (name, false)
  28                 {
  29                 }
  30
  31                 /// <summary>
  32                 /// </summary>
  33                 /// <param name="name"></param>
  34                 /// <param name="ctor"></param>
  35                 public MethodName (string name, bool ctor)
  36                 {
  37                         this.name = name;
  38                         this.isCtor = ctor;
  39                 }
  40
  41
  42                 /// <summary>
  43                 /// </summary>
  44                 public string Name {
  45                         get {
  46                                 return name;
  47                         }
  48                         set {
  49                                 name = value;
  50                         }
  51                 }
  52
  53
  54                 /// <summary>
  55                 /// </summary>
  56                 public bool IsCtor {
  57                         get {
  58                                 return isCtor;
  59                         }
  60                         set {
  61                                 isCtor = value;
  62                         }
  63                 }
  64
  65         }
  66
  67
  68
  69         /// <summary>
  70         /// </summary>
  71         public class Method {
  72
  73                 private MethodName name;
  74                 private MethodAttributes attrs;
  75                 private CallingConventions callConv;
  76                 private string retType;
  77                 private MethodBuilder method_builder;
  78                 private bool entry_point = false;
  79
  80                 private ArrayList param_list;
  81                 private ArrayList instructions;
  82                 private ArrayList local_list;
  83
  84                 /// <summary>
  85                 /// </summary>
  86                 public Method ()
  87                 {
  88                         name = new MethodName ();
  89                         attrs = 0;
  90                 }
  91
  92
  93                 /// <summary>
  94                 /// </summary>
  95                 public string Name {
  96                         get {
  97                                 return name.Name;
  98                         }
  99                         set {
 100                                 name.Name = value;
 101                         }
 102                 }
 103
 104
 105                 /// <summary>
 106                 /// </summary>
 107                 /// <param name="name"></param>
 108                 public void SetMethodName (MethodName name)
 109                 {
 110                         this.name = name;
 111                 }
 112
 113
 114                 /// <summary>
 115                 /// </summary>
 116                 public bool IsCtor {
 117                         get {
 118                                 return name.IsCtor;
 119                         }
 120                         set {
 121                                 name.IsCtor = value;
 122                         }
 123                 }
 124
 125
 126                 /// <summary>
 127                 /// </summary>
 128                 public string RetType {
 129                         get {
 130                                 return retType;
 131                         }
 132                         set {
 133                                 retType = value;
 134                         }
 135                 }
 136
 137
 138                 /// <summary>
 139                 /// </summary>
 140                 public MethodAttributes Attrs {
 141                         get {
 142                                 return attrs;
 143                         }
 144                         set {
 145                                 attrs = value;
 146                         }
 147                 }
 148
 149
 150                 /// <summary>
 151                 /// </summary>
 152                 public CallingConventions CallConv {
 153                         get {
 154                                 return callConv;
 155                         }
 156                         set {
 157                                 callConv = value;
 158                         }
 159                 }
 160
 161
 162                 /// <summary>
 163                 /// </summary>
 164                 public bool IsEntryPoint {
 165                         get {
 166                                 return entry_point;
 167                         }
 168                         set {
 169                                 entry_point = value;
 170                         }
 171                 }
 172
 173                 /// <summary>
 174                 /// </summary>
 175                 /// <param name="instr"></param>
 176                 public void AddInstruction (InstrBase instr)
 177                 {
 178                         if (instr == null) {
 179                                 throw new System.ArgumentNullException ("instr", "<null> instruction");
 180                         }
 181
 182                         if (instructions == null) {
 183                                 this.instructions = new ArrayList ();
 184                         }
 185
 186                         instructions.Add (instr);
 187                 }
 188
 189                 public void AddLocal (DictionaryEntry local)
 190                 {
 191                         if (local_list == null)
 192                                 local_list = new ArrayList ();
 193
 194                         local_list.Add (local);
 195
 196                 }
 197
 198                 public void SetParamList (ArrayList param_list)
 199                 {
 200                         this.param_list = param_list;
 201                 }
 202
 203                 /// <summary>
 204                 /// </summary>
 205                 public int InstrCount {
 206                         get {
 207                                 return (instructions != null) ? instructions.Count : 0;
 208                         }
 209                 }
 210
 211                 /// <summary>
 212                 /// </summary>
 213                 /// <returns></returns>
 214                 public override string ToString ()
 215                 {
 216                         return String.Format ("IL.Method [Name: {0}, Attrs: {1}, CallConv: {2}, RetType: {3}, Instr: {4}]",
 217                                               Name, Attrs, CallConv, RetType, InstrCount);
 218                 }
 219
 220                 public MethodBuilder Builder {
 221                         get {
 222                                 return method_builder;
 223                         }
 224                 }
 225
 226                 public void Resolve (Class host)
 227                 {
 228                         Type return_type = host.CodeGen.TypeManager[RetType];
 229                         method_builder = host.TypeBuilder.DefineMethod (Name, Attrs,
 230                                 CallConv, return_type, CreateTypeList (host.CodeGen.TypeManager));
 231                 }
 232
 233                 /// <summary>
 234                 /// </summary>
 235                 /// <param name="tb"></param>
 236                 public void Emit (Class host)
 237                 {
 238                         TypeBuilder tb = host.TypeBuilder;
 239
 240                         if (IsCtor) {
 241                         } else {
 242                                 ILGenerator ilgen = method_builder.GetILGenerator ();
 243
 244                                 if (local_list != null) {
 245                                         foreach (DictionaryEntry local in local_list) {
 246                                                 Type local_type = host.CodeGen.TypeManager[(string)local.Key];
 247                                                 if (local_type == null) {
 248                                                         Console.WriteLine ("Could not find type: {0}", local.Key);
 249                                                         return;
 250                                                 }
 251                                                 ilgen.DeclareLocal (local_type);
 252                                         }
 253                                 }
 254
 255                                 if (instructions != null) {
 256                                         foreach (InstrBase instr in instructions)
 257                                                 instr.Emit (ilgen, host);
 258                                 }
 259                         }
 260                 }
 261
 262                 private Type[] CreateTypeList (TypeManager type_manager)
 263                 {
 264                         if (param_list == null)
 265                                 return new Type[0];
 266
 267                         int count = param_list.Count;
 268                         Type[] type_list = new Type[count];
 269
 270                         for (int i=0; i<count; i++) {
 271                                 type_list[i] = type_manager[(string) param_list[i]];
 272                         }
 273
 274                         return type_list;
 275                 }
 276
 277         }
 278
 279
 280 }