libjava/classpath/tools/gnu/classpath/tools/giop/grmic/MethodGenerator.java

   1 /* MethodGenerator.java -- Generates methods for GIOP rmic compiler.
   2    Copyright (C) 2006 Free Software Foundation
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20 */
  21
  22 package gnu.classpath.tools.giop.grmic;
  23
  24 import gnu.classpath.tools.AbstractMethodGenerator;
  25
  26 import java.lang.reflect.Method;
  27 import java.util.Properties;
  28
  29 /**
  30  * Keeps information about the single method and generates the code fragments,
  31  * related to that method.
  32  *
  33  * @author Audrius Meskauskas, Lithuania (audriusa@Bioinformatics.org)
  34  */
  35 public class MethodGenerator implements AbstractMethodGenerator
  36 {
  37   /**
  38    * The method being defined.
  39    */
  40   Method method;
  41
  42   /**
  43    * The parent code generator.
  44    */
  45   GiopRmicCompiler rmic;
  46
  47   /**
  48    * The previous method in the list, null for the first element.
  49    * Used to avoid repretetive inclusion of the same hash code label.
  50    */
  51   MethodGenerator previous = null;
  52
  53   /**
  54    * The hash character position.
  55    */
  56   int hashCharPosition;
  57
  58   /**
  59    * Create the new method generator for the given method.
  60    *
  61    * @param aMethod
  62    *          the related method.
  63    * @param aRmic
  64    *          the Rmic generator instance, where more class - related
  65    *          information is defined.
  66    */
  67   public MethodGenerator(Method aMethod, GiopRmicCompiler aRmic)
  68   {
  69     method = aMethod;
  70     rmic = aRmic;
  71   }
  72
  73   /**
  74    * Get the method name.
  75    *
  76    * @return the name of the method.
  77    */
  78   public String getGiopMethodName()
  79   {
  80     String m = method.getName();
  81     if (m.startsWith("get"))
  82       return "_get_J" + m.substring("get".length());
  83     else if (m.startsWith("set"))
  84       return "_set_J" + m.substring("set".length());
  85     else
  86       return m;
  87   }
  88
  89   /**
  90    * Get the method parameter declaration.
  91    *
  92    * @return the string - method parameter declaration.
  93    */
  94   public String getArgumentList()
  95   {
  96     StringBuffer b = new StringBuffer();
  97
  98     Class[] args = method.getParameterTypes();
  99
 100     for (int i = 0; i < args.length; i++)
 101       {
 102         b.append(rmic.name(args[i]));
 103         b.append(" p" + i);
 104         if (i < args.length - 1)
 105           b.append(", ");
 106       }
 107     return b.toString();
 108   }
 109
 110   /**
 111    * Get the method parameter list only (no type declarations). This is used to
 112    * generate the method invocations statement.
 113    *
 114    * @return the string - method parameter list.
 115    */
 116   public String getArgumentNames()
 117   {
 118     StringBuffer b = new StringBuffer();
 119
 120     Class[] args = method.getParameterTypes();
 121
 122     for (int i = 0; i < args.length; i++)
 123       {
 124         b.append(" p" + i);
 125         if (i < args.length - 1)
 126           b.append(", ");
 127       }
 128     return b.toString();
 129   }
 130
 131   /**
 132    * Get the list of exceptions, thrown by this method.
 133    *
 134    * @return the list of exceptions.
 135    */
 136   public String getThrows()
 137   {
 138     StringBuffer b = new StringBuffer();
 139
 140     Class[] args = method.getExceptionTypes();
 141
 142     for (int i = 0; i < args.length; i++)
 143       {
 144         b.append(rmic.name(args[i]));
 145         if (i < args.length - 1)
 146           b.append(", ");
 147       }
 148     return b.toString();
 149   }
 150
 151   /**
 152    * Generate this method for the Stub class.
 153    *
 154    * @return the method body for the stub class.
 155    */
 156   public String generateStubMethod()
 157   {
 158     String templateName;
 159
 160     Properties vars = new Properties(rmic.vars);
 161     vars.put("#return_type", rmic.name(method.getReturnType()));
 162     vars.put("#method_name", method.getName());
 163     vars.put("#giop_method_name", getGiopMethodName());
 164     vars.put("#argument_list", getArgumentList());
 165     vars.put("#argument_names", getArgumentNames());
 166
 167     vars.put("#argument_write", getStubParaWriteStatement());
 168
 169     if (method.getReturnType().equals(void.class))
 170       vars.put("#read_return", "return;");
 171     else
 172       vars.put("#read_return",
 173                "return "
 174                    + GiopIo.getReadStatement(method.getReturnType(), rmic));
 175     String thr = getThrows();
 176     if (thr.length() > 0)
 177       vars.put("#throws", "\n    throws " + thr);
 178     else
 179       vars.put("#throws", "");
 180
 181     if (method.getReturnType().equals(void.class))
 182       templateName = "StubMethodVoid.jav";
 183     else
 184       {
 185         vars.put("#write_result",
 186                  GiopIo.getWriteStatement(method.getReturnType(), "result",
 187                                           rmic));
 188         templateName = "StubMethod.jav";
 189       }
 190
 191     String template = rmic.getResource(templateName);
 192     String generated = rmic.replaceAll(template, vars);
 193     return generated;
 194   }
 195
 196   /**
 197    * Generate this method handling fragment for the Tie class.
 198    *
 199    * @return the fragment to handle this method for the Tie class.
 200    */
 201   public String generateTieMethod()
 202   {
 203     String templateName;
 204
 205     Properties vars = new Properties(rmic.vars);
 206     vars.put("#return_type", rmic.name(method.getReturnType()));
 207     vars.put("#method_name", method.getName());
 208     vars.put("#giop_method_name", getGiopMethodName());
 209     vars.put("#argument_list", getArgumentList());
 210     vars.put("#argument_names", getArgumentNames());
 211
 212     vars.put("#argument_write", getStubParaWriteStatement());
 213
 214     if (previous == null || previous.getHashChar()!=getHashChar())
 215       vars.put("#hashCodeLabel","    case '"+getHashChar()+"':");
 216     else
 217       vars.put("#hashCodeLabel","    // also '"+getHashChar()+"':");
 218
 219     if (method.getReturnType().equals(void.class))
 220       templateName = "TieMethodVoid.jav";
 221     else
 222       {
 223         vars.put("#write_result",
 224                  GiopIo.getWriteStatement(method.getReturnType(), "result",
 225                                           rmic));
 226         templateName = "TieMethod.jav";
 227       }
 228     vars.put("#read_and_define_args", getRda());
 229
 230     String template = rmic.getResource(templateName);
 231     String generated = rmic.replaceAll(template, vars);
 232     return generated;
 233   }
 234
 235   /**
 236    * Generate sentences for Reading and Defining Arguments.
 237    *
 238    * @return the sequence of sentences for reading and defining arguments.
 239    */
 240   public String getRda()
 241   {
 242     StringBuffer b = new StringBuffer();
 243     Class[] args = method.getParameterTypes();
 244
 245     for (int i = 0; i < args.length; i++)
 246       {
 247         b.append("                ");
 248         b.append(rmic.name(args[i]));
 249         b.append(" ");
 250         b.append("p"+i);
 251         b.append(" = ");
 252         b.append(GiopIo.getReadStatement(args[i], rmic));
 253         if (i<args.length-1)
 254           b.append("\n");
 255       }
 256     return b.toString();
 257   }
 258
 259   /**
 260    * Get the write statement for writing parameters inside the stub.
 261    *
 262    * @return the write statement.
 263    */
 264   public String getStubParaWriteStatement()
 265   {
 266     StringBuffer b = new StringBuffer();
 267     Class[] args = method.getParameterTypes();
 268
 269     for (int i = 0; i < args.length; i++)
 270       {
 271         b.append("             ");
 272         b.append(GiopIo.getWriteStatement(args[i], "p" + i, rmic));
 273         b.append("\n");
 274       }
 275     return b.toString();
 276   }
 277
 278   /**
 279    * Get the hash char.
 280    */
 281   public char getHashChar()
 282   {
 283     return getGiopMethodName().charAt(hashCharPosition);
 284   }
 285 }