Changeset a5de33e


Ignore:
Timestamp:
Jul 5, 2017, 5:00:46 PM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
55a68c3, 5805d15
Parents:
f7cb0bc (diff), 1ce2189 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Files:
5 added
1 deleted
51 edited
1 moved

Legend:

Unmodified
Added
Removed
  • .gitignore

    rf7cb0bc ra5de33e  
    4242src/Parser/parser.cc
    4343src/Parser/parser.h
     44src/Parser/parser.hh
    4445
    4546tools/prettyprinter/parser.output
     
    4748tools/prettyprinter/parser.cc
    4849tools/prettyprinter/parser.h
     50tools/prettyprinter/parser.hh
    4951tools/prettyprinter/pretty
    5052tools/pretty
     
    5456doc/user/pointer1.tex
    5557doc/user/pointer2.tex
     58doc/user/EHMHierarchy.tex
  • Makefile.in

    rf7cb0bc ra5de33e  
    1 # Makefile.in generated by automake 1.11.3 from Makefile.am.
     1# Makefile.in generated by automake 1.15 from Makefile.am.
    22# @configure_input@
    33
    4 # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
    5 # 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
    6 # Foundation, Inc.
     4# Copyright (C) 1994-2014 Free Software Foundation, Inc.
     5
    76# This Makefile.in is free software; the Free Software Foundation
    87# gives unlimited permission to copy and/or distribute it,
     
    1918###############################################################################
    2019VPATH = @srcdir@
     20am__is_gnu_make = { \
     21  if test -z '$(MAKELEVEL)'; then \
     22    false; \
     23  elif test -n '$(MAKE_HOST)'; then \
     24    true; \
     25  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
     26    true; \
     27  else \
     28    false; \
     29  fi; \
     30}
     31am__make_running_with_option = \
     32  case $${target_option-} in \
     33      ?) ;; \
     34      *) echo "am__make_running_with_option: internal error: invalid" \
     35              "target option '$${target_option-}' specified" >&2; \
     36         exit 1;; \
     37  esac; \
     38  has_opt=no; \
     39  sane_makeflags=$$MAKEFLAGS; \
     40  if $(am__is_gnu_make); then \
     41    sane_makeflags=$$MFLAGS; \
     42  else \
     43    case $$MAKEFLAGS in \
     44      *\\[\ \   ]*) \
     45        bs=\\; \
     46        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
     47          | sed "s/$$bs$$bs[$$bs $$bs   ]*//g"`;; \
     48    esac; \
     49  fi; \
     50  skip_next=no; \
     51  strip_trailopt () \
     52  { \
     53    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
     54  }; \
     55  for flg in $$sane_makeflags; do \
     56    test $$skip_next = yes && { skip_next=no; continue; }; \
     57    case $$flg in \
     58      *=*|--*) continue;; \
     59        -*I) strip_trailopt 'I'; skip_next=yes;; \
     60      -*I?*) strip_trailopt 'I';; \
     61        -*O) strip_trailopt 'O'; skip_next=yes;; \
     62      -*O?*) strip_trailopt 'O';; \
     63        -*l) strip_trailopt 'l'; skip_next=yes;; \
     64      -*l?*) strip_trailopt 'l';; \
     65      -[dEDm]) skip_next=yes;; \
     66      -[JT]) skip_next=yes;; \
     67    esac; \
     68    case $$flg in \
     69      *$$target_option*) has_opt=yes; break;; \
     70    esac; \
     71  done; \
     72  test $$has_opt = yes
     73am__make_dryrun = (target_option=n; $(am__make_running_with_option))
     74am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
    2175pkgdatadir = $(datadir)/@PACKAGE@
    2276pkgincludedir = $(includedir)/@PACKAGE@
     
    3892host_triplet = @host@
    3993subdir = .
    40 DIST_COMMON = README $(am__configure_deps) $(srcdir)/Makefile.am \
    41         $(srcdir)/Makefile.in $(srcdir)/config.h.in \
    42         $(top_srcdir)/configure INSTALL automake/compile \
    43         automake/config.guess automake/config.sub automake/depcomp \
    44         automake/install-sh automake/missing automake/ylwrap
    4594ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    4695am__aclocal_m4_deps = $(top_srcdir)/configure.ac
    4796am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
    4897        $(ACLOCAL_M4)
     98DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
     99        $(am__configure_deps) $(am__DIST_COMMON)
    49100am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
    50101 configure.lineno config.status.lineno
     
    53104CONFIG_CLEAN_FILES =
    54105CONFIG_CLEAN_VPATH_FILES =
     106AM_V_P = $(am__v_P_@AM_V@)
     107am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
     108am__v_P_0 = false
     109am__v_P_1 = :
    55110AM_V_GEN = $(am__v_GEN_@AM_V@)
    56111am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
    57 am__v_GEN_0 = @echo "  GEN   " $@;
     112am__v_GEN_0 = @echo "  GEN     " $@;
     113am__v_GEN_1 =
    58114AM_V_at = $(am__v_at_@AM_V@)
    59115am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
    60116am__v_at_0 = @
     117am__v_at_1 =
    61118SOURCES =
    62119DIST_SOURCES =
    63 RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
    64         html-recursive info-recursive install-data-recursive \
    65         install-dvi-recursive install-exec-recursive \
    66         install-html-recursive install-info-recursive \
    67         install-pdf-recursive install-ps-recursive install-recursive \
    68         installcheck-recursive installdirs-recursive pdf-recursive \
    69         ps-recursive uninstall-recursive
     120RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
     121        ctags-recursive dvi-recursive html-recursive info-recursive \
     122        install-data-recursive install-dvi-recursive \
     123        install-exec-recursive install-html-recursive \
     124        install-info-recursive install-pdf-recursive \
     125        install-ps-recursive install-recursive installcheck-recursive \
     126        installdirs-recursive pdf-recursive ps-recursive \
     127        tags-recursive uninstall-recursive
     128am__can_run_installinfo = \
     129  case $$AM_UPDATE_INFO_DIR in \
     130    n|no|NO) false;; \
     131    *) (install-info --version) >/dev/null 2>&1;; \
     132  esac
    70133RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
    71134  distclean-recursive maintainer-clean-recursive
    72 AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \
    73         $(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS \
    74         distdir dist dist-all distcheck
     135am__recursive_targets = \
     136  $(RECURSIVE_TARGETS) \
     137  $(RECURSIVE_CLEAN_TARGETS) \
     138  $(am__extra_recursive_targets)
     139AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
     140        cscope distdir dist dist-all distcheck
     141am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \
     142        $(LISP)config.h.in
     143# Read a list of newline-separated strings from the standard input,
     144# and print each of them once, without duplicates.  Input order is
     145# *not* preserved.
     146am__uniquify_input = $(AWK) '\
     147  BEGIN { nonempty = 0; } \
     148  { items[$$0] = 1; nonempty = 1; } \
     149  END { if (nonempty) { for (i in items) print i; }; } \
     150'
     151# Make sure the list of sources is unique.  This is necessary because,
     152# e.g., the same source file might be shared among _SOURCES variables
     153# for different programs/libraries.
     154am__define_uniq_tagged_files = \
     155  list='$(am__tagged_files)'; \
     156  unique=`for i in $$list; do \
     157    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
     158  done | $(am__uniquify_input)`
    75159ETAGS = etags
    76160CTAGS = ctags
     161CSCOPE = cscope
    77162DIST_SUBDIRS = $(SUBDIRS)
     163am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.h.in \
     164        $(top_srcdir)/automake/compile \
     165        $(top_srcdir)/automake/config.guess \
     166        $(top_srcdir)/automake/config.sub \
     167        $(top_srcdir)/automake/install-sh \
     168        $(top_srcdir)/automake/missing INSTALL README automake/compile \
     169        automake/config.guess automake/config.sub automake/depcomp \
     170        automake/install-sh automake/missing automake/ylwrap
    78171DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
    79172distdir = $(PACKAGE)-$(VERSION)
     
    85178      || { sleep 5 && rm -rf "$(distdir)"; }; \
    86179  else :; fi
     180am__post_remove_distdir = $(am__remove_distdir)
    87181am__relativize = \
    88182  dir0=`pwd`; \
     
    112206DIST_ARCHIVES = $(distdir).tar.gz
    113207GZIP_ENV = --best
     208DIST_TARGETS = dist-gzip
    114209distuninstallcheck_listfiles = find . -type f -print
    115210am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
     
    227322program_transform_name = @program_transform_name@
    228323psdir = @psdir@
     324runstatedir = @runstatedir@
    229325sbindir = @sbindir@
    230326sharedstatedir = @sharedstatedir@
     
    258354        $(am__cd) $(top_srcdir) && \
    259355          $(AUTOMAKE) --foreign Makefile
    260 .PRECIOUS: Makefile
    261356Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
    262357        @case '$?' in \
     
    279374
    280375config.h: stamp-h1
    281         @if test ! -f $@; then rm -f stamp-h1; else :; fi
    282         @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) stamp-h1; else :; fi
     376        @test -f $@ || rm -f stamp-h1
     377        @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1
    283378
    284379stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status
     
    294389
    295390# This directory's subdirectories are mostly independent; you can cd
    296 # into them and run `make' without going through this Makefile.
    297 # To change the values of `make' variables: instead of editing Makefiles,
    298 # (1) if the variable is set in `config.status', edit `config.status'
    299 #     (which will cause the Makefiles to be regenerated when you run `make');
    300 # (2) otherwise, pass the desired values on the `make' command line.
    301 $(RECURSIVE_TARGETS):
    302         @fail= failcom='exit 1'; \
    303         for f in x $$MAKEFLAGS; do \
    304           case $$f in \
    305             *=* | --[!k]*);; \
    306             *k*) failcom='fail=yes';; \
    307           esac; \
    308         done; \
     391# into them and run 'make' without going through this Makefile.
     392# To change the values of 'make' variables: instead of editing Makefiles,
     393# (1) if the variable is set in 'config.status', edit 'config.status'
     394#     (which will cause the Makefiles to be regenerated when you run 'make');
     395# (2) otherwise, pass the desired values on the 'make' command line.
     396$(am__recursive_targets):
     397        @fail=; \
     398        if $(am__make_keepgoing); then \
     399          failcom='fail=yes'; \
     400        else \
     401          failcom='exit 1'; \
     402        fi; \
    309403        dot_seen=no; \
    310404        target=`echo $@ | sed s/-recursive//`; \
    311         list='$(SUBDIRS)'; for subdir in $$list; do \
     405        case "$@" in \
     406          distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
     407          *) list='$(SUBDIRS)' ;; \
     408        esac; \
     409        for subdir in $$list; do \
    312410          echo "Making $$target in $$subdir"; \
    313411          if test "$$subdir" = "."; then \
     
    324422        fi; test -z "$$fail"
    325423
    326 $(RECURSIVE_CLEAN_TARGETS):
    327         @fail= failcom='exit 1'; \
    328         for f in x $$MAKEFLAGS; do \
    329           case $$f in \
    330             *=* | --[!k]*);; \
    331             *k*) failcom='fail=yes';; \
    332           esac; \
    333         done; \
    334         dot_seen=no; \
    335         case "$@" in \
    336           distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
    337           *) list='$(SUBDIRS)' ;; \
    338         esac; \
    339         rev=''; for subdir in $$list; do \
    340           if test "$$subdir" = "."; then :; else \
    341             rev="$$subdir $$rev"; \
    342           fi; \
    343         done; \
    344         rev="$$rev ."; \
    345         target=`echo $@ | sed s/-recursive//`; \
    346         for subdir in $$rev; do \
    347           echo "Making $$target in $$subdir"; \
    348           if test "$$subdir" = "."; then \
    349             local_target="$$target-am"; \
    350           else \
    351             local_target="$$target"; \
    352           fi; \
    353           ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
    354           || eval $$failcom; \
    355         done && test -z "$$fail"
    356 tags-recursive:
    357         list='$(SUBDIRS)'; for subdir in $$list; do \
    358           test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
    359         done
    360 ctags-recursive:
    361         list='$(SUBDIRS)'; for subdir in $$list; do \
    362           test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
    363         done
    364 
    365 ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
    366         list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
    367         unique=`for i in $$list; do \
    368             if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
    369           done | \
    370           $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
    371               END { if (nonempty) { for (i in files) print i; }; }'`; \
    372         mkid -fID $$unique
    373 tags: TAGS
    374 
    375 TAGS: tags-recursive $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \
    376                 $(TAGS_FILES) $(LISP)
     424ID: $(am__tagged_files)
     425        $(am__define_uniq_tagged_files); mkid -fID $$unique
     426tags: tags-recursive
     427TAGS: tags
     428
     429tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
    377430        set x; \
    378431        here=`pwd`; \
     
    390443          fi; \
    391444        done; \
    392         list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \
    393         unique=`for i in $$list; do \
    394             if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
    395           done | \
    396           $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
    397               END { if (nonempty) { for (i in files) print i; }; }'`; \
     445        $(am__define_uniq_tagged_files); \
    398446        shift; \
    399447        if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
     
    407455          fi; \
    408456        fi
    409 ctags: CTAGS
    410 CTAGS: ctags-recursive $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \
    411                 $(TAGS_FILES) $(LISP)
    412         list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \
    413         unique=`for i in $$list; do \
    414             if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
    415           done | \
    416           $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
    417               END { if (nonempty) { for (i in files) print i; }; }'`; \
     457ctags: ctags-recursive
     458
     459CTAGS: ctags
     460ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
     461        $(am__define_uniq_tagged_files); \
    418462        test -z "$(CTAGS_ARGS)$$unique" \
    419463          || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
     
    424468          && $(am__cd) $(top_srcdir) \
    425469          && gtags -i $(GTAGS_ARGS) "$$here"
     470cscope: cscope.files
     471        test ! -s cscope.files \
     472          || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS)
     473clean-cscope:
     474        -rm -f cscope.files
     475cscope.files: clean-cscope cscopelist
     476cscopelist: cscopelist-recursive
     477
     478cscopelist-am: $(am__tagged_files)
     479        list='$(am__tagged_files)'; \
     480        case "$(srcdir)" in \
     481          [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
     482          *) sdir=$(subdir)/$(srcdir) ;; \
     483        esac; \
     484        for i in $$list; do \
     485          if test -f "$$i"; then \
     486            echo "$(subdir)/$$i"; \
     487          else \
     488            echo "$$sdir/$$i"; \
     489          fi; \
     490        done >> $(top_builddir)/cscope.files
    426491
    427492distclean-tags:
    428493        -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
     494        -rm -f cscope.out cscope.in.out cscope.po.out cscope.files
    429495
    430496distdir: $(DISTFILES)
     
    462528        @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
    463529          if test "$$subdir" = .; then :; else \
    464             test -d "$(distdir)/$$subdir" \
    465             || $(MKDIR_P) "$(distdir)/$$subdir" \
    466             || exit 1; \
    467           fi; \
    468         done
    469         @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
    470           if test "$$subdir" = .; then :; else \
     530            $(am__make_dryrun) \
     531              || test -d "$(distdir)/$$subdir" \
     532              || $(MKDIR_P) "$(distdir)/$$subdir" \
     533              || exit 1; \
    471534            dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
    472535            $(am__relativize); \
     
    497560dist-gzip: distdir
    498561        tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
    499         $(am__remove_distdir)
     562        $(am__post_remove_distdir)
    500563
    501564dist-bzip2: distdir
    502565        tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
    503         $(am__remove_distdir)
     566        $(am__post_remove_distdir)
    504567
    505568dist-lzip: distdir
    506569        tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
    507         $(am__remove_distdir)
    508 
    509 dist-lzma: distdir
    510         tardir=$(distdir) && $(am__tar) | lzma -9 -c >$(distdir).tar.lzma
    511         $(am__remove_distdir)
     570        $(am__post_remove_distdir)
    512571
    513572dist-xz: distdir
    514573        tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
    515         $(am__remove_distdir)
     574        $(am__post_remove_distdir)
    516575
    517576dist-tarZ: distdir
     577        @echo WARNING: "Support for distribution archives compressed with" \
     578                       "legacy program 'compress' is deprecated." >&2
     579        @echo WARNING: "It will be removed altogether in Automake 2.0" >&2
    518580        tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
    519         $(am__remove_distdir)
     581        $(am__post_remove_distdir)
    520582
    521583dist-shar: distdir
     584        @echo WARNING: "Support for shar distribution archives is" \
     585                       "deprecated." >&2
     586        @echo WARNING: "It will be removed altogether in Automake 2.0" >&2
    522587        shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
    523         $(am__remove_distdir)
     588        $(am__post_remove_distdir)
    524589
    525590dist-zip: distdir
    526591        -rm -f $(distdir).zip
    527592        zip -rq $(distdir).zip $(distdir)
    528         $(am__remove_distdir)
    529 
    530 dist dist-all: distdir
    531         tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
    532         $(am__remove_distdir)
     593        $(am__post_remove_distdir)
     594
     595dist dist-all:
     596        $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:'
     597        $(am__post_remove_distdir)
    533598
    534599# This target untars the dist file and tries a VPATH configuration.  Then
     
    541606        *.tar.bz2*) \
    542607          bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
    543         *.tar.lzma*) \
    544           lzma -dc $(distdir).tar.lzma | $(am__untar) ;;\
    545608        *.tar.lz*) \
    546609          lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
     
    554617          unzip $(distdir).zip ;;\
    555618        esac
    556         chmod -R a-w $(distdir); chmod a+w $(distdir)
    557         mkdir $(distdir)/_build
    558         mkdir $(distdir)/_inst
     619        chmod -R a-w $(distdir)
     620        chmod u+w $(distdir)
     621        mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst
    559622        chmod a-w $(distdir)
    560623        test -d $(distdir)/_build || exit 0; \
     
    562625          && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
    563626          && am__cwd=`pwd` \
    564           && $(am__cd) $(distdir)/_build \
    565           && ../configure --srcdir=.. --prefix="$$dc_install_base" \
     627          && $(am__cd) $(distdir)/_build/sub \
     628          && ../../configure \
    566629            $(AM_DISTCHECK_CONFIGURE_FLAGS) \
    567630            $(DISTCHECK_CONFIGURE_FLAGS) \
     631            --srcdir=../.. --prefix="$$dc_install_base" \
    568632          && $(MAKE) $(AM_MAKEFLAGS) \
    569633          && $(MAKE) $(AM_MAKEFLAGS) dvi \
     
    588652          && cd "$$am__cwd" \
    589653          || exit 1
    590         $(am__remove_distdir)
     654        $(am__post_remove_distdir)
    591655        @(echo "$(distdir) archives ready for distribution: "; \
    592656          list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
     
    723787uninstall-am:
    724788
    725 .MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) all \
    726         ctags-recursive install-am install-strip tags-recursive
    727 
    728 .PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \
    729         all all-am am--refresh check check-am clean clean-generic \
    730         ctags ctags-recursive dist dist-all dist-bzip2 dist-gzip \
    731         dist-lzip dist-lzma dist-shar dist-tarZ dist-xz dist-zip \
     789.MAKE: $(am__recursive_targets) all install-am install-strip
     790
     791.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
     792        am--refresh check check-am clean clean-cscope clean-generic \
     793        cscope cscopelist-am ctags ctags-am dist dist-all dist-bzip2 \
     794        dist-gzip dist-lzip dist-shar dist-tarZ dist-xz dist-zip \
    732795        distcheck distclean distclean-generic distclean-hdr \
    733796        distclean-tags distcleancheck distdir distuninstallcheck dvi \
     
    739802        installcheck installcheck-am installdirs installdirs-am \
    740803        maintainer-clean maintainer-clean-generic mostlyclean \
    741         mostlyclean-generic pdf pdf-am ps ps-am tags tags-recursive \
    742         uninstall uninstall-am
     804        mostlyclean-generic pdf pdf-am ps ps-am tags tags-am uninstall \
     805        uninstall-am
     806
     807.PRECIOUS: Makefile
    743808
    744809
  • aclocal.m4

    rf7cb0bc ra5de33e  
    1 # generated automatically by aclocal 1.11.3 -*- Autoconf -*-
    2 
    3 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
    4 # 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
    5 # Inc.
     1# generated automatically by aclocal 1.15 -*- Autoconf -*-
     2
     3# Copyright (C) 1996-2014 Free Software Foundation, Inc.
     4
    65# This file is free software; the Free Software Foundation
    76# gives unlimited permission to copy and/or distribute it,
     
    1312# PARTICULAR PURPOSE.
    1413
     14m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
    1515m4_ifndef([AC_AUTOCONF_VERSION],
    1616  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
    17 m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.68],,
    18 [m4_warning([this file was generated for autoconf 2.68.
     17m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
     18[m4_warning([this file was generated for autoconf 2.69.
    1919You have another version of autoconf.  It may work, but is not guaranteed to.
    2020If you have problems, you may need to regenerate the build system entirely.
    21 To do so, use the procedure documented by the package, typically `autoreconf'.])])
    22 
    23 # Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008, 2011 Free Software
    24 # Foundation, Inc.
    25 #
    26 # This file is free software; the Free Software Foundation
    27 # gives unlimited permission to copy and/or distribute it,
    28 # with or without modifications, as long as this notice is preserved.
    29 
    30 # serial 1
     21To do so, use the procedure documented by the package, typically 'autoreconf'.])])
     22
     23# Copyright (C) 2002-2014 Free Software Foundation, Inc.
     24#
     25# This file is free software; the Free Software Foundation
     26# gives unlimited permission to copy and/or distribute it,
     27# with or without modifications, as long as this notice is preserved.
    3128
    3229# AM_AUTOMAKE_VERSION(VERSION)
     
    3633# (This private macro should not be called outside this file.)
    3734AC_DEFUN([AM_AUTOMAKE_VERSION],
    38 [am__api_version='1.11'
     35[am__api_version='1.15'
    3936dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
    4037dnl require some minimum version.  Point them to the right macro.
    41 m4_if([$1], [1.11.3], [],
     38m4_if([$1], [1.15], [],
    4239      [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
    4340])
     
    5552# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
    5653AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
    57 [AM_AUTOMAKE_VERSION([1.11.3])dnl
     54[AM_AUTOMAKE_VERSION([1.15])dnl
    5855m4_ifndef([AC_AUTOCONF_VERSION],
    5956  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
     
    6259# Figure out how to run the assembler.                      -*- Autoconf -*-
    6360
    64 # Copyright (C) 2001, 2003, 2004, 2005, 2006  Free Software Foundation, Inc.
    65 #
    66 # This file is free software; the Free Software Foundation
    67 # gives unlimited permission to copy and/or distribute it,
    68 # with or without modifications, as long as this notice is preserved.
    69 
    70 # serial 5
     61# Copyright (C) 2001-2014 Free Software Foundation, Inc.
     62#
     63# This file is free software; the Free Software Foundation
     64# gives unlimited permission to copy and/or distribute it,
     65# with or without modifications, as long as this notice is preserved.
    7166
    7267# AM_PROG_AS
     
    8479# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
    8580
    86 # Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
    87 #
    88 # This file is free software; the Free Software Foundation
    89 # gives unlimited permission to copy and/or distribute it,
    90 # with or without modifications, as long as this notice is preserved.
    91 
    92 # serial 1
     81# Copyright (C) 2001-2014 Free Software Foundation, Inc.
     82#
     83# This file is free software; the Free Software Foundation
     84# gives unlimited permission to copy and/or distribute it,
     85# with or without modifications, as long as this notice is preserved.
    9386
    9487# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
    95 # $ac_aux_dir to `$srcdir/foo'.  In other projects, it is set to
    96 # `$srcdir', `$srcdir/..', or `$srcdir/../..'.
     88# $ac_aux_dir to '$srcdir/foo'.  In other projects, it is set to
     89# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
    9790#
    9891# Of course, Automake must honor this variable whenever it calls a
     
    113106# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
    114107# are both prefixed by $srcdir.  In an in-source build this is usually
    115 # harmless because $srcdir is `.', but things will broke when you
     108# harmless because $srcdir is '.', but things will broke when you
    116109# start a VPATH build or use an absolute $srcdir.
    117110#
     
    131124
    132125AC_DEFUN([AM_AUX_DIR_EXPAND],
    133 [dnl Rely on autoconf to set up CDPATH properly.
    134 AC_PREREQ([2.50])dnl
    135 # expand $ac_aux_dir to an absolute path
    136 am_aux_dir=`cd $ac_aux_dir && pwd`
     126[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
     127# Expand $ac_aux_dir to an absolute path.
     128am_aux_dir=`cd "$ac_aux_dir" && pwd`
    137129])
    138130
    139131# AM_COND_IF                                            -*- Autoconf -*-
    140132
    141 # Copyright (C) 2008, 2010 Free Software Foundation, Inc.
    142 #
    143 # This file is free software; the Free Software Foundation
    144 # gives unlimited permission to copy and/or distribute it,
    145 # with or without modifications, as long as this notice is preserved.
    146 
    147 # serial 3
     133# Copyright (C) 2008-2014 Free Software Foundation, Inc.
     134#
     135# This file is free software; the Free Software Foundation
     136# gives unlimited permission to copy and/or distribute it,
     137# with or without modifications, as long as this notice is preserved.
    148138
    149139# _AM_COND_IF
     
    155145m4_define([_AM_COND_ELSE])
    156146m4_define([_AM_COND_ENDIF])
    157 
    158147
    159148# AM_COND_IF(COND, [IF-TRUE], [IF-FALSE])
     
    179168# AM_CONDITIONAL                                            -*- Autoconf -*-
    180169
    181 # Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005, 2006, 2008
    182 # Free Software Foundation, Inc.
    183 #
    184 # This file is free software; the Free Software Foundation
    185 # gives unlimited permission to copy and/or distribute it,
    186 # with or without modifications, as long as this notice is preserved.
    187 
    188 # serial 9
     170# Copyright (C) 1997-2014 Free Software Foundation, Inc.
     171#
     172# This file is free software; the Free Software Foundation
     173# gives unlimited permission to copy and/or distribute it,
     174# with or without modifications, as long as this notice is preserved.
    189175
    190176# AM_CONDITIONAL(NAME, SHELL-CONDITION)
     
    192178# Define a conditional.
    193179AC_DEFUN([AM_CONDITIONAL],
    194 [AC_PREREQ(2.52)dnl
    195  ifelse([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
    196         [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
     180[AC_PREREQ([2.52])dnl
     181 m4_if([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
     182       [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
    197183AC_SUBST([$1_TRUE])dnl
    198184AC_SUBST([$1_FALSE])dnl
     
    213199fi])])
    214200
    215 # Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009,
    216 # 2010, 2011 Free Software Foundation, Inc.
    217 #
    218 # This file is free software; the Free Software Foundation
    219 # gives unlimited permission to copy and/or distribute it,
    220 # with or without modifications, as long as this notice is preserved.
    221 
    222 # serial 12
    223 
    224 # There are a few dirty hacks below to avoid letting `AC_PROG_CC' be
     201# Copyright (C) 1999-2014 Free Software Foundation, Inc.
     202#
     203# This file is free software; the Free Software Foundation
     204# gives unlimited permission to copy and/or distribute it,
     205# with or without modifications, as long as this notice is preserved.
     206
     207
     208# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
    225209# written in clear, in which case automake, when reading aclocal.m4,
    226210# will think it sees a *use*, and therefore will trigger all it's
     
    232216# ----------------------
    233217# See how the compiler implements dependency checking.
    234 # NAME is "CC", "CXX", "GCJ", or "OBJC".
     218# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
    235219# We try a few techniques and use that to set a single cache variable.
    236220#
     
    245229AC_REQUIRE([AM_DEP_TRACK])dnl
    246230
    247 ifelse([$1], CC,   [depcc="$CC"   am_compiler_list=],
    248        [$1], CXX,  [depcc="$CXX"  am_compiler_list=],
    249        [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
    250        [$1], UPC,  [depcc="$UPC"  am_compiler_list=],
    251        [$1], GCJ,  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
    252                    [depcc="$$1"   am_compiler_list=])
     231m4_if([$1], [CC],   [depcc="$CC"   am_compiler_list=],
     232      [$1], [CXX],  [depcc="$CXX"  am_compiler_list=],
     233      [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
     234      [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'],
     235      [$1], [UPC],  [depcc="$UPC"  am_compiler_list=],
     236      [$1], [GCJ],  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
     237                    [depcc="$$1"   am_compiler_list=])
    253238
    254239AC_CACHE_CHECK([dependency style of $depcc],
     
    258243  # making bogus files that we don't know about and never remove.  For
    259244  # instance it was reported that on HP-UX the gcc test will end up
    260   # making a dummy file named `D' -- because `-MD' means `put the output
    261   # in D'.
     245  # making a dummy file named 'D' -- because '-MD' means "put the output
     246  # in D".
    262247  rm -rf conftest.dir
    263248  mkdir conftest.dir
     
    299284    for i in 1 2 3 4 5 6; do
    300285      echo '#include "conftst'$i'.h"' >> sub/conftest.c
    301       # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
    302       # Solaris 8's {/usr,}/bin/sh.
    303       touch sub/conftst$i.h
     286      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
     287      # Solaris 10 /bin/sh.
     288      echo '/* dummy */' > sub/conftst$i.h
    304289    done
    305290    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
    306291
    307     # We check with `-c' and `-o' for the sake of the "dashmstdout"
     292    # We check with '-c' and '-o' for the sake of the "dashmstdout"
    308293    # mode.  It turns out that the SunPro C++ compiler does not properly
    309     # handle `-M -o', and we need to detect this.  Also, some Intel
    310     # versions had trouble with output in subdirs
     294    # handle '-M -o', and we need to detect this.  Also, some Intel
     295    # versions had trouble with output in subdirs.
    311296    am__obj=sub/conftest.${OBJEXT-o}
    312297    am__minus_obj="-o $am__obj"
     
    317302      ;;
    318303    nosideeffect)
    319       # after this tag, mechanisms are not by side-effect, so they'll
    320       # only be used when explicitly requested
     304      # After this tag, mechanisms are not by side-effect, so they'll
     305      # only be used when explicitly requested.
    321306      if test "x$enable_dependency_tracking" = xyes; then
    322307        continue
     
    326311      ;;
    327312    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
    328       # This compiler won't grok `-c -o', but also, the minuso test has
     313      # This compiler won't grok '-c -o', but also, the minuso test has
    329314      # not run yet.  These depmodes are late enough in the game, and
    330315      # so weak that their functioning should not be impacted.
     
    374359# -------------
    375360# Choose a directory name for dependency files.
    376 # This macro is AC_REQUIREd in _AM_DEPENDENCIES
     361# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
    377362AC_DEFUN([AM_SET_DEPDIR],
    378363[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
     
    384369# ------------
    385370AC_DEFUN([AM_DEP_TRACK],
    386 [AC_ARG_ENABLE(dependency-tracking,
    387 [  --disable-dependency-tracking  speeds up one-time build
    388   --enable-dependency-tracking   do not reject slow dependency extractors])
     371[AC_ARG_ENABLE([dependency-tracking], [dnl
     372AS_HELP_STRING(
     373  [--enable-dependency-tracking],
     374  [do not reject slow dependency extractors])
     375AS_HELP_STRING(
     376  [--disable-dependency-tracking],
     377  [speeds up one-time build])])
    389378if test "x$enable_dependency_tracking" != xno; then
    390379  am_depcomp="$ac_aux_dir/depcomp"
     
    401390# Generate code to set up dependency tracking.              -*- Autoconf -*-
    402391
    403 # Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008
    404 # Free Software Foundation, Inc.
    405 #
    406 # This file is free software; the Free Software Foundation
    407 # gives unlimited permission to copy and/or distribute it,
    408 # with or without modifications, as long as this notice is preserved.
    409 
    410 #serial 5
     392# Copyright (C) 1999-2014 Free Software Foundation, Inc.
     393#
     394# This file is free software; the Free Software Foundation
     395# gives unlimited permission to copy and/or distribute it,
     396# with or without modifications, as long as this notice is preserved.
     397
    411398
    412399# _AM_OUTPUT_DEPENDENCY_COMMANDS
     
    414401AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
    415402[{
    416   # Autoconf 2.62 quotes --file arguments for eval, but not when files
     403  # Older Autoconf quotes --file arguments for eval, but not when files
    417404  # are listed without --file.  Let's play safe and only enable the eval
    418405  # if we detect the quoting.
     
    427414    mf=`echo "$mf" | sed -e 's/:.*$//'`
    428415    # Check whether this is an Automake generated Makefile or not.
    429     # We used to match only the files named `Makefile.in', but
     416    # We used to match only the files named 'Makefile.in', but
    430417    # some people rename them; so instead we look at the file content.
    431418    # Grep'ing the first line is not enough: some people post-process
     
    439426    fi
    440427    # Extract the definition of DEPDIR, am__include, and am__quote
    441     # from the Makefile without running `make'.
     428    # from the Makefile without running 'make'.
    442429    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
    443430    test -z "$DEPDIR" && continue
    444431    am__include=`sed -n 's/^am__include = //p' < "$mf"`
    445     test -z "am__include" && continue
     432    test -z "$am__include" && continue
    446433    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
    447     # When using ansi2knr, U may be empty or an underscore; expand it
    448     U=`sed -n 's/^U = //p' < "$mf"`
    449434    # Find all dependency output files, they are included files with
    450435    # $(DEPDIR) in their names.  We invoke sed twice because it is the
     
    453438    for file in `sed -n "
    454439      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
    455          sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
     440         sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
    456441      # Make sure the directory exists.
    457442      test -f "$dirpart/$file" && continue
     
    471456#
    472457# This code is only required when automatic dependency tracking
    473 # is enabled.  FIXME.  This creates each `.P' file that we will
     458# is enabled.  FIXME.  This creates each '.P' file that we will
    474459# need in order to bootstrap the dependency handling code.
    475460AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
     
    481466# Do all the work for Automake.                             -*- Autoconf -*-
    482467
    483 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
    484 # 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
    485 #
    486 # This file is free software; the Free Software Foundation
    487 # gives unlimited permission to copy and/or distribute it,
    488 # with or without modifications, as long as this notice is preserved.
    489 
    490 # serial 16
     468# Copyright (C) 1996-2014 Free Software Foundation, Inc.
     469#
     470# This file is free software; the Free Software Foundation
     471# gives unlimited permission to copy and/or distribute it,
     472# with or without modifications, as long as this notice is preserved.
    491473
    492474# This macro actually does too much.  Some checks are only needed if
    493475# your package does certain things.  But this isn't really a big deal.
     476
     477dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
     478m4_define([AC_PROG_CC],
     479m4_defn([AC_PROG_CC])
     480[_AM_PROG_CC_C_O
     481])
    494482
    495483# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
     
    505493# release and drop the old call support.
    506494AC_DEFUN([AM_INIT_AUTOMAKE],
    507 [AC_PREREQ([2.62])dnl
     495[AC_PREREQ([2.65])dnl
    508496dnl Autoconf wants to disallow AM_ names.  We explicitly allow
    509497dnl the ones we care about.
     
    534522dnl Distinguish between old-style and new-style calls.
    535523m4_ifval([$2],
    536 [m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
     524[AC_DIAGNOSE([obsolete],
     525             [$0: two- and three-arguments forms are deprecated.])
     526m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
    537527 AC_SUBST([PACKAGE], [$1])dnl
    538528 AC_SUBST([VERSION], [$2])],
    539529[_AM_SET_OPTIONS([$1])dnl
    540530dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
    541 m4_if(m4_ifdef([AC_PACKAGE_NAME], 1)m4_ifdef([AC_PACKAGE_VERSION], 1), 11,,
     531m4_if(
     532  m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]),
     533  [ok:ok],,
    542534  [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
    543535 AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
     
    545537
    546538_AM_IF_OPTION([no-define],,
    547 [AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
    548  AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl
     539[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package])
     540 AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl
    549541
    550542# Some tools Automake needs.
    551543AC_REQUIRE([AM_SANITY_CHECK])dnl
    552544AC_REQUIRE([AC_ARG_PROGRAM])dnl
    553 AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})
    554 AM_MISSING_PROG(AUTOCONF, autoconf)
    555 AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})
    556 AM_MISSING_PROG(AUTOHEADER, autoheader)
    557 AM_MISSING_PROG(MAKEINFO, makeinfo)
     545AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}])
     546AM_MISSING_PROG([AUTOCONF], [autoconf])
     547AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}])
     548AM_MISSING_PROG([AUTOHEADER], [autoheader])
     549AM_MISSING_PROG([MAKEINFO], [makeinfo])
    558550AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
    559551AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
    560 AC_REQUIRE([AM_PROG_MKDIR_P])dnl
    561 # We need awk for the "check" target.  The system "awk" is bad on
    562 # some platforms.
     552AC_REQUIRE([AC_PROG_MKDIR_P])dnl
     553# For better backward compatibility.  To be removed once Automake 1.9.x
     554# dies out for good.  For more background, see:
     555# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
     556# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
     557AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
     558# We need awk for the "check" target (and possibly the TAP driver).  The
     559# system "awk" is bad on some platforms.
    563560AC_REQUIRE([AC_PROG_AWK])dnl
    564561AC_REQUIRE([AC_PROG_MAKE_SET])dnl
     
    569566_AM_IF_OPTION([no-dependencies],,
    570567[AC_PROVIDE_IFELSE([AC_PROG_CC],
    571                   [_AM_DEPENDENCIES(CC)],
    572                   [define([AC_PROG_CC],
    573                           defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl
     568                  [_AM_DEPENDENCIES([CC])],
     569                  [m4_define([AC_PROG_CC],
     570                             m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl
    574571AC_PROVIDE_IFELSE([AC_PROG_CXX],
    575                   [_AM_DEPENDENCIES(CXX)],
    576                   [define([AC_PROG_CXX],
    577                           defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl
     572                  [_AM_DEPENDENCIES([CXX])],
     573                  [m4_define([AC_PROG_CXX],
     574                             m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl
    578575AC_PROVIDE_IFELSE([AC_PROG_OBJC],
    579                   [_AM_DEPENDENCIES(OBJC)],
    580                   [define([AC_PROG_OBJC],
    581                           defn([AC_PROG_OBJC])[_AM_DEPENDENCIES(OBJC)])])dnl
    582 ])
    583 _AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl
    584 dnl The `parallel-tests' driver may need to know about EXEEXT, so add the
    585 dnl `am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This macro
    586 dnl is hooked onto _AC_COMPILER_EXEEXT early, see below.
     576                  [_AM_DEPENDENCIES([OBJC])],
     577                  [m4_define([AC_PROG_OBJC],
     578                             m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl
     579AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
     580                  [_AM_DEPENDENCIES([OBJCXX])],
     581                  [m4_define([AC_PROG_OBJCXX],
     582                             m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
     583])
     584AC_REQUIRE([AM_SILENT_RULES])dnl
     585dnl The testsuite driver may need to know about EXEEXT, so add the
     586dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This
     587dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
    587588AC_CONFIG_COMMANDS_PRE(dnl
    588589[m4_provide_if([_AM_COMPILER_EXEEXT],
    589590  [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
    590 ])
    591 
    592 dnl Hook into `_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
     591
     592# POSIX will say in a future version that running "rm -f" with no argument
     593# is OK; and we want to be able to make that assumption in our Makefile
     594# recipes.  So use an aggressive probe to check that the usage we want is
     595# actually supported "in the wild" to an acceptable degree.
     596# See automake bug#10828.
     597# To make any issue more visible, cause the running configure to be aborted
     598# by default if the 'rm' program in use doesn't match our expectations; the
     599# user can still override this though.
     600if rm -f && rm -fr && rm -rf; then : OK; else
     601  cat >&2 <<'END'
     602Oops!
     603
     604Your 'rm' program seems unable to run without file operands specified
     605on the command line, even when the '-f' option is present.  This is contrary
     606to the behaviour of most rm programs out there, and not conforming with
     607the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
     608
     609Please tell bug-automake@gnu.org about your system, including the value
     610of your $PATH and any error possibly output before this message.  This
     611can help us improve future automake versions.
     612
     613END
     614  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
     615    echo 'Configuration will proceed anyway, since you have set the' >&2
     616    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
     617    echo >&2
     618  else
     619    cat >&2 <<'END'
     620Aborting the configuration process, to ensure you take notice of the issue.
     621
     622You can download and install GNU coreutils to get an 'rm' implementation
     623that behaves properly: <http://www.gnu.org/software/coreutils/>.
     624
     625If you want to complete the configuration process using your problematic
     626'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
     627to "yes", and re-run configure.
     628
     629END
     630    AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
     631  fi
     632fi
     633dnl The trailing newline in this macro's definition is deliberate, for
     634dnl backward compatibility and to allow trailing 'dnl'-style comments
     635dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
     636])
     637
     638dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
    593639dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
    594640dnl mangled by Autoconf and run in a shell conditional statement.
    595641m4_define([_AC_COMPILER_EXEEXT],
    596642m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
    597 
    598643
    599644# When config.status generates a header, we must update the stamp-h file.
     
    618663echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
    619664
    620 # Copyright (C) 2001, 2003, 2005, 2008, 2011 Free Software Foundation,
    621 # Inc.
    622 #
    623 # This file is free software; the Free Software Foundation
    624 # gives unlimited permission to copy and/or distribute it,
    625 # with or without modifications, as long as this notice is preserved.
    626 
    627 # serial 1
     665# Copyright (C) 2001-2014 Free Software Foundation, Inc.
     666#
     667# This file is free software; the Free Software Foundation
     668# gives unlimited permission to copy and/or distribute it,
     669# with or without modifications, as long as this notice is preserved.
    628670
    629671# AM_PROG_INSTALL_SH
     
    632674AC_DEFUN([AM_PROG_INSTALL_SH],
    633675[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
    634 if test x"${install_sh}" != xset; then
     676if test x"${install_sh+set}" != xset; then
    635677  case $am_aux_dir in
    636678  *\ * | *\     *)
     
    640682  esac
    641683fi
    642 AC_SUBST(install_sh)])
    643 
    644 # Copyright (C) 2003, 2005  Free Software Foundation, Inc.
    645 #
    646 # This file is free software; the Free Software Foundation
    647 # gives unlimited permission to copy and/or distribute it,
    648 # with or without modifications, as long as this notice is preserved.
    649 
    650 # serial 2
     684AC_SUBST([install_sh])])
     685
     686# Copyright (C) 2003-2014 Free Software Foundation, Inc.
     687#
     688# This file is free software; the Free Software Foundation
     689# gives unlimited permission to copy and/or distribute it,
     690# with or without modifications, as long as this notice is preserved.
    651691
    652692# Check whether the underlying file-system supports filenames
     
    666706# From Jim Meyering
    667707
    668 # Copyright (C) 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2008,
    669 # 2011 Free Software Foundation, Inc.
    670 #
    671 # This file is free software; the Free Software Foundation
    672 # gives unlimited permission to copy and/or distribute it,
    673 # with or without modifications, as long as this notice is preserved.
    674 
    675 # serial 5
     708# Copyright (C) 1996-2014 Free Software Foundation, Inc.
     709#
     710# This file is free software; the Free Software Foundation
     711# gives unlimited permission to copy and/or distribute it,
     712# with or without modifications, as long as this notice is preserved.
    676713
    677714# AM_MAINTAINER_MODE([DEFAULT-MODE])
    678715# ----------------------------------
    679716# Control maintainer-specific portions of Makefiles.
    680 # Default is to disable them, unless `enable' is passed literally.
    681 # For symmetry, `disable' may be passed as well.  Anyway, the user
     717# Default is to disable them, unless 'enable' is passed literally.
     718# For symmetry, 'disable' may be passed as well.  Anyway, the user
    682719# can override the default with the --enable/--disable switch.
    683720AC_DEFUN([AM_MAINTAINER_MODE],
     
    690727  dnl maintainer-mode's default is 'disable' unless 'enable' is passed
    691728  AC_ARG_ENABLE([maintainer-mode],
    692 [  --][am_maintainer_other][-maintainer-mode  am_maintainer_other make rules and dependencies not useful
    693                           (and sometimes confusing) to the casual installer],
    694       [USE_MAINTAINER_MODE=$enableval],
    695       [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes]))
     729    [AS_HELP_STRING([--]am_maintainer_other[-maintainer-mode],
     730      am_maintainer_other[ make rules and dependencies not useful
     731      (and sometimes confusing) to the casual installer])],
     732    [USE_MAINTAINER_MODE=$enableval],
     733    [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes]))
    696734  AC_MSG_RESULT([$USE_MAINTAINER_MODE])
    697735  AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes])
     
    701739)
    702740
    703 AU_DEFUN([jm_MAINTAINER_MODE], [AM_MAINTAINER_MODE])
    704 
    705741# Check to see how 'make' treats includes.                  -*- Autoconf -*-
    706742
    707 # Copyright (C) 2001, 2002, 2003, 2005, 2009  Free Software Foundation, Inc.
    708 #
    709 # This file is free software; the Free Software Foundation
    710 # gives unlimited permission to copy and/or distribute it,
    711 # with or without modifications, as long as this notice is preserved.
    712 
    713 # serial 4
     743# Copyright (C) 2001-2014 Free Software Foundation, Inc.
     744#
     745# This file is free software; the Free Software Foundation
     746# gives unlimited permission to copy and/or distribute it,
     747# with or without modifications, as long as this notice is preserved.
    714748
    715749# AM_MAKE_INCLUDE()
     
    730764# First try GNU make style include.
    731765echo "include confinc" > confmf
    732 # Ignore all kinds of additional output from `make'.
     766# Ignore all kinds of additional output from 'make'.
    733767case `$am_make -s -f confmf 2> /dev/null` in #(
    734768*the\ am__doit\ target*)
     
    755789])
    756790
    757 # Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2008
    758 # Free Software Foundation, Inc.
    759 #
    760 # This file is free software; the Free Software Foundation
    761 # gives unlimited permission to copy and/or distribute it,
    762 # with or without modifications, as long as this notice is preserved.
    763 
    764 # serial 6
    765 
    766 # AM_PROG_CC_C_O
    767 # --------------
    768 # Like AC_PROG_CC_C_O, but changed for automake.
    769 AC_DEFUN([AM_PROG_CC_C_O],
    770 [AC_REQUIRE([AC_PROG_CC_C_O])dnl
    771 AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
    772 AC_REQUIRE_AUX_FILE([compile])dnl
    773 # FIXME: we rely on the cache variable name because
    774 # there is no other way.
    775 set dummy $CC
    776 am_cc=`echo $[2] | sed ['s/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/']`
    777 eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
    778 if test "$am_t" != yes; then
    779    # Losing compiler, so override with the script.
    780    # FIXME: It is wrong to rewrite CC.
    781    # But if we don't then we get into trouble of one sort or another.
    782    # A longer-term fix would be to have automake use am__CC in this case,
    783    # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
    784    CC="$am_aux_dir/compile $CC"
    785 fi
    786 dnl Make sure AC_PROG_CC is never called again, or it will override our
    787 dnl setting of CC.
    788 m4_define([AC_PROG_CC],
    789           [m4_fatal([AC_PROG_CC cannot be called after AM_PROG_CC_C_O])])
    790 ])
    791 
    792791# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
    793792
    794 # Copyright (C) 1997, 1999, 2000, 2001, 2003, 2004, 2005, 2008
    795 # Free Software Foundation, Inc.
    796 #
    797 # This file is free software; the Free Software Foundation
    798 # gives unlimited permission to copy and/or distribute it,
    799 # with or without modifications, as long as this notice is preserved.
    800 
    801 # serial 6
     793# Copyright (C) 1997-2014 Free Software Foundation, Inc.
     794#
     795# This file is free software; the Free Software Foundation
     796# gives unlimited permission to copy and/or distribute it,
     797# with or without modifications, as long as this notice is preserved.
    802798
    803799# AM_MISSING_PROG(NAME, PROGRAM)
     
    808804AC_SUBST($1)])
    809805
    810 
    811806# AM_MISSING_HAS_RUN
    812807# ------------------
    813 # Define MISSING if not defined so far and test if it supports --run.
    814 # If it does, set am_missing_run to use it, otherwise, to nothing.
     808# Define MISSING if not defined so far and test if it is modern enough.
     809# If it is, set am_missing_run to use it, otherwise, to nothing.
    815810AC_DEFUN([AM_MISSING_HAS_RUN],
    816811[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
     
    825820fi
    826821# Use eval to expand $SHELL
    827 if eval "$MISSING --run true"; then
    828   am_missing_run="$MISSING --run "
     822if eval "$MISSING --is-lightweight"; then
     823  am_missing_run="$MISSING "
    829824else
    830825  am_missing_run=
    831   AC_MSG_WARN([`missing' script is too old or missing])
    832 fi
    833 ])
    834 
    835 # Copyright (C) 2003, 2004, 2005, 2006, 2011 Free Software Foundation,
    836 # Inc.
    837 #
    838 # This file is free software; the Free Software Foundation
    839 # gives unlimited permission to copy and/or distribute it,
    840 # with or without modifications, as long as this notice is preserved.
    841 
    842 # serial 1
    843 
    844 # AM_PROG_MKDIR_P
    845 # ---------------
    846 # Check for `mkdir -p'.
    847 AC_DEFUN([AM_PROG_MKDIR_P],
    848 [AC_PREREQ([2.60])dnl
    849 AC_REQUIRE([AC_PROG_MKDIR_P])dnl
    850 dnl Automake 1.8 to 1.9.6 used to define mkdir_p.  We now use MKDIR_P,
    851 dnl while keeping a definition of mkdir_p for backward compatibility.
    852 dnl @MKDIR_P@ is magic: AC_OUTPUT adjusts its value for each Makefile.
    853 dnl However we cannot define mkdir_p as $(MKDIR_P) for the sake of
    854 dnl Makefile.ins that do not define MKDIR_P, so we do our own
    855 dnl adjustment using top_builddir (which is defined more often than
    856 dnl MKDIR_P).
    857 AC_SUBST([mkdir_p], ["$MKDIR_P"])dnl
    858 case $mkdir_p in
    859   [[\\/$]]* | ?:[[\\/]]*) ;;
    860   */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
    861 esac
     826  AC_MSG_WARN(['missing' script is too old or missing])
     827fi
    862828])
    863829
    864830# Helper functions for option handling.                     -*- Autoconf -*-
    865831
    866 # Copyright (C) 2001, 2002, 2003, 2005, 2008, 2010 Free Software
    867 # Foundation, Inc.
    868 #
    869 # This file is free software; the Free Software Foundation
    870 # gives unlimited permission to copy and/or distribute it,
    871 # with or without modifications, as long as this notice is preserved.
    872 
    873 # serial 5
     832# Copyright (C) 2001-2014 Free Software Foundation, Inc.
     833#
     834# This file is free software; the Free Software Foundation
     835# gives unlimited permission to copy and/or distribute it,
     836# with or without modifications, as long as this notice is preserved.
    874837
    875838# _AM_MANGLE_OPTION(NAME)
     
    882845# Set option NAME.  Presently that only means defining a flag for this option.
    883846AC_DEFUN([_AM_SET_OPTION],
    884 [m4_define(_AM_MANGLE_OPTION([$1]), 1)])
     847[m4_define(_AM_MANGLE_OPTION([$1]), [1])])
    885848
    886849# _AM_SET_OPTIONS(OPTIONS)
     
    896859[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
    897860
     861# Copyright (C) 1999-2014 Free Software Foundation, Inc.
     862#
     863# This file is free software; the Free Software Foundation
     864# gives unlimited permission to copy and/or distribute it,
     865# with or without modifications, as long as this notice is preserved.
     866
     867# _AM_PROG_CC_C_O
     868# ---------------
     869# Like AC_PROG_CC_C_O, but changed for automake.  We rewrite AC_PROG_CC
     870# to automatically call this.
     871AC_DEFUN([_AM_PROG_CC_C_O],
     872[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
     873AC_REQUIRE_AUX_FILE([compile])dnl
     874AC_LANG_PUSH([C])dnl
     875AC_CACHE_CHECK(
     876  [whether $CC understands -c and -o together],
     877  [am_cv_prog_cc_c_o],
     878  [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
     879  # Make sure it works both with $CC and with simple cc.
     880  # Following AC_PROG_CC_C_O, we do the test twice because some
     881  # compilers refuse to overwrite an existing .o file with -o,
     882  # though they will create one.
     883  am_cv_prog_cc_c_o=yes
     884  for am_i in 1 2; do
     885    if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
     886         && test -f conftest2.$ac_objext; then
     887      : OK
     888    else
     889      am_cv_prog_cc_c_o=no
     890      break
     891    fi
     892  done
     893  rm -f core conftest*
     894  unset am_i])
     895if test "$am_cv_prog_cc_c_o" != yes; then
     896   # Losing compiler, so override with the script.
     897   # FIXME: It is wrong to rewrite CC.
     898   # But if we don't then we get into trouble of one sort or another.
     899   # A longer-term fix would be to have automake use am__CC in this case,
     900   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
     901   CC="$am_aux_dir/compile $CC"
     902fi
     903AC_LANG_POP([C])])
     904
     905# For backward compatibility.
     906AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
     907
     908# Copyright (C) 2001-2014 Free Software Foundation, Inc.
     909#
     910# This file is free software; the Free Software Foundation
     911# gives unlimited permission to copy and/or distribute it,
     912# with or without modifications, as long as this notice is preserved.
     913
     914# AM_RUN_LOG(COMMAND)
     915# -------------------
     916# Run COMMAND, save the exit status in ac_status, and log it.
     917# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
     918AC_DEFUN([AM_RUN_LOG],
     919[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
     920   ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
     921   ac_status=$?
     922   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
     923   (exit $ac_status); }])
     924
    898925# Check to make sure that the build environment is sane.    -*- Autoconf -*-
    899926
    900 # Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005, 2008
    901 # Free Software Foundation, Inc.
    902 #
    903 # This file is free software; the Free Software Foundation
    904 # gives unlimited permission to copy and/or distribute it,
    905 # with or without modifications, as long as this notice is preserved.
    906 
    907 # serial 5
     927# Copyright (C) 1996-2014 Free Software Foundation, Inc.
     928#
     929# This file is free software; the Free Software Foundation
     930# gives unlimited permission to copy and/or distribute it,
     931# with or without modifications, as long as this notice is preserved.
    908932
    909933# AM_SANITY_CHECK
     
    911935AC_DEFUN([AM_SANITY_CHECK],
    912936[AC_MSG_CHECKING([whether build environment is sane])
    913 # Just in case
    914 sleep 1
    915 echo timestamp > conftest.file
    916937# Reject unsafe characters in $srcdir or the absolute working directory
    917938# name.  Accept space and tab only in the latter.
     
    924945case $srcdir in
    925946  *[[\\\"\#\$\&\'\`$am_lf\ \    ]]*)
    926     AC_MSG_ERROR([unsafe srcdir value: `$srcdir']);;
     947    AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
    927948esac
    928949
    929 # Do `set' in a subshell so we don't clobber the current shell's
     950# Do 'set' in a subshell so we don't clobber the current shell's
    930951# arguments.  Must try -L first in case configure is actually a
    931952# symlink; some systems play weird games with the mod time of symlinks
     
    933954# directory).
    934955if (
    935    set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
    936    if test "$[*]" = "X"; then
    937       # -L didn't work.
    938       set X `ls -t "$srcdir/configure" conftest.file`
    939    fi
    940    rm -f conftest.file
    941    if test "$[*]" != "X $srcdir/configure conftest.file" \
    942       && test "$[*]" != "X conftest.file $srcdir/configure"; then
    943 
    944       # If neither matched, then we have a broken ls.  This can happen
    945       # if, for instance, CONFIG_SHELL is bash and it inherits a
    946       # broken ls alias from the environment.  This has actually
    947       # happened.  Such a system could not be considered "sane".
    948       AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
    949 alias in your environment])
    950    fi
    951 
     956   am_has_slept=no
     957   for am_try in 1 2; do
     958     echo "timestamp, slept: $am_has_slept" > conftest.file
     959     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
     960     if test "$[*]" = "X"; then
     961        # -L didn't work.
     962        set X `ls -t "$srcdir/configure" conftest.file`
     963     fi
     964     if test "$[*]" != "X $srcdir/configure conftest.file" \
     965        && test "$[*]" != "X conftest.file $srcdir/configure"; then
     966
     967        # If neither matched, then we have a broken ls.  This can happen
     968        # if, for instance, CONFIG_SHELL is bash and it inherits a
     969        # broken ls alias from the environment.  This has actually
     970        # happened.  Such a system could not be considered "sane".
     971        AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
     972  alias in your environment])
     973     fi
     974     if test "$[2]" = conftest.file || test $am_try -eq 2; then
     975       break
     976     fi
     977     # Just in case.
     978     sleep 1
     979     am_has_slept=yes
     980   done
    952981   test "$[2]" = conftest.file
    953982   )
     
    959988Check your system clock])
    960989fi
    961 AC_MSG_RESULT(yes)])
    962 
    963 # Copyright (C) 2009, 2011  Free Software Foundation, Inc.
    964 #
    965 # This file is free software; the Free Software Foundation
    966 # gives unlimited permission to copy and/or distribute it,
    967 # with or without modifications, as long as this notice is preserved.
    968 
    969 # serial 2
     990AC_MSG_RESULT([yes])
     991# If we didn't sleep, we still need to ensure time stamps of config.status and
     992# generated files are strictly newer.
     993am_sleep_pid=
     994if grep 'slept: no' conftest.file >/dev/null 2>&1; then
     995  ( sleep 1 ) &
     996  am_sleep_pid=$!
     997fi
     998AC_CONFIG_COMMANDS_PRE(
     999  [AC_MSG_CHECKING([that generated files are newer than configure])
     1000   if test -n "$am_sleep_pid"; then
     1001     # Hide warnings about reused PIDs.
     1002     wait $am_sleep_pid 2>/dev/null
     1003   fi
     1004   AC_MSG_RESULT([done])])
     1005rm -f conftest.file
     1006])
     1007
     1008# Copyright (C) 2009-2014 Free Software Foundation, Inc.
     1009#
     1010# This file is free software; the Free Software Foundation
     1011# gives unlimited permission to copy and/or distribute it,
     1012# with or without modifications, as long as this notice is preserved.
    9701013
    9711014# AM_SILENT_RULES([DEFAULT])
    9721015# --------------------------
    9731016# Enable less verbose build rules; with the default set to DEFAULT
    974 # (`yes' being less verbose, `no' or empty being verbose).
     1017# ("yes" being less verbose, "no" or empty being verbose).
    9751018AC_DEFUN([AM_SILENT_RULES],
    976 [AC_ARG_ENABLE([silent-rules],
    977 [  --enable-silent-rules          less verbose build output (undo: `make V=1')
    978   --disable-silent-rules         verbose build output (undo: `make V=0')])
    979 case $enable_silent_rules in
    980 yes) AM_DEFAULT_VERBOSITY=0;;
    981 no)  AM_DEFAULT_VERBOSITY=1;;
    982 *)   AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
     1019[AC_ARG_ENABLE([silent-rules], [dnl
     1020AS_HELP_STRING(
     1021  [--enable-silent-rules],
     1022  [less verbose build output (undo: "make V=1")])
     1023AS_HELP_STRING(
     1024  [--disable-silent-rules],
     1025  [verbose build output (undo: "make V=0")])dnl
     1026])
     1027case $enable_silent_rules in @%:@ (((
     1028  yes) AM_DEFAULT_VERBOSITY=0;;
     1029   no) AM_DEFAULT_VERBOSITY=1;;
     1030    *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
    9831031esac
    9841032dnl
    985 dnl A few `make' implementations (e.g., NonStop OS and NextStep)
     1033dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
    9861034dnl do not support nested variable expansions.
    9871035dnl See automake bug#9928 and bug#10237.
     
    10011049fi])
    10021050if test $am_cv_make_support_nested_variables = yes; then
    1003   dnl Using `$V' instead of `$(V)' breaks IRIX make.
     1051  dnl Using '$V' instead of '$(V)' breaks IRIX make.
    10041052  AM_V='$(V)'
    10051053  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
     
    10181066])
    10191067
    1020 # Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
    1021 #
    1022 # This file is free software; the Free Software Foundation
    1023 # gives unlimited permission to copy and/or distribute it,
    1024 # with or without modifications, as long as this notice is preserved.
    1025 
    1026 # serial 1
     1068# Copyright (C) 2001-2014 Free Software Foundation, Inc.
     1069#
     1070# This file is free software; the Free Software Foundation
     1071# gives unlimited permission to copy and/or distribute it,
     1072# with or without modifications, as long as this notice is preserved.
    10271073
    10281074# AM_PROG_INSTALL_STRIP
    10291075# ---------------------
    1030 # One issue with vendor `install' (even GNU) is that you can't
     1076# One issue with vendor 'install' (even GNU) is that you can't
    10311077# specify the program used to strip binaries.  This is especially
    10321078# annoying in cross-compiling environments, where the build's strip
    10331079# is unlikely to handle the host's binaries.
    10341080# Fortunately install-sh will honor a STRIPPROG variable, so we
    1035 # always use install-sh in `make install-strip', and initialize
     1081# always use install-sh in "make install-strip", and initialize
    10361082# STRIPPROG with the value of the STRIP variable (set by the user).
    10371083AC_DEFUN([AM_PROG_INSTALL_STRIP],
    10381084[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
    1039 # Installed binaries are usually stripped using `strip' when the user
    1040 # run `make install-strip'.  However `strip' might not be the right
     1085# Installed binaries are usually stripped using 'strip' when the user
     1086# run "make install-strip".  However 'strip' might not be the right
    10411087# tool to use in cross-compilation environments, therefore Automake
    1042 # will honor the `STRIP' environment variable to overrule this program.
    1043 dnl Don't test for $cross_compiling = yes, because it might be `maybe'.
     1088# will honor the 'STRIP' environment variable to overrule this program.
     1089dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
    10441090if test "$cross_compiling" != no; then
    10451091  AC_CHECK_TOOL([STRIP], [strip], :)
     
    10481094AC_SUBST([INSTALL_STRIP_PROGRAM])])
    10491095
    1050 # Copyright (C) 2006, 2008, 2010 Free Software Foundation, Inc.
    1051 #
    1052 # This file is free software; the Free Software Foundation
    1053 # gives unlimited permission to copy and/or distribute it,
    1054 # with or without modifications, as long as this notice is preserved.
    1055 
    1056 # serial 3
     1096# Copyright (C) 2006-2014 Free Software Foundation, Inc.
     1097#
     1098# This file is free software; the Free Software Foundation
     1099# gives unlimited permission to copy and/or distribute it,
     1100# with or without modifications, as long as this notice is preserved.
    10571101
    10581102# _AM_SUBST_NOTMAKE(VARIABLE)
     
    10691113# Check how to create a tarball.                            -*- Autoconf -*-
    10701114
    1071 # Copyright (C) 2004, 2005, 2012 Free Software Foundation, Inc.
    1072 #
    1073 # This file is free software; the Free Software Foundation
    1074 # gives unlimited permission to copy and/or distribute it,
    1075 # with or without modifications, as long as this notice is preserved.
    1076 
    1077 # serial 2
     1115# Copyright (C) 2004-2014 Free Software Foundation, Inc.
     1116#
     1117# This file is free software; the Free Software Foundation
     1118# gives unlimited permission to copy and/or distribute it,
     1119# with or without modifications, as long as this notice is preserved.
    10781120
    10791121# _AM_PROG_TAR(FORMAT)
    10801122# --------------------
    10811123# Check how to create a tarball in format FORMAT.
    1082 # FORMAT should be one of `v7', `ustar', or `pax'.
     1124# FORMAT should be one of 'v7', 'ustar', or 'pax'.
    10831125#
    10841126# Substitute a variable $(am__tar) that is a command
     
    10901132# a tarball read from stdin.
    10911133#     $(am__untar) < result.tar
     1134#
    10921135AC_DEFUN([_AM_PROG_TAR],
    10931136[# Always define AMTAR for backward compatibility.  Yes, it's still used
    10941137# in the wild :-(  We should find a proper way to deprecate it ...
    10951138AC_SUBST([AMTAR], ['$${TAR-tar}'])
     1139
     1140# We'll loop over all known methods to create a tar archive until one works.
     1141_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
     1142
    10961143m4_if([$1], [v7],
    1097      [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
    1098      [m4_case([$1], [ustar],, [pax],,
    1099               [m4_fatal([Unknown tar format])])
    1100 AC_MSG_CHECKING([how to create a $1 tar archive])
    1101 # Loop over all known methods to create a tar archive until one works.
    1102 _am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
    1103 _am_tools=${am_cv_prog_tar_$1-$_am_tools}
    1104 # Do not fold the above two line into one, because Tru64 sh and
    1105 # Solaris sh will not grok spaces in the rhs of `-'.
    1106 for _am_tool in $_am_tools
    1107 do
    1108   case $_am_tool in
    1109   gnutar)
    1110     for _am_tar in tar gnutar gtar;
    1111     do
    1112       AM_RUN_LOG([$_am_tar --version]) && break
    1113     done
    1114     am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
    1115     am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
    1116     am__untar="$_am_tar -xf -"
    1117     ;;
    1118   plaintar)
    1119     # Must skip GNU tar: if it does not support --format= it doesn't create
    1120     # ustar tarball either.
    1121     (tar --version) >/dev/null 2>&1 && continue
    1122     am__tar='tar chf - "$$tardir"'
    1123     am__tar_='tar chf - "$tardir"'
    1124     am__untar='tar xf -'
    1125     ;;
    1126   pax)
    1127     am__tar='pax -L -x $1 -w "$$tardir"'
    1128     am__tar_='pax -L -x $1 -w "$tardir"'
    1129     am__untar='pax -r'
    1130     ;;
    1131   cpio)
    1132     am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
    1133     am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
    1134     am__untar='cpio -i -H $1 -d'
    1135     ;;
    1136   none)
    1137     am__tar=false
    1138     am__tar_=false
    1139     am__untar=false
    1140     ;;
    1141   esac
    1142 
    1143   # If the value was cached, stop now.  We just wanted to have am__tar
    1144   # and am__untar set.
    1145   test -n "${am_cv_prog_tar_$1}" && break
    1146 
    1147   # tar/untar a dummy directory, and stop if the command works
     1144  [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
     1145
     1146  [m4_case([$1],
     1147    [ustar],
     1148     [# The POSIX 1988 'ustar' format is defined with fixed-size fields.
     1149      # There is notably a 21 bits limit for the UID and the GID.  In fact,
     1150      # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
     1151      # and bug#13588).
     1152      am_max_uid=2097151 # 2^21 - 1
     1153      am_max_gid=$am_max_uid
     1154      # The $UID and $GID variables are not portable, so we need to resort
     1155      # to the POSIX-mandated id(1) utility.  Errors in the 'id' calls
     1156      # below are definitely unexpected, so allow the users to see them
     1157      # (that is, avoid stderr redirection).
     1158      am_uid=`id -u || echo unknown`
     1159      am_gid=`id -g || echo unknown`
     1160      AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format])
     1161      if test $am_uid -le $am_max_uid; then
     1162         AC_MSG_RESULT([yes])
     1163      else
     1164         AC_MSG_RESULT([no])
     1165         _am_tools=none
     1166      fi
     1167      AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format])
     1168      if test $am_gid -le $am_max_gid; then
     1169         AC_MSG_RESULT([yes])
     1170      else
     1171        AC_MSG_RESULT([no])
     1172        _am_tools=none
     1173      fi],
     1174
     1175  [pax],
     1176    [],
     1177
     1178  [m4_fatal([Unknown tar format])])
     1179
     1180  AC_MSG_CHECKING([how to create a $1 tar archive])
     1181
     1182  # Go ahead even if we have the value already cached.  We do so because we
     1183  # need to set the values for the 'am__tar' and 'am__untar' variables.
     1184  _am_tools=${am_cv_prog_tar_$1-$_am_tools}
     1185
     1186  for _am_tool in $_am_tools; do
     1187    case $_am_tool in
     1188    gnutar)
     1189      for _am_tar in tar gnutar gtar; do
     1190        AM_RUN_LOG([$_am_tar --version]) && break
     1191      done
     1192      am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
     1193      am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
     1194      am__untar="$_am_tar -xf -"
     1195      ;;
     1196    plaintar)
     1197      # Must skip GNU tar: if it does not support --format= it doesn't create
     1198      # ustar tarball either.
     1199      (tar --version) >/dev/null 2>&1 && continue
     1200      am__tar='tar chf - "$$tardir"'
     1201      am__tar_='tar chf - "$tardir"'
     1202      am__untar='tar xf -'
     1203      ;;
     1204    pax)
     1205      am__tar='pax -L -x $1 -w "$$tardir"'
     1206      am__tar_='pax -L -x $1 -w "$tardir"'
     1207      am__untar='pax -r'
     1208      ;;
     1209    cpio)
     1210      am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
     1211      am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
     1212      am__untar='cpio -i -H $1 -d'
     1213      ;;
     1214    none)
     1215      am__tar=false
     1216      am__tar_=false
     1217      am__untar=false
     1218      ;;
     1219    esac
     1220
     1221    # If the value was cached, stop now.  We just wanted to have am__tar
     1222    # and am__untar set.
     1223    test -n "${am_cv_prog_tar_$1}" && break
     1224
     1225    # tar/untar a dummy directory, and stop if the command works.
     1226    rm -rf conftest.dir
     1227    mkdir conftest.dir
     1228    echo GrepMe > conftest.dir/file
     1229    AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
     1230    rm -rf conftest.dir
     1231    if test -s conftest.tar; then
     1232      AM_RUN_LOG([$am__untar <conftest.tar])
     1233      AM_RUN_LOG([cat conftest.dir/file])
     1234      grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
     1235    fi
     1236  done
    11481237  rm -rf conftest.dir
    1149   mkdir conftest.dir
    1150   echo GrepMe > conftest.dir/file
    1151   AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
    1152   rm -rf conftest.dir
    1153   if test -s conftest.tar; then
    1154     AM_RUN_LOG([$am__untar <conftest.tar])
    1155     grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
    1156   fi
    1157 done
    1158 rm -rf conftest.dir
    1159 
    1160 AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
    1161 AC_MSG_RESULT([$am_cv_prog_tar_$1])])
     1238
     1239  AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
     1240  AC_MSG_RESULT([$am_cv_prog_tar_$1])])
     1241
    11621242AC_SUBST([am__tar])
    11631243AC_SUBST([am__untar])
  • automake/config.guess

    rf7cb0bc ra5de33e  
    1 /usr/share/automake-1.11/config.guess
     1/usr/share/automake-1.15/config.guess
  • automake/config.sub

    rf7cb0bc ra5de33e  
    1 /usr/share/automake-1.11/config.sub
     1/usr/share/automake-1.15/config.sub
  • automake/missing

    rf7cb0bc ra5de33e  
    11#! /bin/sh
    2 # Common stub for a few missing GNU programs while installing.
    3 
    4 scriptversion=2012-01-06.13; # UTC
    5 
    6 # Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005, 2006,
    7 # 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
    8 # Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
     2# Common wrapper for a few potentially missing GNU programs.
     3
     4scriptversion=2013-10-28.13; # UTC
     5
     6# Copyright (C) 1996-2014 Free Software Foundation, Inc.
     7# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
    98
    109# This program is free software; you can redistribute it and/or modify
     
    2726
    2827if test $# -eq 0; then
    29   echo 1>&2 "Try \`$0 --help' for more information"
     28  echo 1>&2 "Try '$0 --help' for more information"
    3029  exit 1
    3130fi
    3231
    33 run=:
    34 sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p'
    35 sed_minuso='s/.* -o \([^ ]*\).*/\1/p'
    36 
    37 # In the cases where this matters, `missing' is being run in the
    38 # srcdir already.
    39 if test -f configure.ac; then
    40   configure_ac=configure.ac
    41 else
    42   configure_ac=configure.in
    43 fi
    44 
    45 msg="missing on your system"
    46 
    4732case $1 in
    48 --run)
    49   # Try to run requested program, and just exit if it succeeds.
    50   run=
    51   shift
    52   "$@" && exit 0
    53   # Exit code 63 means version mismatch.  This often happens
    54   # when the user try to use an ancient version of a tool on
    55   # a file that requires a minimum version.  In this case we
    56   # we should proceed has if the program had been absent, or
    57   # if --run hadn't been passed.
    58   if test $? = 63; then
    59     run=:
    60     msg="probably too old"
    61   fi
    62   ;;
     33
     34  --is-lightweight)
     35    # Used by our autoconf macros to check whether the available missing
     36    # script is modern enough.
     37    exit 0
     38    ;;
     39
     40  --run)
     41    # Back-compat with the calling convention used by older automake.
     42    shift
     43    ;;
    6344
    6445  -h|--h|--he|--hel|--help)
     
    6647$0 [OPTION]... PROGRAM [ARGUMENT]...
    6748
    68 Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
    69 error status if there is no known handling for PROGRAM.
     49Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
     50to PROGRAM being missing or too old.
    7051
    7152Options:
    7253  -h, --help      display this help and exit
    7354  -v, --version   output version information and exit
    74   --run           try to run the given command, and emulate it if it fails
    7555
    7656Supported PROGRAM values:
    77   aclocal      touch file \`aclocal.m4'
    78   autoconf     touch file \`configure'
    79   autoheader   touch file \`config.h.in'
    80   autom4te     touch the output file, or create a stub one
    81   automake     touch all \`Makefile.in' files
    82   bison        create \`y.tab.[ch]', if possible, from existing .[ch]
    83   flex         create \`lex.yy.c', if possible, from existing .c
    84   help2man     touch the output file
    85   lex          create \`lex.yy.c', if possible, from existing .c
    86   makeinfo     touch the output file
    87   yacc         create \`y.tab.[ch]', if possible, from existing .[ch]
    88 
    89 Version suffixes to PROGRAM as well as the prefixes \`gnu-', \`gnu', and
    90 \`g' are ignored when checking the name.
     57  aclocal   autoconf  autoheader   autom4te  automake  makeinfo
     58  bison     yacc      flex         lex       help2man
     59
     60Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
     61'g' are ignored when checking the name.
    9162
    9263Send bug reports to <bug-automake@gnu.org>."
     
    10071
    10172  -*)
    102     echo 1>&2 "$0: Unknown \`$1' option"
    103     echo 1>&2 "Try \`$0 --help' for more information"
     73    echo 1>&2 "$0: unknown '$1' option"
     74    echo 1>&2 "Try '$0 --help' for more information"
    10475    exit 1
    10576    ;;
     
    10778esac
    10879
    109 # normalize program name to check for.
    110 program=`echo "$1" | sed '
    111   s/^gnu-//; t
    112   s/^gnu//; t
    113   s/^g//; t'`
    114 
    115 # Now exit if we have it, but it failed.  Also exit now if we
    116 # don't have it and --version was passed (most likely to detect
    117 # the program).  This is about non-GNU programs, so use $1 not
    118 # $program.
    119 case $1 in
    120   lex*|yacc*)
    121     # Not GNU programs, they don't have --version.
    122     ;;
    123 
    124   *)
    125     if test -z "$run" && ($1 --version) > /dev/null 2>&1; then
    126        # We have it, but it failed.
    127        exit 1
    128     elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
    129        # Could not run --version or --help.  This is probably someone
    130        # running `$TOOL --version' or `$TOOL --help' to check whether
    131        # $TOOL exists and not knowing $TOOL uses missing.
    132        exit 1
    133     fi
    134     ;;
    135 esac
    136 
    137 # If it does not exist, or fails to run (possibly an outdated version),
    138 # try to emulate it.
    139 case $program in
    140   aclocal*)
    141     echo 1>&2 "\
    142 WARNING: \`$1' is $msg.  You should only need it if
    143          you modified \`acinclude.m4' or \`${configure_ac}'.  You might want
    144          to install the \`Automake' and \`Perl' packages.  Grab them from
    145          any GNU archive site."
    146     touch aclocal.m4
    147     ;;
    148 
    149   autoconf*)
    150     echo 1>&2 "\
    151 WARNING: \`$1' is $msg.  You should only need it if
    152          you modified \`${configure_ac}'.  You might want to install the
    153          \`Autoconf' and \`GNU m4' packages.  Grab them from any GNU
    154          archive site."
    155     touch configure
    156     ;;
    157 
    158   autoheader*)
    159     echo 1>&2 "\
    160 WARNING: \`$1' is $msg.  You should only need it if
    161          you modified \`acconfig.h' or \`${configure_ac}'.  You might want
    162          to install the \`Autoconf' and \`GNU m4' packages.  Grab them
    163          from any GNU archive site."
    164     files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`
    165     test -z "$files" && files="config.h"
    166     touch_files=
    167     for f in $files; do
    168       case $f in
    169       *:*) touch_files="$touch_files "`echo "$f" |
    170                                        sed -e 's/^[^:]*://' -e 's/:.*//'`;;
    171       *) touch_files="$touch_files $f.in";;
    172       esac
    173     done
    174     touch $touch_files
    175     ;;
    176 
    177   automake*)
    178     echo 1>&2 "\
    179 WARNING: \`$1' is $msg.  You should only need it if
    180          you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.
    181          You might want to install the \`Automake' and \`Perl' packages.
    182          Grab them from any GNU archive site."
    183     find . -type f -name Makefile.am -print |
    184            sed 's/\.am$/.in/' |
    185            while read f; do touch "$f"; done
    186     ;;
    187 
    188   autom4te*)
    189     echo 1>&2 "\
    190 WARNING: \`$1' is needed, but is $msg.
    191          You might have modified some files without having the
    192          proper tools for further handling them.
    193          You can get \`$1' as part of \`Autoconf' from any GNU
    194          archive site."
    195 
    196     file=`echo "$*" | sed -n "$sed_output"`
    197     test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
    198     if test -f "$file"; then
    199         touch $file
    200     else
    201         test -z "$file" || exec >$file
    202         echo "#! /bin/sh"
    203         echo "# Created by GNU Automake missing as a replacement of"
    204         echo "#  $ $@"
    205         echo "exit 0"
    206         chmod +x $file
    207         exit 1
    208     fi
    209     ;;
    210 
    211   bison*|yacc*)
    212     echo 1>&2 "\
    213 WARNING: \`$1' $msg.  You should only need it if
    214          you modified a \`.y' file.  You may need the \`Bison' package
    215          in order for those modifications to take effect.  You can get
    216          \`Bison' from any GNU archive site."
    217     rm -f y.tab.c y.tab.h
    218     if test $# -ne 1; then
    219         eval LASTARG=\${$#}
    220         case $LASTARG in
    221         *.y)
    222             SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
    223             if test -f "$SRCFILE"; then
    224                  cp "$SRCFILE" y.tab.c
    225             fi
    226             SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
    227             if test -f "$SRCFILE"; then
    228                  cp "$SRCFILE" y.tab.h
    229             fi
    230           ;;
    231         esac
    232     fi
    233     if test ! -f y.tab.h; then
    234         echo >y.tab.h
    235     fi
    236     if test ! -f y.tab.c; then
    237         echo 'main() { return 0; }' >y.tab.c
    238     fi
    239     ;;
    240 
    241   lex*|flex*)
    242     echo 1>&2 "\
    243 WARNING: \`$1' is $msg.  You should only need it if
    244          you modified a \`.l' file.  You may need the \`Flex' package
    245          in order for those modifications to take effect.  You can get
    246          \`Flex' from any GNU archive site."
    247     rm -f lex.yy.c
    248     if test $# -ne 1; then
    249         eval LASTARG=\${$#}
    250         case $LASTARG in
    251         *.l)
    252             SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
    253             if test -f "$SRCFILE"; then
    254                  cp "$SRCFILE" lex.yy.c
    255             fi
    256           ;;
    257         esac
    258     fi
    259     if test ! -f lex.yy.c; then
    260         echo 'main() { return 0; }' >lex.yy.c
    261     fi
    262     ;;
    263 
    264   help2man*)
    265     echo 1>&2 "\
    266 WARNING: \`$1' is $msg.  You should only need it if
    267          you modified a dependency of a manual page.  You may need the
    268          \`Help2man' package in order for those modifications to take
    269          effect.  You can get \`Help2man' from any GNU archive site."
    270 
    271     file=`echo "$*" | sed -n "$sed_output"`
    272     test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
    273     if test -f "$file"; then
    274         touch $file
    275     else
    276         test -z "$file" || exec >$file
    277         echo ".ab help2man is required to generate this page"
    278         exit $?
    279     fi
    280     ;;
    281 
    282   makeinfo*)
    283     echo 1>&2 "\
    284 WARNING: \`$1' is $msg.  You should only need it if
    285          you modified a \`.texi' or \`.texinfo' file, or any other file
    286          indirectly affecting the aspect of the manual.  The spurious
    287          call might also be the consequence of using a buggy \`make' (AIX,
    288          DU, IRIX).  You might want to install the \`Texinfo' package or
    289          the \`GNU make' package.  Grab either from any GNU archive site."
    290     # The file to touch is that specified with -o ...
    291     file=`echo "$*" | sed -n "$sed_output"`
    292     test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
    293     if test -z "$file"; then
    294       # ... or it is the one specified with @setfilename ...
    295       infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
    296       file=`sed -n '
    297         /^@setfilename/{
    298           s/.* \([^ ]*\) *$/\1/
    299           p
    300           q
    301         }' $infile`
    302       # ... or it is derived from the source name (dir/f.texi becomes f.info)
    303       test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info
    304     fi
    305     # If the file does not exist, the user really needs makeinfo;
    306     # let's fail without touching anything.
    307     test -f $file || exit 1
    308     touch $file
    309     ;;
    310 
    311   *)
    312     echo 1>&2 "\
    313 WARNING: \`$1' is needed, and is $msg.
    314          You might have modified some files without having the
    315          proper tools for further handling them.  Check the \`README' file,
    316          it often tells you about the needed prerequisites for installing
    317          this package.  You may also peek at any GNU archive site, in case
    318          some other package would contain this missing \`$1' program."
    319     exit 1
    320     ;;
    321 esac
    322 
    323 exit 0
     80# Run the given program, remember its exit status.
     81"$@"; st=$?
     82
     83# If it succeeded, we are done.
     84test $st -eq 0 && exit 0
     85
     86# Also exit now if we it failed (or wasn't found), and '--version' was
     87# passed; such an option is passed most likely to detect whether the
     88# program is present and works.
     89case $2 in --version|--help) exit $st;; esac
     90
     91# Exit code 63 means version mismatch.  This often happens when the user
     92# tries to use an ancient version of a tool on a file that requires a
     93# minimum version.
     94if test $st -eq 63; then
     95  msg="probably too old"
     96elif test $st -eq 127; then
     97  # Program was missing.
     98  msg="missing on your system"
     99else
     100  # Program was found and executed, but failed.  Give up.
     101  exit $st
     102fi
     103
     104perl_URL=http://www.perl.org/
     105flex_URL=http://flex.sourceforge.net/
     106gnu_software_URL=http://www.gnu.org/software
     107
     108program_details ()
     109{
     110  case $1 in
     111    aclocal|automake)
     112      echo "The '$1' program is part of the GNU Automake package:"
     113      echo "<$gnu_software_URL/automake>"
     114      echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
     115      echo "<$gnu_software_URL/autoconf>"
     116      echo "<$gnu_software_URL/m4/>"
     117      echo "<$perl_URL>"
     118      ;;
     119    autoconf|autom4te|autoheader)
     120      echo "The '$1' program is part of the GNU Autoconf package:"
     121      echo "<$gnu_software_URL/autoconf/>"
     122      echo "It also requires GNU m4 and Perl in order to run:"
     123      echo "<$gnu_software_URL/m4/>"
     124      echo "<$perl_URL>"
     125      ;;
     126  esac
     127}
     128
     129give_advice ()
     130{
     131  # Normalize program name to check for.
     132  normalized_program=`echo "$1" | sed '
     133    s/^gnu-//; t
     134    s/^gnu//; t
     135    s/^g//; t'`
     136
     137  printf '%s\n' "'$1' is $msg."
     138
     139  configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
     140  case $normalized_program in
     141    autoconf*)
     142      echo "You should only need it if you modified 'configure.ac',"
     143      echo "or m4 files included by it."
     144      program_details 'autoconf'
     145      ;;
     146    autoheader*)
     147      echo "You should only need it if you modified 'acconfig.h' or"
     148      echo "$configure_deps."
     149      program_details 'autoheader'
     150      ;;
     151    automake*)
     152      echo "You should only need it if you modified 'Makefile.am' or"
     153      echo "$configure_deps."
     154      program_details 'automake'
     155      ;;
     156    aclocal*)
     157      echo "You should only need it if you modified 'acinclude.m4' or"
     158      echo "$configure_deps."
     159      program_details 'aclocal'
     160      ;;
     161   autom4te*)
     162      echo "You might have modified some maintainer files that require"
     163      echo "the 'autom4te' program to be rebuilt."
     164      program_details 'autom4te'
     165      ;;
     166    bison*|yacc*)
     167      echo "You should only need it if you modified a '.y' file."
     168      echo "You may want to install the GNU Bison package:"
     169      echo "<$gnu_software_URL/bison/>"
     170      ;;
     171    lex*|flex*)
     172      echo "You should only need it if you modified a '.l' file."
     173      echo "You may want to install the Fast Lexical Analyzer package:"
     174      echo "<$flex_URL>"
     175      ;;
     176    help2man*)
     177      echo "You should only need it if you modified a dependency" \
     178           "of a man page."
     179      echo "You may want to install the GNU Help2man package:"
     180      echo "<$gnu_software_URL/help2man/>"
     181    ;;
     182    makeinfo*)
     183      echo "You should only need it if you modified a '.texi' file, or"
     184      echo "any other file indirectly affecting the aspect of the manual."
     185      echo "You might want to install the Texinfo package:"
     186      echo "<$gnu_software_URL/texinfo/>"
     187      echo "The spurious makeinfo call might also be the consequence of"
     188      echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
     189      echo "want to install GNU make:"
     190      echo "<$gnu_software_URL/make/>"
     191      ;;
     192    *)
     193      echo "You might have modified some files without having the proper"
     194      echo "tools for further handling them.  Check the 'README' file, it"
     195      echo "often tells you about the needed prerequisites for installing"
     196      echo "this package.  You may also peek at any GNU archive site, in"
     197      echo "case some other package contains this missing '$1' program."
     198      ;;
     199  esac
     200}
     201
     202give_advice "$1" | sed -e '1s/^/WARNING: /' \
     203                       -e '2,$s/^/         /' >&2
     204
     205# Propagate the correct exit status (expected to be 127 for a program
     206# not found, 63 for a program that failed due to version mismatch).
     207exit $st
    324208
    325209# Local variables:
  • config.h.in

    rf7cb0bc ra5de33e  
    120120/* Define to 1 if the system has the type `_Bool'. */
    121121#undef HAVE__BOOL
    122 
    123 /* Define to 1 if your C compiler doesn't accept -c and -o together. */
    124 #undef NO_MINUS_C_MINUS_O
    125122
    126123/* Name of package */
  • configure

    rf7cb0bc ra5de33e  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.68 for cfa-cc 1.0.0.0.
     3# Generated by GNU Autoconf 2.69 for cfa-cc 1.0.0.0.
    44#
    55# Report bugs to <cforall@plg.uwaterloo.ca>.
    66#
    77#
    8 # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
    9 # 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
    10 # Foundation, Inc.
     8# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
    119#
    1210#
     
    137135(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
    138136
     137# Use a proper internal environment variable to ensure we don't fall
     138  # into an infinite loop, continuously re-executing ourselves.
     139  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
     140    _as_can_reexec=no; export _as_can_reexec;
     141    # We cannot yet assume a decent shell, so we have to provide a
     142# neutralization value for shells without unset; and this also
     143# works around shells that cannot unset nonexistent variables.
     144# Preserve -v and -x to the replacement shell.
     145BASH_ENV=/dev/null
     146ENV=/dev/null
     147(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
     148case $- in # ((((
     149  *v*x* | *x*v* ) as_opts=-vx ;;
     150  *v* ) as_opts=-v ;;
     151  *x* ) as_opts=-x ;;
     152  * ) as_opts= ;;
     153esac
     154exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
     155# Admittedly, this is quite paranoid, since all the known shells bail
     156# out after a failed `exec'.
     157$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
     158as_fn_exit 255
     159  fi
     160  # We don't want this to propagate to other subprocesses.
     161          { _as_can_reexec=; unset _as_can_reexec;}
    139162if test "x$CONFIG_SHELL" = x; then
    140163  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
     
    170193  exitcode=1; echo positional parameters were not saved.
    171194fi
    172 test x\$exitcode = x0 || exit 1"
     195test x\$exitcode = x0 || exit 1
     196test -x / || exit 1"
    173197  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
    174198  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
     
    215239
    216240      if test "x$CONFIG_SHELL" != x; then :
    217   # We cannot yet assume a decent shell, so we have to provide a
    218         # neutralization value for shells without unset; and this also
    219         # works around shells that cannot unset nonexistent variables.
    220         # Preserve -v and -x to the replacement shell.
    221         BASH_ENV=/dev/null
    222         ENV=/dev/null
    223         (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
    224         export CONFIG_SHELL
    225         case $- in # ((((
    226           *v*x* | *x*v* ) as_opts=-vx ;;
    227           *v* ) as_opts=-v ;;
    228           *x* ) as_opts=-x ;;
    229           * ) as_opts= ;;
    230         esac
    231         exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"}
     241  export CONFIG_SHELL
     242             # We cannot yet assume a decent shell, so we have to provide a
     243# neutralization value for shells without unset; and this also
     244# works around shells that cannot unset nonexistent variables.
     245# Preserve -v and -x to the replacement shell.
     246BASH_ENV=/dev/null
     247ENV=/dev/null
     248(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
     249case $- in # ((((
     250  *v*x* | *x*v* ) as_opts=-vx ;;
     251  *v* ) as_opts=-v ;;
     252  *x* ) as_opts=-x ;;
     253  * ) as_opts= ;;
     254esac
     255exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
     256# Admittedly, this is quite paranoid, since all the known shells bail
     257# out after a failed `exec'.
     258$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
     259exit 255
    232260fi
    233261
     
    332360
    333361} # as_fn_mkdir_p
     362
     363# as_fn_executable_p FILE
     364# -----------------------
     365# Test if FILE is an executable regular file.
     366as_fn_executable_p ()
     367{
     368  test -f "$1" && test -x "$1"
     369} # as_fn_executable_p
    334370# as_fn_append VAR VALUE
    335371# ----------------------
     
    453489    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
    454490
     491  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
     492  # already done that, so ensure we don't try to do so again and fall
     493  # in an infinite loop.  This has already happened in practice.
     494  _as_can_reexec=no; export _as_can_reexec
    455495  # Don't try to exec as it changes $[0], causing all sort of problems
    456496  # (the dirname of $[0] is not the place where we might find the
     
    487527    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    488528    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    489     # In both cases, we have to default to `cp -p'.
     529    # In both cases, we have to default to `cp -pR'.
    490530    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
    491       as_ln_s='cp -p'
     531      as_ln_s='cp -pR'
    492532  elif ln conf$$.file conf$$ 2>/dev/null; then
    493533    as_ln_s=ln
    494534  else
    495     as_ln_s='cp -p'
     535    as_ln_s='cp -pR'
    496536  fi
    497537else
    498   as_ln_s='cp -p'
     538  as_ln_s='cp -pR'
    499539fi
    500540rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
     
    508548fi
    509549
    510 if test -x / >/dev/null 2>&1; then
    511   as_test_x='test -x'
    512 else
    513   if ls -dL / >/dev/null 2>&1; then
    514     as_ls_L_option=L
    515   else
    516     as_ls_L_option=
    517   fi
    518   as_test_x='
    519     eval sh -c '\''
    520       if test -d "$1"; then
    521         test -d "$1/.";
    522       else
    523         case $1 in #(
    524         -*)set "./$1";;
    525         esac;
    526         case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
    527         ???[sx]*):;;*)false;;esac;fi
    528     '\'' sh
    529   '
    530 fi
    531 as_executable_p=$as_test_x
     550as_test_x='test -x'
     551as_executable_p=as_fn_executable_p
    532552
    533553# Sed expression to map a string onto a valid CPP name.
     
    718738oldincludedir
    719739includedir
     740runstatedir
    720741localstatedir
    721742sharedstatedir
     
    803824sharedstatedir='${prefix}/com'
    804825localstatedir='${prefix}/var'
     826runstatedir='${localstatedir}/run'
    805827includedir='${prefix}/include'
    806828oldincludedir='/usr/include'
     
    10551077    silent=yes ;;
    10561078
     1079  -runstatedir | --runstatedir | --runstatedi | --runstated \
     1080  | --runstate | --runstat | --runsta | --runst | --runs \
     1081  | --run | --ru | --r)
     1082    ac_prev=runstatedir ;;
     1083  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
     1084  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
     1085  | --run=* | --ru=* | --r=*)
     1086    runstatedir=$ac_optarg ;;
     1087
    10571088  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
    10581089    ac_prev=sbindir ;;
     
    11921223                datadir sysconfdir sharedstatedir localstatedir includedir \
    11931224                oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
    1194                 libdir localedir mandir
     1225                libdir localedir mandir runstatedir
    11951226do
    11961227  eval ac_val=\$$ac_var
     
    12201251  if test "x$build_alias" = x; then
    12211252    cross_compiling=maybe
    1222     $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
    1223     If a cross compiler is detected then cross compile mode will be used" >&2
    12241253  elif test "x$build_alias" != "x$host_alias"; then
    12251254    cross_compiling=yes
     
    13471376  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
    13481377  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
     1378  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
    13491379  --libdir=DIR            object code libraries [EPREFIX/lib]
    13501380  --includedir=DIR        C header files [PREFIX/include]
     
    13851415  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
    13861416  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
    1387   --enable-silent-rules          less verbose build output (undo: `make V=1')
    1388   --disable-silent-rules         verbose build output (undo: `make V=0')
    1389   --disable-maintainer-mode  disable make rules and dependencies not useful
    1390                           (and sometimes confusing) to the casual installer
     1417  --enable-silent-rules   less verbose build output (undo: "make V=1")
     1418  --disable-silent-rules  verbose build output (undo: "make V=0")
     1419  --disable-maintainer-mode
     1420                          disable make rules and dependencies not useful (and
     1421                          sometimes confusing) to the casual installer
    13911422  --enable-target-release Build and install the release target
    13921423  --enable-target-debug   Build and install the debug target
    13931424  --enable-threading      Build and install libcfa with threading support
    13941425                          (Enabled by default)
    1395   --disable-dependency-tracking  speeds up one-time build
    1396   --enable-dependency-tracking   do not reject slow dependency extractors
     1426  --enable-dependency-tracking
     1427                          do not reject slow dependency extractors
     1428  --disable-dependency-tracking
     1429                          speeds up one-time build
    13971430
    13981431Optional Packages:
     
    14891522  cat <<\_ACEOF
    14901523cfa-cc configure 1.0.0.0
    1491 generated by GNU Autoconf 2.68
    1492 
    1493 Copyright (C) 2010 Free Software Foundation, Inc.
     1524generated by GNU Autoconf 2.69
     1525
     1526Copyright (C) 2012 Free Software Foundation, Inc.
    14941527This configure script is free software; the Free Software Foundation
    14951528gives unlimited permission to copy, distribute and modify it.
     
    16051638       } && test -s conftest$ac_exeext && {
    16061639         test "$cross_compiling" = yes ||
    1607          $as_test_x conftest$ac_exeext
     1640         test -x conftest$ac_exeext
    16081641       }; then :
    16091642  ac_retval=0
     
    19712004{
    19722005static int test_array [1 - 2 * !(0 < ($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 1))];
    1973 test_array [0] = 0
     2006test_array [0] = 0;
     2007return test_array [0];
    19742008
    19752009  ;
     
    19872021static int test_array [1 - 2 * !(($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 1)
    19882022                 < ($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 2))];
    1989 test_array [0] = 0
     2023test_array [0] = 0;
     2024return test_array [0];
    19902025
    19912026  ;
     
    20442079{
    20452080static int test_array [1 - 2 * !((($ac_type) -1 >> ($2 / 2 - 1)) >> ($2 / 2 - 1) == 3)];
    2046 test_array [0] = 0
     2081test_array [0] = 0;
     2082return test_array [0];
    20472083
    20482084  ;
     
    20772113
    20782114It was created by cfa-cc $as_me 1.0.0.0, which was
    2079 generated by GNU Autoconf 2.68.  Invocation command line was
     2115generated by GNU Autoconf 2.69.  Invocation command line was
    20802116
    20812117  $ $0 $@
     
    24612497fi
    24622498
    2463 case $enable_silent_rules in
    2464 yes) AM_DEFAULT_VERBOSITY=0;;
    2465 no) AM_DEFAULT_VERBOSITY=1;;
    2466 *)  AM_DEFAULT_VERBOSITY=1;;
     2499case $enable_silent_rules in # (((
     2500  yes) AM_DEFAULT_VERBOSITY=0;;
     2501   no) AM_DEFAULT_VERBOSITY=1;;
     2502    *) AM_DEFAULT_VERBOSITY=1;;
    24672503esac
    24682504am_make=${MAKE-make}
     
    24962532
    24972533
    2498 am__api_version='1.11'
     2534am__api_version='1.15'
    24992535
    25002536# Find a good install program.  We prefer a C program (faster),
     
    25352571    for ac_prog in ginstall scoinst install; do
    25362572      for ac_exec_ext in '' $ac_executable_extensions; do
    2537         if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
     2573        if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
    25382574          if test $ac_prog = install &&
    25392575            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
     
    25932629{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
    25942630$as_echo_n "checking whether build environment is sane... " >&6; }
    2595 # Just in case
    2596 sleep 1
    2597 echo timestamp > conftest.file
    25982631# Reject unsafe characters in $srcdir or the absolute working directory
    25992632# name.  Accept space and tab only in the latter.
     
    26062639case $srcdir in
    26072640  *[\\\"\#\$\&\'\`$am_lf\ \     ]*)
    2608     as_fn_error $? "unsafe srcdir value: \`$srcdir'" "$LINENO" 5;;
     2641    as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
    26092642esac
    26102643
    2611 # Do `set' in a subshell so we don't clobber the current shell's
     2644# Do 'set' in a subshell so we don't clobber the current shell's
    26122645# arguments.  Must try -L first in case configure is actually a
    26132646# symlink; some systems play weird games with the mod time of symlinks
     
    26152648# directory).
    26162649if (
    2617    set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
    2618    if test "$*" = "X"; then
    2619       # -L didn't work.
    2620       set X `ls -t "$srcdir/configure" conftest.file`
    2621    fi
    2622    rm -f conftest.file
    2623    if test "$*" != "X $srcdir/configure conftest.file" \
    2624       && test "$*" != "X conftest.file $srcdir/configure"; then
    2625 
    2626       # If neither matched, then we have a broken ls.  This can happen
    2627       # if, for instance, CONFIG_SHELL is bash and it inherits a
    2628       # broken ls alias from the environment.  This has actually
    2629       # happened.  Such a system could not be considered "sane".
    2630       as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken
    2631 alias in your environment" "$LINENO" 5
    2632    fi
    2633 
     2650   am_has_slept=no
     2651   for am_try in 1 2; do
     2652     echo "timestamp, slept: $am_has_slept" > conftest.file
     2653     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
     2654     if test "$*" = "X"; then
     2655        # -L didn't work.
     2656        set X `ls -t "$srcdir/configure" conftest.file`
     2657     fi
     2658     if test "$*" != "X $srcdir/configure conftest.file" \
     2659        && test "$*" != "X conftest.file $srcdir/configure"; then
     2660
     2661        # If neither matched, then we have a broken ls.  This can happen
     2662        # if, for instance, CONFIG_SHELL is bash and it inherits a
     2663        # broken ls alias from the environment.  This has actually
     2664        # happened.  Such a system could not be considered "sane".
     2665        as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken
     2666  alias in your environment" "$LINENO" 5
     2667     fi
     2668     if test "$2" = conftest.file || test $am_try -eq 2; then
     2669       break
     2670     fi
     2671     # Just in case.
     2672     sleep 1
     2673     am_has_slept=yes
     2674   done
    26342675   test "$2" = conftest.file
    26352676   )
     
    26432684{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
    26442685$as_echo "yes" >&6; }
     2686# If we didn't sleep, we still need to ensure time stamps of config.status and
     2687# generated files are strictly newer.
     2688am_sleep_pid=
     2689if grep 'slept: no' conftest.file >/dev/null 2>&1; then
     2690  ( sleep 1 ) &
     2691  am_sleep_pid=$!
     2692fi
     2693
     2694rm -f conftest.file
     2695
    26452696test "$program_prefix" != NONE &&
    26462697  program_transform_name="s&^&$program_prefix&;$program_transform_name"
     
    26532704program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
    26542705
    2655 # expand $ac_aux_dir to an absolute path
    2656 am_aux_dir=`cd $ac_aux_dir && pwd`
     2706# Expand $ac_aux_dir to an absolute path.
     2707am_aux_dir=`cd "$ac_aux_dir" && pwd`
    26572708
    26582709if test x"${MISSING+set}" != xset; then
     
    26652716fi
    26662717# Use eval to expand $SHELL
    2667 if eval "$MISSING --run true"; then
    2668   am_missing_run="$MISSING --run "
     2718if eval "$MISSING --is-lightweight"; then
     2719  am_missing_run="$MISSING "
    26692720else
    26702721  am_missing_run=
    2671   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`missing' script is too old or missing" >&5
    2672 $as_echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
    2673 fi
    2674 
    2675 if test x"${install_sh}" != xset; then
     2722  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
     2723$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
     2724fi
     2725
     2726if test x"${install_sh+set}" != xset; then
    26762727  case $am_aux_dir in
    26772728  *\ * | *\     *)
     
    26822733fi
    26832734
    2684 # Installed binaries are usually stripped using `strip' when the user
    2685 # run `make install-strip'.  However `strip' might not be the right
     2735# Installed binaries are usually stripped using 'strip' when the user
     2736# run "make install-strip".  However 'strip' might not be the right
    26862737# tool to use in cross-compilation environments, therefore Automake
    2687 # will honor the `STRIP' environment variable to overrule this program.
     2738# will honor the 'STRIP' environment variable to overrule this program.
    26882739if test "$cross_compiling" != no; then
    26892740  if test -n "$ac_tool_prefix"; then
     
    27042755  test -z "$as_dir" && as_dir=.
    27052756    for ac_exec_ext in '' $ac_executable_extensions; do
    2706   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     2757  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    27072758    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
    27082759    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    27442795  test -z "$as_dir" && as_dir=.
    27452796    for ac_exec_ext in '' $ac_executable_extensions; do
    2746   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     2797  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    27472798    ac_cv_prog_ac_ct_STRIP="strip"
    27482799    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    27952846    for ac_prog in mkdir gmkdir; do
    27962847         for ac_exec_ext in '' $ac_executable_extensions; do
    2797            { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; } || continue
     2848           as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
    27982849           case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
    27992850             'mkdir (GNU coreutils) '* | \
     
    28242875$as_echo "$MKDIR_P" >&6; }
    28252876
    2826 mkdir_p="$MKDIR_P"
    2827 case $mkdir_p in
    2828   [\\/$]* | ?:[\\/]*) ;;
    2829   */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
    2830 esac
    2831 
    28322877for ac_prog in gawk mawk nawk awk
    28332878do
     
    28482893  test -z "$as_dir" && as_dir=.
    28492894    for ac_exec_ext in '' $ac_executable_extensions; do
    2850   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     2895  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    28512896    ac_cv_prog_AWK="$ac_prog"
    28522897    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    29623007MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
    29633008
    2964 # We need awk for the "check" target.  The system "awk" is bad on
    2965 # some platforms.
     3009# For better backward compatibility.  To be removed once Automake 1.9.x
     3010# dies out for good.  For more background, see:
     3011# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
     3012# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
     3013mkdir_p='$(MKDIR_P)'
     3014
     3015# We need awk for the "check" target (and possibly the TAP driver).  The
     3016# system "awk" is bad on some platforms.
    29663017# Always define AMTAR for backward compatibility.  Yes, it's still used
    29673018# in the wild :-(  We should find a proper way to deprecate it ...
    29683019AMTAR='$${TAR-tar}'
    29693020
     3021
     3022# We'll loop over all known methods to create a tar archive until one works.
     3023_am_tools='gnutar  pax cpio none'
     3024
    29703025am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
    29713026
     
    29733028
    29743029
     3030
     3031
     3032# POSIX will say in a future version that running "rm -f" with no argument
     3033# is OK; and we want to be able to make that assumption in our Makefile
     3034# recipes.  So use an aggressive probe to check that the usage we want is
     3035# actually supported "in the wild" to an acceptable degree.
     3036# See automake bug#10828.
     3037# To make any issue more visible, cause the running configure to be aborted
     3038# by default if the 'rm' program in use doesn't match our expectations; the
     3039# user can still override this though.
     3040if rm -f && rm -fr && rm -rf; then : OK; else
     3041  cat >&2 <<'END'
     3042Oops!
     3043
     3044Your 'rm' program seems unable to run without file operands specified
     3045on the command line, even when the '-f' option is present.  This is contrary
     3046to the behaviour of most rm programs out there, and not conforming with
     3047the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
     3048
     3049Please tell bug-automake@gnu.org about your system, including the value
     3050of your $PATH and any error possibly output before this message.  This
     3051can help us improve future automake versions.
     3052
     3053END
     3054  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
     3055    echo 'Configuration will proceed anyway, since you have set the' >&2
     3056    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
     3057    echo >&2
     3058  else
     3059    cat >&2 <<'END'
     3060Aborting the configuration process, to ensure you take notice of the issue.
     3061
     3062You can download and install GNU coreutils to get an 'rm' implementation
     3063that behaves properly: <http://www.gnu.org/software/coreutils/>.
     3064
     3065If you want to complete the configuration process using your problematic
     3066'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
     3067to "yes", and re-run configure.
     3068
     3069END
     3070    as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
     3071  fi
     3072fi
    29753073
    29763074
     
    31023200  test -z "$as_dir" && as_dir=.
    31033201    for ac_exec_ext in '' $ac_executable_extensions; do
    3104   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     3202  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    31053203    ac_cv_path_BACKEND_CC="$as_dir/$ac_word$ac_exec_ext"
    31063204    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    34303528  test -z "$as_dir" && as_dir=.
    34313529    for ac_exec_ext in '' $ac_executable_extensions; do
    3432   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     3530  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    34333531    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
    34343532    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    34743572  test -z "$as_dir" && as_dir=.
    34753573    for ac_exec_ext in '' $ac_executable_extensions; do
    3476   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     3574  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    34773575    ac_cv_prog_ac_ct_CXX="$ac_prog"
    34783576    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    39274025# First try GNU make style include.
    39284026echo "include confinc" > confmf
    3929 # Ignore all kinds of additional output from `make'.
     4027# Ignore all kinds of additional output from 'make'.
    39304028case `$am_make -s -f confmf 2> /dev/null` in #(
    39314029*the\ am__doit\ target*)
     
    39834081  # making bogus files that we don't know about and never remove.  For
    39844082  # instance it was reported that on HP-UX the gcc test will end up
    3985   # making a dummy file named `D' -- because `-MD' means `put the output
    3986   # in D'.
     4083  # making a dummy file named 'D' -- because '-MD' means "put the output
     4084  # in D".
    39874085  rm -rf conftest.dir
    39884086  mkdir conftest.dir
     
    40194117    for i in 1 2 3 4 5 6; do
    40204118      echo '#include "conftst'$i'.h"' >> sub/conftest.c
    4021       # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
    4022       # Solaris 8's {/usr,}/bin/sh.
    4023       touch sub/conftst$i.h
     4119      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
     4120      # Solaris 10 /bin/sh.
     4121      echo '/* dummy */' > sub/conftst$i.h
    40244122    done
    40254123    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
    40264124
    4027     # We check with `-c' and `-o' for the sake of the "dashmstdout"
     4125    # We check with '-c' and '-o' for the sake of the "dashmstdout"
    40284126    # mode.  It turns out that the SunPro C++ compiler does not properly
    4029     # handle `-M -o', and we need to detect this.  Also, some Intel
    4030     # versions had trouble with output in subdirs
     4127    # handle '-M -o', and we need to detect this.  Also, some Intel
     4128    # versions had trouble with output in subdirs.
    40314129    am__obj=sub/conftest.${OBJEXT-o}
    40324130    am__minus_obj="-o $am__obj"
     
    40374135      ;;
    40384136    nosideeffect)
    4039       # after this tag, mechanisms are not by side-effect, so they'll
    4040       # only be used when explicitly requested
     4137      # After this tag, mechanisms are not by side-effect, so they'll
     4138      # only be used when explicitly requested.
    40414139      if test "x$enable_dependency_tracking" = xyes; then
    40424140        continue
     
    40464144      ;;
    40474145    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
    4048       # This compiler won't grok `-c -o', but also, the minuso test has
     4146      # This compiler won't grok '-c -o', but also, the minuso test has
    40494147      # not run yet.  These depmodes are late enough in the game, and
    40504148      # so weak that their functioning should not be impacted.
     
    41224220  test -z "$as_dir" && as_dir=.
    41234221    for ac_exec_ext in '' $ac_executable_extensions; do
    4124   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4222  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    41254223    ac_cv_prog_CC="${ac_tool_prefix}gcc"
    41264224    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    41624260  test -z "$as_dir" && as_dir=.
    41634261    for ac_exec_ext in '' $ac_executable_extensions; do
    4164   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4262  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    41654263    ac_cv_prog_ac_ct_CC="gcc"
    41664264    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    42154313  test -z "$as_dir" && as_dir=.
    42164314    for ac_exec_ext in '' $ac_executable_extensions; do
    4217   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4315  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    42184316    ac_cv_prog_CC="${ac_tool_prefix}cc"
    42194317    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    42564354  test -z "$as_dir" && as_dir=.
    42574355    for ac_exec_ext in '' $ac_executable_extensions; do
    4258   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4356  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    42594357    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
    42604358       ac_prog_rejected=yes
     
    43144412  test -z "$as_dir" && as_dir=.
    43154413    for ac_exec_ext in '' $ac_executable_extensions; do
    4316   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4414  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    43174415    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
    43184416    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    43584456  test -z "$as_dir" && as_dir=.
    43594457    for ac_exec_ext in '' $ac_executable_extensions; do
    4360   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4458  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    43614459    ac_cv_prog_ac_ct_CC="$ac_prog"
    43624460    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    45544652#include <stdarg.h>
    45554653#include <stdio.h>
    4556 #include <sys/types.h>
    4557 #include <sys/stat.h>
     4654struct stat;
    45584655/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
    45594656struct buf { int x; };
     
    46404737ac_compiler_gnu=$ac_cv_c_compiler_gnu
    46414738
     4739ac_ext=c
     4740ac_cpp='$CPP $CPPFLAGS'
     4741ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     4742ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4743ac_compiler_gnu=$ac_cv_c_compiler_gnu
     4744{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
     4745$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
     4746if ${am_cv_prog_cc_c_o+:} false; then :
     4747  $as_echo_n "(cached) " >&6
     4748else
     4749  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     4750/* end confdefs.h.  */
     4751
     4752int
     4753main ()
     4754{
     4755
     4756  ;
     4757  return 0;
     4758}
     4759_ACEOF
     4760  # Make sure it works both with $CC and with simple cc.
     4761  # Following AC_PROG_CC_C_O, we do the test twice because some
     4762  # compilers refuse to overwrite an existing .o file with -o,
     4763  # though they will create one.
     4764  am_cv_prog_cc_c_o=yes
     4765  for am_i in 1 2; do
     4766    if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
     4767   ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
     4768   ac_status=$?
     4769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4770   (exit $ac_status); } \
     4771         && test -f conftest2.$ac_objext; then
     4772      : OK
     4773    else
     4774      am_cv_prog_cc_c_o=no
     4775      break
     4776    fi
     4777  done
     4778  rm -f core conftest*
     4779  unset am_i
     4780fi
     4781{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
     4782$as_echo "$am_cv_prog_cc_c_o" >&6; }
     4783if test "$am_cv_prog_cc_c_o" != yes; then
     4784   # Losing compiler, so override with the script.
     4785   # FIXME: It is wrong to rewrite CC.
     4786   # But if we don't then we get into trouble of one sort or another.
     4787   # A longer-term fix would be to have automake use am__CC in this case,
     4788   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
     4789   CC="$am_aux_dir/compile $CC"
     4790fi
     4791ac_ext=c
     4792ac_cpp='$CPP $CPPFLAGS'
     4793ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     4794ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4795ac_compiler_gnu=$ac_cv_c_compiler_gnu
     4796
     4797
    46424798depcc="$CC"   am_compiler_list=
    46434799
     
    46514807  # making bogus files that we don't know about and never remove.  For
    46524808  # instance it was reported that on HP-UX the gcc test will end up
    4653   # making a dummy file named `D' -- because `-MD' means `put the output
    4654   # in D'.
     4809  # making a dummy file named 'D' -- because '-MD' means "put the output
     4810  # in D".
    46554811  rm -rf conftest.dir
    46564812  mkdir conftest.dir
     
    46874843    for i in 1 2 3 4 5 6; do
    46884844      echo '#include "conftst'$i'.h"' >> sub/conftest.c
    4689       # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
    4690       # Solaris 8's {/usr,}/bin/sh.
    4691       touch sub/conftst$i.h
     4845      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
     4846      # Solaris 10 /bin/sh.
     4847      echo '/* dummy */' > sub/conftst$i.h
    46924848    done
    46934849    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
    46944850
    4695     # We check with `-c' and `-o' for the sake of the "dashmstdout"
     4851    # We check with '-c' and '-o' for the sake of the "dashmstdout"
    46964852    # mode.  It turns out that the SunPro C++ compiler does not properly
    4697     # handle `-M -o', and we need to detect this.  Also, some Intel
    4698     # versions had trouble with output in subdirs
     4853    # handle '-M -o', and we need to detect this.  Also, some Intel
     4854    # versions had trouble with output in subdirs.
    46994855    am__obj=sub/conftest.${OBJEXT-o}
    47004856    am__minus_obj="-o $am__obj"
     
    47054861      ;;
    47064862    nosideeffect)
    4707       # after this tag, mechanisms are not by side-effect, so they'll
    4708       # only be used when explicitly requested
     4863      # After this tag, mechanisms are not by side-effect, so they'll
     4864      # only be used when explicitly requested.
    47094865      if test "x$enable_dependency_tracking" = xyes; then
    47104866        continue
     
    47144870      ;;
    47154871    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
    4716       # This compiler won't grok `-c -o', but also, the minuso test has
     4872      # This compiler won't grok '-c -o', but also, the minuso test has
    47174873      # not run yet.  These depmodes are late enough in the game, and
    47184874      # so weak that their functioning should not be impacted.
     
    47864942  # making bogus files that we don't know about and never remove.  For
    47874943  # instance it was reported that on HP-UX the gcc test will end up
    4788   # making a dummy file named `D' -- because `-MD' means `put the output
    4789   # in D'.
     4944  # making a dummy file named 'D' -- because '-MD' means "put the output
     4945  # in D".
    47904946  rm -rf conftest.dir
    47914947  mkdir conftest.dir
     
    48204976    for i in 1 2 3 4 5 6; do
    48214977      echo '#include "conftst'$i'.h"' >> sub/conftest.c
    4822       # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
    4823       # Solaris 8's {/usr,}/bin/sh.
    4824       touch sub/conftst$i.h
     4978      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
     4979      # Solaris 10 /bin/sh.
     4980      echo '/* dummy */' > sub/conftst$i.h
    48254981    done
    48264982    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
    48274983
    4828     # We check with `-c' and `-o' for the sake of the "dashmstdout"
     4984    # We check with '-c' and '-o' for the sake of the "dashmstdout"
    48294985    # mode.  It turns out that the SunPro C++ compiler does not properly
    4830     # handle `-M -o', and we need to detect this.  Also, some Intel
    4831     # versions had trouble with output in subdirs
     4986    # handle '-M -o', and we need to detect this.  Also, some Intel
     4987    # versions had trouble with output in subdirs.
    48324988    am__obj=sub/conftest.${OBJEXT-o}
    48334989    am__minus_obj="-o $am__obj"
     
    48384994      ;;
    48394995    nosideeffect)
    4840       # after this tag, mechanisms are not by side-effect, so they'll
    4841       # only be used when explicitly requested
     4996      # After this tag, mechanisms are not by side-effect, so they'll
     4997      # only be used when explicitly requested.
    48424998      if test "x$enable_dependency_tracking" = xyes; then
    48434999        continue
     
    48475003      ;;
    48485004    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
    4849       # This compiler won't grok `-c -o', but also, the minuso test has
     5005      # This compiler won't grok '-c -o', but also, the minuso test has
    48505006      # not run yet.  These depmodes are late enough in the game, and
    48515007      # so weak that their functioning should not be impacted.
     
    49015057
    49025058
    4903 if test "x$CC" != xcc; then
    4904   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC and cc understand -c and -o together" >&5
    4905 $as_echo_n "checking whether $CC and cc understand -c and -o together... " >&6; }
    4906 else
    4907   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether cc understands -c and -o together" >&5
    4908 $as_echo_n "checking whether cc understands -c and -o together... " >&6; }
    4909 fi
    4910 set dummy $CC; ac_cc=`$as_echo "$2" |
    4911                       sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
    4912 if eval \${ac_cv_prog_cc_${ac_cc}_c_o+:} false; then :
    4913   $as_echo_n "(cached) " >&6
    4914 else
    4915   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    4916 /* end confdefs.h.  */
    4917 
    4918 int
    4919 main ()
    4920 {
    4921 
    4922   ;
    4923   return 0;
    4924 }
    4925 _ACEOF
    4926 # Make sure it works both with $CC and with simple cc.
    4927 # We do the test twice because some compilers refuse to overwrite an
    4928 # existing .o file with -o, though they will create one.
    4929 ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
    4930 rm -f conftest2.*
    4931 if { { case "(($ac_try" in
    4932   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    4933   *) ac_try_echo=$ac_try;;
    4934 esac
    4935 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    4936 $as_echo "$ac_try_echo"; } >&5
    4937   (eval "$ac_try") 2>&5
    4938   ac_status=$?
    4939   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    4940   test $ac_status = 0; } &&
    4941    test -f conftest2.$ac_objext && { { case "(($ac_try" in
    4942   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    4943   *) ac_try_echo=$ac_try;;
    4944 esac
    4945 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    4946 $as_echo "$ac_try_echo"; } >&5
    4947   (eval "$ac_try") 2>&5
    4948   ac_status=$?
    4949   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    4950   test $ac_status = 0; };
    4951 then
    4952   eval ac_cv_prog_cc_${ac_cc}_c_o=yes
    4953   if test "x$CC" != xcc; then
    4954     # Test first that cc exists at all.
    4955     if { ac_try='cc -c conftest.$ac_ext >&5'
    4956   { { case "(($ac_try" in
    4957   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    4958   *) ac_try_echo=$ac_try;;
    4959 esac
    4960 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    4961 $as_echo "$ac_try_echo"; } >&5
    4962   (eval "$ac_try") 2>&5
    4963   ac_status=$?
    4964   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    4965   test $ac_status = 0; }; }; then
    4966       ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
    4967       rm -f conftest2.*
    4968       if { { case "(($ac_try" in
    4969   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    4970   *) ac_try_echo=$ac_try;;
    4971 esac
    4972 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    4973 $as_echo "$ac_try_echo"; } >&5
    4974   (eval "$ac_try") 2>&5
    4975   ac_status=$?
    4976   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    4977   test $ac_status = 0; } &&
    4978          test -f conftest2.$ac_objext && { { case "(($ac_try" in
    4979   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    4980   *) ac_try_echo=$ac_try;;
    4981 esac
    4982 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    4983 $as_echo "$ac_try_echo"; } >&5
    4984   (eval "$ac_try") 2>&5
    4985   ac_status=$?
    4986   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    4987   test $ac_status = 0; };
    4988       then
    4989         # cc works too.
    4990         :
    4991       else
    4992         # cc exists but doesn't like -o.
    4993         eval ac_cv_prog_cc_${ac_cc}_c_o=no
    4994       fi
    4995     fi
    4996   fi
    4997 else
    4998   eval ac_cv_prog_cc_${ac_cc}_c_o=no
    4999 fi
    5000 rm -f core conftest*
    5001 
    5002 fi
    5003 if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
    5004   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
    5005 $as_echo "yes" >&6; }
    5006 else
    5007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5008 $as_echo "no" >&6; }
    5009 
    5010 $as_echo "#define NO_MINUS_C_MINUS_O 1" >>confdefs.h
    5011 
    5012 fi
    5013 
    5014 # FIXME: we rely on the cache variable name because
    5015 # there is no other way.
    5016 set dummy $CC
    5017 am_cc=`echo $2 | sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
    5018 eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
    5019 if test "$am_t" != yes; then
    5020    # Losing compiler, so override with the script.
    5021    # FIXME: It is wrong to rewrite CC.
    5022    # But if we don't then we get into trouble of one sort or another.
    5023    # A longer-term fix would be to have automake use am__CC in this case,
    5024    # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
    5025    CC="$am_aux_dir/compile $CC"
    5026 fi
    5027 
    50285059        # deprecated
    50295060# These are often not installed and people miss seeing the "no", so stop the configure.
     
    50465077  test -z "$as_dir" && as_dir=.
    50475078    for ac_exec_ext in '' $ac_executable_extensions; do
    5048   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5079  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    50495080    ac_cv_prog_YACC="$ac_prog"
    50505081    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    50915122  test -z "$as_dir" && as_dir=.
    50925123    for ac_exec_ext in '' $ac_executable_extensions; do
    5093   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5124  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    50945125    ac_cv_prog_LEX="$ac_prog"
    50955126    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    51235154c { yymore (); }
    51245155d { yyless (1); }
    5125 e { yyless (input () != 0); }
     5156e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument.  */
     5157    yyless ((input () != 0)); }
    51265158f { unput (yytext[0]); }
    51275159. { BEGIN INITIAL; }
     
    52815313  test -z "$as_dir" && as_dir=.
    52825314    for ac_exec_ext in '' $ac_executable_extensions; do
    5283   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5315  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    52845316    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
    52855317    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    53215353  test -z "$as_dir" && as_dir=.
    53225354    for ac_exec_ext in '' $ac_executable_extensions; do
    5323   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5355  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    53245356    ac_cv_prog_ac_ct_RANLIB="ranlib"
    53255357    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     
    55145546    for ac_exec_ext in '' $ac_executable_extensions; do
    55155547      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
    5516       { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
     5548      as_fn_executable_p "$ac_path_GREP" || continue
    55175549# Check for GNU ac_path_GREP and select it if it is found.
    55185550  # Check for GNU $ac_path_GREP
     
    55805612    for ac_exec_ext in '' $ac_executable_extensions; do
    55815613      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
    5582       { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
     5614      as_fn_executable_p "$ac_path_EGREP" || continue
    55835615# Check for GNU ac_path_EGREP and select it if it is found.
    55845616  # Check for GNU $ac_path_EGREP
     
    59195951$ac_includes_default
    59205952int
    5921 find_stack_direction ()
     5953find_stack_direction (int *addr, int depth)
    59225954{
    5923   static char *addr = 0;
    5924   auto char dummy;
    5925   if (addr == 0)
    5926     {
    5927       addr = &dummy;
    5928       return find_stack_direction ();
    5929     }
    5930   else
    5931     return (&dummy > addr) ? 1 : -1;
     5955  int dir, dummy = 0;
     5956  if (! addr)
     5957    addr = &dummy;
     5958  *addr = addr < &dummy ? 1 : addr == &dummy ? 0 : -1;
     5959  dir = depth ? find_stack_direction (addr, depth - 1) : 0;
     5960  return dir + dummy;
    59325961}
    59335962
    59345963int
    5935 main ()
     5964main (int argc, char **argv)
    59365965{
    5937   return find_stack_direction () < 0;
     5966  return find_stack_direction (0, argc + !argv + 20) < 0;
    59385967}
    59395968_ACEOF
     
    59806009/* end confdefs.h.  */
    59816010
    5982 #include <stdbool.h>
    5983 #ifndef bool
    5984  "error: bool is not defined"
    5985 #endif
    5986 #ifndef false
    5987  "error: false is not defined"
    5988 #endif
    5989 #if false
    5990  "error: false is not 0"
    5991 #endif
    5992 #ifndef true
    5993  "error: true is not defined"
    5994 #endif
    5995 #if true != 1
    5996  "error: true is not 1"
    5997 #endif
    5998 #ifndef __bool_true_false_are_defined
    5999  "error: __bool_true_false_are_defined is not defined"
    6000 #endif
    6001 
    6002         struct s { _Bool s: 1; _Bool t; } s;
    6003 
    6004         char a[true == 1 ? 1 : -1];
    6005         char b[false == 0 ? 1 : -1];
    6006         char c[__bool_true_false_are_defined == 1 ? 1 : -1];
    6007         char d[(bool) 0.5 == true ? 1 : -1];
    6008         /* See body of main program for 'e'.  */
    6009         char f[(_Bool) 0.0 == false ? 1 : -1];
    6010         char g[true];
    6011         char h[sizeof (_Bool)];
    6012         char i[sizeof s.t];
    6013         enum { j = false, k = true, l = false * true, m = true * 256 };
    6014         /* The following fails for
    6015            HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */
    6016         _Bool n[m];
    6017         char o[sizeof n == m * sizeof n[0] ? 1 : -1];
    6018         char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1];
    6019         /* Catch a bug in an HP-UX C compiler.  See
    6020            http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html
    6021            http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html
    6022         */
    6023         _Bool q = true;
    6024         _Bool *pq = &q;
     6011             #include <stdbool.h>
     6012             #ifndef bool
     6013              "error: bool is not defined"
     6014             #endif
     6015             #ifndef false
     6016              "error: false is not defined"
     6017             #endif
     6018             #if false
     6019              "error: false is not 0"
     6020             #endif
     6021             #ifndef true
     6022              "error: true is not defined"
     6023             #endif
     6024             #if true != 1
     6025              "error: true is not 1"
     6026             #endif
     6027             #ifndef __bool_true_false_are_defined
     6028              "error: __bool_true_false_are_defined is not defined"
     6029             #endif
     6030
     6031             struct s { _Bool s: 1; _Bool t; } s;
     6032
     6033             char a[true == 1 ? 1 : -1];
     6034             char b[false == 0 ? 1 : -1];
     6035             char c[__bool_true_false_are_defined == 1 ? 1 : -1];
     6036             char d[(bool) 0.5 == true ? 1 : -1];
     6037             /* See body of main program for 'e'.  */
     6038             char f[(_Bool) 0.0 == false ? 1 : -1];
     6039             char g[true];
     6040             char h[sizeof (_Bool)];
     6041             char i[sizeof s.t];
     6042             enum { j = false, k = true, l = false * true, m = true * 256 };
     6043             /* The following fails for
     6044                HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */
     6045             _Bool n[m];
     6046             char o[sizeof n == m * sizeof n[0] ? 1 : -1];
     6047             char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1];
     6048             /* Catch a bug in an HP-UX C compiler.  See
     6049                http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html
     6050                http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html
     6051              */
     6052             _Bool q = true;
     6053             _Bool *pq = &q;
    60256054
    60266055int
     
    60286057{
    60296058
    6030         bool e = &s;
    6031         *pq |= q;
    6032         *pq |= ! q;
    6033         /* Refer to every declared value, to avoid compiler optimizations.  */
    6034         return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l
    6035                 + !m + !n + !o + !p + !q + !pq);
     6059             bool e = &s;
     6060             *pq |= q;
     6061             *pq |= ! q;
     6062             /* Refer to every declared value, to avoid compiler optimizations.  */
     6063             return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l
     6064                     + !m + !n + !o + !p + !q + !pq);
    60366065
    60376066  ;
     
    60486077{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5
    60496078$as_echo "$ac_cv_header_stdbool_h" >&6; }
    6050 ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default"
     6079   ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default"
    60516080if test "x$ac_cv_type__Bool" = xyes; then :
    60526081
     
    60576086
    60586087fi
     6088
    60596089
    60606090if test $ac_cv_header_stdbool_h = yes; then
     
    63636393
    63646394
     6395{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
     6396$as_echo_n "checking that generated files are newer than configure... " >&6; }
     6397   if test -n "$am_sleep_pid"; then
     6398     # Hide warnings about reused PIDs.
     6399     wait $am_sleep_pid 2>/dev/null
     6400   fi
     6401   { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
     6402$as_echo "done" >&6; }
    63656403 if test -n "$EXEEXT"; then
    63666404  am__EXEEXT_TRUE=
     
    67056743    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    67066744    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    6707     # In both cases, we have to default to `cp -p'.
     6745    # In both cases, we have to default to `cp -pR'.
    67086746    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
    6709       as_ln_s='cp -p'
     6747      as_ln_s='cp -pR'
    67106748  elif ln conf$$.file conf$$ 2>/dev/null; then
    67116749    as_ln_s=ln
    67126750  else
    6713     as_ln_s='cp -p'
     6751    as_ln_s='cp -pR'
    67146752  fi
    67156753else
    6716   as_ln_s='cp -p'
     6754  as_ln_s='cp -pR'
    67176755fi
    67186756rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
     
    67746812fi
    67756813
    6776 if test -x / >/dev/null 2>&1; then
    6777   as_test_x='test -x'
    6778 else
    6779   if ls -dL / >/dev/null 2>&1; then
    6780     as_ls_L_option=L
    6781   else
    6782     as_ls_L_option=
    6783   fi
    6784   as_test_x='
    6785     eval sh -c '\''
    6786       if test -d "$1"; then
    6787         test -d "$1/.";
    6788       else
    6789         case $1 in #(
    6790         -*)set "./$1";;
    6791         esac;
    6792         case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
    6793         ???[sx]*):;;*)false;;esac;fi
    6794     '\'' sh
    6795   '
    6796 fi
    6797 as_executable_p=$as_test_x
     6814
     6815# as_fn_executable_p FILE
     6816# -----------------------
     6817# Test if FILE is an executable regular file.
     6818as_fn_executable_p ()
     6819{
     6820  test -f "$1" && test -x "$1"
     6821} # as_fn_executable_p
     6822as_test_x='test -x'
     6823as_executable_p=as_fn_executable_p
    67986824
    67996825# Sed expression to map a string onto a valid CPP name.
     
    68176843ac_log="
    68186844This file was extended by cfa-cc $as_me 1.0.0.0, which was
    6819 generated by GNU Autoconf 2.68.  Invocation command line was
     6845generated by GNU Autoconf 2.69.  Invocation command line was
    68206846
    68216847  CONFIG_FILES    = $CONFIG_FILES
     
    68836909ac_cs_version="\\
    68846910cfa-cc config.status 1.0.0.0
    6885 configured by $0, generated by GNU Autoconf 2.68,
     6911configured by $0, generated by GNU Autoconf 2.69,
    68866912  with options \\"\$ac_cs_config\\"
    68876913
    6888 Copyright (C) 2010 Free Software Foundation, Inc.
     6914Copyright (C) 2012 Free Software Foundation, Inc.
    68896915This config.status script is free software; the Free Software Foundation
    68906916gives unlimited permission to copy, distribute and modify it."
     
    69777003cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
    69787004if \$ac_cs_recheck; then
    6979   set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
     7005  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
    69807006  shift
    69817007  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
     
    76197645  case $ac_file$ac_mode in
    76207646    "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
    7621   # Autoconf 2.62 quotes --file arguments for eval, but not when files
     7647  # Older Autoconf quotes --file arguments for eval, but not when files
    76227648  # are listed without --file.  Let's play safe and only enable the eval
    76237649  # if we detect the quoting.
     
    76327658    mf=`echo "$mf" | sed -e 's/:.*$//'`
    76337659    # Check whether this is an Automake generated Makefile or not.
    7634     # We used to match only the files named `Makefile.in', but
     7660    # We used to match only the files named 'Makefile.in', but
    76357661    # some people rename them; so instead we look at the file content.
    76367662    # Grep'ing the first line is not enough: some people post-process
     
    76667692    fi
    76677693    # Extract the definition of DEPDIR, am__include, and am__quote
    7668     # from the Makefile without running `make'.
     7694    # from the Makefile without running 'make'.
    76697695    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
    76707696    test -z "$DEPDIR" && continue
    76717697    am__include=`sed -n 's/^am__include = //p' < "$mf"`
    7672     test -z "am__include" && continue
     7698    test -z "$am__include" && continue
    76737699    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
    7674     # When using ansi2knr, U may be empty or an underscore; expand it
    7675     U=`sed -n 's/^U = //p' < "$mf"`
    76767700    # Find all dependency output files, they are included files with
    76777701    # $(DEPDIR) in their names.  We invoke sed twice because it is the
     
    76807704    for file in `sed -n "
    76817705      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
    7682          sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
     7706         sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
    76837707      # Make sure the directory exists.
    76847708      test -f "$dirpart/$file" && continue
  • configure.ac

    rf7cb0bc ra5de33e  
    99AM_SILENT_RULES([no])
    1010
    11 AM_INIT_AUTOMAKE
     11AM_INIT_AUTOMAKE([subdir-objects])
    1212AM_MAINTAINER_MODE(enable)                      # may require auto* software to be installed
    1313
  • doc/LaTeXmacros/lstlang.sty

    rf7cb0bc ra5de33e  
    88%% Created On       : Sat May 13 16:34:42 2017
    99%% Last Modified By : Peter A. Buhr
    10 %% Last Modified On : Fri May 26 12:47:09 2017
    11 %% Update Count     : 8
     10%% Last Modified On : Thu Jun 22 07:40:31 2017
     11%% Update Count     : 10
    1212%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1313
     
    116116                _Atomic, coroutine, is_coroutine, is_monitor, is_thread, monitor, mutex, nomutex,
    117117                resume, suspend, thread, _Thread_local, yield},
     118        moredirectives={defined,include_next}%
    118119}
    119120
  • doc/generic_types/mail

    rf7cb0bc ra5de33e  
    7878
    7979- OOPSLA'17 Submissions
     80
     81
     82
     83From: "OOPSLA'17 HotCRP" <noreply@oopsla17.hotcrp.com>
     84Subject: [OOPSLA'17] Paper #20 "Generic and Tuple Types with Efficient..."
     85To: Peter Buhr <pabuhr@uwaterloo.ca>
     86Cc: jonathan.aldrich@cs.cmu.edu
     87Reply-To: jonathan.aldrich@cs.cmu.edu
     88Date: Wed,  7 Jun 2017 13:33:40 +0000 (UTC)
     89
     90Dear Peter Buhr,
     91
     92The author response period for OOPSLA has started, and will continue until
     93the end of June 10th (Anywhere on Earth).  No email with a snapshot of your
     94reviews will be sent: you can see the live version of reviews (including
     95current updates) on the HotCRP system (links at the bottom).
     96
     97An author response should aim to:
     98 -correct reviewers' mistakes or misunderstandings
     99 -offer new information only when this addresses reviewers' concerns (e.g.,
     100"I wonder if A might work better...";  "we tried that, but...")
     101 -answer explicit questions by the reviewers. The key questions will be in a
     102designated "Questions for Author Response" entry of a review.
     103
     104Please keep in mind that an author response is *not* a "rebuttal". You are
     105not rebutting an opponent's arguments with your own, in front of an
     106audience that weighs both sets of arguments. Instead, your audience is the
     107same reviewers who offered the comments in the first place, and their
     108subjective weighing of different factors is very unlikely to change.
     109
     110During author response, please keep in mind that the reviewers are still
     111unaware of author identity. If you need to refer to author-identifying
     112information during your response, the ideal course of action is to place it
     113at an external location and include a URL, with an explicit warning (e.g.,
     114"WARNING: following this link will reveal author identity").
     115
     116As with all external resources, your response should be self-contained,
     117without consulting them. That is, the author-visible external URL is just
     118evidence, but the claim that this evidence supports should be clear in the
     119response text. For instance:
     120"we have received public feedback from the developers of X that confirm the
     121issue [supporting URL] (WARNING: following this link will reveal author
     122identity)"
     123
     124Your paper's access information is below:
     125
     126       Title: Generic and Tuple Types with Efficient Dynamic Layout in C∀
     127  Paper site: https://oopsla17.hotcrp.com/paper/20
     128
     129Use the link below to sign in to the site.
     130
     131https://oopsla17.hotcrp.com/?email=pabuhr%40uwaterloo.ca
     132
     133Please contact me <jonathan.aldrich@cs.cmu.edu> with any questions or
     134concerns.
     135
     136Best Regards and wishes for a constructive response,
     137
     138Jonathan Aldrich
     139
     140
     141
     142From: "OOPSLA'17 HotCRP" <noreply@oopsla17.hotcrp.com>
     143Subject: [OOPSLA'17] Paper #20 "Generic and Tuple Types with Efficient..."
     144To: Peter Buhr <pabuhr@uwaterloo.ca>
     145Cc: jonathan.aldrich@cs.cmu.edu
     146Reply-To: jonathan.aldrich@cs.cmu.edu
     147Date: Tue, 20 Jun 2017 00:33:10 +0000 (UTC)
     148
     149Dear Peter Buhr,
     150
     151I regret to inform you that your submission to OOPSLA'17 listed below has not
     152been selected for the second phase of the review process. I understand this is
     153not welcome news but selection was very competitive: 157 of the 223 papers
     154submitted did not advance to the second phase. For several of these, there was
     155a clear impression that in the future they can evolve into some of the
     156strongest results of our community.
     157
     158       Title: Generic and Tuple Types with Efficient Dynamic Layout in C∀
     159  Paper site: https://oopsla17.hotcrp.com/paper/20
     160  Login link: https://oopsla17.hotcrp.com/?email=pabuhr%40uwaterloo.ca
     161
     162Below you will find reviews, as well as author-visible comments--the latter may
     163include further communication. I hope you will find the reviewers' feedback
     164useful.
     165
     166Best Regards,
     167
     168- Jonathan Aldrich <jonathan.aldrich@cs.cmu.edu>, for OOPSLA 2017
     169Submissions
     170
     171
     172
     173===========================================================================
     174                           OOPSLA'17 Review #20A
     175---------------------------------------------------------------------------
     176 Paper #20: Generic and Tuple Types with Efficient Dynamic Layout in C∀
     177---------------------------------------------------------------------------
     178
     179                      Overall merit: C. Weak paper, though I will not fight
     180                                        strongly against it
     181                         Confidence: X. I am an expert in this area
     182
     183                         ===== Paper summary =====
     184
     185This presents an extension of the C programming language that tries to preserve the character of the existing language, while adding tuples and generics. Unlike C++ templates, generics preserve separate compilation. Types are represented at runtime, if needed, by size and alignment values, along with pointers to the code for any needed operators. A microbenchmark performance comparison is provided.
     186
     187                      ===== Comments for author =====
     188
     189This is an interesting extension to C, that may be of interest to some C programmers. It generally seems to be fairly well engineered, and mostly respects C's design goals.
     190
     191Unfortunately, there have been enough proposals for extended C dialects that this sort of design is tough to sell. And I don't think the evaluation really went far enough to make that case.
     192
     193The ideas in the paper don't appear to be fundamentally new. The idea of passing types as runtime objects has certainly been explored before. An additional ancient reference is http://dl.acm.org/citation.cfm?doid=13310.13330.
     194
     195There seems to be a new idea of minimally describing types using alignment and size attributes instead of (?) pointers to assignment operators and the like. But this scheme is not very well described. Notably, it is not clear how, say, a struct with atomic field or bit-fields would be described.
     196
     197I wasn't quite clear on the extent to which operator overloading is supported. The MAX example appears to me like it would be quite controversial among C programmers.
     198
     199It is not obvious that type inference here always converges. An outline of the algorithm would be useful.
     200
     201Above all, this needs experience results from a more complete implementation.
     202
     203Details:
     204
     205Relying on TIOBE here seems a bit dubious. Since it counts web pages, and C isn't exactly new and hot, it may actually understate your case.
     206
     207The print example seems a little simplistic, since it's not clear how it handles formatting.
     208
     209"does not using the return type"
     210
     211              ===== Questions for authors’ response =====
     212
     213How are atomics, volatile, and bit-fields in structs handled?
     214
     215===========================================================================
     216                           OOPSLA'17 Review #20B
     217---------------------------------------------------------------------------
     218 Paper #20: Generic and Tuple Types with Efficient Dynamic Layout in C∀
     219---------------------------------------------------------------------------
     220
     221                      Overall merit: D. Reject
     222                         Confidence: X. I am an expert in this area
     223
     224                         ===== Paper summary =====
     225
     226The authors present an extension to C, adding universal polymorphism and tuples. These features are described in prose. There is an implementation, though this is not described in depth in the paper. There is a benchmark evaluation.
     227
     228                      ===== Comments for author =====
     229
     230The paper is well-written and the concepts explained well. It is nice to see work in the low-level/C space - I believe that it is an area that has not been well-served by the OOPSLA community. My concerns with the paper are that the contribution is rather small and the concepts are not well-evaluated; specifically this is a language design paper and there is no attempt to evaluate the actual language design.
     231
     232While it is reasonable to describe only a couple of features in a paper, I would then expect a detailed description of the implementation and/or a formalism with proven safety properties and a thorough evaluation of the design. For a paper which only describes the design of a language the bar is higher than two features - for example, a description of a 'large' language such as D or Rust, even then I would expect a stronger evaluation.
     233
     234## On the design of C-forall
     235
     236There are some interesting points in the design of generics, notably the otype/dtype distinction. The design seems reasonable and follows what I would expect from other languages. The design for tuples is more unusual - the usual design of simple anonymous records with anonymous fields is extended with a mix of 'spread'ing, variadics, and implicit conversions. Importantly, the authors neither justify nor evaluate this departure - that is a severe omission for this paper. Furthermore, the only in-depth description of the implementation in the paper concerns tuples, and it seems to me that this is only interesting because of the unusual design - further reason for justifying it.
     237
     238## Evaluation
     239
     240The paper evaluates the implementation of C-forall with (effectively) a single micro-benchmark. That benchmark seems to show that C-forall performs worse than C++ on every measure, but this is not really discussed.
     241
     242A better performance evaluation would consist of multiple tests, both micro-benchmarks and realistic code and would test C-forall compared to alternatives (D, Rust, Go, etc.) not just C/C++.
     243
     244However, performance is not the really interesting thing to test here. The authors propose a new language and while performance is an important consideration for systems languages, it is far from the most important. I would like to see the usability of the language tested with user studies of different kinds (various levels of skill-level and coding scenarios). The authors could also use case studies or programming idioms to compare programming in C-forall vs the alternatives (again, comparing with D, Rust, etc. is more interesting to me than C).
     245
     246Finally, in designing C-forall, the authors make several assumptions about why C programmers use C. These should be backed up either with evaluation or citation. Statements in the paper certainly do not reflect my experience discussing language design with C programmers, and I would like to see them verified.
     247
     248
     249## Related work
     250
     251The related work section is broad and gives good descriptions of other languages. However, the comparisons between languages focus more on the high-level goals of the language. It would be more interesting to focus on the details of the languages - the comparisons between Cyclone, C++, Java, and C-forall generics are good, I would like to see more of this with D and Rust, which are the more modern alternatives to C-forall (for example, Rust's notion of Sized and ?Sized types seems similar to otypes/dtypes).
     252
     253The related work is really missing any discussion of why the C-forall design choices are better than other languages. To clarify, I mean the specific design of generics and tuples, c.f., the suitability of the language in general because of garbage collection or learning difficulties.
     254
     255===========================================================================
     256                           OOPSLA'17 Review #20C
     257---------------------------------------------------------------------------
     258 Paper #20: Generic and Tuple Types with Efficient Dynamic Layout in C∀
     259---------------------------------------------------------------------------
     260
     261                      Overall merit: D. Reject
     262                         Confidence: Z. I am not an expert; my evaluation
     263                                        is that of an informed outsider
     264
     265                         ===== Paper summary =====
     266
     267The paper presents two language features of "Cforall": generics and tuples.
     268
     269                      ===== Comments for author =====
     270
     271The authors really need to talk about C++ as early as possible IMHO. That's the first thing that came to mind when reading the abstract: how is this different from C++?
     272
     273Comparison with C++:
     274The main difference with C++ seems to be that Cforall favors separate compilation at the expense of runtime overhead while C++ systematically avoids any runtime overhead (at the expense of slow compilation times). C++ approach makes more sense IMHO. While it's true that people where using C for almost everything 30 years ago, that is just not true anymore. Most people writing C today are doing system programming, otherwise there would be using a higher level programming language (C#, Java etc ...).
     275Now, when doing system programming, one needs very fine grain control over the resources: memory layout, etc ...
     276It is pretty clear to me that the people writing that kind of code will favor generics that do not cost any overhead at runtime, otherwise they would be writing Java in the first place.
     277The authors need to better justify the runtime overhead, or give escape hatches for those who don't want to pay that cost at runtime.
     278They very often go back to the benefit of separate compilation, but that's not enough IMHO. Here is a proposal: why not have 2 modes, one called debug mode, used while developing the code, that would compile generics with a runtime overhead. Another, called production, that would unfold the world like C++ does?
     279
     280About Tuples:
     281The section about tuples is too long. I would have spent more time explaining generics.
     282
     283Feedback:
     284"This installation base"
     285Unclear what you mean by that.
     286
     287"Prior projects ... but failed ..."
     288Hummm ... What about C++.
     289
     290"... object-oriented or functional programming with garbage collection ..."
     291You are really mixing apples and oranges here. Many C programmers have nothing agains object-oriented features, not even functional programming (C++ 11 adds
     292a bunch of features proving my point), but it's clear that most of them feel very strongly against automated garbage collection.
     293
     294"In many cases, C++ is often ..."
     295This sentence feels like it is coming out of nowhere.
     296
     297"... the polymorphic runtime-cost ..."
     298Is there any way to avoid that overhead? It's true it will make the compiler faster, but there are cases where the user might not want to pay for
     299the overhead at runtime. Is there a way to force the compiler to specialize the code?
     300
     301"... to write a type-safe Cforall wrapper malloc based ..."
     302That cannot be true in general. Malloc produces a pointer (of any type), given an integer (the size).
     303It looks like Cforall is assuming that the integer is the result of a call to sizeof (a good practice in C).
     304However, if that's the case, it should be explained.
     305
     306"... allows variable overloading ..."
     307How are conflict resolved? In other words, what happens when two variables could be used?
     308
     309"... reuses the generated structure declarations where appropriate."
     310This is too vague.
     311
     312"... have multiple outcomes, some exceptional."
     313Humm, I would say these two things are distinct. Let's just way that this way of presenting things is strange, I woulds ay that a function can either
     314return one or multiple values or throw an exception. Not that some of the values returned are "exceptional".
     315
     316"The type-resolver ..."
     317What's that? Type-checker? Type-inference?
     318
     319"... applies C conversions."
     320Noooo! That's exactly what leads to very subtle bugs. Is there any way to stop those conversions from happening?
     321
     322"The minimal cost ..."
     323In what regard? Runtime cost? How does the "resolver" know how expensive the conversions are?
     324
     325"z = 10 // mass assignments"
     326That stuff is completely unreadable. Why not introduce a new operator?
     327
     328"... roughly equivalent time ..."
     329Well, C++ looks faster to me.
     330
     331"... is restricted because the resolution does not using ..."
     332Did you mean, does not use?
     333
     334"... D and go are garbage collected ..."
     335Yes, but in D, the use of the GC is optional.
     336
     337"... while respecting the talent and skill of C programmers."
     338Are you implying that other approaches are not?
     339
     340"On the surface, the project may appear as a rehash of similar mechanisms in C++."
     341Absolutely.
     342
     343"... integration with C and its programmers ..."
     344Bold claim. What makes you think you are integrated with programmers? Number of users?
     345
     346"... inline annotation at polymorphic function call sites to create a template-specialization ..."
     347This should have been mentioned sooner. Plus conflating inlining and specialization is unfortunate.
     348Does "inline" also inline the function? Or does it only specialize the code?
     349If it also inline, that's a very unfortunate design. I might want to specialize the code, but without inlining ...
     350How do I specialize a recursive function?
  • doc/proposals/references.md

    rf7cb0bc ra5de33e  
    1717derived rvalue types such as pointer types may include qualifiers;
    1818`const int *` is a distinct type from `int *`, though the latter is safely
    19 convertable to the former.
     19convertible to the former.
    2020In general, any number of qualifiers can be safely added to the
    2121pointed-to-type of a pointer type, e.g. `int *` converts safely to
     
    2323`const volatile int *`.
    2424
    25 Since lvalues are precicely "addressable objects", in C, only lvalues can be
     25Since lvalues are precisely "addressable objects", in C, only lvalues can be
    2626used as the operand of the `&` address-of operator.
    2727Similarly, only modifiable lvalues may be used as the assigned-to
     
    147147call "lvalue of type `T`" as `T&`.
    148148There's also an obvious argument that lvalues of a (possibly-qualified) type
    149 `T` should be convertable to references of type `T`, where `T` is also
     149`T` should be convertible to references of type `T`, where `T` is also
    150150so-qualified (e.g. lvalue `int` to `int&`, lvalue `const char` to
    151151`const char&`).
    152152By similar arguments to pointer types, qualifiers should be addable to the
    153153referred-to type of a reference (e.g. `int&` to `const int&`).
    154 As a note, since pointer arithmetic is explictly not defined on `T&`,
     154As a note, since pointer arithmetic is explicitly not defined on `T&`,
    155155`restrict T&` should be allowable and would have alias-analysis rules that
    156156are actually comprehensible to mere mortals.
  • doc/user/Makefile

    rf7cb0bc ra5de33e  
    1212
    1313FIGURES = ${addsuffix .tex, \
     14EHMHierarchy \
    1415Cdecl \
    1516pointer1 \
  • doc/user/user.tex

    rf7cb0bc ra5de33e  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Fri Jun 16 12:00:01 2017
    14 %% Update Count     : 2433
     13%% Last Modified On : Sun Jul  2 09:49:56 2017
     14%% Update Count     : 2503
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    2525\usepackage{textcomp}
    2626\usepackage[latin1]{inputenc}
    27 % Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
    28 % removes it as a variable-name character so keyworks in variables are highlighted
    29 \DeclareTextCommandDefault{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}
    30 
    3127
    3228\usepackage{fullpage,times,comment}
     
    4844\renewcommand{\UrlFont}{\small\sf}
    4945
     46% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
     47% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
     48% AFTER HYPERREF.
     49\renewcommand{\_}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
     50\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
     51
    5052\setlength{\topmargin}{-0.45in}                                                 % move running title into header
    5153\setlength{\headsep}{0.25in}
     
    110112\renewcommand{\subsectionmark}[1]{\markboth{\thesubsection\quad #1}{\thesubsection\quad #1}}
    111113\pagenumbering{roman}
    112 %\linenumbers                                            % comment out to turn off line numbering
     114\linenumbers                                            % comment out to turn off line numbering
    113115
    114116\maketitle
     
    477479#endif // ! otype
    478480
    479 #include_next <bfd.h>                   §\C{// must have internal check for multiple expansion}§
     481#®include_next® <bfd.h>                 §\C{// must have internal check for multiple expansion}§
    480482
    481483#if defined( otype ) && defined( __CFA_BFD_H__ )        §\C{// reset only if set}§
     
    487489\label{f:InterpositionHeaderFile}
    488490\end{figure}
    489 
    490 
    491 \section{Declarations}
    492 \label{s:Declarations}
    493 
    494 C declaration syntax is notoriously confusing and error prone.
    495 For example, many C programmers are confused by a declaration as simple as:
    496 \begin{quote2}
    497 \begin{tabular}{@{}ll@{}}
    498 \begin{cfa}
    499 int * x[5]
    500 \end{cfa}
    501 &
    502 \raisebox{-0.75\totalheight}{\input{Cdecl}}
    503 \end{tabular}
    504 \end{quote2}
    505 Is this an array of 5 pointers to integers or a \Index{pointer} to an array of 5 integers?
    506 The fact this declaration is unclear to many C programmers means there are \Index{productivity} and \Index{safety} issues even for basic programs.
    507 Another example of confusion results from the fact that a routine name and its parameters are embedded within the return type, mimicking the way the return value is used at the routine's call site.
    508 For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
    509 \begin{cfa}
    510 int ®(*®f®())[®5®]® {...};                              §\C{definition}§
    511  ... ®(*®f®())[®3®]® += 1;                              §\C{usage}§
    512 \end{cfa}
    513 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
    514 While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice.
    515 
    516 \CFA provides its own type, variable and routine declarations, using a different syntax.
    517 The new declarations place qualifiers to the left of the base type, while C declarations place qualifiers to the right of the base type.
    518 In the following example, \R{red} is the base type and \B{blue} is qualifiers.
    519 The \CFA declarations move the qualifiers to the left of the base type, \ie move the blue to the left of the red, while the qualifiers have the same meaning but are ordered left to right to specify a variable's type.
    520 \begin{quote2}
    521 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    522 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    523 \begin{cfa}
    524 ß[5] *ß ®int® x1;
    525 ß* [5]ß ®int® x2;
    526 ß[* [5] int]ß f®( int p )®;
    527 \end{cfa}
    528 &
    529 \begin{cfa}
    530 ®int® ß*ß x1 ß[5]ß;
    531 ®int® ß(*ßx2ß)[5]ß;
    532 ßint (*ßf®( int p )®ß)[5]ß;
    533 \end{cfa}
    534 \end{tabular}
    535 \end{quote2}
    536 The only exception is \Index{bit field} specification, which always appear to the right of the base type.
    537 % Specifically, the character ©*© is used to indicate a pointer, square brackets ©[©\,©]© are used to represent an array or function return value, and parentheses ©()© are used to indicate a routine parameter.
    538 However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
    539 For instance, variables ©x© and ©y© of type \Index{pointer} to integer are defined in \CFA as follows:
    540 \begin{quote2}
    541 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    542 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    543 \begin{cfa}
    544 ®*® int x, y;
    545 \end{cfa}
    546 &
    547 \begin{cfa}
    548 int ®*®x, ®*®y;
    549 \end{cfa}
    550 \end{tabular}
    551 \end{quote2}
    552 The downside of this semantics is the need to separate regular and \Index{pointer} declarations:
    553 \begin{quote2}
    554 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    555 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    556 \begin{cfa}
    557 ®*® int x;
    558 int y;
    559 \end{cfa}
    560 &
    561 \begin{cfa}
    562 int ®*®x, y;
    563 
    564 \end{cfa}
    565 \end{tabular}
    566 \end{quote2}
    567 which is \Index{prescribing} a safety benefit.
    568 Other examples are:
    569 \begin{quote2}
    570 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
    571 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
    572 \begin{cfa}
    573 [ 5 ] int z;
    574 [ 5 ] * char w;
    575 * [ 5 ] double v;
    576 struct s {
    577         int f0:3;
    578         * int f1;
    579         [ 5 ] * int f2;
    580 };
    581 \end{cfa}
    582 &
    583 \begin{cfa}
    584 int z[ 5 ];
    585 char * w[ 5 ];
    586 double (* v)[ 5 ];
    587 struct s {
    588         int f0:3;
    589         int * f1;
    590         int * f2[ 5 ]
    591 };
    592 \end{cfa}
    593 &
    594 \begin{cfa}
    595 // array of 5 integers
    596 // array of 5 pointers to char
    597 // pointer to array of 5 doubles
    598 
    599 // common bit field syntax
    600 
    601 
    602 
    603 \end{cfa}
    604 \end{tabular}
    605 \end{quote2}
    606 
    607 All type qualifiers, \eg ©const©, ©volatile©, etc., are used in the normal way with the new declarations and also appear left to right, \eg:
    608 \begin{quote2}
    609 \begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
    610 \multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\
    611 \begin{cfa}
    612 const * const int x;
    613 const * [ 5 ] const int y;
    614 \end{cfa}
    615 &
    616 \begin{cfa}
    617 int const * const x;
    618 const int (* const y)[ 5 ]
    619 \end{cfa}
    620 &
    621 \begin{cfa}
    622 // const pointer to const integer
    623 // const pointer to array of 5 const integers
    624 \end{cfa}
    625 \end{tabular}
    626 \end{quote2}
    627 All declaration qualifiers, \eg ©extern©, ©static©, etc., are used in the normal way with the new declarations but can only appear at the start of a \CFA routine declaration,\footnote{\label{StorageClassSpecifier}
    628 The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}} \eg:
    629 \begin{quote2}
    630 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
    631 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
    632 \begin{cfa}
    633 extern [ 5 ] int x;
    634 static * const int y;
    635 \end{cfa}
    636 &
    637 \begin{cfa}
    638 int extern x[ 5 ];
    639 const int static * y;
    640 \end{cfa}
    641 &
    642 \begin{cfa}
    643 // externally visible array of 5 integers
    644 // internally visible pointer to constant int
    645 \end{cfa}
    646 \end{tabular}
    647 \end{quote2}
    648 
    649 The new declaration syntax can be used in other contexts where types are required, \eg casts and the pseudo-routine ©sizeof©:
    650 \begin{quote2}
    651 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    652 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    653 \begin{cfa}
    654 y = (®* int®)x;
    655 i = sizeof(®[ 5 ] * int®);
    656 \end{cfa}
    657 &
    658 \begin{cfa}
    659 y = (®int *®)x;
    660 i = sizeof(®int * [ 5 ]®);
    661 \end{cfa}
    662 \end{tabular}
    663 \end{quote2}
    664 
    665 Finally, new \CFA declarations may appear together with C declarations in the same program block, but cannot be mixed within a specific declaration.
    666 Therefore, a programmer has the option of either continuing to use traditional C declarations or take advantage of the new style.
    667 Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX systems.
    668 
    669 
    670 \section{Pointer/Reference}
    671 
    672 C provides a \newterm{pointer type};
    673 \CFA adds a \newterm{reference type}.
    674 These types may be derived from an object or routine type, called the \newterm{referenced type}.
    675 Objects of these types contain an \newterm{address}, which is normally a location in memory, but may also address memory-mapped registers in hardware devices.
    676 An integer constant expression with the value 0, or such an expression cast to type ©void *©, is called a \newterm{null-pointer constant}.\footnote{
    677 One way to conceptualize the null pointer is that no variable is placed at this address, so the null-pointer address can be used to denote an uninitialized pointer/reference object;
    678 \ie the null pointer is guaranteed to compare unequal to a pointer to any object or routine.}
    679 An address is \newterm{sound}, if it points to a valid memory location in scope, \ie within the program's execution-environment and has not been freed.
    680 Dereferencing an \newterm{unsound} address, including the null pointer, is \Index{undefined}, often resulting in a \Index{memory fault}.
    681 
    682 A program \newterm{object} is a region of data storage in the execution environment, the contents of which can represent values.
    683 In most cases, objects are located in memory at an address, and the variable name for an object is an implicit address to the object generated by the compiler and automatically dereferenced, as in:
    684 \begin{quote2}
    685 \begin{tabular}{@{}ll@{\hspace{2em}}l@{}}
    686 \begin{cfa}
    687 int x;
    688 x = 3;
    689 int y;
    690 y = x;
    691 \end{cfa}
    692 &
    693 \raisebox{-0.45\totalheight}{\input{pointer1}}
    694 &
    695 \begin{cfa}
    696 int * ®const® x = (int *)100
    697 *x = 3;                 // implicit dereference
    698 int * ®const® y = (int *)104;
    699 *y = *x;                // implicit dereference
    700 \end{cfa}
    701 \end{tabular}
    702 \end{quote2}
    703 where the right example is how the compiler logically interprets the variables in the left example.
    704 Since a variable name only points to one address during its lifetime, it is an \Index{immutable} \Index{pointer};
    705 hence, the implicit type of pointer variables ©x© and ©y© are constant pointers in the compiler interpretation.
    706 In general, variable addresses are stored in instructions instead of loaded from memory, and hence may not occupy storage.
    707 These approaches are contrasted in the following:
    708 \begin{quote2}
    709 \begin{tabular}{@{}l|l@{}}
    710 \multicolumn{1}{c|}{explicit variable address} & \multicolumn{1}{c}{implicit variable address} \\
    711 \hline
    712 \begin{cfa}
    713 lda             r1,100                  // load address of x
    714 ld               r2,(r1)                  // load value of x
    715 lda             r3,104                  // load address of y
    716 st               r2,(r3)                  // store x into y
    717 \end{cfa}
    718 &
    719 \begin{cfa}
    720 
    721 ld              r2,(100)                // load value of x
    722 
    723 st              r2,(104)                // store x into y
    724 \end{cfa}
    725 \end{tabular}
    726 \end{quote2}
    727 Finally, the immutable nature of a variable's address and the fact that there is no storage for the variable pointer means pointer assignment\index{pointer!assignment}\index{assignment!pointer} is impossible.
    728 Therefore, the expression ©x = y© has only one meaning, ©*x = *y©, \ie manipulate values, which is why explicitly writing the dereferences is unnecessary even though it occurs implicitly as part of \Index{instruction decoding}.
    729 
    730 A \Index{pointer}/\Index{reference} object is a generalization of an object variable-name, \ie a mutable address that can point to more than one memory location during its lifetime.
    731 (Similarly, an integer variable can contain multiple integer literals during its lifetime versus an integer constant representing a single literal during its lifetime, and like a variable name, may not occupy storage if the literal is embedded directly into instructions.)
    732 Hence, a pointer occupies memory to store its current address, and the pointer's value is loaded by dereferencing, \eg:
    733 \begin{quote2}
    734 \begin{tabular}{@{}l@{\hspace{2em}}l@{}}
    735 \begin{cfa}
    736 int x, y, ®*® p1, ®*® p2, ®**® p3;
    737 p1 = ®&®x;               // p1 points to x
    738 p2 = p1;                 // p2 points to x
    739 p1 = ®&®y;               // p1 points to y
    740 p3 = &p2;               // p3 points to p2
    741 \end{cfa}
    742 &
    743 \raisebox{-0.5\totalheight}{\input{pointer2.pstex_t}}
    744 \end{tabular}
    745 \end{quote2}
    746 
    747 Notice, an address has a \Index{duality}\index{address!duality}: a location in memory or the value at that location.
    748 In many cases, a compiler might be able to infer the best meaning for these two cases.
    749 For example, \Index*{Algol68}~\cite{Algol68} infers pointer dereferencing to select the best meaning for each pointer usage
    750 \begin{cfa}
    751 p2 = p1 + x;                                    §\C{// compiler infers *p2 = *p1 + x;}§
    752 \end{cfa}
    753 Algol68 infers the following dereferencing ©*p2 = *p1 + x©, because adding the arbitrary integer value in ©x© to the address of ©p1© and storing the resulting address into ©p2© is an unlikely operation.
    754 Unfortunately, automatic dereferencing does not work in all cases, and so some mechanism is necessary to fix incorrect choices.
    755 
    756 Rather than inferring dereference, most programming languages pick one implicit dereferencing semantics, and the programmer explicitly indicates the other to resolve address-duality.
    757 In C, objects of pointer type always manipulate the pointer object's address:
    758 \begin{cfa}
    759 p1 = p2;                                                §\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}§
    760 p2 = p1 + x;                                    §\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}§
    761 \end{cfa}
    762 even though the assignment to ©p2© is likely incorrect, and the programmer probably meant:
    763 \begin{cfa}
    764 p1 = p2;                                                §\C{// pointer address assignment}§
    765 ®*®p2 = ®*®p1 + x;                              §\C{// pointed-to value assignment / operation}§
    766 \end{cfa}
    767 The C semantics work well for situations where manipulation of addresses is the primary meaning and data is rarely accessed, such as storage management (©malloc©/©free©).
    768 
    769 However, in most other situations, the pointed-to value is requested more often than the pointer address.
    770 \begin{cfa}
    771 *p2 = ((*p1 + *p2) * (**p3 - *p1)) / (**p3 - 15);
    772 \end{cfa}
    773 In this case, it is tedious to explicitly write the dereferencing, and error prone when pointer arithmetic is allowed.
    774 It is better to have the compiler generate the dereferencing and have no implicit pointer arithmetic:
    775 \begin{cfa}
    776 p2 = ((p1 + p2) * (p3 - p1)) / (p3 - 15);
    777 \end{cfa}
    778 
    779 To support this common case, a reference type is introduced in \CFA, denoted by ©&©, which is the opposite dereference semantics to a pointer type, making the value at the pointed-to location the implicit semantics for dereferencing (similar but not the same as \CC \Index{reference type}s).
    780 \begin{cfa}
    781 int x, y, ®&® r1, ®&® r2, ®&&® r3;
    782 ®&®r1 = &x;                                             §\C{// r1 points to x}§
    783 ®&®r2 = &r1;                                    §\C{// r2 points to x}§
    784 ®&®r1 = &y;                                             §\C{// r1 points to y}§
    785 ®&&®r3 = ®&®&r2;                                §\C{// r3 points to r2}§
    786 r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); §\C{// implicit dereferencing}§
    787 \end{cfa}
    788 Except for auto-dereferencing by the compiler, this reference example is the same as the previous pointer example.
    789 Hence, a reference behaves like the variable name for the current variable it is pointing-to.
    790 One way to conceptualize a reference is via a rewrite rule, where the compiler inserts a dereference operator before the reference variable for each reference qualifier in a declaration, so the previous example becomes:
    791 \begin{cfa}
    792 ®*®r2 = ((®*®r1 + ®*®r2) ®*® (®**®r3 - ®*®r1)) / (®**®r3 - 15);
    793 \end{cfa}
    794 When a reference operation appears beside a dereference operation, \eg ©&*©, they cancel out.
    795 However, in C, the cancellation always yields a value (\Index{rvalue}).\footnote{
    796 The unary ©&© operator yields the address of its operand.
    797 If the operand has type ``type'', the result has type ``pointer to type''.
    798 If the operand is the result of a unary ©*© operator, neither that operator nor the ©&© operator is evaluated and the result is as if both were omitted, except that the constraints on the operators still apply and the result is not an lvalue.~\cite[\S~6.5.3.2--3]{C11}}
    799 For a \CFA reference type, the cancellation on the left-hand side of assignment leaves the reference as an address (\Index{lvalue}):
    800 \begin{cfa}
    801 (&®*®)r1 = &x;                                  §\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}§
    802 \end{cfa}
    803 Similarly, the address of a reference can be obtained for assignment or computation (\Index{rvalue}):
    804 \begin{cfa}
    805 (&(&®*®)®*®)r3 = &(&®*®)r2;             §\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}§
    806 \end{cfa}
    807 Cancellation\index{cancellation!pointer/reference}\index{pointer!cancellation} works to arbitrary depth.
    808 
    809 Fundamentally, pointer and reference objects are functionally interchangeable because both contain addresses.
    810 \begin{cfa}
    811 int x, *p1 = &x, **p2 = &p1, ***p3 = &p2,
    812                  &r1 = x,    &&r2 = r1,   &&&r3 = r2;
    813 ***p3 = 3;                                              §\C{// change x}§
    814 r3 = 3;                                                 §\C{// change x, ***r3}§
    815 **p3 = ...;                                             §\C{// change p1}§
    816 &r3 = ...;                                              §\C{// change r1, (\&*)**r3, 1 cancellation}§
    817 *p3 = ...;                                              §\C{// change p2}§
    818 &&r3 = ...;                                             §\C{// change r2, (\&(\&*)*)*r3, 2 cancellations}§
    819 &&&r3 = p3;                                             §\C{// change r3 to p3, (\&(\&(\&*)*)*)r3, 3 cancellations}§
    820 \end{cfa}
    821 Furthermore, both types are equally performant, as the same amount of dereferencing occurs for both types.
    822 Therefore, the choice between them is based solely on whether the address is dereferenced frequently or infrequently, which dictates the amount of implicit dereferencing aid from the compiler.
    823 
    824 As for a pointer type, a reference type may have qualifiers:
    825 \begin{cfa}
    826 const int cx = 5;                                       §\C{// cannot change cx;}§
    827 const int & cr = cx;                            §\C{// cannot change what cr points to}§
    828 ®&®cr = &cx;                                            §\C{// can change cr}§
    829 cr = 7;                                                         §\C{// error, cannot change cx}§
    830 int & const rc = x;                                     §\C{// must be initialized}§
    831 ®&®rc = &x;                                                     §\C{// error, cannot change rc}§
    832 const int & const crc = cx;                     §\C{// must be initialized}§
    833 crc = 7;                                                        §\C{// error, cannot change cx}§
    834 ®&®crc = &cx;                                           §\C{// error, cannot change crc}§
    835 \end{cfa}
    836 Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be the null pointer unless an arbitrary pointer is coerced\index{coercion} into the reference}:
    837 \begin{cfa}
    838 int & const cr = *0;                            §\C{// where 0 is the int * zero}§
    839 \end{cfa}
    840 Note, constant reference-types do not prevent \Index{addressing errors} because of explicit storage-management:
    841 \begin{cfa}
    842 int & const cr = *malloc();
    843 cr = 5;
    844 free( &cr );
    845 cr = 7;                                                         §\C{// unsound pointer dereference}§
    846 \end{cfa}
    847 
    848 The position of the ©const© qualifier \emph{after} the pointer/reference qualifier causes confuse for C programmers.
    849 The ©const© qualifier cannot be moved before the pointer/reference qualifier for C style-declarations;
    850 \CFA-style declarations (see \VRef{s:Declarations}) attempt to address this issue:
    851 \begin{quote2}
    852 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    853 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    854 \begin{cfa}
    855 ®const® * ®const® * const int ccp;
    856 ®const® & ®const® & const int ccr;
    857 \end{cfa}
    858 &
    859 \begin{cfa}
    860 const int * ®const® * ®const® ccp;
    861 
    862 \end{cfa}
    863 \end{tabular}
    864 \end{quote2}
    865 where the \CFA declaration is read left-to-right.
    866 
    867 Finally, like pointers, references are usable and composable with other type operators and generators.
    868 \begin{cfa}
    869 int w, x, y, z, & ar[3] = { x, y, z }; §\C{// initialize array of references}§
    870 &ar[1] = &w;                                            §\C{// change reference array element}§
    871 typeof( ar[1] ) p;                                      §\C{// (gcc) is int, i.e., the type of referenced object}§
    872 typeof( &ar[1] ) q;                                     §\C{// (gcc) is int \&, i.e., the type of reference}§
    873 sizeof( ar[1] ) == sizeof( int );       §\C{// is true, i.e., the size of referenced object}§
    874 sizeof( &ar[1] ) == sizeof( int *)      §\C{// is true, i.e., the size of a reference}§
    875 \end{cfa}
    876 
    877 In contrast to \CFA reference types, \Index*[C++]{\CC{}}'s reference types are all ©const© references, preventing changes to the reference address, so only value assignment is possible, which eliminates half of the \Index{address duality}.
    878 Also, \CC does not allow \Index{array}s\index{array!reference} of reference\footnote{
    879 The reason for disallowing arrays of reference is unknown, but possibly comes from references being ethereal (like a textual macro), and hence, replaceable by the referant object.}
    880 \Index*{Java}'s reference types to objects (all Java objects are on the heap) are like C pointers, which always manipulate the address, and there is no (bit-wise) object assignment, so objects are explicitly cloned by shallow or deep copying, which eliminates half of the address duality.
    881 
    882 
    883 \subsection{Initialization}
    884 
    885 \Index{Initialization} is different than \Index{assignment} because initialization occurs on the empty (uninitialized) storage on an object, while assignment occurs on possibly initialized storage of an object.
    886 There are three initialization contexts in \CFA: declaration initialization, argument/parameter binding, return/temporary binding.
    887 Because the object being initialized has no value, there is only one meaningful semantics with respect to address duality: it must mean address as there is no pointed-to value.
    888 In contrast, the left-hand side of assignment has an address that has a duality.
    889 Therefore, for pointer/reference initialization, the initializing value must be an address not a value.
    890 \begin{cfa}
    891 int * p = &x;                                           §\C{// assign address of x}§
    892 ®int * p = x;®                                          §\C{// assign value of x}§
    893 int & r = x;                                            §\C{// must have address of x}§
    894 \end{cfa}
    895 Like the previous example with C pointer-arithmetic, it is unlikely assigning the value of ©x© into a pointer is meaningful (again, a warning is usually given).
    896 Therefore, for safety, this context requires an address, so it is superfluous to require explicitly taking the address of the initialization object, even though the type is incorrect.
    897 Note, this is strictly a convenience and safety feature for a programmer.
    898 Hence, \CFA allows ©r© to be assigned ©x© because it infers a reference for ©x©, by implicitly inserting a address-of operator, ©&©, and it is an error to put an ©&© because the types no longer match due to the implicit dereference.
    899 Unfortunately, C allows ©p© to be assigned with ©&x© (address) or ©x© (value), but most compilers warn about the latter assignment as being potentially incorrect.
    900 Similarly, when a reference type is used for a parameter/return type, the call-site argument does not require a reference operator for the same reason.
    901 \begin{cfa}
    902 int & f( int & r );                                     §\C{// reference parameter and return}§
    903 z = f( x ) + f( y );                            §\C{// reference operator added, temporaries needed for call results}§
    904 \end{cfa}
    905 Within routine ©f©, it is possible to change the argument by changing the corresponding parameter, and parameter ©r© can be locally reassigned within ©f©.
    906 Since operator routine ©?+?© takes its arguments by value, the references returned from ©f© are used to initialize compiler generated temporaries with value semantics that copy from the references.
    907 \begin{cfa}
    908 int temp1 = f( x ), temp2 = f( y );
    909 z = temp1 + temp2;
    910 \end{cfa}
    911 This \Index{implicit referencing} is crucial for reducing the syntactic burden for programmers when using references;
    912 otherwise references have the same syntactic  burden as pointers in these contexts.
    913 
    914 When a pointer/reference parameter has a ©const© value (immutable), it is possible to pass literals and expressions.
    915 \begin{cfa}
    916 void f( ®const® int & cr );
    917 void g( ®const® int * cp );
    918 f( 3 );                   g( ®&®3 );
    919 f( x + y );             g( ®&®(x + y) );
    920 \end{cfa}
    921 Here, the compiler passes the address to the literal 3 or the temporary for the expression ©x + y©, knowing the argument cannot be changed through the parameter.
    922 The ©&© before the constant/expression for the pointer-type parameter (©g©) is a \CFA extension necessary to type match and is a common requirement before a variable in C (\eg ©scanf©).
    923 Importantly, ©&3© may not be equal to ©&3©, where the references occur across calls because the temporaries maybe different on each call.
    924 
    925 \CFA \emph{extends} this semantics to a mutable pointer/reference parameter, and the compiler implicitly creates the necessary temporary (copying the argument), which is subsequently pointed-to by the reference parameter and can be changed.\footnote{
    926 If whole program analysis is possible, and shows the parameter is not assigned, \ie it is ©const©, the temporary is unnecessary.}
    927 \begin{cfa}
    928 void f( int & r );
    929 void g( int * p );
    930 f( 3 );                   g( ®&®3 );            §\C{// compiler implicit generates temporaries}§
    931 f( x + y );             g( ®&®(x + y) );        §\C{// compiler implicit generates temporaries}§
    932 \end{cfa}
    933 Essentially, there is an implicit \Index{rvalue} to \Index{lvalue} conversion in this case.\footnote{
    934 This conversion attempts to address the \newterm{const hell} problem, when the innocent addition of a ©const© qualifier causes a cascade of type failures, requiring an unknown number of additional ©const© qualifiers, until it is discovered a ©const© qualifier cannot be added and all the ©const© qualifiers must be removed.}
    935 The implicit conversion allows seamless calls to any routine without having to explicitly name/copy the literal/expression to allow the call.
    936 
    937 %\CFA attempts to handle pointers and references in a uniform, symmetric manner.
    938 Finally, C handles \Index{routine object}s in an inconsistent way.
    939 A routine object is both a pointer and a reference (\Index{particle and wave}).
    940 \begin{cfa}
    941 void f( int i );
    942 void (*fp)( int );                                      §\C{// routine pointer}§
    943 fp = f;                                                         §\C{// reference initialization}§
    944 fp = &f;                                                        §\C{// pointer initialization}§
    945 fp = *f;                                                        §\C{// reference initialization}§
    946 fp(3);                                                          §\C{// reference invocation}§
    947 (*fp)(3);                                                       §\C{// pointer invocation}§
    948 \end{cfa}
    949 While C's treatment of routine objects has similarity to inferring a reference type in initialization contexts, the examples are assignment not initialization, and all possible forms of assignment are possible (©f©, ©&f©, ©*f©) without regard for type.
    950 Instead, a routine object should be referenced by a ©const© reference:
    951 \begin{cfa}
    952 ®const® void (®&® fr)( int ) = f;       §\C{// routine reference}§
    953 fr = ...                                                        §\C{// error, cannot change code}§
    954 &fr = ...;                                                      §\C{// changing routine reference}§
    955 fr( 3 );                                                        §\C{// reference call to f}§
    956 (*fr)(3);                                                       §\C{// error, incorrect type}§
    957 \end{cfa}
    958 because the value of the routine object is a routine literal, \ie the routine code is normally immutable during execution.\footnote{
    959 Dynamic code rewriting is possible but only in special circumstances.}
    960 \CFA allows this additional use of references for routine objects in an attempt to give a more consistent meaning for them.
    961 
    962 
    963 \subsection{Address-of Semantics}
    964 
    965 In C, ©&E© is an rvalue for any expression ©E©.
    966 \CFA extends the ©&© (address-of) operator as follows:
    967 \begin{itemize}
    968 \item
    969 if ©R© is an \Index{rvalue} of type ©T &$_1$...&$_r$© where $r \ge 1$ references (©&© symbols) than ©&R© has type ©T ®*®&$_{\color{red}2}$...&$_{\color{red}r}$©, \ie ©T© pointer with $r-1$ references (©&© symbols).
    970 
    971 \item
    972 if ©L© is an \Index{lvalue} of type ©T &$_1$...&$_l$© where $l \ge 0$ references (©&© symbols) then ©&L© has type ©T ®*®&$_{\color{red}1}$...&$_{\color{red}l}$©, \ie ©T© pointer with $l$ references (©&© symbols).
    973 \end{itemize}
    974 The following example shows the first rule applied to different \Index{rvalue} contexts:
    975 \begin{cfa}
    976 int x, * px, ** ppx, *** pppx, **** ppppx;
    977 int & rx = x, && rrx = rx, &&& rrrx = rrx ;
    978 x = rrrx;               // rrrx is an lvalue with type int &&& (equivalent to x)
    979 px = &rrrx;             // starting from rrrx, &rrrx is an rvalue with type int *&&& (&x)
    980 ppx = &&rrrx;   // starting from &rrrx, &&rrrx is an rvalue with type int **&& (&rx)
    981 pppx = &&&rrrx; // starting from &&rrrx, &&&rrrx is an rvalue with type int ***& (&rrx)
    982 ppppx = &&&&rrrx; // starting from &&&rrrx, &&&&rrrx is an rvalue with type int **** (&rrrx)
    983 \end{cfa}
    984 The following example shows the second rule applied to different \Index{lvalue} contexts:
    985 \begin{cfa}
    986 int x, * px, ** ppx, *** pppx;
    987 int & rx = x, && rrx = rx, &&& rrrx = rrx ;
    988 rrrx = 2;               // rrrx is an lvalue with type int &&& (equivalent to x)
    989 &rrrx = px;             // starting from rrrx, &rrrx is an rvalue with type int *&&& (rx)
    990 &&rrrx = ppx;   // starting from &rrrx, &&rrrx is an rvalue with type int **&& (rrx)
    991 &&&rrrx = pppx; // starting from &&rrrx, &&&rrrx is an rvalue with type int ***& (rrrx)
    992 \end{cfa}
    993 
    994 
    995 \subsection{Conversions}
    996 
    997 C provides a basic implicit conversion to simplify variable usage:
    998 \begin{enumerate}
    999 \setcounter{enumi}{-1}
    1000 \item
    1001 lvalue to rvalue conversion: ©cv T© converts to ©T©, which allows implicit variable dereferencing.
    1002 \begin{cfa}
    1003 int x;
    1004 x + 1;                  // lvalue variable (int) converts to rvalue for expression
    1005 \end{cfa}
    1006 An rvalue has no type qualifiers (©cv©), so the lvalue qualifiers are dropped.
    1007 \end{enumerate}
    1008 \CFA provides three new implicit conversion for reference types to simplify reference usage.
    1009 \begin{enumerate}
    1010 \item
    1011 reference to rvalue conversion: ©cv T &© converts to ©T©, which allows implicit reference dereferencing.
    1012 \begin{cfa}
    1013 int x, &r = x, f( int p );
    1014 x = ®r® + f( ®r® );  // lvalue reference converts to rvalue
    1015 \end{cfa}
    1016 An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped.
    1017 
    1018 \item
    1019 lvalue to reference conversion: \lstinline[deletekeywords={lvalue}]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
    1020 \begin{cfa}
    1021 int x, &r = ®x®, f( int & p ); // lvalue variable (int) convert to reference (int &)
    1022 f( ®x® );               // lvalue variable (int) convert to reference (int &)
    1023 \end{cfa}
    1024 Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost.
    1025 Conversion can expand a type, where ©cv1© $>$ ©cv2©, \eg passing a ©const volatile int© to an ©int &©, which has high cost (\Index{warning});
    1026 furthermore, if ©cv1© has ©const© but not ©cv2©, a temporary variable is created to preserve the immutable lvalue.
    1027 
    1028 \item
    1029 rvalue to reference conversion: ©T© converts to ©cv T &©, which allows binding references to temporaries.
    1030 \begin{cfa}
    1031 int x, & f( int & p );
    1032 f( ®x + 3® );   // rvalue parameter (int) implicitly converts to lvalue temporary reference (int &)
    1033 ®&f®(...) = &x; // rvalue result (int &) implicitly converts to lvalue temporary reference (int &)
    1034 \end{cfa}
    1035 In both case, modifications to the temporary are inaccessible (\Index{warning}).
    1036 Conversion expands the temporary-type with ©cv©, which is low cost since the temporary is inaccessible.
    1037 \end{enumerate}
    1038 
    1039 
    1040 \begin{comment}
    1041 From: Richard Bilson <rcbilson@gmail.com>
    1042 Date: Wed, 13 Jul 2016 01:58:58 +0000
    1043 Subject: Re: pointers / references
    1044 To: "Peter A. Buhr" <pabuhr@plg2.cs.uwaterloo.ca>
    1045 
    1046 As a general comment I would say that I found the section confusing, as you move back and forth
    1047 between various real and imagined programming languages. If it were me I would rewrite into two
    1048 subsections, one that specifies precisely the syntax and semantics of reference variables and
    1049 another that provides the rationale.
    1050 
    1051 I don't see any obvious problems with the syntax or semantics so far as I understand them. It's not
    1052 obvious that the description you're giving is complete, but I'm sure you'll find the special cases
    1053 as you do the implementation.
    1054 
    1055 My big gripes are mostly that you're not being as precise as you need to be in your terminology, and
    1056 that you say a few things that aren't actually true even though I generally know what you mean.
    1057 
    1058 20 C provides a pointer type; CFA adds a reference type. Both types contain an address, which is normally a
    1059 21 location in memory.
    1060 
    1061 An address is not a location in memory; an address refers to a location in memory. Furthermore it
    1062 seems weird to me to say that a type "contains" an address; rather, objects of that type do.
    1063 
    1064 21 Special addresses are used to denote certain states or access co-processor memory. By
    1065 22 convention, no variable is placed at address 0, so addresses like 0, 1, 2, 3 are often used to denote no-value
    1066 23 or other special states.
    1067 
    1068 This isn't standard C at all. There has to be one null pointer representation, but it doesn't have
    1069 to be a literal zero representation and there doesn't have to be more than one such representation.
    1070 
    1071 23 Often dereferencing a special state causes a memory fault, so checking is necessary
    1072 24 during execution.
    1073 
    1074 I don't see the connection between the two clauses here. I feel like if a bad pointer will not cause
    1075 a memory fault then I need to do more checking, not less.
    1076 
    1077 24 If the programming language assigns addresses, a program's execution is sound, \ie all
    1078 25 addresses are to valid memory locations.
    1079 
    1080 You haven't said what it means to "assign" an address, but if I use my intuitive understanding of
    1081 the term I don't see how this can be true unless you're assuming automatic storage management.
    1082 
    1083 1 Program variables are implicit pointers to memory locations generated by the compiler and automatically
    1084 2 dereferenced, as in:
    1085 
    1086 There is no reason why a variable needs to have a location in memory, and indeed in a typical
    1087 program many variables will not. In standard terminology an object identifier refers to data in the
    1088 execution environment, but not necessarily in memory.
    1089 
    1090 13 A pointer/reference is a generalization of a variable name, \ie a mutable address that can point to more
    1091 14 than one memory location during its lifetime.
    1092 
    1093 I feel like you're off the reservation here. In my world there are objects of pointer type, which
    1094 seem to be what you're describing here, but also pointer values, which can be stored in an object of
    1095 pointer type but don't necessarily have to be. For example, how would you describe the value denoted
    1096 by "&main" in a C program? I would call it a (function) pointer, but that doesn't satisfy your
    1097 definition.
    1098 
    1099 16 not occupy storage as the literal is embedded directly into instructions.) Hence, a pointer occupies memory
    1100 17 to store its current address, and the pointer's value is loaded by dereferencing, e.g.:
    1101 
    1102 As with my general objection regarding your definition of variables, there is no reason why a
    1103 pointer variable (object of pointer type) needs to occupy memory.
    1104 
    1105 21 p2 = p1 + x; // compiler infers *p2 = *p1 + x;
    1106 
    1107 What language are we in now?
    1108 
    1109 24 pointer usage. However, in C, the following cases are ambiguous, especially with pointer arithmetic:
    1110 25 p1 = p2; // p1 = p2 or *p1 = *p2
    1111 
    1112 This isn't ambiguous. it's defined to be the first option.
    1113 
    1114 26 p1 = p1 + 1; // p1 = p1 + 1 or *p1 = *p1 + 1
    1115 
    1116 Again, this statement is not ambiguous.
    1117 
    1118 13 example. Hence, a reference behaves like the variable name for the current variable it is pointing-to. The
    1119 14 simplest way to understand a reference is to imagine the compiler inserting a dereference operator before
    1120 15 the reference variable for each reference qualifier in a declaration, e.g.:
    1121 
    1122 It's hard for me to understand who the audience for this part is. I think a practical programmer is
    1123 likely to be satisfied with "a reference behaves like the variable name for the current variable it
    1124 is pointing-to," maybe with some examples. Your "simplest way" doesn't strike me as simpler than
    1125 that. It feels like you're trying to provide a more precise definition for the semantics of
    1126 references, but it isn't actually precise enough to be a formal specification. If you want to
    1127 express the semantics of references using rewrite rules that's a great way to do it, but lay the
    1128 rules out clearly, and when you're showing an example of rewriting keep your
    1129 references/pointers/values separate (right now, you use \eg "r3" to mean a reference, a pointer,
    1130 and a value).
    1131 
    1132 24 Cancellation works to arbitrary depth, and pointer and reference values are interchangeable because both
    1133 25 contain addresses.
    1134 
    1135 Except they're not interchangeable, because they have different and incompatible types.
    1136 
    1137 40 Interestingly, C++ deals with the address duality by making the pointed-to value the default, and prevent-
    1138 41 ing changes to the reference address, which eliminates half of the duality. Java deals with the address duality
    1139 42 by making address assignment the default and requiring field assignment (direct or indirect via methods),
    1140 43 \ie there is no builtin bit-wise or method-wise assignment, which eliminates half of the duality.
    1141 
    1142 I can follow this but I think that's mostly because I already understand what you're trying to
    1143 say. I don't think I've ever heard the term "method-wise assignment" and I don't see you defining
    1144 it. Furthermore Java does have value assignment of basic (non-class) types, so your summary here
    1145 feels incomplete. (If it were me I'd drop this paragraph rather than try to save it.)
    1146 
    1147 11 Hence, for type & const, there is no pointer assignment, so &rc = &x is disallowed, and the address value
    1148 12 cannot be 0 unless an arbitrary pointer is assigned to the reference.
    1149 
    1150 Given the pains you've taken to motivate every little bit of the semantics up until now, this last
    1151 clause ("the address value cannot be 0") comes out of the blue. It seems like you could have
    1152 perfectly reasonable semantics that allowed the initialization of null references.
    1153 
    1154 12 In effect, the compiler is managing the
    1155 13 addresses for type & const not the programmer, and by a programming discipline of only using references
    1156 14 with references, address errors can be prevented.
    1157 
    1158 Again, is this assuming automatic storage management?
    1159 
    1160 18 rary binding. For reference initialization (like pointer), the initializing value must be an address (lvalue) not
    1161 19 a value (rvalue).
    1162 
    1163 This sentence appears to suggest that an address and an lvalue are the same thing.
    1164 
    1165 20 int * p = &x; // both &x and x are possible interpretations
    1166 
    1167 Are you saying that we should be considering "x" as a possible interpretation of the initializer
    1168 "&x"? It seems to me that this expression has only one legitimate interpretation in context.
    1169 
    1170 21 int & r = x; // x unlikely interpretation, because of auto-dereferencing
    1171 
    1172 You mean, we can initialize a reference using an integer value? Surely we would need some sort of
    1173 cast to induce that interpretation, no?
    1174 
    1175 22 Hence, the compiler implicitly inserts a reference operator, &, before the initialization expression.
    1176 
    1177 But then the expression would have pointer type, which wouldn't be compatible with the type of r.
    1178 
    1179 22 Similarly,
    1180 23 when a reference is used for a parameter/return type, the call-site argument does not require a reference
    1181 24 operator.
    1182 
    1183 Furthermore, it would not be correct to use a reference operator.
    1184 
    1185 45 The implicit conversion allows
    1186 1 seamless calls to any routine without having to explicitly name/copy the literal/expression to allow the call.
    1187 2 While C' attempts to handle pointers and references in a uniform, symmetric manner, C handles routine
    1188 3 variables in an inconsistent way: a routine variable is both a pointer and a reference (particle and wave).
    1189 
    1190 After all this talk of how expressions can have both pointer and value interpretations, you're
    1191 disparaging C because it has expressions that have both pointer and value interpretations?
    1192 
    1193 On Sat, Jul 9, 2016 at 4:18 PM Peter A. Buhr <pabuhr@plg.uwaterloo.ca> wrote:
    1194 > Aaron discovered a few places where "&"s are missing and where there are too many "&", which are
    1195 > corrected in the attached updated. None of the text has changed, if you have started reading
    1196 > already.
    1197 \end{comment}
    1198 
    1199 
    1200 \section{Routine Definition}
    1201 
    1202 \CFA also supports a new syntax for routine definition, as well as \Celeven and K\&R routine syntax.
    1203 The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, \eg:
    1204 \begin{cfa}
    1205 ®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) {
    1206         §\emph{routine body}§
    1207 }
    1208 \end{cfa}
    1209 where routine ©f© has three output (return values) and three input parameters.
    1210 Existing C syntax cannot be extended with multiple return types because it is impossible to embed a single routine name within multiple return type specifications.
    1211 
    1212 In detail, the brackets, ©[]©, enclose the result type, where each return value is named and that name is a local variable of the particular return type.\footnote{
    1213 \Index*{Michael Tiemann}, with help from \Index*{Doug Lea}, provided named return values in g++, circa 1989.}
    1214 The value of each local return variable is automatically returned at routine termination.
    1215 Declaration qualifiers can only appear at the start of a routine definition, \eg:
    1216 \begin{cfa}
    1217 ®extern® [ int x ] g( int y ) {§\,§}
    1218 \end{cfa}
    1219 Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified;
    1220 in both cases the type is assumed to be void as opposed to old style C defaults of int return type and unknown parameter types, respectively, as in:
    1221 \begin{cfa}
    1222 [§\,§] g();                                                     §\C{// no input or output parameters}§
    1223 [ void ] g( void );                                     §\C{// no input or output parameters}§
    1224 \end{cfa}
    1225 
    1226 Routine f is called as follows:
    1227 \begin{cfa}
    1228 [ i, j, ch ] = f( 3, 'a', ch );
    1229 \end{cfa}
    1230 The list of return values from f and the grouping on the left-hand side of the assignment is called a \newterm{return list} and discussed in Section 12.
    1231 
    1232 \CFA style declarations cannot be used to declare parameters for K\&R style routine definitions because of the following ambiguity:
    1233 \begin{cfa}
    1234 int (*f(x))[ 5 ] int x; {}
    1235 \end{cfa}
    1236 The string ``©int (*f(x))[ 5 ]©'' declares a K\&R style routine of type returning a pointer to an array of 5 integers, while the string ``©[ 5 ] int x©'' declares a \CFA style parameter x of type array of 5 integers.
    1237 Since the strings overlap starting with the open bracket, ©[©, there is an ambiguous interpretation for the string.
    1238 As well, \CFA-style declarations cannot be used to declare parameters for C-style routine-definitions because of the following ambiguity:
    1239 \begin{cfa}
    1240 typedef int foo;
    1241 int f( int (* foo) );                           §\C{// foo is redefined as a parameter name}§
    1242 \end{cfa}
    1243 The string ``©int (* foo)©'' declares a C-style named-parameter of type pointer to an integer (the parenthesis are superfluous), while the same string declares a \CFA style unnamed parameter of type routine returning integer with unnamed parameter of type pointer to foo.
    1244 The redefinition of a type name in a parameter list is the only context in C where the character ©*© can appear to the left of a type name, and \CFA relies on all type qualifier characters appearing to the right of the type name.
    1245 The inability to use \CFA declarations in these two contexts is probably a blessing because it precludes programmers from arbitrarily switching between declarations forms within a declaration contexts.
    1246 
    1247 C-style declarations can be used to declare parameters for \CFA style routine definitions, \eg:
    1248 \begin{cfa}
    1249 [ int ] f( * int, int * );                      §\C{// returns an integer, accepts 2 pointers to integers}§
    1250 [ * int, int * ] f( int );                      §\C{// returns 2 pointers to integers, accepts an integer}§
    1251 \end{cfa}
    1252 The reason for allowing both declaration styles in the new context is for backwards compatibility with existing preprocessor macros that generate C-style declaration-syntax, as in:
    1253 \begin{cfa}
    1254 #define ptoa( n, d ) int (*n)[ d ]
    1255 int f( ptoa( p, 5 ) ) ...                       §\C{// expands to int f( int (*p)[ 5 ] )}§
    1256 [ int ] f( ptoa( p, 5 ) ) ...           §\C{// expands to [ int ] f( int (*p)[ 5 ] )}§
    1257 \end{cfa}
    1258 Again, programmers are highly encouraged to use one declaration form or the other, rather than mixing the forms.
    1259 
    1260 
    1261 \subsection{Named Return Values}
    1262 
    1263 \Index{Named return values} handle the case where it is necessary to define a local variable whose value is then returned in a ©return© statement, as in:
    1264 \begin{cfa}
    1265 int f() {
    1266         int x;
    1267         ... x = 0; ... x = y; ...
    1268         return x;
    1269 }
    1270 \end{cfa}
    1271 Because the value in the return variable is automatically returned when a \CFA routine terminates, the ©return© statement \emph{does not} contain an expression, as in:
    1272 \newline
    1273 \begin{minipage}{\linewidth}
    1274 \begin{cfa}
    1275 ®[ int x, int y ]® f() {
    1276         int z;
    1277         ... x = 0; ... y = z; ...
    1278         ®return;®                                                       §\C{// implicitly return x, y}§
    1279 }
    1280 \end{cfa}
    1281 \end{minipage}
    1282 \newline
    1283 When the return is encountered, the current values of ©x© and ©y© are returned to the calling routine.
    1284 As well, ``falling off the end'' of a routine without a ©return© statement is permitted, as in:
    1285 \begin{cfa}
    1286 [ int x, int y ] f() {
    1287         ...
    1288 }                                                                               §\C{// implicitly return x, y}§
    1289 \end{cfa}
    1290 In this case, the current values of ©x© and ©y© are returned to the calling routine just as if a ©return© had been encountered.
    1291 
    1292 Named return values may be used in conjunction with named parameter values;
    1293 specifically, a return and parameter can have the same name.
    1294 \begin{cfa}
    1295 [ int x, int y ] f( int, x, int y ) {
    1296         ...
    1297 }                                                                               §\C{// implicitly return x, y}§
    1298 \end{cfa}
    1299 This notation allows the compiler to eliminate temporary variables in nested routine calls.
    1300 \begin{cfa}
    1301 [ int x, int y ] f( int, x, int y );    §\C{// prototype declaration}§
    1302 int a, b;
    1303 [a, b] = f( f( f( a, b ) ) );
    1304 \end{cfa}
    1305 While the compiler normally ignores parameters names in prototype declarations, here they are used to eliminate temporary return-values by inferring that the results of each call are the inputs of the next call, and ultimately, the left-hand side of the assignment.
    1306 Hence, even without the body of routine ©f© (separate compilation), it is possible to perform a global optimization across routine calls.
    1307 The compiler warns about naming inconsistencies between routine prototype and definition in this case, and behaviour is \Index{undefined} if the programmer is inconsistent.
    1308 
    1309 
    1310 \subsection{Routine Prototype}
    1311 
    1312 The syntax of the new routine prototype declaration follows directly from the new routine definition syntax;
    1313 as well, parameter names are optional, \eg:
    1314 \begin{cfa}
    1315 [ int x ] f ();                                                 §\C{// returning int with no parameters}§
    1316 [ * int ] g (int y);                                    §\C{// returning pointer to int with int parameter}§
    1317 [ ] h ( int, char );                                    §\C{// returning no result with int and char parameters}§
    1318 [ * int, int ] j ( int );                               §\C{// returning pointer to int and int, with int parameter}§
    1319 \end{cfa}
    1320 This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
    1321 It is possible to declare multiple routine-prototypes in a single declaration, but the entire type specification is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:Declarations}), \eg:
    1322 \begin{quote2}
    1323 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    1324 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    1325 \begin{cfa}
    1326 [ int ] f( int ), g;
    1327 \end{cfa}
    1328 &
    1329 \begin{cfa}
    1330 int f( int ), g( int );
    1331 \end{cfa}
    1332 \end{tabular}
    1333 \end{quote2}
    1334 Declaration qualifiers can only appear at the start of a \CFA routine declaration,\footref{StorageClassSpecifier} \eg:
    1335 \begin{cfa}
    1336 extern [ int ] f ( int );
    1337 static [ int ] g ( int );
    1338 \end{cfa}
    1339 
    1340 
    1341 \section{Routine Pointers}
    1342 
    1343 The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg:
    1344 \begin{cfa}
    1345 * [ int x ] () fp;                                              §\C{// pointer to routine returning int with no parameters}§
    1346 * [ * int ] (int y) gp;                                 §\C{// pointer to routine returning pointer to int with int parameter}§
    1347 * [ ] (int,char) hp;                                    §\C{// pointer to routine returning no result with int and char parameters}§
    1348 * [ * int,int ] ( int ) jp;                             §\C{// pointer to routine returning pointer to int and int, with int parameter}§
    1349 \end{cfa}
    1350 While parameter names are optional, \emph{a routine name cannot be specified};
    1351 for example, the following is incorrect:
    1352 \begin{cfa}
    1353 * [ int x ] f () fp;                                    §\C{// routine name "f" is not allowed}§
    1354 \end{cfa}
    1355 
    1356 
    1357 \section{Named and Default Arguments}
    1358 
    1359 Named\index{named arguments}\index{arguments!named} and default\index{default arguments}\index{arguments!default} arguments~\cite{Hardgrave76}\footnote{
    1360 Francez~\cite{Francez77} proposed a further extension to the named-parameter passing style, which specifies what type of communication (by value, by reference, by name) the argument is passed to the routine.}
    1361 are two mechanisms to simplify routine call.
    1362 Both mechanisms are discussed with respect to \CFA.
    1363 \begin{description}
    1364 \item[Named (or Keyword) Arguments:]
    1365 provide the ability to specify an argument to a routine call using the parameter name rather than the position of the parameter.
    1366 For example, given the routine:
    1367 \begin{cfa}
    1368 void p( int x, int y, int z ) {...}
    1369 \end{cfa}
    1370 a positional call is:
    1371 \begin{cfa}
    1372 p( 4, 7, 3 );
    1373 \end{cfa}
    1374 whereas a named (keyword) call may be:
    1375 \begin{cfa}
    1376 p( z : 3, x : 4, y : 7 );       §\C{// rewrite $\Rightarrow$ p( 4, 7, 3 )}§
    1377 \end{cfa}
    1378 Here the order of the arguments is unimportant, and the names of the parameters are used to associate argument values with the corresponding parameters.
    1379 The compiler rewrites a named call into a positional call.
    1380 The advantages of named parameters are:
    1381 \begin{itemize}
    1382 \item
    1383 Remembering the names of the parameters may be easier than the order in the routine definition.
    1384 \item
    1385 Parameter names provide documentation at the call site (assuming the names are descriptive).
    1386 \item
    1387 Changes can be made to the order or number of parameters without affecting the call (although the call must still be recompiled).
    1388 \end{itemize}
    1389 
    1390 Unfortunately, named arguments do not work in C-style programming-languages because a routine prototype is not required to specify parameter names, nor do the names in the prototype have to match with the actual definition.
    1391 For example, the following routine prototypes and definition are all valid.
    1392 \begin{cfa}
    1393 void p( int, int, int );                        §\C{// equivalent prototypes}§
    1394 void p( int x, int y, int z );
    1395 void p( int y, int x, int z );
    1396 void p( int z, int y, int x );
    1397 void p( int q, int r, int s ) {}        §\C{// match with this definition}§
    1398 \end{cfa}
    1399 Forcing matching parameter names in routine prototypes with corresponding routine definitions is possible, but goes against a strong tradition in C programming.
    1400 Alternatively, prototype definitions can be eliminated by using a two-pass compilation, and implicitly creating header files for exports.
    1401 The former is easy to do, while the latter is more complex.
    1402 
    1403 Furthermore, named arguments do not work well in a \CFA-style programming-languages because they potentially introduces a new criteria for type matching.
    1404 For example, it is technically possible to disambiguate between these two overloaded definitions of ©f© based on named arguments at the call site:
    1405 \begin{cfa}
    1406 int f( int i, int j );
    1407 int f( int x, double y );
    1408 
    1409 f( j : 3, i : 4 );                              §\C{// 1st f}§
    1410 f( x : 7, y : 8.1 );                    §\C{// 2nd f}§
    1411 f( 4, 5 );                                              §\C{// ambiguous call}§
    1412 \end{cfa}
    1413 However, named arguments compound routine resolution in conjunction with conversions:
    1414 \begin{cfa}
    1415 f( i : 3, 5.7 );                                §\C{// ambiguous call ?}§
    1416 \end{cfa}
    1417 Depending on the cost associated with named arguments, this call could be resolvable or ambiguous.
    1418 Adding named argument into the routine resolution algorithm does not seem worth the complexity.
    1419 Therefore, \CFA does \emph{not} attempt to support named arguments.
    1420 
    1421 \item[Default Arguments]
    1422 provide the ability to associate a default value with a parameter so it can be optionally specified in the argument list.
    1423 For example, given the routine:
    1424 \begin{cfa}
    1425 void p( int x = 1, int y = 2, int z = 3 ) {...}
    1426 \end{cfa}
    1427 the allowable positional calls are:
    1428 \begin{cfa}
    1429 p();                                                    §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
    1430 p( 4 );                                                 §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
    1431 p( 4, 4 );                                              §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
    1432 p( 4, 4, 4 );                                   §\C{// rewrite $\Rightarrow$ p( 4, 4, 4 )}§
    1433 // empty arguments
    1434 p(  , 4, 4 );                                   §\C{// rewrite $\Rightarrow$ p( 1, 4, 4 )}§
    1435 p( 4,  , 4 );                                   §\C{// rewrite $\Rightarrow$ p( 4, 2, 4 )}§
    1436 p( 4, 4,   );                                   §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
    1437 p( 4,  ,   );                                   §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
    1438 p(  , 4,   );                                   §\C{// rewrite $\Rightarrow$ p( 1, 4, 3 )}§
    1439 p(  ,  , 4 );                                   §\C{// rewrite $\Rightarrow$ p( 1, 2, 4 )}§
    1440 p(  ,  ,   );                                   §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
    1441 \end{cfa}
    1442 Here the missing arguments are inserted from the default values in the parameter list.
    1443 The compiler rewrites missing default values into explicit positional arguments.
    1444 The advantages of default values are:
    1445 \begin{itemize}
    1446 \item
    1447 Routines with a large number of parameters are often very generalized, giving a programmer a number of different options on how a computation is performed.
    1448 For many of these kinds of routines, there are standard or default settings that work for the majority of computations.
    1449 Without default values for parameters, a programmer is forced to specify these common values all the time, resulting in long argument lists that are error prone.
    1450 \item
    1451 When a routine's interface is augmented with new parameters, it extends the interface providing generalizability\footnote{
    1452 ``It should be possible for the implementor of an abstraction to increase its generality.
    1453 So long as the modified abstraction is a generalization of the original, existing uses of the abstraction will not require change.
    1454 It might be possible to modify an abstraction in a manner which is not a generalization without affecting existing uses, but, without inspecting the modules in which the uses occur, this possibility cannot be determined.
    1455 This criterion precludes the addition of parameters, unless these parameters have default or inferred values that are valid for all possible existing applications.''~\cite[p.~128]{Cormack90}}
    1456 (somewhat like the generalization provided by inheritance for classes).
    1457 That is, all existing calls are still valid, although the call must still be recompiled.
    1458 \end{itemize}
    1459 The only disadvantage of default arguments is that unintentional omission of an argument may not result in a compiler-time error.
    1460 Instead, a default value is used, which may not be the programmer's intent.
    1461 
    1462 Default values may only appear in a prototype versus definition context:
    1463 \begin{cfa}
    1464 void p( int x, int y = 2, int z = 3 );          §\C{// prototype: allowed}§
    1465 void p( int, int = 2, int = 3 );                        §\C{// prototype: allowed}§
    1466 void p( int x, int y = 2, int z = 3 ) {}        §\C{// definition: not allowed}§
    1467 \end{cfa}
    1468 The reason for this restriction is to allow separate compilation.
    1469 Multiple prototypes with different default values is an error.
    1470 \end{description}
    1471 
    1472 Ellipse (``...'') arguments present problems when used with default arguments.
    1473 The conflict occurs because both named and ellipse arguments must appear after positional arguments, giving two possibilities:
    1474 \begin{cfa}
    1475 p( /* positional */, ... , /* named */ );
    1476 p( /* positional */, /* named */, ... );
    1477 \end{cfa}
    1478 While it is possible to implement both approaches, the first possibly is more complex than the second, \eg:
    1479 \begin{cfa}
    1480 p( int x, int y, int z, ... );
    1481 p( 1, 4, 5, 6, z : 3, y : 2 ); §\C{// assume p( /* positional */, ... , /* named */ );}§
    1482 p( 1, z : 3, y : 2, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§
    1483 \end{cfa}
    1484 In the first call, it is necessary for the programmer to conceptually rewrite the call, changing named arguments into positional, before knowing where the ellipse arguments begin.
    1485 Hence, this approach seems significantly more difficult, and hence, confusing and error prone.
    1486 In the second call, the named arguments separate the positional and ellipse arguments, making it trivial to read the call.
    1487 
    1488 The problem is exacerbated with default arguments, \eg:
    1489 \begin{cfa}
    1490 void p( int x, int y = 2, int z = 3... );
    1491 p( 1, 4, 5, 6, z : 3 );         §\C{// assume p( /* positional */, ... , /* named */ );}§
    1492 p( 1, z : 3, 4, 5, 6 );         §\C{// assume p( /* positional */, /* named */, ... );}§
    1493 \end{cfa}
    1494 The first call is an error because arguments 4 and 5 are actually positional not ellipse arguments;
    1495 therefore, argument 5 subsequently conflicts with the named argument z : 3.
    1496 In the second call, the default value for y is implicitly inserted after argument 1 and the named arguments separate the positional and ellipse arguments, making it trivial to read the call.
    1497 For these reasons, \CFA requires named arguments before ellipse arguments.
    1498 Finally, while ellipse arguments are needed for a small set of existing C routines, like printf, the extended \CFA type system largely eliminates the need for ellipse arguments (see Section 24), making much of this discussion moot.
    1499 
    1500 Default arguments and overloading (see Section 24) are complementary.
    1501 While in theory default arguments can be simulated with overloading, as in:
    1502 \begin{quote2}
    1503 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    1504 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{default arguments}}   & \multicolumn{1}{c}{\textbf{overloading}}      \\
    1505 \begin{cfa}
    1506 void p( int x, int y = 2, int z = 3 ) {...}
    1507 
    1508 
    1509 \end{cfa}
    1510 &
    1511 \begin{cfa}
    1512 void p( int x, int y, int z ) {...}
    1513 void p( int x ) { p( x, 2, 3 ); }
    1514 void p( int x, int y ) { p( x, y, 3 ); }
    1515 \end{cfa}
    1516 \end{tabular}
    1517 \end{quote2}
    1518 the number of required overloaded routines is linear in the number of default values, which is unacceptable growth.
    1519 In general, overloading should only be used over default arguments if the body of the routine is significantly different.
    1520 Furthermore, overloading cannot handle accessing default arguments in the middle of a positional list, via a missing argument, such as:
    1521 \begin{cfa}
    1522 p( 1, /* default */, 5 );               §\C{// rewrite $\Rightarrow$ p( 1, 2, 5 )}§
    1523 \end{cfa}
    1524 
    1525 Given the \CFA restrictions above, both named and default arguments are backwards compatible.
    1526 \Index*[C++]{\CC{}} only supports default arguments;
    1527 \Index*{Ada} supports both named and default arguments.
    1528 
    1529 
    1530 \section{Unnamed Structure Fields}
    1531 
    1532 C requires each field of a structure to have a name, except for a bit field associated with a basic type, \eg:
    1533 \begin{cfa}
    1534 struct {
    1535         int f1;                                 §\C{// named field}§
    1536         int f2 : 4;                             §\C{// named field with bit field size}§
    1537         int : 3;                                §\C{// unnamed field for basic type with bit field size}§
    1538         int ;                                   §\C{// disallowed, unnamed field}§
    1539         int *;                                  §\C{// disallowed, unnamed field}§
    1540         int (*)( int );                 §\C{// disallowed, unnamed field}§
    1541 };
    1542 \end{cfa}
    1543 This requirement is relaxed by making the field name optional for all field declarations; therefore, all the field declarations in the example are allowed.
    1544 As for unnamed bit fields, an unnamed field is used for padding a structure to a particular size.
    1545 A list of unnamed fields is also supported, \eg:
    1546 \begin{cfa}
    1547 struct {
    1548         int , , ;                               §\C{// 3 unnamed fields}§
    1549 }
    1550 \end{cfa}
    1551 
    1552 
    1553 \section{Nesting}
    1554 
    1555 Nesting of types and routines is useful for controlling name visibility (\newterm{name hiding}).
    1556 
    1557 
    1558 \subsection{Type Nesting}
    1559 
    1560 \CFA allows \Index{type nesting}, and type qualification of the nested types (see \VRef[Figure]{f:TypeNestingQualification}), where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification.
    1561 \begin{figure}
    1562 \centering
    1563 \begin{tabular}{@{}l@{\hspace{3em}}l|l@{}}
    1564 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}}      & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}}      & \multicolumn{1}{|c}{\textbf{\CFA}}    \\
    1565 \hline
    1566 \begin{cfa}
    1567 struct S {
    1568         enum C { R, G, B };
    1569         struct T {
    1570                 union U { int i, j; };
    1571                 enum C c;
    1572                 short int i, j;
    1573         };
    1574         struct T t;
    1575 } s;
    1576 
    1577 int fred() {
    1578         s.t.c = R;
    1579         struct T t = { R, 1, 2 };
    1580         enum C c;
    1581         union U u;
    1582 }
    1583 \end{cfa}
    1584 &
    1585 \begin{cfa}
    1586 enum C { R, G, B };
    1587 union U { int i, j; };
    1588 struct T {
    1589         enum C c;
    1590         short int i, j;
    1591 };
    1592 struct S {
    1593         struct T t;
    1594 } s;
    1595        
    1596 
    1597 
    1598 
    1599 
    1600 
    1601 
    1602 \end{cfa}
    1603 &
    1604 \begin{cfa}
    1605 struct S {
    1606         enum C { R, G, B };
    1607         struct T {
    1608                 union U { int i, j; };
    1609                 enum C c;
    1610                 short int i, j;
    1611         };
    1612         struct T t;
    1613 } s;
    1614 
    1615 int fred() {
    1616         s.t.c = ®S.®R;  // type qualification
    1617         struct ®S.®T t = { ®S.®R, 1, 2 };
    1618         enum ®S.®C c;
    1619         union ®S.T.®U u;
    1620 }
    1621 \end{cfa}
    1622 \end{tabular}
    1623 \caption{Type Nesting / Qualification}
    1624 \label{f:TypeNestingQualification}
    1625 \end{figure}
    1626 In the left example in C, types ©C©, ©U© and ©T© are implicitly hoisted outside of type ©S© into the containing block scope.
    1627 In the right example in \CFA, the types are not hoisted and accessed using the field-selection operator ``©.©'' for type qualification, as does \Index*{Java}, rather than the \CC type-selection operator ``©::©''.
    1628 
    1629 
    1630 \subsection{Routine Nesting}
    1631 
    1632 While \CFA does not provide object programming by putting routines into structures, it does rely heavily on locally nested routines to redefine operations at or close to a call site.
    1633 For example, the C quick-sort is wrapped into the following polymorphic \CFA routine:
    1634 \begin{cfa}
    1635 forall( otype T | { int ?<?( T, T ); } )
    1636 void qsort( const T * arr, size_t dimension );
    1637 \end{cfa}
    1638 which can be used to sort in ascending and descending order by locally redefining the less-than operator into greater-than.
    1639 \begin{cfa}
    1640 const unsigned int size = 5;
    1641 int ia[size];
    1642 ...                                             §\C{// assign values to array ia}§
    1643 qsort( ia, size );              §\C{// sort ascending order using builtin ?<?}§
    1644 {
    1645         ®int ?<?( int x, int y ) { return x > y; }® §\C{// nested routine}§
    1646         qsort( ia, size );      §\C{// sort descending order by local redefinition}§
    1647 }
    1648 \end{cfa}
    1649 
    1650 Nested routines are not first-class, meaning a nested routine cannot be returned if it has references to variables in its enclosing blocks;
    1651 the only exception is references to the external block of the translation unit, as these variables persist for the duration of the program.
    1652 The following program in undefined in \CFA (and Indexc{gcc})
    1653 \begin{cfa}
    1654 [* [int]( int )] foo() {                §\C{// int (*foo())( int )}§
    1655         int ®i® = 7;
    1656         int bar( int p ) {
    1657                 ®i® += 1;                               §\C{// dependent on local variable}§
    1658                 sout | ®i® | endl;
    1659         }
    1660         return bar;                                     §\C{// undefined because of local dependence}§
    1661 }
    1662 int main() {
    1663         * [int]( int ) fp = foo();      §\C{// int (*fp)( int )}§
    1664         sout | fp( 3 ) | endl;
    1665 }
    1666 \end{cfa}
    1667 because
    1668 
    1669 Currently, there are no \Index{lambda} expressions, \ie unnamed routines because routine names are very important to properly select the correct routine.
    1670 
    1671 
    1672 \section{Tuples}
    1673 
    1674 In C and \CFA, lists of elements appear in several contexts, such as the parameter list for a routine call.
    1675 (More contexts are added shortly.)
    1676 A list of such elements is called a \newterm{lexical list}.
    1677 The general syntax of a lexical list is:
    1678 \begin{cfa}
    1679 [ §\emph{exprlist}§ ]
    1680 \end{cfa}
    1681 where ©$\emph{exprlist}$© is a list of one or more expressions separated by commas.
    1682 The brackets, ©[]©, allow differentiating between lexical lists and expressions containing the C comma operator.
    1683 The following are examples of lexical lists:
    1684 \begin{cfa}
    1685 [ x, y, z ]
    1686 [ 2 ]
    1687 [ v+w, x*y, 3.14159, f() ]
    1688 \end{cfa}
    1689 Tuples are permitted to contain sub-tuples (\ie nesting), such as ©[ [ 14, 21 ], 9 ]©, which is a 2-element tuple whose first element is itself a tuple.
    1690 Note, a tuple is not a record (structure);
    1691 a record denotes a single value with substructure, whereas a tuple is multiple values with no substructure (see flattening coercion in Section 12.1).
    1692 In essence, tuples are largely a compile time phenomenon, having little or no runtime presence.
    1693 
    1694 Tuples can be organized into compile-time tuple variables;
    1695 these variables are of \newterm{tuple type}.
    1696 Tuple variables and types can be used anywhere lists of conventional variables and types can be used.
    1697 The general syntax of a tuple type is:
    1698 \begin{cfa}
    1699 [ §\emph{typelist}§ ]
    1700 \end{cfa}
    1701 where ©$\emph{typelist}$© is a list of one or more legal \CFA or C type specifications separated by commas, which may include other tuple type specifications.
    1702 Examples of tuple types include:
    1703 \begin{cfa}
    1704 [ unsigned int, char ]
    1705 [ double, double, double ]
    1706 [ * int, int * ]                §\C{// mix of CFA and ANSI}§
    1707 [ * [ 5 ] int, * * char, * [ [ int, int ] ] (int, int) ]
    1708 \end{cfa}
    1709 Like tuples, tuple types may be nested, such as ©[ [ int, int ], int ]©, which is a 2-element tuple type whose first element is itself a tuple type.
    1710 
    1711 Examples of declarations using tuple types are:
    1712 \begin{cfa}
    1713 [ int, int ] x;                 §\C{// 2 element tuple, each element of type int}§
    1714 * [ char, char ] y;             §\C{// pointer to a 2 element tuple}§
    1715 [ [ int, int ] ] z ([ int, int ]);
    1716 \end{cfa}
    1717 The last example declares an external routine that expects a 2 element tuple as an input parameter and returns a 2 element tuple as its result.
    1718 
    1719 As mentioned, tuples can appear in contexts requiring a list of value, such as an argument list of a routine call.
    1720 In unambiguous situations, the tuple brackets may be omitted, \eg a tuple that appears as an argument may have its
    1721 square brackets omitted for convenience; therefore, the following routine invocations are equivalent:
    1722 \begin{cfa}
    1723 f( [ 1, x+2, fred() ] );
    1724 f( 1, x+2, fred() );
    1725 \end{cfa}
    1726 Also, a tuple or a tuple variable may be used to supply all or part of an argument list for a routine expecting multiple input parameters or for a routine expecting a tuple as an input parameter.
    1727 For example, the following are all legal:
    1728 \begin{cfa}
    1729 [ int, int ] w1;
    1730 [ int, int, int ] w2;
    1731 [ void ] f (int, int, int); /* three input parameters of type int */
    1732 [ void ] g ([ int, int, int ]); /* 3 element tuple as input */
    1733 f( [ 1, 2, 3 ] );
    1734 f( w1, 3 );
    1735 f( 1, w1 );
    1736 f( w2 );
    1737 g( [ 1, 2, 3 ] );
    1738 g( w1, 3 );
    1739 g( 1, w1 );
    1740 g( w2 );
    1741 \end{cfa}
    1742 Note, in all cases 3 arguments are supplied even though the syntax may appear to supply less than 3. As mentioned, a
    1743 tuple does not have structure like a record; a tuple is simply converted into a list of components.
    1744 \begin{rationale}
    1745 The present implementation of \CFA does not support nested routine calls when the inner routine returns multiple values; \ie a statement such as ©g( f() )© is not supported.
    1746 Using a temporary variable to store the  results of the inner routine and then passing this variable to the outer routine works, however.
    1747 \end{rationale}
    1748 
    1749 A tuple can contain a C comma expression, provided the expression containing the comma operator is enclosed in parentheses.
    1750 For instance, the following tuples are equivalent:
    1751 \begin{cfa}
    1752 [ 1, 3, 5 ]
    1753 [ 1, (2, 3), 5 ]
    1754 \end{cfa}
    1755 The second element of the second tuple is the expression (2, 3), which yields the result 3.
    1756 This requirement is the same as for comma expressions in argument lists.
    1757 
    1758 Type qualifiers, \ie const and volatile, may modify a tuple type.
    1759 The meaning is the same as for a type qualifier modifying an aggregate type [Int99, x 6.5.2.3(7),x 6.7.3(11)], \ie the qualifier is distributed across all of the types in the tuple, \eg:
    1760 \begin{cfa}
    1761 const volatile [ int, float, const int ] x;
    1762 \end{cfa}
    1763 is equivalent to:
    1764 \begin{cfa}
    1765 [ const volatile int, const volatile float, const volatile int ] x;
    1766 \end{cfa}
    1767 Declaration qualifiers can only appear at the start of a \CFA tuple declaration4, \eg:
    1768 \begin{cfa}
    1769 extern [ int, int ] w1;
    1770 static [ int, int, int ] w2;
    1771 \end{cfa}
    1772 \begin{rationale}
    1773 Unfortunately, C's syntax for subscripts precluded treating them as tuples.
    1774 The C subscript list has the form ©[i][j]...© and not ©[i, j, ...]©.
    1775 Therefore, there is no syntactic way for a routine returning multiple values to specify the different subscript values, \eg ©f[g()]© always means a single subscript value because there is only one set of brackets.
    1776 Fixing this requires a major change to C because the syntactic form ©M[i, j, k]© already has a particular meaning: ©i, j, k© is a comma expression.
    1777 \end{rationale}
    1778 
    1779 
    1780 \subsection{Tuple Coercions}
    1781 
    1782 There are four coercions that can be performed on tuples and tuple variables: closing, opening, flattening and structuring.
    1783 In addition, the coercion of dereferencing can be performed on a tuple variable to yield its value(s), as for other variables.
    1784 A \newterm{closing coercion} takes a set of values and converts it into a tuple value, which is a contiguous set of values, as in:
    1785 \begin{cfa}
    1786 [ int, int, int, int ] w;
    1787 w = [ 1, 2, 3, 4 ];
    1788 \end{cfa}
    1789 First the right-hand tuple is closed into a tuple value and then the tuple value is assigned.
    1790 
    1791 An \newterm{opening coercion} is the opposite of closing; a tuple value is converted into a tuple of values, as in:
    1792 \begin{cfa}
    1793 [ a, b, c, d ] = w
    1794 \end{cfa}
    1795 ©w© is implicitly opened to yield a tuple of four values, which are then assigned individually.
    1796 
    1797 A \newterm{flattening coercion} coerces a nested tuple, \ie a tuple with one or more components, which are themselves tuples, into a flattened tuple, which is a tuple whose components are not tuples, as in:
    1798 \begin{cfa}
    1799 [ a, b, c, d ] = [ 1, [ 2, 3 ], 4 ];
    1800 \end{cfa}
    1801 First the right-hand tuple is flattened and then the values are assigned individually.
    1802 Flattening is also performed on tuple types.
    1803 For example, the type ©[ int, [ int, int ], int ]© can be coerced, using flattening, into the type ©[ int, int, int, int ]©.
    1804 
    1805 A \newterm{structuring coercion} is the opposite of flattening;
    1806 a tuple is structured into a more complex nested tuple.
    1807 For example, structuring the tuple ©[ 1, 2, 3, 4 ]© into the tuple ©[ 1, [ 2, 3 ], 4 ]© or the tuple type ©[ int, int, int, int ]© into the tuple type ©[ int, [ int, int ], int ]©.
    1808 In the following example, the last assignment illustrates all the tuple coercions:
    1809 \begin{cfa}
    1810 [ int, int, int, int ] w = [ 1, 2, 3, 4 ];
    1811 int x = 5;
    1812 [ x, w ] = [ w, x ];            §\C{// all four tuple coercions}§
    1813 \end{cfa}
    1814 Starting on the right-hand tuple in the last assignment statement, w is opened, producing a tuple of four values;
    1815 therefore, the right-hand tuple is now the tuple ©[ [ 1, 2, 3, 4 ], 5 ]©.
    1816 This tuple is then flattened, yielding ©[ 1, 2, 3, 4, 5 ]©, which is structured into ©[ 1, [ 2, 3, 4, 5 ] ]© to match the tuple type of the left-hand side.
    1817 The tuple ©[ 2, 3, 4, 5 ]© is then closed to create a tuple value.
    1818 Finally, ©x© is assigned ©1© and ©w© is assigned the tuple value using multiple assignment (see Section 14).
    1819 \begin{rationale}
    1820 A possible additional language extension is to use the structuring coercion for tuples to initialize a complex record with a tuple.
    1821 \end{rationale}
    1822 
    1823 
    1824 \section{Mass Assignment}
    1825 
    1826 \CFA permits assignment to several variables at once using mass assignment~\cite{CLU}.
    1827 Mass assignment has the following form:
    1828 \begin{cfa}
    1829 [ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = §\emph{expr}§;
    1830 \end{cfa}
    1831 \index{lvalue}
    1832 The left-hand side is a tuple of \emph{lvalues}, which is a list of expressions each yielding an address, \ie any data object that can appear on the left-hand side of a conventional assignment statement.
    1833 ©$\emph{expr}$© is any standard arithmetic expression.
    1834 Clearly, the types of the entities being assigned must be type compatible with the value of the expression.
    1835 
    1836 Mass assignment has parallel semantics, \eg the statement:
    1837 \begin{cfa}
    1838 [ x, y, z ] = 1.5;
    1839 \end{cfa}
    1840 is equivalent to:
    1841 \begin{cfa}
    1842 x = 1.5; y = 1.5; z = 1.5;
    1843 \end{cfa}
    1844 This semantics is not the same as the following in C:
    1845 \begin{cfa}
    1846 x = y = z = 1.5;
    1847 \end{cfa}
    1848 as conversions between intermediate assignments may lose information.
    1849 A more complex example is:
    1850 \begin{cfa}
    1851 [ i, y[i], z ] = a + b;
    1852 \end{cfa}
    1853 which is equivalent to:
    1854 \begin{cfa}
    1855 t = a + b;
    1856 a1 = &i; a2 = &y[i]; a3 = &z;
    1857 *a1 = t; *a2 = t; *a3 = t;
    1858 \end{cfa}
    1859 The temporary ©t© is necessary to store the value of the expression to eliminate conversion issues.
    1860 The temporaries for the addresses are needed so that locations on the left-hand side do not change as the values are assigned.
    1861 In this case, ©y[i]© uses the previous value of ©i© and not the new value set at the beginning of the mass assignment.
    1862 
    1863 
    1864 \section{Multiple Assignment}
    1865 
    1866 \CFA also supports the assignment of several values at once, known as multiple assignment~\cite{CLU,Galletly96}.
    1867 Multiple assignment has the following form:
    1868 \begin{cfa}
    1869 [ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§ ];
    1870 \end{cfa}
    1871 \index{lvalue}
    1872 The left-hand side is a tuple of \emph{lvalues}, and the right-hand side is a tuple of \emph{expr}s.
    1873 Each \emph{expr} appearing on the right-hand side of a multiple assignment statement is assigned to the corresponding \emph{lvalues} on the left-hand side of the statement using parallel semantics for each assignment.
    1874 An example of multiple assignment is:
    1875 \begin{cfa}
    1876 [ x, y, z ] = [ 1, 2, 3 ];
    1877 \end{cfa}
    1878 Here, the values ©1©, ©2© and ©3© are assigned, respectively, to the variables ©x©, ©y© and ©z©.
    1879  A more complex example is:
    1880 \begin{cfa}
    1881 [ i, y[ i ], z ] = [ 1, i, a + b ];
    1882 \end{cfa}
    1883 Here, the values ©1©, ©i© and ©a + b© are assigned to the variables ©i©, ©y[i]© and ©z©, respectively.
    1884  Note, the parallel semantics of
    1885 multiple assignment ensures:
    1886 \begin{cfa}
    1887 [ x, y ] = [ y, x ];
    1888 \end{cfa}
    1889 correctly interchanges (swaps) the values stored in ©x© and ©y©.
    1890 The following cases are errors:
    1891 \begin{cfa}
    1892 [ a, b, c ] = [ 1, 2, 3, 4 ];
    1893 [ a, b, c ] = [ 1, 2 ];
    1894 \end{cfa}
    1895 because the number of entities in the left-hand tuple is unequal with the right-hand tuple.
    1896 
    1897 As for all tuple contexts in C, side effects should not be used because C does not define an ordering for the evaluation of the elements of a tuple;
    1898 both these examples produce indeterminate results:
    1899 \begin{cfa}
    1900 f( x++, x++ );                          §\C{// C routine call with side effects in arguments}§
    1901 [ v1, v2 ] = [ x++, x++ ];      §\C{// side effects in righthand side of multiple assignment}§
    1902 \end{cfa}
    1903 
    1904 
    1905 \section{Cascade Assignment}
    1906 
    1907 As in C, \CFA mass and multiple assignments can be cascaded, producing cascade assignment.
    1908 Cascade assignment has the following form:
    1909 \begin{cfa}
    1910 §\emph{tuple}§ = §\emph{tuple}§ = ... = §\emph{tuple}§;
    1911 \end{cfa}
    1912 and it has the same parallel semantics as for mass and multiple assignment.
    1913 Some examples of cascade assignment are:
    1914 \begin{cfa}
    1915 x1 = y1 = x2 = y2 = 0;
    1916 [ x1, y1 ] = [ x2, y2 ] = [ x3, y3 ];
    1917 [ x1, y1 ] = [ x2, y2 ] = 0;
    1918 [ x1, y1 ] = z = 0;
    1919 \end{cfa}
    1920 As in C, the rightmost assignment is performed first, \ie assignment parses right to left.
    1921 
    1922 
    1923 \section{Field Tuples}
    1924 
    1925 Tuples may be used to select multiple fields of a record by field name.
    1926 Its general form is:
    1927 \begin{cfa}
    1928 §\emph{expr}§ . [ §\emph{fieldlist}§ ]
    1929 §\emph{expr}§ -> [ §\emph{fieldlist}§ ]
    1930 \end{cfa}
    1931 \emph{expr} is any expression yielding a value of type record, \eg ©struct©, ©union©.
    1932 Each element of \emph{ fieldlist} is an element of the record specified by \emph{expr}.
    1933 A record-field tuple may be used anywhere a tuple can be used. An example of the use of a record-field tuple is
    1934 the following:
    1935 \begin{cfa}
    1936 struct s {
    1937         int f1, f2;
    1938         char f3;
    1939         double f4;
    1940 } v;
    1941 v.[ f3, f1, f2 ] = ['x', 11, 17 ];      §\C{// equivalent to v.f3 = 'x', v.f1 = 11, v.f2 = 17}§
    1942 f( v.[ f3, f1, f2 ] );                          §\C{// equivalent to f( v.f3, v.f1, v.f2 )}§
    1943 \end{cfa}
    1944 Note, the fields appearing in a record-field tuple may be specified in any order;
    1945 also, it is unnecessary to specify all the fields of a struct in a multiple record-field tuple.
    1946 
    1947 If a field of a ©struct© is itself another ©struct©, multiple fields of this subrecord can be specified using a nested record-field tuple, as in the following example:
    1948 \begin{cfa}
    1949 struct inner {
    1950         int f2, f3;
    1951 };
    1952 struct outer {
    1953         int f1;
    1954         struct inner i;
    1955         double f4;
    1956 } o;
    1957 
    1958 o.[ f1, i.[ f2, f3 ], f4 ] = [ 11, 12, 13, 3.14159 ];
    1959 \end{cfa}
    1960491
    1961492
     
    2249780still works.
    2250781Nevertheless, reversing the default action would have a non-trivial effect on case actions that compound, such as the above example of processing shell arguments.
    2251 Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthrough©/©fallthru©, e.g.:
     782Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthrough©/©fallthru©, \eg:
    2252783\begin{cfa}
    2253784®choose® ( i ) {
     
    2397928
    2398929
     930\subsection{Exception Hierarchy}
     931
     932An exception type can be derived from another exception type, just like deriving a subclass from a class, providing a kind of polymorphism among exception types.
     933The exception-type hierarchy that is created is used to organize exception types, similar to a class hierarchy in object-oriented languages, \eg:
     934\begin{center}
     935\input{EHMHierarchy}
     936\end{center}
     937A programmer can then choose to handle an exception at different degrees of specificity along the hierarchy;
     938derived exception-types support a more flexible programming style.
     939For example, higher-level code should catch general exceptions to reduce coupling to the specific implementation at the lower levels;
     940unnecessary coupling may force changes in higher-level code when low-level code changes.
     941A consequence of derived exception-types is that multiple exceptions may match, \eg:
     942\begin{cfa}
     943catch( Arithmetic )
     944\end{cfa}
     945matches all three derived exception-types: ©DivideByZero©, ©Overflow©, and ©Underflow©.
     946Because the propagation mechanisms perform a simple linear search of the handler clause for a guarded block, and selects the first matching handler, the order of catch clauses in the handler clause becomes important, \eg:
     947\begin{cfa}
     948try {
     949        ...
     950} catch( Overflow ) {   // must appear first
     951        // handle overflow
     952} catch( Arithmetic )
     953        // handle other arithmetic issues
     954}
     955\end{cfa}
     956\newterm{Multiple derivation} among exception is not supported.
     957
     958
     959\section{Declarations}
     960\label{s:Declarations}
     961
     962C declaration syntax is notoriously confusing and error prone.
     963For example, many C programmers are confused by a declaration as simple as:
     964\begin{quote2}
     965\begin{tabular}{@{}ll@{}}
     966\begin{cfa}
     967int * x[5]
     968\end{cfa}
     969&
     970\raisebox{-0.75\totalheight}{\input{Cdecl}}
     971\end{tabular}
     972\end{quote2}
     973Is this an array of 5 pointers to integers or a \Index{pointer} to an array of 5 integers?
     974The fact this declaration is unclear to many C programmers means there are \Index{productivity} and \Index{safety} issues even for basic programs.
     975Another example of confusion results from the fact that a routine name and its parameters are embedded within the return type, mimicking the way the return value is used at the routine's call site.
     976For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
     977\begin{cfa}
     978int ®(*®f®())[®5®]® {...};                              §\C{definition}§
     979 ... ®(*®f®())[®3®]® += 1;                              §\C{usage}§
     980\end{cfa}
     981Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
     982While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice.
     983
     984\CFA provides its own type, variable and routine declarations, using a different syntax.
     985The new declarations place qualifiers to the left of the base type, while C declarations place qualifiers to the right of the base type.
     986In the following example, \R{red} is the base type and \B{blue} is qualifiers.
     987The \CFA declarations move the qualifiers to the left of the base type, \ie move the blue to the left of the red, while the qualifiers have the same meaning but are ordered left to right to specify a variable's type.
     988\begin{quote2}
     989\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     990\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
     991\begin{cfa}
     992ß[5] *ß ®int® x1;
     993ß* [5]ß ®int® x2;
     994ß[* [5] int]ß f®( int p )®;
     995\end{cfa}
     996&
     997\begin{cfa}
     998®int® ß*ß x1 ß[5]ß;
     999®int® ß(*ßx2ß)[5]ß;
     1000ßint (*ßf®( int p )®ß)[5]ß;
     1001\end{cfa}
     1002\end{tabular}
     1003\end{quote2}
     1004The only exception is \Index{bit field} specification, which always appear to the right of the base type.
     1005% Specifically, the character ©*© is used to indicate a pointer, square brackets ©[©\,©]© are used to represent an array or function return value, and parentheses ©()© are used to indicate a routine parameter.
     1006However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
     1007For instance, variables ©x© and ©y© of type \Index{pointer} to integer are defined in \CFA as follows:
     1008\begin{quote2}
     1009\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     1010\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
     1011\begin{cfa}
     1012®*® int x, y;
     1013\end{cfa}
     1014&
     1015\begin{cfa}
     1016int ®*®x, ®*®y;
     1017\end{cfa}
     1018\end{tabular}
     1019\end{quote2}
     1020The downside of this semantics is the need to separate regular and \Index{pointer} declarations:
     1021\begin{quote2}
     1022\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     1023\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
     1024\begin{cfa}
     1025®*® int x;
     1026int y;
     1027\end{cfa}
     1028&
     1029\begin{cfa}
     1030int ®*®x, y;
     1031
     1032\end{cfa}
     1033\end{tabular}
     1034\end{quote2}
     1035which is \Index{prescribing} a safety benefit.
     1036Other examples are:
     1037\begin{quote2}
     1038\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
     1039\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
     1040\begin{cfa}
     1041[ 5 ] int z;
     1042[ 5 ] * char w;
     1043* [ 5 ] double v;
     1044struct s {
     1045        int f0:3;
     1046        * int f1;
     1047        [ 5 ] * int f2;
     1048};
     1049\end{cfa}
     1050&
     1051\begin{cfa}
     1052int z[ 5 ];
     1053char * w[ 5 ];
     1054double (* v)[ 5 ];
     1055struct s {
     1056        int f0:3;
     1057        int * f1;
     1058        int * f2[ 5 ]
     1059};
     1060\end{cfa}
     1061&
     1062\begin{cfa}
     1063// array of 5 integers
     1064// array of 5 pointers to char
     1065// pointer to array of 5 doubles
     1066
     1067// common bit field syntax
     1068
     1069
     1070
     1071\end{cfa}
     1072\end{tabular}
     1073\end{quote2}
     1074
     1075All type qualifiers, \eg ©const©, ©volatile©, etc., are used in the normal way with the new declarations and also appear left to right, \eg:
     1076\begin{quote2}
     1077\begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
     1078\multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\
     1079\begin{cfa}
     1080const * const int x;
     1081const * [ 5 ] const int y;
     1082\end{cfa}
     1083&
     1084\begin{cfa}
     1085int const * const x;
     1086const int (* const y)[ 5 ]
     1087\end{cfa}
     1088&
     1089\begin{cfa}
     1090// const pointer to const integer
     1091// const pointer to array of 5 const integers
     1092\end{cfa}
     1093\end{tabular}
     1094\end{quote2}
     1095All declaration qualifiers, \eg ©extern©, ©static©, etc., are used in the normal way with the new declarations but can only appear at the start of a \CFA routine declaration,\footnote{\label{StorageClassSpecifier}
     1096The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}} \eg:
     1097\begin{quote2}
     1098\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
     1099\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
     1100\begin{cfa}
     1101extern [ 5 ] int x;
     1102static * const int y;
     1103\end{cfa}
     1104&
     1105\begin{cfa}
     1106int extern x[ 5 ];
     1107const int static * y;