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