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

   1 /* GiopRmicCompiler -- Central GIOP-based RMI stub and tie compiler class.
   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.rmi.Remote;
  28 import java.rmi.RemoteException;
  29 import java.util.ArrayList;
  30 import java.util.Collection;
  31 import java.util.Collections;
  32 import java.util.Comparator;
  33 import java.util.HashSet;
  34 import java.util.Iterator;
  35 import java.util.Properties;
  36 import java.util.TreeSet;
  37
  38 /**
  39  * Provides the extended rmic functionality to generate the POA - based classes
  40  * for GIOP (javax.rmi.CORBA package).
  41  *
  42  * @author Audrius Meskauskas, Lithuania (audriusa@Bioinformatics.org)
  43  */
  44 public class GiopRmicCompiler
  45     extends Generator implements Comparator
  46 {
  47   /** The package name. */
  48   protected String packag;
  49
  50   /**
  51    * The "basic" name (normally, the interface name, unless several Remote -
  52    * derived interfaces are implemented.
  53    */
  54   protected String name;
  55
  56   /**
  57    * The name (without package) of the class, passed as the parameter.
  58    */
  59   protected String implName;
  60
  61   /**
  62    * The proposed name for the stub.
  63    */
  64   protected String stubName;
  65
  66   /**
  67    * The Remote's, implemented by this class.
  68    */
  69   protected Collection implementedRemotes = new HashSet();
  70
  71   /**
  72    * The extra classes that must be imported.
  73    */
  74   protected Collection extraImports = new HashSet();
  75
  76   /**
  77    * The methods we must implement.
  78    */
  79   protected Collection methods = new HashSet();
  80
  81   /**
  82    * The map of all code generator variables.
  83    */
  84   public Properties vars = new Properties();
  85
  86   /**
  87    * If this flag is set (true by default), the compiler generates the Servant
  88    * based classes. If set to false, the compiler generates the old style
  89    * ObjectImpl based classes.
  90    */
  91   protected boolean poaMode = true;
  92
  93   /**
  94    * If this flag is set (true by default), the compiler emits warnings.
  95    */
  96   protected boolean warnings = true;
  97
  98   /**
  99    * Verbose output
 100    */
 101   protected boolean verbose = false;
 102
 103   /**
 104    * Force mode - do not check the exceptions
 105    */
 106   protected boolean force = false;
 107
 108   /**
 109    * Clear data, preparing for the next compilation.
 110    */
 111   public void reset()
 112   {
 113     packag = name = implName = stubName = null;
 114     implementedRemotes.clear();
 115     extraImports.clear();
 116     methods.clear();
 117     vars.clear();
 118   }
 119
 120   /**
 121    * Compile the given class (the instance of Remote), generating the stub and
 122    * tie for it.
 123    *
 124    * @param remote
 125    *          the class to compile.
 126    */
 127   public synchronized void compile(Class remote)
 128   {
 129     reset();
 130     String s;
 131
 132     // Get the package.
 133     s = remote.getName();
 134     int p = s.lastIndexOf('.');
 135     if (p < 0)
 136       {
 137         // Root package.
 138         packag = "";
 139         implName = name = s;
 140       }
 141     else
 142       {
 143         packag = s.substring(0, p);
 144         implName = name = s.substring(p + 1);
 145       }
 146
 147     name = convertStubName(name);
 148
 149     stubName = name;
 150
 151     vars.put("#name", name);
 152     vars.put("#package", packag);
 153     vars.put("#implName", implName);
 154
 155     if (verbose)
 156       System.out.println("Package " + packag + ", name " + name + " impl "
 157                          + implName);
 158
 159     // Get the implemented remotes.
 160     Class[] interfaces = remote.getInterfaces();
 161
 162     for (int i = 0; i < interfaces.length; i++)
 163       {
 164         if (Remote.class.isAssignableFrom(interfaces[i]))
 165           {
 166             if (! interfaces[i].equals(Remote.class))
 167               {
 168                 implementedRemotes.add(interfaces[i]);
 169               }
 170           }
 171       }
 172
 173     vars.put("#idList", getIdList(implementedRemotes));
 174
 175     // Collect and process methods.
 176     Iterator iter = implementedRemotes.iterator();
 177
 178     while (iter.hasNext())
 179       {
 180         Class c = (Class) iter.next();
 181         Method[] m = c.getMethods();
 182
 183         // Check if throws RemoteException.
 184         for (int i = 0; i < m.length; i++)
 185           {
 186             Class[] exc = m[i].getExceptionTypes();
 187             boolean remEx = false;
 188
 189             for (int j = 0; j < exc.length; j++)
 190               {
 191                 if (RemoteException.class.isAssignableFrom(exc[j]))
 192                   {
 193                     remEx = true;
 194                     break;
 195                   }
 196                 if (! remEx && !force)
 197                   throw new CompilationError(m[i].getName() + ", defined in "
 198                                              + c.getName()
 199                                              + ", does not throw "
 200                                              + RemoteException.class.getName());
 201               }
 202             AbstractMethodGenerator mm = createMethodGenerator(m[i]);
 203             methods.add(mm);
 204           }
 205       }
 206   }
 207
 208   /**
 209    * Create the method generator for the given method.
 210    *
 211    * @param m the method
 212    *
 213    * @return the created method generator
 214    */
 215   protected AbstractMethodGenerator createMethodGenerator(Method m)
 216   {
 217     return new MethodGenerator(m, this);
 218   }
 219
 220   /**
 221    * Get the name of the given class. The class is added to imports, if not
 222    * already present and not from java.lang and not from the current package.
 223    *
 224    * @param nameIt
 225    *          the class to name
 226    * @return the name of class as it should appear in java language
 227    */
 228   public String name(Class nameIt)
 229   {
 230     if (nameIt.isArray())
 231       {
 232         // Mesure dimensions:
 233         int dimension = 0;
 234         Class finalComponent = nameIt;
 235         while (finalComponent.isArray())
 236           {
 237             finalComponent = finalComponent.getComponentType();
 238             dimension++;
 239           }
 240
 241         StringBuffer brackets = new StringBuffer();
 242
 243         for (int i = 0; i < dimension; i++)
 244           {
 245             brackets.append("[]");
 246           }
 247
 248         return name(finalComponent) + " " + brackets;
 249       }
 250     else
 251       {
 252         String n = nameIt.getName();
 253         if (! nameIt.isArray() && ! nameIt.isPrimitive())
 254           if (! n.startsWith("java.lang")
 255               && ! (packag != null && n.startsWith(packag)))
 256             extraImports.add(n);
 257
 258         int p = n.lastIndexOf('.');
 259         if (p < 0)
 260           return n;
 261         else
 262           return n.substring(p + 1);
 263       }
 264   }
 265
 266   /**
 267    * Get the RMI-style repository Id for the given class.
 268    *
 269    * @param c
 270    *          the interface, for that the repository Id must be created.
 271    * @return the repository id
 272    */
 273   public String getId(Class c)
 274   {
 275     return "RMI:" + c.getName() + ":0000000000000000";
 276   }
 277
 278   /**
 279    * Get repository Id string array declaration.
 280    *
 281    * @param remotes
 282    *          the collection of interfaces
 283    * @return the fully formatted string array.
 284    */
 285   public String getIdList(Collection remotes)
 286   {
 287     StringBuffer b = new StringBuffer();
 288
 289     // Keep the Ids sorted, ensuring, that the same order will be preserved
 290     // between compilations.
 291     TreeSet sortedIds = new TreeSet();
 292
 293     Iterator iter = remotes.iterator();
 294     while (iter.hasNext())
 295       {
 296         sortedIds.add(getId((Class) iter.next()));
 297       }
 298
 299     iter = sortedIds.iterator();
 300     while (iter.hasNext())
 301       {
 302         b.append("      \"" + iter.next() + "\"");
 303         if (iter.hasNext())
 304           b.append(", \n");
 305       }
 306     return b.toString();
 307   }
 308
 309   /**
 310    * Generate stub. Can only be called from {@link #compile}.
 311    *
 312    * @return the string, containing the text of the generated stub.
 313    */
 314   public String generateStub()
 315   {
 316     String template = getResource("Stub.jav");
 317
 318     // Generate methods.
 319     StringBuffer b = new StringBuffer();
 320     Iterator iter = methods.iterator();
 321     while (iter.hasNext())
 322       {
 323         AbstractMethodGenerator m = (AbstractMethodGenerator) iter.next();
 324         b.append(m.generateStubMethod());
 325       }
 326
 327     vars.put("#stub_methods", b.toString());
 328     vars.put("#imports", getImportStatements());
 329     vars.put("#interfaces", getAllInterfaces());
 330
 331     String output = replaceAll(template, vars);
 332     return output;
 333   }
 334
 335   /**
 336    * Get the list of all interfaces, implemented by the class, that are
 337    * derived from Remote.
 338    *
 339    * @return the string - all interfaces.
 340    */
 341   public String getAllInterfaces()
 342   {
 343     StringBuffer b = new StringBuffer();
 344     Iterator iter = implementedRemotes.iterator();
 345
 346     while (iter.hasNext())
 347       {
 348         b.append(name((Class) iter.next()));
 349         if (iter.hasNext())
 350           b.append(", ");
 351       }
 352
 353     return b.toString();
 354   }
 355
 356   /**
 357    * Generate Tie. Can only be called from {@link #compile}.
 358    *
 359    * @return the string, containing the text of the generated Tie.
 360    */
 361   public String generateTie()
 362   {
 363     String template;
 364     if (poaMode)
 365       template = getResource("Tie.jav");
 366     else
 367       template = getResource("ImplTie.jav");
 368
 369     // Generate methods.
 370     HashFinder hashFinder = new HashFinder();
 371
 372     // Find the hash character position:
 373     Iterator iter = methods.iterator();
 374     String[] names = new String[methods.size()];
 375     int p = 0;
 376
 377     for (int i = 0; i < names.length; i++)
 378       names[i] = ((MethodGenerator) iter.next()).getGiopMethodName();
 379
 380     int hashCharPosition = hashFinder.findHashCharPosition(names);
 381
 382     iter = methods.iterator();
 383     while (iter.hasNext())
 384       ((MethodGenerator) iter.next()).hashCharPosition = hashCharPosition;
 385
 386     vars.put("#hashCharPos", Integer.toString(hashCharPosition));
 387
 388     ArrayList sortedMethods = new ArrayList(methods);
 389     Collections.sort(sortedMethods, this);
 390
 391     iter = sortedMethods.iterator();
 392
 393     StringBuffer b = new StringBuffer();
 394
 395     MethodGenerator prev = null;
 396
 397     while (iter.hasNext())
 398       {
 399         MethodGenerator m = (MethodGenerator) iter.next();
 400         m.previous = prev;
 401         m.hashCharPosition = hashCharPosition;
 402         prev = m;
 403         b.append(m.generateTieMethod());
 404       }
 405
 406     vars.put("#tie_methods", b.toString());
 407
 408     vars.put("#imports", getImportStatements());
 409
 410     String output = replaceAll(template, vars);
 411     return output;
 412   }
 413
 414   public int compare(Object a, Object b)
 415   {
 416     MethodGenerator g1 = (MethodGenerator) a;
 417     MethodGenerator g2 = (MethodGenerator) b;
 418
 419     return g1.getHashChar() - g2.getHashChar();
 420   }
 421
 422   /**
 423    * Import the extra classes, used as the method parameters and return values.
 424    *
 425    * @return the additional import block.
 426    */
 427   protected String getImportStatements()
 428   {
 429     TreeSet imp = new TreeSet();
 430
 431     Iterator it = extraImports.iterator();
 432     while (it.hasNext())
 433       {
 434         String ic = it.next().toString();
 435         imp.add("import " + ic + ";\n");
 436       }
 437
 438     StringBuffer b = new StringBuffer();
 439     it = imp.iterator();
 440
 441     while (it.hasNext())
 442       {
 443         b.append(it.next());
 444       }
 445     return b.toString();
 446   }
 447
 448   /**
 449    * If this flag is set (true by default), the compiler generates the Servant
 450    * based classes. If set to false, the compiler generates the old style
 451    * ObjectImpl based classes.
 452    */
 453   public void setPoaMode(boolean mode)
 454   {
 455     poaMode = mode;
 456   }
 457
 458   /**
 459    * Set the verbose output mode (false by default)
 460    *
 461    * @param isVerbose the verbose output mode
 462    */
 463   public void setVerbose(boolean isVerbose)
 464   {
 465     verbose = isVerbose;
 466   }
 467
 468   /**
 469    * If this flag is set (true by default), the compiler emits warnings.
 470    */
 471   public void setWarnings(boolean warn)
 472   {
 473     warnings = warn;
 474   }
 475
 476   /**
 477    * Set the error ignore mode.
 478    */
 479   public void setForce(boolean isforce)
 480   {
 481     force = isforce;
 482   }
 483
 484   /**
 485    * Get the package name.
 486    */
 487   public String getPackageName()
 488   {
 489     return packag;
 490   }
 491
 492   /**
 493    * Get the proposed stub name
 494    */
 495   public String getStubName()
 496   {
 497     return stubName;
 498   }
 499
 500   /**
 501    * Additional processing of the stub name.
 502    */
 503   public String convertStubName(String name)
 504   {
 505     // Drop the Impl suffix, if one exists.
 506     if (name.endsWith("Impl"))
 507       return name.substring(0, name.length() - "Impl".length());
 508     else
 509       return name;
 510   }
 511 }