private static TomlTable CreateStandardTable(TomlTable.RootTable root, StandardTableNode table, IHasComments comments)
{
var keySegments = table.Key.SyntaxNode().GetSegments();
KeyChain chain = KeyChain.FromSegments(keySegments);
if (chain.IsEmpty)
{
throw new InvalidOperationException("Empty TOML key is not allowed.");
}
TomlTable owner = FindOrCreateOwnerTableForTable(root, chain, out TomlKey last);
TomlObject existing = owner.TryGetValue(last);
if (existing != null)
{
throw new InvalidOperationException($"Cannot define table with key '{chain}' as the owner already " +
$"contains a row for key '{last}' of type '{existing.ReadableTypeName}'.");
}
else
{
TomlTable newTable = new TomlTable(root);
owner.AddRow(last, newTable);
newTable.AddComments(comments);
return(newTable);
}
}
private static TomlTable CreateTableArray(TomlTable.RootTable root, TableArrayNode tableArray, IHasComments comments)
{
System.Collections.Generic.IEnumerable <TerminalNode> keySegments = tableArray.Key.SyntaxNode().GetSegments();
KeyChain chain = KeyChain.FromSegments(keySegments);
if (chain.IsEmpty)
{
throw new InvalidOperationException("Empty TOML key is not allowed.");
}
TomlTable owner = FindOrCreateOwnerTableForTableArray(root, chain, out TomlKey last);
TomlObject existing = owner.TryGetValue(last);
if (existing != null && existing is TomlTableArray existingArray)
{
TomlTable newTable = new TomlTable(root);
existingArray.Add(newTable);
newTable.AddComments(comments);
return(newTable);
}
else if (existing == null)
{
TomlTableArray newTableArray = new TomlTableArray(root);
owner.AddRow(last, newTableArray);
TomlTable newTable = new TomlTable(root);
newTable.AddComments(comments);
newTableArray.Add(newTable);
return(newTable);
}
else
{
throw new InvalidOperationException($"Cannot define table array '{last}' as an object of type "
+ $"'{existing.ReadableTypeName}' exists already.");
}
}
public static TomlTable Build(StartNode node, TomlSettings settings)
{
TomlTable.RootTable rootTable = new TomlTable.RootTable(settings);
TomlTable current = rootTable;
if (node == null)
{
return(rootTable);
}
System.Collections.Generic.IEnumerable <ExpressionNode> expressions = node.Expressions();
foreach (ExpressionNode e in expressions)
{
switch (e)
{
case KeyValueExpressionNode kvn:
var val = ToTomlValue(rootTable, kvn.Value.SyntaxNode());
val.AddComments(kvn);
if (kvn.Key.SyntaxNode().IsDottedKey())
{
var chain = KeyChain.FromSegments(kvn.Key.SyntaxNode().GetSegments());
var owner = FindOrCreateOwnerTableForTable(current, chain, out var last, TomlTable.TableTypes.Dotted);
owner.AddRow(last, val);
}
else
{
current.AddRow(kvn.Key.SyntaxNode().ExpressionKey(), val);
}
break;
case TableNode tn:
current = CreateTableOrArrayOfTables(rootTable, tn);
break;
case CommentExpressionNode cen:
var loc = rootTable.Rows.Any() ? CommentLocation.Append : CommentLocation.Prepend;
foreach (var c in cen.Comments)
{
rootTable.AddComment(c.Value, loc);
}
break;
default:
throw new InvalidOperationException($"Encountered unexpected expression of type '{e.GetType()}'.");
}
}
return(rootTable);
}
private static TomlTable CreateTableOrArrayOfTables(TomlTable.RootTable root, TableNode table)
{
Node sn = table.Table.SyntaxNode();
switch (sn)
{
case StandardTableNode stn: return(CreateStandardTable(root, stn, table));
case TableArrayNode an: return(CreateTableArray(root, an, table));
default:
throw new InvalidOperationException(
$"Encountered unexpected table node of type '{sn?.GetType().ToString() ?? "null"}'.");
}
}
private TomlTable Toml()
{
var root = new TomlTable.RootTable(this.settings)
{
IsDefined = true
};
TomlTable current = root;
while (!this.Tokens.End)
{
current = ExpressionsProduction.TryApply(current, root, this.Tokens);
if (current == null)
{
if (!this.Tokens.End)
{
throw new Exception();
}
break;
}
}
return(root);
}
public static TomlTable TryApply(TomlTable current, TomlTable.RootTable root, TokenBuffer tokens)
{
tokens.ConsumeAllNewlines();
var preComments = CommentProduction.TryParsePreExpressionCommenst(tokens);
var expressionToken = tokens.Peek();
tokens.ConsumeAllNewlines();
var arrayKeyChain = TomlArrayTableProduction.TryApply(tokens);
if (arrayKeyChain != null)
{
var addTo = GetTargetTable(root, arrayKeyChain, CreateImplicitelyType.Table);
var arr = GetExistingOrCreateAndAdd(addTo, arrayKeyChain.Last(), errorPosition: expressionToken);
arr.Comments.AddRange(preComments);
arr.Comments.AddRange(CommentProduction.TryParseAppendExpressionComments(expressionToken, tokens));
var newArrayEntry = new TomlTable(root);
arr.Add(newArrayEntry);
return(newArrayEntry);
}
var tableKeyChain = TomlTableProduction.TryApply(tokens);
if (tableKeyChain != null)
{
var newTable = new TomlTable(root)
{
IsDefined = true
};
newTable.Comments.AddRange(preComments);
newTable.Comments.AddRange(CommentProduction.TryParseAppendExpressionComments(expressionToken, tokens));
var addTo = GetTargetTable(root, tableKeyChain, CreateImplicitelyType.Table);
var key = tableKeyChain.Last();
var existingRow = addTo.TryGetValue(key);
if (existingRow == null)
{
addTo.AddRow(key, newTable);
}
else
{
var tbl = existingRow as TomlTable;
if (tbl.IsDefined)
{
throw new Exception($"Failed to add new table because the target table already contains a row with the key '{key}' of type '{existingRow.ReadableTypeName}'.");
}
else
{
tbl.IsDefined = true;
return(tbl);
}
}
return(newTable);
}
if (!tokens.End)
{
var kvp = KeyValuePairProduction.Apply(root, tokens);
if (kvp != null)
{
kvp.Item2.Comments.AddRange(preComments);
kvp.Item2.Comments.AddRange(CommentProduction.TryParseAppendExpressionComments(expressionToken, tokens));
current.AddRow(kvp.Item1, kvp.Item2);
return(current);
}
}
root.Comments.AddRange(preComments);
return(null);
}
