private IToken processDelimiter(Delimiter d)
{
DelimiterProperties dp = d.DelimiterProperties;
char beginChar = dp.BeginChar == null ? '(' : dp.BeginChar.Val.ToString().Trim().ElementAt(0);
char endChar = dp.EndChar == null ? ')' : dp.EndChar.Val.ToString().Trim().ElementAt(0);
var delimiterElements = d.Elements <Base>();
if (delimiterElements.Count() > 1)
{
char separator = dp.SeparatorChar == null ? '|' : dp.SeparatorChar.Val.ToString().Trim().ElementAt(0);
DelimiterToken delimiterToken = new DelimiterToken(beginChar, endChar, separator);
foreach (var element in delimiterElements)
{
var processedElement = processElement(element);
delimiterToken.AddElement(processedElement);
}
return(delimiterToken);
}
else
{
var children = from child in delimiterElements.First() select processElement(child);
return(new ParenthesesToken(beginChar, endChar, new TokenList(children)));
}
}
public void DelimiterToken_Uniqueness()
{
var delimiterToken = new DelimiterToken
{
StartTag = "{{",
EndTag = "}}",
Indent = 0,
ContentStartPosition = 0,
ContentEndPosition = 6,
IsClosed = true,
TagStartPosition = 0,
TagEndPosition = 6
};
var delimiterToken2 = new DelimiterToken
{
StartTag = "{{",
EndTag = "}}",
Indent = 0,
ContentStartPosition = 0,
ContentEndPosition = 6,
IsClosed = true,
TagStartPosition = 0,
TagEndPosition = 6
};
Assert.False(delimiterToken.Equals(null));
Assert.Equal(delimiterToken, delimiterToken2);
Assert.Equal(delimiterToken.GetHashCode(), delimiterToken2.GetHashCode());
}
protected ArgumentListNode parseArgumentList(DelimiterToken argumentList)
{
if (argumentList.BeginChar != '(' || argumentList.EndChar != ')' || argumentList.Delimiter != ',')
{
throw new ParseException(argumentList.simpleRepresentation() +
" cannot be used as an argument list for a function call.");
}
ArgumentListNode argumentListNode = new ArgumentListNode();
foreach (TokenList argument in argumentList.Elements)
{
TokenListParser argumentParser = new TokenListParser(properties);
SyntaxNode argumentRootNode = argumentParser.parse(argument);
argumentListNode.addArgument(argumentRootNode);
}
return(argumentListNode);
}
/// <summary>
/// Tries to match delimiter tags from the current slice
/// </summary>
/// <param name="processor">The processor</param>
/// <param name="slice">The slice</param>
/// <returns>If the match was successful</returns>
public override bool Match(Processor processor, ref StringSlice slice)
{
var tagStart = slice.Start - processor.CurrentTags.StartTag.Length;
var index = slice.Start;
while (slice[index].IsWhitespace())
{
index++;
}
var match = slice[index];
if (match == openingTagDelimiter[0])
{
index++;
while (slice[index].IsWhitespace())
{
index++;
}
slice.Start = index;
var startIndex = slice.Start;
// Take Characters that aren't whitespace
while (!slice.CurrentChar.IsWhitespace())
{
slice.NextChar();
}
var startTag = slice.ToString(startIndex, slice.Start);
// Skip Whitespace any
while (slice.CurrentChar.IsWhitespace())
{
slice.NextChar();
}
var endTagStartIndex = slice.Start;
// Take characters until end delimiter;
var closingTag = closingTagDelimiter[0] + processor.CurrentTags.EndTag;
while (!slice.IsEmpty && !slice.Match(closingTag))
{
slice.NextChar();
}
var endTag = new StringSlice(slice.Text, endTagStartIndex, slice.Start - 1);
endTag.TrimEnd();
var contentEnd = endTag.End + 1;
var tag = new DelimiterToken
{
TagStartPosition = tagStart,
ContentStartPosition = startIndex,
ContentEndPosition = contentEnd,
TagEndPosition = slice.Start + closingTag.Length,
StartTag = startTag,
EndTag = endTag.ToString(),
IsClosed = true
};
processor.CurrentToken = tag;
processor.CurrentTags = new Classes.Tags(tag.StartTag, tag.EndTag);
slice.Start += closingTag.Length;
return(true);
}
return(false);
}
