23 #if defined (HAVE_CONFIG_H) 107 new_scope = af_scope.
dup ();
109 if (new_scope && af_parent_scope)
110 new_scope.
inherit (af_parent_scope);
113 = param_list ? param_list->
dup (new_scope) :
nullptr;
180 if (
a.ndims () == 2 &&
a.rows () == 1 &&
a.columns () == 1)
184 bool a_true =
a.is_true ();
222 if (
a.is_defined () && op_rhs)
265 bool a_true =
a.is_true ();
314 if (
a.is_defined () && op_rhs)
348 error (
"break must appear in a loop in the same file as loop command");
359 if (! op_base || ! op_limit)
380 tmp1(1) = ov_increment;
394 error (
"can not find overloaded colon function");
405 ov_increment =
evaluate (op_increment);
453 const std::list<octave_lvalue> *lvalues =
lvalue_list ();
460 for (
const auto& lval : *lvalues)
461 nbh += lval.is_black_hole ();
470 for (
const auto& lval : *lvalues)
472 if (lval.is_black_hole ())
485 const std::list<octave_lvalue> *lvalues =
lvalue_list ();
492 for (
const auto& lval : *lvalues)
495 return ! lval.is_black_hole ();
510 const std::list<octave_lvalue> *lvalues =
lvalue_list ();
515 for (
const auto& lval : *lvalues)
517 if (lval.is_black_hole ())
529 for (
int i = 0;
i < nout;
i++)
560 if (args(
i).is_defined () && args(
i).is_magic_colon ())
562 if (! eval_decl_elt (elt))
563 error (
"no default value for argument %d",
i+1);
589 int len = ret_list->
length ();
665 if (label_value.
iscell ())
673 bool match =
val.is_equal (cell(
i,j));
681 return val.is_equal (label_value);
711 init_list->
accept (*
this);
748 bool local_val_is_defined =
val.is_defined ();
750 if (local_val_is_defined)
753 "global: '%s' is defined in the current scope.\n",
756 "global: in a future version, global variables must be declared before use.\n");
767 "global: global value overrides existing local value");
772 "global: existing local value used to initialize global variable");
778 id->link_to_global (global_scope, global_sr);
782 id->mark_persistent ();
784 error (
"declaration list element not global or persistent");
852 #if defined (HAVE_LLVM) 882 loop_body->
accept (*
this);
896 loop_body->
accept (*
this);
913 if (rhs.
ndims () > 2)
916 if (nrows > 0 && steps > 0)
946 loop_body->
accept (*
this);
959 error (
"invalid type in for loop expression near line %d, column %d",
991 error (
"in statement 'for [X, Y] = VAL', VAL must be a structure");
1034 loop_body->
accept (*
this);
1105 if (
val.is_defined ())
1120 if (
val.is_function ())
1121 fcn =
val.function_value (
true);
1137 feval (
"display", args);
1192 stmt_lst->
accept (*
this);
1234 extra_message =
" (note: variable '" +
var +
"' shadows function)";
1322 std::list<tree_argument_list *> args = idx_expr.
arg_lists ();
1323 std::list<string_vector> arg_nm = idx_expr.
arg_names ();
1324 std::list<tree_expression *> dyn_field = idx_expr.
dyn_fields ();
1326 assert (! args.empty ());
1328 std::list<tree_argument_list *>::iterator p_args = args.begin ();
1329 std::list<string_vector>::iterator p_arg_nm = arg_nm.begin ();
1330 std::list<tree_expression *>::iterator p_dyn_field = dyn_field.begin ();
1332 int n = args.size ();
1353 if (al && al->
length () > 0)
1363 &
value_stack<
const std::list<octave_lvalue>*>::pop);
1374 if (
val.is_function ())
1375 fcn =
val.function_value (
true);
1399 error (
"indexing undefined value");
1401 base_expr_val =
retval(0);
1427 bool indexing_object = (base_expr_val.
isobject ()
1428 || base_expr_val.
isjava ()
1432 std::list<octave_value_list> idx;
1436 for (
int i = beg;
i < n;
i++)
1458 if (! indexing_object)
1460 base_expr_val = partial_expr_val;
1465 retval = partial_expr_val;
1471 || partial_expr_val.
isjava ()
1486 indexing_object =
true;
1500 idx.push_back (
make_value_list (*p_args, *p_arg_nm, &partial_expr_val));
1504 idx.push_back (
make_value_list (*p_args, *p_arg_nm, &partial_expr_val));
1570 if (
val.is_function ())
1581 error (
"unexpected extra index at end of expression");
1583 if (
type[beg] !=
'(')
1584 error (
"invalid index type '%c' for function call",
1587 final_args = idx.front ();
1602 bool all_strings_p =
false;
1603 bool all_sq_strings_p =
false;
1604 bool all_dq_strings_p =
false;
1605 bool all_empty_p =
false;
1606 bool all_real_p =
false;
1607 bool any_sparse_p =
false;
1608 bool any_class_p =
false;
1609 bool frc_str_conv =
false;
1613 if (
tmp && !
tmp.empty ())
1616 all_strings_p =
tmp.all_strings_p ();
1617 all_sq_strings_p =
tmp.all_sq_strings_p ();
1618 all_dq_strings_p =
tmp.all_dq_strings_p ();
1619 all_empty_p =
tmp.all_empty_p ();
1620 all_real_p =
tmp.all_real_p ();
1621 any_sparse_p =
tmp.any_sparse_p ();
1622 any_class_p =
tmp.any_class_p ();
1623 frc_str_conv =
tmp.some_strings_p ();
1638 retval = do_single_type_concat<SparseMatrix> (
dv,
tmp);
1640 retval = do_single_type_concat<SparseComplexMatrix> (
dv,
tmp);
1645 retval = do_single_type_concat<NDArray> (
dv,
tmp);
1647 retval = do_single_type_concat<ComplexNDArray> (
dv,
tmp);
1653 retval = do_single_type_concat<FloatNDArray> (
dv,
tmp);
1655 retval = do_single_type_concat<FloatComplexNDArray> (
dv,
tmp);
1659 char type = (all_dq_strings_p ?
'"' :
'\'');
1661 if (! all_strings_p)
1669 single_type_concat<charNDArray> (
result,
tmp);
1676 retval = do_single_type_concat<SparseBoolMatrix> (
dv,
tmp);
1678 retval = do_single_type_concat<boolNDArray> (
dv,
tmp);
1681 retval = do_single_type_concat<int8NDArray> (
dv,
tmp);
1683 retval = do_single_type_concat<int16NDArray> (
dv,
tmp);
1685 retval = do_single_type_concat<int32NDArray> (
dv,
tmp);
1687 retval = do_single_type_concat<int64NDArray> (
dv,
tmp);
1689 retval = do_single_type_concat<uint8NDArray> (
dv,
tmp);
1691 retval = do_single_type_concat<uint16NDArray> (
dv,
tmp);
1693 retval = do_single_type_concat<uint32NDArray> (
dv,
tmp);
1695 retval = do_single_type_concat<uint64NDArray> (
dv,
tmp);
1738 for (
auto& elt :
row)
1745 goto found_non_empty;
1749 ctmp = (*(
tmp.begin () -> begin ()));
1770 for (
auto& elt :
row)
1809 &
value_stack<
const std::list<octave_lvalue>*>::pop);
1840 error (
"number of columns must match");
1876 &
value_stack<
const std::list<octave_lvalue>*>::pop);
1881 n_out += lval.numel ();
1886 && rhs_val1(0).is_cs_list ()
1887 ? rhs_val1(0).list_value ()
1896 std::list<octave_value_list> retval_list;
1918 && ! ult.is_black_hole () && ult.is_undefined ()
1919 && ult.index_type () ==
"{" && ult.index_is_empty ())
1927 ult.define (
Cell (1, 1));
1930 std::list<octave_value_list> idx;
1932 ult.set_index (
"{", idx);
1936 error (
"some elements undefined in return list");
1946 retval_list.push_back (
ovl);
1954 if (ult.is_black_hole ())
1963 if (
tmp.is_undefined ())
1964 error (
"element number %d undefined in return list",
1969 retval_list.push_back (
tmp);
1991 if (! ult.is_black_hole ())
1992 error (
"element number %d undefined in return list",
k+1);
2012 feval (
"display", args);
2043 error (
"invalid number of output arguments for constant expression");
2227 error (
"value on right hand side of assignment is undefined");
2234 error (
"invalid number of elements on RHS of assignment");
2253 &
value_stack<
const std::list<octave_lvalue>*>::pop);
2255 if (ult.
numel () != 1)
2260 ult.
assign (etype, rhs_val);
2281 feval (
"display", args);
2286 e.set_var (lhs->
name ());
2339 if (tmp_result.is_defined ())
2341 bool do_bind_ans =
false;
2353 do_bind_ans = (!
id->is_variable (
context));
2364 catch (
const std::bad_alloc&)
2372 "out of memory or dimension too large for Octave's index type");
2374 catch (
const octave::interrupt_exception&)
2395 if (
p != lst.
end ())
2402 error (
"invalid statement found in statement list!");
2415 if (
p == lst.
end ())
2466 error (
"missing value in switch command near line %d, column %d",
2482 stmt_lst->
accept (*
this);
2500 bool execution_error =
false;
2524 try_code->
accept (*
this);
2532 execution_error =
true;
2540 if (execution_error)
2562 catch_code->
accept (*
this);
2597 list->accept (*
this);
2660 if (unwind_protect_code)
2664 unwind_protect_code->
accept (*
this);
2682 catch (
const interrupt_exception&)
2707 #if defined (HAVE_LLVM) 2736 loop_body->
accept (*
this);
2757 #if defined (HAVE_LLVM) 2769 int until_line = cmd.
line ();
2770 int until_column = cmd.
column ();
2783 loop_body->
accept (*
this);
2802 if (
val.is_defined ())
2804 if (
val.is_cs_list ())
2821 feval (
"display", args);
2835 bool is_end_of_fcn_or_script)
const 2837 bool break_on_this_statement =
false;
2841 break_on_this_statement =
true;
2847 else if (is_breakpoint)
2849 break_on_this_statement =
true;
2867 break_on_this_statement =
true;
2886 break_on_this_statement =
true;
2895 break_on_this_statement =
true;
2909 if (is_end_of_fcn_or_script
2914 if (break_on_this_statement)
2931 const char *warn_for)
2933 bool expr_value =
false;
2940 error (
"%s: undefined value used in conditional expression", warn_for);
2962 &
value_stack<
const std::list<octave_lvalue>*>::pop);
2965 &&
object->is_undefined ())
2974 retval.stash_name_tags (arg_nm);
2979 std::list<octave_lvalue>
2982 std::list<octave_lvalue>
retval;
2985 retval.push_back (elt->lvalue (
this));
2995 "max_recursion_depth", 0);
3002 "silent_functions");
3009 "string_fill_char");
3114 else if (arg0 ==
"off")
3122 error (
"echo: no such file %s", arg0.c_str ());
3149 p->second = !
p->second;
3161 if (arg1 ==
"on" || arg1 ==
"off")
3177 error (
"echo: no such file %s", arg1.c_str ());
3183 else if (arg0 ==
"off")
3196 error (
"echo: no such file %s", arg1.c_str ());
3268 std::deque<std::string> lines
3271 for (
auto& elt : lines)
OCTINTERP_API octave_value_list feval(const std::string &name, const octave_value_list &args=octave_value_list(), int nargout=0)
virtual int line(void) const
tree_expression * right_hand_side(void)
void warning_with_id(const char *id, const char *fmt,...)
virtual std::string name(void) const
static void final_index_error(octave::index_exception &e, const octave::tree_expression *expr)
symbol_record symbol(void) const
void set_echo_state(int type, const std::string &file_name, size_t pos)
octave_value find_function(const std::string &name, const octave_value_list &args=octave_value_list(), bool local_funcs=true)
void visit_funcall(tree_funcall &)
void do_unary_op(octave_value::unary_op op)
void undefine_parameter_list(tree_parameter_list *param_list)
virtual bool is_user_function(void) const
std::string PS4(void) const
octave_value::unary_op op_type(void) const
For example cd octave end example noindent changes the current working directory to file
void visit_argument_list(tree_argument_list &)
tree_parameter_list * dup(symbol_scope &scope) const
bool maybe_push_echo_state_cleanup(void)
#define DEFMETHOD(name, interp_name, args_name, nargout_name, doc)
Macro to define a builtin method.
Range range_value(void) const
virtual octave_value_list call(octave::tree_evaluator &tw, int nargout=0, const octave_value_list &args=octave_value_list())=0
octave_value::binary_op op_type(void) const
void assign(const std::string &name, const octave_value &value, bool force_add)
virtual octave_value do_keyboard(const octave_value_list &args=octave_value_list()) const
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx)
bool is_persistent(void) const
static std::string decode_prompt_string(const std::string &s)
void eval_undefined_error(void)
octave_value_list arguments(void) const
tree_statement_list * cleanup(void)
const octave_base_value const Array< octave_idx_type > & ra_idx
virtual int column(void) const
void set_location(int l, int c)
string_vector keys(void) const
The value of lines which begin with a space character are not saved in the history list A value of all commands are saved on the history list
bool is_end_of_fcn_or_script(void) const
void push_echo_state(unwind_protect &frame, int type, const std::string &file_name, size_t pos=1)
void inherit(const symbol_scope &donor_scope)
static void recover_from_exception(void)
void visit_parameter_list(tree_parameter_list &)
void visit_octave_user_script(octave_user_script &)
void visit_octave_user_function_header(octave_user_function &)
bool is_eligible_for_braindead_shortcircuit(void) const
symbol_scope global_scope(void)
octave_map map_value(void) const
bool is_undefined(void) const
OCTINTERP_API void print_usage(void)
void define(const octave_value &v)
virtual bool is_user_code(void) const
tree_expression * base(void)
octave_value_list slice(octave_idx_type offset, octave_idx_type len, bool tags=false) const
void set_echo_file_pos(const size_t &file_pos)
void visit_if_command_list(tree_if_command_list &)
bool isargout(int nargout, int iout) const
octave_value find(context_id context, const octave_value_list &args=octave_value_list()) const
identity matrix If supplied two scalar respectively For allows like xample val
F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE * f
static bool in_loop_command
interpreter & m_interpreter
symbol_scope scope(void) const
value_stack< const std::list< octave_lvalue > * > m_lvalue_list_stack
OCTINTERP_API std::string fcn_file_in_path(const std::string &)
symbol_scope current_scope(void)
symbol_record find_symbol(const std::string &name)
void visit_decl_command(tree_decl_command &)
void push_result(const octave_value &val)
bool all_zero_dims(void) const
bool eval_decl_elt(tree_decl_elt *elt)
bool is_cs_list(void) const
symbol_scope dup(void) const
void do_breakpoint(tree_statement &stmt) const
virtual void accept(tree_walker &tw)=0
size_t length(void) const
void error(const char *fmt,...)
static void reset_debug_state(void)
void accept(tree_walker &tw)
void visit_try_catch_command(tree_try_catch_command &)
void visit_boolean_expression(tree_boolean_expression &)
octave_lvalue lvalue(tree_evaluator *)
tree_decl_init_list * initializer_list(void)
void visit_constant(tree_constant &)
tree_statement_list * body(void)
bool is_breakpoint(bool check_active=false) const
void visit_simple_assignment(tree_simple_assignment &)
bool is_breakpoint(bool check_valid=false) const
std::list< tree_expression * >::iterator iterator
bool is_defined(void) const
static llvm::LLVMContext & context
void visit_prefix_expression(tree_prefix_expression &)
OCTAVE_EXPORT octave_value_list return the number of command line arguments passed to Octave If called with the optional argument the function t
octave_value function(void)
std::list< string_vector > arg_names(void)
bool statement_printing_enabled(void)
char postfix_index(void) const
octave_value value(void) const
octave_value_list make_value_list(tree_argument_list *args, const string_vector &arg_nm, const octave_value *object, bool rvalue=true)
type_info & get_type_info(void)
void visit_statement(tree_statement &)
bool isobject(void) const
void stash_dir_name(const std::string &dir)
octave_value echo(const octave_value_list &args, int nargout)
virtual std::string fcn_file_name(void) const
bool is_global(void) const
octave_value_list evaluate_n(tree_expression *expr, int nargout=1)
static bool quiet_breakpoint_flag
Matrix ignored_fcn_outputs(void) const
void bind_ans(const octave_value &val, bool print)
octave_value & do_non_const_unary_op(unary_op op)
void matlab_style_short_circuit_warning(const char *op)
void visit_compound_binary_expression(tree_compound_binary_expression &)
void visit_return_command(tree_return_command &)
octave_value resize(const dim_vector &dv, bool fill=false) const
bool is_defined(void) const
calling an anonymous function involves an overhead quite comparable to the overhead of an m file function Passing a handle to a built in function is because the interpreter is not involved in the internal loop For a
void err_indexed_cs_list(void)
octave_value storable_value(void) const
static std::string make_absolute(const std::string &s, const std::string &dot_path=get_current_directory())
void accept(tree_walker &tw)
octave_value PS4(const octave_value_list &args, int nargout)
void visit_switch_command(tree_switch_command &)
symbol_table & __get_symbol_table__(const std::string &who)
int buffer_error_messages
nd deftypefn *std::string name
void visit_postfix_expression(tree_postfix_expression &)
OCTAVE_EXPORT octave_value_list isdir nd deftypefn *std::string nm
octave_value resize(const dim_vector &dv, bool=false) const
tree_expression * expression(void)
tree_parameter_list * parameter_list(void) const
std::string m_echo_file_name
void maybe_warn_string_concat(bool all_dq_strings_p, bool all_sq_strings_p)
octave_value do_unary_op(octave::type_info &ti, octave_value::unary_op op, const octave_value &v)
OCTAVE_EXPORT octave_value_list return the number of command line arguments passed to Octave If called with the optional argument the function xample nargout(@histc)
std::string dispatch_class(void) const
void visit_cell(tree_cell &)
void visit_identifier(tree_identifier &)
octave_function * caller(void) const
void assign(octave_value::assign_op, const octave_value &)
void visit_if_command(tree_if_command &)
void visit_fcn_handle(tree_fcn_handle &)
symbol_record::context_id current_context(void) const
octave_value_list convert_return_list_to_const_vector(tree_parameter_list *ret_list, int nargout, const Cell &varargout)
void error_with_id(const char *id, const char *fmt,...)
octave_value function(void) const
static size_t current_frame
OCTINTERP_API octave_value do_binary_op(octave::type_info &ti, octave_value::binary_op op, const octave_value &a, const octave_value &b)
bool have_breakpoints(void)
std::list< tree_argument_list * > arg_lists(void)
void visit_if_clause(tree_if_clause &)
void err_invalid_structure_assignment(void)
std::string type_tags(void)
tree_expression * control_expr(void)
tree_expression * control_expr(void)
dim_vector dims(void) const
std::map< std::string, bool > m_echo_files
OCTINTERP_API std::string last_error_id(void)
string_vector make_argv(const std::string &="") const
tree_statement_list * cleanup(void)
tree_expression * left_hand_side(void)
virtual bool is_class_method(const std::string &="") const
bool is_function(void) const
void accept(tree_walker &tw)
octave_idx_type numel(void) const
static bool is_variable(octave::symbol_table &symtab, const std::string &name)
octave_value do_single_type_concat< octave_map >(const dim_vector &dv, tm_const &tmp)
void maybe_set_echo_state(void)
#define panic_impossible()
void visit_binary_expression(tree_binary_expression &)
void set_echo_file_name(const std::string &file_name)
void do_unwind_protect_cleanup_code(tree_statement_list *list)
tree_expression * expression(void)
void visit_anon_fcn_handle(tree_anon_fcn_handle &)
void visit_octave_user_function_trailer(octave_user_function &)
octave_function * function_value(bool silent=false) const
tree_expression * clhs(void)
const Cell & contents(const_iterator p) const
sig_atomic_t octave_interrupt_state
void visit_break_command(tree_break_command &)
virtual bool accepts_postfix_index(char type) const
octave_value m_expr_result_value
double elem(octave_idx_type i) const
bool is_function(void) const
bool is_package(void) const
tree_expression * increment(void)
bool isstruct(void) const
bool octave_debug_on_interrupt_state
std::string dir_name(void) const
tree_command * command(void)
const std::list< octave_lvalue > * lvalue_list(void) const
dim_vector redim(int n) const
Force certain dimensionality, preserving numel ().
octave_idx_type get_count(void) const
end deftypefn *return set_internal_variable(Vsvd_driver, args, nargout, "svd_driver", driver_names)
void numel(octave_idx_type n)
octave_value convert_to_str(bool pad=false, bool force=false, char type='\'') const
octave_value varval(const std::string &name) const
void visit_switch_case_list(tree_switch_case_list &)
With real return the complex result
void visit_while_command(tree_while_command &)
bool is_added_static(void) const
virtual bool is_identifier(void) const
symbol_table & get_symbol_table(void)
octave_value::compound_binary_op cop_type(void) const
tree_expression * switch_value(void)
int m_max_recursion_depth
tree_expression * right_hand_side(void)
bool has_parent_scope(void) const
octave_function * current(void) const
void visit_decl_elt(tree_decl_elt &)
octave_value reshape(const dim_vector &dv) const
int max_recursion_depth(void) const
octave::unwind_protect frame
OCTINTERP_API std::string last_error_message(void)
void visit_complex_for_command(tree_complex_for_command &)
return octave_value(v1.char_array_value() . concat(v2.char_array_value(), ra_idx),((a1.is_sq_string()||a2.is_sq_string()) ? '\'' :'"'))
charNDArray max(char d, const charNDArray &m)
tree_statement_list * body(void)
tree_statement_list * body(void)
octave_value_list list_value(void) const
std::list< octave_lvalue > make_lvalue_list(tree_argument_list *)
OCTINTERP_API octave_map last_error_stack(void)
virtual octave_lvalue lvalue(tree_evaluator *)
void visit_simple_for_command(tree_simple_for_command &)
void visit_statement_list(tree_statement_list &)
tree_expression * rhs(void)
OCTINTERP_API octave_value do_cat_op(octave::type_info &ti, const octave_value &a, const octave_value &b, const Array< octave_idx_type > &ra_idx)
bool is_undefined(void) const
void push_echo_state_cleanup(unwind_protect &frame)
symbol_scope __require_current_scope__(const std::string &who)
OCTAVE_EXPORT octave_value_list isa nd deftypefn *return ovl(args(0).isinteger())
bool is_for_cmd_expr(void) const
octave_value do_class_concat(tm_const &tmc)
int current_line(void) const
tree_statement_list * body(void)
bp_table & __get_bp_table__(const std::string &who)
tree_expression * left_hand_side(void)
std::string name(void) const
result_type m_result_type
virtual bool is_class_constructor(const std::string &="") const
void force_assign(const std::string &name, const octave_value &value)
tree_expression * crhs(void)
void visit_function_def(tree_function_def &)
void visit_do_until_command(tree_do_until_command &)
static octave_value make_fcn_handle(octave_builtin::fcn ff, const std::string &nm)
void warn_implicit_conversion(const char *id, const char *from, const char *to)
tree_expression * expression(void) const
octave_idx_type length(void) const
bool is_logically_true(tree_expression *expr, const char *warn_for)
void stash_dispatch_class(const std::string &nm)
static octave_fcn_handle * maybe_binder(const octave_value &f, octave::tree_evaluator *tw)
void visit_decl_init_list(tree_decl_init_list &)
symbol_scope get_current_scope(void)
void define_parameter_list_from_arg_vector(tree_parameter_list *param_list, const octave_value_list &args)
tree_argument_list * left_hand_side(void)
void err_invalid_inquiry_subscript(void)
void static_workspace_error(void)
void resize(octave_idx_type n, const octave_value &rfv=octave_value())
void add_method(T *obj, void(T::*method)(void))
tree_expression * lhs(void)
tree_expression * case_label(void)
octave_value_list m_expr_result_value_list
void visit_continue_command(tree_continue_command &)
int current_column(void) const
std::string name(void) const
char string_fill_char(void) const
bool is_postfix_indexed(void) const
void mark_as_anonymous_function(void)
octave_value evaluate(tree_expression *expr, int nargout=1)
octave_value_list convert_to_const_vector(tree_evaluator *tw, const octave_value *object=nullptr)
octave_idx_type columns(void) const
static bool execute(tree_simple_for_command &cmd, const octave_value &bounds)
bool is_string(void) const
bool has_magic_end(void) const
value_stack< int > m_nargout_stack
OCTAVE_EXPORT octave_value_list error nd deftypefn *const octave_scalar_map err
static stmt_list_type statement_context
octave_idx_type ndims(void) const
Number of dimensions.
bool is_classdef_meta(void) const
bool echo_this_file(const std::string &file, int type) const
bool switch_case_label_matches(tree_switch_case *expr, const octave_value &val)
virtual octave_function * function_value(bool silent=false)
void visit_switch_case(tree_switch_case &)
bool is_range(void) const
tree_expression * operand(void)
octave_idx_type numel(void) const
Number of elements in the array.
octave_idx_type length(void) const
void visit_no_op_command(tree_no_op_command &)
void accept(tree_walker &tw)
tree_identifier * ident(void)
void install_cmdline_function(const std::string &name, const octave_value &fcn)
void echo_code(size_t line)
void set_parent(const symbol_scope &p)
void stash_parent_fcn_name(const std::string &p)
static bool quit_loop_now(void)
Vector representing the dimensions (size) of an Array.
bool silent_functions(void) const
void visit_return_list(tree_return_list &)
std::string name(void) const
void visit_octave_user_function(octave_user_function &)
tree_expression * condition(void)
virtual bool is_assignment_expression(void) const
bool is_global(const std::string &name) const
If this string is the system will ring the terminal sometimes it is useful to be able to print the original representation of the string
void visit_unwind_protect_command(tree_unwind_protect_command &)
void visit_colon_expression(tree_colon_expression &)
OCTINTERP_API octave_value do_colon_op(const octave_value &base, const octave_value &limit, bool is_for_cmd_expr=false)
void visit_index_expression(tree_index_expression &)
void visit_multi_assignment(tree_multi_assignment &)
bool is_scalar_type(void) const
Cell cell_value(void) const
virtual tree_expression * dup(symbol_scope &scope) const =0
bool is_end_of_fcn_or_script(void) const
tree_statement_list * body(void)
bool is_matrix_type(void) const
size_t current_frame(void) const
where the brackets indicate optional arguments and and character or cell array For character arrays the conversion is repeated for every row
tree_switch_case_list * case_list(void)
std::list< tree_expression * > dyn_fields(void)
charNDArray min(char d, const charNDArray &m)
octave_value::assign_op op_type(void) const
tree_argument_list * left_hand_side(void)
void visit_matrix(tree_matrix &)
tree_if_command_list * cmd_list(void)
std::string get_struct_index(tree_evaluator *tw, std::list< string_vector >::const_iterator p_arg_nm, std::list< tree_expression *>::const_iterator p_dyn_field) const
bool print_result(void) const
tree_identifier * identifier(void)
tree_expression * limit(void)
tree_expression * expression(void)
void stash_name_tags(const string_vector &nm)
octave_value do_index_op(const octave_value_list &idx, bool resize_ok=false)