1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
|
/******************************************************************************
*
* Copyright (C) 1997-2015 by Dimitri van Heesch.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation under the terms of the GNU General Public License is hereby
* granted. No representations are made about the suitability of this software
* for any purpose. It is provided "as is" without express or implied warranty.
* See the GNU General Public License for more details.
*
* Documents produced by Doxygen are derivative works derived from the
* input used in their production; they are not affected by this license.
*
*/
/** @file
* @brief Example of how to use doxygen as part of another GPL applications
*
* This example shows how to configure and run doxygen programmatically from
* within an application without generating the usual output.
* The example should work on any Unix like OS (including Linux and Mac OS X).
*
* This example shows how to use to code parser to get cross-references information
* and it also shows how to look up symbols in a program parsed by doxygen and
* show some information about them.
*/
#include <stdlib.h>
#include <qfile.h>
#include <qdir.h>
#include "doxygen.h"
#include "outputgen.h"
#include "parserintf.h"
#include "classdef.h"
#include "namespacedef.h"
#include "filedef.h"
#include "util.h"
#include "classlist.h"
#include "config.h"
#include "filename.h"
class XRefDummyCodeGenerator : public CodeOutputInterface
{
public:
XRefDummyCodeGenerator(FileDef *fd) : m_fd(fd) {}
~XRefDummyCodeGenerator() {}
// these are just null functions, they can be used to produce a syntax highlighted
// and cross-linked version of the source code, but who needs that anyway ;-)
void codify(const char *) {}
void writeCodeLink(const char *,const char *,const char *,const char *,const char *) {}
void writeLineNumber(const char *,const char *,const char *,int) {}
virtual void writeTooltip(const char *,const DocLinkInfo &,
const char *,const char *,const SourceLinkInfo &,
const SourceLinkInfo &) {}
void startCodeLine(bool) {}
void endCodeLine() {}
void startCodeAnchor(const char *) {}
void endCodeAnchor() {}
void startFontClass(const char *) {}
void endFontClass() {}
void writeCodeAnchor(const char *) {}
void setCurrentDoc(const Definition *,const char *,bool) {}
void addWord(const char *,bool) {}
// here we are presented with the symbols found by the code parser
void linkableSymbol(int l, const char *sym,Definition *symDef,Definition *context)
{
QCString ctx;
if (context) // the context of the symbol is known
{
if (context->definitionType()==Definition::TypeMember) // it is inside a member
{
Definition *parentContext = context->getOuterScope();
if (parentContext && parentContext->definitionType()==Definition::TypeClass)
// it is inside a member of a class
{
ctx.sprintf("inside %s %s of %s %s",
(dynamic_cast<MemberDef*>(context))->memberTypeName().data(),
context->name().data(),
(dynamic_cast<ClassDef*>(parentContext))->compoundTypeString().data(),
parentContext->name().data());
}
else if (parentContext==Doxygen::globalScope) // it is inside a global member
{
ctx.sprintf("inside %s %s",
(dynamic_cast<MemberDef*>(context))->memberTypeName().data(),
context->name().data());
}
}
if (ctx.isEmpty()) // it is something else (class, or namespace member, ...)
{
ctx.sprintf("in %s",context->name().data());
}
}
printf("Found symbol %s at line %d of %s %s\n",
sym,l,m_fd->getDefFileName().data(),ctx.data());
if (symDef && context) // in this case the definition of the symbol is
// known to doxygen.
{
printf("-> defined at line %d of %s\n",
symDef->getDefLine(),symDef->getDefFileName().data());
}
}
private:
FileDef *m_fd;
};
static void findXRefSymbols(FileDef *fd)
{
// get the interface to a parser that matches the file extension
ParserInterface *pIntf=Doxygen::parserManager->getParser(fd->getDefFileExtension());
// get the programming language from the file name
SrcLangExt lang = getLanguageFromFileName(fd->name());
// reset the parsers state
pIntf->resetCodeParserState();
// create a new backend object
XRefDummyCodeGenerator *xrefGen = new XRefDummyCodeGenerator(fd);
// parse the source code
pIntf->parseCode(*xrefGen,
0,
fileToString(fd->absFilePath()),
lang,
FALSE,
0,
fd);
// dismiss the object.
delete xrefGen;
}
static void listSymbol(Definition *d)
{
if (d!=Doxygen::globalScope && // skip the global namespace symbol
d->name().at(0)!='@' // skip anonymous stuff
)
{
printf("%s\n",
d->name().data());
}
}
static void listSymbols()
{
QDictIterator<DefinitionIntf> sli(*Doxygen::symbolMap);
DefinitionIntf *di;
for (sli.toFirst();(di=sli.current());++sli)
{
if (di->definitionType()==DefinitionIntf::TypeSymbolList) // list of symbols
// with same name
{
DefinitionListIterator dli(*(DefinitionList*)di);
Definition *d;
// for each symbol
for (dli.toFirst();(d=dli.current());++dli)
{
listSymbol(d);
}
}
else // single symbol
{
listSymbol((Definition*)di);
}
}
}
static void lookupSymbol(Definition *d)
{
if (d!=Doxygen::globalScope && // skip the global namespace symbol
d->name().at(0)!='@' // skip anonymous stuff
)
{
printf("Symbol info\n");
printf("-----------\n");
printf("Name: %s\n",d->name().data());
printf("File: %s\n",d->getDefFileName().data());
printf("Line: %d\n",d->getDefLine());
// depending on the definition type we can case to the appropriate
// derived to get additional information
switch (d->definitionType())
{
case Definition::TypeClass:
{
ClassDef *cd = dynamic_cast<ClassDef*>(d);
printf("Kind: %s\n",cd->compoundTypeString().data());
}
break;
case Definition::TypeFile:
{
FileDef *fd = dynamic_cast<FileDef*>(d);
printf("Kind: File: #includes %d other files\n",
fd->includeFileList() ? fd->includeFileList()->count() : 0);
}
break;
case Definition::TypeNamespace:
{
NamespaceDef *nd = dynamic_cast<NamespaceDef*>(d);
printf("Kind: Namespace: contains %d classes and %d namespaces\n",
nd->getClassSDict() ? nd->getClassSDict()->count() : 0,
nd->getNamespaceSDict() ? nd->getNamespaceSDict()->count() : 0);
}
break;
case Definition::TypeMember:
{
MemberDef *md = dynamic_cast<MemberDef*>(d);
printf("Kind: %s\n",md->memberTypeName().data());
}
break;
default:
// ignore groups/pages/packages/dirs for now
break;
}
}
}
static void lookupSymbols(const QCString &sym)
{
if (!sym.isEmpty())
{
DefinitionIntf *di = Doxygen::symbolMap->find(sym);
if (di)
{
if (di->definitionType()==DefinitionIntf::TypeSymbolList)
{
DefinitionListIterator dli(*(DefinitionList*)di);
Definition *d;
// for each symbol with the given name
for (dli.toFirst();(d=dli.current());++dli)
{
lookupSymbol(d);
}
}
else
{
lookupSymbol((Definition*)di);
}
}
else
{
printf("Unknown symbol\n");
}
}
}
int main(int argc,char **argv)
{
char cmd[256];
if (argc<2)
{
printf("Usage: %s [source_file | source_dir]\n",argv[0]);
exit(1);
}
// initialize data structures
initDoxygen();
// setup the non-default configuration options
Config::postProcess(FALSE);
ConfigValues::instance().init();
// we need a place to put intermediate files
Config_getString(OUTPUT_DIRECTORY)="/tmp/doxygen";
// disable html output
Config_getBool(GENERATE_HTML)=FALSE;
// disable latex output
Config_getBool(GENERATE_LATEX)=FALSE;
// be quiet
Config_getBool(QUIET)=TRUE;
// turn off warnings
Config_getBool(WARNINGS)=FALSE;
Config_getBool(WARN_IF_UNDOCUMENTED)=FALSE;
Config_getBool(WARN_IF_DOC_ERROR)=FALSE;
// Extract as much as possible
Config_getBool(EXTRACT_ALL)=TRUE;
Config_getBool(EXTRACT_STATIC)=TRUE;
Config_getBool(EXTRACT_PRIVATE)=TRUE;
Config_getBool(EXTRACT_LOCAL_METHODS)=TRUE;
// Extract source browse information, needed
// to make doxygen gather the cross reference info
Config_getBool(SOURCE_BROWSER)=TRUE;
// set the input
Config_getList(INPUT).clear();
Config_getList(INPUT).append(argv[1]);
// check and finialize the configuration
checkConfiguration();
adjustConfiguration();
// parse the files
parseInput();
// iterate over the input files
FileNameListIterator fnli(*Doxygen::inputNameList);
FileName *fn;
// foreach file with a certain name
for (fnli.toFirst();(fn=fnli.current());++fnli)
{
FileNameIterator fni(*fn);
FileDef *fd;
// for each file definition
for (;(fd=fni.current());++fni)
{
// get the references (linked and unlinked) found in this file
findXRefSymbols(fd);
}
}
// remove temporary files
if (!Doxygen::objDBFileName.isEmpty()) QFile::remove(Doxygen::objDBFileName);
if (!Doxygen::entryDBFileName.isEmpty()) QFile::remove(Doxygen::entryDBFileName);
// clean up after us
QDir().rmdir("/tmp/doxygen");
while (1)
{
printf("> Type a symbol name or\n> .list for a list of symbols or\n> .quit to exit\n> ");
fgets(cmd,256,stdin);
QCString s(cmd);
if (s.at(s.length()-1)=='\n') s=s.left(s.length()-1); // strip trailing \n
if (s==".list")
listSymbols();
else if (s==".quit")
exit(0);
else
lookupSymbols(s);
}
}
|