// parse path value
private HoconPath ParseKey()
{
// sanity check
if (_tokens.Current.IsNonSignificant() || _tokens.Current.Type != TokenType.LiteralValue)
{
throw HoconParserException.Create(_tokens.Current, Path,
$"Internal parser error, ParseKey() is called on an invalid token. Should be `{TokenType.LiteralValue}`, found `{_tokens.Current.Type}` instead.");
}
var keyTokens = new HoconTokenizerResult();
while (_tokens.Current.Type == TokenType.LiteralValue)
{
keyTokens.Add(_tokens.Current);
_tokens.Next();
}
// TODO: this is janky, fix this
keyTokens.Reverse();
while (keyTokens.Count > 0 && keyTokens[0].LiteralType == TokenLiteralType.Whitespace)
{
keyTokens.RemoveAt(0);
}
keyTokens.Reverse();
keyTokens.Add(new Token("", TokenType.EndOfFile, null));
return(HoconPath.FromTokens(keyTokens));
}
internal static HoconPath FromTokens(HoconTokenizerResult tokens)
{
if (tokens == null)
{
throw new ArgumentNullException(nameof(tokens));
}
var result = new List <string>();
var sb = new StringBuilder();
while (tokens.Current.Type == TokenType.LiteralValue)
{
switch (tokens.Current.LiteralType)
{
case TokenLiteralType.TripleQuotedLiteralValue:
throw HoconParserException.Create(tokens.Current, null,
"Triple quoted string could not be used in path expression.");
case TokenLiteralType.QuotedLiteralValue:
// Normalize quoted keys, remove the quotes if the key doesn't need them.
//sb.Append(tokens.Current.Value.NeedQuotes() ? $"\"{tokens.Current.Value}\"" : tokens.Current.Value);
sb.Append(tokens.Current.Value);
break;
default:
var split = tokens.Current.Value.Split('.');
for (var i = 0; i < split.Length - 1; ++i)
{
sb.Append(split[i]);
result.Add(sb.ToString());
sb.Clear();
}
sb.Append(split[split.Length - 1]);
break;
}
tokens.Next();
}
result.Add(sb.ToString());
return(new HoconPath(result));
}
private void ParseTokens()
{
if (_tokens.Current.IsNonSignificant())
{
ConsumeWhitelines();
}
while (_tokens.Current.Type != TokenType.EndOfFile)
{
switch (_tokens.Current.Type)
{
case TokenType.Include:
var parsedInclude = ParseInclude(null);
if (_root.Type != HoconType.Object)
{
_root.Clear();
_root.Add(parsedInclude.GetObject());
}
else
{
_root.Add(parsedInclude.GetObject());
}
break;
// Hocon config file may contain one array and one array only
case TokenType.StartOfArray:
_root.Clear();
_root.Add(ParseArray(null));
ConsumeWhitelines();
if (_tokens.Current.Type != TokenType.EndOfFile)
{
throw HoconParserException.Create(_tokens.Current, Path, "Hocon config can only contain one array or one object.");
}
return;
case TokenType.StartOfObject:
{
var parsedObject = ParseObject(null);
if (_root.Type != HoconType.Object)
{
_root.Clear();
_root.Add(parsedObject);
}
else
{
_root.Add(parsedObject.GetObject());
}
break;
}
case TokenType.LiteralValue:
{
if (_tokens.Current.IsNonSignificant())
{
ConsumeWhitelines();
}
if (_tokens.Current.Type != TokenType.LiteralValue)
{
break;
}
var parsedObject = ParseObject(null);
if (_root.Type != HoconType.Object)
{
_root.Clear();
_root.Add(parsedObject);
}
else
{
_root.Add(parsedObject.GetObject());
}
break;
}
case TokenType.Comment:
case TokenType.EndOfLine:
case TokenType.EndOfFile:
case TokenType.EndOfObject:
case TokenType.EndOfArray:
_tokens.Next();
break;
default:
throw HoconParserException.Create(_tokens.Current, null, $"Illegal token type: {_tokens.Current.Type}", null);
}
}
}