Makefile.in

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