#!/bin/sh
#
#  Name:
#     mex    compilation program for MATLAB C and Fortran language MEX-files
#
#  Usage:
#    MEX [option1 ... optionN] sourcefile1 [... sourcefileN]
#        [objectfile1 ... objectfileN] [libraryfile1 ... libraryfileN]
#  
#  Description:
#    MEX compiles and links source files into a shared library called a
#    MEX-file, executable from within MATLAB. The resulting file has a
#    platform-dependent extension, as shown in the table below:
#  
#      sol2, SunOS 5.x - .mexsol
#      hpux            - .mexhpux
#      hp700           - .mexhp7
#      ibm_rs          - .mexrs6
#      sgi             - .mexsg
#      alpha           - .mexaxp
#      glnx86          - .mexglx
#      Windows         - .dll
#  
#    The first file name given (less any file name extension) will be the name
#    of the resulting MEX-file. Additional source, object, or library files can
#    be given to satisfy external references. On Windows, either C or Fortran,
#    but not both, may be specified. On UNIX, both C and Fortran source files
#    can be specified when building a MEX-file. If C and Fortran are mixed, the
#    first source file given determines the entry point exported from the
#    MEX-file (MATLAB loads and runs a different entry point symbol for C or
#    Fortran MEX-files).
#  
#    Both an options file and command line options affect the behavior of MEX.
#    The options file contains a list of variables that are passed as arguments
#    to various tools such as the compiler, linker, and other platform-
#    dependent tools (such as the resource linker on Windows). Command line
#    options to MEX may also affect what arguments are passed to these tools,
#    or may control other aspects of MEX's behavior.
#  
#  Command Line Options:
#    Options available on all platforms:
#  
#    -ada <sfcn.ads>
#        Use this option to compile a Simulink S-function written in Ada, where
#        <sfcn.ads> is the Package Specification for the S-function. When this
#        option is specified, only the -v (verbose) and -g (debug) options are
#        relevant. All other options are ignored. See
#        $MATLAB/simulink/ada/examples/README for examples and info on
#        supported compilers and other requirements.
#    -argcheck
#        Add argument checking. This adds code so that arguments passed
#        incorrectly to MATLAB API functions will cause assertion failures.
#        Adds -DARGCHECK to the C compiler flags, and adds
#        $MATLAB/extern/src/mwdebug.c to the list of source files. (C functions
#        only).
#    -c
#        Compile only. Creates an object file but not a MEX-file.
#    -D<name>
#        Define a symbol name to the C preprocessor. Equivalent to a
#        "#define <name>" directive in the source.
#    -D<name>#<value>
#        Define a symbol name and value to the C preprocessor. Equivalent to a
#        "#define <name> <value>" directive in the source.
#    -f <optionsfile>
#        Specify location and name of options file to use. Overrides MEX's
#        default options file search mechanism.
#    -g
#        Create a debuggable MEX-file. If this option is specified, MEX appends
#        the value of options file variables ending in DEBUGFLAGS with their
#        corresponding base variable. (For example, the value of LINKDEBUGFLAGS
#        would be appended to the LINKFLAGS variable before calling the
#        linker.) This option also disables MEX's default behavior of
#        optimizing built object code.
#    -h[elp]
#        Print this message.
#    -I<pathname>
#        Add <pathname> to the list of directories to search for #include
#        files.
#    -inline
#        Inline matrix accessor functions (mx*). The MEX-function generated
#        may not be compatible with future versions of MATLAB.
#    -n
#        No execute mode. Print out any commands that MEX would otherwise have
#        executed, but do not actually execute any of them.
#    -O
#        Optimize the object code by including the optimization flags listed in
#        the options file. If this option is specified, MEX appends the value
#        of options file variables ending in OPTIMFLAGS with their
#        corresponding base variable. (For example, the value of LINKOPTIMFLAGS
#        would be appended to the LINKFLAGS variable before calling the
#        linker.) Note that optimizations are enabled by default, are disabled
#        by the -g option, but are reenabled by -O.
#    -outdir <dirname>
#        Place all output files in directory <dirname>.
#    -output <resultname>
#        Create MEX-file named <resultname> (an appropriate MEX-file extension
#        is automatically appended). Overrides MEX's default MEX-file naming
#        mechanism.
#    -setup
#        Interactively specify the compiler options file to use as default for
#        future invocations of MEX by placing it in "<UserProfile>\Application
#        Data\MathWorks\MATLAB\R12" (for Windows) or $HOME/.matlab/R12 (for
#        UNIX). When this option is specified, no other command line input is
#        accepted.
#    -U<name>
#        Remove any initial definition of the C preprocessor symbol <name>.
#        (Inverse of the -D option.)
#    -v
#        Print the values for important internal variables after the options
#        file is processed and all command line arguments are considered.
#        Prints each compile step and final link step fully evaluated to see
#        which options and files were used. Very useful for debugging.
#    -V4
#        Compile a MATLAB 4-style MEX-file. This option is intended as an aid
#        to migration, and is not recommended as a permanent solution.
#    <name>#<value>
#        Override an options file variable for variable <name>. See the
#        platform-dependent discussion of options files below for more details.
#        This option is processed after the options file is processed and all
#        command line arguments are considered.
#  
#  Additional options available on Windows platforms:
#  
#    @<rspfile>
#        Include contents of the text file <rspfile> as command line arguments
#        to MEX.
#  
#  Additional options available on Unix platforms:
#  
#    -<arch>
#        Assume local host has architecture <arch>. Possible values for <arch>
#        include sol2, hpux, hp700, alpha, ibm_rs, sgi, and glnx86.
#    -D<name>=<value>
#        Define a symbol name and value to the C preprocessor. Equivalent to a
#        "#define <name> <value>" directive in the source.
#    -fortran
#        Specify that the gateway routine is in Fortran. This will override
#        what the script normally assumes, which is that the first source file
#        in the list is the gateway routine.
#    -l<name>
#        Link with object library "lib<name>" (for "ld(1)").
#    -L<directory>
#        Add <directory> to the list of directories containing object-library
#        routines (for linking using "ld(1)").
#    <name>=<value>
#        Override an options file variable for variable <name>. See the
#        platform-dependent discussion of options files below for more details.
#  
#  Options File Details:
#    On Windows:
#      The options file is written as a DOS batch file. If the -f option is not
#      used to specify the options file name and location, then MEX searches
#      for an options file named mexopts.bat in the following directories: the
#      current directory, then the directory "<UserProfile>\Application
#      Data\MathWorks\MATLAB\R12". Any variable specified in the options file
#      can be overridden at the command line by use of the <name>#<value>
#      command line argument. If <value> has spaces in it, then it should be
#      wrapped in double quotes (e.g., COMPFLAGS#"opt1 opt2"). The definition
#      can rely on other variables defined in the options file; in this case
#      the variable referenced should have a prepended "$" (e.g.,
#      COMPFLAGS#"$COMPFLAGS opt2").
#  
#      Note: The options files in $MATLAB\bin\mexopts named *engmatopts.bat are
#      special case options files that can be used with MEX (via the -f option)
#      to generate stand-alone MATLAB Engine and MATLAB MAT-API executables.
#      Such executables are given a ".exe" extension.
#  
#    On UNIX:
#      The options file is written as a UNIX shell script. If the -f option is
#      not used to specify the options file name and location, then MEX
#      searches for an options file named mexopts.sh in the following
#      directories: the current directory (.), then $HOME/.matlab/R12, then
#      $MATLAB/bin. Any variable specified in the options file can be
#      overridden at the command line by use of the <name>=<def> command line
#      argument. If <def> has spaces in it, then it should be wrapped in single
#      quotes (e.g., CFLAGS='opt1 opt2'). The definition can rely on other
#      variables defined in the options file; in this case the variable
#      referenced should have a prepended "$" (e.g., CFLAGS='$CFLAGS opt2').
#  
#      Note: The options files in $MATLAB/bin named engopts.sh and matopts.sh
#      are special case options files that can be used with MEX (via the -f
#      option) to generate stand-alone MATLAB Engine and MATLAB MAT-API
#      executables. Such executables are not given any default extension.
#  
#  Examples:
#      The following command will compile "myprog.c" into "myprog.mexsol" (when
#      run under Solaris):
#  
#        mex myprog.c
#  
#      When debugging, it is often useful to use "verbose" mode as well
#      as include symbolic debugging information:
#  
#        mex -v -g myprog.c
#  
#  Files:
#     mexopts.sh,                         Mex options file that is
#     $HOME/.matlab/R12/mexopts.sh,       source from from the first
#     $MATLAB/bin/mexopts.sh              file in the list. It allows
#                                         the user to set the values 
#                                         for important directories,
#                                         files, and environment
#                                         variables. See 
#                                         $MATLAB/bin/mexopts.sh 
#                                         for a template.
#     matlab/extern/include/mex.h         Header file for MEX files.
#     matlab/extern/lib/ibm_rs/exp.ibm_rs Text file containing a list of
#                                         symbols exported by MATLAB. Needed
#                                         for linking mex files on the
#                                         IBM/RS 6000.
#     matlab/extern/lib/sol2/mapfile      Map file to specify export
#                                         symbols on Solaris platform.
#
#  See Also:
#     MATLAB API User's Guide
#
# Copyright (c) 1984-2000 The MathWorks, Inc.
# $Revision: 1.92 $  $Date: 2000/08/29 18:32:21 $
#____________________________________________________________________________
    arg0_=$0
#
    abort='rm -f $files_to_remove $basename.o > /dev/null 2>&1; \
          echo ""; \
          echo "    mex:  interrupted."; \
          echo ""'
#
    trap "eval $abort; exit 1" 1 2 3 15
#
#========================= archlist.sh (start) ============================
#
# usage:        archlist.sh
#
# abstract:     This Bourne Shell script creates the variable ARCH_LIST.
#
# note(s):      1. This file is always imbedded in another script
#
# Copyright 1997-2000 The MathWorks, Inc.
# $Revision: 1.8 $  $Date: 2000/06/16 16:08:59 $
#----------------------------------------------------------------------------
#
    ARCH_LIST='sol2 hpux hp700 alpha ibm_rs sgi glnx86'
#=======================================================================
# Functions:
#   check_archlist ()
#=======================================================================
    check_archlist () { # Sets ARCH. If first argument contains a valid
			# arch then ARCH is set to that value else
		        # an empty string. If there is a second argument
			# do not output any warning message. The most
			# common forms of the first argument are:
			#
			#     ARCH=arch
			#     MATLAB_ARCH=arch
			#     argument=-arch
			#
                        # Always returns a 0 status.
                        #
                        # usage: check_archlist arch=[-]value [noprint]
                        #
	if [ $# -gt 0 ]; then
	    arch_in=`expr "$1" : '.*=\(.*\)'`
	    if [ "$arch_in" != "" ]; then
	        ARCH=`echo "$ARCH_LIST EOF $arch_in" | awk '
#-----------------------------------------------------------------------
	{ for (i = 1; i <= NF; i = i + 1)
	      if ($i == "EOF")
		  narch = i - 1
	  for (i = 1; i <= narch; i = i + 1)
		if ($i == $NF || "-" $i == $NF) {
		    print $i
		    exit
		}
	}'`
#-----------------------------------------------------------------------
	       if [ "$ARCH" = "" -a $# -eq 1 ]; then
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
echo ' '
echo "    Warning: $1 does not specify a valid architecture - ignored . . ."
echo ' '
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	       fi
	    else
		ARCH=""
	    fi
	else
	    ARCH=""
	fi
#
	return 0
    }
#=======================================================================
#========================= archlist.sh (end) ==============================
#
#============================================================================
#  FUNCTION DEFINITIONS
#============================================================================
#
#****************************************************************************
#
# NOTE: A call to cleanup MUST precede any call to exit within this script,
#       except for within trap calls.
  cleanup () {
#
# Clean up temporary and intermediate files (usually in preparation
# for exiting)
#
    trap "eval $abort; exit 1" 1 2 3 15
    if [ -f $SO_LOCATIONS ]; then
        rm -f $SO_LOCATIONS > /dev/null 2>&1
    fi
    rm -f $files_to_remove > /dev/null 2>&1
    }
#   end cleanup ()
#
#****************************************************************************
#
  describe () {
#
    case "$1" in
        internal_error_1)
    echo ''
    echo 'Internal error 1: We could not determine the path of the'
    echo '                  MATLAB root directory.'
    echo ''
    echo "                  original command path = $arg0_"
    echo "                  current  command path = $filename"
    echo ''
    echo '                  Please contact:'
    echo '' 
    echo '                      MathWorks Technical Support'
    echo ''
    echo '                  for further assistance.'
    echo ''
            ;;
        internal_error_2)
    echo ''
    echo 'Internal error 2: Could not determine the path of the'
    echo '                  MATLAB root directory.'
    echo ''
    echo "                  original command path = $filename"
    echo "                  current  command path = $filename"
    echo ''
    echo '                  Please contact:'
    echo '' 
    echo '                      MathWorks Technical Support'
    echo ''
    echo '                  for further assistance.'
    echo ''
            ;;
        internal_error_3)
    echo ''
    echo 'Internal error 3: More than $maxlinks links in path to'
    echo "                  this script. That's too many!"
    echo ''
    echo "                  original command path = $filename"
    echo "                  current  command path = $filename"
    echo ''
    echo '                  Please contact:'
    echo '' 
    echo '                      MathWorks Technical Support'
    echo ''
    echo '                  for further assistance.'
    echo ''
            ;;        
        unknown_architecture)
    echo ''
    echo '    Sorry! We could not determine the machine architecture'
    echo '           for your host. Please contact:'
    echo ''
    echo '               MathWorks Technical Support'
    echo ''
    echo '           for further assistance.'
    echo ''
            ;;
        no_util_scripts)
    echo ''
    echo '    Sorry! We could not determine the machine architecture'
    echo '           for your host, because one of the utilities'
    echo ''
    echo '               $MATLAB/bin/util/arch.sh'
    echo ''
    echo '           or'
    echo ''
    echo '               $MATLAB/bin/util/oscheck.sh'
    echo ''
    echo '           could not be found. Please make sure that your'
    echo '           installation is not corrupted.  If you specified'
    echo '           the value of $MATLAB in the command line, please'
    echo '           make sure you specified the right value.'
    echo ''
    echo '           Here'
    echo ''
    echo "               MATLAB = $MATLAB"
    echo ''
    echo '           Please contact:'
    echo ''
    echo '               MathWorks Technical Support'
    echo ''
    echo '           if you need assistance.'
    echo ''
            ;;
        unknown_arch)
    echo ''
    echo "    mex:  machine architecture '$Arch' not supported."
    echo ''
            ;;
        invalid_options_file)
    echo ''
    echo '    Error: An invalid options file name was specified:'
    echo "           $2 is not a normal file or does not exist."
    echo ''
            ;;
        no_options_file)
    echo ''
    echo '    Sorry! No options file was found for mex.'
    echo '           The mex script must be able to source'
    echo '           an options file to define compiler flags'
    echo '           and other settings.  This options file'
    echo "           is normally found in MATLAB/bin/$OPTSFILE_NAME."
    echo '           Please check to make sure that your installation'
    echo '           is complete and includes this file.'
    echo ''
    echo '           Here'
    echo ''
    echo "               MATLAB = $MATLAB"
    echo ''
    echo '           Please contact:'
    echo ''
    echo '               MathWorks Technical Support'
    echo ''
    echo '           for further assistance.'
    echo ''
            ;;
        final_options)
            if [ "$SOURCE_DIR" = "none" ]; then
    echo '----------------------------------------------------------------'
    echo "-> options file specified on command line:"
    echo "   FILE = $OPTIONS_FILE"
            elif [ "$SOURCE_DIR" != "" ]; then
    echo "-> $OPTSFILE_NAME sourced from directory (DIR = $SOURCE_DIR)"
    echo "   FILE = $SOURCE_DIReval/$OPTSFILE_NAME"
            else
    echo "-> options file not found ($OPTSFILE_NAME looked for)."
            fi
    echo '----------------------------------------------------------------'
    echo "->    MATLAB                = $MATLAB"
    echo "->    CC                    = $CC"
    echo "->    CC flags:"
    echo "         CFLAGS             = $CFLAGS"
    echo "         CDEBUGFLAGS        = $CDEBUGFLAGS"
    echo "         COPTIMFLAGS        = $COPTIMFLAGS"
    echo "         CLIBS              = $CLIBS"
    echo "         arguments          = $cc_flags"
    echo "->    FC                    = $FC"
    echo "->    FC flags:"
    echo "         FFLAGS             = $FFLAGS"
    echo "         FDEBUGFLAGS        = $FDEBUGFLAGS"
    echo "         FOPTIMFLAGS        = $FOPTIMFLAGS"
    echo "         FLIBS              = $FLIBS"
    echo "         arguments          = $fc_flags"
    echo "->    LD                    = $LD"
    echo "->    Link flags:"
    echo "         LDFLAGS            = $LDFLAGS"
    echo "         LDDEBUGFLAGS       = $LDDEBUGFLAGS"
    echo "         LDOPTIMFLAGS       = $LDOPTIMFLAGS"
    echo "         LDEXTENSION        = $LDEXTENSION"
    echo "         arguments          = $libs"
    echo '----------------------------------------------------------------'
    echo ''
            ;;
        assuming_c_source)
    echo ''
    echo '    Warning: No source files in argument list.'
    echo ''
    echo '      Assuming C source code. To override this assumption, use'
    echo '      -fortran.'
    echo ''
            ;;
        meaningless_output_flag)
    echo ''
    echo '    Warning: -output ignored (no MEX-file is being created).'
    echo ''
            ;;
        assuming_matlab_5)
    echo '      Assuming fully MATLAB 6 compliant MEX-file.  To override'
    echo '      this assumption, use -V4.'
    echo ''
            ;;
        status)
    echo ""
    echo "    mex:  $stat"
            ;;
        help)
    cat<<'EOF'

Usage:
  MEX [option1 ... optionN] sourcefile1 [... sourcefileN]
      [objectfile1 ... objectfileN] [libraryfile1 ... libraryfileN]

Description:
  MEX compiles and links source files into a shared library called a
  MEX-file, executable from within MATLAB. The resulting file has a
  platform-dependent extension, as shown in the table below:

    sol2, SunOS 5.x - .mexsol
    hpux            - .mexhpux
    hp700           - .mexhp7
    ibm_rs          - .mexrs6
    sgi             - .mexsg
    alpha           - .mexaxp
    glnx86          - .mexglx
    Windows         - .dll

  The first file name given (less any file name extension) will be the name
  of the resulting MEX-file. Additional source, object, or library files can
  be given to satisfy external references. On Windows, either C or Fortran,
  but not both, may be specified. On UNIX, both C and Fortran source files
  can be specified when building a MEX-file. If C and Fortran are mixed, the
  first source file given determines the entry point exported from the
  MEX-file (MATLAB loads and runs a different entry point symbol for C or
  Fortran MEX-files).

  Both an options file and command line options affect the behavior of MEX.
  The options file contains a list of variables that are passed as arguments
  to various tools such as the compiler, linker, and other platform-
  dependent tools (such as the resource linker on Windows). Command line
  options to MEX may also affect what arguments are passed to these tools,
  or may control other aspects of MEX's behavior.

Command Line Options:
  Options available on all platforms:

  -ada <sfcn.ads>
      Use this option to compile a Simulink S-function written in Ada, where
      <sfcn.ads> is the Package Specification for the S-function. When this
      option is specified, only the -v (verbose) and -g (debug) options are
      relevant. All other options are ignored. See
      $MATLAB/simulink/ada/examples/README for examples and info on
      supported compilers and other requirements.
  -argcheck
      Add argument checking. This adds code so that arguments passed
      incorrectly to MATLAB API functions will cause assertion failures.
      Adds -DARGCHECK to the C compiler flags, and adds
      $MATLAB/extern/src/mwdebug.c to the list of source files. (C functions
      only).
  -c
      Compile only. Creates an object file but not a MEX-file.
  -D<name>
      Define a symbol name to the C preprocessor. Equivalent to a
      "#define <name>" directive in the source.
  -D<name>#<value>
      Define a symbol name and value to the C preprocessor. Equivalent to a
      "#define <name> <value>" directive in the source.
  -f <optionsfile>
      Specify location and name of options file to use. Overrides MEX's
      default options file search mechanism.
  -g
      Create a debuggable MEX-file. If this option is specified, MEX appends
      the value of options file variables ending in DEBUGFLAGS with their
      corresponding base variable. (For example, the value of LINKDEBUGFLAGS
      would be appended to the LINKFLAGS variable before calling the
      linker.) This option also disables MEX's default behavior of
      optimizing built object code.
  -h[elp]
      Print this message.
  -I<pathname>
      Add <pathname> to the list of directories to search for #include
      files.
  -inline
      Inline matrix accessor functions (mx*). The MEX-function generated
      may not be compatible with future versions of MATLAB.
  -n
      No execute mode. Print out any commands that MEX would otherwise have
      executed, but do not actually execute any of them.
  -O
      Optimize the object code by including the optimization flags listed in
      the options file. If this option is specified, MEX appends the value
      of options file variables ending in OPTIMFLAGS with their
      corresponding base variable. (For example, the value of LINKOPTIMFLAGS
      would be appended to the LINKFLAGS variable before calling the
      linker.) Note that optimizations are enabled by default, are disabled
      by the -g option, but are reenabled by -O.
  -outdir <dirname>
      Place all output files in directory <dirname>.
  -output <resultname>
      Create MEX-file named <resultname> (an appropriate MEX-file extension
      is automatically appended). Overrides MEX's default MEX-file naming
      mechanism.
  -setup
      Interactively specify the compiler options file to use as default for
      future invocations of MEX by placing it in "<UserProfile>\Application
      Data\MathWorks\MATLAB\R12" (for Windows) or $HOME/.matlab/R12 (for
      UNIX). When this option is specified, no other command line input is
      accepted.
  -U<name>
      Remove any initial definition of the C preprocessor symbol <name>.
      (Inverse of the -D option.)
  -v
      Print the values for important internal variables after the options
      file is processed and all command line arguments are considered.
      Prints each compile step and final link step fully evaluated to see
      which options and files were used. Very useful for debugging.
  -V4
      Compile a MATLAB 4-style MEX-file. This option is intended as an aid
      to migration, and is not recommended as a permanent solution.
  <name>#<value>
      Override an options file variable for variable <name>. See the
      platform-dependent discussion of options files below for more details.
      This option is processed after the options file is processed and all
      command line arguments are considered.

Additional options available on Windows platforms:

  @<rspfile>
      Include contents of the text file <rspfile> as command line arguments
      to MEX.

Additional options available on Unix platforms:

  -<arch>
      Assume local host has architecture <arch>. Possible values for <arch>
      include sol2, hpux, hp700, alpha, ibm_rs, sgi, and glnx86.
  -D<name>=<value>
      Define a symbol name and value to the C preprocessor. Equivalent to a
      "#define <name> <value>" directive in the source.
  -fortran
      Specify that the gateway routine is in Fortran. This will override
      what the script normally assumes, which is that the first source file
      in the list is the gateway routine.
  -l<name>
      Link with object library "lib<name>" (for "ld(1)").
  -L<directory>
      Add <directory> to the list of directories containing object-library
      routines (for linking using "ld(1)").
  <name>=<value>
      Override an options file variable for variable <name>. See the
      platform-dependent discussion of options files below for more details.

Options File Details:
  On Windows:
    The options file is written as a DOS batch file. If the -f option is not
    used to specify the options file name and location, then MEX searches
    for an options file named mexopts.bat in the following directories: the
    current directory, then the directory "<UserProfile>\Application
    Data\MathWorks\MATLAB\R12". Any variable specified in the options file
    can be overridden at the command line by use of the <name>#<value>
    command line argument. If <value> has spaces in it, then it should be
    wrapped in double quotes (e.g., COMPFLAGS#"opt1 opt2"). The definition
    can rely on other variables defined in the options file; in this case
    the variable referenced should have a prepended "$" (e.g.,
    COMPFLAGS#"$COMPFLAGS opt2").

    Note: The options files in $MATLAB\bin\mexopts named *engmatopts.bat are
    special case options files that can be used with MEX (via the -f option)
    to generate stand-alone MATLAB Engine and MATLAB MAT-API executables.
    Such executables are given a ".exe" extension.

  On UNIX:
    The options file is written as a UNIX shell script. If the -f option is
    not used to specify the options file name and location, then MEX
    searches for an options file named mexopts.sh in the following
    directories: the current directory (.), then $HOME/.matlab/R12, then
    $MATLAB/bin. Any variable specified in the options file can be
    overridden at the command line by use of the <name>=<def> command line
    argument. If <def> has spaces in it, then it should be wrapped in single
    quotes (e.g., CFLAGS='opt1 opt2'). The definition can rely on other
    variables defined in the options file; in this case the variable
    referenced should have a prepended "$" (e.g., CFLAGS='$CFLAGS opt2').

    Note: The options files in $MATLAB/bin named engopts.sh and matopts.sh
    are special case options files that can be used with MEX (via the -f
    option) to generate stand-alone MATLAB Engine and MATLAB MAT-API
    executables. Such executables are not given any default extension.

Examples:
    The following command will compile "myprog.c" into "myprog.mexsol" (when
    run under Solaris):

      mex myprog.c

    When debugging, it is often useful to use "verbose" mode as well
    as include symbolic debugging information:

      mex -v -g myprog.c
EOF
            ;;
        usage)
    cat<<'EOF'

    Usage:
      MEX [option1 ... optionN] sourcefile1 [... sourcefileN]
          [objectfile1 ... objectfileN] [libraryfile1 ... libraryfileN]

    or (to build an Ada S-function):
      MEX [-v] [-g] -ada <sfcn>.ads

    Use the -help option for more information, or consult the MATLAB API Guide.

EOF
            ;;
        file_not_found)
    echo ''
    echo "    mex:  $file not a normal file or does not exist."
    echo ''
            ;;
        compile_stage)
    echo "-> $compile_command"
    echo ''
            ;;
        ibm_preprocess)
            if [ "$TEMP" != "" -a "$compile_only" != "1" ]; then
    echo "-> cp -f $file $basename.F"
    echo "-> $CC -P $include_dirs $flags $basename.F"
    echo "-> rm -f $basename.F"
            else
    echo "-> $CC -P $include_dirs $flags $file"
            fi
    echo "-> mv -f $basename.i $basename.f"
    echo ''
            ;;
        failed_compile)
    echo ''
    echo "    mex: compile of '$file' failed."
    echo ''
            ;;
        link_stage)
    echo "-> $LD $LDFLAGS -o $mex_file $libetc"
    echo ''
            ;;
        failed_link)
    echo ''
    echo "    mex: link of '$mex_file' failed."
    echo ''
            ;;
        invalid_ada_flag)
    echo ''
    echo '    Error: An invalid Ada S-function file name was specified:'
    echo "           $2 is not a normal file or does not exist."
    echo ''
            ;;
	ada_needs_gnu_make)
    echo ''
    echo '    Error: Need GNU make properly installed and available on path '
    echo "           to build Ada S-function '$ada_sfcn'"
    echo ''
            ;;
        ada_build_failure)
    echo ''
    echo "    mex: Failed to build Ada S-Function '$ada_sfcn'"
    echo ''
            ;;
        fortran_cannot_change_entrypt)
    echo ''
    echo '    Warning: -entrypt ignored (FORTRAN entry point cannot be overridden).'
    echo ''
            ;;
        *)
    echo ''
    echo " Internal error 4: unimplemented message $1"
    echo ''
            ;;
    esac
  }
# end describe ()
#
#****************************************************************************
#
  smart_quote () {
#
# Return a quoted version of the input string if it has spaces in it.
#
    if [ $# -gt 1 ]; then
        echo \"$*\"
    else
        echo $1
    fi   
  }
# end smart_quote ()
#
#****************************************************************************
#
  get_root_dir () {
#
#   Determine the path of the MATLAB root directory - always one directory
#   up from the path to this command.
#
    filename=$1
#
# Now it is either a file or a link to a file.
#
    cpath=`pwd`
#
# Follow up to 8 links before giving up. Same as BSD 4.3
#
    n=1
    maxlinks=8
    while [ $n -le $maxlinks ]
    do
#
# Get directory correctly!
#
        newdir=`echo "$filename" | awk '
                        { tail = $0
                          np = index (tail, "/")
                          while ( np != 0 ) {
                             tail = substr (tail, np + 1, length (tail) - np)
                             if (tail == "" ) break
                             np = index (tail, "/")
                          }
                          head = substr ($0, 1, length ($0) - length (tail))
                          if ( tail == "." || tail == "..")
                             print $0
                          else
                             print head
                        }'`
        if [ ! "$newdir" ]; then
            newdir="."
        fi
        (cd $newdir) > /dev/null 2>&1
        if [ $? -ne 0 ]; then
            describe internal_error_1 >&2
            cleanup
            exit 1
        fi
        cd $newdir
#
# Need the function pwd - not the built in one
#
        newdir=`/bin/pwd`
#
        newbase=`expr //$filename : '.*/\(.*\)' \| $filename`
        lscmd=`ls -l $newbase 2>/dev/null`
        if [ ! "$lscmd" ]; then
            describe internal_error_2 >&2
            cleanup
            exit 1
        fi
#
# Check for link portably
#
        if [ `expr "$lscmd" : '.*->.*'` -ne 0 ]; then
            filename=`echo "$lscmd" | awk '{ print $NF }'`
        else
#
# It's a file
#
            dir="$newdir"
            command="$newbase"
#
            cd $dir/..
            MATLAB=`/bin/pwd`; export MATLAB
            break
        fi
        n=`expr $n + 1`
    done
    if [ $n -gt $maxlinks ]; then
        describe internal_error_3 >&2
        cleanup
        exit 1
    fi
#       
    cd $cpath
  }
#   end get_root_dir ()
#
#****************************************************************************
#
  get_entrypt () {
#
#   Set up the entry point based on the input argument
#
    if [ "$1" = "FORTRAN" ]; then
#
#   The gateway routine is in Fortran; use Fortran entry point
#
        MAPFILE='fexport.map'
        if [ "$Arch" = "hp700" ]; then
            ENTRYPOINT='mexfunction'
        elif [ "$Arch" = "hpux" ]; then
            ENTRYPOINT='mexfunction'
        elif [ "$Arch" != "ibm_rs" ]; then
            ENTRYPOINT='mexfunction_'
        else
            ENTRYPOINT='mexFunction'
        fi
    else
#
#   C, C++ and Ada entry points are the same
#
        MAPFILE=$entrypt'.map'
        ENTRYPOINT=$entrypt
    fi
  }
# end get_entrypt ()
#
#****************************************************************************
#
  determine_options_file () {
# Source options file (default is $OPTSFILE_NAME) and get values for the
# following local variables
# 
#       MATLAB                  (MATLAB root directory)
#       CC                      (C compiler)
#       CFLAGS                  (C compiler options)
#       COPTIMFLAGS             (Compiler optimization flags)
#       CDEBUGFLAGS             (Compiler debugging flags)
#       CLIBS                   (C libraries for linking)
#       FC                      (Fortran 77 compiler)
#       FFLAGS                  (Fortran 77 options)
#       FOPTIMFLAGS             (Compiler optimization flags)
#       FDEBUGFLAGS             (Compiler debugging flags)
#       FLIBS                   (Fortran libraries for linking)
#       LD                      (Linker command)
#       LDFLAGS                 (Linker options)
#       LDOPTIMFLAGS            (Compiler optimization flags)
#       LDDEBUGFLAGS            (Compiler debugging flags)
#       LDEXTENSION             (Extension to add to output filename)
#
# The search order for the options file is:
#
#  -f optionsfile                    (file specified with -f command line option)
#  ./$OPTSFILE_NAME                  ($OPTSFILE_NAME in current directory)
#  $HOME/.matlab/R12/$OPTSFILE_NAME  ($OPTSFILE_NAME in user's matlab preferences directory)
#  $MATLAB/bin/$OPTSFILE_NAME        ($OPTSFILE_NAME file in MATLAB bin directory)
#
#
    if [ -f ./$OPTSFILE_NAME ]; then
        SOURCE_DIR='.'
        SOURCE_DIReval=`pwd`
        OPTIONS_FILE="./$OPTSFILE_NAME"
    elif [ -f $HOME/.matlab/R12/$OPTSFILE_NAME ]; then
        SOURCE_DIR='$HOME/.matlab/R12'
        SOURCE_DIReval=$HOME/.matlab/R12
        OPTIONS_FILE="$HOME/.matlab/R12/$OPTSFILE_NAME"
    elif [ -f $MATLAB/bin/$OPTSFILE_NAME ]; then
#
# NOTE: At this point we will use the MATLAB determined earlier to
#       source the file. After that the value in that file if not
#       null will be used.
#
        SOURCE_DIR='$MATLAB/bin'
        SOURCE_DIReval=$MATLAB/bin
        OPTIONS_FILE="$MATLAB/bin/$OPTSFILE_NAME"
    else
        describe no_options_file >&2
        cleanup
        exit 1
    fi
  }
# end determine_options_file ()
#
#****************************************************************************
#
  get_arch () {
    if [ "$ARCH" = "" ]; then # No command line override given
	if [ ! -f $MATLAB/bin/util/arch.sh ]; then
	    describe no_util_scripts >&2
	    cleanup
	    exit 1
	fi
	. $MATLAB/bin/util/arch.sh
	if [ "$Arch" = "unknown" ]; then
	    describe unknown_architecture >&2
            cleanup
	    exit 1
	fi
    else # Use command line override
	Arch=$ARCH
    fi
    if [ ! -f $MATLAB/bin/util/oscheck.sh ]; then
        describe no_util_scripts >&2
        cleanup
        exit 1
    fi
    if [ "$verbose" = "1" ]; then
        temp_file=/tmp/$$b
        files_to_remove="$files_to_remove $temp_file"
        . $MATLAB/bin/util/oscheck.sh
        if [ "$oscheck_status" = "1" ]; then
            cleanup
            exit 1
        fi
    fi
  }
# end get_arch ()
#
#****************************************************************************
#
  eval_assignments () {
#
# Source the file of argument variables, name=[def]
#
    if [ -f /tmp/$$a ]; then
        . /tmp/$$a
    fi

#
# Make sure that LD is fully evaluated to handle LD=$COMPILER assignment
#
    LD="`eval echo $LD`"
  }
# end eval_assignments ()
#
#****************************************************************************
#
  build_ada_s_function () {
#
#
    ada_build_args="MATLAB_ROOT=$MATLAB ARCH=$ARCH MEX_EXT=$mex_ext "
    ada_build_args="$ada_build_args ADA_SFCN=$ada_sfcn "
#
#   Determine GNAT Compiler Version
#
    gnatVer=`gnatmake -v 2>&1 | grep GNATMAKE | awk '{print $2}'`
    ada_build_args="$ada_build_args GNAT_VER=$gnatVer "
#
    if [ "$debug" = "1" ]; then
	ada_build_args="$ada_build_args DEBUG=1 "
    fi
#
    if [ "$verbose" = "1" ]; then
	ada_build_args="$ada_build_args VERBOSE=1 "
    fi
#
    if [ "$OUTDIR" != "" ]; then
	ada_build_args="$ada_build_args OUTPUT_DIR=$OUTDIR "
    fi
#
    makefile="$MATLAB/simulink/ada/interface/gnat_unix.mk"
#
#   Verify that make exists and is gnu make
#
    makeVer='make --version | paste -s -d" " -'
    makeOk='expr "$makeVer" : "^GNU Make version .*"'
    if [ "$makeOk" = "0" ]; then
	describe ada_needs_gnu_make >&2
        cleanup
	exit 1
    fi
    echo " "
    echo "### Starting build for Ada S-function $ada_sfcn"
    ada_build_cmd="make -f $makefile $ada_build_args"
    if [ "$verbose" = "1" ]; then
	echo " "
	echo "    $ada_build_cmd"
	echo " "
    fi
    eval "$ada_build_cmd"
    if [ $? -ne 0 ]; then
        describe ada_build_failure >&2
        cleanup
        exit 1
    else
	echo "### Mex build successful"
	echo " "
    fi
  }
# end build_ada_s_function ()
#
#****************************************************************************
#
  error_check () {
#
#   Check for errors in calling syntax
#
    if [ "$argcheck" = "1" -a "$cfiles" != "1" ]; then
        stat="Argument checking not possible without C source files."
    fi
    if [ "$argcheck" = "1" -a "$v4_compat" = "1" ]; then
        stat="Argument checking not available for V4 MEX-files."
    fi
    if [ "$inlined" = "1" -a "$cfiles" != "1" ]; then
        stat="Inlining not possible without C source files."
    fi
    if [ "$inlined" = "1" -a "$v4_compat" = "1" ]; then
        stat="Inlining not available for V4 MEX-files."
    fi
    if [ "$argcheck" = "1" -a "$inlined" = "1" ]; then
        stat="Argument checking and inlining are mutually exclusive."
    fi
    if [ "$files" != "" -a "$cfiles" != "1" -a "$ffiles" != "1" ]; then
        cfiles=1
	if [ "$verbose" != "" ]; then
	    describe assuming_c_source
	    if [ "$v4_compat" != "1" ]; then
		describe assuming_matlab_5
	    fi
	fi
    fi
    if [ "$stat" = "no file name given." -a "$verbose" = "1" ]; then
        # Exit quietly
        cleanup
        exit 0
    fi
    if [ "$stat" != "OK" ]; then                  # An error occurred.
        if [ "$stat" != "" ]; then
            describe status >&2
        fi
        describe usage >&2
        cleanup
        exit 1
    fi
  }
# end error_check ()
#
#****************************************************************************
#
  get_ext () {
#
#   Determine extension for MEX-file
#
        case "$Arch" in
            alpha)
                mex_ext='mexaxp'
                ;;
            hpux)
                mex_ext='mexhpux'
                ;;
            hp700)
                mex_ext='mexhp7'
                ;;
            ibm_rs)
                mex_ext='mexrs6'
                ;;
            glnx86)
                mex_ext='mexglx'
                ;;
            sgi)
                mex_ext='mexsg'
                ;;
            sol2)
                mex_ext='mexsol'
                ;;
        esac
  }
# end get_ext ()
#
#****************************************************************************
#
  get_name () {
#
#   If there is already a mex name, -output was used: supply an appropriate
#   MEX-file extension if necessary. (Warn if -c was also used.)
#   Otherwise, use the first file name to determine the MEX-file name.
#   If there are no files, don't complain (error_check comes later).
#
    if [ "$mex_file" != "" ]; then
	if [ "$compile_only" = "1" ]; then
	    describe meaningless_output_flag
	fi
        ext=`expr "$mex_file" : ".*$LDEXTENSION$"`
        if [ "$ext" = "0" ]; then
            mex_file=$mex_file$LDEXTENSION
        fi
    elif [ "$1" != "" ]; then
        ext=`expr "$1" : '\.*[^.].*\.\([^.]*\)$'`
        mex_file=`expr "//$1" : ".*/\(.*\)\.${ext}$" \| "//$1" : ".*/\(.*\)"`
	mex_file=$mex_file$LDEXTENSION
    fi
    if [ "$OUTDIR" != "" ]; then
	mex_file="$OUTDIR/$mex_file"
    fi
    mex_file=`smart_quote $mex_file`
  }
# end get_name ()
#
#****************************************************************************
#
  get_includes () {
#
#   Determine which include directories to specify
#
    include_dirs="$include_dirs -I`smart_quote $MATLAB/$MEX_INCLUDE_DIR`"
    if [ -d $MATLAB/simulink ]; then
        include_dirs="$include_dirs -I`smart_quote $MATLAB/simulink/include`"
    fi
    if [ -d $MATLAB/codegen ]; then
        include_dirs="$include_dirs -I`smart_quote $MATLAB/codegen/external/common`"
    fi
  }
# end get_includes ()
#
#****************************************************************************
#
  compile () {
    trap "eval $abort; exit 1" 1 2 3 15
#
#   For each file, compile source files and add other files
#   to the list of link options.
#
    file="$1"
    if [ ! -f "$file" ]; then
        describe file_not_found >&2
        cleanup
        exit 1
    fi
#
# determine extension and basename
#
    ext=`expr "$file" : '\.*[^.].*\.\([^.]*\)$'`
    if [ "$ext" = "" ]; then
        ext=`expr "$file" : '\.*[^.].*\.\(so\)[.0-9]*$'`
    fi
    basename=`expr "//$file" : ".*/\(.*\)\.${ext}$" \| //$file : ".*/\(.*\)"`
#
    if [ "$TEMP" != "" -a "$compile_only" != "1" ]; then
        basename=$TEMP/$basename$$
    elif [ "$OUTDIR" != "" ]; then
        basename=$OUTDIR/$basename
    fi

    basename=`smart_quote $basename`
#
# Source file extensions: .c .C .cc .cxx .cpp .f .for .F
#
    case "$ext" in
        c | C | cc | cpp | cxx) # C/C++ source file.
#
# determine whether to optimize or debug
#
            if [ "$debug" != "1" ]; then
                flags="$COPTIMFLAGS"
            elif [ "$optimize" = "1" ]; then
                flags="$CDEBUGFLAGS $COPTIMFLAGS"
            else
                flags="$CDEBUGFLAGS"
            fi
#
# Determine final compile command for C source code.
#
            flags="-DMATLAB_MEX_FILE $CFLAGS $cc_flags $flags"
            compile_command="$CC -c $include_dirs $flags $file"
            ;;
        f | for | F)                   # Fortran source file.
#
# determine whether to optimize or debug
#
            if [ "$debug" != "1" ]; then
                flags="$FOPTIMFLAGS"
            elif [ "$optimize" = "1" ]; then
                flags="$FDEBUGFLAGS $FOPTIMFLAGS"
            else
                flags="$FDEBUGFLAGS"
            fi
#
# Determine final compile command for Fortran source code.
#
            flags="$FFLAGS $fc_flags $flags"
            if [ "$Arch" = "ibm_rs" -a "$ext" = "F" ]; then
                if [ "$verbose" = "1" ]; then
                    describe ibm_preprocess
                fi
                if [ "$no_execute" != "true" ]; then
                    if [ "$TEMP" != "" -a "$compile_only" != "1" ]; then
                        CD=`pwd`
                        eval "cp -f $file $basename.F"
                        eval "cd $TEMP"
                        eval "$CC -P $include_dirs $flags $basename.F"
                        eval "cd $CD"
                        files_to_remove="$files_to_remove $basename.f $basename.F"
                    else
                        eval "$CC -P $include_dirs $flags $file"
                    fi
                    eval "mv -f $basename.i $basename.f"
                fi
                file=$basename.f
            fi
            compile_command="$FC -c $include_dirs $flags $file"
#
# Using f2c/gcc for Fortran MEX requires appending gcc backend to the
# command line
# bmb 7/25/96
#
            if [ "$Arch" = "glnx86" -a "$FC" = "f2c" ]; then
                cc_file=`expr "//$file" : ".*/\(.*\)\.${ext}$" \| //$file : ".*/\(.*\)"`.c;
                compile_command="$compile_command; $CC -c $include_dirs $flags $cc_file"
	        files_to_remove="$files_to_remove $basename.c"
            fi
            ;;
        *)
#
# Object files: Don't need to do anything except add to compiled list
#
            objs="$objs $file"
            return 0
            ;;
    esac
#
    if [ "$TEMP" != "" -a "$compile_only" != "1" ]; then
        compile_command="$compile_command -o $basename.o"
    elif [ "$OUTDIR" != "" ]; then
        compile_command="$compile_command -o $basename.o"
    fi
#
    if [ "$verbose" = "1" -o "$no_execute" = "true" ]; then
        describe compile_stage
    fi
#
    if [ "$no_execute" != "true" ]; then eval "$compile_command"; fi
    if [ $? -ne 0 ]; then
        describe failed_compile >&2
	cleanup
        exit 1
    fi
    if [ "$compile_only" != "1" ]; then
        if [ "$Arch" = "sol2" -a "$debug" = "1" -a \
	     "$basename" != "$TEMP/mexversion$$" ]; then
            # We need to keep the object files around
            :
        else
            files_to_remove="$files_to_remove $basename.o"
        fi
    fi
    objs="$objs $basename.o"
  }
# end compile ()
#
#****************************************************************************
#
  link () {
    trap "eval $abort; exit 1" 1 2 3 15
#
#   Link stage
#
    if [ "$cfiles" = "1" ]; then
        libs="$libs $CLIBS"
    fi
    if [ "$ffiles" = "1" ]; then
        libs="$libs $FLIBS"
    fi
    libetc="$objs $libs"
#
# determine whether to optimize or debug
#
    if [ "$debug" != "1" ]; then
        LDFLAGS="$LDOPTIMFLAGS $LDFLAGS"
    elif [ "$optimize" = "1" ]; then
        LDFLAGS="$LDDEBUGFLAGS $LDOPTIMFLAGS $LDFLAGS"
    else
        LDFLAGS="$LDDEBUGFLAGS $LDFLAGS"
    fi
    case "$Arch" in
        alpha | sgi)
            if [ "$TEMP" != "" -a `expr "$LDFLAGS" : '.*-shared.*'` -ne 0 ]; then
                SO_LOCATIONS=$TEMP/so_locations$$
                LDFLAGS="$LDFLAGS -update_registry $SO_LOCATIONS"
            fi
            ;;
        ibm_rs)
            if [ "$ffiles" = "1" ]; then
                LD=$FC
            fi
            ;;
    esac
    if [ "$verbose" = "1" -o "$no_execute" = "true" ]; then
        describe link_stage
    fi
    if [ "$no_execute" != "true" ]; then eval "$LD $LDFLAGS $ld_flags -o $mex_file $libetc"; fi
    if [ $? -ne 0 ]; then
        describe failed_link >&2
        cleanup
        exit 1
    fi
  }
# end link ()
#
#****************************************************************************
#
# Main routine
#
#
#  Initialize some variables
#
    OPTSFILE_NAME='mexopts.sh'
#
    MEX_INCLUDE_DIR='extern/include'
#
    SO_LOCATIONS=so_locations
#
    stat="OK"
#
   ARCH=
    Arch='Undetermined'
    verbose=0
#
#  Use a C entry point by default
#
    gateway_lang=C
    entrypt=mexFunction
#
    arg_count=$#
    while [ "$stat" = "OK" -a  $# -gt 0 ]; do
#
# Parse input arguments.  The routine may need the next two arguments,
# as in -f optionsfile and -o mexfilename.
#
        case "$1" in
            -argcheck)
                argcheck=1
                cc_flags="$cc_flags -DARGCHECK"
                ;;
            -c)
                compile_only=1
                ;;
            -D*)                         # Compiler flags.
                lhs=`expr "$1" : '\(-D[a-zA-Z0-9_]*\).*'`
                mid=`expr "$1" : '-D[a-zA-Z0-9_]*\([=\#]\).*$'`
                rhs=`expr "$1" : '-D[a-zA-Z0-9_]*[=\#]\(.*\)$'`
                
                if [ "$mid" != "" ]; then
                    mid="="
                fi

                cc_flags="$cc_flags $lhs$mid$rhs"
                fc_flags="$fc_flags $lhs$mid$rhs"

                if [ "$lhs" = "-DV4_COMPAT" ]; then
                    stat="Please use -V4 rather than directly passing"
                    stat="$stat -DV4_COMPAT."
                fi
                if [ "$lhs" = "-DARRAY_ACCESS_INLINING" ]; then
                    stat="Please use -inline rather than directly passing"
                    stat="$stat -DARRAY_ACCESS_INLINING."
                fi
                ;;
            -U*)                         # Compiler flags.
                cc_flags="$cc_flags $1"
                fc_flags="$fc_flags $1"
                ;;
            -I*)                            # Include directories
                include_dirs="$include_dirs $1"
                ;;
            -f)
                if [ -f "$2" ]; then
                    OPTIONS_FILE="$2"
                    SOURCE_DIR='none'
                else
                    describe invalid_options_file >& 2
                    cleanup
                    exit 1
                fi
                shift
                ;;
            -fortran)
                ffiles=1
                gateway_lang=FORTRAN
                ;;
            -[g]*)                          # Use debugging flags.
                debug=1
                ;;
            -h | -help)                     # -help: Help option.
                describe "help"
                cleanup
                exit 0
                ;;
            -inline)
                cc_flags="$cc_flags -DARRAY_ACCESS_INLINING"
                inlined=1
                ;;
            -[Ll]*)
                libs="$libs $1"
                ;;
            -n)                             # output name
                no_execute="true"
                ;;
            -no_mwsglm)                     # ignored for compatibility with mbuild
                ;;
            -no_mmfile)                     # ignored for compatibility with mbuild
                ;;
            -o | -output)                   # mexfile name
                mex_file=$2
                shift
                ;;
            -outdir)                        # output directory
                OUTDIR=$2
                shift
                ;;
            -O)                             # Use optimization flags.
                optimize=1
                ;;
            -setup)
		if [ $arg_count -ne 2 -a $arg_count -ne 1 ]; then
		    describe usage >&2
                    cleanup
		    exit 1
		else
		    SETUP_OPTIONS_FILE=$2
		    if [ ! "$MATLAB" ]; then       # If no MATLAB='' was used
			get_root_dir $arg0_
		    fi
		    TMW_ROOT=$MATLAB
		    #
		    # source the setup_options_file finction declaration  
		    #
		    . $MATLAB/bin/optsetup.sh
		    #
		    setup_options_file $SETUP_OPTIONS_FILE
                    cleanup
		    exit 0
		fi
                ;;
            -silent)            # really not verbose - undocumented
                verbose=
                ;;
            -v)
                verbose=1
                ;;
            -v3.5)
                stat="The -v3.5 option is no longer supported."
                ;;
            -V4)
                cc_flags="$cc_flags -DV4_COMPAT"
                v4_compat=1
                ;;
	    -ada)
		gateway_lang=ADA
                if [ -f "$2" ]; then
		    ada_sfcn=$2
                else
                    describe invalid_ada_flag >& 2
                    cleanup
                    exit 1
                fi
                shift
                ;;
            -entrypt)
                if [ "$2" != "mexFunction" -a "$2" != "mexLibrary" ]; then
                     stat="-entrypt argument must be either 'mexFunction' or 'mexLibrary'"
                fi
                entrypt=$2
                shift
                ;;
            -*)
                check_archlist argument=$1 noprint
                if [ "$ARCH" = "" ]; then
                    stat="$1 not a valid option."
                fi
                ;;
            ARCH[=\#]*)
                rhs=`expr "$1" : '[a-zA-Z0-9_]*[=\#]\(.*\)$'`
                ARCH="`eval echo $rhs`"
                ;;
            MATLAB[=\#]*)
                mlrhs=`expr "$1" : '[a-zA-Z0-9_]*[=\#]\(.*\)$'`
                MATLAB="`eval echo $mlrhs`"
                ;;
            *[=\#]*)
                lhs=`expr "$1" : '\([a-zA-Z0-9_]*\)[=\#].*'`
                rhs=`expr "$1" : '[a-zA-Z0-9_]*[=\#]\(.*\)$'`
                echo $lhs='"'$rhs'"' >> /tmp/$$a
                files_to_remove="$files_to_remove /tmp/$$a"
                ;;
            *.c | *.C | *.cc | *.cpp | *.cxx) # C/C++ source file.
                cfiles='1'
                files="$files $1"
                ;;
            *.f | *.for | *.F)                # FORTRAN source file.
                if [ "$ffiles" != "1" -a "$cfiles" != "1" ]; then
                    gateway_lang=FORTRAN
                fi
                ffiles='1'
                files="$files $1"
                ;;
            *.o)                              # object files
                files="$files $1"
                ;;
            *)                                # other files
                libs="$libs $1"
                ;;
        esac
    shift
    done
    if [ $# -eq 0 -a "$files" = "" -a "$stat" = "OK" ]; then
        stat="no file name given."
    fi
    if [ "$gateway_lang" = "FORTRAN" -a "$entrypt" != "mexFunction" ]; then
        describe fortran_cannot_change_entrypt
        entrypt=mexFunction
    fi
#
# It is now safe to use functions, since we have parsed all of the
# input arguments.  (The use of functions corrupts $# and $* on
# HP-UX 9.0x systems.)
#
    if [ ! "$MATLAB" ]; then            # If no MATLAB='' was used
        get_root_dir $arg0_
    fi
#
    if [ ! "$OPTIONS_FILE" ]; then      # If no -f optionsfile was used
        determine_options_file
    fi
#
    . $OPTIONS_FILE                     # Source file to determine $MATLAB
    get_arch                            # Call $MATLAB/bin/util/arch.sh
#
    get_ext                             # Determine MEX-file extension
    get_entrypt $gateway_lang           # Determine MEX-file entry pt
#
    if [ "$ffiles" = "1" ]; then
        COMPILER='$FC'
    else
        COMPILER='$CC'
    fi
#
    LDEXTENSION=.$mex_ext                 # Default string to append to output
#
    . $OPTIONS_FILE                     # Source options file
#
    eval_assignments                    # Evaluate VAR=value arguments

    get_name $files                     # Determine MEX-file name

#
#   Ada
#
    if [ "$gateway_lang" = "ADA" ]; then
	build_ada_s_function
        cleanup
	exit 0
    fi
#
    if [ "$verbose" = "1" ]; then
        describe final_options
    fi
#
    error_check                         # Check calling syntax errors
#
    get_includes                        # Determine include directories
#
    if [ "$compile_only" != "1" ]; then
	if [ "$gateway_lang" = "C" ]; then
	    files="$files $MATLAB/extern/src/mexversion.c"
	else
	    files="$files $MATLAB/extern/lib/$Arch/version4.o"
	fi
    fi
    if [ "$argcheck" = "1" ]; then
        files="$files $MATLAB/extern/src/mwdebug.c"
    fi
#
# From this point on, we need to put traps in each function.  The IBM
# resets traps on entry to each function, so we need to safeguard
# any functions we call after compiling.  This includes compile(),
# link(), and cleanup().
#
    set $files
    for file in $*
    do
        compile $file                   # Process each file in list
    done
#
    if [ "$compile_only" != "1" ]; then
        link                            # Perform linking
    fi
#
    cleanup
    exit 0
#
#****************************************************************************