#!/bin/sh
#
#     mex    compilation program for MATLAB C and Fortran language MEX-files
#
# Copyright 1984-2011 The MathWorks, Inc.
#____________________________________________________________________________
    arg0_=$0
#
    abort='rm -rf $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-2013 The MathWorks, Inc.
#----------------------------------------------------------------------------
#
    ARCH_LIST='glnxa64 maci64'
#=======================================================================
# 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) ==============================
#
#========================== version.sh (start) ============================
#
# usage:        version [-b | -f | -p]
#
# abstract:     This POSIX Shell script function returns the MATLAB
#               release version. Any bad options are ignored without
#		warning.
#
#		The version is assumed to be of the form:
#
#		    R<integer>[<noninteger>]
#
#               options:
#
#		b       - return just R<integer> or the base version.
#               f       - return full version, e.g. R14SP5
#               p       - return previous full version, e.g. R14SP4
#
# note(s):      1. This file is always imbedded in another script
#
# Copyright 1992-2015 The MathWorks, Inc.
#----------------------------------------------------------------------------
#
version () {
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    full_ver='R2017b'
    prev_ver='R2017a'
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    if [ $# -eq 1 ]; then
        if [ "$1" = '-b' ]; then
            expr "$full_ver" : '\(R[0-9]*\).*$'
	    return $?
        fi
        if [ "$1" = '-f' ]; then
            echo "$full_ver"
	    return 0
        fi
        if [ "$1" = '-p' ]; then
            echo "$prev_ver"
	    return 0
        fi
    fi
    echo "$full_ver"
    return 0
}
#========================== version.sh (end) ==============================
#========================== quotearg.sh (start) ============================
# Copyright 2008 The MathWorks, Inc.
    quote_arg () { # Assumes a single argument and outputs the argument
                   # correctly quoted to be evaluated again. <arg1> on
                   # input must be properly quoted so that it appears
                   # to this function as a single argument.
                   # The algorithm is to start out with a double quote
                   # and switch to single quote at the next double quote.
                   # Switch to a double quote at the next single quote and
                   # and so forth. While in a substring between double
                   # quotes be sure to escape '\' , '$', and '`'. While
                   # in a substring between single quotes no characters
                   # need to be escaped.
                   #
                   # IMPORTANT: 1. printf is portable. echo is not.
                   #               Solaris does not handle backslash
                   #               properly inside of single quotes.
                   #            2. Old awk coding used to make it work
                   #               on Solaris.
                   #
                   # Always returns a 0
                   #
                   # usage: quote_arg  <arg1>
                   #
        printf '%s' "$1" | awk '
#----------------------------------------------------------------------------
        BEGIN { squote = sprintf ("%c", 39)   # set single quote
                dquote = sprintf ("%c", 34)   # set double quote
              }
NF != 0 { newarg=dquote                 # initialize output string to
                                        # double quote
          lookquote=dquote              # look for double quote
          oldarg = $0
          for (i = 1; i <= length(oldarg); i++) {
              c = substr(oldarg,i,1);
              if (c == lookquote) {
                  newarg = newarg c
                  if (lookquote == dquote)
                      lookquote = squote
                  else
                      lookquote = dquote
                  newarg = newarg lookquote
              }
              else if (lookquote == dquote) {
                  if (c == "\\")
                      newarg = newarg "\\\\"
                  else if (c == "$")
                      newarg = newarg "\\$"
                  else if (c == "`")
                      newarg = newarg "\\`"
                  else
                      newarg = newarg c
              }
              else
                  newarg = newarg c
          }
          printf " %s", newarg lookquote }'
#----------------------------------------------------------------------------
        return 0
    }

#========================== quotearg.sh (end) ==============================
#========================== getrootdir.sh (start) ============================
# Copyright 2008 The MathWorks, Inc.
  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 ()
#========================== getrootdir.sh (end) ==============================
#========================== validatecompiler.sh (start) ============================
# Copyright 2008-2012 The MathWorks, Inc.
# Routines to validate compilers.


# Validate if $CC contains a gcc-based compiler
  check_for_gcc()
  {
    echo $CC | awk '
    BEGIN {
        isGcc = "no"
    }
    /gcc/ {isGcc = "yes";exit 0 }
    /g\+\+/ {isGcc = "yes";exit 0 }
    END {
         print isGcc
      }
    '
  }

  validate_gcc()
  {
      if [ `check_for_gcc` "=" "yes" ];then
# We have a gcc compiler, so we need to check the version.
# The warning data table format is:
# allowable_versions[i]="ARCH,supported,acceptable_lower_bound,acceptable_upper_bound"
# Bounds are inclusive, and missing points are wildcards: "4.2" will allow 4.2.x

          $CC --version | head -n 1  | awk '
      BEGIN{
         allowable_versions[1]="glnxa64,4.7.x,4.4,4.7"
         toolName = "'"$TOOL_DISPLAY_NAME"'"
      }
      {
         # Figure out what version of gcc we are dealing with. 
         # Set version_number to the version of gcc.
   
         for (i = NF; i >= 1; i--)
         {
            if ($i ~ /^[0-9]+\./)
            {
               version_number=$i
               exit 0 # This sends you to the end block 
            }
         }
      }
      END{
   
         # Find the array member of allowable_versions that corresponds to the
         # architecture of the local machine.

         for(i in allowable_versions)
         {
            # This uses the shell interpreter to substitute for arch.

            if (allowable_versions[i] ~ /^'"$Arch"'/)
            {
               string_of_test_versions = allowable_versions[i]
               break
            }
         }
   
         # If there is no match, we are dealing with gcc on 
         # an architecture not in the table.  Assume it is ok and 
         # quit checking the version.

         if (string_of_test_versions == "")
         {
            exit 0;
         }
         split(string_of_test_versions, versions, ",")
         size_of_min_version = split(versions[3], min_version_array,  ".")
         number_of_digits = split(version_number, gcc_version_array, ".")
   
         # Check if the version is smaller than the minimum version.  If it is,
         # print a warning message and exit.

         need_to_warn = 0
         for (i = 1; i <= size_of_min_version; i++)
         {
            if ( i > number_of_digits)
            {
               curr_num = 0
            }
            else
            {
               curr_num = gcc_version_array[i]
            }
            if (curr_num < min_version_array[i])
            {
               need_to_warn = 1
               break
            }
            if (curr_num > min_version_array[i])
            {
               break
            }
         }
   
         # If the version is not smaller than the minimum version, check if
         # it is larger than the maximum version.

         size_of_max_version = split(versions[4], max_version_array, ".")
         for (i = 1; i <= size_of_max_version; i++)
         {
            if (i > number_of_digits)
            {
               curr_num = 0
            }
            else
            {
               curr_num = gcc_version_array[i]
            }
            if (curr_num > max_version_array[i])
            {
               need_to_warn = 1
               break
            }
            if (curr_num < max_version_array[i])
            {
               break
            }
         }

         if (need_to_warn == 1)
         {
               printf("\n");
               printf("Warning: You are using gcc version \"%s\".  The version\n", version_number);
               printf("         currently supported with %s is \"%s\".\n", toolName, versions[2]);
               printf("         For a list of currently supported compilers see: \n");
               printf("         http://www.mathworks.com/support/compilers/current_release/\n\n");
         }
         exit 0

      }'
      fi
}

#========================== validatecompiler.sh (end) ==============================
    REL_VERSION=`version -f`
#
#========================= optsetup.sh (start) ============================
#!/bin/sh
#
#  Name:
#     optsetup    sh function declaration of setup_options_file
#     
#  Usage: (not for interactive use. To be sourced and called as a function)
#
#     . optsetup
#     setup_options_file [<filename>]
#
#   Description:
#     When invoked without a parameter, setup_options_file generates a list
#     of options files from which to select one to be copied to the default
#     options file location and name.
#
#     When invoked with a parameter, setup_options_file copies the
#     specified file to the default options file location and name.
#
#     setup_options_file is context sensitive. When invoked from mex, it
#     uses 'mexopts.sh' as the default options file target. When invoked
#     from mbuild, it uses 'mbuildopts.sh' as the default options file
#     target. 
#
#  See Also:
#     MATLAB API Guide
#
# Copyright 1984-2011 The MathWorks, Inc.
#____________________________________________________________________________
#
#****************************************************************************
#

determine_preference_dir () { 
    REL_VERSION=`version -f`
    # set PREF_DIR to environment variable if it is set
    # <rel_version> is the base release version like R14.

    # if set but empty, use default
    PREF_DIR=${MATLAB_PREFDIR:-$HOME/.matlab/$REL_VERSION}
}

setup_describe () {

SCRIPT_NAME=`basename $arg0_`;

determine_preference_dir

cat << EOF

    Options files control which compiler to use, the compiler and link command
    options, and the runtime libraries to link against.

    Using the '$SCRIPT_NAME -setup' command selects an options file that is
    placed in $PREF_DIR and used by default for '$SCRIPT_NAME'. An options 
    file in the current working directory or specified on the command line 
    overrides the default options file in $PREF_DIR.
 
    To override the default options file, use the '$SCRIPT_NAME -f' command
    (see '$SCRIPT_NAME -help' for more information).
EOF
 
}

setup_options_file () {


    TAG="#SELECTION_TAG"
    DEFAULT_OPTIONS_FILE="mbuildopts.sh"

    #
    # Determine what script invoked this routine
    #
    SOURCE_SCRIPT=`basename $arg0_`

    #
    # if source script is MEX set the selection tag for MEX
    #
    if [ "$SOURCE_SCRIPT" = "mex" ] || [ "$SOURCE_SCRIPT" = "mexsh" ]; then 
      TAG="#SELECTION_TAG_MEX_OPT:"
      DEFAULT_OPTIONS_FILE="mexopts.sh"
    fi

    #
    # if source script is MBUILD set the selection tag for all non generic...
    #
    if [ "$SOURCE_SCRIPT" = "mbuild" ]; then 
      TAG="#SELECTION_TAG_ML_OPT:"
      DEFAULT_OPTIONS_FILE="mbuildopts.sh"
    fi

    #
    # This function is normally called by MEX/MBUILD with 0 arguments.
    # When given an input file that exists as first argument, process it
    # Second argument overrides destination
    #

    if [ "X$1" != "X" -a -f "$1" ]; then
        FOUND_FILE=$1
        OPTIONS_DEST_OVERRIDE=$2
    else

	setup_describe

	#
	# Inform the user of the available options files
	#
        echo
        echo The options files available for $SOURCE_SCRIPT are:
        echo

	#
	# For each *opt*.sh file in the options file path generate a prompt and
	# identifier for that file to be selected to copy to the default options
	# file. 
	#
	# Find *opts.sh files in the list of search directories
	#
	#  $TMW_ROOT/bin/<filename> 
	#
        file_list="`ls $TMW_ROOT/bin/*opts.sh 2> /dev/null`"

        opt_count=0
        file_array=""
        for file in $file_list ; do 
            file_comment=`egrep "^$TAG" $file | cut -f 2,3,4,5,6,7,8 -d:`
            if [ "$file_comment" != "" ]; then 
	        opt_count=`expr $opt_count + 1` ;
	        file_array="$file_array$file:"
	        echo "  $opt_count: $file : "
		echo "     $file_comment"
		echo ' '
            fi
        done
        echo
        echo "  0: Exit with no changes"
 
	#
	# Prompt user for a file selection.
	#

	if [ "$opt_count" = "0" ]; then
	    fname_number=0
        else
            temp=1
            echo
            while [ $temp -ne 0 ];
            do
              echo "Enter the number of the compiler (0-$opt_count):"
              read fname_number
              with_letters_removed=`echo $fname_number | sed -e "s/[^[:digit:]]//g"`
              if [ "$with_letters_removed" = "$fname_number" -a "$with_letters_removed" != "" ]; then

              #Using test instead of [ ] so we can discard output to stderr
                  test "$fname_number" -ge "0" -a "$fname_number" -le "$opt_count"
                  temp=$?
              fi
              if [ $temp -ne 0 ]; then
                  echo
                  echo "Please enter from 0-$opt_count"
              fi
            done
            echo
	fi
        if [ $fname_number -eq 0 ]; then
            echo "No compiler selected, no action taken."
            exit 0
        fi
	FOUND_FILE="`echo $file_array | cut -f $fname_number -d:`"
    
    fi

    #
    # Choose a destination for the options file, and copy it there.
    #

    if [ "X$OPTIONS_DEST_OVERRIDE" != "X" ]; then
        # Override destination
        echo
        echo "$FOUND_FILE is being copied to "
        echo "$OPTIONS_DEST_OVERRIDE"
        echo
        cp $FOUND_FILE $OPTIONS_DEST_OVERRIDE
    else
        #
        # Options file goes into preferences directory.
        # Create the preferences directory for the user, if it doesn't already exist.
        #
        
        determine_preference_dir

        if [ ! -d $PREF_DIR ]; then
            echo
            echo $PREF_DIR does not exist. It will be created.
            echo
            mkdir -p $PREF_DIR
        fi

        if [ -d $PREF_DIR/$DEFAULT_OPTIONS_FILE ]; then
            echo "$PREF_DIR/$DEFAULT_OPTIONS_FILE is a directory. Please remove it."
            exit 1
        fi
        if [ -f $PREF_DIR/$DEFAULT_OPTIONS_FILE ]; then
            echo "Overwrite $PREF_DIR/$DEFAULT_OPTIONS_FILE ([y]/n)? "
            read action
            if [ "$action" = "n" ]; then
                echo
                echo "Will not overwrite existing file. Options file not changed."
                echo
                exit 0
            fi
            rm -f $PREF_DIR/$DEFAULT_OPTIONS_FILE
        fi
        echo
        echo "$FOUND_FILE is being copied to "
        echo "$PREF_DIR/$DEFAULT_OPTIONS_FILE"
        echo
        cp $FOUND_FILE $PREF_DIR/$DEFAULT_OPTIONS_FILE
    fi
        
}
# end setup_options_file ()
#
#========================= optsetup.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
    rm -rf $files_to_remove > /dev/null 2>&1
    }
#   end cleanup ()
#
#****************************************************************************
#
  printHelp () {
      helpTextFileName="$MATLAB/bin/util/mex/mexHelp.txt"
      cat $helpTextFileName
      echo ''
  }

#****************************************************************************
#
  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:'
    printf '               %s\n' "$2"
    echo "           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 "->    CXX                   = $CXX"
    echo "->    CXX flags:"
    echo "         CXXFLAGS           = $CXXFLAGS"
    echo "         CXXDEBUGFLAGS      = $CXXDEBUGFLAGS"
    echo "         CXXOPTIMFLAGS      = $CXXOPTIMFLAGS"
    echo "         CXXLIBS            = $CXXLIBS"
    echo "         arguments          = $cxx_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 "->    LDCXX                 = $LDCXX"
    echo "->    Link flags:"
    echo "         LDCXXFLAGS         = $LDCXXFLAGS"
    echo "         LDCXXDEBUGFLAGS    = $LDCXXDEBUGFLAGS"
    echo "         LDCXXOPTIMFLAGS    = $LDCXXOPTIMFLAGS"
    echo "         LDCXXEXTENSION     = $LDCXXEXTENSION"
    echo "         arguments          = $libs"
    echo '----------------------------------------------------------------'
    echo ''
            ;;
        largeArrayDimsCompatibleArrayDimsNotSelected)
    echo ''
    echo "**************************************************************************"
    echo "  Warning: Neither -compatibleArrayDims nor -largeArrayDims is selected. "
    echo "           Using -compatibleArrayDims. In the future, MATLAB will require"
    echo "           the use of -largeArrayDims and remove the -compatibleArrayDims"
    echo "           option. For more information, see:"
    echo "           http://www.mathworks.com/help/matlab/matlab_external/upgrading-mex-files-to-use-64-bit-api.html"
    echo "**************************************************************************"
    echo ''
            ;;
            
        largeArrayDimsWarning)
    echo ''
    echo "**************************************************************************"
    echo "  Warning: The MATLAB C and Fortran API has changed to support MATLAB "
    echo "           variables with more than 2^32-1 elements.  In the near future "
    echo "           you will be required to update your code to utilize the new "
    echo "           API. You can find more information about this at: "
    echo "           http://www.mathworks.com/help/matlab/matlab_external/upgrading-mex-files-to-use-64-bit-api.html"
    echo "           Building with the -largeArrayDims option enables the new API. "
    echo "**************************************************************************"
    echo ''
            ;;
        assuming_c_source)
    echo ''
    echo '    Warning: No source files in argument list. Assuming C source'
    echo '             code for linking purposes. To override this'
    echo "             assumption use '-fortran' or '-cxx'."
    echo ''
            ;;
        meaningless_output_flag)
    echo ''
    echo '    Warning: -output ignored (no MEX-file is being created).'
    echo ''
            ;;
        status)
    echo ""
    echo "    mex:  $stat"
            ;;
        usage)
    cat<<'EOF'

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

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

EOF
            ;;
        file_not_found)
    echo ''
    printf '    mex:  %s  not a normal file or does not exist.\n' "$file"
    echo ''
            ;;
        compile_stage)
    echo "-> $compile_command"
    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 ''
            ;;
        postlink_stage)
    echo "-> $POSTLINK_CMDS"
    echo ''
            ;;
        fortran_cannot_change_entrypt)
    echo ''
    echo '    Warning: -entrypt ignored (FORTRAN entry point cannot be overridden).'
    echo ''
            ;;
	cannot_create_outdir)
    echo ''
    echo "    Error: Could not create OUTDIR = $OUTDIR"
    echo ''
	    ;;
	cannot_create_temp)
    echo ''
    echo "    Error: Could not create TEMP = $TEMP"
    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_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'
    else
#
#   C and C++ 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)
#       CXX                     (C++ compiler)
#       CXXFLAGS                (C++ compiler options)
#       CXXOPTIMFLAGS           (Compiler optimization flags)
#       CXXDEBUGFLAGS           (Compiler debugging flags)
#       CXXLIBS                 (C++ libraries for linking)
#       FC                      (Fortran compiler)
#       FFLAGS                  (Fortran 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/<rel_version>/$OPTSFILE_NAME  ($OPTSFILE_NAME in user's matlab preferences directory)
#  $MATLAB/bin/$OPTSFILE_NAME        ($OPTSFILE_NAME file in MATLAB bin directory)
#
#

    determine_preference_dir

    if [ -f ./$OPTSFILE_NAME ]; then
        SOURCE_DIR='.'
        SOURCE_DIReval=`pwd`
        OPTIONS_FILE="./$OPTSFILE_NAME"
    elif [ -f $PREF_DIR/$OPTSFILE_NAME ]; then
        SOURCE_DIR='$PREF_DIR'
        SOURCE_DIReval=$PREF_DIR
        OPTIONS_FILE="$PREF_DIR/$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
        . $MATLAB/bin/util/oscheck.sh
        if [ "$oscheck_status" = "1" ]; then
            cleanup
            exit 1
        fi
    fi
  }
# end get_arch ()
#
#****************************************************************************
#
  isArch64Bit () {
#
# Identify if the current architecture is a 64-bit architecture.
#
    get_arch
    if [ "`expr \"$Arch\" : \".*64\" `" != 0 ]; then
        return 0
    else
        return 1
    fi
  }
# end isArch64Bit ()
#
#****************************************************************************
#
  set_v7_compat_mode_and_switches () {
#
# Set the appropriate mode and compiler switches for 64-bit API usage (largeArrayDims).
#
    # Set the default value if the user has not already overriden the default.
    if [ "$v7_compat" = "" ]; then
        if isArch64Bit ; then
            # In the future we plan to change the default on 64-bit architectures.  
            # This is here to make that change easier in the future.
            v7_compat=1
        else
            v7_compat=1
        fi
    fi

    if [ "$v7_compat" = "1" ] ; then
        fc_flags="$fc_flags -DMX_COMPAT_32"
	cc_flags="$cc_flags -DMX_COMPAT_32"
	cxx_flags="$cxx_flags -DMX_COMPAT_32"
    fi	
  }
# end set_v7_compat_mode_and_switches ()
#
#****************************************************************************
#
  eval_assignments () {
#
# eval command line overrides of argument variables, name=[def]
#
    eval "$cmd_line_overrides"

#
# Make sure that LD is fully evaluated to handle LD=$COMPILER assignment
# Some platforms also use the special LDCXX variable for C++ files
#
    LD="`eval echo $LD`"
    LDCXX="`eval echo $LDCXX`"

#
# If TEMP is defined be sure that TEMP has been created.
#
    if [ "$TEMP" != "" ]; then
	(cd $TEMP) > /dev/null 2>&1
	if [ $? -ne 0 ]; then
	    mkdir -p $TEMP 2>/dev/null
	    if [ $? -ne 0 ]; then
		describe cannot_create_temp >&2
		cleanup
		exit 1
	    fi
	fi
    fi
  }
# end eval_assignments ()
#
#****************************************************************************
#
  error_check () {
#
#   Check for errors in calling syntax
#
    if [ "$files" != "" -a "$cfiles" != "1" -a "$cxxfiles" != "1" -a "$ffiles" != "1" ]; then
        cfiles=1
	if [ "$verbose" != "" ]; then
	    describe assuming_c_source
	fi
    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_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          # This case is if -output was used
	if [ "$compile_only" = "1" ]; then
	    describe meaningless_output_flag
        fi
        # Keep only the name and ext (not path) if linking and no OUTDIR set
        if [ "$compile_only" != "1" -a "$OUTDIR" != "" -a \
             `expr "$mex_file" : '.*\/.*'` != 0 ]; then 
                  mex_file=`expr "$mex_file" : '.*\/\(.*\)$'`
	fi
        ext=`expr "$mex_file" : ".*$LDEXTENSION$"`
        if [ "$ext" = "0" ]; then
            mex_file=$mex_file$LDEXTENSION
        fi
    elif [ "$1" != "" ]; then              # This case sets mex_file using the SOURCE name from $1
        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=`quote_arg "$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 .f90 .F90 .cu .CU
#
    file=`quote_arg "$file"`
    case "$ext" in
        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"
            ;;
	cc | cpp | cxx | C) # C++ source file
#
# determine whether to optimize or debug
#
            if [ "$debug" != "1" ]; then
                flags="$CXXOPTIMFLAGS"
            elif [ "$optimize" = "1" ]; then
                flags="$CXXDEBUGFLAGS $CXXOPTIMFLAGS"
            else
                flags="$CXXDEBUGFLAGS"
            fi
#
# Determine final compile command for C++ source code.
#
            flags="-DMATLAB_MEX_FILE $CXXFLAGS $cxx_flags $flags"
            compile_command="$CXX -c $include_dirs $flags $file"
            ;;
	cu | CU ) # CUDA source file
#
# determine whether to optimize or debug
#
            if [ "$debug" != "1" ]; then
                flags="$CXXOPTIMFLAGS"
            elif [ "$optimize" = "1" ]; then
                flags="$CXXDEBUGFLAGS $CXXOPTIMFLAGS"
            else
                flags="$CXXDEBUGFLAGS"
            fi
#
# Determine final compile command for CUDA source code.
#
            flags="-DMATLAB_MEX_FILE $CXXFLAGS $cxx_flags $flags"
            compile_command="$CXX -c $include_dirs $flags $file"
            ;;   
        f | for | F | f90 | F90)            # 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"
            compile_command="$FC -c $include_dirs $flags $file"
            ;;
        *)
#
# 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

    removeObjectFiles=1
    if [ "$Arch" = "maci64" -o "$Arch" = "maci" ]; then
#       Macintoshes store debug information in the object files. So we need
#       to keep them from debugging on Macs.
        if [ "$debug" = 1 ]; then
            removeObjectFiles=0
        fi
    fi

    if [ "$compile_only" = "1" ]; then
        removeObjectFiles=0
    fi

    if [ "$removeObjectFiles" = "1" ]; then
        files_to_remove="$files_to_remove $basename.o"
    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 [ "$cxxfiles" = "1" ]; then
	libs="$libs $CXXLIBS"
    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
    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
#
    TOOL_DISPLAY_NAME='MEX'
    OPTSFILE_NAME='mexopts.sh'
#
    MEX_INCLUDE_DIR='extern/include'
#
    stat="OK"
#
  ARCH=
    Arch='Undetermined'
    verbose=0

    # Define $MATLAB if it's not defined. 
    if [ ! "$MATLAB" ]; then            # If no MATLAB='' was used
        get_root_dir $arg0_
    fi

#
#  Use a C entry point by default
#
    gateway_lang=C
    entrypt=mexFunction
#
    arg_count=$#
    cmd_line_overrides=":"
    bool_found_compat=0
    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
            -compatibleArrayDims)
                v7_compat=1
		bool_found_compat=1
                ;;
            -largeArrayDims)
                v7_compat=0
		bool_found_compat=1
                ;;
            -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"
                cxx_flags="$cxx_flags $lhs$mid$rhs"
                fc_flags="$fc_flags $lhs$mid$rhs"
                ;;
            -U*)                         # Compiler flags.
                cc_flags="$cc_flags $1"
                cxx_flags="$cxx_flags $1"
                fc_flags="$fc_flags $1"
                ;;
            -I* | -isystem*)             # Include directories
                include_dirs="$include_dirs `smart_quote $1`"
                ;;
            -f)
                if [ -f "$2" ]; then
                    OPTIONS_FILE="$2"
                    SOURCE_DIR='none'
                else
                    describe invalid_options_file "$2" >&2
                    cleanup
                    exit 1
                fi
                shift
                ;;
            -cxx)
                cxxfiles=1
                gateway_lang=C
                ;;    
	    -fortran)
                ffiles=1
                gateway_lang=FORTRAN
                ;;
            -g)                             # Use debugging flags.
                debug=1
                ;;
            -h | -help)                     # -help: Help option.
                printHelp
                cleanup
                exit 0
                ;;
            -[Ll]*)
                libs="$libs $1"
                ;;
            -Wl* | -R*)                     # allow other linker options
                libs="$libs $1"
                ;;
            -n)                             # output name
                no_execute="true"
                ;;
            -nohg)                          # ignored for compatibility with mbuild
                ;;
            -o | -output)                   # mexfile name
                mex_file=$2
                shift
                ;;
            -outdir)                        # output directory
		if [ $# -lt 2 ]; then
		    describe usage >&2
                    cleanup
		    exit 1
		fi
                OUTDIR=$2
		(cd $OUTDIR) > /dev/null 2>&1
		if [ $? -ne 0 ]; then
		    mkdir -p $OUTDIR 2>/dev/null
		    if [ $? -ne 0 ]; then
			describe cannot_create_outdir >&2
			cleanup
			exit 1
		    fi
		fi
                shift
                ;;
            -O)                             # Use optimization flags.
                optimize=1
                ;;
            -setup)
		if [ $arg_count -ne 4 -a $arg_count -ne 3 -a $arg_count -ne 2 -a $arg_count -ne 1 ]; then
		    describe usage >&2
                    cleanup
		    exit 1
		else
		    # Allow "-setup", "-setup optionsfile", 
		    # or "-setup optionsfile destination"
		    SETUP_OPTIONS_FILE=$2
		    SETUP_OPTIONS_DESTINATION=$3
		    TMW_ROOT=$MATLAB
		    setup_options_file $SETUP_OPTIONS_FILE $SETUP_OPTIONS_DESTINATION
                    describe largeArrayDimsWarning
                    cleanup
		    exit 0
		fi
                ;;
            -silent)            # really not verbose - undocumented
                verbose=
                ;;
            -v)
                verbose=1
                ;;
            -entrypt)
                if [ "$2" != "mexFunction" ]; then
                     stat="-entrypt argument must be 'mexFunction'"
                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_]*[=\#]\(.*\)$'`
                cmd_line_overrides="$cmd_line_overrides; $lhs="'"'"$rhs"'"'
                ;;
            *.c) # c source file.
                cfiles='1'
                quoted_arg1=`quote_arg "$1"`
                files="$files $quoted_arg1"
                ;;
			*.cu | *.CU) # CUDA source file.
				cxxfiles='1'
				quoted_arg1=`quote_arg "$1"`
				files="$files $quoted_arg1"
				;;
           *.C | *.cc | *.cpp | *.cxx) # C++ source file.
                cxxfiles='1'
                quoted_arg1=`quote_arg "$1"`
                files="$files $quoted_arg1"
                ;;
            *.f | *.for | *.F | *.f90 | *.F90 )      # FORTRAN source file.
                if [ "$ffiles" != "1" -a "$cfiles" != "1" -a "$cxxfiles" != "1" ]; then
                    gateway_lang=FORTRAN
                fi
                ffiles='1'
                quoted_arg1=`quote_arg "$1"`
                files="$files $quoted_arg1"
                ;;
            *.o)                              # object files
                quoted_arg1=`quote_arg "$1"`
                files="$files $quoted_arg1"
                ;;
            *)                                # other files
                libs="$libs `smart_quote $1`"
                ;;
        esac
    shift
    done
    if [ $# -eq 0 -a "$files" = "" -a "$stat" = "OK" ]; then
        stat="no file name given."
    fi
    if [ $bool_found_compat -eq 0 -a "$verbose" = "1" ]; then
	 describe largeArrayDimsCompatibleArrayDimsNotSelected
    fi
    if [ "$gateway_lang" = "FORTRAN" -a "$entrypt" != "mexFunction" ]; then
        describe fortran_cannot_change_entrypt
        entrypt=mexFunction
    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_entrypt $gateway_lang           # Determine MEX-file entry pt
#
    if [ "$ffiles" = "1" ]; then
        COMPILER='$FC'
    elif [ "$cxxfiles" = "1" ]; then
        COMPILER='$CXX'
    else
        COMPILER='$CC'
    fi
#
    . "$OPTIONS_FILE"                   # Source options file
#
    set_v7_compat_mode_and_switches
#
    eval_assignments                    # Evaluate VAR=value arguments

    eval get_name "$files"		# Determine MEX-file name

#
    if [ "$verbose" = "1" ]; then
        describe final_options
    fi
#
    error_check                         # Check calling syntax errors
#
    get_includes                        # Determine include directories
#
# Check the version of gcc if we are using gcc to warn about possible
# version conflicts
    validate_gcc
#
# 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().
#
    eval set -- "$files"
    while [ $# -ne 0 ]
    do
        compile "$1"
        shift
    done
#
    if [ "$compile_only" != "1" ]; then
        link                            # Perform linking

        # Perform any POSTLINK_CMDS; ":" is the empty/null command which
        # we initialize POSTLINK_CMDS to in order to allow for concatenation
        # of multiple postlink commands such as 
        #
        # POSTLINK_CMDS='$POSTLINK_CMDS;my_command'
        #
        # if POSTLINK_CMDS were initially empty in the above command, the 
        # result would be ";my_command" which isn't legal.
        if [ "$POSTLINK_CMDS" != ":" -a "$POSTLINK_CMDS" != "" ]; then
            if [ "$verbose" = "1" -o "$no_execute" = "true" ]; then
                describe postlink_stage
            fi
            if [ "$no_execute" != "true" ]; then 
                eval "$POSTLINK_CMDS"; 
            fi
        fi
    fi
#
    export LD_LIBRARY_PATH=''
    cleanup
    exit 0
#
#****************************************************************************