protected FuncDefNode AssertFunctionSignature(string src,
int line,
string fname,
string returnType = "void",
bool isVariadic = false,
AccessModifiers access = AccessModifiers.Unspecified,
QualifierFlags qualifiers = QualifierFlags.None,
params (string Type, string Identifier)[] @params)
protected void AssertVariableDeclaration(string src,
string identifier,
string type,
AccessModifiers access = AccessModifiers.Unspecified,
QualifierFlags qualifiers = QualifierFlags.None,
object?value = null)
{
DeclStatNode decl = this.AssertDeclarationNode(src, type, access, qualifiers);
Assert.That(decl.DeclaratorList.Parent, Is.EqualTo(decl));
VarDeclNode var = decl.DeclaratorList.Declarators.Single().As <VarDeclNode>();
Assert.That(var.Parent, Is.EqualTo(decl.DeclaratorList));
Assert.That(var.Identifier, Is.EqualTo(identifier));
Assert.That(var.Children.First().As <IdNode>().Identifier, Is.EqualTo(identifier));
if (value is { })
protected DeclStatNode AssertDeclarationNode(string src,
string type,
AccessModifiers access = AccessModifiers.Unspecified,
QualifierFlags qualifiers = QualifierFlags.None)
{
ASTNode ast = this.GenerateAST(src);
DeclStatNode decl = ast is SourceNode block
? this.ExtractDeclarationFromBlock(block)
: ast.As <DeclStatNode>();
Assert.That(decl.Children, Has.Exactly(2).Items);
Assert.That(decl.Specifiers.Parent, Is.EqualTo(decl));
Assert.That(decl.Specifiers.Modifiers.AccessModifiers, Is.EqualTo(access));
Assert.That(decl.Specifiers.Modifiers.QualifierFlags, Is.EqualTo(qualifiers));
Assert.That(decl.Specifiers.TypeName, Is.EqualTo(type));
Assert.That(decl.Specifiers.Children, Is.Empty);
return(decl);
}
public static Modifiers Parse(string specs)
{
AccessModifiers access = AccessModifiers.Unspecified;
string[] split = specs.ToLowerInvariant()
.Split(" ", StringSplitOptions.RemoveEmptyEntries)
.Distinct()
.ToArray();
if (split.Contains("private") || split.Contains("local"))
{
access = AccessModifiers.Private;
}
else if (split.Contains("protected"))
{
access = AccessModifiers.Protected;
}
else if (split.Contains("internal"))
{
access = AccessModifiers.Internal;
}
else if (split.Contains("public") || split.Contains("extern"))
{
access = AccessModifiers.Public;
}
QualifierFlags qualifiers = QualifierFlags.None;
if (split.Contains("const"))
{
qualifiers |= QualifierFlags.Const;
}
if (split.Contains("static"))
{
qualifiers |= QualifierFlags.Static;
}
if (split.Contains("volatile"))
{
qualifiers |= QualifierFlags.Volatile;
}
return(new Modifiers(access, qualifiers));
}
private Modifiers(AccessModifiers accessModifiers, QualifierFlags qualifiers)
{
this.AccessModifiers = accessModifiers;
this.QualifierFlags = qualifiers;
}
