octave-nkf: src/variables.cc comparison

comparison src/variables.cc @ 2086:bfb775fb6fe8

[project @ 1996-04-25 05:55:19 by jwe]

author	jwe
date	Thu, 25 Apr 1996 05:55:19 +0000
parents	36800cb7fe04
children	4dcc8b77e84a

comparison

equal deleted inserted replaced

-:7603b37325db
+:bfb775fb6fe8
 {
 symbol_record *sr = curr_sym_tab->lookup (name, 0, 0);
 return (sr && sr->is_linked_to_global ());
 }
-// Is this tree_constant a valid function?
+// Is this octave_value a valid function?
 tree_fvc *
-is_valid_function (const tree_constant& arg, const string& warn_for, int warn)
+is_valid_function (const octave_value& arg, const string& warn_for, int warn)
 {
 tree_fvc *ans = 0;
 string fcn_name;
 DEFUN (is_global, args, ,
 "is_global (X): return 1 if the string X names a global variable\n\
 otherwise, return 0.")
 {
-Octave_object retval = 0.0;
+octave_value_list retval = 0.0;
 int nargin = args.length ();
 if (nargin != 1)
 {
 1 : NAME is a variable\n\
 2 : NAME is a function\n\
 3 : NAME is a .oct file in the current LOADPATH\n\
 5 : NAME is a built-in function")
 {
-Octave_object retval;
+octave_value_list retval;
 int nargin = args.length ();
 if (nargin != 1)
 {
 if (! struct_elts.empty ())
 	{
 	  retval = 0.0;
 	  if (def->is_constant ())
 	    {
-	      tree_constant *tmp = (tree_constant *) def;
+	      octave_value *tmp = (octave_value *) def;
-	      tree_constant ult	= tmp->lookup_map_element (struct_elts, 0, 1);
+	      octave_value ult	= tmp->lookup_map_element (struct_elts, 0, 1);
 	      if (ult.is_defined ())
 		retval = 1.0;
 	    }
 	}
 tree_fvc *defn = sr->def ();
 if (defn)
 {
-tree_constant val = defn->eval (0);
+octave_value val = defn->eval (0);
 if (! error_state && val.is_string ())
 	retval = val.string_value ();
 }
 tree_fvc *defn = sr->def ();
 if (defn)
 {
-tree_constant val = defn->eval (0);
+octave_value val = defn->eval (0);
 if (! error_state && val.is_scalar_type ())
 	{
 	  d = val.double_value ();
 	  status = 1;
 return status;
 }
 // Look for the given name in the global symbol table.
-tree_constant
+octave_value
 builtin_any_variable (const string& name)
 {
-tree_constant retval;
+octave_value retval;
 symbol_record *sr = global_sym_tab->lookup (name, 0, 0);
 // It is a prorgramming error to look for builtins that aren't.
 if (sr->is_variable ())
 {
 // Would be nice not to have this cast.  XXX FIXME XXX
-tree_constant *tmp = (tree_constant *) sr->def ();
+octave_value *tmp = (octave_value *) sr->def ();
 if (tmp)
-	tmp = new tree_constant (*tmp);
+	tmp = new octave_value (*tmp);
 else
-	tmp = new tree_constant ();
+	tmp = new octave_value ();
 gsr->define (tmp);
 }
 else
 sr->clear ();
 // If the global symbol is currently defined as a function, we need
 // to hide it with a variable.
 if (gsr->is_function ())
-gsr->define ((tree_constant *) 0);
+gsr->define ((octave_value *) 0);
 sr->alias (gsr, 1);
 sr->mark_as_linked_to_global ();
 }
 DEFUN_TEXT (document, args, ,
 "document symbol string ...\n\
 \n\
 Associate a cryptic message with a variable name.")
 {
-Octave_object retval;
+octave_value_list retval;
 int argc = args.length () + 1;
 string_vector argv = args.make_argv ("document");
 }
 // XXX FIXME XXX -- this should take a list of regular expressions
 // naming the variables to look for.
-static Octave_object
+static octave_value_list
 do_who (int argc, const string_vector& argv)
 {
-Octave_object retval;
+octave_value_list retval;
 int show_builtins = 0;
 int show_functions = (curr_sym_tab == top_level_sym_tab);
 int show_variables = 1;
 int show_verbose = 0;
 "who [-all] [-builtins] [-functions] [-long] [-variables]\n\
 \n\
 List currently defined symbol(s).  Options may be shortened to one\n\
 character, but may not be combined.")
 {
-Octave_object retval;
+octave_value_list retval;
 int argc = args.length () + 1;
 string_vector argv = args.make_argv ("who");
 "whos [-all] [-builtins] [-functions] [-long] [-variables]\n\
 \n\
 List currently defined symbol(s).  Options may be shortened to one\n\
 character, but may not be combined.")
 {
-Octave_object retval;
+octave_value_list retval;
 int nargin = args.length ();
-Octave_object tmp_args;
+octave_value_list tmp_args;
 for (int i = nargin; i > 0; i--)
 tmp_args(i) = args(i-1);
 tmp_args(0) = "-long";
 int argc = tmp_args.length () + 1;
 bind_builtin_variable (v.name, v.value, v.protect, v.eternal,
 			   v.sv_function, v.help_string);
 }
 void
-install_builtin_variable_as_function (const string& name, tree_constant *val,
+install_builtin_variable_as_function (const string& name, octave_value *val,
 				      int protect, int eternal,
 				      const string& help)
 {
 symbol_record *sym_rec = global_sym_tab->lookup (name, 1);
 sym_rec->unprotect ();
 #if 0
 void
 bind_nargin_and_nargout (symbol_table *sym_tab, int nargin, int nargout)
 {
-tree_constant *tmp;
+octave_value *tmp;
 symbol_record *sr;
 sr = sym_tab->lookup ("nargin", 1, 0);
 sr->unprotect ();
-tmp = new tree_constant (nargin);
+tmp = new octave_value (nargin);
 sr->define (tmp);
 sr = sym_tab->lookup ("nargout", 1, 0);
 sr->unprotect ();
-tmp = new tree_constant (nargout);
+tmp = new octave_value (nargout);
 sr->define (tmp);
 }
 #endif
 void
-bind_ans (const tree_constant& val, int print)
+bind_ans (const octave_value& val, int print)
 {
 static symbol_record *sr = global_sym_tab->lookup ("ans", 1, 0);
 tree_identifier *ans_id = new tree_identifier (sr);
-tree_constant *tmp = new tree_constant (val);
+octave_value *tmp = new octave_value (val);
 // XXX FIXME XXX -- making ans_id static, passing its address to
 // tree_simple_assignment_expression along with a flag to not delete
 // it seems to create a memory leak.  Hmm.
 // How is this different than install_builtin_variable?  Are both
 // functions needed?
 void
-bind_builtin_variable (const string& varname, tree_constant *val,
+bind_builtin_variable (const string& varname, octave_value *val,
 		       int protect, int eternal, sv_Function sv_fcn,
 		       const string& help)
 {
 symbol_record *sr = global_sym_tab->lookup (varname, 1, 0);
 sr->document (help);
 }
 void
-bind_builtin_variable (const string& varname, const tree_constant& val,
+bind_builtin_variable (const string& varname, const octave_value& val,
 		       int protect, int eternal, sv_Function sv_fcn,
 		       const string& help)
 {
-tree_constant *tc = new tree_constant (val);
+octave_value *tc = new octave_value (val);
 bind_builtin_variable (varname, tc, protect, eternal, sv_fcn, help);
 }
 // XXX FIXME XX -- these should probably be moved to where they
 // logically belong instead of being all grouped here.
 If no arguments are given, clear all user-defined variables and
 functions.\n\
 \n\
 With -x, exclude the named variables")
 {
-Octave_object retval;
+octave_value_list retval;
 int argc = args.length () + 1;
 string_vector argv = args.make_argv ("clear");

Mercurial > octave-nkf

comparison src/variables.cc @ 2086:bfb775fb6fe8