Mercurial > hg > octave-nkf

comparison src/oct-stream.cc @ 2572:5c2be7c820ed

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 1996-12-08 04:02:46 by jwe]
author jwe
date Sun, 08 Dec 1996 04:02:46 +0000
parents 3be97fe02051
children c454cd888ada
comparison
equal deleted inserted replaced
2571:2480ef198c46 2572:5c2be7c820ed
854 invalid_operation ("fread", "reading"); 854 invalid_operation ("fread", "reading");
855 855
856 return retval; 856 return retval;
857 } 857 }
858 858
859 #define do_scanf_conv(is, fmt, valptr, mval, data, idx, max_size, discard) \ 859 template <class T>
860 do \ 860 void
861 { \ 861 do_scanf_conv (istream& is, const char *fmt, T valptr, Matrix& mval,
862 is.scan (fmt, valptr); \ 862 double *data, int& idx, int nr, int max_size,
863 \ 863 bool discard)
864 if (is) \ 864 {
865 { \ 865 is.scan (fmt, valptr);
866 if (idx == max_size && ! discard) \ 866
867 { \ 867 if (is)
868 max_size *= 2; \ 868 {
869 \ 869 if (idx == max_size && ! discard)
870 if (nr > 0) \ 870 {
871 mval.resize (nr, max_size / nr, 0.0); \ 871 max_size *= 2;
872 else \ 872
873 mval.resize (max_size, 1, 0.0); \ 873 if (nr > 0)
874 \ 874 mval.resize (nr, max_size / nr, 0.0);
875 data = mval.fortran_vec (); \ 875 else
876 } \ 876 mval.resize (max_size, 1, 0.0);
877 \ 877
878 if (! discard) \ 878 data = mval.fortran_vec ();
879 data[idx++] = *(valptr); \ 879 }
880 } \ 880
881 } \ 881 if (! discard)
882 while (0) 882 data[idx++] = *(valptr);
883 }
884 }
885
886 template void
887 do_scanf_conv (istream&, const char*, int*, Matrix&, double*, int&,
888 int, int, bool);
889
890 template void
891 do_scanf_conv (istream&, const char*, float*, Matrix&, double*, int&,
892 int, int, bool);
893
894 template void
895 do_scanf_conv (istream&, const char*, double*, Matrix&, double*, int&,
896 int, int, bool);
897
883 898
884 octave_value 899 octave_value
885 octave_base_stream::do_scanf (scanf_format_list& fmt_list, 900 octave_base_stream::do_scanf (scanf_format_list& fmt_list,
886 int nr, int nc, int& count) 901 int nr, int nc, int& count)
887 { 902 {
959 case 'd': case 'i': case 'o': case 'u': case 'x': 974 case 'd': case 'i': case 'o': case 'u': case 'x':
960 { 975 {
961 int tmp; 976 int tmp;
962 977
963 do_scanf_conv (is, fmt, &tmp, mval, data, count, 978 do_scanf_conv (is, fmt, &tmp, mval, data, count,
964 max_size, discard); 979 nr, max_size, discard);
965 } 980 }
966 break; 981 break;
967 982
968 case 'e': case 'f': case 'g': 983 case 'e': case 'f': case 'g':
969 { 984 {
970 if (elt->modifier == 'l') 985 if (elt->modifier == 'l')
971 { 986 {
972 double tmp; 987 double tmp;
973 988
974 do_scanf_conv (is, fmt, &tmp, mval, data, 989 do_scanf_conv (is, fmt, &tmp, mval, data,
975 count, max_size, discard); 990 count, nr, max_size, discard);
976 } 991 }
977 else 992 else
978 { 993 {
979 float tmp; 994 float tmp;
980 995
981 do_scanf_conv (is, fmt, &tmp, mval, data, 996 do_scanf_conv (is, fmt, &tmp, mval, data,
982 count, max_size, discard); 997 count, nr, max_size, discard);
983 } 998 }
984 } 999 }
985 break; 1000 break;
986 1001
987 case 'c': 1002 case 'c':
1192 invalid_operation ("fscanf", "writing"); 1207 invalid_operation ("fscanf", "writing");
1193 1208
1194 return retval; 1209 return retval;
1195 } 1210 }
1196 1211
1197 #define do_oscanf_num_conv(is, fmt, valptr) \ 1212 template <class T>
1198 do \ 1213 octave_value
1199 { \ 1214 do_oscanf_num_conv (istream& is, const char *fmt, T valptr, bool discard)
1200 streambuf *isb = is.rdbuf (); \ 1215 {
1201 \ 1216 octave_value retval;
1202 if (isb->scan (fmt, valptr) > 0) \ 1217
1203 { \ 1218 is.scan (fmt, valptr);
1204 if (! discard && is) \ 1219
1205 retval = (double) (*valptr); \ 1220 if (is)
1206 } \ 1221 {
1207 else \ 1222 if (! discard)
1208 error ("fscanf: conversion failed"); \ 1223 retval = (double) (*valptr);
1209 } \ 1224 }
1210 while (0) 1225 else
1211 1226 error ("fscanf: conversion failed");
1212 #define do_oscanf_str_conv(is, fmt, sptr, maxlen) \ 1227
1213 do \ 1228 return retval;
1214 { \ 1229 }
1215 streambuf *isb = is.rdbuf (); \ 1230
1216 \ 1231 template octave_value
1217 if (isb->scan (fmt, sptr) > 0) \ 1232 do_oscanf_num_conv (istream&, const char*, int*, bool);
1218 { \ 1233
1219 if (! discard && is) \ 1234 template octave_value
1220 { \ 1235 do_oscanf_num_conv (istream&, const char*, float*, bool);
1221 sptr[maxlen] = '\0'; \ 1236
1222 retval = sptr; \ 1237 template octave_value
1223 } \ 1238 do_oscanf_num_conv (istream&, const char*, double*, bool);
1224 } \ 1239
1225 else \ 1240 static inline octave_value
1226 error ("fscanf: conversion failed"); \ 1241 do_oscanf_str_conv (istream& is, const char *fmt, char *sptr,
1227 } \ 1242 int maxlen, bool discard)
1228 while (0) 1243 {
1244 octave_value retval;
1245
1246 is.scan (fmt, sptr);
1247
1248 if (is)
1249 {
1250 if (! discard)
1251 {
1252 sptr[maxlen] = '\0';
1253 retval = sptr;
1254 }
1255 }
1256 else
1257 error ("fscanf: conversion failed");
1258
1259 return retval;
1260 }
1229 1261
1230 octave_value 1262 octave_value
1231 octave_base_stream::do_oscanf (const scanf_format_elt *elt) 1263 octave_base_stream::do_oscanf (const scanf_format_elt *elt)
1232 { 1264 {
1233 octave_value retval = Matrix (); 1265 octave_value retval;
1234 1266
1235 istream *isp = input_stream (); 1267 istream *isp = input_stream ();
1236 1268
1237 if (isp) 1269 if (isp)
1238 { 1270 {
1258 1290
1259 case 'd': case 'i': case 'o': case 'u': case 'x': 1291 case 'd': case 'i': case 'o': case 'u': case 'x':
1260 { 1292 {
1261 int tmp; 1293 int tmp;
1262 1294
1263 do_oscanf_num_conv (is, fmt, &tmp); 1295 retval = do_oscanf_num_conv (is, fmt, &tmp, discard);
1264 } 1296 }
1265 break; 1297 break;
1266 1298
1267 case 'e': case 'f': case 'g': 1299 case 'e': case 'f': case 'g':
1268 { 1300 {
1269 if (elt->modifier == 'l') 1301 if (elt->modifier == 'l')
1270 { 1302 {
1271 double tmp; 1303 double tmp;
1272 1304
1273 do_oscanf_num_conv (is, fmt, &tmp); 1305 retval = do_oscanf_num_conv (is, fmt, &tmp, discard);
1274 } 1306 }
1275 else 1307 else
1276 { 1308 {
1277 float tmp; 1309 float tmp;
1278 1310
1279 do_oscanf_num_conv (is, fmt, &tmp); 1311 retval = do_oscanf_num_conv (is, fmt, &tmp, discard);
1280 } 1312 }
1281 } 1313 }
1282 break; 1314 break;
1283 1315
1284 case 'c': 1316 case 'c':
1287 1319
1288 int width = elt->width ? elt->width : 1; 1320 int width = elt->width ? elt->width : 1;
1289 1321
1290 char *tmp = new char[width + 1]; 1322 char *tmp = new char[width + 1];
1291 1323
1292 do_oscanf_str_conv (is, fmt, tmp, width); 1324 retval = do_oscanf_str_conv (is, fmt, tmp, width, discard);
1293 1325
1294 is.setf (flags); 1326 is.setf (flags);
1295 1327
1296 delete [] tmp; 1328 delete [] tmp;
1297 } 1329 }
1301 { 1333 {
1302 // XXX FIXME XXX -- this must be fixed! 1334 // XXX FIXME XXX -- this must be fixed!
1303 1335
1304 int width = elt->width ? elt->width : 65535; 1336 int width = elt->width ? elt->width : 65535;
1305 char *tmp = new char [width+1]; 1337 char *tmp = new char [width+1];
1306 do_oscanf_str_conv (is, fmt, tmp, width); 1338
1339 retval = do_oscanf_str_conv (is, fmt, tmp, width, discard);
1340
1307 delete [] tmp; 1341 delete [] tmp;
1308 } 1342 }
1309 break; 1343 break;
1310 1344
1311 case 'p': case '[': 1345 case 'p': case '[':
1400 1434
1401 retval.resize (nconv, Matrix ()); 1435 retval.resize (nconv, Matrix ());
1402 1436
1403 const scanf_format_elt *elt = fmt_list.first (); 1437 const scanf_format_elt *elt = fmt_list.first ();
1404 1438
1439 int num_values = 0;
1440
1405 for (int i = 0; i < nconv; i++) 1441 for (int i = 0; i < nconv; i++)
1406 { 1442 {
1407 retval (i) = do_oscanf (elt); 1443 octave_value tmp = do_oscanf (elt);
1444
1445 if (tmp.is_defined ())
1446 retval (num_values++) = tmp;
1408 1447
1409 if (! ok ()) 1448 if (! ok ())
1410 break; 1449 break;
1411 1450
1412 elt = fmt_list.next (); 1451 elt = fmt_list.next ();
1413 } 1452 }
1453
1454 retval.resize (num_values);
1414 1455
1415 // Pick up any trailing stuff. 1456 // Pick up any trailing stuff.
1416 if (ok () && len > nconv) 1457 if (ok () && len > nconv)
1417 do_oscanf (elt); 1458 do_oscanf (elt);
1418 } 1459 }
1640 return retval; 1681 return retval;
1641 } 1682 }
1642 1683
1643 // Ugh again and again. 1684 // Ugh again and again.
1644 1685
1645 #define do_printf_conv(os, fmt, nsa, sa_1, sa_2, have_arg, arg) \ 1686 template <class T>
1646 do \ 1687 void
1647 { \ 1688 do_printf_conv (ostream& os, const char *fmt, int nsa, int sa_1,
1648 switch (nsa) \ 1689 int sa_2, bool have_arg, T arg)
1649 { \ 1690 {
1650 case 2: \ 1691 switch (nsa)
1651 if (have_arg) \ 1692 {
1652 os.form (fmt, sa_1, sa_2, arg); \ 1693 case 2:
1653 else \ 1694 if (have_arg)
1654 os.form (fmt, sa_1, sa_2); \ 1695 os.form (fmt, sa_1, sa_2, arg);
1655 break; \ 1696 else
1656 \ 1697 os.form (fmt, sa_1, sa_2);
1657 case 1: \ 1698 break;
1658 if (have_arg) \ 1699
1659 os.form (fmt, sa_1, arg); \ 1700 case 1:
1660 else \ 1701 if (have_arg)
1661 os.form (fmt, sa_1); \ 1702 os.form (fmt, sa_1, arg);
1662 break; \ 1703 else
1663 \ 1704 os.form (fmt, sa_1);
1664 case 0: \ 1705 break;
1665 if (have_arg) \ 1706
1666 os.form (fmt, arg); \ 1707 case 0:
1667 else \ 1708 if (have_arg)
1668 os.form (fmt); \ 1709 os.form (fmt, arg);
1669 break; \ 1710 else
1670 \ 1711 os.form (fmt);
1671 default: \ 1712 break;
1672 ::error ("fprintf: internal error handling format"); \ 1713
1673 break; \ 1714 default:
1674 } \ 1715 ::error ("fprintf: internal error handling format");
1675 } \ 1716 break;
1676 while (0) 1717 }
1718 }
1719
1720 template void
1721 do_printf_conv (ostream&, const char*, int, int, int, bool, int);
1722
1723 template void
1724 do_printf_conv (ostream&, const char*, int, int, int, bool, long);
1725
1726 template void
1727 do_printf_conv (ostream&, const char*, int, int, int, bool, double);
1728
1729 template void
1730 do_printf_conv (ostream&, const char*, int, int, int, bool, const char*);
1677 1731
1678 int 1732 int
1679 octave_base_stream::do_printf (printf_format_list& fmt_list, 1733 octave_base_stream::do_printf (printf_format_list& fmt_list,
1680 const octave_value_list& args) 1734 const octave_value_list& args)
1681 { 1735 {
1725 } 1779 }
1726 1780
1727 const char *fmt = elt->text; 1781 const char *fmt = elt->text;
1728 1782
1729 if (doing_percent || args == 0) 1783 if (doing_percent || args == 0)
1730 do_printf_conv (os, fmt, nsa, sa_1, sa_2, 0, 0.0); 1784 do_printf_conv (os, fmt, nsa, sa_1, sa_2, false, 0.0);
1731 else 1785 else
1732 { 1786 {
1733 if (elt->type == 's' && val_cache.looking_at_string ()) 1787 if (elt->type == 's' && val_cache.looking_at_string ())
1734 { 1788 {
1735 string val = val_cache.string_value (); 1789 string val = val_cache.string_value ();
1736 1790
1737 if (val_cache) 1791 if (val_cache)
1738 do_printf_conv (os, fmt, nsa, sa_1, sa_2, 1, 1792 do_printf_conv (os, fmt, nsa, sa_1, sa_2, true,
1739 val.c_str ()); 1793 val.c_str ());
1740 else 1794 else
1741 break; 1795 break;
1742 } 1796 }
1743 else 1797 else
1751 case 'd': case 'i': case 'o': case 'x': 1805 case 'd': case 'i': case 'o': case 'x':
1752 case 'X': case 'u': case 'c': 1806 case 'X': case 'u': case 'c':
1753 { 1807 {
1754 if (elt->modifier == 'l') 1808 if (elt->modifier == 'l')
1755 do_printf_conv (os, fmt, nsa, sa_1, 1809 do_printf_conv (os, fmt, nsa, sa_1,
1756 sa_2, 1, (long) val); 1810 sa_2, true, (long) val);
1757 else 1811 else
1758 do_printf_conv (os, fmt, nsa, sa_1, 1812 do_printf_conv (os, fmt, nsa, sa_1,
1759 sa_2, 1, (int) val); 1813 sa_2, true, (int) val);
1760 } 1814 }
1761 break; 1815 break;
1762 1816
1763 case 'f': case 'e': case 'E': 1817 case 'f': case 'e': case 'E':
1764 case 'g': case 'G': 1818 case 'g': case 'G':
1765 do_printf_conv (os, fmt, nsa, sa_1, 1819 do_printf_conv (os, fmt, nsa, sa_1,
1766 sa_2, 1, val); 1820 sa_2, true, val);
1767 break; 1821 break;
1768 1822
1769 default: 1823 default:
1770 error ("fprintf: invalid format specifier"); 1824 error ("fprintf: invalid format specifier");
1771 return -1; 1825 return -1;