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