public void Tell(ITriggerMsg e)
{
// tell <nick> <message>
var message =
e.GetArg(out string destinationNick)
.ToJoined(JoinedOptions.TrimExterior);
if (ParseArgs.Success(destinationNick, message))
{
var inbox = inboxes.GetOrNew(destinationNick);
if (inbox.Add(e.Nick, message))
{
e.Reply("Sending message to {0} when they're active. [{1}/{2}]",
destinationNick, inbox.MessagesCount, inbox.Capacity);
inboxes.Save(inbox);
}
else
{
e.Reply("Sorry, {0}'s inbox is full!", destinationNick);
}
}
// Short circuit tell to tell-read if not enough arguments.
else
{
Read(e);
}
}
public override PluginArgs InputText(PluginArgs args)
{
if (args.Command.StartsWith("!google"))
{
String search = args.Command.Substring(8);
search = search.Replace(" ", "%20");
search = search.Replace("&", "&");
string url = "http://www.google.ca/search?q=" + search;
args.Command = "/say " + args.Command;
OnCommand(args);
ParseArgs pa = new ParseArgs
{
args = args,
url = url,
self = true
};
BackgroundWorker bgw = new BackgroundWorker();
bgw.DoWork += new DoWorkEventHandler(Bgw_DoWork);
bgw.RunWorkerAsync(pa);
//ParseGoogleResults(args, url, true);
args.Command = "";
}
return(base.InputText(args));
}
public IParse Parse(string s, ParseArgs args = null)
{
DeclensionFlags flags = ConvertToDeclensionFlags(args);
var parse = _client.Parse(s, flags);
return(new Parse(parse));
}
protected override int InnerParse(ParseArgs args)
{
((MarkdownGrammar)args.Grammar).IndentLevel++;
var match = base.InnerParse(args);
((MarkdownGrammar)args.Grammar).IndentLevel--;
return match;
}
static void Main(string[] args)
{
var log = new SIR.Common.Log.Logger("SIR.Sync", new Common.Log.LoggerConfig()
{
Console = new Common.Log.LoggerConfig.ConsoleConfig()
{
ShowInConsole = true
}
});
try
{
log.Info("== Inicio de Procesamiento de SIR.Sync ==");
log.Info($"Version: {System.Reflection.Assembly.GetExecutingAssembly().GetName().Version}");
log.Info($"Command: {AppDomain.CurrentDomain.FriendlyName} {string.Join(' ', args)}");
var optionsRes = new ParseArgs().Parse <Arguments>(args);
if (optionsRes.ExistsErrorMessages)
{
log.Log(optionsRes);
Console.ReadLine();
return;
}
var options = optionsRes.Data;
if (options.ShowHelp)
{
Console.WriteLine("Listado de Parámetros válidos para la aplicación");
Console.WriteLine(new ParseArgs().GetHelpText <Arguments>());
return;
}
var config = Newtonsoft.Json.JsonConvert.DeserializeObject <Application>(System.IO.File.ReadAllText("SIR.Sync.Config.json"));
if (options.ProcesarSync)
{
var procesador = new BLL.ProcesadorSync(log, config);
procesador.ProcesarNotificaciones(options.FechaDesde, options.FechaHasta);
procesador.ProcesarAnulaciones(options.FechaDesde, options.FechaHasta);
procesador.ProcesarVencimientos();
procesador.ProcesarNotificacionesPE();
}
if (options.ProcesarRendicion)
{
var procesador = new BLL.ProcesadorRendiciones(log, config);
procesador.ProcesarRendicionDAI(options.FechaRendicion, options.DiasRendicion);
}
}
catch (Exception ex)
{
log.Error(ex);
}
finally
{
log.Info("== Fin de Procesamiento de SIR.Sync ==");
}
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
var pos = scanner.Position;
int ch = scanner.ReadChar();
if (ch != -1)
{
if (ch == '\n')
{
return(1);
}
if (ch == '\r')
{
ch = scanner.ReadChar();
if (ch == -1)
{
return(1);
}
if (ch == '\n')
{
return(2);
}
scanner.Position = pos + 1;
return(1);
}
}
scanner.Position = pos;
return(-1);
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
var length = 0;
var pos = scanner.Position;
var ch = scanner.ReadChar();
for (int i = 0; i < _items.Count; i++)
{
var item = _items[i];
var count = 0;
while (ch != -1 && item.Test((char)ch))
{
length++;
count++;
ch = scanner.ReadChar();
if (count >= item.Maximum)
{
break;
}
}
if (count < item.Minimum)
{
scanner.Position = pos;
return(-1);
}
}
scanner.Position = pos + length;
return(length);
}
void Say(ITriggerMsg e)
{
var rest = e.GetArg(out string channel);
string message = null;
// say [channel] <message>
// Send message to specified channel.
if (channel.StartsWith("#", StringComparison.Ordinal))
{
message = rest.ToJoined();
}
// say <message>
// Send message to current channel.
if (!message.HasValue())
{
channel = e.Channel;
message = e.MessageWithoutTrigger();
}
if (ParseArgs.Success(channel, message) && Say(channel, message))
{
string origin = string.Empty;
if (e.Channel != null)
{
origin = '/' + e.Channel;
}
log.Message("Say: {0}{1} -> {2}", e.Nick, origin, channel);
}
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
var pos = scanner.Position;
int match = -1;
if (Start != null)
{
match = Start.Parse(args);
}
if (match < 0)
{
if (Line == null)
{
return(-1);
}
match = Line.Parse(args);
if (match < 0)
{
return(-1);
}
for (;;)
{
match = eol.Parse(args);
if (match >= 0)
{
break;
}
if (scanner.Advance(1) < 0)
{
break;
}
}
if (match < 0)
{
return(-1);
}
scanner.Advance(-match);
return(scanner.Position - pos + 1);
}
for (;;)
{
match = End.Parse(args);
if (match >= 0)
{
break;
}
if (scanner.Advance(1) < 0)
{
break;
}
}
if (match >= 0)
{
return(scanner.Position - pos + 1);
}
return(-1);
}
protected override int InnerParse(ParseArgs args)
{
if (TrueValues != null)
{
for (int i = 0; i < TrueValues.Length; i++)
{
var val = TrueValues[i];
if (args.Scanner.ReadString(val, caseSensitive))
{
return(val.Length);
}
}
}
if (FalseValues != null)
{
for (int i = 0; i < FalseValues.Length; i++)
{
var val = FalseValues[i];
if (args.Scanner.ReadString(val, caseSensitive))
{
return(val.Length);
}
}
}
return(-1);
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
var length = 0;
var pos = scanner.Position;
var ch = scanner.ReadChar();
for (int i = 0; i < _items.Count; i++)
{
var item = _items[i];
var count = 0;
while (ch != -1 && item.Test((char)ch))
{
length++;
count++;
ch = scanner.ReadChar();
if (count >= item.Maximum)
break;
}
if (count < item.Minimum)
{
scanner.Position = pos;
return -1;
}
}
scanner.Position = pos + length;
return length;
}
static void Main(string[] args)
{
var log = new Logger("SIR.BcoCiudad", new LoggerConfig()
{
Console = new LoggerConfig.ConsoleConfig()
{
ShowInConsole = true
}
});
try
{
log.Info("== Inicio de Procesamiento de SIR.BcoCiudad ==");
log.Info($"Version: {System.Reflection.Assembly.GetExecutingAssembly().GetName().Version}");
log.Info($"Command: {AppDomain.CurrentDomain.FriendlyName} {string.Join(' ', args)}");
var optionsRes = new ParseArgs().Parse <Arguments>(args);
if (optionsRes.ExistsErrorMessages)
{
log.Log(optionsRes);
Console.ReadLine();
return;
}
var options = optionsRes.Data;
if (options.ShowHelp)
{
Console.WriteLine("Listado de Parámetros válidos para la aplicación");
Console.WriteLine(new ParseArgs().GetHelpText <Arguments>());
return;
}
var config = Newtonsoft.Json.JsonConvert.DeserializeObject <Application>(System.IO.File.ReadAllText("SIR.BcoCiudad.Config.json"));
var processor = Factory.GetBcoCiudadService(log, config);
if (options.ProcesarArchivo)
{
processor.ProcesarArchivos(options.Reprocesar);
}
if (options.Exportacion)
{
processor.ExportarBUI();
}
if (options.Notificaciones)
{
Factory.GetNotificacionService(log, config).ProcesarNotificaciones();
}
}
catch (Exception ex)
{
log.Error(ex);
}
finally
{
log.Info("== Fin de Procesamiento de SIR.BcoCiudad ==");
}
}
public void ShouldParseArgs()
{
ParseArgs pa = new ParseArgs(new string[] { "from", "to" });
pa.IsValid.Should().BeTrue();
pa.Replace.Should().Be("from");
pa.With.Should().Be("to");
}
protected override int InnerParse(ParseArgs args)
{
if (groupParser != null)
{
return(groupParser.Parse(args));
}
return(-1);
}
protected override int InnerParse(ParseArgs args)
{
if (Inner != null)
{
return(Inner.Parse(args));
}
return(0);
}
ValidateExampleParametersElseShowHelpTextAndExit(string[] args)
{
ShowHelpTextAndExitImmediatelyIf(args.Length == 0);
ShowHelpTextAndExitImmediatelyIf(HelpOptions.Contains(args[0].TrimStart('/').TrimStart('-')));
var(someFiles, someKeys) = ParseArgs.GetSomeFileNamesAndKeys(args);
ShowHelpTextAndExitImmediatelyIf(someFiles.Length == 0 && someKeys.Count == 0);
return(someFiles, someKeys);
}
protected override int InnerParse(ParseArgs args)
{
((MarkdownGrammar)args.Grammar).IndentLevel++;
var match = base.InnerParse(args);
((MarkdownGrammar)args.Grammar).IndentLevel--;
return(match);
}
public void Timer(ITriggerMsg e)
{
var timers = ircTimers.GetTimers(e.Nick);
var rest = e.GetArg(out string command, toLower: true);
// timer
if (!command.HasValue())
{
EmitDescriptions(timers.Descriptions(), e);
return;
}
// timer <delta> [index]
// Delta is +N or -N
char deltaSign = command[0];
if (deltaSign == '+' || deltaSign == '-')
{
TimerChange(
ParseIdx(rest.GetArg(), 0),
ParseTs(command),
e, timers
);
}
// timer stop [index]
else if (command == "stop")
{
TimerStop(
ParseIdx(rest.GetArg(), -1),
e, timers
);
}
// timer change <index> <delta>
else if (command == "change")
{
var args = rest.GetArgs(2);
if (ParseArgs.Success(args))
{
TimerChange(
ParseIdx(args[0], -1),
ParseTs(args[1]),
e, timers
);
}
}
// timer <duration> [message]
else
{
TimerStart(
ParseTs(command),
rest.ToJoined(JoinedOptions.TrimExterior),
e, timers
);
}
}
public void ParseArgsForMerge(params string[] args)
{
var(command, files, mergefields) = ParseArgs.FromStringArray(args);
command.ShouldBe(Program.Command.Merge);
files[0].Item1.Name.ShouldBe(args[0]);
files[0].Item2.Name.ShouldBe(args[1]);
mergefields["a"].ShouldNotBeNull().ShouldBe("b");
mergefields["aa"].ShouldNotBeNull().ShouldBe("bb");
}
public void SemiSimpleQuote_Test()
{
var input = "\"test value \"aaaaaa\" dog\"";
var expectedOutput = "test value \"aaaaaa\" dog";
var parsed = ParseArgs.Parse(input);
Assert.AreEqual(1, parsed.Count);
Assert.AreEqual(expectedOutput, parsed[0]);
}
protected override int InnerParse(ParseArgs args)
{
var pos = args.Scanner.Position;
var match = Except.Parse(args);
if (match < 0)
return base.InnerParse(args);
args.Scanner.Position = pos;
return -1;
}
protected override int InnerParse(ParseArgs args)
{
if (inBold)
return -1;
inBold = true;
var match = base.InnerParse(args);
inBold = false;
return match;
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
int count = 0;
var pos = scanner.Position;
int length = 0;
while (count < Maximum)
{
int curPos = scanner.Position;
int stopMatch;
if (skipMatches)
{
args.Push();
stopMatch = Inner.Parse(args);
args.PopFailed();
}
else
{
stopMatch = Inner.Parse(args);
}
if (stopMatch >= 0)
{
if (Capture)
{
length += stopMatch;
}
else if (!Skip)
{
scanner.Position = curPos;
}
break;
}
var ofs = scanner.Advance(1);
if (ofs >= 0)
{
length++;
count++;
}
else
{
scanner.Position = curPos;
break;
}
}
if (count < Minimum)
{
scanner.Position = pos;
return(-1);
}
return(length);
}
protected override int InnerParse(ParseArgs args)
{
object tagsObject;
if (!args.Properties.TryGetValue(tagKey, out tagsObject))
{
args.Properties[tagKey] = tagsObject = new HashSet <string>();
}
var tags = (HashSet <string>)tagsObject;
var pos = args.Scanner.Position;
if (AllowWithDifferentPosition)
{
if (!string.IsNullOrEmpty(ExcludeTag) && tags.Contains(ExcludeTag + pos))
{
return(-1);
}
if (!string.IsNullOrEmpty(IncludeTag) && !tags.Contains(IncludeTag + pos))
{
return(-1);
}
if (!string.IsNullOrEmpty(AddTag))
{
tags.Add(AddTag + pos);
var ret = base.InnerParse(args);
tags.Remove(AddTag);
return(ret);
}
}
else
{
if (!string.IsNullOrEmpty(ExcludeTag) && tags.Contains(ExcludeTag))
{
return(-1);
}
if (!string.IsNullOrEmpty(IncludeTag) && !tags.Contains(IncludeTag))
{
return(-1);
}
if (!string.IsNullOrEmpty(AddTag))
{
var added = tags.Add(AddTag);
var ret = base.InnerParse(args);
if (added)
{
tags.Remove(AddTag);
}
return(ret);
}
}
return(base.InnerParse(args));
}
protected override int InnerParse(ParseArgs args)
{
var pos = args.Scanner.Position;
var match = Inner.Parse(args);
if (match >= 0)
{
args.Scanner.Position = pos;
return Inverse ? -1 : 0;
}
return Inverse ? 0 : -1;
}
/// <summary>
/// Parses the arguments into the supplied instance.
/// </summary>
/// <param name="source"></param>
/// <param name="input"></param>
/// <returns></returns>
public ISettingParserResult Parse(TSource source, ParseArgs input)
{
return(Parse(input, (setting, value) =>
{
var result = setting.TrySetValue(source, value);
if (result.IsSuccess)
{
SetSettings.GetValue(source, x => new HashSet <IStaticSetting <TSource> >()).Add(setting);
}
return result;
}));
}
protected override int InnerParse(ParseArgs args)
{
var pos = args.Scanner.Position;
var length = 0;
var count = Items.Count;
if (separator != null)
{
var parser = Items[0];
var childMatch = parser.Parse(args);
if (childMatch < 0)
{
return(childMatch);
}
length += childMatch;
for (int i = 1; i < count; i++)
{
var sepMatch = separator.Parse(args);
if (sepMatch >= 0)
{
parser = Items[i];
childMatch = parser.Parse(args);
if (childMatch > 0)
{
length += childMatch + sepMatch;
continue;
}
else if (childMatch == 0)
{
continue;
}
}
// failed
args.Scanner.Position = pos;
return(-1);
}
return(length);
}
for (int i = 0; i < count; i++)
{
var parser = Items[i];
var childMatch = parser.Parse(args);
if (childMatch >= 0)
{
length += childMatch;
continue;
}
args.Scanner.Position = pos;
return(-1);
}
return(length);
}
public void ParseArgsForShowXml(params string[] args)
{
var(command, files, mergefields) = ParseArgs.FromStringArray(args);
command.ShouldBe(Program.Command.ShowXml);
files[0].Item1.Name.ShouldBe(args[1]);
files[0].Item2.Name.ShouldBe(args[1]);
files[1].Item1.Name.ShouldBe(args[2]);
files[1].Item2.Name.ShouldBe(args[2]);
files[2].Item1.Name.ShouldBe(args[3]);
files[2].Item2.Name.ShouldBe(args[3]);
files.Length.ShouldBe(args.Length - 1);
}
protected override int InnerParse(ParseArgs args)
{
var pos = args.Scanner.Position;
var match = Except.Parse(args);
if (match < 0)
{
return(base.InnerParse(args));
}
args.Scanner.Position = pos;
return(-1);
}
protected override int InnerParse(ParseArgs args)
{
if (inBold)
{
return(-1);
}
inBold = true;
var match = base.InnerParse(args);
inBold = false;
return(match);
}
protected override int InnerParse(ParseArgs args)
{
var pos = args.Scanner.Position;
var match = Inner.Parse(args);
if (match >= 0)
{
args.Scanner.Position = pos;
return(Inverse ? -1 : 0);
}
return(Inverse ? 0 : -1);
}
/// <summary>
/// Parses the arguments into the parent.
/// </summary>
/// <param name="input"></param>
/// <returns>The results of this parsing.</returns>
public ISettingParserResult Parse(ParseArgs input)
{
return(Parse(input, (setting, value) =>
{
var result = setting.TrySetValue(value);
if (result.IsSuccess)
{
SetSettings.Add(setting);
}
return result;
}));
}
protected override int InnerParse(ParseArgs args)
{
var count = Items.Count;
if (HasNamedChildren)
{
args.Push();
for (int i = 0; i < count; i++)
{
var parser = Items[i];
if (parser != null)
{
var match = parser.Parse(args);
if (match < 0)
{
args.ClearMatches();
}
else
{
args.PopSuccess();
return(match);
}
}
else
{
args.PopFailed();
return(0);
}
}
args.PopFailed();
}
else
{
for (int i = 0; i < count; i++)
{
var parser = Items[i];
if (parser != null)
{
var match = parser.Parse(args);
if (match >= 0)
{
return(match);
}
}
else
{
return(0);
}
}
}
return(-1);
}
protected override int InnerParse(ParseArgs args)
{
var pos = args.Scanner.Position;
var length = 0;
var count = Items.Count;
if (separator != null)
{
var parser = Items[0];
var childMatch = parser.Parse(args);
if (childMatch < 0)
{
return childMatch;
}
length += childMatch;
for (int i = 1; i < count; i++)
{
var sepMatch = separator.Parse(args);
if (sepMatch >= 0)
{
parser = Items[i];
childMatch = parser.Parse(args);
if (childMatch > 0)
{
length += childMatch + sepMatch;
continue;
}
else if (childMatch == 0)
{
continue;
}
}
// failed
args.Scanner.Position = pos;
return -1;
}
return length;
}
for (int i = 0; i < count; i++)
{
var parser = Items[i];
var childMatch = parser.Parse(args);
if (childMatch >= 0)
{
length += childMatch;
continue;
}
args.Scanner.Position = pos;
return -1;
}
return length;
}
protected override int InnerParse(ParseArgs args)
{
parserLookup = new Dictionary <string, Parser>(StringComparer.OrdinalIgnoreCase);
if (DefineCommonNonTerminals)
{
parserLookup["letter or digit"] = Terminals.LetterOrDigit;
parserLookup["letter"] = Terminals.Letter;
parserLookup["decimal digit"] = Terminals.Digit;
parserLookup["character"] = Terminals.AnyChar;
}
return(base.InnerParse(args));
}
protected override int InnerParse(ParseArgs args)
{
object tagsObject;
if (!args.Properties.TryGetValue(tagKey, out tagsObject))
{
args.Properties[tagKey] = tagsObject = new HashSet<string>();
}
var tags = (HashSet<string>)tagsObject;
var pos = args.Scanner.Position;
if (AllowWithDifferentPosition)
{
if (!string.IsNullOrEmpty(ExcludeTag) && tags.Contains(ExcludeTag + pos))
{
return -1;
}
if (!string.IsNullOrEmpty(IncludeTag) && !tags.Contains(IncludeTag + pos))
{
return -1;
}
if (!string.IsNullOrEmpty(AddTag))
{
tags.Add(AddTag + pos);
var ret = base.InnerParse(args);
tags.Remove(AddTag);
return ret;
}
}
else
{
if (!string.IsNullOrEmpty(ExcludeTag) && tags.Contains(ExcludeTag))
{
return -1;
}
if (!string.IsNullOrEmpty(IncludeTag) && !tags.Contains(IncludeTag))
{
return -1;
}
if (!string.IsNullOrEmpty(AddTag))
{
var added = tags.Add(AddTag);
var ret = base.InnerParse(args);
if (added)
tags.Remove(AddTag);
return ret;
}
}
return base.InnerParse(args);
}
protected override int InnerParse(ParseArgs args)
{
int codePoint;
if (!args.Scanner.IsEof && TryGetCodePoint(args.Scanner, out codePoint))
{
if (Test(codePoint) != Inverse)
{
return 2;
}
}
return -1;
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
int ch = scanner.ReadChar();
if (ch != -1)
{
if (Test((char)ch) != Inverse)
{
return 1;
}
scanner.Position--;
}
return -1;
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
var pos = scanner.Position;
int match = -1;
if (Start != null)
{
match = Start.Parse(args);
}
if (match < 0)
{
if (Line == null)
return -1;
match = Line.Parse(args);
if (match < 0)
return -1;
for (;;)
{
match = eol.Parse(args);
if (match >= 0)
break;
if (scanner.Advance(1) < 0)
break;
}
if (match < 0)
return -1;
scanner.Advance(-match);
return scanner.Position - pos + 1;
}
for (;;)
{
match = End.Parse(args);
if (match >= 0)
break;
if (scanner.Advance(1) < 0)
break;
}
if (match >= 0)
return scanner.Position - pos + 1;
return -1;
}
protected override int InnerParse(ParseArgs args)
{
if (TrueValues != null)
{
for (int i = 0; i < TrueValues.Length; i++)
{
var val = TrueValues[i];
if (args.Scanner.ReadString(val, caseSensitive))
return val.Length;
}
}
if (FalseValues != null)
{
for (int i = 0; i < FalseValues.Length; i++)
{
var val = FalseValues[i];
if (args.Scanner.ReadString(val, caseSensitive))
return val.Length;
}
}
return -1;
}
protected override int InnerParse(ParseArgs args)
{
if (!HasNamedChildren)
{
var match = Inner.Parse(args);
return match < 0 ? 0 : match;
}
else
{
args.Push();
var match = Inner.Parse(args);
if (match >= 0)
{
args.PopSuccess();
return match;
}
args.PopFailed();
return 0;
}
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
var pos = scanner.Position;
var length = Surrounding.Parse(args);
if (length >= 0)
{
var str = scanner.Substring(pos, length);
while (!scanner.ReadString(str, true))
{
if (scanner.Advance(1) < 0)
{
scanner.Position = pos;
return -1;
}
length++;
}
length += str.Length;
return length;
}
return -1;
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
var pos = scanner.Position;
int ch = scanner.ReadChar();
if (ch != -1)
{
if (ch == '\n')
return 1;
if (ch == '\r')
{
ch = scanner.ReadChar();
if (ch == -1)
return 1;
if (ch == '\n')
return 2;
scanner.Position = pos + 1;
return 1;
}
}
scanner.Position = pos;
return -1;
}
protected override int InnerParse(ParseArgs args)
{
return base.InnerParse(args);
}
protected override int InnerParse(ParseArgs args)
{
var pos = args.Scanner.Position;
return pos <= 0 ? 0 : -1;
}
protected override int InnerParse(ParseArgs args)
{
var pos = args.Scanner.Advance(1);
return pos < 0 ? -1 : 1;
}
protected override int InnerParse(ParseArgs args)
{
parserLookup = new Dictionary<string, Parser>(StringComparer.InvariantCultureIgnoreCase);
if (DefineCommonNonTerminals)
{
parserLookup["letter or digit"] = Terminals.LetterOrDigit;
parserLookup["letter"] = Terminals.Letter;
parserLookup["decimal digit"] = Terminals.Digit;
parserLookup["character"] = Terminals.AnyChar;
}
return base.InnerParse(args);
}
protected override int InnerParse(ParseArgs args)
{
definition = new GoldDefinition();
return base.InnerParse(args);
}
protected override int InnerParse(ParseArgs args)
{
parserLookup = new Dictionary<string, Parser>();
return base.InnerParse(args);
}
protected override int InnerParse(ParseArgs args)
{
return 0;
}
protected override int InnerParse(ParseArgs args)
{
int length = 1;
var scanner = args.Scanner;
var pos = scanner.Position;
int ch;
if (AllowQuoted)
{
ch = scanner.ReadChar();
if (ch == -1)
return -1;
var quoteIndex = quoteCharString.IndexOf((char)ch);
if (quoteIndex >= 0)
{
char quote = endQuoteCharString[quoteIndex];
bool isEscape = false;
ch = scanner.ReadChar();
while (ch != -1)
{
length++;
if (AllowEscapeCharacters && ch == '\\')
isEscape = true;
else if (!isEscape)
{
if (ch == quote)
{
if (!AllowDoubleQuote || scanner.Peek() != quote)
return length;
isEscape = true;
}
}
else
isEscape = false;
ch = scanner.ReadChar();
}
}
length = 0;
scanner.Position = pos;
}
if (AllowNonQuoted && NonQuotedLetter != null)
{
var m = NonQuotedLetter.Parse(args);
while (m > 0)
{
length += m;
m = NonQuotedLetter.Parse(args);
}
if (length > 0)
return length;
}
return -1;
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
var pos = scanner.Position;
int length = 0;
int ch;
ch = scanner.ReadChar();
length++;
if (ch == '<')
{
ch = scanner.ReadChar();
length++;
if (ch == '!')
{
length = 7;
// read comment
if (scanner.ReadString("--", true))
{
while (!scanner.ReadString("-->", true))
{
if (scanner.ReadChar() == -1)
{
scanner.Position = pos;
return -1;
}
length++;
}
return length;
}
scanner.Position = pos;
return -1;
}
tagNameBuilder.Clear();
var first = true;
while (ch != -1 && char.IsLetter((char)ch))
{
if (first && !char.IsLetter((char)ch))
{
scanner.Position = pos;
return -1;
}
first = false;
tagNameBuilder.Append((char)ch);
ch = scanner.ReadChar();
length++;
}
if (ch == ' ' || ch == '>' || ch == '/')
{
var isVoid = voidTags.Contains(tagNameBuilder.ToString());
int prev = ch;
while (ch != '>' && ch != -1)
{
prev = ch;
if (ch == '\'' || ch == '"')
{
var quote = ch;
ch = scanner.ReadChar();
length++;
while (ch != quote && ch != -1)
{
if (ch == '\n')
{
scanner.Position = pos;
return -1;
}
ch = scanner.ReadChar();
length++;
}
}
ch = scanner.ReadChar();
length++;
}
if (ch != '>')
{
scanner.Position = pos;
return -1;
}
if (isVoid || prev == '/') // self closing, or a tag with no content
{
return length;
}
// now, read till the end tag
if (MatchContent && Name != null)
args.Push();
var start = pos + length;
var contentLength = 0;
tagNameBuilder.Insert(0, "</");
tagNameBuilder.Append(">");
var tagName = tagNameBuilder.ToString();
while (!scanner.ReadString(tagName, true))
{
ch = scanner.Peek();
if (ch == '<')
{
if (MatchContent && contentLength > 0)
{
args.AddMatch(this, start, contentLength, "content");
}
var inner = Parse(args);
if (inner < 0)
{
scanner.Position = pos;
return -1;
}
length += inner;
start = pos + length;
contentLength = 0;
continue;
}
if (scanner.Advance(1) >= 0)
{
length++;
contentLength++;
}
else
{
scanner.Position = pos;
return -1;
}
}
length += tagName.Length;
if (MatchContent)
{
if (contentLength > 0)
{
args.AddMatch(this, start, contentLength, "content");
}
if (Name != null)
args.PopMatch(this, pos, length);
}
return length;
}
}
scanner.Position = pos;
return -1;
}
protected override int InnerParse(ParseArgs args)
{
return !args.Scanner.IsEof ? -1 : 0;
}
protected override int InnerParse(ParseArgs args)
{
if (groupParser != null)
return groupParser.Parse(args);
return -1;
}
protected override int InnerParse(ParseArgs args)
{
var scanner = args.Scanner;
var len = 0;
int ch;
var pos = scanner.Position;
if (AllowSign)
{
ch = scanner.ReadChar();
if (ch == -1)
{
return -1;
}
if (ch == '-' || ch == '+')
{
len++;
ch = scanner.ReadChar();
}
}
else
ch = scanner.ReadChar();
bool foundNumber = false;
bool hasDecimal = false;
bool hasExponent = false;
do
{
if (char.IsDigit((char)ch))
{
foundNumber = true;
}
else if (AllowDecimal && !hasDecimal && ch == DecimalSeparator)
{
hasDecimal = true;
}
else if (hasExponent && (ch == '+' || ch == '-'))
{
}
else if (AllowExponent && !hasExponent && (ch == 'E' || ch == 'e'))
{
hasExponent = true;
hasDecimal = true; // no decimals after exponent
}
else if (!foundNumber)
{
scanner.Position = pos;
return -1;
}
else
break;
len++;
ch = scanner.ReadChar();
}
while (ch != -1);
scanner.Position = pos + len;
return len;
}
