octave-avbm: src/symtab.cc comparison

comparison src/symtab.cc @ 2856:8c516da3c1f7

[project @ 1997-03-31 06:37:21 by jwe]

author	jwe
date	Mon, 31 Mar 1997 06:39:28 +0000
parents	8b262e771614
children	55cca18e943a

comparison

equal deleted inserted replaced

-:1bb7dc230a4b
+:8c516da3c1f7
 symbol_def::~symbol_def (void)
 {
 delete definition;
 }
-int
+bool
 symbol_def::is_variable (void) const
 {
 return (type & USER_VARIABLE || type & BUILTIN_VARIABLE);
 }
-int
+bool
 symbol_def::is_function (void) const
 {
 return (type & USER_FUNCTION || type & BUILTIN_FUNCTION);
 }
-int
+bool
 symbol_def::is_user_variable (void) const
 {
 return (type & USER_VARIABLE);
 }
-int
+bool
 symbol_def::is_text_function (void) const
 {
 return (type & TEXT_FUNCTION);
 }
-int
+bool
 symbol_def::is_mapper_function (void) const
 {
 return (type & MAPPER_FUNCTION);
 }
-int
+bool
 symbol_def::is_user_function (void) const
 {
 return (type & USER_FUNCTION);
 }
-int
+bool
 symbol_def::is_builtin_variable (void) const
 {
 return (type & BUILTIN_VARIABLE);
 }
-int
+bool
 symbol_def::is_builtin_function (void) const
 {
 return (type & BUILTIN_FUNCTION);
 }
 // XXX FIXME XXX
-int
+bool
 symbol_def::is_map_element (const string& /* elts */) const
 {
 return 0;
 }
 }
 tree_fvc *
 symbol_record::def (void) const
 {
-return definition ? definition->def () : 0;
+return definition ? definition->def () : false;
 }
 void
 symbol_record::rename (const string& new_name)
 {
 if (! read_only_error ("rename"))
 nm = new_name;
 }
-int
+bool
 symbol_record::is_function (void) const
 {
-return definition ? definition->is_function () : 0;
+return definition ? definition->is_function () : false;
 }
-int
+bool
 symbol_record::is_text_function (void) const
 {
-return definition ? definition->is_text_function () : 0;
+return definition ? definition->is_text_function () : false;
 }
-int
+bool
 symbol_record::is_mapper_function (void) const
 {
-return definition ? definition->is_mapper_function () : 0;
+return definition ? definition->is_mapper_function () : false;
 }
-int
+bool
 symbol_record::is_user_function (void) const
 {
-return definition ? definition->is_user_function () : 0;
+return definition ? definition->is_user_function () : false;
 }
-int
+bool
 symbol_record::is_builtin_function (void) const
 {
-return definition ? definition->is_builtin_function () : 0;
+return definition ? definition->is_builtin_function () : false;
 }
-int
+bool
 symbol_record::is_variable (void) const
 {
-return definition ? definition->is_variable () : 0;
+return definition ? definition->is_variable () : false;
 }
-int
+bool
 symbol_record::is_user_variable (void) const
 {
-return definition ? definition->is_user_variable () : 0;
+return definition ? definition->is_user_variable () : false;
 }
-int
+bool
 symbol_record::is_builtin_variable (void) const
 {
-return definition ? definition->is_builtin_variable () : 0;
+return definition ? definition->is_builtin_variable () : false;
 }
-int
+bool
 symbol_record::is_map_element (const string& elts) const
 {
-return definition ? definition->is_map_element (elts) : 0;
+return definition ? definition->is_map_element (elts) : false;
 }
 unsigned
 symbol_record::type (void) const
 {
-return definition ? definition->type : 0;
+return definition ? definition->type : false;
 }
-int
+bool
 symbol_record::is_defined (void) const
 {
-return definition ? (definition->def () != 0) : 0;
+return definition ? (definition->def () != 0) : false;
 }
-int
+bool
 symbol_record::is_read_only (void) const
 {
-return definition ? definition->read_only : 0;
+return definition ? definition->read_only : false;
 }
-int
+bool
 symbol_record::is_eternal (void) const
 {
-return definition ? definition->eternal : 0;
+return definition ? definition->eternal : false;
 }
 void
 symbol_record::protect (void)
 {
 tree_constant *t = new tree_constant (v);
 return define (t);
 }
 int
-symbol_record::define (tree_builtin *t, int text_fcn)
+symbol_record::define (tree_builtin *t, bool text_fcn)
 {
 if (read_only_error ("redefine"))
 return 0;
 if (is_variable ())
 return 1;
 }
 int
-symbol_record::define (tree_function *t, int text_fcn)
+symbol_record::define (tree_function *t, bool text_fcn)
 {
 if (read_only_error ("redefine"))
 return 0;
 if (is_variable ())
 }
 return count;
 }
 void
-symbol_record::alias (symbol_record *s, int force)
+symbol_record::alias (symbol_record *s, bool force)
 {
 sv_fcn = s->sv_fcn;
 if (force && ! s->definition)
 {
 symbol_record::mark_as_formal_parameter (void)
 {
 formal_param = 1;
 }
-int
+bool
 symbol_record::is_formal_parameter (void) const
 {
 return formal_param;
 }
 symbol_record::mark_as_linked_to_global (void)
 {
 linked_to_global = 1;
 }
-int
+bool
 symbol_record::is_linked_to_global (void) const
 {
 return linked_to_global;
 }
 error ("can't make formal parameter static");
 else
 tagged_static = 1;
 }
-int
+bool
 symbol_record::is_static (void) const
 {
 return tagged_static;
 }
 const_type = s.const_type;
 }
 return *this;
 }
-int
+bool
 symbol_record_info::is_defined (void) const
 {
 return initialized;
 }
-int
+bool
 symbol_record_info::is_read_only (void) const
 {
 return read_only;
 }
-int
+bool
 symbol_record_info::is_eternal (void) const
 {
 return eternal;
 }
-int
+bool
 symbol_record_info::hides_fcn (void) const
 {
 return (hides & SR_INFO_USER_FUNCTION);
 }
-int
+bool
 symbol_record_info::hides_builtin (void) const
 {
 return (hides & SR_INFO_BUILTIN_FUNCTION);
 }
 retval = const_type;
 return retval;
 }
-int
+bool
 symbol_record_info::is_function (void) const
 {
 return (type == symbol_def::USER_FUNCTION
 	  || type == symbol_def::BUILTIN_FUNCTION
 	  || symbol_def::TEXT_FUNCTION
 symbol_table::symbol_table (void)
 {
 }
 symbol_record *
-symbol_table::lookup (const string& nm, int insert, int warn)
+symbol_table::lookup (const string& nm, bool insert, bool warn)
 {
 int index = hash (nm) & HASH_MASK;
 symbol_record *ptr = table[index].next ();
 error ("unable to rename `%s' to `%s'", old_name.c_str (),
 	 new_name.c_str ());
 }
 void
-symbol_table::clear (int clear_user_functions)
+symbol_table::clear (bool clear_user_functions)
 {
 for (int i = 0; i < HASH_TABLE_SIZE; i++)
 {
 symbol_record *ptr = table[i].next ();
 	}
 }
 }
 int
-symbol_table::clear (const string& nm, int clear_user_functions)
+symbol_table::clear (const string& nm, bool clear_user_functions)
 {
 int index = hash (nm) & HASH_MASK;
 symbol_record *ptr = table[index].next ();
 // This function should probably share code with symbol_table::list.
 // XXX FIXME XXX
 symbol_record_info *
 symbol_table::long_list (int& count, const string_vector& pats,
-			 int npats, int sort, unsigned type,
+			 int npats, bool sort, unsigned type,
 			 unsigned scope) const
 {
 count = 0;
 int n = size ();
 if (n == 0)
 return symbols;
 }
 string_vector
 symbol_table::list (int& count, const string_vector& pats, int npats,
-		    int sort, unsigned type, unsigned scope) const
+		    bool sort, unsigned type, unsigned scope) const
 {
 count = 0;
 int n = size ();
 if (n == 0)
 return 0;
 return h;
 }
 // Return nonzero if S is a valid identifier.
-int
+bool
 valid_identifier (const char *s)
 {
 if (! s || ! (isalnum (*s) || *s == '_'))
-return 0;
+return false;
 while (*++s != '\0')
 if (! (isalnum (*s) || *s == '_'))
-return 0;
+return false;
-return 1;
+return true;
 }
-int
+bool
 valid_identifier (const string& s)
 {
 return valid_identifier (s.c_str ());
 }

Mercurial > hg > octave-avbm

comparison src/symtab.cc @ 2856:8c516da3c1f7