/*
  termlib_parser.js  v.1.0
  command line parser for termlib.js
  (c) Norbert Landsteiner 2005
  mass:werk - media environments
  <http://www.masswerk.at>

  you are free to use this parser under the "termlib.js" license.

  usage:  call "parseLine(this)" from your Terminal handler
          parsed args in this.argv
          quoting levels per arg in this.argQL (value: quote char)
          this.argc: pointer to this.argv and this.argQL (used by parserGetopt)
          call parserGetopt(this, "<options>") from your handler to get opts
          (returns an object with properties for every option flag. any float
          values are stored in Object.<flag>.value; illegal opts in array
          Object.illegals)

  configuration: you may want to overide the follow objects (or add properties):
          parserWhiteSpace: chars to be parsed as whitespace
          parserQuoteChars: chars to be parsed as quotes
          parserSingleEscapes: chars to escape a quote or escape expression
          parserOptionChars: chars that start an option
          parserEscapeExpressions: chars that start escape expressions
*/

// chars to be parsed as white space
var parserWhiteSpace = {
	' ': true,
	'\t': true
}

// chars to be parsed as quotes
var parserQuoteChars = {
	'"': true,
	"'": true,
	'`': true
};

// chars to be parsed as escape char
var parserSingleEscapes = {
	'\\': true
};

// chars that mark the start of an option-expression
// for use with parserGetopt
var parserOptionChars = {
	'-': true
}

// chars that start escape expressions (value = handler)
// plugin handlers for ascii escapes or variable substitution
var parserEscapeExpressions = {
	'%': parserHexExpression
}

function parserHexExpression(termref, pointer, echar, quotelevel) {
	/* example for parserEscapeExpressions
	   params:
	     termref: ref to Terminal instance
	     pointer: position in termref.lineBuffer (echar)
	     echar:   escape character found
	     quotelevel: current quoting level (quote char or empty)
	   char under pointer will be ignored
	   the return value is added to the current argument
	*/
	// convert hex values to chars (e.g. %20 => <SPACE>)
	if (termref.lineBuffer.length > pointer+2) {
		// get next 2 chars
		var hi = termref.lineBuffer.charAt(pointer+1);
		var lo = termref.lineBuffer.charAt(pointer+2);
		lo = lo.toUpperCase();
		hi = hi.toUpperCase();
		// check for valid hex digits
		if ((((hi>='0') && (hi<='9')) || ((hi>='A') && ((hi<='F')))) &&
		    (((lo>='0') && (lo<='9')) || ((lo>='A') && ((lo<='F'))))) {
			// next 2 chars are valid hex, so strip them from lineBuffer
			parserEscExprStrip(termref, pointer+1, pointer+3);
			// and return the char
			return String.fromCharCode(parseInt(hi+lo, 16));
		}
	}
	// if not handled return the escape character (=> no conversion)
	return echar;
}

function parserEscExprStrip(termref, from, to) {
	// strip characters from termref.lineBuffer (for use with escape expressions)
	termref.lineBuffer =
		termref.lineBuffer.substring(0, from) +
		termref.lineBuffer.substring(to);
}

function parserGetopt(termref, optsstring) {
    // scans argv form current position of argc for opts
    // arguments in argv must not be quoted
	// returns an object with a property for every option flag found
	// option values (absolute floats) are stored in Object.<opt>.value (default -1)
	// the property "illegals" contains an array of  all flags found but not in optstring
	// argc is set to first argument that is not an option
	var opts = { 'illegals':[] };
	while ((termref.argc < termref.argv.length) && (termref.argQL[termref.argc]==''))  {
		var a = termref.argv[termref.argc];
		if ((a.length>0) && (parserOptionChars[a.charAt(0)])) {
			var i = 1;
			while (i<a.length) {
				var c=a.charAt(i);
				var v = '';
				while (i<a.length-1) {
					var nc=a.charAt(i+1);
					if ((nc=='.') || ((nc>='0') && (nc<='9'))) {
						v += nc;
						i++;
					}
					else break;
				}
				if (optsstring.indexOf(c)>=0) {
					opts[c] = (v == '')? {value:-1} : (isNaN(v))? {value:0} : {value:parseFloat(v)};
				}
				else {
					opts.illegals[opts.illegals.length]=c;
				}
				i++;
			}
			termref.argc++;
		}
		else break;
	}
	return opts;
}

function parseLine(termref) {
	// stand-alone parser, takes a Terminal instance as argument
	// parses the command line and stores results as instance properties
	//   argv:  list of parsed arguments
	//   argQL: argument's quoting level (<empty> or quote character)
	//   argc:  cursur for argv, set initinally to zero (0)
	// open quote strings are not an error but automatically closed.
	var argv = [''];     // arguments vector
	var argQL = [''];    // quoting level
	var argc = 0;        // arguments cursor
	var escape = false ; // escape flag
	for (var i=0; i<termref.lineBuffer.length; i++) {
		var ch= termref.lineBuffer.charAt(i);
		if (escape) {
			argv[argc] += ch;
			escape = false;
		}
		else if (parserEscapeExpressions[ch]) {
			var v = parserEscapeExpressions[ch](termref, i, ch, argQL[argc]);
			if (typeof v != 'undefined') argv[argc] += v;
		}
		else if (parserQuoteChars[ch]) {
			if (argQL[argc]) {
				if (argQL[argc] == ch) {
					argc ++;
					argv[argc] = argQL[argc] = '';
				}
				else {
					argv[argc] += ch;
				}
			}
			else {
				if (argv[argc] != '') {
					argc ++;
					argv[argc] = '';
					argQL[argc] = ch;
				}
				else {
					argQL[argc] = ch;
				}
			}
		}
		else if (parserWhiteSpace[ch]) {
			if (argQL[argc]) {
				argv[argc] += ch;
			}
			else if (argv[argc] != '') {
				argc++;
				argv[argc] = argQL[argc] = '';
			}
		}
		else if (parserSingleEscapes[ch]) {
			escape = true;
		}
		else {
			argv[argc] += ch;
		}
	}
	if ((argv[argc] == '') && (!argQL[argc])) {
		argv.length--;
		argQL.length--;
	}
	termref.argv = argv;
	termref.argQL = argQL;
	termref.argc = 0;
}

// eof