ant/org.eclipse.ant.tests.ui/Ant Editor Tests/org/eclipse/ui/externaltools/internal/ant/dtd/test/dumper.java

/*====================================================================
Copyright (c) 2002, 2003 Object Factory Inc.
All rights reserved. This program and the accompanying materials
are made available under the terms of the Common Public License v1.0
which accompanies this distribution, and is available at
http://www.eclipse.org/legal/cpl-v10.html

Contributors:
    Object Factory Inc. - Initial implementation
====================================================================*/
package org.eclipse.ui.externaltools.internal.ant.dtd.test;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;

import org.eclipse.ui.externaltools.internal.ant.dtd.IDfm;
import org.eclipse.ui.externaltools.internal.ant.dtd.IElement;
import org.eclipse.ui.externaltools.internal.ant.dtd.IModel;
import org.eclipse.ui.externaltools.internal.ant.dtd.ISchema;
import org.eclipse.ui.externaltools.internal.ant.dtd.ParseError;
import org.eclipse.ui.externaltools.internal.ant.dtd.Parser;

/**
 * This class is intended to be used from the command line (hence the
 * uncapitalized class name).
 * @author Bob Foster
 */
public class dumper {

	public static int main(String[] args) {

		if (args.length <= 0) {
			System.out.println("Usage: java DTDMerger URL");
			return 0;
		}
		String document = args[0];

		Parser parser = new Parser();
		
		ISchema schema;
		try {
			schema = parser.parse(document);
		} catch (ParseError e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
			return 1;
		} catch (IOException e) {
			e.printStackTrace();
			return 1;
		}
		System.out.println("DTD successfully parsed");
		dumpSchema(schema);
		return 0;
	}
	
	/**
	 * Write schema contents to standard output.
	 */
	private static void dumpSchema(ISchema schema) {
		IElement[] elements = schema.getElements();
		System.out.println(""+elements.length+" elements defined");
		for (int i = 0; i < elements.length; i++) {
			IElement element = elements[i];
			IModel model = element.getContentModel();
			System.out.println("ELEMENT "+element.getName()
				+'"'+model.stringRep()+'"');
			dumpDfm(element.getDfm());
		}
	}

	/**
	 * Dump dfm as a series of states.
	 * <pre>
	 * S0  a=>S1 b=>S2 
	 * S1  c=>S2
	 * S2* d=>S2
	 * </pre>
	 * Where * indicates accepting state.
	 * @param dfm to dump
	 */
	private static void dumpDfm(IDfm dfm) {
		HashMap map = new HashMap();
		dumpDfm(dfm, map, 0);
		LinkedList list = new LinkedList();
		Iterator it = map.entrySet().iterator();
		while (it.hasNext()) {
			Map.Entry entry = (Map.Entry) it.next();
			list.add(new State((IDfm)entry.getKey(), (Integer)entry.getValue()));
		}
		State[] states = (State[]) list.toArray(new State[list.size()]);
		Arrays.sort(states);
		for (int i = 0; i < states.length; i++) {
			print(states[i], map);
		}
	}

	private static void print(State state, HashMap map) {
		System.out.print("  S"+state.n.intValue()
			+(state.dfm.isAccepting() ? "*  " : "  "));
		String[] accepts = state.dfm.getAccepts();
		for (int i = 0; i < accepts.length; i++) {
			String accept = accepts[i];
			IDfm next = state.dfm.advance(accept);
			int n = ((Integer)map.get(next)).intValue();
			System.out.print(" "+accept+"=>S"+n);
		}
		System.out.println();
	}
	
	private static int dumpDfm(IDfm dfm, HashMap map, int num) {
		if (!map.containsKey(dfm)) {
			map.put(dfm, new Integer(num++));
			String[] accepts = dfm.getAccepts();
			for (int i = 0; i < accepts.length; i++) {
				IDfm next = dfm.advance(accepts[i]);
				num = dumpDfm(next, map, num);
			}
		}
		return num;
	}
	
	private static class State implements Comparable {
		public IDfm dfm;
		public Integer n;
		public State(IDfm dfm, Integer n) {
			this.dfm = dfm;
			this.n = n;
		}
		/**
		 * @see java.lang.Comparable#compareTo(java.lang.Object)
		 */
		public int compareTo(Object o) {
			State other = (State) o;
			return n.intValue() < other.n.intValue()
				? -1 
				: (n.intValue() == other.n.intValue() 
					? 0 
					: 1);
		}

	}
}