Mercurial > octave-nkf

comparison libinterp/corefcn/utils.cc @ 20591:0650b8431037

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
eliminate more simple uses of error_state * besselj.cc, bitfcns.cc, utils.cc, chol.cc, ov-java.cc: Eliminate simple uses of error_state.
author John W. Eaton <jwe@octave.org>
date Mon, 05 Oct 2015 21:37:03 -0400
parents dd6345fd8a97
children ba2b07c13913
comparison
equal deleted inserted replaced
20590:1a0a433c8263 20591:0650b8431037
1213 1213
1214 if (nr == 1 || nc == 1) 1214 if (nr == 1 || nc == 1)
1215 { 1215 {
1216 Array<double> v = a.vector_value (); 1216 Array<double> v = a.vector_value ();
1217 1217
1218 if (error_state)
1219 return;
1220
1221 octave_idx_type n = v.numel (); 1218 octave_idx_type n = v.numel ();
1222 dim.resize (n); 1219 dim.resize (n);
1223 for (octave_idx_type i = 0; i < n; i++) 1220 for (octave_idx_type i = 0; i < n; i++)
1224 dim(i) = static_cast<int> (fix (v(i))); 1221 dim(i) = static_cast<int> (fix (v(i)));
1225 } 1222 }
1226 else 1223 else
1227 error ("%s (A): use %s (size (A)) instead", warn_for, warn_for); 1224 error ("%s (A): use %s (size (A)) instead", warn_for, warn_for);
1228 } 1225 }
1229 1226
1230 if (! error_state) 1227 check_dimensions (dim, warn_for);
1231 check_dimensions (dim, warn_for); // May set error_state.
1232 } 1228 }
1233 1229
1234 1230
1235 void 1231 void
1236 get_dimensions (const octave_value& a, const char *warn_for, 1232 get_dimensions (const octave_value& a, const char *warn_for,
1247 1243
1248 if ((nr == 1 && nc == 2) || (nr == 2 && nc == 1)) 1244 if ((nr == 1 && nc == 2) || (nr == 2 && nc == 1))
1249 { 1245 {
1250 Array<double> v = a.vector_value (); 1246 Array<double> v = a.vector_value ();
1251 1247
1252 if (error_state)
1253 return;
1254 1248
1255 nr = static_cast<octave_idx_type> (fix (v (0))); 1249 nr = static_cast<octave_idx_type> (fix (v (0)));
1256 nc = static_cast<octave_idx_type> (fix (v (1))); 1250 nc = static_cast<octave_idx_type> (fix (v (1)));
1257 } 1251 }
1258 else 1252 else
1259 error ("%s (A): use %s (size (A)) instead", warn_for, warn_for); 1253 error ("%s (A): use %s (size (A)) instead", warn_for, warn_for);
1260 } 1254 }
1261 1255
1262 if (! error_state) 1256 check_dimensions (nr, nc, warn_for);
1263 check_dimensions (nr, nc, warn_for); // May set error_state.
1264 } 1257 }
1265 1258
1266 void 1259 void
1267 get_dimensions (const octave_value& a, const octave_value& b, 1260 get_dimensions (const octave_value& a, const octave_value& b,
1268 const char *warn_for, octave_idx_type& nr, octave_idx_type& nc) 1261 const char *warn_for, octave_idx_type& nr, octave_idx_type& nc)
1271 nc = b.is_empty () ? 0 : b.int_value (); 1264 nc = b.is_empty () ? 0 : b.int_value ();
1272 1265
1273 if (error_state) 1266 if (error_state)
1274 error ("%s: expecting two scalar arguments", warn_for); 1267 error ("%s: expecting two scalar arguments", warn_for);
1275 else 1268 else
1276 check_dimensions (nr, nc, warn_for); // May set error_state. 1269 check_dimensions (nr, nc, warn_for);
1277 } 1270 }
1278 1271
1279 octave_idx_type 1272 octave_idx_type
1280 dims_to_numel (const dim_vector& dims, const octave_value_list& idx) 1273 dims_to_numel (const dim_vector& dims, const octave_value_list& idx)
1281 { 1274 {
1299 else 1292 else
1300 { 1293 {
1301 try 1294 try
1302 { 1295 {
1303 idx_vector jdx = idxi.index_vector (); 1296 idx_vector jdx = idxi.index_vector ();
1304 if (error_state) 1297
1305 break;
1306 retval *= jdx.length (dv(i)); 1298 retval *= jdx.length (dv(i));
1307 } 1299 }
1308 catch (index_exception& e) 1300 catch (index_exception& e)
1309 { 1301 {
1310 error ("dims_to_numel: Invalid IDX %s. %s", 1302 error ("dims_to_numel: Invalid IDX %s. %s",
1456 if (nargin == 2) 1448 if (nargin == 2)
1457 n = args(1).idx_type_value (); 1449 n = args(1).idx_type_value ();
1458 else if (nargin != 1) 1450 else if (nargin != 1)
1459 print_usage (); 1451 print_usage ();
1460 1452
1461 if (! error_state) 1453 unwind_protect frame;
1462 { 1454
1463 unwind_protect frame; 1455 frame.protect_var (discard_error_messages);
1464 1456 discard_error_messages = true;
1465 frame.protect_var (error_state); 1457
1466 1458 try
1467 frame.protect_var (discard_error_messages); 1459 {
1468 discard_error_messages = true; 1460 idx_vector idx = args(0).index_vector (true);
1469 1461
1470 try 1462 if (nargin == 2)
1471 { 1463 retval = idx.extent (n) <= n;
1472 idx_vector idx = args(0).index_vector (true); 1464 else
1473 1465 retval = true;
1474 if (! error_state) 1466 }
1475 { 1467 catch (const octave_execution_exception&)
1476 if (nargin == 2) 1468 {
1477 retval = idx.extent (n) <= n; 1469 retval = false;
1478 else
1479 retval = true;
1480 }
1481 else
1482 retval = false;
1483 }
1484 catch (const octave_execution_exception&)
1485 {
1486 retval = false;
1487 }
1488 } 1470 }
1489 1471
1490 return retval; 1472 return retval;
1491 } 1473 }
1492 1474
1540 break; 1522 break;
1541 } 1523 }
1542 } 1524 }
1543 } 1525 }
1544 1526
1545 if (! error_state) 1527 for (int i = 0; i < nargout; i++)
1546 { 1528 rcells[i].clear (dims);
1547 for (int i = 0; i < nargout; i++) 1529
1548 rcells[i].clear (dims); 1530 for (octave_idx_type j = 0; j < numel; j++)
1549 1531 {
1550 for (octave_idx_type j = 0; j < numel; j++) 1532 for (int i = 0; i < nargin; i++)
1551 { 1533 if (iscell[i])
1552 for (int i = 0; i < nargin; i++) 1534 new_args(i) = ccells[i](j);
1553 if (iscell[i]) 1535
1554 new_args(i) = ccells[i](j); 1536 octave_quit ();
1555 1537
1556 octave_quit (); 1538 const octave_value_list tmp = fun (new_args, nargout);
1557 1539
1558 const octave_value_list tmp = fun (new_args, nargout); 1540 if (tmp.length () < nargout)
1559 1541 {
1560 if (tmp.length () < nargout) 1542 error ("%s: do_simple_cellfun: internal error", fun_name);
1561 { 1543 break;
1562 error ("%s: do_simple_cellfun: internal error", fun_name); 1544 }
1563 break; 1545 else
1564 } 1546 {
1565 else 1547 for (int i = 0; i < nargout; i++)
1566 { 1548 rcells[i](j) = tmp(i);
1567 for (int i = 0; i < nargout; i++) 1549 }
1568 rcells[i](j) = tmp(i); 1550 }
1569 } 1551
1570 } 1552 retval.resize (nargout);
1571 } 1553
1572 1554 for (int i = 0; i < nargout; i++)
1573 if (! error_state) 1555 retval(i) = rcells[i];
1574 {
1575 retval.resize (nargout);
1576 for (int i = 0; i < nargout; i++)
1577 retval(i) = rcells[i];
1578 }
1579 1556
1580 return retval; 1557 return retval;
1581 } 1558 }
1582 1559
1583 octave_value 1560 octave_value