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