.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 ispell
  56         ld less libg++ libgcc libgloss libiberty libio
  57         librx 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} 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 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
 121 # This top-level directory is special.  We often check out only subsets
 122 # of this directory, and complaining about directories or files we didn't
 123 # check out just gets obnoxious.
 124
 125 list="`(for i in ${keep_these_too}; do echo $i ; done) | sort -u`"
 126 keep_these_too=
 127
 128 for file in $list ; do
 129         if [ -r $file ] || [ -d $file ] ; then
 130                 keep_these_too="${keep_these_too} $file"
 131         fi
 132 done
 133
 134 list="`(for i in ${lose_these_too}; do echo $i ; done) | sort -u` "
 135 lose_these_too=
 136
 137 for file in $list ; do
 138         if [ -r $file ] || [ -d $file ] ; then
 139                 lose_these_too="${lose_these_too} $file"
 140         fi
 141 done
 142
 143 # All files listed between the "Things-to-keep:" line and the
 144 # "Do-last:" line will be kept.  All other files will be removed.
 145 # Directories listed in this section will have their own Sanitize
 146 # called.  Directories not listed will be removed in their entirety
 147 # with rm -rf.
 148
 149 Things-to-keep:
 150
 151 COPYING
 152 ChangeLog
 153 Makefile.in
 154 README
 155 config.guess
 156 config.sub
 157 configure
 158 configure.in
 159
 160 Things-to-lose:
 161
 162 # Not sure we want to include mkdep in releases yet.
 163 mkdep
 164
 165 # The lines between the "Do-last:" line and the end of the file
 166 # are executed as a /bin/sh shell script after everything else is
 167 # done.
 168
 169 Do-last:
 170
 171 # Don't try to clean directories here, as the 'mv' command will fail.
 172 # Also, grep fails on NFS mounted directories.
 173
 174 if ( echo $* | egrep verbose > /dev/null ) ; then
 175         verbose=true
 176 else
 177         verbose=
 178 fi
 179
 180 # Remove "sanitize-Sanitize" lines.
 181 if [ -n "${verbose}" ] ; then
 182         echo Cleaning unconditional sanitizations out of Makefile.in...
 183 fi
 184 cp Makefile.in new
 185 sed '/start\-sanitize\-Sanitize/,/end-\sanitize\-Sanitize/d' < Makefile.in > new
 186 if [ -n "${safe}" -a ! -f .Recover/Makefile.in ] ; then
 187         mv Makefile.in .Recover
 188 fi
 189 mv new Makefile.in
 190
 191 if [ -n "${verbose}" ] ; then
 192         echo Thawing away the \"chill\"...
 193 fi
 194
 195 if ( echo $* | grep keep\-chill > /dev/null ) ; then
 196         for i in * ; do
 197                 if test ! -d $i && (grep sanitize-chill $i > /dev/null) ; then
 198                         if [ -n "${verbose}" ] ; then
 199                                 echo Keeping chill stuff in $i
 200                         fi
 201                 fi
 202         done
 203 else
 204         for i in * ; do
 205                 if test ! -d $i && (grep sanitize-chill $i > /dev/null) ; then
 206                         if [ -n "${verbose}" ] ; then
 207                                 echo Thawing the \"chill\" out of $i...
 208                         fi
 209                         cp $i new
 210                         sed '/start\-sanitize\-chill/,/end-\sanitize\-chill/d' < $i > new
 211                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 212                                 if [ -n "${verbose}" ] ; then
 213                                         echo Caching $i in .Recover...
 214                                 fi
 215                                 mv $i .Recover
 216                         fi
 217                         mv new $i
 218                 fi
 219         done
 220 fi
 221
 222 if [ -n "${verbose}" ] ; then
 223         echo Processing \"d30v\"...
 224 fi
 225
 226 d30v_files="ChangeLog config.sub configure.in"
 227
 228 if ( echo $* | grep keep\-d30v > /dev/null ) ; then
 229         for i in $d30v_files ; do
 230                 if test ! -d $i && (grep sanitize-d30v $i > /dev/null) ; then
 231                         if [ -n "${verbose}" ] ; then
 232                                 echo Keeping d30v stuff in $i
 233                         fi
 234                 fi
 235         done
 236 else
 237         for i in * ; do
 238                 if test ! -d $i && (grep sanitize-d30v $i > /dev/null) ; then
 239                         if [ -n "${verbose}" ] ; then
 240                                 echo Removing traces of \"d30v\" from $i...
 241                         fi
 242                         cp $i new
 243                         sed '/start\-sanitize\-d30v/,/end-\sanitize\-d30v/d' < $i > new
 244                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 245                                 if [ -n "${verbose}" ] ; then
 246                                         echo Caching $i in .Recover...
 247                                 fi
 248                                 mv $i .Recover
 249                         fi
 250                         mv new $i
 251                 fi
 252         done
 253 fi
 254
 255 if [ -n "${verbose}" ] ; then
 256         echo Processing \"v850\"...
 257 fi
 258
 259 v850_files="ChangeLog config.sub configure.in"
 260
 261 if ( echo $* | grep keep\-v850e > /dev/null ) ; then
 262         for i in $v850_files ; do
 263                 if test ! -d $i && (grep sanitize-v850e $i > /dev/null) ; then
 264                         if [ -n "${verbose}" ] ; then
 265                                 echo Keeping v850e stuff in $i
 266                         fi
 267                 fi
 268         done
 269 else
 270         for i in * ; do
 271                 if test ! -d $i && (grep sanitize-v850e $i > /dev/null) ; then
 272                         if [ -n "${verbose}" ] ; then
 273                                 echo Removing traces of \"v850e\" from $i...
 274                         fi
 275                         cp $i new
 276                         sed '/start\-sanitize\-v850e/,/end-\sanitize\-v850e/d' < $i > new
 277                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 278                                 if [ -n "${verbose}" ] ; then
 279                                         echo Caching $i in .Recover...
 280                                 fi
 281                                 mv $i .Recover
 282                         fi
 283                         mv new $i
 284                 fi
 285         done
 286 fi
 287
 288 r5900_files="ChangeLog config.sub configure.in"
 289
 290 if ( echo $* | grep keep\-r5900 > /dev/null ) ; then
 291         for i in $r5900_files ; do
 292                 if test ! -d $i && (grep sanitize-r5900 $i > /dev/null) ; then
 293                         if [ -n "${verbose}" ] ; then
 294                                 echo Keeping r5900 stuff in $i
 295                         fi
 296                 fi
 297         done
 298 else
 299         for i in * ; do
 300                 if test ! -d $i && (grep sanitize-r5900 $i > /dev/null) ; then
 301                         if [ -n "${verbose}" ] ; then
 302                                 echo Removing traces of \"r5900\" from $i...
 303                         fi
 304                         cp $i new
 305                         sed '/start\-sanitize\-r5900/,/end-\sanitize\-r5900/d' < $i > new
 306                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 307                                 if [ -n "${verbose}" ] ; then
 308                                         echo Caching $i in .Recover...
 309                                 fi
 310                                 mv $i .Recover
 311                         fi
 312                         mv new $i
 313                 fi
 314         done
 315 fi
 316
 317 vr4320_files="ChangeLog config.sub"
 318
 319 if ( echo $* | grep keep\-vr4320 > /dev/null ) ; then
 320         for i in $vr4320_files ; do
 321                 if test ! -d $i && (grep sanitize-vr4320 $i > /dev/null) ; then
 322                         if [ -n "${verbose}" ] ; then
 323                                 echo Keeping vr4320 stuff in $i
 324                         fi
 325                 fi
 326         done
 327 else
 328         for i in * ; do
 329                 if test ! -d $i && (grep sanitize-vr4320 $i > /dev/null) ; then
 330                         if [ -n "${verbose}" ] ; then
 331                                 echo Removing traces of \"vr4320\" from $i...
 332                         fi
 333                         cp $i new
 334                         sed '/start\-sanitize\-vr4320/,/end-\sanitize\-vr4320/d' < $i > new
 335                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 336                                 if [ -n "${verbose}" ] ; then
 337                                         echo Caching $i in .Recover...
 338                                 fi
 339                                 mv $i .Recover
 340                         fi
 341                         mv new $i
 342                 fi
 343         done
 344 fi
 345
 346 tx19_files="ChangeLog config.sub"
 347
 348 if ( echo $* | grep keep\-tx19 > /dev/null ) ; then
 349         for i in $tx19_files ; do
 350                 if test ! -d $i && (grep sanitize-tx19 $i > /dev/null) ; then
 351                         if [ -n "${verbose}" ] ; then
 352                                 echo Keeping tx19 stuff in $i
 353                         fi
 354                 fi
 355         done
 356 else
 357         for i in * ; do
 358                 if test ! -d $i && (grep sanitize-tx19 $i > /dev/null) ; then
 359                         if [ -n "${verbose}" ] ; then
 360                                 echo Removing traces of \"tx19\" from $i...
 361                         fi
 362                         cp $i new
 363                         sed '/start\-sanitize\-tx19/,/end-\sanitize\-tx19/d' < $i > new
 364                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 365                                 if [ -n "${verbose}" ] ; then
 366                                         echo Caching $i in .Recover...
 367                                 fi
 368                                 mv $i .Recover
 369                         fi
 370                         mv new $i
 371                 fi
 372         done
 373 fi
 374
 375 tx49_files="ChangeLog config.sub"
 376
 377 if ( echo $* | grep keep\-tx49 > /dev/null ) ; then
 378         for i in $tx49_files ; do
 379                 if test ! -d $i && (grep sanitize-tx49 $i > /dev/null) ; then
 380                         if [ -n "${verbose}" ] ; then
 381                                 echo Keeping tx49 stuff in $i
 382                         fi
 383                 fi
 384         done
 385 else
 386         for i in * ; do
 387                 if test ! -d $i && (grep sanitize-tx49 $i > /dev/null) ; then
 388                         if [ -n "${verbose}" ] ; then
 389                                 echo Removing traces of \"tx49\" from $i...
 390                         fi
 391                         cp $i new
 392                         sed '/start\-sanitize\-tx49/,/end-\sanitize\-tx49/d' < $i > new
 393                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 394                                 if [ -n "${verbose}" ] ; then
 395                                         echo Caching $i in .Recover...
 396                                 fi
 397                                 mv $i .Recover
 398                         fi
 399                         mv new $i
 400                 fi
 401         done
 402 fi
 403
 404 tic80_files="ChangeLog config.sub configure.in"
 405
 406 if ( echo $* | grep keep\-tic80 > /dev/null ) ; then
 407         for i in $tic80_files ; do
 408                 if test ! -d $i && (grep sanitize-tic80 $i > /dev/null) ; then
 409                         if [ -n "${verbose}" ] ; then
 410                                 echo Keeping tic80 stuff in $i
 411                         fi
 412                 fi
 413         done
 414 else
 415         for i in * ; do
 416                 if test ! -d $i && (grep sanitize-tic80 $i > /dev/null) ; then
 417                         if [ -n "${verbose}" ] ; then
 418                                 echo Removing traces of \"tic80\" from $i...
 419                         fi
 420                         cp $i new
 421                         sed '/start\-sanitize\-tic80/,/end-\sanitize\-tic80/d' < $i > new
 422                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 423                                 if [ -n "${verbose}" ] ; then
 424                                         echo Caching $i in .Recover...
 425                                 fi
 426                                 mv $i .Recover
 427                         fi
 428                         mv new $i
 429                 fi
 430         done
 431 fi
 432
 433 sky_files="ChangeLog config.sub configure.in"
 434
 435 if ( echo $* | grep keep\-sky > /dev/null ) ; then
 436         for i in $sky_files ; do
 437                 if test ! -d $i && (grep sanitize-sky $i > /dev/null) ; then
 438                         if [ -n "${verbose}" ] ; then
 439                                 echo Keeping sky stuff in $i
 440                         fi
 441                 fi
 442         done
 443 else
 444         for i in * ; do
 445                 if test ! -d $i && (grep sanitize-sky $i > /dev/null) ; then
 446                         if [ -n "${verbose}" ] ; then
 447                                 echo Removing traces of \"sky\" from $i...
 448                         fi
 449                         cp $i new
 450                         sed '/start\-sanitize\-sky/,/end-\sanitize\-sky/d' < $i > new
 451                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 452                                 if [ -n "${verbose}" ] ; then
 453                                         echo Caching $i in .Recover...
 454                                 fi
 455                                 mv $i .Recover
 456                         fi
 457                         mv new $i
 458                 fi
 459         done
 460 fi
 461
 462 if ( echo $* | grep keep\-ide > /dev/null ) ; then
 463         for i in * ; do
 464                 if test ! -d $i && (grep sanitize-ide $i > /dev/null) ; then
 465                         if [ -n "${verbose}" ] ; then
 466                                 echo Keeping ide stuff in $i
 467                         fi
 468                 fi
 469         done
 470 else
 471         for i in * ; do
 472                 if test ! -d $i && (grep sanitize-ide $i > /dev/null) ; then
 473                         if [ -n "${verbose}" ] ; then
 474                                 echo Removing traces of \"ide\" from $i...
 475                         fi
 476                         cp $i new
 477                         sed '/start\-sanitize\-ide/,/end-\sanitize\-ide/d' < $i > new
 478                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 479                                 if [ -n "${verbose}" ] ; then
 480                                         echo Caching $i in .Recover...
 481                                 fi
 482                                 mv $i .Recover
 483                         fi
 484                         mv new $i
 485                 fi
 486         done
 487 fi
 488
 489 if ( echo $* | grep lose\-gdbtk > /dev/null ) ; then
 490         if [ -n "${verbose}" ] ; then
 491                 echo Catering to RMS by removing traces of \"gdbtk\"...
 492         fi
 493         for i in * ; do
 494                 if test ! -d $i && (grep sanitize-gdbtk $i > /dev/null) ; then
 495                         if [ -n "${verbose}" ] ; then
 496                                 echo Removing traces of \"gdbtk\" from $i...
 497                         fi
 498                         cp $i new
 499                         sed '/start\-sanitize\-gdbtk/,/end-\sanitize\-gdbtk/d' < $i > new
 500                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 501                                 if [ -n "${verbose}" ] ; then
 502                                         echo Caching $i in .Recover...
 503                                 fi
 504                                 mv $i .Recover
 505                         fi
 506                         mv new $i
 507                 fi
 508         done
 509         cp Makefile.in new
 510         sed -e '/GDBTK_SUPPORT_DIRS=/d' -e 's/ $(GDBTK_SUPPORT_DIRS)//' < Makefile.in > new
 511         if [ -n "${safe}" -a ! -f .Recover/Makefile.in ] ; then
 512                 if [ -n "${verbose}" ] ; then
 513                         echo Caching Makefile.in in .Recover...
 514                 fi
 515                 mv Makefile.in .Recover
 516         fi
 517         mv new Makefile.in
 518 else
 519         if [ -n "${verbose}" ] ; then
 520                 echo Leaving \"gdbtk\" in the sources...
 521         fi
 522         for i in * ; do
 523                 if test ! -d $i && (grep sanitize-gdbtk $i > /dev/null) ; then
 524                         if [ -n "${verbose}" ] ; then
 525                                 echo Keeping \"gdbtk\" stuff in $i, but editing out sanitize lines...
 526                         fi
 527                         cp $i new
 528                         sed -e '/start\-sanitize\-gdbtk/d' -e '/end\-sanitize\-gdbtk/d' < $i > new
 529                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 530                                 if [ -n "${verbose}" ] ; then
 531                                         echo Caching $i in .Recover...
 532                                 fi
 533                                 mv $i .Recover
 534                         fi
 535                         mv new $i
 536                 fi
 537         done
 538 fi
 539
 540 if ( echo $* | grep lose\-mswin > /dev/null ) ; then
 541         if [ -n "${verbose}" ] ; then
 542                 echo Removing traces of \"mswin\"...
 543         fi
 544         for i in * ; do
 545                 if test ! -d $i && (grep sanitize-mswin $i > /dev/null) ; then
 546                         if [ -n "${verbose}" ] ; then
 547                                 echo Removing traces of \"mswin\" from $i...
 548                         fi
 549                         cp $i new
 550                         sed '/start\-sanitize\-mswin/,/end-\sanitize\-mswin/d' < $i > new
 551                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 552                                 if [ -n "${verbose}" ] ; then
 553                                         echo Caching $i in .Recover...
 554                                 fi
 555                                 mv $i .Recover
 556                         fi
 557                         mv new $i
 558                 fi
 559         done
 560 else
 561         if [ -n "${verbose}" ] ; then
 562                 echo Leaving \"mswin\" in the sources...
 563         fi
 564         for i in * ; do
 565                 if test ! -d $i && (grep sanitize-mswin $i > /dev/null) ; then
 566                         if [ -n "${verbose}" ] ; then
 567                                 echo Keeping \"mswin\" stuff in $i, but editing out sanitize lines...
 568                         fi
 569                         cp $i new
 570                         sed -e '/start\-sanitize\-mswin/d' -e '/end\-sanitize\-mswin/d' < $i > new
 571                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 572                                 if [ -n "${verbose}" ] ; then
 573                                         echo Caching $i in .Recover...
 574                                 fi
 575                                 mv $i .Recover
 576                         fi
 577                         mv new $i
 578                 fi
 579         done
 580 fi
 581
 582 vr5400_files="ChangeLog config.sub"
 583
 584 if ( echo $* | grep keep\-vr5400 > /dev/null ) ; then
 585         for i in $vr5400_files ; do
 586                 if test ! -d $i && (grep sanitize-vr5400 $i > /dev/null) ; then
 587                         if [ -n "${verbose}" ] ; then
 588                                 echo Keeping vr5400 stuff in $i
 589                         fi
 590                 fi
 591         done
 592 else
 593         for i in * ; do
 594                 if test ! -d $i && (grep sanitize-vr5400 $i > /dev/null) ; then
 595                         if [ -n "${verbose}" ] ; then
 596                                 echo Removing traces of \"vr5400\" from $i...
 597                         fi
 598                         cp $i new
 599                         sed '/start\-sanitize\-vr5400/,/end-\sanitize\-vr5400/d' < $i > new
 600                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 601                                 if [ -n "${verbose}" ] ; then
 602                                         echo Caching $i in .Recover...
 603                                 fi
 604                                 mv $i .Recover
 605                         fi
 606                         mv new $i
 607                 fi
 608         done
 609 fi
 610
 611 m32rx_files="ChangeLog config-ml.in"
 612 if ( echo $* | grep keep\-m32rx > /dev/null ) ; then
 613         for i in $m32rx_files ; do
 614                 if test ! -d $i && (grep sanitize-m32rx $i > /dev/null) ; then
 615                         if [ -n "${verbose}" ] ; then
 616                                 echo Keeping m32rx stuff in $i
 617                         fi
 618                 fi
 619         done
 620 else
 621         for i in * ; do
 622                 if test ! -d $i && (grep sanitize-m32rx $i > /dev/null) ; then
 623                         if [ -n "${verbose}" ] ; then
 624                                 echo Removing traces of \"m32rx\" from $i...
 625                         fi
 626                         cp $i new
 627                         sed '/start\-sanitize\-m32rx/,/end-\sanitize\-m32rx/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 kcygnus_files="configure"
 640 if ( echo $* | grep keep\-cygnus > /dev/null ) ; then
 641         for i in $kcygnus_files ; do
 642                 if test ! -d $i && (grep sanitize-cygnus $i > /dev/null) ; then
 643                         if [ -n "${verbose}" ] ; then
 644                                 echo Keeping Cygnus stuff in $i
 645                         fi
 646                         cp $i new
 647                         grep -v sanitize-cygnus $i > new
 648                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 649                                 if [ -n "${verbose}" ] ; then
 650                                         echo Caching $i in .Recover...
 651                                 fi
 652                                 mv $i .Recover
 653                         fi
 654                         mv new $i
 655                 fi
 656         done
 657 else
 658         for i in * ; do
 659                 if test ! -d $i && (grep sanitize-cygnus $i > /dev/null) ; then
 660                         if [ -n "${verbose}" ] ; then
 661                                 echo Removing traces of \"cygnus\" from $i...
 662                         fi
 663                         cp $i new
 664                         sed '/start\-sanitize\-cygnus/,/end-\sanitize\-cygnus/d' < $i > new
 665                         if [ -n "${safe}" -a ! -f .Recover/$i ] ; then
 666                                 if [ -n "${verbose}" ] ; then
 667                                         echo Caching $i in .Recover...
 668                                 fi
 669                                 mv $i .Recover
 670                         fi
 671                         mv new $i
 672                 fi
 673         done
 674 fi
 675
 676
 677 # Do this check LAST!
 678 for i in * ; do
 679         if test ! -d $i && (grep sanitize $i > /dev/null) ; then
 680                 echo '***' Some mentions of Sanitize are still left in $i! 1>&2
 681                 exit 1
 682         fi
 683 done
 684
 685 # eof