/FileExtraction/Java_unseen/dlitz_resin/modules/kernel/src/com/caucho/java/AbstractGenerator.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.java;

import com.caucho.java.gen.DependencyComponent;
import com.caucho.java.gen.GenClass;
import com.caucho.loader.SimpleLoader;
import com.caucho.server.util.CauchoSystem;
import com.caucho.util.CharBuffer;
import com.caucho.vfs.IOExceptionWrapper;
import com.caucho.vfs.Path;
import com.caucho.vfs.PersistentDependency;
import com.caucho.vfs.WriteStream;

import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * Generates the Java code for the wrapped object.
 */
public abstract class AbstractGenerator {
  // The full name of the generated class
  private String _fullClassName;
  // The package of the generated class
  private String _packageName;
  // The class name of the generated class
  private String _className;
  
  // Parent class loader
  private ClassLoader _parentLoader;
  // class loader
  private ClassLoader _loader;
  
  // Write stream for generating the code
  private WriteStream _os;
  // The java writer
  protected JavaWriter _out;
  
  // The search path
  private Path _searchPath;

  // The work directory
  private Path _workPath;

  private GenClass _genClass;

  private String _initMethod = "_caucho_init";
  private String _isModifiedMethod = "_caucho_is_modified";
  
  /**
   * Sets the search path.
   */
  public void setSearchPath(Path path)
  {
    _searchPath = path;
  }

  public Path getSearchPath()
  {
    return _searchPath;
  }

  /**
   * Sets the full generated class.
   */
  public void setFullClassName(String fullClassName)
  {
    CharBuffer cb = CharBuffer.allocate();
    for (int i = 0; i < fullClassName.length(); i++) {
      char ch = fullClassName.charAt(i);

      if (ch == '.' || ch == '/')
        cb.append('.');
      else if (Character.isJavaIdentifierPart(ch))
        cb.append(ch);
      else
        cb.append('_');
    }
    
    _fullClassName = cb.close();

    int p = _fullClassName.lastIndexOf('.');
    if (p > 0) {
      _packageName = _fullClassName.substring(0, p);
      _className = _fullClassName.substring(p + 1);
    }
    else {
      _packageName = "";
      _className = _fullClassName;
    }
  }
  
  /**
   * Returns the full class name
   */
  public String getFullClassName()
  {
    if (_genClass != null)
      return _genClass.getFullClassName();
    else
      return _fullClassName;
  }
  
  /**
   * Returns the generated package name
   */
  public String getPackageName()
  {
    if (_genClass != null)
      return _genClass.getPackageName();
    else
      return _packageName;
  }
  
  /**
   * Returns the generated class name
   */
  public String getClassName()
  {
    if (_genClass != null)
      return _genClass.getClassName();
    else
      return _className;
  }

  /**
   * Sets the java class.
   */
  public void setGenClass(GenClass genClass)
  {
    _genClass = genClass;
  }

  /**
   * Gets the java class.
   */
  public GenClass getGenClass()
  {
    return _genClass;
  }
  
  /**
   * Sets the parent class loader.
   *
   * @param loader parent class loader
   */
  public void setParentLoader(ClassLoader loader)
  {
    _parentLoader = loader;
  }
  
  /**
   * Sets the class loader.
   *
   * @param loader parent class loader
   */
  public void setLoader(ClassLoader loader)
  {
    _loader = loader;
  }

  /**
   * Sets the parent class loader.
   *
   * @return the parent class loader
   */
  public ClassLoader getParentLoader()
  {
    if (_parentLoader == null)
      _parentLoader = Thread.currentThread().getContextClassLoader();
    
    return _parentLoader;
  }

  /**
   * Sets the work path for the generated class.
   */
  public void setClassDir(Path workPath)
  {
    _workPath = workPath;
    Thread.dumpStack();
  }
  
  /**
   * Returns the class dir for the generated class.
   */
  public Path getClassDir()
  {
    if (_workPath == null)
      return WorkDir.getLocalWorkDir();
    else
      return _workPath;
  }

  /**
   * Try to preload the class.
   *
   * @return true if the preloaded class is still valid.
   */
  public Class<?> preload()
    throws IOException
  {
    return loadClass(true);
  }

  /**
   * Call to generate the java source.
   */
  public void generate()
    throws Exception
  {
    String className = getFullClassName();
    String javaPathName = className.replace('.', '/') + ".java";
    String classPathName = className.replace('.', '/') + ".class";

    Path javaPath = getClassDir().lookup(javaPathName);
    Path classPath = getClassDir().lookup(classPathName);
    
    try {
      classPath.remove();
    } catch (IOException e) {
    }

    javaPath.getParent().mkdirs();

    _os = javaPath.openWrite();
    _out = new JavaWriter(_os);

    if (_genClass != null)
      _genClass.generate(_out);
    else
      generateJava();

    _os.close();
  }

  /**
   * Compiles the Java code
   */
  public Class compile()
    throws Exception
  {
    compileJava();
    
    return loadClass(false);
  }
  
  /**
   * Starts generation of the Java code
   */
  public void generateJava()
    throws Exception
  {
  }

  /**
   * Generates the class dependency code.
   *
   * @param depends list of Paths representing dependencies
   */
  protected void printDependList(ArrayList<PersistentDependency> depends)
    throws IOException
  {
    DependencyComponent depend = new DependencyComponent();
    depend.setSearchPath(_searchPath);

    for (int i = 0; i < depends.size(); i++)
      depend.addDependency(depends.get(i));

    depend.generate(getOut());
  }

  /**
   * Prints a method header.
   *
   * @param method the method to print
   */
  public void printMethodHeader(Method method)
    throws IOException
  {
    printMethodHeader(method.getName(), method.getParameterTypes(),
                      method.getReturnType(), method.getExceptionTypes());
  }

  /**
   * Prints a method header.
   *
   * @param name the method name to print
   * @param method the method to print
   */
  public void printMethodHeader(String name, Method method)
    throws IOException
  {
    printMethodHeader(name, method.getParameterTypes(),
                      method.getReturnType(), method.getExceptionTypes());
  }
  
  /**
   * Prints a method header.
   *
   * @param methodName the method name to print
   * @param param the method argument classes
   * @param returnType the return type of the method
   * @param exn array of exceptions thrown by the method
   */
  public void printMethodHeader(String methodName, Class []parameters,
                                Class returnType, Class []exn)
    throws IOException
  {
    println();
    print("public ");
    printClass(returnType);
    print(" ");
    print(methodName);
    print("(");

    for (int i = 0; i < parameters.length; i++) {
      if (i != 0)
        print(", ");

      printClass(parameters[i]);
      print(" a" + i);
    }
    println(")");

    if (exn != null && exn.length > 0) {
      print("  throws ");
      printClass(exn[0]);
      
      for (int i = 1; i < exn.length; i++) {
        print(", ");
        printClass(exn[i]);
      }
      println();
    }
  }
  
  /**
   * Prints the Java represention of the class
   */
  public void printClass(Class cl)
    throws IOException
  {
    if (! cl.isArray())
      print(cl.getName().replace('$',  '.'));
    else {
      printClass(cl.getComponentType());
      print("[]");
    }
  }
  
  /**
   * Compiles the class.
   */
  public void compileJava()
    throws IOException, ClassNotFoundException
  {
    JavaCompiler compiler = getCompiler();
    
    compiler.compile(getFullClassName().replace('.', '/') + ".java", null);
  }

  public JavaCompiler getCompiler()
  {
    JavaCompiler compiler = JavaCompiler.create(getParentLoader());

    compiler.setClassLoader(getParentLoader());
    compiler.setClassDir(getClassDir());

    return compiler;
  }

  /**
   * Loads the generated class.  If any class dependencies have
   * changed, return null.
   */
  public Class loadClass(boolean preload)
    throws IOException
  {
    return loadClass(getFullClassName(), preload);
  }

  /**
   * Loads the generated class.  If any class dependencies have
   * changed, return null.
   */
  public Class loadClass(String fullClassName, boolean preload)
    throws IOException
  {
    try {
      ClassLoader loader;

      if (! preload && _loader != null)
        loader = _loader;
      else {
        loader = SimpleLoader.create(getParentLoader(),
                                     getClassDir(),
                                     fullClassName);
      }

      Class cl = CauchoSystem.loadClass(fullClassName, false, loader);


      if (cl == null)
        return null;
      if (! preload)
        return cl;

      Method method = cl.getMethod(_initMethod, new Class[] { Path.class });
      method.invoke(null, new Object[] { getSearchPath() });

      method = cl.getMethod(_isModifiedMethod, new Class[0]);
      Boolean value = (Boolean) method.invoke(null, new Object[] {});

      if (value.booleanValue())
        return null;

      if (_loader != null)
        loader = _loader;
      else {
        loader = SimpleLoader.create(getParentLoader(),
                                     getClassDir(),
                                     fullClassName);
      }

      return CauchoSystem.loadClass(fullClassName, false, loader);
    } catch (Throwable e) {
      if (! preload)
        throw new IOExceptionWrapper(e);
      else
        return null;
    }
  }

  /**
   * Returns the java writer.
   */
  public JavaWriter getOut()
  {
    return _out;
  }

  /**
   * Pushes an indentation depth.
   */
  public void pushDepth()
    throws IOException
  {
    _out.pushDepth();
  }

  /**
   * Pops an indentation depth.
   */
  public void popDepth()
    throws IOException
  {
    _out.popDepth();
  }

  /**
   * Prints a character
   */
  public void print(int ch)
    throws IOException
  {
    _out.print(ch);
  }

  /**
   * Prints a character
   */
  public void print(char ch)
    throws IOException
  {
    _out.print(ch);
  }

  /**
   * Prints a string
   */
  public void print(String s)
    throws IOException
  {
    _out.print(s);
  }

  /**
   * Prints a string
   */
  public void printStr(String s)
    throws IOException
  {
    int len = s.length();
    for (int i = 0; i < len; i++) {
      char ch = s.charAt(i);

      switch (ch) {
      case '\\':
        _out.print("\\\\");
        break;
      case '\n':
        _out.print("\\n");
        break;
      case '\r':
        _out.print("\\r");
        break;
      case '"':
        _out.print("\\\"");
        break;
      default:
        _out.print(ch);
      }
    }
  }

  /**
   * Prints a new line.
   */
  public void println()
    throws IOException
  {
    _out.println();
  }

  /**
   * Prints a string with a new line
   */
  public void println(String s)
    throws IOException
  {
    _out.println(s);
  }
}
