imread.cpp

matlab的可执行程序

                    // fid = fopen([filename '.' fmt_s.ext{p}]);
                    // 
                    // if (fid ~= -1)
                    // % The file was found.  Don't continue searching.
                    // break
                    // end
                    // end
                    //
                    for (; ; ) {
                        fid
                          = fopen(
                              horzcat(
                                mwVarargin(
                                  mwVv(filename, "filename"),
                                  _mxarray22_,
                                  mwVv(fmt_s, "fmt_s").field("ext").cell(
                                    v_))));
                        if (mclNeBool(mwVv(fid, "fid"), _mxarray12_)) {
                            break;
                        }
                        if (v_ == e_) {
                            break;
                        }
                        ++v_;
                    }
                    p = v_;
                }
            }
        //
        // end
        //
        }
        //
        // 
        // if (fid == -1)
        //
        if (mclEqBool(mwVv(fid, "fid"), _mxarray12_)) {
            //
            // if ~isempty(dir(filename))
            //
            if (mclNotBool(isempty(Ndir(1, mwVv(filename, "filename"))))) {
                //
                // error(['Can''t open file "%s" for reading;\nyou' ...
                //
                error(mwVarargin(_mxarray13_, mwVv(filename, "filename")));
            //
            // ' may not have read permission.'], ...
            // filename);
            // else
            //
            } else {
                //
                // error('File "%s" does not exist.', filename);
                //
                error(mwVarargin(_mxarray15_, mwVv(filename, "filename")));
            //
            // end
            //
            }
        //
        // else
        //
        } else {
            //
            // filename = fopen(fid);
            //
            filename = fopen(mwVv(fid, "fid"));
            //
            // fclose(fid);
            //
            ans.EqAns(fclose(mwVv(fid, "fid")));
        //
        // end
        //
        }
    //
    // 
    // end
    //
    }
    //
    // 
    // % Get format details.
    // fmt_s = imformats(format);
    //
    fmt_s
      = Nimformats(0, mwValueVarargout(), mwVarargin(mwVv(format, "format")));
    //
    // 
    // % Verify that a read function exists
    // if (isempty(fmt_s.read))
    //
    if (tobool(
          feval(
            mwValueVarargout(),
            mlxIsempty,
            mwVarargin(mwVv(fmt_s, "fmt_s").field("read"))))) {
        //
        // error('No reading function for format %s.  See "help imformats".', ...
        //
        error(
          mwVarargin(
            _mxarray24_, mwVv(fmt_s, "fmt_s").field("ext").cell(_mxarray26_)));
    //
    // fmt_s.ext{1});
    // end
    //
    }
    //
    // 
    // if ((fmt_s.alpha) & (nargout == 3))
    //
    {
        mwArray a_ = mwVv(fmt_s, "fmt_s").field("alpha");
        if (tobool(a_) && tobool(a_ & nargout_ == 3)) {
            //
            // 
            // % Use the alpha channel.
            // [X, map, alpha] = feval(fmt_s.read, filename, extraArgs{:});
            //
            feval(
              mwVarargout(X, *map, *alpha),
              mwVarargin(
                mwVv(fmt_s, "fmt_s").field("read"),
                mwVv(filename, "filename"),
                mwVv(extraArgs, "extraArgs").cell(colon())));
        //
        // 
        // else
        //
        } else {
            //
            // 
            // % Alpha channel is not requested or is not applicable.
            // alpha = [];
            //
            *alpha = _mxarray21_;
            //
            // [X, map] = feval(fmt_s.read, filename, extraArgs{:});
            //
            feval(
              mwVarargout(X, *map),
              mwVarargin(
                mwVv(fmt_s, "fmt_s").field("read"),
                mwVv(filename, "filename"),
                mwVv(extraArgs, "extraArgs").cell(colon())));
        }
    //
    // 
    // end
    //
    }
    //
    // 
    // % Delete temporary file from Internet download.
    // if (url)
    //
    if (tobool(mwVv(url, "url"))) {
        //
        // delete_download(filename);
        //
        imread_delete_download(mwVv(filename, "filename"));
    //
    // end
    //
    }
    mwValidateOutput(X, 1, nargout_, "X", "imread");
    mwValidateOutput(*map, 2, nargout_, "map", "imread");
    mwValidateOutput(*alpha, 3, nargout_, "alpha", "imread");
    return X;
    //
    // 
    // 
    // 
    // %%%
    // %%% Function delete_download
    // %%%
    //
}

//
// The function "Mimread_delete_download" is the implementation version of the
// "imread/delete_download" M-function from file
// "e:\matlab6.5\toolbox\matlab\iofun\imread.m" (lines 297-311). It contains
// the actual compiled code for that M-function. It is a static function and
// must only be called from one of the interface functions, appearing below.
//
//
// function delete_download(filename)
//
static void Mimread_delete_download(mwArray filename) {
    mwLocalFunctionTable save_local_function_table_
      = &_local_function_table_imread;
    mwArray ans = mwArray::UNDEFINED;
    //
    // 
    // try
    //
    try {
        //
        // delete(filename);
        //
        delete_func(mwVarargin(mwVa(filename, "filename")));
    //
    // catch
    //
    } catch(mwException e_) {
        //
        // warning('Can''t delete temporary file "%s".', filename)
        //
        ans.EqPrintAns(
          Nwarning(
            0, NULL, mwVarargin(_mxarray27_, mwVa(filename, "filename"))));
    //
    // end
    //
    }
    //
    // 
    // 
    // 
    // 
    // %%%
    // %%% Function parse_inputs
    // %%%
    //
}

//
// The function "Mimread_parse_inputs" is the implementation version of the
// "imread/parse_inputs" M-function from file
// "e:\matlab6.5\toolbox\matlab\iofun\imread.m" (lines 311-354). It contains
// the actual compiled code for that M-function. It is a static function and
// must only be called from one of the interface functions, appearing below.
//
//
// function [filename, format, extraArgs, msg] = ...
//
static mwArray Mimread_parse_inputs(mwArray * format,
                                    mwArray * extraArgs,
                                    mwArray * msg,
                                    int nargout_,
                                    mwArray varargin) {
    mwLocalFunctionTable save_local_function_table_
      = &_local_function_table_imread;
    int nargin_ = nargin(-1, mwVarargin(varargin));
    mwArray filename = mwArray::UNDEFINED;
    mwArray fmt_s = mwArray::UNDEFINED;
    //
    // parse_inputs(varargin)
    // 
    // filename = '';
    //
    filename = _mxarray29_;
    //
    // format = '';
    //
    *format = _mxarray29_;
    //
    // extraArgs = {};
    //
    *extraArgs = _mxarray30_;
    //
    // msg = '';
    //
    *msg = _mxarray29_;
    //
    // 
    // % Parse arguments based on their number.
    // switch(nargin)
    //
    {
        mwArray v_ = nargin_;
        if (switchcompare(v_, _mxarray31_)) {
            //
            // case 0
            // 
            // % Not allowed.
            // msg = 'Too few input arguments.';
            //
            *msg = _mxarray32_;
        //
        // return;
        // 
        // case 1
        //
        } else if (switchcompare(v_, _mxarray26_)) {
            //
            // 
            // % Filename only.
            // filename = varargin{1};
            //
            filename = mwVa(varargin, "varargin").cell(_mxarray26_);
        //
        // 
        // otherwise
        //
        } else {
            //
            // 
            // % Filename and format or other arguments.
            // filename = varargin{1};
            //
            filename = mwVa(varargin, "varargin").cell(_mxarray26_);
            //
            // 
            // % Check whether second argument is a format.
            // if (ischar(varargin{2}))
            //
            if (tobool(
                  feval(
                    mwValueVarargout(),
                    mlxIschar,
                    mwVarargin(
                      mwVa(varargin, "varargin").cell(_mxarray34_))))) {
                //
                // fmt_s = imformats(varargin{2});
                //
                fmt_s
                  = Nimformats(
                      0,
                      mwValueVarargout(),
                      mwVarargin(
                        mwVa(varargin, "varargin").cell(_mxarray34_)));
            //
            // else
            //
            } else {
                //
                // fmt_s = struct([]);
                //
                fmt_s = struct_func(mwVarargin(_mxarray21_));
            //
            // end
            //
            }
            //
            // 
            // if (~isempty(fmt_s))
            //
            if (mclNotBool(isempty(mwVv(fmt_s, "fmt_s")))) {
                //
                // % The argument matches a format.
                // format = varargin{2};
                //
                *format = mwVa(varargin, "varargin").cell(_mxarray34_);
                //
                // extraArgs = varargin(3:end);
                //
                *extraArgs
                  = mclArrayRef(
                      mwVa(varargin, "varargin"),
                      colon(
                        _mxarray35_,
                        end(
                          mwVa(varargin, "varargin"),
                          _mxarray26_,
                          _mxarray26_)));
            //
            // else
            //
            } else {
                //
                // % The argument begins the format-specific parameters.
                // extraArgs = varargin(2:end);
                //
                *extraArgs
                  = mclArrayRef(
                      mwVa(varargin, "varargin"),
                      colon(
                        _mxarray34_,
                        end(
                          mwVa(varargin, "varargin"),
                          _mxarray26_,
                          _mxarray26_)));
            //
            // end
            //
            }
        //
        // 
        // end
        //
        }
    }
    mwValidateOutput(filename, 1, nargout_, "filename", "imread/parse_inputs");
    mwValidateOutput(*format, 2, nargout_, "format", "imread/parse_inputs");
    mwValidateOutput(
      *extraArgs, 3, nargout_, "extraArgs", "imread/parse_inputs");
    mwValidateOutput(*msg, 4, nargout_, "msg", "imread/parse_inputs");
    return filename;
}