Mercurial > octave-antonio

diff src/ov-typeinfo.cc @ 10315:57a59eae83cc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
untabify src C++ source files
author John W. Eaton <jwe@octave.org>
date Thu, 11 Feb 2010 12:41:46 -0500
parents cd96d29c5efa
children 12884915a8e4
line wrap: on
line diff
--- a/src/ov-typeinfo.cc	Thu Feb 11 12:23:32 2010 -0500
+++ b/src/ov-typeinfo.cc	Thu Feb 11 12:41:46 2010 -0500
@@ -59,8 +59,8 @@
 
 int
 octave_value_typeinfo::register_type (const std::string& t_name,
-				      const std::string& c_name,
-				      const octave_value& val)
+                                      const std::string& c_name,
+                                      const octave_value& val)
 {
   return (instance_ok ())
     ? instance->do_register_type (t_name, c_name, val) : -1;
@@ -68,7 +68,7 @@
 
 bool
 octave_value_typeinfo::register_unary_class_op (octave_value::unary_op op,
-					        octave_value_typeinfo::unary_class_op_fcn f)
+                                                octave_value_typeinfo::unary_class_op_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_unary_class_op (op, f) : false;
@@ -76,7 +76,7 @@
 
 bool
 octave_value_typeinfo::register_unary_op (octave_value::unary_op op,
-					   int t, octave_value_typeinfo::unary_op_fcn f)
+                                           int t, octave_value_typeinfo::unary_op_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_unary_op (op, t, f) : false;
@@ -84,8 +84,8 @@
 
 bool
 octave_value_typeinfo::register_non_const_unary_op (octave_value::unary_op op,
-						    int t,
-						    octave_value_typeinfo::non_const_unary_op_fcn f)
+                                                    int t,
+                                                    octave_value_typeinfo::non_const_unary_op_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_non_const_unary_op (op, t, f) : false;
@@ -93,7 +93,7 @@
 
 bool
 octave_value_typeinfo::register_binary_class_op (octave_value::binary_op op,
-						 octave_value_typeinfo::binary_class_op_fcn f)
+                                                 octave_value_typeinfo::binary_class_op_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_binary_class_op (op, f) : false;
@@ -101,8 +101,8 @@
 
 bool
 octave_value_typeinfo::register_binary_op (octave_value::binary_op op,
-					   int t1, int t2,
-					   octave_value_typeinfo::binary_op_fcn f)
+                                           int t1, int t2,
+                                           octave_value_typeinfo::binary_op_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_binary_op (op, t1, t2, f) : false;
@@ -110,7 +110,7 @@
 
 bool
 octave_value_typeinfo::register_binary_class_op (octave_value::compound_binary_op op,
-						 octave_value_typeinfo::binary_class_op_fcn f)
+                                                 octave_value_typeinfo::binary_class_op_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_binary_class_op (op, f) : false;
@@ -118,8 +118,8 @@
 
 bool
 octave_value_typeinfo::register_binary_op (octave_value::compound_binary_op op,
-					   int t1, int t2,
-					   octave_value_typeinfo::binary_op_fcn f)
+                                           int t1, int t2,
+                                           octave_value_typeinfo::binary_op_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_binary_op (op, t1, t2, f) : false;
@@ -134,8 +134,8 @@
 
 bool
 octave_value_typeinfo::register_assign_op (octave_value::assign_op op,
-					   int t_lhs, int t_rhs,
-					   octave_value_typeinfo::assign_op_fcn f)
+                                           int t_lhs, int t_rhs,
+                                           octave_value_typeinfo::assign_op_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_assign_op (op, t_lhs, t_rhs, f) : -1;
@@ -143,7 +143,7 @@
 
 bool
 octave_value_typeinfo::register_assignany_op (octave_value::assign_op op,
-					      int t_lhs, octave_value_typeinfo::assignany_op_fcn f)
+                                              int t_lhs, octave_value_typeinfo::assignany_op_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_assignany_op (op, t_lhs, f) : -1;
@@ -151,7 +151,7 @@
 
 bool
 octave_value_typeinfo::register_pref_assign_conv (int t_lhs, int t_rhs,
-						  int t_result) 
+                                                  int t_result) 
 {
   return (instance_ok ())
     ? instance->do_register_pref_assign_conv (t_lhs, t_rhs, t_result) : false;
@@ -159,7 +159,7 @@
 
 bool
 octave_value_typeinfo::register_type_conv_op (int t, int t_result,
-					      octave_base_value::type_conv_fcn f)
+                                              octave_base_value::type_conv_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_type_conv_op (t, t_result, f) : false;
@@ -167,7 +167,7 @@
 
 bool
 octave_value_typeinfo::register_widening_op (int t, int t_result,
-					     octave_base_value::type_conv_fcn f)
+                                             octave_base_value::type_conv_fcn f)
 {
   return (instance_ok ())
     ? instance->do_register_widening_op (t, t_result, f) : false;
@@ -178,8 +178,8 @@
 
 int
 octave_value_typeinfo::do_register_type (const std::string& t_name,
-					 const std::string& /* c_name */,
-					 const octave_value& val)
+                                         const std::string& /* c_name */,
+                                         const octave_value& val)
 {
   int i = 0;
 
@@ -200,10 +200,10 @@
       unary_ops.resize (static_cast<int> (octave_value::num_unary_ops), len, 0);
 
       non_const_unary_ops.resize
-	(static_cast<int> (octave_value::num_unary_ops), len, 0);
+        (static_cast<int> (octave_value::num_unary_ops), len, 0);
 
       binary_ops.resize (static_cast<int> (octave_value::num_binary_ops),
-			 len, len, 0);
+                         len, len, 0);
 
       compound_binary_ops.resize (static_cast<int> (octave_value::num_compound_binary_ops),
                                   len, len, 0);
@@ -232,14 +232,14 @@
 
 bool
 octave_value_typeinfo::do_register_unary_class_op (octave_value::unary_op op,
-					           octave_value_typeinfo::unary_class_op_fcn f)
+                                                   octave_value_typeinfo::unary_class_op_fcn f)
 {
   if (lookup_unary_class_op (op))
     {
       std::string op_name = octave_value::unary_op_as_string (op);
 
       warning ("duplicate unary operator `%s' for class dispatch",
-	       op_name.c_str ());
+               op_name.c_str ());
     }
 
   unary_class_ops.checkelem (static_cast<int> (op)) = reinterpret_cast<void *> (f);
@@ -249,7 +249,7 @@
 
 bool
 octave_value_typeinfo::do_register_unary_op (octave_value::unary_op op,
-					     int t, octave_value_typeinfo::unary_op_fcn f)
+                                             int t, octave_value_typeinfo::unary_op_fcn f)
 {
   if (lookup_unary_op (op, t))
     {
@@ -257,7 +257,7 @@
       std::string type_name = types(t);
 
       warning ("duplicate unary operator `%s' for type `%s'",
-	       op_name.c_str (), type_name.c_str ());
+               op_name.c_str (), type_name.c_str ());
     }
 
   unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f);
@@ -275,7 +275,7 @@
       std::string type_name = types(t);
 
       warning ("duplicate unary operator `%s' for type `%s'",
-	       op_name.c_str (), type_name.c_str ());
+               op_name.c_str (), type_name.c_str ());
     }
 
   non_const_unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f);
@@ -285,14 +285,14 @@
 
 bool
 octave_value_typeinfo::do_register_binary_class_op (octave_value::binary_op op,
-						    octave_value_typeinfo::binary_class_op_fcn f)
+                                                    octave_value_typeinfo::binary_class_op_fcn f)
 {
   if (lookup_binary_class_op (op))
     {
       std::string op_name = octave_value::binary_op_as_string (op);
 
       warning ("duplicate binary operator `%s' for class dispatch",
-	       op_name.c_str ());
+               op_name.c_str ());
     }
 
   binary_class_ops.checkelem (static_cast<int> (op)) = reinterpret_cast<void *> (f);
@@ -302,8 +302,8 @@
 
 bool
 octave_value_typeinfo::do_register_binary_op (octave_value::binary_op op,
-					      int t1, int t2,
-					      octave_value_typeinfo::binary_op_fcn f)
+                                              int t1, int t2,
+                                              octave_value_typeinfo::binary_op_fcn f)
 {
   if (lookup_binary_op (op, t1, t2))
     {
@@ -312,7 +312,7 @@
       std::string t2_name = types(t2);
 
       warning ("duplicate binary operator `%s' for types `%s' and `%s'",
-	       op_name.c_str (), t1_name.c_str (), t1_name.c_str ());
+               op_name.c_str (), t1_name.c_str (), t1_name.c_str ());
     }
 
   binary_ops.checkelem (static_cast<int> (op), t1, t2) = reinterpret_cast<void *> (f);
@@ -322,14 +322,14 @@
 
 bool
 octave_value_typeinfo::do_register_binary_class_op (octave_value::compound_binary_op op,
-						    octave_value_typeinfo::binary_class_op_fcn f)
+                                                    octave_value_typeinfo::binary_class_op_fcn f)
 {
   if (lookup_binary_class_op (op))
     {
       std::string op_name = octave_value::binary_op_fcn_name (op);
 
       warning ("duplicate compound binary operator `%s' for class dispatch",
-	       op_name.c_str ());
+               op_name.c_str ());
     }
 
   compound_binary_class_ops.checkelem (static_cast<int> (op)) = reinterpret_cast<void *> (f);
@@ -339,8 +339,8 @@
 
 bool
 octave_value_typeinfo::do_register_binary_op (octave_value::compound_binary_op op,
-					      int t1, int t2,
-					      octave_value_typeinfo::binary_op_fcn f)
+                                              int t1, int t2,
+                                              octave_value_typeinfo::binary_op_fcn f)
 {
   if (lookup_binary_op (op, t1, t2))
     {
@@ -349,7 +349,7 @@
       std::string t2_name = types(t2);
 
       warning ("duplicate compound binary operator `%s' for types `%s' and `%s'",
-	       op_name.c_str (), t1_name.c_str (), t1_name.c_str ());
+               op_name.c_str (), t1_name.c_str (), t1_name.c_str ());
     }
 
   compound_binary_ops.checkelem (static_cast<int> (op), t1, t2) = reinterpret_cast<void *> (f);
@@ -366,7 +366,7 @@
       std::string t2_name = types(t2);
 
       warning ("duplicate concatenation operator for types `%s' and `%s'",
-	       t1_name.c_str (), t1_name.c_str ());
+               t1_name.c_str (), t1_name.c_str ());
     }
 
   cat_ops.checkelem (t1, t2) = reinterpret_cast<void *> (f);
@@ -376,8 +376,8 @@
 
 bool
 octave_value_typeinfo::do_register_assign_op (octave_value::assign_op op,
-					      int t_lhs, int t_rhs,
-					      octave_value_typeinfo::assign_op_fcn f)
+                                              int t_lhs, int t_rhs,
+                                              octave_value_typeinfo::assign_op_fcn f)
 {
   if (lookup_assign_op (op, t_lhs, t_rhs))
     {
@@ -386,7 +386,7 @@
       std::string t_rhs_name = types(t_rhs);
 
       warning ("duplicate assignment operator `%s' for types `%s' and `%s'",
-	       op_name.c_str (), t_lhs_name.c_str (), t_rhs_name.c_str ());
+               op_name.c_str (), t_lhs_name.c_str (), t_rhs_name.c_str ());
     }
 
   assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs) = reinterpret_cast<void *> (f);
@@ -396,7 +396,7 @@
 
 bool
 octave_value_typeinfo::do_register_assignany_op (octave_value::assign_op op,
-						 int t_lhs, octave_value_typeinfo::assignany_op_fcn f)
+                                                 int t_lhs, octave_value_typeinfo::assignany_op_fcn f)
 {
   if (lookup_assignany_op (op, t_lhs))
     {
@@ -404,7 +404,7 @@
       std::string t_lhs_name = types(t_lhs);
 
       warning ("duplicate assignment operator `%s' for types `%s'",
-	       op_name.c_str (), t_lhs_name.c_str ());
+               op_name.c_str (), t_lhs_name.c_str ());
     }
 
   assignany_ops.checkelem (static_cast<int> (op), t_lhs) = reinterpret_cast<void *> (f);
@@ -414,7 +414,7 @@
 
 bool
 octave_value_typeinfo::do_register_pref_assign_conv (int t_lhs, int t_rhs,
-						     int t_result) 
+                                                     int t_result) 
 {
   if (lookup_pref_assign_conv (t_lhs, t_rhs) >= 0)
     {
@@ -422,7 +422,7 @@
       std::string t_rhs_name = types(t_rhs);
 
       warning ("overriding assignment conversion for types `%s' and `%s'",
-	       t_lhs_name.c_str (), t_rhs_name.c_str ());
+               t_lhs_name.c_str (), t_rhs_name.c_str ());
     }
 
   pref_assign_conv.checkelem (t_lhs, t_rhs) = t_result;
@@ -440,7 +440,7 @@
       std::string t_result_name = types(t_result);
 
       warning ("overriding type conversion op for `%s' to `%s'",
-	       t_name.c_str (), t_result_name.c_str ());
+               t_name.c_str (), t_result_name.c_str ());
     }
 
   type_conv_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f);
@@ -458,7 +458,7 @@
       std::string t_result_name = types(t_result);
 
       warning ("overriding widening op for `%s' to `%s'",
-	       t_name.c_str (), t_result_name.c_str ());
+               t_name.c_str (), t_result_name.c_str ());
     }
 
   widening_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f);
@@ -474,11 +474,11 @@
   for (int i = 0; i < num_types; i++)
     {
       if (nm == types(i))
-	{
-	  retval = vals(i);
-	  retval.make_unique ();
-	  break;
-	}
+        {
+          retval = vals(i);
+          retval.make_unique ();
+          break;
+        }
     }
 
   return retval;
@@ -515,7 +515,7 @@
 
 octave_value_typeinfo::binary_op_fcn
 octave_value_typeinfo::do_lookup_binary_op (octave_value::binary_op op,
-					    int t1, int t2)
+                                            int t1, int t2)
 {
   void *f = binary_ops.checkelem (static_cast<int> (op), t1, t2);
   return reinterpret_cast<octave_value_typeinfo::binary_op_fcn> (f);
@@ -530,7 +530,7 @@
 
 octave_value_typeinfo::binary_op_fcn
 octave_value_typeinfo::do_lookup_binary_op (octave_value::compound_binary_op op,
-					    int t1, int t2)
+                                            int t1, int t2)
 {
   void *f = compound_binary_ops.checkelem (static_cast<int> (op), t1, t2);
   return reinterpret_cast<octave_value_typeinfo::binary_op_fcn> (f);
@@ -545,7 +545,7 @@
 
 octave_value_typeinfo::assign_op_fcn
 octave_value_typeinfo::do_lookup_assign_op (octave_value::assign_op op,
-					    int t_lhs, int t_rhs)
+                                            int t_lhs, int t_rhs)
 {
   void *f = assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs);
   return reinterpret_cast<octave_value_typeinfo::assign_op_fcn> (f);
@@ -553,7 +553,7 @@
 
 octave_value_typeinfo::assignany_op_fcn
 octave_value_typeinfo::do_lookup_assignany_op (octave_value::assign_op op,
-					       int t_lhs)
+                                               int t_lhs)
 {
   void *f = assignany_ops.checkelem (static_cast<int> (op), t_lhs);
   return reinterpret_cast<octave_value_typeinfo::assignany_op_fcn> (f);