octave-nkf: src/variables.cc comparison

comparison src/variables.cc @ 3523:b80bbb43a1a9

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

author	jwe
date	Wed, 02 Feb 2000 10:26:25 +0000
parents	78e1e0007f0f
children	ab7fa5a8f23f

comparison

equal deleted inserted replaced

-:bd422cf62f0c
+:b80bbb43a1a9
 // Attributes of variables and functions.
 // Is this variable a builtin?
 bool
-is_builtin_variable (const string& name)
+is_builtin_variable (const std::string& name)
 {
 symbol_record *sr = global_sym_tab->lookup (name);
 return (sr && sr->is_builtin_variable ());
 }
 // Is this a text-style function?
 bool
-is_text_function_name (const string& s)
+is_text_function_name (const std::string& s)
 {
 symbol_record *sr = global_sym_tab->lookup (s);
 return (sr && sr->is_text_function ());
 }
 // Is this a built-in function?
 bool
-is_builtin_function_name (const string& s)
+is_builtin_function_name (const std::string& s)
 {
 symbol_record *sr = global_sym_tab->lookup (s);
 return (sr && sr->is_builtin_function ());
 }
 // Is this a mapper function?
 bool
-is_mapper_function_name (const string& s)
+is_mapper_function_name (const std::string& s)
 {
 symbol_record *sr = global_sym_tab->lookup (s);
 return (sr && sr->is_mapper_function ());
 }
 // Is this function globally in this scope?
 bool
-is_globally_visible (const string& name)
+is_globally_visible (const std::string& name)
 {
 symbol_record *sr = curr_sym_tab->lookup (name);
 return (sr && sr->is_linked_to_global ());
 }
 // Is this octave_value a valid function?
 octave_function *
-is_valid_function (const string& fcn_name, const string& warn_for, bool warn)
+is_valid_function (const std::string& fcn_name, const std::string& warn_for, bool warn)
 {
 octave_function *ans = 0;
 symbol_record *sr = 0;
 return ans;
 }
 octave_function *
-is_valid_function (const octave_value& arg, const string& warn_for, bool warn)
+is_valid_function (const octave_value& arg, const std::string& warn_for, bool warn)
 {
 octave_function *ans = 0;
-string fcn_name;
+std::string fcn_name;
 if (arg.is_string ())
 fcn_name = arg.string_value ();
 if (! error_state)
 return ans;
 }
 octave_function *
-extract_function (const octave_value& arg, const string& warn_for,
+extract_function (const octave_value& arg, const std::string& warn_for,
-		  const string& fname, const string& header,
+		  const std::string& fname, const std::string& header,
-		  const string& trailer)
+		  const std::string& trailer)
 {
 octave_function *retval = 0;
 retval = is_valid_function (arg, warn_for, 0);
 if (! retval)
 {
-string s = arg.string_value ();
+std::string s = arg.string_value ();
-string cmd = header;
+std::string cmd = header;
 cmd.append (s);
 cmd.append (trailer);
 if (! error_state)
 	{
 return retval;
 }
 string_vector
-get_struct_elts (const string& text)
+get_struct_elts (const std::string& text)
 {
 int n = 1;
 size_t pos = 0;
 return retval;
 }
 string_vector
-generate_struct_completions (const string& text, string& prefix, string& hint)
+generate_struct_completions (const std::string& text, std::string& prefix, std::string& hint)
 {
 string_vector names;
 size_t pos = text.rfind ('.');
-string id;
+std::string id;
 string_vector elts;
 if (pos == NPOS)
 {
 hint = text;
 return names;
 }
 bool
-looks_like_struct (const string& text)
+looks_like_struct (const std::string& text)
 {
 bool retval = true;
 string_vector elts = get_struct_elts (text);
-string id = elts[0];
+std::string id = elts[0];
 symbol_record *sr = curr_sym_tab->lookup (id);
 if (! sr)
 sr = global_sym_tab->lookup (id);
 {
 print_usage ("is_global");
 return retval;
 }
-string name = args(0).string_value ();
+std::string name = args(0).string_value ();
 if (error_state)
 {
-error ("is_global: expecting string argument");
+error ("is_global: expecting std::string argument");
 return retval;
 }
 symbol_record *sr = curr_sym_tab->lookup (name);
 {
 print_usage ("exist");
 return retval;
 }
-string name = args(0).string_value ();
+std::string name = args(0).string_value ();
 if (error_state)
 {
-error ("exist: expecting string argument");
+error ("exist: expecting std::string argument");
 return retval;
 }
-string struct_elts;
+std::string struct_elts;
-string symbol_name = name;
+std::string symbol_name = name;
 size_t pos = name.find ('.');
 if (pos != NPOS && pos > 0)
 {
 {
 retval = 2.0;
 }
 else
 {
-string path = fcn_file_in_path (name);
+std::string path = fcn_file_in_path (name);
 if (path.length () > 0)
 	{
 	  retval = 2.0;
 	}
 	    {
 	      retval = 3.0;
 	    }
 	  else
 	    {
-	      string file_name = file_in_path (name, "");
+	      std::string file_name = file_in_path (name, "");
 	      if (! file_name.empty ())
 		{
 		  file_stat fs (file_name);
 octave_function *tmp = ans.function_value (true);
 if (tmp)
 	{
-	  string ff = tmp->fcn_file_name ();
+	  std::string ff = tmp->fcn_file_name ();
 	  if (! (ff.empty ()
 		 || (Vignore_function_time_stamp
 		     && tmp->is_system_fcn_file ())))
 	    {
 	      if (tmp->time_checked () < Vlast_prompt_time)
 		{
 		  time_t tp = tmp->time_parsed ();
-		  string fname;
+		  std::string fname;
 		  if (tmp->is_dld_function ())
 		    fname = ff;
 		  else
 		    fname = fcn_file_in_path (ff);
 // out of date.  If a function is available in a file but is not
 // currently loaded, this will load it and insert the name in the
 // current symbol table.
 symbol_record *
-lookup_by_name (const string& nm, bool exec_script)
+lookup_by_name (const std::string& nm, bool exec_script)
 {
 symbol_record *sym_rec = curr_sym_tab->lookup (nm, true);
 lookup (sym_rec, exec_script);
 return sym_rec;
 }
 octave_value
-get_global_value (const string& nm)
+get_global_value (const std::string& nm)
 {
 octave_value retval;
 symbol_record *sr = global_sym_tab->lookup (nm);
 return retval;
 }
 void
-set_global_value (const string& nm, const octave_value& val)
+set_global_value (const std::string& nm, const octave_value& val)
 {
 symbol_record *sr = global_sym_tab->lookup (nm, true);
 if (sr)
 sr->define (val);
 // Variable values.
 // Look for the given name in the global symbol table.  If it refers
 // to a string, return a new copy.  If not, return 0;
-string
+std::string
-builtin_string_variable (const string& name)
+builtin_string_variable (const std::string& name)
 {
 symbol_record *sr = global_sym_tab->lookup (name);
 // It is a prorgramming error to look for builtins that aren't.
 assert (sr);
-string retval;
+std::string retval;
 octave_value val = sr->def ();
 if (! error_state && val.is_string ())
 retval = val.string_value ();
 // Look for the given name in the global symbol table.  If it refers
 // to a real scalar, place the value in d and return 1.  Otherwise,
 // return 0.
 int
-builtin_real_scalar_variable (const string& name, double& d)
+builtin_real_scalar_variable (const std::string& name, double& d)
 {
 int status = 0;
 symbol_record *sr = global_sym_tab->lookup (name);
 // It is a prorgramming error to look for builtins that aren't.
 }
 // Look for the given name in the global symbol table.
 octave_value
-builtin_any_variable (const string& name)
+builtin_any_variable (const std::string& name)
 {
 symbol_record *sr = global_sym_tab->lookup (name);
 // It is a prorgramming error to look for builtins that aren't.
 {
 sr->mark_as_linked_to_global ();
 if (! error_state)
 	{
-	  string nm = sr->name ();
+	  std::string nm = sr->name ();
 	  symbol_record *gsr = global_sym_tab->lookup (nm, true);
 	  // There must be a better way to do this.   XXX FIXME XXX
 //
 // Return without doing anything if there isn't a function with the
 // given name defined in the global symbol table.
 void
-force_link_to_function (const string& id_name)
+force_link_to_function (const std::string& id_name)
 {
 symbol_record *gsr = global_sym_tab->lookup (id_name, true);
 if (gsr->is_function ())
 {
 curr_sym_tab->clear (id_name);
 int nargin = args.length ();
 if (nargin == 2)
 {
-string name = args(0).string_value ();
+std::string name = args(0).string_value ();
 if (! error_state)
 	{
-	  string help = args(1).string_value ();
+	  std::string help = args(1).string_value ();
 	  if (! error_state)
 	    {
 	      if (is_builtin_variable (name)
 		  || is_text_function_name (name)
 bool show_builtins = false;
 bool show_functions = false;
 bool show_variables = false;
 bool show_verbose = false;
-string my_name = argv[0];
+std::string my_name = argv[0];
 int i;
 for (i = 1; i < argc; i++)
 {
 if (argv[i] == "-all" || argv[i] == "-a")
 // How is this different than install_builtin_constant?  Are both
 // functions needed?
 void
-bind_builtin_constant (const string& name, const octave_value& val,
+bind_builtin_constant (const std::string& name, const octave_value& val,
-		       bool protect, bool eternal, const string& help)
+		       bool protect, bool eternal, const std::string& help)
 {
 symbol_record *sym_rec = global_sym_tab->lookup (name, true);
 sym_rec->unprotect ();
-string tmp_help = help.empty () ? sym_rec->help () : help;
+std::string tmp_help = help.empty () ? sym_rec->help () : help;
 sym_rec->define_builtin_const (val);
 sym_rec->document (tmp_help);
 // How is this different than install_builtin_variable?  Are both
 // functions needed?
 void
-bind_builtin_variable (const string& varname, const octave_value& val,
+bind_builtin_variable (const std::string& varname, const octave_value& val,
 		       bool protect, bool eternal,
 		       symbol_record::change_function chg_fcn,
-		       const string& help)
+		       const std::string& help)
 {
 symbol_record *sr = global_sym_tab->lookup (varname, true);
 // It is a programming error for a builtin symbol to be missing.
 // Besides, we just inserted it, so it must be there.
 // pattern matching code if the string doesn't contain any
 // globbing patterns.
 for (int k = idx; k < argc; k++)
 	{
-	  string patstr = argv[k];
+	  std::string patstr = argv[k];
 	  if (! patstr.empty ())
 	    {
 	      glob_match pattern (patstr);
 	      int lcount = lvars.length ();
 	      for (int i = 0; i < lcount; i++)
 		{
-		  string nm = lvars[i];
+		  std::string nm = lvars[i];
 		  int match = pattern.match (nm);
 		  if ((exclusive && ! match) || (! exclusive && match))
 		    curr_sym_tab->clear (nm);
 		}
 	      int gcount = gvars.length ();
 	      for (int i = 0; i < gcount; i++)
 		{
-		  string nm = gvars[i];
+		  std::string nm = gvars[i];
 		  int match = pattern.match (nm);
 		  if ((exclusive && ! match) || (! exclusive && match))
 		    {
 		      int count = curr_sym_tab->clear (nm);
 		      if (count > 0)
 		}
 	      int fcount = fcns.length ();
 	      for (int i = 0; i < fcount; i++)
 		{
-		  string nm = fcns[i];
+		  std::string nm = fcns[i];
 		  int match = pattern.match (nm);
 		  if ((exclusive && ! match) || (! exclusive && match))
 		    {
 		      curr_sym_tab->clear (nm);
 		      global_sym_tab->clear (nm, clear_user_functions);
 int nargin = args.length ();
 if (nargin == 1)
 {
-string arg = args(0).string_value ();
+std::string arg = args(0).string_value ();
 if (arg == "global")
 	global_sym_tab->print_stats ();
 else
 	print_usage ("__dump_symtab_info__");
 int nargin = args.length ();
 if (nargin == 1)
 {
-string symbol_name = args(0).string_value ();
+std::string symbol_name = args(0).string_value ();
 if (! error_state)
 	{
 	  symbol_record *sr = curr_sym_tab->lookup (symbol_name);
 static int
 ignore_function_time_stamp (void)
 {
 int pref = 0;
-string val = builtin_string_variable ("ignore_function_time_stamp");
+std::string val = builtin_string_variable ("ignore_function_time_stamp");
 if (! val.empty ())
 {
 if (val.compare ("all", 0, 3) == 0)
 	pref = 2;

Mercurial > octave-nkf

comparison src/variables.cc @ 3523:b80bbb43a1a9