Mercurial > hg > octave-nkf

comparison src/oct-stream.cc @ 2317:8c09c04f7747

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 1996-07-14 22:30:15 by jwe]
author jwe
date Sun, 14 Jul 1996 22:40:35 +0000
parents 5a3f1d00a474
children 6ee55c0f25a9
comparison
equal deleted inserted replaced
2316:fbc76f6e4893 2317:8c09c04f7747
815 octave_base_stream::gets (int max_len, bool& err) 815 octave_base_stream::gets (int max_len, bool& err)
816 { 816 {
817 return do_gets (max_len, err, false, "fgets"); 817 return do_gets (max_len, err, false, "fgets");
818 } 818 }
819 819
820 // XXX FIXME XXX -- need to handle architecture type conversions.
821
822 #define do_read_elem(is, type, val) \
823 do \
824 { \
825 type tmp_val; \
826 is.read ((char *) &tmp_val, sizeof (type)); \
827 val = tmp_val; \
828 } \
829 while (0)
830
831 octave_value 820 octave_value
832 octave_base_stream::do_read (int nr, int nc, data_type dt, int skip, 821 octave_base_stream::read (const Matrix& size,
833 arch_type at, int& count) 822 oct_data_conv::data_type dt, int skip,
834 { 823 oct_mach_info::float_format flt_fmt, int& count)
824 {
825 Matrix retval;
826
835 count = 0; 827 count = 0;
836 828
837 octave_value retval = Matrix ();
838
839 istream *isp = input_stream (); 829 istream *isp = input_stream ();
840 830
841 Matrix mval;
842 double *data = 0;
843 int max_size = 0;
844
845 int final_nr = 0;
846 int final_nc = 0;
847
848 if (nr > 0)
849 {
850 if (nc > 0)
851 {
852 mval.resize (nr, nc, 0.0);
853 data = mval.fortran_vec ();
854 max_size = nr * nc;
855 }
856 else
857 {
858 mval.resize (nr, 32, 0.0);
859 data = mval.fortran_vec ();
860 max_size = nr * 32;
861 }
862 }
863 else
864 {
865 mval.resize (32, 1, 0.0);
866 data = mval.fortran_vec ();
867 max_size = 32;
868 }
869
870 if (isp) 831 if (isp)
871 { 832 {
872 istream& is = *isp; 833 istream& is = *isp;
873 834
874 for (;;)
875 {
876 // XXX FIXME XXX -- maybe there should be a special case for
877 // skip == 0.
878
879 if (is)
880 {
881 if (nr > 0 && nc > 0 && count == max_size)
882 {
883 final_nr = nr;
884 final_nc = nc;
885
886 break;
887 }
888
889 if (skip != 0)
890 seek (skip, ios::cur);
891
892 if (is)
893 {
894 double tmp = 0.0;
895
896 switch (dt)
897 {
898 case dt_char:
899 do_read_elem (is, char, tmp);
900 break;
901
902 case dt_schar:
903 do_read_elem (is, signed char, tmp);
904 break;
905
906 case dt_uchar:
907 do_read_elem (is, unsigned char, tmp);
908 break;
909
910 case dt_short:
911 do_read_elem (is, short, tmp);
912 break;
913
914 case dt_ushort:
915 do_read_elem (is, unsigned short, tmp);
916 break;
917
918 case dt_int:
919 do_read_elem (is, int, tmp);
920 break;
921
922 case dt_uint:
923 do_read_elem (is, unsigned int, tmp);
924 break;
925
926 case dt_long:
927 do_read_elem (is, long, tmp);
928 break;
929
930 case dt_ulong:
931 do_read_elem (is, unsigned long, tmp);
932 break;
933
934 case dt_float:
935 do_read_elem (is, float, tmp);
936 break;
937
938 case dt_double:
939 do_read_elem (is, double, tmp);
940 break;
941
942 default:
943 error ("fread: invalid type specification");
944 }
945
946 if (is && ok ())
947 {
948 if (count == max_size)
949 {
950 max_size *= 2;
951
952 if (nr > 0)
953 mval.resize (nr, max_size / 2, 0.0);
954 else
955 mval.resize (max_size, 1, 0.0);
956
957 data = mval.fortran_vec ();
958 }
959
960 data[count++] = tmp;
961 }
962 else
963 {
964 if (is.eof ())
965 {
966 if (nr > 0)
967 {
968 if (count > nr)
969 {
970 final_nr = nr;
971 final_nc = (count - 1) / nr + 1;
972 }
973 else
974 {
975 final_nr = count;
976 final_nc = 1;
977 }
978 }
979 else
980 {
981 final_nr = count;
982 final_nc = 1;
983 }
984 }
985
986 break;
987 }
988 }
989 else
990 {
991 error ("fread: read error");
992 break;
993 }
994 }
995 else
996 {
997 error ("fread: read error");
998 break;
999 }
1000 }
1001 }
1002
1003 if (ok ())
1004 {
1005 mval.resize (final_nr, final_nc, 0.0);
1006
1007 retval = mval;
1008 }
1009
1010 return retval;
1011 }
1012
1013 octave_value
1014 octave_base_stream::read (const Matrix& size, data_type dt, int skip,
1015 arch_type at, int& count)
1016 {
1017 octave_value retval;
1018
1019 count = 0;
1020
1021 istream *is = input_stream ();
1022
1023 if (is)
1024 {
1025 int nr = -1; 835 int nr = -1;
1026 int nc = -1; 836 int nc = -1;
1027 837
1028 get_size (size, nr, nc, "fread"); 838 get_size (size, nr, nc, "fread");
1029 839
1030 if (! error_state) 840 if (! error_state)
1031 retval = do_read (nr, nc, dt, skip, at, count); 841 {
842 if (flt_fmt == oct_mach_info::unknown)
843 flt_fmt = float_format ();
844
845 int tmp = retval.read (is, nr, nc, dt, skip, flt_fmt);
846
847 if (tmp < 0)
848 error ("fread: read error");
849 else
850 count = tmp;
851 }
1032 } 852 }
1033 else 853 else
1034 invalid_operation ("fread", "reading"); 854 invalid_operation ("fread", "reading");
1035 855
1036 return retval; 856 return retval;
1626 invalid_operation ("fflush", "writing"); 1446 invalid_operation ("fflush", "writing");
1627 1447
1628 return retval; 1448 return retval;
1629 } 1449 }
1630 1450
1631 // XXX FIXME XXX -- need to handle architecture type conversions.
1632
1633 #define do_write_elem(os, type, val) \
1634 do \
1635 { \
1636 type tmp_val = (type) val; \
1637 os.write ((char *) &tmp_val, sizeof (type)); \
1638 } \
1639 while (0)
1640
1641 int 1451 int
1642 octave_base_stream::do_write (const double *data, int n, data_type dt, 1452 octave_base_stream::write (const octave_value& data,
1643 int skip, arch_type at) 1453 oct_data_conv::data_type dt, int skip,
1454 oct_mach_info::float_format flt_fmt)
1644 { 1455 {
1645 int retval = -1; 1456 int retval = -1;
1646 1457
1647 int count = 0;
1648
1649 ostream *osp = output_stream (); 1458 ostream *osp = output_stream ();
1650 1459
1651 if (osp) 1460 if (osp)
1652 { 1461 {
1653 ostream& os = *osp; 1462 ostream& os = *osp;
1654 1463
1655 // XXX FIXME XXX -- maybe there should be a special case for 1464 Matrix mval = data.matrix_value ();
1656 // skip == 0. 1465
1657 1466 if (! error_state)
1658 for (int i = 0; i < n; i++) 1467 {
1659 { 1468 if (flt_fmt == oct_mach_info::unknown)
1660 if (os) 1469 flt_fmt = float_format ();
1661 { 1470
1662 if (skip != 0) 1471 int tmp = mval.write (os, dt, skip, flt_fmt);
1663 seek (skip, ios::cur); 1472
1664 1473 if (tmp < 0)
1665 if (os) 1474 error ("fwrite: write error");
1666 {
1667 double tmp = data[i];
1668
1669 switch (dt)
1670 {
1671 case dt_char:
1672 do_write_elem (os, char, tmp);
1673 break;
1674
1675 case dt_schar:
1676 do_write_elem (os, signed char, tmp);
1677 break;
1678
1679 case dt_uchar:
1680 do_write_elem (os, unsigned char, tmp);
1681 break;
1682
1683 case dt_short:
1684 do_write_elem (os, short, tmp);
1685 break;
1686
1687 case dt_ushort:
1688 do_write_elem (os, unsigned short, tmp);
1689 break;
1690
1691 case dt_int:
1692 do_write_elem (os, int, tmp);
1693 break;
1694
1695 case dt_uint:
1696 do_write_elem (os, unsigned int, tmp);
1697 break;
1698
1699 case dt_long:
1700 do_write_elem (os, long, tmp);
1701 break;
1702
1703 case dt_ulong:
1704 do_write_elem (os, unsigned long, tmp);
1705 break;
1706
1707 case dt_float:
1708 do_write_elem (os, float, tmp);
1709 break;
1710
1711 case dt_double:
1712 do_write_elem (os, double, tmp);
1713 break;
1714
1715 default:
1716 error ("fwrite: invalid type specification");
1717 }
1718
1719 if (os && ok ())
1720 count++;
1721 else
1722 break;
1723 }
1724 else
1725 {
1726 error ("fwrite: write error");
1727 break;
1728 }
1729 }
1730 else 1475 else
1731 { 1476 retval = tmp;
1732 error ("fwrite: write error");
1733 break;
1734 }
1735 }
1736 }
1737
1738 if (ok ())
1739 retval = count;
1740
1741 return retval;
1742 }
1743
1744 int
1745 octave_base_stream::write (const octave_value& data, data_type dt,
1746 int skip, arch_type at)
1747 {
1748 int retval = -1;
1749
1750 ostream *os = output_stream ();
1751
1752 if (os)
1753 {
1754 Matrix mval = data.matrix_value ();
1755
1756 if (! error_state)
1757 {
1758 int n = mval.length ();
1759
1760 const double *d = mval.data ();
1761
1762 retval = octave_base_stream::do_write (d, n, dt, skip, at);
1763 } 1477 }
1764 } 1478 }
1765 else 1479 else
1766 invalid_operation ("fwrite", "writing"); 1480 invalid_operation ("fwrite", "writing");
1767 1481
2366 return retval; 2080 return retval;
2367 } 2081 }
2368 2082
2369 octave_value 2083 octave_value
2370 octave_stream::read (const Matrix& size, 2084 octave_stream::read (const Matrix& size,
2371 octave_base_stream::data_type dt, int skip, 2085 oct_data_conv::data_type dt, int skip,
2372 octave_base_stream::arch_type at, int& count) 2086 oct_mach_info::float_format flt_fmt, int& count)
2373 { 2087 {
2374 octave_value retval; 2088 octave_value retval;
2375 2089
2376 if (stream_ok ("fread")) 2090 if (stream_ok ("fread"))
2377 retval = rep->read (size, dt, skip, at, count); 2091 retval = rep->read (size, dt, skip, flt_fmt, count);
2378 2092
2379 return retval; 2093 return retval;
2380 } 2094 }
2381 2095
2382 int 2096 int
2383 octave_stream::write (const octave_value& data, 2097 octave_stream::write (const octave_value& data,
2384 octave_base_stream::data_type dt, int skip, 2098 oct_data_conv::data_type dt, int skip,
2385 octave_base_stream::arch_type at) 2099 oct_mach_info::float_format flt_fmt)
2386 { 2100 {
2387 int retval = -1; 2101 int retval = -1;
2388 2102
2389 if (stream_ok ("fwrite")) 2103 if (stream_ok ("fwrite"))
2390 retval = rep->write (data, dt, skip, at); 2104 retval = rep->write (data, dt, skip, flt_fmt);
2391 2105
2392 return retval; 2106 return retval;
2393 } 2107 }
2394 2108
2395 octave_value 2109 octave_value
2496 retval = rep->mode (); 2210 retval = rep->mode ();
2497 2211
2498 return retval; 2212 return retval;
2499 } 2213 }
2500 2214
2501 octave_base_stream::arch_type 2215 oct_mach_info::float_format
2502 octave_stream::architecture (void) 2216 octave_stream::float_format (void)
2503 { 2217 {
2504 octave_base_stream::arch_type retval = octave_base_stream::at_unknown; 2218 oct_mach_info::float_format retval = oct_mach_info::unknown;
2505 2219
2506 if (stream_ok ("architecture")) 2220 if (stream_ok ("float_format"))
2507 retval = rep->architecture (); 2221 retval = rep->float_format ();
2508 2222
2509 return retval; 2223 return retval;
2510 } 2224 }
2511 2225
2512 string 2226 string
2567 break; 2281 break;
2568 2282
2569 default: 2283 default:
2570 break; 2284 break;
2571 } 2285 }
2572
2573 return retval;
2574 }
2575
2576 string
2577 octave_stream::arch_as_string (octave_base_stream::arch_type at)
2578 {
2579 string retval = "unknown";
2580
2581 switch (at)
2582 {
2583 case octave_base_stream::at_native:
2584 retval = "native";
2585 break;
2586
2587 default:
2588 break;
2589 }
2590
2591 return retval;
2592 }
2593
2594 octave_base_stream::data_type
2595 octave_stream::string_to_data_type (const string& s)
2596 {
2597 octave_base_stream::data_type retval = octave_base_stream::dt_unknown;
2598
2599 // XXX FINISHME XXX
2600
2601 /*
2602 int16
2603 integer*2
2604 int32
2605 integer*4 */
2606
2607 // XXX FIXME XXX -- before checking s, need to strip spaces and downcase.
2608
2609 if (s == "char" || s == "char*1" || s == "integer*1" || s == "int8")
2610 retval = octave_base_stream::dt_char;
2611 else if (s == "schar" || s == "signedchar")
2612 retval = octave_base_stream::dt_schar;
2613 else if (s == "uchar" || s == "unsignedchar")
2614 retval = octave_base_stream::dt_uchar;
2615 else if (s == "short")
2616 retval = octave_base_stream::dt_short;
2617 else if (s == "ushort" || s == "unsignedshort")
2618 retval = octave_base_stream::dt_ushort;
2619 else if (s == "int")
2620 retval = octave_base_stream::dt_int;
2621 else if (s == "uint" || s == "unsignedint")
2622 retval = octave_base_stream::dt_uint;
2623 else if (s == "long")
2624 retval = octave_base_stream::dt_long;
2625 else if (s == "ulong" || s == "unsignedlong")
2626 retval = octave_base_stream::dt_ulong;
2627 else if (s == "float" || s == "float32" || s == "real*4")
2628 retval = octave_base_stream::dt_float;
2629 else if (s == "double" || s == "float64" || s == "real**")
2630 retval = octave_base_stream::dt_double;
2631 else
2632 ::error ("invalid data type specified");
2633
2634 return retval;
2635 }
2636
2637 octave_base_stream::arch_type
2638 octave_stream::string_to_arch_type (const string& s)
2639 {
2640 octave_base_stream::arch_type retval = octave_base_stream::at_unknown;
2641
2642 if (s == "native")
2643 retval = octave_base_stream::at_native;
2644 else
2645 ::error ("invalid architecture type specified");
2646 2286
2647 return retval; 2287 return retval;
2648 } 2288 }
2649 2289
2650 void 2290 void
2854 { 2494 {
2855 retval.resize (3); 2495 retval.resize (3);
2856 2496
2857 retval(0) = os->name (); 2497 retval(0) = os->name ();
2858 retval(1) = octave_stream::mode_as_string (os->mode ()); 2498 retval(1) = octave_stream::mode_as_string (os->mode ());
2859 retval(2) = octave_stream::arch_as_string (os->architecture ()); 2499 retval(2) = oct_mach_info::float_format_as_string (os->float_format ());
2860 } 2500 }
2861 else 2501 else
2862 ::error ("invalid file id"); 2502 ::error ("invalid file id");
2863 2503
2864 return retval; 2504 return retval;
2921 octave_stream *os = list (i); 2561 octave_stream *os = list (i);
2922 2562
2923 if (os) 2563 if (os)
2924 { 2564 {
2925 string mode = octave_stream::mode_as_string (os->mode ()); 2565 string mode = octave_stream::mode_as_string (os->mode ());
2926 string arch = octave_stream::arch_as_string (os->architecture ()); 2566
2567 string arch =
2568 oct_mach_info::float_format_as_string (os->float_format ());
2569
2927 string name = os->name (); 2570 string name = os->name ();
2928 2571
2929 buf.form (" %4d %-3s %-9s %s\n", 2572 buf.form (" %4d %-3s %-9s %s\n",
2930 i, mode.c_str (), arch.c_str (), name.c_str ()); 2573 i, mode.c_str (), arch.c_str (), name.c_str ());
2931 } 2574 }