.Sanitize

   1 ########################
   2 #
   3 #        H    H  EEEEEE Y     Y  !!
   4 #        H    H  E       Y   Y   !!
   5 #        H    H  E        Y Y    !!
   6 #        H    H  E         Y     !!
   7 #        HHHHHH  EEEEE     Y     !!
   8 #        H    H  E         Y     !!
   9 #        H    H  E         Y     !!
  10 #        H    H  E         Y
  11 #        H    H  EEEEEE    Y     !!
  12 #
  13 # YO!  READ ME!!!!!!!!!
  14 # If you're about to add a file or directory which isn't checked out as part
  15 # of every module in devo (e.g., if "cvs co gas+utils" won't get it, or if
  16 # "cvs co gcc" won't get it), then don't, Don't, DON'T add it to the regular
  17 # things-to-keep or things-to-lose sections.  Instead, add it to the setting
  18 # of keep_these_too or lose_these_too before those variables are rescanned
  19 # to check for the existence of the items listed in them.
  20 #
  21 # Otherwise, somebody will check out some package that doesn't include your
  22 # new file, and will get warnings from Sanitize when everything is really
  23 # okay.  You don't want to get people in the habit of ignoring complaints from
  24 # Sanitize, do you?  No, I didn't think so.
  25 #
  26 # If you do add a file to the regular things-to-keep section, don't forget
  27 # to add the corresponding entry to the devo-support entry (or whatever) in
  28 # the modules file.
  29 #
  30 ########################
  31
  32 # .Sanitize for devo.
  33
  34 # Each directory to survive its way into a release will need a file
  35 # like this one called "./.Sanitize".  All keyword lines must exist,
  36 # and must exist in the order specified by this file.  Each directory
  37 # in the tree will be processed, top down, in the following order.
  38
  39 # Hash started lines like this one are comments and will be deleted
  40 # before anything else is done.  Blank lines will also be squashed
  41 # out.
  42
  43 # The lines between the "Do-first:" line and the "Things-to-keep:"
  44 # line are executed as a /bin/sh shell script before anything else is
  45 # done in this directory.
  46
  47 Do-first:
  48
  49 keep_these_too="${keep_these_too} .cvsignore autoconf automake
  50         apache bash
  51         bfd binutils bison byacc cvs deja-gnu dejagnu diff dosrel dvips
  52         emacs emacs19 examples expect fileutils findutils flex
  53         gas gawk gcc gdb gdbm gdbtest glob gperf gprof grep grez groff
  54         guile gzip
  55         include inet install-sh intl ispell
  56         ld less libgcc libgloss libiberty libio
  57         libstdc++ libtool
  58         m4 make mkinstalldirs mmalloc move-if-change newlib ncurses opcodes
  59         pagas patch perl prms
  60         rcs readline sed send-pr shellutils sim tar textutils time
  61         texinfo tgas utils uudecode wdiff xiberty
  62         configure.bat makeall.bat setup.com makefile.vms winsup
  63         mpw-README mpw-configure mpw-config.in mpw-build.in mpw-install
  64         ltconfig ltmain.sh missing ylwrap"
  65
  66 lose_these_too="${lose_these_too} libg++ librx testsuite"
  67
  68 cygnus_files="release release-info build-all.mk test-build.mk CYGNUS COPYING.NEWLIB"
  69
  70 if ( echo $* | grep keep\-cygnus > /dev/null) ; then
  71         keep_these_too="${keep_these_too} ${cygnus_files}"
  72 else
  73         lose_these_too="${lose_these_too} ${cygnus_files}"
  74 fi
  75
  76 gdbtk_files="tcl tk itcl tix libgui"
  77
  78 if ( echo $* | grep lose\-gdbtk > /dev/null) ; then
  79         lose_these_too="${lose_these_too} ${gdbtk_files}"
  80         if [ -n "${verbose}" ] ; then
  81                 echo Deleting ${gdbtk_files}
  82         fi
  83 else
  84         keep_these_too="${keep_these_too} ${gdbtk_files}"
  85         if [ -n "${verbose}" ] ; then
  86                 echo Keeping ${gdbtk_files}
  87         fi
  88 fi
  89
  90 # This is for newlib net releases.
  91 newlib_file="COPYING.NEWLIB"
  92
  93 if (echo $* | grep keep\-newlib > /dev/null) ; then
  94         if (echo $* | grep -v keep\-cygnus > /dev/null) ; then
  95                 keep_these_too="${keep_these_too} ${newlib_file}"
  96                 lose_these_too="`echo ${lose_these_too} | sed -e s/${newlib_file}//`"
  97         fi
  98 else
  99         true; # Let keep-cygnus handle it.
 100 fi
 101
 102 # IDK releases don't include files which only matter to CDK.
 103 inet_files="COPYING.LIB config config-ml.in etc symlink-tree"
 104
 105 if (echo $* | grep keep\-inet > /dev/null); then
 106         lose_these_too="${lose_these_too} ${inet_files}"
 107 else
 108         keep_these_too="${keep_these_too} ${inet_files}"
 109 fi
 110
 111 ide_files="libide libidetcl vmake jstools"
 112
 113 if (echo $* | grep keep\-ide > /dev/null); then
 114         keep_these_too="${keep_these_too} ${ide_files}"
 115         test -n "$verbose" && echo Keeping ${ide_files}
 116 else
 117         lose_these_too="${lose_these_too} ${ide_files}"
 118 fi
 119
 120 flexlm_files="flexlm"
 121
 122 if (echo $* | grep keep\-cygnus > /dev/null); then
 123         keep_these_too="${keep_these_too} ${flexlm_files}"
 124         test -n "$verbose" && echo Keeping ${flexlm_files}
 125 else
 126         lose_these_too="${lose_these_too} ${flexlm_files}"
 127 fi
 128
 129 # CGEN files:
 130 # It is not yet clear if the cgen package will be shipped with the
 131 # simulators.
 132 cgen_files="cgen"
 133
 134 if (echo $* | grep keep\-cgen > /dev/null); then
 135         keep_these_too="${keep_these_too} ${cgen_files}"
 136 else
 137         lose_these_too="${lose_these_too} ${cgen_files}"
 138 fi
 139
 140 # Java stuff
 141 java_files="boehm-gc libjava"
 142
 143 if (echo $* | grep keep\-java > /dev/null); then
 144         keep_these_too="${keep_these_too} ${java_files}"
 145 else
 146         lose_these_too="${lose_these_too} ${java_files}"
 147 fi
 148
 149 # This top-level directory is special.  We often check out only subsets
 150 # of this directory, and complaining about directories or files we didn't
 151 # check out just gets obnoxious.
 152
 153 list="`(for i in ${keep_these_too}; do echo $i ; done) | sort -u`"
 154 keep_these_too=
 155
 156 for file in $list ; do
 157         if [ -r $file ] || [ -d $file ] ; then
 158                 keep_these_too="${keep_these_too} $file"
 159         fi
 160 done
 161
 162 list="`(for i in ${lose_these_too}; do echo $i ; done) | sort -u` "
 163 lose_these_too=
 164
 165 for file in $list ; do
 166         if [ -r $file ] || [ -d $file ] ; then
 167                 lose_these_too="${lose_these_too} $file"
 168         fi
 169 done
 170
 171 # All files listed between the "Things-to-keep:" line and the
 172 # "Do-last:" line will be kept.  All other files will be removed.
 173 # Directories listed in this section will have their own Sanitize
 174 # called.  Directories not listed will be removed in their entirety
 175 # with rm -rf.
 176
 177 Things-to-keep:
 178
 179 COPYING
 180 ChangeLog
 181 Makefile.in
 182 README
 183 config.guess
 184 config.sub
 185 configure
 186 configure.in
 187
 188 Things-to-lose:
 189
 190 # Not sure we want to include mkdep in releases yet.
 191 mkdep
 192
 193 # The lines between the "Do-last:" line and the end of the file
 194 # are executed as a /bin/sh shell script after everything else is
 195 # done.
 196
 197 Do-last:
 198
 199 # Don't try to clean directories here, as the 'mv' command will fail.
 200 # Also, grep fails on NFS mounted directories.
 201
 202 if ( echo $* | egrep verbose > /dev/null ) ; then
 203         verbose=true
 204 else
 205         verbose=
 206 fi
 207
 208 # Remove "sanitize-Sanitize" lines.
 209 if [ -n "${verbose}" ] ; then
 210         echo Cleaning unconditional sanitizations out of Makefile.in...
 211 fi
 212 cp Makefile.in new
 213 sed '/start\-sanitize\-Sanitize/,/end-\sanitize\-Sanitize/d' < Makefile.in > new
 214 if [ -n "${safe}" -a ! -f .Recover/Makefile.in ] ; then
 215         mv Makefile.in .Recover
 216 fi
 217 mv new Makefile.in
 218
 219 if [ -n "${verbose}" ] ; then
 220         echo Thawing away the \"chill\"...
 221 fi
 222
 223 if ( echo $* | grep keep\-chill > /dev/null ) ; then
 224         for i in * ; do
 225                 if test ! -d $i && (grep sanitize-chill $i > /dev/null) ; then
 226                         if [ -n "${verbose}" ] ; then
 227                                 echo Keeping chill stuff in $i
 228                         fi
 229                 fi
 230         done
 231 else
 232         for i in * ; do
 233                 if test ! -d $i && (grep sanitize-chill $i > /dev/null) ; then
 234                         if [ -n "${verbose}" ] ; then
 235                                 echo Thawing the \"chill\" out of $i...
 236                         fi
 237                         cp $i new
 238                         sed '/start\-sanitize\-chill/,/end-\sanitize\-chill/d' < $i > new
 239                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 240                                 if [ -n "${verbose}" ] ; then
 241                                         echo Caching $i in .Recover...
 242                                 fi
 243                                 mv $i .Recover
 244                         fi
 245                         mv new $i
 246                 fi
 247         done
 248 fi
 249
 250 if [ -n "${verbose}" ] ; then
 251         echo Processing \"d30v\"...
 252 fi
 253
 254 d30v_files="ChangeLog config.sub configure.in"
 255
 256 if ( echo $* | grep keep\-d30v > /dev/null ) ; then
 257         for i in $d30v_files ; do
 258                 if test ! -d $i && (grep sanitize-d30v $i > /dev/null) ; then
 259                         if [ -n "${verbose}" ] ; then
 260                                 echo Keeping d30v stuff in $i
 261                         fi
 262                 fi
 263         done
 264 else
 265         for i in * ; do
 266                 if test ! -d $i && (grep sanitize-d30v $i > /dev/null) ; then
 267                         if [ -n "${verbose}" ] ; then
 268                                 echo Removing traces of \"d30v\" from $i...
 269                         fi
 270                         cp $i new
 271                         sed '/start\-sanitize\-d30v/,/end-\sanitize\-d30v/d' < $i > new
 272                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 273                                 if [ -n "${verbose}" ] ; then
 274                                         echo Caching $i in .Recover...
 275                                 fi
 276                                 mv $i .Recover
 277                         fi
 278                         mv new $i
 279                 fi
 280         done
 281 fi
 282
 283 if [ -n "${verbose}" ] ; then
 284         echo Processing \"v850\"...
 285 fi
 286
 287 v850_files="ChangeLog config.sub configure.in"
 288
 289 if ( echo $* | grep keep\-v850e > /dev/null ) ; then
 290         for i in $v850_files ; do
 291                 if test ! -d $i && (grep sanitize-v850e $i > /dev/null) ; then
 292                         if [ -n "${verbose}" ] ; then
 293                                 echo Keeping v850e stuff in $i
 294                         fi
 295                 fi
 296         done
 297 else
 298         for i in * ; do
 299                 if test ! -d $i && (grep sanitize-v850e $i > /dev/null) ; then
 300                         if [ -n "${verbose}" ] ; then
 301                                 echo Removing traces of \"v850e\" from $i...
 302                         fi
 303                         cp $i new
 304                         sed '/start\-sanitize\-v850e/,/end-\sanitize\-v850e/d' < $i > new
 305                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 306                                 if [ -n "${verbose}" ] ; then
 307                                         echo Caching $i in .Recover...
 308                                 fi
 309                                 mv $i .Recover
 310                         fi
 311                         mv new $i
 312                 fi
 313         done
 314 fi
 315
 316 r5900_files="ChangeLog config.sub configure.in"
 317
 318 if ( echo $* | grep keep\-r5900 > /dev/null ) ; then
 319         for i in $r5900_files ; do
 320                 if test ! -d $i && (grep sanitize-r5900 $i > /dev/null) ; then
 321                         if [ -n "${verbose}" ] ; then
 322                                 echo Keeping r5900 stuff in $i
 323                         fi
 324                 fi
 325         done
 326 else
 327         for i in * ; do
 328                 if test ! -d $i && (grep sanitize-r5900 $i > /dev/null) ; then
 329                         if [ -n "${verbose}" ] ; then
 330                                 echo Removing traces of \"r5900\" from $i...
 331                         fi
 332                         cp $i new
 333                         sed '/start\-sanitize\-r5900/,/end-\sanitize\-r5900/d' < $i > new
 334                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 335                                 if [ -n "${verbose}" ] ; then
 336                                         echo Caching $i in .Recover...
 337                                 fi
 338                                 mv $i .Recover
 339                         fi
 340                         mv new $i
 341                 fi
 342         done
 343 fi
 344
 345 vr4320_files="ChangeLog config.sub"
 346
 347 if ( echo $* | grep keep\-vr4320 > /dev/null ) ; then
 348         for i in $vr4320_files ; do
 349                 if test ! -d $i && (grep sanitize-vr4320 $i > /dev/null) ; then
 350                         if [ -n "${verbose}" ] ; then
 351                                 echo Keeping vr4320 stuff in $i
 352                         fi
 353                 fi
 354         done
 355 else
 356         for i in * ; do
 357                 if test ! -d $i && (grep sanitize-vr4320 $i > /dev/null) ; then
 358                         if [ -n "${verbose}" ] ; then
 359                                 echo Removing traces of \"vr4320\" from $i...
 360                         fi
 361                         cp $i new
 362                         sed '/start\-sanitize\-vr4320/,/end-\sanitize\-vr4320/d' < $i > new
 363                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 364                                 if [ -n "${verbose}" ] ; then
 365                                         echo Caching $i in .Recover...
 366                                 fi
 367                                 mv $i .Recover
 368                         fi
 369                         mv new $i
 370                 fi
 371         done
 372 fi
 373
 374 tx19_files="ChangeLog config.sub"
 375
 376 if ( echo $* | grep keep\-tx19 > /dev/null ) ; then
 377         for i in $tx19_files ; do
 378                 if test ! -d $i && (grep sanitize-tx19 $i > /dev/null) ; then
 379                         if [ -n "${verbose}" ] ; then
 380                                 echo Keeping tx19 stuff in $i
 381                         fi
 382                 fi
 383         done
 384 else
 385         for i in * ; do
 386                 if test ! -d $i && (grep sanitize-tx19 $i > /dev/null) ; then
 387                         if [ -n "${verbose}" ] ; then
 388                                 echo Removing traces of \"tx19\" from $i...
 389                         fi
 390                         cp $i new
 391                         sed '/start\-sanitize\-tx19/,/end-\sanitize\-tx19/d' < $i > new
 392                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 393                                 if [ -n "${verbose}" ] ; then
 394                                         echo Caching $i in .Recover...
 395                                 fi
 396                                 mv $i .Recover
 397                         fi
 398                         mv new $i
 399                 fi
 400         done
 401 fi
 402
 403 tx49_files="ChangeLog config.sub"
 404
 405 if ( echo $* | grep keep\-tx49 > /dev/null ) ; then
 406         for i in $tx49_files ; do
 407                 if test ! -d $i && (grep sanitize-tx49 $i > /dev/null) ; then
 408                         if [ -n "${verbose}" ] ; then
 409                                 echo Keeping tx49 stuff in $i
 410                         fi
 411                 fi
 412         done
 413 else
 414         for i in * ; do
 415                 if test ! -d $i && (grep sanitize-tx49 $i > /dev/null) ; then
 416                         if [ -n "${verbose}" ] ; then
 417                                 echo Removing traces of \"tx49\" from $i...
 418                         fi
 419                         cp $i new
 420                         sed '/start\-sanitize\-tx49/,/end-\sanitize\-tx49/d' < $i > new
 421                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 422                                 if [ -n "${verbose}" ] ; then
 423                                         echo Caching $i in .Recover...
 424                                 fi
 425                                 mv $i .Recover
 426                         fi
 427                         mv new $i
 428                 fi
 429         done
 430 fi
 431
 432 tic80_files="ChangeLog config.sub configure.in"
 433
 434 if ( echo $* | grep keep\-tic80 > /dev/null ) ; then
 435         for i in $tic80_files ; do
 436                 if test ! -d $i && (grep sanitize-tic80 $i > /dev/null) ; then
 437                         if [ -n "${verbose}" ] ; then
 438                                 echo Keeping tic80 stuff in $i
 439                         fi
 440                 fi
 441         done
 442 else
 443         for i in * ; do
 444                 if test ! -d $i && (grep sanitize-tic80 $i > /dev/null) ; then
 445                         if [ -n "${verbose}" ] ; then
 446                                 echo Removing traces of \"tic80\" from $i...
 447                         fi
 448                         cp $i new
 449                         sed '/start\-sanitize\-tic80/,/end-\sanitize\-tic80/d' < $i > new
 450                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 451                                 if [ -n "${verbose}" ] ; then
 452                                         echo Caching $i in .Recover...
 453                                 fi
 454                                 mv $i .Recover
 455                         fi
 456                         mv new $i
 457                 fi
 458         done
 459 fi
 460
 461 sky_files="ChangeLog config.sub configure.in"
 462
 463 if ( echo $* | grep keep\-sky > /dev/null ) ; then
 464         for i in $sky_files ; do
 465                 if test ! -d $i && (grep sanitize-sky $i > /dev/null) ; then
 466                         if [ -n "${verbose}" ] ; then
 467                                 echo Keeping sky stuff in $i
 468                         fi
 469                 fi
 470         done
 471 else
 472         for i in * ; do
 473                 if test ! -d $i && (grep sanitize-sky $i > /dev/null) ; then
 474                         if [ -n "${verbose}" ] ; then
 475                                 echo Removing traces of \"sky\" from $i...
 476                         fi
 477                         cp $i new
 478                         sed '/start\-sanitize\-sky/,/end-\sanitize\-sky/d' < $i > new
 479                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 480                                 if [ -n "${verbose}" ] ; then
 481                                         echo Caching $i in .Recover...
 482                                 fi
 483                                 mv $i .Recover
 484                         fi
 485                         mv new $i
 486                 fi
 487         done
 488 fi
 489
 490 if ( echo $* | grep keep\-ide > /dev/null ) ; then
 491         for i in * ; do
 492                 if test ! -d $i && (grep sanitize-ide $i > /dev/null) ; then
 493                         if [ -n "${verbose}" ] ; then
 494                                 echo Keeping ide stuff in $i
 495                         fi
 496                 fi
 497         done
 498 else
 499         for i in * ; do
 500                 if test ! -d $i && (grep sanitize-ide $i > /dev/null) ; then
 501                         if [ -n "${verbose}" ] ; then
 502                                 echo Removing traces of \"ide\" from $i...
 503                         fi
 504                         cp $i new
 505                         sed '/start\-sanitize\-ide/,/end-\sanitize\-ide/d' < $i > new
 506                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 507                                 if [ -n "${verbose}" ] ; then
 508                                         echo Caching $i in .Recover...
 509                                 fi
 510                                 mv $i .Recover
 511                         fi
 512                         mv new $i
 513                 fi
 514         done
 515 fi
 516
 517 if ( echo $* | grep lose\-gdbtk > /dev/null ) ; then
 518         if [ -n "${verbose}" ] ; then
 519                 echo Catering to RMS by removing traces of \"gdbtk\"...
 520         fi
 521         for i in * ; do
 522                 if test ! -d $i && (grep sanitize-gdbtk $i > /dev/null) ; then
 523                         if [ -n "${verbose}" ] ; then
 524                                 echo Removing traces of \"gdbtk\" from $i...
 525                         fi
 526                         cp $i new
 527                         sed '/start\-sanitize\-gdbtk/,/end-\sanitize\-gdbtk/d' < $i > new
 528                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 529                                 if [ -n "${verbose}" ] ; then
 530                                         echo Caching $i in .Recover...
 531                                 fi
 532                                 mv $i .Recover
 533                         fi
 534                         mv new $i
 535                 fi
 536         done
 537         cp Makefile.in new
 538         sed -e '/GDBTK_SUPPORT_DIRS=/d' -e 's/ $(GDBTK_SUPPORT_DIRS)//' < Makefile.in > new
 539         if [ -n "${safe}" -a ! -f .Recover/Makefile.in ] ; then
 540                 if [ -n "${verbose}" ] ; then
 541                         echo Caching Makefile.in in .Recover...
 542                 fi
 543                 mv Makefile.in .Recover
 544         fi
 545         mv new Makefile.in
 546 else
 547         if [ -n "${verbose}" ] ; then
 548                 echo Leaving \"gdbtk\" in the sources...
 549         fi
 550         for i in * ; do
 551                 if test ! -d $i && (grep sanitize-gdbtk $i > /dev/null) ; then
 552                         if [ -n "${verbose}" ] ; then
 553                                 echo Keeping \"gdbtk\" stuff in $i, but editing out sanitize lines...
 554                         fi
 555                         cp $i new
 556                         sed -e '/start\-sanitize\-gdbtk/d' -e '/end\-sanitize\-gdbtk/d' < $i > new
 557                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 558                                 if [ -n "${verbose}" ] ; then
 559                                         echo Caching $i in .Recover...
 560                                 fi
 561                                 mv $i .Recover
 562                         fi
 563                         mv new $i
 564                 fi
 565         done
 566 fi
 567
 568 if ( echo $* | grep lose\-mswin > /dev/null ) ; then
 569         if [ -n "${verbose}" ] ; then
 570                 echo Removing traces of \"mswin\"...
 571         fi
 572         for i in * ; do
 573                 if test ! -d $i && (grep sanitize-mswin $i > /dev/null) ; then
 574                         if [ -n "${verbose}" ] ; then
 575                                 echo Removing traces of \"mswin\" from $i...
 576                         fi
 577                         cp $i new
 578                         sed '/start\-sanitize\-mswin/,/end-\sanitize\-mswin/d' < $i > new
 579                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 580                                 if [ -n "${verbose}" ] ; then
 581                                         echo Caching $i in .Recover...
 582                                 fi
 583                                 mv $i .Recover
 584                         fi
 585                         mv new $i
 586                 fi
 587         done
 588 else
 589         if [ -n "${verbose}" ] ; then
 590                 echo Leaving \"mswin\" in the sources...
 591         fi
 592         for i in * ; do
 593                 if test ! -d $i && (grep sanitize-mswin $i > /dev/null) ; then
 594                         if [ -n "${verbose}" ] ; then
 595                                 echo Keeping \"mswin\" stuff in $i, but editing out sanitize lines...
 596                         fi
 597                         cp $i new
 598                         sed -e '/start\-sanitize\-mswin/d' -e '/end\-sanitize\-mswin/d' < $i > new
 599                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 600                                 if [ -n "${verbose}" ] ; then
 601                                         echo Caching $i in .Recover...
 602                                 fi
 603                                 mv $i .Recover
 604                         fi
 605                         mv new $i
 606                 fi
 607         done
 608 fi
 609
 610 vr5400_files="ChangeLog config.sub"
 611
 612 if ( echo $* | grep keep\-vr5400 > /dev/null ) ; then
 613         for i in $vr5400_files ; do
 614                 if test ! -d $i && (grep sanitize-vr5400 $i > /dev/null) ; then
 615                         if [ -n "${verbose}" ] ; then
 616                                 echo Keeping vr5400 stuff in $i
 617                         fi
 618                 fi
 619         done
 620 else
 621         for i in * ; do
 622                 if test ! -d $i && (grep sanitize-vr5400 $i > /dev/null) ; then
 623                         if [ -n "${verbose}" ] ; then
 624                                 echo Removing traces of \"vr5400\" from $i...
 625                         fi
 626                         cp $i new
 627                         sed '/start\-sanitize\-vr5400/,/end-\sanitize\-vr5400/d' < $i > new
 628                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 629                                 if [ -n "${verbose}" ] ; then
 630                                         echo Caching $i in .Recover...
 631                                 fi
 632                                 mv $i .Recover
 633                         fi
 634                         mv new $i
 635                 fi
 636         done
 637 fi
 638
 639 m32rx_files="ChangeLog config-ml.in"
 640 if ( echo $* | grep keep\-m32rx > /dev/null ) ; then
 641         for i in $m32rx_files ; do
 642                 if test ! -d $i && (grep sanitize-m32rx $i > /dev/null) ; then
 643                         if [ -n "${verbose}" ] ; then
 644                                 echo Keeping m32rx stuff in $i
 645                         fi
 646                 fi
 647         done
 648 else
 649         for i in * ; do
 650                 if test ! -d $i && (grep sanitize-m32rx $i > /dev/null) ; then
 651                         if [ -n "${verbose}" ] ; then
 652                                 echo Removing traces of \"m32rx\" from $i...
 653                         fi
 654                         cp $i new
 655                         sed '/start\-sanitize\-m32rx/,/end-\sanitize\-m32rx/d' < $i > new
 656                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 657                                 if [ -n "${verbose}" ] ; then
 658                                         echo Caching $i in .Recover...
 659                                 fi
 660                                 mv $i .Recover
 661                         fi
 662                         mv new $i
 663                 fi
 664         done
 665 fi
 666
 667 java_files="ChangeLog"
 668 if ( echo $* | grep keep\-java > /dev/null ) ; then
 669         for i in $java_files ; do
 670                 if test ! -d $i && (grep sanitize-java $i > /dev/null) ; then
 671                         if [ -n "${verbose}" ] ; then
 672                                 echo Keeping java stuff in $i
 673                         fi
 674                 fi
 675         done
 676 else
 677         for i in * ; do
 678                 if test ! -d $i && (grep sanitize-java $i > /dev/null) ; then
 679                         if [ -n "${verbose}" ] ; then
 680                                 echo Removing traces of \"java\" from $i...
 681                         fi
 682                         cp $i new
 683                         sed '/start\-sanitize\-java/,/end-\sanitize\-java/d' < $i > new
 684                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 685                                 if [ -n "${verbose}" ] ; then
 686                                         echo Caching $i in .Recover...
 687                                 fi
 688                                 mv $i .Recover
 689                         fi
 690                         mv new $i
 691                 fi
 692         done
 693 fi
 694
 695 kcygnus_files="ChangeLog configure configure.in Makefile.in"
 696 if ( echo $* | grep keep\-cygnus > /dev/null ) ; then
 697         for i in $kcygnus_files ; do
 698                 if test ! -d $i && (grep sanitize-cygnus $i > /dev/null) ; then
 699                         if [ -n "${verbose}" ] ; then
 700                                 echo Keeping Cygnus stuff in $i
 701                         fi
 702                         cp $i new
 703                         grep -v sanitize-cygnus $i > new
 704                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 705                                 if [ -n "${verbose}" ] ; then
 706                                         echo Caching $i in .Recover...
 707                                 fi
 708                                 mv $i .Recover
 709                         fi
 710                         mv new $i
 711                 fi
 712         done
 713 else
 714         for i in * ; do
 715                 if test ! -d $i && (grep sanitize-cygnus $i > /dev/null) ; then
 716                         if [ -n "${verbose}" ] ; then
 717                                 echo Removing traces of \"cygnus\" from $i...
 718                         fi
 719                         cp $i new
 720                         sed '/start\-sanitize\-cygnus/,/end-\sanitize\-cygnus/d' < $i > new
 721                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 722                                 if [ -n "${verbose}" ] ; then
 723                                         echo Caching $i in .Recover...
 724                                 fi
 725                                 mv $i .Recover
 726                         fi
 727                         mv new $i
 728                 fi
 729         done
 730 fi
 731
 732
 733 # Do this check LAST!
 734 for i in * ; do
 735         if test ! -d $i && (grep sanitize $i > /dev/null) ; then
 736                 echo '***' Some mentions of Sanitize are still left in $i! 1>&2
 737                 exit 1
 738         fi
 739 done
 740
 741 # eof