mustella/java/src/utils/ArgumentParser.java

/*
 *
 * 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 utils;

import java.util.ArrayList;

/**
 * Parses a string of arguments into an ArrayList of name=value pairs.
 */
public class ArgumentParser {

	public ArgumentParser( String value )
	{
		_arguments = value;
	}
	
	// ---------------------------------------------------------------------------
	// arguments (to be parsed)
	// ---------------------------------------------------------------------------
	
	private String _arguments;

	/**
	 * The argument string to be parsed. Valid arguments are those that may be passed
	 * to compc or mxmlc.
	 */
	public String get_arguments() {
		return _arguments;
	}

	public void set_arguments(String _arguments) {
		this._arguments = _arguments;
	}
	
	// ---------------------------------------------------------------------------
	// result
	// ---------------------------------------------------------------------------
	
	/**
	 * The resultant ArrayList of arg=value pairs as String entries.
	 */
	public ArrayList result;
	
	// ---------------------------------------------------------------------------
	// toArray
	// ---------------------------------------------------------------------------
	
	/**
	 * Converts the given ArrayList into an array of Strings.
	 */
	static public String[] toArray(ArrayList value)
	{
		String[] strArray = new String[value.size()];
		for(int i=0; i < value.size(); i++ ) {
			strArray[i] = (String)value.get(i);
		}
		return strArray;
	}
	
	// ---------------------------------------------------------------------------
	// toString
	// ---------------------------------------------------------------------------
	
	/**
	 * Converts an ArrayList into a String separated by spaces. The parser should
	 * be able to re-create the ArrayList from this String.
	 */
	static public String toString(ArrayList value)
	{
		String str = "";
		for(int i=0; i < value.size(); i++ ) {
			if( i > 0 ) str += " ";
			str += (String)value.get(i);
		}
		return str;
	}
	
	// ---------------------------------------------------------------------------
	// parseArguments
	// ---------------------------------------------------------------------------
	
	/**
	 * Arguments are identified with - or -- preceding them and separated from the previous argument
	 * by one or more spaces. The value of the argument, if present, is separated from the argument name
	 * using an equal-sign.
	 * @return
	 */
	public ArrayList parseArguments()
	{
		// prefix the working copy with a space so that every argument is separated by one or more spaces.
		String working = " "+_arguments+" ";
		int index = 0;
		
		result = new ArrayList();
		
		while( index < working.length() )
		{
			int next = findNextArg(index, working);
			if( next < 0 ) break;
			
			int pos = extractArgName( next, working );
			ArgRange range = extractArgValue( pos+1, working );
			
			if( range != null ) {
				String argName = working.substring(next, pos);
				String argValue = working.substring(range.startIndex,range.endIndex);

// Places quotes around the file name just makes a file name with quotes in it and adversely
// affects how the file name is interpreted. Better to leave off the quotes				
//				result.add( argName+"="+(range.hasSpaces?"\"":"")+argValue+(range.hasSpaces?"\"":""));
//debug			System.out.println("arg name=value: "+argName+"="+(range.hasSpaces?"'":"")+argValue+(range.hasSpaces?"'":""));

				result.add( argName+"="+argValue );
				
				index = range.endIndex+1;
			} else {
				String argName = working.substring(next, pos);
				result.add(argName);
				
				index = pos+1;
			}
			
		}
		
		return result;
	}
	
	/**
	 * @private
	 * Returns the index of the next argument in the sequence.
	 */
	private int findNextArg( int index, String working )
	{
		for(int i=index; i < working.length(); i++ )
		{
			char c = working.charAt(i);
			if( c == ' ' ) continue;
			if( c == '-' || c == '+' ) {
				return i;
			}
		}
		
		return -1;
	}
	
	/**
	 * Find the index of the start of the argument name. The name must end with
	 * either a - or a space.
	 */
	private int extractArgName( int index, String working )
	{
		for(int i=index; i < working.length(); i++ )
		{
			char c = working.charAt(i);
			if( c == ' ' ) return i;
			if( c == '=' ) return i;
		}
		
		return -1;
	}
	
	/**
	 * Returns an ArgRange denoting the position of the argument value. The end of an
	 * argument's value is either the end of the string or a hyphen that is proceeded
	 * by at least one space. Should the argument value contain any spaces the ArgRange
	 * hasSpaces property is set to true.
	 */
	private ArgRange extractArgValue( int index, String working )
	{
		int firstPos = index;
		int lastPos = index;
		boolean hasSpaces = false;
		
		for(int i=index; i < working.length(); i++ )
		{
			char c = working.charAt(i);
			if( c == ' ' ) continue; // skip leading blanks.
			firstPos = i;
			break;
		}
		
		if( working.charAt(firstPos) == '-' ) return null; // there is no argValue
		
		for(int i=index; i < working.length(); i++ )
		{
			char c = working.charAt(i);
			
			// the only thing that stops us at this point is - or the end of the string
			if( c == '-' ) {
				// look at the previous character: if it is a space, then the argument's end
				// has been found. If not, consider the hyphen part of the argument value.
				char prev = working.charAt(i-1);
				if( prev == ' ' ) break;
			}
			else if( c == '+' ) {
				break;
			}
			else {
				if( c != ' ' ) lastPos = i; // the last non-blank character
			}
		}
		
		// scan for any spaces between the first and last positions
		for(int i=firstPos; !hasSpaces && i <= lastPos; i++) {
			char c = working.charAt(i);
			if( c == ' ' ) hasSpaces = true;
		}
		
		return new ArgRange(firstPos,lastPos+1,hasSpaces);
	}
}