path: root/core/plugins/org.eclipse.dltk.core/model/org/eclipse/dltk/internal/core/ModelManager.java

/*******************************************************************************
 * Copyright (c) 2005, 2017 IBM Corporation and others.
 * 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
 *
 *******************************************************************************/
package org.eclipse.dltk.internal.core;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.ISaveContext;
import org.eclipse.core.resources.ISaveParticipant;
import org.eclipse.core.resources.ISavedState;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.AssertionFailedException;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.preferences.DefaultScope;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
import org.eclipse.core.runtime.preferences.IPreferencesService;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.dltk.compiler.problem.IProblem;
import org.eclipse.dltk.compiler.util.HashtableOfObjectToInt;
import org.eclipse.dltk.core.BuildpathContainerInitializer;
import org.eclipse.dltk.core.DLTKContentTypeManager;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.IAccessRule;
import org.eclipse.dltk.core.IArchive;
import org.eclipse.dltk.core.IBuildpathAttribute;
import org.eclipse.dltk.core.IBuildpathContainer;
import org.eclipse.dltk.core.IBuildpathEntry;
import org.eclipse.dltk.core.IDLTKLanguageToolkit;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.IModelStatus;
import org.eclipse.dltk.core.IModelStatusConstants;
import org.eclipse.dltk.core.IParent;
import org.eclipse.dltk.core.IProblemRequestor;
import org.eclipse.dltk.core.IProjectFragment;
import org.eclipse.dltk.core.IProjectFragmentTimestamp;
import org.eclipse.dltk.core.IScriptFolder;
import org.eclipse.dltk.core.IScriptModel;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.ISourceModuleInfoCache;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.core.WorkingCopyOwner;
import org.eclipse.dltk.core.caching.IContentCache;
import org.eclipse.dltk.core.environment.EnvironmentPathUtils;
import org.eclipse.dltk.core.environment.IFileHandle;
import org.eclipse.dltk.core.search.indexing.IndexManager;
import org.eclipse.dltk.internal.core.builder.ScriptBuilder;
import org.eclipse.dltk.internal.core.caching.DLTKCoreCache;
import org.eclipse.dltk.internal.core.search.DLTKWorkspaceScope;
import org.eclipse.dltk.internal.core.search.ProjectIndexerManager;
import org.eclipse.dltk.internal.core.util.Messages;
import org.eclipse.dltk.internal.core.util.Util;
import org.eclipse.dltk.internal.core.util.WeakHashSet;
import org.eclipse.osgi.util.NLS;
import org.osgi.service.prefs.BackingStoreException;

public class ModelManager implements ISaveParticipant {
	private final static int CONTAINERS_FILE_VERSION = 1;
	public final static String BP_VARIABLE_PREFERENCES_PREFIX = DLTKCore.PLUGIN_ID
			+ ".buildpathVariable."; //$NON-NLS-1$
	public final static String BP_CONTAINER_PREFERENCES_PREFIX = DLTKCore.PLUGIN_ID
			+ ".buildpathContainer."; //$NON-NLS-1$
	public final static String BP_USERLIBRARY_PREFERENCES_PREFIX = DLTKCore.PLUGIN_ID
			+ ".userLibrary."; //$NON-NLS-1$
	public final static String BP_ENTRY_IGNORE = "##<cp entry ignore>##"; //$NON-NLS-1$
	public final static IPath BP_ENTRY_IGNORE_PATH = new Path(BP_ENTRY_IGNORE);
	public final static String TRUE = "true"; //$NON-NLS-1$
	/**
	 * Unique handle onto the Model
	 */
	final Model model = new Model();
	/**
	 * Buildpath variables pool
	 */
	public HashMap variables = new HashMap(5);
	public HashSet variablesWithInitializer = new HashSet(5);
	public HashSet readOnlyVariables = new HashSet(5);
	public HashMap previousSessionVariables = new HashMap(5);
	private ThreadLocal variableInitializationInProgress = new ThreadLocal();

	/**
	 * Buildpath containers pool
	 */
	public HashMap containers = new HashMap(5);
	public HashMap previousSessionContainers = new HashMap(5);
	private ThreadLocal containerInitializationInProgress = new ThreadLocal();
	public boolean batchContainerInitializations = false;
	public final Hashtable<String, BuildpathContainerInitializer> containerInitializersCache = new Hashtable<String, BuildpathContainerInitializer>(
			5);
	/**
	 * Special value used for recognizing ongoing initialization and breaking
	 * initialization cycles
	 */
	public final static IPath VARIABLE_INITIALIZATION_IN_PROGRESS = new Path(
			"Variable Initialization In Progress"); //$NON-NLS-1$

	public final static IBuildpathContainer CONTAINER_INITIALIZATION_IN_PROGRESS = new IBuildpathContainer() {
		@Override
		public IBuildpathEntry[] getBuildpathEntries() {
			return null;
		}

		@Override
		public String getDescription() {
			return "Container Initialization In Progress";} //$NON-NLS-1$

		@Override
		public int getKind() {
			return 0;
		}

		@Override
		public IPath getPath() {
			return null;
		}

		@Override
		public String toString() {
			return getDescription();
		}

	};
	/*
	 * A HashSet that contains the IScriptProject whose buildpath is being
	 * resolved.
	 */
	private ThreadLocal<HashSet<IScriptProject>> buildpathsBeingResolved = new ThreadLocal<HashSet<IScriptProject>>();

	public static class PerProjectInfo {
		static final IModelStatus NEED_RESOLUTION = new ModelStatus();

		public IProject project;
		public Object savedState;
		public boolean triedRead;
		public IBuildpathEntry[] rawBuildpath;
		public IModelStatus rawBuildpathStatus;
		public int rawTimeStamp = 0;
		public boolean writtingRawClasspath = false;
		public IBuildpathEntry[] resolvedBuildpath;
		public IModelStatus unresolvedEntryStatus;
		// reverse map from a package fragment root's path to the raw entry
		public Map<IPath, IBuildpathEntry> rootPathToRawEntries;
		// map from a package fragment root's path to the resolved entry
		public Map<IPath, IBuildpathEntry> rootPathToResolvedEntries;

		public IEclipsePreferences preferences;
		public Hashtable options;

		public PerProjectInfo(IProject project) {
			this.triedRead = false;
			this.savedState = null;
			this.project = project;
		}

		public synchronized IBuildpathEntry[] getResolvedBuildpath() {
			if (this.unresolvedEntryStatus == NEED_RESOLUTION)
				return null;
			return this.resolvedBuildpath;
		}

		public void rememberExternalLibTimestamps() {
			IBuildpathEntry[] buildpath = this.resolvedBuildpath;
			if (buildpath == null)
				return;
			Map<IPath, Long> externalTimeStamps = ModelManager
					.getModelManager().deltaState.getExternalLibTimeStamps();
			for (int i = 0, length = buildpath.length; i < length; i++) {
				IBuildpathEntry entry = buildpath[i];
				if (entry.getEntryKind() == IBuildpathEntry.BPE_LIBRARY) {
					IPath path = entry.getPath();
					if (externalTimeStamps.get(path) == null) {
						Object target = Model.getTarget(ResourcesPlugin
								.getWorkspace().getRoot(), path, true);
						if (target instanceof IFileHandle) {
							long timestamp = DeltaProcessor
									.getTimeStamp((IFileHandle) target);
							externalTimeStamps.put(path, new Long(timestamp));
						}
					}
				}
			}
			Map<IPath, Long> customTimeStamps = ModelManager.getModelManager().deltaState
					.getCustomTimeStamps();
			// Save custom project fragments timestamps.
			try {
				IScriptProject scriptProject = DLTKCore.create(project);
				IProjectFragment[] fragments = scriptProject
						.getAllProjectFragments();
				for (int i = 0; i < fragments.length; i++) {
					if (fragments[i] instanceof IProjectFragmentTimestamp) {
						IProjectFragmentTimestamp stamp = (IProjectFragmentTimestamp) fragments[i];
						long timeStamp = stamp.getTimeStamp();
						customTimeStamps.put(fragments[i].getPath(),
								new Long(
								timeStamp));
					}
				}
			} catch (ModelException e) {
				if (DLTKCore.DEBUG) {
					e.printStackTrace();
				}
			}
		}

		public synchronized BuildpathChange resetResolvedBuildpath() {
			return setResolvedBuildpath(null, null, null, null, rawTimeStamp,
					true);
		}

		protected BuildpathChange addBuildpathChange() {
			// remember old info
			ModelManager manager = ModelManager.getModelManager();
			BuildpathChange buildpathChange = manager.deltaState
					.addBuildpathChange(this.project, this.rawBuildpath,
							this.resolvedBuildpath);
			return buildpathChange;
		}

		public synchronized BuildpathChange setRawBuildpath(
				IBuildpathEntry[] newRawBuildpath,
				IModelStatus newRawBuildpathStatus) {
			this.rawTimeStamp++;
			return setBuildpath(newRawBuildpath, newRawBuildpathStatus,
					null/* resolved classpath */, null/* rootPathToRawEntries */,
					null/* rootPathToResolvedEntries */,
					null/* unresolved status */, true/* add classpath change */);
		}

		public synchronized BuildpathChange setResolvedBuildpath(
				IBuildpathEntry[] newResolvedClasspath,
				Map<IPath, IBuildpathEntry> newRootPathToRawEntries,
				Map<IPath, IBuildpathEntry> newRootPathToResolvedEntries,
				IModelStatus newUnresolvedEntryStatus, int timeStamp,
				boolean addBuildpathChange) {
			if (this.rawTimeStamp != timeStamp)
				return null;
			return setBuildpath(this.rawBuildpath, this.rawBuildpathStatus,
					newResolvedClasspath, newRootPathToRawEntries,
					newRootPathToResolvedEntries, newUnresolvedEntryStatus,
					addBuildpathChange);
		}

		private BuildpathChange setBuildpath(IBuildpathEntry[] newRawBuildpath,
				IModelStatus newRawBuildpathStatus,
				IBuildpathEntry[] newResolvedBuildpath,
				Map<IPath, IBuildpathEntry> newRootPathToRawEntries,
				Map<IPath, IBuildpathEntry> newRootPathToResolvedEntries,
				IModelStatus newUnresolvedEntryStatus,
				boolean addBuildpathChange) {
			BuildpathChange classpathChange = addBuildpathChange ? addBuildpathChange()
					: null;
			this.rawBuildpath = newRawBuildpath;
			this.rawBuildpathStatus = newRawBuildpathStatus;
			this.resolvedBuildpath = newResolvedBuildpath;
			this.rootPathToRawEntries = newRootPathToRawEntries;
			this.rootPathToResolvedEntries = newRootPathToResolvedEntries;
			this.unresolvedEntryStatus = newUnresolvedEntryStatus;
			return classpathChange;
		}

		/**
		 * Reads the buildpath and caches the entries. Returns an array of raw
		 * buildpath entries.
		 */
		public synchronized IBuildpathEntry[] readAndCacheBuildpath(
				ScriptProject javaProject) {
			// read file entries and update status
			IBuildpathEntry[] classpath;
			IModelStatus status;
			try {
				classpath = javaProject.readFileEntriesWithException(null/*
																		 * not
																		 * interested
																		 * in
																		 * unknown
																		 * elements
																		 */);
				status = ModelStatus.VERIFIED_OK;
			} catch (CoreException e) {
				classpath = ScriptProject.INVALID_BUILDPATH;
				status = new ModelStatus(
						IModelStatusConstants.INVALID_BUILDPATH_FILE_FORMAT,
						Messages.bind(
								Messages.buildpath_cannotReadBuildpathFile,
								javaProject.getElementName()));
			} catch (IOException e) {
				classpath = ScriptProject.INVALID_BUILDPATH;
				if (Messages.file_badFormat.equals(e.getMessage()))
					status = new ModelStatus(
							IModelStatusConstants.INVALID_BUILDPATH_FILE_FORMAT,
							Messages.bind(Messages.buildpath_xmlFormatError,
									javaProject.getElementName(),
									Messages.file_badFormat));
				else
					status = new ModelStatus(
							IModelStatusConstants.INVALID_BUILDPATH_FILE_FORMAT,
							Messages.bind(
									Messages.buildpath_cannotReadBuildpathFile,
									javaProject.getElementName()));
			} catch (/* BuildpathEntry. */AssertionFailedException e) {
				classpath = ScriptProject.INVALID_BUILDPATH;
				status = new ModelStatus(
						IModelStatusConstants.INVALID_BUILDPATH_FILE_FORMAT,
						Messages.bind(
								Messages.buildpath_illegalEntryInBuildpathFile,
								new String[] { javaProject.getElementName(),
										e.getMessage() }));
			}

			// store new raw buildpath and new status, and null out
			// resolved info
			setRawBuildpath(classpath, status);

			return classpath;
		}

		@Override
		public String toString() {
			StringBuffer buffer = new StringBuffer();
			buffer.append("Info for "); //$NON-NLS-1$
			buffer.append(this.project.getFullPath());
			buffer.append("\nRaw buildpath:\n"); //$NON-NLS-1$
			if (this.rawBuildpath == null) {
				buffer.append("  <null>\n"); //$NON-NLS-1$
			} else {
				for (int i = 0, length = this.rawBuildpath.length; i < length; i++) {
					buffer.append("  "); //$NON-NLS-1$
					buffer.append(this.rawBuildpath[i]);
					buffer.append('\n');
				}
			}
			buffer.append("Resolved buildpath:\n"); //$NON-NLS-1$
			IBuildpathEntry[] resolvedCP = this.resolvedBuildpath;
			if (resolvedCP == null) {
				buffer.append("  <null>\n"); //$NON-NLS-1$
			} else {
				for (int i = 0, length = resolvedCP.length; i < length; i++) {
					buffer.append("  "); //$NON-NLS-1$
					buffer.append(resolvedCP[i]);
					buffer.append('\n');
				}
			}
			return buffer.toString();
		}

		public boolean writeAndCacheBuildpath(ScriptProject scriptProject,
				final IBuildpathEntry[] newRawBuildpath) throws ModelException {
			try {
				this.writtingRawClasspath = true;

				// write .classpath
				if (!scriptProject.writeFileEntries(newRawBuildpath)) {
					return false;
				}
				// store new raw classpath, new output and new status, and null
				// out resolved info
				setRawBuildpath(newRawBuildpath, ModelStatus.VERIFIED_OK);
			} finally {
				this.writtingRawClasspath = false;
			}
			return true;
		}

	}

	public static class PerWorkingCopyInfo implements IProblemRequestor {
		int useCount = 0;
		IProblemRequestor problemRequestor;
		ISourceModule workingCopy;

		public PerWorkingCopyInfo(ISourceModule workingCopy,
				IProblemRequestor problemRequestor) {
			this.workingCopy = workingCopy;
			this.problemRequestor = problemRequestor;
		}

		@Override
		public void acceptProblem(IProblem problem) {
			if (this.problemRequestor == null)
				return;
			this.problemRequestor.acceptProblem(problem);
		}

		@Override
		public void beginReporting() {
			if (this.problemRequestor == null)
				return;
			this.problemRequestor.beginReporting();
		}

		@Override
		public void endReporting() {
			if (this.problemRequestor == null)
				return;
			this.problemRequestor.endReporting();
		}

		public ISourceModule getWorkingCopy() {
			return this.workingCopy;
		}

		@Override
		public boolean isActive() {
			return this.problemRequestor != null
					&& this.problemRequestor.isActive();
		}

		@Override
		public String toString() {
			StringBuffer buffer = new StringBuffer();
			buffer.append("Info for "); //$NON-NLS-1$
			buffer.append(((ModelElement) this.workingCopy)
					.toStringWithAncestors());
			buffer.append("\nUse count = "); //$NON-NLS-1$
			buffer.append(this.useCount);
			buffer.append("\nProblem requestor:\n  "); //$NON-NLS-1$
			buffer.append(this.problemRequestor);
			return buffer.toString();
		}
	}

	public static boolean VERBOSE = DLTKCore.VERBOSE_MODEL_MANAGER;
	public static boolean BP_RESOLVE_VERBOSE = DLTKCore.VERBOSE_BP_RESOLVE;
	public static final boolean BP_RESOLVE_VERBOSE_ADVANCED = false;
	/**
	 * Name of the extension point for contributing buildpath variable
	 * initializers
	 */
	public static final String BPVARIABLE_INITIALIZER_EXTPOINT_ID = "buildpathVariableInitializer"; //$NON-NLS-1$

	/**
	 * Name of the extension point for contributing buildpath container
	 * initializers
	 */
	public static final String BPCONTAINER_INITIALIZER_EXTPOINT_ID = "buildpathContainerInitializer"; //$NON-NLS-1$
	public static boolean ZIP_ACCESS_VERBOSE = DLTKCore.VERBOSE_ZIP_ACCESS;
	/**
	 * A cache of opened zip files per thread. (for a given thread, the object
	 * value is a HashMap from IPath to java.io.ZipFile)
	 */
	private ThreadLocal<Map<IPath, IArchive>> zipFiles = new ThreadLocal<Map<IPath, IArchive>>();

	private UserLibraryManager userLibraryManager;

	public final static ISourceModule[] NO_WORKING_COPY = new ISourceModule[0];
	/**
	 * The singleton manager
	 */
	private static ModelManager MANAGER = new ModelManager();
	/**
	 * Infos cache.
	 */
	public ModelCache cache;// = new ModelCache();
	/*
	 * Temporary cache of newly opened elements
	 */
	private ThreadLocal temporaryCache = new ThreadLocal();
	/**
	 * Set of elements which are out of sync with their buffers.
	 */
	protected HashSet<Openable> elementsOutOfSynchWithBuffers = new HashSet<Openable>(
			11);
	/**
	 * Holds the state used for delta processing.
	 */
	public DeltaProcessingState deltaState = new DeltaProcessingState();
	public IndexManager indexManager;
	/**
	 * Table from IProject to PerProjectInfo. NOTE: this object itself is used
	 * as a lock to synchronize creation/removal of per project infos
	 */
	protected Map perProjectInfos = new HashMap(5);
	/**
	 * Table from WorkingCopyOwner to a table of ISourceModule (working copy
	 * handle) to PerWorkingCopyInfo. NOTE: this object itself is used as a lock
	 * to synchronize creation/removal of per working copy infos
	 */
	protected Map perWorkingCopyInfos = new HashMap(5);
	public final IEclipsePreferences[] preferencesLookup = new IEclipsePreferences[2];
	static final int PREF_INSTANCE = 0;
	static final int PREF_DEFAULT = 1;
	// Preferences
	HashSet<String> optionNames = new HashSet<String>(20);
	Hashtable<String, String> optionsCache;
	/*
	 * Pools of symbols used in the model. Used as a replacement for
	 * String#intern() that could prevent garbage collection of strings on some
	 * VMs.
	 */
	private WeakHashSet stringSymbols = new WeakHashSet(5);
	Map workspaceScope = null;
	public static final String DELTA_LISTENER_PERF = DLTKCore.PLUGIN_ID
			+ "/perf/deltalistener"; //$NON-NLS-1$

	private ExternalFoldersManager externalFoldersManager = new ExternalFoldersManager();
	private DLTKCoreCache coreCache = null;

	final boolean resolveReferencedLibrariesForContainers = false;

	public IContentCache getCoreCache() {
		if (coreCache == null) {
			coreCache = new DLTKCoreCache();
		}
		return coreCache;
	}

	/**
	 * Listener on properties changes.
	 */
	private IEclipsePreferences.IPreferenceChangeListener propertyListener;
	private IEclipsePreferences.IPreferenceChangeListener resourcesPropertyListener;

	/**
	 * Constructs a new ModelManager
	 */
	private ModelManager() {
		// singleton: prevent others from creating a new instance
		if (Platform.isRunning())
			this.indexManager = new IndexManager();
	}

	/**
	 * Returns the handle to the active script model.
	 */
	public final Model getModel() {
		return this.model;
	}

	/**
	 * Returns the singleton ModelManager
	 */
	public final static ModelManager getModelManager() {
		return MANAGER;
	}

	public static DeltaProcessingState getDeltaState() {
		return MANAGER.deltaState;
	}

	/**
	 * Returns the set of elements which are out of synch with their buffers.
	 */
	protected HashSet<Openable> getElementsOutOfSynchWithBuffers() {
		return this.elementsOutOfSynchWithBuffers;
	}

	/**
	 * Returns the info for the element.
	 */
	public synchronized Object getInfo(IModelElement element) {
		HashMap tempCache = (HashMap) this.temporaryCache.get();
		if (tempCache != null) {
			Object result = tempCache.get(element);
			if (result != null) {
				return result;
			}
		}
		return this.cache.getInfo(element);
	}

	/**
	 * Returns the info for this element without disturbing the cache ordering.
	 */
	protected synchronized Object peekAtInfo(IModelElement element) {
		HashMap tempCache = (HashMap) this.temporaryCache.get();
		if (tempCache != null) {
			Object result = tempCache.get(element);
			if (result != null) {
				return result;
			}
		}
		return this.cache.peekAtInfo(element);
	}

	/*
	 * Removes all cached info for the given element (including all children)
	 * from the cache. Returns the info for the given element, or null if it was
	 * closed.
	 */
	public synchronized Object removeInfoAndChildren(ModelElement element)
			throws ModelException {
		Object info = this.cache.peekAtInfo(element);
		if (info != null) {
			boolean wasVerbose = false;
			try {
				if (VERBOSE) {
					String elementType;
					switch (element.getElementType()) {
					case IModelElement.SCRIPT_PROJECT:
						elementType = "project"; //$NON-NLS-1$
						break;
					case IModelElement.PROJECT_FRAGMENT:
						elementType = "root"; //$NON-NLS-1$
						break;
					case IModelElement.SCRIPT_FOLDER:
						elementType = "folder"; //$NON-NLS-1$
						break;
					case IModelElement.BINARY_MODULE:
						elementType = "binary module"; //$NON-NLS-1$
						break;
					case IModelElement.SOURCE_MODULE:
						elementType = "source module"; //$NON-NLS-1$
						break;
					default:
						elementType = "element"; //$NON-NLS-1$
					}
					System.out
							.println(Thread.currentThread()
									+ " CLOSING " + elementType + " " + element.toStringWithAncestors()); //$NON-NLS-1$//$NON-NLS-2$
					wasVerbose = true;
					VERBOSE = false;
				}
				element.closing(info);
				if (element instanceof IParent
						&& info instanceof ModelElementInfo) {
					IModelElement[] children = ((ModelElementInfo) info)
							.getChildren();
					for (int i = 0, size = children.length; i < size; ++i) {
						ModelElement child = (ModelElement) children[i];
						child.close();
					}
				}
				this.cache.removeInfo(element);
				if (wasVerbose) {
					System.out.println(this.cache.toStringFillingRation("-> ")); //$NON-NLS-1$
				}
			} finally {
				ModelManager.VERBOSE = wasVerbose;
			}
			return info;
		}
		return null;
	}

	/*
	 * Puts the infos in the given map (keys are IModelElements and values are
	 * ModelElementInfos) in the model cache in an atomic way. First checks that
	 * the info for the opened element (or one of its ancestors) has not been
	 * added to the cache. If it is the case, another thread has opened the
	 * element (or one of its ancestors). So returns without updating the cache.
	 */
	protected synchronized void putInfos(IModelElement openedElement,
			Map newElements) {
		// remove children
		Object existingInfo = this.cache.peekAtInfo(openedElement);
		if (openedElement instanceof IParent
				&& existingInfo instanceof ModelElementInfo) {
			IModelElement[] children = ((ModelElementInfo) existingInfo)
					.getChildren();
			for (int i = 0, size = children.length; i < size; ++i) {
				ModelElement child = (ModelElement) children[i];
				try {
					child.close();
				} catch (ModelException e) {
					// ignore
				}
			}
		}
		// Need to put any ArchiveProjectFragment in first.
		// This is due to the way the LRU cache flushes entries.
		// When a BinaryFolder is flused from the LRU cache, the entire
		// archive is flushed by removing the ArchiveProjectFragment and all of
		// its
		// children (see ElementCache.close()). If we flush the BinaryFolder
		// when its ArchiveProjectFragment is not in the cache and the root is
		// about to be
		// added (during the 'while' loop), we will end up in an inconsist
		// state.
		// Subsequent resolution against package in the archive would fail as a
		// result.
		for (Iterator it = newElements.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			IModelElement element = (IModelElement) entry.getKey();
			if (element instanceof ArchiveProjectFragment
					|| element instanceof ExternalScriptFolder) {
				Object info = entry.getValue();
				it.remove();
				this.cache.putInfo(element, info);
			}
		}
		Iterator iterator = newElements.keySet().iterator();
		while (iterator.hasNext()) {
			IModelElement element = (IModelElement) iterator.next();
			Object info = newElements.get(element);
			this.cache.putInfo(element, info);
		}
	}

	/**
	 * Returns the temporary cache for newly opened elements for the current
	 * thread. Creates it if not already created.
	 */
	public HashMap getTemporaryCache() {
		HashMap result = (HashMap) this.temporaryCache.get();
		if (result == null) {
			result = new HashMap();
			this.temporaryCache.set(result);
		}
		return result;
	}

	/*
	 * Resets the temporary cache for newly created elements to null.
	 */
	public void resetTemporaryCache() {
		this.temporaryCache.set(null);
	}

	/*
	 * Returns whether there is a temporary cache for the current thread.
	 */
	public boolean hasTemporaryCache() {
		return this.temporaryCache.get() != null;
	}

	/**
	 * Returns the model element corresponding to the given file, its project
	 * being the given project. Returns <code>null</code> if unable to associate
	 * the given file with a model element.
	 * 
	 * Creating a model element has the side effect of creating and opening all
	 * of the element's parents if they are not yet open.
	 */
	public static IModelElement create(IFile file, IScriptProject project) {
		if (file == null) {
			return null;
		}
		if (project == null) {
			project = DLTKCore.create(file.getProject());
		}
		// FIXME at the moment we can create source modules only
		if (Util.isValidSourceModule(project, file)) {
			return createSourceModuleFrom(file, project);
		}
		return null;
	}

	/**
	 * Creating an element has the side effect of creating and opening all of
	 * the element's parents if they are not yet open.
	 */
	public static IModelElement create(IResource resource,
			IScriptProject project) {
		if (resource == null) {
			return null;
		}
		int type = resource.getType();
		switch (type) {
		case IResource.PROJECT:
			return DLTKCore.create((IProject) resource);
		case IResource.FILE:
			return create((IFile) resource, project);
		case IResource.FOLDER:
			return create((IFolder) resource, project);
		case IResource.ROOT:
			return DLTKCore.create((IWorkspaceRoot) resource);
		default:
			return null;
		}
	}

	public static IModelElement create(IFolder folder, IScriptProject project) {
		if (folder == null) {
			return null;
		}
		IModelElement element;
		if (project == null) {
			project = DLTKCore.create(folder.getProject());
			element = determineIfOnBuildpath(folder, project);
			if (element == null) {
				// walk all projects and find one that have the given folder on
				// its buildpath
				IScriptProject[] projects;
				try {
					projects = ModelManager.getModelManager().getModel()
							.getScriptProjects();
				} catch (ModelException e) {
					return null;
				}
				for (int i = 0, length = projects.length; i < length; i++) {
					project = projects[i];
					element = determineIfOnBuildpath(folder, project);
					if (element != null)
						break;
				}
			}
		} else {
			element = determineIfOnBuildpath(folder, project);
		}
		return element;
	}

	/**
	 * Creates and returns a source module element for the given file, its
	 * project being the given project. Returns <code>null</code> if unable to
	 * recognize the source module.
	 */
	public static ISourceModule createSourceModuleFrom(IFile file,
			IScriptProject project) {
		if (file == null)
			return null;
		if (project == null) {
			project = DLTKCore.create(file.getProject());
		}
		IScriptFolder folder = (IScriptFolder) determineIfOnBuildpath(file,
				project);
		if (folder == null) {
			// not on buildpath - make the root its folder
			IProjectFragment root = project
					.getProjectFragment(file.getParent());
			folder = root.getScriptFolder(Path.EMPTY);
			if (VERBOSE) {
				System.out
						.println("WARNING : creating module element outside buildpath (" + Thread.currentThread() + "): " + file.getFullPath()); //$NON-NLS-1$//$NON-NLS-2$
			}
		}
		return folder.getSourceModule(file.getName());
	}

	/**
	 * Returns the project fragment root represented by the resource, or the
	 * folder the given resource is located in, or <code>null</code> if the
	 * given resource is not on the buildpath of the given project.
	 */
	public static IModelElement determineIfOnBuildpath(IResource resource,
			IScriptProject project) {
		IPath resourcePath = resource.getFullPath();
		try {
			IBuildpathEntry[] entries = ((ScriptProject) project)
					.getResourceOnlyResolvedBuildpath();

			for (int i = 0; i < entries.length; i++) {
				IBuildpathEntry entry = entries[i];
				if (entry.getEntryKind() == IBuildpathEntry.BPE_PROJECT)
					continue;
				IPath rootPath = entry.getPath();
				if (rootPath.equals(resourcePath)) {
					return project.getProjectFragment(resource);
				} else if (rootPath.isPrefixOf(resourcePath)) {
					BuildpathEntry bpe = (BuildpathEntry) entry;
					if (!Util.isExcluded(resource,
							bpe.fullInclusionPatternChars(),
							bpe.fullExclusionPatternChars())) {
						/*
						 * given we have a resource child of the root, it cannot
						 * be a ZIP fragment
						 */
						IProjectFragment root = ((ScriptProject) project)
								.getFolderProjectFragment(rootPath);
						if (root == null)
							return null;
						IPath folderPath = resourcePath
								.removeFirstSegments(rootPath.segmentCount());
						if (resource.getType() == IResource.FILE) {
							/*
							 * if the resource is a file, then remove the last
							 * segment which is the file name in the folder
							 */
							folderPath = folderPath.removeLastSegments(1);
						}
						return root.getScriptFolder(folderPath);
					}
				}
			}
		} catch (ModelException npe) {
			return null;
		}
		return null;
	}

	/*
	 * Returns the per-project info for the given project. If specified, create
	 * the info if the info doesn't exist.
	 */
	public PerProjectInfo getPerProjectInfo(IProject project, boolean create) {
		synchronized (this.perProjectInfos) { // use the perProjectInfo
			// collection as its own lock
			PerProjectInfo info = (PerProjectInfo) this.perProjectInfos
					.get(project);
			if (info == null && create) {
				info = new PerProjectInfo(project);
				this.perProjectInfos.put(project, info);
			}
			return info;
		}
	}

	/*
	 * Returns the per-project info for the given project. If the info doesn't
	 * exist, check for the project existence and create the info. @throws
	 * ModelException if the project doesn't exist.
	 */
	public PerProjectInfo getPerProjectInfoCheckExistence(IProject project)
			throws ModelException {
		ModelManager.PerProjectInfo info = getPerProjectInfo(project, false /*
																			 * don't
																			 * create
																			 * info
																			 */);
		if (info == null) {
			if (!ScriptProject.hasScriptNature(project)) {
				throw ((ScriptProject) DLTKCore.create(project))
						.newNotPresentException();
			}
			info = getPerProjectInfo(project, true /* create info */);
		}
		return info;
	}

	/*
	 * Returns the per-working copy info for the given working copy at the given
	 * path. If it doesn't exist and if create, add a new per-working copy info
	 * with the given problem requestor. If recordUsage, increment the
	 * per-working copy info's use count. Returns null if it doesn't exist and
	 * not create.
	 */
	public PerWorkingCopyInfo getPerWorkingCopyInfo(SourceModule workingCopy,
			boolean create, boolean recordUsage,
			IProblemRequestor problemRequestor) {
		synchronized (this.perWorkingCopyInfos) {
			// use the perWorkingCopyInfo collection as its own lock
			WorkingCopyOwner owner = workingCopy.getOwner();
			Map workingCopyToInfos = (Map) this.perWorkingCopyInfos.get(owner);
			if (workingCopyToInfos == null && create) {
				workingCopyToInfos = new HashMap();
				this.perWorkingCopyInfos.put(owner, workingCopyToInfos);
			}
			PerWorkingCopyInfo info = workingCopyToInfos == null ? null
					: (PerWorkingCopyInfo) workingCopyToInfos.get(workingCopy);
			if (info == null && create) {
				info = new PerWorkingCopyInfo(workingCopy, problemRequestor);
				workingCopyToInfos.put(workingCopy, info);
			}
			if (info != null && recordUsage)
				info.useCount++;
			return info;
		}
	}

	/*
	 * Returns all the working copies which have the given owner. Adds the
	 * working copies of the primary owner if specified. Returns null if it has
	 * none.
	 */
	public ISourceModule[] getWorkingCopies(WorkingCopyOwner owner,
			boolean addPrimary) {
		synchronized (this.perWorkingCopyInfos) {
			ISourceModule[] primaryWCs = addPrimary
					&& owner != DefaultWorkingCopyOwner.PRIMARY ? getWorkingCopies(
					DefaultWorkingCopyOwner.PRIMARY, false) : null;
			Map workingCopyToInfos = (Map) this.perWorkingCopyInfos.get(owner);
			if (workingCopyToInfos == null)
				return primaryWCs;
			int primaryLength = primaryWCs == null ? 0 : primaryWCs.length;
			int size = workingCopyToInfos.size(); // note size is > 0
			// otherwise
			// pathToPerWorkingCopyInfos
			// would be null
			ISourceModule[] result = new ISourceModule[primaryLength + size];
			int index = 0;
			if (primaryWCs != null) {
				for (int i = 0; i < primaryLength; i++) {
					ISourceModule primaryWorkingCopy = primaryWCs[i];
					boolean validSrcModule = false;
					IResource res = primaryWorkingCopy.getResource();
					if (res != null) {
						validSrcModule = Util.isValidSourceModule(
								primaryWorkingCopy, res);
					} else {
						validSrcModule = Util.isValidSourceModule(
								primaryWorkingCopy,
								primaryWorkingCopy.getPath());
					}
					if (validSrcModule) {
						ISourceModule workingCopy = new SourceModule(
								(ModelElement) primaryWorkingCopy.getParent(),
								primaryWorkingCopy.getElementName(), owner);
						if (!workingCopyToInfos.containsKey(workingCopy))
							result[index++] = primaryWorkingCopy;
					} else {
						System.err.println("Not valid primary working copy:" //$NON-NLS-1$
								+ primaryWorkingCopy.getElementName());
					}
				}
				if (index != primaryLength)
					System.arraycopy(result, 0,
							result = new ISourceModule[index + size], 0, index);
			}
			Iterator iterator = workingCopyToInfos.values().iterator();
			while (iterator.hasNext()) {
				result[index++] = ((ModelManager.PerWorkingCopyInfo) iterator
						.next()).getWorkingCopy();
			}
			return result;
		}
	}

	public DeltaProcessor getDeltaProcessor() {
		return this.deltaState.getDeltaProcessor();
	}

	public static ExternalFoldersManager getExternalManager() {
		return MANAGER.externalFoldersManager;
	}

	public IndexManager getIndexManager() {
		return this.indexManager;
	}

	public Object getLastBuiltState(IProject project, IProgressMonitor monitor) {
		if (!DLTKLanguageManager.hasScriptNature(project)) {
			if (ScriptBuilder.DEBUG)
				System.out.println(project + " is not a Java project"); //$NON-NLS-1$
			return null; // should never be requested on non-Java projects
		}
		PerProjectInfo info = getPerProjectInfo(project, true/*
															 * create if missing
															 */);
		if (!info.triedRead) {
			info.triedRead = true;
			try {
				if (monitor != null)
					monitor.subTask(Messages.bind(
							Messages.build_readStateProgress, project.getName()));
				info.savedState = readState(project);
			} catch (CoreException e) {
				e.printStackTrace();
			}
		}
		return info.savedState;
	}

	public String getOption(String optionName) {
		if (DLTKCore.CORE_ENCODING.equals(optionName)) {
			return DLTKCore.getEncoding();
		}
		String propertyName = optionName;
		if (this.optionNames.contains(propertyName)) {
			IPreferencesService service = Platform.getPreferencesService();
			String value = service
					.get(optionName, null, this.preferencesLookup);
			return value == null ? null : value.trim();
		}
		return null;
	}

	/**
	 * Get workpsace eclipse preference for ScriptCore plugin.
	 */
	public IEclipsePreferences getInstancePreferences() {
		return preferencesLookup[PREF_INSTANCE];
	}

	public void setOptions(Hashtable newOptions) {
		try {
			IEclipsePreferences defaultPreferences = getDefaultPreferences();
			IEclipsePreferences instancePreferences = getInstancePreferences();
			if (newOptions == null) {
				instancePreferences.clear();
			} else {
				Enumeration keys = newOptions.keys();
				while (keys.hasMoreElements()) {
					String key = (String) keys.nextElement();
					if (!this.optionNames.contains(key))
						continue; // unrecognized option
					if (key.equals(DLTKCore.CORE_ENCODING))
						continue; // skipped, contributed by resource prefs
					String value = (String) newOptions.get(key);
					String defaultValue = defaultPreferences.get(key, null);
					if (defaultValue != null && defaultValue.equals(value)) {
						instancePreferences.remove(key);
					} else {
						instancePreferences.put(key, value);
					}
				}
			}
			// persist options
			instancePreferences.flush();
			// update cache
			this.optionsCache = newOptions == null ? null : new Hashtable(
					newOptions);
		} catch (BackingStoreException e) {
			// ignore
		}
	}

	public Hashtable<String, String> getOptions() {
		// return cached options if already computed
		if (this.optionsCache != null)
			return new Hashtable<String, String>(this.optionsCache);
		if (!Platform.isRunning()) {
			return this.optionsCache = getDefaultOptionsNoInitialization();
		}
		// init
		Hashtable<String, String> options = new Hashtable<String, String>(10);
		IPreferencesService service = Platform.getPreferencesService();
		// set options using preferences service lookup
		for (String propertyName : optionNames) {
			String propertyValue = service.get(propertyName, null,
					this.preferencesLookup);
			if (propertyValue != null) {
				options.put(propertyName, propertyValue);
			}
		}
		// get encoding through resource plugin
		options.put(DLTKCore.CORE_ENCODING, DLTKCore.getEncoding());
		// store built map in cache
		this.optionsCache = new Hashtable<String, String>(options);
		// return built map
		return options;
	}

	/*
	 * Reset project options stored in info cache.
	 */
	public void resetProjectOptions(ScriptProject scriptProject) {
		synchronized (this.perProjectInfos) { // use the perProjectInfo
			// collection as its own lock
			IProject project = scriptProject.getProject();
			PerProjectInfo info = (PerProjectInfo) this.perProjectInfos
					.get(project);
			if (info != null) {
				info.options = null;
			}
		}
	}

	/*
	 * Reset project preferences stored in info cache.
	 */
	public void resetProjectPreferences(ScriptProject scriptProject) {
		synchronized (this.perProjectInfos) { // use the perProjectInfo
			// collection as its own lock
			IProject project = scriptProject.getProject();
			PerProjectInfo info = (PerProjectInfo) this.perProjectInfos
					.get(project);
			if (info != null) {
				info.preferences = null;
			}
		}
	}

	public void setBuildpathBeingResolved(IScriptProject project,
			boolean buildpathIsResolved) {
		if (buildpathIsResolved) {
			getBuildpathBeingResolved().add(project);
		} else {
			getBuildpathBeingResolved().remove(project);
		}
	}

	private HashSet<IScriptProject> getBuildpathBeingResolved() {
		HashSet<IScriptProject> result = this.buildpathsBeingResolved.get();
		if (result == null) {
			result = new HashSet<IScriptProject>();
			this.buildpathsBeingResolved.set(result);
		}
		return result;
	}

	public boolean isBuildpathBeingResolved(IScriptProject project) {
		return getBuildpathBeingResolved().contains(project);
	}

	/*
	 * Discards the per working copy info for the given working copy (making it
	 * a compilation unit) if its use count was 1. Otherwise, just decrement the
	 * use count. If the working copy is primary, computes the delta between its
	 * state and the original compilation unit and register it. Close the
	 * working copy, its buffer and remove it from the shared working copy
	 * table. Ignore if no per-working copy info existed. NOTE: it must NOT be
	 * synchronized as it may interact with the element info cache (if useCount
	 * is decremented to 0), see bug 50667. Returns the new use count (or -1 if
	 * it didn't exist).
	 */
	public int discardPerWorkingCopyInfo(SourceModule workingCopy)
			throws ModelException {
		// create the delta builder (this remembers the current content of the
		// working copy)
		// outside the perWorkingCopyInfos lock (see bug 50667)
		ModelElementDeltaBuilder deltaBuilder = null;
		if (workingCopy.isPrimary() && workingCopy.hasUnsavedChanges()) {
			deltaBuilder = new ModelElementDeltaBuilder(workingCopy);
		}
		PerWorkingCopyInfo info = null;
		synchronized (this.perWorkingCopyInfos) {
			WorkingCopyOwner owner = workingCopy.getOwner();
			Map workingCopyToInfos = (Map) this.perWorkingCopyInfos.get(owner);
			if (workingCopyToInfos == null)
				return -1;
			info = (PerWorkingCopyInfo) workingCopyToInfos.get(workingCopy);
			if (info == null)
				return -1;
			if (--info.useCount == 0) {
				// remove per working copy info
				workingCopyToInfos.remove(workingCopy);
				if (workingCopyToInfos.isEmpty()) {
					this.perWorkingCopyInfos.remove(owner);
				}
			}
		}
		if (info.useCount == 0) { // info cannot be null here (check was done
			// above)
			// remove infos + close buffer (since no longer working copy)
			// outside the perWorkingCopyInfos lock (see bug 50667)
			removeInfoAndChildren(workingCopy);
			workingCopy.closeBuffer();
			// compute the delta if needed and register it if there are changes
			if (deltaBuilder != null) {
				getSourceModuleInfoCache().remove(workingCopy);
				deltaBuilder.buildDeltas();
				if ((deltaBuilder.delta != null)
						&& (deltaBuilder.delta.getAffectedChildren().length > 0)) {
					getDeltaProcessor().registerModelDelta(deltaBuilder.delta);
				}
			}
		}
		return info.useCount;
	}

	public synchronized String intern(String s) {
		// make sure to copy the string (so that it doesn't hold on the
		// underlying char[] that might be much bigger than necessary)
		return (String) this.stringSymbols.add(s);
	}

	public void startup() throws CoreException {
		try {
			// initialize Model model cache
			this.cache = new ModelCache();
			// request state folder creation (workaround 19885)
			DLTKCore.getPlugin().getStateLocation();
			// Initialize eclipse preferences
			initializePreferences();
			// Listen to preference changes
			this.propertyListener = event -> ModelManager.this.optionsCache = null;
			installPreferenceChangeListener(DLTKCore.PLUGIN_ID,
					this.propertyListener);
			// listen for encoding changes (see
			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=255501 )
			this.resourcesPropertyListener = event -> {
				if (ResourcesPlugin.PREF_ENCODING.equals(event.getKey())) {
					ModelManager.this.optionsCache = null;
				}
			};
			installPreferenceChangeListener(ResourcesPlugin.getPlugin()
					.getBundle().getSymbolicName(),
					this.resourcesPropertyListener);
			long start = -1;
			if (VERBOSE)
				start = System.currentTimeMillis();
			loadContainers();
			if (VERBOSE)
				traceContainers("Loaded", start); //$NON-NLS-1$
			final IWorkspace workspace = ResourcesPlugin.getWorkspace();
			workspace.addResourceChangeListener(this.deltaState,
					IResourceChangeEvent.PRE_BUILD
							| IResourceChangeEvent.POST_BUILD
							| IResourceChangeEvent.POST_CHANGE
							| IResourceChangeEvent.PRE_DELETE
							| IResourceChangeEvent.PRE_CLOSE);
			DLTKContentTypeManager.installListener();
			sourceModuleInfoCache = new SourceModuleInfoCache();
			sourceModuleInfoCache.start();
			startIndexing();
			// process deltas since last activated in indexer thread so that
			// indexes are up-to-date.
			// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38658
			Job processSavedState = new Job(Messages.savedState_jobName) {
				@Override
				protected IStatus run(IProgressMonitor monitor) {
					try {
						// add save participant and process delta atomically
						// see
						// https://bugs.eclipse.org/bugs/show_bug.cgi?id=59937
						workspace.run(progress -> {
							ISavedState savedState = workspace
									.addSaveParticipant(DLTKCore.getPlugin(),
											ModelManager.this);
							if (savedState != null) {
								// the event type coming from the saved
								// state is always POST_AUTO_BUILD
								// force it to be POST_CHANGE so that the
								// delta processor can handle it
								ModelManager.this.deltaState
										.getDeltaProcessor().overridenEventType = IResourceChangeEvent.POST_CHANGE;
								savedState.processResourceChangeEvents(
										ModelManager.this.deltaState);
							}
						}, monitor);
					} catch (CoreException e) {
						return e.getStatus();
					}
					return Status.OK_STATUS;
				}
			};
			processSavedState.setSystem(true);
			processSavedState.setPriority(Job.SHORT); // process asap
			processSavedState.schedule();
		} catch (RuntimeException e) {
			shutdown();
			throw e;
		}
	}

	private static IEclipsePreferences getPluginPreferences(String pluginId) {
		return InstanceScope.INSTANCE.getNode(pluginId);
	}

	private static void installPreferenceChangeListener(String pluginId,
			IPreferenceChangeListener listener) {
		getPluginPreferences(pluginId).addPreferenceChangeListener(listener);
	}

	private void startIndexing() {
		if (indexManager != null) {
			indexManager.reset();
			// create contributed indexers in a job, so
			// dltk.core initialization completes earlier.
			final Job startIndexing = new Job("DLTK indexing initialization") {
				@Override
				protected IStatus run(IProgressMonitor monitor) {
					ProjectIndexerManager.startIndexing();
					return Status.OK_STATUS;
				}
			};
			startIndexing.setSystem(true);
			startIndexing.setPriority(Job.BUILD);
			startIndexing.schedule();
		}
	}

	/**
	 * Update the buildpath variable cache
	 */
	public static class EclipsePreferencesListener implements
			IEclipsePreferences.IPreferenceChangeListener {
		/**
		 * @see org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener#preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent)
		 */
		@Override
		public void preferenceChange(
				IEclipsePreferences.PreferenceChangeEvent event) {
			String propertyName = event.getKey();
			if (propertyName.startsWith(BP_CONTAINER_PREFERENCES_PREFIX)) {
				recreatePersistedContainer(propertyName,
						(String) event.getNewValue(), false);
			} else if (propertyName
					.startsWith(BP_USERLIBRARY_PREFERENCES_PREFIX)) {
				String libName = propertyName
						.substring(BP_USERLIBRARY_PREFERENCES_PREFIX.length());
				UserLibraryManager manager = ModelManager
						.getUserLibraryManager();
				manager.updateUserLibrary(libName, (String) event.getNewValue());
			}
		}
	}

	/**
	 * Reads the build state for the relevant project.
	 */
	protected Object readState(IProject project) throws CoreException {
		File file = getSerializationFile(project);
		if (file != null && file.exists()) {
			try {
				DataInputStream in = new DataInputStream(
						new BufferedInputStream(new FileInputStream(file)));
				try {
					String pluginID = in.readUTF();
					if (!pluginID.equals(DLTKCore.PLUGIN_ID))
						throw new IOException(Messages.build_wrongFileFormat);
					String kind = in.readUTF();
					if (!kind.equals("STATE")) //$NON-NLS-1$
						throw new IOException(Messages.build_wrongFileFormat);
					if (in.readBoolean())
						return ScriptBuilder.readState(project, in);
					if (ScriptBuilder.DEBUG)
						System.out
								.println("Saved state thinks last build failed for " + project.getName()); //$NON-NLS-1$
				} finally {
					in.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
				throw new CoreException(
						new Status(
								IStatus.ERROR,
								DLTKCore.PLUGIN_ID,
								Platform.PLUGIN_ERROR,
								"Error reading last build state for project " + project.getName(), e)); //$NON-NLS-1$
			}
		} else if (ScriptBuilder.DEBUG) {
			if (file == null)
				System.out.println("Project does not exist: " + project); //$NON-NLS-1$
			else
				System.out
						.println("Build state file " + file.getPath() + " does not exist"); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return null;
	}

	public static void recreatePersistedContainer(String propertyName,
			String containerString, boolean addToContainerValues) {
		int containerPrefixLength = BP_CONTAINER_PREFERENCES_PREFIX.length();
		int index = propertyName.indexOf('|', containerPrefixLength);
		if (containerString != null)
			containerString = containerString.trim();
		if (index > 0) {
			String projectName = propertyName.substring(containerPrefixLength,
					index).trim();
			IScriptProject project = getModelManager().getModel()
					.getScriptProject(projectName);
			IPath containerPath = new Path(propertyName.substring(index + 1)
					.trim());
			recreatePersistedContainer(project, containerPath, containerString,
					addToContainerValues);
		}
	}

	private static void recreatePersistedContainer(
			final IScriptProject project, final IPath containerPath,
			String containerString, boolean addToContainerValues) {
		if (!project.getProject().isAccessible())
			return; // avoid leaking deleted project's persisted container
		if (containerString == null) {
			getModelManager().containerPut(project, containerPath, null);
		} else {
			IBuildpathEntry[] entries;
			try {
				entries = ((ScriptProject) project).decodeBuildpath(
						containerString, null/*
											 * not interested in unknown
											 * elements
											 */);
			} catch (IOException e) {
				Util.log(
						e,
						"Could not recreate persisted container: \n" + containerString); //$NON-NLS-1$
				entries = ScriptProject.INVALID_BUILDPATH;
			}
			if (entries != ScriptProject.INVALID_BUILDPATH) {
				final IBuildpathEntry[] containerEntries = entries;
				IBuildpathContainer container = new IBuildpathContainer() {
					@Override
					public IBuildpathEntry[] getBuildpathEntries() {
						return containerEntries;
					}

					@Override
					public String getDescription() {
						return "Persisted container [" + containerPath + " for project [" + project.getElementName() + "]"; //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
					}

					@Override
					public int getKind() {
						return 0;
					}

					@Override
					public IPath getPath() {
						return containerPath;
					}

					@Override
					public String toString() {
						return getDescription();
					}

				};
				if (addToContainerValues) {
					getModelManager().containerPut(project, containerPath,
							container);
				}
				Map projectContainers = (Map) getModelManager().previousSessionContainers
						.get(project);
				if (projectContainers == null) {
					projectContainers = new HashMap(1);
					getModelManager().previousSessionContainers.put(project,
							projectContainers);
				}
				projectContainers.put(containerPath, container);
			}
		}
	}

	/**
	 * Initialize preferences lookups for DLTKCore plugin.
	 */
	public void initializePreferences() {
		// Create lookups
		preferencesLookup[PREF_INSTANCE] = InstanceScope.INSTANCE
				.getNode(DLTKCore.PLUGIN_ID);
		preferencesLookup[PREF_DEFAULT] = DefaultScope.INSTANCE
				.getNode(DLTKCore.PLUGIN_ID);
		// Listen to instance preferences node removal from parent in order to
		// refresh stored one
		IEclipsePreferences.INodeChangeListener listener = new IEclipsePreferences.INodeChangeListener() {
			@Override
			public void added(IEclipsePreferences.NodeChangeEvent event) {
				// do nothing
			}

			@Override
			public void removed(IEclipsePreferences.NodeChangeEvent event) {
				if (event.getChild() == preferencesLookup[PREF_INSTANCE]) {
					preferencesLookup[PREF_INSTANCE] = InstanceScope.INSTANCE
							.getNode(DLTKCore.PLUGIN_ID);
					preferencesLookup[PREF_INSTANCE]
							.addPreferenceChangeListener(new EclipsePreferencesListener());
				}
			}
		};
		((IEclipsePreferences) preferencesLookup[PREF_INSTANCE].parent())
				.addNodeChangeListener(listener);
		preferencesLookup[PREF_INSTANCE]
				.addPreferenceChangeListener(new EclipsePreferencesListener());
		// Listen to default preferences node removal from parent in order to
		// refresh stored one
		listener = new IEclipsePreferences.INodeChangeListener() {
			@Override
			public void added(IEclipsePreferences.NodeChangeEvent event) {
				// do nothing
			}

			@Override
			public void removed(IEclipsePreferences.NodeChangeEvent event) {
				if (event.getChild() == preferencesLookup[PREF_DEFAULT]) {
					preferencesLookup[PREF_DEFAULT] = DefaultScope.INSTANCE
							.getNode(DLTKCore.PLUGIN_ID);
				}
			}
		};
		((IEclipsePreferences) preferencesLookup[PREF_DEFAULT].parent())
				.addNodeChangeListener(listener);
	}

	public void shutdown() {
		final IEclipsePreferences preferences = getPluginPreferences(DLTKCore.PLUGIN_ID);
		try {
			preferences.flush();
		} catch (BackingStoreException e) {
			Util.log(e, "Could not save DLTKCore preferences"); //$NON-NLS-1$
		}
		// Stop listening to preferences changes
		preferences.removePreferenceChangeListener(this.propertyListener);
		getPluginPreferences(
				ResourcesPlugin.getPlugin().getBundle().getSymbolicName())
				.removePreferenceChangeListener(this.resourcesPropertyListener);

		if (coreCache != null) {
			coreCache.stop();
		}
		IWorkspace workspace = ResourcesPlugin.getWorkspace();
		workspace.removeResourceChangeListener(this.deltaState);
		DLTKContentTypeManager.uninstallListener();
		workspace.removeSaveParticipant(DLTKCore.getDefault());

		if (sourceModuleInfoCache != null) {
			sourceModuleInfoCache.stop();
		}
		if (this.indexManager != null) { // no more indexing
			this.indexManager.shutdown();
		}
		// wait for the initialization job to finish
		try {
			Job.getJobManager().join(DLTKCore.PLUGIN_ID, null);
		} catch (InterruptedException e) {
			// ignore
		}
	}

	public void removePerProjectInfo(ScriptProject scriptProject) {
		synchronized (this.perProjectInfos) { // use the perProjectInfo
			// collection as its own lock
			IProject project = scriptProject.getProject();
			PerProjectInfo info = (PerProjectInfo) this.perProjectInfos
					.get(project);
			if (info != null) {
				this.perProjectInfos.remove(project);
			}
		}
	}

	public synchronized IPath variableGet(String variableName) {
		// check initialization in progress first
		HashSet initializations = variableInitializationInProgress();
		if (initializations.contains(variableName)) {
			return VARIABLE_INITIALIZATION_IN_PROGRESS;
		}
		return (IPath) this.variables.get(variableName);
	}

	private synchronized IPath variableGetDefaultToPreviousSession(
			String variableName) {
		IPath variablePath = (IPath) this.variables.get(variableName);
		if (variablePath == null)
			return getPreviousSessionVariable(variableName);
		return variablePath;
	}

	/*
	 * Returns the set of variable names that are being initialized in the
	 * current thread.
	 */
	private HashSet variableInitializationInProgress() {
		HashSet initializations = (HashSet) this.variableInitializationInProgress
				.get();
		if (initializations == null) {
			initializations = new HashSet();
			this.variableInitializationInProgress.set(initializations);
		}
		return initializations;
	}

	public synchronized String[] variableNames() {
		int length = this.variables.size();
		String[] result = new String[length];
		Iterator vars = this.variables.keySet().iterator();
		int index = 0;
		while (vars.hasNext()) {
			result[index++] = (String) vars.next();
		}
		return result;
	}

	public synchronized void variablePut(String variableName, IPath variablePath) {

		// set/unset the initialization in progress
		HashSet initializations = variableInitializationInProgress();
		if (variablePath == VARIABLE_INITIALIZATION_IN_PROGRESS) {
			initializations.add(variableName);

			// do not write out intermediate initialization value
			return;
		} else {
			initializations.remove(variableName);

			// update cache - do not only rely on listener refresh
			if (variablePath == null) {
				// if path is null, record that the variable was removed to
				// avoid asking the initializer to initialize it again
				// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=112609
				this.variables.put(variableName, BP_ENTRY_IGNORE_PATH);
				// clean other variables caches
				this.variablesWithInitializer.remove(variableName);
			} else {
				this.variables.put(variableName, variablePath);
			}
			// discard obsoleted information about previous session
			this.previousSessionVariables.remove(variableName);
		}
	}

	public void variablePreferencesPut(String variableName, IPath variablePath) {
		String variableKey = BP_VARIABLE_PREFERENCES_PREFIX + variableName;
		if (variablePath == null) {
			getInstancePreferences().remove(variableKey);
		} else {
			getInstancePreferences().put(variableKey, variablePath.toString());
		}
		try {
			getInstancePreferences().flush();
		} catch (BackingStoreException e) {
			// ignore exception
		}
	}

	/*
	 * Optimize startup case where 1 variable is initialized at a time with the
	 * same value as on shutdown.
	 */
	public boolean variablePutIfInitializingWithSameValue(
			String[] variableNames, IPath[] variablePaths) {
		if (variableNames.length != 1)
			return false;
		String variableName = variableNames[0];
		IPath oldPath = variableGetDefaultToPreviousSession(variableName);
		if (oldPath == null)
			return false;
		IPath newPath = variablePaths[0];
		if (!oldPath.equals(newPath))
			return false;
		variablePut(variableName, newPath);
		return true;
	}

	/**
	 * Sets the last built state for the given project, or null to reset it.
	 */
	public void setLastBuiltState(IProject project, Object state) {
		if (DLTKLanguageManager.hasScriptNature(project)) {
			// should never be requested on non-script projects
			PerProjectInfo info = getPerProjectInfo(project, true /*
																 * create if
																 * missing
																 */);
			info.triedRead = true; // no point trying to re-read once using
			// setter
			info.savedState = state;
		}
		if (state == null) { // delete state file to ensure a full build
			// happens if the workspace crashes
			try {
				File file = getSerializationFile(project);
				if (file != null && file.exists())
					file.delete();
			} catch (SecurityException se) {
				// could not delete file: cannot do much more
			}
		}
	}

	/**
	 * Returns the File to use for saving and restoring the last built state for
	 * the given project.
	 */
	private File getSerializationFile(IProject project) {
		if (!project.exists())
			return null;
		IPath workingLocation = project.getWorkingLocation(DLTKCore.PLUGIN_ID);
		return workingLocation.append("state.dat").toFile(); //$NON-NLS-1$
	}

	// If modified, also modify the method getDefaultOptionsNoInitialization()
	public Hashtable getDefaultOptions() {
		Hashtable defaultOptions = new Hashtable(10);
		// see
		// DLTKCorePreferenceInitializer#initializeDefaultPluginPreferences()
		// for changing default settings
		// If modified, also modify the method
		// getDefaultOptionsNoInitialization()
		IEclipsePreferences defaultPreferences = getDefaultPreferences();
		// initialize preferences to their default
		Iterator iterator = this.optionNames.iterator();
		while (iterator.hasNext()) {
			String propertyName = (String) iterator.next();
			String value = defaultPreferences.get(propertyName, null);
			if (value != null)
				defaultOptions.put(propertyName, value);
		}
		// get encoding through resource plugin
		defaultOptions.put(DLTKCore.CORE_ENCODING, DLTKCore.getEncoding());
		return defaultOptions;
	}

	/**
	 * Get default eclipse preference for DLTKCore plugin.
	 */
	public IEclipsePreferences getDefaultPreferences() {
		return preferencesLookup[PREF_DEFAULT];
	}

	// Do not modify without modifying getDefaultOptions()
	private Hashtable<String, String> getDefaultOptionsNoInitialization() {
		System.err
				.println("Add language dependent compiler options. Or implement it in another whan in DLTK way..."); //$NON-NLS-1$
		Map defaultOptionsMap = new HashMap(); // compiler defaults
		return new Hashtable(defaultOptionsMap);
	}

	public IBuildpathContainer getBuildpathContainer(IPath containerPath,
			IScriptProject project) throws ModelException {
		IBuildpathContainer container = containerGet(project, containerPath);
		if (container == null) {
			if (this.batchContainerInitializations) {
				// avoid deep recursion while initializaing container on
				// workspace restart
				// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=60437)
				this.batchContainerInitializations = false;
				return initializeAllContainers(project, containerPath);
			}
			return initializeContainer(project, containerPath);
		}
		return container;
	}

	public synchronized IBuildpathContainer containerGet(
			IScriptProject project, IPath containerPath) {
		// check initialization in progress first
		HashSet projectInitializations = containerInitializationInProgress(project);
		if (projectInitializations.contains(containerPath)) {
			return CONTAINER_INITIALIZATION_IN_PROGRESS;
		}
		Map projectContainers = (Map) this.containers.get(project);
		if (projectContainers == null) {
			return null;
		}
		IBuildpathContainer container = (IBuildpathContainer) projectContainers
				.get(containerPath);
		return container;
	}

	/*
	 * Returns the set of container paths for the given project that are being
	 * initialized in the current thread.
	 */
	private HashSet containerInitializationInProgress(IScriptProject project) {
		Map initializations = (Map) this.containerInitializationInProgress
				.get();
		if (initializations == null) {
			initializations = new HashMap();
			this.containerInitializationInProgress.set(initializations);
		}
		HashSet projectInitializations = (HashSet) initializations.get(project);
		if (projectInitializations == null) {
			projectInitializations = new HashSet();
			initializations.put(project, projectInitializations);
		}
		return projectInitializations;
	}

	/*
	 * Initialize all container at the same time as the given container. Return
	 * the container for the given path and project.
	 */
	private IBuildpathContainer initializeAllContainers(
			IScriptProject scriptProjectToInit, IPath containerToInit)
			throws ModelException {
		/*
		 * if (BP_RESOLVE_VERBOSE) { Util.verbose( "CPContainer INIT - batching
		 * containers initialization\n" + //$NON-NLS-1$ " project to init: " +
		 * scriptProjectToInit.getElementName() + '\n' + //$NON-NLS-1$ "
		 * container path to init: " + containerToInit); //$NON-NLS-1$ }
		 */
		// collect all container paths
		final HashMap allContainerPaths = new HashMap();
		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot()
				.getProjects();
		for (int i = 0, length = projects.length; i < length; i++) {
			IProject project = projects[i];
			if (!DLTKLanguageManager.hasScriptNature(project))
				continue;
			ScriptProject scriptProject = new ScriptProject(project, getModel());
			HashSet paths = null;
			IBuildpathEntry[] rawBuildpath = scriptProject.getRawBuildpath();
			for (int j = 0, length2 = rawBuildpath.length; j < length2; j++) {
				IBuildpathEntry entry = rawBuildpath[j];
				IPath path = entry.getPath();
				if (entry.getEntryKind() == IBuildpathEntry.BPE_CONTAINER
						&& containerGet(scriptProject, path) == null) {
					if (paths == null) {
						paths = new HashSet();
						allContainerPaths.put(scriptProject, paths);
					}
					paths.add(path);
				}
			}
		}
		HashSet containerPaths = (HashSet) allContainerPaths
				.get(scriptProjectToInit);
		if (containerPaths == null) {
			containerPaths = new HashSet();
			allContainerPaths.put(scriptProjectToInit, containerPaths);
		}
		containerPaths.add(containerToInit);
		// end block
		// mark all containers as being initialized
		this.containerInitializationInProgress.set(allContainerPaths);
		// initialize all containers
		boolean ok = false;
		try {
			// if possible run inside an IWokspaceRunnable with AVOID_UPATE to
			// avoid unwanted builds
			// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=118507)
			IWorkspaceRunnable runnable = monitor -> {
				Set keys = allContainerPaths.keySet();
				int length = keys.size();
				IScriptProject[] scriptProjects = new IScriptProject[length]; // clone
				// as
				// the
				// following
				// will
				// have
				// a
				// side
				// effect
				keys.toArray(scriptProjects);
				for (int i = 0; i < length; i++) {
					IScriptProject scriptProject = scriptProjects[i];
					HashSet pathSet = (HashSet) allContainerPaths
							.get(scriptProject);
					if (pathSet == null)
						continue;
					int length2 = pathSet.size();
					IPath[] paths = new IPath[length2];
					pathSet.toArray(paths); // clone as the following will
					// have a side effect
					for (int j = 0; j < length2; j++) {
						IPath path = paths[j];
						initializeContainer(scriptProject, path);
					}
				}
			};
			IWorkspace workspace = ResourcesPlugin.getWorkspace();
			if (workspace.isTreeLocked())
				runnable.run(null/* no progress available */);
			else
				workspace.run(runnable, null/* don't take any lock */,
						IWorkspace.AVOID_UPDATE, null/*
													 * no progress available
													 * here
													 */);
			ok = true;
		} catch (CoreException e) {
			// ignore
			System.err.println("Exception while initializing all containers"); //$NON-NLS-1$
			// Util.log(e, "Exception while initializing all containers");
			// //$NON-NLS-1$
		} finally {
			if (!ok) {
				// if we're being traversed by an exception, ensure that that
				// containers are
				// no longer marked as initialization in progress
				// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=66437)
				this.containerInitializationInProgress.set(null);
			}
		}
		return containerGet(scriptProjectToInit, containerToInit);
	}

	IBuildpathContainer initializeContainer(IScriptProject project,
			IPath containerPath) throws ModelException {
		IBuildpathContainer container = null;
		final BuildpathContainerInitializer initializer = DLTKCore
				.getBuildpathContainerInitializer(containerPath.segment(0));
		if (initializer != null) {
			if (BP_RESOLVE_VERBOSE) {
				verbose_triggering_container_initialization(project,
						containerPath, initializer);
			}
			// PerformanceStats stats = null;
			containerPut(project, containerPath,
					CONTAINER_INITIALIZATION_IN_PROGRESS); // avoid
			// initialization
			// cycles
			boolean ok = false;
			try {
				// let OperationCanceledException go through
				// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=59363)
				initializer.initialize(containerPath, project);
				// retrieve value (if initialization was successful)
				container = containerGet(project, containerPath);
				if (container == CONTAINER_INITIALIZATION_IN_PROGRESS)
					return null; // break cycle
				ok = true;
			} catch (CoreException e) {
				if (e instanceof ModelException) {
					throw (ModelException) e;
				} else {
					throw new ModelException(e);
				}
			} catch (RuntimeException e) {
				if (ModelManager.BP_RESOLVE_VERBOSE) {
					e.printStackTrace();
				}
				throw e;
			} catch (Error e) {
				if (ModelManager.BP_RESOLVE_VERBOSE) {
					e.printStackTrace();
				}
				throw e;
			} finally {
				if (!ok) {
					// just remove initialization in progress and keep previous
					// session container so as to avoid a full build
					// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=92588
					containerRemoveInitializationInProgress(project,
							containerPath);
					if (BP_RESOLVE_VERBOSE) {
						verbose_container_initialization_failed(project,
								containerPath, container, initializer);
					}
				}
			}
			if (BP_RESOLVE_VERBOSE) {
				verbose_container_value_after_initialization(project,
						containerPath, container);
			}
		} else {
			if (BP_RESOLVE_VERBOSE) {
				Util.verbose("CPContainer INIT - no initializer found\n" + //$NON-NLS-1$
						"	project: " + project.getElementName() + '\n' + //$NON-NLS-1$
						"	container path: " + containerPath); //$NON-NLS-1$
			}
		}
		return container;
	}

	private void verbose_triggering_container_initialization(
			IScriptProject project, IPath containerPath,
			final BuildpathContainerInitializer initializer) {
		Util.verbose("BPContainer INIT - triggering initialization\n" + //$NON-NLS-1$
				"	project: " + project.getElementName() + '\n' + //$NON-NLS-1$
				"	container path: " + containerPath + '\n' + //$NON-NLS-1$
				"	initializer: " + initializer + '\n' + //$NON-NLS-1$
				"	invocation stack trace:"); //$NON-NLS-1$
		new Exception("<Fake exception>").printStackTrace(System.out); //$NON-NLS-1$
	}

	private void verbose_container_value_after_initialization(
			IScriptProject project, IPath containerPath,
			IBuildpathContainer container) {
		StringBuffer buffer = new StringBuffer();
		buffer.append("CPContainer INIT - after resolution\n"); //$NON-NLS-1$
		buffer.append("	project: " + project.getElementName() + '\n'); //$NON-NLS-1$
		buffer.append("	container path: " + containerPath + '\n'); //$NON-NLS-1$
		if (container != null) {
			buffer.append("	container: " + container.getDescription() + " {\n"); //$NON-NLS-2$//$NON-NLS-1$
			IBuildpathEntry[] entries = container.getBuildpathEntries();
			if (entries != null) {
				for (int i = 0; i < entries.length; i++) {
					buffer.append("		" + entries[i] + '\n'); //$NON-NLS-1$
				}
			}
			buffer.append("	}");//$NON-NLS-1$
		} else {
			buffer.append("	container: {unbound}");//$NON-NLS-1$
		}
		Util.verbose(buffer.toString());
	}

	private void verbose_container_initialization_failed(
			IScriptProject project, IPath containerPath,
			IBuildpathContainer container,
			final BuildpathContainerInitializer initializer) {
		if (container == CONTAINER_INITIALIZATION_IN_PROGRESS) {
			Util.verbose("CPContainer INIT - FAILED (initializer did not initialize container)\n" + //$NON-NLS-1$
					"	project: " //$NON-NLS-1$
					+ project.getElementName() + '\n' + "	container path: " //$NON-NLS-1$
					+ containerPath + '\n' + "	initializer: " + initializer); //$NON-NLS-1$
		} else {
			Util.verbose("CPContainer INIT - FAILED (see exception above)\n" + //$NON-NLS-1$
					"	project: " //$NON-NLS-1$
					+ project.getElementName() + '\n' + "	container path: " //$NON-NLS-1$
					+ containerPath + '\n' + "	initializer: " + initializer); //$NON-NLS-1$
		}
	}

	/**
	 * Returns a persisted container from previous session if any. Note that it
	 * is not the original container from previous session (i.e. it did not get
	 * serialized) but rather a summary of its entries recreated for CP
	 * initialization purpose. As such it should not be stored into container
	 * caches.
	 */
	public IBuildpathContainer getPreviousSessionContainer(IPath containerPath,
			IScriptProject project) {
		Map previousContainerValues = (Map) this.previousSessionContainers
				.get(project);
		if (previousContainerValues != null) {
			IBuildpathContainer previousContainer = (IBuildpathContainer) previousContainerValues
					.get(containerPath);
			if (previousContainer != null) {
				if (ModelManager.BP_RESOLVE_VERBOSE) {
					StringBuffer buffer = new StringBuffer();
					buffer.append("CPContainer INIT - reentering access to project container during its initialization, will see previous value\n"); //$NON-NLS-1$ 
					buffer.append("	project: " + project.getElementName() + '\n'); //$NON-NLS-1$
					buffer.append("	container path: " + containerPath + '\n'); //$NON-NLS-1$
					buffer.append("	previous value: "); //$NON-NLS-1$
					buffer.append(previousContainer.getDescription());
					buffer.append(" {\n"); //$NON-NLS-1$
					IBuildpathEntry[] entries = previousContainer
							.getBuildpathEntries();
					if (entries != null) {
						for (int j = 0; j < entries.length; j++) {
							buffer.append(" 		"); //$NON-NLS-1$
							buffer.append(entries[j]);
							buffer.append('\n');
						}
					}
					buffer.append(" 	}"); //$NON-NLS-1$
					Util.verbose(buffer.toString());
					new Exception("<Fake exception>").printStackTrace(System.out); //$NON-NLS-1$
				}
				return previousContainer;
			}
		}
		return null; // break cycle if none found
	}

	/**
	 * Returns a persisted container from previous session if any
	 */
	public IPath getPreviousSessionVariable(String variableName) {
		IPath previousPath = (IPath) this.previousSessionVariables
				.get(variableName);
		if (previousPath != null) {
			// if (BP_RESOLVE_VERBOSE_ADVANCED)
			// verbose_reentering_variable_access(variableName, previousPath);
			return previousPath;
		}
		return null; // break cycle
	}

	public synchronized void containerPut(IScriptProject project,
			IPath containerPath, IBuildpathContainer container) {
		// set/unset the initialization in progress
		if (container == CONTAINER_INITIALIZATION_IN_PROGRESS) {
			HashSet projectInitializations = containerInitializationInProgress(project);
			projectInitializations.add(containerPath);
			// do not write out intermediate initialization value
			return;
		} else {
			containerRemoveInitializationInProgress(project, containerPath);
			Map projectContainers = (Map) this.containers.get(project);
			if (projectContainers == null) {
				projectContainers = new HashMap(1);
				this.containers.put(project, projectContainers);
			}
			if (container == null) {
				projectContainers.remove(containerPath);
			} else {
				projectContainers.put(containerPath, container);
			}
			// discard obsoleted information about previous session
			Map previousContainers = (Map) this.previousSessionContainers
					.get(project);
			if (previousContainers != null) {
				previousContainers.remove(containerPath);
			}
		}
		// container values are persisted in preferences during save operations,
		// see #saving(ISaveContext)
	}

	/*
	 * The given project is being removed. Remove all containers for this
	 * project from the cache.
	 */
	public synchronized void containerRemove(IScriptProject project) {
		Map initializations = (Map) this.containerInitializationInProgress
				.get();
		if (initializations != null) {
			initializations.remove(project);
		}
		this.containers.remove(project);
	}

	void verbose_missbehaving_container(IScriptProject project,
			IPath containerPath, IBuildpathEntry[] classpathEntries) {
		Util.verbose("CPContainer GET - missbehaving container (returning null classpath entry)\n" + //$NON-NLS-1$
				"	project: " + project.getElementName() + '\n' + //$NON-NLS-1$
				"	container path: " + containerPath + '\n' + //$NON-NLS-1$
				"	classpath entries: {\n" + //$NON-NLS-1$
						Util.toString(classpathEntries, o -> {
							StringBuffer buffer = new StringBuffer("		"); //$NON-NLS-1$
							if (o == null) {
								buffer.append("<null>"); //$NON-NLS-1$
						return buffer.toString();
					}
							buffer.append(o);
							return buffer.toString();
				}) + "\n	}" //$NON-NLS-1$
		);
	}

	void verbose_missbehaving_container_null_entries(IScriptProject project,
			IPath containerPath) {
		Util.verbose("CPContainer GET - missbehaving container (returning null as classpath entries)\n" + //$NON-NLS-1$
				"	project: " + project.getElementName() + '\n' + //$NON-NLS-1$
				"	container path: " + containerPath + '\n' + //$NON-NLS-1$
				"	classpath entries: <null>" //$NON-NLS-1$
		);
	}

	private void containerRemoveInitializationInProgress(
			IScriptProject project, IPath containerPath) {
		HashSet projectInitializations = containerInitializationInProgress(project);
		projectInitializations.remove(containerPath);
		if (projectInitializations.size() == 0) {
			Map initializations = (Map) this.containerInitializationInProgress
					.get();
			initializations.remove(project);
		}
	}

	/*
	 * Optimize startup case where a container for 1 project is initialized at a
	 * time with the same entries as on shutdown.
	 */
	public boolean containerPutIfInitializingWithSameEntries(
			IPath containerPath, IScriptProject[] projects,
			IBuildpathContainer[] respectiveContainers) {
		int projectLength = projects.length;
		if (projectLength != 1)
			return false;
		final IBuildpathContainer container = respectiveContainers[0];
		if (container == null)
			return false;
		final IScriptProject project = projects[0];
		if (!containerInitializationInProgress(project).contains(containerPath))
			return false;
		IBuildpathContainer previousSessionContainer = getPreviousSessionContainer(
				containerPath, project);
		final IBuildpathEntry[] newEntries = container.getBuildpathEntries();
		if (previousSessionContainer == null)
			if (newEntries.length == 0) {
				containerPut(project, containerPath, container);
				return true;
			} else {
				return false;
			}
		final IBuildpathEntry[] oldEntries = previousSessionContainer
				.getBuildpathEntries();
		if (oldEntries.length != newEntries.length)
			return false;
		for (int i = 0, length = newEntries.length; i < length; i++) {
			if (!newEntries[i].equals(oldEntries[i])) {
				if (BP_RESOLVE_VERBOSE) {
					Util.verbose("CPContainer SET  - missbehaving container\n" + //$NON-NLS-1$
							"	container path: " //$NON-NLS-1$
							+ containerPath
							+ '\n'
							+ "	projects: {" //$NON-NLS-1$
							+ Util.toString(projects,
									o -> ((IScriptProject) o).getElementName())
							+ "}\n	values on previous session: {\n" + //$NON-NLS-1$
							Util.toString(respectiveContainers,
									o -> {
										StringBuffer buffer = new StringBuffer(
												"		"); //$NON-NLS-1$
										if (o == null) {
											buffer.append("<null>"); //$NON-NLS-1$
											return buffer.toString();
										}
										buffer.append(
												container.getDescription());
										buffer.append(" {\n"); //$NON-NLS-1$
										for (int j = 0; j < oldEntries.length; j++) {
											buffer.append(" 			"); //$NON-NLS-1$
											buffer.append(oldEntries[j]);
											buffer.append('\n');
										}
										buffer.append(" 		}"); //$NON-NLS-1$
										return buffer.toString();
									})
							+ "}\n	new values: {\n" + //$NON-NLS-1$
							Util.toString(respectiveContainers,
									o -> {
										StringBuffer buffer = new StringBuffer(
												"		"); //$NON-NLS-1$
										if (o == null) {
											buffer.append("<null>"); //$NON-NLS-1$
											return buffer.toString();
										}
										buffer.append(
												container.getDescription());
										buffer.append(" {\n"); //$NON-NLS-1$
										for (int j = 0; j < newEntries.length; j++) {
											buffer.append(" 			"); //$NON-NLS-1$
											buffer.append(newEntries[j]);
											buffer.append('\n');
										}
										buffer.append(" 		}"); //$NON-NLS-1$
										return buffer.toString();
									}) + "\n	}"); //$NON-NLS-1$
				}
				return false;
			}
		}
		containerPut(project, containerPath, container);
		return true;
	}

	/**
	 * Returns the open ZipFile at the given path. If the ZipFile does not yet
	 * exist, it is created, opened, and added to the cache of open ZipFiles.
	 * 
	 * NOTE: closeZipFile() must be called for the resulting ZipFile, when the
	 * client is done using it.
	 * 
	 * The path must be a file system path if representing an external zip, or
	 * it must be an absolute workspace relative path if representing a zip
	 * inside the workspace.
	 * 
	 * @param archiveProjectFragment
	 * 
	 * @exception CoreException
	 *                If unable to create/open the ZipFile
	 */
	public IArchive getArchive(IPath path,
			IProjectFragment archiveProjectFragment) throws CoreException {
		Map<IPath, IArchive> map;
		IArchive zipFile;
		if ((map = this.zipFiles.get()) != null
				&& (zipFile = map.get(path)) != null) {
			return zipFile;
		}
		File localFile = null;
		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
		IResource file = root.findMember(path);
		if (file != null) {
			// internal resource
			URI location;
			if (file.getType() != IResource.FILE
					|| (location = file.getLocationURI()) == null) {
				throw new CoreException(new Status(IStatus.ERROR,
						DLTKCore.PLUGIN_ID, -1, Messages.bind(
								Messages.file_notFound, path.toString()), null));
			}
			localFile = Util.toLocalFile(location, null/*
														 * no progress
														 * availaible
														 */);
			if (localFile == null)
				throw new CoreException(new Status(IStatus.ERROR,
						DLTKCore.PLUGIN_ID, -1, Messages.bind(
								Messages.file_notFound, path.toString()), null));
		} else {
			// external resource -> it is ok to use toFile()
			if (EnvironmentPathUtils.isFull(path)) {
				path = EnvironmentPathUtils.getLocalPath(path);
			}
			localFile = path.toFile();
		}
		try {
			if (ZIP_ACCESS_VERBOSE) {
				System.out
						.println("(" + Thread.currentThread() + ") [ModelManager.getZipFile(IPath)] Creating ZipFile on " + localFile); //$NON-NLS-1$ //$NON-NLS-2$
			}
			zipFile = openArchive(archiveProjectFragment, localFile);

			if (map != null) {
				map.put(path, zipFile);
			}
			return zipFile;
		} catch (IOException e) {
			throw new CoreException(new Status(IStatus.ERROR,
					DLTKCore.PLUGIN_ID, -1, Messages.status_IOException, e));
		}
	}

	public IArchive openArchive(IProjectFragment archiveProjectFragment,
			File localFile) throws IOException {
		final IDLTKLanguageToolkit toolkit = DLTKLanguageManager
				.getLanguageToolkit(archiveProjectFragment);
		if (toolkit != null) {
			return toolkit.openArchive(localFile);
		} else {
			return new ZipArchiveFile(localFile);
		}
	}

	/**
	 * Starts caching ZipFiles. Ignores if there are already clients.
	 */
	public void cacheZipFiles() {
		if (this.zipFiles.get() != null)
			return;
		this.zipFiles.set(new HashMap<IPath, IArchive>());
	}

	public void closeArchive(IArchive zipFile) {
		if (zipFile == null)
			return;
		if (this.zipFiles.get() != null) {
			return; // zip file will be closed by call to flushZipFiles
		}
		try {
			if (ModelManager.ZIP_ACCESS_VERBOSE) {
				System.out
						.println("(" + Thread.currentThread() + ") [ModelManager.closeZipFile(ZipFile)] Closing ZipFile on " + zipFile.getName()); //$NON-NLS-1$	//$NON-NLS-2$
			}
			zipFile.close();
		} catch (IOException e) {
			// problem occured closing zip file: cannot do much more
		}
	}

	public void doneSaving(ISaveContext context) {
		// nothing
	}

	public void prepareToSave(ISaveContext context) throws CoreException {
		// TODO Auto-generated method stub
	}

	public void rollback(ISaveContext context) {
		// TODO Auto-generated method stub
	}

	private void traceContainers(String action, long start) {
		Long delta = System.currentTimeMillis() - start;
		Long length = getContainersFile().length();
		String pattern = "{0} {1} bytes in containers.dat in {2}ms"; //$NON-NLS-1$
		String message = NLS.bind(pattern,
				new Object[] { action, length, delta });
		System.out.println(message);
	}

	public void saving(ISaveContext context) throws CoreException {
		// save variable and container values on snapshot/full save
		long start = -1;
		if (VERBOSE)
			start = System.currentTimeMillis();
		savesContainers();
		if (VERBOSE)
			traceContainers("Saved", start); //$NON-NLS-1$
		if (context.getKind() == ISaveContext.FULL_SAVE) {
			// will need delta since this save (see
			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=38658)
			context.needDelta();
			// clean up indexes on workspace full save
			// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=52347)
			IndexManager manager = this.indexManager;
			if (manager != null
			// don't force initialization of workspace scope as we could be
			// shutting down
			// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=93941)
					&& this.workspaceScope != null) {
				manager.cleanUpIndexes();
			}
		}
		IProject savedProject = context.getProject();
		if (savedProject != null) {
			if (!ScriptProject.hasScriptNature(savedProject))
				return; // ignore
			PerProjectInfo info = getPerProjectInfo(savedProject, true /*
																		 * create
																		 * info
																		 */);
			saveState(info, context);
			info.rememberExternalLibTimestamps();
			return;
		}
		ArrayList vStats = null; // lazy initialized
		ArrayList values = null;
		synchronized (this.perProjectInfos) {
			values = new ArrayList(this.perProjectInfos.values());
		}
		Iterator iterator = values.iterator();
		while (iterator.hasNext()) {
			try {
				PerProjectInfo info = (PerProjectInfo) iterator.next();
				saveState(info, context);
				info.rememberExternalLibTimestamps();
			} catch (CoreException e) {
				if (vStats == null)
					vStats = new ArrayList();
				vStats.add(e.getStatus());
			}
		}
		if (vStats != null) {
			IStatus[] stats = new IStatus[vStats.size()];
			vStats.toArray(stats);
			throw new CoreException(
					new MultiStatus(DLTKCore.PLUGIN_ID, IStatus.ERROR, stats,
							Messages.build_cannotSaveStates, null));
		}
		// save external libs timestamps
		this.deltaState.saveExternalLibTimeStamps();
	}

	private File getContainersFile() {
		return DLTKCore.getPlugin().getStateLocation()
				.append("Containers.dat").toFile(); //$NON-NLS-1$
	}

	private void saveState(PerProjectInfo info, ISaveContext context)
			throws CoreException {
		// passed this point, save actions are non trivial
		if (context.getKind() == ISaveContext.SNAPSHOT)
			return;
		// save built state
		if (info.triedRead)
			saveBuiltState(info);
	}

	/**
	 * Saves the built state for the project.
	 */
	private void saveBuiltState(PerProjectInfo info) throws CoreException {
		if (ScriptBuilder.DEBUG)
			System.out.println(Messages.bind(Messages.build_saveStateProgress,
					info.project.getName()));
		File file = getSerializationFile(info.project);
		if (file == null)
			return;
		long t = System.currentTimeMillis();
		try {
			DataOutputStream out = new DataOutputStream(
					new BufferedOutputStream(new FileOutputStream(file)));
			try {
				out.writeUTF(DLTKCore.PLUGIN_ID);
				out.writeUTF("STATE"); //$NON-NLS-1$
				if (info.savedState == null) {
					out.writeBoolean(false);
				} else {
					out.writeBoolean(true);
					ScriptBuilder.writeState(info.savedState, out);
				}
			} finally {
				out.close();
			}
		} catch (RuntimeException e) {
			try {
				file.delete();
			} catch (SecurityException se) {
				// could not delete file: cannot do much more
			}
			throw new CoreException(new Status(IStatus.ERROR,
					DLTKCore.PLUGIN_ID, Platform.PLUGIN_ERROR, Messages.bind(
							Messages.build_cannotSaveState,
							info.project.getName()), e));
		} catch (IOException e) {
			try {
				file.delete();
			} catch (SecurityException se) {
				// could not delete file: cannot do much more
			}
			throw new CoreException(new Status(IStatus.ERROR,
					DLTKCore.PLUGIN_ID, Platform.PLUGIN_ERROR, Messages.bind(
							Messages.build_cannotSaveState,
							info.project.getName()), e));
		}
		if (ScriptBuilder.DEBUG) {
			t = System.currentTimeMillis() - t;
			System.out.println(Messages.bind(Messages.build_saveStateComplete,
					String.valueOf(t)));
		}
	}

	private void savesContainers() throws CoreException {
		File file = getContainersFile();
		DataOutputStream out = null;
		try {
			out = new DataOutputStream(new BufferedOutputStream(
					new FileOutputStream(file)));
			out.writeInt(CONTAINERS_FILE_VERSION);
			new ContainersSaveHelper(out).save();
			// old code retained for performance comparisons
			// containers
			IScriptProject[] projects = getModel().getScriptProjects();
			int length = projects.length;
			out.writeInt(length);
			for (int i = 0; i < length; i++) {
				IScriptProject project = projects[i];
				// clone while iterating (see
				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=59638)
				Map projectContainers = containerClone(project);
				out.writeUTF(project.getElementName());
				if (projectContainers == null) {
					out.writeInt(0);
					continue;
				}
				HashMap containersToSave = new HashMap();
				for (Iterator iterator = projectContainers.keySet().iterator(); iterator
						.hasNext();) {
					IPath containerPath = (IPath) iterator.next();
					IBuildpathContainer container = (IBuildpathContainer) projectContainers
							.get(containerPath);
					String containerString = null;
					try {
						if (container == null) {
							// container has not been initialized yet, use
							// previous session value
							// (see
							// https://bugs.eclipse.org/bugs/show_bug.cgi?id=73969
							// )
							container = getPreviousSessionContainer(
									containerPath, project);
						}
						if (container != null) {
							IBuildpathEntry[] entries = container
									.getBuildpathEntries();
							containerString = ((ScriptProject) project)
									.encodeBuildpath(entries, false, null/*
																		 * not
																		 * interested
																		 * in
																		 * unknown
																		 * elements
																		 */);
						}
					} catch (ModelException e) {
						// could not encode entry: will not persist
						Util.log(
								e,
								"Could not persist container " + containerPath + " for project " + project.getElementName()); //$NON-NLS-1$ //$NON-NLS-2$
					}
					if (containerString != null)
						containersToSave.put(containerPath, containerString);
				}
				out.writeInt(containersToSave.size());
				Iterator iterator = containersToSave.keySet().iterator();
				while (iterator.hasNext()) {
					IPath containerPath = (IPath) iterator.next();
					out.writeUTF(containerPath.toPortableString());
					String containerString = (String) containersToSave
							.get(containerPath);
					out.writeInt(containerString.length());
					out.writeBytes(containerString);
				}
			}
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, DLTKCore.PLUGIN_ID,
					IStatus.ERROR,
					"Problems while saving variables and containers", e); //$NON-NLS-1$
			throw new CoreException(status);
		} finally {
			if (out != null) {
				try {
					out.close();
				} catch (IOException e) {
					// nothing we can do: ignore
				}
			}
		}
	}

	protected synchronized void resetZIPTypeCache() {
		this.cache.resetZIPTypeCache();
	}

	public DLTKWorkspaceScope getWorkspaceScope(IDLTKLanguageToolkit toolkit) {
		if (this.workspaceScope == null) {
			this.workspaceScope = new HashMap();
		}
		if (this.workspaceScope.containsKey(toolkit)) {
			return (DLTKWorkspaceScope) this.workspaceScope.get(toolkit);
		} else {
			DLTKWorkspaceScope scope = new DLTKWorkspaceScope(toolkit);
			this.workspaceScope.put(toolkit, scope);
			return scope;
		}
	}

	private final class ContainersSaveHelper {
		private final HashtableOfObjectToInt buildpathEntryIds;
		// -> int
		private final DataOutputStream out;
		private final HashtableOfObjectToInt stringIds; // Strings -> int

		ContainersSaveHelper(DataOutputStream out) {
			super();
			this.buildpathEntryIds = new HashtableOfObjectToInt();
			this.out = out;
			this.stringIds = new HashtableOfObjectToInt();
		}

		void save() throws IOException, ModelException {
			saveProjects(ModelManager.this.getModel().getScriptProjects());
		}

		private void saveAccessRule(BuildpathAccessRule rule)
				throws IOException {
			saveInt(rule.problemId);
			savePath(rule.getPattern());
		}

		private void saveAccessRules(IAccessRule[] rules) throws IOException {
			int count = rules == null ? 0 : rules.length;
			saveInt(count);
			for (int i = 0; i < count; ++i)
				saveAccessRule((BuildpathAccessRule) rules[i]);
		}

		private void saveAttribute(IBuildpathAttribute attribute)
				throws IOException {
			saveString(attribute.getName());
			saveString(attribute.getValue());
		}

		private void saveAttributes(IBuildpathAttribute[] attributes)
				throws IOException {
			int count = attributes == null ? 0 : attributes.length;
			saveInt(count);
			for (int i = 0; i < count; ++i)
				saveAttribute(attributes[i]);
		}

		private void saveBuildpathEntries(IBuildpathEntry[] entries)
				throws IOException {
			int count = entries == null ? 0 : entries.length;
			saveInt(count);
			for (int i = 0; i < count; ++i)
				saveBuildpathEntry(entries[i]);
		}

		private void saveBuildpathEntry(IBuildpathEntry entry)
				throws IOException {
			if (saveNewId(entry, this.buildpathEntryIds)) {
				saveInt(entry.getContentKind());
				saveInt(entry.getEntryKind());
				savePath(entry.getPath());
				savePaths(entry.getInclusionPatterns());
				savePaths(entry.getExclusionPatterns());
				this.out.writeBoolean(entry.isExported());
				this.out.writeBoolean(entry.isExternal());
				saveAccessRules(entry.getAccessRules());
				this.out.writeBoolean(entry.combineAccessRules());
				saveAttributes(entry.getExtraAttributes());
			}
		}

		private void saveContainers(IScriptProject project, Map containerMap)
				throws IOException {
			saveInt(containerMap.size());
			for (Iterator i = containerMap.entrySet().iterator(); i.hasNext();) {
				Entry entry = (Entry) i.next();
				IPath path = (IPath) entry.getKey();
				IBuildpathContainer container = (IBuildpathContainer) entry
						.getValue();
				IBuildpathEntry[] cpEntries = null;
				if (container == null) {
					// container has not been initialized yet, use previous
					// session value
					// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=73969)
					container = ModelManager.this.getPreviousSessionContainer(
							path, project);
				}
				if (container != null)
					cpEntries = container.getBuildpathEntries();
				savePath(path);
				saveBuildpathEntries(cpEntries);
			}
		}

		private void saveInt(int value) throws IOException {
			this.out.writeInt(value);
		}

		private boolean saveNewId(Object key, HashtableOfObjectToInt map)
				throws IOException {
			int id = map.get(key);
			if (id == -1) {
				int newId = map.size();
				map.put(key, newId);
				saveInt(newId);
				return true;
			} else {
				saveInt(id);
				return false;
			}
		}

		private void savePath(IPath path) throws IOException {
			if (path == null) {
				this.out.writeBoolean(true);
			} else {
				this.out.writeBoolean(false);
				saveString(path.toPortableString());
			}
		}

		private void savePaths(IPath[] paths) throws IOException {
			int count = paths == null ? 0 : paths.length;
			saveInt(count);
			for (int i = 0; i < count; ++i)
				savePath(paths[i]);
		}

		private void saveProjects(IScriptProject[] projects)
				throws IOException, ModelException {
			int count = projects.length;
			saveInt(count);
			for (int i = 0; i < count; ++i) {
				IScriptProject project = projects[i];
				saveString(project.getElementName());
				Map containerMap = (Map) ModelManager.this.containers
						.get(project);
				if (containerMap == null) {
					containerMap = Collections.EMPTY_MAP;
				} else {
					// clone while iterating
					// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=59638)
					containerMap = new HashMap(containerMap);
				}
				saveContainers(project, containerMap);
			}
		}

		private void saveString(String string) throws IOException {
			if (saveNewId(string, this.stringIds))
				this.out.writeUTF(string);
		}
	}

	private synchronized Map containerClone(IScriptProject project) {
		Map originalProjectContainers = (Map) this.containers.get(project);
		if (originalProjectContainers == null)
			return null;
		Map projectContainers = new HashMap(originalProjectContainers.size());
		projectContainers.putAll(originalProjectContainers);
		return projectContainers;
	}

	public void loadContainers() throws CoreException {
		// backward compatibility, load variables and containers from
		// preferences into cache
		loadVariablesAndContainers(getDefaultPreferences());
		loadVariablesAndContainers(getInstancePreferences());
		// load variables and containers from saved file into cache
		File file = getContainersFile();
		DataInputStream in = null;
		try {
			in = new DataInputStream(new BufferedInputStream(
					new FileInputStream(file)));
			switch (in.readInt()) {
			case 1:
				new ContainersLoadHelper(in).load();
				break;
			}
		} catch (IOException e) {
			if (file.exists())
				Util.log(e, "Unable to read variable and containers file"); //$NON-NLS-1$
		} catch (RuntimeException e) {
			if (file.exists())
				Util.log(e,
						"Unable to read variable and containers file (file is corrupt)"); //$NON-NLS-1$
		} finally {
			if (in != null) {
				try {
					in.close();
				} catch (IOException e) {
					// nothing we can do: ignore
				}
			}
		}
		// override persisted values for containers which have a registered
		// initializer
		containersReset(getRegisteredContainerIDs());
	}

	private void loadVariablesAndContainers(IEclipsePreferences preferences) {
		try {
			// only get variable from preferences not set to their default
			String[] propertyNames = preferences.keys();
			int variablePrefixLength = BP_VARIABLE_PREFERENCES_PREFIX.length();
			for (int i = 0; i < propertyNames.length; i++) {
				String propertyName = propertyNames[i];
				if (propertyName.startsWith(BP_VARIABLE_PREFERENCES_PREFIX)) {
					String varName = propertyName
							.substring(variablePrefixLength);
					String propertyValue = preferences.get(propertyName, null);
					if (propertyValue != null) {
						String pathString = propertyValue.trim();

						if (BP_ENTRY_IGNORE.equals(pathString)) {
							// cleanup old preferences
							preferences.remove(propertyName);
							continue;
						}

						// add variable to table
						IPath varPath = new Path(pathString);
						this.variables.put(varName, varPath);
						this.previousSessionVariables.put(varName, varPath);
					}
				} else if (propertyName
						.startsWith(BP_CONTAINER_PREFERENCES_PREFIX)) {
					String propertyValue = preferences.get(propertyName, null);
					if (propertyValue != null) {
						// cleanup old preferences
						preferences.remove(propertyName);

						// recreate container
						recreatePersistedContainer(propertyName, propertyValue,
								true/* add to container values */);
					}
				}
			}
		} catch (BackingStoreException e1) {
			// TODO (frederic) see if it's necessary to report this failure...
		}
	}

	private static final class PersistedBuildpathContainer implements
			IBuildpathContainer {
		private final IPath containerPath;
		private final IBuildpathEntry[] entries;
		private final IScriptProject project;

		PersistedBuildpathContainer(IScriptProject project,
				IPath containerPath, IBuildpathEntry[] entries) {
			super();
			this.containerPath = containerPath;
			this.entries = entries;
			this.project = project;
		}

		public IBuildpathEntry[] getBuildpathEntries() {
			return entries;
		}

		public String getDescription() {
			return "Persisted container [" + containerPath //$NON-NLS-1$
					+ " for project [" + project.getElementName() //$NON-NLS-1$
					+ "]]"; //$NON-NLS-1$  
		}

		public int getKind() {
			return 0;
		}

		public IPath getPath() {
			return containerPath;
		}

		public String toString() {
			return getDescription();
		}

	}

	private final class ContainersLoadHelper {
		private static final int ARRAY_INCREMENT = 200;
		private IBuildpathEntry[] allBuildpathEntries;
		private int allBuildpathEntryCount;
		private final Map allPaths; // String -> IPath
		private String[] allStrings;
		private int allStringsCount;
		private final DataInputStream in;

		ContainersLoadHelper(DataInputStream in) {
			super();
			this.allBuildpathEntries = null;
			this.allBuildpathEntryCount = 0;
			this.allPaths = new HashMap();
			this.allStrings = null;
			this.allStringsCount = 0;
			this.in = in;
		}

		void load() throws IOException {
			loadProjects(ModelManager.this.getModel());
		}

		private IAccessRule loadAccessRule() throws IOException {
			int problemId = loadInt();
			IPath pattern = loadPath();
			return new BuildpathAccessRule(pattern.toString().toCharArray(),
					problemId);
		}

		private IAccessRule[] loadAccessRules() throws IOException {
			int count = loadInt();
			if (count == 0)
				return BuildpathEntry.NO_ACCESS_RULES;
			IAccessRule[] rules = new IAccessRule[count];
			for (int i = 0; i < count; ++i)
				rules[i] = loadAccessRule();
			return rules;
		}

		private IBuildpathAttribute loadAttribute() throws IOException {
			String name = loadString();
			String value = loadString();
			return new BuildpathAttribute(name, value);
		}

		private IBuildpathAttribute[] loadAttributes() throws IOException {
			int count = loadInt();
			if (count == 0)
				return BuildpathEntry.NO_EXTRA_ATTRIBUTES;
			IBuildpathAttribute[] attributes = new IBuildpathAttribute[count];
			for (int i = 0; i < count; ++i)
				attributes[i] = loadAttribute();
			return attributes;
		}

		private boolean loadBoolean() throws IOException {
			return this.in.readBoolean();
		}

		private IBuildpathEntry[] loadBuildpathEntries() throws IOException {
			int count = loadInt();
			IBuildpathEntry[] entries = new IBuildpathEntry[count];
			for (int i = 0; i < count; ++i)
				entries[i] = loadBuildpathEntry();
			return entries;
		}

		private IBuildpathEntry loadBuildpathEntry() throws IOException {
			int id = loadInt();
			if (id < 0 || id > this.allBuildpathEntryCount)
				throw new IOException("Unexpected buildpathentry id"); //$NON-NLS-1$
			if (id < this.allBuildpathEntryCount)
				return this.allBuildpathEntries[id];
			int contentKind = loadInt();
			int entryKind = loadInt();
			IPath path = loadPath();
			IPath[] inclusionPatterns = loadPaths();
			IPath[] exclusionPatterns = loadPaths();
			boolean isExported = loadBoolean();
			boolean isExternal = loadBoolean();
			IAccessRule[] accessRules = loadAccessRules();
			boolean combineAccessRules = loadBoolean();
			IBuildpathAttribute[] extraAttributes = loadAttributes();
			IBuildpathEntry entry = new BuildpathEntry(contentKind, entryKind,
					path, isExported, inclusionPatterns, exclusionPatterns,
					accessRules, combineAccessRules, extraAttributes,
					isExternal);
			IBuildpathEntry[] array = this.allBuildpathEntries;
			if (array == null || id == array.length) {
				array = new IBuildpathEntry[id + ARRAY_INCREMENT];
				if (id != 0)
					System.arraycopy(this.allBuildpathEntries, 0, array, 0, id);
				this.allBuildpathEntries = array;
			}
			array[id] = entry;
			this.allBuildpathEntryCount = id + 1;
			return entry;
		}

		private void loadContainers(IScriptProject project) throws IOException {
			boolean projectIsAccessible = project.getProject().isAccessible();
			int count = loadInt();
			for (int i = 0; i < count; ++i) {
				IPath path = loadPath();
				IBuildpathEntry[] entries = loadBuildpathEntries();
				if (!projectIsAccessible)
					// avoid leaking deleted project's persisted container,
					// but still read the container as it is is part of the file
					// format
					continue;
				IBuildpathContainer container = new PersistedBuildpathContainer(
						project, path, entries);
				ModelManager.this.containerPut(project, path, container);
				Map oldContainers = (Map) ModelManager.this.previousSessionContainers
						.get(project);
				if (oldContainers == null) {
					oldContainers = new HashMap();
					ModelManager.this.previousSessionContainers.put(project,
							oldContainers);
				}
				oldContainers.put(path, container);
			}
		}

		private int loadInt() throws IOException {
			return this.in.readInt();
		}

		private IPath loadPath() throws IOException {
			if (loadBoolean())
				return null;
			String portableString = loadString();
			IPath path = (IPath) this.allPaths.get(portableString);
			if (path == null) {
				path = Path.fromPortableString(portableString);
				this.allPaths.put(portableString, path);
			}
			return path;
		}

		private IPath[] loadPaths() throws IOException {
			int count = loadInt();
			IPath[] pathArray = new IPath[count];
			for (int i = 0; i < count; ++i)
				pathArray[i] = loadPath();
			return pathArray;
		}

		private void loadProjects(IScriptModel model) throws IOException {
			int count = loadInt();
			for (int i = 0; i < count; ++i) {
				String projectName = loadString();
				loadContainers(model.getScriptProject(projectName));
			}
		}

		private String loadString() throws IOException {
			int id = loadInt();
			if (id < 0 || id > this.allStringsCount)
				throw new IOException("Unexpected string id"); //$NON-NLS-1$
			if (id < this.allStringsCount)
				return this.allStrings[id];
			String string = this.in.readUTF();
			String[] array = this.allStrings;
			if (array == null || id == array.length) {
				array = new String[id + ARRAY_INCREMENT];
				if (id != 0)
					System.arraycopy(this.allStrings, 0, array, 0, id);
				this.allStrings = array;
			}
			array[id] = string;
			this.allStringsCount = id + 1;
			return string;
		}
	}

	/**
	 * Returns the name of the container IDs for which an CP container
	 * initializer is registered through an extension point
	 */
	public static String[] getRegisteredContainerIDs() {

		Plugin dltkCorePlugin = DLTKCore.getPlugin();
		if (dltkCorePlugin == null)
			return null;

		ArrayList containerIDList = new ArrayList(5);
		IExtensionPoint extension = Platform.getExtensionRegistry()
				.getExtensionPoint(DLTKCore.PLUGIN_ID,
						ModelManager.BPCONTAINER_INITIALIZER_EXTPOINT_ID);
		if (extension != null) {
			IExtension[] extensions = extension.getExtensions();
			for (int i = 0; i < extensions.length; i++) {
				IConfigurationElement[] configElements = extensions[i]
						.getConfigurationElements();
				for (int j = 0; j < configElements.length; j++) {
					String idAttribute = configElements[j].getAttribute("id"); //$NON-NLS-1$
					if (idAttribute != null)
						containerIDList.add(idAttribute);
				}
			}
		}
		String[] containerIDs = new String[containerIDList.size()];
		containerIDList.toArray(containerIDs);
		return containerIDs;
	}

	private synchronized void containersReset(String[] containerIDs) {
		for (int i = 0; i < containerIDs.length; i++) {
			String containerID = containerIDs[i];
			Iterator projectIterator = this.containers.keySet().iterator();
			while (projectIterator.hasNext()) {
				IScriptProject project = (IScriptProject) projectIterator
						.next();
				Map projectContainers = (Map) this.containers.get(project);
				if (projectContainers != null) {
					Iterator containerIterator = projectContainers.keySet()
							.iterator();
					while (containerIterator.hasNext()) {
						IPath containerPath = (IPath) containerIterator.next();
						if (containerPath.segment(0).equals(containerID)) { // registered
							// container
							projectContainers.put(containerPath, null); // reset
							// container
							// value,
							// but
							// leave
							// entry
							// in
							// Map
						}
					}
				}
			}
		}
	}

	/**
	 * Flushes ZipFiles cache if there are no more clients.
	 */
	public void flushZipFiles() {
		Thread currentThread = Thread.currentThread();
		Map<IPath, IArchive> map = this.zipFiles.get();
		if (map == null)
			return;
		this.zipFiles.set(null);
		for (IArchive zipFile : map.values()) {
			try {
				if (ModelManager.ZIP_ACCESS_VERBOSE) {
					System.out
							.println("(" + currentThread + ") [ModelManager.flushZipFiles()] Closing ZipFile on " + zipFile.getName()); //$NON-NLS-1$//$NON-NLS-2$
				}
				zipFile.close();
			} catch (IOException e) {
				// problem occured closing zip file: cannot do much more
			}
		}
	}

	private SourceModuleInfoCache sourceModuleInfoCache = null;

	public ISourceModuleInfoCache getSourceModuleInfoCache() {
		return sourceModuleInfoCache;
	}

	public static UserLibraryManager getUserLibraryManager() {
		if (MANAGER.userLibraryManager == null) {
			UserLibraryManager libraryManager = new UserLibraryManager();
			synchronized (MANAGER) {
				if (MANAGER.userLibraryManager == null) { // ensure another
					// library manager
					// was not set while
					// creating the
					// instance above
					MANAGER.userLibraryManager = libraryManager;
				}
			}
		}
		return MANAGER.userLibraryManager;
	}
}