symbols versus strings ? writing route

I hope I am not too annoyingly, ..., but writing route I encountered some problems:

feature of my route:

	  - routing first number of lists: output rest of list 
	  - routing numbers, output bang on matched numbers
	  - routing strings (which are in fact symbols), 
	    with bang and list output 
	  - mixing routing strings and numbers 
	    (which does not work in max)

solution:
- adding methods for each string (class_addmethod(route_class,route_symbol, es->e_atom.a_w.w_symbol,A_GIMME,0);

	  - adding class_addanything(...) for not parsed strings,messages
	  

problem:

if a a string is for example "int", a used symbol, than route_symbol(...) seg_faults, because pd_float is used for calling route_symbol(..) with wrong arguments, because the route_symbol(...) is registered as c_floatmethod.

So the string "int" or "float" matches all numbers. Lists, which in fact are lists beginning with numbers not strings, are handled correctly. Lists with beginning strings are handled as methods --- is this correct ?

So the my idea of route (to be compatible in future with real route) could be that "float", "int" routes all integers and floats, which are not in a list,

(route should be fast, since, in my experience with max, it is often used for sending synthesis parameters and has to handle high data-rates)

mfg winfried.

PS.:my route as source: ---- snip --- /* -------------------------- route ------------------------------ */ static t_class *route_class;

typedef struct _routeelement { t_atom e_atom; t_outlet *e_outlet; } t_routeelement;

typedef struct _route { t_object x_obj; t_int x_nelement; t_routeelement *x_vec; t_int x_nsymbols; t_routeelement *x_vecsymbols; t_outlet *x_rejectout; } t_route;

static void route_list(t_route *x, t_symbol *sel, int argc, t_atom *argv) { t_routeelement *e; int nelement, n; union word a_w;

if (!argc) return;

a_w = argv->a_w;

for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++){

 /* dont know how excatly to compare atomes since
	 strncmp is slow for a 8Byte long, 
	 and i am not sure all types ar the same length (w_int, w_float,...)
	 so I have to test on atom type */

 switch(argv->a_type){

 case A_FLOAT:
	if(e->e_atom.a_type == A_FLOAT && e->e_atom.a_w.w_float == a_w.w_float)
	  {
		 if(argc <= 1)	outlet_bang(e->e_outlet);
		 else	outlet_list(e->e_outlet, 0, argc-1, argv+1);
		 return;
	  }
	break;

 case A_INT :
	if(e->e_atom.a_type == A_INT && e->e_atom.a_w.w_int == a_w.w_int)
	  {
		 if(argc <= 1)	outlet_bang(e->e_outlet);
		 else outlet_list(e->e_outlet, 0, argc-1, argv+1);
		 return;
	  }
	break;
 }

}; outlet_list(x->x_rejectout, sel, argc, argv); return; }

static void route_symbol(t_route *x, t_symbol *sel, int argc, t_atom *argv) { t_routeelement *e; int nelement;

for (nelement = x->x_nsymbols, e = x->x_vecsymbols; nelement--; e++) if(/* e->e_atom.a_type == A_SYMBOL &&*/ e->e_atom.a_w.w_symbol == sel){

	if(argc<=0) outlet_bang(e->e_outlet);
	else outlet_list(e->e_outlet, 0, argc, argv);
	return;
 }
	

/* never reach this, but... */ outlet_anything(x->x_rejectout, sel, argc, argv); return; }

static void route_anything(t_route *x, t_symbol *sel, int argc, t_atom *argv) { outlet_anything(x->x_rejectout, sel, argc, argv); return; }

static void route_free(t_route *x) { freebytes(x->x_vec, x->x_nelement * sizeof(*x->x_vec)); }

static void *route_new(t_symbol *s, int argc, t_atom *argv) { int n; t_routeelement *ee, *es; t_route *x = (t_route *)pd_new(route_class);

x->x_nelement = x->x_nsymbols = 0; /* count from top */ x->x_vec = (t_routeelement *)getbytes(argc * sizeof(*x->x_vec)); x->x_rejectout = outlet_new(&x->x_obj, &s_list);

for (n = argc, ee = x->x_vec, es=x->x_vec+argc; n--;){

 if(argv[n].a_type == A_SYMBOL){

	es--;x->x_nsymbols++;    /* count from top */

	es->e_outlet = outlet_new(&x->x_obj, &s_list);
	es->e_atom.a_type = argv[n].a_type;
	es->e_atom.a_w = argv[n].a_w;

	post("new_symbol: new symbol at %lx name %s",
		  argv[n].a_w.w_symbol,argv[n].a_w.w_symbol->s_name);

	class_addmethod(route_class,route_symbol,
							es->e_atom.a_w.w_symbol,A_GIMME,0);

 }
 else{ /* element */
	  
	ee->e_outlet = outlet_new(&x->x_obj, &s_list);
	ee->e_atom.a_type = argv[n].a_type;
	ee->e_atom.a_w = argv[n].a_w;

	ee++;x->x_nelement++;/* count from bottom */
}

};

x->x_vecsymbols = es;

return (x); }

void route_setup(void) { route_class = class_new(gensym("route"), route_new, route_free, sizeof(t_route), 0, A_GIMME, 0);

 class_addlist(route_class, route_list);

 /* symbols which are not matched and so no messages */
 class_addanything(route_class, route_anything);

} ---- snip ---