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