private static ParameterDefinition ParseParameter(Cursor cursor, CppParserContext context)
{
string parameterName = cursor.Spelling;
IEnumerable <Token> tokens = context.TranslationUnit.Tokenize(cursor.Extent);
bool isOptional = tokens.Any(t => t.Spelling == "=");
return(new ParameterDefinition(parameterName, new TypeRefDefinition(cursor.Type), isOptional));
}
public void Parse(Cursor cursor, CppParserContext context)
{
string namespaceName = cursor.Spelling;
NamespaceDefinition @namespace = CreateOrGetNamespace(namespaceName, context);
NamespaceDefinition previousNamespace = context.Namespace;
context.Namespace = @namespace;
cursor.VisitChildren(context.NodeVisitor);
context.Namespace = previousNamespace;
}
private static string GetEnumeratorValue(Cursor constantDecl, CppParserContext context)
{
var value = constantDecl.Children.FirstOrDefault();
if (value != null)
{
var valueTokens = context.TranslationUnit.Tokenize(value.Extent)
.Where(IsValueToken);
string spelling = string.Join("", valueTokens.Select(t => t.Spelling));
return(string.IsNullOrEmpty(spelling) ? null : spelling);
}
return(null);
}
public void Parse(Cursor cursor, CppParserContext context)
{
string fieldName = cursor.Spelling;
var field = new FieldDefinition(fieldName, new TypeRefDefinition(cursor.Type));
ModelNodeDefinition parent = context.GetContainingClassOrNamespace();
if (parent is NamespaceDefinition)
{
field.Header = context.Header;
}
parent.AddChild(field);
}
private static NamespaceDefinition CreateOrGetNamespace(string name, CppParserContext context)
{
var @namespace = context.Namespace.Namespaces
.FirstOrDefault(n => n.Name == name);
if (@namespace == null)
{
@namespace = new NamespaceDefinition(name)
{
Parent = context.Namespace
};
context.Namespace.Children.Add(@namespace);
}
return(@namespace);
}
private static bool IsCursorAbstract(Cursor cursor, CppParserContext context)
{
IList <Token> tokens = context.TranslationUnit.Tokenize(cursor.Extent).ToList();
int count = tokens.Count;
if (count > 3)
{
if (tokens[count - 3].Spelling.Equals("=") &&
tokens[count - 2].Spelling.Equals("0") &&
tokens[count - 1].Spelling.Equals(";"))
{
return(true);
}
}
return(false);
}
public void Parse(Cursor cursor, CppParserContext context)
{
var parent = context.GetContainingClassOrNamespace();
var @enum = new EnumDefinition(cursor.Spelling);
foreach (var constantDecl in cursor.Children
.Where(c => c.Kind == CursorKind.EnumConstantDecl))
{
string name = constantDecl.Spelling;
string value = GetEnumeratorValue(constantDecl, context);
@enum.AddChild(new EnumeratorDefinition(name, value));
}
parent.AddChild(@enum);
if (parent is NamespaceDefinition)
{
context.Header.AddNode(@enum);
}
}
public void Parse(Cursor cursor, CppParserContext context)
{
string className = cursor.Spelling;
ModelNodeDefinition parent = context.GetContainingClassOrNamespace();
if (HasNameConflict(className, parent))
{
return;
}
context.Class = new ClassDefinition(className);
parent.AddChild(context.Class);
if (parent is NamespaceDefinition)
{
context.Header.AddNode(context.Class);
}
cursor.VisitChildren(context.NodeVisitor);
context.Class = parent as ClassDefinition;
}
private void InitializeContext(RootFolderDefinition rootFolder)
{
_context = new CppParserContext(rootFolder)
{
NodeVisitor = HeaderVisitor
};
var classParser = new ClassParser();
var methodParser = new MethodParser();
_context.DefinitionParsers.Add(CursorKind.ClassDecl, classParser);
_context.DefinitionParsers.Add(CursorKind.ClassTemplate, classParser);
_context.DefinitionParsers.Add(CursorKind.StructDecl, classParser);
_context.DefinitionParsers.Add(CursorKind.EnumDecl, new EnumParser());
_context.DefinitionParsers.Add(CursorKind.Namespace, new NamespaceParser());
_context.DeclarationParsers.Add(CursorKind.FieldDecl, new FieldParser());
_context.DeclarationParsers.Add(CursorKind.CxxMethod, methodParser);
_context.DeclarationParsers.Add(CursorKind.Constructor, methodParser);
var globalNamespace = new NamespaceDefinition("");
_context.Namespace = globalNamespace;
}
public void Parse(Cursor cursor, CppParserContext context)
{
string methodName = cursor.Spelling;
var parameters = new ParameterDefinition[cursor.NumArguments];
for (uint i = 0; i < cursor.NumArguments; i++)
{
Cursor parameterCursor = cursor.GetArgument(i);
parameters[i] = ParseParameter(parameterCursor, context);
}
context.Method = new MethodDefinition(methodName, parameters)
{
IsConstructor = cursor.Kind == CursorKind.Constructor,
IsStatic = cursor.IsStaticCxxMethod,
IsAbstract = IsCursorAbstract(cursor, context),
ReturnType = new TypeRefDefinition(cursor.ResultType)
};
ModelNodeDefinition parent = context.GetContainingClassOrNamespace();
if (parent is NamespaceDefinition)
{
if (cursor.SemanticParent.Kind == CursorKind.ClassDecl ||
cursor.SemanticParent.Kind == CursorKind.ClassTemplate ||
cursor.SemanticParent.Kind == CursorKind.StructDecl)
{
// FIXME: Clang reports a method definition as a method declaration
return;
}
context.Method.Header = context.Header;
}
parent.AddChild(context.Method);
context.Method = null;
}
