--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,18 @@
+2010-01-12  Jaroslav Hajek  <highegg@gmail.com>
+
+	* ov-base.h (builtin_type_t): New enum constants: btyp_cell,
+	btyp_struct and btyp_func_handle.
+	(btyp_isinteger, btyp_isfloat, btyp_isarray): New funcs.
+	(btyp_class_name): New array.
+	(get_builtin_classes): New func.
+	* ov-cell.h (octave_cell::builtin_type): New virtual override.
+	* ov-struct.h (octave_struct::builtin_type): New virtual override.
+	* ov-fcn-handle.h (octave_fcn_handle::builtin_type): New virtual override.
+	* symtab.cc (get_dispatch_type): Rewrite. Add overload.
+	* symtab.h: Update decls.
+	* ov-fcn-handle.cc (octave_fcn_handle::do_multi_index_op): Rewrite.
+	(get_builtin_classes): Remove.
+
 2010-01-12  Jaroslav Hajek  <highegg@gmail.com>
 
 	* oct-obj.cc (octave_value_list::any_cell): New method.

--- a/src/ov-base.cc
+++ b/src/ov-base.cc
@@ -78,6 +78,36 @@
   return retval;
 }
 
+std::string btyp_class_name[btyp_num_types] = 
+{
+  "double", "single", "double", "single",
+  "int8", "int16", "int32", "int64",
+  "uint8", "uint16", "uint32", "uint64",
+  "logical", "char",
+  "struct", "cell", "function_handle"
+};
+
+string_vector
+get_builtin_classes (void)
+{
+  static string_vector retval;
+
+  if (retval.is_empty ())
+    {
+      int n = btyp_num_types - 2;
+      retval = string_vector (n);
+      int j = 0;
+      for (int i = 0; i < btyp_num_types; i++)
+        {
+          builtin_type_t ityp = static_cast<builtin_type_t> (i);
+          if (ityp != btyp_complex && ityp != btyp_float_complex)
+            retval(j++) = btyp_class_name[i];
+        }
+    }
+
+  return retval;
+}
+
 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_base_value,
 				     "<unknown type>", "unknown");
 

--- a/src/ov-base.h
+++ b/src/ov-base.h
@@ -71,13 +71,31 @@
   btyp_uint64,
   btyp_bool,
   btyp_char,
+  btyp_struct,
+  btyp_cell,
+  btyp_func_handle,
   btyp_unknown,
   btyp_num_types = btyp_unknown
 };
 
+extern OCTINTERP_API std::string 
+btyp_class_name [btyp_num_types];
+
+extern OCTINTERP_API string_vector
+get_builtin_classes (void); 
+
 inline bool btyp_isnumeric (builtin_type_t btyp)
 { return btyp <= btyp_uint64; }
 
+inline bool btyp_isinteger (builtin_type_t btyp)
+{ return btyp >= btyp_int8 && btyp <= btyp_uint64; }
+
+inline bool btyp_isfloat (builtin_type_t btyp)
+{ return btyp <= btyp_float_complex; }
+
+inline bool btyp_isarray (builtin_type_t btyp)
+{ return btyp <= btyp_char; }
+
 // Compute a numeric type for a possibly mixed-type operation, using these rules:
 // bool -> double
 // single + double -> single

--- a/src/ov-cell.h
+++ b/src/ov-cell.h
@@ -119,6 +119,8 @@
 
   bool is_cell (void) const { return true; }
 
+  builtin_type_t builtin_type (void) const { return btyp_cell; }
+
   bool is_cellstr (void) const;
 
   bool is_true (void) const;

--- a/src/ov-fcn-handle.cc
+++ b/src/ov-fcn-handle.cc
@@ -131,36 +131,24 @@
       // Possibly overloaded function.
       octave_value ovfcn = fcn;
 
+      // No need to compute built-in class dispatch if we don't have builtin class overloads.
+      bool builtin_class = ! disp->empty ();
       // Get dynamic (class) dispatch type.
-      std::string ddt = get_dispatch_type (args);
+      std::string dt = get_dispatch_type (args, builtin_class);
 
-      if (ddt.empty ())
+      if (! dt.empty ())
         {
-          // Static dispatch (class of 1st arg)?
-          if (! disp->empty ())
-            {
-              std::string sdt = args(0).class_name ();
-              str_ov_map::iterator pos = disp->find (sdt);
-              if (pos != disp->end ())
-                {
-                  out_of_date_check (pos->second, sdt, false);
-                  ovfcn = pos->second;
-                }
-            }
-        }
-      else
-        {
-          str_ov_map::iterator pos = disp->find (ddt);
+          str_ov_map::iterator pos = disp->find (dt);
           if (pos != disp->end ())
             {
-              out_of_date_check (pos->second, ddt, false);
+              out_of_date_check (pos->second, dt, false);
               ovfcn = pos->second;
             }
-          else
+          else if (! builtin_class)
             {
-              octave_value method = symbol_table::find_method (nm, ddt);
+              octave_value method = symbol_table::find_method (nm, dt);
               if (method.is_defined ())
-                (*disp)[ddt] = ovfcn = method;
+                (*disp)[dt] = ovfcn = method;
             }
         }
 
@@ -168,10 +156,10 @@
         retval = ovfcn.do_multi_index_op (nargout, args);
       else if (fcn.is_undefined ())
         {
-          if (ddt.empty ())
-            ddt = args(0).class_name ();
+          if (dt.empty ())
+            dt = args(0).class_name ();
 
-          error ("no %s method to handle class %s", nm.c_str (), ddt.c_str ());
+          error ("no %s method to handle class %s", nm.c_str (), dt.c_str ());
         }
       else
         error ("invalid function handle");
@@ -1336,40 +1324,6 @@
 			   current_print_indent_level ());
 }
 
-static string_vector
-get_builtin_classes (void)
-{
-  // FIXME: this should really be read from somewhere else.
-  static const char *cnames[15] = {
-      "double",
-      "single",
-      "int8",
-      "int16",
-      "int32",
-      "int64",
-      "uint8",
-      "uint16",
-      "uint32",
-      "uint64",
-      "logical",
-      "char",
-      "cell",
-      "struct",
-      "function_handle"
-  };
-
-  static string_vector retval;
-
-  if (retval.is_empty ())
-    {
-      retval = string_vector (15);
-      for (int i = 0; i < 15; i++)
-        retval(i) = cnames[i];
-    }
-
-  return retval;
-}
-
 octave_value
 make_fcn_handle (const std::string& nm, bool local_funcs)
 {

--- a/src/ov-fcn-handle.h
+++ b/src/ov-fcn-handle.h
@@ -87,6 +87,8 @@
 
   bool is_function_handle (void) const { return true; }
 
+  builtin_type_t builtin_type (void) const { return btyp_func_handle; }
+
   bool is_overloaded (void) const { return disp.get () && ! disp->empty (); }
 
   dim_vector dims (void) const { static dim_vector dv (1, 1); return dv; }

--- a/src/ov-struct.h
+++ b/src/ov-struct.h
@@ -120,6 +120,8 @@
 
   bool is_map (void) const { return true; }
 
+  builtin_type_t builtin_type (void) const { return btyp_struct; }
+
   Octave_map map_value (void) const { return map; }
 
   string_vector map_keys (void) const { return map.keys (); }

--- a/src/symtab.cc
+++ b/src/symtab.cc
@@ -448,9 +448,38 @@
   return retval;
 }
 
+// :-) JWE, can you parse this? Returns a 2D array with second dimension equal
+// to btyp_num_types (static constant). Only the leftmost dimension can be
+// variable in C/C++. Typedefs are boring.
+
+static builtin_type_t (*build_sup_table (void))[btyp_num_types]
+{
+  static builtin_type_t sup_table[btyp_num_types][btyp_num_types];
+  for (int i = 0; i < btyp_num_types; i++)
+    for (int j = 0; j < btyp_num_types; j++)
+      {
+        builtin_type_t ityp = static_cast<builtin_type_t> (i);
+        builtin_type_t jtyp = static_cast<builtin_type_t> (j);
+        // FIXME: Is this really right?
+        bool use_j = 
+          (jtyp == btyp_func_handle || ityp == btyp_bool
+           || (btyp_isarray (ityp) 
+               && (! btyp_isarray (jtyp) 
+                   || (btyp_isinteger (jtyp) && ! btyp_isinteger (ityp))
+                   || ((ityp == btyp_double || ityp == btyp_complex || ityp == btyp_char)
+                       && (jtyp == btyp_float || jtyp == btyp_float_complex)))));
+
+        sup_table[i][j] = use_j ? jtyp : ityp;
+      }
+
+  return sup_table;
+}
+
 std::string
-get_dispatch_type (const octave_value_list& args)
+get_dispatch_type (const octave_value_list& args, 
+                   bool& builtin_class)
 {
+  static builtin_type_t (*sup_table)[btyp_num_types] = build_sup_table ();
   std::string dispatch_type;
 
   int n = args.length ();
@@ -459,39 +488,62 @@
     {
       // Find first object, if any.
 
-      int i;
-
-      for (i = 0; i < n; i++)
+      for (int i = 0; i < n; i++)
 	{
 	  octave_value arg = args(i);
 
 	  if (arg.is_object ())
 	    {
 	      dispatch_type = arg.class_name ();
-	      break;
+              for (int j = i+1; j < n; j++)
+                {
+                  octave_value arg1 = args(j);
+
+                  if (arg1.is_object ())
+                    {
+                      std::string cname = arg1.class_name ();
+
+                      // Only switch to type of ARG if it is marked superior
+                      // to the current DISPATCH_TYPE.
+                      if (! symbol_table::is_superiorto (dispatch_type, cname)
+                          && symbol_table::is_superiorto (cname, dispatch_type))
+                        dispatch_type = cname;
+                    }
+                }
+
+              builtin_class = false;
+              break;
 	    }
 	}
 
-      for (int j = i+1; j < n; j++)
-	{
-	  octave_value arg = args(j);
+      // No object.
 
-	  if (arg.is_object ())
-	    {
-	      std::string cname = arg.class_name ();
+      if (builtin_class)
+        {
+          // Use the builtin_type mechanism to do this by one method call per
+          // element. 
 
-	      // Only switch to type of ARG if it is marked superior
-	      // to the current DISPATCH_TYPE.
-	      if (! symbol_table::is_superiorto (dispatch_type, cname)
-		  && symbol_table::is_superiorto (cname, dispatch_type))
-		dispatch_type = cname;
-	    }
-	}
+          builtin_type_t btyp = args(0).builtin_type ();
+          for (int i = 1; i < n; i++)
+            btyp = sup_table[btyp][args(i).builtin_type ()];
+
+          if (btyp != btyp_unknown)
+            dispatch_type = btyp_class_name[btyp];
+          else
+            builtin_class = false;
+        }
     }
 
   return dispatch_type;
 }
 
+std::string
+get_dispatch_type (const octave_value_list& args)
+{
+  bool builtin_class = true;
+  return get_dispatch_type (args, builtin_class);
+}
+
 // Find the definition of NAME according to the following precedence
 // list:
 //
@@ -639,9 +691,6 @@
     {
       std::string dispatch_type = get_dispatch_type (args);
 
-      if (dispatch_type.empty ())
-        dispatch_type = args(0).class_name ();
-
       octave_value fcn = find_method (dispatch_type);
 
       if (fcn.is_defined ())

--- a/src/symtab.h
+++ b/src/symtab.h
@@ -2370,7 +2370,10 @@
                                const std::string& dispatch_type = std::string (),
                                bool check_relative = true);
 
-extern std::string get_dispatch_type (const octave_value_list& args);
+extern OCTINTERP_API std::string
+get_dispatch_type (const octave_value_list& args);
+extern OCTINTERP_API std::string
+get_dispatch_type (const octave_value_list& args, bool& builtin_class);
 
 #endif