Mercurial > octave

comparison libinterp/parse-tree/oct-parse.yy @ 27516:c3e24c82157f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
skip constant folding if expression evaluation generates warning * oct-parse.yy (base_parser::make_colon_expression, base_parser::finish_array_list): Skip constant folding if expression evaluation generates a warning. Save and restore last warning message. Move unwind_protect frame inside try-catch block.
author John W. Eaton <jwe@octave.org>
date Wed, 16 Oct 2019 13:35:08 -0400
parents 257105b5193a
children 5e92bff668d6
comparison
equal deleted inserted replaced
27515:466e61c5fb4b 27516:c3e24c82157f
2439 tree_expression *limit, 2439 tree_expression *limit,
2440 tree_expression *incr) 2440 tree_expression *incr)
2441 { 2441 {
2442 tree_expression *retval = nullptr; 2442 tree_expression *retval = nullptr;
2443 2443
2444 interpreter& interp = __get_interpreter__ ("finish_colon_expression");
2445 error_system& es = interp.get_error_system ();
2446
2447 unwind_protect frame;
2448
2449 frame.add_method (es, &error_system::set_discard_warning_messages,
2450 es.discard_warning_messages ());
2451
2452 es.discard_warning_messages (true);
2453
2454 if (! base || ! limit) 2444 if (! base || ! limit)
2455 { 2445 {
2456 delete base; 2446 delete base;
2457 delete limit; 2447 delete limit;
2458 delete incr; 2448 delete incr;
2461 } 2451 }
2462 2452
2463 int l = base->line (); 2453 int l = base->line ();
2464 int c = base->column (); 2454 int c = base->column ();
2465 2455
2466 tree_colon_expression *e 2456 tree_colon_expression *expr
2467 = new tree_colon_expression (base, limit, incr, l, c); 2457 = new tree_colon_expression (base, limit, incr, l, c);
2458
2459 retval = expr;
2468 2460
2469 if (base->is_constant () && limit->is_constant () 2461 if (base->is_constant () && limit->is_constant ()
2470 && (! incr || incr->is_constant ())) 2462 && (! incr || incr->is_constant ()))
2471 { 2463 {
2464 interpreter& interp = __get_interpreter__ ("finish_colon_expression");
2465
2472 try 2466 try
2473 { 2467 {
2468 // If the evaluation generates a warning message, restore
2469 // the previous value of last_warning_message and skip the
2470 // conversion to a constant value.
2471
2472 unwind_protect frame;
2473
2474 error_system& es = interp.get_error_system ();
2475
2476 frame.add_method (es, &error_system::set_last_warning_message,
2477 es.last_warning_message (""));
2478
2479 frame.add_method (es, &error_system::set_discard_warning_messages,
2480 es.discard_warning_messages (true));
2481
2474 tree_evaluator& tw = interp.get_evaluator (); 2482 tree_evaluator& tw = interp.get_evaluator ();
2475 2483
2476 octave_value tmp = e->evaluate (tw); 2484 octave_value tmp = expr->evaluate (tw);
2477 2485
2478 tree_constant *tc_retval 2486 std::string msg = es.last_warning_message ();
2479 = new tree_constant (tmp, e->line (), e->column ()); 2487
2480 2488 if (msg.empty ())
2481 std::ostringstream buf; 2489 {
2482 2490 tree_constant *tc_retval
2483 tree_print_code tpc (buf); 2491 = new tree_constant (tmp, expr->line (), expr->column ());
2484 2492
2485 e->accept (tpc); 2493 std::ostringstream buf;
2486 2494
2487 tc_retval->stash_original_text (buf.str ()); 2495 tree_print_code tpc (buf);
2488 2496
2489 delete e; 2497 expr->accept (tpc);
2490 2498
2491 retval = tc_retval; 2499 tc_retval->stash_original_text (buf.str ());
2500
2501 delete expr;
2502
2503 retval = tc_retval;
2504 }
2492 } 2505 }
2493 catch (const execution_exception&) 2506 catch (const execution_exception&)
2494 { 2507 {
2495 interp.recover_from_exception (); 2508 interp.recover_from_exception ();
2496 } 2509 }
2497 } 2510 }
2498 else
2499 retval = e;
2500 2511
2501 return retval; 2512 return retval;
2502 } 2513 }
2503 2514
2504 // Build a binary expression. 2515 // Build a binary expression.
4132 tree_expression * 4143 tree_expression *
4133 base_parser::finish_array_list (tree_array_list *array_list) 4144 base_parser::finish_array_list (tree_array_list *array_list)
4134 { 4145 {
4135 tree_expression *retval = array_list; 4146 tree_expression *retval = array_list;
4136 4147
4137 interpreter& interp = __get_interpreter__ ("finish_array_list");
4138 error_system& es = interp.get_error_system ();
4139
4140 unwind_protect frame;
4141
4142 frame.add_method (es, &error_system::set_discard_warning_messages,
4143 es.discard_warning_messages ());
4144
4145 es.discard_warning_messages (true);
4146
4147 if (array_list->all_elements_are_constant ()) 4148 if (array_list->all_elements_are_constant ())
4148 { 4149 {
4150 interpreter& interp = __get_interpreter__ ("finish_array_list");
4151
4149 try 4152 try
4150 { 4153 {
4154 // If the evaluation generates a warning message, restore
4155 // the previous value of last_warning_message and skip the
4156 // conversion to a constant value.
4157
4158 unwind_protect frame;
4159
4160 error_system& es = interp.get_error_system ();
4161
4162 frame.add_method (es, &error_system::set_last_warning_message,
4163 es.last_warning_message (""));
4164
4165 frame.add_method (es, &error_system::set_discard_warning_messages,
4166 es.discard_warning_messages (true));
4167
4151 tree_evaluator& tw = interp.get_evaluator (); 4168 tree_evaluator& tw = interp.get_evaluator ();
4152 4169
4153 octave_value tmp = array_list->evaluate (tw); 4170 octave_value tmp = array_list->evaluate (tw);
4154 4171
4155 tree_constant *tc_retval 4172 std::string msg = es.last_warning_message ();
4156 = new tree_constant (tmp, array_list->line (), 4173
4157 array_list->column ()); 4174 if (msg.empty ())
4158 4175 {
4159 std::ostringstream buf; 4176 tree_constant *tc_retval
4160 4177 = new tree_constant (tmp, array_list->line (),
4161 tree_print_code tpc (buf); 4178 array_list->column ());
4162 4179
4163 array_list->accept (tpc); 4180 std::ostringstream buf;
4164 4181
4165 tc_retval->stash_original_text (buf.str ()); 4182 tree_print_code tpc (buf);
4166 4183
4167 delete array_list; 4184 array_list->accept (tpc);
4168 4185
4169 retval = tc_retval; 4186 tc_retval->stash_original_text (buf.str ());
4187
4188 delete array_list;
4189
4190 retval = tc_retval;
4191 }
4170 } 4192 }
4171 catch (const execution_exception&) 4193 catch (const execution_exception&)
4172 { 4194 {
4173 interp.recover_from_exception (); 4195 interp.recover_from_exception ();
4174 } 4196 }