private static Parser Alternative(Match m, string innerName, Func <Match, Parser> inner)
{
Parser[] parsers = m.Find(innerName).Select(inner).ToArray();
if (parsers.Length > 1)
{
return(new AlternativeParser(parsers));
}
return(parsers.FirstOrDefault());
}
private Parser DefinitionList(Match match, bool isTerminal)
{
Match[] definitions = match.Find("single definition").ToArray();
if (definitions.Length == 1)
{
return(SingleDefinition(definitions[0], isTerminal));
}
else
{
return(new AlternativeParser(definitions.Select(r => SingleDefinition(r, isTerminal))));
}
}
Parser DefinitionList(Match match, bool isTerminal)
{
var definitions = match.Find("single definition").ToList();
if (definitions.Count == 1)
{
return(SingleDefinition(definitions[0], isTerminal));
}
if (definitions.Count == 0)
{
return(null);
}
return(new AlternativeParser(definitions.Select(r => SingleDefinition(r, isTerminal))));
}
public static IEnumerable <Match> FindUniq(this Match ast, string id, bool deep = false)
{
var offset_to_match = new SortedDictionary <int, Match> ();
var matches = ast.Find(id, deep);
foreach (var m in matches)
{
int offset = m.Index;
if (offset_to_match.ContainsKey(offset) == false)
{
offset_to_match.Add(offset, m);
}
}
return(offset_to_match.Values);
}
// GET: Home
public async Task <ActionResult> Index(string To, string From, string Body)
{
var response = new TwilioResponse();
var match = new Match();
var opportunityResult = await match.Find(Body);
var builder = new StringBuilder();
foreach (var opportunity in opportunityResult.Opportunities)
{
builder.Append($"{opportunity.Title}\r\n");
}
response.Message(builder.ToString());
return(TwiML(response));
}
private Parser SingleDefinition(Match match, bool isTerminal)
{
Match[] terms = match.Find("term").ToArray();
if (terms.Length == 1)
{
return(Term(terms[0], isTerminal));
}
else
{
var sequence = new SequenceParser(terms.Select(r => Term(r, isTerminal)));
if (!isTerminal)
{
sequence.Separator = separator;
}
return(sequence);
}
}
public void Transform(Match match, MarkdownReplacementArgs args)
{
var reference = new ReferenceSection();
foreach (var refMatch in match.Find(reference.Name))
{
reference.AddReference(refMatch, args);
}
var count = match.Matches.Count;
for (int i = 0; i < count; i++)
{
var section = match.Matches[i];
var replacement = replacements.GetReplacement(section.Name);
replacement.Transform(section, args);
}
}
private Parser Sequence(Match m, string innerName, Func <Match, Parser> inner, bool addWhitespace = false)
{
Parser[] parsers = m.Find(innerName).Select(inner).ToArray();
if (addWhitespace || parsers.Length > 1)
{
Parser sep = definition.Separator;
var seq = new SequenceParser(parsers)
{
Separator = sep
};
if (addWhitespace && sep != null)
{
seq.Items.Insert(0, sep);
seq.Items.Add(sep);
}
return(seq);
}
return(parsers.FirstOrDefault());
}
private Parser SetLiteralOrName(Match m, bool error = true)
{
Match literal = m.Name == "setLiteral" ? m : m["setLiteral"];
if (literal.Success)
{
return(Terminals.Set(literal.Find("ch").Select(r => r.Text.Length > 0 ? r.Text[0] : '\'').ToArray()));
}
Match name = m.Name == "setName" ? m["value"] : m["setName"]["value"];
if (name.Success)
{
Parser parser;
string nameText = name.Text;
if (definition.Sets.TryGetValue(nameText, out parser))
{
return(parser);
}
string[] chars = nameText.Split(new[] { ".." }, StringSplitOptions.RemoveEmptyEntries);
if (chars.Length == 2)
{
// range of characters
return(new CharRangeTerminal(Character(chars[0]), Character(chars[1])));
}
if (chars.Length == 1)
{
// single character
return(new SingleCharTerminal(Character(chars[0])));
}
}
if (error)
{
throw new FormatException("Literal or set name missing or invalid");
}
return(null);
}
Parser SingleDefinition(Match match, bool isTerminal)
{
var terms = match.Find("term").ToArray();
if (terms.Length == 1)
return Term(terms[0], isTerminal);
else
{
var sequence = new SequenceParser(terms.Select(r => Term(r, isTerminal)));
if (!isTerminal)
sequence.Separator = separator;
return sequence;
}
}
Parser DefinitionList(Match match, bool isTerminal)
{
var definitions = match.Find("single definition").ToList();
if (definitions.Count == 1)
return SingleDefinition(definitions[0], isTerminal);
if (definitions.Count == 0)
return null;
return new AlternativeParser(definitions.Select(r => SingleDefinition(r, isTerminal)));
}
public void Transform(Match match, MarkdownReplacementArgs args)
{
var reference = new ReferenceSection();
foreach (var refMatch in match.Find(reference.Name))
{
reference.AddReference(refMatch, args);
}
var count = match.Matches.Count;
for (int i = 0; i < count; i++)
{
var section = match.Matches[i];
var replacement = replacements.GetReplacement(section.Name);
replacement.Transform(section, args);
}
}
Parser DefinitionList(Match match, bool isTerminal)
{
var definitions = match.Find("single definition").ToArray();
if (definitions.Length == 1)
return SingleDefinition(definitions[0], isTerminal);
else
return new AlternativeParser(definitions.Select(r => SingleDefinition(r, isTerminal)));
}
Parser Sequence(Match m, string innerName, Func<Match, Parser> inner, bool addWhitespace = false)
{
var parsers = m.Find(innerName).Select(inner).ToArray();
if (addWhitespace || parsers.Length > 1)
{
var sep = definition.Separator;
var seq = new SequenceParser(parsers) { Separator = sep };
if (addWhitespace && sep != null)
{
seq.Items.Insert(0, sep);
seq.Items.Add(sep);
}
return seq;
}
return parsers.FirstOrDefault();
}
static Parser Alternative(Match m, string innerName, Func<Match, Parser> inner)
{
var parsers = m.Find(innerName).Select(inner).ToArray();
if (parsers.Length > 1)
return new AlternativeParser(parsers);
return parsers.FirstOrDefault();
}
