path: root/plugins/org.eclipse.gmt.tcs.builder/src/org/eclipse/gmt/tcs/builder/TCSBuilder.java

/**
 * Copyright (c) 2008 INRIA.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     INRIA - initial API and implementation
 *
 * $Id: TCSBuilder.java,v 1.17 2008/07/03 14:38:28 fjouault Exp $
 */
package org.eclipse.gmt.tcs.builder;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.ref.SoftReference;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;

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.IResource;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.util.URI;
import org.eclipse.gmt.tcs.builder.ct.ResourceLocator;
import org.eclipse.gmt.tcs.metadata.Language;
import org.eclipse.gmt.tcs.metadata.LanguageRegistry;
import org.eclipse.gmt.tcs.metadata.LanguageSource;
import org.eclipse.jdt.core.compiler.CategorizedProblem;
import org.eclipse.jdt.internal.compiler.ClassFile;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.Compiler;
import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
import org.eclipse.jdt.internal.compiler.batch.FileSystem;
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.core.builder.ProblemFactory;
import org.eclipse.jdt.internal.core.util.ResourceCompilationUnit;
import org.eclipse.m2m.atl.core.ATLCoreException;
import org.eclipse.m2m.atl.core.IExtractor;
import org.eclipse.m2m.atl.core.IModel;
import org.eclipse.m2m.atl.core.ModelFactory;
import org.eclipse.m2m.atl.core.emf.EMFModelFactory;
import org.eclipse.m2m.atl.core.service.CoreService;
import org.eclipse.m2m.atl.dsls.DSLResourceProvider;
import org.eclipse.m2m.atl.dsls.Resource;
import org.eclipse.m2m.atl.dsls.textsource.IFileTextSource;
import org.eclipse.m2m.atl.dsls.textsource.TextSource;
import org.eclipse.m2m.atl.engine.MarkerMaker;
import org.osgi.framework.Bundle;

/**
 * 
 * @author Fr�d�ric Jouault
 * 
 */
public class TCSBuilder extends IncrementalProjectBuilder {

	public static final String ID = "org.eclipse.gmt.tcs.builder.Builder";

	private Map parserGenerators = new HashMap();;

	public TCSBuilder() throws Exception {
	}

	private ResourceLocator rl;
	// soft reference: to prevent from being retained, which causes a leak
	// TODO: is the SoftReference itself leaked now?
	private SoftReference ct = null;

	private TCSBuilderCT getTCSBuilderCT() throws CoreException {
		TCSBuilderCT ret = (ct == null) ? null : (TCSBuilderCT)ct.get();
		final IProject ammaCore = ResourcesPlugin.getWorkspace().getRoot().getProject("AMMACore");
		if((ret != null) && (ammaCore.exists())) {
			IFile noChangeFile = ammaCore.getFile("NO_CHANGE.txt");
			if(!noChangeFile.exists()) {
				ret = null;	// force reload of all models
				noChangeFile.create(new ByteArrayInputStream("Remove this file to force the TCS builder to purge its cache and reload the AMMACore models (e.g., after updating from CVS, or changing a model).".getBytes()), true, null);
				noChangeFile.setDerived(true);
			}
		}
		if(ret == null) {
			boolean canUseAMMACore = false;
			if(ammaCore.exists()) {
				IFile doNotUseFile = ammaCore.getFile("DO_NOT_USE.txt");
				if(!doNotUseFile.exists()) {
					canUseAMMACore = true;
				}
			}
			final boolean useAMMACore = canUseAMMACore;
			rl = new ResourceLocator() {
				public Resource getResource(final String id) throws IOException {
					if(useAMMACore) {
						// Get resources from AMMACore project in workspace
						return new Resource() {
							public TextSource asTextSource() {
								return new IFileTextSource(ammaCore.getFile(id));
							}

							public URI asEMFURI() {
								return URI.createPlatformResourceURI(ammaCore.getFile(id).getFullPath().toString(), true);
							}
							public URL asURL() {
								throw new RuntimeException("Conversion to URL unsupported");
							}
						};
					} else {
						return DSLResourceProvider.getDefault().getResource(id);
					}
				}
			};
			try {
				ret = new TCSBuilderCT(rl);
				ct = new SoftReference(ret);
			} catch(IOException ioe) {
				// setting exception (ie., last argument) to non-null value (i.e., ioe) prevents the error pop-up from opening
				throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, IStatus.OK, "error loading resources from AMMACore project", ioe));
			} catch (ATLCoreException ace) {
				// setting exception (ie., last argument) to non-null value (i.e., ace) prevents the error pop-up from opening
				throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, IStatus.OK, "error loading resources from AMMACore project", ace));
			}
		}
		return ret;
	}


	// TODO: add 'if(monitor.isCanceled()) return null;' where appropriate
	protected IProject[] build(int kind, Map args, IProgressMonitor monitor) throws CoreException {
		TCSBuilderCT ct = getTCSBuilderCT();
		final IProject p = getProject();
		Language ts = LanguageRegistry.getDefault().getLanguageFromSource(p);
		if(ts == null) {
			return null;	// not a valid TCS project
		}
		LanguageSource tss = ts.getSource();
		final String name = ts.getName();
		IFile km3File = tss.getKM3SourceFile();
		IFile tcsFile = tss.getTCSSourceFile();
		IFile outlineFile = tss.getOutlineFile();
		IFile editorFile = tss.getEditorFile();
		IFile ecoreFile = tss.getMetamodelFile();
		final IFile grammarFile = tss.getGrammarFile();
		final IFile jarFile = tss.getParserFile();
		IFile compilerSourceFile = tss.getACGSourceFile();
		IFile compilerBinaryFile = tss.getCompilerFile();
		try {
			String ext = ts.getExtension();
			boolean removeParserJavaSource = !"false".equals(tss.getProperty("syntax.jar.source.remove"));
			boolean rebuildPlugin = false;
			boolean isJavaProject = false;

			ModelFactory mf = CoreService.getModelFactory(EMFModelFactory.MODEL_FACTORY_NAME);
			IExtractor extractor = CoreService.getExtractor(mf.getDefaultExtractorName());
			Map models = new HashMap();
			models.put(ct.srckm3, new IFileTextSource(km3File));
			models.put(ct.srctcs, new IFileTextSource(tcsFile));
			models.put("problemReporter", new ProblemReporter() {
				public boolean reportProblem(TextSource textSource, IModel problemModel) {
					int nbErrors = 0;
					try {
						IFile file = ((IFileTextSource)textSource).getFile();
						nbErrors = new MarkerMaker().applyMarkers(file, problemModel);
					} catch (CoreException e) {
						e.printStackTrace();
					}
					return nbErrors == 0;
				}
			});
			
			if(tcsFile.getLocalTimeStamp() > editorFile.getLocalTimeStamp()) {
				monitor.subTask("creating Editor model " + editorFile.getName());
				IModel editorModel = (IModel)ct.getTarget(ct.tgteditor, models);
				extractor.extract(editorModel,
						URI.createPlatformResourceURI(
								"/" + p.getName() + "/" + editorFile.getProjectRelativePath().toString(), true)
								.toString());
				p.getFolder("TGE").setDerived(true);
				rebuildPlugin = true;
			}

			if(km3File.getLocalTimeStamp() > outlineFile.getLocalTimeStamp()) {
				monitor.subTask("creating Outline model " + outlineFile.getName());
				IModel outlineModel = (IModel)ct.getTarget(ct.tgtoutline, models);
				extractor.extract(outlineModel,
						URI.createPlatformResourceURI(
								"/" + p.getName() + "/" + outlineFile.getProjectRelativePath().toString(), true)
								.toString());
				p.getFolder("TGE").setDerived(true);
				rebuildPlugin = true;
			}

			if(km3File.getLocalTimeStamp() > ecoreFile.getLocalTimeStamp()) {
				monitor.subTask("creating Ecore metamodel " + ecoreFile.getName());
				IModel ecoreModel = (IModel)ct.getTarget(ct.tgtecore, models);
				
				IFile annotationFile = tss.getAnnotationSourceFile();
				if(annotationFile.exists()) {
					models.put(ct.srcannotation, new IFileTextSource(annotationFile));
					ecoreModel = (IModel)ct.getTarget(ct.tgtecorePlusAnnotations, models);
				}				

				extractor.extract(ecoreModel,
						URI.createPlatformResourceURI(
								"/" + p.getName() + "/" + ecoreFile.getProjectRelativePath().toString(), true)
								.toString());
				rebuildPlugin = true;
			}

			if(compilerSourceFile.exists()) {
				if(compilerSourceFile.getLocalTimeStamp() > compilerBinaryFile.getLocalTimeStamp()) {
					monitor.subTask("compiling compiler to " + compilerBinaryFile.getName());
					models.put(ct.srcacg, new IFileTextSource(compilerSourceFile));
					int nbACGErrors = 0;
					if(nbACGErrors == 0) {
						TextSource asmFile = (TextSource)ct.getTarget(ct.tgtasm, models);
						if (compilerBinaryFile.exists()) {
							compilerBinaryFile.setContents(asmFile.openStream(), IFile.DERIVED, monitor);
						} else {
							compilerBinaryFile.create(asmFile.openStream(), IFile.DERIVED, monitor);
						}
					}
				}
			}

			// TODO: improve TCS2Problem so that it is automatically invoked after injection (e.g., for TCS2Editor too)
			// TODO: keep injection errors as well
			// => possible solution to both problems: add a problem model to each getTarget request
			// (possibly using a special id in the models Map)
			if(
					(km3File.getLocalTimeStamp() > grammarFile.getLocalTimeStamp()) ||
					(tcsFile.getLocalTimeStamp() > grammarFile.getLocalTimeStamp())) {
				monitor.subTask("creating grammar " + grammarFile.getName());
				IModel tcsProblemModel = (IModel)ct.getTarget(ct.tgttcsproblem, models);
				int nbTCSErrors = new MarkerMaker().applyMarkers(tcsFile, tcsProblemModel);
				IModel km3ProblemModel = (IModel)ct.getTarget(ct.tgtkm3problem, models);
				int nbKM3Errors = new MarkerMaker().applyMarkers(km3File, km3ProblemModel);
				if((nbTCSErrors == 0) && (nbKM3Errors == 0)) {
					TextSource grammarModel = (TextSource)ct.getTarget(ct.tgtgrammar, models);
					if (grammarFile.exists()) {
						grammarFile.setContents(grammarModel.openStream(), IFile.DERIVED, monitor);
					} else {
						grammarFile.create(grammarModel.openStream(), IFile.DERIVED, monitor);
					}
				}
			}

			String parserSourceFolderPathName = "Syntax/parser_src/";
			if(grammarFile.getLocalTimeStamp() > jarFile.getLocalTimeStamp()) {
				monitor.subTask("compiling grammar to jar " + jarFile.getName());
				IFolder javaFilesPath = p.getFolder(parserSourceFolderPathName + "org/eclipse/gmt/tcs/injector/");
				grammarFile.deleteMarkers(IMarker.PROBLEM, true, IResource.DEPTH_INFINITE);
				ParserGenerator parserGenerator = getParserGenerator(tss);
				if(parserGenerator == null) {
					throw new RuntimeException("Missing parser generator: " + tss.getParserGenerator() + " see http://wiki.eclipse.org/TCS/Language_Project#Installing_the_Required_Features");
				}
				parserGenerator.generate(
					grammarFile.getRawLocation().toOSString(),
					javaFilesPath.getRawLocation().toOSString(),
					new ParserGeneratorErrorListener() {	
						public void addError(String message, int lineNumber,
								int charStart, int charEnd) {
							addMarker(grammarFile, IMarker.SEVERITY_ERROR, message, lineNumber, charStart, charEnd);
						}

						public void addInfo(String message, int lineNumber,
								int charStart, int charEnd) {
							addMarker(grammarFile, IMarker.SEVERITY_INFO, message, lineNumber, charStart, charEnd);
						}

						public void addWarning(String message, int lineNumber,
								int charStart, int charEnd) {
							addMarker(grammarFile, IMarker.SEVERITY_WARNING, message, lineNumber, charStart, charEnd);
						}
					});
				IFolder syntaxFolder = p.getFolder("Syntax/"); 
				syntaxFolder.refreshLocal(IFolder.DEPTH_INFINITE, null);

				if(!isJavaProject) {
					monitor.subTask("compiling parser and lexer to jar " + jarFile.getName());
					try {
						if(jarFile.exists())
							jarFile.delete(true, monitor);
					} catch(CoreException ce) {
						// We tried to delete the jarFile, but it may be in use (e.g., by TGE).
						// In this case, we can still overwrite it.
					}
					Manifest man = new Manifest();
					man.getMainAttributes().putValue("Manifest-Version", "1.0");
					final JarOutputStream out = new JarOutputStream(new FileOutputStream(jarFile.getLocation().toFile()), man);
					final List errors = new ArrayList(); 
	
					
					List classpath = new ArrayList();
					populateClassPath(p, classpath);
					INameEnvironment ne = new FileSystem((String[])classpath.toArray(new String[] {}), new String[0], "UTF-8");
					CompilerOptions co = new CompilerOptions();
					Map options = new HashMap();
					options.put(CompilerOptions.OPTION_LocalVariableAttribute, CompilerOptions.GENERATE);
					// Java code generated by the parser generator may contain unused imports that are not worth reporting
					options.put(CompilerOptions.OPTION_ReportUnusedImport, CompilerOptions.IGNORE);
					co.set(options);
					ICompilerRequestor cr = new ICompilerRequestor() {
						public void acceptResult(CompilationResult result) {
							try {
								// TODO: report errors
								CategorizedProblem pbs[] = result.getProblems();
								boolean hasError = false;							
								IFile javaFile = p.getParent().getFile(new Path(new String(result.getFileName())));
								javaFile.deleteMarkers(IMarker.PROBLEM, true, IResource.DEPTH_INFINITE);
								if(pbs != null) {
									for(int i = 0 ; i < pbs.length ; i++) {
										CategorizedProblem pb = pbs[i];
										System.out.println(pb);
										if(pb.isError()) {
											hasError |= true;
											errors.add(pb);
											addMarker(javaFile, IMarker.SEVERITY_ERROR, pb.getMessage(), pb.getSourceLineNumber(), pb.getSourceStart(), pb.getSourceEnd() + 1);
										} else if(pb.isWarning()) {
											addMarker(javaFile, IMarker.SEVERITY_WARNING, pb.getMessage(), pb.getSourceLineNumber(), pb.getSourceStart(), pb.getSourceEnd() + 1);
										}
									}
								}
								if(!hasError) {
									ClassFile cfs[] = result.getClassFiles();
									for(int i = 0 ; i < cfs.length ; i++) {
										out.putNextEntry(new ZipEntry(new String(cfs[i].fileName()) + ".class"));
										out.write(cfs[i].getBytes());
										out.closeEntry();
									}
								}
							} catch(IOException ioe) {
								ioe.printStackTrace(System.out);
							} catch (CoreException e) {
								e.printStackTrace(System.out);
							}
						}
					};
					Compiler compiler = new Compiler(ne,  DefaultErrorHandlingPolicies.proceedWithAllProblems(), co, cr, ProblemFactory.getProblemFactory(Locale.getDefault()));
					syntaxFolder.refreshLocal(IFolder.DEPTH_INFINITE, null);
					compiler.compile(new ICompilationUnit[] {
							new ResourceCompilationUnit(javaFilesPath.getFile(name + "_ANTLR3Lexer.java")),
							new ResourceCompilationUnit(javaFilesPath.getFile(name + "_ANTLR3Parser.java")),
					});
					syntaxFolder.refreshLocal(IFolder.DEPTH_INFINITE, null);
					out.close();
	
					IFolder parserSourceFolder = p.getFolder(parserSourceFolderPathName);
					if(parserSourceFolder.exists()) {
						parserSourceFolder.setDerived(true);
					}
					if(errors.isEmpty()) {
						if(removeParserJavaSource) {
							parserSourceFolder.delete(false, null);
						}
					} else {
						jarFile.delete(true, null);
					}
					if(jarFile.exists()) {
						jarFile.refreshLocal(IResource.DEPTH_ZERO, monitor);
						jarFile.setDerived(true);
						rebuildPlugin = true;
					}
				}
			}

			Map subst = new HashMap();
//			subst.put("ammacore.path", "/AMMACore");
//			subst.put("ammacore.metamodel.dir.name", "Metamodel");
			subst.put("dsl.name", name);
			subst.put("syntax.path", "/" + name + "/Syntax");
			subst.put("syntax.tcs.filename", name + ".tcs");
			subst.put("syntax.jar.filename", name + "-parser.jar");
			subst.put("dsl.ext", ext);
//			subst.put("tge.path", "/" + name + "/TGE");
			subst.put("mm.location", "/" + name + "/Metamodel/" + name + ".ecore");
//			subst.put("injector.path", "/" + name + "/injector.xml");
//			subst.put("extractor.path", "/" + name + "/extractor.xml");

			if("true".equals(tss.getProperty("scripts.ant.create"))) {
				IFile injectorFile = p.getFile("injector.xml");
				if(!injectorFile.exists()) {
					injectorFile.create(new ByteArrayInputStream(getTemplate("templates/injector.xml", subst).getBytes()), true, null);
					injectorFile.setDerived(true);
				}
				IFile extractorFile = p.getFile("extractor.xml");
				if(!extractorFile.exists()) {
					extractorFile.create(new ByteArrayInputStream(getTemplate("templates/extractor.xml", subst).getBytes()), true, null);
					extractorFile.setDerived(true);
				}
			}


			if(!isJavaProject) {
				IFile pluginFile = p.getFile("plugin/org.eclipse.gmt.tcs.language." + name + ".jar");
				if(!pluginFile.exists()) {
					rebuildPlugin = true;
				}
				if("true".equals(tss.getProperty("plugin.create")) && rebuildPlugin) {
					IFolder pluginFolder = p.getFolder("plugin");
					if(!pluginFolder.exists()) {
						pluginFolder.create(IFolder.DERIVED + IFolder.FORCE, true, monitor);
					}
					BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(pluginFile.getRawLocation().toString()));
					JarOutputStream jout = new JarOutputStream(out);
					
					jout.putNextEntry(new ZipEntry("plugin.xml"));
					jout.write(getTemplate("templates/plugin.xml", subst).getBytes());
					
					jout.putNextEntry(new ZipEntry("META-INF/MANIFEST.MF"));
					jout.write(getTemplate("templates/MANIFEST.MF", subst).getBytes());
					
					jout.putNextEntry(new ZipEntry("resources/" + name + ".ecore"));
					IModel ecoreModel = (IModel)ct.getTarget(ct.tgtecore, models);
					extractor.extract(ecoreModel, jout, Collections.emptyMap());
	
					jout.putNextEntry(new ZipEntry("resources/" + name + "-Editor.xmi"));
					IModel editorModel = (IModel)ct.getTarget(ct.tgteditor, models);
					extractor.extract(editorModel, jout, Collections.emptyMap());
	
					jout.putNextEntry(new ZipEntry("resources/" + name + "-Outline.xmi"));
					IModel outlineModel = (IModel)ct.getTarget(ct.tgtoutline, models);
					extractor.extract(outlineModel, jout, Collections.emptyMap());
	
					jout.putNextEntry(new ZipEntry("resources/" + name + "-TCS.xmi"));
					IModel tcsModel = (IModel)ct.getTarget(ct.tgttcs, models);
					extractor.extract(tcsModel, jout, Collections.emptyMap());
	
					jout.putNextEntry(new ZipEntry("resources/" + name + "-parser.jar"));
					BufferedInputStream in = new BufferedInputStream(jarFile.getContents());
					int size;
					byte buffer[] = new byte[1024];
					while((size = in.read(buffer)) > 0) {
						jout.write(buffer, 0, size);
					}
					in.close();
	
					jout.close();
					if(!pluginFile.exists()) {
						pluginFile.refreshLocal(IResource.DEPTH_ZERO, monitor);
						pluginFile.setDerived(true);
					}
				}
			}
		} catch(IOException ioe) {
			ioe.printStackTrace(System.out);
		} catch (ATLCoreException e) {
			e.printStackTrace(System.out);
		}
		rl=null;ct=null;
		return null;
	}

	private ParserGenerator getParserGenerator(LanguageSource tss) {
		String parserGeneratorName = tss.getParserGenerator();
		ParserGenerator ret = (ParserGenerator)parserGenerators.get(parserGeneratorName);

		if(ret == null) {
			IExtensionRegistry registry = Platform.getExtensionRegistry();
	        if (registry == null) {
	            throw new RuntimeException("Extension registry not found");
	        }

			IExtensionPoint point = registry.getExtensionPoint("org.eclipse.gmt.tcs.builder.parserGenerator");//$NON-NLS-1$

			IExtension[] extensions = point.getExtensions();		
			extensions: for(int i = 0 ; i < extensions.length ; i++) {		
				IConfigurationElement[] elements = extensions[i].getConfigurationElements();
				for(int j = 0 ; j < elements.length ; j++) {
					try {
						if(elements[j].getAttribute("name").equals(parserGeneratorName)) {//$NON-NLS-1$
							ret = (ParserGenerator)elements[j].createExecutableExtension("class");
							break extensions;
						}
					} catch (CoreException e){
						throw new RuntimeException(e);
					}
				}
			}
			synchronized(parserGenerators) {
				parserGenerators.put(parserGeneratorName, ret);
			}
		}

		return ret;
	}

	private static void addMarker(IResource res, int severity, String description, int lineNumber, int charStart, int charEnd) {
		try {
			IMarker pbmMarker = res.createMarker(IMarker.PROBLEM);
			pbmMarker.setAttribute(IMarker.SEVERITY, severity);
			pbmMarker.setAttribute(IMarker.MESSAGE, description);
			pbmMarker.setAttribute(IMarker.LINE_NUMBER, (lineNumber == -1) ? 1 : lineNumber);
			pbmMarker.setAttribute(IMarker.CHAR_START, charStart);
			pbmMarker.setAttribute(IMarker.CHAR_END, charEnd);
		} catch(CoreException ce) {
			ce.printStackTrace(System.err);
		}
	}

	public static String getTemplate(String path, Map substitutions) throws IOException {
		Bundle bundle = Activator.getDefault().getBundle();
		URL templateURL = bundle.getResource("resources/" + path); //FileLocator.find(bundle, new Path("resources/" + path), Collections.EMPTY_MAP);
		BufferedInputStream in = new BufferedInputStream(templateURL.openStream());
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		int size;
		byte buffer[] = new byte[1000];
		while((size = in.read(buffer)) > 0) {
			out.write(buffer, 0, size);
		}
		String ret = out.toString();
		for(Iterator i = substitutions.keySet().iterator() ; i.hasNext() ; ) {
			String key = (String)i.next();
			String value = (String)substitutions.get(key);
			ret = ret.replaceAll("\\$\\{" + key + "}", value);
		}
		return ret;
	}

//	private void createIfMissing(IFolder f, IProgressMonitor monitor) throws CoreException {
//		if(!f.exists()) {
//			createIfMissing((IFolder)f.getParent(), monitor);
//			f.create(0,false, monitor);
//		}
//	}
	
	private void populateClassPath(IProject project, List classpath) throws IOException {
		// property: sun.boot.class.path
		// According to JDT help: If no bootclasspath is specified, the compiler will infer it using the following system properties sun.boot.class.path, vm.boot.class.path or org.apache.harmony.boot.class.path in this order respectively.
		// see example in org.eclipse.jdt.internal.compiler.batch.Main.handleBootclasspath([...])
		classpath.add(System.getProperty("java.home") + "/lib/rt.jar");

		Bundle bundle = org.eclipse.m2m.atl.dsls.Activator.getDefault().getBundle();
		URL urlPlatform = bundle.getEntry("/");
		URL localFileInPluginURL;
		localFileInPluginURL = FileLocator.toFileURL(urlPlatform);
		String atlEnginePath = localFileInPluginURL.getPath().toString();

		classpath.add(atlEnginePath + "libraries/org.eclipse.gmt.tcs.injector.jar");

		urlPlatform = Platform.getBundle("org.antlr.runtime").getEntry("/");
		localFileInPluginURL = FileLocator.toFileURL(urlPlatform);
		classpath.add(localFileInPluginURL.getPath().toString());
	}
}