Mercurial > octave
view libinterp/corefcn/defun.cc @ 23433:c9fab0bc983e
maint: Use convention 'int& x' for naming references.
* ButtonGroup.cc, Canvas.cc, Canvas.h, annotation-dialog.cc,
annotation-dialog.h, dialog.h, documentation-dock-widget.cc,
files-dock-widget.cc, files-dock-widget.h, find-files-dialog.cc,
find-files-dialog.h, find-files-model.cc, find-files-model.h,
history-dock-widget.cc, history-dock-widget.h, file-editor-tab.cc,
file-editor-tab.h, file-editor.cc, file-editor.h, main-window.cc,
main-window.h, octave-qt-link.h, parser.cc, parser.h, webinfo.cc, webinfo.h,
settings-dialog.cc, bsxfun.cc, call-stack.cc, call-stack.h, fft.cc, fft2.cc,
fftn.cc, gl-render.cc, graphics.cc, graphics.in.h, input.cc, load-save.cc,
ls-hdf5.cc, ls-hdf5.h, octave-link.h, pr-output.cc, regexp.cc, sparse-xdiv.cc,
sparse-xdiv.h, symtab.cc, xdiv.cc, xdiv.h, zfstream.h, __eigs__.cc,
__ode15__.cc, ov-base.h, ov-builtin.cc, ov-cx-sparse.h, ov-fcn-handle.cc,
ov-fcn-handle.h, ov.cc, ov.h, jit-ir.h, jit-typeinfo.cc, jit-typeinfo.h,
pt-jit.cc, pt-jit.h, CMatrix.cc, CMatrix.h, CSparse.cc, CSparse.h,
MatrixType.cc, MatrixType.h, dDiagMatrix.cc, dMatrix.cc, dMatrix.h, dSparse.cc,
dSparse.h, fCMatrix.cc, fCMatrix.h, fDiagMatrix.cc, fMatrix.cc, fMatrix.h,
eigs-base.cc, oct-fftw.cc, oct-rand.h, sparse-dmsolve.cc, kpse.cc, lo-regexp.h:
Use convention 'int& x' for naming references.
author | Rik <rik@octave.org> |
---|---|
date | Mon, 24 Apr 2017 17:20:37 -0700 |
parents | 092078913d54 |
children | 73558a835b64 |
line wrap: on
line source
/* Copyright (C) 1996-2017 John W. Eaton This file is part of Octave. Octave is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. Octave is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Octave; see the file COPYING. If not, see <http://www.gnu.org/licenses/>. */ #if defined (HAVE_CONFIG_H) # include "config.h" #endif #include <sstream> #include <iostream> #include <string> #include "call-stack.h" #include "defun.h" #include "dynamic-ld.h" #include "error.h" #include "help.h" #include "ov.h" #include "ov-builtin.h" #include "ov-dld-fcn.h" #include "ov-fcn.h" #include "ov-mex-fcn.h" #include "ov-usr-fcn.h" #include "ovl.h" #include "oct-lvalue.h" #include "pager.h" #include "symtab.h" #include "interpreter.h" #include "variables.h" #include "parse.h" // Print the usage part of the doc string of FCN (user-defined or DEFUN). void print_usage (void) { const octave_function *cur = octave::call_stack::current (); if (cur) print_usage (cur->name ()); else error ("print_usage: invalid function"); } void print_usage (const std::string& name) { octave::feval ("print_usage", octave_value (name), 0); } void check_version (const std::string& version, const std::string& fcn) { if (version != OCTAVE_API_VERSION) { error ("API version %s found in .oct file function '%s'\n" " does not match the running Octave (API version %s)\n" " this can lead to incorrect results or other failures\n" " you can fix this problem by recompiling this .oct file", version.c_str (), fcn.c_str (), OCTAVE_API_VERSION); } } // Install variables and functions in the symbol tables. void install_builtin_function (octave_builtin::fcn f, const std::string& name, const std::string& file, const std::string& doc, bool /* can_hide_function -- not yet implemented */) { octave_value fcn (new octave_builtin (f, name, file, doc)); symbol_table::install_built_in_function (name, fcn); } void install_dld_function (octave_dld_function::fcn f, const std::string& name, const octave::dynamic_library& shl, const std::string& doc, bool relative) { octave_dld_function *fcn = new octave_dld_function (f, shl, name, doc); if (relative) fcn->mark_relative (); octave_value fval (fcn); symbol_table::install_built_in_function (name, fval); } void install_mex_function (void *fptr, bool fmex, const std::string& name, const octave::dynamic_library& shl, bool relative) { octave_mex_function *fcn = new octave_mex_function (fptr, fmex, shl, name); if (relative) fcn->mark_relative (); octave_value fval (fcn); symbol_table::install_built_in_function (name, fval); } void alias_builtin (const std::string& alias, const std::string& name) { symbol_table::alias_built_in_function (alias, name); } void install_builtin_dispatch (const std::string& name, const std::string& klass) { symbol_table::install_built_in_dispatch (name, klass); } octave::dynamic_library get_current_shlib (void) { octave::dynamic_library retval; octave_function *curr_fcn = octave::call_stack::current (); if (curr_fcn) { if (curr_fcn->is_dld_function ()) { octave_dld_function *dld = dynamic_cast<octave_dld_function *> (curr_fcn); retval = dld->get_shlib (); } else if (curr_fcn->is_mex_function ()) { octave_mex_function *mex = dynamic_cast<octave_mex_function *> (curr_fcn); retval = mex->get_shlib (); } } return retval; } bool defun_isargout (int nargout, int iout) { const std::list<octave_lvalue> *lvalue_list = octave_builtin::curr_lvalue_list; if (iout >= std::max (nargout, 1)) return false; else if (lvalue_list) { int k = 0; for (const auto& lval : *lvalue_list) { if (k == iout) return ! lval.is_black_hole (); k += lval.numel (); if (k > iout) break; } return true; } else return true; } void defun_isargout (int nargout, int nout, bool *isargout) { const std::list<octave_lvalue> *lvalue_list = octave_builtin::curr_lvalue_list; if (lvalue_list) { int k = 0; for (const auto& lval : *lvalue_list) { if (lval.is_black_hole ()) isargout[k++] = false; else { int l = std::min (k + lval.numel (), static_cast<octave_idx_type> (nout)); while (k < l) isargout[k++] = true; } } } else for (int i = 0; i < nout; i++) isargout[i] = true; for (int i = std::max (nargout, 1); i < nout; i++) isargout[i] = false; }