<extension-point id="scriptResolvers" name="scriptResolvers" schema="schema/scriptResolvers.exsd"/>

<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="org.eclipse.wst.jsdt.debug.core" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appinfo>

         <meta.schema plugin="org.eclipse.wst.jsdt.debug.core" id="scriptResolvers" name="scriptResolvers"/>

      </appinfo>

      <documentation>

         This extension point is used to contribute a script solver that is consulted any place in JSDT where a <code>ScriptReference</code> must be resolved to a workspace-local <code>IFile</code>.

<br><br>

An example of typical usage is resolving if a breakpoint's workspace path matches that of a given <code>ScriptReference</code>

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appinfo>

            <meta.element />

         </appinfo>

      </annotation>

      <complexType>

         <sequence minOccurs="1" maxOccurs="unbounded">

            <element ref="scriptResolver"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute translatable="true"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="scriptResolver">

      <annotation>

         <documentation>

            A resolver that can help determine equality between workspace-local IFiles and JavaScript ScriptReferences

         </documentation>

      </annotation>

      <complexType>

         <attribute name="class" type="string" use="required">

            <annotation>

               <documentation>

                  The fully qualified name of the Java class that implements org.eclipse.wst.jsdt.debug.core.model.IScriptResolver

               </documentation>

               <appinfo>

                  <meta.attribute kind="java" basedOn=":org.eclipse.wst.jsdt.debug.core.model.IScriptResolver"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appinfo>

         <meta.section type="since"/>

      </appinfo>

      <documentation>

         3.4

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="examples"/>

      </appinfo>

      <documentation>

         The following is an example of the default script resolver:

<pre>

   <extension point="org.eclipse.wst.jsdt.debug.core.scriptResolvers">

      <scriptResolver

            class="org.eclipse.wst.jsdt.debug.internal.core.model.DefaultScriptResolver">

      </scriptResolver>

   </extension>

</pre>

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="apiinfo"/>

      </appinfo>

      <documentation>

         The class field must specify the fully qualified name of the the class the implements <code>org.eclipse.wst.jsdt.debug.core.model.IScriptResolver.java</code>.

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="implementation"/>

      </appinfo>

      <documentation>

         [Enter information about supplied implementation of this extension point.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="copyright"/>

      </appinfo>

      <documentation>

         Copyright (c) 2011 IBM Corporation and others.<br>

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 

<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>

      </documentation>

   </annotation>

</schema>

/*******************************************************************************

 * Copyright (c) 2011 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

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.wst.jsdt.debug.core.model;

import java.net.URI;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.runtime.IPath;

import org.eclipse.wst.jsdt.debug.core.jsdi.ScriptReference;

/**

 * This resolver allows contributors to plug-in to the process of resolving a {@link ScriptReference}'s 

 * {@link URI} to a workspace-local {@link IFile}.

 * @noextend This interface is not intended to be extended by clients.

 * @since 3.4

 */

public interface IScriptResolver {

	/**

	 * This method determines if the given {@link IPath} matches the {@link URI} from {@link ScriptReference#sourceURI()}.

	 * @param script the {@link ScriptReference} to compare the source {@link URI} from - never <code>null</code>

	 * @param path the path to match against the source {@link URI} - never <code>null</code>

	 * 

	 * @return <code>true</code> if the source {@link URI} of the given {@link ScriptReference} is considered to match the given {@link IPath}, <code>false</code> otherwise.

	 */

	public boolean matches(ScriptReference script, IPath path);

	/**

	 * This method is used to find the workspace {@link IFile} that corresponds to the source {@link URI} from the given {@link ScriptReference}.

	 * <br><br>

	 * If no file can be determined the method must return <code>null</code>. The result will be checked for existence.

	 * 

	 * @param script the {@link ScriptReference} to find the {@link IFile} for

	 * @return the {@link IFile} for the {@link ScriptReference} or <code>null</code>

	 */

	public IFile getFile(ScriptReference script);

}

	/**

	 * The name of the script resolvers extension point

	 * @since 3.4

	 */

	static final String SCRIPT_RESOLVERS = "scriptResolvers"; //$NON-NLS-1$

import org.eclipse.wst.jsdt.debug.internal.core.model.ScriptResolutionManager;

	 * Singleton {@link ScriptResolutionManager}

	 */

	private static ScriptResolutionManager resolutionmanager = null;

	/**

	 * Returns the singleton {@link ScriptResolutionManager}

	 * @return the {@link ScriptResolutionManager}

	 * @since 3.4

	 */

	public static synchronized ScriptResolutionManager getResolutionManager() {

		if(resolutionmanager == null) {

			resolutionmanager = new ScriptResolutionManager();

		}

		return resolutionmanager;

	}

	/**

				}

				}

import org.eclipse.core.runtime.Path;

		return supports;

	}

	/**

	 * Returns if this breakpoint supports global suspend

	 * 

	 * @return <code>true</code> if we should suspend on all script loads <code>false</code> otherwise

	 */

	private boolean isGlobalLoadSuspend() {

		String name = null;

/*******************************************************************************

 * Copyright (c) 2011 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

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.wst.jsdt.debug.internal.core.model;

import java.net.URI;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IWorkspaceRoot;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IExtensionPoint;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.ListenerList;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.URIUtil;

import org.eclipse.wst.jsdt.debug.core.jsdi.ScriptReference;

import org.eclipse.wst.jsdt.debug.core.model.IScriptResolver;

import org.eclipse.wst.jsdt.debug.internal.core.Constants;

import org.eclipse.wst.jsdt.debug.internal.core.JavaScriptDebugPlugin;

import org.eclipse.wst.jsdt.debug.internal.core.Messages;

import org.eclipse.wst.jsdt.debug.internal.core.launching.SourceLookup;

/**

 * Handles the collection of {@link ScriptResolverExtension}s and provide useful utilities for path / script handling

 * @since 3.4

 */

public final class ScriptResolutionManager {

	static IScriptResolver[] NO_RESOLVERS = new IScriptResolver[0];

	ListenerList resolvers = null;

	/**

	 * This is a convenience method that consults all of the registered {@link IScriptResolver}s.

	 * <br><br>

	 * This method will return <code>true</code> iff any one (or all) of the {@link IScriptResolver}s returns <code>true</code> or

	 * the default matching algorithm returns <code>true</code> - which is consulted after all extensions have been asked.

	 * @param script the script to check

	 * @param path the path to compare against

	 * @return <code>true</code> if any one (or all) of the {@link IScriptResolver}s return <code>true</code>, <code>false</code> otherwise

	 */

	public boolean matches(ScriptReference script, IPath path) {

		IScriptResolver[] res = getResolvers();

		for (int i = 0; i < res.length; i++) {

			if(res[i].matches(script, path)) {

				return true;

			}

		}

		//no extensions matched, fall-back to the old way

		return isMatch(script, path);

	}

	boolean isMatch(ScriptReference script, IPath path) {

		if(guessScriptMatches(script, path)) {

			return true;

		}

		//no luck, try an exact match

		URI sourceURI = script.sourceURI();

		if (URIUtil.isFileURI(sourceURI)) {

			IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();

			URI workspaceURI = workspaceRoot.getRawLocationURI();			

			sourceURI = workspaceURI.relativize(sourceURI);

		}

		IPath spath = path;

		if(spath.segmentCount() > 0 && spath.segment(0).equals(Messages.external_javascript_source)) {

			spath = spath.removeFirstSegments(1).makeAbsolute();

		}

		IPath uripath = SourceLookup.getSourcePath(sourceURI);

		if(uripath != null) {

			uripath = uripath.makeAbsolute();

		}

		return spath.equals(uripath);

	}

	/**

	 * Guesses if the paths are considered equal by walking backward from the last segment of the paths and counting the matching segments. 

	 * The paths are guessed to be equal iff any two or more segments match in order.

	 * 

	 * @param script the {@link ScriptReference}

	 * @param path the path to compare

	 * @return <code>true</code> if the paths 'match', <code>false</code> otherwise

	 */

	boolean guessScriptMatches(ScriptReference script, IPath path) {

		IPath newpath = path.makeAbsolute();

		IPath uri = new Path(script.sourceURI().getPath());

		if(SourceLookup.TOP_LEVEL_PATH.equals(newpath) && SourceLookup.TOP_LEVEL_PATH.equals(uri)) {

			return true;

		}

		uri = uri.makeAbsolute();

		int matched_segments = 0;

		int last = uri.segmentCount()-1;

		for(int i  = newpath.segmentCount()-1; i > -1; i--) {

			if(last < 0) {

				break;

			}

			if(newpath.segment(i).equals(uri.segment(last))) {

				matched_segments++;

				last--;

			}

		}

		return matched_segments > 1;

	}

	/**

	 * Convenience method to consult all of the registered {@link IScriptResolver}s for the matching {@link IFile}.

	 * <br><br>

	 * This method will vote on the file to return, and return the {@link IFile} that has the most votes as follows:

	 * <ul>

	 * <li>If there is one contributor and it returns an {@link IFile} that one is chosen</li>

	 * <li>If there is &gt; one contributor the greatest number of matching {@link IFile}s returned is chosen. If there is a tie, the {@link IFile}

	 * that matches the one selected from the default algorithm will be chosen. In the event the default algorithm returns <code>null</code> the first {@link IFile}

	 * will be selected.</li>

	 * <li>If there are no contributors the default algorithm is consulted</li>

	 * </ul>

	 * @param script

	 * @return the matching {@link IFile} or <code>null</code>

	 */

	public IFile getFile(ScriptReference script) {

		IScriptResolver[] resolvers = getResolvers();

		ArrayList files = new ArrayList();

		IFile file = null;

		for (int i = 0; i < resolvers.length; i++) {

			file = resolvers[i].getFile(script);

			if(file != null) {

				if(files.contains(file)) {

					return file;

				}

				files.add(file);

			}

		}

		file = null;

		IPath p = SourceLookup.getSourcePath(script.sourceURI());

		IResource res = ResourcesPlugin.getWorkspace().getRoot().findMember(p);

		if(res.getType() == IResource.FILE) {

			file = (IFile) res;

		}

		if(files.size() > 0) {

			if(files.contains(file)) {

				return file;

			}

			return (IFile) files.get(0);

		}

		return file;

	}

	/**

	 * Returns the complete listing of {@link IScriptResolver}s or an empty array, never <code>null</code>

	 * 

	 * @return the complete listing of {@link IScriptResolver}s

	 */

	public IScriptResolver[] getResolvers() {

		loadResolvers();

		if(resolvers.size() < 1) {

			return NO_RESOLVERS;

		}

		List res = Arrays.asList(resolvers.getListeners());

		return (IScriptResolver[]) res.toArray(new IScriptResolver[res.size()]);

	}

	/**

	 * load up all the extension points to the delegate listeners

	 */

	void loadResolvers() {

		if(resolvers == null) {

			resolvers = new ListenerList();

			IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(JavaScriptDebugPlugin.PLUGIN_ID, Constants.SCRIPT_RESOLVERS);

			IConfigurationElement[] elements = extensionPoint.getConfigurationElements();

			for (int i = 0; i < elements.length; i++) {

				resolvers.add(new ScriptResolverExtension(elements[i]));

			}

		}

	}

	/**

	 * Clean up

	 */

	public void dispose() {

		if(resolvers != null) {

			resolvers.clear();

			resolvers = null;

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2011 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

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.wst.jsdt.debug.internal.core.model;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IPath;

import org.eclipse.wst.jsdt.debug.core.jsdi.ScriptReference;

import org.eclipse.wst.jsdt.debug.core.model.IScriptResolver;

import org.eclipse.wst.jsdt.debug.internal.core.Constants;

/**

 * Default implementation of the delegate class for all {@link IScriptResolver}s

 * 

 * @since 3.4

 */

public class ScriptResolverExtension implements IScriptResolver {

	private IConfigurationElement element = null;

	private IScriptResolver delegate = null;

	/**

	 * Constructor

	 * @param element the backing {@link IConfigurationElement} to lazily load and delegate to

	 */

	public ScriptResolverExtension(IConfigurationElement element) {

		this.element = element;

	}

	/**

	 * Returns the delegate {@link IScriptResolver} from the backing {@link IConfigurationElement}

	 * 

	 * @return the delegate {@link IScriptResolver}

	 * @throws CoreException thrown if the delegate class fails to be created

	 */

	synchronized IScriptResolver getDelegate() throws CoreException {

		if(delegate == null) {

			delegate = (IScriptResolver) element.createExecutableExtension(Constants.CLASS);

		}

		return delegate;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.wst.jsdt.debug.core.model.IScriptPathResolver#matches(org.eclipse.wst.jsdt.debug.core.jsdi.ScriptReference, org.eclipse.core.runtime.IPath)

	 */

	public boolean matches(ScriptReference script, IPath path) {

		try {

			return getDelegate().matches(script, path);

		}

		catch(CoreException ce) {

			return false;

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.wst.jsdt.debug.core.model.IScriptPathResolver#getFile(org.eclipse.wst.jsdt.debug.core.jsdi.ScriptReference)

	 */

	public IFile getFile(ScriptReference script) {

		try {

			return getDelegate().getFile(script);

		}

		catch(CoreException ce) {

			return null;

		}

	}

}

      <factory

            adaptableType="org.eclipse.wst.sse.ui.StructuredTextEditor"

            class="org.eclipse.wst.jsdt.debug.internal.ui.adapters.JavaScriptAdapterFactory">

         <adapter

               type="org.eclipse.debug.ui.actions.IToggleBreakpointsTarget">

         </adapter>

         <adapter

               type="org.eclipse.debug.ui.actions.IRunToLineTarget">

         </adapter>

      </factory>

      <viewerContribution

            id="org.eclipse.wst.jsdt.debug.ui.html.ruler.popup.actions"

            targetID="org.eclipse.wst.html.core.htmlsource.source">

         <action

               class="org.eclipse.wst.jsdt.debug.internal.ui.breakpoints.ToggleBreakpointEnablementEditorDelegate"

               helpContextId="toggle_breakpoint_anablement_ruler_context"

               id="org.eclipse.wst.jsdt.debug.ui.html.toggle.breakpoint.enablement"

               label="%togglebreakpointenablementRulerAction.name"

               menubarPath="debug"

               tooltip="%togglebreakpointenablementRulerAction.tooltip">

         </action>

         <action

               class="org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate"

               helpContextId="editor_toggle_breakpoint_action_context"

               icon="$nl$/icons/elcl16/brkp_obj.gif"

               id="org.eclipse.wst.jsdt.debug.ui.html.toggle.breakpoint.ruler.delegate"

               label="%togglebreakpointRulerAction.name"

               menubarPath="debug">

         </action>

      </viewerContribution>

   <extension

         point="org.eclipse.wst.sse.ui.breakpoint">

      <breakpointContribution

            id="org.eclipse.wst.jsdt.html.breakpointContribution">

         <provider

               class="org.eclipse.wst.jsdt.debug.internal.ui.breakpoints.JavaScriptHtmlBreakpointProvider"

               contentTypes="org.eclipse.wst.html.core.htmlsource"

               id="org.eclipse.wst.jsdt.html.breakpoint.provider">

         </provider>

      </breakpointContribution>

   </extension>

/*******************************************************************************

 * Copyright (c) 2011 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

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.wst.jsdt.debug.internal.ui.breakpoints;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.ITypedRegion;

import org.eclipse.ui.IEditorInput;

import org.eclipse.wst.jsdt.debug.internal.ui.adapters.JavaScriptAdapterFactory;

import org.eclipse.wst.sse.ui.internal.provisional.extensions.ISourceEditingTextTools;

import org.eclipse.wst.sse.ui.internal.provisional.extensions.breakpoint.IBreakpointProvider;

/**

 * Provide the JavaScript breakpoint for the HTML editor

 * 

 * @since 3.4

 */

public class JavaScriptHtmlBreakpointProvider implements IBreakpointProvider {

	static final String SCRIPT_REGION = "org.eclipse.wst.html.SCRIPT"; //$NON-NLS-1$

	/**

	 * Constructor

	 */

	public JavaScriptHtmlBreakpointProvider() {

	}

	/* (non-Javadoc)

	 * @see org.eclipse.wst.sse.ui.internal.provisional.extensions.breakpoint.IBreakpointProvider#addBreakpoint(org.eclipse.jface.text.IDocument, org.eclipse.ui.IEditorInput, int, int)

	 */

	public IStatus addBreakpoint(final IDocument document, IEditorInput input, final int lineNumber, final int offset) throws CoreException {

		final IResource resource = getResource(input);

		if(resource != null && offset > -1) {

			try {

				final ITypedRegion region = document.getPartition(document.getLineOffset(lineNumber));

				if (region != null && SCRIPT_REGION.equals(region.getType())) {

					Job j = new Job("Toggle JavaScript Line Breakpoint") { //$NON-NLS-1$

						protected IStatus run(IProgressMonitor monitor) {

							try {

								JavaScriptAdapterFactory.getToggleBreakpointAdapter().addBreakpoint(resource, document, lineNumber);

								return Status.OK_STATUS;

							}

							catch(CoreException ce) {

								return Status.CANCEL_STATUS;

							}

						}

					};

					j.setPriority(Job.INTERACTIVE);

					j.schedule();

				}

			}

			catch(BadLocationException ble) {}

		}

		return Status.CANCEL_STATUS;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.wst.sse.ui.internal.provisional.extensions.breakpoint.IBreakpointProvider#getResource(org.eclipse.ui.IEditorInput)

	 */

	public IResource getResource(IEditorInput input) {

        IResource resource = (IResource) input.getAdapter(IFile.class);

        if (resource == null) {

            resource = ResourcesPlugin.getWorkspace().getRoot();

        }

        return resource;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.wst.sse.ui.internal.provisional.extensions.breakpoint.IBreakpointProvider#setSourceEditingTextTools(org.eclipse.wst.sse.ui.internal.provisional.extensions.ISourceEditingTextTools)

	 */

	public void setSourceEditingTextTools(ISourceEditingTextTools tool) {

	}

}

import org.eclipse.jface.text.ITypedRegion;

import org.eclipse.wst.jsdt.core.dom.AST;

import org.eclipse.wst.jsdt.core.dom.ASTParser;

	 * Callback from {@link JavaScriptHtmlBreakpointProvider}

	 * @param resource

	 * @param document

	 * @param linenumber

	 * @throws CoreException

	 */

	void addBreakpoint(IResource resource, IDocument document, int linenumber) throws CoreException {

		IBreakpoint bp = lineBreakpointExists(resource, linenumber);

		if(bp != null) {

			DebugPlugin.getDefault().getBreakpointManager().removeBreakpoint(bp, true);

		}

		int charstart = -1, charend = -1;

		try {

			IRegion line = document.getLineInformation(linenumber - 1);

			charstart = line.getOffset();

			charend = charstart + line.getLength();

		}

		catch (BadLocationException ble) {}

		HashMap attributes = new HashMap();

		attributes.put(IJavaScriptBreakpoint.TYPE_NAME, null);

		attributes.put(IJavaScriptBreakpoint.SCRIPT_PATH, resource.getFullPath().makeAbsolute().toString());

		attributes.put(IJavaScriptBreakpoint.ELEMENT_HANDLE, null);

		JavaScriptDebugModel.createLineBreakpoint(resource, linenumber, charstart, charend, attributes, true);

	}

	/**

	 * Resolves the region from the given document and tries to parse the text of the region. Returns the {@link JavaScriptUnit}

	 * representing the region or <code>null</code> if it could not be computed

	 * 

	 * @param doc

	 * @param offset

	 * @return the {@link JavaScriptUnit} for the region from the document or <code>null</code>

	 */

	JavaScriptUnit parse(IDocument doc, int offset) {

		try {

			ITypedRegion region = doc.getPartition(offset);

			if(region != null) {

				ASTParser parser = ASTParser.newParser(AST.JLS3);

				//parser.setKind(ASTParser.K_STATEMENTS);

				parser.setSource(doc.get(offset, region.getLength()).toCharArray());

				return (JavaScriptUnit)parser.createAST(null);

			}

		}

		catch(BadLocationException ble) {

			//do nothing, return null

		}

		return null;

	}

	/**