/// <summary>
/// Tries to parse whitespace
/// </summary>
/// <returns>
/// Amount of newlines
/// </returns>
/// <param name='data'>
/// Data to parse,
/// </param>
/// <param name='offset'>
/// Offset in data
/// </param>
/// <param name='result'>
/// Nothing
/// </param>
internal override int ParseMethod(ParsingSession session, out object result)
{
Match oncomingWhitespace = whiteSpaceRegex.Match (
session.Data.Substring (session.Offset));
result = null;
if (!oncomingWhitespace.Success)
return -1;
if (oncomingWhitespace.Index != 0)
return -1;
string consecSpace = oncomingWhitespace.Value;
session.Offset += consecSpace.Length;
int lastBreak = 0;
for (int charI = 0; charI < consecSpace.Length; charI++) {
if (consecSpace [charI] == '\n') {
lastBreak = charI;
session.CurrentLine++;
}
}
session.CurrentColumn = consecSpace.Length - lastBreak;
result = oncomingWhitespace.Value;
return oncomingWhitespace.Length;
}
protected virtual int ParseListBody(ParsingSession session, ref List<object> target)
{
object parsed;
bool coupled = true;
while (coupled && (InnerParser.Run(session, out parsed) > 0)) {
target.Add (parsed);
coupled = false;
while (coupler.Run (session) > 0)
coupled = true;
}
int closerResult = closer.Run (session);
if (closerResult > 0) {
return target.Count + 1;
} else {
string trail, ahead;
trail = session.GetTrail();
ahead = session.GetAhead();
throw new ParsingException (session, closer, trail, ahead);
}
}
internal override int ParseMethod(ParsingSession session, out object result)
{
// "
if (session.Data[session.Offset] == '\"') {
if (session.Data[session.Offset + 1] != '\"') {
string entirity, quotedText, escapedText, text;
// "cheese"
entirity = session.Data.Substring(session.Offset);
Match quoteMatch = stringRegex.Match (entirity);
quotedText = quoteMatch.Value;
escapedText = quotedText.Remove(quotedText.Length - 1, 1).Remove(0, 1);
text = Regex.Unescape(escapedText);
session.Offset += quotedText.Length;
result = text;
return text.Length;
} else {
session.Offset += 2;
result = "";
return 1;
}
}
result = null;
return -1;
}
private static List <Block> Parse(AssemblyDef assembly, XmlContainerCodeElement container, ParsingSession session)
{
List <Block> blocks = new List <Block>();
ExceptionList exceptions = new ExceptionList();
PermissionList permissions = new PermissionList();
Paragraph inlineContainer = null;
if (session == null)
{
session = new ParsingSession();
}
for (int counter = 0; counter < container.Elements.Count;)
{
if (container.Elements[counter].IsInline)
{
inlineContainer = new Paragraph();
while (counter < container.Elements.Count && container.Elements[counter].IsInline)
{
inlineContainer.Inlines.Add(Parser.ParseInline(assembly, container.Elements[counter], session));
counter++;
}
blocks.Add(inlineContainer);
inlineContainer = null;
}
else
{
Block block = Parser.ParseBlock(assembly, container.Elements[counter], session);
if (block != null)
{
if (block is ExceptionEntry)
{
exceptions.Add(block as ExceptionEntry);
}
else if (block is PermissionEntry)
{
permissions.Add(block as PermissionEntry);
}
else
{
blocks.Add(block);
}
}
counter++;
}
}
if (exceptions.ExceptionCount > 0)
{
blocks.Add(exceptions);
}
if (permissions.Count > 0)
{
blocks.Add(permissions);
}
return(blocks);
}
internal override int ParseMethod(ParsingSession session, out object result)
{
for (int iParser = 0; iParser < AcceptedParsers.Count; iParser++)
if (AcceptedParsers [iParser].Run (session, out result) > 0)
return iParser + 1;
result = null;
return -1;
}
public void TestHandover()
{
var session = new ParsingSession ("cherry cake", new WhitespaceParser ());
object result;
Assert.Less (SUT.Run (session, out result), 0);
Assert.Greater ((new SequenceParser ("cherry")).Run (session, out result), 0);
Assert.AreEqual ("cherry", result);
Assert.Greater (SUT.Run (session, out result), 0);
Assert.AreEqual ("cake", result);
}
public void TestSequentialHandover()
{
var session = new ParsingSession ("koekjes eten kaas", new WhitespaceParser ());
object result;
Assert.AreEqual (2, SUT.Run (session, out result));
Assert.AreEqual ("koekjes", result);
Assert.AreEqual (3, SUT.Run (session, out result));
Assert.AreEqual ("eten", result);
Assert.AreEqual (1, SUT.Run (session, out result));
Assert.AreEqual ("kaas", result);
}
internal override int ParseMethod(ParsingSession session, out object result)
{
List<Tuple<string, object>> tuples;
if (Parse<Tuple<string, object>>.TryListUsing(this.BlockParser, session, out tuples)) {
result = Settings.FromTuples (tuples);
return 1;
} else {
result = null;
return -1;
}
}
internal override int ParseMethod(ParsingSession session, out object result)
{
if (session.Data.Length > session.Offset) {
if (session.Data [session.Offset] == TargetCharacter) {
session.Offset++;
result = TargetCharacter;
return 1;
}
}
result = null;
return -1;
}
internal override int ParseMethod(ParsingSession session, out object result)
{
if (base.ParseMethod (session, out result) > 0) {
var target = (IEnumerable<object>)result;
StringBuilder mergedString = new StringBuilder ();
foreach (object component in target) {
mergedString.Append (component);
}
result = mergedString.ToString ();
return mergedString.Length + 1;
} else {
return -1;
}
}
private object GetParsedValue(string serialValue)
{
ParsingSession session = new ParsingSession(serialValue, new WhitespaceParser());
object value;
if (valueParser.Run(session, out value) < 0)
{
return(serialValue);
}
else
{
return(value);
}
}
internal override int ParseMethod(ParsingSession session, out object result)
{
int successValue = -1;
if (opener.Run (session) > 0) {
List<object> target = new List<object> ();
successValue = ParseListBody (session, ref target);
result = target;
} else {
result = null;
}
return successValue;
}
internal override int ParseMethod(ParsingSession session, out object result)
{
List<Settings> predefinitions = new List<Settings> ();
object referenceCandidate;
while (ReferenceParser.ParseMethod (session, out referenceCandidate) > 0) {
if (referenceCandidate is Settings) {
predefinitions.Add ((Settings)referenceCandidate);
} else {
throw new ParsingException (session, ReferenceParser, session.Ahead, session.Trail);
}
}
result = predefinitions;
return predefinitions.Count + 1;
}
internal override int ParseMethod(ParsingSession session, out object result)
{
result = "";
var bookmark = session.Offset;
foreach (Parser parserInSequence in parserSequence) {
if (parserInSequence.Run (session) < 0) {
session.Offset = bookmark;
return -1;
}
}
result = this.Sequence;
return Sequence.Length;
}
/// <summary>
/// Tries to parse an Identifier
/// </summary>
/// <returns>
/// The parsed result
/// </returns>
internal override int ParseMethod(ParsingSession session, out object result)
{
StringBuilder resultBuilder = new StringBuilder ();
result = "";
// d
if (IsAlpha (session.Data [session.Offset]))
resultBuilder.Append (session.Data [session.Offset++]);
else
return -1;
while ((session.Data.Length > session.Offset) && Validator(session.Data[session.Offset])) {
resultBuilder.Append (session.Data [session.Offset++]);
}
result = resultBuilder.ToString();
return resultBuilder.Length;
}
internal override int ParseMethod(ParsingSession session, out object result)
{
if ((session.Data [session.Offset++] == 'f') && (session.Data[session.Offset] == '"')) {
object fileNameObj;
string fileName, fullPath;
base.ParseMethod (session, out fileNameObj);
fileName = (string)fileNameObj;
fullPath = string.Format("{0}{1}{2}",
session.WorkingDirectory,
Path.DirectorySeparatorChar,
fileName);
result = fullPath;
return fullPath.Length;
} else {
session.Offset--;
result = "";
return -1;
}
}
internal override int ParseMethod(ParsingSession session, out object result)
{
int succescode = 0;
object unparsedIdentifier, dummy;
CharacterParser leadingDot = new CharacterParser ('.');
List<string> contextString = null;
result = null;
int bookmark = session.Offset;
while (leadingDot.ParseMethod(session, out dummy) > 0) {
if (contextString == null) {
contextString = new List<string>(session.Context.ToArray());
contextString.Reverse();
}
contextString.RemoveAt(contextString.Count - 1);
succescode--;
}
string identifier = (contextString == null ? "" : string.Join(".", contextString.ToArray()) + ".");
if (base.ParseMethod (session, out unparsedIdentifier) > 0) {
identifier += unparsedIdentifier as String;
if (session.References.Has (identifier)) {
result = session.References [identifier];
succescode = 1;
} else {
session.Offset = bookmark;
if (succescode < 0)
throw new InvalidReferenceException (identifier);
else
succescode = -1;
}
}
return succescode;
}
internal override int ParseMethod(ParsingSession session, out object result)
{
if (Parse<char>.Try (ExtensionMarker, session)) {
var chainDefinition = Parse<Settings>.Using (ReferenceParser, session);
if (chainDefinition == null) {
session.DeepenContext (Substitution);
chainDefinition = Parse<Settings>.Using (InnerParser, session);
session.SurfaceContext (Substitution);
}
if (chainDefinition == null) {
throw new ParsingException (session, InnerParser, session.Ahead, session.Trail);
}
result = chainDefinition;
return 1;
} else {
result = null;
return -1;
}
}
private static Inline ParseInline(AssemblyDef assembly, XmlCodeElement element, ParsingSession session)
{
TraceHelper.WriteLine("parsing-inline: e({0})", element.Element.ToString());
switch (element.Element)
{
// Invalid elements
case XmlCodeElements.Code:
case XmlCodeElements.Example:
case XmlCodeElements.Exception:
case XmlCodeElements.List:
case XmlCodeElements.ListHeader:
case XmlCodeElements.ListItem:
case XmlCodeElements.Include:
case XmlCodeElements.Para:
case XmlCodeElements.Param:
case XmlCodeElements.Permission:
case XmlCodeElements.Remarks:
case XmlCodeElements.Returns:
case XmlCodeElements.Summary:
case XmlCodeElements.TypeParam:
case XmlCodeElements.Value:
InvalidOperationException ex = new InvalidOperationException(
"Found a block level element where an inline element was expected."
);
ex.Data["element"] = element;
throw ex;
case XmlCodeElements.B:
return(new Bold(new Run(element.Text)));
case XmlCodeElements.C:
return(new C(element.Text));
case XmlCodeElements.I:
return(new Italic(new Run(element.Text)));
case XmlCodeElements.ParamRef:
return(new Italic(new Run(element.Text)));
case XmlCodeElements.See:
SeeXmlCodeElement seeElement = element as SeeXmlCodeElement;
string displayName;
CrefEntryKey key;
if (Parser.ResolveMember(seeElement.Text, seeElement.Member, assembly, out key, out displayName))
{
return(new See(key, displayName));
}
else
{
return(new Run(displayName));
}
case XmlCodeElements.SeeAlso:
SeeAlsoXmlCodeElement seeAlsoElement = element as SeeAlsoXmlCodeElement;
// key and displayname defined in see
if (Parser.ResolveMember(seeAlsoElement.Text, seeAlsoElement.Member, assembly, out key, out displayName))
{
return(new SeeAlso(key, displayName));
}
else
{
return(new SeeAlso(displayName));
}
case XmlCodeElements.Text:
return(new Run(element.Text));
case XmlCodeElements.TypeParamRef:
return(new Italic(new Run(element.Text)));
}
throw new Exception("Unknown inline parsing error.");
}
private static Block ParseBlock(AssemblyDef assembly, XmlCodeElement element, ParsingSession session)
{
TraceHelper.WriteLine("parsing-block: e({0})", element.Element.ToString());
CrefEntryKey crefEntryKey;
Inline link;
string displayName;
switch (element.Element)
{
// Invalid inline elements
case XmlCodeElements.C:
case XmlCodeElements.ParamRef:
case XmlCodeElements.See:
case XmlCodeElements.SeeAlso:
case XmlCodeElements.Text:
case XmlCodeElements.TypeParamRef:
InvalidOperationException ex = new InvalidOperationException(
"Found an inline element where a block level element was expected."
);
ex.Data["element"] = element;
throw ex;
case XmlCodeElements.Include:
InvalidOperationException includeEx = new InvalidOperationException(
"Found an include comment element, the c# parser has failed."
);
includeEx.Data["element"] = element;
throw includeEx;
// End points
case XmlCodeElements.Code:
return(new Code(element.Text));
case XmlCodeElements.Exception:
ExceptionXmlCodeElement exceptionElement = element as ExceptionXmlCodeElement;
if (Parser.ResolveMember(exceptionElement.Text, exceptionElement.Member, assembly, out crefEntryKey, out displayName))
{
link = link = Parser.CreateHyperlink(crefEntryKey, exceptionElement.Member.TypeName);
}
else
{
if (string.IsNullOrEmpty(displayName))
{
link = new Run(exceptionElement.Member.TypeName);
}
else
{
link = new Run(displayName);
}
}
return(new ExceptionEntry(link, Parser.Parse(assembly, element as ExceptionXmlCodeElement)));
case XmlCodeElements.Example:
ExampleXmlCodeElement exampleElement = element as ExampleXmlCodeElement;
return(new Example(Parser.Parse(assembly, exampleElement)));
case XmlCodeElements.Para:
ParaXmlCodeElement paraElement = element as ParaXmlCodeElement;
return(new Para(Parser.Parse(assembly, paraElement)));
case XmlCodeElements.Permission:
PermissionXmlCodeElement permissionElement = element as PermissionXmlCodeElement;
if (Parser.ResolveMember(permissionElement.Text, permissionElement.Member, assembly, out crefEntryKey, out displayName))
{
link = link = Parser.CreateHyperlink(crefEntryKey, permissionElement.Member.TypeName);
}
else
{
if (string.IsNullOrEmpty(displayName))
{
link = new Run(permissionElement.Member.TypeName);
}
else
{
link = new Run(displayName);
}
}
return(new PermissionEntry(link, Parser.Parse(assembly, element as PermissionXmlCodeElement)));
case XmlCodeElements.Remarks:
return(new Remarks(Parser.Parse(assembly, element as RemarksXmlCodeElement)));
case XmlCodeElements.Returns:
return(new Returns(Parser.Parse(assembly, element as ReturnsXmlCodeElement)));
case XmlCodeElements.Summary:
return(new Summary(Parser.Parse(assembly, element as SummaryXmlCodeElement)));
case XmlCodeElements.Value:
return(new Value(Parser.Parse(assembly, element as ValueXmlCodeElement)));
case XmlCodeElements.Param:
return(new Param(((ParamXmlCodeElement)element).Name, Parser.Parse(assembly, element as ParamXmlCodeElement)));
case XmlCodeElements.TypeParam:
TypeParamXmlCodeElement typeParamElement = (TypeParamXmlCodeElement)element;
return(new TypeParamEntry(typeParamElement.Name, typeParamElement.Text));
case XmlCodeElements.List:
ListXmlCodeElement listElement = (ListXmlCodeElement)element;
return(Parser.ParseList(assembly, listElement));
case XmlCodeElements.Term:
case XmlCodeElements.Description:
Section termOrDescription = new Section();
termOrDescription.Blocks.AddRange(Parser.Parse(assembly, (XmlContainerCodeElement)element));
return(termOrDescription);
break;
}
throw new Exception("WTF, block parsing error");
}
