All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.eclipse.emf.codegen.jet.JETEmitter Maven / Gradle / Ivy

There is a newer version: 2.24.0
Show newest version
/**
 * Copyright (c) 2002-2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 * 
 * Contributors: 
 *   IBM - Initial API and implementation
 */
package org.eclipse.emf.codegen.jet;


import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.osgi.framework.Bundle;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.emf.codegen.CodeGenPlugin;
import org.eclipse.emf.codegen.util.CodeGenUtil;
import org.eclipse.emf.common.CommonPlugin;
import org.eclipse.emf.common.EMFPlugin;
import org.eclipse.emf.common.util.BasicMonitor;
import org.eclipse.emf.common.util.Monitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.common.util.UniqueEList;


/**
 * A convenience class for compiling and invoking a template dynamically.
 */
public class JETEmitter
{
  protected String projectName = ".JETEmitters";
  protected Method method;
  protected Object object;
  protected String [] templateURIPath;
  protected String templateURI;
  protected ClassLoader classLoader;
  protected String encoding;
  protected List classpathEntries = new ArrayList();
  protected Map javaOptions = new HashMap();

  /**
   * Creates an instance with the specified template URI.
   * @param templateURI the URI of a JET template.
   */
  public JETEmitter(String templateURI)
  {
    this.templateURI = templateURI;
    this.classLoader = JETEmitter.this.getClass().getClassLoader();
  }

  /**
   * Creates an instance with the specified template URI path and relative template URI.
   * The relative URI will be resolved against each path URI until a JET template is found.
   * @param templateURIPath a sequence of URIs that will be searched.
   * @param relativeTemplateURI the relative URI of a JET template.
   */
  public JETEmitter(String [] templateURIPath, String relativeTemplateURI)
  {
    this.templateURIPath = templateURIPath;
    this.templateURI = relativeTemplateURI;
    this.classLoader = JETEmitter.this.getClass().getClassLoader();
  }

  /**
   * Creates an instance with the specified template URI and class loader.
   * @param templateURI the URI of a JET template.
   * @param classLoader the class loader used to load classes when compiling the template.
   */
  public JETEmitter(String templateURI, ClassLoader classLoader)
  {
    this.templateURI = templateURI;
    this.classLoader = classLoader;
  }

  /**
   * Creates an instance with the specified template URI path, relative template URI, and class loader.
   * The relative URI will be resolved against each path URI until a JET template is found.
   * @param templateURIPath a sequence of URIs that will be searched.
   * @param relativeTemplateURI the relative URI of a JET template.
   * @param classLoader the class loader used to load classes when compiling the template.
   */
  public JETEmitter(String [] templateURIPath, String relativeTemplateURI, ClassLoader classLoader)
  {
    this.templateURIPath = templateURIPath;
    this.templateURI = relativeTemplateURI;
    this.classLoader = classLoader;
  }

  /**
   * Creates an instance with the specified template URI path, relative template URI, class loader, and encoding.
   * The relative URI will be resolved against each path URI until a JET template is found.
   * @param templateURIPath a sequence of URIs that will be searched.
   * @param relativeTemplateURI the relative URI of a JET template.
   * @param classLoader the class loader used to load classes when compiling the template.
   * @param encoding the encoding that will be used to read the templates.
   */
  public JETEmitter(String [] templateURIPath, String relativeTemplateURI, ClassLoader classLoader, String encoding)
  {
    this.templateURIPath = templateURIPath;
    this.templateURI = relativeTemplateURI;
    this.classLoader = classLoader;
    this.encoding = encoding;
  }

  /**
   * Returns the name of the project where JET templates will be compiled.
   * @return the name of the project where JET templates will be compiled.
   */
  public String getProjectName()
  {
    return projectName;
  }

  /**
   * Sets the name of the project where JET templates will be compiled.
   * @param projectName the name of the project.
   */
  public void setProjectName(String projectName)
  {
    this.projectName = projectName;
  }

  /**
   * Returns a list of classpath entries that will be added to the classpath of the internal {@link #getProjectName project}
   * where emitted JET templates are compiled.
   * 

* This method must be called before * {@link #initialize(Monitor) initialize} or {@link #generate(Monitor, Object[]) generate} * are called. * @return a list of classpath entries. */ public List getClasspathEntries() { return classpathEntries; } /** * Returns options that will be {@link IJavaProject#setOption(String, String) applied} to the Java project the first time it's created. * @return the Java options. */ public Map getJavaOptions() { return javaOptions; } /** * Returns the object used as the target for the template. * @return the object used as target for the template. */ public Object getObject() { return object; } /** * Returns the object used as the target for the template; * it ensures that the returned object is using the given lineDelimiter * and creates a new one if necessary. * @return the object used as target for the template. * @since 2.3 */ public Object getObject(String lineDelimiter) { if (lineDelimiter != null) { if (object != null) { Class javaClass = object.getClass(); try { Field field = javaClass.getField("NL"); Object nl = field.get(object); if (lineDelimiter.equals(nl)) { return object; } else { object = null; } } catch (Throwable exception) { CodeGenPlugin.INSTANCE.log(exception); } } if (object == null && method != null) { Class javaClass = method.getDeclaringClass(); try { Method method = javaClass.getMethod("create", String.class); object = method.invoke(null, lineDelimiter); } catch (Throwable exception) { CodeGenPlugin.INSTANCE.log(exception); } } } return object; } /** * Sets the object used as the target of the template. * @param object the object used as target of the template. */ public void setObject(Object object) { this.object = object; } /** * Returns the method that will be invoked when {@link #generate(Monitor, Object[]) generate} called. * @return the generator method. */ public Method getMethod() { return method; } /** * Set the method that will be invoked when {@link #generate(Monitor, Object[]) generate} called. * @param method the generator method. */ public void setMethod(Method method) { this.method = method; if ((method.getModifiers() & Modifier.STATIC) == 0 && object == null) { try { object = method.getDeclaringClass().getDeclaredConstructor().newInstance(); } catch (RuntimeException exception) { CodeGenPlugin.INSTANCE.log(exception); } catch (InstantiationException exception) { CodeGenPlugin.INSTANCE.log(exception); } catch (IllegalAccessException exception) { CodeGenPlugin.INSTANCE.log(exception); } catch (InvocationTargetException exception) { CodeGenPlugin.INSTANCE.log(exception); } catch (NoSuchMethodException exception) { CodeGenPlugin.INSTANCE.log(exception); } } } protected static class MyBaseJETCompiler extends JETCompiler { protected ClassLoader classLoader; public MyBaseJETCompiler(String templateURI, ClassLoader classLoader) throws JETException { super(templateURI); this.classLoader = classLoader; } public MyBaseJETCompiler(String templateURI, String encoding, ClassLoader classLoader) throws JETException { super(templateURI, encoding); this.classLoader = classLoader; } public MyBaseJETCompiler(String [] templateURIPath, String relativeTemplateURI, ClassLoader classLoader) throws JETException { super(templateURIPath, relativeTemplateURI); this.classLoader = classLoader; } public MyBaseJETCompiler(String [] templateURIPath, String relativeTemplateURI, String encoding, ClassLoader classLoader) throws JETException { super(templateURIPath, relativeTemplateURI, encoding); this.classLoader = classLoader; } @Override protected void handleNewSkeleton() { String packageName = skeleton.getPackageName(); String skeletonClassName = skeleton.getClassName(); String qualifiedSkeletonClassName = (packageName.length() == 0 ? "" : packageName + ".") + skeletonClassName; if (classLoader != null) { try { Class theClass = classLoader.loadClass(qualifiedSkeletonClassName); if (theClass != null) { skeleton.setClassName(skeletonClassName += "_"); } } catch (Exception exception) { // Ignore } } } } protected class MyJETCompiler extends MyBaseJETCompiler { public MyJETCompiler(String templateURI) throws JETException { super(templateURI, JETEmitter.this.classLoader); } public MyJETCompiler(String templateURI, String encoding) throws JETException { super(templateURI, encoding, JETEmitter.this.classLoader); } public MyJETCompiler(String [] templateURIPath, String relativeTemplateURI) throws JETException { super(templateURIPath, relativeTemplateURI, JETEmitter.this.classLoader); } public MyJETCompiler(String [] templateURIPath, String relativeTemplateURI, String encoding) throws JETException { super(templateURIPath, relativeTemplateURI, encoding, JETEmitter.this.classLoader); } } /** * Compiles the template to {@link #setMethod set} the method will be invoked to generate template results. * @param progressMonitor the progress monitor for tracking progress. */ public void initialize(IProgressMonitor progressMonitor) throws JETException { initialize(BasicMonitor.toMonitor(progressMonitor)); } /** * Compiles the template to {@link #setMethod set} the method will be invoked to generate template results. * @param progressMonitor the progress monitor for tracking progress. */ public void initialize(Monitor progressMonitor) throws JETException { if (EMFPlugin.IS_ECLIPSE_RUNNING) { EclipseHelper.initialize(progressMonitor, this); } } /** * Registers the specified classpath variable in the workspace * and adds a classpath entry to the {@link #getClasspathEntries() classpath entry list}. * The variable is bound to the first runtime library JAR file in the list * of runtime libraries of the specified plugin. * When {@link #generate(Monitor, Object[]) generate} is called * and it needs to generate the {@link #getMethod method} to invoke, * it will call {@link #initialize(Monitor) initialize} * which will add the classpath entries to the {@link #getProjectName project} created to hold and compile the emitted template. *

* This method must be called before * {@link #initialize(Monitor) initialize} or {@link #generate(Monitor, Object[]) generate} * are called. *

* The specified plugin ID must be the ID of an existing plugin. * The referenced plugin must have at least one * runtime library JAR file in its plugin descriptor. * If the plugin descriptor's list of runtime libraries contains more than one JAR file, * the classpath variable will be bound to the first * library in the list. * @param variableName name of the classpath variable * @param pluginID the ID of an existing plugin */ public void addVariable(String variableName, String pluginID) throws JETException { if (EMFPlugin.IS_ECLIPSE_RUNNING && method == null) { EclipseHelper.addVariable(this, variableName, pluginID); } } /** * Invokes the emitter method on the compiled template and returns the result. * @return the template result. */ public String generate(IProgressMonitor progressMonitor, Object [] arguments) throws JETException { return generate(BasicMonitor.toMonitor(progressMonitor), arguments); } /** * Invokes the emitter method on the compiled template and returns the result. * @return the template result. */ public String generate(Monitor progressMonitor, Object [] arguments) throws JETException { return generate(progressMonitor, arguments, null); } /** * Invokes the emitter method on the compiled template and returns the result. * @return the template result. * @since 2.3 */ public String generate(Monitor progressMonitor, Object [] arguments, String lineDelimiter) throws JETException { if (method == null) { initialize(progressMonitor); } String result = ""; if (method != null) { try { result = (String)method.invoke(getObject(lineDelimiter), arguments); } catch (IllegalAccessException exception) { throw new JETException(exception); } catch (InvocationTargetException exception) { throw new JETException(exception); } } return result; } private static class EclipseHelper { public static void initialize(Monitor monitor, final JETEmitter jetEmitter) throws JETException { IProgressMonitor progressMonitor = BasicMonitor.toIProgressMonitor(monitor); progressMonitor.beginTask("", 10); progressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_GeneratingJETEmitterFor_message", new Object [] { jetEmitter.templateURI })); final IWorkspace workspace = ResourcesPlugin.getWorkspace(); IJavaModel javaModel = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()); try { final JETCompiler jetCompiler = jetEmitter.templateURIPath == null ? new MyBaseJETCompiler(jetEmitter.templateURI, jetEmitter.encoding, jetEmitter.classLoader) : new MyBaseJETCompiler(jetEmitter.templateURIPath, jetEmitter.templateURI, jetEmitter.encoding, jetEmitter.classLoader); progressMonitor.subTask (CodeGenPlugin.getPlugin().getString("_UI_JETParsing_message", new Object [] { jetCompiler.getResolvedTemplateURI() })); jetCompiler.parse(); progressMonitor.worked(1); String packageName = jetCompiler.getSkeleton().getPackageName(); if (jetEmitter.templateURIPath != null) { URI templateURI = URI.createURI(jetEmitter.templateURIPath[0]); URLClassLoader theClassLoader = null; if (templateURI.isPlatformResource()) { // If the template path points at a project with a JET Nature, // then we will assume that the templates we want to use are already compiled in this plugin Java project. // IProject project = workspace.getRoot().getProject(templateURI.segment(1)); if (JETNature.getRuntime(project) != null) { List urls = new ArrayList(); // Compute the URL for where the classes for this project will be located. // IJavaProject javaProject = JavaCore.create(project); urls.add(new File(project.getLocation() + "/" + javaProject.getOutputLocation().removeFirstSegments(1) + "/").toURI().toURL()); // Compute the URLs for all the output folder of all the project dependencies. // for (IClasspathEntry classpathEntry : javaProject.getResolvedClasspath(true)) { if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_PROJECT) { IPath projectPath = classpathEntry.getPath(); IProject otherProject = workspace.getRoot().getProject(projectPath.segment(0)); IJavaProject otherJavaProject = JavaCore.create(otherProject); urls.add(new File(otherProject.getLocation() + "/" + otherJavaProject.getOutputLocation().removeFirstSegments(1) + "/").toURI().toURL()); } } // Define a class loader that will look in the URLs first, // and if it doesn't find the class there, uses the emitter's loader. // theClassLoader = new URLClassLoader(urls.toArray(new URL [0])) { @Override public Class loadClass(String className) throws ClassNotFoundException { try { return super.loadClass(className); } catch (ClassNotFoundException classNotFoundException) { return jetEmitter.classLoader.loadClass(className); } } }; } } else if (templateURI.isPlatformPlugin()) { final Bundle bundle = Platform.getBundle(templateURI.segment(1)); if (bundle != null) { // Define a class loader that will look up the class in the bundle, // and if it doesn't find it there, will look in the parent. // theClassLoader = new URLClassLoader(new URL [0], jetEmitter.classLoader) { @Override public Class loadClass(String className) throws ClassNotFoundException { try { return bundle.loadClass(className); } catch (ClassNotFoundException classNotFoundException) { return super.loadClass(className); } } }; } } if (theClassLoader != null) { // Strip off the trailing "_" and load that class. // String className = (packageName.length() == 0 ? "" : packageName + ".") + jetCompiler.getSkeleton().getClassName(); if (className.endsWith("_")) { className = className.substring(0, className.length() - 1); } try { Class theClass = theClassLoader.loadClass(className); // Check that the class is actually different from the one that's directly visible to the JETEmitter. // Class theOtherClass = null; try { theOtherClass = jetEmitter.classLoader.loadClass(className); } catch (ClassNotFoundException exception) { // Ignore. } if (theClass != theOtherClass) { String methodName = jetCompiler.getSkeleton().getMethodName(); Method [] methods = theClass.getDeclaredMethods(); for (int i = 0; i < methods.length; ++i) { if (methods[i].getName().equals(methodName)) { jetEmitter.setMethod(methods[i]); break; } } // Don't do any of the other normally dynamic JETEmitter project processing. // return; } } catch (ClassNotFoundException exception) { // Continue processing dynamically as normal. } } } ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); jetCompiler.generate(outputStream); final InputStream contents = new ByteArrayInputStream(outputStream.toByteArray()); if (!javaModel.isOpen()) { javaModel.open(BasicMonitor.subProgress(progressMonitor, 1)); } else { progressMonitor.worked(1); } final IProject project = workspace.getRoot().getProject(jetEmitter.getProjectName()); progressMonitor.subTask (CodeGenPlugin.getPlugin().getString("_UI_JETPreparingProject_message", new Object [] { project.getName() })); IJavaProject javaProject; if (!project.exists()) { progressMonitor.subTask("JET creating project " + project.getName()); project.create(BasicMonitor.subProgress(progressMonitor, 1)); progressMonitor.subTask (CodeGenPlugin.getPlugin().getString("_UI_JETCreatingProject_message", new Object [] { project.getName() })); IProjectDescription description = workspace.newProjectDescription(project.getName()); description.setNatureIds(new String [] { JavaCore.NATURE_ID }); description.setLocation(null); project.open(BasicMonitor.subProgress(progressMonitor, 1)); project.setDescription(description, BasicMonitor.subProgress(progressMonitor, 1)); javaProject = JavaCore.create(project); for (Map.Entry option : jetEmitter.getJavaOptions().entrySet()) { javaProject.setOption(option.getKey(), option.getValue()); } } else { project.open(BasicMonitor.subProgress(progressMonitor, 5)); IProjectDescription description = project.getDescription(); description.setNatureIds(new String [] { JavaCore.NATURE_ID }); project.setDescription(description, BasicMonitor.subProgress(progressMonitor, 1)); javaProject = JavaCore.create(project); } // Get the existing classpath and remove the project root if necessary. // Any new non-duplicate entries will be added to this. // List classpath = new UniqueEList(Arrays.asList(javaProject.getRawClasspath())); for (int i = 0, len = classpath.size(); i < len; i++) { IClasspathEntry entry = classpath.get(i); if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE && ("/" + project.getName()).equals(entry.getPath().toString())) { classpath.remove(i); } } // Add the new entries, including source, JRE container, and added variables and classpath containers. // progressMonitor.subTask (CodeGenPlugin.getPlugin().getString("_UI_JETInitializingProject_message", new Object [] { project.getName() })); IClasspathEntry classpathEntry = JavaCore.newSourceEntry(new Path("/" + project.getName() + "/src")); IClasspathEntry jreClasspathEntry = JavaCore.newContainerEntry(new Path("org.eclipse.jdt.launching.JRE_CONTAINER")); classpath.add(classpathEntry); classpath.add(jreClasspathEntry); classpath.addAll(jetEmitter.classpathEntries); IFolder sourceFolder = project.getFolder(new Path("src")); if (!sourceFolder.exists()) { sourceFolder.create(false, true, BasicMonitor.subProgress(progressMonitor, 1)); } IFolder runtimeFolder = project.getFolder(new Path("bin")); if (!runtimeFolder.exists()) { runtimeFolder.create(false, true, BasicMonitor.subProgress(progressMonitor, 1)); } javaProject.setRawClasspath(classpath.toArray(new IClasspathEntry[classpath.size()]), BasicMonitor.subProgress(progressMonitor, 1)); javaProject.setOutputLocation(new Path("/" + project.getName() + "/bin"), BasicMonitor.subProgress(progressMonitor, 1)); javaProject.close(); progressMonitor.subTask (CodeGenPlugin.getPlugin().getString("_UI_JETOpeningJavaProject_message", new Object [] { project.getName() })); javaProject.open(BasicMonitor.subProgress(progressMonitor, 1)); IPackageFragmentRoot [] packageFragmentRoots = javaProject.getPackageFragmentRoots(); IPackageFragmentRoot sourcePackageFragmentRoot = null; for (int j = 0; j < packageFragmentRoots.length; ++j) { IPackageFragmentRoot packageFragmentRoot = packageFragmentRoots[j]; if (packageFragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE) { sourcePackageFragmentRoot = packageFragmentRoot; break; } } StringTokenizer stringTokenizer = new StringTokenizer(packageName, "."); IProgressMonitor subProgressMonitor = BasicMonitor.subProgress(progressMonitor, 1); subProgressMonitor.beginTask("", stringTokenizer.countTokens() + 4); subProgressMonitor.subTask(CodeGenPlugin.getPlugin().getString("_UI_CreateTargetFile_message")); IContainer sourceContainer = sourcePackageFragmentRoot == null ? project : (IContainer)sourcePackageFragmentRoot.getCorrespondingResource(); while (stringTokenizer.hasMoreElements()) { String folderName = stringTokenizer.nextToken(); sourceContainer = sourceContainer.getFolder(new Path(folderName)); if (!sourceContainer.exists()) { ((IFolder)sourceContainer).create(false, true, BasicMonitor.subProgress(subProgressMonitor, 1)); } } IFile targetFile = sourceContainer.getFile(new Path(jetCompiler.getSkeleton().getClassName() + ".java")); if (!targetFile.exists()) { subProgressMonitor.subTask (CodeGenPlugin.getPlugin().getString("_UI_JETCreating_message", new Object [] { targetFile.getFullPath() })); targetFile.create(contents, true, BasicMonitor.subProgress(subProgressMonitor, 1)); } else { subProgressMonitor.subTask (CodeGenPlugin.getPlugin().getString("_UI_JETUpdating_message", new Object [] { targetFile.getFullPath() })); targetFile.setContents(contents, true, true, BasicMonitor.subProgress(subProgressMonitor, 1)); } subProgressMonitor.subTask (CodeGenPlugin.getPlugin().getString("_UI_JETBuilding_message", new Object [] { project.getName() })); project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, BasicMonitor.subProgress(subProgressMonitor, 1)); IMarker [] markers = targetFile.findMarkers(IMarker.PROBLEM, true, IResource.DEPTH_INFINITE); boolean errors = false; for (int i = 0; i < markers.length; ++i) { IMarker marker = markers[i]; if (marker.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO) == IMarker.SEVERITY_ERROR) { errors = true; subProgressMonitor.subTask (marker.getAttribute(IMarker.MESSAGE) + " : " + (CodeGenPlugin.getPlugin().getString ("jet.mark.file.line", new Object [] { targetFile.getLocation(), marker.getAttribute(IMarker.LINE_NUMBER) }))); } } if (!errors) { subProgressMonitor.subTask (CodeGenPlugin.getPlugin().getString ("_UI_JETLoadingClass_message", new Object [] { jetCompiler.getSkeleton().getClassName() + ".class" })); // Construct a proper URL for relative lookup. // List urls = new ArrayList(); urls.add(new File(project.getLocation() + "/" + javaProject.getOutputLocation().removeFirstSegments(1) + "/").toURI().toURL()); // Determine all the bundles that this project depends on. // final Set bundles = new HashSet(); LOOP: for (IClasspathEntry jetEmitterClasspathEntry : jetEmitter.getClasspathEntries()) { IClasspathAttribute [] classpathAttributes = jetEmitterClasspathEntry.getExtraAttributes(); if (classpathAttributes != null) { for (IClasspathAttribute classpathAttribute : classpathAttributes) { if (classpathAttribute.getName().equals(CodeGenUtil.EclipseUtil.PLUGIN_ID_CLASSPATH_ATTRIBUTE_NAME)) { Bundle bundle = Platform.getBundle(classpathAttribute.getValue()); if (bundle != null) { bundles.add(bundle); continue LOOP; } } } } // For any entry that doesn't correspond to a plugin in the running JVM, compute a URL for the classes. // urls.add(new URL("platform:/resource" + jetEmitterClasspathEntry.getPath() + "/")); } // Define a class loader that looks up classes using the URLs or the parent class loader, // and failing those, tries to look up the class in each bundle in the running JVM. // @SuppressWarnings("all") URLClassLoader theClassLoader = new URLClassLoader(urls.toArray(new URL [0]), jetEmitter.classLoader) { @Override public Class loadClass(String className) throws ClassNotFoundException { try { return super.loadClass(className); } catch (ClassNotFoundException exception) { for (Bundle bundle : bundles) { try { return bundle.loadClass(className); } catch (ClassNotFoundException exception2) { // Ignore because we'll rethrow the original exception eventually. } } throw exception; } } }; Class theClass = theClassLoader.loadClass ((packageName.length() == 0 ? "" : packageName + ".") + jetCompiler.getSkeleton().getClassName()); String methodName = jetCompiler.getSkeleton().getMethodName(); Method [] methods = theClass.getDeclaredMethods(); for (int i = 0; i < methods.length; ++i) { if (methods[i].getName().equals(methodName)) { jetEmitter.setMethod(methods[i]); break; } } } subProgressMonitor.done(); } catch (CoreException exception) { throw new JETException(exception); } catch (Exception exception) { throw new JETException(exception); } finally { progressMonitor.done(); } } public static void addVariable(JETEmitter jetEmitter, String variableName, String pluginID) throws JETException { Bundle bundle = Platform.getBundle(pluginID); URL classpathURL = bundle != null && Platform.inDevelopmentMode() ? bundle.getEntry(".classpath") : null; // If it doesn't correspond to a bundle, then try to process it as a project in the workspace. // if (bundle == null) { try { IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(pluginID); if (project != null) { classpathURL = new File(project.getLocation()+ "/.classpath").toURI().toURL(); } } catch (MalformedURLException exception) { throw new JETException(exception); } } boolean addClasspathEntries = true; if (classpathURL != null) { DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance(); documentBuilderFactory.setNamespaceAware(true); documentBuilderFactory.setValidating(false); try { DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder(); Document document = documentBuilder.parse(new InputSource(classpathURL.toString())); for (Node child = document.getDocumentElement().getFirstChild(); child != null; child = child.getNextSibling()) { if (child.getNodeType() == Node.ELEMENT_NODE) { Element classpathEntryElement = (Element)child; if ("classpathentry".equals(classpathEntryElement.getNodeName()) && "output".equals(classpathEntryElement.getAttribute("kind"))) { URI uri = URI.createURI(classpathEntryElement.getAttribute("path")).resolve(URI.createURI(classpathURL.toString())); IWorkspace workspace = ResourcesPlugin.getWorkspace(); IProject project = workspace.getRoot().getProject(jetEmitter.getProjectName()); if (!project.exists()) { project.create(new NullProgressMonitor()); } if (!project.isOpen()) { project.open(new NullProgressMonitor()); } IFolder folder = project.getFolder("." + pluginID); if (!folder.exists()) { folder.createLink (new Path(CommonPlugin.asLocalURI(uri).toFileString()).removeTrailingSeparator(), IResource.ALLOW_MISSING_LOCAL, new NullProgressMonitor()); } folder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor()); IPath path = folder.getFullPath(); IClasspathEntry newLibraryEntry = JavaCore.newLibraryEntry (path, null, null, null, bundle == null ? new IClasspathAttribute[0] : new IClasspathAttribute[] { JavaCore.newClasspathAttribute(CodeGenUtil.EclipseUtil.PLUGIN_ID_CLASSPATH_ATTRIBUTE_NAME, pluginID) }, true); jetEmitter.getClasspathEntries().add(newLibraryEntry); addClasspathEntries = false; break; } } } } catch (Exception exception) { CodeGenPlugin.INSTANCE.log(exception); } } if (addClasspathEntries) { CodeGenUtil.EclipseUtil.addClasspathEntries(jetEmitter.getClasspathEntries(), variableName, pluginID); } } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy