src/Boo.Lang.Compiler/Steps/TransformCallableDefinitions.cs

   1 #region license
   2 // Copyright (c) 2004, Rodrigo B. de Oliveira (rbo@acm.org)
   3 // All rights reserved.
   4 //
   5 // Redistribution and use in source and binary forms, with or without modification,
   6 // are permitted provided that the following conditions are met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright notice,
   9 //     this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above copyright notice,
  11 //     this list of conditions and the following disclaimer in the documentation
  12 //     and/or other materials provided with the distribution.
  13 //     * Neither the name of Rodrigo B. de Oliveira nor the names of its
  14 //     contributors may be used to endorse or promote products derived from this
  15 //     software without specific prior written permission.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  18 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  21 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  24 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  25 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27 #endregion
  28
  29 namespace Boo.Lang.Compiler.Steps
  30 {
  31         using System;
  32         using Boo.Lang.Compiler.Ast;
  33
  34         public class TransformCallableDefinitions : AbstractTransformerCompilerStep
  35         {
  36                 override public void Run()
  37                 {
  38                         Visit(CompileUnit);
  39                 }
  40
  41                 override public void OnMethod(Method node)
  42                 {
  43                 }
  44
  45                 override public void OnClassDefinition(ClassDefinition node)
  46                 {
  47                         Visit(node.Members);
  48                 }
  49
  50                 override public void OnCallableDefinition(CallableDefinition node)
  51                 {
  52                         if (null == node.ReturnType)
  53                         {
  54                                 node.ReturnType = CodeBuilder.CreateTypeReference(TypeSystemServices.VoidType);
  55                         }
  56
  57                         CompleteOmittedParameterType(node);
  58
  59                         ClassDefinition cd = TypeSystemServices.CreateCallableDefinition(node.Name);
  60                         cd.LexicalInfo = node.LexicalInfo;
  61                         cd.GenericParameters = node.GenericParameters;
  62
  63                         cd.Members.Add(CreateInvokeMethod(node));
  64                         cd.Members.Add(CreateBeginInvokeMethod(node));
  65                         cd.Members.Add(CreateEndInvokeMethod(node));
  66
  67                         ReplaceCurrentNode(cd);
  68                 }
  69
  70                 private void CompleteOmittedParameterType(CallableDefinition node)
  71                 {
  72                         ParameterDeclarationCollection parameters = node.Parameters;
  73                         if (0 == parameters.Count) return;
  74
  75                         ParameterDeclaration last = parameters[-1];
  76                         foreach (ParameterDeclaration parameter in parameters)
  77                         {
  78                                 if (null == parameter.Type)
  79                                 {
  80                                         if (parameters.VariableNumber && last == parameter)
  81                                         {
  82                                                 parameter.Type = CodeBuilder.CreateTypeReference(TypeSystemServices.ObjectArrayType);
  83                                         }
  84                                         else
  85                                         {
  86                                                 parameter.Type = CodeBuilder.CreateTypeReference(TypeSystemServices.ObjectType);
  87                                         }
  88                                 }
  89                         }
  90                 }
  91
  92                 Method CreateInvokeMethod(CallableDefinition node)
  93                 {
  94                         Method method = CreateRuntimeMethod("Invoke", node.ReturnType);
  95                         method.Parameters = node.Parameters;
  96                         return method;
  97                 }
  98
  99                 Method CreateBeginInvokeMethod(CallableDefinition node)
 100                 {
 101                         Method method = CreateRuntimeMethod("BeginInvoke",
 102                                                 CodeBuilder.CreateTypeReference(node.LexicalInfo, typeof(IAsyncResult)));
 103                         method.Parameters.ExtendWithClones(node.Parameters);
 104                         method.Parameters.Add(
 105                                 new ParameterDeclaration("callback",
 106                                         CodeBuilder.CreateTypeReference(node.LexicalInfo, typeof(AsyncCallback))));
 107                         method.Parameters.Add(
 108                                 new ParameterDeclaration("asyncState",
 109                                         CodeBuilder.CreateTypeReference(node.LexicalInfo, TypeSystemServices.ObjectType)));
 110                         return method;
 111                 }
 112
 113                 Method CreateEndInvokeMethod(CallableDefinition node)
 114                 {
 115                         Method method = CreateRuntimeMethod("EndInvoke", node.ReturnType);
 116
 117                         foreach(ParameterDeclaration p in node.Parameters)
 118                         {
 119                                 if (p.IsByRef)
 120                                 {
 121                                         method.Parameters.Add(p.CloneNode());
 122                                 }
 123                         }
 124
 125                         method.Parameters.Add(
 126                                 new ParameterDeclaration("asyncResult",
 127                                         CodeBuilder.CreateTypeReference(node.LexicalInfo, typeof(IAsyncResult))));
 128                         return method;
 129                 }
 130
 131                 Method CreateRuntimeMethod(string name, TypeReference returnType)
 132                 {
 133                         Method method = new Method();
 134                         method.Name = name;
 135                         method.ReturnType = returnType;
 136                         method.Modifiers = TypeMemberModifiers.Public|TypeMemberModifiers.Virtual;
 137                         method.ImplementationFlags = MethodImplementationFlags.Runtime;
 138                         return method;
 139                 }
 140         }
 141 }