Mercurial > octave-nkf

comparison libinterp/octave-value/ov.cc @ 20569:b70cc4bd8109

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
begin removal of global error_state variable * gripes.h, gripes.cc (gripe_library_execution_error): Delete. * error.cc (warning_state): Delete unused variable. (reset_error_handler): Don't set warning_state or error_state. (debug_or_throw_exception): New static function. (verror): Don't check error_state. (vmessage): Call debug_or_throw_exception instead of setting error_state. (error_1, error_2): Combine into single function, error_1 that prints error message and ultimately calls debug_or_throw_exception. (verror, verror_with_cfn, verror_with_id_cfn): Call error_1. Don't check or set warning_state. (error): Don't check error_state. (Flasterror, Flasterr): Adapt to not using error_state. (interpreter_try): Don't unwind_protect error_state. * NEWS: Update. * doc/interpreter/external.txi: Explain octave_execution_exception instead of error_state for matrix addition example. * jit-typeinfo.cc (octave_jit_gripe_nan_to_logical_conversion, octave_jit_ginvalid_index, octave_jit_gindex_range, octave_jit_paren_scalar, octave_jit_paren_scalar_subsasgn): Don't catch octave_execution_exception. * cellfun.cc (Fcellfun): Use exceptions instead of error_state. * ls-mat-ascii.cc (save_mat_ascii_data): Likewise. * mex.cc (mexCallMATLAB, mexEvalString): Likewise. * variables.cc (safe_symbol_lookup): Likewise. * svd.cc (Fsvd): Eliminate use of error_state. * __magick_read__.cc (read_file, write_file): Likewise. * variables.cc (generate_struct_completions): Eliminate use of obsolete warning_state variable. * ov-builtin.cc (octave_builtin::do_multi_index_op): Don't catch octave_execution_exception and call gripe_library_execution_error. * ov-class.cc (octave_class::reconstruct_exemplar): Eliminate use of error_state. Catch possible octave_execution_exception in do_multi_index_op. * ov-mex-fcn.cc (octave_mex_function::do_multi_index_op): Eliminate use of error_state. Catch possible octave_execution_exception in call_mex. * ov-fcn-handle.cc (octave_fcn_binder::maybe_binder): Eliminate use of error_state. * ov-oncleanup.cc (octave_oncleanup::~octave_oncleanup): Eliminate use of error_state. Propagate possible octave_execution_exception from do_multi_index_op. * ov.cc (octave_value::assign, do_binary_op, do_unary_op, octave_value::do_non_const_unary_op): Don't catch octave_execution_exception here. * oct-parse.in.yy (octave_base_parser::finish_colon_expression, octave_base_parser::finish_array_list): Eliminate use of warning_state and error_state. (Feval, Fevalin): Use exceptions instead of error_state. * pt-eval.cc, pt-eval.h (tree_evaluator::unwind_protect_exception): New static variable. * (tree_evaluator::visit_statement): Don't catch octave_execution_exception here. (tree_evaluator::visit_try_catch_command, tree_evaluator::do_unwind_protect_cleanup): Eliminate use of error_state. (tree_evaluator::visit_unwind_protect_command): Use unwind_protect_exception to track whether an exception has occurred in the try block.
author John W. Eaton <jwe@octave.org>
date Thu, 01 Oct 2015 16:18:19 -0400
parents a9574e3c6e9e
children 56fee8f84fe7
comparison
equal deleted inserted replaced
20568:fcb792acab9b 20569:b70cc4bd8109
1488 f = octave_value_typeinfo::lookup_assign_op (op, tthis, trhs); 1488 f = octave_value_typeinfo::lookup_assign_op (op, tthis, trhs);
1489 } 1489 }
1490 1490
1491 if (f) 1491 if (f)
1492 { 1492 {
1493 try 1493 f (*rep, octave_value_list (), *rhs.rep);
1494 { 1494 // Usually unnecessary, but may be needed (complex arrays).
1495 f (*rep, octave_value_list (), *rhs.rep); 1495 maybe_mutate ();
1496 // Usually unnecessary, but may be needed (complex arrays).
1497 maybe_mutate ();
1498 }
1499 catch (octave_execution_exception)
1500 {
1501 gripe_library_execution_error ();
1502 }
1503 } 1496 }
1504 else 1497 else
1505 { 1498 {
1506 1499
1507 binary_op binop = op_eq_to_binary_op (op); 1500 binary_op binop = op_eq_to_binary_op (op);
1991 octave_value_typeinfo::binary_class_op_fcn f 1984 octave_value_typeinfo::binary_class_op_fcn f
1992 = octave_value_typeinfo::lookup_binary_class_op (op); 1985 = octave_value_typeinfo::lookup_binary_class_op (op);
1993 1986
1994 if (f) 1987 if (f)
1995 { 1988 {
1996 try 1989 retval = f (v1, v2);
1997 {
1998 retval = f (v1, v2);
1999 }
2000 catch (octave_execution_exception)
2001 {
2002 gripe_library_execution_error ();
2003 }
2004 } 1990 }
2005 else 1991 else
2006 gripe_binary_op (octave_value::binary_op_as_string (op), 1992 gripe_binary_op (octave_value::binary_op_as_string (op),
2007 v1.class_name (), v2.class_name ()); 1993 v1.class_name (), v2.class_name ());
2008 } 1994 }
2013 1999
2014 octave_value_typeinfo::binary_op_fcn f 2000 octave_value_typeinfo::binary_op_fcn f
2015 = octave_value_typeinfo::lookup_binary_op (op, t1, t2); 2001 = octave_value_typeinfo::lookup_binary_op (op, t1, t2);
2016 2002
2017 if (f) 2003 if (f)
2018 { 2004 retval = f (*v1.rep, *v2.rep);
2019 try
2020 {
2021 retval = f (*v1.rep, *v2.rep);
2022 }
2023 catch (octave_execution_exception)
2024 {
2025 gripe_library_execution_error ();
2026 }
2027 }
2028 else 2005 else
2029 { 2006 {
2030 octave_value tv1; 2007 octave_value tv1;
2031 octave_base_value::type_conv_info cf1 = 2008 octave_base_value::type_conv_info cf1 =
2032 v1.numeric_conversion_function (); 2009 v1.numeric_conversion_function ();
2141 if (cf1 || cf2) 2118 if (cf1 || cf2)
2142 { 2119 {
2143 f = octave_value_typeinfo::lookup_binary_op (op, t1, t2); 2120 f = octave_value_typeinfo::lookup_binary_op (op, t1, t2);
2144 2121
2145 if (f) 2122 if (f)
2146 { 2123 retval = f (*tv1.rep, *tv2.rep);
2147 try
2148 {
2149 retval = f (*tv1.rep, *tv2.rep);
2150 }
2151 catch (octave_execution_exception)
2152 {
2153 gripe_library_execution_error ();
2154 }
2155 }
2156 else 2124 else
2157 gripe_binary_op (octave_value::binary_op_as_string (op), 2125 gripe_binary_op (octave_value::binary_op_as_string (op),
2158 v1.type_name (), v2.type_name ()); 2126 v1.type_name (), v2.type_name ());
2159 } 2127 }
2160 else 2128 else
2249 { 2217 {
2250 octave_value_typeinfo::binary_class_op_fcn f 2218 octave_value_typeinfo::binary_class_op_fcn f
2251 = octave_value_typeinfo::lookup_binary_class_op (op); 2219 = octave_value_typeinfo::lookup_binary_class_op (op);
2252 2220
2253 if (f) 2221 if (f)
2254 { 2222 retval = f (v1, v2);
2255 try
2256 {
2257 retval = f (v1, v2);
2258 }
2259 catch (octave_execution_exception)
2260 {
2261 gripe_library_execution_error ();
2262 }
2263 }
2264 else 2223 else
2265 retval = decompose_binary_op (op, v1, v2); 2224 retval = decompose_binary_op (op, v1, v2);
2266 } 2225 }
2267 else 2226 else
2268 { 2227 {
2269 octave_value_typeinfo::binary_op_fcn f 2228 octave_value_typeinfo::binary_op_fcn f
2270 = octave_value_typeinfo::lookup_binary_op (op, t1, t2); 2229 = octave_value_typeinfo::lookup_binary_op (op, t1, t2);
2271 2230
2272 if (f) 2231 if (f)
2273 { 2232 retval = f (*v1.rep, *v2.rep);
2274 try
2275 {
2276 retval = f (*v1.rep, *v2.rep);
2277 }
2278 catch (octave_execution_exception)
2279 {
2280 gripe_library_execution_error ();
2281 }
2282 }
2283 else 2233 else
2284 retval = decompose_binary_op (op, v1, v2); 2234 retval = decompose_binary_op (op, v1, v2);
2285 } 2235 }
2286 2236
2287 return retval; 2237 return retval;
2314 2264
2315 octave_value_typeinfo::cat_op_fcn f 2265 octave_value_typeinfo::cat_op_fcn f
2316 = octave_value_typeinfo::lookup_cat_op (t1, t2); 2266 = octave_value_typeinfo::lookup_cat_op (t1, t2);
2317 2267
2318 if (f) 2268 if (f)
2319 { 2269 retval = f (*v1.rep, *v2.rep, ra_idx);
2320 try
2321 {
2322 retval = f (*v1.rep, *v2.rep, ra_idx);
2323 }
2324 catch (octave_execution_exception)
2325 {
2326 gripe_library_execution_error ();
2327 }
2328 }
2329 else 2270 else
2330 { 2271 {
2331 octave_value tv1; 2272 octave_value tv1;
2332 octave_base_value::type_conv_info cf1 = v1.numeric_conversion_function (); 2273 octave_base_value::type_conv_info cf1 = v1.numeric_conversion_function ();
2333 2274
2519 { 2460 {
2520 octave_value_typeinfo::unary_class_op_fcn f 2461 octave_value_typeinfo::unary_class_op_fcn f
2521 = octave_value_typeinfo::lookup_unary_class_op (op); 2462 = octave_value_typeinfo::lookup_unary_class_op (op);
2522 2463
2523 if (f) 2464 if (f)
2524 { 2465 retval = f (v);
2525 try
2526 {
2527 retval = f (v);
2528 }
2529 catch (octave_execution_exception)
2530 {
2531 gripe_library_execution_error ();
2532 }
2533 }
2534 else 2466 else
2535 gripe_unary_op (octave_value::unary_op_as_string (op), 2467 gripe_unary_op (octave_value::unary_op_as_string (op),
2536 v.class_name ()); 2468 v.class_name ());
2537 } 2469 }
2538 else 2470 else
2542 2474
2543 octave_value_typeinfo::unary_op_fcn f 2475 octave_value_typeinfo::unary_op_fcn f
2544 = octave_value_typeinfo::lookup_unary_op (op, t); 2476 = octave_value_typeinfo::lookup_unary_op (op, t);
2545 2477
2546 if (f) 2478 if (f)
2547 { 2479 retval = f (*v.rep);
2548 try
2549 {
2550 retval = f (*v.rep);
2551 }
2552 catch (octave_execution_exception)
2553 {
2554 gripe_library_execution_error ();
2555 }
2556 }
2557 else 2480 else
2558 { 2481 {
2559 octave_value tv; 2482 octave_value tv;
2560 octave_base_value::type_conv_fcn cf 2483 octave_base_value::type_conv_fcn cf
2561 = v.numeric_conversion_function (); 2484 = v.numeric_conversion_function ();
2613 2536
2614 if (f) 2537 if (f)
2615 { 2538 {
2616 make_unique (); 2539 make_unique ();
2617 2540
2618 try 2541 f (*rep);
2619 {
2620 f (*rep);
2621 }
2622 catch (octave_execution_exception)
2623 {
2624 gripe_library_execution_error ();
2625 }
2626 } 2542 }
2627 else 2543 else
2628 { 2544 {
2629 octave_base_value::type_conv_fcn cf = numeric_conversion_function (); 2545 octave_base_value::type_conv_fcn cf = numeric_conversion_function ();
2630 2546
2641 2557
2642 f = octave_value_typeinfo::lookup_non_const_unary_op (op, t); 2558 f = octave_value_typeinfo::lookup_non_const_unary_op (op, t);
2643 2559
2644 if (f) 2560 if (f)
2645 { 2561 {
2646 try 2562 f (*rep);
2647 {
2648 f (*rep);
2649 }
2650 catch (octave_execution_exception)
2651 {
2652 gripe_library_execution_error ();
2653 }
2654 2563
2655 if (old_rep && --old_rep->count == 0) 2564 if (old_rep && --old_rep->count == 0)
2656 delete old_rep; 2565 delete old_rep;
2657 } 2566 }
2658 else 2567 else
2688 // Only attempt to operate in-place if this variable is unshared. 2597 // Only attempt to operate in-place if this variable is unshared.
2689 if (rep->count == 1) 2598 if (rep->count == 1)
2690 f = octave_value_typeinfo::lookup_non_const_unary_op (op, t); 2599 f = octave_value_typeinfo::lookup_non_const_unary_op (op, t);
2691 2600
2692 if (f) 2601 if (f)
2693 { 2602 f (*rep);
2694 try
2695 {
2696 f (*rep);
2697 }
2698 catch (octave_execution_exception)
2699 {
2700 gripe_library_execution_error ();
2701 }
2702 }
2703 else 2603 else
2704 *this = do_unary_op (op, *this); 2604 *this = do_unary_op (op, *this);
2705 } 2605 }
2706 2606
2707 return *this; 2607 return *this;