Skip to content

Commit

Permalink
using YAML in the output of "doxyparse"
Browse files Browse the repository at this point in the history 
refers to pull-request !425
  • Loading branch information
@joenio
joenio committed Feb 3, 2016
1 parent e6dcc3b commit 82dbb5f
Showing 1 changed file with 121 additions and 129 deletions.
250 changes: 121 additions & 129 deletions addon/doxyparse/doxyparse.cpp
View file
Expand Up @@ -34,6 +34,7 @@
#include <string>
#include <cstdlib>
#include <sstream>
#include <map>

class Doxyparse : public CodeOutputInterface
{
Expand Down Expand Up @@ -75,6 +76,8 @@ class Doxyparse : public CodeOutputInterface
};

static bool is_c_code = true;
static std::map<std::string, bool> modules;
static std::string current_module;

static void findXRefSymbols(FileDef *fd)
{
Expand Down Expand Up @@ -115,121 +118,133 @@ static bool ignoreStaticExternalCall(MemberDef *context, MemberDef *md) {
}
}

void printArgumentList(MemberDef* md) {
ArgumentList *argList = md->argumentList();
ArgumentListIterator iterator(*argList);

printf("(");
Argument * argument = iterator.toFirst();
if(argument != NULL) {
printf("%s", argument->type.data());
for(++iterator; (argument = iterator.current()) ;++iterator){
printf(",%s", argument->type.data());
}
}
printf(")");
static void printFile(std::string file) {
printf("%s:\n", file.c_str());
}

void printType(MemberDef* md) {
printf("%s ", md->memberTypeName().data());
static void printModule(std::string module) {
current_module = module;
printf(" %s:\n", module.c_str());
}

void printSignature(MemberDef* md) {
printf("%s", md->name().data());
if(md->isFunction()){
printArgumentList(md);
}
printf(" ");
static void printClassInformation(std::string information) {
printf(" informations: %s\n", information.c_str());
}

static void printWhereItWasDefined(MemberDef * md) {
if (md->getClassDef()) {
printf("defined in %s\n", md->getClassDef()->name().data());
}
else if (md->getFileDef()) {
printf("defined in %s\n", md->getFileDef()->getFileBase().data());
}
else {
printf("\n");
static void printInheritance(std::string base_class) {
printf(" inherits: %s\n", base_class.c_str());
}
static void printDefines() {
if (! modules[current_module]) {
printf(" defines:\n");
}
modules[current_module] = true;
}

static void printCStructMember(MemberDef * md) {
printType(md);
printf("%s::", md->getClassDef()->name().data());
printSignature(md);
printf("defined in %s\n", md->getClassDef()->getFileDef()->getFileBase().data());
static void printDefinition(std::string type, std::string signature, int line) {
printf(" - %s:\n", signature.c_str());
printf(" type: %s\n", type.c_str());
printf(" line: %d\n", line);
}
static void printProtection(std::string protection) {
printf(" protection: %s\n", protection.c_str());
}
static void printNumberOfLines(int lines) {
printf(" lines_of_code: %d\n", lines);
}
static void printNumberOfArguments(int arguments) {
printf(" parameters: %d\n", arguments);
}
static void printUses() {
printf(" uses:\n");
}
static void printReferenceTo(std::string type, std::string signature, std::string defined_in) {
printf(" - %s:\n", signature.c_str());
printf(" type: %s\n", type.c_str());
printf(" defined_in: %s\n", defined_in.c_str());
}

static int isPartOfCStruct(MemberDef * md) {
return is_c_code && md->getClassDef() != NULL;
}

static void printReferenceTo(MemberDef* md) {
printf(" uses ");
std::string functionSignature(MemberDef* md) {
std::string signature = md->name().data();
if(md->isFunction()){
ArgumentList *argList = md->argumentList();
ArgumentListIterator iterator(*argList);
signature += "(";
Argument * argument = iterator.toFirst();
if(argument != NULL) {
signature += argument->type.data();
for(++iterator; (argument = iterator.current()) ;++iterator){
signature += std::string(",") + argument->type.data();
}
}
signature += ")";
}
return signature;
}

static void referenceTo(MemberDef* md) {
std::string type = md->memberTypeName().data();
std::string defined_in = "";
std::string signature = "";
if (isPartOfCStruct(md)) {
printCStructMember(md);
signature = md->getClassDef()->name().data() + std::string("::") + functionSignature(md);
defined_in = md->getClassDef()->getFileDef()->getFileBase().data();
}
else {
printType(md);
printSignature(md);
printWhereItWasDefined(md);
signature = functionSignature(md);
if (md->getClassDef()) {
defined_in = md->getClassDef()->name().data();
}
else if (md->getFileDef()) {
defined_in = md->getFileDef()->getFileBase().data();
}
}
printReferenceTo(type, signature, defined_in);
}

static void printReferencesMembers(MemberDef *md) {
void cModule(ClassDef* cd) {
MemberList* ml = cd->getMemberList(MemberListType_variableMembers);
if (ml) {
MemberListIterator mli(*ml);
MemberDef* md;
for (mli.toFirst(); (md=mli.current()); ++mli) {
printDefinition("variable", cd->name().data() + std::string("::") + md->name().data(), md->getDefLine());
if (md->protection() == Public) {
printProtection("public");
}
}
}
}

void functionInformation(MemberDef* md) {
int size = md->getEndBodyLine() - md->getStartBodyLine() + 1;
printNumberOfLines(size);
ArgumentList *argList = md->argumentList();
printNumberOfArguments(argList->count());
MemberSDict *defDict = md->getReferencesMembers();
if (defDict) {
MemberSDict::Iterator msdi(*defDict);
MemberDef *rmd;
printUses();
for (msdi.toFirst(); (rmd=msdi.current()); ++msdi) {
if (rmd->definitionType() == Definition::TypeMember && !ignoreStaticExternalCall(md, rmd)) {
printReferenceTo(rmd);
referenceTo(rmd);
}
}
}
}

void printDefinitionLine(MemberDef* md) {
printf("in line %d\n", md->getDefLine());
}

void printDefinition(MemberDef* md) {
printf(" ");
printType(md);
printSignature(md);
printDefinitionLine(md);
}

static void printProtection(MemberDef* md) {
if (md->protection() == Public) {
printf(" protection public\n");
}
}

void printNumberOfLines(MemberDef* md) {
int size = md->getEndBodyLine() - md->getStartBodyLine() + 1;
printf(" %d lines of code\n", size);
}

void printNumberOfArguments(MemberDef* md) {
ArgumentList *argList = md->argumentList();
printf(" %d parameters\n", argList->count());
}

void printFunctionInformation(MemberDef* md) {
printNumberOfLines(md);
printNumberOfArguments(md);
printReferencesMembers(md);
}

static void lookupSymbol(Definition *d) {
if (d->definitionType() == Definition::TypeMember) {
MemberDef *md = (MemberDef *)d;
printDefinition(md);
printProtection(md);
std::string type = md->memberTypeName().data();
std::string signature = functionSignature(md);
printDefinition(type, signature, md->getDefLine());
if (md->protection() == Public) {
printProtection("protection public");
}
if (md->isFunction()) {
printFunctionInformation(md);
functionInformation(md);
}
}
}
Expand All @@ -238,35 +253,13 @@ void listMembers(MemberList *ml) {
if (ml) {
MemberListIterator mli(*ml);
MemberDef *md;
printDefines();
for (mli.toFirst(); (md=mli.current()); ++mli) {
lookupSymbol((Definition*) md);
}
}
}

static void printInheritance(ClassDef* cd) {
BaseClassList* baseClasses = cd->baseClasses();
if (baseClasses) {
BaseClassListIterator bci(*baseClasses);
BaseClassDef* bcd;
for (bci.toFirst(); (bcd = bci.current()); ++bci) {
printf(" inherits from %s\n", bcd->classDef->name().data());
}
}
}

void printCModule(ClassDef* cd) {
MemberList* ml = cd->getMemberList(MemberListType_variableMembers);
if (ml) {
MemberListIterator mli(*ml);
MemberDef* md;
for (mli.toFirst(); (md=mli.current()); ++mli) {
printf(" variable %s::%s in line %d\n", cd->name().data(), md->name().data(), md->getDefLine());
printProtection(md);
}
}
}

void listAllMembers(ClassDef* cd) {
// methods
listMembers(cd->getMemberList(MemberListType_functionMembers));
Expand All @@ -276,29 +269,23 @@ void listAllMembers(ClassDef* cd) {
listMembers(cd->getMemberList(MemberListType_variableMembers));
}

void printClassInformation(ClassDef* cd) {
printf("module %s\n", cd->name().data());
printInheritance(cd);
if(cd->isAbstract()) {
printf(" abstract class\n");
}
listAllMembers(cd);
}

static void printClass(ClassDef* cd) {
static void classInformation(ClassDef* cd) {
if (is_c_code) {
printCModule(cd);
cModule(cd);
} else {
printClassInformation(cd);
}
}

static void printFile(FileDef* fd) {
printf("file %s\n", fd->absFilePath().data());
MemberList *ml = fd->getMemberList(MemberListType_allMembersList);
if (ml && ml->count() > 0) {
printf("module %s\n", fd->getFileBase().data());
listMembers(ml);
printModule(cd->name().data());
BaseClassList* baseClasses = cd->baseClasses();
if (baseClasses) {
BaseClassListIterator bci(*baseClasses);
BaseClassDef* bcd;
for (bci.toFirst(); (bcd = bci.current()); ++bci) {
printInheritance(bcd->classDef->name().data());
}
}
if(cd->isAbstract()) {
printClassInformation("abstract class");
}
listAllMembers(cd);
}
}

Expand Down Expand Up @@ -339,14 +326,19 @@ static void listSymbols() {
FileNameIterator fni(*fn);
FileDef *fd;
for (; (fd=fni.current()); ++fni) {
printFile(fd);
printFile(fd->absFilePath().data());
MemberList *ml = fd->getMemberList(MemberListType_allMembersList);
if (ml && ml->count() > 0) {
printModule(fd->getFileBase().data());
listMembers(ml);
}

ClassSDict *classes = fd->getClassSDict();
if (classes) {
ClassSDict::Iterator cli(*classes);
ClassDef *cd;
for (cli.toFirst(); (cd = cli.current()); ++cli) {
printClass(cd);
classInformation(cd);
}
}
}
Expand Down

0 comments on commit 82dbb5f

Please sign in to comment.