octave-nkf: src/load-save.cc comparison

comparison src/load-save.cc @ 3523:b80bbb43a1a9

[project @ 2000-02-02 10:25:52 by jwe]

author	jwe
date	Wed, 02 Feb 2000 10:26:25 +0000
parents	d14c483b3c12
children	97cf542676e1

comparison

equal deleted inserted replaced

-:bd422cf62f0c
+:b80bbb43a1a9
 // The number of decimal digits to use when writing ascii data.
 static bool Vcrash_dumps_octave_core;
 // The default output format.  May be one of "binary", "text", or
 // "mat-binary".
-static string Vdefault_save_format;
+static std::string Vdefault_save_format;
 // The number of decimal digits to use when writing ascii data.
 static int Vsave_precision;
 // Used when converting Inf to something that gnuplot can read.
 return true;
 }
 static bool
-valid_identifier (const string& s)
+valid_identifier (const std::string& s)
 {
 return valid_identifier (s.c_str ());
 }
 // XXX FIXME XXX -- shouldn't this be implemented in terms of other
 // Functions for reading ascii data.
 // Skip white space and comments on stream IS.
 static void
-skip_comments (istream& is)
+skip_comments (std::istream& is)
 {
 char c = '\0';
 while (is.get (c))
 {
 if (c == ' ' || c == '\t' || c == '\n')
 // Input should look something like:
 //
 //  #[ \t]*keyword[ \t]*:[ \t]*string-value[ \t]*\n
 static char *
-extract_keyword (istream& is, const char *keyword)
+extract_keyword (std::istream& is, const char *keyword)
 {
 char *retval = 0;
 char c;
 while (is.get (c))
 {
 if (c == '#')
 	{
-	  ostrstream buf;
+	  std::ostrstream buf;
 	  while (is.get (c) && (c == ' ' || c == '\t' || c == '#'))
 	    ; // Skip whitespace and comment characters.
 	  if (isalpha (c))
 	  int match = (strncmp (tmp, keyword, strlen (keyword)) == 0);
 	  delete [] tmp;
 	  if (match)
 	    {
-	      ostrstream value;
+	      std::ostrstream value;
 	      while (is.get (c) && (c == ' ' || c == '\t' || c == ':'))
 		; // Skip whitespace and the colon.
 	      if (c != '\n')
 		{
 // Input should look something like:
 //
 //  [ \t]*keyword[ \t]*int-value.*\n
 static bool
-extract_keyword (istream& is, const char *keyword, int& value)
+extract_keyword (std::istream& is, const char *keyword, int& value)
 {
 bool status = false;
 value = 0;
 char c;
 while (is.get (c))
 {
 if (c == '#')
 	{
-	  ostrstream buf;
+	  std::ostrstream buf;
 	  while (is.get (c) && (c == ' ' || c == '\t' || c == '#'))
 	    ; // Skip whitespace and comment characters.
 	  if (isalpha (c))
 //
 // XXX FIXME XXX -- this format is fairly rigid, and doesn't allow for
 // arbitrary comments, etc.  Someone should fix that.
 static char *
-read_ascii_data (istream& is, const string& filename, bool& global,
+read_ascii_data (std::istream& is, const std::string& filename, bool& global,
 		 octave_value& tc, int count)
 {
 // Read name for this entry or break on EOF.
 char *name = extract_keyword (is, "name");
 //         data           string         length
 //
 // FILENAME is used for error messages.
 static char *
-read_binary_data (istream& is, bool swap,
+read_binary_data (std::istream& is, bool swap,
 		  oct_mach_info::float_format fmt,
-		  const string& filename, bool& global,
+		  const std::string& filename, bool& global,
 		  octave_value& tc, char *&doc)
 {
 char tmp = 0;
 FOUR_BYTE_INT name_len = 0;
 return name;
 }
 static string
-get_mat_data_input_line (istream& is)
+get_mat_data_input_line (std::istream& is)
 {
-string retval;
+std::string retval;
 bool have_data = false;
 do
 {
 return retval;
 }
 static void
-get_lines_and_columns (istream& is, const string& filename, int& nr, int& nc)
+get_lines_and_columns (std::istream& is, const std::string& filename, int& nr, int& nc)
 {
 streampos pos = is.tellg ();
 int file_line_number = 0;
 nr = 0;
 nc = 0;
 while (is && ! error_state)
 {
-string buf = get_mat_data_input_line (is);
+std::string buf = get_mat_data_input_line (is);
 file_line_number++;
 size_t beg = buf.find_first_not_of (" \t");
 // FILENAME is used for error messages.
 //
 // This format provides no way to tag the data as global.
 static char *
-read_mat_ascii_data (istream& is, const string& filename,
+read_mat_ascii_data (std::istream& is, const std::string& filename,
 		     octave_value& tc)
 {
 char *name = 0;
-string varname;
+std::string varname;
 size_t pos = filename.rfind ('/');
 if (pos != NPOS)
 varname = filename.substr (pos+1);
 	  else
 	    {
 	      double d;
 	      for (int i = 0; i < nr; i++)
 		{
-		  string buf = get_mat_data_input_line (is);
+		  std::string buf = get_mat_data_input_line (is);
-		  istrstream tmp_stream (buf.c_str ());
+		  std::istrstream tmp_stream (buf.c_str ());
 		  for (int j = 0; j < nc; j++)
 		    {
 		      tmp_stream >> d;
 // the bytes of each element before copying to DATA.  FLT_FMT
 // specifies the format of the data if we are reading floating point
 // numbers.
 static void
-read_mat_binary_data (istream& is, double *data, int precision,
+read_mat_binary_data (std::istream& is, double *data, int precision,
 		      int len, bool swap,
 		      oct_mach_info::float_format flt_fmt)
 {
 switch (precision)
 {
 break;
 }
 }
 static int
-read_mat_file_header (istream& is, bool& swap, FOUR_BYTE_INT& mopt,
+read_mat_file_header (std::istream& is, bool& swap, FOUR_BYTE_INT& mopt,
 		      FOUR_BYTE_INT& nr, FOUR_BYTE_INT& nc,
 		      FOUR_BYTE_INT& imag, FOUR_BYTE_INT& len,
 		      int quiet = 0)
 {
 swap = false;
 // FILENAME is used for error messages.
 //
 // This format provides no way to tag the data as global.
 static char *
-read_mat_binary_data (istream& is, const string& filename,
+read_mat_binary_data (std::istream& is, const std::string& filename,
 		      octave_value& tc)
 {
 // These are initialized here instead of closer to where they are
 // first used to avoid errors from gcc about goto crossing
 // initialization of variable.
 // Return TRUE if NAME matches one of the given globbing PATTERNS.
 static bool
 matches_patterns (const string_vector& patterns, int pat_idx,
-		  int num_pat, const string& name)
+		  int num_pat, const std::string& name)
 {
 for (int i = pat_idx; i < num_pat; i++)
 {
 glob_match pattern (patterns[i]);
 }
 return false;
 }
 static int
-read_binary_file_header (istream& is, bool& swap,
+read_binary_file_header (std::istream& is, bool& swap,
 			 oct_mach_info::float_format& flt_fmt,
 			 bool quiet = false)
 {
 int magic_len = 10;
 char magic [magic_len+1];
 return 0;
 }
 static load_save_format
-get_file_format (const string& fname, const string& orig_fname)
+get_file_format (const std::string& fname, const std::string& orig_fname)
 {
 load_save_format retval = LS_UNKNOWN;
-ifstream file (fname.c_str ());
+std::ifstream file (fname.c_str ());
 if (! file)
 {
 error ("load: couldn't open input file `%s'", orig_fname.c_str ());
 return retval;
 return retval;
 }
 static octave_value_list
-do_load (istream& stream, const string& orig_fname, bool force,
+do_load (std::istream& stream, const std::string& orig_fname, bool force,
 	 load_save_format format, oct_mach_info::float_format flt_fmt,
 	 bool list_only, bool swap, bool verbose, const string_vector& argv,
 	 int argv_idx, int argc, int nargout)
 {
 octave_value_list retval;
-ostrstream output_buf;
+std::ostrstream output_buf;
 int count = 0;
 for (;;)
 {
 bool global = false;
 octave_value tc;
 {
 print_usage ("load");
 return retval;
 }
-string orig_fname = argv[i];
+std::string orig_fname = argv[i];
 oct_mach_info::float_format flt_fmt = oct_mach_info::unknown;
 bool swap = false;
 else
 	error ("load: must specify file format if reading from stdin");
 }
 else
 {
-string fname = file_ops::tilde_expand (argv[i]);
+std::string fname = file_ops::tilde_expand (argv[i]);
 if (format == LS_UNKNOWN)
 	format = get_file_format (fname, orig_fname);
 if (format != LS_UNKNOWN)
 	  unsigned mode = ios::in;
 	  if (format == LS_BINARY || format == LS_MAT_BINARY)
 	    mode |= ios::bin;
-	  ifstream file (fname.c_str (), mode);
+	  std::ifstream file (fname.c_str (), mode);
 	  if (file)
 	    {
 	      if (format == LS_BINARY)
 		{
 }
 // Return TRUE if PATTERN has any special globbing chars in it.
 static bool
-glob_pattern_p (const string& pattern)
+glob_pattern_p (const std::string& pattern)
 {
 int open = 0;
 int len = pattern.length ();
 // Save the data from TC along with the corresponding NAME, help
 // string DOC, and global flag MARK_AS_GLOBAL on stream OS in the
 // binary format described above for read_binary_data.
 static bool
-save_binary_data (ostream& os, const octave_value& tc,
+save_binary_data (std::ostream& os, const octave_value& tc,
-		  const string& name, const string& doc,
+		  const std::string& name, const std::string& doc,
 		  bool mark_as_global, bool save_as_floats)
 {
 FOUR_BYTE_INT name_len = name.length ();
 os.write (&name_len, 4);
 charMatrix chm = tc.char_matrix_value ();
 for (int i = 0; i < nr; i++)
 	{
 	  FOUR_BYTE_INT len = chm.cols ();
 	  os.write (&len, 4);
-	  string tstr = chm.row_as_string (i);
+	  std::string tstr = chm.row_as_string (i);
 	  const char *tmp = tstr.data ();
 	  os.write (tmp, len);
 	}
 }
 else if (tc.is_range ())
 // Save the data from TC along with the corresponding NAME on stream OS
 // in the MatLab binary format.
 static bool
-save_mat_binary_data (ostream& os, const octave_value& tc,
+save_mat_binary_data (std::ostream& os, const octave_value& tc,
-		      const string& name)
+		      const std::string& name)
 {
 FOUR_BYTE_INT mopt = 0;
 mopt += tc.is_string () ? 1 : 0;
 return os;
 }
 static void
-ascii_save_type (ostream& os, const char *type, bool mark_as_global)
+ascii_save_type (std::ostream& os, const char *type, bool mark_as_global)
 {
 if (mark_as_global)
 os << "# type: global ";
 else
 os << "# type: ";
 // Returns 1 for success and 0 for failure.
 // XXX FIXME XXX -- should probably write the help string here too.
 bool
-save_ascii_data (ostream& os, const octave_value& tc,
+save_ascii_data (std::ostream& os, const octave_value& tc,
-		 const string& name, bool strip_nan_and_inf,
+		 const std::string& name, bool strip_nan_and_inf,
 		 bool mark_as_global, int precision)
 {
 bool success = true;
 if (! precision)
 os << "# elements: " << elements << "\n";
 for (int i = 0; i < elements; i++)
 	{
 	  int len = chm.cols ();
 	  os << "# length: " << len << "\n";
-	  string tstr = chm.row_as_string (i);
+	  std::string tstr = chm.row_as_string (i);
 	  const char *tmp = tstr.data ();
 	  os.write (tmp, len);
 	  os << "\n";
 	}
 }
 }
 // Save the info from sr on stream os in the format specified by fmt.
 static void
-do_save (ostream& os, symbol_record *sr, load_save_format fmt,
+do_save (std::ostream& os, symbol_record *sr, load_save_format fmt,
 	 int save_as_floats)
 {
 if (! sr->is_variable ())
 {
 error ("save: can only save variables, not functions");
 return;
 }
-string name = sr->name ();
+std::string name = sr->name ();
-string help = sr->help ();
+std::string help = sr->help ();
 int global = sr->is_linked_to_global ();
 octave_value tc = sr->def ();
 if (tc.is_undefined ())
 // Save variables with names matching PATTERN on stream OS in the
 // format specified by FMT.  If SAVE_BUILTINS is TRUE, also save
 // builtin variables with names that match PATTERN.
 static int
-save_vars (ostream& os, const string& pattern, bool save_builtins,
+save_vars (std::ostream& os, const std::string& pattern, bool save_builtins,
 	   load_save_format fmt, int save_as_floats)
 {
 Array<symbol_record *> vars = curr_sym_tab->glob
 (pattern, symbol_record::USER_VARIABLE, SYMTAB_ALL_SCOPES);
 static load_save_format
 get_default_save_format (void)
 {
 load_save_format retval = LS_ASCII;
-string fmt = Vdefault_save_format;
+std::string fmt = Vdefault_save_format;
 if (fmt == "binary")
 retval = LS_BINARY;
 else if (fmt == "mat-binary" || fmt =="mat_binary")
 retval = LS_MAT_BINARY;
 return retval;
 }
 static void
-write_header (ostream& os, load_save_format format)
+write_header (std::ostream& os, load_save_format format)
 {
 switch (format)
 {
 case LS_BINARY:
 {
 break;
 case LS_ASCII:
 {
 	octave_gmtime now;
-	string time_string = now.asctime ();
+	std::string time_string = now.asctime ();
 	time_string = time_string.substr (0, time_string.length () - 1);
 	os << "# Created by Octave " OCTAVE_VERSION ", "
 	   << time_string
 	   << " <"
 }
 }
 static void
 save_vars (const string_vector& argv, int argv_idx, int argc,
-	   ostream& os, bool save_builtins, load_save_format fmt,
+	   std::ostream& os, bool save_builtins, load_save_format fmt,
 	   bool save_as_floats, bool write_header_info)
 {
 if (write_header_info)
 write_header (os, fmt);
 unsigned mode = ios::out|ios::trunc;
 if (format == LS_BINARY || format == LS_MAT_BINARY)
 	mode |= ios::bin;
-ofstream file (fname, mode);
+std::ofstream file (fname, mode);
 if (file)
 	{
 	  save_vars (string_vector (), 0, 0, file, false, format, false, true);
 	  message (0, "save to `%s' complete", fname);
 print_usage ("save");
 return retval;
 }
 else
 {
-string fname = file_ops::tilde_expand (argv[i]);
+std::string fname = file_ops::tilde_expand (argv[i]);
 i++;
 unsigned mode = ios::out;
 if (format == LS_BINARY || format == LS_MAT_BINARY)
 	mode |= ios::bin;
 mode |= append ? ios::ate : ios::trunc;
-ofstream file (fname.c_str (), mode);
+std::ofstream file (fname.c_str (), mode);
 if (file)
 	{
 	  bool write_header_info
 	    = ((file.rdbuf ())->seekoff (0, ios::cur) == 0);
 // If TC is matrix, save it on stream OS in a format useful for
 // making a 3-dimensional plot with gnuplot.  If PARAMETRIC is
 // TRUE, assume a parametric 3-dimensional plot will be generated.
 bool
-save_three_d (ostream& os, const octave_value& tc, bool parametric)
+save_three_d (std::ostream& os, const octave_value& tc, bool parametric)
 {
 bool fail = false;
 int nr = tc.rows ();
 int nc = tc.columns ();
 static int
 default_save_format (void)
 {
 int status = 0;
-string s = builtin_string_variable ("default_save_format");
+std::string s = builtin_string_variable ("default_save_format");
 if (s.empty ())
 {
 gripe_invalid_value_specified ("default_save_format");
 status = -1;

Mercurial > octave-nkf

comparison src/load-save.cc @ 3523:b80bbb43a1a9