/*
    * Created on 27.7.2004 TODO To change the template for this generated file go
    * to Window - Preferences - Java - Code Style - Code Templates
    */
   package net.sf.tomp.xtcl;
   
   import net.sf.tomp.xtcl.command.End;
   import net.sf.tomp.xtcl.command.Sequence;
   
  import java.io.File;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.StringTokenizer;
  
  /***
   * Abstract base for a Compiler.
   * 
   * @author tomp
   */
  public abstract class CompilerBase implements Compiler {
  
  	private Context context;
  
  	/***
  	 * Compiles commands from a CommandLineReader into a command Sequence
  	 * 
  	 * @param clr
  	 *            CommandLineReader - the source for compilation
  	 * @return compiled Command
  	 * @throws Exception
  	 *             if compilation fails
  	 */
  	public Command compile(CommandLineReader clr) throws Exception {
  		String line = clr.nextCommandLine();
  		List lines = new ArrayList();
  
  		while (line != null) {
  			Command command = compile(line, clr);
  
  			if (command instanceof End) {
  				break;
  			}
  
  			if (command != null) {
  				lines.add(command);
  			}
  
  			line = clr.nextCommandLine();
  		}
  
  		Sequence c = new Sequence();
  
  		c.setCommands((Command[]) lines.toArray(new Command[0]));
  
  		return c;
  	}
  
  	/***
  	 * Compiles commands from a String
  	 * 
  	 * @param f
  	 *            String - the source from which it compiles
  	 * @return compiled Command
  	 * @throws Exception
  	 *             if compilation fails
  	 */
  	public Command compile(File f) throws Exception {
  		return compile(new CommandLineReader(f));
  	}
  
  	/***
  	 * Compiles commands from a String
  	 * 
  	 * @param s
  	 *            String - the source from which it compiles
  	 * @return compiled Command
  	 * @throws Exception
  	 *             if compilation fails
  	 */
  	public Command compile(String s) throws Exception {
  		return compile(new CommandLineReader(s));
  	}
  
  	/***
  	 * Compiles commands from a String followed by a CommandLineReader into a
  	 * command Sequence
  	 * 
  	 * @param cl
  	 *            String - will be tokenized and passed further to
  	 *            compile(String[], CommandLineReader)
  	 * @param clr
  	 *            CommandLineReader - the sources for compilation first the
  	 *            String, then the CLR
  	 * @return compiled Command
  	 * @throws Exception
  	 *             if compilation fails
  	 */
  	public Command compile(String cl, CommandLineReader clr) throws Exception {
 		List com = new ArrayList();
 
 		StringTokenizer st = new Tokenizer(cl.trim());
 
 		while (st.hasMoreTokens()) {
 			com.add(st.nextToken());
 		}
 
 		return compile((String[]) com.toArray(new String[0]), clr);
 	}
 
 	/***
 	 * @param ci
 	 *            Command name - used just for error reporting if it happens
 	 * @param i current position in the cl fields (parameters) array
 	 * @param cl fields (parameters) array
 	 * @param commandToReturn
 	 */
 	protected void assertWholeLineRead(String ci, int i, String[] cl,
 			Command commandToReturn) {
 		if ((commandToReturn != null) && (i != cl.length)) {
 			throw new IllegalArgumentException(getClass().getName()
 					+ " - invalid parameters for command " + ci);
 		}
 	}
 
 	/***
 	 * @param ci
 	 * @param cl
 	 * @param clr
 	 * @return
 	 * @throws Exception
 	 */
 	protected Command compileByNextCompiler(String ci, String[] cl,
 			CommandLineReader clr) throws Exception {
 		Compiler next = getNextCompiler();
 
 		if (next == null) {
 			throw new UnknownCommandException(ci);
 		} else {
 			return next.compile(cl, clr);
 		}
 	}
 
 	/***
 	 * Reads and sets all the parameters to the ParametrizedCommand 
 	 * @param cl parameter array
 	 * @param i starting position in the cl array
 	 * @param command the ParametrizedCommand
 	 * @return position in the cl parameter array after parsing 
 	 */
 	protected int setParameters(String[] cl, int i, ParametrizedCommand command) {
 		// params passed to the command
 		while (i < cl.length) {
 			String param = cl[i++];
 			// is it a @property reference?
 			if (param.startsWith("@")) {
 				// yes, set the reference
 				command.addParameterPropertiesReference(param.substring(1));
 			} else {
 				//no, normal assignment
 				String[] ss = param.split("(?<!////)//=");
 
 				if (ss.length > 0) {
 					command.setParameter(ss[0], ss.length == 1 ? "" : ss[1]);
 				}
 			}
 		}
 		return i;
 	}
 
 	/***
 	 * @return Returns the context.
 	 */
 	public Context getContext() {
 		return context;
 	}
 
 	/***
 	 * @return Returns the parent.
 	 */
 	public Compiler getNextCompiler() {
 		return context.getNextCompiler(this);
 	}
 
 	/***
 	 * @param context
 	 *            The context to set.
 	 */
 	public void setContext(Context context) {
 		this.context = context;
 	}
 }
 
 /***
  * Tokenizer for parsing parameters from the String from the line
  */
 
 class Tokenizer extends StringTokenizer {
 	/***
 	 * Creates a new Tokenizer object.
 	 * 
 	 * @param s the Tokenizer will be filled with this String
 	 */
 	public Tokenizer(String s) {
 		super(s);
 	}
 
 	/***
 	 * Gets the next Token
 	 * 
 	 * @return the next token
 	 */
 	public String nextToken() {
 		StringBuffer token = new StringBuffer();
 
 		String n = super.nextToken();
 
 		token.append(n.replaceAll("//\"", ""));
 
 		if (n.indexOf('"') >= 0) {
 			do {
 				token.append(' ');
 				n = super.nextToken();
 				token.append(n.replaceAll("//\"", ""));
 			} while (n.indexOf('"') < 0);
 		}
 
 		return token.toString();
 	}
 }