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