pluginId = attributes.getValue("Bundle-SymbolicName");				if (pluginId == null)					throw new EclipseClasspathException("Missing Bundle-SymbolicName in " + manifestFileName);				pluginId = stripSemiPart(pluginId);				// Get the plugin version				pluginVersion = attributes.getValue("Bundle-Version");				if (pluginVersion == null)					throw new EclipseClasspathException("Missing Bundle-Version in " + manifestFileName);				// Get required plugins				String required = attributes.getValue("Require-Bundle");				if (required != null) {					StringTokenizer tok = new StringTokenizer(required, ",");					while (tok.hasMoreTokens()) {						String requiredPlugin = tok.nextToken();						requiredPlugin = requiredPlugin.trim();						requiredPlugin = stripSemiPart(requiredPlugin);						//System.out.println("Required plugin=" +requiredPlugin);						requiredPluginIdList.add(requiredPlugin);					}				}				// Get exported libraries				String exported = attributes.getValue("Bundle-ClassPath");				if (exported != null) {					StringTokenizer tok2 = new StringTokenizer(exported, ",");					while (tok2.hasMoreTokens()) {						String jar = tok2.nextToken();						jar = jar.trim();						jar = stripSemiPart(jar);						exportedLibraryList.add(directory + File.separator + jar);					}				}			} catch (IOException e) {				throw new EclipseClasspathException("Could not parse Eclipse 3.0 plugin in " + directory, e);			} finally {				try {					if (in != null)						in.close();				} catch (IOException e) {					// Ignore				}			}		}		private String stripSemiPart(String s) {			int semi = s.indexOf(';');			if (semi >= 0)				s = s.substring(0, semi);			return s;		}	}	private static final Pattern pluginDirPattern = Pattern.compile("^(\\w+(\\.\\w+)*)_(\\w+(\\.\\w+)*)$");	private static final int PLUGIN_ID_GROUP = 1;	private String eclipseDir;	private String rootPluginDir;	private Map<String, File> pluginDirectoryMap;	private Map<String, String> varMap;	private Plugin rootPlugin;	private List<String> importList;	public EclipseClasspath(String eclipseDir, String rootPluginDir) {		this.eclipseDir = eclipseDir;		this.rootPluginDir = rootPluginDir;		this.pluginDirectoryMap = new HashMap<String, File>();		this.varMap = new HashMap<String, String>();	}	public void addRequiredPlugin(String pluginId, String pluginDir) {		pluginDirectoryMap.put(pluginId, new File(pluginDir));	}	private static class WorkListItem {		private String directory;		private boolean isDependent;		public WorkListItem(String directory, boolean isDependent) {			this.directory = directory;			this.isDependent = isDependent;		}		public String getDirectory() { return directory; }		public boolean isDependent() { return isDependent; }	}	public EclipseClasspath execute() throws EclipseClasspathException, DocumentException, IOException {		// Build plugin directory map		File pluginDir = new File(eclipseDir, "plugins");		File[] dirList = pluginDir.listFiles(new FileFilter() {			public boolean accept(File pathname) {				return pathname.isDirectory();			}		});		if (dirList == null)			throw new EclipseClasspathException("Could not list plugins in directory " + pluginDir);		for (int i = 0; i < dirList.length; ++i) {			String dirName = dirList[i].getName();			String pluginId = getPluginId(dirName);			if (pluginId != null) {				//System.out.println(pluginId + " ==> " + dirList[i]);				pluginDirectoryMap.put(pluginId, dirList[i]);				// HACK - see if we can deduce the value of the special "ws" variable.				if (pluginId.startsWith("org.eclipse.swt.")) {					String ws = pluginId.substring("org.eclipse.swt.".length());					if (ws.equals("gtk64"))						ws = "gtk";					varMap.put("ws", new File(dirList[i] + File.separator + "ws" + File.separator + ws).getPath().replace('\\', '/'));				}			}		}		Map<String, Plugin> requiredPluginMap = new HashMap<String, Plugin>();		LinkedList<WorkListItem> workList = new LinkedList<WorkListItem>();		workList.add(new WorkListItem(rootPluginDir, false));		while (!workList.isEmpty()) {			WorkListItem item = workList.removeFirst();			Plugin plugin = new Plugin(item.getDirectory(), item.isDependent());			requiredPluginMap.put(plugin.getId(), plugin);			if (!plugin.isDependent()) {				if (rootPlugin != null) throw new IllegalStateException("multiple root plugins");				this.rootPlugin = plugin;			}			// Add unresolved required plugins to the worklist			for (Iterator<String> i = plugin.requiredPluginIdIterator(); i.hasNext(); ) {				String requiredPluginId = i.next();				if (requiredPluginMap.get(requiredPluginId) == null) {					// Find the plugin's directory					File requiredPluginDir = pluginDirectoryMap.get(requiredPluginId);					if (requiredPluginDir == null)						throw new EclipseClasspathException("Unable to find plugin " + requiredPluginId);					workList.add(new WorkListItem(requiredPluginDir.getPath(), true));				}			}		}		//System.out.println("Found " + requiredPluginMap.size() + " required plugins");		importList = new LinkedList<String>();		for (Iterator<Plugin> i = requiredPluginMap.values().iterator(); i.hasNext(); ) {			Plugin plugin = i.next();			if (plugin.isDependent()) {				for (Iterator<String> j = plugin.exportedLibraryIterator(); j.hasNext(); ) {					//System.out.println("Import: " + j.next());					importList.add(j.next());				}			}		}		return this;	}	public Iterator<String> importListIterator() {		return importList.iterator();	}	public String getClasspath() {		if (importList == null) throw new IllegalStateException("execute() has not been called");		StringBuffer buf = new StringBuffer();		boolean first = true;		Iterator <String> i = importListIterator();		while (i.hasNext()) {			if (first)				first = false;			else				buf.append(File.pathSeparator);			buf.append(i.next());		}		// Convert backslashes to forward slashes,		// since raw backslashes cause problems in .properties files.		String s = buf.toString();		s = s.replace('\\', '/');		return s;	}	public Plugin getRootPlugin() {		return rootPlugin;	}	/**	 * Get the plugin id for given directory name.	 * Returns null if the directory name does not seem to	 * be a plugin.	 */	private String getPluginId(String dirName) {		Matcher m = pluginDirPattern.matcher(dirName);		return m.matches() ? m.group(PLUGIN_ID_GROUP) : null;	}	/**	 * Expand variables of the form $varname$ in library names.	 * This is used to handle the "$ws$" substitution used to refer to	 * the plugin containing swt.jar.	 */	private String replaceSpecial(String value) {		if (!varMap.isEmpty()) {			for (Iterator<String> i = varMap.keySet().iterator(); i.hasNext(); ) {				String key = i.next();				String replace = varMap.get(key);				Pattern pat = Pattern.compile("\\$\\Q" + key + "\\E\\$");				Matcher m = pat.matcher(value);				StringBuffer buf = new StringBuffer();					while (m.find())					m.appendReplacement(buf, replace);				m.appendTail(buf);					value = buf.toString();			}		}		return value;	}	public static void main(String[] argv) throws Exception {		if (argv.length < 2 || (argv.length % 2 != 0)) {			System.err.println("Usage: " + EclipseClasspath.class.getName() +				" <eclipse dir> <root plugin directory> [<required plugin id> <required plugin dir> ...]");			System.exit(1);		}		EclipseClasspath ec = new EclipseClasspath(argv[0], argv[1]);		for (int i = 2; i < argv.length; i += 2) {			ec.addRequiredPlugin(argv[i], new File(argv[i+1]).getAbsolutePath());		}		// Generate a build.properties file which communicates to Ant:		//   - what the build classpath should be		//   - what the plugin id and version are		ec.execute();		System.out.println("plugin.build.classpath=" + ec.getClasspath());		System.out.println("plugin.id=" + ec.getRootPlugin().getId());		System.out.println("plugin.version=" + ec.getRootPlugin().getVersion());	}}// vim:ts=4