← Back to branch summary

~ubuntu-branches/ubuntu/karmic/rkward/karmic

« back to all changes in this revision

Viewing changes to admin/doxygen.sh

  • Committer: Bazaar Package Importer
  • Author(s): Thomas Friedrichsmeier
  • Date: 2006-11-06 16:30:00 UTC
  • mfrom: (1.2.1 upstream) (3.1.1 feisty)
  • Revision ID: james.westby@ubuntu.com-20061106163000-qi8ju75eqecrfay7
* new upstream release
* depend on either php4-cli or php5-cli

Show diffs side-by-side

added added

removed removed

Lines of Context:
admin/doxygen.sh
 
1
#! /bin/sh
 
2
#
 
3
# doxygen.sh Copyright (C) 2005 by Adriaan de Groot
 
4
#            Based on some code from Doxyfile.am, among other things.
 
5
# License:   GPL version 2.
 
6
#            See file COPYING in kdelibs for details.
 
7
 
 
8
echo "*** doxygen.sh"
 
9
 
 
10
# Recurse handling is a little complicated, since normally
 
11
# subdir (given on the command-line) processing doesn't recurse
 
12
# but you can force it to do so.
 
13
recurse=1
 
14
recurse_given=NO
 
15
use_modulename=1
 
16
cleanup=YES
 
17
 
 
18
while test -n "$1" ; do
 
19
case "x$1" in
 
20
"x--no-cleanup" )
 
21
        cleanup=NO
 
22
        ;;
 
23
"x--no-recurse" )
 
24
        recurse=0
 
25
        recurse_given=YES
 
26
        ;;
 
27
"x--recurse" )
 
28
        recurse=1
 
29
        recurse_given=YES
 
30
        ;;
 
31
"x--no-modulename" )
 
32
        use_modulename=0
 
33
        ;;
 
34
"x--modulename" )
 
35
        use_modulename=1
 
36
        ;;
 
37
"x--help" )
 
38
        echo "doxygen.sh usage:"
 
39
        echo "doxygen.sh [--no-recurse] [--no-modulename] <srcdir> [<subdir>]"
 
40
        exit 2
 
41
        ;;
 
42
x--doxdatadir=* )
 
43
        DOXDATA=`echo $1 | sed -e 's+--doxdatadir=++'`
 
44
        ;;
 
45
x--installdir=*)
 
46
        PREFIX=`echo $1 | sed -e 's+--installdir=++'`
 
47
        ;;
 
48
x--* )
 
49
        echo "Unknown option: $1"
 
50
        exit 1
 
51
        ;;
 
52
* )
 
53
        top_srcdir="$1"
 
54
        break
 
55
        ;;
 
56
esac
 
57
shift
 
58
done
 
59
 
 
60
 
 
61
### Sanity check the mandatory "top srcdir" argument.
 
62
if test -z "$top_srcdir" ; then
 
63
        echo "Usage: doxygen.sh <top_srcdir>"
 
64
        exit 1
 
65
fi
 
66
if test ! -d "$top_srcdir" ; then
 
67
        echo "top_srcdir ($top_srcdir) is not a directory."
 
68
        exit 1
 
69
fi
 
70
 
 
71
### Normalize top_srcdir so it is an absolute path.
 
72
if expr "x$top_srcdir" : "x/" > /dev/null ; then
 
73
        # top_srcdir is absolute already
 
74
        :
 
75
else
 
76
        top_srcdir=`cd "$top_srcdir" 2> /dev/null && pwd`
 
77
        if test ! -d "$top_srcdir" ; then
 
78
                echo "top_srcdir ($top_srcdir) is not a directory."
 
79
                exit 1
 
80
        fi
 
81
fi
 
82
 
 
83
 
 
84
 
 
85
### Sanity check and guess QTDOCDIR.
 
86
if test -z "$QTDOCDIR" ; then
 
87
        if test -z "$QTDIR" ; then
 
88
                for i in /usr/X11R6/share/doc/qt/html
 
89
                do
 
90
                        QTDOCDIR="$i"
 
91
                        test -d "$QTDOCDIR" && break
 
92
                done
 
93
        else
 
94
                for i in share/doc/qt/html doc/html
 
95
                do
 
96
                        QTDOCDIR="$QTDIR/$i"
 
97
                        test -d "$QTDOCDIR" && break
 
98
                done
 
99
        fi
 
100
fi
 
101
if test -z "$QTDOCDIR"  || test ! -d "$QTDOCDIR" ; then
 
102
        if test -z "$QTDOCDIR" ; then
 
103
                echo "* QTDOCDIR could not be guessed."
 
104
        else
 
105
                echo "* QTDOCDIR does not name a directory."
 
106
        fi
 
107
        if test -z "$QTDOCTAG" ; then
 
108
                echo "* QTDOCDIR set to \"\""
 
109
                QTDOCDIR=""
 
110
        else
 
111
                echo "* But I'll use $QTDOCDIR anyway because of QTDOCTAG."
 
112
        fi
 
113
fi
 
114
 
 
115
### Get the "top srcdir", also its name, and handle the case that subdir "."
 
116
### is given (which would be top_srcdir then, so it's equal to none-given
 
117
### but no recursion either).
 
118
###
 
119
# top_srcdir="$1" # Already set by options processing
 
120
module_name=`basename "$top_srcdir"`
 
121
subdir="$2"
 
122
if test "x." = "x$subdir" ; then
 
123
        subdir=""
 
124
        if test "x$recurse_given" = "xNO" ; then
 
125
                recurse=0
 
126
        fi
 
127
fi
 
128
if test "x" != "x$subdir" ; then
 
129
        # If no recurse option given explicitly, default to
 
130
        # no recurse when processing subdirs given on the command-line.
 
131
        if test "x$recurse_given" = "xNO" ; then
 
132
                recurse=0
 
133
        fi
 
134
fi
 
135
 
 
136
if test -z "$DOXDATA" || test ! -d "$DOXDATA" ; then
 
137
        if test -n "$DOXDATA" ; then
 
138
                echo "* \$DOXDATA is '$DOXDATA' which does not name a directory"
 
139
        fi
 
140
        DOXDATA="$top_srcdir/doc/common"
 
141
fi
 
142
 
 
143
if test ! -d "$DOXDATA" ; then
 
144
        echo "* \$DOXDATA does not name a directory ( or is unset ), tried \"$DOXDATA\""
 
145
        exit 1
 
146
fi
 
147
 
 
148
if test -n "$PREFIX" && test ! -d "$PREFIX" ; then
 
149
        echo "* \$PREFIX does not name a directory, tried \"$PREFIX\""
 
150
        echo "* \$PREFIX is disabled."
 
151
        PREFIX=""
 
152
fi
 
153
 
 
154
### We need some values from top-level files, which
 
155
### are not preserved between invocations of this
 
156
### script, so factor it out for easy use.
 
157
create_doxyfile_in() 
 
158
{
 
159
        eval `grep 'VERSION="' "$top_srcdir/admin/cvs.sh"`
 
160
        echo "PROJECT_NUMBER = $VERSION" > Doxyfile.in
 
161
        grep '^KDE_INIT_DOXYGEN' "$top_srcdir/configure.in.in" | \
 
162
                sed -e 's+[^[]*\[\([^]]*\)+PROJECT_NAME = "\1"+' \
 
163
                        -e 's+].*++' >> Doxyfile.in
 
164
}
 
165
 
 
166
apidoxdir="$module_name"-apidocs
 
167
test "x$use_modulename" = "x0" && apidoxdir="apidocs"
 
168
 
 
169
### If we're making the top subdir, create the structure
 
170
### for the apidox and initialize it. Otherwise, just use the
 
171
### structure assumed to be there.
 
172
if test -z "$subdir" ; then
 
173
        if test ! -d "$apidoxdir" ; then
 
174
                mkdir "$apidoxdir" > /dev/null 2>&1
 
175
        fi
 
176
        cd "$apidoxdir" > /dev/null 2>&1 || { 
 
177
                echo "Cannot create and cd into $apidoxdir"
 
178
                exit 1
 
179
        }
 
180
 
 
181
        test -f "Doxyfile.in" || create_doxyfile_in
 
182
 
 
183
        # Copy in logos and the like
 
184
        for i in "favicon.ico" "kde_gear_64.png"
 
185
        do
 
186
                cp "$DOXDATA/$i" . > /dev/null 2> /dev/null
 
187
        done
 
188
        for i in "$top_srcdir/doc/api/Dox-"*.png
 
189
        do
 
190
                T=`basename "$i" | sed -e 's+Dox-++'`
 
191
                test -f "$i" && cp "$i" "./$T" > /dev/null 2> /dev/null
 
192
        done
 
193
 
 
194
        top_builddir="."
 
195
        srcdir="$1"
 
196
        subdir="."
 
197
else
 
198
        cd "$apidoxdir" > /dev/null 2>&1 || {
 
199
                echo "Cannot cd into $apidoxdir -- maybe you need to"
 
200
                echo "build the top-level dox first."
 
201
                exit 1
 
202
        }
 
203
 
 
204
        if test "x1" = "x$recurse" ; then
 
205
                # OK, so --recurse was requested
 
206
                if test ! -f "subdirs.top" ; then
 
207
                        echo "* No subdirs.top available in the $apidoxdir."
 
208
                        echo "* The --recurse option will be ignored."
 
209
                        recurse=0
 
210
                fi
 
211
        fi
 
212
fi
 
213
 
 
214
### Read a single line (TODO: support \ continuations) from the Makefile.am.
 
215
### Used to extract variable assignments from it.
 
216
extract_line()
 
217
{
 
218
        file="$2" ; test -z "$file" && file="$srcdir/Makefile.am"
 
219
        pattern=`echo "$1" | tr + .`
 
220
        grep "^$1" "$file" | \
 
221
                sed -e "s+$pattern.*=\s*++"
 
222
}
 
223
 
 
224
### Handle the COMPILE_{FIRST,LAST,BEFORE,AFTER} part of Makefile.am
 
225
### in the toplevel. Copied from admin/cvs.sh. Licence presumed LGPL).
 
226
create_subdirs()
 
227
{
 
228
echo "* Sorting top-level subdirs"
 
229
dirs=
 
230
idirs=
 
231
if test -f "$top_srcdir/inst-apps"; then
 
232
   idirs=`cat "$top_srcdir/"inst-apps`
 
233
else
 
234
   idirs=`cd "$top_srcdir" && ls -1 | sort`
 
235
fi
 
236
 
 
237
compilefirst=""
 
238
compilelast=""
 
239
if test -f "$top_srcdir/"Makefile.am.in ; then
 
240
        compilefirst=`sed -ne 's#^COMPILE_FIRST[ ]*=[ ]*##p' "$top_srcdir/"Makefile.am.in | head -n 1`
 
241
        compilelast=`sed -ne 's#^COMPILE_LAST[ ]*=[ ]*##p' "$top_srcdir/"Makefile.am.in | head -n 1`
 
242
fi
 
243
for i in $idirs; do
 
244
    if test -f "$top_srcdir/$i"/Makefile.am; then
 
245
       case " $compilefirst $compilelast " in
 
246
         *" $i "*) ;;
 
247
         *) dirs="$dirs $i"
 
248
       esac
 
249
    fi
 
250
done
 
251
 
 
252
: > ./_SUBDIRS
 
253
 
 
254
for d in $compilefirst; do
 
255
   echo $d >> ./_SUBDIRS
 
256
done
 
257
 
 
258
(for d in $dirs; do
 
259
   list=""
 
260
   if test -f "$top_srcdir/"Makefile.am.in ; then
 
261
           list=`sed -ne "s#^COMPILE_BEFORE_$d""[ ]*=[ ]*##p" "$top_srcdir/"Makefile.am.in | head -n 1`
 
262
   fi
 
263
   for s in $list; do
 
264
      echo $s $d
 
265
   done
 
266
   list=""
 
267
   if test -f "$top_srcdir/"Makefile.am.in ; then
 
268
           list=`sed -ne "s#^COMPILE_AFTER_$d""[ ]*=[ ]*##p" "$top_srcdir/"Makefile.am.in | head -n 1`
 
269
   fi
 
270
   for s in $list; do
 
271
      echo $d $s
 
272
   done
 
273
   echo $d $d
 
274
done ) | tsort >> ./_SUBDIRS
 
275
 
 
276
for d in $compilelast; do
 
277
   echo $d >> ./_SUBDIRS
 
278
done
 
279
 
 
280
test -r _SUBDIRS && mv _SUBDIRS subdirs.top || true
 
281
}
 
282
 
 
283
 
 
284
### Add HTML header, footer, CSS tags to Doxyfile.
 
285
### Assumes $subdir is set. Argument is a string
 
286
### to stick in front of the file if needed.
 
287
apidox_htmlfiles()
 
288
{
 
289
        dox_header="$top_srcdir/doc/api/$1header.html"
 
290
        dox_footer="$top_srcdir/doc/api/$1footer.html"
 
291
        dox_css="$top_srcdir/doc/api/doxygen.css"
 
292
        test -f "$dox_header" || dox_header="$DOXDATA/$1header.html"
 
293
        test -f "$dox_footer" || dox_footer="$DOXDATA/$1footer.html"
 
294
        test -f "$dox_css" || dox_css="$DOXDATA/doxygen.css"
 
295
 
 
296
        echo "HTML_HEADER            = $dox_header" >> "$subdir/Doxyfile" ; \
 
297
        echo "HTML_FOOTER            = $dox_footer" >> "$subdir/Doxyfile" ; \
 
298
        echo "HTML_STYLESHEET        = $dox_css" >> "$subdir/Doxyfile"
 
299
}
 
300
 
 
301
apidox_specials()
 
302
{
 
303
        line=`extract_line DOXYGEN_PROJECTNAME "$1"`
 
304
        test -n "$line" && echo "PROJECT_NAME = \"$line\"" >> "$2"
 
305
}
 
306
 
 
307
apidox_local()
 
308
{
 
309
        for i in "$top_srcdir/doc/api/Doxyfile.local"
 
310
        do
 
311
                if test -f "$i" ; then
 
312
                        cat "$i" >> "$subdir/Doxyfile"
 
313
                        break
 
314
                fi
 
315
        done
 
316
}
 
317
 
 
318
### Post-process HTML files by substituting in the menu files
 
319
#
 
320
# In non-top directories, both <!-- menu --> and <!-- gmenu -->
 
321
# are calculated and replaced. Top directories get an empty <!-- menu -->
 
322
# if any.
 
323
doxyndex()
 
324
{
 
325
        # Special case top-level to have an empty MENU.
 
326
        if test "x$subdir" = "x." ; then
 
327
                MENU=""
 
328
                htmldir="."
 
329
                htmltop="$top_builddir" # Just ., presumably
 
330
                echo "* Post-processing top-level files"
 
331
        else
 
332
                MENU="<ul>"
 
333
                htmldir="$subdir/html"
 
334
                htmltop="$top_builddir.." # top_builddir ends with /
 
335
                echo "* Post-processing files in $htmldir"
 
336
 
 
337
                # Build a little PHP file that maps class names to file
 
338
                # names, for the quick-class-picker functionality.
 
339
                # (The quick-class-picker is disabled due to styling
 
340
                # problems in IE & FF).
 
341
                (
 
342
                echo "<?php \$map = array(";  \
 
343
                for htmlfile in `find $htmldir/ -type f -name "class[A-Z]*.html" | grep -v "\-members.html$"`; do
 
344
                        classname=`echo $htmlfile | sed -e "s,.*/class\\(.*\\).html,\1," -e "s,_1_1,::,g" -e "s,_01, ,g" -e "s,_4,>,g" -e "s+_00+,+g" -e "s+_3+<+g" | tr "[A-Z]" "[a-z]"`
 
345
                        echo "  \"$classname\" => \"$htmlfile\","
 
346
                done | sort ; \
 
347
                echo ") ?>"
 
348
                ) > "$subdir/classmap.inc"
 
349
 
 
350
                # This is a list of pairs, with / separators so we can use
 
351
                # basename and dirname (a crude shell hack) to split them
 
352
                # into parts. For each, if the file part exists (as a html
 
353
                # file) tack it onto the MENU variable as a <li> with link.
 
354
                for i in "Main Page/index" \
 
355
                        "Modules/modules" \
 
356
                        "Namespace List/namespaces" \
 
357
                        "Class Hierarchy/hierarchy" \
 
358
                        "Alphabetical List/classes" \
 
359
                        "Class List/annotated" \
 
360
                        "File List/files" \
 
361
                        "Directories/dirs" \
 
362
                        "Namespace Members/namespacemembers" \
 
363
                        "Class Members/functions" \
 
364
                        "Related Pages/pages"
 
365
                do
 
366
                        NAME=`dirname "$i"`
 
367
                        FILE=`basename "$i"`
 
368
                        test -f "$htmldir/$FILE.html" && MENU="$MENU<li><a href=\"$FILE.html\">$NAME</a></li>"
 
369
                done
 
370
 
 
371
                MENU="$MENU</ul>"
 
372
        fi
 
373
 
 
374
 
 
375
        # Get the list of global Menu entries.
 
376
        GMENU=`cat subdirs | tr -d '\n'`
 
377
 
 
378
        PMENU=`grep '<!-- pmenu' "$htmldir/index.html" | sed -e 's+.*pmenu *++' -e 's+ *-->++' | awk '{ c=split($0,a,"/"); for (j=1; j<=c; j++) { printf " / <a href=\""; if (j==c) { printf("."); } for (k=j; k<c; k++) { printf "../"; } if (j<c) { printf("../html/index.html"); } printf "\">%s</a>\n" , a[j]; } }' | tr -d '\n'`
 
379
 
 
380
        # Map the PHP file into HTML options so that
 
381
        # it can be substituted in for the quick-class-picker.
 
382
        CMENU=""
 
383
        # For now, leave the CMENU disabled
 
384
        CMENUBEGIN="<!--"
 
385
        CMENUEND="-->"
 
386
 
 
387
        if test "x$subdir" = "x." ; then
 
388
                # Disable CMENU on toplevel anyway
 
389
                CMENUBEGIN="<!--"
 
390
                CMENUEND="-->"
 
391
        else
 
392
                test -f "$subdir/classmap.inc" && \
 
393
                CMENU=`grep '=>' "$subdir/classmap.inc" | sed -e 's+"\([^"]*\)" => "'"$subdir/html/"'\([^"]*\)"+<option value="\2">\1<\/option>+' | tr -d '\n'`
 
394
 
 
395
                if test -f "$subdir/classmap.inc" && grep "=>" "$subdir/classmap.inc" > /dev/null 2>&1 ; then
 
396
                        # Keep the menu, it's useful
 
397
                        :
 
398
                else
 
399
                        CMENUBEGIN="<!--"
 
400
                        CMENUEND="-->"
 
401
                fi
 
402
        fi
 
403
 
 
404
        # Now substitute in the MENU in every file. This depends
 
405
        # on HTML_HEADER (ie. header.html) containing the
 
406
        # <!-- menu --> comment.
 
407
        for i in "$htmldir"/*.html
 
408
        do
 
409
                if test -f "$i" ; then
 
410
                        sed -e "s+<!-- menu -->+$MENU+" \
 
411
                                -e "s+<!-- gmenu -->+$GMENU+" \
 
412
                                -e "s+<!-- pmenu.*-->+$PMENU+" \
 
413
                                -e "s+<!-- cmenu.begin -->+$CMENUBEGIN+" \
 
414
                                -e "s+<!-- cmenu.end -->+$CMENUEND+" \
 
415
                                < "$i"  | sed -e "s+@topdir@+$htmltop+g" > "$i.new" && mv "$i.new" "$i"
 
416
                        sed -e "s+<!-- cmenu -->+$CMENU+" < "$i" > "$i.new"
 
417
                        test -s "$i.new" && mv "$i.new" "$i"
 
418
                fi
 
419
        done
 
420
}
 
421
 
 
422
 
 
423
 
 
424
 
 
425
 
 
426
 
 
427
### Handle the Doxygen processing of a toplevel directory.
 
428
apidox_toplevel()
 
429
{
 
430
        echo ""
 
431
        echo "*** Creating API documentation main page for $module_name"
 
432
        echo "*"
 
433
        rm -f "Doxyfile"
 
434
        for i in "$top_srcdir/doc/api/Doxyfile.global" \
 
435
                "$top_srcdir/admin/Doxyfile.global" \
 
436
                "$DOXDATA/Doxyfile.global"
 
437
        do
 
438
                if test -f "$i" ; then
 
439
                        cp "$i" Doxyfile
 
440
                        break
 
441
                fi
 
442
        done
 
443
 
 
444
        if test ! -f "Doxyfile" ; then
 
445
                echo "* Cannot create Doxyfile."
 
446
                exit 1
 
447
        fi
 
448
 
 
449
        cat "$top_builddir/Doxyfile.in" >> Doxyfile
 
450
 
 
451
 
 
452
        echo "INPUT                  = $top_srcdir" >> Doxyfile
 
453
        echo "OUTPUT_DIRECTORY       = $top_builddir" >> Doxyfile ; \
 
454
        echo "FILE_PATTERNS          = *.dox" >> Doxyfile ; \
 
455
        echo "RECURSIVE              = NO" >> Doxyfile ; \
 
456
        echo "ALPHABETICAL_INDEX     = NO" >> Doxyfile ; \
 
457
        echo "HTML_OUTPUT            = ." >> Doxyfile ; \
 
458
        apidox_htmlfiles "main"
 
459
 
 
460
        # KDevelop has a top-level Makefile.am with settings.
 
461
        for i in "$top_srcdir/Makefile.am.in" "$top_srcdir/Makefile.am"
 
462
        do
 
463
                if test -f "$i" ; then
 
464
                        grep '^DOXYGEN_SET_' "$i" | \
 
465
                                sed -e 's+DOXYGEN_SET_++' -e "s+@topdir@+$top_srcdir+" >> Doxyfile
 
466
                        apidox_specials "$srcdir/Makefile.am" "$subdir/Doxyfile"
 
467
 
 
468
                        break
 
469
                fi
 
470
        done
 
471
 
 
472
        apidox_local
 
473
 
 
474
        doxygen Doxyfile
 
475
 
 
476
        ( cd "$top_srcdir" && grep -l '^include.*Doxyfile.am' `find . -name Makefile.am` ) | sed -e 's+/Makefile.am$++' -e 's+^\./++' | sort > subdirs.in
 
477
        for i in `cat subdirs.in`
 
478
        do
 
479
                test "x." = "x$i" && continue;
 
480
 
 
481
                dir=`dirname "$i"`
 
482
                file=`basename "$i"`
 
483
                if test "x." = "x$dir" ; then
 
484
                        dir=""
 
485
                else
 
486
                        dir="$dir/"
 
487
                fi
 
488
                indent=`echo "$dir" | sed -e 's+[^/]*/+\&nbsp;\&nbsp;+g' | sed -e 's+&+\\\&+g'`
 
489
                entryname=`extract_line DOXYGEN_SET_PROJECT_NAME "$top_srcdir/$dir/$file/Makefile.am"`
 
490
                test -z "$entryname" && entryname="$file"
 
491
 
 
492
                if grep DOXYGEN_EMPTY "$top_srcdir/$dir/$file/Makefile.am" > /dev/null 2>&1 ; then
 
493
                        echo "<li>$indent$file</li>"
 
494
                else
 
495
                        echo "<li>$indent<a href=\"@topdir@/$dir$file/html/index.html\">$entryname</a></li>"
 
496
                fi
 
497
        done > subdirs
 
498
 
 
499
        doxyndex
 
500
}
 
501
 
 
502
### Handle the Doxygen processing of a non-toplevel directory.
 
503
apidox_subdir()
 
504
{
 
505
        echo ""
 
506
        echo "*** Creating apidox in $subdir"
 
507
        echo "*"
 
508
        rm -f "$subdir/Doxyfile"
 
509
        if test ! -d "$top_srcdir/$subdir" ; then
 
510
                echo "* No source (sub)directory $subdir"
 
511
                return
 
512
        fi
 
513
        for i in "$top_srcdir/doc/api/Doxyfile.global" \
 
514
                "$top_srcdir/admin/Doxyfile.global" \
 
515
                "$DOXDATA/Doxyfile.global"
 
516
        do
 
517
                if test -f "$i" ; then
 
518
                        cp "$i" "$subdir/Doxyfile"
 
519
                        break
 
520
                fi
 
521
        done
 
522
 
 
523
 
 
524
        test -f "Doxyfile.in" || create_doxyfile_in
 
525
        cat "Doxyfile.in" >> "$subdir/Doxyfile"
 
526
 
 
527
        echo "PROJECT_NAME           = \"$subdir\"" >> "$subdir/Doxyfile"
 
528
        echo "INPUT                  = $srcdir" >> "$subdir/Doxyfile"
 
529
        echo "OUTPUT_DIRECTORY       = ." >> "$subdir/Doxyfile"
 
530
        if grep -l "$subdir/" subdirs.in > /dev/null 2>&1 ; then
 
531
                echo "RECURSIVE              = NO" >> "$subdir/Doxyfile"
 
532
        fi
 
533
        echo "HTML_OUTPUT            = $subdir/html" >> "$subdir/Doxyfile"
 
534
        echo "GENERATE_TAGFILE       = $subdir/$subdirname.tag" >> "$subdir/Doxyfile"
 
535
        test -d "$top_srcdir/doc/api" && \
 
536
                echo "IMAGE_PATH             = $top_srcdir/doc/api" >> "$subdir/Doxyfile"
 
537
 
 
538
        apidox_htmlfiles ""
 
539
 
 
540
        # Makefile.ams may contain overrides to our settings,
 
541
        # so copy them in.
 
542
        grep '^DOXYGEN_SET_' "$srcdir/Makefile.am" | \
 
543
                sed -e 's+DOXYGEN_SET_++' >> "$subdir/Doxyfile"
 
544
        apidox_specials "$srcdir/Makefile.am" "$subdir/Doxyfile"
 
545
 
 
546
        excludes=`extract_line DOXYGEN_EXCLUDE`
 
547
        if test -n "$excludes"; then
 
548
                patterns=""
 
549
                dirs=""
 
550
                for item in `echo "$excludes"`; do
 
551
                        if test -d "$top_srcdir/$subdir/$item"; then
 
552
                                dirs="$dirs $top_srcdir/$subdir/$item/"
 
553
                        else
 
554
                                patterns="$patterns $item"
 
555
                        fi
 
556
                done
 
557
                echo "EXCLUDE_PATTERNS      += $patterns" >> "$subdir/Doxyfile"
 
558
                echo "EXCLUDE               += $dirs" >> "$subdir/Doxyfile"
 
559
        fi
 
560
 
 
561
        echo "TAGFILES = \\" >> "$subdir/Doxyfile"
 
562
        ## For now, don't support \ continued references lines
 
563
        tags=`extract_line DOXYGEN_REFERENCES`
 
564
        for i in $tags qt ; do
 
565
                tagsubdir=`dirname $i` ; tag=`basename $i`
 
566
                tagpath=""
 
567
                not_found=""
 
568
 
 
569
                if test "x$tagsubdir" = "x." ; then
 
570
                        tagsubdir=""
 
571
                else
 
572
                        tagsubdir="$tagsubdir/"
 
573
                fi
 
574
 
 
575
                # Find location of tag file
 
576
                if test -f "$tagsubdir$tag/$tag.tag" ; then
 
577
                        file="$tagsubdir$tag/$tag.tag"
 
578
                        loc="$tagsubdir$tag/html"
 
579
                else
 
580
                        # This checks for dox built with_out_ --no-modulename
 
581
                        # in the same build dir as this dox run was started in.
 
582
                        file=`ls -1 ../*-apidocs/"$tagsubdir$tag/$tag.tag" 2> /dev/null`
 
583
 
 
584
                        if test -n "$file" ; then
 
585
                                loc=`echo "$file" | sed -e "s/$tag.tag\$/html/"`
 
586
                        else
 
587
                                # If the tag file doesn't exist yet, but should
 
588
                                # because we have the right dirs here, queue
 
589
                                # this directory for re-processing later.
 
590
                                if test -d "$top_srcdir/$tagsubdir$tag" ; then
 
591
                                        echo "* Need to re-process $subdir for tag $i"
 
592
                                        echo "$subdir" >> "subdirs.later"
 
593
                                else
 
594
                                        # Re-check in $PREFIX if needed.
 
595
                                        test -n "$PREFIX" && \
 
596
                                        file=`cd "$PREFIX" && \
 
597
                                        ls -1 *-apidocs/"$tagsubdir$tag/$tag.tag" 2> /dev/null`
 
598
 
 
599
                                        # If something is found, patch it up. The location must be
 
600
                                        # relative to the installed location of the dox and the
 
601
                                        # file must be absolute.
 
602
                                        if test -n "$file" ; then
 
603
                                                loc=`echo "../$file" | sed -e "s/$tag.tag\$/html/"`
 
604
                                                file="$PREFIX/$file"
 
605
                                                echo "* Tags for $tagsubdir$tag will only work when installed."
 
606
                                                not_found="YES"
 
607
                                        fi
 
608
                                fi
 
609
                        fi
 
610
                fi
 
611
                if test "$tag" = "qt" ; then
 
612
                        if test -z "$QTDOCDIR" ; then
 
613
                                echo "  $file" >> "$subdir/Doxyfile"
 
614
                        else
 
615
                                if test -z "$file" ; then
 
616
                                        # Really no Qt tags
 
617
                                        echo "" >> "$subdir/Doxyfile"
 
618
                                else
 
619
                                        echo "  $file=$QTDOCDIR" >> "$subdir/Doxyfile"
 
620
                                fi
 
621
                        fi
 
622
                else
 
623
                        if test -n "$file"  ; then
 
624
                                test -z "$not_found" && echo "* Found tag $file"
 
625
                                echo "  $file=../$top_builddir$loc \\" >> "$subdir/Doxyfile"
 
626
                        fi
 
627
                fi
 
628
        done
 
629
 
 
630
        apidox_local
 
631
 
 
632
        if grep '^DOXYGEN_EMPTY' "$srcdir/Makefile.am" > /dev/null 2>&1 ; then
 
633
                # This directory is empty, so don't process it, but
 
634
                # *do* handle subdirs that might have dox.
 
635
                :
 
636
        else
 
637
                # Regular processing
 
638
                doxygen "$subdir/Doxyfile"
 
639
                doxyndex
 
640
        fi
 
641
}
 
642
 
 
643
### Run a given subdir by setting up global variables first.
 
644
do_subdir()
 
645
{
 
646
        subdir=`echo "$1" | sed -e 's+/$++'`
 
647
        srcdir="$top_srcdir/$subdir"
 
648
        subdirname=`basename "$subdir"`
 
649
        mkdir -p "$subdir" 2> /dev/null
 
650
        if test ! -d "$subdir" ; then
 
651
                echo "Can't create dox subdirectory $subdir"
 
652
                return
 
653
        fi
 
654
        top_builddir=`echo "/$subdir" | sed -e 's+/[^/]*+../+g'`
 
655
        apidox_subdir
 
656
}
 
657
 
 
658
 
 
659
### Create installdox-slow in the toplevel
 
660
create_installdox()
 
661
{
 
662
# Fix up the installdox script so it accepts empty args
 
663
#
 
664
# This code is copied from the installdox generated by Doxygen,
 
665
# copyright by Dimitri van Heesch and released under the GPL.
 
666
# This does a _slow_ update of the dox, because it loops
 
667
# over the given substitutions instead of assuming all the
 
668
# needed ones are given.
 
669
#
 
670
cat <<\EOF
 
671
#! /usr/bin/env perl
 
672
 
 
673
%subst = () ;
 
674
$quiet   = 0;
 
675
 
 
676
if (open(F,"search.cfg"))
 
677
{
 
678
  $_=<F> ; s/[ \t\n]*$//g ; $subst{"_doc"} = $_;
 
679
  $_=<F> ; s/[ \t\n]*$//g ; $subst{"_cgi"} = $_;
 
680
}
 
681
 
 
682
while ( @ARGV ) {
 
683
  $_ = shift @ARGV;
 
684
  if ( s/^-// ) {
 
685
    if ( /^l(.*)/ ) {
 
686
      $v = ($1 eq "") ? shift @ARGV : $1;
 
687
      ($v =~ /\/$/) || ($v .= "/");
 
688
      $_ = $v;
 
689
      if ( /(.+)\@(.+)/ ) {
 
690
          $subst{$1} = $2;
 
691
      } else {
 
692
        print STDERR "Argument $_ is invalid for option -l\n";
 
693
        &usage();
 
694
      }
 
695
    }
 
696
    elsif ( /^q/ ) {
 
697
      $quiet = 1;
 
698
    }
 
699
    elsif ( /^\?|^h/ ) {
 
700
      &usage();
 
701
    }
 
702
    else {
 
703
      print STDERR "Illegal option -$_\n";
 
704
      &usage();
 
705
    }
 
706
  }
 
707
  else {
 
708
    push (@files, $_ );
 
709
  }
 
710
}
 
711
 
 
712
 
 
713
if ( ! @files ) {
 
714
  if (opendir(D,".")) {
 
715
    foreach $file ( readdir(D) ) {
 
716
      $match = ".html";
 
717
      next if ( $file =~ /^\.\.?$/ );
 
718
      ($file =~ /$match/) && (push @files, $file);
 
719
      ($file =~ "tree.js") && (push @files, $file);
 
720
    }
 
721
    closedir(D);
 
722
  }
 
723
}
 
724
 
 
725
if ( ! @files ) {
 
726
  print STDERR "Warning: No input files given and none found!\n";
 
727
}
 
728
 
 
729
foreach $f (@files)
 
730
{
 
731
  if ( ! $quiet ) {
 
732
    print "Editing: $f...\n";
 
733
  }
 
734
  $oldf = $f;
 
735
  $f   .= ".bak";
 
736
  unless (rename $oldf,$f) {
 
737
    print STDERR "Error: cannot rename file $oldf\n";
 
738
    exit 1;
 
739
  }
 
740
  if (open(F,"<$f")) {
 
741
    unless (open(G,">$oldf")) {
 
742
      print STDERR "Error: opening file $oldf for writing\n";
 
743
      exit 1;
 
744
    }
 
745
    if ($oldf ne "tree.js") {
 
746
      while (<F>) {
 
747
        foreach $sub (keys %subst) {
 
748
          s/doxygen\=\"$sub\:([^ \"\t\>\<]*)\" (href|src)=\"\1/doxygen\=\"$sub:$subst{$sub}\" \2=\"$subst{$sub}/g;
 
749
          print G "$_";
 
750
        }
 
751
      }
 
752
    }
 
753
    else {
 
754
      while (<F>) {
 
755
        foreach $sub (keys %subst) {
 
756
          s/\"$sub\:([^ \"\t\>\<]*)\", \"\1/\"$sub:$subst{$sub}\" ,\"$subst{$sub}/g;
 
757
          print G "$_";
 
758
        }
 
759
      }
 
760
    }
 
761
  }
 
762
  else {
 
763
    print STDERR "Warning file $f does not exist\n";
 
764
  }
 
765
  unlink $f;
 
766
}
 
767
 
 
768
sub usage {
 
769
  print STDERR "Usage: installdox [options] [html-file [html-file ...]]\n";
 
770
  print STDERR "Options:\n";
 
771
  print STDERR "     -l tagfile\@linkName   tag file + URL or directory \n";
 
772
  print STDERR "     -q                    Quiet mode\n\n";
 
773
  exit 1;
 
774
}
 
775
EOF
 
776
}
 
777
 
 
778
# Do only the subdirs that match the RE passed in as $1
 
779
do_subdirs_re()
 
780
{
 
781
        RE=`echo "$1" | sed -e 's+/$++'`
 
782
 
 
783
        # Here's a queue of dirs to re-process later when
 
784
        # all the rest have been done already.
 
785
        > subdirs.later
 
786
 
 
787
        # subdirs.top lists _all_ subdirs of top in the order they
 
788
        # should be handled; subdirs.in lists those dirs that contain
 
789
        # dox. So the intersection of the two is the ordered list
 
790
        # of top-level subdirs that contain dox.
 
791
        #
 
792
        # subdirs.top also doesn't contain ".", so that special
 
793
        # case can be ignored in the loop.
 
794
 
 
795
 
 
796
        (
 
797
        for i in `grep "^$RE" subdirs.top`
 
798
        do
 
799
                if test "x$i" = "x." ; then
 
800
                        continue
 
801
                fi
 
802
                # Calculate intersection of this element and the
 
803
                # set of dox dirs.
 
804
                if grep "^$i\$" subdirs.in > /dev/null 2>&1 ; then
 
805
                        echo "$i"
 
806
                        mkdir -p "$i" 2> /dev/null
 
807
 
 
808
                        # Handle the subdirs of this one
 
809
                        for j in `grep "$i/" subdirs.in`
 
810
                        do
 
811
                                echo "$j"
 
812
                                mkdir -p "$j" 2> /dev/null
 
813
                        done
 
814
                fi
 
815
        done
 
816
 
 
817
        # Now we still need to handle whatever is left
 
818
        for i in `cat subdirs.in`
 
819
        do
 
820
                test -d "$i" || echo "$i"
 
821
                mkdir -p "$i" 2> /dev/null
 
822
        done
 
823
        ) > subdirs.sort
 
824
        for i in `cat subdirs.sort`
 
825
        do
 
826
                do_subdir "$i"
 
827
        done
 
828
 
 
829
        if test -s "subdirs.later" ; then
 
830
                sort subdirs.later | uniq > subdirs.sort
 
831
                for i in `cat subdirs.sort`
 
832
                do
 
833
                        : > subdirs.later
 
834
                        echo "*** Reprocessing $i"
 
835
                        do_subdir "$i"
 
836
                        test -s "subdirs.later" && echo "* Some tag files were still not found."
 
837
                done
 
838
        fi
 
839
}
 
840
 
 
841
if test "x." = "x$top_builddir" ; then
 
842
        apidox_toplevel
 
843
        create_subdirs
 
844
        create_installdox > installdox-slow
 
845
        if test "x$recurse" = "x1" ; then
 
846
                if test "x$module_name" = "xkdelibs" ; then
 
847
                        if test -z "$QTDOCTAG" && test -d "$QTDOCDIR" && \
 
848
                                test ! -f "qt/qt.tag" ; then
 
849
                                # Special case: create a qt tag file.
 
850
                                echo "*** Creating a tag file for the Qt library:"
 
851
                                mkdir qt
 
852
                                doxytag -t qt/qt.tag "$QTDOCDIR" > /dev/null 2>&1
 
853
                        fi
 
854
                fi
 
855
                if test -n "$QTDOCTAG" && test -r "$QTDOCTAG" ; then
 
856
                        echo "*** Copying tag file for the Qt library:"
 
857
                        mkdir qt
 
858
                        cp "$QTDOCTAG" qt/qt.tag
 
859
                fi
 
860
 
 
861
                do_subdirs_re "."
 
862
 
 
863
        fi
 
864
else
 
865
        if test "x$recurse" = "x1" ; then
 
866
                do_subdirs_re "$subdir"
 
867
        else
 
868
                do_subdir "$subdir"
 
869
        fi
 
870
fi
 
871
 
 
872
 
 
873
# At the end of a run, clean up stuff.
 
874
if test "YES" = "$cleanup" ; then
 
875
        rm -f subdirs.in  subdirs.later subdirs.sort subdirs.top Doxyfile.in
 
876
        rm -f `find . -name Doxyfile`
 
877
        rm -f qt/qt.tag
 
878
        rmdir qt > /dev/null 2>&1
 
879
fi
 
880
 
 
881
 
 
882
exit 0
 
883