How to get the type of a object method given a t_object* object and its methodname?

Unfortunately, I tried object_mess and got the same result as before (an empty m_type). I tried it with untyped and typed methods but in all cases, empty.

I'm surprised that m_type in t_messlist holds method type information, since it's a char[]

typedef struct messlist
{
struct symbol *m_sym; // Name of the message
method m_fun; // Method associated w/ the message
char m_type[MSG_MAXARG + 1]; // Argument type information
} t_messlist;

Since I'm interested in programmatically figuring out whether a method is a A_GIMME or not, i.e. typed or untyped. These are defined e_max_atomtypes (see below) which also contains a remark recommending to use a long instead to represent the value: "While these values are defined in an enum, you should use a long to represent the value". Why is m_type in t_messlist then a char[] and why is it empty? Now I'm totally confused...

/** the list of officially recognized types, including pseudotypes for
    commas and semicolons.  Used in two places: 1. the reader, when it reads
    a string, returns long, float, sym, comma, semi, or dollar;
    and 2. each object method comes with an array of them saying what types
    it needs, from among long, float, sym, obj, gimme, and cant.
 

    @ingroup atom
 

    @remark    While these values are defined in an enum, you should use a long to represent the value.
            Using the enum type creates ambiguity in struct size and is subject to various inconsistent 
            compiler settings.
*/
typedef enum {
    A_NOTHING = 0,    ///< no type, thus no atom
    A_LONG,            ///< long integer
    A_FLOAT,        ///< 32-bit float
    A_SYM,            ///< t_symbol pointer
    A_OBJ,            ///< t_object pointer (for argtype lists; passes the value of sym)
    A_DEFLONG,        ///< long but defaults to zero
    A_DEFFLOAT,        ///< float, but defaults to zero
    A_DEFSYM,        ///< symbol, defaults to ""
    A_GIMME,        ///< request that args be passed as an array, the routine will check the types itself.
    A_CANT,            ///< cannot typecheck args
    A_SEMI,            ///< semicolon
    A_COMMA,        ///< comma
    A_DOLLAR,        ///< dollar
    A_DOLLSYM,        ///< dollar
    A_GIMMEBACK,    ///< request that args be passed as an array, the routine will check the types itself. can return atom value in final atom ptr arg. function returns long error code 0 = no err. see gimmeback_meth typedef

    A_DEFER    =        0x41,    ///< A special signature for declaring methods. This is like A_GIMME, but the call is deferred.
    A_USURP =        0x42,    ///< A special signature for declaring methods. This is like A_GIMME, but the call is deferred and multiple calls within one servicing of the queue are filtered down to one call.
    A_DEFER_LOW =    0x43,    ///< A special signature for declaring methods. This is like A_GIMME, but the call is deferref to the back of the queue.
    A_USURP_LOW =    0x44    ///< A special signature for declaring methods. This is like A_GIMME, but the call is deferred to the back of the queue and multiple calls within one servicing of the queue are filtered down to one call.
} e_max_atomtypes;

Any help figuring this out would be appreciated.

Thanks,

S