public void TestLessAndGreater()
{
ArgumentToken <int> token = new ArgumentToken <int> .Builder().Name("arg").Parser(int.TryParse).Build();
TokenMatchResult result1 = new TokenMatchResult(token, "12345", "12345", MatchOutcome.Full, 5, 1);
TokenMatchResult result2 = new TokenMatchResult(token, "123", "123", MatchOutcome.Full, 3, 1);
TokenMatchResult result3 = new TokenMatchResult(token, "12345", "12345", MatchOutcome.Partial, 3, 1);
TokenMatchResult result4 = new TokenMatchResult(token, "123 45", "123 45", MatchOutcome.Full, 5, 2);
//Chars matched
Assert.False(result1 <= result2);
Assert.False(result1 < result2);
Assert.True(result1 > result2);
Assert.True(result1 >= result2);
//Outcome
Assert.True(result1 > result3);
Assert.True(result2 > result3);
//Tokens Matched
Assert.True(result1 < result4);
Assert.True(result4 > result1);
}
/// <summary>
/// If,elseステートメントの開始
/// </summary>
/// <param defaultName="primitives"></param>
/// <returns></returns>
private static IfStatement readIf(TokenCollection stream)
{
IfStatementPrimitive token = stream.GetNextToken() as IfStatementPrimitive;
if (token == null)
{
throw new HspLogicalLineException("条件分岐行：条件分岐プリミティブ以外からスタート");
}
//elseには式がない。
if (stream.NextIsEndOfLine)
{
return(new IfStatement(token));
}
else
{
//式を読む。あまりが出なければOK
ArgumentToken arg = CodeTokenFactory.ReadArgument(stream);
if (stream.NextIsEndOfLine)
{
return(new IfStatement(token, arg));
}
}
throw new HspLogicalLineException("条件分岐行：余分なトークンがある");
}
public void TestParseWithStringArg()
{
VerbToken token1 = new VerbToken(new Name("verb1", "a"));
ArgumentToken token2 = TokenUtils.BuildArgString("arg1");
CommandRoot command1 = new CommandRoot.Builder()
.Id(0)
.Description("command")
.WithToken(token1)
.WithUsage(new CommandUsage.Builder()
.Description("usage1")
.WithToken(token2)
.Build())
.Build();
CommandLibrary library = new CommandLibrary();
library.AddCommand(command1);
CommandUsageMatchData matchData = library.Parse("verb1 \"the entire string\"");
Assert.True(matchData.IsSuccessful);
Assert.True(matchData.HasToken(token1));
Assert.True(matchData.HasToken(token2));
bool hasArg1Val = matchData.TryGetArgValue(token2, out string arg1Val);
Assert.True(hasArg1Val);
Assert.Equal("the entire string", arg1Val);
}
public void TestParse()
{
VerbToken token1 = new VerbToken(new Name("verb1", "a"));
ArgumentToken token2 = new ArgumentToken <int> .Builder().Name("arg").Parser(int.TryParse).IsOptional(false).Build();
CommandRoot command1 = new CommandRoot.Builder()
.Id(0)
.Description("command")
.WithToken(token1)
.WithUsage(new CommandUsage.Builder()
.Description("usage1")
.WithToken(token2)
.Build())
.Build();
CommandLibrary library = new CommandLibrary();
library.AddCommand(command1);
CommandUsageMatchData matchData = library.Parse("verb1 123");
Assert.True(matchData.IsSuccessful);
Assert.True(matchData.HasToken(token1));
Assert.True(matchData.HasToken(token2));
bool hasArgVal = matchData.TryGetArgValue(token2, out int argVal);
Assert.True(hasArgVal);
Assert.Equal(123, argVal);
}
public void TestOptionWithQuotedStringNotFullMatch(string input)
{
ICommandArgumentToken <string> .ValueParser trivialStringParser = (string i, out string v) => { v = i; return(true); };
ArgumentToken arg1 = new ArgumentToken <string> .Builder().Name("arg1").Parser(trivialStringParser).Build();
ArgumentToken arg2 = new ArgumentToken <string> .Builder().Name("arg2").Parser(trivialStringParser).Build();
ArgumentToken arg3 = new ArgumentToken <string> .Builder().Name("arg3").Parser(trivialStringParser).Build();
var token = new OptionWithArgumentToken.Builder()
.Name("option", "alt1", "alt2")
.WithArgument(arg1)
.WithArgument(arg2)
.WithArgument(arg3)
.Build();
ICommandUsage usage = new CommandUsage.Builder().WithToken(token).Build();
TokenMatchCollection matchCollection = CommandParser.Match(usage.Tokens, input);
Assert.True(matchCollection.Matches.Count() == 1);
ParserTokenMatch match = matchCollection.Matches.First();
Assert.False(match.IsFullMatch, input);
}
} /* end ParseInfoRequest */
/* ---------------------------------------------------------------------------
* private method ParseCompilationRequest(sym)
* ---------------------------------------------------------------------------
* compilationRequest :
* dialect? products? capabilities? sourceFile diagnostics?
* ;
* ------------------------------------------------------------------------ */
private static ArgumentToken ParseCompilationRequest(ArgumentToken sym)
{
if (ArgumentLexer.IsDialectOption(sym))
{
sym = ParseDialect(sym);
} /* end */
if (ArgumentLexer.IsProductOption(sym))
{
sym = ParseProducts(sym);
} /* end */
if (ArgumentLexer.IsCapabilityOption(sym))
{
sym = ParseCapabilities(sym);
} /* end */
if (sym == ArgumentToken.SOURCE_FILE)
{
sym = ParseSourceFile(sym);
}
else
{
ReportMissingSourceFile();
} /* end if */
if (ArgumentLexer.IsDiagnosticsOption(sym))
{
sym = ParseDiagnostics(sym);
} /* end */
return(sym);
} /* end ParseCompilationRequest */
public void TestMatchArgValuesWithOptionalTokens()
{
ArgumentToken arg1 = new ArgumentToken <int> .Builder().Name("arg1").IsOptional(false).Parser(int.TryParse).Build();
ArgumentToken arg2 = new ArgumentToken <double> .Builder().Name("arg2").IsOptional(false).Parser(double.TryParse).Build();
var tokens = new ICommandToken[]
{
new VerbToken(new Name("verb0")),
new OptionWithArgumentToken.Builder().Name("-o2", "--option2").WithArgument(arg1).WithArgument(arg2).Build(),
};
var builder = new CommandUsage.Builder().Description("test usage");
foreach (var token in tokens)
{
builder.WithToken(token);
}
ICommandUsage usage = builder.Build();
TokenMatchCollection matchCollection = CommandParser.Match(usage.Tokens, "verb0 -o2 1 2.34");
int arg1Value;
bool arg1Exists = matchCollection.TryGetArgValue(arg1, out arg1Value);
double arg2Value;
bool arg2Exists = matchCollection.TryGetArgValue(arg2, out arg2Value);
Assert.True(arg1Exists);
Assert.True(arg2Exists);
Assert.Equal(1, arg1Value);
Assert.Equal(2.34, arg2Value);
}
[InlineData("-o2 1", false)] //partial match
public void TestTokenIsFullMatch(string input, bool expIsFullMatch)
{
ArgumentToken arg1 = new ArgumentToken <int> .Builder().Name("arg1").IsOptional(false).Parser(int.TryParse).Build();
ArgumentToken arg2 = new ArgumentToken <double> .Builder().Name("arg2").IsOptional(false).Parser(double.TryParse).Build();
var tokens = new ICommandToken[]
{
new OptionWithArgumentToken.Builder().Name("-o2", "--option2").WithArgument(arg1).WithArgument(arg2).Build()
};
var builder = new CommandUsage.Builder()
.Description("test usage");
foreach (var token in tokens)
{
builder.WithToken(token);
}
ICommandUsage usage = builder.Build();
TokenMatchCollection matchCollection = CommandParser.Match(usage.Tokens, input);
Assert.Same(usage.Tokens, matchCollection.MatchableTokens);
Assert.NotEmpty(matchCollection.Matches);
Assert.Equal(1, matchCollection.Matches.Count());
ParserTokenMatch match = matchCollection.Matches.First();
Assert.Equal(expIsFullMatch, match.IsFullMatch);
}
} /* end */
/* ---------------------------------------------------------------------------
* private method ParseDiagnostics(sym)
* ---------------------------------------------------------------------------
* diagnostics :
* ( VERBOSE | LEXER_DEBUG | PARSER_DEBUG | PRINT_SETTINGS
* ERRANT_SEMICOLONS )+
* ;
* ------------------------------------------------------------------------ */
private static ArgumentToken ParseDiagnostics(ArgumentToken sym)
{
while (ArgumentLexer.IsDiagnosticsOption(sym))
{
switch (sym)
{
case ArgumentToken.VERBOSE:
CompilerOptions.SetOption(Option.Verbose, true);
break;
case ArgumentToken.LEXER_DEBUG:
CompilerOptions.SetOption(Option.LexerDebug, true);
break;
case ArgumentToken.PARSER_DEBUG:
CompilerOptions.SetOption(Option.ParserDebug, true);
break;
case ArgumentToken.SHOW_SETTINGS:
CompilerOptions.SetOption(Option.ShowSettings, true);
break;
case ArgumentToken.ERRANT_SEMICOLONS:
CompilerOptions.SetOption(Option.ErrantSemicolons, true);
break;
} /* end switch */
sym = ArgumentLexer.NextToken();
} /* end while*/
return(sym);
} /* end ParseDiagnostics */
/// <summary>
/// 代入行
/// </summary>
/// <param defaultName="primitives"></param>
/// <returns></returns>
private static Assignment readAssignment(TokenCollection stream)
{
//変数を読む。失敗したら代入行じゃない。
VariableToken token = CodeTokenFactory.ReadVariable(stream);
//演算子を読む。失敗するなら代入行じゃない。
if (stream.NextIsEndOfLine)
{
throw new HspLogicalLineException("代入行：演算子なし");
}
OperatorToken op = CodeTokenFactory.ReadOperator(stream);
//式が続かないこともある。"x++"とか
if (stream.NextIsEndOfLine)
{
return(new Assignment(token, op));
}
else
{
//引数を読む。あまりが出なければOK
ArgumentToken arg = CodeTokenFactory.ReadArgument(stream);
if (stream.NextIsEndOfLine)
{
return(new Assignment(token, op, arg));
}
}
throw new HspLogicalLineException("代入行：余分なトークンがある");
}
public void TestParseArgument()
{
var arguments = new[] { "--some-option", "file1.bmp", "file2.png" };
var tokens = ArgumentToken.ParseArgument(arguments).ToArray();
var expected = new[] { new ArgumentToken("--some-option"), new ArgumentToken("file1.bmp"), new ArgumentToken("file2.png") };
CollectionAssert.AreEqual(expected, tokens);
}
public void TestArgumentTokenConstruction()
{
var token = new ArgumentToken <int> .Builder().Name("arg1").IsOptional(false).Parser(int.TryParse).Build();
Assert.Equal("arg1", token.ArgumentName);
Assert.Equal("<arg1>", token.DisplayName);
Assert.False(token.IsOptional);
Assert.Equal(TokenKind.Argument, token.Kind);
}
private static LogicalLine readMcall(TokenCollection stream)
{
int start = stream.Position;
McallFunctionPrimitive mcall = stream.GetNextToken() as McallFunctionPrimitive;
if (mcall == null)
{
throw new HspLogicalLineException("mcall：mcallプリミティブ以外からスタート");
}
if (stream.NextIsEndOfLine)
{
stream.Position = start;
return((LogicalLine)readCommand(stream));
}
ExpressionToken exp = CodeTokenFactory.ReadExpression(stream);
if (exp.CanRpnConvert) //RPN変換ができるなら普通の関数として扱う。
{
stream.Position = start;
return((LogicalLine)readCommand(stream));
}
stream.Position = start;
stream.GetNextToken();
VariablePrimitive var = stream.GetNextToken() as VariablePrimitive;
if (var == null)
{
throw new HspLogicalLineException("mcall行：変換不能な形式");
}
if (stream.NextIsBracketStart) //mcall の記法は配列変数を認めない
{
throw new HspLogicalLineException("mcall行：変換不能な形式");
}
if (stream.NextIsEndOfLine)
{
throw new HspLogicalLineException("mcall行：変換不能な形式");
}
exp = CodeTokenFactory.ReadExpression(stream);
if (stream.NextIsEndOfLine)
{
return(new McallStatement(mcall, var, exp, null));
}
ArgumentToken arg = CodeTokenFactory.ReadArgument(stream);
if (stream.NextIsEndOfLine)
{
return(new McallStatement(mcall, var, exp, arg));
}
throw new HspLogicalLineException("mcall行：余分なトークンがある");
}
public static bool TryMatchYesterday(ArgumentToken token, DateTime currentDate, string[] inputTokens, int startIdx, out TokenMatchResult result)
{
//Yesterday
if (inputTokens[startIdx].Equals("yesterday", StringComparison.CurrentCultureIgnoreCase))
{
DateTime output = currentDate.Subtract(new TimeSpan(1, 0, 0, 0));
result = new TokenMatchResult(token, inputTokens[startIdx], inputTokens[startIdx], MatchOutcome.Full, inputTokens[startIdx].Length, 1);
result.SetArgValue(token, output);
return(true);
}
result = TokenMatchResult.None;
return(false);
}
public void TestTryGetValueByString()
{
ArgumentToken <int> token = new ArgumentToken <int> .Builder().Name("arg").Parser(int.TryParse).Build();
TokenMatchResult result = new TokenMatchResult(token, "123", "123", MatchOutcome.Full, 3, 1);
result.SetArgValue(token, 123);
int argValue;
bool hasValue = result.TryGetArgValue("arg", out argValue);
Assert.True(hasValue);
Assert.Equal(123, argValue);
}
[InlineData(new [] { "a" }, 0, MatchOutcome.Partial, 0)] //not enough
public void TestOptionWithArgumentsMatches(string[] input, int startIdx, MatchOutcome expMatchLength, int expNumMatchTokens)
{
ArgumentToken arg1 = new ArgumentToken <int> .Builder().Name("arg1").Parser(int.TryParse).Build();
var token = new OptionWithArgumentToken.Builder()
.Name("option", "alt1", "alt2")
.WithArgument(arg1)
.Build();
TokenMatchResult matchResult = token.Matches(input, startIdx);
Assert.True(expMatchLength == matchResult.MatchOutcome, $"Failed in case \"{input}\"");
Assert.Equal(expNumMatchTokens, matchResult.TokensMatched);
}
public static bool TryMatchExplicitDate(ArgumentToken token, string[] inputTokens, int startIdx, out TokenMatchResult result)
{
DateTime output;
//Explicit date
if (DateTime.TryParse(inputTokens[startIdx], out output))
{
result = new TokenMatchResult(token, inputTokens[startIdx], inputTokens[startIdx], MatchOutcome.Full, inputTokens[startIdx].Length, 1);
result.SetArgValue(token, output);
return(true);
}
result = TokenMatchResult.None;
return(false);
}
public void TestLoadArgumentOptionCollection_NoToken()
{
var logger = new LoggerImpl();
var argumentTokens = new ArgumentToken[0];
var(optionCollection, remainningTokens) = ArgumentOptionCollection.LoadArgumentOptionCollection(argumentTokens, logger);
Assert.IsFalse(optionCollection.AllowDestinationOverwrite);
Assert.IsFalse(optionCollection.EnableRecursiveDirectorySearch);
Assert.AreEqual(ImageFileKind.Pdf, optionCollection.DestinationImageFileKind);
Assert.AreEqual(new Range <uint>(uint.MinValue, uint.MaxValue), optionCollection.PowerpointPageRange);
Assert.IsFalse(optionCollection.EnableVersionInfoDisplay);
Assert.AreEqual(0, remainningTokens.Count);
}
} /* end ParseMultipleProducts */
/* ---------------------------------------------------------------------------
* private method ParseIdentifierOption(sym)
* ---------------------------------------------------------------------------
* identifierOption :
* USE_IDENTIFIERS_VERBATIM | TRANSLITERATE_IDENTIFIERS
* ;
* ------------------------------------------------------------------------ */
private static ArgumentToken ParseIdentifierOption(ArgumentToken sym)
{
switch (sym)
{
case ArgumentToken.USE_IDENTIFIERS_VERBATIM:
CompilerOptions.SetOption(Option.UseIdentifiersVerbatim, true);
break;
case ArgumentToken.TRANSLITERATE_IDENTIFIERS:
CompilerOptions.SetOption(Option.UseIdentifiersVerbatim, false);
break;
} /* end switch */
return(ArgumentLexer.NextToken());
} /* end ParseIdentifierOption */
} /* end ParseIdentifierOption */
/* ---------------------------------------------------------------------------
* private method ParseCommentOption(sym)
* ---------------------------------------------------------------------------
* commentOption :
* PRESERVE_COMMENTS | STRIP_COMMENTS
* ;
* ------------------------------------------------------------------------ */
private static ArgumentToken ParseCommentOption(ArgumentToken sym)
{
switch (sym)
{
case ArgumentToken.PRESERVE_COMMENTS:
CompilerOptions.SetOption(Option.PreserveComments, true);
break;
case ArgumentToken.STRIP_COMMENTS:
CompilerOptions.SetOption(Option.PreserveComments, false);
break;
} /* end switch */
return(ArgumentLexer.NextToken());
} /* end ParseCommentOption */
[InlineData(new [] { "1234", "b", "c", "d" }, 2, false, 0)] //Match is before the start token
public void TestArgumentMatches(string[] input, int startIdx, bool expMatches, int expMatchLength)
{
var token = new ArgumentToken <int> .Builder().Name("arg1").IsOptional(false).Parser(int.TryParse).Build();
TokenMatchResult matchResult = token.Matches(input, startIdx);
if (expMatches)
{
Assert.True(matchResult.MatchOutcome == MatchOutcome.Full, $"Failed in case \"{input}\"");
}
else
{
Assert.False(matchResult.MatchOutcome == MatchOutcome.Full, $"Failed in case \"{input}\"");
}
Assert.Equal(expMatchLength, matchResult.TokensMatched);
}
public void TestOptionWithArgumentsTokenConstruction()
{
ArgumentToken arg1 = new ArgumentToken <int> .Builder().Name("arg1").Parser(int.TryParse).Build();
Name name = new Name("option", "alt1", "alt2");
var token = new OptionWithArgumentToken.Builder()
.Name("option", "alt1", "alt2")
.WithArgument(arg1)
.Build();
Assert.Equal(name, token.Name);
Assert.Equal("(option|alt1|alt2) <arg1>", token.DisplayName);
Assert.True(token.IsOptional);
Assert.Equal(TokenKind.OptionWithArgument, token.Kind);
Assert.Equal(1, token.Arguments.Length);
Assert.Same(arg1, token.Arguments[0]);
}
} /* end ParseCompilationRequest */
/* ---------------------------------------------------------------------------
* private method ParseDialect(sym)
* ---------------------------------------------------------------------------
* dialect :
* ( PIM3 | PIM4 ) ( SAFER | COMPLIANT )? | EXT
* ;
* ------------------------------------------------------------------------ */
private static ArgumentToken ParseDialect(ArgumentToken sym)
{
if (sym == ArgumentToken.EXT)
{
CompilerOptions.SetDialect(Dialect.Extended);
}
else
{
switch (sym)
{
case ArgumentToken.PIM3:
CompilerOptions.SetDialect(Dialect.PIM3);
break;
case ArgumentToken.PIM4:
CompilerOptions.SetDialect(Dialect.PIM4);
break;
} /* end switch */
sym = ArgumentLexer.NextToken();
switch (sym)
{
case ArgumentToken.SAFER:
CompilerOptions.SetOption(Option.Synonyms, false);
CompilerOptions.SetOption(Option.OctalLiterals, false);
CompilerOptions.SetOption(Option.ExplicitCast, false);
CompilerOptions.SetOption(Option.Coroutines, false);
CompilerOptions.SetOption(Option.VariantRecords, false);
CompilerOptions.SetOption(Option.LocalModules, false);
break;
case ArgumentToken.COMPLIANT:
CompilerOptions.SetOption(Option.Synonyms, true);
CompilerOptions.SetOption(Option.OctalLiterals, true);
CompilerOptions.SetOption(Option.ExplicitCast, true);
CompilerOptions.SetOption(Option.Coroutines, true);
CompilerOptions.SetOption(Option.VariantRecords, true);
CompilerOptions.SetOption(Option.LocalModules, true);
break;
} /* end switch */
} /* end if */
return(ArgumentLexer.NextToken());
} /* end ParseDialect */
public void TestEqualAndHashCode()
{
ArgumentToken <int> token = new ArgumentToken <int> .Builder().Name("arg").Parser(int.TryParse).Build();
TokenMatchResult result1 = new TokenMatchResult(token, "123", "123", MatchOutcome.Full, 3, 1);
TokenMatchResult result2 = new TokenMatchResult(token, "123", "123", MatchOutcome.Full, 3, 1);
Assert.Equal(result1, result2);
Assert.True(result1 == result2);
Assert.False(result1 != result2);
Assert.True(result1 <= result2);
Assert.True(result1 >= result2);
Assert.False(result1.Equals(null));
Assert.True(result1.Equals((object)result2));
Assert.False(result1.Equals("not the same type"));
Assert.Equal(result1.GetHashCode(), result2.GetHashCode());
}
[InlineData("verb0 verb4 -o1 -o2 1 2.34 -o3", 0, 4)] //All tokens present, wrong order
public void TestMatchWithOptionalTokensWithArgs(string input, params int[] expectedMatchingIndexes)
{
ArgumentToken arg1 = new ArgumentToken <int> .Builder().Name("arg1").IsOptional(false).Parser(int.TryParse).Build();
ArgumentToken arg2 = new ArgumentToken <double> .Builder().Name("arg2").IsOptional(false).Parser(double.TryParse).Build();
var tokens = new ICommandToken[]
{
new VerbToken(new Name("verb0")),
new StandAloneOptionToken(new Name("-o1", "--option1")),
new OptionWithArgumentToken.Builder().Name("-o2", "--option2").WithArgument(arg1).WithArgument(arg2).Build(),
new StandAloneOptionToken(new Name("-o3", "--option3")),
new VerbToken(new Name("verb4")),
};
var builder = new CommandUsage.Builder()
.Description("test usage");
foreach (var token in tokens)
{
builder.WithToken(token);
}
ICommandUsage usage = builder.Build();
TokenMatchCollection matchCollection = CommandParser.Match(usage.Tokens, input);
Assert.Same(usage.Tokens, matchCollection.MatchableTokens);
if (expectedMatchingIndexes.Length > 0)
{
Assert.NotEmpty(matchCollection.Matches);
Assert.Equal(expectedMatchingIndexes.Length, matchCollection.Matches.Count());
//Ensure all that are expected are there
foreach (var expectedMatchingIndex in expectedMatchingIndexes)
{
Assert.True(matchCollection.Matches.Any(x => x.TokenIdx == expectedMatchingIndex));
}
}
else
{
Assert.Empty(matchCollection.Matches);
}
}
} /* end ParseSingleProduct */
/* ---------------------------------------------------------------------------
* private method ParseMultipleProducts(sym)
* ---------------------------------------------------------------------------
* multipleProducts :
* ( ast | graph | xlat | obj )+
* ;
* ------------------------------------------------------------------------ */
private static ArgumentToken ParseMultipleProducts(ArgumentToken sym)
{
while (ArgumentLexer.IsMultipleProductsOption(sym))
{
switch (sym)
{
case ArgumentToken.AST:
SetOption(Option.AstRequired, true);
break;
case ArgumentToken.NO_AST:
SetOption(Option.AstRequired, false);
break;
case ArgumentToken.GRAPH:
SetOption(Option.GraphRequired, true);
break;
case ArgumentToken.NO_GRAPH:
SetOption(Option.GraphRequired, true);
break;
case ArgumentToken.XLAT:
SetOption(Option.XlatRequired, true);
break;
case ArgumentToken.NO_XLAT:
SetOption(Option.XlatRequired, false);
break;
case ArgumentToken.OBJ:
SetOption(Option.ObjRequired, true);
break;
case ArgumentToken.NO_OBJ:
SetOption(Option.ObjRequired, true);
break;
} /* end switch */
sym = ArgumentLexer.NextToken();
} /* end while */
return(sym);
} /* end ParseMultipleProducts */
public static bool TryMatchLastDayOfWeek(ArgumentToken token, DateTime currentDate, string[] inputTokens, int startIdx, out TokenMatchResult result)
{
//last <day-of-week>
if (inputTokens.Length > startIdx + 1)
{
DayOfWeek dayOfWeek;
if (DateParser.TryParseDayOfWeek(inputTokens[startIdx + 1], out dayOfWeek))
{
DateTime output = DateUtil.GetRelativeDateDayOfWeek(currentDate, dayOfWeek);
string matchText = TokenUtils.GetMatchText(inputTokens, startIdx, 2);
result = new TokenMatchResult(token, matchText, matchText, MatchOutcome.Full, matchText.Length, 2);
result.SetArgValue(token, output);
return(true);
}
}
result = TokenMatchResult.None;
return(false);
}
} /* end ErrorCount */
/* ---------------------------------------------------------------------------
* private method ParseInfoRequest(sym)
* ---------------------------------------------------------------------------
* infoRequest :
* HELP | VERSION | LICENSE
* ;
* ------------------------------------------------------------------------ */
private static ArgumentToken ParseInfoRequest(ArgumentToken sym)
{
switch (sym)
{
case ArgumentToken.HELP:
status = ArgumentStatus.HelpRequested;
break;
case ArgumentToken.VERSION:
status = ArgumentStatus.VersionRequested;
break;
case ArgumentToken.LICENSE:
status = ArgumentStatus.LicenseRequested;
break;
} /* end switch */
return(ArgumentLexer.NextToken());
} /* end ParseInfoRequest */
} /* end ParseProducts */
/* ---------------------------------------------------------------------------
* private method ParseSingleProduct(sym)
* ---------------------------------------------------------------------------
* singleProduct :
* SYNTAX_ONLY | AST_ONLY | GRAPH_ONLY | XLAT_ONLY | OBJ_ONLY
* ;
* ------------------------------------------------------------------------ */
private static ArgumentToken ParseSingleProduct(ArgumentToken sym)
{
switch (sym)
{
case ArgumentToken.SYNTAX_ONLY:
CompilerOptions.SetOption(Option.AstRequired, false);
CompilerOptions.SetOption(Option.GraphRequired, false);
CompilerOptions.SetOption(Option.XlatRequired, false);
CompilerOptions.SetOption(Option.ObjRequired, false);
break;
case ArgumentToken.AST_ONLY:
CompilerOptions.SetOption(Option.AstRequired, true);
CompilerOptions.SetOption(Option.GraphRequired, false);
CompilerOptions.SetOption(Option.XlatRequired, false);
CompilerOptions.SetOption(Option.ObjRequired, false);
break;
case ArgumentToken.GRAPH_ONLY:
CompilerOptions.SetOption(Option.AstRequired, false);
CompilerOptions.SetOption(Option.GraphRequired, true);
CompilerOptions.SetOption(Option.XlatRequired, false);
CompilerOptions.SetOption(Option.ObjRequired, false);
break;
case ArgumentToken.XLAT_ONLY:
CompilerOptions.SetOption(Option.AstRequired, false);
CompilerOptions.SetOption(Option.GraphRequired, false);
CompilerOptions.SetOption(Option.XlatRequired, true);
CompilerOptions.SetOption(Option.ObjRequired, false);
break;
case ArgumentToken.OBJ_ONLY:
CompilerOptions.SetOption(Option.AstRequired, false);
CompilerOptions.SetOption(Option.GraphRequired, false);
CompilerOptions.SetOption(Option.XlatRequired, false);
CompilerOptions.SetOption(Option.ObjRequired, true);
break;
} /* end switch */
return(ArgumentLexer.NextToken());
} /* end ParseSingleProduct */
public static bool TryMatchLastDayOfMonth(ArgumentToken token, DateTime currentDate, string[] inputTokens, int startIdx, out TokenMatchResult result)
{
//last <month> <day-of-month>
if (inputTokens.Length > startIdx + 2)
{
int month;
int day;
if (DateParser.TryParseMonth(inputTokens[startIdx + 1], out month) &&
DateParser.TryParseDayOfMonth(inputTokens[startIdx + 2], currentDate.Year - 1, month, out day))
{
DateTime output = new DateTime(currentDate.Year - 1, month, day);
string matchText = TokenUtils.GetMatchText(inputTokens, startIdx, 3);
result = new TokenMatchResult(token, matchText, matchText, MatchOutcome.Full, matchText.Length, 3);
result.SetArgValue(token, output);
return(true);
}
}
result = TokenMatchResult.None;
return(false);
}
