octave-nkf: src/variables.cc comparison

comparison src/variables.cc @ 7336:745a8299c2b5

[project @ 2007-12-28 20:56:55 by jwe]

author	jwe
date	Fri, 28 Dec 2007 20:56:58 +0000
parents	97db94ae2cf0
children	0fa079d04772

comparison

equal deleted inserted replaced

-:58f5fab3ebe5
+:745a8299c2b5
 #endif
 #include <cstdio>
 #include <cstring>
+#include <iomanip>
 #include <set>
 #include <string>
 #include "file-stat.h"
 #include "oct-env.h"
 // Should Octave always check to see if function files have changed
 // since they were last compiled?
 static int Vignore_function_time_stamp = 1;
-// Symbol table for symbols at the top level.
+// Defines layout for the whos/who -long command
-symbol_table *top_level_sym_tab = 0;
+static std::string Vwhos_line_format
+= "  %a:4; %ln:6; %cs:16:6:8:1;  %rb:12;  %lc:-1;\n";
-// Symbol table for the current scope.
-symbol_table *curr_sym_tab = 0;
-// Symbol table for the current caller scope.
-symbol_table *curr_caller_sym_tab = 0;
-// Symbol table for global symbols.
-symbol_table *global_sym_tab = 0;
-// Symbol table for functions and built-in symbols.
-symbol_table *fbi_sym_tab = 0;
-bool
-at_top_level (void)
-{
-return (curr_sym_tab == top_level_sym_tab);
-}
-// Initialization.
-// Create the initial symbol tables and set the current scope at the
-// top level.
-void
-initialize_symbol_tables (void)
-{
-if (! fbi_sym_tab)
-fbi_sym_tab = new symbol_table (2048, "FBI");
-if (! global_sym_tab)
-global_sym_tab = new symbol_table (2048, "GLOBAL");
-if (! top_level_sym_tab)
-top_level_sym_tab = new symbol_table (4096, "TOP");
-curr_caller_sym_tab = curr_sym_tab = top_level_sym_tab;
-}
 void
 clear_mex_functions (void)
 {
-fbi_sym_tab->clear_mex_functions ();
+symbol_table::clear_mex_functions ();
+}
+void
+clear_function (const std::string& nm)
+{
+symbol_table::clear_function (nm);
+}
+void
+clear_variable (const std::string& nm)
+{
+symbol_table::clear_variable (nm);
+}
+void
+clear_symbol (const std::string& nm)
+{
+symbol_table::clear_symbol (nm);
 }
 // Attributes of variables and functions.
 // Is this a command-style function?
 static std::set <std::string> command_set;
-static inline bool
+void
-is_marked_as_command (const std::string& s)
-{
-return command_set.find (s) != command_set.end ();
-}
-static inline void
 mark_as_command (const std::string& s)
 {
 command_set.insert (s);
 }
 static inline void
 unmark_command (const std::string& s)
 {
 command_set.erase (s);
-symbol_record *sr = fbi_sym_tab->lookup (s);
-if (sr)
-sr->unmark_command ();
 }
 DEFCMD (mark_as_command, args, ,
 "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} mark_as_command (@var{name})\n\
 @seealso{unmark_command, iscommand}\n\
 @end deftypefn")
 {
 octave_value_list retval;
-if (at_top_level ())
+if (symbol_table::at_top_level ())
 {
 int nargin = args.length ();
 if (nargin > 0)
 	{
 @seealso{mark_as_command, iscommand}\n\
 @end deftypefn")
 {
 octave_value_list retval;
-if (at_top_level ())
+if (symbol_table::at_top_level ())
 {
 int nargin = args.length ();
 if (nargin > 0)
 	{
 }
 bool
 is_command_name (const std::string& s)
 {
-bool retval = false;
+return command_set.find (s) != command_set.end ();
+}
-symbol_record *sr = fbi_sym_tab->lookup (s);
-if (sr)
-{
-if (sr->is_command ())
-	retval = true;
-else if (is_marked_as_command (s))
-	{
-	  sr->mark_as_command ();
-	  retval = true;
-	}
-}
-else
-retval = is_marked_as_command (s);
-return retval;
-}
 DEFCMD (iscommand, args, ,
 "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} iscommand (@var{name})\n\
 Return true if @var{name} is a command style function.  If @var{name}\n\
 // Is this a raw input command?
 static std::set <std::string> rawcommand_set;
-bool
-is_marked_as_rawcommand (const std::string& s)
-{
-return rawcommand_set.find (s) != rawcommand_set.end ();
-}
 void
 mark_as_rawcommand (const std::string& s)
 {
 command_set.insert (s);
 rawcommand_set.insert (s);
 void
 unmark_rawcommand (const std::string& s)
 {
 rawcommand_set.erase (s);
-symbol_record *sr = fbi_sym_tab->lookup (s);
-if (sr)
-sr->unmark_rawcommand ();
 }
 DEFCMD (mark_as_rawcommand, args, ,
 "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} mark_as_rawcommand (@var{name})\n\
 @seealso{unmark_rawcommand, israwcommand, iscommand, mark_as_command}\n\
 @end deftypefn")
 {
 octave_value_list retval;
-if (at_top_level ())
+if (symbol_table::at_top_level ())
 {
 int nargin = args.length ();
 if (nargin > 0)
 	{
 @seealso{mark_as_rawcommand, israwcommand, iscommand, unmark_command}\n\
 @end deftypefn")
 {
 octave_value_list retval;
-if (at_top_level ())
+if (symbol_table::at_top_level ())
 {
 int nargin = args.length ();
 if (nargin > 0)
 	{
 }
 bool
 is_rawcommand_name (const std::string& s)
 {
-bool retval = false;
+return rawcommand_set.find (s) != rawcommand_set.end ();
-symbol_record *sr = fbi_sym_tab->lookup (s);
-if (sr)
-{
-if (sr->is_rawcommand ())
-	retval = true;
-else if (is_marked_as_rawcommand (s))
-	{
-	  sr->mark_as_rawcommand ();
-	  retval = true;
-	}
-}
-else
-retval = is_marked_as_rawcommand (s);
-return retval;
 }
 DEFCMD (israwcommand, args, ,
 "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} israwcommand (@var{name})\n\
 print_usage ();
 return retval;
 }
-// Is this a built-in function?
-bool
-is_builtin_function_name (const std::string& s)
-{
-symbol_record *sr = fbi_sym_tab->lookup (s);
-return (sr && sr->is_builtin_function ());
-}
-// Is this a mapper function?
-bool
-is_mapper_function_name (const std::string& s)
-{
-symbol_record *sr = fbi_sym_tab->lookup (s);
-return (sr && sr->is_mapper_function ());
-}
-// Is this function globally in this scope?
-bool
-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 std::string& fcn_name,
 		   const std::string& warn_for, bool warn)
 {
 octave_function *ans = 0;
-symbol_record *sr = 0;
 if (! fcn_name.empty ())
 {
-sr = fbi_sym_tab->lookup (fcn_name, true);
+octave_value val = symbol_table::find_function (fcn_name);
-lookup (sr, false);
+if (val.is_defined ())
-}
+	ans = val.function_value (true);
+}
-if (sr)
-{
+if (! ans && warn)
-octave_value tmp = sr->def ();
+error ("%s: the symbol `%s' is not valid as a function",
-ans = tmp.function_value (true);
+	   warn_for.c_str (), fcn_name.c_str ());
-}
-if (! sr || ! ans || ! sr->is_function ())
-{
-if (warn)
-	error ("%s: the symbol `%s' is not valid as a function",
-	       warn_for.c_str (), fcn_name.c_str ());
-ans = 0;
-}
 return ans;
 }
 octave_function *
 {
 bool retval = false;
 if (! name.empty ())
 {
-symbol_record *sr = curr_sym_tab->lookup (name);
+octave_value val = symbol_table::varval (name);
-if (! sr)
+retval = val.is_defined ();
-	sr = fbi_sym_tab->lookup (name);
-retval = (sr  && sr->is_variable ());
 }
 return retval;
 }
 {
 error ("isglobal: expecting std::string argument");
 return retval;
 }
-symbol_record *sr = curr_sym_tab->lookup (name);
+return symbol_table::is_global (name);
-retval = (sr && sr->is_linked_to_global ());
-return retval;
 }
 DEFUN (isglobal, args, ,
 "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} isglobal (@var{name})\n\
 // We shouldn't need to look in the global symbol table, since any
 // name that is visible in the current scope will be in the local
 // symbol table.
-symbol_record *sr = curr_sym_tab->lookup (symbol_name);
+octave_value_list evaluated_args;
+bool args_evaluated;
-if (! (sr && sr->is_defined ()))
-sr = fbi_sym_tab->lookup (symbol_name);
+octave_value val = symbol_table::find (symbol_name, 0, string_vector (),
+					 evaluated_args, args_evaluated);
-if (sr && sr->is_defined ())
+if (val.is_defined ())
 {
 bool not_a_struct = struct_elts.empty ();
-bool var_ok = not_a_struct || sr->is_map_element (struct_elts);
+bool var_ok = not_a_struct /* || val.is_map_element (struct_elts) */;
 if (! retval
 	  && var_ok
 	  && (type == "any" || type == "var")
-	  && sr->is_user_variable ())
+	  && val.is_constant ())
 	{
 	  retval = 1;
 	}
 if (! retval
 	  && (type == "any" || type == "builtin"))
 	{
-	  if (not_a_struct && sr->is_builtin_function ())
+	  if (not_a_struct && val.is_builtin_function ())
 	    {
 	      retval = 5;
 	    }
 	}
 if (! retval
 	  && not_a_struct
 	  && (type == "any" || type == "file")
-	  && (sr->is_user_function () || sr->is_dld_function ()))
+	  && (val.is_user_function () || val.is_dld_function ()))
 	{
-	  octave_value t = sr->def ();
+	  octave_function *f = val.function_value (true);
-	  octave_function *f = t.function_value (true);
 	  std::string s = f ? f->fcn_file_name () : std::string ();
-	  retval = s.empty () ? 103 : (sr->is_user_function () ? 2 : 3);
+	  retval = s.empty () ? 103 : (val.is_user_function () ? 2 : 3);
 	}
 }
 if (! (type == "var" || type == "builtin"))
 {
 print_usage ();
 return retval;
 }
-bool
-fcn_out_of_date (octave_function *fcn, const std::string& ff, time_t tp)
-{
-bool retval = false;
-fcn->mark_fcn_file_up_to_date (octave_time ());
-if (! (Vignore_function_time_stamp == 2
-	 || (Vignore_function_time_stamp && fcn->is_system_fcn_file ())))
-{
-file_stat fs (ff);
-if (fs && fs.is_newer (tp))
-	retval = true;
-}
-return retval;
-}
-// Is there a corresponding function file that is newer than the
-// symbol definition?
-static bool
-symbol_out_of_date (symbol_record *sr)
-{
-bool retval = false;
-if (sr)
-{
-octave_value ans = sr->def ();
-octave_function *fcn = ans.function_value (true);
-if (fcn)
-	{
-	  std::string ff = fcn->fcn_file_name ();
-	  if (! ff.empty ())
-	    {
-	      octave_time tc = fcn->time_checked ();
-	      bool relative = fcn->is_relative ();
-	      if (tc < Vlast_prompt_time
-		  || (relative && tc < Vlast_chdir_time))
-		{
-		  octave_time ottp = fcn->time_parsed ();
-		  time_t tp = ottp.unix_time ();
-		  std::string nm = fcn->is_nested_function ()
-		    ? fcn->parent_fcn_name () : fcn->name ();
-		  // FIXME -- the following code is repeated
-		  // in load_fcn_from_file in parse.y.
-		  int nm_len = nm.length ();
-		  std::string file;
-		  if (octave_env::absolute_pathname (nm)
-		      && ((nm_len > 4 && (nm.substr (nm_len-4) == ".oct"
-					  || nm.substr (nm_len-4) == ".mex"))
-			  || (nm_len > 2 && nm.substr (nm_len-4) == ".m")))
-		    {
-		      file = nm;
-		    }
-		  else
-		    {
-		      file = lookup_autoload (nm);
-		      if (file.empty ())
-			file = load_path::find_fcn (nm);
-		      file = octave_env::make_absolute (file, octave_env::getcwd ());
-		    }
-		  if (file.empty ())
-		    {
-		      // Can't see this function now, so we should
-		      // clear it.
-		      sr->clear ();
-		      retval = true;
-		    }
-		  else if (same_file (file, ff))
-		    {
-		      retval = fcn_out_of_date (fcn, ff, tp);
-		    }
-		  else
-		    {
-		      // Check the full function name.  Maybe we already
-		      // parsed it.
-		      symbol_record *full_sr = fbi_sym_tab->lookup (file);
-		      if (full_sr)
-			{
-			  octave_value v = full_sr->def ();
-			  if (v.is_function ())
-			    {
-			      // OK, swap the aliases around.
-			      // FIXME -- this is a bit
-			      // tricky, so maybe some refactoring is
-			      // in order here too...
-			      symbol_record *short_sr = fbi_sym_tab->lookup (nm);
-			      if (short_sr)
-				short_sr->alias (full_sr);
-			      // Make local symbol table entry point
-			      // to correct global function too.
-			      sr->alias (full_sr);
-			      fcn = v.function_value ();
-			      retval = fcn_out_of_date (fcn, file, tp);
-			    }
-			  else
-			    retval = true;
-			}
-		      else
-			retval = true;
-		    }
-		}
-	    }
-	}
-}
-return retval;
-}
-bool
-lookup (symbol_record *sym_rec, bool exec_script)
-{
-bool script_executed = false;
-if (! sym_rec->is_linked_to_global ())
-{
-if (sym_rec->is_defined ())
-	{
-	  if (sym_rec->is_function () && symbol_out_of_date (sym_rec))
-	    script_executed = load_fcn_from_file (sym_rec, exec_script);
-	}
-else if (! sym_rec->is_formal_parameter ())
-	{
-	  link_to_builtin_or_function (sym_rec);
-	  if (! sym_rec->is_defined ())
-	    script_executed = load_fcn_from_file (sym_rec, exec_script);
-	  else if (sym_rec->is_function () && symbol_out_of_date (sym_rec))
-	    script_executed = load_fcn_from_file (sym_rec, exec_script);
-	}
-}
-return script_executed;
-}
-// Get the symbol record for the given name that is visible in the
-// current scope.  Reread any function definitions that appear to be
-// 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 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
-lookup_function (const std::string& nm, const std::string& parent)
-{
-octave_value retval;
-symbol_record *sr = 0;
-if (! parent.empty ())
-sr = fbi_sym_tab->lookup (parent + ":" + nm);
-if (! sr || ! sr->is_function ())
-{
-if (curr_parent_function)
-	sr = fbi_sym_tab->lookup (curr_parent_function->name () + ":" + nm);
-if (! sr || ! sr->is_function ())
-	sr = fbi_sym_tab->lookup (nm, true);
-if (sr && ! sr->is_function ())
-	load_fcn_from_file (sr, false);
-}
-if (sr)
-{
-octave_value v = sr->def ();
-if (v.is_function ())
-	retval = v;
-}
-return retval;
-}
-octave_value
-lookup_user_function (const std::string& nm)
-{
-octave_value retval;
-symbol_record *sr = 0;
-if (curr_parent_function)
-{
-std::string parent = curr_parent_function->name ();
-sr = fbi_sym_tab->lookup (parent + ":" + nm);
-}
-if (! sr || ! sr->is_user_function ())
-{
-sr = fbi_sym_tab->lookup (nm, true);
-if (sr && ! sr->is_user_function ())
-	load_fcn_from_file (sr, false);
-}
-if (sr)
-retval = sr->def ();
-return retval;
-}
 octave_value
 lookup_function_handle (const std::string& nm)
 {
-octave_value retval;
+octave_value val = symbol_table::varval (nm);
-symbol_record *sr = curr_sym_tab->lookup (nm, true);
+return val.is_function_handle () ? val : octave_value ();
-if (sr && sr->def ().is_function_handle ())
-retval = sr->def ();
-return retval;
 }
 octave_value
 get_global_value (const std::string& nm, bool silent)
 {
-octave_value retval;
+octave_value val = symbol_table::varval (nm, symbol_table::global_scope ());
-symbol_record *sr = global_sym_tab->lookup (nm);
+if (val.is_undefined () && ! silent)
+error ("get_global_by_name: undefined symbol `%s'", nm.c_str ());
-if (sr)
-{
+return val;
-octave_value sr_def = sr->def ();
-if (sr_def.is_defined ())
-	retval = sr_def;
-else if (! silent)
-	error ("get_global_by_name: undefined symbol `%s'", nm.c_str ());
-}
-else if (! silent)
-error ("get_global_by_name: unknown symbol `%s'", nm.c_str ());
-return retval;
 }
 void
 set_global_value (const std::string& nm, const octave_value& val)
 {
-symbol_record *sr = global_sym_tab->lookup (nm, true);
+symbol_table::varref (nm, symbol_table::global_scope ()) = val;
-if (sr)
-sr->define (val);
-else
-panic_impossible ();
 }
 // Variable values.
 octave_value
 print_usage ();
 return retval;
 }
-// Global stuff and links to builtin variables and functions.
+struct
+symbol_record_name_compare
-// Make the definition of the symbol record sr be the same as the
+{
-// definition of the global variable of the same name, creating it if
+bool operator () (const symbol_table::symbol_record& a,
-// it doesn't already exist.
+		    const symbol_table::symbol_record& b)
+{
+std::string a_nm = a.name ();
+std::string b_nm = b.name ();
+return a_nm.compare (b_nm);
+}
+};
+struct
+whos_parameter
+{
+char command;
+char modifier;
+int parameter_length;
+int first_parameter_length;
+int dimensions;
+int balance;
+std::string text;
+std::string line;
+};
+static void
+print_descriptor (std::ostream& os, std::list<whos_parameter> params)
+{
+// This method prints a line of information on a given symbol
+std::list<whos_parameter>::iterator i = params.begin ();
+std::ostringstream param_buf;
+while (i != params.end ())
+{
+whos_parameter param = *i;
+if (param.command != '\0')
+{
+	  // Do the actual printing
+	  switch (param.modifier)
+	    {
+	    case 'l':
+	      os << std::setiosflags (std::ios::left) << std::setw (param.parameter_length);
+	      param_buf << std::setiosflags (std::ios::left) << std::setw (param.parameter_length);
+	      break;
+	    case 'r':
+	      os << std::setiosflags (std::ios::right) << std::setw (param.parameter_length);
+	      param_buf << std::setiosflags (std::ios::right) << std::setw (param.parameter_length);
+	      break;
+	    case 'c':
+	      if (param.command != 's')
+	        {
+		  os << std::setiosflags (std::ios::left)
+		     << std::setw (param.parameter_length);
+		  param_buf << std::setiosflags (std::ios::left)
+			    << std::setw (param.parameter_length);
+		}
+	      break;
+	    default:
+	      os << std::setiosflags (std::ios::left) << std::setw (param.parameter_length);
+	      param_buf << std::setiosflags (std::ios::left) << std::setw (param.parameter_length);
+	    }
+	  if (param.command == 's' && param.modifier == 'c')
+	    {
+	      int a, b;
+	      if (param.modifier == 'c')
+	        {
+		  a = param.first_parameter_length - param.balance;
+		  a = (a < 0 ? 0 : a);
+		  b = param.parameter_length - a - param.text . length ();
+		  b = (b < 0 ? 0 : b);
+		  os << std::setiosflags (std::ios::left) << std::setw (a)
+		     << "" << std::resetiosflags (std::ios::left) << param.text
+		     << std::setiosflags (std::ios::left)
+		     << std::setw (b) << ""
+		     << std::resetiosflags (std::ios::left);
+		  param_buf << std::setiosflags (std::ios::left) << std::setw (a)
+		     << "" << std::resetiosflags (std::ios::left) << param.line
+		     << std::setiosflags (std::ios::left)
+		     << std::setw (b) << ""
+		     << std::resetiosflags (std::ios::left);
+		}
+	    }
+	  else
+	    {
+	      os << param.text;
+	      param_buf << param.line;
+	    }
+	  os << std::resetiosflags (std::ios::left)
+	     << std::resetiosflags (std::ios::right);
+	  param_buf << std::resetiosflags (std::ios::left)
+		    << std::resetiosflags (std::ios::right);
+	  i++;
+	}
+else
+	{
+	  os << param.text;
+	  param_buf << param.line;
+	  i++;
+	}
+}
+os << param_buf.str ();
+}
+// Calculate how much space needs to be reserved for the first part of
+// the dimensions string.  For example,
+//
+//   mat is a 12x3 matrix
+//            ^^  => 2 columns
+static int
+dimensions_string_req_first_space (const dim_vector& dims, int print_dims)
+{
+int first_param_space = 0;
+// Calculating dimensions.
+std::string dim_str = "";
+std::stringstream ss;
+long dim = dims.length ();
+first_param_space = (first_param_space >= 1 ? first_param_space : 1);
+// Preparing dimension string.
+if ((dim <= print_dims || print_dims < 0) && print_dims != 0)
+{
+// Dimensions string must be printed like this: 2x3x4x2.
+if (dim == 0 || dim == 1)
+	first_param_space = 1; // First parameter is 1.
+else
+{
+	  ss << dims (0);
+	  dim_str = ss.str ();
+	  first_param_space = dim_str.length ();
+	}
+}
+else
+{
+// Printing dimension string as: a-D.
+ss << dim;
+dim_str = ss.str ();
+first_param_space = dim_str.length ();
+}
+return first_param_space;
+}
+// Make the dimensions-string.  For example: mat is a 2x3 matrix.
+//                                                    ^^^
+//
+// FIXME -- why not just use the dim_vector::str () method?
+std::string
+make_dimensions_string (const dim_vector& dims, int print_dims)
+{
+// Calculating dimensions.
+std::string dim_str = "";
+std::stringstream ss;
+long dim = dims.length ();
+// Preparing dimension string.
+if ((dim <= print_dims || print_dims < 0) && print_dims != 0)
+{
+// Only printing the dimension string as: axbxc...
+if (dim == 0)
+	ss << "1x1";
+else
+{
+	  for (int i = 0; i < dim; i++)
+	    {
+	      if (i == 0)
+		{
+		  if (dim == 1)
+		    {
+		      // Looks like this is not going to happen in
+		      // Octave, but ...
+		      ss << "1x" << dims (i);
+		    }
+		  else
+		    ss << dims (i);
+		}
+	      else if (i < dim && dim != 1)
+		ss << "x" << dims (i);
+	    }
+	}
+}
+else
+{
+// Printing dimension string as: a-D.
+ss << dim << "-D";
+}
+dim_str = ss.str ();
+return dim_str;
+}
+// Calculate how much space needs to be reserved for the
+// dimensions string.  For example,
+//
+//   mat is a 12x3 matrix
+//            ^^^^ => 4 columns
+//
+// FIXME -- why not just use the dim_vector::str () method?
+static int
+dimensions_string_req_total_space (const dim_vector& dims, int print_dims)
+{
+std::string dim_str = "";
+std::stringstream ss;
+ss << make_dimensions_string (dims, print_dims);
+dim_str = ss.str ();
+return dim_str.length ();
+}
+static std::list<whos_parameter>
+parse_whos_line_format (const std::list<symbol_table::symbol_record>& symbols)
+{
+// This method parses the string whos_line_format, and returns
+// a parameter list, containing all information needed to print
+// the given attributtes of the symbols
+int idx;
+size_t format_len = Vwhos_line_format.length ();
+char garbage;
+std::list<whos_parameter> params;
+size_t bytes1;
+int elements1;
+std::string param_string = "abcenst";
+Array<int> param_length (dim_vector (param_string.length (), 1));
+Array<std::string> param_names (dim_vector (param_string.length (), 1));
+size_t pos_a, pos_b, pos_c, pos_e, pos_n, pos_s, pos_t;
+pos_a = param_string.find ('a'); // Attributes
+pos_b = param_string.find ('b'); // Bytes
+pos_c = param_string.find ('c'); // Class
+pos_e = param_string.find ('e'); // Elements
+pos_n = param_string.find ('n'); // Name
+pos_s = param_string.find ('s'); // Size
+pos_t = param_string.find ('t'); // Type
+param_names(pos_a) = "Attr";
+param_names(pos_b) = "Bytes";
+param_names(pos_c) = "Class";
+param_names(pos_e) = "Elements";
+param_names(pos_n) = "Name";
+param_names(pos_s) = "Size";
+param_names(pos_t) = "Type";
+for (size_t i = 0; i < param_string.length (); i++)
+param_length(i) = param_names(i) . length ();
+// Calculating necessary spacing for name column,
+// bytes column, elements column and class column
+for (std::list<symbol_table::symbol_record>::const_iterator p = symbols.begin ();
+p != symbols.end (); p++)
+{
+std::stringstream ss1, ss2;
+std::string str;
+str = p->name ();
+param_length(pos_n) = ((str.length ()
+			      > static_cast<size_t> (param_length(pos_n)))
+			     ? str.length () : param_length(pos_n));
+octave_value val = p->varval ();
+str = val.type_name ();
+param_length(pos_t) = ((str.length ()
+			      > static_cast<size_t> (param_length(pos_t)))
+			     ? str.length () : param_length(pos_t));
+elements1 = val.capacity ();
+ss1 << elements1;
+str = ss1.str ();
+param_length(pos_e) = ((str.length ()
+			      > static_cast<size_t> (param_length(pos_e)))
+			     ? str.length () : param_length(pos_e));
+bytes1 = val.byte_size ();
+ss2 << bytes1;
+str = ss2.str ();
+param_length(pos_b) = ((str.length ()
+			      > static_cast<size_t> (param_length(pos_b)))
+			     ? str.length () : param_length (pos_b));
+}
+idx = 0;
+while (static_cast<size_t> (idx) < format_len)
+{
+whos_parameter param;
+param.command = '\0';
+if (Vwhos_line_format[idx] == '%')
+{
+	  bool error_encountered = false;
+	  param.modifier = 'r';
+	  param.parameter_length = 0;
+	  param.dimensions = 8;
+	  int a = 0, b = -1, c = 8, balance = 1;
+	  unsigned int items;
+	  size_t pos;
+	  std::string cmd;
+	  // Parse one command from whos_line_format
+	  cmd = Vwhos_line_format.substr (idx, Vwhos_line_format.length ());
+	  pos = cmd.find (';');
+	  if (pos != NPOS)
+	    cmd = cmd.substr (0, pos+1);
+	  else
+	    error ("parameter without ; in whos_line_format");
+	  idx += cmd.length ();
+	  // FIXME -- use iostream functions instead of sscanf!
+	  if (cmd.find_first_of ("crl") != 1)
+	    items = sscanf (cmd.c_str (), "%c%c:%d:%d:%d:%d;",
+			    &garbage, &param.command, &a, &b, &c, &balance);
+	  else
+	    items = sscanf (cmd.c_str (), "%c%c%c:%d:%d:%d:%d;",
+			    &garbage, &param.modifier, &param.command,
+			    &a, &b, &c, &balance) - 1;
+	  if (items < 2)
+	    {
+	      error ("whos_line_format: parameter structure without command in whos_line_format");
+	      error_encountered = true;
+	    }
+	  // Insert data into parameter
+	  param.first_parameter_length = 0;
+	  pos = param_string.find (param.command);
+	  if (pos != NPOS)
+	    {
+	      param.parameter_length = param_length(pos);
+	      param.text = param_names(pos);
+	      param.line.assign (param_names(pos).length (), '=');
+	      param.parameter_length = (a > param.parameter_length
+					? a : param.parameter_length);
+	      if (param.command == 's' && param.modifier == 'c' && b > 0)
+		param.first_parameter_length = b;
+	    }
+	  else
+	    {
+	      error ("whos_line_format: '%c' is not a command",
+		     param.command);
+	      error_encountered = true;
+	    }
+	  if (param.command == 's')
+	    {
+	      // Have to calculate space needed for printing matrix dimensions
+	      // Space needed for Size column is hard to determine in prior,
+	      // because it depends on dimensions to be shown. That is why it is
+	      // recalculated for each Size-command
+	      int first, rest = 0, total;
+	      param.dimensions = c;
+	      first = param.first_parameter_length;
+	      total = param.parameter_length;
+	      for (std::list<symbol_table::symbol_record>::const_iterator p = symbols.begin ();
+		   p != symbols.end (); p++)
+		{
+		  octave_value val = p->varval ();
+		  dim_vector dims = val.dims ();
+		  int first1 = dimensions_string_req_first_space (dims, param.dimensions);
+		  int total1 = dimensions_string_req_total_space (dims, param.dimensions);
+		  int rest1 = total1 - first1;
+		  rest = (rest1 > rest ? rest1 : rest);
+		  first = (first1 > first ? first1 : first);
+		  total = (total1 > total ? total1 : total);
+		}
+	      if (param.modifier == 'c')
+	        {
+		  if (first < balance)
+		    first += balance - first;
+		  if (rest + balance < param.parameter_length)
+		    rest += param.parameter_length - rest - balance;
+		  param.parameter_length = first + rest;
+		  param.first_parameter_length = first;
+		  param.balance = balance;
+		}
+	      else
+	        {
+		  param.parameter_length = total;
+		  param.first_parameter_length = 0;
+		}
+	    }
+	  else if (param.modifier == 'c')
+	    {
+	      error ("whos_line_format: modifier 'c' not available for command '%c'",
+		     param.command);
+	      error_encountered = true;
+	    }
+	  // What happens if whos_line_format contains negative numbers
+	  // at param_length positions?
+	  param.balance = (b < 0 ? 0 : param.balance);
+	  param.first_parameter_length = (b < 0 ? 0 :
+					  param.first_parameter_length);
+	  param.parameter_length = (a < 0
+				    ? 0
+				    : (param.parameter_length
+				       < param_length(pos_s)
+				       ? param_length(pos_s)
+				       : param.parameter_length));
+	  // Parameter will not be pushed into parameter list if ...
+	  if (! error_encountered)
+	    params.push_back (param);
+	}
+else
+{
+	  // Text string, to be printed as it is ...
+	  std::string text;
+	  size_t pos;
+	  text = Vwhos_line_format.substr (idx, Vwhos_line_format.length ());
+	  pos = text.find ('%');
+	  if (pos != NPOS)
+	    text = text.substr (0, pos);
+	  // Push parameter into list ...
+	  idx += text.length ();
+	  param.text=text;
+	  param.line.assign (text.length(), ' ');
+	  params.push_back (param);
+	}
+}
+return params;
+}
 void
-link_to_global_variable (symbol_record *sr)
+print_symbol_info_line (std::ostream& os,
-{
+			const symbol_table::symbol_record& sr,
-if (! sr->is_linked_to_global ())
+			std::list<whos_parameter>& params)
 {
-sr->mark_as_linked_to_global ();
+octave_value val = sr.varval ();
+dim_vector dims = val.dims ();
-if (! error_state)
-	{
+std::list<whos_parameter>::iterator i = params.begin ();
-	  std::string nm = sr->name ();
+while (i != params.end ())
-	  symbol_record *gsr = global_sym_tab->lookup (nm, true);
+{
+whos_parameter param = *i;
-	  // Make sure this symbol is a variable.
+if (param.command != '\0')
-	  if (! gsr->is_user_variable ())
+{
-	    gsr->define (octave_value ());
+	  // Do the actual printing.
-	  sr->alias (gsr);
+	  switch (param.modifier)
-	}
+	    {
-}
+	    case 'l':
-}
+	      os << std::setiosflags (std::ios::left)
+		 << std::setw (param.parameter_length);
-// Make the definition of the symbol record sr be the same as the
+	      break;
-// definition of the builtin variable of the same name.
+	    case 'r':
-// Make the definition of the symbol record sr be the same as the
+	      os << std::setiosflags (std::ios::right)
-// definition of the builtin function, or user function of the same
+		 << std::setw (param.parameter_length);
-// name, provided that the name has not been used as a formal parameter.
+	      break;
-void
+	    case 'c':
-link_to_builtin_or_function (symbol_record *sr)
+	      if (param.command == 's')
-{
+	        {
-std::string nm = sr->name ();
+		  int front = param.first_parameter_length
+		    - dimensions_string_req_first_space (dims, param.dimensions);
-symbol_record *tmp_sym = 0;
+		  int back = param.parameter_length
+		    - dimensions_string_req_total_space (dims, param.dimensions)
-octave_function *fcn = octave_call_stack::current ();
+		    - front;
+		  front = (front > 0) ? front : 0;
-std::string parent = fcn ? fcn->parent_fcn_name () : std::string ();
+		  back = (back > 0) ? back : 0;
-if (! parent.empty ())
+		  os << std::setiosflags (std::ios::left)
-tmp_sym = fbi_sym_tab->lookup (parent + ":" + nm);
+		     << std::setw (front)
+		     << ""
-if (! tmp_sym && curr_parent_function)
+		     << std::resetiosflags (std::ios::left)
-tmp_sym = fbi_sym_tab->lookup (curr_parent_function->name () + ":" + nm);
+		     << make_dimensions_string (dims, param.dimensions)
+		     << std::setiosflags (std::ios::left)
-if (! tmp_sym)
+		     << std::setw (back)
-tmp_sym = fbi_sym_tab->lookup (nm);
+		     << ""
+		     << std::resetiosflags (std::ios::left);
-if (tmp_sym
+		}
-&& tmp_sym->is_function ()
+	      else
-&& ! tmp_sym->is_formal_parameter ())
+	        {
-sr->alias (tmp_sym);
+		  os << std::setiosflags (std::ios::left)
-}
+		     << std::setw (param.parameter_length);
+		}
-// Force a link to a function in the current symbol table.  This is
+	      break;
-// used just after defining a function to avoid different behavior
-// depending on whether or not the function has been evaluated after
+	    default:
-// being defined.
+	      error ("whos_line_format: modifier `%c' unknown",
-//
+		     param.modifier);
-// Return without doing anything if there isn't a function with the
-// given name defined in the global symbol table.
+	      os << std::setiosflags (std::ios::right)
+		 << std::setw (param.parameter_length);
-void
+	    }
-force_link_to_function (const std::string& id_name)
-{
+	  switch (param.command)
-symbol_record *fsr = fbi_sym_tab->lookup (id_name, true);
+	    {
-if (fsr->is_function ())
+	    case 'a':
-{
+	      {
-curr_sym_tab->clear (id_name);
+		char tmp[5];
-symbol_record *csr = curr_sym_tab->lookup (id_name, true);
-csr->alias (fsr);
+		tmp[0] = (sr.is_automatic () ? 'a' : ' ');
-}
+		tmp[1] = (sr.is_formal () ? 'f' : ' ');
-}
+		tmp[2] = (sr.is_global () ? 'g' : ' ');
+		tmp[3] = (sr.is_persistent () ? 'p' : ' ');
-DEFUN (document, args, ,
+		tmp[4] = 0;
-"-*- texinfo -*-\n\
-@deftypefn {Built-in Function} {} document (@var{symbol}, @var{text})\n\
+		os << tmp;
-Set the documentation string for @var{symbol} to @var{text}.\n\
+	      }
-@end deftypefn")
+	      break;
+	    case 'b':
+	      os << val.byte_size ();
+	      break;
+	    case 'c':
+	      os << val.class_name ();
+	      break;
+	    case 'e':
+	      os << val.capacity ();
+	      break;
+	    case 'n':
+	      os << sr.name ();
+	      break;
+	    case 's':
+	      if (param.modifier != 'c')
+		os << make_dimensions_string (dims, param.dimensions);
+	      break;
+	    case 't':
+	      os << val.type_name ();
+	      break;
+	    default:
+	      error ("whos_line_format: command `%c' unknown", param.command);
+	    }
+	  os << std::resetiosflags (std::ios::left)
+	     << std::resetiosflags (std::ios::right);
+	  i++;
+}
+else
+	{
+	  os << param.text;
+	  i++;
+	}
+}
+}
+static octave_value
+do_who (int argc, const string_vector& argv, bool return_list,
+	bool verbose = false)
 {
 octave_value retval;
-int nargin = args.length ();
-if (nargin == 2)
-{
-std::string name = args(0).string_value ();
-if (! error_state)
-	{
-	  std::string help = args(1).string_value ();
-	  if (! error_state)
-	    {
-	      if (is_command_name (name)
-		  || is_mapper_function_name (name)
-		  || is_builtin_function_name (name))
-		error ("document: can't redefine help for built-in functions");
-	      else
-		{
-		  symbol_record *sym_rec = curr_sym_tab->lookup (name);
-		  if (sym_rec)
-		    sym_rec->document (help);
-		  else
-		    error ("document: no such symbol `%s'", name.c_str ());
-		}
-	    }
-	}
-}
-else
-print_usage ();
-return retval;
-}
-// FIXME -- this function is duplicated in symtab.cc with the
-// name maybe_list_cmp_fcn.
-static int
-symbol_record_name_compare (const void *a_arg, const void *b_arg)
-{
-const symbol_record *a = *(static_cast<symbol_record *const*> (a_arg));
-const symbol_record *b = *(static_cast<symbol_record *const*> (b_arg));
-std::string a_nm = a->name ();
-std::string b_nm = b->name ();
-return a_nm.compare (b_nm);
-}
-static octave_value
-do_who (int argc, const string_vector& argv, int return_list)
-{
-octave_value retval;
-bool show_builtins = false;
-bool show_functions = false;
-bool show_variables = false;
-bool show_verbose = false;
 std::string my_name = argv[0];
+bool global_only = false;
 int i;
 for (i = 1; i < argc; i++)
 {
-if (argv[i] == "-all" || argv[i] == "-a")
+if (argv[i] == "-regexp" || argv[i] == "-file")
 	{
-	  show_builtins = true;
+	  error ("%s: `%s' option not implemented", my_name.c_str (),
-	  show_functions = true;
+		 argv[i].c_str ());
-	  show_variables = true;
-	}
+	  return retval;
-else if (argv[i] == "-builtins" || argv[i] == "-b")
+	}
-	show_builtins = true;
+else if (argv[i] == "global")
-else if (argv[i] == "-functions" || argv[i] == "-f")
+	global_only = true;
-	show_functions = true;
-else if (argv[i] == "-long" || argv[i] == "-l")
-	show_verbose = true;
-else if (argv[i] == "-variables" || argv[i] == "-v")
-	show_variables = true;
 else if (argv[i][0] == '-')
 	warning ("%s: unrecognized option `%s'", my_name.c_str (),
 		 argv[i].c_str ());
 else
 	break;
 }
-// If no options were specified to select the type of symbol to
-// display, then set defaults.
-if (! (show_builtins || show_functions || show_variables))
-{
-show_functions = at_top_level ();
-show_variables = true;
-}
 int npats = argc - i;
-string_vector pats (npats);
+string_vector pats (npats > 0 ? npats : 1);
-for (int j = 0; j < npats; j++)
+if (npats > 0)
-pats[j] = argv[i+j];
+{
+for (int j = 0; j < npats; j++)
-// If the user specified -l and nothing else, show variables.  If
+	pats[j] = argv[i+j];
-// evaluating this at the top level, also show functions.
+}
+else
-if (show_verbose && ! (show_builtins || show_functions || show_variables))
+pats[0] = "*";
-{
-show_functions = at_top_level ();
+symbol_table::scope_id scope = global_only
-show_variables = 1;
+? symbol_table::global_scope () : symbol_table::current_scope ();
-}
+std::list<symbol_table::symbol_record> symbols
+= symbol_table::glob_variables (pats, scope);
+size_t symbols_len = symbols.size ();
 if (return_list)
 {
-// FIXME -- maybe symbol_list should return a std::list
+if (verbose)
-// object instead of an Array.
-dim_vector dv (0, 0);
-Array<symbol_record *> s3 (dv);
-Array<symbol_record *> s4 (dv);
-Array<symbol_record *> s5 (dv);
-Array<symbol_record *> s6 (dv);
-Array<symbol_record *> s7 (dv);
-Array<symbol_record *> s8 (dv);
-if (show_builtins)
-	{
-	  s3 = fbi_sym_tab->symbol_list (pats, symbol_record::BUILTIN_FUNCTION,
-					 SYMTAB_ALL_SCOPES);
-	}
-if (show_functions)
-	{
-	  s4 = fbi_sym_tab->symbol_list (pats, symbol_record::DLD_FUNCTION,
-					 SYMTAB_ALL_SCOPES);
-	  s5 = fbi_sym_tab->symbol_list (pats, symbol_record::USER_FUNCTION,
-					 SYMTAB_ALL_SCOPES);
-	  s6 = fbi_sym_tab->symbol_list (pats, symbol_record::MEX_FUNCTION,
-					 SYMTAB_ALL_SCOPES);
-	}
-if (show_variables)
-	{
-	  s7 = curr_sym_tab->symbol_list (pats, symbol_record::USER_VARIABLE,
-					  SYMTAB_LOCAL_SCOPE);
-	  s8 = curr_sym_tab->symbol_list (pats, symbol_record::USER_VARIABLE,
-					  SYMTAB_GLOBAL_SCOPE);
-	}
-octave_idx_type s3_len = s3.length ();
-octave_idx_type s4_len = s4.length ();
-octave_idx_type s5_len = s5.length ();
-octave_idx_type s6_len = s6.length ();
-octave_idx_type s7_len = s7.length ();
-octave_idx_type s8_len = s8.length ();
-octave_idx_type symbols_len
-	= s3_len + s4_len + s5_len + s6_len + s7_len + s8_len;
-Array<symbol_record *> symbols (dim_vector (symbols_len, 1));
-octave_idx_type k = 0;
-symbols.insert (s3, k, 0);
-k += s3_len;
-symbols.insert (s4, k, 0);
-k += s4_len;
-symbols.insert (s5, k, 0);
-k += s5_len;
-symbols.insert (s6, k, 0);
-k += s6_len;
-symbols.insert (s7, k, 0);
-k += s7_len;
-symbols.insert (s8, k, 0);
-symbols.qsort (symbol_record_name_compare);
-if (show_verbose)
 	{
 	  Array<octave_value> name_info (symbols_len, 1);
 	  Array<octave_value> size_info (symbols_len, 1);
 	  Array<octave_value> bytes_info (symbols_len, 1);
 	  Array<octave_value> class_info (symbols_len, 1);
 	  Array<octave_value> global_info (symbols_len, 1);
 	  Array<octave_value> sparse_info (symbols_len, 1);
 	  Array<octave_value> complex_info (symbols_len, 1);
 	  Array<octave_value> nesting_info (symbols_len, 1);
-	  for (octave_idx_type j = 0; j < symbols_len; j++)
+	  std::list<symbol_table::symbol_record>::const_iterator p
-	    {
+	    = symbols.begin ();
-	      symbol_record *sr = symbols(j);
+	  for (size_t j = 0; j < symbols_len; j++)
+	    {
+	      const symbol_table::symbol_record& sr = *p++;
 	      Octave_map ni;
 	      std::string caller_function_name;
 		caller_function_name = caller->name ();
 	      ni.assign ("function", caller_function_name);
 	      ni.assign ("level", 1);
-	      name_info(j) = sr->name ();
+	      name_info(j) = sr.name ();
-	      size_info(j) = sr->size ();
+	      global_info(j) = sr.is_global ();
-	      bytes_info(j) = sr->byte_size ();
-	      class_info(j) = sr->class_name ();
+	      octave_value val = sr.varval ();
-	      global_info(j) = sr->is_linked_to_global ();
-	      sparse_info(j) = sr->is_sparse_type ();
+	      size_info(j) = val.size ();
-	      complex_info(j) = sr->is_complex_type ();
+	      bytes_info(j) = val.byte_size ();
+	      class_info(j) = val.class_name ();
+	      sparse_info(j) = val.is_sparse_type ();
+	      complex_info(j) = val.is_complex_type ();
 	      nesting_info(j) = ni;
 	    }
 	  Octave_map info;
 	  if (symbols_len > 0)
 	    {
 	      names.resize (symbols_len);
-	      for (octave_idx_type j = 0; j < symbols_len; j++)
+	      std::list<symbol_table::symbol_record>::const_iterator p
-		names[j] = symbols(j)->name ();
+		= symbols.begin ();
+	      for (size_t j = 0; j < symbols_len; j++)
+		{
+		  names[j] = p->name ();
+		  p++;
+		}
 	    }
 	  retval = Cell (names);
 	}
 }
-else
+else if (symbols_len > 0)
 {
-int pad_after = 0;
+if (global_only)
+	octave_stdout << "Global variables:\n\n";
-if (show_builtins)
+else
-	{
+	octave_stdout << "Variables in the current scope:\n\n";
-	  pad_after += fbi_sym_tab->maybe_list
-	    ("*** built-in functions:", pats, octave_stdout,
+if (verbose)
-	     show_verbose, symbol_record::BUILTIN_FUNCTION, SYMTAB_ALL_SCOPES);
+	{
-	}
+	  size_t bytes = 0;
+	  size_t elements = 0;
-if (show_functions)
-	{
+	  std::list<whos_parameter> params;
-	  pad_after += fbi_sym_tab->maybe_list
-	    ("*** dynamically linked functions:", pats,
+	  params = parse_whos_line_format (symbols);
-	     octave_stdout, show_verbose, symbol_record::DLD_FUNCTION,
-	     SYMTAB_ALL_SCOPES);
+	  print_descriptor (octave_stdout, params);
-	  pad_after += fbi_sym_tab->maybe_list
+	  octave_stdout << "\n";
-	    ("*** currently compiled functions:", pats,
-	     octave_stdout, show_verbose, symbol_record::USER_FUNCTION,
+	  for (std::list<symbol_table::symbol_record>::const_iterator p = symbols.begin ();
-	     SYMTAB_ALL_SCOPES);
+	       p != symbols.end (); p++)
+	    {
-	  pad_after += fbi_sym_tab->maybe_list
+	      print_symbol_info_line (octave_stdout, *p, params);
-	    ("*** mex functions:", pats,
+	      octave_value val = p->varval ();
-	     octave_stdout, show_verbose, symbol_record::MEX_FUNCTION,
+	      elements += val.capacity ();
-	     SYMTAB_ALL_SCOPES);
+	      bytes += val.byte_size ();
-	}
+	    }
-if (show_variables)
+	  octave_stdout << "\nTotal is " << elements
-	{
+			<< (elements == 1 ? " element" : " elements")
-	  pad_after += curr_sym_tab->maybe_list
+			<< " using " << bytes
-	    ("*** local user variables:", pats, octave_stdout,
+			<< (bytes == 1 ? " byte" : " bytes") << "\n";
-	     show_verbose, symbol_record::USER_VARIABLE, SYMTAB_LOCAL_SCOPE);
+	}
+else
-	  pad_after += curr_sym_tab->maybe_list
+	{
-	    ("*** globally visible user variables:", pats,
+	  string_vector names (symbols_len);
-	     octave_stdout, show_verbose, symbol_record::USER_VARIABLE,
-	     SYMTAB_GLOBAL_SCOPE);
+	  std::list<symbol_table::symbol_record>::const_iterator p
-	}
+	    = symbols.begin ();
-if (pad_after)
+	  for (size_t j = 0; j < symbols_len; j++)
-	octave_stdout << "\n";
+	    {
+	      names[j] = p->name ();
+	      p++;
+	    }
+	  names.list_in_columns (octave_stdout);
+	}
+octave_stdout << "\n";
 }
 return retval;
 }
 {
 int argc = args.length () + 1;
 string_vector argv = args.make_argv ("who");
-if (error_state)
+if (! error_state)
-	return retval;
+	retval = do_who (argc, argv, nargout == 1);
-retval = do_who (argc, argv, nargout == 1);
 }
 else
 print_usage ();
 return retval;
 {
 octave_value retval;
 if (nargout < 2)
 {
-int nargin = args.length ();
+int argc = args.length () + 1;
-octave_value_list tmp_args;
+string_vector argv = args.make_argv ("whos");
-for (int i = nargin; i > 0; i--)
+if (! error_state)
-	tmp_args(i) = args(i-1);
+	retval = do_who (argc, argv, nargout == 1, true);
-tmp_args(0) = "-long";
-int argc = tmp_args.length () + 1;
-string_vector argv = tmp_args.make_argv ("whos");
-if (error_state)
-	return retval;
-retval = do_who (argc, argv, nargout == 1);
 }
 else
 print_usage ();
 return retval;
 // Defining variables.
 void
 bind_ans (const octave_value& val, bool print)
 {
-symbol_record *sr = curr_sym_tab->lookup ("ans", true);
+static std::string ans = "ans";
 if (val.is_defined ())
 {
-sr->define (val);
+symbol_table::varref (ans) = val;
 if (print)
-	val.print_with_name (octave_stdout, "ans");
+	val.print_with_name (octave_stdout, ans);
 }
 }
 void
 bind_internal_variable (const std::string& fname, const octave_value& val)
 feval (fname, args, 0);
 }
 void
-mlock (const std::string& nm)
+mlock (void)
 {
-symbol_record *sr = fbi_sym_tab->lookup (nm, true);
+octave_function *fcn = octave_call_stack::caller ();
-if (sr)
+if (fcn)
-sr->mark_as_static ();
+fcn->lock ();
+else
+error ("mlock: invalid use outside a function");
 }
 void
 munlock (const std::string& nm)
 {
-symbol_record *sr = fbi_sym_tab->lookup (nm);
+octave_value val = symbol_table::find_function (nm);
-if (sr && sr->is_static ())
+if (val.is_defined ())
-sr->unmark_static ();
+{
-else
+octave_function *fcn = val.function_value ();
-error ("munlock: %s is not locked", nm.c_str ());
+if (fcn)
+	fcn->unlock ();
+}
 }
 bool
 mislocked (const std::string& nm)
 {
-symbol_record *sr = fbi_sym_tab->lookup (nm);
+bool retval = false;
-return (sr && sr->is_static ());
+octave_value val = symbol_table::find_function (nm);
+if (val.is_defined ())
+{
+octave_function *fcn = val.function_value ();
+if (fcn)
+	retval = fcn->islocked ();
+}
+return retval;
 }
 DEFCMD (mlock, args, ,
 "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} mlock (@var{name})\n\
-Lock the named function into memory.  If no function is named\n\
+Lock the current function into memory so that it can't be cleared.\n\
-then lock in the current function.\n\
 @seealso{munlock, mislocked, persistent}\n\
 @end deftypefn")
 {
 octave_value_list retval;
-if (args.length () == 1)
+if (args.length () == 0)
-{
+mlock ();
-std::string name = args(0).string_value ();
-if (! error_state)
-	mlock (name);
-else
-	error ("mlock: expecting argument to be a function name");
-}
-else if (args.length () == 0)
-{
-octave_user_function *fcn = octave_call_stack::caller_user_function ();
-if (fcn)
-mlock (fcn->name ());
-else
-error ("mlock: invalid use outside a function");
-}
 else
 print_usage ();
 return retval;
 }
 else
 	error ("munlock: expecting argument to be a function name");
 }
 else if (args.length () == 0)
 {
-octave_user_function *fcn = octave_call_stack::caller_user_function ();
+octave_function *fcn = octave_call_stack::caller ();
 if (fcn)
-munlock (fcn->name ());
+fcn->unlock ();
 else
 error ("munlock: invalid use outside a function");
 }
 else
 print_usage ();
 else
 	error ("mislocked: expecting argument to be a function name");
 }
 else if (args.length () == 0)
 {
-octave_user_function *fcn = octave_call_stack::caller_user_function ();
+octave_function *fcn = octave_call_stack::caller ();
 if (fcn)
-retval = mislocked (fcn->name ());
+retval = fcn->islocked ();
 else
 error ("mislocked: invalid use outside a function");
 }
 else
 print_usage ();
 }
 return retval;
 }
-static inline bool
-is_local_variable (const std::string& nm)
-{
-symbol_record *sr = curr_sym_tab->lookup (nm);
-return (sr && sr->is_variable ());
-}
 static inline void
 maybe_warn_exclusive (bool exclusive)
 {
 if (exclusive)
 warning ("clear: ignoring --exclusive option");
 }
-static inline void
+static void
-do_clear_all (void)
-{
-curr_sym_tab->clear ();
-fbi_sym_tab->clear_functions ();
-global_sym_tab->clear ();
-}
-static inline void
-do_clear_functions (void)
-{
-curr_sym_tab->clear_functions ();
-fbi_sym_tab->clear_functions ();
-}
-static inline void
-do_clear_globals (void)
-{
-curr_sym_tab->clear_globals ();
-global_sym_tab->clear ();
-}
-static inline void
-do_clear_variables (void)
-{
-curr_sym_tab->clear ();
-}
-static inline bool
-do_clear_function (const std::string& nm)
-{
-bool b1 = curr_sym_tab->clear_function (nm);
-bool b2 = fbi_sym_tab->clear_function (nm);
-return b1 || b2;
-}
-static inline bool
-do_clear_global (const std::string& nm)
-{
-bool b1 = curr_sym_tab->clear_global (nm);
-bool b2 = global_sym_tab->clear_variable (nm);
-return b1 || b2;
-}
-static inline bool
-do_clear_variable (const std::string& nm)
-{
-return curr_sym_tab->clear_variable (nm);
-}
-static inline bool
-do_clear_symbol (const std::string& nm)
-{
-bool cleared = curr_sym_tab->clear_variable (nm);
-if (! cleared)
-cleared = do_clear_function (nm);
-return cleared;
-}
-static inline bool
-do_clear_function_pattern (const std::string& pat)
-{
-bool b1 = curr_sym_tab->clear_function_pattern (pat);
-bool b2 = fbi_sym_tab->clear_function_pattern (pat);
-return b1 || b2;
-}
-static inline bool
-do_clear_global_pattern (const std::string& pat)
-{
-bool b1 = curr_sym_tab->clear_global_pattern (pat);
-bool b2 = global_sym_tab->clear_variable_pattern (pat);
-return b1 || b2;
-}
-static inline bool
-do_clear_variable_pattern (const std::string& pat)
-{
-return curr_sym_tab->clear_variable_pattern (pat);
-}
-static inline bool
-do_clear_symbol_pattern (const std::string& pat)
-{
-// FIXME -- if we have a variable v1 and a function v2 and
-// someone says clear v*, we will clear the variable but not the
-// function.  Is that really what should happen?  (I think it is
-// what Matlab does.)
-bool cleared = curr_sym_tab->clear_variable_pattern (pat);
-if (! cleared)
-cleared = do_clear_function_pattern (pat);
-return cleared;
-}
-static inline void
 do_clear_functions (const string_vector& argv, int argc, int idx,
 		    bool exclusive = false)
 {
 if (idx == argc)
-do_clear_functions ();
+symbol_table::clear_functions ();
 else
 {
 if (exclusive)
 	{
-	  string_vector lfcns = curr_sym_tab->user_function_name_list ();
+	  string_vector fcns = symbol_table::user_function_names ();
-	  int lcount = lfcns.length ();
+	  int fcount = fcns.length ();
-	  for (int i = 0; i < lcount; i++)
+	  for (int i = 0; i < fcount; i++)
 	    {
-	      std::string nm = lfcns[i];
+	      std::string nm = fcns[i];
 	      if (! name_matches_any_pattern (nm, argv, argc, idx))
-		do_clear_function (nm);
+		symbol_table::clear_function (nm);
-	    }
-	  string_vector fcns = fbi_sym_tab->user_function_name_list ();
-	  int fcount = fcns.length ();
-	  for (int i = 0; i < fcount; i++)
-	    {
-	      std::string nm = fcns[i];
-	      if (! name_matches_any_pattern (nm, argv, argc, idx))
-		do_clear_function (nm);
 	    }
 	}
 else
 	{
 	  while (idx < argc)
-	    do_clear_function_pattern (argv[idx++]);
+	    symbol_table::clear_function_pattern (argv[idx++]);
 	}
 }
 }
-static inline void
+static void
 do_clear_globals (const string_vector& argv, int argc, int idx,
 		  bool exclusive = false)
 {
 if (idx == argc)
-do_clear_globals ();
+symbol_table::clear_variables(symbol_table::global_scope ());
 else
 {
 if (exclusive)
 	{
-	  string_vector lvars = curr_sym_tab->global_variable_name_list ();
+	  string_vector gvars
+	    = symbol_table::variable_names (symbol_table::global_scope ());
-	  int lcount = lvars.length ();
+	  int gcount = gvars.length ();
-	  for (int i = 0; i < lcount; i++)
-	    {
+	  for (int i = 0; i < gcount; i++)
-	      std::string nm = lvars[i];
+	    {
+	      std::string nm = gvars[i];
 	      if (! name_matches_any_pattern (nm, argv, argc, idx))
-		do_clear_global (nm);
+		symbol_table::clear_global (nm);
-	    }
-	  string_vector gvars = global_sym_tab->global_variable_name_list ();
-	  int gcount = gvars.length ();
-	  for (int i = 0; i < gcount; i++)
-	    {
-	      std::string nm = gvars[i];
-	      if (! name_matches_any_pattern (nm, argv, argc, idx))
-		do_clear_global (nm);
 	    }
 	}
 else
 	{
 	  while (idx < argc)
-	    do_clear_global_pattern (argv[idx++]);
+	    symbol_table::clear_global_pattern (argv[idx++]);
 	}
 }
 }
-static inline void
+static void
 do_clear_variables (const string_vector& argv, int argc, int idx,
 		    bool exclusive = false)
 {
 if (idx == argc)
-do_clear_variables ();
+symbol_table::clear_variables ();
 else
 {
 if (exclusive)
 	{
-	  string_vector lvars = curr_sym_tab->variable_name_list ();
+	  string_vector lvars = symbol_table::variable_names ();
 	  int lcount = lvars.length ();
 	  for (int i = 0; i < lcount; i++)
 	    {
 	      std::string nm = lvars[i];
 	      if (! name_matches_any_pattern (nm, argv, argc, idx))
-		do_clear_variable (nm);
+		symbol_table::clear_variable (nm);
 	    }
 	}
 else
 	{
 	  while (idx < argc)
-	    do_clear_variable_pattern (argv[idx++]);
+	    symbol_table::clear_variable_pattern (argv[idx++]);
 	}
 }
 }
-static inline void
+static void
 do_clear_symbols (const string_vector& argv, int argc, int idx,
 		  bool exclusive = false)
 {
 if (idx == argc)
-do_clear_variables ();
+symbol_table::clear_variables ();
 else
 {
 if (exclusive)
 	{
 	  // FIXME -- is this really what we want, or do we
 	  do_clear_functions (argv, argc, idx, exclusive);
 	}
 else
 	{
 	  while (idx < argc)
-	    do_clear_symbol_pattern (argv[idx++]);
+	    symbol_table::clear_symbol_pattern (argv[idx++]);
 	}
 }
 }
 static void
 {
 // This is supposed to be mostly Matlab compatible.
 for (; idx < argc; idx++)
 {
-if (argv[idx] == "all" && ! is_local_variable ("all"))
+if (argv[idx] == "all"
-	{
+	  && ! symbol_table::is_local_variable ("all"))
-	  do_clear_all ();
+	{
-	}
+	  symbol_table::clear_all ();
-else if (argv[idx] == "functions" && ! is_local_variable ("functions"))
+	}
+else if (argv[idx] == "functions"
+	       && ! symbol_table::is_local_variable ("functions"))
 	{
 	  do_clear_functions (argv, argc, ++idx);
 	}
-else if (argv[idx] == "global" && ! is_local_variable ("global"))
+else if (argv[idx] == "global"
+	       && ! symbol_table::is_local_variable ("global"))
 	{
 	  do_clear_globals (argv, argc, ++idx);
 	}
-else if (argv[idx] == "variables" && ! is_local_variable ("variables"))
+else if (argv[idx] == "variables"
-	{
+	       && ! symbol_table::is_local_variable ("variables"))
-	  do_clear_variables ();
+	{
-	}
+	  symbol_table::clear_variables ();
-else
+	}
-	{
+else
-	  do_clear_symbol_pattern (argv[idx]);
+	{
+	  symbol_table::clear_symbol_pattern (argv[idx]);
 	}
 }
 }
 #define CLEAR_OPTION_ERROR(cond) \
 return retval; \
 } \
 } \
 while (0)
-bool
-clear_function (const std::string& nm)
-{
-return do_clear_function (nm);
-}
-bool
-clear_variable (const std::string& nm)
-{
-return do_clear_variable (nm);
-}
-bool
-clear_symbol (const std::string& nm)
-{
-return do_clear_symbol (nm);
-}
 DEFCMD (clear, args, ,
 "-*- texinfo -*-\n\
 @deffn {Command} clear [-x] pattern @dots{}\n\
 Delete the names matching the given patterns from the symbol table.  The\n\
 pattern may contain the following special characters:\n\
 if (! error_state)
 {
 if (argc == 1)
 	{
-	  do_clear_variables ();
+	  symbol_table::clear_variables ();
 	}
 else
 	{
 	  int idx = 0;
 		      if (++idx < argc)
 			warning
 			  ("clear: ignoring extra arguments after -all");
-		      curr_sym_tab->clear ();
+		      symbol_table::clear_all ();
-		      fbi_sym_tab->clear_functions ();
-		      global_sym_tab->clear ();
 		    }
 		  else if (clear_functions)
 		    {
 		      do_clear_functions (argv, argc, idx, exclusive);
 		    }
 Undocumented internal function.\n\
 @end deftypefn")
 {
 octave_value_list retval;
-int nargin = args.length ();
+// FIXME -- what should this function do now?  Print a summary for
+// each scope?  Print the entire symbol table?  Accept a scope
-if (nargin == 1)
+// argument?
-{
-std::string arg = args(0).string_value ();
-if (arg == "fbi")
-	fbi_sym_tab->print_info (octave_stdout);
-else if (arg == "global")
-	global_sym_tab->print_info (octave_stdout);
-else if (arg == "top-level")
-	top_level_sym_tab->print_info (octave_stdout);
-else
-	{
-	  symbol_record *fsr = fbi_sym_tab->lookup (arg, true);
-	  if (fsr && fsr->is_user_function ())
-	    {
-	      octave_value tmp = fsr->def ();
-	      const octave_base_value& rep = tmp.get_rep ();
-	      const octave_user_function& fcn
-		= dynamic_cast<const octave_user_function&> (rep);
-	      fcn.print_symtab_info (octave_stdout);
-	    }
-	  else
-	    error ("no user-defined function named %s", arg.c_str ());
-	}
-}
-else if (nargin == 0)
-curr_sym_tab->print_info (octave_stdout);
-else
-print_usage ();
 return retval;
 }
 DEFUN (__print_symbol_info__, args, ,
 Undocumented internal function.\n\
 @end deftypefn")
 {
 octave_value_list retval;
-int nargin = args.length ();
+// FIXME -- what should this function do now?
-if (nargin == 1)
+return retval;
-{
+}
-std::string symbol_name = args(0).string_value ();
+DEFUN (whos_line_format, args, nargout,
-if (! error_state)
+"-*- texinfo -*-\n\
-	{
+@deftypefn {Built-in Function} {@var{val} =} whos_line_format ()\n\
-	  symbol_record *sr = curr_sym_tab->lookup (symbol_name);
+@deftypefnx {Built-in Function} {@var{old_val} =} whos_line_format (@var{new_val})\n\
+Query or set the format string used by the @code{whos}.\n\
-	  if (sr)
+\n\
-	    sr->print_info (octave_stdout);
+The following escape sequences may be used in the format:\n\
-	  else
+@table @code\n\
-	    error ("__print_symbol_info__: symbol %s not found",
+@item %a\n\
-		   symbol_name.c_str ());
+Prints attributes of variables (g=global, p=persistent,\n\
-	}
+f=formal parameter, a=automatic variable).\n\
-else
+@item %b\n\
-	print_usage ();
+Prints number of bytes occupied by variables.\n\
-}
+@item %c\n\
-else
+Prints class names of variables.\n\
-print_usage ();
+@item %e\n\
+Prints elements held by variables.\n\
-return retval;
+@item %n\n\
-}
+Prints variable names.\n\
+@item %s\n\
-DEFUN (ignore_function_time_stamp, args, nargout,
+Prints dimensions of variables.\n\
-"-*- texinfo -*-\n\
+@item %t\n\
-@deftypefn {Built-in Function} {@var{val} =} ignore_function_time_stamp ()\n\
+Prints type names of variables.\n\
-@deftypefnx {Built-in Function} {@var{old_val} =} ignore_function_time_stamp (@var{new_val})\n\
+@end table\n\
-Query or set the internal variable that controls whether Octave checks\n\
+\n\
-the time stamp on files each time it looks up functions defined in\n\
+Every command may also have a modifier:\n\
-function files.  If the internal variable is set to @code{\"system\"},\n\
+@table @code\n\
-Octave will not automatically recompile function files in subdirectories of\n\
+@item l\n\
-@file{@var{octave-home}/lib/@var{version}} if they have changed since\n\
+Left alignment.\n\
-they were last compiled, but will recompile other function files in the\n\
+@item r\n\
-search path if they change.  If set to @code{\"all\"}, Octave will not\n\
+Right alignment (this is the default).\n\
-recompile any function files unless their definitions are removed with\n\
+@item c\n\
-@code{clear}.  If set to \"none\", Octave will always check time stamps\n\
+Centered (may only be applied to command %s).\n\
-on files to determine whether functions defined in function files\n\
+@end table\n\
-need to be recompiled.\n\
+\n\
+A command is composed like this:\n\
+\n\
+@example\n\
+%[modifier]<command>[:size_of_parameter[:center-specific[\n\
+:print_dims[:balance]]]];\n\
+@end example\n\
+\n\
+Command and modifier is already explained. Size_of_parameter\n\
+tells how many columns the parameter will need for printing.\n\
+print_dims tells how many dimensions to print. If number of\n\
+dimensions exceeds print_dims, dimensions will be printed like\n\
+x-D.\n\
+center-specific and print_dims may only be applied to command\n\
+%s. A negative value for print_dims will cause Octave to print all\n\
+dimensions whatsoever.\n\
+balance specifies the offset for printing of the dimensions string.\n\
+\n\
+The default format is \"  %a:4; %ln:6; %cs:16:6:8:1;  %rb:12;  %lc:-1;\\n\".\n\
 @end deftypefn")
 {
-octave_value retval;
+return SET_INTERNAL_VARIABLE (whos_line_format);
-if (nargout > 0)
-{
-switch (Vignore_function_time_stamp)
-	{
-	case 1:
-	  retval = "system";
-	  break;
-	case 2:
-	  retval = "all";
-	  break;
-	default:
-	  retval = "none";
-	  break;
-	}
-}
-int nargin = args.length ();
-if (nargin == 1)
-{
-std::string sval = args(0).string_value ();
-if (! error_state)
-	{
-	  if (sval == "all")
-	    Vignore_function_time_stamp = 2;
-	  else if (sval == "system")
-	    Vignore_function_time_stamp = 1;
-	  else if (sval == "none")
-	    Vignore_function_time_stamp = 0;
-	  else
-	    error ("ignore_function_time_stamp: expecting argument to be \"all\", \"system\", or \"none\"");
-	}
-else
-	error ("ignore_function_time_stamp: expecting argument to be character string");
-}
-else if (nargin > 1)
-print_usage ();
-return retval;
 }
 /*
 ;;; Local Variables: ***
 ;;; mode: C++ ***

Mercurial > octave-nkf

comparison src/variables.cc @ 7336:745a8299c2b5