public void AllTries_StartWithCompilationUnit(string code)
{
var tree = SimpleSyntaxNode.FromSourceCode(code);
Assert.AreEqual(SyntaxKind.CompilationUnit, tree.Kind);
Assert.AreEqual(SyntaxNodeType.Node, tree.Type);
}
private static void CheckBuild_ForValue(string value)
{
var tree = SimpleSyntaxNode.FromSyntax(value);
tree.Type.Should().BeEquivalentTo(SyntaxNodeType.Value);
tree.Kind.Should().BeEquivalentTo(SyntaxKind.None);
tree.Value.Should().BeEquivalentTo(value);
tree.Children.Should().BeEmpty();
}
private static void CheckBuild_ForTrivia(SyntaxTrivia trivia)
{
var tree = SimpleSyntaxNode.FromSyntax(trivia);
tree.Type.Should().BeEquivalentTo(SyntaxNodeType.Trivia);
tree.Kind.Should().BeEquivalentTo(trivia.Kind());
tree.Value.Should().BeEquivalentTo(trivia.ToFullString());
tree.Children.Should().BeEmpty();
}
private static void CheckBuild_ForNode(SyntaxNode node, IEnumerable <SyntaxKind> childrenOrder)
{
var tree = SimpleSyntaxNode.FromSyntax(node);
tree.Type.Should().BeEquivalentTo(SyntaxNodeType.Node);
tree.Kind.Should().BeEquivalentTo(node.Kind());
tree.Value.Should().BeEmpty();
tree.Children
.Select(c => c.Kind)
.Should()
.BeEquivalentTo(childrenOrder);
}
public static string GetJsonTreeFromFile(string path, Encoding encoding = null)
{
encoding ??= Encoding.UTF8;
var code = string.Empty;
if (File.Exists(path))
{
code = File.ReadAllText(path, encoding);
}
var tree = SimpleSyntaxNode.FromSourceCode(code);
var options = new JsonSerializerOptions {
MaxDepth = (int)1e4
};
return(JsonSerializer.Serialize(tree, typeof(SimpleSyntaxNode), options));
}
public void SimpleTest_When_EmptyCode()
{
const string code = "";
var actualTree = SimpleSyntaxNode.FromSourceCode(code);
var endOfFile = new SimpleSyntaxNode(
SyntaxNodeType.Token,
SyntaxKind.EndOfFileToken,
value: "");
var expectedTree = new SimpleSyntaxNode(
SyntaxNodeType.Node,
SyntaxKind.CompilationUnit,
new List <SimpleSyntaxNode> {
endOfFile
});
expectedTree.Should().BeEquivalentTo(actualTree);
}
private static void CheckBuild_ForToken(SyntaxToken token, IReadOnlyCollection <SyntaxKind> childrenOrder)
{
var tree = SimpleSyntaxNode.FromSyntax(token);
tree.Type.Should().BeEquivalentTo(SyntaxNodeType.Token);
tree.Kind.Should().BeEquivalentTo(token.Kind());
if (!childrenOrder.Any())
{
tree.Value.Should().BeEquivalentTo(token.ValueText);
tree.Children.Should().BeEmpty();
}
else
{
tree.Value.Should().BeEmpty();
tree.Children
.Select(c => c.Kind)
.Should()
.BeEquivalentTo(childrenOrder);
}
}
private static void ValidateSyntaxNode(SimpleSyntaxNode simpleSyntaxNode, params SymbolConstants[] symbolConstants)
{
if (simpleSyntaxNode == null)
{
throw new ArgumentNullException("simpleSyntaxNode");
}
if ((simpleSyntaxNode.Symbol == null) ||
((symbolConstants != null) &&
(symbolConstants.Length > 0) &&
!symbolConstants.Contains((SymbolConstants)simpleSyntaxNode.Symbol.Index)))
{
throw new ArgumentException(mc_InvalidSyntaxNode, "simpleSyntaxNode");
}
}
private static String CreateXpidlId(SimpleSyntaxNode idSyntaxNode)
{
ValidateSyntaxNode(idSyntaxNode, SymbolConstants.XpidlId);
String xpidlId = idSyntaxNode.Text;
return xpidlId;
}
public static string GetJsonTreeFromCode(string code)
{
var tree = SimpleSyntaxNode.FromSourceCode(code);
return(JsonSerializer.Serialize(tree));
}
private ComplexSyntaxNode ParseImpl(TextReader xpidlTextReader)
{
var goldParser = new GoldParser.Parser(xpidlTextReader, m_Grammar) { TrimReductions = true, IgnoreNestedComments = true };
goldParser.AddCommentSymbols(
new Regex(@"^\/\*$", RegexOptions.Singleline), // /*
new Regex(@"^\*\/$", RegexOptions.Singleline)); // */
goldParser.AddCommentSymbols(
new Regex(@"^\%\{\s*C\+\+$", RegexOptions.Singleline), // %{ C++
new Regex(@"^\%\}(\s*C\+\+)?$", RegexOptions.Singleline)); // %} C++
var rootSyntaxNode = new ComplexSyntaxNode(null);
while (true)
{
ParseMessage parseMessage = goldParser.Parse();
switch (parseMessage)
{
case ParseMessage.Empty:
break;
// Comment or inline C header
case ParseMessage.CommentLineRead:
case ParseMessage.CommentBlockRead:
var commentSyntaxNode = new CommentSyntaxNode(goldParser.CommentText);
if (goldParser.TokenSyntaxNode == null)
{
rootSyntaxNode.AddChildNode(commentSyntaxNode);
}
else
{
((SyntaxNode)goldParser.TokenSyntaxNode).AttachCommentNode(commentSyntaxNode);
}
break;
// Read valid token
case ParseMessage.TokenRead:
var simpleSyntaxNode = new SimpleSyntaxNode(goldParser.TokenSymbol, goldParser.TokenText);
goldParser.TokenSyntaxNode = simpleSyntaxNode;
break;
// Can create new xpidl-node
case ParseMessage.Reduction:
var complexSyntaxNode = new ComplexSyntaxNode(goldParser.ReductionRule);
for (Int32 i = 0; i < goldParser.ReductionCount; ++i)
{
var syntaxNode = (SyntaxNode)goldParser.GetReductionSyntaxNode(i);
complexSyntaxNode.AddChildNode(syntaxNode);
if (i == (goldParser.ReductionCount - 1))
{
complexSyntaxNode.ReattachCommentNodes(syntaxNode);
}
else
{
syntaxNode.DetachCommentNodes(complexSyntaxNode);
}
}
goldParser.TokenSyntaxNode = complexSyntaxNode;
break;
// Parsing successfully completed
case ParseMessage.Accept:
var acceptedSyntaxNode = (SyntaxNode)goldParser.TokenSyntaxNode;
Debug.Assert(acceptedSyntaxNode != null);
rootSyntaxNode.AddChildNode(acceptedSyntaxNode);
acceptedSyntaxNode.DetachCommentNodes(rootSyntaxNode);
return rootSyntaxNode;
// Grammar table is not loaded
case ParseMessage.NotLoadedError:
throw new XpidlParserException("Grammar not loaded");
// Unexpected end of input
case ParseMessage.CommentError:
throw new XpidlParserException("Comment error");
// Invalid token
case ParseMessage.LexicalError:
throw new XpidlParserSyntaxException("Can not recognize token", goldParser.TokenText, goldParser.LineNumber, goldParser.LinePosition);
// Unexpected token
case ParseMessage.SyntaxError:
throw new XpidlParserSyntaxException("Unexpected token", goldParser.TokenText, goldParser.LineNumber, goldParser.LinePosition);
// Fatal internal error
case ParseMessage.InternalError:
throw new XpidlParserException("Internal parser error");
}
}
}
