// Returns list of 2-element arrays, element 0 is field name (or null), element 1 is term/phrase
public List<NuGetSearchTerm> Parse(string searchTerm)
{
var terms = new List<NuGetSearchTerm>();
_tokenizer = new Tokenizer(searchTerm);
while (_tokenizer.Peek() != TokenType.Eof)
{
var term = new NuGetSearchTerm();
if (_tokenizer.Peek() == TokenType.Field)
{
if (ParseField(term))
{
terms.Add(term);
}
}
else
{
if (ParseTermOrPhrase(term))
{
terms.Add(term);
}
}
}
return terms;
}
private object NextValue(Tokenizer tokenizer)
{
if (tokenizer.Peek() == tokenizer.SeparatorToken || tokenizer.Peek() == tokenizer.NewlineToken)
{
return(string.Empty);
}
Token current = tokenizer.Next();
if (current.type == TokenTypeEnum.Separator)
{
return(double.NaN);
}
else if (current.type == TokenTypeEnum.String)
{
return(current.stringValue);
}
else if (current.type == TokenTypeEnum.Double)
{
return(current.doubleValue);
}
else if (current.type == TokenTypeEnum.DateTime)
{
return(current.dateTimeValue);
}
// found an unexpected token => throw error
Error("Unexpected token.", current.stringValue, tokenizer.CurrentLineNumber);
// this line is never executed because Error() throws an exception
throw new InvalidOperationException();
}
// Returns list of 2-element arrays, element 0 is field name (or null), element 1 is term/phrase
public List <NuGetSearchTerm> Parse(string searchTerm)
{
var terms = new List <NuGetSearchTerm>();
_tokenizer = new Tokenizer(searchTerm);
while (_tokenizer.Peek() != TokenType.Eof)
{
var term = new NuGetSearchTerm();
if (_tokenizer.Peek() == TokenType.Field)
{
if (ParseField(term))
{
terms.Add(term);
}
}
else
{
if (ParseTermOrPhrase(term))
{
terms.Add(term);
}
}
}
return(terms);
}
internal static LayoutRenderer[] CompileLayout(ConfigurationItemFactory configurationItemFactory, Tokenizer sr, bool isNested, out string text)
{
var result = new List<LayoutRenderer>();
var literalBuf = new StringBuilder();
int ch;
int p0 = sr.Position;
while ((ch = sr.Peek()) != -1)
{
if (isNested && (ch == '}' || ch == ':'))
{
break;
}
sr.Read();
if (ch == '$' && sr.Peek() == '{')
{
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
LayoutRenderer newLayoutRenderer = ParseLayoutRenderer(configurationItemFactory, sr);
if (CanBeConvertedToLiteral(newLayoutRenderer))
{
newLayoutRenderer = ConvertToLiteral(newLayoutRenderer);
}
// layout renderer
result.Add(newLayoutRenderer);
}
else
{
literalBuf.Append((char)ch);
}
}
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
int p1 = sr.Position;
MergeLiterals(result);
text = sr.Substring(p0, p1);
return result.ToArray();
}
internal static LayoutRenderer[] CompileLayout(ConfigurationItemFactory configurationItemFactory, Tokenizer sr, bool isNested, out string text)
{
var result = new List <LayoutRenderer>();
var literalBuf = new StringBuilder();
int ch;
int p0 = sr.Position;
while ((ch = sr.Peek()) != -1)
{
if (isNested && (ch == '}' || ch == ':'))
{
break;
}
sr.Read();
if (ch == '$' && sr.Peek() == '{')
{
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
LayoutRenderer newLayoutRenderer = ParseLayoutRenderer(configurationItemFactory, sr);
if (CanBeConvertedToLiteral(newLayoutRenderer))
{
newLayoutRenderer = ConvertToLiteral(newLayoutRenderer);
}
// layout renderer
result.Add(newLayoutRenderer);
}
else
{
literalBuf.Append((char)ch);
}
}
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
int p1 = sr.Position;
MergeLiterals(result);
text = sr.Substring(p0, p1);
return(result.ToArray());
}
internal static LayoutRenderer[] CompileLayout(Tokenizer sr, bool isNested, out string text)
{
ArrayList result = new ArrayList();
StringBuilder literalBuf = new StringBuilder();
int ch;
int p0 = sr.Position;
while ((ch = sr.Peek()) != -1)
{
if (isNested && (ch == '}' || ch == ':'))
{
break;
}
sr.Read();
if (ch == '$' && sr.Peek() == '{')
{
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
LayoutRenderer newLayoutRenderer = ParseLayoutRenderer(sr);
if (newLayoutRenderer.IsAppDomainFixed())
{
newLayoutRenderer = ConvertToLiteral(newLayoutRenderer);
}
result.Add(newLayoutRenderer);
// layout renderer
}
else
{
literalBuf.Append((char)ch);
}
}
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
int p1 = sr.Position;
MergeLiterals(result);
text = sr.Substring(p0, p1);
return((LayoutRenderer[])result.ToArray(typeof(LayoutRenderer)));
}
private static string ParseParameterName(Tokenizer sr)
{
int ch;
int nestLevel = 0;
var nameBuf = new StringBuilder();
while ((ch = sr.Peek()) != -1)
{
if ((ch == '=' || ch == '}' || ch == ':') && nestLevel == 0)
{
break;
}
if (ch == '$')
{
sr.Read();
nameBuf.Append('$');
if (sr.Peek() == '{')
{
nameBuf.Append('{');
nestLevel++;
sr.Read();
}
continue;
}
if (ch == '}')
{
nestLevel--;
}
if (ch == '\\')
{
// skip the backslash
sr.Read();
// append next character
nameBuf.Append((char)sr.Read());
continue;
}
nameBuf.Append((char)ch);
sr.Read();
}
return(nameBuf.ToString());
}
private static string ParseParameterValue(Tokenizer sr)
{
int ch;
StringBuilder nameBuf = new StringBuilder();
while ((ch = sr.Peek()) != -1)
{
if (ch == ':' || ch == '}')
{
break;
}
if (ch == '\\')
{
// skip the backslash
sr.Read();
// append next character
nameBuf.Append((char)sr.Read());
continue;
}
nameBuf.Append((char)ch);
sr.Read();
}
return(nameBuf.ToString());
}
public override Token Match(Tokenizer tz)
{
int count = 0;
for (; ; count++)
{
var c = tz.Peek(count);
if (c == '\n')
{
tz.IncLine();
}
if (!IsWhiteSpace(c))
{
break;
}
}
if (count == 0)
{
return(null);
}
tz.Consume(count);
return(WhiteToken);
}
public override Token Match(Tokenizer tz)
{
if (tz.CharLeft < _word.Length)
{
return(null);
}
int index = 0;
foreach (var c in _word)
{
if (tz.Peek(index) != c)
{
return(null);
}
index++;
}
tz.Consume(_word.Length);
return(new Token(_type, _word));
}
public bool AreColumnNamesInFirstLine(Stream stream, NumberFormatInfo numberFormat,
DateTimeFormatInfo dateTimeFormatInfo, char separator)
{
using (StreamReader reader = new StreamReader(stream)) {
tokenizer = new Tokenizer(reader, numberFormat, dateTimeFormatInfo, separator);
return(tokenizer.Peek().type != TokenTypeEnum.Double);
}
}
public void Peek_ShouldReturnTheNextToken_WithoutAdvancingTheStream()
{
var input = "a";
var tokenizer = new Tokenizer(input);
Assert.That(tokenizer.Peek(), Is.EqualTo(new Token(Symbol.Identifier, "a", 0)));
Assert.That(tokenizer.Pop(), Is.EqualTo(new Token(Symbol.Identifier, "a", 0)));
Assert.That(tokenizer.Pop(), Is.EqualTo(new Token(Symbol.End, "", 0)));
}
public void ShouldTokenizeNumber(double number)
{
var s = number.ToString();
var tokenizer = new Tokenizer(s);
var token = tokenizer.CurrentToken;
Assert.Equal(TokenType.Constant, token.Type);
Assert.Equal(s, token.Value);
Assert.Equal(TokenType.EOF, tokenizer.Peek().Type);
}
public void Peek_ShouldNotScrewUp_IfPeekAtTheEndOfTheStream()
{
var input = " aaa";
var tokenizer = new Tokenizer(input);
Assert.That(tokenizer.Pop(), Is.EqualTo(new Token(Symbol.Identifier, "aaa", 0)));
Assert.That(tokenizer.Pop(), Is.EqualTo(new Token(Symbol.End, "", 0)));
Assert.That(tokenizer.Peek(), Is.EqualTo(new Token(Symbol.End, "", 0)));
Assert.That(tokenizer.Pop(), Is.EqualTo(new Token(Symbol.End, "", 0)));
}
public void Peek_ShouldIgnoreBlockComments()
{
var input = @"{ line comment }
a";
var tokenizer = new Tokenizer(input);
Assert.That(tokenizer.Peek(), Is.EqualTo(new Token(Symbol.Identifier, "a", 0)));
Assert.That(tokenizer.Pop(), Is.EqualTo(new Token(Symbol.Identifier, "a", 0)));
Assert.That(tokenizer.Pop(), Is.EqualTo(new Token(Symbol.End, "", 0)));
}
public void ShouldPeek(string input)
{
var tokenizer = new Tokenizer(input);
Assert.Equal(TokenType.OpAdd, tokenizer.CurrentToken.Type);
var peek = tokenizer.Peek();
Assert.Equal(TokenType.OpSubtract, peek.Type);
Assert.Equal(TokenType.OpAdd, tokenizer.CurrentToken.Type);
}
private static string ParseParameterName(Tokenizer sr)
{
int ch;
int nestLevel = 0;
StringBuilder nameBuf = new StringBuilder();
while ((ch = sr.Peek()) != -1)
{
if ((ch == '=' || ch == '}' || ch == ':') && nestLevel == 0)
break;
if (ch == '$')
{
sr.Read();
nameBuf.Append('$');
if (sr.Peek() == '{')
{
nameBuf.Append('{');
nestLevel++;
sr.Read();
}
continue;
}
if (ch == '}')
{
nestLevel--;
}
if (ch == '\\')
{
// skip the backslash
sr.Read();
// append next character
nameBuf.Append((char)sr.Read());
continue;
}
nameBuf.Append((char)ch);
sr.Read();
}
return nameBuf.ToString();
}
public static NeuToken?MaybeNext(
this Tokenizer <NeuToken> tokenizer)
{
var peek = tokenizer.Peek();
if (peek != null)
{
tokenizer.Position++;
}
return(peek);
}
public static bool MatchPunc(
this Tokenizer <NeuToken> tokenizer,
params NeuPuncType[] puncTypes)
{
if (tokenizer.Peek() is NeuPunc p && puncTypes.Contains(p.PuncType))
{
return(true);
}
///
return(false);
}
public void PeekTest()
{
var t = new Tokenizer(" \t*/ 10 - 20, 23");
Assert.True(t.Peek().IsSymbol("*")); t.Pop(true);
Assert.True(t.Peek().IsSymbol("/")); t.Pop(true);
Assert.True(t.Peek().IsInteger()); t.Pop(true);
Assert.True(t.Peek().IsSymbol("-")); t.Pop(true);
Assert.True(t.Peek().IsInteger()); t.Pop(true);
Assert.True(t.Peek().IsSymbol(",")); t.Pop(true);
Assert.True(t.Peek().IsInteger()); t.Pop(true);
}
public static NeuNumberLiteral?MaybeNextNumberLiteral(
this Tokenizer <NeuToken> tokenizer)
{
if (tokenizer.Peek() is NeuNumberLiteral n)
{
tokenizer.Position++;
return(n);
}
///
return(null);
}
public static NeuIdentifier?MaybeNextIdentifier(
this Tokenizer <NeuToken> tokenizer)
{
if (tokenizer.Peek() is NeuIdentifier i)
{
tokenizer.Position++;
return(i);
}
///
return(null);
}
private static string ParseLayoutRendererName(Tokenizer sr)
{
int ch;
StringBuilder nameBuf = new StringBuilder();
while ((ch = sr.Peek()) != -1)
{
if (ch == ':' || ch == '}')
break;
nameBuf.Append((char)ch);
sr.Read();
}
return nameBuf.ToString();
}
public static NeuPunc?MaybeNextPunc(
this Tokenizer <NeuToken> tokenizer,
NeuPuncType puncType)
{
if (tokenizer.Peek() is NeuPunc p && p.PuncType == puncType)
{
tokenizer.Position++;
return(p);
}
///
return(null);
}
public static NeuKeyword?MaybeNextKeyword(
this Tokenizer <NeuToken> tokenizer,
params NeuKeywordType[] keywordTypes)
{
if (tokenizer.Peek() is NeuKeyword k && keywordTypes.Contains(k.KeywordType))
{
tokenizer.Position++;
return(k);
}
///
return(null);
}
public static NeuComment?MaybeNextComment(
this Tokenizer <NeuToken> tokenizer)
{
if (tokenizer.Peek() is NeuComment c)
{
tokenizer.Position++;
///
return(c);
}
///
return(null);
}
private void Comma(Tokenizer.Tokenizer tokenizer, Boolean optional = false)
{
AbstractToken token = tokenizer.Peek();
if (token.GetType() == typeof(Comma))
{
tokenizer.NextToken();
return;
}
if (optional)
{
return;
}
throw new ParseException("Expected type Comma but found: " + token.GetType() + " after " + tokenizer.GetPreviousCharacters(25));
}
public override bool Match(Tokenizer lexer)
{
var token = lexer.Peek();
if (token.Kind == TokenKind.Identity ||
token.Kind == TokenKind.Symbol)
{
foreach (var symbol in _tokens)
{
if (token.Image.Equals(symbol))
{
return(true);
}
}
}
return(false);
}
private static string ParseLayoutRendererName(Tokenizer sr)
{
int ch;
StringBuilder nameBuf = new StringBuilder();
while ((ch = sr.Peek()) != -1)
{
if (ch == ':' || ch == '}')
{
break;
}
nameBuf.Append((char)ch);
sr.Read();
}
return(nameBuf.ToString());
}
private string ReadSyntax(Tokenizer tokenizer, out TokenType?symbolType)
{
symbolType = null;
var sb = new StringBuilder().Append(tokenizer.NextChar());
for (var i = 0; i < 2; i++)
{
var ch = tokenizer.Peek();
if (!_syntax.IsSyntaxChar(ch) || _syntax.IsParen(ch))
{
break;
}
sb.Append(tokenizer.NextChar());
}
var probe = sb.ToString();
if (probe.Length == 1)
{
// one char read, let the lexer decide about the token type
return(probe);
}
while (true)
{
TokenType st;
if (_grammar.Syntax.Symbols.TryGetValue(probe, out st))
{
symbolType = st;
return(probe);
}
if (probe.Length == 1)
{
return(probe);
}
probe = probe.Substring(0, probe.Length - 1);
tokenizer.Position--;
}
}
public static NeuUnaryOperator?PeekUnaryOperator(
this Tokenizer <NeuToken> tokenizer)
{
switch (tokenizer.Peek())
{
case NeuPrefixOperator _:
return(null);
///
case NeuPostfixOperator _:
return(null);
///
case NeuUnaryOperator unaryOp:
return(unaryOp);
///
case NeuToken t when ToNeuUnaryOperator(t) is NeuUnaryOperator unaryOp:
tokenizer.Tokens[tokenizer.Position] = unaryOp;
return(unaryOp);
///
default:
return(null);
}
}
public static NeuBinaryOperator?PeekBinaryOperator(
this Tokenizer <NeuToken> tokenizer)
{
switch (tokenizer.Peek())
{
case NeuBinaryOperator binaryOp:
return(binaryOp);
///
case NeuToken t when ToNeuBinaryOperator(t) is NeuBinaryOperator binaryOp:
tokenizer.Tokens[tokenizer.Position] = binaryOp;
return(binaryOp);
///
default:
return(null);
}
}
public override bool Match(Tokenizer lexer)
{
var token = lexer.Peek();
return(Test(token));
}
private static LayoutRenderer ParseLayoutRenderer(ConfigurationItemFactory configurationItemFactory, Tokenizer sr)
{
int ch = sr.Read();
Debug.Assert(ch == '{', "'{' expected in layout specification");
string name = ParseLayoutRendererName(sr);
LayoutRenderer lr = configurationItemFactory.LayoutRenderers.CreateInstance(name);
var wrappers = new Dictionary<Type, LayoutRenderer>();
var orderedWrappers = new List<LayoutRenderer>();
ch = sr.Read();
while (ch != -1 && ch != '}')
{
string parameterName = ParseParameterName(sr).Trim();
if (sr.Peek() == '=')
{
sr.Read(); // skip the '='
PropertyInfo pi;
LayoutRenderer parameterTarget = lr;
if (!PropertyHelper.TryGetPropertyInfo(lr, parameterName, out pi))
{
Type wrapperType;
if (configurationItemFactory.AmbientProperties.TryGetDefinition(parameterName, out wrapperType))
{
LayoutRenderer wrapperRenderer;
if (!wrappers.TryGetValue(wrapperType, out wrapperRenderer))
{
wrapperRenderer = configurationItemFactory.AmbientProperties.CreateInstance(parameterName);
wrappers[wrapperType] = wrapperRenderer;
orderedWrappers.Add(wrapperRenderer);
}
if (!PropertyHelper.TryGetPropertyInfo(wrapperRenderer, parameterName, out pi))
{
pi = null;
}
else
{
parameterTarget = wrapperRenderer;
}
}
}
if (pi == null)
{
ParseParameterValue(sr);
}
else
{
if (typeof(Layout).IsAssignableFrom(pi.PropertyType))
{
var nestedLayout = new SimpleLayout();
string txt;
LayoutRenderer[] renderers = CompileLayout(configurationItemFactory, sr, true, out txt);
nestedLayout.SetRenderers(renderers, txt);
pi.SetValue(parameterTarget, nestedLayout, null);
}
else
{
string value = ParseParameterValue(sr);
PropertyHelper.SetPropertyFromString(parameterTarget, parameterName, value);
}
}
}
else
{
// what we've just read is not a parameterName, but a value
// assign it to a default property (denoted by empty string)
PropertyInfo pi;
if (PropertyHelper.TryGetPropertyInfo(lr, string.Empty, out pi))
{
if (typeof(SimpleLayout) == pi.PropertyType)
{
pi.SetValue(lr, new SimpleLayout(parameterName), null);
}
else
{
string value = parameterName;
PropertyHelper.SetPropertyFromString(lr, pi.Name, value);
}
}
else
{
InternalLogger.Warn("{0} has no default property", lr.GetType().FullName);
}
}
ch = sr.Read();
}
lr = ApplyWrappers(configurationItemFactory, lr, orderedWrappers);
return lr;
}
/// <summary>
/// Retrieves the tag values from the input.
/// </summary>
/// <param name="tokenizer"></param>
/// <returns></returns>
///
private ICollection<Tag> Tags(Tokenizer.Tokenizer tokenizer)
{
// This function needs some refactoring.
List<Tag> tags = new List<Tag>();
while (tokenizer.Peek().GetType() != typeof (ClosingBrace))
{
Tag tag = new Tag {Key = Text(tokenizer)};
Equals(tokenizer);
AbstractToken startToken = ValueStart(tokenizer);
List<AbstractToken> tokens = new List<AbstractToken>();
bool keepProcessing = true;
int balance = 1;
while (keepProcessing)
{
Type nextTokenType = tokenizer.Peek().GetType();
if (nextTokenType == typeof (OpeningBrace))
{
balance++;
}
if ( (startToken.GetType() == typeof(OpeningBrace) && nextTokenType == typeof (ClosingBrace)))
{
if (balance == 1)
{
keepProcessing = false;
ValueStop(tokenizer);
}
}
if (nextTokenType == typeof(ClosingBrace))
{
if (balance > 1)
{
balance--;
}
}
// Double quotes are much more difficult to handle then the braces. The problem is that there is no distinction between
// start and stop quotes. This means we need to look forward to see what is behind the quote to see if it is a quote @ the end
// or the start of a new quote.
if (nextTokenType == typeof (ValueQuote))
{
AbstractToken quote = tokenizer.NextToken();
Type nextType = tokenizer.Peek().GetType();
if ((nextType == typeof(ClosingBrace) && balance == 1) ||
nextType == typeof(Comma))
{
// end of line found.
keepProcessing = false;
}
else
{
tokens.Add(quote);
continue;
}
}
if (keepProcessing)
{
tokens.Add(tokenizer.NextToken());
}
}
tag.Value = tokens.Aggregate("", (s, token) => s + token.RawValue);
Comma(tokenizer, true);
NewLine(tokenizer, true);
tags.Add(tag);
}
return tags;
}
internal static LayoutRenderer[] CompileLayout(Tokenizer sr, bool isNested, out string text)
{
List<LayoutRenderer> result = new List<LayoutRenderer>();
StringBuilder literalBuf = new StringBuilder();
int ch;
int p0 = sr.Position;
while ((ch = sr.Peek()) != -1)
{
if (isNested && (ch == '}' || ch == ':'))
{
break;
}
sr.Read();
if (ch == '$' && sr.Peek() == '{')
{
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
LayoutRenderer newLayoutRenderer = ParseLayoutRenderer(sr);
if (newLayoutRenderer.IsAppDomainFixed())
newLayoutRenderer = ConvertToLiteral(newLayoutRenderer);
result.Add(newLayoutRenderer);
// layout renderer
}
else
{
literalBuf.Append((char)ch);
}
}
if (literalBuf.Length > 0)
{
result.Add(new LiteralLayoutRenderer(literalBuf.ToString()));
literalBuf.Length = 0;
}
int p1 = sr.Position;
MergeLiterals(result);
text = sr.Substring(p0, p1);
return result.ToArray();
}
private static LayoutRenderer ParseLayoutRenderer(Tokenizer sr)
{
int ch;
ch = sr.Read();
if (ch != '{')
throw new NLogConfigurationException("'{' expected in layout specification");
string name = ParseLayoutRendererName(sr);
LayoutRenderer lr = LayoutRendererFactory.CreateLayoutRenderer(name, null);
ch = sr.Read();
while (ch != -1 && ch != '}')
{
string parameterName = ParseParameterName(sr).Trim();
if (sr.Peek() == '=')
{
sr.Read(); // skip the '='
PropertyInfo pi = PropertyHelper.GetPropertyInfo(lr, parameterName);
if (pi == null)
{
ParseParameterValue(sr);
}
else
{
if (typeof(Layout) == pi.PropertyType)
{
Layout nestedLayout = new Layout();
string txt;
LayoutRenderer[] renderers = CompileLayout(sr, true, out txt);
nestedLayout.SetRenderers(renderers, txt);
pi.SetValue(lr, nestedLayout, null);
}
else
{
string value = ParseParameterValue(sr);
PropertyHelper.SetPropertyFromString(lr, parameterName, value, null);
}
}
}
else
{
// what we've just read is not a parameterName, but a value
// assign it to a default property (denoted by empty string)
PropertyInfo pi = PropertyHelper.GetPropertyInfo(lr, "");
if (pi != null)
{
if (typeof(Layout) == pi.PropertyType)
{
pi.SetValue(lr, new Layout(parameterName), null);
}
else
{
string value = parameterName;
PropertyHelper.SetPropertyFromString(lr, pi.Name, value, null);
}
}
else
{
InternalLogger.Warn("{0} has no default property", lr.GetType().FullName);
}
}
ch = sr.Read();
}
return lr;
}
private static string ParseParameterValue(Tokenizer sr)
{
int ch;
StringBuilder nameBuf = new StringBuilder();
while ((ch = sr.Peek()) != -1)
{
if (ch == ':' || ch == '}')
break;
if (ch == '\\')
{
// skip the backslash
sr.Read();
// append next character
nameBuf.Append((char)sr.Read());
continue;
}
nameBuf.Append((char)ch);
sr.Read();
}
return nameBuf.ToString();
}
private object NextValue(Tokenizer tokenizer) {
if (tokenizer.Peek() == tokenizer.SeparatorToken || tokenizer.Peek() == tokenizer.NewlineToken) return string.Empty;
Token current = tokenizer.Next();
if (current.type == TokenTypeEnum.Separator) {
return double.NaN;
} else if (current.type == TokenTypeEnum.String) {
return current.stringValue;
} else if (current.type == TokenTypeEnum.Double) {
return current.doubleValue;
} else if (current.type == TokenTypeEnum.DateTime) {
return current.dateTimeValue;
}
// found an unexpected token => throw error
Error("Unexpected token.", current.stringValue, tokenizer.CurrentLineNumber);
// this line is never executed because Error() throws an exception
throw new InvalidOperationException();
}
public bool AreColumnNamesInFirstLine(Stream stream, NumberFormatInfo numberFormat,
DateTimeFormatInfo dateTimeFormatInfo, char separator) {
using (StreamReader reader = new StreamReader(stream)) {
tokenizer = new Tokenizer(reader, numberFormat, dateTimeFormatInfo, separator);
return tokenizer.Peek().type != TokenTypeEnum.Double;
}
}
private static LayoutRenderer ParseLayoutRenderer(ConfigurationItemFactory configurationItemFactory, Tokenizer sr)
{
int ch = sr.Read();
Debug.Assert(ch == '{', "'{' expected in layout specification");
string name = ParseLayoutRendererName(sr);
LayoutRenderer lr = configurationItemFactory.LayoutRenderers.CreateInstance(name);
var wrappers = new Dictionary <Type, LayoutRenderer>();
var orderedWrappers = new List <LayoutRenderer>();
ch = sr.Read();
while (ch != -1 && ch != '}')
{
string parameterName = ParseParameterName(sr).Trim();
if (sr.Peek() == '=')
{
sr.Read(); // skip the '='
PropertyInfo pi;
LayoutRenderer parameterTarget = lr;
if (!PropertyHelper.TryGetPropertyInfo(lr, parameterName, out pi))
{
Type wrapperType;
if (configurationItemFactory.AmbientProperties.TryGetDefinition(parameterName, out wrapperType))
{
LayoutRenderer wrapperRenderer;
if (!wrappers.TryGetValue(wrapperType, out wrapperRenderer))
{
wrapperRenderer = configurationItemFactory.AmbientProperties.CreateInstance(parameterName);
wrappers[wrapperType] = wrapperRenderer;
orderedWrappers.Add(wrapperRenderer);
}
if (!PropertyHelper.TryGetPropertyInfo(wrapperRenderer, parameterName, out pi))
{
pi = null;
}
else
{
parameterTarget = wrapperRenderer;
}
}
}
if (pi == null)
{
ParseParameterValue(sr);
}
else
{
if (typeof(Layout).IsAssignableFrom(pi.PropertyType))
{
var nestedLayout = new SimpleLayout();
string txt;
LayoutRenderer[] renderers = CompileLayout(configurationItemFactory, sr, true, out txt);
nestedLayout.SetRenderers(renderers, txt);
pi.SetValue(parameterTarget, nestedLayout, null);
}
else
{
string value = ParseParameterValue(sr);
PropertyHelper.SetPropertyFromString(parameterTarget, parameterName, value);
}
}
}
else
{
// what we've just read is not a parameterName, but a value
// assign it to a default property (denoted by empty string)
PropertyInfo pi;
if (PropertyHelper.TryGetPropertyInfo(lr, string.Empty, out pi))
{
if (typeof(SimpleLayout) == pi.PropertyType)
{
pi.SetValue(lr, new SimpleLayout(parameterName), null);
}
else
{
string value = parameterName;
PropertyHelper.SetPropertyFromString(lr, pi.Name, value);
}
}
else
{
InternalLogger.Warn("{0} has no default property", lr.GetType().FullName);
}
}
ch = sr.Read();
}
lr = ApplyWrappers(configurationItemFactory, lr, orderedWrappers);
return(lr);
}
private static LayoutRenderer ParseLayoutRenderer(Tokenizer sr)
{
int ch;
ch = sr.Read();
if (ch != '{')
{
throw new NLogConfigurationException("'{' expected in layout specification");
}
string name = ParseLayoutRendererName(sr);
LayoutRenderer lr = LayoutRendererFactory.CreateLayoutRenderer(name, null);
ch = sr.Read();
while (ch != -1 && ch != '}')
{
string parameterName = ParseParameterName(sr).Trim();
if (sr.Peek() == '=')
{
sr.Read(); // skip the '='
PropertyInfo pi = PropertyHelper.GetPropertyInfo(lr, parameterName);
if (pi == null)
{
ParseParameterValue(sr);
}
else
{
if (typeof(Layout) == pi.PropertyType)
{
Layout nestedLayout = new Layout();
string txt;
LayoutRenderer[] renderers = CompileLayout(sr, true, out txt);
nestedLayout.SetRenderers(renderers, txt);
pi.SetValue(lr, nestedLayout, null);
}
else
{
string value = ParseParameterValue(sr);
PropertyHelper.SetPropertyFromString(lr, parameterName, value, null);
}
}
}
else
{
// what we've just read is not a parameterName, but a value
// assign it to a default property (denoted by empty string)
PropertyInfo pi = PropertyHelper.GetPropertyInfo(lr, "");
if (pi != null)
{
if (typeof(Layout) == pi.PropertyType)
{
pi.SetValue(lr, new Layout(parameterName), null);
}
else
{
string value = parameterName;
PropertyHelper.SetPropertyFromString(lr, pi.Name, value, null);
}
}
else
{
InternalLogger.Warn("{0} has no default property", lr.GetType().FullName);
}
}
ch = sr.Read();
}
return(lr);
}
