Changeset 3730


Ignore:
Timestamp:
Sep 23, 2015 11:56:53 AM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 5a9084e28d2147cf1b7101d41aa72c2eefd60f1d
end hash code: 6b89ca25800449853e79c16bb1f7e755cf29675d

commit 6b89ca25800449853e79c16bb1f7e755cf29675d
Author: Brad Bell <bradbell@…>
Date: Wed Sep 23 08:54:20 2015 -0700

Remove invisible white space.

commit 1e2449cb036f2b468d6b5cbee32004dd974fed77
Author: Brad Bell <bradbell@…>
Date: Wed Sep 23 08:52:21 2015 -0700

  1. Change bin/get_* to check if requested version has already been installed.
  2. Put NumberOp? entry at end of NumArgTable? and NumResTable? in op_code.hpp.


op_code.hpp: use white space to align comments.
jenkins.sh: call all bin/get_* routines and let them descide if install is necessary.
configure: automatic changes corresponding to configure.ac.
configure.ac: define have_ar before its first use and improve its messaging.

commit 39a713028e11e2935098b2dd80d1fdd907e32371
Author: Brad Bell <bradbell@…>
Date: Wed Sep 23 05:54:15 2015 -0700

  1. minor white space edit
  2. put some operator cases in alphabetical order.
  3. remove invisible white space.
Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/bin/check_op_code.sh

    r3250 r3730  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
     
    2121sed -n -e '/^enum/,/^\tNumberOp$/p' cppad/local/op_code.hpp | \
    2222        sed -e '/^enum/d' -e '/^\tNumberOp$/d' \
    23                 -e 's/^[        ]*//' -e 's/Op[, ].*//' -e '/^\/\//d' > bin/op_code.1.$$
     23                -e 's/^[        ]*//' -e 's/Op[, ].*//' -e '/^\/\//d' > bin/op_code.1.$$
    2424#
    2525sort --ignore-case bin/op_code.1.$$ > bin/op_code.2.$$
    26 if ! diff bin/op_code.1.$$ bin/op_code.2.$$ 
     26if ! diff bin/op_code.1.$$ bin/op_code.2.$$
    2727then
    2828        echo "check_op_code.sh: enum list is not in alphabetical order"
     
    3535        sed \
    3636                -e '/NumArgTable\[\]/d' \
     37                -e '/NumberOp.*not used/d' \
    3738                -e '/^[ \t]*};/d' \
    3839                -e 's|^[ \t]*[0-9],* *// *||' \
     
    4041                > bin/op_code.3.$$
    4142#
    42 if ! diff bin/op_code.1.$$ bin/op_code.3.$$ 
     43if ! diff bin/op_code.1.$$ bin/op_code.3.$$
    4344then
    4445        echo "check_op_code.sh: NumArgTable list is not in alphabetical order"
     
    5253                -e '/NumResTable\[\]/d' \
    5354                -e '/^[ \t]*};/d' \
    54                 -e '/Last entry not used/d' \
     55                -e '/NumberOp.*not used/d' \
    5556                -e 's|^[ \t]*[0-9],* *// *||' \
    5657                -e 's|Op.*||' \
    5758                > bin/op_code.4.$$
    5859#
    59 if ! diff bin/op_code.1.$$ bin/op_code.4.$$ 
     60if ! diff bin/op_code.1.$$ bin/op_code.4.$$
    6061then
    6162        echo "check_op_code.sh: NumResTable list is not in alphabetical order"
     
    6970        sed \
    7071                -e '/OpNameTable\[\]/d' \
     72                -e '/"Number".*not used/d' \
    7173                -e '/^[ \t]*};/d' \
    7274                -e 's|^[ \t]*"||' \
     
    7476                > bin/op_code.5.$$
    7577#
    76 if ! diff bin/op_code.1.$$ bin/op_code.5.$$ 
     78if ! diff bin/op_code.1.$$ bin/op_code.5.$$
    7779then
    7880        echo "check_op_code.sh: OpName list is not in alphabetical order"
  • trunk/bin/get_adolc.sh

    r3722 r3730  
    7272version='2.4.1'
    7373web_page="http://www.coin-or.org/download/source/ADOL-C"
    74 prefix=`pwd`'/build/prefix'
     74cppad_dir=`pwd`
     75prefix="$cppad_dir/build/prefix"
     76installed_flag="build/external/adolc-${version}.installed"
     77if [ -e "$installed_flag" ]
     78then
     79        echo "$installed_flag exists: Skipping get_adolc.sh"
     80        exit 0
     81fi
    7582# --------------------------------------------------------------------------
    7683if [ -e /usr/lib64 ]
     
    127134echo_eval make install
    128135# -----------------------------------------------------------------------------
     136echo_eval touch $cppad_dir/$installed_flag
    129137echo "get_adolc: OK"
  • trunk/bin/get_colpack.sh

    r3722 r3730  
    6464version='1.0.9'
    6565web_page='http://cscapes.cs.purdue.edu/download/ColPack'
    66 prefix=`pwd`'/build/prefix'
     66cppad_dir=`pwd`
     67prefix="$cppad_dir/build/prefix"
     68installed_flag="build/external/colpack-${version}.installed"
     69if [ -e "$installed_flag" ]
     70then
     71        echo "$installed_flag exists: Skipping get_colpack.sh"
     72        exit 0
     73fi
    6774# --------------------------------------------------------------------------
    6875if [ -e /usr/lib64 ]
     
    114121echo_eval make install
    115122# -----------------------------------------------------------------------------
     123echo_eval touch $cppad_dir/$installed_flag
    116124echo "get_colpack: OK"
  • trunk/bin/get_eigen.sh

    r3657 r3730  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
    7 # the terms of the 
     7# the terms of the
    88#                     Eclipse Public License Version 1.0.
    99#
     
    2121# $index eigen, download and install$$
    2222# $index download, install eigen$$
    23 # $index install, eigen$$ 
     23# $index install, eigen$$
    2424#
    2525# $head Syntax$$
     
    2727#
    2828# $head Purpose$$
    29 # If you are using Unix, this command will download and install 
     29# If you are using Unix, this command will download and install
    3030# $href%http://eigen.tuxfamily.org%Eigen%$$ in the
    3131# CppAD $code build$$ directory.
    3232#
    3333# $head Distribution Directory$$
    34 # This command must be executed in the 
     34# This command must be executed in the
    3535# $cref/distribution directory/download/Distribution Directory/$$.
    3636#
     
    6666version='3.2.0'
    6767web_page='https://bitbucket.org/eigen/eigen/get'
    68 prefix=`pwd`'/build/prefix'
     68cppad_dir=`pwd`
     69prefix="$cppad_dir/build/prefix"
     70installed_flag="build/external/eigen-${version}.installed"
     71if [ -e "$installed_flag" ]
     72then
     73        echo "$installed_flag exists: Skipping get_eigen.sh"
     74        exit 0
     75fi
    6976# -----------------------------------------------------------------------------
    7077# determine which version of cmake to use
     
    124131fi
    125132# -----------------------------------------------------------------------------
    126 #
    127133echo_eval cd eigen-$version
    128134if [ ! -e build ]
     
    134140echo_eval make install
    135141echo_eval ln -s $prefix/include/eigen3/Eigen $prefix/include/Eigen
    136 #
     142# -----------------------------------------------------------------------------
     143echo_eval touch $cppad_dir/$installed_flag
    137144echo "get_eigen.sh: OK"
  • trunk/bin/get_fadbad.sh

    r2915 r3730  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
    7 # the terms of the 
     7# the terms of the
    88#                     Eclipse Public License Version 1.0.
    99#
     
    2020# $index fadbad, download and install$$
    2121# $index download, install fadbad$$
    22 # $index install, fadbad$$ 
     22# $index install, fadbad$$
    2323#
    2424# $head Syntax$$
     
    2626#
    2727# $head Purpose$$
    28 # If you are using Unix, this command will download and install 
     28# If you are using Unix, this command will download and install
    2929# $href%http://www.fadbad.com%Fadbad%$$ in the
    3030# CppAD $code build$$ directory.
    3131#
    3232# $head Distribution Directory$$
    33 # This command must be executed in the 
     33# This command must be executed in the
    3434# $cref/distribution directory/download/Distribution Directory/$$.
    3535#
     
    5959version='2.1'
    6060web_page='http://www.fadbad.com/download'
    61 prefix=`pwd`'/build/prefix'
     61cppad_dir=`pwd`
     62prefix="$cppad_dir/build/prefix"
     63installed_flag="build/external/fadbad-${version}.installed"
     64if [ -e "$installed_flag" ]
     65then
     66        echo "$installed_flag exists: Skipping get_fadbad.sh"
     67        exit 0
     68fi
    6269# -----------------------------------------------------------------------------
    6370if [ ! -d build/external ]
     
    8592fi
    8693echo_eval cp -r FADBAD++ "$prefix/include/FADBAD++"
    87 #
     94# -----------------------------------------------------------------------------
     95echo_eval touch $cppad_dir/$installed_flag
    8896echo "get_fadbad.sh: OK"
  • trunk/bin/get_ipopt.sh

    r3408 r3730  
    22# $Id$
    33# -----------------------------------------------------------------------------
    4 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     4# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    55#
    66# CppAD is distributed under multiple licenses. This distribution is under
    7 # the terms of the 
     7# the terms of the
    88#                     Eclipse Public License Version 1.0.
    99#
     
    2121# $index ipopt, download and install$$
    2222# $index download, install ipopt$$
    23 # $index install, ipopt$$ 
     23# $index install, ipopt$$
    2424#
    2525# $head Syntax$$
     
    2727#
    2828# $head Purpose$$
    29 # If you are using Unix, this command will download and install 
     29# If you are using Unix, this command will download and install
    3030# $href%http://www.coin-or.org/projects/Ipopt.xml%Ipopt%$$ in the
    3131# CppAD $code build$$ directory.
    3232#
    3333# $head Distribution Directory$$
    34 # This command must be executed in the 
     34# This command must be executed in the
    3535# $cref/distribution directory/download/Distribution Directory/$$.
    3636#
     
    6666version='3.11.9'
    6767web_page='http://www.coin-or.org/download/source/Ipopt'
    68 prefix=`pwd`'/build/prefix'
     68cppad_dir=`pwd`
     69prefix="$cppad_dir/build/prefix"
     70installed_flag="build/external/ipopt-${version}.installed"
     71if [ -e "$installed_flag" ]
     72then
     73        echo "$installed_flag exists: Skipping get_ipopt.sh"
     74        exit 0
     75fi
    6976# -----------------------------------------------------------------------------
    7077if [ ! -d build/external ]
     
    100107                echo_eval cd ThirdParty/$package
    101108                echo_eval "./get.$package"
    102                 echo_eval touch "get.$package.done" 
     109                echo_eval touch "get.$package.done"
    103110                echo_eval cd ../..
    104111        fi
     
    115122        --enable-debug \
    116123        --prefix="$prefix" \
    117         --libdir="$prefix/$libdir"
     124        --libdir="$prefix/$libdir"
     125echo_eval make install
    118126# -----------------------------------------------------------------------------
    119 echo_eval make install
    120 #
     127echo_eval touch $cppad_dir/$installed_flag
    121128echo "get_ipopt.sh: OK"
  • trunk/bin/get_sacado.sh

    r3728 r3730  
    6565# -----------------------------------------------------------------------------
    6666echo 'Download sacado to build/external and install it to build/prefix'
    67 version="trilinos-11.12.1-Source"
     67version="11.12.1"
     68trilinos_dir="trilinos-$version-Source"
    6869web_page="http://trilinos.org/oldsite/download/files"
    69 prefix=`pwd`'/build/prefix'
     70cppad_dir=`pwd`
     71prefix="$cppad_dir/build/prefix"
     72installed_flag="build/external/trilinos-${version}.installed"
     73if [ -e "$installed_flag" ]
     74then
     75        echo "$installed_flag exists: Skipping get_sacado.sh"
     76        exit 0
     77fi
    7078# -----------------------------------------------------------------------------
    7179# determine which version of cmake to use
     
    125133# -----------------------------------------------------------------------------
    126134# create the trilions source directory and change into it
    127 if [ ! -e "$version.tar.gz" ]
     135if [ ! -e "$trilinos_dir.tar.gz" ]
    128136then
    129         echo_eval wget --no-check-certificate $web_page/$version.tar.gz
     137        echo_eval wget --no-check-certificate $web_page/$trilinos_dir.tar.gz
    130138fi
    131139for package in Sacado Teuchos Trilinois
     
    133141        echo_eval rm -rf $prefix/include/$package*
    134142done
    135 if [ ! -e "$version" ]
     143if [ ! -e "$trilinos_dir" ]
    136144then
    137         echo_eval tar -xzf $version.tar.gz
     145        echo_eval tar -xzf $trilinos_dir.tar.gz
    138146        # ------------------------------------------------------------------------
    139147        # patch the cmake/tribits/modules/FindPythonInterp.cmake file
    140         file="$version/cmake/tribits/modules/FindPythonInterp.cmake"
     148        file="$trilinos_dir/cmake/tribits/modules/FindPythonInterp.cmake"
    141149        line='[HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Python\\\\PythonCore\\\\2.8\\\\'
    142150        line="${line}InstallPath]"
     
    151159        # ------------------------------------------------------------------------
    152160fi
    153 echo_eval cd $version
     161echo_eval cd $trilinos_dir
    154162# -----------------------------------------------------------------------------
    155163# change into build sub-directory
     
    160168echo_eval cd build
    161169# -----------------------------------------------------------------------------
    162 # cmake command
     170# cmake command and install
    163171if [ "$coin_lapack_blas" == 'yes' ]
    164172then
     
    184192fi
    185193echo_eval make install
    186 #
     194# -----------------------------------------------------------------------------
     195echo_eval touch $cppad_dir/$installed_flag
    187196echo "get_sacado.sh: OK"
  • trunk/bin/jenkins.sh

    r3729 r3730  
    1616        exit 1
    1717fi
    18 if [ "$1" != 'none' ] && [ "$1" != 'build' ] && [ "$1" != 'install' ]
     18if [ "$1" != '' ]
    1919then
    20         echo 'bin/junk.sh: redo_external'
    21         echo 'where redo_external is one of: build, install, none'
    22         echo
    23         echo 'build:   download build and install all the externals'
    24         echo 'install: reuse as much of previous build as possible'
    25         echo 'none:    uses the previous install (fastest option)'
     20        echo 'bin/junk.sh no longer has any arguments'
    2621        exit 1
    2722fi
    28 redo_external="$1"
    2923# -----------------------------------------------------------------------------
    3024# distribution directory corresponding to this version of CppAD
     
    6761g++ --version
    6862# -----------------------------------------------------------------------
    69 # Build and install external packages
    70 if [ "$redo_external" != 'none' ]
    71 then
    72         # -------------------------------------------------------------------
    73         # this comand cleans out the previous install for all externals
    74         echo_eval rm -rf build/prefix
    75         # -------------------------------------------------------------------
    76         if [ "$redo_external" == 'build' ]
    77         then
    78                 # This command causes a new download, and compile for all externals
    79                 echo_eval rm -rf build/external
    80         fi
    81         # -------------------------------------------------------------------
    82         # Running bin/get_fadbad.sh will install include files in
    83         #       $trunk_dir/build/prefix/include/FADBAD++
    84         log_eval bin/get_fadbad.sh
    85         # -------------------------------------------------------------------
    86         # Running bin/get_eigen.sh will install include files in
    87         #       $trunk_dir/build/prefix/include/Eigen
    88         log_eval bin/get_eigen.sh
    89         # -------------------------------------------------------------------
    90         # Running bin/get_ipopt.sh will install include files in
    91         #       $trunk_dir/build/prefix/include/coin
    92         # and library files in
    93         #       $trunk_dir/build/prefix/$libdir
    94         # where $libdir is 'lib64' if /usr/lib64 exists and 'lib' otherwise.
    95         log_eval bin/get_ipopt.sh
    96         # -------------------------------------------------------------------
    97         # Running bin/get_sacado.sh will install include files in
    98         #       $trunk_dir/build/prefix/include
    99         # and library files in
    100         #       $trunk_dir/build/prefix/$libdir
    101         log_eval bin/get_sacado.sh
    102         # -------------------------------------------------------------------
    103         # Running bin/get_colpack.sh will install library files in
    104         #       $trunk_dir/build/prefix/$libdir
    105         log_eval bin/get_colpack.sh
    106         # -------------------------------------------------------------------
    107         # Running bin/get_acolc.sh will install include files in
    108         #       $trunk_dir/build/prefix/include/adolc
    109         # and library files in
    110         #       $trunk_dir/build/prefix/$libdir
    111         log_eval bin/get_adolc.sh
    112         # -------------------------------------------------------------------
    113 fi
    114 # -----------------------------------------------------------------------
     63# Running bin/get_fadbad.sh ensures its include files are in
     64#       $trunk_dir/build/prefix/include/FADBAD++
     65log_eval bin/get_fadbad.sh
     66# -------------------------------------------------------------------
     67# Running bin/get_eigen.sh ensures its include files are in
     68#       $trunk_dir/build/prefix/include/Eigen
     69log_eval bin/get_eigen.sh
     70# -------------------------------------------------------------------
     71# Running bin/get_ipopt.sh ensures its include files are in
     72#       $trunk_dir/build/prefix/include/coin
     73# and library files in
     74#       $trunk_dir/build/prefix/$libdir
     75# where $libdir is 'lib64' if /usr/lib64 exists and 'lib' otherwise.
     76log_eval bin/get_ipopt.sh
     77# -------------------------------------------------------------------
     78# Running bin/get_sacado.sh ensures its include files are in
     79#       $trunk_dir/build/prefix/include
     80# and library files in
     81#       $trunk_dir/build/prefix/$libdir
     82log_eval bin/get_sacado.sh
     83# -------------------------------------------------------------------
     84# Running bin/get_colpack.sh ensures its library files are in
     85#       $trunk_dir/build/prefix/$libdir
     86log_eval bin/get_colpack.sh
     87# -------------------------------------------------------------------
     88# Running bin/get_acolc.sh ensures its include files are in
     89#       $trunk_dir/build/prefix/include/adolc
     90# and library files in
     91#       $trunk_dir/build/prefix/$libdir
     92log_eval bin/get_adolc.sh
     93# -------------------------------------------------------------------
    11594system_name=`uname | sed -e 's|\(......\).*|\1|'`
    11695if [ "$system_name" == 'CYGWIN' ]
  • trunk/configure

    r3705 r3730  
    676676CppAD_HAVE_AR_FALSE
    677677CppAD_HAVE_AR_TRUE
    678 ac_ct_AR
    679 AR
    680678CppAD_PKG_CONFIG_FALSE
    681679CppAD_PKG_CONFIG_TRUE
     
    684682FCFLAGS
    685683FC
    686 am__fastdepCC_FALSE
    687 am__fastdepCC_TRUE
    688 CCDEPMODE
    689 ac_ct_CC
    690 CFLAGS
    691 CC
    692684am__fastdepCXX_FALSE
    693685am__fastdepCXX_TRUE
    694686CXXDEPMODE
    695 am__nodep
    696 AMDEPBACKSLASH
    697 AMDEP_FALSE
    698 AMDEP_TRUE
    699 am__quote
    700 am__include
    701 DEPDIR
    702 OBJEXT
    703 EXEEXT
    704687ac_ct_CXX
    705 CPPFLAGS
    706 LDFLAGS
    707688CXXFLAGS
    708689CXX
     
    749730CppAD_DOCUMENTATION_FALSE
    750731CppAD_DOCUMENTATION_TRUE
     732am__fastdepCC_FALSE
     733am__fastdepCC_TRUE
     734CCDEPMODE
     735am__nodep
     736AMDEPBACKSLASH
     737AMDEP_FALSE
     738AMDEP_TRUE
     739am__quote
     740am__include
     741DEPDIR
     742OBJEXT
     743EXEEXT
     744ac_ct_CC
     745CPPFLAGS
     746LDFLAGS
     747CFLAGS
     748CC
     749ac_ct_AR
     750AR
    751751am__untar
    752752am__tar
     
    822822enable_silent_rules
    823823enable_maintainer_mode
     824enable_dependency_tracking
    824825with_SpeedExample
    825826with_profiling
     
    837838with_sparse_list
    838839with_implicit_ctor
    839 enable_dependency_tracking
    840840'
    841841      ac_precious_vars='build_alias
    842842host_alias
    843843target_alias
     844CC
     845CFLAGS
     846LDFLAGS
     847LIBS
     848CPPFLAGS
    844849POSTFIX_DIR
    845850ADOLC_DIR
     
    856861CXX
    857862CXXFLAGS
    858 LDFLAGS
    859 LIBS
    860 CPPFLAGS
    861863CCC
    862 CC
    863 CFLAGS
    864864FC
    865865FCFLAGS
     
    14881488                          enable make rules and dependencies not useful (and
    14891489                          sometimes confusing) to the casual installer
    1490   --enable-msvc           Prefer (i)cl/ifort/link over GNU on MinGW/Cygwin.
    14911490  --enable-dependency-tracking
    14921491                          do not reject slow dependency extractors
    14931492  --disable-dependency-tracking
    14941493                          speeds up one-time build
     1494  --enable-msvc           Prefer (i)cl/ifort/link over GNU on MinGW/Cygwin.
    14951495
    14961496Optional Packages:
     
    15141514
    15151515Some influential environment variables:
     1516  CC          C compiler command
     1517  CFLAGS      C compiler flags
     1518  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
     1519              nonstandard directory <lib dir>
     1520  LIBS        libraries to pass to the linker, e.g. -l<library>
     1521  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
     1522              you have headers in a nonstandard directory <include dir>
    15161523  POSTFIX_DIR postfix directory for CppAD installation
    15171524  ADOLC_DIR   value of configure prefix directory during Adolc install
     
    15321539  CXX         C++ compiler command
    15331540  CXXFLAGS    C++ compiler flags
    1534   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
    1535               nonstandard directory <lib dir>
    1536   LIBS        libraries to pass to the linker, e.g. -l<library>
    1537   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
    1538               you have headers in a nonstandard directory <include dir>
    1539   CC          C compiler command
    1540   CFLAGS      C compiler flags
    15411541  FC          Fortran compiler command
    15421542  FCFLAGS     Fortran compiler flags
     
    16221622## Autoconf initialization. ##
    16231623## ------------------------ ##
     1624
     1625# ac_fn_c_try_compile LINENO
     1626# --------------------------
     1627# Try to compile conftest.$ac_ext, and return whether this succeeded.
     1628ac_fn_c_try_compile ()
     1629{
     1630  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
     1631  rm -f conftest.$ac_objext
     1632  if { { ac_try="$ac_compile"
     1633case "(($ac_try" in
     1634  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     1635  *) ac_try_echo=$ac_try;;
     1636esac
     1637eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
     1638$as_echo "$ac_try_echo"; } >&5
     1639  (eval "$ac_compile") 2>conftest.err
     1640  ac_status=$?
     1641  if test -s conftest.err; then
     1642    grep -v '^ *+' conftest.err >conftest.er1
     1643    cat conftest.er1 >&5
     1644    mv -f conftest.er1 conftest.err
     1645  fi
     1646  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
     1647  test $ac_status = 0; } && {
     1648         test -z "$ac_c_werror_flag" ||
     1649         test ! -s conftest.err
     1650       } && test -s conftest.$ac_objext; then :
     1651  ac_retval=0
     1652else
     1653  $as_echo "$as_me: failed program was:" >&5
     1654sed 's/^/| /' conftest.$ac_ext >&5
     1655
     1656        ac_retval=1
     1657fi
     1658  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
     1659  as_fn_set_status $ac_retval
     1660
     1661} # ac_fn_c_try_compile
    16241662
    16251663# ac_fn_cxx_try_compile LINENO
     
    16601698
    16611699} # ac_fn_cxx_try_compile
    1662 
    1663 # ac_fn_c_try_compile LINENO
    1664 # --------------------------
    1665 # Try to compile conftest.$ac_ext, and return whether this succeeded.
    1666 ac_fn_c_try_compile ()
    1667 {
    1668   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1669   rm -f conftest.$ac_objext
    1670   if { { ac_try="$ac_compile"
    1671 case "(($ac_try" in
    1672   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    1673   *) ac_try_echo=$ac_try;;
    1674 esac
    1675 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    1676 $as_echo "$ac_try_echo"; } >&5
    1677   (eval "$ac_compile") 2>conftest.err
    1678   ac_status=$?
    1679   if test -s conftest.err; then
    1680     grep -v '^ *+' conftest.err >conftest.er1
    1681     cat conftest.er1 >&5
    1682     mv -f conftest.er1 conftest.err
    1683   fi
    1684   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    1685   test $ac_status = 0; } && {
    1686          test -z "$ac_c_werror_flag" ||
    1687          test ! -s conftest.err
    1688        } && test -s conftest.$ac_objext; then :
    1689   ac_retval=0
    1690 else
    1691   $as_echo "$as_me: failed program was:" >&5
    1692 sed 's/^/| /' conftest.$ac_ext >&5
    1693 
    1694         ac_retval=1
    1695 fi
    1696   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1697   as_fn_set_status $ac_retval
    1698 
    1699 } # ac_fn_c_try_compile
    17001700
    17011701# ac_fn_fc_try_compile LINENO
     
    32223222
    32233223
    3224 { $as_echo "$as_me:${as_lineno-$LINENO}: *** Check command line arguments that are longer used ****" >&5
    3225 $as_echo "$as_me: *** Check command line arguments that are longer used ****" >&6;}
    3226 
    3227 if test "$CPP_ERROR_WARN" != "" ; then
    3228     as_fn_error $? "The CPP_ERROR_WARN configure option is now CXX_FLAGS" "$LINENO" 5
    3229 fi
    3230 
    3231 # Check whether --with-SpeedExample was given.
    3232 if test "${with_SpeedExample+set}" = set; then :
    3233   withval=$with_SpeedExample; SpeedExample="yes"
    3234 else
    3235   SpeedExample="no"
    3236 
    3237 fi
    3238 
    3239 if test "$SpeedExample" = "yes" ; then
    3240     as_fn_error $? "--with-SpeedExample not necessary, see install instructions." "$LINENO" 5
    3241 fi
    3242 
    3243 # Check whether --with-profiling was given.
    3244 if test "${with_profiling+set}" = set; then :
    3245   withval=$with_profiling; profiling="yes"
    3246 else
    3247   profiling="no"
    3248 
    3249 fi
    3250 
    3251 if test "$profiling" = "yes" ; then
    3252     as_fn_error $? "--with-profiling not necessary, see install instructions." "$LINENO" 5
    3253 fi
    3254 
    3255 # Check whether --with-Speed was given.
    3256 if test "${with_Speed+set}" = set; then :
    3257   withval=$with_Speed; Speed="yes"
    3258 else
    3259   Speed="no"
    3260 
    3261 fi
    3262 
    3263 if test "$Speed" = "yes" ; then
    3264     as_fn_error $? "--with-Speed not necessary, see install instructions." "$LINENO" 5
    3265 fi
    3266 
    3267 # Check whether --with-Introduction was given.
    3268 if test "${with_Introduction+set}" = set; then :
    3269   withval=$with_Introduction; Introduction="yes"
    3270 else
    3271   Introduction="no"
    3272 
    3273 fi
    3274 
    3275 if test "$Introduction" = "yes" ; then
    3276     as_fn_error $? "--with-Introduction not necessary, see install instructions." "$LINENO" 5
    3277 fi
    3278 
    3279 # Check whether --with-Example was given.
    3280 if test "${with_Example+set}" = set; then :
    3281   withval=$with_Example; Example="yes"
    3282 else
    3283   Example="no"
    3284 
    3285 fi
    3286 
    3287 if test "$Example" = "yes" ; then
    3288     as_fn_error $? "--with-Example not necessary, see install instructions." "$LINENO" 5
    3289 fi
    3290 
    3291 # Check whether --with-TestMore was given.
    3292 if test "${with_TestMore+set}" = set; then :
    3293   withval=$with_TestMore; TestMore="yes"
    3294 else
    3295   TestMore="no"
    3296 
    3297 fi
    3298 
    3299 if test "$TestMore" = "yes" ; then
    3300     as_fn_error $? "--with-TestMore not necessary, see install instructions." "$LINENO" 5
    3301 fi
    3302 
    3303 # Check whether --with-PrintFor was given.
    3304 if test "${with_PrintFor+set}" = set; then :
    3305   withval=$with_PrintFor; PrintFor="yes"
    3306 else
    3307   PrintFor="no"
    3308 
    3309 fi
    3310 
    3311 if test "$PrintFor" = "yes" ; then
    3312     as_fn_error $? "--with-PrintFor not necessary, see install instructions." "$LINENO" 5
    3313 fi
    3314 { $as_echo "$as_me:${as_lineno-$LINENO}: ******  Check command line arguments that are used ***********" >&5
    3315 $as_echo "$as_me: ******  Check command line arguments that are used ***********" >&6;}
    3316 
    3317 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --enable-msvc" >&5
    3318 $as_echo_n "checking --enable-msvc... " >&6; }
    3319 # Check whether --enable-msvc was given.
    3320 if test "${enable_msvc+set}" = set; then :
    3321   enableval=$enable_msvc; enable_msvc=$enableval
    3322 else
    3323   enable_msvc=no
    3324 
    3325 fi
    3326 
    3327 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_msvc" >&5
    3328 $as_echo "$enable_msvc" >&6; }
    3329 
    3330 
    3331 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --prefix" >&5
    3332 $as_echo_n "checking --prefix... " >&6; }
    3333 if test "$prefix" = "NONE" ; then
    3334         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOME" >&5
    3335 $as_echo "$HOME" >&6; }
    3336 else
    3337         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $prefix" >&5
    3338 $as_echo "$prefix" >&6; }
    3339 fi
    3340 
    3341 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-Documentation" >&5
    3342 $as_echo_n "checking --with-Documentation... " >&6; }
    3343 
    3344 # Check whether --with-Documentation was given.
    3345 if test "${with_Documentation+set}" = set; then :
    3346   withval=$with_Documentation; Documentation="yes"
    3347 else
    3348   Documentation="no"
    3349 
    3350 fi
    3351 
    3352  if test "$Documentation" = "yes"; then
    3353   CppAD_DOCUMENTATION_TRUE=
    3354   CppAD_DOCUMENTATION_FALSE='#'
    3355 else
    3356   CppAD_DOCUMENTATION_TRUE='#'
    3357   CppAD_DOCUMENTATION_FALSE=
    3358 fi
    3359 
    3360 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $Documentation" >&5
    3361 $as_echo "$Documentation" >&6; }
    3362 
    3363 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-stdvector" >&5
    3364 $as_echo_n "checking --with-stdvector... " >&6; }
    3365 
    3366 # Check whether --with-stdvector was given.
    3367 if test "${with_stdvector+set}" = set; then :
    3368   withval=$with_stdvector; stdvector="yes"
    3369 else
    3370   stdvector="no"
    3371 
    3372 fi
    3373 
    3374 if test "$stdvector" = "yes" ; then
    3375         cppad_stdvector=1
    3376 
    3377 else
    3378         cppad_stdvector=0
    3379 
    3380 fi
    3381 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $stdvector" >&5
    3382 $as_echo "$stdvector" >&6; }
    3383 
    3384 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-boostvector" >&5
    3385 $as_echo_n "checking --with-boostvector... " >&6; }
    3386 
    3387 # Check whether --with-boostvector was given.
    3388 if test "${with_boostvector+set}" = set; then :
    3389   withval=$with_boostvector; boostvector="yes"
    3390 else
    3391   boostvector="no"
    3392 
    3393 fi
    3394 
    3395 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boostvector" >&5
    3396 $as_echo "$boostvector" >&6; }
    3397 if test "$boostvector" = "yes" ; then
    3398         if test "$stdvector" != "no" ; then
    3399                 as_fn_error $? "cannot --with both stdvector and boostvector" "$LINENO" 5
    3400         fi
    3401         cppad_boostvector=1
    3402 
    3403 else
    3404         cppad_boostvector=0
    3405 
    3406 fi
    3407 
    3408 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-eigenvector" >&5
    3409 $as_echo_n "checking --with-eigenvector... " >&6; }
    3410 
    3411 # Check whether --with-eigenvector was given.
    3412 if test "${with_eigenvector+set}" = set; then :
    3413   withval=$with_eigenvector; eigenvector="yes"
    3414 else
    3415   eigenvector="no"
    3416 
    3417 fi
    3418 
    3419 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $eigenvector" >&5
    3420 $as_echo "$eigenvector" >&6; }
    3421 if test "$eigenvector" = "yes" ; then
    3422         if test "$stdvector" != "no" ; then
    3423                 as_fn_error $? "cannot --with both stdvector and eigenvector" "$LINENO" 5
    3424         fi
    3425         if test "$boostvector" != "no" ; then
    3426                 as_fn_error $? "cannot --with both boostvector and eigenvector" "$LINENO" 5
    3427         fi
    3428         cppad_eigenvector=1
    3429 
    3430 else
    3431         cppad_eigenvector=0
    3432 
    3433 fi
    3434 
    3435 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-sparse_set" >&5
    3436 $as_echo_n "checking --with-sparse_set... " >&6; }
    3437 
    3438 # Check whether --with-sparse_set was given.
    3439 if test "${with_sparse_set+set}" = set; then :
    3440   withval=$with_sparse_set; sparse_set="yes"
    3441 else
    3442   sparse_set="no"
    3443 
    3444 fi
    3445 
    3446 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $sparse_set" >&5
    3447 $as_echo "$sparse_set" >&6; }
    3448 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-sparse_list" >&5
    3449 $as_echo_n "checking --with-sparse_list... " >&6; }
    3450 
    3451 # Check whether --with-sparse_list was given.
    3452 if test "${with_sparse_list+set}" = set; then :
    3453   withval=$with_sparse_list; sparse_list="yes"
    3454 else
    3455   sparse_list="no"
    3456 
    3457 fi
    3458 
    3459 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $sparse_list" >&5
    3460 $as_echo "$sparse_list" >&6; }
    3461 if test "$sparse_set" = "yes" ; then
    3462         if test "$sparse_list" == "yes" ; then
    3463                 as_fn_error $? "cannot --with both sparse_set and sparse_list" "$LINENO" 5
    3464         fi
    3465         cppad_internal_sparse_set=sparse_set
    3466 
    3467 else
    3468         cppad_internal_sparse_set=sparse_list
    3469 
    3470 fi
    3471 
    3472 
    3473 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-implicit_ctor" >&5
    3474 $as_echo_n "checking --with-implicit_ctor... " >&6; }
    3475 
    3476 # Check whether --with-implicit_ctor was given.
    3477 if test "${with_implicit_ctor+set}" = set; then :
    3478   withval=$with_implicit_ctor; implicit_ctor="yes"
    3479 else
    3480   implicit_ctor="no"
    3481 
    3482 fi
    3483 
    3484 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $implicit_ctor" >&5
    3485 $as_echo "$implicit_ctor" >&6; }
    3486 if test "$implicit_ctor" = "yes" ; then
    3487         cppad_implicit_ctor_from_any_type="1"
    3488 
    3489 else
    3490         cppad_implicit_ctor_from_any_type="0"
    3491 
    3492 fi
    3493 
    3494 { $as_echo "$as_me:${as_lineno-$LINENO}: checking POSTFIX_DIR" >&5
    3495 $as_echo_n "checking POSTFIX_DIR... " >&6; }
    3496 
    3497  if test "$POSTFIX_DIR" != ""; then
    3498   CppAD_POSTFIX_TRUE=
    3499   CppAD_POSTFIX_FALSE='#'
    3500 else
    3501   CppAD_POSTFIX_TRUE='#'
    3502   CppAD_POSTFIX_FALSE=
    3503 fi
    3504 
    3505 if test "$POSTFIX_DIR" != "" ; then
    3506         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POSTFIX_DIR" >&5
    3507 $as_echo "$POSTFIX_DIR" >&6; }
    3508 else
    3509         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3510 $as_echo "no" >&6; }
    3511 fi
    3512 
    3513 { $as_echo "$as_me:${as_lineno-$LINENO}: checking ADOLC_DIR" >&5
    3514 $as_echo_n "checking ADOLC_DIR... " >&6; }
    3515 
    3516  if test "$ADOLC_DIR" != ""; then
    3517   CppAD_ADOLC_TRUE=
    3518   CppAD_ADOLC_FALSE='#'
    3519 else
    3520   CppAD_ADOLC_TRUE='#'
    3521   CppAD_ADOLC_FALSE=
    3522 fi
    3523 
    3524 if test "$ADOLC_DIR" != "" ; then
    3525         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ADOLC_DIR" >&5
    3526 $as_echo "$ADOLC_DIR" >&6; }
    3527         if test "$have_ar" = "no"; then
    3528                 as_fn_error $? "ar is missing and ADOLC_DIR is present" "$LINENO" 5
    3529         fi
    3530 else
    3531         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3532 $as_echo "no" >&6; }
    3533 fi
    3534 
    3535 { $as_echo "$as_me:${as_lineno-$LINENO}: checking EIGEN_DIR" >&5
    3536 $as_echo_n "checking EIGEN_DIR... " >&6; }
    3537 
    3538  if test "$EIGEN_DIR" != ""; then
    3539   CppAD_EIGEN_DIR_TRUE=
    3540   CppAD_EIGEN_DIR_FALSE='#'
    3541 else
    3542   CppAD_EIGEN_DIR_TRUE='#'
    3543   CppAD_EIGEN_DIR_FALSE=
    3544 fi
    3545 
    3546 if test "$EIGEN_DIR" != "" ; then
    3547         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EIGEN_DIR" >&5
    3548 $as_echo "$EIGEN_DIR" >&6; }
    3549         EIGEN_INCLUDE=-I$EIGEN_DIR/include
    3550 
    3551 else
    3552         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3553 $as_echo "no" >&6; }
    3554 
    3555 fi
    3556 
    3557 { $as_echo "$as_me:${as_lineno-$LINENO}: checking FADBAD_DIR" >&5
    3558 $as_echo_n "checking FADBAD_DIR... " >&6; }
    3559 
    3560  if test "$FADBAD_DIR" != ""; then
    3561   CppAD_FADBAD_TRUE=
    3562   CppAD_FADBAD_FALSE='#'
    3563 else
    3564   CppAD_FADBAD_TRUE='#'
    3565   CppAD_FADBAD_FALSE=
    3566 fi
    3567 
    3568 if test "$FADBAD_DIR" != "" ; then
    3569         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FADBAD_DIR" >&5
    3570 $as_echo "$FADBAD_DIR" >&6; }
    3571         if test "$have_ar" = "no"; then
    3572                 as_fn_error $? "ar is missing and FADBAD_DIR is present" "$LINENO" 5
    3573         fi
    3574 else
    3575         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3576 $as_echo "no" >&6; }
    3577 fi
    3578 
    3579 { $as_echo "$as_me:${as_lineno-$LINENO}: checking SACADO_DIR" >&5
    3580 $as_echo_n "checking SACADO_DIR... " >&6; }
    3581 
    3582  if test "$SACADO_DIR" != ""; then
    3583   CppAD_SACADO_TRUE=
    3584   CppAD_SACADO_FALSE='#'
    3585 else
    3586   CppAD_SACADO_TRUE='#'
    3587   CppAD_SACADO_FALSE=
    3588 fi
    3589 
    3590 if test "$SACADO_DIR" != "" ; then
    3591         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SACADO_DIR" >&5
    3592 $as_echo "$SACADO_DIR" >&6; }
    3593         if test "$have_ar" = "no"; then
    3594                 as_fn_error $? "ar is missing and SACADO_DIR is present" "$LINENO" 5
    3595         fi
    3596 else
    3597         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3598 $as_echo "no" >&6; }
    3599 fi
    3600 
    3601 { $as_echo "$as_me:${as_lineno-$LINENO}: checking IPOPT_DIR" >&5
    3602 $as_echo_n "checking IPOPT_DIR... " >&6; }
    3603 
    3604  if test "$IPOPT_DIR" != ""; then
    3605   CppAD_IPOPT_TRUE=
    3606   CppAD_IPOPT_FALSE='#'
    3607 else
    3608   CppAD_IPOPT_TRUE='#'
    3609   CppAD_IPOPT_FALSE=
    3610 fi
    3611 
    3612 if test "$IPOPT_DIR" != "" ; then
    3613         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $IPOPT_DIR" >&5
    3614 $as_echo "$IPOPT_DIR" >&6; }
    3615         if test "$have_ar" = "no"; then
    3616                 as_fn_error $? "ar is missing and IPOPT_DIR is present" "$LINENO" 5
    3617         fi
    3618 else
    3619         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3620 $as_echo "no" >&6; }
    3621 fi
    3622 
    3623 { $as_echo "$as_me:${as_lineno-$LINENO}: checking BOOST_DIR" >&5
    3624 $as_echo_n "checking BOOST_DIR... " >&6; }
    3625 
    3626  if test "$BOOST_DIR" != ""; then
    3627   CppAD_BOOST_DIR_TRUE=
    3628   CppAD_BOOST_DIR_FALSE='#'
    3629 else
    3630   CppAD_BOOST_DIR_TRUE='#'
    3631   CppAD_BOOST_DIR_FALSE=
    3632 fi
    3633 
    3634 if test "$BOOST_DIR" != "" ; then
    3635         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOST_DIR" >&5
    3636 $as_echo "$BOOST_DIR" >&6; }
    3637         BOOST_INCLUDE=-I$BOOST_DIR/include
    3638 
    3639 else
    3640         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3641 $as_echo "no" >&6; }
    3642 
    3643 fi
    3644 
    3645 #
    3646 { $as_echo "$as_me:${as_lineno-$LINENO}: checking CXX_FLAGS" >&5
    3647 $as_echo_n "checking CXX_FLAGS... " >&6; }
    3648 
    3649 # cxx_flags for fadbad and eigen
    3650 if test "$CXX_FLAGS" != "" ; then
    3651         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX_FLAGS" >&5
    3652 $as_echo "$CXX_FLAGS" >&6; }
    3653         cxx_flags_fadbad=`echo "$CXX_FLAGS" | sed -e 's|-Wshadow||'`
    3654         cxx_flags_eigen="$cxx_flags_fadbda -Wno-long-long"
    3655 else
    3656         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3657 $as_echo "no" >&6; }
    3658         cxx_flags_fadbad=""
    3659         cxx_flags_eigen=""
    3660 fi
    3661 CXX_FLAGS_FADBAD="$cxx_flags_fadbad"
    3662 
    3663 CXX_FLAGS_EIGEN="$cxx_flags_eigen"
    3664 
    3665 
    3666 { $as_echo "$as_me:${as_lineno-$LINENO}: checking OPENMP_FLAGS" >&5
    3667 $as_echo_n "checking OPENMP_FLAGS... " >&6; }
    3668 
    3669 if test "$OPENMP_FLAGS" != "" ; then
    3670         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENMP_FLAGS" >&5
    3671 $as_echo "$OPENMP_FLAGS" >&6; }
    3672 else
    3673         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3674 $as_echo "no" >&6; }
    3675 fi
    3676  if test "$OPENMP_FLAGS" != ""; then
    3677   CppAD_OPENMP_TRUE=
    3678   CppAD_OPENMP_FALSE='#'
    3679 else
    3680   CppAD_OPENMP_TRUE='#'
    3681   CppAD_OPENMP_FALSE=
    3682 fi
    3683 
    3684 
    3685 { $as_echo "$as_me:${as_lineno-$LINENO}: checking MAX_NUM_THREADS" >&5
    3686 $as_echo_n "checking MAX_NUM_THREADS... " >&6; }
    3687 
    3688 if test "$MAX_NUM_THREADS" != "" ; then
    3689         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAX_NUM_THREADS" >&5
    3690 $as_echo "$MAX_NUM_THREADS" >&6; }
    3691         if test "$MAX_NUM_THREADS" -lt "4" ; then
    3692                 as_fn_error $? " MAX_NUM_THREADS=$MAX_NUM_THREADS is less than 4
    3693                 " "$LINENO" 5
    3694         fi
    3695         max_num_threads="$MAX_NUM_THREADS"
    3696 else
    3697         max_num_threads="48"
    3698         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using default value $max_num_threads" >&5
    3699 $as_echo "no, using default value $max_num_threads" >&6; }
    3700 fi
    3701 cppad_max_num_threads=$max_num_threads
    3702 
    3703 
    3704 { $as_echo "$as_me:${as_lineno-$LINENO}: checking TAPE_ADDR_TYPE" >&5
    3705 $as_echo_n "checking TAPE_ADDR_TYPE... " >&6; }
    3706 
    3707 if test "$TAPE_ADDR_TYPE" == "" ; then
    3708         addr_t="unsigned int"
    3709 else
    3710         addr_t="$TAPE_ADDR_TYPE"
    3711 fi
    3712 cppad_tape_addr_type=$addr_t
    3713 
    3714 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $addr_t" >&5
    3715 $as_echo "$addr_t" >&6; }
    3716 ok="no"
    3717 if test "$addr_t" == "size_t" ; then
    3718         ok="yes"
    3719 fi
    3720 if test "$addr_t" == "int" ; then
    3721         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: TAPE_ADDR_TYPE=int is for CppAD developers (not users)
    3722         " >&5
    3723 $as_echo "$as_me: WARNING: TAPE_ADDR_TYPE=int is for CppAD developers (not users)
    3724         " >&2;}
    3725         ok="yes"
    3726 fi
    3727 if test "$addr_t" == "unsigned int" ; then
    3728         ok="yes"
    3729 fi
    3730 if test "$addr_t" == "unsigned short int" ; then
    3731         ok="yes"
    3732 fi
    3733 if test "$ok" == "no" ; then
    3734         as_fn_error $? "$addr_t is not a valid choice for TAPE_ADDR_TYPE
    3735         " "$LINENO" 5
    3736 fi
    3737 
    3738 { $as_echo "$as_me:${as_lineno-$LINENO}: checking TAPE_ID_TYPE" >&5
    3739 $as_echo_n "checking TAPE_ID_TYPE... " >&6; }
    3740 
    3741 if test "$TAPE_ID_TYPE" == "" ; then
    3742         tape_id_t="unsigned int"
    3743 else
    3744         tape_id_t="$TAPE_ID_TYPE"
    3745 fi
    3746 cppad_tape_id_type=$tape_id_t
    3747 
    3748 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tape_id_t" >&5
    3749 $as_echo "$tape_id_t" >&6; }
    3750 ok="no"
    3751 if test "$tape_id_t" == "size_t" ; then
    3752         ok="yes"
    3753 fi
    3754 if test "$tape_id_t" == "int" ; then
    3755         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: TAPE_ID_TYPE=int is for CppAD developers (not users)
    3756         " >&5
    3757 $as_echo "$as_me: WARNING: TAPE_ID_TYPE=int is for CppAD developers (not users)
    3758         " >&2;}
    3759         ok="yes"
    3760 fi
    3761 if test "$tape_id_t" == "unsigned int" ; then
    3762         ok="yes"
    3763 fi
    3764 if test "$tape_id_t" == "unsigned short int" ; then
    3765         ok="yes"
    3766 fi
    3767 if test "$ok" == "no" ; then
    3768         as_fn_error $? "$tape_id_t is not a valid choice for TAPE_ID_TYPE
    3769         " "$LINENO" 5
    3770 fi
    3771 { $as_echo "$as_me:${as_lineno-$LINENO}: ********** End Checking Command Line arguments ***************" >&5
    3772 $as_echo "$as_me: ********** End Checking Command Line arguments ***************" >&6;}
    3773 
    3774 if test "$enable_msvc" == "no"
    3775 then
    3776         cxx_list="g++ clang++ CC pgCC icpc gpp cxx cc++"
    3777         cc_list="gcc clang cc pgcc icc"
    3778         fc_list="gfortran ifort g95 fort77 f77 g77 pgf90 pgf77 ifc frt af77"
    3779 else
    3780                 cxx_list="icl cl g++"
    3781         cc_list="icl cl gcc"
    3782         fc_list="ifort gfortran"
    3783 fi
    3784 
    3785 ac_ext=cpp
    3786 ac_cpp='$CXXCPP $CPPFLAGS'
    3787 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    3788 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    3789 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
    3790 if test -z "$CXX"; then
    3791   if test -n "$CCC"; then
    3792     CXX=$CCC
    3793   else
    3794     if test -n "$ac_tool_prefix"; then
    3795   for ac_prog in $cxx_list
    3796   do
    3797     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
    3798 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     3224# check if we have ar program
     3225have_ar='yes'
     3226DEPDIR="${am__leading_dot}deps"
     3227
     3228ac_config_commands="$ac_config_commands depfiles"
     3229
     3230
     3231am_make=${MAKE-make}
     3232cat > confinc << 'END'
     3233am__doit:
     3234        @echo this is the am__doit target
     3235.PHONY: am__doit
     3236END
     3237# If we don't find an include directive, just comment out the code.
     3238{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
     3239$as_echo_n "checking for style of include used by $am_make... " >&6; }
     3240am__include="#"
     3241am__quote=
     3242_am_result=none
     3243# First try GNU make style include.
     3244echo "include confinc" > confmf
     3245# Ignore all kinds of additional output from 'make'.
     3246case `$am_make -s -f confmf 2> /dev/null` in #(
     3247*the\ am__doit\ target*)
     3248  am__include=include
     3249  am__quote=
     3250  _am_result=GNU
     3251  ;;
     3252esac
     3253# Now try BSD make style include.
     3254if test "$am__include" = "#"; then
     3255   echo '.include "confinc"' > confmf
     3256   case `$am_make -s -f confmf 2> /dev/null` in #(
     3257   *the\ am__doit\ target*)
     3258     am__include=.include
     3259     am__quote="\""
     3260     _am_result=BSD
     3261     ;;
     3262   esac
     3263fi
     3264
     3265
     3266{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
     3267$as_echo "$_am_result" >&6; }
     3268rm -f confinc confmf
     3269
     3270# Check whether --enable-dependency-tracking was given.
     3271if test "${enable_dependency_tracking+set}" = set; then :
     3272  enableval=$enable_dependency_tracking;
     3273fi
     3274
     3275if test "x$enable_dependency_tracking" != xno; then
     3276  am_depcomp="$ac_aux_dir/depcomp"
     3277  AMDEPBACKSLASH='\'
     3278  am__nodep='_no'
     3279fi
     3280 if test "x$enable_dependency_tracking" != xno; then
     3281  AMDEP_TRUE=
     3282  AMDEP_FALSE='#'
     3283else
     3284  AMDEP_TRUE='#'
     3285  AMDEP_FALSE=
     3286fi
     3287
     3288
     3289ac_ext=c
     3290ac_cpp='$CPP $CPPFLAGS'
     3291ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     3292ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     3293ac_compiler_gnu=$ac_cv_c_compiler_gnu
     3294if test -n "$ac_tool_prefix"; then
     3295  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
     3296set dummy ${ac_tool_prefix}gcc; ac_word=$2
    37993297{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    38003298$as_echo_n "checking for $ac_word... " >&6; }
    3801 if ${ac_cv_prog_CXX+:} false; then :
     3299if ${ac_cv_prog_CC+:} false; then :
    38023300  $as_echo_n "(cached) " >&6
    38033301else
    3804   if test -n "$CXX"; then
    3805   ac_cv_prog_CXX="$CXX" # Let the user override the test.
     3302  if test -n "$CC"; then
     3303  ac_cv_prog_CC="$CC" # Let the user override the test.
    38063304else
    38073305as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     
    38123310    for ac_exec_ext in '' $ac_executable_extensions; do
    38133311  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    3814     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
     3312    ac_cv_prog_CC="${ac_tool_prefix}gcc"
    38153313    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    38163314    break 2
     
    38223320fi
    38233321fi
    3824 CXX=$ac_cv_prog_CXX
    3825 if test -n "$CXX"; then
    3826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
    3827 $as_echo "$CXX" >&6; }
     3322CC=$ac_cv_prog_CC
     3323if test -n "$CC"; then
     3324  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
     3325$as_echo "$CC" >&6; }
    38283326else
    38293327  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     
    38323330
    38333331
    3834     test -n "$CXX" && break
    3835   done
    3836 fi
    3837 if test -z "$CXX"; then
    3838   ac_ct_CXX=$CXX
    3839   for ac_prog in $cxx_list
    3840 do
    3841   # Extract the first word of "$ac_prog", so it can be a program name with args.
    3842 set dummy $ac_prog; ac_word=$2
     3332fi
     3333if test -z "$ac_cv_prog_CC"; then
     3334  ac_ct_CC=$CC
     3335  # Extract the first word of "gcc", so it can be a program name with args.
     3336set dummy gcc; ac_word=$2
    38433337{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    38443338$as_echo_n "checking for $ac_word... " >&6; }
    3845 if ${ac_cv_prog_ac_ct_CXX+:} false; then :
     3339if ${ac_cv_prog_ac_ct_CC+:} false; then :
    38463340  $as_echo_n "(cached) " >&6
    38473341else
    3848   if test -n "$ac_ct_CXX"; then
    3849   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
     3342  if test -n "$ac_ct_CC"; then
     3343  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
    38503344else
    38513345as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     
    38563350    for ac_exec_ext in '' $ac_executable_extensions; do
    38573351  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    3858     ac_cv_prog_ac_ct_CXX="$ac_prog"
     3352    ac_cv_prog_ac_ct_CC="gcc"
    38593353    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    38603354    break 2
     
    38663360fi
    38673361fi
    3868 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
    3869 if test -n "$ac_ct_CXX"; then
    3870   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
    3871 $as_echo "$ac_ct_CXX" >&6; }
     3362ac_ct_CC=$ac_cv_prog_ac_ct_CC
     3363if test -n "$ac_ct_CC"; then
     3364  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
     3365$as_echo "$ac_ct_CC" >&6; }
    38723366else
    38733367  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     
    38753369fi
    38763370
    3877 
    3878   test -n "$ac_ct_CXX" && break
    3879 done
    3880 
    3881   if test "x$ac_ct_CXX" = x; then
    3882     CXX="g++"
     3371  if test "x$ac_ct_CC" = x; then
     3372    CC=""
    38833373  else
    38843374    case $cross_compiling:$ac_tool_warned in
     
    38883378ac_tool_warned=yes ;;
    38893379esac
    3890     CXX=$ac_ct_CXX
     3380    CC=$ac_ct_CC
    38913381  fi
    3892 fi
    3893 
     3382else
     3383  CC="$ac_cv_prog_CC"
     3384fi
     3385
     3386if test -z "$CC"; then
     3387          if test -n "$ac_tool_prefix"; then
     3388    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
     3389set dummy ${ac_tool_prefix}cc; ac_word=$2
     3390{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     3391$as_echo_n "checking for $ac_word... " >&6; }
     3392if ${ac_cv_prog_CC+:} false; then :
     3393  $as_echo_n "(cached) " >&6
     3394else
     3395  if test -n "$CC"; then
     3396  ac_cv_prog_CC="$CC" # Let the user override the test.
     3397else
     3398as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3399for as_dir in $PATH
     3400do
     3401  IFS=$as_save_IFS
     3402  test -z "$as_dir" && as_dir=.
     3403    for ac_exec_ext in '' $ac_executable_extensions; do
     3404  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     3405    ac_cv_prog_CC="${ac_tool_prefix}cc"
     3406    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     3407    break 2
    38943408  fi
    3895 fi
     3409done
     3410  done
     3411IFS=$as_save_IFS
     3412
     3413fi
     3414fi
     3415CC=$ac_cv_prog_CC
     3416if test -n "$CC"; then
     3417  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
     3418$as_echo "$CC" >&6; }
     3419else
     3420  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     3421$as_echo "no" >&6; }
     3422fi
     3423
     3424
     3425  fi
     3426fi
     3427if test -z "$CC"; then
     3428  # Extract the first word of "cc", so it can be a program name with args.
     3429set dummy cc; ac_word=$2
     3430{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     3431$as_echo_n "checking for $ac_word... " >&6; }
     3432if ${ac_cv_prog_CC+:} false; then :
     3433  $as_echo_n "(cached) " >&6
     3434else
     3435  if test -n "$CC"; then
     3436  ac_cv_prog_CC="$CC" # Let the user override the test.
     3437else
     3438  ac_prog_rejected=no
     3439as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3440for as_dir in $PATH
     3441do
     3442  IFS=$as_save_IFS
     3443  test -z "$as_dir" && as_dir=.
     3444    for ac_exec_ext in '' $ac_executable_extensions; do
     3445  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     3446    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
     3447       ac_prog_rejected=yes
     3448       continue
     3449     fi
     3450    ac_cv_prog_CC="cc"
     3451    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     3452    break 2
     3453  fi
     3454done
     3455  done
     3456IFS=$as_save_IFS
     3457
     3458if test $ac_prog_rejected = yes; then
     3459  # We found a bogon in the path, so make sure we never use it.
     3460  set dummy $ac_cv_prog_CC
     3461  shift
     3462  if test $# != 0; then
     3463    # We chose a different compiler from the bogus one.
     3464    # However, it has the same basename, so the bogon will be chosen
     3465    # first if we set CC to just the basename; use the full file name.
     3466    shift
     3467    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
     3468  fi
     3469fi
     3470fi
     3471fi
     3472CC=$ac_cv_prog_CC
     3473if test -n "$CC"; then
     3474  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
     3475$as_echo "$CC" >&6; }
     3476else
     3477  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     3478$as_echo "no" >&6; }
     3479fi
     3480
     3481
     3482fi
     3483if test -z "$CC"; then
     3484  if test -n "$ac_tool_prefix"; then
     3485  for ac_prog in cl.exe
     3486  do
     3487    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     3488set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     3489{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     3490$as_echo_n "checking for $ac_word... " >&6; }
     3491if ${ac_cv_prog_CC+:} false; then :
     3492  $as_echo_n "(cached) " >&6
     3493else
     3494  if test -n "$CC"; then
     3495  ac_cv_prog_CC="$CC" # Let the user override the test.
     3496else
     3497as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3498for as_dir in $PATH
     3499do
     3500  IFS=$as_save_IFS
     3501  test -z "$as_dir" && as_dir=.
     3502    for ac_exec_ext in '' $ac_executable_extensions; do
     3503  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     3504    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
     3505    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     3506    break 2
     3507  fi
     3508done
     3509  done
     3510IFS=$as_save_IFS
     3511
     3512fi
     3513fi
     3514CC=$ac_cv_prog_CC
     3515if test -n "$CC"; then
     3516  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
     3517$as_echo "$CC" >&6; }
     3518else
     3519  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     3520$as_echo "no" >&6; }
     3521fi
     3522
     3523
     3524    test -n "$CC" && break
     3525  done
     3526fi
     3527if test -z "$CC"; then
     3528  ac_ct_CC=$CC
     3529  for ac_prog in cl.exe
     3530do
     3531  # Extract the first word of "$ac_prog", so it can be a program name with args.
     3532set dummy $ac_prog; ac_word=$2
     3533{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     3534$as_echo_n "checking for $ac_word... " >&6; }
     3535if ${ac_cv_prog_ac_ct_CC+:} false; then :
     3536  $as_echo_n "(cached) " >&6
     3537else
     3538  if test -n "$ac_ct_CC"; then
     3539  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
     3540else
     3541as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3542for as_dir in $PATH
     3543do
     3544  IFS=$as_save_IFS
     3545  test -z "$as_dir" && as_dir=.
     3546    for ac_exec_ext in '' $ac_executable_extensions; do
     3547  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     3548    ac_cv_prog_ac_ct_CC="$ac_prog"
     3549    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     3550    break 2
     3551  fi
     3552done
     3553  done
     3554IFS=$as_save_IFS
     3555
     3556fi
     3557fi
     3558ac_ct_CC=$ac_cv_prog_ac_ct_CC
     3559if test -n "$ac_ct_CC"; then
     3560  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
     3561$as_echo "$ac_ct_CC" >&6; }
     3562else
     3563  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     3564$as_echo "no" >&6; }
     3565fi
     3566
     3567
     3568  test -n "$ac_ct_CC" && break
     3569done
     3570
     3571  if test "x$ac_ct_CC" = x; then
     3572    CC=""
     3573  else
     3574    case $cross_compiling:$ac_tool_warned in
     3575yes:)
     3576{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
     3577$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
     3578ac_tool_warned=yes ;;
     3579esac
     3580    CC=$ac_ct_CC
     3581  fi
     3582fi
     3583
     3584fi
     3585
     3586
     3587test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
     3588$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
     3589as_fn_error $? "no acceptable C compiler found in \$PATH
     3590See \`config.log' for more details" "$LINENO" 5; }
     3591
    38963592# Provide some information about the compiler.
    3897 $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
     3593$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
    38983594set X $ac_compile
    38993595ac_compiler=$2
     
    39353631# It will help us diagnose broken compilers, and finding out an intuition
    39363632# of exeext.
    3937 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
    3938 $as_echo_n "checking whether the C++ compiler works... " >&6; }
     3633{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
     3634$as_echo_n "checking whether the C compiler works... " >&6; }
    39393635ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
    39403636
     
    40063702{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
    40073703$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
    4008 as_fn_error 77 "C++ compiler cannot create executables
     3704as_fn_error 77 "C compiler cannot create executables
    40093705See \`config.log' for more details" "$LINENO" 5; }
    40103706else
     
    40123708$as_echo "yes" >&6; }
    40133709fi
    4014 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
    4015 $as_echo_n "checking for C++ compiler default output file name... " >&6; }
     3710{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
     3711$as_echo_n "checking for C compiler default output file name... " >&6; }
    40163712{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
    40173713$as_echo "$ac_file" >&6; }
     
    41073803        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
    41083804$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
    4109 as_fn_error $? "cannot run C++ compiled programs.
     3805as_fn_error $? "cannot run C compiled programs.
    41103806If you meant to cross compile, use \`--host'.
    41113807See \`config.log' for more details" "$LINENO" 5; }
     
    41693865OBJEXT=$ac_cv_objext
    41703866ac_objext=$OBJEXT
     3867{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
     3868$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
     3869if ${ac_cv_c_compiler_gnu+:} false; then :
     3870  $as_echo_n "(cached) " >&6
     3871else
     3872  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     3873/* end confdefs.h.  */
     3874
     3875int
     3876main ()
     3877{
     3878#ifndef __GNUC__
     3879       choke me
     3880#endif
     3881
     3882  ;
     3883  return 0;
     3884}
     3885_ACEOF
     3886if ac_fn_c_try_compile "$LINENO"; then :
     3887  ac_compiler_gnu=yes
     3888else
     3889  ac_compiler_gnu=no
     3890fi
     3891rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     3892ac_cv_c_compiler_gnu=$ac_compiler_gnu
     3893
     3894fi
     3895{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
     3896$as_echo "$ac_cv_c_compiler_gnu" >&6; }
     3897if test $ac_compiler_gnu = yes; then
     3898  GCC=yes
     3899else
     3900  GCC=
     3901fi
     3902ac_test_CFLAGS=${CFLAGS+set}
     3903ac_save_CFLAGS=$CFLAGS
     3904{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
     3905$as_echo_n "checking whether $CC accepts -g... " >&6; }
     3906if ${ac_cv_prog_cc_g+:} false; then :
     3907  $as_echo_n "(cached) " >&6
     3908else
     3909  ac_save_c_werror_flag=$ac_c_werror_flag
     3910   ac_c_werror_flag=yes
     3911   ac_cv_prog_cc_g=no
     3912   CFLAGS="-g"
     3913   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     3914/* end confdefs.h.  */
     3915
     3916int
     3917main ()
     3918{
     3919
     3920  ;
     3921  return 0;
     3922}
     3923_ACEOF
     3924if ac_fn_c_try_compile "$LINENO"; then :
     3925  ac_cv_prog_cc_g=yes
     3926else
     3927  CFLAGS=""
     3928      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     3929/* end confdefs.h.  */
     3930
     3931int
     3932main ()
     3933{
     3934
     3935  ;
     3936  return 0;
     3937}
     3938_ACEOF
     3939if ac_fn_c_try_compile "$LINENO"; then :
     3940
     3941else
     3942  ac_c_werror_flag=$ac_save_c_werror_flag
     3943         CFLAGS="-g"
     3944         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     3945/* end confdefs.h.  */
     3946
     3947int
     3948main ()
     3949{
     3950
     3951  ;
     3952  return 0;
     3953}
     3954_ACEOF
     3955if ac_fn_c_try_compile "$LINENO"; then :
     3956  ac_cv_prog_cc_g=yes
     3957fi
     3958rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     3959fi
     3960rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     3961fi
     3962rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     3963   ac_c_werror_flag=$ac_save_c_werror_flag
     3964fi
     3965{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
     3966$as_echo "$ac_cv_prog_cc_g" >&6; }
     3967if test "$ac_test_CFLAGS" = set; then
     3968  CFLAGS=$ac_save_CFLAGS
     3969elif test $ac_cv_prog_cc_g = yes; then
     3970  if test "$GCC" = yes; then
     3971    CFLAGS="-g -O2"
     3972  else
     3973    CFLAGS="-g"
     3974  fi
     3975else
     3976  if test "$GCC" = yes; then
     3977    CFLAGS="-O2"
     3978  else
     3979    CFLAGS=
     3980  fi
     3981fi
     3982{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
     3983$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
     3984if ${ac_cv_prog_cc_c89+:} false; then :
     3985  $as_echo_n "(cached) " >&6
     3986else
     3987  ac_cv_prog_cc_c89=no
     3988ac_save_CC=$CC
     3989cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     3990/* end confdefs.h.  */
     3991#include <stdarg.h>
     3992#include <stdio.h>
     3993struct stat;
     3994/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
     3995struct buf { int x; };
     3996FILE * (*rcsopen) (struct buf *, struct stat *, int);
     3997static char *e (p, i)
     3998     char **p;
     3999     int i;
     4000{
     4001  return p[i];
     4002}
     4003static char *f (char * (*g) (char **, int), char **p, ...)
     4004{
     4005  char *s;
     4006  va_list v;
     4007  va_start (v,p);
     4008  s = g (p, va_arg (v,int));
     4009  va_end (v);
     4010  return s;
     4011}
     4012
     4013/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
     4014   function prototypes and stuff, but not '\xHH' hex character constants.
     4015   These don't provoke an error unfortunately, instead are silently treated
     4016   as 'x'.  The following induces an error, until -std is added to get
     4017   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
     4018   array size at least.  It's necessary to write '\x00'==0 to get something
     4019   that's true only with -std.  */
     4020int osf4_cc_array ['\x00' == 0 ? 1 : -1];
     4021
     4022/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
     4023   inside strings and character constants.  */
     4024#define FOO(x) 'x'
     4025int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
     4026
     4027int test (int i, double x);
     4028struct s1 {int (*f) (int a);};
     4029struct s2 {int (*f) (double a);};
     4030int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
     4031int argc;
     4032char **argv;
     4033int
     4034main ()
     4035{
     4036return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
     4037  ;
     4038  return 0;
     4039}
     4040_ACEOF
     4041for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
     4042        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
     4043do
     4044  CC="$ac_save_CC $ac_arg"
     4045  if ac_fn_c_try_compile "$LINENO"; then :
     4046  ac_cv_prog_cc_c89=$ac_arg
     4047fi
     4048rm -f core conftest.err conftest.$ac_objext
     4049  test "x$ac_cv_prog_cc_c89" != "xno" && break
     4050done
     4051rm -f conftest.$ac_ext
     4052CC=$ac_save_CC
     4053
     4054fi
     4055# AC_CACHE_VAL
     4056case "x$ac_cv_prog_cc_c89" in
     4057  x)
     4058    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
     4059$as_echo "none needed" >&6; } ;;
     4060  xno)
     4061    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
     4062$as_echo "unsupported" >&6; } ;;
     4063  *)
     4064    CC="$CC $ac_cv_prog_cc_c89"
     4065    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
     4066$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
     4067esac
     4068if test "x$ac_cv_prog_cc_c89" != xno; then :
     4069
     4070fi
     4071
     4072ac_ext=c
     4073ac_cpp='$CPP $CPPFLAGS'
     4074ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     4075ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4076ac_compiler_gnu=$ac_cv_c_compiler_gnu
     4077
     4078ac_ext=c
     4079ac_cpp='$CPP $CPPFLAGS'
     4080ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     4081ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4082ac_compiler_gnu=$ac_cv_c_compiler_gnu
     4083{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
     4084$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
     4085if ${am_cv_prog_cc_c_o+:} false; then :
     4086  $as_echo_n "(cached) " >&6
     4087else
     4088  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     4089/* end confdefs.h.  */
     4090
     4091int
     4092main ()
     4093{
     4094
     4095  ;
     4096  return 0;
     4097}
     4098_ACEOF
     4099  # Make sure it works both with $CC and with simple cc.
     4100  # Following AC_PROG_CC_C_O, we do the test twice because some
     4101  # compilers refuse to overwrite an existing .o file with -o,
     4102  # though they will create one.
     4103  am_cv_prog_cc_c_o=yes
     4104  for am_i in 1 2; do
     4105    if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
     4106   ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
     4107   ac_status=$?
     4108   echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4109   (exit $ac_status); } \
     4110         && test -f conftest2.$ac_objext; then
     4111      : OK
     4112    else
     4113      am_cv_prog_cc_c_o=no
     4114      break
     4115    fi
     4116  done
     4117  rm -f core conftest*
     4118  unset am_i
     4119fi
     4120{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
     4121$as_echo "$am_cv_prog_cc_c_o" >&6; }
     4122if test "$am_cv_prog_cc_c_o" != yes; then
     4123   # Losing compiler, so override with the script.
     4124   # FIXME: It is wrong to rewrite CC.
     4125   # But if we don't then we get into trouble of one sort or another.
     4126   # A longer-term fix would be to have automake use am__CC in this case,
     4127   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
     4128   CC="$am_aux_dir/compile $CC"
     4129fi
     4130ac_ext=c
     4131ac_cpp='$CPP $CPPFLAGS'
     4132ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     4133ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4134ac_compiler_gnu=$ac_cv_c_compiler_gnu
     4135
     4136
     4137depcc="$CC"   am_compiler_list=
     4138
     4139{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
     4140$as_echo_n "checking dependency style of $depcc... " >&6; }
     4141if ${am_cv_CC_dependencies_compiler_type+:} false; then :
     4142  $as_echo_n "(cached) " >&6
     4143else
     4144  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
     4145  # We make a subdir and do the tests there.  Otherwise we can end up
     4146  # making bogus files that we don't know about and never remove.  For
     4147  # instance it was reported that on HP-UX the gcc test will end up
     4148  # making a dummy file named 'D' -- because '-MD' means "put the output
     4149  # in D".
     4150  rm -rf conftest.dir
     4151  mkdir conftest.dir
     4152  # Copy depcomp to subdir because otherwise we won't find it if we're
     4153  # using a relative directory.
     4154  cp "$am_depcomp" conftest.dir
     4155  cd conftest.dir
     4156  # We will build objects and dependencies in a subdirectory because
     4157  # it helps to detect inapplicable dependency modes.  For instance
     4158  # both Tru64's cc and ICC support -MD to output dependencies as a
     4159  # side effect of compilation, but ICC will put the dependencies in
     4160  # the current directory while Tru64 will put them in the object
     4161  # directory.
     4162  mkdir sub
     4163
     4164  am_cv_CC_dependencies_compiler_type=none
     4165  if test "$am_compiler_list" = ""; then
     4166     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
     4167  fi
     4168  am__universal=false
     4169  case " $depcc " in #(
     4170     *\ -arch\ *\ -arch\ *) am__universal=true ;;
     4171     esac
     4172
     4173  for depmode in $am_compiler_list; do
     4174    # Setup a source with many dependencies, because some compilers
     4175    # like to wrap large dependency lists on column 80 (with \), and
     4176    # we should not choose a depcomp mode which is confused by this.
     4177    #
     4178    # We need to recreate these files for each test, as the compiler may
     4179    # overwrite some of them when testing with obscure command lines.
     4180    # This happens at least with the AIX C compiler.
     4181    : > sub/conftest.c
     4182    for i in 1 2 3 4 5 6; do
     4183      echo '#include "conftst'$i'.h"' >> sub/conftest.c
     4184      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
     4185      # Solaris 10 /bin/sh.
     4186      echo '/* dummy */' > sub/conftst$i.h
     4187    done
     4188    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
     4189
     4190    # We check with '-c' and '-o' for the sake of the "dashmstdout"
     4191    # mode.  It turns out that the SunPro C++ compiler does not properly
     4192    # handle '-M -o', and we need to detect this.  Also, some Intel
     4193    # versions had trouble with output in subdirs.
     4194    am__obj=sub/conftest.${OBJEXT-o}
     4195    am__minus_obj="-o $am__obj"
     4196    case $depmode in
     4197    gcc)
     4198      # This depmode causes a compiler race in universal mode.
     4199      test "$am__universal" = false || continue
     4200      ;;
     4201    nosideeffect)
     4202      # After this tag, mechanisms are not by side-effect, so they'll
     4203      # only be used when explicitly requested.
     4204      if test "x$enable_dependency_tracking" = xyes; then
     4205        continue
     4206      else
     4207        break
     4208      fi
     4209      ;;
     4210    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
     4211      # This compiler won't grok '-c -o', but also, the minuso test has
     4212      # not run yet.  These depmodes are late enough in the game, and
     4213      # so weak that their functioning should not be impacted.
     4214      am__obj=conftest.${OBJEXT-o}
     4215      am__minus_obj=
     4216      ;;
     4217    none) break ;;
     4218    esac
     4219    if depmode=$depmode \
     4220       source=sub/conftest.c object=$am__obj \
     4221       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
     4222       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
     4223         >/dev/null 2>conftest.err &&
     4224       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
     4225       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
     4226       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
     4227       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
     4228      # icc doesn't choke on unknown options, it will just issue warnings
     4229      # or remarks (even with -Werror).  So we grep stderr for any message
     4230      # that says an option was ignored or not supported.
     4231      # When given -MP, icc 7.0 and 7.1 complain thusly:
     4232      #   icc: Command line warning: ignoring option '-M'; no argument required
     4233      # The diagnosis changed in icc 8.0:
     4234      #   icc: Command line remark: option '-MP' not supported
     4235      if (grep 'ignoring option' conftest.err ||
     4236          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
     4237        am_cv_CC_dependencies_compiler_type=$depmode
     4238        break
     4239      fi
     4240    fi
     4241  done
     4242
     4243  cd ..
     4244  rm -rf conftest.dir
     4245else
     4246  am_cv_CC_dependencies_compiler_type=none
     4247fi
     4248
     4249fi
     4250{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
     4251$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
     4252CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
     4253
     4254 if
     4255  test "x$enable_dependency_tracking" != xno \
     4256  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
     4257  am__fastdepCC_TRUE=
     4258  am__fastdepCC_FALSE='#'
     4259else
     4260  am__fastdepCC_TRUE='#'
     4261  am__fastdepCC_FALSE=
     4262fi
     4263
     4264
     4265
     4266if test -n "$ac_tool_prefix"; then
     4267  for ac_prog in ar lib "link -lib"
     4268  do
     4269    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     4270set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     4271{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     4272$as_echo_n "checking for $ac_word... " >&6; }
     4273if ${ac_cv_prog_AR+:} false; then :
     4274  $as_echo_n "(cached) " >&6
     4275else
     4276  if test -n "$AR"; then
     4277  ac_cv_prog_AR="$AR" # Let the user override the test.
     4278else
     4279as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     4280for as_dir in $PATH
     4281do
     4282  IFS=$as_save_IFS
     4283  test -z "$as_dir" && as_dir=.
     4284    for ac_exec_ext in '' $ac_executable_extensions; do
     4285  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     4286    ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
     4287    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     4288    break 2
     4289  fi
     4290done
     4291  done
     4292IFS=$as_save_IFS
     4293
     4294fi
     4295fi
     4296AR=$ac_cv_prog_AR
     4297if test -n "$AR"; then
     4298  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
     4299$as_echo "$AR" >&6; }
     4300else
     4301  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4302$as_echo "no" >&6; }
     4303fi
     4304
     4305
     4306    test -n "$AR" && break
     4307  done
     4308fi
     4309if test -z "$AR"; then
     4310  ac_ct_AR=$AR
     4311  for ac_prog in ar lib "link -lib"
     4312do
     4313  # Extract the first word of "$ac_prog", so it can be a program name with args.
     4314set dummy $ac_prog; ac_word=$2
     4315{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     4316$as_echo_n "checking for $ac_word... " >&6; }
     4317if ${ac_cv_prog_ac_ct_AR+:} false; then :
     4318  $as_echo_n "(cached) " >&6
     4319else
     4320  if test -n "$ac_ct_AR"; then
     4321  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
     4322else
     4323as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     4324for as_dir in $PATH
     4325do
     4326  IFS=$as_save_IFS
     4327  test -z "$as_dir" && as_dir=.
     4328    for ac_exec_ext in '' $ac_executable_extensions; do
     4329  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     4330    ac_cv_prog_ac_ct_AR="$ac_prog"
     4331    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     4332    break 2
     4333  fi
     4334done
     4335  done
     4336IFS=$as_save_IFS
     4337
     4338fi
     4339fi
     4340ac_ct_AR=$ac_cv_prog_ac_ct_AR
     4341if test -n "$ac_ct_AR"; then
     4342  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
     4343$as_echo "$ac_ct_AR" >&6; }
     4344else
     4345  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4346$as_echo "no" >&6; }
     4347fi
     4348
     4349
     4350  test -n "$ac_ct_AR" && break
     4351done
     4352
     4353  if test "x$ac_ct_AR" = x; then
     4354    AR="false"
     4355  else
     4356    case $cross_compiling:$ac_tool_warned in
     4357yes:)
     4358{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
     4359$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
     4360ac_tool_warned=yes ;;
     4361esac
     4362    AR=$ac_ct_AR
     4363  fi
     4364fi
     4365
     4366: ${AR=ar}
     4367
     4368{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the archiver ($AR) interface" >&5
     4369$as_echo_n "checking the archiver ($AR) interface... " >&6; }
     4370if ${am_cv_ar_interface+:} false; then :
     4371  $as_echo_n "(cached) " >&6
     4372else
     4373  ac_ext=c
     4374ac_cpp='$CPP $CPPFLAGS'
     4375ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     4376ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4377ac_compiler_gnu=$ac_cv_c_compiler_gnu
     4378
     4379   am_cv_ar_interface=ar
     4380   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     4381/* end confdefs.h.  */
     4382int some_variable = 0;
     4383_ACEOF
     4384if ac_fn_c_try_compile "$LINENO"; then :
     4385  am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&5'
     4386      { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5
     4387  (eval $am_ar_try) 2>&5
     4388  ac_status=$?
     4389  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
     4390  test $ac_status = 0; }
     4391      if test "$ac_status" -eq 0; then
     4392        am_cv_ar_interface=ar
     4393      else
     4394        am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&5'
     4395        { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5
     4396  (eval $am_ar_try) 2>&5
     4397  ac_status=$?
     4398  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
     4399  test $ac_status = 0; }
     4400        if test "$ac_status" -eq 0; then
     4401          am_cv_ar_interface=lib
     4402        else
     4403          am_cv_ar_interface=unknown
     4404        fi
     4405      fi
     4406      rm -f conftest.lib libconftest.a
     4407
     4408fi
     4409rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     4410   ac_ext=c
     4411ac_cpp='$CPP $CPPFLAGS'
     4412ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     4413ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4414ac_compiler_gnu=$ac_cv_c_compiler_gnu
     4415
     4416fi
     4417{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_ar_interface" >&5
     4418$as_echo "$am_cv_ar_interface" >&6; }
     4419
     4420case $am_cv_ar_interface in
     4421ar)
     4422  ;;
     4423lib)
     4424  # Microsoft lib, so override with the ar-lib wrapper script.
     4425  # FIXME: It is wrong to rewrite AR.
     4426  # But if we don't then we get into trouble of one sort or another.
     4427  # A longer-term fix would be to have automake use am__AR in this case,
     4428  # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something
     4429  # similar.
     4430  AR="$am_aux_dir/ar-lib $AR"
     4431  ;;
     4432unknown)
     4433  have_ar='no'
     4434  ;;
     4435esac
     4436
     4437{ $as_echo "$as_me:${as_lineno-$LINENO}: have_ar = $have_ar" >&5
     4438$as_echo "$as_me: have_ar = $have_ar" >&6;}
     4439
     4440{ $as_echo "$as_me:${as_lineno-$LINENO}: *** Check command line arguments that are longer used ****" >&5
     4441$as_echo "$as_me: *** Check command line arguments that are longer used ****" >&6;}
     4442
     4443if test "$CPP_ERROR_WARN" != "" ; then
     4444    as_fn_error $? "The CPP_ERROR_WARN configure option is now CXX_FLAGS" "$LINENO" 5
     4445fi
     4446
     4447# Check whether --with-SpeedExample was given.
     4448if test "${with_SpeedExample+set}" = set; then :
     4449  withval=$with_SpeedExample; SpeedExample="yes"
     4450else
     4451  SpeedExample="no"
     4452
     4453fi
     4454
     4455if test "$SpeedExample" = "yes" ; then
     4456    as_fn_error $? "--with-SpeedExample not necessary, see install instructions." "$LINENO" 5
     4457fi
     4458
     4459# Check whether --with-profiling was given.
     4460if test "${with_profiling+set}" = set; then :
     4461  withval=$with_profiling; profiling="yes"
     4462else
     4463  profiling="no"
     4464
     4465fi
     4466
     4467if test "$profiling" = "yes" ; then
     4468    as_fn_error $? "--with-profiling not necessary, see install instructions." "$LINENO" 5
     4469fi
     4470
     4471# Check whether --with-Speed was given.
     4472if test "${with_Speed+set}" = set; then :
     4473  withval=$with_Speed; Speed="yes"
     4474else
     4475  Speed="no"
     4476
     4477fi
     4478
     4479if test "$Speed" = "yes" ; then
     4480    as_fn_error $? "--with-Speed not necessary, see install instructions." "$LINENO" 5
     4481fi
     4482
     4483# Check whether --with-Introduction was given.
     4484if test "${with_Introduction+set}" = set; then :
     4485  withval=$with_Introduction; Introduction="yes"
     4486else
     4487  Introduction="no"
     4488
     4489fi
     4490
     4491if test "$Introduction" = "yes" ; then
     4492    as_fn_error $? "--with-Introduction not necessary, see install instructions." "$LINENO" 5
     4493fi
     4494
     4495# Check whether --with-Example was given.
     4496if test "${with_Example+set}" = set; then :
     4497  withval=$with_Example; Example="yes"
     4498else
     4499  Example="no"
     4500
     4501fi
     4502
     4503if test "$Example" = "yes" ; then
     4504    as_fn_error $? "--with-Example not necessary, see install instructions." "$LINENO" 5
     4505fi
     4506
     4507# Check whether --with-TestMore was given.
     4508if test "${with_TestMore+set}" = set; then :
     4509  withval=$with_TestMore; TestMore="yes"
     4510else
     4511  TestMore="no"
     4512
     4513fi
     4514
     4515if test "$TestMore" = "yes" ; then
     4516    as_fn_error $? "--with-TestMore not necessary, see install instructions." "$LINENO" 5
     4517fi
     4518
     4519# Check whether --with-PrintFor was given.
     4520if test "${with_PrintFor+set}" = set; then :
     4521  withval=$with_PrintFor; PrintFor="yes"
     4522else
     4523  PrintFor="no"
     4524
     4525fi
     4526
     4527if test "$PrintFor" = "yes" ; then
     4528    as_fn_error $? "--with-PrintFor not necessary, see install instructions." "$LINENO" 5
     4529fi
     4530{ $as_echo "$as_me:${as_lineno-$LINENO}: ******  Check command line arguments that are used ***********" >&5
     4531$as_echo "$as_me: ******  Check command line arguments that are used ***********" >&6;}
     4532
     4533{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --enable-msvc" >&5
     4534$as_echo_n "checking --enable-msvc... " >&6; }
     4535# Check whether --enable-msvc was given.
     4536if test "${enable_msvc+set}" = set; then :
     4537  enableval=$enable_msvc; enable_msvc=$enableval
     4538else
     4539  enable_msvc=no
     4540
     4541fi
     4542
     4543{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_msvc" >&5
     4544$as_echo "$enable_msvc" >&6; }
     4545
     4546
     4547{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --prefix" >&5
     4548$as_echo_n "checking --prefix... " >&6; }
     4549if test "$prefix" = "NONE" ; then
     4550        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOME" >&5
     4551$as_echo "$HOME" >&6; }
     4552else
     4553        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $prefix" >&5
     4554$as_echo "$prefix" >&6; }
     4555fi
     4556
     4557{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-Documentation" >&5
     4558$as_echo_n "checking --with-Documentation... " >&6; }
     4559
     4560# Check whether --with-Documentation was given.
     4561if test "${with_Documentation+set}" = set; then :
     4562  withval=$with_Documentation; Documentation="yes"
     4563else
     4564  Documentation="no"
     4565
     4566fi
     4567
     4568 if test "$Documentation" = "yes"; then
     4569  CppAD_DOCUMENTATION_TRUE=
     4570  CppAD_DOCUMENTATION_FALSE='#'
     4571else
     4572  CppAD_DOCUMENTATION_TRUE='#'
     4573  CppAD_DOCUMENTATION_FALSE=
     4574fi
     4575
     4576{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $Documentation" >&5
     4577$as_echo "$Documentation" >&6; }
     4578
     4579{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-stdvector" >&5
     4580$as_echo_n "checking --with-stdvector... " >&6; }
     4581
     4582# Check whether --with-stdvector was given.
     4583if test "${with_stdvector+set}" = set; then :
     4584  withval=$with_stdvector; stdvector="yes"
     4585else
     4586  stdvector="no"
     4587
     4588fi
     4589
     4590if test "$stdvector" = "yes" ; then
     4591        cppad_stdvector=1
     4592
     4593else
     4594        cppad_stdvector=0
     4595
     4596fi
     4597{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $stdvector" >&5
     4598$as_echo "$stdvector" >&6; }
     4599
     4600{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-boostvector" >&5
     4601$as_echo_n "checking --with-boostvector... " >&6; }
     4602
     4603# Check whether --with-boostvector was given.
     4604if test "${with_boostvector+set}" = set; then :
     4605  withval=$with_boostvector; boostvector="yes"
     4606else
     4607  boostvector="no"
     4608
     4609fi
     4610
     4611{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $boostvector" >&5
     4612$as_echo "$boostvector" >&6; }
     4613if test "$boostvector" = "yes" ; then
     4614        if test "$stdvector" != "no" ; then
     4615                as_fn_error $? "cannot --with both stdvector and boostvector" "$LINENO" 5
     4616        fi
     4617        cppad_boostvector=1
     4618
     4619else
     4620        cppad_boostvector=0
     4621
     4622fi
     4623
     4624{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-eigenvector" >&5
     4625$as_echo_n "checking --with-eigenvector... " >&6; }
     4626
     4627# Check whether --with-eigenvector was given.
     4628if test "${with_eigenvector+set}" = set; then :
     4629  withval=$with_eigenvector; eigenvector="yes"
     4630else
     4631  eigenvector="no"
     4632
     4633fi
     4634
     4635{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $eigenvector" >&5
     4636$as_echo "$eigenvector" >&6; }
     4637if test "$eigenvector" = "yes" ; then
     4638        if test "$stdvector" != "no" ; then
     4639                as_fn_error $? "cannot --with both stdvector and eigenvector" "$LINENO" 5
     4640        fi
     4641        if test "$boostvector" != "no" ; then
     4642                as_fn_error $? "cannot --with both boostvector and eigenvector" "$LINENO" 5
     4643        fi
     4644        cppad_eigenvector=1
     4645
     4646else
     4647        cppad_eigenvector=0
     4648
     4649fi
     4650
     4651{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-sparse_set" >&5
     4652$as_echo_n "checking --with-sparse_set... " >&6; }
     4653
     4654# Check whether --with-sparse_set was given.
     4655if test "${with_sparse_set+set}" = set; then :
     4656  withval=$with_sparse_set; sparse_set="yes"
     4657else
     4658  sparse_set="no"
     4659
     4660fi
     4661
     4662{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $sparse_set" >&5
     4663$as_echo "$sparse_set" >&6; }
     4664{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-sparse_list" >&5
     4665$as_echo_n "checking --with-sparse_list... " >&6; }
     4666
     4667# Check whether --with-sparse_list was given.
     4668if test "${with_sparse_list+set}" = set; then :
     4669  withval=$with_sparse_list; sparse_list="yes"
     4670else
     4671  sparse_list="no"
     4672
     4673fi
     4674
     4675{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $sparse_list" >&5
     4676$as_echo "$sparse_list" >&6; }
     4677if test "$sparse_set" = "yes" ; then
     4678        if test "$sparse_list" == "yes" ; then
     4679                as_fn_error $? "cannot --with both sparse_set and sparse_list" "$LINENO" 5
     4680        fi
     4681        cppad_internal_sparse_set=sparse_set
     4682
     4683else
     4684        cppad_internal_sparse_set=sparse_list
     4685
     4686fi
     4687
     4688
     4689{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-implicit_ctor" >&5
     4690$as_echo_n "checking --with-implicit_ctor... " >&6; }
     4691
     4692# Check whether --with-implicit_ctor was given.
     4693if test "${with_implicit_ctor+set}" = set; then :
     4694  withval=$with_implicit_ctor; implicit_ctor="yes"
     4695else
     4696  implicit_ctor="no"
     4697
     4698fi
     4699
     4700{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $implicit_ctor" >&5
     4701$as_echo "$implicit_ctor" >&6; }
     4702if test "$implicit_ctor" = "yes" ; then
     4703        cppad_implicit_ctor_from_any_type="1"
     4704
     4705else
     4706        cppad_implicit_ctor_from_any_type="0"
     4707
     4708fi
     4709
     4710{ $as_echo "$as_me:${as_lineno-$LINENO}: checking POSTFIX_DIR" >&5
     4711$as_echo_n "checking POSTFIX_DIR... " >&6; }
     4712
     4713 if test "$POSTFIX_DIR" != ""; then
     4714  CppAD_POSTFIX_TRUE=
     4715  CppAD_POSTFIX_FALSE='#'
     4716else
     4717  CppAD_POSTFIX_TRUE='#'
     4718  CppAD_POSTFIX_FALSE=
     4719fi
     4720
     4721if test "$POSTFIX_DIR" != "" ; then
     4722        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POSTFIX_DIR" >&5
     4723$as_echo "$POSTFIX_DIR" >&6; }
     4724else
     4725        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4726$as_echo "no" >&6; }
     4727fi
     4728
     4729{ $as_echo "$as_me:${as_lineno-$LINENO}: checking ADOLC_DIR" >&5
     4730$as_echo_n "checking ADOLC_DIR... " >&6; }
     4731
     4732 if test "$ADOLC_DIR" != ""; then
     4733  CppAD_ADOLC_TRUE=
     4734  CppAD_ADOLC_FALSE='#'
     4735else
     4736  CppAD_ADOLC_TRUE='#'
     4737  CppAD_ADOLC_FALSE=
     4738fi
     4739
     4740if test "$ADOLC_DIR" != "" ; then
     4741        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ADOLC_DIR" >&5
     4742$as_echo "$ADOLC_DIR" >&6; }
     4743        if test "$have_ar" = "no"; then
     4744                as_fn_error $? "ar is missing and ADOLC_DIR is present" "$LINENO" 5
     4745        fi
     4746else
     4747        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4748$as_echo "no" >&6; }
     4749fi
     4750
     4751{ $as_echo "$as_me:${as_lineno-$LINENO}: checking EIGEN_DIR" >&5
     4752$as_echo_n "checking EIGEN_DIR... " >&6; }
     4753
     4754 if test "$EIGEN_DIR" != ""; then
     4755  CppAD_EIGEN_DIR_TRUE=
     4756  CppAD_EIGEN_DIR_FALSE='#'
     4757else
     4758  CppAD_EIGEN_DIR_TRUE='#'
     4759  CppAD_EIGEN_DIR_FALSE=
     4760fi
     4761
     4762if test "$EIGEN_DIR" != "" ; then
     4763        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EIGEN_DIR" >&5
     4764$as_echo "$EIGEN_DIR" >&6; }
     4765        EIGEN_INCLUDE=-I$EIGEN_DIR/include
     4766
     4767else
     4768        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4769$as_echo "no" >&6; }
     4770
     4771fi
     4772
     4773{ $as_echo "$as_me:${as_lineno-$LINENO}: checking FADBAD_DIR" >&5
     4774$as_echo_n "checking FADBAD_DIR... " >&6; }
     4775
     4776 if test "$FADBAD_DIR" != ""; then
     4777  CppAD_FADBAD_TRUE=
     4778  CppAD_FADBAD_FALSE='#'
     4779else
     4780  CppAD_FADBAD_TRUE='#'
     4781  CppAD_FADBAD_FALSE=
     4782fi
     4783
     4784if test "$FADBAD_DIR" != "" ; then
     4785        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FADBAD_DIR" >&5
     4786$as_echo "$FADBAD_DIR" >&6; }
     4787        if test "$have_ar" = "no"; then
     4788                as_fn_error $? "ar is missing and FADBAD_DIR is present" "$LINENO" 5
     4789        fi
     4790else
     4791        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4792$as_echo "no" >&6; }
     4793fi
     4794
     4795{ $as_echo "$as_me:${as_lineno-$LINENO}: checking SACADO_DIR" >&5
     4796$as_echo_n "checking SACADO_DIR... " >&6; }
     4797
     4798 if test "$SACADO_DIR" != ""; then
     4799  CppAD_SACADO_TRUE=
     4800  CppAD_SACADO_FALSE='#'
     4801else
     4802  CppAD_SACADO_TRUE='#'
     4803  CppAD_SACADO_FALSE=
     4804fi
     4805
     4806if test "$SACADO_DIR" != "" ; then
     4807        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SACADO_DIR" >&5
     4808$as_echo "$SACADO_DIR" >&6; }
     4809        if test "$have_ar" = "no"; then
     4810                as_fn_error $? "ar is missing and SACADO_DIR is present" "$LINENO" 5
     4811        fi
     4812else
     4813        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4814$as_echo "no" >&6; }
     4815fi
     4816
     4817{ $as_echo "$as_me:${as_lineno-$LINENO}: checking IPOPT_DIR" >&5
     4818$as_echo_n "checking IPOPT_DIR... " >&6; }
     4819
     4820 if test "$IPOPT_DIR" != ""; then
     4821  CppAD_IPOPT_TRUE=
     4822  CppAD_IPOPT_FALSE='#'
     4823else
     4824  CppAD_IPOPT_TRUE='#'
     4825  CppAD_IPOPT_FALSE=
     4826fi
     4827
     4828if test "$IPOPT_DIR" != "" ; then
     4829        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $IPOPT_DIR" >&5
     4830$as_echo "$IPOPT_DIR" >&6; }
     4831        if test "$have_ar" = "no"; then
     4832                as_fn_error $? "ar is missing and IPOPT_DIR is present" "$LINENO" 5
     4833        fi
     4834else
     4835        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4836$as_echo "no" >&6; }
     4837fi
     4838
     4839{ $as_echo "$as_me:${as_lineno-$LINENO}: checking BOOST_DIR" >&5
     4840$as_echo_n "checking BOOST_DIR... " >&6; }
     4841
     4842 if test "$BOOST_DIR" != ""; then
     4843  CppAD_BOOST_DIR_TRUE=
     4844  CppAD_BOOST_DIR_FALSE='#'
     4845else
     4846  CppAD_BOOST_DIR_TRUE='#'
     4847  CppAD_BOOST_DIR_FALSE=
     4848fi
     4849
     4850if test "$BOOST_DIR" != "" ; then
     4851        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOST_DIR" >&5
     4852$as_echo "$BOOST_DIR" >&6; }
     4853        BOOST_INCLUDE=-I$BOOST_DIR/include
     4854
     4855else
     4856        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4857$as_echo "no" >&6; }
     4858
     4859fi
     4860
     4861#
     4862{ $as_echo "$as_me:${as_lineno-$LINENO}: checking CXX_FLAGS" >&5
     4863$as_echo_n "checking CXX_FLAGS... " >&6; }
     4864
     4865# cxx_flags for fadbad and eigen
     4866if test "$CXX_FLAGS" != "" ; then
     4867        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX_FLAGS" >&5
     4868$as_echo "$CXX_FLAGS" >&6; }
     4869        cxx_flags_fadbad=`echo "$CXX_FLAGS" | sed -e 's|-Wshadow||'`
     4870        cxx_flags_eigen="$cxx_flags_fadbda -Wno-long-long"
     4871else
     4872        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4873$as_echo "no" >&6; }
     4874        cxx_flags_fadbad=""
     4875        cxx_flags_eigen=""
     4876fi
     4877CXX_FLAGS_FADBAD="$cxx_flags_fadbad"
     4878
     4879CXX_FLAGS_EIGEN="$cxx_flags_eigen"
     4880
     4881
     4882{ $as_echo "$as_me:${as_lineno-$LINENO}: checking OPENMP_FLAGS" >&5
     4883$as_echo_n "checking OPENMP_FLAGS... " >&6; }
     4884
     4885if test "$OPENMP_FLAGS" != "" ; then
     4886        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENMP_FLAGS" >&5
     4887$as_echo "$OPENMP_FLAGS" >&6; }
     4888else
     4889        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4890$as_echo "no" >&6; }
     4891fi
     4892 if test "$OPENMP_FLAGS" != ""; then
     4893  CppAD_OPENMP_TRUE=
     4894  CppAD_OPENMP_FALSE='#'
     4895else
     4896  CppAD_OPENMP_TRUE='#'
     4897  CppAD_OPENMP_FALSE=
     4898fi
     4899
     4900
     4901{ $as_echo "$as_me:${as_lineno-$LINENO}: checking MAX_NUM_THREADS" >&5
     4902$as_echo_n "checking MAX_NUM_THREADS... " >&6; }
     4903
     4904if test "$MAX_NUM_THREADS" != "" ; then
     4905        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAX_NUM_THREADS" >&5
     4906$as_echo "$MAX_NUM_THREADS" >&6; }
     4907        if test "$MAX_NUM_THREADS" -lt "4" ; then
     4908                as_fn_error $? " MAX_NUM_THREADS=$MAX_NUM_THREADS is less than 4
     4909                " "$LINENO" 5
     4910        fi
     4911        max_num_threads="$MAX_NUM_THREADS"
     4912else
     4913        max_num_threads="48"
     4914        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using default value $max_num_threads" >&5
     4915$as_echo "no, using default value $max_num_threads" >&6; }
     4916fi
     4917cppad_max_num_threads=$max_num_threads
     4918
     4919
     4920{ $as_echo "$as_me:${as_lineno-$LINENO}: checking TAPE_ADDR_TYPE" >&5
     4921$as_echo_n "checking TAPE_ADDR_TYPE... " >&6; }
     4922
     4923if test "$TAPE_ADDR_TYPE" == "" ; then
     4924        addr_t="unsigned int"
     4925else
     4926        addr_t="$TAPE_ADDR_TYPE"
     4927fi
     4928cppad_tape_addr_type=$addr_t
     4929
     4930{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $addr_t" >&5
     4931$as_echo "$addr_t" >&6; }
     4932ok="no"
     4933if test "$addr_t" == "size_t" ; then
     4934        ok="yes"
     4935fi
     4936if test "$addr_t" == "int" ; then
     4937        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: TAPE_ADDR_TYPE=int is for CppAD developers (not users)
     4938        " >&5
     4939$as_echo "$as_me: WARNING: TAPE_ADDR_TYPE=int is for CppAD developers (not users)
     4940        " >&2;}
     4941        ok="yes"
     4942fi
     4943if test "$addr_t" == "unsigned int" ; then
     4944        ok="yes"
     4945fi
     4946if test "$addr_t" == "unsigned short int" ; then
     4947        ok="yes"
     4948fi
     4949if test "$ok" == "no" ; then
     4950        as_fn_error $? "$addr_t is not a valid choice for TAPE_ADDR_TYPE
     4951        " "$LINENO" 5
     4952fi
     4953
     4954{ $as_echo "$as_me:${as_lineno-$LINENO}: checking TAPE_ID_TYPE" >&5
     4955$as_echo_n "checking TAPE_ID_TYPE... " >&6; }
     4956
     4957if test "$TAPE_ID_TYPE" == "" ; then
     4958        tape_id_t="unsigned int"
     4959else
     4960        tape_id_t="$TAPE_ID_TYPE"
     4961fi
     4962cppad_tape_id_type=$tape_id_t
     4963
     4964{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tape_id_t" >&5
     4965$as_echo "$tape_id_t" >&6; }
     4966ok="no"
     4967if test "$tape_id_t" == "size_t" ; then
     4968        ok="yes"
     4969fi
     4970if test "$tape_id_t" == "int" ; then
     4971        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: TAPE_ID_TYPE=int is for CppAD developers (not users)
     4972        " >&5
     4973$as_echo "$as_me: WARNING: TAPE_ID_TYPE=int is for CppAD developers (not users)
     4974        " >&2;}
     4975        ok="yes"
     4976fi
     4977if test "$tape_id_t" == "unsigned int" ; then
     4978        ok="yes"
     4979fi
     4980if test "$tape_id_t" == "unsigned short int" ; then
     4981        ok="yes"
     4982fi
     4983if test "$ok" == "no" ; then
     4984        as_fn_error $? "$tape_id_t is not a valid choice for TAPE_ID_TYPE
     4985        " "$LINENO" 5
     4986fi
     4987{ $as_echo "$as_me:${as_lineno-$LINENO}: ********** End Checking Command Line arguments ***************" >&5
     4988$as_echo "$as_me: ********** End Checking Command Line arguments ***************" >&6;}
     4989
     4990if test "$enable_msvc" == "no"
     4991then
     4992        cxx_list="g++ clang++ CC pgCC icpc gpp cxx cc++"
     4993        cc_list="gcc clang cc pgcc icc"
     4994        fc_list="gfortran ifort g95 fort77 f77 g77 pgf90 pgf77 ifc frt af77"
     4995else
     4996                cxx_list="icl cl g++"
     4997        cc_list="icl cl gcc"
     4998        fc_list="ifort gfortran"
     4999fi
     5000
     5001ac_ext=cpp
     5002ac_cpp='$CXXCPP $CPPFLAGS'
     5003ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     5004ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     5005ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     5006if test -z "$CXX"; then
     5007  if test -n "$CCC"; then
     5008    CXX=$CCC
     5009  else
     5010    if test -n "$ac_tool_prefix"; then
     5011  for ac_prog in $cxx_list
     5012  do
     5013    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     5014set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     5015{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     5016$as_echo_n "checking for $ac_word... " >&6; }
     5017if ${ac_cv_prog_CXX+:} false; then :
     5018  $as_echo_n "(cached) " >&6
     5019else
     5020  if test -n "$CXX"; then
     5021  ac_cv_prog_CXX="$CXX" # Let the user override the test.
     5022else
     5023as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5024for as_dir in $PATH
     5025do
     5026  IFS=$as_save_IFS
     5027  test -z "$as_dir" && as_dir=.
     5028    for ac_exec_ext in '' $ac_executable_extensions; do
     5029  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     5030    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
     5031    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     5032    break 2
     5033  fi
     5034done
     5035  done
     5036IFS=$as_save_IFS
     5037
     5038fi
     5039fi
     5040CXX=$ac_cv_prog_CXX
     5041if test -n "$CXX"; then
     5042  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
     5043$as_echo "$CXX" >&6; }
     5044else
     5045  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     5046$as_echo "no" >&6; }
     5047fi
     5048
     5049
     5050    test -n "$CXX" && break
     5051  done
     5052fi
     5053if test -z "$CXX"; then
     5054  ac_ct_CXX=$CXX
     5055  for ac_prog in $cxx_list
     5056do
     5057  # Extract the first word of "$ac_prog", so it can be a program name with args.
     5058set dummy $ac_prog; ac_word=$2
     5059{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     5060$as_echo_n "checking for $ac_word... " >&6; }
     5061if ${ac_cv_prog_ac_ct_CXX+:} false; then :
     5062  $as_echo_n "(cached) " >&6
     5063else
     5064  if test -n "$ac_ct_CXX"; then
     5065  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
     5066else
     5067as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5068for as_dir in $PATH
     5069do
     5070  IFS=$as_save_IFS
     5071  test -z "$as_dir" && as_dir=.
     5072    for ac_exec_ext in '' $ac_executable_extensions; do
     5073  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     5074    ac_cv_prog_ac_ct_CXX="$ac_prog"
     5075    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     5076    break 2
     5077  fi
     5078done
     5079  done
     5080IFS=$as_save_IFS
     5081
     5082fi
     5083fi
     5084ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
     5085if test -n "$ac_ct_CXX"; then
     5086  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
     5087$as_echo "$ac_ct_CXX" >&6; }
     5088else
     5089  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     5090$as_echo "no" >&6; }
     5091fi
     5092
     5093
     5094  test -n "$ac_ct_CXX" && break
     5095done
     5096
     5097  if test "x$ac_ct_CXX" = x; then
     5098    CXX="g++"
     5099  else
     5100    case $cross_compiling:$ac_tool_warned in
     5101yes:)
     5102{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
     5103$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
     5104ac_tool_warned=yes ;;
     5105esac
     5106    CXX=$ac_ct_CXX
     5107  fi
     5108fi
     5109
     5110  fi
     5111fi
     5112# Provide some information about the compiler.
     5113$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
     5114set X $ac_compile
     5115ac_compiler=$2
     5116for ac_option in --version -v -V -qversion; do
     5117  { { ac_try="$ac_compiler $ac_option >&5"
     5118case "(($ac_try" in
     5119  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     5120  *) ac_try_echo=$ac_try;;
     5121esac
     5122eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
     5123$as_echo "$ac_try_echo"; } >&5
     5124  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
     5125  ac_status=$?
     5126  if test -s conftest.err; then
     5127    sed '10a\
     5128... rest of stderr output deleted ...
     5129         10q' conftest.err >conftest.er1
     5130    cat conftest.er1 >&5
     5131  fi
     5132  rm -f conftest.er1 conftest.err
     5133  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
     5134  test $ac_status = 0; }
     5135done
     5136
    41715137{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
    41725138$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
     
    42895255ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    42905256ac_compiler_gnu=$ac_cv_c_compiler_gnu
    4291 DEPDIR="${am__leading_dot}deps"
    4292 
    4293 ac_config_commands="$ac_config_commands depfiles"
    4294 
    4295 
    4296 am_make=${MAKE-make}
    4297 cat > confinc << 'END'
    4298 am__doit:
    4299         @echo this is the am__doit target
    4300 .PHONY: am__doit
    4301 END
    4302 # If we don't find an include directive, just comment out the code.
    4303 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
    4304 $as_echo_n "checking for style of include used by $am_make... " >&6; }
    4305 am__include="#"
    4306 am__quote=
    4307 _am_result=none
    4308 # First try GNU make style include.
    4309 echo "include confinc" > confmf
    4310 # Ignore all kinds of additional output from 'make'.
    4311 case `$am_make -s -f confmf 2> /dev/null` in #(
    4312 *the\ am__doit\ target*)
    4313   am__include=include
    4314   am__quote=
    4315   _am_result=GNU
    4316   ;;
    4317 esac
    4318 # Now try BSD make style include.
    4319 if test "$am__include" = "#"; then
    4320    echo '.include "confinc"' > confmf
    4321    case `$am_make -s -f confmf 2> /dev/null` in #(
    4322    *the\ am__doit\ target*)
    4323      am__include=.include
    4324      am__quote="\""
    4325      _am_result=BSD
    4326      ;;
    4327    esac
    4328 fi
    4329 
    4330 
    4331 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
    4332 $as_echo "$_am_result" >&6; }
    4333 rm -f confinc confmf
    4334 
    4335 # Check whether --enable-dependency-tracking was given.
    4336 if test "${enable_dependency_tracking+set}" = set; then :
    4337   enableval=$enable_dependency_tracking;
    4338 fi
    4339 
    4340 if test "x$enable_dependency_tracking" != xno; then
    4341   am_depcomp="$ac_aux_dir/depcomp"
    4342   AMDEPBACKSLASH='\'
    4343   am__nodep='_no'
    4344 fi
    4345  if test "x$enable_dependency_tracking" != xno; then
    4346   AMDEP_TRUE=
    4347   AMDEP_FALSE='#'
    4348 else
    4349   AMDEP_TRUE='#'
    4350   AMDEP_FALSE=
    4351 fi
    4352 
    4353 
    43545257
    43555258depcc="$CXX"  am_compiler_list=
     
    52806183
    52816184
    5282 
    5283 if test -n "$ac_tool_prefix"; then
    5284   for ac_prog in ar lib "link -lib"
    5285   do
    5286     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
    5287 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
    5288 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5289 $as_echo_n "checking for $ac_word... " >&6; }
    5290 if ${ac_cv_prog_AR+:} false; then :
    5291   $as_echo_n "(cached) " >&6
    5292 else
    5293   if test -n "$AR"; then
    5294   ac_cv_prog_AR="$AR" # Let the user override the test.
    5295 else
    5296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5297 for as_dir in $PATH
    5298 do
    5299   IFS=$as_save_IFS
    5300   test -z "$as_dir" && as_dir=.
    5301     for ac_exec_ext in '' $ac_executable_extensions; do
    5302   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5303     ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
    5304     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5305     break 2
    5306   fi
    5307 done
    5308   done
    5309 IFS=$as_save_IFS
    5310 
    5311 fi
    5312 fi
    5313 AR=$ac_cv_prog_AR
    5314 if test -n "$AR"; then
    5315   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
    5316 $as_echo "$AR" >&6; }
    5317 else
    5318   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5319 $as_echo "no" >&6; }
    5320 fi
    5321 
    5322 
    5323     test -n "$AR" && break
    5324   done
    5325 fi
    5326 if test -z "$AR"; then
    5327   ac_ct_AR=$AR
    5328   for ac_prog in ar lib "link -lib"
    5329 do
    5330   # Extract the first word of "$ac_prog", so it can be a program name with args.
    5331 set dummy $ac_prog; ac_word=$2
    5332 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5333 $as_echo_n "checking for $ac_word... " >&6; }
    5334 if ${ac_cv_prog_ac_ct_AR+:} false; then :
    5335   $as_echo_n "(cached) " >&6
    5336 else
    5337   if test -n "$ac_ct_AR"; then
    5338   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
    5339 else
    5340 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5341 for as_dir in $PATH
    5342 do
    5343   IFS=$as_save_IFS
    5344   test -z "$as_dir" && as_dir=.
    5345     for ac_exec_ext in '' $ac_executable_extensions; do
    5346   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5347     ac_cv_prog_ac_ct_AR="$ac_prog"
    5348     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5349     break 2
    5350   fi
    5351 done
    5352   done
    5353 IFS=$as_save_IFS
    5354 
    5355 fi
    5356 fi
    5357 ac_ct_AR=$ac_cv_prog_ac_ct_AR
    5358 if test -n "$ac_ct_AR"; then
    5359   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
    5360 $as_echo "$ac_ct_AR" >&6; }
    5361 else
    5362   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5363 $as_echo "no" >&6; }
    5364 fi
    5365 
    5366 
    5367   test -n "$ac_ct_AR" && break
    5368 done
    5369 
    5370   if test "x$ac_ct_AR" = x; then
    5371     AR="false"
    5372   else
    5373     case $cross_compiling:$ac_tool_warned in
    5374 yes:)
    5375 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    5376 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    5377 ac_tool_warned=yes ;;
    5378 esac
    5379     AR=$ac_ct_AR
    5380   fi
    5381 fi
    5382 
    5383 : ${AR=ar}
    5384 
    5385 { $as_echo "$as_me:${as_lineno-$LINENO}: checking the archiver ($AR) interface" >&5
    5386 $as_echo_n "checking the archiver ($AR) interface... " >&6; }
    5387 if ${am_cv_ar_interface+:} false; then :
    5388   $as_echo_n "(cached) " >&6
    5389 else
    5390   ac_ext=c
    5391 ac_cpp='$CPP $CPPFLAGS'
    5392 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    5393 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    5394 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    5395 
    5396    am_cv_ar_interface=ar
    5397    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    5398 /* end confdefs.h.  */
    5399 int some_variable = 0;
    5400 _ACEOF
    5401 if ac_fn_c_try_compile "$LINENO"; then :
    5402   am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&5'
    5403       { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5
    5404   (eval $am_ar_try) 2>&5
    5405   ac_status=$?
    5406   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    5407   test $ac_status = 0; }
    5408       if test "$ac_status" -eq 0; then
    5409         am_cv_ar_interface=ar
    5410       else
    5411         am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&5'
    5412         { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5
    5413   (eval $am_ar_try) 2>&5
    5414   ac_status=$?
    5415   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    5416   test $ac_status = 0; }
    5417         if test "$ac_status" -eq 0; then
    5418           am_cv_ar_interface=lib
    5419         else
    5420           am_cv_ar_interface=unknown
    5421         fi
    5422       fi
    5423       rm -f conftest.lib libconftest.a
    5424 
    5425 fi
    5426 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    5427    ac_ext=c
    5428 ac_cpp='$CPP $CPPFLAGS'
    5429 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    5430 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    5431 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    5432 
    5433 fi
    5434 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_ar_interface" >&5
    5435 $as_echo "$am_cv_ar_interface" >&6; }
    5436 
    5437 case $am_cv_ar_interface in
    5438 ar)
    5439   ;;
    5440 lib)
    5441   # Microsoft lib, so override with the ar-lib wrapper script.
    5442   # FIXME: It is wrong to rewrite AR.
    5443   # But if we don't then we get into trouble of one sort or another.
    5444   # A longer-term fix would be to have automake use am__AR in this case,
    5445   # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something
    5446   # similar.
    5447   AR="$am_aux_dir/ar-lib $AR"
    5448   ;;
    5449 unknown)
    5450   as_fn_error $? "could not determine $AR interface" "$LINENO" 5
    5451   ;;
    5452 esac
    5453 
    5454  if test "$AR" = "ar"; then
     6185 if test "$have_ar" = 'yes' ; then
    54556186  CppAD_HAVE_AR_TRUE=
    54566187  CppAD_HAVE_AR_FALSE='#'
     
    54606191fi
    54616192
    5462 if test "$AR" != "ar"; then
     6193if test "$have_ar" = 'no'; then
    54636194        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot build any libraries because ar is missing; e.g,, speed/* not built
    54646195        " >&5
     
    73658096fi
    73668097
     8098if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
     8099  as_fn_error $? "conditional \"AMDEP\" was never defined.
     8100Usually this means the macro was only invoked conditionally." "$LINENO" 5
     8101fi
     8102if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
     8103  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
     8104Usually this means the macro was only invoked conditionally." "$LINENO" 5
     8105fi
    73678106if test -z "${CppAD_DOCUMENTATION_TRUE}" && test -z "${CppAD_DOCUMENTATION_FALSE}"; then
    73688107  as_fn_error $? "conditional \"CppAD_DOCUMENTATION\" was never defined.
     
    73998138if test -z "${CppAD_OPENMP_TRUE}" && test -z "${CppAD_OPENMP_FALSE}"; then
    74008139  as_fn_error $? "conditional \"CppAD_OPENMP\" was never defined.
    7401 Usually this means the macro was only invoked conditionally." "$LINENO" 5
    7402 fi
    7403 if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
    7404   as_fn_error $? "conditional \"AMDEP\" was never defined.
    74058140Usually this means the macro was only invoked conditionally." "$LINENO" 5
    74068141fi
  • trunk/configure.ac

    r3692 r3730  
    3232dnl http://lists.gnu.org/archive/html/automake/2010-08/msg00113.html
    3333AM_INIT_AUTOMAKE([nostdinc subdir-objects -Wall])
     34
     35# check if we have ar program
     36have_ar='yes'
     37AM_PROG_AR([have_ar='no'])
     38AC_MSG_NOTICE([have_ar = $have_ar])
    3439
    3540dnl ----------------------------------------------------------------------
     
    365370if test "$MAX_NUM_THREADS" != "" ; then
    366371        AC_MSG_RESULT([$MAX_NUM_THREADS])
    367         if test "$MAX_NUM_THREADS" -lt "4" ; then
     372        if test "$MAX_NUM_THREADS" -lt "4" ; then
    368373                AC_MSG_ERROR(
    369374                        [ MAX_NUM_THREADS=$MAX_NUM_THREADS is less than 4 ]
     
    404409fi
    405410if test "$ok" == "no" ; then
    406         AC_MSG_ERROR(
     411        AC_MSG_ERROR(
    407412                [$addr_t is not a valid choice for TAPE_ADDR_TYPE]
    408413        )
     
    436441fi
    437442if test "$ok" == "no" ; then
    438         AC_MSG_ERROR(
     443        AC_MSG_ERROR(
    439444                [$tape_id_t is not a valid choice for TAPE_ID_TYPE]
    440445        )
     
    475480
    476481dnl check if we can build libraries
    477 AM_PROG_AR()
    478 AM_CONDITIONAL(CppAD_HAVE_AR, test "$AR" = "ar")
    479 if test "$AR" != "ar"; then
     482AM_CONDITIONAL(CppAD_HAVE_AR, test "$have_ar" = 'yes' )
     483if test "$have_ar" = 'no'; then
    480484        AC_MSG_WARN(
    481485        [cannot build any libraries because ar is missing; e.g,, speed/* not built]
  • trunk/cppad/local/op_code.hpp

    r3684 r3730  
    5050        AbsOp,    //  abs(variable)
    5151        AcosOp,   // acos(variable)
    52         AcoshOp,   // acosh(variable)
     52        AcoshOp,  // acosh(variable)
    5353        AddpvOp,  //      parameter  + variable
    5454        AddvvOp,  //      variable   + variable
     
    5656        AsinhOp,  // asinh(variable)
    5757        AtanOp,   // atan(variable)
    58         AtanhOp,   // atanh(variable)
     58        AtanhOp,  // atanh(variable)
    5959        BeginOp,  // used to mark the beginning of the tape
    6060        CExpOp,   // CondExpRel(left, right, trueCase, falseCase)
     
    8989        // arg[3+arg[0]+arg[1]] = arg[0] + arg[1]
    9090        DisOp,    //  discrete::eval(index, variable)
    91         DivpvOp,  //      parameter  / variable
    92         DivvpOp,  //      variable   / parameter
    93         DivvvOp,  //      variable   / variable
     91        DivpvOp,  //  parameter  / variable
     92        DivvpOp,  //  variable   / parameter
     93        DivvvOp,  //  variable   / variable
    9494        EndOp,    //  used to mark the end of the tape
    9595        EqpvOp,   //  parameter  == variable
     
    9797        ErfOp,    //  erf(variable)
    9898        ExpOp,    //  exp(variable)
    99         Expm1Op,   // expm1(variable)
    100         InvOp,    //                             independent variable
    101         LdpOp,    //    z[parameter]
    102         LdvOp,    //    z[variable]
     99        Expm1Op,  // expm1(variable)
     100        InvOp,    //  independent variable
     101        LdpOp,    //  z[parameter]
     102        LdvOp,    //  z[variable]
    103103        LepvOp,   //  parameter <= variable
    104104        LevpOp,   //  variable  <= parameter
    105105        LevvOp,   //  variable  <= variable
    106106        LogOp,    //  log(variable)
    107         Log1pOp,   // log1p(variable)
     107        Log1pOp,  // log1p(variable)
    108108        LtpvOp,   //  parameter < variable
    109109        LtvpOp,   //  variable  < parameter
    110110        LtvvOp,   //  variable  < variable
    111         MulpvOp,  //      parameter  * variable
    112         MulvvOp,  //      variable   * variable
     111        MulpvOp,  //  parameter  * variable
     112        MulvvOp,  //  variable   * variable
    113113        NepvOp,   //  parameter  != variable
    114114        NevvOp,   //  variable   != variable
    115         ParOp,    //      parameter
     115        ParOp,    //  parameter
    116116        PowpvOp,  //  pow(parameter,   variable)
    117117        PowvpOp,  //  pow(variable,    parameter)
    118118        PowvvOp,  //  pow(variable,    variable)
    119119        PriOp,    //  PrintFor(text, parameter or variable, parameter or variable)
    120         SignOp,   // sign(variable)
     120        SignOp,   //  sign(variable)
    121121        SinOp,    //  sin(variable)
    122         SinhOp,   // sinh(variable)
    123         SqrtOp,   // sqrt(variable)
    124         StppOp,   //    z[parameter] = parameter
    125         StpvOp,   //    z[parameter] = variable
    126         StvpOp,   //    z[variable]  = parameter
    127         StvvOp,   //    z[variable]  = variable
    128         SubpvOp,  //      parameter  - variable
    129         SubvpOp,  //      variable   - parameter
    130         SubvvOp,  //      variable   - variable
     122        SinhOp,   //  sinh(variable)
     123        SqrtOp,   //  sqrt(variable)
     124        StppOp,   //  z[parameter] = parameter
     125        StpvOp,   //  z[parameter] = variable
     126        StvpOp,   //  z[variable]  = parameter
     127        StvvOp,   //  z[variable]  = variable
     128        SubpvOp,  //  parameter  - variable
     129        SubvpOp,  //  variable   - parameter
     130        SubvvOp,  //  variable   - variable
    131131        TanOp,    //  tan(variable)
    132132        TanhOp,   //  tan(variable)
     
    234234                1, // UsravOp
    235235                1, // UsrrpOp
    236                 0  // UsrrvOp
     236                0, // UsrrvOp
     237                0  // NumberOp not used
    237238        };
    238239# ifndef NDEBUG
     
    240241        static bool first = true;
    241242        if( first )
    242         {       CPPAD_ASSERT_UNKNOWN( size_t(NumberOp) ==
     243        {       CPPAD_ASSERT_UNKNOWN( size_t(NumberOp) + 1 ==
    243244                        sizeof(NumArgTable) / sizeof(NumArgTable[0])
    244245                );
     
    340341                0, // UsrrpOp
    341342                1, // UsrrvOp
    342                 0  // Last entry not used: avoids g++ 4.3.2 warn when pycppad builds
     343                0  // NumberOp not used and avoids g++ 4.3.2 warn when pycppad builds
    343344        };
    344345        // check ensuring conversion to size_t is as expected
    345         CPPAD_ASSERT_UNKNOWN( size_t(NumberOp) ==
    346                 sizeof(NumResTable) / sizeof(NumResTable[0]) - 1
     346        CPPAD_ASSERT_UNKNOWN( size_t(NumberOp) + 1 ==
     347                sizeof(NumResTable) / sizeof(NumResTable[0])
    347348        );
    348349        // this test ensures that all indices are within the table
     
    371372                "Addvv" ,
    372373                "Asin"  ,
    373                 "Asinh"  ,
     374                "Asinh" ,
    374375                "Atan"  ,
    375376                "Atanh" ,
     
    427428                "Usrav" ,
    428429                "Usrrp" ,
    429                 "Usrrv"
     430                "Usrrv" ,
     431                "Number"  // not used
    430432        };
    431433        // check ensuring conversion to size_t is as expected
     
    584586                if( size_t(ind[4]) < 3 )
    585587                {       for(i = 0; i < size_t(ind[4]); i++)
    586                                 printOpField(os, " ot=", ind[6+i], ncol);
     588                                printOpField(os, " ot=", ind[6+i], ncol);
    587589                }
    588590                else
    589591                {       printOpField(os, "\n\tot=", ind[6+0], ncol);
    590592                        for(i = 1; i < size_t(ind[4]); i++)
    591                                 printOpField(os, " ot=", ind[6+i], ncol);
     593                                printOpField(os, " ot=", ind[6+i], ncol);
    592594                }
    593595                if( size_t(ind[5]) < 3 )
     
    662664                case AddvvOp:
    663665                case DivvvOp:
     666                case EqvvOp:
    664667                case LevvOp:
    665668                case LtvvOp:
    666                 case EqvvOp:
    667669                case NevvOp:
    668670                case MulvvOp:
     
    675677
    676678                case AddpvOp:
     679                case EqpvOp:
     680                case DivpvOp:
    677681                case LepvOp:
    678682                case LtpvOp:
    679                 case EqpvOp:
    680683                case NepvOp:
    681684                case SubpvOp:
    682685                case MulpvOp:
    683686                case PowpvOp:
    684                 case DivpvOp:
    685687                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
    686688                printOpField(os, " pl=", play->GetPar(ind[0]), ncol);
Note: See TracChangeset for help on using the changeset viewer.