org.apache.harmony.beans.Command Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of app55-java Show documentation
App55 client library for the Java platform.
The newest version!
/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.apache.harmony.beans;

import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;

import org.apache.harmony.beans.internal.nls.Messages;
import org.xml.sax.Attributes;

import com.googlecode.openbeans.BeanInfo;
import com.googlecode.openbeans.Expression;
import com.googlecode.openbeans.IndexedPropertyDescriptor;
import com.googlecode.openbeans.IntrospectionException;
import com.googlecode.openbeans.Introspector;
import com.googlecode.openbeans.PropertyDescriptor;
import com.googlecode.openbeans.Statement;
import com.googlecode.openbeans.XMLDecoder;

public class Command
{

	private static final int	INITIALIZED			= 0;

	private static final int	CHILDREN_FILTERED	= 1;

	private static final int	COMMAND_EXECUTED	= 2;

	private static final int	CHILDREN_PROCESSED	= 3;

	private String				tagName;										// tag name

	private Map	attrs;											// set of attrs

	private String				data;											// string data

	// inner commands
	private Vector		commands			= new Vector();

	// arguments
	private Vector		arguments			= new Vector();

	// operations
	private Vector		operations			= new Vector();

	// additional arguments placed before others
	private Vector	auxArguments		= new Vector();

	private Argument			result;										// result argument

	private Object				target;										// target to execute a command on

	private String				methodName;									// method name

	private Command				ctx;											// context for command

	private int					status;										// commands

	private XMLDecoder			decoder;

	// private int tabCount = 0;

	public Command(String tagName, Map attrs)
	{
		this.tagName = tagName;
		this.attrs = attrs;
		this.status = initializeStatus(tagName);
	}

	public Command(XMLDecoder decoder, String tagName, Map attrs)
	{
		this.decoder = decoder;
		this.tagName = tagName;
		this.attrs = attrs;
		this.status = initializeStatus(tagName);
	}

	// set data for command
	public void setData(String data)
	{
		this.data = data;
	}

	// set tab count to display log messages
	// public void setTabCount(int tabCount) {
	// this.tabCount = tabCount;
	// }

	// set context - upper level command
	public void setContext(Command ctx)
	{
		this.ctx = ctx;
	}

	// add child command
	public void addChild(Command cmd)
	{
		if (cmd != null)
		{
			cmd.setContext(this);
			commands.add(cmd);
		}
	}

	// remove child command
	public void removeChild(Command cmd)
	{
		if ((cmd != null) && commands.remove(cmd))
		{
			cmd.setContext(null);
		}
	}

	// command status
	public int getStatus()
	{
		return status;
	}

	// check if one of arguments or operations is unresolved
	private boolean isResolved()
	{
		if (getStatus() < Command.CHILDREN_PROCESSED)
		{
			return false;
		}
		for (int i = 0; i < arguments.size(); ++i)
		{
			Command arg = arguments.elementAt(i);

			if (!arg.isResolved())
			{
				return false;
			}
		}
		for (int j = 0; j < operations.size(); ++j)
		{
			Command opr = operations.elementAt(j);

			if (!opr.isResolved())
			{
				return false;
			}
		}
		return true;
	}

	// execute command and return execution flags
	public int exec(Map references) throws Exception
	{
		// System.out.println("in exec() status = " + translateStatus(status) +
		// "...");
		if (status < Command.CHILDREN_PROCESSED)
		{
			if (status < Command.COMMAND_EXECUTED)
			{
				if (status < Command.CHILDREN_FILTERED)
				{
					status = doBeforeRun(references);
					// System.out.println("after doBeforeRun() status = " +
					// translateStatus(status));
				}
				if (status == Command.CHILDREN_FILTERED)
				{
					status = doRun(references);
					// System.out.println("after doRun() status = " +
					// translateStatus(status));
				}
			}
			if (status == Command.COMMAND_EXECUTED)
			{
				status = doAfterRun(references);
				// System.out.println("after doAfterRun() status = " +
				// translateStatus(status));
			}
		}
		// System.out.println("...out of exec() status = " +
		// translateStatus(status));
		return status;
	}

	// execute commands in backtrack order
	public boolean backtrack(Map references) throws Exception
	{
		for (int i = 0; i < arguments.size(); ++i)
		{
			Command arg = arguments.elementAt(i);
			arg.backtrack(references);
		}
		for (int i = 0; i < operations.size(); ++i)
		{
			Command opr = operations.elementAt(i);
			opr.backtrack(references);
		}
		if (status == Command.CHILDREN_FILTERED)
		{
			status = doRun(references);
		}
		if (status == Command.COMMAND_EXECUTED)
		{
			status = doAfterRun(references);
			return (getStatus() == Command.CHILDREN_PROCESSED);
		}
		return false;
	}

	// put command in one of two collections - arguments or operations
	private int doBeforeRun(Map references) throws Exception
	{
		if (status == Command.INITIALIZED)
		{
			for (int i = 0; i < commands.size(); ++i)
			{
				Command cmd = commands.elementAt(i);

				// XXX is this correct?
				if (cmd.isExecutable())
				{
					arguments.add(cmd);
				}
				else
				{
					operations.add(cmd);
				}
			}
			return Command.CHILDREN_FILTERED;
		}
		return status;
	}

	// run command
	private int doRun(Map references) throws Exception
	{
		if (status == Command.CHILDREN_FILTERED)
		{
			if (isRoot())
			{
				result = new Argument(decoder);
				// System.out.println("doRun(): result is decoder...");
				return Command.COMMAND_EXECUTED;
			}

			if (isNull())
			{
				result = new Argument(null);
				// System.out.println("doRun(): result is null...");
				return Command.COMMAND_EXECUTED;
			}

			if (ctx != null && ctx.isArray() && (ctx.getResultValue() == null) && !isExecutable())
			{
				// System.out.println("doRun(): context is array...");
				return status;
			}

			Object target = getTarget(references);
			if (target == null)
			{
				// System.out.println("doRun(): target is null...");
				return status;
			}
			// if (target instanceof Class) {
			// System.out.println("doRun(): target = " +
			// ((Class)target).getName());
			// } else {
			// System.out.println("doRun(): target = " +
			// target.getClass().getName());
			// }
			if (isReference())
			{
				result = getReferencedArgument(references);
				// System.out.println("doRun(): reference - result is " +
				// result.getType());
			}
			else
			{
				String methodName = getMethodName(references);
				// System.out.println("doRun(): methodName = " +
				// methodName);
				Argument[] arguments = getArguments();
				if (arguments == null)
				{
					return status;
				}
				// for (Argument element : arguments) {
				// if (element != null) {
				// System.out.println("doRun(): arg [" + i + "] = "
				// + arguments[i].getType());
				// } else {
				// System.out.println("doRun(): arg [" + i + "] =
				// null");
				// }
				// }

				Expression expr = new Expression(target, methodName, getArgumentsValues());
				result = new Argument(expr.getValue());

				if (isPrimitiveClassName(getTagName()))
				{
					result.setType(getPrimitiveClass(tagName));
				}

				// System.out.println("doRun(): method call - result is " +
				// result.getType());
			}
			return Command.COMMAND_EXECUTED;
		}
		return status;
	}

	// run child commands
	private int doAfterRun(Map references) throws Exception
	{
		if (status == Command.COMMAND_EXECUTED)
		{
			// System.out.println("doAfterRun(): command " + getResultType() + "
			// processed...");
			Vector toBeRemoved = new Vector();
			try
			{
				Statement[] statements = null;

				for (int i = 0; i < operations.size(); ++i)
				{
					Command cmd = operations.elementAt(i);

					if (cmd.isArrayElement())
					{

						if (cmd.isResolved())
						{
							if (statements == null)
							{
								statements = new Statement[operations.size()];
							}
							statements[i] = new Statement(getResultValue(), "set", new Object[] { Integer.valueOf(i), //$NON-NLS-1$
									cmd.getResultValue() });
							if ((i + 1) == operations.size())
							{
								for (int j = 0; j < operations.size(); ++j)
								{
									statements[j].execute();
								}
								toBeRemoved.addAll(operations);
							}
						}
						else
						{
							break;
						}

					}
					else
					{
						// since the call is Array.set()
						if (!isArray())
						{
							cmd.setTarget(getResultValue());
						}
						cmd.exec(references);

						if (cmd.isResolved())
						{
							// System.out.println("doAfterRun(): cmd = " +
							// cmd.methodName + " is resolved");
							toBeRemoved.add(cmd);
						}
						else
						{
							// System.out.println("doAfterRun(): cmd = " +
							// cmd.methodName + " is unresolved");
							break;
						}

					}

				}
			}
			catch (Exception e)
			{
				throw new Exception(e);
			}
			finally
			{
				operations.removeAll(toBeRemoved);
			}

			// if (operations.size() == 0) {
			// System.out.println("doAfterRun(): command " + getResultType()
			// + " completely processed.");
			// } else {
			// System.out.println("doAfterRun(): command " + getResultType()
			// + " contains incomplete " +
			// operations.size() + " commands.");
			// }
			return (operations.size() == 0) ? Command.CHILDREN_PROCESSED : status;
		}
		return status;
	}

	// Result accessors

	// Return result - Argument class
	public Argument getResult()
	{
		return result;
	}

	// Returns result value
	public Object getResultValue()
	{
		return (result != null) ? result.getValue() : null;
	}

	// Returns result type
	public Class getResultType() throws ClassNotFoundException
	{
		return (result != null) ? result.getType() : null;
	}

	// accessors to XML tags and attrs
	public boolean hasAttr(String name)
	{
		return attrs.get(name) != null;
	}

	public String getAttr(String name)
	{
		return attrs.get(name);
	}

	public boolean isTag(String name)
	{
		return tagName.equals(name);
	}

	public boolean hasAttr(String name, String value)
	{
		return value.equals(attrs.get(name));
	}

	public String getTagName()
	{
		return tagName;
	}

	// Checks if the object is primitive - int, float, etc...
	private boolean isPrimitive()
	{
		return isPrimitiveClassName(tagName);
	}

	// Checks if the object is constructor
	private boolean isConstructor()
	{
		return isPrimitive() || !isStaticMethod() && !isMethod() && !isProperty() && !isField() && !isArray() && !isReference();
	}

	// Checks if the command is static method
	private boolean isStaticMethod()
	{
		return isTag("object") && hasAttr("method") || isTag("class"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

	// Checks if the command is public method
	private boolean isMethod()
	{
		return isTag("void") && (hasAttr("method") || hasAttr("index")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

	// Check if the command relates to property - getter ot setter depends on
	// number of args
	private boolean isProperty()
	{
		return isTag("void") && hasAttr("property"); //$NON-NLS-1$ //$NON-NLS-2$
	}

	// Check if the command is field accessor
	private boolean isField()
	{
		return isTag("object") && hasAttr("field"); //$NON-NLS-1$ //$NON-NLS-2$
	}

	// Check if the command is array
	private boolean isArray()
	{
		return isTag("array"); //$NON-NLS-1$
	}

	// Check if the command is array element
	private boolean isArrayElement()
	{
		return (ctx != null) && (ctx.isArray()) && isExecutable();
	}

	private boolean isReference()
	{
		return hasAttr("idref"); //$NON-NLS-1$
	}

	// Check if the command is root object
	private boolean isRoot()
	{
		return isTag("java"); //$NON-NLS-1$
	}

	// Check if the command is null
	private boolean isNull()
	{
		return isTag("null"); //$NON-NLS-1$
	}

	// Checks if the command could generate object
	public boolean isExecutable()
	{
		boolean result = isTag("object") || isTag("void") && hasAttr("class") //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
				&& hasAttr("method") || isTag("array") || isPrimitive() //$NON-NLS-1$ //$NON-NLS-2$
				|| isTag("class") || isTag("null"); //$NON-NLS-1$ //$NON-NLS-2$
		return result;
	}

	private Argument getReferencedArgument(Map references)
	{
		return references.get(getAttr("idref")).getResult(); //$NON-NLS-1$
	}

	// get a target through tag and attrs analysis
	private Object getTarget(Map references) throws Exception
	{
		if (target == null)
		{
			if (isReference())
			{
				Command cmd = references.get(getAttr("idref")); //$NON-NLS-1$
				target = (cmd != null) ? cmd.getResultValue() : null;
			}
			else if (isExecutable())
			{
				String className = null;

				if (isPrimitive())
				{
					className = getPrimitiveClassName(tagName);
				}
				else if (isTag("class")) { //$NON-NLS-1$
					className = getPrimitiveClassName(tagName);
				}
				else if (isConstructor() || isStaticMethod() || isField())
				{
					className = getAttr("class"); //$NON-NLS-1$
				}
				else if (isArray())
				{
					className = getAttr("class"); //$NON-NLS-1$
					Class componentType = isPrimitiveClassName(className) ? getPrimitiveClass(className) : Class.forName(className, true, Thread
							.currentThread().getContextClassLoader());
					className = Array.newInstance(componentType, 0).getClass().getName();
				}

				if (className != null)
				{
					try
					{
						target = Class.forName(className, true, Thread.currentThread().getContextClassLoader());
					}
					catch (ClassNotFoundException e)
					{
						target = Class.forName(className);
					}

					if (isField())
					{
						String fieldName = getAttr("field"); //$NON-NLS-1$
						target = ((Class) target).getField(fieldName);
					}
				}
				else
				{
					throw new Exception(Messages.getString("beans.42", className)); //$NON-NLS-1$
				}
			}
			else if (ctx.isArray())
			{
				// target = ctx.getTarget(references);
				target = Class.forName("java.lang.reflect.Array"); //$NON-NLS-1$
			}
		}
		return target;
	}

	// set target to execute command on
	private void setTarget(Object target)
	{
		this.target = target;
	}

	// Return a method name of command
	private String getMethodName(Map references) throws NoSuchMethodException, IntrospectionException, Exception
	{
		if (methodName == null)
		{
			String methodValue = null;
			if (isTag("class")) { //$NON-NLS-1$
				addArgument(new Argument(String.class, data), 0);
				methodValue = "forName"; //$NON-NLS-1$
			}
			else if (isPrimitive())
			{
				if (isTag("char")) { //$NON-NLS-1$
					if (data.length() != 1)
					{
						throw new IntrospectionException(Messages.getString("beans.43", //$NON-NLS-1$
								data));
					}
					addArgument(new Argument(char.class, Character.valueOf(data.charAt(0))), 0);
				}
				else
				{
					addArgument(new Argument(String.class, data), 0);
				}
				methodValue = "new"; //$NON-NLS-1$
			}
			else if (isConstructor() || hasAttr("method", "new")) { //$NON-NLS-1$ //$NON-NLS-2$
				methodValue = "new"; //$NON-NLS-1$
			}
			else if (isArray())
			{
				methodValue = "new"; //$NON-NLS-1$
				int length = hasAttr("length") ? Integer //$NON-NLS-1$
						.parseInt(getAttr("length")) : getArgumentsNumber(); //$NON-NLS-1$
				copyArgumentsToCommands();
				addArgument(new Argument(int.class, Integer.valueOf(length)), 0);
			}
			else if (hasAttr("property")) { //$NON-NLS-1$
				String propertyValue = getAttr("property"); //$NON-NLS-1$
				if (hasAttr("index")) { //$NON-NLS-1$
					addArgument(new Argument(int.class, new Integer(getAttr("index"))), 0); //$NON-NLS-1$
				}

				BeanInfo beanInfo = Introspector.getBeanInfo(getTarget(references).getClass());
				PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();

				boolean methodFound = false;
				Method method = null;
				for (PropertyDescriptor pd : pds)
				{
					if (propertyValue.equals(pd.getName()))
					{
						int argsNum = getArgumentsNumber();
						if (hasAttr("index")) { //$NON-NLS-1$
							IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
							if (argsNum == 1)
							{
								method = ipd.getIndexedReadMethod();
							}
							else if (argsNum == 0)
							{
								method = ipd.getReadMethod();
							}
						}
						else
						{
							method = pd.getReadMethod();
						}

						if (method != null)
						{
							methodFound = matchMethodParams(method, references);
						}

						if (methodFound == false)
						{
							if (hasAttr("index")) { //$NON-NLS-1$
								IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
								if (argsNum == 2)
								{
									method = ipd.getIndexedWriteMethod();
								}
								else if (argsNum == 1)
								{
									method = ipd.getWriteMethod();
								}
							}
							else
							{
								method = pd.getWriteMethod();
							}
						}

						if (method != null)
						{
							methodFound = matchMethodParams(method, references);
						}
					}
				}

				if (method == null)
				{
					throw new NoSuchMethodException(Messages.getString("beans.44", //$NON-NLS-1$
							propertyValue));
				}
				methodValue = method.getName();
			}
			else if (hasAttr("method")) { //$NON-NLS-1$
				if (hasAttr("index")) { //$NON-NLS-1$
					addArgument(new Argument(int.class, Integer.valueOf(getAttr("index"))), 0); //$NON-NLS-1$
				}
				methodValue = getAttr("method"); //$NON-NLS-1$
			}
			else if (hasAttr("index")) { //$NON-NLS-1$
				addArgument(new Argument(int.class, Integer.valueOf(getAttr("index"))), 0); //$NON-NLS-1$
				methodValue = getArgumentsNumber() > 1 ? "set" : "get"; //$NON-NLS-1$ //$NON-NLS-2$
				if (ctx.isArray())
				{
					addArgument(ctx.getResult(), 0);
				}
			}
			else if (hasAttr("field")) { //$NON-NLS-1$
				addArgument(new Argument(Class.forName(getAttr("class"), true, //$NON-NLS-1$
						Thread.currentThread().getContextClassLoader())), 0);

				methodValue = "get"; //$NON-NLS-1$
			}
			else
			{
				throw new Exception(Messages.getString("beans.45")); //$NON-NLS-1$
			}
			methodName = methodValue;
		}
		return methodName;
	}

	// return a list of arguments as of Argument type
	private Argument[] getArguments()
	{
		Argument[] args = new Argument[auxArguments.size() + arguments.size()];

		for (int i = 0; i < auxArguments.size(); ++i)
		{
			args[i] = auxArguments.elementAt(i);
		}
		for (int j = 0; j < arguments.size(); ++j)
		{
			Command cmd = arguments.elementAt(j);

			if (cmd.getStatus() >= Command.COMMAND_EXECUTED)
			{
				args[auxArguments.size() + j] = cmd.getResult();
			}
			else
			{
				// System.out.println("arg: " + cmd.getResultValue());
				args = null;
				break;
			}
		}
		return args;
	}

	// return argument values
	private Object[] getArgumentsValues()
	{
		Argument[] args = getArguments();
		Object[] result = new Object[args.length];
		for (int i = 0; i < args.length; ++i)
		{
			result[i] = args[i].getValue();
		}
		return result;
	}

	// copy arguments to treat as commands
	private void copyArgumentsToCommands()
	{
		Iterator i = arguments.iterator();
		while (i.hasNext())
		{
			Command cmd = i.next();
			cmd.status = Command.CHILDREN_FILTERED;
			operations.add(cmd);
		}
		arguments.clear();
	}

	// return number of arguments
	private int getArgumentsNumber()
	{
		return auxArguments.size() + arguments.size();
	}

	// return number of commands
	// private int getOperationsNumber() {
	// return operations.size();
	// }

	// add argument to the beginning of arguments
	private void addArgument(Argument argument, int idx)
	{
		auxArguments.insertElementAt(argument, idx);
	}

	// Check if the name of class is primitive
	public static boolean isPrimitiveClassName(String className)
	{
		return className.equalsIgnoreCase("boolean") //$NON-NLS-1$
				|| className.equalsIgnoreCase("byte") //$NON-NLS-1$
				|| className.equalsIgnoreCase("char") //$NON-NLS-1$
				|| className.equalsIgnoreCase("short") //$NON-NLS-1$
				|| className.equalsIgnoreCase("int") //$NON-NLS-1$
				|| className.equalsIgnoreCase("long") //$NON-NLS-1$
				|| className.equalsIgnoreCase("float") //$NON-NLS-1$
				|| className.equalsIgnoreCase("double") //$NON-NLS-1$
				|| className.equalsIgnoreCase("string"); //$NON-NLS-1$
	}

	// Transforms a primitive class name
	private String getPrimitiveClassName(String data)
	{
		String shortClassName = null;
		if (data.equals("int")) { //$NON-NLS-1$
			shortClassName = "Integer"; //$NON-NLS-1$
		}
		else if (data.equals("char")) { //$NON-NLS-1$
			shortClassName = "Character"; //$NON-NLS-1$
		}
		else
		{
			shortClassName = data.substring(0, 1).toUpperCase() + data.substring(1, data.length());
		}
		return "java.lang." + shortClassName; //$NON-NLS-1$
	}

	public static Class getPrimitiveClass(String className)
	{
		Class result = null;
		if (className.equals("boolean")) { //$NON-NLS-1$
			result = boolean.class;
		}
		else if (className.equals("byte")) { //$NON-NLS-1$
			result = byte.class;
		}
		else if (className.equals("char")) { //$NON-NLS-1$
			result = char.class;
		}
		else if (className.equals("short")) { //$NON-NLS-1$
			result = short.class;
		}
		else if (className.equals("int")) { //$NON-NLS-1$
			result = int.class;
		}
		else if (className.equals("long")) { //$NON-NLS-1$
			result = long.class;
		}
		else if (className.equals("float")) { //$NON-NLS-1$
			result = float.class;
		}
		else if (className.equals("double")) { //$NON-NLS-1$
			result = double.class;
		}
		else if (className.equals("string")) { //$NON-NLS-1$
			result = String.class;
		}
		return result;
	}

	private boolean matchMethodParams(Method method, Map references)
	{
		Class[] paramTypes = method.getParameterTypes();
		Argument[] args = getArguments();
		if (args == null)
		{
			return false;
		}
		boolean result = true;
		if (paramTypes.length == args.length)
		{
			for (int j = 0; j < paramTypes.length; ++j)
			{
				// System.out.println("paramTypes[j] = " + paramTypes[j]);
				// System.out.println("args[j] = " + args[j].getType());

				boolean isAssignable = (args[j].getType() == null) ? !paramTypes[j].isPrimitive() : paramTypes[j].isAssignableFrom(args[j].getType());

				// System.out.println("args[j] = " + args[j].getType());

				if (!isAssignable)
				{
					result = false;
					break;
				}
			}
		}
		else
		{
			result = false;
		}
		return result;
	}

	public static Map parseAttrs(String tagName, Attributes attrs)
	{
		Map result = new HashMap();
		if (tagName.equals("object")) { //$NON-NLS-1$
			for (String name : objectAttrNames)
			{
				String value = attrs.getValue(name);
				if (value != null)
				{
					result.put(name, value);
				}
			}
		}
		else if (tagName.equals("void")) { //$NON-NLS-1$
			for (String name : voidAttrNames)
			{
				String value = attrs.getValue(name);
				if (value != null)
				{
					result.put(name, value);
				}
			}
		}
		else if (tagName.equals("array")) { //$NON-NLS-1$
			for (String name : arrayAttrNames)
			{
				String value = attrs.getValue(name);
				if (value != null)
				{
					result.put(name, value);
				}
			}
		}
		else if (tagName.equals("java")) { //$NON-NLS-1$
			for (String name : javaAttrNames)
			{
				String value = attrs.getValue(name);
				if (value != null)
				{
					result.put(name, value);
				}
			}
		}
		return result;
	}

	// Auxiliary logging with tabs functions
	public static void pr(String msg)
	{
		// System.out.print(msg);
	}

	public static void pr(int tabCount, String msg)
	{
		// String result = ""; //$NON-NLS-1$
		// for (int i = 0; i < tabCount; ++i)
		// {
		// result += '\t';
		// }
		// result += msg;
		// System.out.print(result);
	}

	public static void prn(String msg)
	{
		// System.out.println(msg);
	}

	public static void prn(int tabCount, String msg)
	{
		// String result = ""; //$NON-NLS-1$
		// for (int i = 0; i < tabCount; ++i)
		// {
		// result += '\t';
		// }
		// result += msg;
		// System.out.println(result);
	}

	public static void printAttrs(int tabCount, String tagName, Attributes attrs)
	{
		pr(tabCount, tabCount + ">in <" + tagName); //$NON-NLS-1$
		for (int i = 0; i < attrs.getLength(); ++i)
		{
			String attrName = attrs.getQName(i);
			String attrValue = attrs.getValue(i);
			pr(" " + attrName + "=" + attrValue); //$NON-NLS-1$ //$NON-NLS-2$
		}
		prn(">"); //$NON-NLS-1$
	}

	private static int initializeStatus(String tagName)
	{
		// return tagName.equals("java") ? Command.COMMAND_EXECUTED :
		// Command.INITIALIZED;
		return Command.INITIALIZED;
	}

	// private static String translateStatus(int status) {
	// String result = "unknown";
	// if(status == Command.INITIALIZED) {
	// result = "initialized";
	// } else if(status == Command.CHILDREN_FILTERED) {
	// result = "children filtered";
	// } else if(status == Command.COMMAND_EXECUTED) {
	// result = "executed";
	// } else if(status == Command.CHILDREN_PROCESSED) {
	// result = "children processed";
	// }
	// return result;
	// }

	private static final String[]	objectAttrNames	= { "id", "idref", "class", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			"field", "method", "property", "index"	};								//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

	private static final String[]	voidAttrNames	= { "id", "class", "method", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			"property", "index"					};								//$NON-NLS-1$ //$NON-NLS-2$

	private static final String[]	arrayAttrNames	= { "id", "class", "length" };	//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

	private static final String[]	javaAttrNames	= { "version", "class" };		//$NON-NLS-1$ //$NON-NLS-2$
}