Makefile.in

   1 #
   2 # Makefile for directory with subdirs to build.
   3 #   Copyright (C) 1990, 1991, 1992 Free Software Foundation
   4 #
   5 # This file is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 2 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18 #
  19
  20 srcdir = .
  21
  22 prefix = /usr/local
  23
  24 exec_prefix = $(prefix)
  25 bindir = $(exec_prefix)/bin
  26 libdir = $(exec_prefix)/lib
  27
  28 datadir = $(prefix)/lib
  29 mandir = $(prefix)/man
  30 man1dir = $(mandir)/man1
  31 man2dir = $(mandir)/man2
  32 man3dir = $(mandir)/man3
  33 man4dir = $(mandir)/man4
  34 man5dir = $(mandir)/man5
  35 man6dir = $(mandir)/man6
  36 man7dir = $(mandir)/man7
  37 man8dir = $(mandir)/man8
  38 man9dir = $(mandir)/man9
  39 infodir = $(prefix)/info
  40 includedir = $(prefix)/include
  41 docdir = $(datadir)/doc
  42
  43 SHELL = /bin/sh
  44
  45 INSTALL = install -c
  46 INSTALL_PROGRAM = $(INSTALL)
  47 INSTALL_DATA = $(INSTALL)
  48
  49 AR = ar
  50 AR_FLAGS = qc
  51 RANLIB = ranlib
  52
  53 BISON = `if [ -d $${rootme}/bison ] ; \
  54         then echo $${rootme}/bison/bison -L $${rootme}/bison/ -y ; \
  55         else echo bison -y ; fi`
  56
  57 MAKEINFO = `if [ -d $${rootme}/texinfo/C ] ; \
  58         then echo $${rootme}/texinfo/C/makeinfo ; \
  59         else echo makeinfo ; fi`
  60
  61 SUBDIRS = libiberty glob readline bfd gdb binutils ld gas gcc libg++ libgcc clib newlib
  62 OTHERS =
  63
  64 ALL = all.normal
  65 INSTALL_TARGET = install.all
  66
  67 ### for debugging
  68 #GCCVERBOSE=-v
  69
  70
  71 #### host and target specific makefile fragments come in here.
  72 ###
  73
  74 .PHONY: all info install-info clean-info
  75
  76 all:    $(ALL)
  77
  78 info:   cfg-paper.info configure.info
  79         rootme=`pwd` ; export rootme ; $(MAKE) subdir_do DO=info "DODIRS=$(SUBDIRS)" "MAKEINFO=$(MAKEINFO)"
  80
  81 check:; rootme=`pwd` ; export rootme ; $(MAKE) subdir_do DO=check \
  82         "DODIRS=`echo $(SUBDIRS) | sed -e \"s/libg\+\+//\"" \
  83         "MAKEINFO=$(MAKEINFO)"
  84         if [ -d libg++ ] ; then \
  85                 rootme=`pwd` ; export rootme ; \
  86                 (cd libg++ ; \
  87                  $(MAKE) check "CC=$${rootme}/gcc/gcc \
  88                  -B$${rootme}/gcc/") ; \
  89         fi
  90
  91
  92 clean-info:
  93         $(MAKE) subdir_do DO=clean-info "DODIRS=$(SUBDIRS)"
  94         rm -f cfg-paper.info* configure.info*
  95
  96 cfg-paper.info: cfg-paper.texi
  97         rootme=`pwd` ; export rootme ; $(MAKEINFO) -o cfg-paper.info $(srcdir)/cfg-paper.texi
  98
  99 configure.info: configure.texi
 100         rootme=`pwd` ; export rootme ; $(MAKEINFO) -o configure.info $(srcdir)/configure.texi
 101
 102 install-info: install-info-dirs force
 103         [ -d $(infodir) ] || mkdir $(infodir)
 104         $(MAKE) subdir_do DO=install-info "DODIRS=$(SUBDIRS)"
 105         $(INSTALL_DATA) cfg-paper.info $(infodir)/cfg-paper.info
 106         $(INSTALL_DATA) configure.info $(infodir)/configure.info
 107         $(MAKE) dir.info install-dir.info
 108
 109 install-dir.info:
 110         $(INSTALL_DATA) dir.info $(infodir)/dir.info
 111
 112 # clib send_pr
 113 #       all-libgcc
 114 all.normal: .stmp-texinfo .stmp-bison .stmp-byacc .stmp-ld \
 115         .stmp-gas .stmp-gcc .stmp-binutils \
 116         .stmp-libg++ .stmp-gdb .stmp-make .stmp-cvs .stmp-patch .stmp-emacs \
 117         .stmp-ispell .stmp-fileutils \
 118         .stmp-newlib
 119 all.cross: .stmp-bison .stmp-ld .stmp-libgcc .stmp-gdb
 120 #       $(MAKE) subdir_do DO=all "DODIRS=$(SUBDIRS) $(OTHERS)"
 121
 122 clean: clean-stamps clean-libiberty clean-texinfo clean-bfd clean-newlib clean-binutils \
 123         clean-bison clean-byacc clean-ld clean-gas \
 124         clean-gcc clean-libgcc clean-readline clean-glob clean-gdb \
 125         clean-make clean-diff clean-grep clean-rcs clean-gdbm \
 126         clean-cvs clean-patch clean-emacs clean-ispell clean-fileutils \
 127         clean-libg++
 128         -rm -rf *.a TEMP errs core *.o *~ \#* TAGS *.E
 129
 130 clean-stamps:
 131         -rm -f .stmp-*
 132
 133 install: $(INSTALL_TARGET) $(srcdir)/configure.man
 134         $(INSTALL_DATA) $(srcdir)/configure.man $(man1dir)/configure.1
 135
 136 install.all: install-dirs install-libiberty install-texinfo \
 137         install-bfd install-binutils install-bison install-byacc \
 138         install-ld install-gas install-gcc \
 139         install-libgcc install-readline install-glob install-gdb \
 140         install-make install-cvs install-patch install-emacs \
 141         install-ispell install-fileutils install-libg++ install-newlib
 142
 143 install.cross: install-dirs install-libiberty install-binutils install-bison \
 144         install-byacc install-ld install-gas install-libgcc \
 145         install-readline install-glob install-gdb
 146
 147 ### libiberty
 148 all-libiberty: .stmp-libiberty
 149 .stmp-libiberty:
 150         if [ -d ./libiberty ] ; then \
 151                 rootme=`pwd` ; export rootme ; \
 152                 (cd ./libiberty; \
 153                 $(MAKE) \
 154                         "against=$(against)" \
 155                         "AR=$(AR)" \
 156                         "AR_FLAGS=$(AR_FLAGS)" \
 157                         "CC=$(CC)" \
 158                         "RANLIB=$(RANLIB)" \
 159                         "LOADLIBES=$(LOADLIBES)" \
 160                         "LDFLAGS=$(LDFLAGS)" \
 161                         "BISON=$(BISON)" \
 162                         "MAKEINFO=$(MAKEINFO)" \
 163                         all) ; \
 164         else \
 165                 true ; \
 166         fi
 167         touch .stmp-libiberty
 168
 169 clean-libiberty: force
 170         if [ -d ./libiberty ] ; then \
 171                 rootme=`pwd` ; export rootme ; \
 172                 (cd ./libiberty; \
 173                 $(MAKE) \
 174                         "against=$(against)" \
 175                         "AR=$(AR)" \
 176                         "AR_FLAGS=$(AR_FLAGS)" \
 177                         "CC=$(CC)" \
 178                         "RANLIB=$(RANLIB)" \
 179                         "LOADLIBES=$(LOADLIBES)" \
 180                         "LDFLAGS=$(LDFLAGS)" \
 181                         "BISON=$(BISON)" \
 182                         "MAKEINFO=$(MAKEINFO)" \
 183                         clean) ; \
 184         else \
 185                 true ; \
 186         fi
 187
 188 install-libiberty: force
 189         if [ -d ./libiberty ] ; then \
 190                 rootme=`pwd` ; export rootme ; \
 191                 (cd ./libiberty; \
 192                 $(MAKE) \
 193                         "against=$(against)" \
 194                         "AR=$(AR)" \
 195                         "AR_FLAGS=$(AR_FLAGS)" \
 196                         "CC=$(CC)" \
 197                         "RANLIB=$(RANLIB)" \
 198                         "LOADLIBES=$(LOADLIBES)" \
 199                         "LDFLAGS=$(LDFLAGS)" \
 200                         "BISON=$(BISON)" \
 201                         "MAKEINFO=$(MAKEINFO)" \
 202                         install) ; \
 203         else \
 204                 true ; \
 205         fi
 206
 207 ### texinfo
 208 all-texinfo: .stmp-libiberty .stmp-texinfo
 209 .stmp-texinfo:
 210         if [ -d ./texinfo ] ; then \
 211                 rootme=`pwd` ; export rootme ; \
 212                 rootme=`pwd` ; export rootme ; \
 213                 (cd ./texinfo; \
 214                 $(MAKE) \
 215                         "against=$(against)" \
 216                         "AR=$(AR)" \
 217                         "AR_FLAGS=$(AR_FLAGS)" \
 218                         "CC=$(CC)" \
 219                         "RANLIB=$(RANLIB)" \
 220                         "LOADLIBES=$(LOADLIBES)" \
 221                         "LDFLAGS=$(LDFLAGS)" \
 222                         "BISON=$(BISON)" \
 223                         "MAKEINFO=$(MAKEINFO)" \
 224                         all) ; \
 225         else \
 226                 true ; \
 227         fi
 228         touch .stmp-texinfo
 229
 230 clean-texinfo: force
 231         if [ -d ./texinfo ] ; then \
 232                 rootme=`pwd` ; export rootme ; \
 233                 (cd ./texinfo; \
 234                 $(MAKE) \
 235                         "against=$(against)" \
 236                         "AR=$(AR)" \
 237                         "AR_FLAGS=$(AR_FLAGS)" \
 238                         "CC=$(CC)" \
 239                         "RANLIB=$(RANLIB)" \
 240                         "LOADLIBES=$(LOADLIBES)" \
 241                         "LDFLAGS=$(LDFLAGS)" \
 242                         "BISON=$(BISON)" \
 243                         "MAKEINFO=$(MAKEINFO)" \
 244                         clean) ; \
 245         else \
 246                 true ; \
 247         fi
 248
 249 install-texinfo: force
 250         if [ -d ./texinfo ] ; then \
 251                 rootme=`pwd` ; export rootme ; \
 252                 (cd ./texinfo; \
 253                 $(MAKE) \
 254                         "against=$(against)" \
 255                         "AR=$(AR)" \
 256                         "AR_FLAGS=$(AR_FLAGS)" \
 257                         "CC=$(CC)" \
 258                         "RANLIB=$(RANLIB)" \
 259                         "LOADLIBES=$(LOADLIBES)" \
 260                         "LDFLAGS=$(LDFLAGS)" \
 261                         "BISON=$(BISON)" \
 262                         "MAKEINFO=$(MAKEINFO)" \
 263                         install) ; \
 264         else \
 265                 true ; \
 266         fi
 267
 268 ### bfd
 269 all-bfd: .stmp-bfd
 270 .stmp-bfd:
 271         if [ -d ./bfd ] ; then \
 272                 rootme=`pwd` ; export rootme ; \
 273                 (cd ./bfd; \
 274                 $(MAKE) \
 275                         "against=$(against)" \
 276                         "AR=$(AR)" \
 277                         "AR_FLAGS=$(AR_FLAGS)" \
 278                         "CC=$(CC)" \
 279                         "RANLIB=$(RANLIB)" \
 280                         "LOADLIBES=$(LOADLIBES)" \
 281                         "LDFLAGS=$(LDFLAGS)" \
 282                         "BISON=$(BISON)" \
 283                         "MAKEINFO=$(MAKEINFO)" \
 284                         all) ; \
 285         else \
 286                 true ; \
 287         fi
 288         touch .stmp-bfd
 289
 290 clean-bfd: force
 291         if [ -d ./bfd ] ; then \
 292                 rootme=`pwd` ; export rootme ; \
 293                 (cd ./bfd; \
 294                 $(MAKE) \
 295                         "against=$(against)" \
 296                         "AR=$(AR)" \
 297                         "AR_FLAGS=$(AR_FLAGS)" \
 298                         "CC=$(CC)" \
 299                         "RANLIB=$(RANLIB)" \
 300                         "LOADLIBES=$(LOADLIBES)" \
 301                         "LDFLAGS=$(LDFLAGS)" \
 302                         "BISON=$(BISON)" \
 303                         "MAKEINFO=$(MAKEINFO)" \
 304                         clean) ; \
 305         else \
 306                 true ; \
 307         fi
 308
 309 install-bfd: force
 310         if [ -d ./bfd ] ; then \
 311                 rootme=`pwd` ; export rootme ; \
 312                 (cd ./bfd; \
 313                 $(MAKE) \
 314                         "against=$(against)" \
 315                         "AR=$(AR)" \
 316                         "AR_FLAGS=$(AR_FLAGS)" \
 317                         "CC=$(CC)" \
 318                         "RANLIB=$(RANLIB)" \
 319                         "LOADLIBES=$(LOADLIBES)" \
 320                         "LDFLAGS=$(LDFLAGS)" \
 321                         "BISON=$(BISON)" \
 322                         "MAKEINFO=$(MAKEINFO)" \
 323                         install) ; \
 324         else \
 325                 true ; \
 326         fi
 327
 328 ### binutils
 329 all-binutils: .stmp-libiberty .stmp-bfd .stmp-binutils
 330 .stmp-binutils:
 331         if [ -d ./binutils ] ; then \
 332                 rootme=`pwd` ; export rootme ; \
 333                 (cd ./binutils; \
 334                 $(MAKE) \
 335                         "against=$(against)" \
 336                         "AR=$(AR)" \
 337                         "AR_FLAGS=$(AR_FLAGS)" \
 338                         "CC=$(CC)" \
 339                         "RANLIB=$(RANLIB)" \
 340                         "LOADLIBES=$(LOADLIBES)" \
 341                         "LDFLAGS=$(LDFLAGS)" \
 342                         "BISON=$(BISON)" \
 343                         "MAKEINFO=$(MAKEINFO)" \
 344                         all) ; \
 345         else \
 346                 true ; \
 347         fi
 348         touch .stmp-binutils
 349
 350 clean-binutils: force
 351         if [ -d ./binutils ] ; then \
 352                 rootme=`pwd` ; export rootme ; \
 353                 (cd ./binutils; \
 354                 $(MAKE) \
 355                         "against=$(against)" \
 356                         "AR=$(AR)" \
 357                         "AR_FLAGS=$(AR_FLAGS)" \
 358                         "CC=$(CC)" \
 359                         "RANLIB=$(RANLIB)" \
 360                         "LOADLIBES=$(LOADLIBES)" \
 361                         "LDFLAGS=$(LDFLAGS)" \
 362                         "BISON=$(BISON)" \
 363                         "MAKEINFO=$(MAKEINFO)" \
 364                         clean) ; \
 365         else \
 366                 true ; \
 367         fi
 368
 369 install-binutils: force
 370         if [ -d ./binutils ] ; then \
 371                 rootme=`pwd` ; export rootme ; \
 372                 (cd ./binutils; \
 373                 $(MAKE) \
 374                         "against=$(against)" \
 375                         "AR=$(AR)" \
 376                         "AR_FLAGS=$(AR_FLAGS)" \
 377                         "CC=$(CC)" \
 378                         "RANLIB=$(RANLIB)" \
 379                         "LOADLIBES=$(LOADLIBES)" \
 380                         "LDFLAGS=$(LDFLAGS)" \
 381                         "BISON=$(BISON)" \
 382                         "MAKEINFO=$(MAKEINFO)" \
 383                         install) ; \
 384         else \
 385                 true ; \
 386         fi
 387
 388 ### newlib
 389 all-newlib: .stmp-newlib
 390 .stmp-newlib:
 391         if [ -d ./newlib ] ; then \
 392                 rootme=`pwd` ; export rootme ; \
 393                 (cd ./newlib; \
 394                 $(MAKE) \
 395                         "against=$(against)" \
 396                         "AR=$(AR)" \
 397                         "AR_FLAGS=$(AR_FLAGS)" \
 398                         "CC=$(CC)" \
 399                         "RANLIB=$(RANLIB)" \
 400                         "LOADLIBES=$(LOADLIBES)" \
 401                         "LDFLAGS=$(LDFLAGS)" \
 402                         "BISON=$(BISON)" \
 403                         "MAKEINFO=$(MAKEINFO)" \
 404                         all) ; \
 405         else \
 406                 true ; \
 407         fi
 408         touch .stmp-newlib
 409
 410 clean-newlib: force
 411         if [ -d ./newlib ] ; then \
 412                 rootme=`pwd` ; export rootme ; \
 413                 (cd ./newlib; \
 414                 $(MAKE) \
 415                         "against=$(against)" \
 416                         "AR=$(AR)" \
 417                         "AR_FLAGS=$(AR_FLAGS)" \
 418                         "CC=$(CC)" \
 419                         "RANLIB=$(RANLIB)" \
 420                         "LOADLIBES=$(LOADLIBES)" \
 421                         "LDFLAGS=$(LDFLAGS)" \
 422                         "BISON=$(BISON)" \
 423                         "MAKEINFO=$(MAKEINFO)" \
 424                         clean) ; \
 425         else \
 426                 true ; \
 427         fi
 428
 429 install-newlib: force
 430         if [ -d ./newlib ] ; then \
 431                 rootme=`pwd` ; export rootme ; \
 432                 (cd ./newlib; \
 433                 $(MAKE) \
 434                         "against=$(against)" \
 435                         "AR=$(AR)" \
 436                         "AR_FLAGS=$(AR_FLAGS)" \
 437                         "CC=$(CC)" \
 438                         "RANLIB=$(RANLIB)" \
 439                         "LOADLIBES=$(LOADLIBES)" \
 440                         "LDFLAGS=$(LDFLAGS)" \
 441                         "BISON=$(BISON)" \
 442                         "MAKEINFO=$(MAKEINFO)" \
 443                         install) ; \
 444         else \
 445                 true ; \
 446         fi
 447
 448 ### byacc
 449 all-byacc: .stmp-byacc
 450 .stmp-byacc:
 451         if [ -d ./byacc ] ; then \
 452                 rootme=`pwd` ; export rootme ; \
 453                 (cd ./byacc; \
 454                 $(MAKE) \
 455                         "against=$(against)" \
 456                         "AR=$(AR)" \
 457                         "AR_FLAGS=$(AR_FLAGS)" \
 458                         "CC=$(CC)" \
 459                         "RANLIB=$(RANLIB)" \
 460                         "LOADLIBES=$(LOADLIBES)" \
 461                         "LDFLAGS=$(LDFLAGS)" \
 462                         "BISON=$(BISON)" \
 463                         "MAKEINFO=$(MAKEINFO)" \
 464                         all) ; \
 465         else \
 466                 true ; \
 467         fi
 468         touch .stmp-byacc
 469
 470 clean-byacc: force
 471         if [ -d ./byacc ] ; then \
 472                 rootme=`pwd` ; export rootme ; \
 473                 (cd ./byacc; \
 474                 $(MAKE) \
 475                         "against=$(against)" \
 476                         "AR=$(AR)" \
 477                         "AR_FLAGS=$(AR_FLAGS)" \
 478                         "CC=$(CC)" \
 479                         "RANLIB=$(RANLIB)" \
 480                         "LOADLIBES=$(LOADLIBES)" \
 481                         "LDFLAGS=$(LDFLAGS)" \
 482                         "BISON=$(BISON)" \
 483                         "MAKEINFO=$(MAKEINFO)" \
 484                         clean) ; \
 485         else \
 486                 true ; \
 487         fi
 488
 489 install-byacc: force
 490         if [ -d ./byacc ] ; then \
 491                 rootme=`pwd` ; export rootme ; \
 492                 (cd ./byacc; \
 493                 $(MAKE) \
 494                         "against=$(against)" \
 495                         "AR=$(AR)" \
 496                         "AR_FLAGS=$(AR_FLAGS)" \
 497                         "CC=$(CC)" \
 498                         "RANLIB=$(RANLIB)" \
 499                         "LOADLIBES=$(LOADLIBES)" \
 500                         "LDFLAGS=$(LDFLAGS)" \
 501                         "BISON=$(BISON)" \
 502                         "MAKEINFO=$(MAKEINFO)" \
 503                         install) ; \
 504         else \
 505                 true ; \
 506         fi
 507
 508 ### bison
 509 all-bison: .stmp-libiberty .stmp-bison
 510 .stmp-bison:
 511         if [ -d ./bison ] ; then \
 512                 rootme=`pwd` ; export rootme ; \
 513                 (cd ./bison; \
 514                 $(MAKE) \
 515                         "prefix=$(prefix)" \
 516                         "datadir=$(datadir)" \
 517                         "AR=$(AR)" \
 518                         "AR_FLAGS=$(AR_FLAGS)" \
 519                         "CC=$(CC)" \
 520                         "RANLIB=$(RANLIB)" \
 521                         "LOADLIBES=$(LOADLIBES)" \
 522                         "LDFLAGS=$(LDFLAGS)" \
 523                         "BISON=$(BISON)" \
 524                         "MAKEINFO=$(MAKEINFO)" \
 525                         all) ; \
 526         else \
 527                 true ; \
 528         fi
 529         touch .stmp-bison
 530
 531 clean-bison: force
 532         if [ -d ./bison ] ; then \
 533                 rootme=`pwd` ; export rootme ; \
 534                 (cd ./bison; \
 535                 $(MAKE) \
 536                         "prefix=$(prefix)" \
 537                         "datadir=$(datadir)" \
 538                         "AR=$(AR)" \
 539                         "AR_FLAGS=$(AR_FLAGS)" \
 540                         "CC=$(CC)" \
 541                         "RANLIB=$(RANLIB)" \
 542                         "LOADLIBES=$(LOADLIBES)" \
 543                         "LDFLAGS=$(LDFLAGS)" \
 544                         "BISON=$(BISON)" \
 545                         "MAKEINFO=$(MAKEINFO)" \
 546                         clean) ; \
 547         else \
 548                 true ; \
 549         fi
 550
 551 install-bison: force
 552         if [ -d ./bison ] ; then \
 553                 rootme=`pwd` ; export rootme ; \
 554                 (cd ./bison; \
 555                 $(MAKE) \
 556                         "prefix=$(prefix)" \
 557                         "datadir=$(datadir)" \
 558                         "AR=$(AR)" \
 559                         "AR_FLAGS=$(AR_FLAGS)" \
 560                         "CC=$(CC)" \
 561                         "RANLIB=$(RANLIB)" \
 562                         "LOADLIBES=$(LOADLIBES)" \
 563                         "LDFLAGS=$(LDFLAGS)" \
 564                         "BISON=$(BISON)" \
 565                         "MAKEINFO=$(MAKEINFO)" \
 566                         install) ; \
 567         else \
 568                 true ; \
 569         fi
 570
 571 ### gcc
 572 all-gcc: .stmp-libiberty .stmp-bison .stmp-gas
 573 .stmp-gcc:
 574         if [ -d ./gcc ] ; then \
 575                 rootme=`pwd` ; export rootme ; \
 576                 (cd ./gcc; \
 577                 $(MAKE) \
 578                         "against=$(against)" \
 579                         "AR=$(AR)" \
 580                         "AR_FLAGS=$(AR_FLAGS)" \
 581                         "CC=$(CC)" \
 582                         "RANLIB=$(RANLIB)" \
 583                         "LOADLIBES=$(LOADLIBES)" \
 584                         "LDFLAGS=$(LDFLAGS)" \
 585                         "BISON=$(BISON)" \
 586                         "MAKEINFO=$(MAKEINFO)" \
 587                         all) ; \
 588         else \
 589                 true ; \
 590         fi
 591         touch .stmp-gcc
 592
 593 clean-gcc: force
 594         if [ -d ./gcc ] ; then \
 595                 rootme=`pwd` ; export rootme ; \
 596                 (cd ./gcc; \
 597                 $(MAKE) \
 598                         "against=$(against)" \
 599                         "AR=$(AR)" \
 600                         "AR_FLAGS=$(AR_FLAGS)" \
 601                         "CC=$(CC)" \
 602                         "RANLIB=$(RANLIB)" \
 603                         "LOADLIBES=$(LOADLIBES)" \
 604                         "LDFLAGS=$(LDFLAGS)" \
 605                         "BISON=$(BISON)" \
 606                         "MAKEINFO=$(MAKEINFO)" \
 607                         clean) ; \
 608         else \
 609                 true ; \
 610         fi
 611
 612 install-gcc:
 613         if [ -d ./gcc ] ; then \
 614                 rootme=`pwd` ; export rootme ; \
 615                 (cd ./gcc; \
 616                 $(MAKE) \
 617                         "against=$(against)" \
 618                         "AR=$(AR)" \
 619                         "AR_FLAGS=$(AR_FLAGS)" \
 620                         "CC=$(CC)" \
 621                         "RANLIB=$(RANLIB)" \
 622                         "LOADLIBES=$(LOADLIBES)" \
 623                         "LDFLAGS=$(LDFLAGS)" \
 624                         "BISON=$(BISON)" \
 625                         "MAKEINFO=$(MAKEINFO)" \
 626                         install) ; \
 627         else \
 628                 true ; \
 629         fi
 630
 631 ### readline
 632 all-readline: .stmp-readline
 633 .stmp-readline:
 634         if [ -d ./readline ] ; then \
 635                 rootme=`pwd` ; export rootme ; \
 636                 (cd ./readline; \
 637                 $(MAKE) \
 638                         "against=$(against)" \
 639                         "AR=$(AR)" \
 640                         "AR_FLAGS=$(AR_FLAGS)" \
 641                         "CC=$(CC)" \
 642                         "RANLIB=$(RANLIB)" \
 643                         "LOADLIBES=$(LOADLIBES)" \
 644                         "LDFLAGS=$(LDFLAGS)" \
 645                         "BISON=$(BISON)" \
 646                         "MAKEINFO=$(MAKEINFO)" \
 647                         all) ; \
 648         else \
 649                 true ; \
 650         fi
 651         touch .stmp-readline
 652
 653 clean-readline: force
 654         if [ -d ./readline ] ; then \
 655                 rootme=`pwd` ; export rootme ; \
 656                 (cd ./readline; \
 657                 $(MAKE) \
 658                         "against=$(against)" \
 659                         "AR=$(AR)" \
 660                         "AR_FLAGS=$(AR_FLAGS)" \
 661                         "CC=$(CC)" \
 662                         "RANLIB=$(RANLIB)" \
 663                         "LOADLIBES=$(LOADLIBES)" \
 664                         "LDFLAGS=$(LDFLAGS)" \
 665                         "BISON=$(BISON)" \
 666                         "MAKEINFO=$(MAKEINFO)" \
 667                         clean) ; \
 668         else \
 669                 true ; \
 670         fi
 671
 672 install-readline: force
 673         if [ -d ./readline ] ; then \
 674                 rootme=`pwd` ; export rootme ; \
 675                 (cd ./readline; \
 676                 $(MAKE) \
 677                         "against=$(against)" \
 678                         "AR=$(AR)" \
 679                         "AR_FLAGS=$(AR_FLAGS)" \
 680                         "CC=$(CC)" \
 681                         "RANLIB=$(RANLIB)" \
 682                         "LOADLIBES=$(LOADLIBES)" \
 683                         "LDFLAGS=$(LDFLAGS)" \
 684                         "BISON=$(BISON)" \
 685                         "MAKEINFO=$(MAKEINFO)" \
 686                         install) ; \
 687         else \
 688                 true ; \
 689         fi
 690
 691 ### glob
 692 all-glob: .stmp-glob
 693 .stmp-glob:
 694         if [ -d ./glob ] ; then \
 695                 rootme=`pwd` ; export rootme ; \
 696                 (cd ./glob; \
 697                 $(MAKE) \
 698                         "against=$(against)" \
 699                         "AR=$(AR)" \
 700                         "AR_FLAGS=$(AR_FLAGS)" \
 701                         "CC=$(CC)" \
 702                         "RANLIB=$(RANLIB)" \
 703                         "LOADLIBES=$(LOADLIBES)" \
 704                         "LDFLAGS=$(LDFLAGS)" \
 705                         "BISON=$(BISON)" \
 706                         "MAKEINFO=$(MAKEINFO)" \
 707                         all) ; \
 708         else \
 709                 true ; \
 710         fi
 711         touch .stmp-glob
 712
 713 clean-glob: force
 714         if [ -d ./glob ] ; then \
 715                 rootme=`pwd` ; export rootme ; \
 716                 (cd ./glob; \
 717                 $(MAKE) \
 718                         "against=$(against)" \
 719                         "AR=$(AR)" \
 720                         "AR_FLAGS=$(AR_FLAGS)" \
 721                         "CC=$(CC)" \
 722                         "RANLIB=$(RANLIB)" \
 723                         "LOADLIBES=$(LOADLIBES)" \
 724                         "LDFLAGS=$(LDFLAGS)" \
 725                         "BISON=$(BISON)" \
 726                         "MAKEINFO=$(MAKEINFO)" \
 727                         clean) ; \
 728         else \
 729                 true ; \
 730         fi
 731
 732 install-glob: force
 733         if [ -d ./glob ] ; then \
 734                 rootme=`pwd` ; export rootme ; \
 735                 (cd ./glob; \
 736                 $(MAKE) \
 737                         "against=$(against)" \
 738                         "AR=$(AR)" \
 739                         "AR_FLAGS=$(AR_FLAGS)" \
 740                         "CC=$(CC)" \
 741                         "RANLIB=$(RANLIB)" \
 742                         "LOADLIBES=$(LOADLIBES)" \
 743                         "LDFLAGS=$(LDFLAGS)" \
 744                         "BISON=$(BISON)" \
 745                         "MAKEINFO=$(MAKEINFO)" \
 746                         install) ; \
 747         else \
 748                 true ; \
 749         fi
 750
 751 ### gas
 752 all-gas: .stmp-libiberty .stmp-bfd .stmp-gas
 753 .stmp-gas:
 754         if [ -d ./gas ] ; then \
 755                 rootme=`pwd` ; export rootme ; \
 756                 (cd ./gas; \
 757                 $(MAKE) \
 758                         "against=$(against)" \
 759                         "AR=$(AR)" \
 760                         "AR_FLAGS=$(AR_FLAGS)" \
 761                         "CC=$(CC)" \
 762                         "RANLIB=$(RANLIB)" \
 763                         "LOADLIBES=$(LOADLIBES)" \
 764                         "LDFLAGS=$(LDFLAGS)" \
 765                         "BISON=$(BISON)" \
 766                         "MAKEINFO=$(MAKEINFO)" \
 767                         all) ; \
 768         else \
 769                 true ; \
 770         fi
 771         touch .stmp-gas
 772
 773 clean-gas: force
 774         if [ -d ./gas ] ; then \
 775                 rootme=`pwd` ; export rootme ; \
 776                 (cd ./gas; \
 777                 $(MAKE) \
 778                         "against=$(against)" \
 779                         "AR=$(AR)" \
 780                         "AR_FLAGS=$(AR_FLAGS)" \
 781                         "CC=$(CC)" \
 782                         "RANLIB=$(RANLIB)" \
 783                         "LOADLIBES=$(LOADLIBES)" \
 784                         "LDFLAGS=$(LDFLAGS)" \
 785                         "BISON=$(BISON)" \
 786                         "MAKEINFO=$(MAKEINFO)" \
 787                         clean) ; \
 788         else \
 789                 true ; \
 790         fi
 791
 792 install-gas: force
 793         if [ -d ./gas ] ; then \
 794                 rootme=`pwd` ; export rootme ; \
 795                 (cd ./gas; \
 796                 $(MAKE) \
 797                         "against=$(against)" \
 798                         "AR=$(AR)" \
 799                         "AR_FLAGS=$(AR_FLAGS)" \
 800                         "CC=$(CC)" \
 801                         "RANLIB=$(RANLIB)" \
 802                         "LOADLIBES=$(LOADLIBES)" \
 803                         "LDFLAGS=$(LDFLAGS)" \
 804                         "BISON=$(BISON)" \
 805                         "MAKEINFO=$(MAKEINFO)" \
 806                         install) ; \
 807         else \
 808                 true ; \
 809         fi
 810
 811 ### ld
 812 all-ld: .stmp-libiberty .stmp-bfd .stmp-bison .stmp-ld
 813 .stmp-ld:
 814         if [ -d ./ld ] ; then \
 815                 rootme=`pwd` ; export rootme ; \
 816                 (cd ./ld; \
 817                 $(MAKE) \
 818                         "against=$(against)" \
 819                         "AR=$(AR)" \
 820                         "AR_FLAGS=$(AR_FLAGS)" \
 821                         "CC=$(CC)" \
 822                         "RANLIB=$(RANLIB)" \
 823                         "LOADLIBES=$(LOADLIBES)" \
 824                         "LDFLAGS=$(LDFLAGS)" \
 825                         "BISON=$(BISON)" \
 826                         "MAKEINFO=$(MAKEINFO)" \
 827                         all) ; \
 828         else \
 829                 true ; \
 830         fi
 831         touch .stmp-ld
 832
 833 clean-ld: force
 834         if [ -d ./ld ] ; then \
 835                 rootme=`pwd` ; export rootme ; \
 836                 (cd ./ld; \
 837                 $(MAKE) \
 838                         "against=$(against)" \
 839                         "AR=$(AR)" \
 840                         "AR_FLAGS=$(AR_FLAGS)" \
 841                         "CC=$(CC)" \
 842                         "RANLIB=$(RANLIB)" \
 843                         "LOADLIBES=$(LOADLIBES)" \
 844                         "LDFLAGS=$(LDFLAGS)" \
 845                         "BISON=$(BISON)" \
 846                         "MAKEINFO=$(MAKEINFO)" \
 847                         clean) ; \
 848         else \
 849                 true ; \
 850         fi
 851
 852 install-ld: force
 853         if [ -d ./ld ] ; then \
 854                 rootme=`pwd` ; export rootme ; \
 855                 (cd ./ld; \
 856                 $(MAKE) \
 857                         "against=$(against)" \
 858                         "AR=$(AR)" \
 859                         "AR_FLAGS=$(AR_FLAGS)" \
 860                         "CC=$(CC)" \
 861                         "RANLIB=$(RANLIB)" \
 862                         "LOADLIBES=$(LOADLIBES)" \
 863                         "LDFLAGS=$(LDFLAGS)" \
 864                         "BISON=$(BISON)" \
 865                         "MAKEINFO=$(MAKEINFO)" \
 866                         install) ; \
 867         else \
 868                 true ; \
 869         fi
 870
 871 ### libgcc (and libgcc1)
 872 all-libgcc1: all-gas all-binutils .stmp-libgcc1
 873 .stmp-libgcc1:
 874         if [ -d ./libgcc ] ; then \
 875                 rootme=`pwd` ; export rootme ; \
 876                 (cd ./libgcc; \
 877                 $(MAKE) \
 878                         "against=$(against)" \
 879                         "AR=$(AR)" \
 880                         "AR_FLAGS=$(AR_FLAGS)" \
 881                         "CC=$(CC)" \
 882                         "RANLIB=$(RANLIB)" \
 883                         "LOADLIBES=$(LOADLIBES)" \
 884                         "LDFLAGS=$(LDFLAGS)" \
 885                         "BISON=$(BISON)" \
 886                         "MAKEINFO=$(MAKEINFO)" \
 887                         libgcc1.a) ; \
 888         else \
 889                 true ; \
 890         fi
 891         touch .stmp-libgcc1
 892
 893 clean-libgcc1: force
 894         if [ -d ./libgcc ] ; then \
 895                 rootme=`pwd` ; export rootme ; \
 896                 (cd ./libgcc; \
 897                 $(MAKE) \
 898                         "against=$(against)" \
 899                         "AR=$(AR)" \
 900                         "AR_FLAGS=$(AR_FLAGS)" \
 901                         "CC=$(CC)" \
 902                         "RANLIB=$(RANLIB)" \
 903                         "LOADLIBES=$(LOADLIBES)" \
 904                         "LDFLAGS=$(LDFLAGS)" \
 905                         "BISON=$(BISON)" \
 906                         "MAKEINFO=$(MAKEINFO)" \
 907                         clean-libgcc1) ; \
 908         else \
 909                 true ; \
 910         fi
 911
 912 install-libgcc1: force
 913         echo libgcc1 is a component, not an installable target
 914
 915 all-libgcc: all-gas all-gcc all-binutils .stmp-libgcc
 916 .stmp-libgcc:
 917         true
 918         if [ -d ./libgcc ] ; then \
 919                 rootme=`pwd` ; export rootme ; \
 920                 (cd ./libgcc; \
 921                 $(MAKE) \
 922                         "against=$(against)" \
 923                         "AR=$(AR)" \
 924                         "AR_FLAGS=$(AR_FLAGS)" \
 925                         "CC=$(CC)" \
 926                         "RANLIB=$(RANLIB)" \
 927                         "LOADLIBES=$(LOADLIBES)" \
 928                         "LDFLAGS=$(LDFLAGS)" \
 929                         "BISON=$(BISON)" \
 930                         "MAKEINFO=$(MAKEINFO)" \
 931                         all) ; \
 932         else \
 933                 true ; \
 934         fi
 935         touch .stmp-libgcc
 936
 937 clean-libgcc: force
 938         if [ -d ./libgcc ] ; then \
 939                 rootme=`pwd` ; export rootme ; \
 940                 (cd ./libgcc; \
 941                 $(MAKE) \
 942                         "against=$(against)" \
 943                         "AR=$(AR)" \
 944                         "AR_FLAGS=$(AR_FLAGS)" \
 945                         "CC=$(CC)" \
 946                         "RANLIB=$(RANLIB)" \
 947                         "LOADLIBES=$(LOADLIBES)" \
 948                         "LDFLAGS=$(LDFLAGS)" \
 949                         "BISON=$(BISON)" \
 950                         "MAKEINFO=$(MAKEINFO)" \
 951                         clean) ; \
 952         else \
 953                 true ; \
 954         fi
 955
 956 install-libgcc: force
 957         if [ -d ./libgcc ] ; then \
 958                 rootme=`pwd` ; export rootme ; \
 959                 (cd ./libgcc; \
 960                 $(MAKE) \
 961                         "against=$(against)" \
 962                         "AR=$(AR)" \
 963                         "AR_FLAGS=$(AR_FLAGS)" \
 964                         "CC=$(CC)" \
 965                         "RANLIB=$(RANLIB)" \
 966                         "LOADLIBES=$(LOADLIBES)" \
 967                         "LDFLAGS=$(LDFLAGS)" \
 968                         "BISON=$(BISON)" \
 969                         "MAKEINFO=$(MAKEINFO)" \
 970                         install) ; \
 971         else \
 972                 true ; \
 973         fi
 974
 975 ### gdb
 976 all-gdb: .stmp-bfd .stmp-libiberty .stmp-readline .stmp-glob .stmp-bison .stmp-gdb
 977 .stmp-gdb:
 978         if [ -d ./gdb ] ; then \
 979                 rootme=`pwd` ; export rootme ; \
 980                 (cd ./gdb; \
 981                 $(MAKE) \
 982                         "against=$(against)" \
 983                         "AR=$(AR)" \
 984                         "AR_FLAGS=$(AR_FLAGS)" \
 985                         "CC=$(CC)" \
 986                         "RANLIB=$(RANLIB)" \
 987                         "LOADLIBES=$(LOADLIBES)" \
 988                         "LDFLAGS=$(LDFLAGS)" \
 989                         "BISON=$(BISON)" \
 990                         "MAKEINFO=$(MAKEINFO)" \
 991                         all) ; \
 992         else \
 993                 true ; \
 994         fi
 995         touch .stmp-gdb
 996
 997 clean-gdb: force
 998         if [ -d ./gdb ] ; then \
 999                 rootme=`pwd` ; export rootme ; \
1000                 (cd ./gdb; \
1001                 $(MAKE) \
1002                         "against=$(against)" \
1003                         "AR=$(AR)" \
1004                         "AR_FLAGS=$(AR_FLAGS)" \
1005                         "CC=$(CC)" \
1006                         "RANLIB=$(RANLIB)" \
1007                         "LOADLIBES=$(LOADLIBES)" \
1008                         "LDFLAGS=$(LDFLAGS)" \
1009                         "BISON=$(BISON)" \
1010                         "MAKEINFO=$(MAKEINFO)" \
1011                         clean) ; \
1012         else \
1013                 true ; \
1014         fi
1015
1016 install-gdb: force
1017         if [ -d ./gdb ] ; then \
1018                 rootme=`pwd` ; export rootme ; \
1019                 (cd ./gdb; \
1020                 $(MAKE) \
1021                         "against=$(against)" \
1022                         "AR=$(AR)" \
1023                         "AR_FLAGS=$(AR_FLAGS)" \
1024                         "CC=$(CC)" \
1025                         "RANLIB=$(RANLIB)" \
1026                         "LOADLIBES=$(LOADLIBES)" \
1027                         "LDFLAGS=$(LDFLAGS)" \
1028                         "BISON=$(BISON)" \
1029                         "MAKEINFO=$(MAKEINFO)" \
1030                         install) ; \
1031         else \
1032                 true ; \
1033         fi
1034
1035 ### make
1036 all-make: all-libiberty .stmp-make
1037 .stmp-make:
1038         if [ -d ./make ] ; then \
1039                 rootme=`pwd` ; export rootme ; \
1040                 (cd ./make; \
1041                 $(MAKE) \
1042                         "against=$(against)" \
1043                         "AR=$(AR)" \
1044                         "AR_FLAGS=$(AR_FLAGS)" \
1045                         "CC=$(CC)" \
1046                         "RANLIB=$(RANLIB)" \
1047                         "LOADLIBES=$(LOADLIBES)" \
1048                         "LDFLAGS=$(LDFLAGS)" \
1049                         "BISON=$(BISON)" \
1050                         "MAKEINFO=$(MAKEINFO)" \
1051                         all) ; \
1052         else \
1053                 true ; \
1054         fi
1055         touch .stmp-make
1056
1057 clean-make: force
1058         if [ -d ./make ] ; then \
1059                 rootme=`pwd` ; export rootme ; \
1060                 (cd ./make; \
1061                 $(MAKE) \
1062                         "against=$(against)" \
1063                         "AR=$(AR)" \
1064                         "AR_FLAGS=$(AR_FLAGS)" \
1065                         "CC=$(CC)" \
1066                         "RANLIB=$(RANLIB)" \
1067                         "LOADLIBES=$(LOADLIBES)" \
1068                         "LDFLAGS=$(LDFLAGS)" \
1069                         "BISON=$(BISON)" \
1070                         "MAKEINFO=$(MAKEINFO)" \
1071                         clean) ; \
1072         else \
1073                 true ; \
1074         fi
1075
1076 install-make: force
1077         if [ -d ./make ] ; then \
1078                 rootme=`pwd` ; export rootme ; \
1079                 (cd ./make; \
1080                 $(MAKE) \
1081                         "against=$(against)" \
1082                         "AR=$(AR)" \
1083                         "AR_FLAGS=$(AR_FLAGS)" \
1084                         "CC=$(CC)" \
1085                         "RANLIB=$(RANLIB)" \
1086                         "LOADLIBES=$(LOADLIBES)" \
1087                         "LDFLAGS=$(LDFLAGS)" \
1088                         "BISON=$(BISON)" \
1089                         "MAKEINFO=$(MAKEINFO)" \
1090                         install) ; \
1091         else \
1092                 true ; \
1093         fi
1094
1095 ### diff
1096 all-diff: .stmp-diff
1097 .stmp-diff:
1098         if [ -d ./diff ] ; then \
1099                 rootme=`pwd` ; export rootme ; \
1100                 (cd ./diff; \
1101                 $(MAKE) \
1102                         "against=$(against)" \
1103                         "AR=$(AR)" \
1104                         "AR_FLAGS=$(AR_FLAGS)" \
1105                         "CC=$(CC)" \
1106                         "RANLIB=$(RANLIB)" \
1107                         "LOADLIBES=$(LOADLIBES)" \
1108                         "LDFLAGS=$(LDFLAGS)" \
1109                         "BISON=$(BISON)" \
1110                         "MAKEINFO=$(MAKEINFO)" \
1111                         all) ; \
1112         else \
1113                 true ; \
1114         fi
1115         touch .stmp-diff
1116
1117 clean-diff: force
1118         if [ -d ./diff ] ; then \
1119                 rootme=`pwd` ; export rootme ; \
1120                 (cd ./diff; \
1121                 $(MAKE) \
1122                         "against=$(against)" \
1123                         "AR=$(AR)" \
1124                         "AR_FLAGS=$(AR_FLAGS)" \
1125                         "CC=$(CC)" \
1126                         "RANLIB=$(RANLIB)" \
1127                         "LOADLIBES=$(LOADLIBES)" \
1128                         "LDFLAGS=$(LDFLAGS)" \
1129                         "BISON=$(BISON)" \
1130                         "MAKEINFO=$(MAKEINFO)" \
1131                         clean) ; \
1132         else \
1133                 true ; \
1134         fi
1135
1136 install-diff: force
1137         if [ -d ./diff ] ; then \
1138                 rootme=`pwd` ; export rootme ; \
1139                 (cd ./diff/; \
1140                 $(MAKE) \
1141                         "against=$(against)" \
1142                         "AR=$(AR)" \
1143                         "AR_FLAGS=$(AR_FLAGS)" \
1144                         "CC=$(CC)" \
1145                         "RANLIB=$(RANLIB)" \
1146                         "LOADLIBES=$(LOADLIBES)" \
1147                         "LDFLAGS=$(LDFLAGS)" \
1148                         "BISON=$(BISON)" \
1149                         "MAKEINFO=$(MAKEINFO)" \
1150                         install) ; \
1151         else \
1152                 true ; \
1153         fi
1154
1155 ### grep
1156 all-grep: .stmp-grep
1157 .stmp-grep:
1158         if [ -d ./grep ] ; then \
1159                 rootme=`pwd` ; export rootme ; \
1160                 (cd ./grep; \
1161                 $(MAKE) \
1162                         "against=$(against)" \
1163                         "AR=$(AR)" \
1164                         "AR_FLAGS=$(AR_FLAGS)" \
1165                         "CC=$(CC)" \
1166                         "RANLIB=$(RANLIB)" \
1167                         "LOADLIBES=$(LOADLIBES)" \
1168                         "LDFLAGS=$(LDFLAGS)" \
1169                         "BISON=$(BISON)" \
1170                         "MAKEINFO=$(MAKEINFO)" \
1171                         all) ; \
1172         else \
1173                 true ; \
1174         fi
1175         touch .stmp-grep
1176
1177 clean-grep: force
1178         if [ -d ./grep ] ; then \
1179                 rootme=`pwd` ; export rootme ; \
1180                 (cd ./grep; \
1181                 $(MAKE) \
1182                         "against=$(against)" \
1183                         "AR=$(AR)" \
1184                         "AR_FLAGS=$(AR_FLAGS)" \
1185                         "CC=$(CC)" \
1186                         "RANLIB=$(RANLIB)" \
1187                         "LOADLIBES=$(LOADLIBES)" \
1188                         "LDFLAGS=$(LDFLAGS)" \
1189                         "BISON=$(BISON)" \
1190                         "MAKEINFO=$(MAKEINFO)" \
1191                         clean) ; \
1192         else \
1193                 true ; \
1194         fi
1195
1196 install-grep: force
1197         if [ -d ./grep ] ; then \
1198                 rootme=`pwd` ; export rootme ; \
1199                 (cd ./grep; \
1200                 $(MAKE) \
1201                         "against=$(against)" \
1202                         "AR=$(AR)" \
1203                         "AR_FLAGS=$(AR_FLAGS)" \
1204                         "CC=$(CC)" \
1205                         "RANLIB=$(RANLIB)" \
1206                         "LOADLIBES=$(LOADLIBES)" \
1207                         "LDFLAGS=$(LDFLAGS)" \
1208                         "BISON=$(BISON)" \
1209                         "MAKEINFO=$(MAKEINFO)" \
1210                         install) ; \
1211         else \
1212                 true ; \
1213         fi
1214
1215 ### rcs
1216 all-rcs: .stmp-diff .stmp-grep .stmp-rcs
1217 .stmp-rcs:
1218         if [ -d ./rcs ] ; then \
1219                 rootme=`pwd` ; export rootme ; \
1220                 (cd ./rcs; \
1221                 $(MAKE) \
1222                         "against=$(against)" \
1223                         "AR=$(AR)" \
1224                         "AR_FLAGS=$(AR_FLAGS)" \
1225                         "CC=$(CC)" \
1226                         "RANLIB=$(RANLIB)" \
1227                         "LOADLIBES=$(LOADLIBES)" \
1228                         "LDFLAGS=$(LDFLAGS)" \
1229                         "BISON=$(BISON)" \
1230                         "MAKEINFO=$(MAKEINFO)" \
1231                         all) ; \
1232         else \
1233                 true ; \
1234         fi
1235         touch .stmp-rcs
1236
1237 clean-rcs: force
1238         if [ -d ./rcs ] ; then \
1239                 rootme=`pwd` ; export rootme ; \
1240                 (cd ./rcs; \
1241                 $(MAKE) \
1242                         "against=$(against)" \
1243                         "AR=$(AR)" \
1244                         "AR_FLAGS=$(AR_FLAGS)" \
1245                         "CC=$(CC)" \
1246                         "RANLIB=$(RANLIB)" \
1247                         "LOADLIBES=$(LOADLIBES)" \
1248                         "LDFLAGS=$(LDFLAGS)" \
1249                         "BISON=$(BISON)" \
1250                         "MAKEINFO=$(MAKEINFO)" \
1251                         clean) ; \
1252         else \
1253                 true ; \
1254         fi
1255
1256 install-rcs: install-grep install-diff force
1257         if [ -d ./rcs ] ; then \
1258                 rootme=`pwd` ; export rootme ; \
1259                 (cd ./rcs; \
1260                 $(MAKE) \
1261                         "against=$(against)" \
1262                         "AR=$(AR)" \
1263                         "AR_FLAGS=$(AR_FLAGS)" \
1264                         "CC=$(CC)" \
1265                         "RANLIB=$(RANLIB)" \
1266                         "LOADLIBES=$(LOADLIBES)" \
1267                         "LDFLAGS=$(LDFLAGS)" \
1268                         "BISON=$(BISON)" \
1269                         "MAKEINFO=$(MAKEINFO)" \
1270                         install) ; \
1271         else \
1272                 true ; \
1273         fi
1274
1275 ### gdbm
1276 all-gdbm: .stmp-gdbm
1277 .stmp-gdbm:
1278         if [ -d ./gdbm ] ; then \
1279                 rootme=`pwd` ; export rootme ; \
1280                 (cd ./gdbm; \
1281                 $(MAKE) \
1282                         "against=$(against)" \
1283                         "AR=$(AR)" \
1284                         "AR_FLAGS=$(AR_FLAGS)" \
1285                         "CC=$(CC)" \
1286                         "RANLIB=$(RANLIB)" \
1287                         "LOADLIBES=$(LOADLIBES)" \
1288                         "LDFLAGS=$(LDFLAGS)" \
1289                         "BISON=$(BISON)" \
1290                         "MAKEINFO=$(MAKEINFO)" \
1291                         all) ; \
1292         else \
1293                 true ; \
1294         fi
1295         touch .stmp-gdbm
1296
1297 clean-gdbm: force
1298         if [ -d ./gdbm ] ; then \
1299                 rootme=`pwd` ; export rootme ; \
1300                 (cd ./gdbm; \
1301                 $(MAKE) \
1302                         "against=$(against)" \
1303                         "AR=$(AR)" \
1304                         "AR_FLAGS=$(AR_FLAGS)" \
1305                         "CC=$(CC)" \
1306                         "RANLIB=$(RANLIB)" \
1307                         "LOADLIBES=$(LOADLIBES)" \
1308                         "LDFLAGS=$(LDFLAGS)" \
1309                         "BISON=$(BISON)" \
1310                         "MAKEINFO=$(MAKEINFO)" \
1311                         clean) ; \
1312         else \
1313                 true ; \
1314         fi
1315
1316 install-gdbm: force
1317         if [ -d ./gdbm ] ; then \
1318                 rootme=`pwd` ; export rootme ; \
1319                 (cd ./gdbm; \
1320                 $(MAKE) \
1321                         "against=$(against)" \
1322                         "AR=$(AR)" \
1323                         "AR_FLAGS=$(AR_FLAGS)" \
1324                         "CC=$(CC)" \
1325                         "RANLIB=$(RANLIB)" \
1326                         "LOADLIBES=$(LOADLIBES)" \
1327                         "LDFLAGS=$(LDFLAGS)" \
1328                         "BISON=$(BISON)" \
1329                         "MAKEINFO=$(MAKEINFO)" \
1330                         install) ; \
1331         else \
1332                 true ; \
1333         fi
1334
1335 ### cvs
1336
1337 all-cvs: .stmp-cvs .stmp-rcs .stmp-grep .stmp-diff
1338 .stmp-cvs: .stmp-gdbm force
1339         if [ -d ./cvs ] ; then \
1340                 rootme=`pwd` ; export rootme ; \
1341                 (cd ./cvs; \
1342                 $(MAKE) \
1343                         "against=$(against)" \
1344                         "AR=$(AR)" \
1345                         "AR_FLAGS=$(AR_FLAGS)" \
1346                         "CC=$(CC)" \
1347                         "RANLIB=$(RANLIB)" \
1348                         "LOADLIBES=$(LOADLIBES)" \
1349                         "LDFLAGS=$(LDFLAGS)" \
1350                         "BISON=$(BISON)" \
1351                         "MAKEINFO=$(MAKEINFO)" \
1352                         all) ; \
1353         else \
1354                 true ; \
1355         fi
1356         touch .stmp-cvs
1357
1358 clean-cvs: clean-gdbm force
1359         if [ -d ./cvs ] ; then \
1360                 rootme=`pwd` ; export rootme ; \
1361                 (cd ./cvs; \
1362                 $(MAKE) \
1363                         "against=$(against)" \
1364                         "AR=$(AR)" \
1365                         "AR_FLAGS=$(AR_FLAGS)" \
1366                         "CC=$(CC)" \
1367                         "RANLIB=$(RANLIB)" \
1368                         "LOADLIBES=$(LOADLIBES)" \
1369                         "LDFLAGS=$(LDFLAGS)" \
1370                         "BISON=$(BISON)" \
1371                         "MAKEINFO=$(MAKEINFO)" \
1372                         clean) ; \
1373         else \
1374                 true ; \
1375         fi
1376
1377 install-cvs: install-rcs install-gdbm force
1378         if [ -d ./cvs ] ; then \
1379                 rootme=`pwd` ; export rootme ; \
1380                 (cd ./cvs; \
1381                 $(MAKE) \
1382                         "against=$(against)" \
1383                         "AR=$(AR)" \
1384                         "AR_FLAGS=$(AR_FLAGS)" \
1385                         "CC=$(CC)" \
1386                         "RANLIB=$(RANLIB)" \
1387                         "LOADLIBES=$(LOADLIBES)" \
1388                         "LDFLAGS=$(LDFLAGS)" \
1389                         "BISON=$(BISON)" \
1390                         "MAKEINFO=$(MAKEINFO)" \
1391                         install) ; \
1392         else \
1393                 true ; \
1394         fi
1395
1396 ### patch
1397 all-patch: .stmp-patch
1398 .stmp-patch: force
1399         if [ -d ./patch ] ; then \
1400                 rootme=`pwd` ; export rootme ; \
1401                 (cd ./patch; \
1402                 $(MAKE) \
1403                         "against=$(against)" \
1404                         "AR=$(AR)" \
1405                         "AR_FLAGS=$(AR_FLAGS)" \
1406                         "CC=$(CC)" \
1407                         "RANLIB=$(RANLIB)" \
1408                         "LOADLIBES=$(LOADLIBES)" \
1409                         "LDFLAGS=$(LDFLAGS)" \
1410                         "BISON=$(BISON)" \
1411                         "MAKEINFO=$(MAKEINFO)" \
1412                         all) ; \
1413         else \
1414                 true ; \
1415         fi
1416         touch .stmp-patch
1417
1418 clean-patch: force
1419         if [ -d ./patch ] ; then \
1420                 rootme=`pwd` ; export rootme ; \
1421                 (cd ./patch; \
1422                 $(MAKE) \
1423                         "against=$(against)" \
1424                         "AR=$(AR)" \
1425                         "AR_FLAGS=$(AR_FLAGS)" \
1426                         "CC=$(CC)" \
1427                         "RANLIB=$(RANLIB)" \
1428                         "LOADLIBES=$(LOADLIBES)" \
1429                         "LDFLAGS=$(LDFLAGS)" \
1430                         "BISON=$(BISON)" \
1431                         "MAKEINFO=$(MAKEINFO)" \
1432                         clean) ; \
1433         else \
1434                 true ; \
1435         fi
1436
1437 install-patch: force
1438         if [ -d ./patch ] ; then \
1439                 rootme=`pwd` ; export rootme ; \
1440                 (cd ./patch; \
1441                 $(MAKE) \
1442                         bindir=$(bindir) \
1443                         man1dir=$(man1dir) \
1444                         "AR=$(AR)" \
1445                         "AR_FLAGS=$(AR_FLAGS)" \
1446                         "CC=$(CC)" \
1447                         "RANLIB=$(RANLIB)" \
1448                         "LOADLIBES=$(LOADLIBES)" \
1449                         "LDFLAGS=$(LDFLAGS)" \
1450                         "BISON=$(BISON)" \
1451                         "MAKEINFO=$(MAKEINFO)" \
1452                         install) ; \
1453         else \
1454                 true ; \
1455         fi
1456
1457 ### emacs
1458 all-emacs: .stmp-emacs
1459 .stmp-emacs: force
1460         if [ -d ./emacs ] ; then \
1461                 rootme=`pwd` ; export rootme ; \
1462                 (cd ./emacs; \
1463                 $(MAKE) \
1464                         "against=$(against)" \
1465                         "AR=$(AR)" \
1466                         "AR_FLAGS=$(AR_FLAGS)" \
1467                         "CC=$(CC)" \
1468                         "RANLIB=$(RANLIB)" \
1469                         "LOADLIBES=$(LOADLIBES)" \
1470                         "LDFLAGS=$(LDFLAGS)" \
1471                         "BISON=$(BISON)" \
1472                         "MAKEINFO=$(MAKEINFO)" \
1473                         all) ; \
1474         else \
1475                 true ; \
1476         fi
1477         touch .stmp-emacs
1478
1479 clean-emacs: force
1480         if [ -d ./emacs ] ; then \
1481                 rootme=`pwd` ; export rootme ; \
1482                 (cd ./emacs; \
1483                 $(MAKE) \
1484                         "against=$(against)" \
1485                         "AR=$(AR)" \
1486                         "AR_FLAGS=$(AR_FLAGS)" \
1487                         "CC=$(CC)" \
1488                         "RANLIB=$(RANLIB)" \
1489                         "LOADLIBES=$(LOADLIBES)" \
1490                         "LDFLAGS=$(LDFLAGS)" \
1491                         "BISON=$(BISON)" \
1492                         "MAKEINFO=$(MAKEINFO)" \
1493                         clean) ; \
1494         else \
1495                 true ; \
1496         fi
1497
1498 install-emacs: install-rcs install-gdbm force
1499         if [ -d ./emacs ] ; then \
1500                 rootme=`pwd` ; export rootme ; \
1501                 (cd ./emacs; \
1502                 $(MAKE) \
1503                         "against=$(against)" \
1504                         "AR=$(AR)" \
1505                         "AR_FLAGS=$(AR_FLAGS)" \
1506                         "CC=$(CC)" \
1507                         "RANLIB=$(RANLIB)" \
1508                         "LOADLIBES=$(LOADLIBES)" \
1509                         "LDFLAGS=$(LDFLAGS)" \
1510                         "BISON=$(BISON)" \
1511                         "MAKEINFO=$(MAKEINFO)" \
1512                         install) ; \
1513         else \
1514                 true ; \
1515         fi
1516
1517 ### ispell
1518 all-ispell: .stmp-ispell
1519 .stmp-ispell: all-emacs force
1520         if [ -d ./ispell ] ; then \
1521                 rootme=`pwd` ; export rootme ; \
1522                 (cd ./ispell; \
1523                 $(MAKE) \
1524                         "against=$(against)" \
1525                         "AR=$(AR)" \
1526                         "AR_FLAGS=$(AR_FLAGS)" \
1527                         "CC=$(CC)" \
1528                         "RANLIB=$(RANLIB)" \
1529                         "LOADLIBES=$(LOADLIBES)" \
1530                         "LDFLAGS=$(LDFLAGS)" \
1531                         "BISON=$(BISON)" \
1532                         "MAKEINFO=$(MAKEINFO)" \
1533                         all) ; \
1534         else \
1535                 true ; \
1536         fi
1537         touch .stmp-ispell
1538
1539 clean-ispell: force
1540         if [ -d ./ispell ] ; then \
1541                 rootme=`pwd` ; export rootme ; \
1542                 (cd ./ispell; \
1543                 $(MAKE) \
1544                         "against=$(against)" \
1545                         "AR=$(AR)" \
1546                         "AR_FLAGS=$(AR_FLAGS)" \
1547                         "CC=$(CC)" \
1548                         "RANLIB=$(RANLIB)" \
1549                         "LOADLIBES=$(LOADLIBES)" \
1550                         "LDFLAGS=$(LDFLAGS)" \
1551                         "BISON=$(BISON)" \
1552                         "MAKEINFO=$(MAKEINFO)" \
1553                         clean) ; \
1554         else \
1555                 true ; \
1556         fi
1557
1558 install-ispell: install-rcs install-gdbm force
1559         if [ -d ./ispell ] ; then \
1560                 rootme=`pwd` ; export rootme ; \
1561                 (cd ./ispell; \
1562                 $(MAKE) \
1563                         "against=$(against)" \
1564                         "AR=$(AR)" \
1565                         "AR_FLAGS=$(AR_FLAGS)" \
1566                         "CC=$(CC)" \
1567                         "RANLIB=$(RANLIB)" \
1568                         "LOADLIBES=$(LOADLIBES)" \
1569                         "LDFLAGS=$(LDFLAGS)" \
1570                         "BISON=$(BISON)" \
1571                         "MAKEINFO=$(MAKEINFO)" \
1572                         install) ; \
1573         else \
1574                 true ; \
1575         fi
1576
1577 ### fileutils
1578 all-fileutils: .stmp-fileutils
1579 .stmp-fileutils: force
1580         if [ -d ./fileutils ] ; then \
1581                 rootme=`pwd` ; export rootme ; \
1582                 (cd ./fileutils; \
1583                 $(MAKE) \
1584                         "prefix=$(prefix)" \
1585                         "datadir=$(datadir)" \
1586                         "mandir=$(mandir)" \
1587                         "against=$(against)" \
1588                         "AR=$(AR)" \
1589                         "AR_FLAGS=$(AR_FLAGS)" \
1590                         "CC=$(CC)" \
1591                         "RANLIB=$(RANLIB)" \
1592                         "LOADLIBES=$(LOADLIBES)" \
1593                         "LDFLAGS=$(LDFLAGS)" \
1594                         "BISON=$(BISON)" \
1595                         "MAKEINFO=$(MAKEINFO)" \
1596                         all) ; \
1597         else \
1598                 true ; \
1599         fi
1600         touch .stmp-fileutils
1601
1602 clean-fileutils: force
1603         if [ -d ./fileutils ] ; then \
1604                 rootme=`pwd` ; export rootme ; \
1605                 (cd ./fileutils; \
1606                 $(MAKE) \
1607                         "prefix=$(prefix)" \
1608                         "datadir=$(datadir)" \
1609                         "mandir=$(mandir)" \
1610                         "against=$(against)" \
1611                         "AR=$(AR)" \
1612                         "AR_FLAGS=$(AR_FLAGS)" \
1613                         "CC=$(CC)" \
1614                         "RANLIB=$(RANLIB)" \
1615                         "LOADLIBES=$(LOADLIBES)" \
1616                         "LDFLAGS=$(LDFLAGS)" \
1617                         "BISON=$(BISON)" \
1618                         "MAKEINFO=$(MAKEINFO)" \
1619                         clean) ; \
1620         else \
1621                 true ; \
1622         fi
1623
1624 install-fileutils: force
1625         if [ -d ./fileutils ] ; then \
1626                 rootme=`pwd` ; export rootme ; \
1627                 (cd ./fileutils; \
1628                 $(MAKE) \
1629                         "prefix=$(prefix)" \
1630                         "datadir=$(datadir)" \
1631                         "mandir=$(mandir)" \
1632                         "against=$(against)" \
1633                         "AR=$(AR)" \
1634                         "AR_FLAGS=$(AR_FLAGS)" \
1635                         "CC=$(CC)" \
1636                         "RANLIB=$(RANLIB)" \
1637                         "LOADLIBES=$(LOADLIBES)" \
1638                         "LDFLAGS=$(LDFLAGS)" \
1639                         "BISON=$(BISON)" \
1640                         "MAKEINFO=$(MAKEINFO)" \
1641                         install) ; \
1642         else \
1643                 true ; \
1644         fi
1645
1646 ### libg++
1647 GXX = `if [ -d $${rootme}/gcc ] ; \
1648         then echo $${rootme}/gcc/gcc -B$${rootme}/gcc/ ; \
1649         else echo gcc ; fi`
1650
1651 XTRAFLAGS = `if [ -d $${rootme}/gcc ] ; \
1652         then echo -I$${rootme}/gcc/include ; \
1653         else echo ; fi`
1654
1655 all-libg++: .stmp-gas .stmp-ld .stmp-gcc .stmp-libg++
1656 .stmp-libg++: .stmp-gcc
1657         if [ -d ./libg++ ] ; then \
1658                 rootme=`pwd` ; export rootme ; \
1659                 (cd ./libg++; \
1660                 $(MAKE) \
1661                         "prefix=$(prefix)" \
1662                         "datadir=$(datadir)" \
1663                         "mandir=$(mandir)" \
1664                         "against=$(against)" \
1665                         "AR=$(AR)" \
1666                         "AR_FLAGS=$(AR_FLAGS)" \
1667                         "CC=${GXX}" \
1668                         "XTRAFLAGS=${XTRAFLAGS}" \
1669                         "RANLIB=$(RANLIB)" \
1670                         "LOADLIBES=$(LOADLIBES)" \
1671                         "LDFLAGS=$(LDFLAGS)" \
1672                         "BISON=$(BISON)" \
1673                         "MAKEINFO=$(MAKEINFO)" \
1674                         all) ; \
1675         else \
1676                 true ; \
1677         fi
1678         touch .stmp-libg++
1679
1680 clean-libg++: force
1681         if [ -d ./libg++ ] ; then \
1682                 rootme=`pwd` ; export rootme ; \
1683                 (cd ./libg++; \
1684                 $(MAKE) \
1685                         "prefix=$(prefix)" \
1686                         "datadir=$(datadir)" \
1687                         "mandir=$(mandir)" \
1688                         "against=$(against)" \
1689                         "AR=$(AR)" \
1690                         "AR_FLAGS=$(AR_FLAGS)" \
1691                         "CC=$(CC)" \
1692                         "RANLIB=$(RANLIB)" \
1693                         "LOADLIBES=$(LOADLIBES)" \
1694                         "LDFLAGS=$(LDFLAGS)" \
1695                         "BISON=$(BISON)" \
1696                         "MAKEINFO=$(MAKEINFO)" \
1697                         clean) ; \
1698         else \
1699                 true ; \
1700         fi
1701
1702 install-libg++: force
1703         if [ -d ./libg++ ] ; then \
1704                 rootme=`pwd` ; export rootme ; \
1705                 (cd ./libg++; \
1706                 $(MAKE) \
1707                         "prefix=$(prefix)" \
1708                         "datadir=$(datadir)" \
1709                         "mandir=$(mandir)" \
1710                         "against=$(against)" \
1711                         "AR=$(AR)" \
1712                         "AR_FLAGS=$(AR_FLAGS)" \
1713                         "CC=$(CC)" \
1714                         "RANLIB=$(RANLIB)" \
1715                         "LOADLIBES=$(LOADLIBES)" \
1716                         "LDFLAGS=$(LDFLAGS)" \
1717                         "BISON=$(BISON)" \
1718                         "MAKEINFO=$(MAKEINFO)" \
1719                         install) ; \
1720         else \
1721                 true ; \
1722         fi
1723
1724 ### other supporting targets
1725 # this is a bad hack.
1726 all.xclib:      all.normal
1727         if [ -d clib ] ; then \
1728                 (cd clib ; $(MAKE)) ; \
1729         fi
1730
1731 subdir_do: force
1732         for i in $(DODIRS); do \
1733                 if [ -f ./$$i/localenv ] ; then \
1734                         if (rootme=`pwd` ; export rootme ; cd ./$$i; \
1735                                 $(MAKE) \
1736                                         "against=$(against)" \
1737                                         "BISON=$(BISON)" \
1738                                         "MAKEINFO=$(MAKEINFO)" \
1739                                         $(DO)) ; then true ; \
1740                                 else exit 1 ; fi ; \
1741                 else if [ -d ./$$i ] ; then \
1742                         if (rootme=`pwd` ; export rootme ; cd ./$$i; \
1743                                 $(MAKE) \
1744                                         "against=$(against)" \
1745                                         "AR=$(AR)" \
1746                                         "AR_FLAGS=$(AR_FLAGS)" \
1747                                         "CC=$(CC)" \
1748                                         "RANLIB=$(RANLIB)" \
1749                                         "LOADLIBES=$(LOADLIBES)" \
1750                                         "LDFLAGS=$(LDFLAGS)" \
1751                                         "BISON=$(BISON)" \
1752                                         "MAKEINFO=$(MAKEINFO)" \
1753                                         $(DO)) ; then true ; \
1754                         else exit 1 ; fi ; \
1755                 else true ; fi ; \
1756         fi ; \
1757         done
1758
1759 bootstrap:
1760         $(MAKE) all info
1761         $(MAKE) stage1
1762         $(MAKE) pass "stagepass=stage1"
1763         $(MAKE) stage2
1764         $(MAKE) pass "stagepass=stage2"
1765         $(MAKE) comparison
1766
1767 bootstrap2:
1768         $(MAKE) pass "stagepass=stage1"
1769         $(MAKE) stage2
1770         $(MAKE) pass "stagepass=stage2"
1771         $(MAKE) comparison
1772
1773 bootstrap3:
1774         $(MAKE) pass "stagepass=stage2"
1775         $(MAKE) comparison
1776
1777 pass:
1778         cp $(srcdir)/gcc/gstdarg.h ./gas/stdarg.h
1779         $(MAKE) subdir_do "DO=all info" "DODIRS=$(SUBDIRS)" \
1780                 "CC=`pwd`/gcc/$(stagepass)/gcc \
1781                 -O $(GCCVERBOSE) -I`pwd`/gcc/include \
1782                 -B`pwd`/gcc/$(stagepass)/ \
1783                 -B`pwd`/gas/$(stagepass)/ \
1784                 -B`pwd`/ld/$(stagepass)/" \
1785                 "AR=`pwd`/binutils/$(stagepass)/ar" \
1786                 "LD=`pwd`/gcc/$(stagepass)/gcc $(GCCVERBOSE)" \
1787                 "RANLIB=`pwd`/binutils/$(stagepass)/ranlib" \
1788                 "LOADLIBES=`pwd`/libgcc/$(stagepass)/libgcc.a /lib/libc.a" \
1789                 "LDFLAGS=-nostdlib /lib/crt0.o \
1790                 -L`pwd`/libgcc/$(stagepass)/ \
1791                 -B`pwd`/ld/$(stagepass)/"
1792
1793
1794 stage1:
1795         $(MAKE) subdir_do DO=stage1 "DODIRS=$(SUBDIRS)"
1796
1797 stage2:
1798         $(MAKE) subdir_do DO=stage2 "DODIRS=$(SUBDIRS)"
1799
1800 stage3:
1801         $(MAKE) subdir_do DO=stage3 "DODIRS=$(SUBDIRS)"
1802
1803 stage4:
1804         $(MAKE) subdir_do DO=stage4 "DODIRS=$(SUBDIRS)"
1805
1806 against=stage2
1807
1808 comparison:; $(MAKE) subdir_do DO=comparison against=$(against) "DODIRS=$(SUBDIRS)"
1809
1810 de-stage1:; $(MAKE) subdir_do DO=de-stage1 "DODIRS=$(SUBDIRS)"
1811 de-stage2:; $(MAKE) subdir_do DO=de-stage2 "DODIRS=$(SUBDIRS)"
1812 de-stage3:; $(MAKE) subdir_do DO=de-stage3 "DODIRS=$(SUBDIRS)"
1813 de-stage4:; $(MAKE) subdir_do DO=de-stage4 "DODIRS=$(SUBDIRS)"
1814
1815 # The "else true" stuff is for Ultrix; the shell returns the exit code
1816 # of the "if" command, if no commands are run in the "then" or "else" part,
1817 # causing Make to quit.
1818
1819 MAKEDIRS= \
1820         $(prefix) \
1821         $(exec_prefix) \
1822         $(bindir) \
1823         $(libdir) \
1824         $(tooldir) \
1825         $(includedir) \
1826         $(datadir) \
1827         $(docdir) \
1828         $(mandir) \
1829         $(man1dir) \
1830         $(man5dir)
1831
1832 #       $(man2dir) \
1833 #       $(man3dir) \
1834 #       $(man4dir) \
1835 #       $(man6dir) \
1836 #       $(man7dir) \
1837 #       $(man8dir)
1838
1839 install-dirs: force
1840         for i in $(MAKEDIRS) ; do \
1841                 echo Making $$i... ; \
1842                 [ -d $$i ] || mkdir $$i || exit 1 ; \
1843         done
1844
1845 MAKEINFODIRS= \
1846         $(prefix) \
1847         $(infodir)
1848
1849 install-info-dirs: force
1850         if [ -d $(prefix) ] ; then true ; else mkdir $(prefix) ; fi
1851         if [ -d $(datadir) ] ; then true ; else mkdir $(datadir) ; fi
1852         if [ -d $(infodir) ] ; then true ; else mkdir $(infodir) ; fi
1853
1854 dir.info: force
1855         $(srcdir)/texinfo/gen-info-dir $(infodir) > dir.info.new
1856         mv -f dir.info.new dir.info
1857
1858 etags tags: TAGS
1859
1860 TAGS: FORCE
1861         etags `$(MAKE) ls`
1862
1863 ls:
1864         @echo Makefile
1865         @for i in $(SUBDIRS); \
1866         do \
1867                 (cd $$i; \
1868                         pwd=`pwd`; \
1869                         wd=`basename $$pwd`; \
1870                         for j in `$(MAKE) ls`; \
1871                         do \
1872                                 echo $$wd/$$j; \
1873                         done) \
1874         done
1875
1876 force:
1877
1878 # with the gnu make, this is done automatically.
1879
1880 Makefile: $(srcdir)/Makefile.in $(host_makefile_frag) $(target_makefile_frag)
1881         $(SHELL) ./config.status
1882
1883 #
1884 # Build GDB distributions that contain BFD, Include, Libiberty, Readline, etc
1885
1886 DEVO_SUPPORT= README cfg-paper.texi Makefile.in configure configure.in \
1887         config.sub config configure.man
1888 GDB_SUPPORT_DIRS= bfd include libiberty readline glob
1889 GDB_SUPPORT_FILES= $(GDB_SUPPORT_DIRS) texinfo/fsf/texinfo.tex
1890
1891 setup-dirs: force_update
1892         ./configure sun4
1893         make clean
1894         ./configure -rm sun4
1895         chmod og=u `find $(DEVO_SUPPORT) $(GDB_SUPPORT_FILES) -print`
1896
1897 bfd.ilrt.tar.Z: setup-dirs
1898         rm -f bfd.ilrt.tar.Z
1899         tar cf - $(DEVO_SUPPORT) $(GDB_SUPPORT_FILES) \
1900                 | compress -v >bfd.ilrt.tar.Z
1901
1902 gdb.tar.Z: setup-dirs
1903         (cd gdb; $(MAKE) -f Makefile.in make-proto-gdb.dir)
1904         $(MAKE) $(MFLAGS) -f Makefile.in make-gdb.tar.Z
1905
1906 make-gdb.tar.Z: $(DEVO_SUPPORT) $(GDB_SUPPORT_DIRS) gdb texinfo/fsf/texinfo.tex
1907         rm -rf proto-toplev; mkdir proto-toplev
1908         ln -s ../gdb/proto-gdb.dir proto-toplev/gdb
1909         (cd proto-toplev; for i in $(DEVO_SUPPORT) $(GDB_SUPPORT_DIRS); do \
1910                 ln -s ../$$i . ; \
1911         done)
1912         # Put only one copy (four hard links) of COPYING in the tar file.
1913         rm                          proto-toplev/bfd/COPYING
1914         ln proto-toplev/gdb/COPYING proto-toplev/bfd/COPYING
1915         rm                          proto-toplev/include/COPYING
1916         ln proto-toplev/gdb/COPYING proto-toplev/include/COPYING
1917         rm                          proto-toplev/readline/COPYING
1918         ln proto-toplev/gdb/COPYING proto-toplev/readline/COPYING
1919         # Take out texinfo from configurable dirs
1920         rm proto-toplev/configure.in
1921         sed '/^configdirs=/s/texinfo //' <configure.in >proto-toplev/configure.in
1922         # Take out glob from buildable dirs
1923         rm proto-toplev/Makefile.in
1924         sed '/^SUBDIRS =/s/glob //' <Makefile.in >proto-toplev/Makefile.in
1925         # Take out texinfo from buildable dirs
1926         cp proto-toplev/Makefile.in temp.$$
1927         sed '/^all\.normal: /s/all-texinfo //' <temp.$$ >temp1.$$
1928         sed '/^clean: /s/clean-texinfo //' <temp1.$$ >temp.$$
1929         sed '/^install\.all: /s/install-texinfo //' <temp.$$ >proto-toplev/Makefile.in
1930         rm temp.$$ temp1.$$
1931         mkdir proto-toplev/texinfo
1932         mkdir proto-toplev/texinfo/fsf
1933         ln -s ../../../texinfo/fsf/texinfo.tex proto-toplev/texinfo/fsf/
1934         chmod og=u `find proto-toplev -print`
1935         (VER=`sed <gdb/Makefile.in -n 's/VERSION = //p'`; \
1936                 echo "==> Making gdb-$$VER.tar.Z"; \
1937                 ln -s proto-toplev gdb-$$VER; \
1938                 tar cfh - gdb-$$VER \
1939                 | compress -v >gdb-$$VER.tar.Z)
1940
1941 force_update:
1942
1943 nothing:
1944
1945 # end of Makefile.in