tagging KDE 3.5.8
[kdevelop:kdevelop.git] / 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