2008-12-09 20:55:34 +00:00
|
|
|
|
#region CPL License
|
|
|
|
|
/*
|
|
|
|
|
Nuclex Framework
|
|
|
|
|
Copyright (C) 2002-2008 Nuclex Development Labs
|
|
|
|
|
|
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
|
|
|
modify it under the terms of the IBM Common Public License as
|
|
|
|
|
published by the IBM Corporation; either version 1.0 of the
|
|
|
|
|
License, or (at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
IBM Common Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the IBM Common Public
|
|
|
|
|
License along with this library
|
|
|
|
|
*/
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
using System;
|
|
|
|
|
using System.Collections.Generic;
|
2008-12-10 19:26:25 +00:00
|
|
|
|
using System.Diagnostics;
|
2008-12-09 20:55:34 +00:00
|
|
|
|
|
|
|
|
|
namespace Nuclex.Support.Parsing {
|
|
|
|
|
|
|
|
|
|
partial class CommandLine {
|
|
|
|
|
|
|
|
|
|
/// <summary>Parses command line strings</summary>
|
2008-12-10 19:26:25 +00:00
|
|
|
|
private class Parser {
|
|
|
|
|
|
|
|
|
|
/// <summary>Initializes a new command line parser</summary>
|
|
|
|
|
private Parser() {
|
|
|
|
|
this.commandLine = new CommandLine();
|
|
|
|
|
}
|
2008-12-09 20:55:34 +00:00
|
|
|
|
|
|
|
|
|
/// <summary>Parses a string containing command line arguments</summary>
|
|
|
|
|
/// <param name="commandLineString">String that will be parsed</param>
|
|
|
|
|
/// <returns>The parsed command line arguments from the string</returns>
|
|
|
|
|
public static CommandLine Parse(string commandLineString) {
|
2008-12-10 19:26:25 +00:00
|
|
|
|
Parser theParser = new Parser();
|
|
|
|
|
theParser.parse(commandLineString);
|
|
|
|
|
return theParser.commandLine;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Parses the provided string and adds the parameters found to
|
|
|
|
|
/// the command line representation
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="commandLineString">
|
|
|
|
|
/// String containing the command line arguments that will be parsed
|
|
|
|
|
/// </param>
|
|
|
|
|
private void parse(string commandLineString) {
|
2008-12-09 20:55:34 +00:00
|
|
|
|
if(commandLineString == null) {
|
2008-12-10 19:26:25 +00:00
|
|
|
|
return;
|
2008-12-09 20:55:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-12-10 19:26:25 +00:00
|
|
|
|
// Walk through the command line character by character and gather
|
|
|
|
|
// the parameters and values to build the command line representation from
|
2008-12-09 20:55:34 +00:00
|
|
|
|
for(int index = 0; index < commandLineString.Length; ) {
|
|
|
|
|
|
2008-12-10 19:26:25 +00:00
|
|
|
|
// Look for the next non-whitespace character
|
|
|
|
|
index = StringHelper.IndexNotOfAny(
|
|
|
|
|
commandLineString, WhitespaceCharacters, index
|
|
|
|
|
);
|
|
|
|
|
if(index == -1) {
|
|
|
|
|
break;
|
2008-12-09 20:55:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-12-10 19:26:25 +00:00
|
|
|
|
// Parse the chunk of characters at this location and advance the index
|
|
|
|
|
// to the next location after the chunk of characters
|
|
|
|
|
index += parseCharacterChunk(commandLineString, index);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Parses a chunk of characters and adds it as an option or a loose value to
|
|
|
|
|
/// the command line representation we're building
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="commandLineString">
|
|
|
|
|
/// String containing the chunk of characters that will be parsed
|
|
|
|
|
/// </param>
|
|
|
|
|
/// <param name="index">Index in the string at which to begin parsing</param>
|
|
|
|
|
/// <returns>The number of characters that were consumed</returns>
|
|
|
|
|
private int parseCharacterChunk(string commandLineString, int index) {
|
|
|
|
|
int startIndex = index;
|
|
|
|
|
|
|
|
|
|
char currentCharacter = commandLineString[index];
|
|
|
|
|
switch(currentCharacter) {
|
|
|
|
|
|
|
|
|
|
// Unix style argument using either '-' or "--" as its initiator
|
|
|
|
|
case '-': {
|
|
|
|
|
++index;
|
|
|
|
|
|
|
|
|
|
// Does the string end here? Stop parsing.
|
|
|
|
|
if(index >= commandLineString.Length) {
|
|
|
|
|
addValue("-");
|
2008-12-09 20:55:34 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2008-12-10 19:26:25 +00:00
|
|
|
|
|
|
|
|
|
// Does another '-' follow? Might be a unix style option or a loose "--"
|
|
|
|
|
if(commandLineString[index] == '-') {
|
|
|
|
|
++index;
|
|
|
|
|
index += parsePotentialOption(commandLineString, startIndex, index);
|
|
|
|
|
} else { // Nope, it's a normal option or a loose '-'
|
|
|
|
|
index += parsePotentialOption(commandLineString, startIndex, index);
|
2008-12-09 20:55:34 +00:00
|
|
|
|
}
|
2008-12-10 19:26:25 +00:00
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Windows style argument using '/' as its initiator
|
|
|
|
|
case '/': {
|
|
|
|
|
++index;
|
|
|
|
|
index += parsePotentialOption(commandLineString, startIndex, index);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Quoted loose value
|
|
|
|
|
case '"': {
|
|
|
|
|
StringSegment value = parseQuotedValue(commandLineString, index);
|
|
|
|
|
index += value.Count + 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Unquoted loose value
|
|
|
|
|
default: {
|
|
|
|
|
StringSegment value = parseNakedValue(commandLineString, index);
|
|
|
|
|
index += value.Count;
|
|
|
|
|
break;
|
2008-12-09 20:55:34 +00:00
|
|
|
|
}
|
2008-12-10 19:26:25 +00:00
|
|
|
|
|
2008-12-09 20:55:34 +00:00
|
|
|
|
}
|
2008-12-10 19:26:25 +00:00
|
|
|
|
|
|
|
|
|
return index - startIndex;
|
2008-12-09 20:55:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-12-10 19:26:25 +00:00
|
|
|
|
/// <summary>Parses a potential command line option</summary>
|
|
|
|
|
/// <param name="commandLineString">String containing the command line arguments</param>
|
|
|
|
|
/// <param name="initiatorStartIndex">
|
|
|
|
|
/// Index of the option's initiator ('-' or '--' or '/')
|
|
|
|
|
/// </param>
|
|
|
|
|
/// <param name="index">
|
|
|
|
|
/// Index at which the option name is supposed start (if it's an actual option)
|
|
|
|
|
/// </param>
|
|
|
|
|
/// <returns>The number of characters consumed</returns>
|
|
|
|
|
private int parsePotentialOption(
|
|
|
|
|
string commandLineString, int initiatorStartIndex, int index
|
2008-12-09 20:55:34 +00:00
|
|
|
|
) {
|
2008-12-10 19:26:25 +00:00
|
|
|
|
|
|
|
|
|
// If the string ends here this can only be considered as a loose value
|
|
|
|
|
if(index >= commandLineString.Length) {
|
|
|
|
|
addValue(commandLineString.Substring(initiatorStartIndex));
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Look for the first character that ends the option. If it is not an actual option,
|
|
|
|
|
// the very first character might be the end
|
|
|
|
|
int nameEndIndex = commandLineString.IndexOfAny(OptionNameEndingCharacters, index);
|
|
|
|
|
if(nameEndIndex == -1) {
|
|
|
|
|
nameEndIndex = commandLineString.Length;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If the first character of the supposed option is not valid for an option,
|
|
|
|
|
// we have to consider this to be a loose value
|
|
|
|
|
if(nameEndIndex == index) {
|
|
|
|
|
// Parse normal unquoted value
|
|
|
|
|
//parseNakedValue(commandLineString, initiatorStartIndex).Count;
|
|
|
|
|
/*
|
|
|
|
|
int endIndex = commandLineString.IndexOfAny(WhitespaceCharacters, index);
|
|
|
|
|
if(endIndex == -1) {
|
|
|
|
|
addValue(commandLineString.Substring(initiatorStartIndex));
|
|
|
|
|
return commandLineString.Length - index;
|
|
|
|
|
} else {
|
|
|
|
|
addValue(
|
|
|
|
|
commandLineString.Substring(initiatorStartIndex, endIndex - initiatorStartIndex)
|
|
|
|
|
);
|
|
|
|
|
return endIndex - index;
|
|
|
|
|
}
|
|
|
|
|
*/
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Console.WriteLine(
|
|
|
|
|
"Argument name: " + commandLineString.Substring(index, nameEndIndex - index)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
// TODO: Parse argument value (if provided) here!!
|
|
|
|
|
|
|
|
|
|
return nameEndIndex - index;
|
2008-12-09 20:55:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-12-10 19:26:25 +00:00
|
|
|
|
static readonly char[] OptionNameEndingCharacters = new char[] {
|
|
|
|
|
' ', '\t', '=', ':', '/', '-', '+', '"'
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/// <summary>Parses a quoted value from the input string</summary>
|
|
|
|
|
/// <param name="commandLineString">String the quoted value is parsed from</param>
|
|
|
|
|
/// <param name="index">Index at which the quoted value begins</param>
|
|
|
|
|
/// <returns>A string segment containing the parsed quoted value</returns>
|
|
|
|
|
/// <remarks>
|
|
|
|
|
/// The returned string segment does not include the quotes.
|
|
|
|
|
/// </remarks>
|
|
|
|
|
private static StringSegment parseQuotedValue(string commandLineString, int index) {
|
|
|
|
|
char quoteCharacter = commandLineString[index];
|
|
|
|
|
++index;
|
|
|
|
|
|
|
|
|
|
int endIndex = commandLineString.IndexOf(quoteCharacter, index);
|
|
|
|
|
if(endIndex == -1) {
|
|
|
|
|
endIndex = commandLineString.Length;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// TODO: We don't skip the closing quote, the callee would have to detect it himself
|
|
|
|
|
|
|
|
|
|
return new StringSegment(commandLineString, index, endIndex - index);
|
2008-12-09 20:55:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-12-10 19:26:25 +00:00
|
|
|
|
/// <summary>Parses a plain, unquoted value from the input string</summary>
|
|
|
|
|
/// <param name="commandLineString">String containing the value to be parsed</param>
|
|
|
|
|
/// <param name="index">Index at which the value begins</param>
|
|
|
|
|
/// <returns>A string segment containing the parsed value</returns>
|
|
|
|
|
private static StringSegment parseNakedValue(string commandLineString, int index) {
|
2008-12-09 20:55:34 +00:00
|
|
|
|
int endIndex = commandLineString.IndexOfAny(WhitespaceCharacters, index);
|
2008-12-10 19:26:25 +00:00
|
|
|
|
if(endIndex == -1) {
|
|
|
|
|
endIndex = commandLineString.Length;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return new StringSegment(commandLineString, index, endIndex - index);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Determines whether the specified character is valid as the first character
|
|
|
|
|
/// in an option
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="character">Character that will be tested for validity</param>
|
|
|
|
|
/// <returns>True if the character is valid as the first character in an option</returns>
|
|
|
|
|
private static bool isValidFirstCharacterInOption(char character) {
|
|
|
|
|
const string InvalidCharacters = " \t=:/-+\"";
|
|
|
|
|
return (InvalidCharacters.IndexOf(character) == -1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private void addValue(string value) {
|
|
|
|
|
Console.WriteLine("Added Value: '" + value + "'");
|
2008-12-09 20:55:34 +00:00
|
|
|
|
}
|
2008-12-10 19:26:25 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// <summary>Characters the parser considers to be whitespace</summary>
|
2008-12-09 20:55:34 +00:00
|
|
|
|
private static readonly char[] WhitespaceCharacters = new char[] { ' ', '\t' };
|
2008-12-10 19:26:25 +00:00
|
|
|
|
|
|
|
|
|
/// <summary>Command line currently being built by the parser</summary>
|
|
|
|
|
private CommandLine commandLine;
|
|
|
|
|
|
2008-12-09 20:55:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // namespace Nuclex.Support.Parsing
|