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