Mercurial > octave
view libinterp/parse-tree/pt-eval.cc @ 21301:40de9f8f23a6
Use '#include "config.h"' rather than <config.h>.
* mk-octave-config-h.sh, mk-opts.pl, Backend.cc, BaseControl.cc,
ButtonControl.cc, Canvas.cc, CheckBoxControl.cc, Container.cc, ContextMenu.cc,
EditControl.cc, Figure.cc, FigureWindow.cc, GLCanvas.cc, KeyMap.cc,
ListBoxControl.cc, Logger.cc, Menu.cc, MouseModeActionGroup.cc, Object.cc,
ObjectFactory.cc, ObjectProxy.cc, Panel.cc, PopupMenuControl.cc,
PushButtonControl.cc, PushTool.cc, QtHandlesUtils.cc, RadioButtonControl.cc,
SliderControl.cc, TextControl.cc, TextEdit.cc, ToggleButtonControl.cc,
ToggleTool.cc, ToolBar.cc, ToolBarButton.cc, __init_qt__.cc,
annotation-dialog.cc, gl-select.cc, module.mk, kpty.cpp, color-picker.cc,
dialog.cc, documentation-dock-widget.cc, files-dock-widget.cc,
find-files-dialog.cc, find-files-model.cc, history-dock-widget.cc,
file-editor-tab.cc, file-editor-tab.h, file-editor.cc, find-dialog.cc,
marker.cc, octave-qscintilla.cc, octave-txt-lexer.cc, main-window.cc,
octave-cmd.cc, octave-dock-widget.cc, octave-gui.cc, octave-interpreter.cc,
octave-qt-link.cc, parser.cc, webinfo.cc, resource-manager.cc,
settings-dialog.cc, shortcut-manager.cc, terminal-dock-widget.cc,
thread-manager.cc, welcome-wizard.cc, workspace-model.cc, workspace-view.cc,
build-env-features.sh, build-env.in.cc, Cell.cc, __contourc__.cc,
__dispatch__.cc, __dsearchn__.cc, __ichol__.cc, __ilu__.cc, __lin_interpn__.cc,
__pchip_deriv__.cc, __qp__.cc, balance.cc, besselj.cc, betainc.cc, bitfcns.cc,
bsxfun.cc, c-file-ptr-stream.cc, cdisplay.c, cellfun.cc, coct-hdf5-types.c,
colloc.cc, comment-list.cc, conv2.cc, daspk.cc, dasrt.cc, dassl.cc, data.cc,
debug.cc, defaults.cc, defun.cc, det.cc, dirfns.cc, display.cc, dlmread.cc,
dot.cc, dynamic-ld.cc, eig.cc, ellipj.cc, error.cc, errwarn.cc, event-queue.cc,
fft.cc, fft2.cc, fftn.cc, file-io.cc, filter.cc, find.cc, ft-text-renderer.cc,
gammainc.cc, gcd.cc, getgrent.cc, getpwent.cc, getrusage.cc, givens.cc,
gl-render.cc, gl2ps-print.cc, graphics.cc, gripes.cc, hash.cc, help.cc,
hess.cc, hex2num.cc, hook-fcn.cc, input.cc, inv.cc, jit-ir.cc, jit-typeinfo.cc,
jit-util.cc, kron.cc, load-path.cc, load-save.cc, lookup.cc,
ls-ascii-helper.cc, ls-hdf5.cc, ls-mat-ascii.cc, ls-mat4.cc, ls-mat5.cc,
ls-oct-binary.cc, ls-oct-text.cc, ls-utils.cc, lsode.cc, lu.cc, luinc.cc,
mappers.cc, matrix_type.cc, max.cc, mex.cc, mgorth.cc, nproc.cc,
oct-errno.in.cc, oct-fstrm.cc, oct-hdf5-types.cc, oct-hist.cc, oct-iostrm.cc,
oct-lvalue.cc, oct-map.cc, oct-prcstrm.cc, oct-procbuf.cc, oct-stream.cc,
oct-strstrm.cc, oct-tex-lexer.in.ll, oct-tex-parser.in.yy, octave-link.cc,
ordschur.cc, pager.cc, pinv.cc, pr-output.cc, procstream.cc, profiler.cc,
psi.cc, pt-jit.cc, quad.cc, quadcc.cc, qz.cc, rand.cc, rcond.cc, regexp.cc,
schur.cc, sighandlers.cc, siglist.c, sparse-xdiv.cc, sparse-xpow.cc, sparse.cc,
spparms.cc, sqrtm.cc, str2double.cc, strfind.cc, strfns.cc, sub2ind.cc, svd.cc,
sylvester.cc, symtab.cc, syscalls.cc, sysdep.cc, text-renderer.cc, time.cc,
toplev.cc, tril.cc, tsearch.cc, txt-eng.cc, typecast.cc, urlwrite.cc, utils.cc,
variables.cc, xdiv.cc, xgl2ps.c, xnorm.cc, xpow.cc, zfstream.cc,
__delaunayn__.cc, __eigs__.cc, __fltk_uigetfile__.cc, __glpk__.cc,
__init_fltk__.cc, __init_gnuplot__.cc, __magick_read__.cc, __osmesa_print__.cc,
__voronoi__.cc, amd.cc, audiodevinfo.cc, audioread.cc, ccolamd.cc, chol.cc,
colamd.cc, convhulln.cc, dmperm.cc, fftw.cc, qr.cc, symbfact.cc, symrcm.cc,
mkbuiltins, mkops, ov-base-diag.cc, ov-base-int.cc, ov-base-mat.cc,
ov-base-scalar.cc, ov-base-sparse.cc, ov-base.cc, ov-bool-mat.cc,
ov-bool-sparse.cc, ov-bool.cc, ov-builtin.cc, ov-cell.cc, ov-ch-mat.cc,
ov-class.cc, ov-classdef.cc, ov-colon.cc, ov-complex.cc, ov-cs-list.cc,
ov-cx-diag.cc, ov-cx-mat.cc, ov-cx-sparse.cc, ov-dld-fcn.cc, ov-fcn-handle.cc,
ov-fcn-inline.cc, ov-fcn.cc, ov-float.cc, ov-flt-complex.cc, ov-flt-cx-diag.cc,
ov-flt-cx-mat.cc, ov-flt-re-diag.cc, ov-flt-re-mat.cc, ov-int16.cc,
ov-int32.cc, ov-int64.cc, ov-int8.cc, ov-java.cc, ov-lazy-idx.cc,
ov-mex-fcn.cc, ov-null-mat.cc, ov-oncleanup.cc, ov-perm.cc, ov-range.cc,
ov-re-diag.cc, ov-re-mat.cc, ov-re-sparse.cc, ov-scalar.cc, ov-str-mat.cc,
ov-struct.cc, ov-typeinfo.cc, ov-uint16.cc, ov-uint32.cc, ov-uint64.cc,
ov-uint8.cc, ov-usr-fcn.cc, ov.cc, ovl.cc, octave.cc, op-b-b.cc, op-b-bm.cc,
op-b-sbm.cc, op-bm-b.cc, op-bm-bm.cc, op-bm-sbm.cc, op-cdm-cdm.cc, op-cell.cc,
op-chm.cc, op-class.cc, op-cm-cm.cc, op-cm-cs.cc, op-cm-m.cc, op-cm-s.cc,
op-cm-scm.cc, op-cm-sm.cc, op-cs-cm.cc, op-cs-cs.cc, op-cs-m.cc, op-cs-s.cc,
op-cs-scm.cc, op-cs-sm.cc, op-dm-dm.cc, op-dm-scm.cc, op-dm-sm.cc,
op-dm-template.cc, op-dms-template.cc, op-double-conv.cc, op-fcdm-fcdm.cc,
op-fcdm-fdm.cc, op-fcm-fcm.cc, op-fcm-fcs.cc, op-fcm-fm.cc, op-fcm-fs.cc,
op-fcn.cc, op-fcs-fcm.cc, op-fcs-fcs.cc, op-fcs-fm.cc, op-fcs-fs.cc,
op-fdm-fdm.cc, op-float-conv.cc, op-fm-fcm.cc, op-fm-fcs.cc, op-fm-fm.cc,
op-fm-fs.cc, op-fs-fcm.cc, op-fs-fcs.cc, op-fs-fm.cc, op-fs-fs.cc,
op-i16-i16.cc, op-i32-i32.cc, op-i64-i64.cc, op-i8-i8.cc, op-int-concat.cc,
op-int-conv.cc, op-m-cm.cc, op-m-cs.cc, op-m-m.cc, op-m-s.cc, op-m-scm.cc,
op-m-sm.cc, op-pm-pm.cc, op-pm-scm.cc, op-pm-sm.cc, op-pm-template.cc,
op-range.cc, op-s-cm.cc, op-s-cs.cc, op-s-m.cc, op-s-s.cc, op-s-scm.cc,
op-s-sm.cc, op-sbm-b.cc, op-sbm-bm.cc, op-sbm-sbm.cc, op-scm-cm.cc,
op-scm-cs.cc, op-scm-m.cc, op-scm-s.cc, op-scm-scm.cc, op-scm-sm.cc,
op-sm-cm.cc, op-sm-cs.cc, op-sm-m.cc, op-sm-s.cc, op-sm-scm.cc, op-sm-sm.cc,
op-str-m.cc, op-str-s.cc, op-str-str.cc, op-struct.cc, op-ui16-ui16.cc,
op-ui32-ui32.cc, op-ui64-ui64.cc, op-ui8-ui8.cc, lex.ll, oct-parse.in.yy,
pt-arg-list.cc, pt-array-list.cc, pt-assign.cc, pt-binop.cc, pt-bp.cc,
pt-cbinop.cc, pt-cell.cc, pt-check.cc, pt-classdef.cc, pt-cmd.cc, pt-colon.cc,
pt-const.cc, pt-decl.cc, pt-eval.cc, pt-except.cc, pt-exp.cc, pt-fcn-handle.cc,
pt-funcall.cc, pt-id.cc, pt-idx.cc, pt-jump.cc, pt-loop.cc, pt-mat.cc,
pt-misc.cc, pt-pr-code.cc, pt-select.cc, pt-stmt.cc, pt-unop.cc, pt.cc,
token.cc, Array-jit.cc, Array-os.cc, Array-sym.cc, Array-tc.cc, version.cc,
Array-C.cc, Array-b.cc, Array-ch.cc, Array-d.cc, Array-f.cc, Array-fC.cc,
Array-i.cc, Array-idx-vec.cc, Array-s.cc, Array-str.cc, Array-util.cc,
Array-voidp.cc, Array.cc, CColVector.cc, CDiagMatrix.cc, CMatrix.cc,
CNDArray.cc, CRowVector.cc, CSparse.cc, DiagArray2.cc, MArray-C.cc,
MArray-d.cc, MArray-f.cc, MArray-fC.cc, MArray-i.cc, MArray-s.cc, MArray.cc,
MDiagArray2.cc, MSparse-C.cc, MSparse-d.cc, MatrixType.cc, PermMatrix.cc,
Range.cc, Sparse-C.cc, Sparse-b.cc, Sparse-d.cc, Sparse.cc, boolMatrix.cc,
boolNDArray.cc, boolSparse.cc, chMatrix.cc, chNDArray.cc, dColVector.cc,
dDiagMatrix.cc, dMatrix.cc, dNDArray.cc, dRowVector.cc, dSparse.cc,
dim-vector.cc, fCColVector.cc, fCDiagMatrix.cc, fCMatrix.cc, fCNDArray.cc,
fCRowVector.cc, fColVector.cc, fDiagMatrix.cc, fMatrix.cc, fNDArray.cc,
fRowVector.cc, idx-vector.cc, int16NDArray.cc, int32NDArray.cc,
int64NDArray.cc, int8NDArray.cc, intNDArray.cc, uint16NDArray.cc,
uint32NDArray.cc, uint64NDArray.cc, uint8NDArray.cc, blaswrap.c, cquit.c,
f77-extern.cc, f77-fcn.c, lo-error.c, quit.cc, CollocWt.cc, DASPK.cc, DASRT.cc,
DASSL.cc, EIG.cc, LSODE.cc, ODES.cc, Quad.cc, aepbalance.cc, chol.cc,
eigs-base.cc, fEIG.cc, gepbalance.cc, hess.cc, lo-mappers.cc, lo-specfun.cc,
lu.cc, oct-convn.cc, oct-fftw.cc, oct-norm.cc, oct-rand.cc, oct-spparms.cc,
qr.cc, qrp.cc, randgamma.c, randmtzig.c, randpoisson.c, schur.cc,
sparse-chol.cc, sparse-dmsolve.cc, sparse-lu.cc, sparse-qr.cc, svd.cc,
mk-ops.awk, dir-ops.cc, file-ops.cc, file-stat.cc, lo-sysdep.cc, mach-info.cc,
oct-env.cc, oct-group.cc, oct-passwd.cc, oct-syscalls.cc, oct-time.cc,
oct-uname.cc, cmd-edit.cc, cmd-hist.cc, data-conv.cc, f2c-main.c,
glob-match.cc, kpse.cc, lo-array-errwarn.cc, lo-array-gripes.cc, lo-cutils.c,
lo-ieee.cc, lo-regexp.cc, lo-utils.cc, oct-base64.cc, oct-glob.cc,
oct-inttypes.cc, oct-locbuf.cc, oct-mutex.cc, oct-rl-edit.c, oct-rl-hist.c,
oct-shlib.cc, oct-sort.cc, pathsearch.cc, singleton-cleanup.cc, sparse-sort.cc,
sparse-util.cc, str-vec.cc, unwind-prot.cc, url-transfer.cc,
display-available.c, main-cli.cc, main-gui.cc, main.in.cc, mkoctfile.in.cc,
octave-config.in.cc:
Use '#include "config.h"' rather than <config.h>.
author | Rik <rik@octave.org> |
---|---|
date | Thu, 18 Feb 2016 13:34:50 -0800 |
parents | 2cf8bc5c7017 |
children | 7ba48ff6ce83 |
line wrap: on
line source
/* Copyright (C) 2009-2015 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/>. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include <cctype> #include <iostream> #include <fstream> #include <typeinfo> #include "debug.h" #include "defun.h" #include "error.h" #include "errwarn.h" #include "input.h" #include "ov-fcn-handle.h" #include "ov-usr-fcn.h" #include "variables.h" #include "pt-all.h" #include "pt-eval.h" #include "symtab.h" #include "toplev.h" #include "unwind-prot.h" //FIXME: This should be part of tree_evaluator #include "pt-jit.h" static tree_evaluator std_evaluator; tree_evaluator *current_evaluator = &std_evaluator; int tree_evaluator::dbstep_flag = 0; size_t tree_evaluator::current_frame = 0; bool tree_evaluator::debug_mode = false; bool tree_evaluator::quiet_breakpoint_flag = false; tree_evaluator::stmt_list_type tree_evaluator::statement_context = tree_evaluator::other; bool tree_evaluator::in_loop_command = false; // Maximum nesting level for functions, scripts, or sourced files called // recursively. int Vmax_recursion_depth = 256; // If TRUE, turn off printing of results in functions (as if a // semicolon has been appended to each statement). static bool Vsilent_functions = false; // Normal evaluator. void tree_evaluator::visit_anon_fcn_handle (tree_anon_fcn_handle&) { panic_impossible (); } void tree_evaluator::visit_argument_list (tree_argument_list&) { panic_impossible (); } void tree_evaluator::visit_binary_expression (tree_binary_expression&) { panic_impossible (); } void tree_evaluator::visit_break_command (tree_break_command& cmd) { if (debug_mode) do_breakpoint (cmd.is_breakpoint (true)); if (statement_context == function || statement_context == script || in_loop_command) tree_break_command::breaking = 1; } void tree_evaluator::visit_colon_expression (tree_colon_expression&) { panic_impossible (); } void tree_evaluator::visit_continue_command (tree_continue_command& cmd) { if (debug_mode) do_breakpoint (cmd.is_breakpoint (true)); if (statement_context == function || statement_context == script || in_loop_command) tree_continue_command::continuing = 1; } void tree_evaluator::reset_debug_state (void) { debug_mode = bp_table::have_breakpoints () || Vdebugging; dbstep_flag = 0; } bool tree_evaluator::statement_printing_enabled (void) { return ! (Vsilent_functions && (statement_context == function || statement_context == script)); } static inline void do_global_init (tree_decl_elt& elt) { tree_identifier *id = elt.ident (); if (id) { id->mark_global (); octave_lvalue ult = id->lvalue (); if (ult.is_undefined ()) { tree_expression *expr = elt.expression (); octave_value init_val; if (expr) init_val = expr->rvalue1 (); else init_val = Matrix (); ult.assign (octave_value::op_asn_eq, init_val); } } } static inline void do_static_init (tree_decl_elt& elt) { tree_identifier *id = elt.ident (); if (id) { id->mark_as_static (); octave_lvalue ult = id->lvalue (); if (ult.is_undefined ()) { tree_expression *expr = elt.expression (); octave_value init_val; if (expr) init_val = expr->rvalue1 (); else init_val = Matrix (); ult.assign (octave_value::op_asn_eq, init_val); } } } void tree_evaluator::do_decl_init_list (decl_elt_init_fcn fcn, tree_decl_init_list *init_list) { if (init_list) { for (tree_decl_init_list::iterator p = init_list->begin (); p != init_list->end (); p++) { tree_decl_elt *elt = *p; fcn (*elt); } } } void tree_evaluator::visit_global_command (tree_global_command& cmd) { if (debug_mode) do_breakpoint (cmd.is_breakpoint (true)); do_decl_init_list (do_global_init, cmd.initializer_list ()); } void tree_evaluator::visit_persistent_command (tree_persistent_command& cmd) { if (debug_mode) do_breakpoint (cmd.is_breakpoint (true)); do_decl_init_list (do_static_init, cmd.initializer_list ()); } void tree_evaluator::visit_decl_elt (tree_decl_elt&) { panic_impossible (); } #if 0 bool tree_decl_elt::eval (void) { bool retval = false; if (id && expr) { octave_lvalue ult = id->lvalue (); octave_value init_val = expr->rvalue1 (); ult.assign (octave_value::op_asn_eq, init_val); retval = true; } return retval; } #endif void tree_evaluator::visit_decl_init_list (tree_decl_init_list&) { panic_impossible (); } // Decide if it's time to quit a for or while loop. static inline bool quit_loop_now (void) { octave_quit (); // Maybe handle 'continue N' someday... if (tree_continue_command::continuing) tree_continue_command::continuing--; bool quit = (tree_return_command::returning || tree_break_command::breaking || tree_continue_command::continuing); if (tree_break_command::breaking) tree_break_command::breaking--; return quit; } void tree_evaluator::visit_simple_for_command (tree_simple_for_command& cmd) { if (debug_mode) do_breakpoint (cmd.is_breakpoint (true)); // FIXME: need to handle PARFOR loops here using cmd.in_parallel () // and cmd.maxproc_expr (); unwind_protect frame; frame.protect_var (in_loop_command); in_loop_command = true; tree_expression *expr = cmd.control_expr (); octave_value rhs = expr->rvalue1 (); #if defined (HAVE_LLVM) if (tree_jit::execute (cmd, rhs)) return; #endif if (rhs.is_undefined ()) return; tree_expression *lhs = cmd.left_hand_side (); octave_lvalue ult = lhs->lvalue (); tree_statement_list *loop_body = cmd.body (); if (rhs.is_range ()) { Range rng = rhs.range_value (); octave_idx_type steps = rng.numel (); for (octave_idx_type i = 0; i < steps; i++) { octave_value val (rng.elem (i)); ult.assign (octave_value::op_asn_eq, val); if (loop_body) loop_body->accept (*this); if (quit_loop_now ()) break; } } else if (rhs.is_scalar_type ()) { ult.assign (octave_value::op_asn_eq, rhs); if (loop_body) loop_body->accept (*this); // Maybe decrement break and continue states. quit_loop_now (); } else if (rhs.is_matrix_type () || rhs.is_cell () || rhs.is_string () || rhs.is_map ()) { // A matrix or cell is reshaped to 2 dimensions and iterated by // columns. dim_vector dv = rhs.dims ().redim (2); octave_idx_type nrows = dv(0); octave_idx_type steps = dv(1); if (steps > 0) { octave_value arg = rhs; if (rhs.ndims () > 2) arg = arg.reshape (dv); // for row vectors, use single index to speed things up. octave_value_list idx; octave_idx_type iidx; if (nrows == 1) { idx.resize (1); iidx = 0; } else { idx.resize (2); idx(0) = octave_value::magic_colon_t; iidx = 1; } for (octave_idx_type i = 1; i <= steps; i++) { // do_index_op expects one-based indices. idx(iidx) = i; octave_value val = arg.do_index_op (idx); ult.assign (octave_value::op_asn_eq, val); if (loop_body) loop_body->accept (*this); if (quit_loop_now ()) break; } } } else error ("invalid type in for loop expression near line %d, column %d", cmd.line (), cmd.column ()); } void tree_evaluator::visit_complex_for_command (tree_complex_for_command& cmd) { if (debug_mode) do_breakpoint (cmd.is_breakpoint (true)); unwind_protect frame; frame.protect_var (in_loop_command); in_loop_command = true; tree_expression *expr = cmd.control_expr (); octave_value rhs = expr->rvalue1 (); if (rhs.is_undefined ()) return; if (! rhs.is_map ()) error ("in statement 'for [X, Y] = VAL', VAL must be a structure"); // Cycle through structure elements. First element of id_list // is set to value and the second is set to the name of the // structure element. tree_argument_list *lhs = cmd.left_hand_side (); tree_argument_list::iterator p = lhs->begin (); tree_expression *elt = *p++; octave_lvalue val_ref = elt->lvalue (); elt = *p; octave_lvalue key_ref = elt->lvalue (); const octave_map tmp_val = rhs.map_value (); tree_statement_list *loop_body = cmd.body (); string_vector keys = tmp_val.keys (); octave_idx_type nel = keys.numel (); for (octave_idx_type i = 0; i < nel; i++) { std::string key = keys[i]; const Cell val_lst = tmp_val.contents (key); octave_idx_type n = val_lst.numel (); octave_value val = (n == 1) ? val_lst(0) : octave_value (val_lst); val_ref.assign (octave_value::op_asn_eq, val); key_ref.assign (octave_value::op_asn_eq, key); if (loop_body) loop_body->accept (*this); if (quit_loop_now ()) break; } } void tree_evaluator::visit_octave_user_script (octave_user_script&) { panic_impossible (); } void tree_evaluator::visit_octave_user_function (octave_user_function&) { panic_impossible (); } void tree_evaluator::visit_octave_user_function_header (octave_user_function&) { panic_impossible (); } void tree_evaluator::visit_octave_user_function_trailer (octave_user_function&) { panic_impossible (); } void tree_evaluator::visit_function_def (tree_function_def& cmd) { octave_value fcn = cmd.function (); octave_function *f = fcn.function_value (); if (f) { std::string nm = f->name (); symbol_table::install_cmdline_function (nm, fcn); // Make sure that any variable with the same name as the new // function is cleared. symbol_table::assign (nm); } } void tree_evaluator::visit_identifier (tree_identifier&) { panic_impossible (); } void tree_evaluator::visit_if_clause (tree_if_clause&) { panic_impossible (); } void tree_evaluator::visit_if_command (tree_if_command& cmd) { tree_if_command_list *lst = cmd.cmd_list (); if (lst) lst->accept (*this); } void tree_evaluator::visit_if_command_list (tree_if_command_list& lst) { for (tree_if_command_list::iterator p = lst.begin (); p != lst.end (); p++) { tree_if_clause *tic = *p; tree_expression *expr = tic->condition (); if (statement_context == function || statement_context == script) octave_call_stack::set_location (tic->line (), tic->column ()); if (debug_mode && ! tic->is_else_clause ()) do_breakpoint (tic->is_breakpoint (true)); if (tic->is_else_clause () || expr->is_logically_true ("if")) { tree_statement_list *stmt_lst = tic->commands (); if (stmt_lst) stmt_lst->accept (*this); break; } } } void tree_evaluator::visit_index_expression (tree_index_expression&) { panic_impossible (); } void tree_evaluator::visit_matrix (tree_matrix&) { panic_impossible (); } void tree_evaluator::visit_cell (tree_cell&) { panic_impossible (); } void tree_evaluator::visit_multi_assignment (tree_multi_assignment&) { panic_impossible (); } void tree_evaluator::visit_no_op_command (tree_no_op_command& cmd) { if (debug_mode && cmd.is_end_of_fcn_or_script ()) do_breakpoint (cmd.is_breakpoint (true), true); } void tree_evaluator::visit_constant (tree_constant&) { panic_impossible (); } void tree_evaluator::visit_fcn_handle (tree_fcn_handle&) { panic_impossible (); } void tree_evaluator::visit_funcall (tree_funcall&) { panic_impossible (); } void tree_evaluator::visit_parameter_list (tree_parameter_list&) { panic_impossible (); } void tree_evaluator::visit_postfix_expression (tree_postfix_expression&) { panic_impossible (); } void tree_evaluator::visit_prefix_expression (tree_prefix_expression&) { panic_impossible (); } void tree_evaluator::visit_return_command (tree_return_command& cmd) { if (debug_mode) do_breakpoint (cmd.is_breakpoint (true)); // Act like dbcont. if (Vdebugging && octave_call_stack::current_frame () == current_frame) { Vdebugging = false; reset_debug_state (); } else if (statement_context == function || statement_context == script || in_loop_command) tree_return_command::returning = 1; } void tree_evaluator::visit_return_list (tree_return_list&) { panic_impossible (); } void tree_evaluator::visit_simple_assignment (tree_simple_assignment&) { panic_impossible (); } void tree_evaluator::visit_statement (tree_statement& stmt) { tree_command *cmd = stmt.command (); tree_expression *expr = stmt.expression (); if (cmd || expr) { if (statement_context == function || statement_context == script) { // Skip commands issued at a debug> prompt to avoid disturbing // the state of the program we are debugging. if (! Vdebugging) octave_call_stack::set_location (stmt.line (), stmt.column ()); if ((statement_context == script && ((Vecho_executing_commands & ECHO_SCRIPTS && octave_call_stack::all_scripts ()) || Vecho_executing_commands & ECHO_FUNCTIONS)) || (statement_context == function && Vecho_executing_commands & ECHO_FUNCTIONS)) stmt.echo_code (); } try { if (cmd) cmd->accept (*this); else { if (debug_mode) do_breakpoint (expr->is_breakpoint (true)); // FIXME: maybe all of this should be packaged in // one virtual function that returns a flag saying whether // or not the expression will take care of binding ans and // printing the result. // FIXME: it seems that we should just have to // call expr->rvalue1 () and that should take care of // everything, binding ans as necessary? bool do_bind_ans = false; if (expr->is_identifier ()) { tree_identifier *id = dynamic_cast<tree_identifier *> (expr); do_bind_ans = (! id->is_variable ()); } else do_bind_ans = (! expr->is_assignment_expression ()); octave_value tmp_result = expr->rvalue1 (0); if (do_bind_ans && tmp_result.is_defined ()) bind_ans (tmp_result, expr->print_result () && statement_printing_enabled ()); // if (tmp_result.is_defined ()) // result_values(0) = tmp_result; } } catch (const std::bad_alloc&) { // FIXME: We want to use error_with_id here so that give users // control over this error message but error_with_id will // require some memory allocations. Is there anything we can // do to make those more likely to succeed? error_with_id ("Octave:bad-alloc", "out of memory or dimension too large for Octave's index type"); } } } void tree_evaluator::visit_statement_list (tree_statement_list& lst) { // FIXME: commented out along with else clause below. // static octave_value_list empty_list; tree_statement_list::iterator p = lst.begin (); if (p != lst.end ()) { while (true) { tree_statement *elt = *p++; if (! elt) error ("invalid statement found in statement list!"); octave_quit (); elt->accept (*this); if (tree_break_command::breaking || tree_continue_command::continuing) break; if (tree_return_command::returning) break; if (p == lst.end ()) break; else { // Clear previous values before next statement is // evaluated so that we aren't holding an extra // reference to a value that may be used next. For // example, in code like this: // // X = rand (N); # refcount for X should be 1 // # after this statement // // X(idx) = val; # no extra copy of X should be // # needed, but we will be faked // # out if retval is not cleared // # between statements here // result_values = empty_list; } } } } void tree_evaluator::visit_switch_case (tree_switch_case&) { panic_impossible (); } void tree_evaluator::visit_switch_case_list (tree_switch_case_list&) { panic_impossible (); } void tree_evaluator::visit_switch_command (tree_switch_command& cmd) { if (debug_mode) do_breakpoint (cmd.is_breakpoint (true)); tree_expression *expr = cmd.switch_value (); if (! expr) error ("missing value in switch command near line %d, column %d", cmd.line (), cmd.column ()); octave_value val = expr->rvalue1 (); tree_switch_case_list *lst = cmd.case_list (); if (lst) { for (tree_switch_case_list::iterator p = lst->begin (); p != lst->end (); p++) { tree_switch_case *t = *p; if (t->is_default_case () || t->label_matches (val)) { tree_statement_list *stmt_lst = t->commands (); if (stmt_lst) stmt_lst->accept (*this); break; } } } } void tree_evaluator::visit_try_catch_command (tree_try_catch_command& cmd) { unwind_protect frame; frame.protect_var (buffer_error_messages); frame.protect_var (Vdebug_on_error); frame.protect_var (Vdebug_on_warning); buffer_error_messages++; Vdebug_on_error = false; Vdebug_on_warning = false; tree_statement_list *catch_code = cmd.cleanup (); // The catch code is *not* added to unwind_protect stack; it doesn't need // to be run on interrupts. tree_statement_list *try_code = cmd.body (); bool execution_error = false; if (try_code) { try { in_try_catch++; try_code->accept (*this); in_try_catch--; } catch (const octave_execution_exception&) { recover_from_exception (); in_try_catch--; // must be restored before "catch" block execution_error = true; } } if (execution_error) { if (catch_code) { // Set up for letting the user print any messages from errors that // occurred in the body of the try_catch statement. buffer_error_messages--; tree_identifier *expr_id = cmd.identifier (); octave_lvalue ult; if (expr_id) { ult = expr_id->lvalue (); octave_scalar_map err; err.assign ("message", last_error_message ()); err.assign ("identifier", last_error_id ()); err.assign ("stack", last_error_stack ()); ult.assign (octave_value::op_asn_eq, err); } // perform actual "catch" block if (catch_code) catch_code->accept (*this); } } } void tree_evaluator::do_unwind_protect_cleanup_code (tree_statement_list *list) { unwind_protect frame; frame.protect_var (octave_interrupt_state); octave_interrupt_state = 0; // We want to preserve the last location info for possible // backtracking. frame.add_fcn (octave_call_stack::set_line, octave_call_stack::current_line ()); frame.add_fcn (octave_call_stack::set_column, octave_call_stack::current_column ()); // Similarly, if we have seen a return or break statement, allow all // the cleanup code to run before returning or handling the break. // We don't have to worry about continue statements because they can // only occur in loops. frame.protect_var (tree_return_command::returning); tree_return_command::returning = 0; frame.protect_var (tree_break_command::breaking); tree_break_command::breaking = 0; try { if (list) list->accept (*this); } catch (const octave_execution_exception&) { recover_from_exception (); if (tree_break_command::breaking || tree_return_command::returning) frame.discard (2); else frame.run (2); frame.discard (2); throw; } // The unwind_protects are popped off the stack in the reverse of // the order they are pushed on. // FIXME: these statements say that if we see a break or // return statement in the cleanup block, that we want to use the // new value of the breaking or returning flag instead of restoring // the previous value. Is that the right thing to do? I think so. // Consider the case of // // function foo () // unwind_protect // fprintf (stderr, "1: this should always be executed\n"); // break; // fprintf (stderr, "1: this should never be executed\n"); // unwind_protect_cleanup // fprintf (stderr, "2: this should always be executed\n"); // return; // fprintf (stderr, "2: this should never be executed\n"); // end_unwind_protect // endfunction // // If we reset the value of the breaking flag, both the returning // flag and the breaking flag will be set, and we shouldn't have // both. So, use the most recent one. If there is no return or // break in the cleanup block, the values should be reset to // whatever they were when the cleanup block was entered. if (tree_break_command::breaking || tree_return_command::returning) frame.discard (2); else frame.run (2); } void tree_evaluator::visit_unwind_protect_command (tree_unwind_protect_command& cmd) { tree_statement_list *cleanup_code = cmd.cleanup (); tree_statement_list *unwind_protect_code = cmd.body (); if (unwind_protect_code) { try { unwind_protect_code->accept (*this); } catch (const octave_execution_exception&) { // FIXME: Maybe we should be able to temporarily set the // interpreter's exception handling state to something "safe" // while the cleanup block runs instead of just resetting it // here? recover_from_exception (); // Run the cleanup code on exceptions, so that it is run even // in case of interrupt or out-of-memory. do_unwind_protect_cleanup_code (cleanup_code); // If an error occurs inside the cleanup code, a new // exception will be thrown instead of the original. throw; } // Also execute the unwind_protect_cleanump code if the // unwind_protect block runs without error. do_unwind_protect_cleanup_code (cleanup_code); } } void tree_evaluator::visit_while_command (tree_while_command& cmd) { #if defined (HAVE_LLVM) if (tree_jit::execute (cmd)) return; #endif unwind_protect frame; frame.protect_var (in_loop_command); in_loop_command = true; tree_expression *expr = cmd.condition (); if (! expr) panic_impossible (); for (;;) { if (debug_mode) do_breakpoint (cmd.is_breakpoint (true)); if (expr->is_logically_true ("while")) { tree_statement_list *loop_body = cmd.body (); if (loop_body) loop_body->accept (*this); if (quit_loop_now ()) break; } else break; } } void tree_evaluator::visit_do_until_command (tree_do_until_command& cmd) { #if defined (HAVE_LLVM) if (tree_jit::execute (cmd)) return; #endif unwind_protect frame; frame.protect_var (in_loop_command); in_loop_command = true; tree_expression *expr = cmd.condition (); if (! expr) panic_impossible (); for (;;) { tree_statement_list *loop_body = cmd.body (); if (loop_body) loop_body->accept (*this); if (quit_loop_now ()) break; if (debug_mode) do_breakpoint (cmd.is_breakpoint (true)); if (expr->is_logically_true ("do-until")) break; } } void tree_evaluator::do_breakpoint (tree_statement& stmt) const { do_breakpoint (stmt.is_breakpoint (true), stmt.is_end_of_fcn_or_script ()); } void tree_evaluator::do_breakpoint (bool is_breakpoint, bool is_end_of_fcn_or_script) const { bool break_on_this_statement = false; if (octave_debug_on_interrupt_state) { break_on_this_statement = true; octave_debug_on_interrupt_state = false; current_frame = octave_call_stack::current_frame (); } else if (is_breakpoint) { break_on_this_statement = true; dbstep_flag = 0; current_frame = octave_call_stack::current_frame (); } else if (dbstep_flag > 0) { if (octave_call_stack::current_frame () == current_frame) { if (dbstep_flag == 1 || is_end_of_fcn_or_script) { // We get here if we are doing a "dbstep" or a "dbstep N" and the // count has reached 1 so that we must stop and return to debug // prompt. Alternatively, "dbstep N" has been used but the end // of the frame has been reached so we stop at the last line and // return to prompt. break_on_this_statement = true; dbstep_flag = 0; } else { // Executing "dbstep N". Decrease N by one and continue. dbstep_flag--; } } else if (dbstep_flag == 1 && octave_call_stack::current_frame () < current_frame) { // We stepped out from the end of a function. current_frame = octave_call_stack::current_frame (); break_on_this_statement = true; dbstep_flag = 0; } } else if (dbstep_flag == -1) { // We get here if we are doing a "dbstep in". break_on_this_statement = true; dbstep_flag = 0; current_frame = octave_call_stack::current_frame (); } else if (dbstep_flag == -2) { // We get here if we are doing a "dbstep out". Check for end of // function and whether the current frame is the same as the // cached value because we want to step out from the frame where // "dbstep out" was evaluated, not from any functions called from // that frame. if (is_end_of_fcn_or_script && octave_call_stack::current_frame () == current_frame) dbstep_flag = -1; } if (break_on_this_statement) do_keyboard (); } // ARGS is currently unused, but since the do_keyboard function in // input.cc accepts an argument list, we preserve it here so that the // interface won't have to change if we decide to use it in the future. octave_value tree_evaluator::do_keyboard (const octave_value_list& args) const { return ::do_keyboard (args); } DEFUN (max_recursion_depth, args, nargout, "-*- texinfo -*-\n\ @deftypefn {} {@var{val} =} max_recursion_depth ()\n\ @deftypefnx {} {@var{old_val} =} max_recursion_depth (@var{new_val})\n\ @deftypefnx {} {} max_recursion_depth (@var{new_val}, \"local\")\n\ Query or set the internal limit on the number of times a function may\n\ be called recursively.\n\ \n\ If the limit is exceeded, an error message is printed and control returns to\n\ the top level.\n\ \n\ When called from inside a function with the @qcode{\"local\"} option, the\n\ variable is changed locally for the function and any subroutines it calls.\n\ The original variable value is restored when exiting the function.\n\ @end deftypefn") { return SET_INTERNAL_VARIABLE (max_recursion_depth); } /* %!test %! orig_val = max_recursion_depth (); %! old_val = max_recursion_depth (2*orig_val); %! assert (orig_val, old_val); %! assert (max_recursion_depth (), 2*orig_val); %! max_recursion_depth (orig_val); %! assert (max_recursion_depth (), orig_val); %!error (max_recursion_depth (1, 2)) */ DEFUN (silent_functions, args, nargout, "-*- texinfo -*-\n\ @deftypefn {} {@var{val} =} silent_functions ()\n\ @deftypefnx {} {@var{old_val} =} silent_functions (@var{new_val})\n\ @deftypefnx {} {} silent_functions (@var{new_val}, \"local\")\n\ Query or set the internal variable that controls whether internal\n\ output from a function is suppressed.\n\ \n\ If this option is disabled, Octave will display the results produced by\n\ evaluating expressions within a function body that are not terminated with\n\ a semicolon.\n\ \n\ When called from inside a function with the @qcode{\"local\"} option, the\n\ variable is changed locally for the function and any subroutines it calls.\n\ The original variable value is restored when exiting the function.\n\ @end deftypefn") { return SET_INTERNAL_VARIABLE (silent_functions); } /* %!test %! orig_val = silent_functions (); %! old_val = silent_functions (! orig_val); %! assert (orig_val, old_val); %! assert (silent_functions (), ! orig_val); %! silent_functions (orig_val); %! assert (silent_functions (), orig_val); %!error (silent_functions (1, 2)) */