.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 \"v850\"...
 252 fi
 253
 254 v850_files="ChangeLog config.sub configure.in"
 255
 256 if ( echo $* | grep keep\-v850e > /dev/null ) ; then
 257         for i in $v850_files ; do
 258                 if test ! -d $i && (grep sanitize-v850e $i > /dev/null) ; then
 259                         if [ -n "${verbose}" ] ; then
 260                                 echo Keeping v850e stuff in $i
 261                         fi
 262                 fi
 263         done
 264 else
 265         for i in * ; do
 266                 if test ! -d $i && (grep sanitize-v850e $i > /dev/null) ; then
 267                         if [ -n "${verbose}" ] ; then
 268                                 echo Removing traces of \"v850e\" from $i...
 269                         fi
 270                         cp $i new
 271                         sed '/start\-sanitize\-v850e/,/end-\sanitize\-v850e/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 r5900_files="ChangeLog config.sub configure.in"
 284
 285 if ( echo $* | grep keep\-r5900 > /dev/null ) ; then
 286         for i in $r5900_files ; do
 287                 if test ! -d $i && (grep sanitize-r5900 $i > /dev/null) ; then
 288                         if [ -n "${verbose}" ] ; then
 289                                 echo Keeping r5900 stuff in $i
 290                         fi
 291                 fi
 292         done
 293 else
 294         for i in * ; do
 295                 if test ! -d $i && (grep sanitize-r5900 $i > /dev/null) ; then
 296                         if [ -n "${verbose}" ] ; then
 297                                 echo Removing traces of \"r5900\" from $i...
 298                         fi
 299                         cp $i new
 300                         sed '/start\-sanitize\-r5900/,/end-\sanitize\-r5900/d' < $i > new
 301                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 302                                 if [ -n "${verbose}" ] ; then
 303                                         echo Caching $i in .Recover...
 304                                 fi
 305                                 mv $i .Recover
 306                         fi
 307                         mv new $i
 308                 fi
 309         done
 310 fi
 311
 312 vr4320_files="ChangeLog config.sub"
 313
 314 if ( echo $* | grep keep\-vr4320 > /dev/null ) ; then
 315         for i in $vr4320_files ; do
 316                 if test ! -d $i && (grep sanitize-vr4320 $i > /dev/null) ; then
 317                         if [ -n "${verbose}" ] ; then
 318                                 echo Keeping vr4320 stuff in $i
 319                         fi
 320                 fi
 321         done
 322 else
 323         for i in * ; do
 324                 if test ! -d $i && (grep sanitize-vr4320 $i > /dev/null) ; then
 325                         if [ -n "${verbose}" ] ; then
 326                                 echo Removing traces of \"vr4320\" from $i...
 327                         fi
 328                         cp $i new
 329                         sed '/start\-sanitize\-vr4320/,/end-\sanitize\-vr4320/d' < $i > new
 330                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 331                                 if [ -n "${verbose}" ] ; then
 332                                         echo Caching $i in .Recover...
 333                                 fi
 334                                 mv $i .Recover
 335                         fi
 336                         mv new $i
 337                 fi
 338         done
 339 fi
 340
 341 tx19_files="ChangeLog config.sub"
 342
 343 if ( echo $* | grep keep\-tx19 > /dev/null ) ; then
 344         for i in $tx19_files ; do
 345                 if test ! -d $i && (grep sanitize-tx19 $i > /dev/null) ; then
 346                         if [ -n "${verbose}" ] ; then
 347                                 echo Keeping tx19 stuff in $i
 348                         fi
 349                 fi
 350         done
 351 else
 352         for i in * ; do
 353                 if test ! -d $i && (grep sanitize-tx19 $i > /dev/null) ; then
 354                         if [ -n "${verbose}" ] ; then
 355                                 echo Removing traces of \"tx19\" from $i...
 356                         fi
 357                         cp $i new
 358                         sed '/start\-sanitize\-tx19/,/end-\sanitize\-tx19/d' < $i > new
 359                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 360                                 if [ -n "${verbose}" ] ; then
 361                                         echo Caching $i in .Recover...
 362                                 fi
 363                                 mv $i .Recover
 364                         fi
 365                         mv new $i
 366                 fi
 367         done
 368 fi
 369
 370 tx49_files="ChangeLog config.sub"
 371
 372 if ( echo $* | grep keep\-tx49 > /dev/null ) ; then
 373         for i in $tx49_files ; do
 374                 if test ! -d $i && (grep sanitize-tx49 $i > /dev/null) ; then
 375                         if [ -n "${verbose}" ] ; then
 376                                 echo Keeping tx49 stuff in $i
 377                         fi
 378                 fi
 379         done
 380 else
 381         for i in * ; do
 382                 if test ! -d $i && (grep sanitize-tx49 $i > /dev/null) ; then
 383                         if [ -n "${verbose}" ] ; then
 384                                 echo Removing traces of \"tx49\" from $i...
 385                         fi
 386                         cp $i new
 387                         sed '/start\-sanitize\-tx49/,/end-\sanitize\-tx49/d' < $i > new
 388                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 389                                 if [ -n "${verbose}" ] ; then
 390                                         echo Caching $i in .Recover...
 391                                 fi
 392                                 mv $i .Recover
 393                         fi
 394                         mv new $i
 395                 fi
 396         done
 397 fi
 398
 399 tic80_files="ChangeLog config.sub configure.in"
 400
 401 if ( echo $* | grep keep\-tic80 > /dev/null ) ; then
 402         for i in $tic80_files ; do
 403                 if test ! -d $i && (grep sanitize-tic80 $i > /dev/null) ; then
 404                         if [ -n "${verbose}" ] ; then
 405                                 echo Keeping tic80 stuff in $i
 406                         fi
 407                 fi
 408         done
 409 else
 410         for i in * ; do
 411                 if test ! -d $i && (grep sanitize-tic80 $i > /dev/null) ; then
 412                         if [ -n "${verbose}" ] ; then
 413                                 echo Removing traces of \"tic80\" from $i...
 414                         fi
 415                         cp $i new
 416                         sed '/start\-sanitize\-tic80/,/end-\sanitize\-tic80/d' < $i > new
 417                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 418                                 if [ -n "${verbose}" ] ; then
 419                                         echo Caching $i in .Recover...
 420                                 fi
 421                                 mv $i .Recover
 422                         fi
 423                         mv new $i
 424                 fi
 425         done
 426 fi
 427
 428 sky_files="ChangeLog config.sub configure.in"
 429
 430 if ( echo $* | grep keep\-sky > /dev/null ) ; then
 431         for i in $sky_files ; do
 432                 if test ! -d $i && (grep sanitize-sky $i > /dev/null) ; then
 433                         if [ -n "${verbose}" ] ; then
 434                                 echo Keeping sky stuff in $i
 435                         fi
 436                 fi
 437         done
 438 else
 439         for i in * ; do
 440                 if test ! -d $i && (grep sanitize-sky $i > /dev/null) ; then
 441                         if [ -n "${verbose}" ] ; then
 442                                 echo Removing traces of \"sky\" from $i...
 443                         fi
 444                         cp $i new
 445                         sed '/start\-sanitize\-sky/,/end-\sanitize\-sky/d' < $i > new
 446                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 447                                 if [ -n "${verbose}" ] ; then
 448                                         echo Caching $i in .Recover...
 449                                 fi
 450                                 mv $i .Recover
 451                         fi
 452                         mv new $i
 453                 fi
 454         done
 455 fi
 456
 457 if ( echo $* | grep keep\-ide > /dev/null ) ; then
 458         for i in * ; do
 459                 if test ! -d $i && (grep sanitize-ide $i > /dev/null) ; then
 460                         if [ -n "${verbose}" ] ; then
 461                                 echo Keeping ide stuff in $i
 462                         fi
 463                 fi
 464         done
 465 else
 466         for i in * ; do
 467                 if test ! -d $i && (grep sanitize-ide $i > /dev/null) ; then
 468                         if [ -n "${verbose}" ] ; then
 469                                 echo Removing traces of \"ide\" from $i...
 470                         fi
 471                         cp $i new
 472                         sed '/start\-sanitize\-ide/,/end-\sanitize\-ide/d' < $i > new
 473                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 474                                 if [ -n "${verbose}" ] ; then
 475                                         echo Caching $i in .Recover...
 476                                 fi
 477                                 mv $i .Recover
 478                         fi
 479                         mv new $i
 480                 fi
 481         done
 482 fi
 483
 484 if ( echo $* | grep lose\-gdbtk > /dev/null ) ; then
 485         if [ -n "${verbose}" ] ; then
 486                 echo Catering to RMS by removing traces of \"gdbtk\"...
 487         fi
 488         for i in * ; do
 489                 if test ! -d $i && (grep sanitize-gdbtk $i > /dev/null) ; then
 490                         if [ -n "${verbose}" ] ; then
 491                                 echo Removing traces of \"gdbtk\" from $i...
 492                         fi
 493                         cp $i new
 494                         sed '/start\-sanitize\-gdbtk/,/end-\sanitize\-gdbtk/d' < $i > new
 495                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 496                                 if [ -n "${verbose}" ] ; then
 497                                         echo Caching $i in .Recover...
 498                                 fi
 499                                 mv $i .Recover
 500                         fi
 501                         mv new $i
 502                 fi
 503         done
 504         cp Makefile.in new
 505         sed -e '/GDBTK_SUPPORT_DIRS=/d' -e 's/ $(GDBTK_SUPPORT_DIRS)//' < Makefile.in > new
 506         if [ -n "${safe}" -a ! -f .Recover/Makefile.in ] ; then
 507                 if [ -n "${verbose}" ] ; then
 508                         echo Caching Makefile.in in .Recover...
 509                 fi
 510                 mv Makefile.in .Recover
 511         fi
 512         mv new Makefile.in
 513 else
 514         if [ -n "${verbose}" ] ; then
 515                 echo Leaving \"gdbtk\" in the sources...
 516         fi
 517         for i in * ; do
 518                 if test ! -d $i && (grep sanitize-gdbtk $i > /dev/null) ; then
 519                         if [ -n "${verbose}" ] ; then
 520                                 echo Keeping \"gdbtk\" stuff in $i, but editing out sanitize lines...
 521                         fi
 522                         cp $i new
 523                         sed -e '/start\-sanitize\-gdbtk/d' -e '/end\-sanitize\-gdbtk/d' < $i > new
 524                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 525                                 if [ -n "${verbose}" ] ; then
 526                                         echo Caching $i in .Recover...
 527                                 fi
 528                                 mv $i .Recover
 529                         fi
 530                         mv new $i
 531                 fi
 532         done
 533 fi
 534
 535 if ( echo $* | grep lose\-mswin > /dev/null ) ; then
 536         if [ -n "${verbose}" ] ; then
 537                 echo Removing traces of \"mswin\"...
 538         fi
 539         for i in * ; do
 540                 if test ! -d $i && (grep sanitize-mswin $i > /dev/null) ; then
 541                         if [ -n "${verbose}" ] ; then
 542                                 echo Removing traces of \"mswin\" from $i...
 543                         fi
 544                         cp $i new
 545                         sed '/start\-sanitize\-mswin/,/end-\sanitize\-mswin/d' < $i > new
 546                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 547                                 if [ -n "${verbose}" ] ; then
 548                                         echo Caching $i in .Recover...
 549                                 fi
 550                                 mv $i .Recover
 551                         fi
 552                         mv new $i
 553                 fi
 554         done
 555 else
 556         if [ -n "${verbose}" ] ; then
 557                 echo Leaving \"mswin\" in the sources...
 558         fi
 559         for i in * ; do
 560                 if test ! -d $i && (grep sanitize-mswin $i > /dev/null) ; then
 561                         if [ -n "${verbose}" ] ; then
 562                                 echo Keeping \"mswin\" stuff in $i, but editing out sanitize lines...
 563                         fi
 564                         cp $i new
 565                         sed -e '/start\-sanitize\-mswin/d' -e '/end\-sanitize\-mswin/d' < $i > new
 566                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 567                                 if [ -n "${verbose}" ] ; then
 568                                         echo Caching $i in .Recover...
 569                                 fi
 570                                 mv $i .Recover
 571                         fi
 572                         mv new $i
 573                 fi
 574         done
 575 fi
 576
 577 cygnus_files="ChangeLog config.sub"
 578
 579 if ( echo $* | grep keep\-cygnus > /dev/null ) ; then
 580         for i in $cygnus_files ; do
 581                 if test ! -d $i && (grep sanitize-cygnus $i > /dev/null) ; then
 582                         if [ -n "${verbose}" ] ; then
 583                                 echo Keeping cygnus stuff in $i
 584                         fi
 585                 fi
 586         done
 587 else
 588         for i in * ; do
 589                 if test ! -d $i && (grep sanitize-cygnus $i > /dev/null) ; then
 590                         if [ -n "${verbose}" ] ; then
 591                                 echo Removing traces of \"cygnus\" from $i...
 592                         fi
 593                         cp $i new
 594                         sed '/start\-sanitize\-cygnus/,/end-\sanitize\-cygnus/d' < $i > new
 595                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 596                                 if [ -n "${verbose}" ] ; then
 597                                         echo Caching $i in .Recover...
 598                                 fi
 599                                 mv $i .Recover
 600                         fi
 601                         mv new $i
 602                 fi
 603         done
 604 fi
 605
 606 m32rx_files="ChangeLog config-ml.in"
 607 if ( echo $* | grep keep\-m32rx > /dev/null ) ; then
 608         for i in $m32rx_files ; do
 609                 if test ! -d $i && (grep sanitize-m32rx $i > /dev/null) ; then
 610                         if [ -n "${verbose}" ] ; then
 611                                 echo Keeping m32rx stuff in $i
 612                         fi
 613                 fi
 614         done
 615 else
 616         for i in * ; do
 617                 if test ! -d $i && (grep sanitize-m32rx $i > /dev/null) ; then
 618                         if [ -n "${verbose}" ] ; then
 619                                 echo Removing traces of \"m32rx\" from $i...
 620                         fi
 621                         cp $i new
 622                         sed '/start\-sanitize\-m32rx/,/end-\sanitize\-m32rx/d' < $i > new
 623                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 624                                 if [ -n "${verbose}" ] ; then
 625                                         echo Caching $i in .Recover...
 626                                 fi
 627                                 mv $i .Recover
 628                         fi
 629                         mv new $i
 630                 fi
 631         done
 632 fi
 633
 634 armelf_files="ChangeLog configure.in"
 635 if ( echo $* | grep keep\-armelf > /dev/null ) ; then
 636         for i in $armelf_files ; do
 637                 if test ! -d $i && (grep sanitize-armelf $i > /dev/null) ; then
 638                         if [ -n "${verbose}" ] ; then
 639                                 echo Keeping armelf stuff in $i
 640                         fi
 641                 fi
 642         done
 643 else
 644         for i in * ; do
 645                 if test ! -d $i && (grep sanitize-armelf $i > /dev/null) ; then
 646                         if [ -n "${verbose}" ] ; then
 647                                 echo Removing traces of \"armelf\" from $i...
 648                         fi
 649                         cp $i new
 650                         sed '/start\-sanitize\-armelf/,/end-\sanitize\-armelf/d' < $i > new
 651                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 652                                 if [ -n "${verbose}" ] ; then
 653                                         echo Caching $i in .Recover...
 654                                 fi
 655                                 mv $i .Recover
 656                         fi
 657                         mv new $i
 658                 fi
 659         done
 660 fi
 661
 662 java_files="ChangeLog Makefile.in configure.in"
 663 if ( echo $* | grep keep\-java > /dev/null ) ; then
 664         for i in $java_files ; do
 665                 if test ! -d $i && (grep sanitize-java $i > /dev/null) ; then
 666                         if [ -n "${verbose}" ] ; then
 667                                 echo Keeping java stuff in $i
 668                         fi
 669                 fi
 670         done
 671 else
 672         for i in * ; do
 673                 if test ! -d $i && (grep sanitize-java $i > /dev/null) ; then
 674                         if [ -n "${verbose}" ] ; then
 675                                 echo Removing traces of \"java\" from $i...
 676                         fi
 677                         cp $i new
 678                         sed '/start\-sanitize\-java/,/end-\sanitize\-java/d' < $i > new
 679                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 680                                 if [ -n "${verbose}" ] ; then
 681                                         echo Caching $i in .Recover...
 682                                 fi
 683                                 mv $i .Recover
 684                         fi
 685                         mv new $i
 686                 fi
 687         done
 688 fi
 689
 690 beos_files="ChangeLog configure.in"
 691 if ( echo $* | grep keep\-beos > /dev/null ) ; then
 692         for i in $beos_files ; do
 693                 if test ! -d $i && (grep sanitize-beos $i > /dev/null) ; then
 694                         if [ -n "${verbose}" ] ; then
 695                                 echo Keeping beos stuff in $i
 696                         fi
 697                 fi
 698         done
 699 else
 700         for i in * ; do
 701                 if test ! -d $i && (grep sanitize-beos $i > /dev/null) ; then
 702                         if [ -n "${verbose}" ] ; then
 703                                 echo Removing traces of \"beos\" from $i...
 704                         fi
 705                         cp $i new
 706                         sed '/start\-sanitize\-beos/,/end-\sanitize\-beos/d' < $i > new
 707                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 708                                 if [ -n "${verbose}" ] ; then
 709                                         echo Caching $i in .Recover...
 710                                 fi
 711                                 mv $i .Recover
 712                         fi
 713                         mv new $i
 714                 fi
 715         done
 716 fi
 717
 718 kcygnus_files="ChangeLog configure configure.in Makefile.in"
 719 if ( echo $* | grep keep\-cygnus > /dev/null ) ; then
 720         for i in $kcygnus_files ; do
 721                 if test ! -d $i && (grep sanitize-cygnus $i > /dev/null) ; then
 722                         if [ -n "${verbose}" ] ; then
 723                                 echo Keeping Cygnus stuff in $i
 724                         fi
 725                         cp $i new
 726                         grep -v sanitize-cygnus $i > new
 727                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 728                                 if [ -n "${verbose}" ] ; then
 729                                         echo Caching $i in .Recover...
 730                                 fi
 731                                 mv $i .Recover
 732                         fi
 733                         mv new $i
 734                 fi
 735         done
 736 else
 737         for i in * ; do
 738                 if test ! -d $i && (grep sanitize-cygnus $i > /dev/null) ; then
 739                         if [ -n "${verbose}" ] ; then
 740                                 echo Removing traces of \"cygnus\" from $i...
 741                         fi
 742                         cp $i new
 743                         sed '/start\-sanitize\-cygnus/,/end-\sanitize\-cygnus/d' < $i > new
 744                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 745                                 if [ -n "${verbose}" ] ; then
 746                                         echo Caching $i in .Recover...
 747                                 fi
 748                                 mv $i .Recover
 749                         fi
 750                         mv new $i
 751                 fi
 752         done
 753 fi
 754
 755
 756 # Do this check LAST!
 757 for i in * ; do
 758         if test ! -d $i && (grep sanitize $i > /dev/null) ; then
 759                 echo '***' Some mentions of Sanitize are still left in $i! 1>&2
 760                 exit 1
 761         fi
 762 done
 763
 764 # eof