[Guardsoft-cvs] guard/src/dbgsrv dbgsrv_gdbmi.c,1.5,1.6

[Greg W. <ja...@us...>]

Update of /cvsroot/guardsoft/guard/src/dbgsrv
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv8837

Modified Files:
	dbgsrv_gdbmi.c 
Log Message:
first attempt at converting to AIF types

Index: dbgsrv_gdbmi.c
===================================================================
RCS file: /cvsroot/guardsoft/guard/src/dbgsrv/dbgsrv_gdbmi.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** dbgsrv_gdbmi.c	13 May 2005 17:56:34 -0000	1.5
--- dbgsrv_gdbmi.c	23 May 2005 22:28:11 -0000	1.6
***************
*** 78,82 ****
  extern int	Shutdown;
  
! AIF *		GDBMIBuildAIFVar(char *, char *);
  dbgevent_t *	SetAndCheckBreak(char *);
  dbgevent_t *	ShowBreak(int);
--- 78,82 ----
  extern int	Shutdown;
  
! dbgevent_t *	GDBMIBuildAIFVar(char *, char *, char *);
  dbgevent_t *	SetAndCheckBreak(char *);
  dbgevent_t *	ShowBreak(int);
***************
*** 855,858 ****
--- 855,865 ----
  }
  
+ int
+ gmi_dump_binary_value(mi_h *h, char *exp, char *file)
+ {
+ 	mi_send(h, "dump binary value %s %s\n", file, exp);
+ 	return mi_res_simple_done(h);
+ }
+ 
  /*
  ** Evaluate the expression exp.
***************
*** 861,867 ****
  DbgGDBMIEvalExpr(char *exp)
  {
  	char *		type;
! 	char *		val;
! #ifdef GDB_WITH_AIF
  	mi_aif *	aif;
  #endif /* GDB_WITH_AIF */
--- 868,875 ----
  DbgGDBMIEvalExpr(char *exp)
  {
+ #ifndef GDB_WITH_AIF
  	char *		type;
! 	char		tmp[18];
! #else /* GDB_WITH_AIF */
  	mi_aif *	aif;
  #endif /* GDB_WITH_AIF */
***************
*** 871,875 ****
  
  #ifdef GDB_WITH_AIF
! 	aif = gmi_aif_evaluate_expression(exp);
  
  	if ( aif == NULL )
--- 879,883 ----
  
  #ifdef GDB_WITH_AIF
! 	aif = gmi_aif_evaluate_expression(MIHandle, exp);
  
  	if ( aif == NULL )
***************
*** 890,899 ****
  			
  	type = strdup(e->ev_type);
! 		
  	FreeEvent(e);
  
! 	val = gmi_data_evaluate_expression(MIHandle, exp);
  
! 	if ( val == NULL )
  	{
  		EVENT_ERROR(e, DBGERR_DEBUGGER, (char *)mi_get_error_str());
--- 898,913 ----
  			
  	type = strdup(e->ev_type);
! 
  	FreeEvent(e);
  
! 	strcpy(tmp, "/tmp/guard.XXXXXX");
  
! 	if ( mktemp(tmp) == NULL )
! 	{
! 		EVENT_ERROR(e, DBGERR_DEBUGGER, (char *)strerror(errno));
! 		return e;
! 	}
! 
! 	if ( !gmi_dump_binary_value(MIHandle, exp, tmp) )
  	{
  		EVENT_ERROR(e, DBGERR_DEBUGGER, (char *)mi_get_error_str());
***************
*** 901,909 ****
  	}
  
! 	e = NewEvent(DBGEV_DATA);
! 	e->ev_data = GDBMIBuildAIFVar(type, val);
  
  	(void)free(type);
! 	(void)free(val);
  #endif /* GDB_WITH_AIF */
  
--- 915,922 ----
  	}
  
! 	e = GDBMIBuildAIFVar(exp, type, tmp);
  
  	(void)free(type);
! 	(void)unlink(tmp);
  #endif /* GDB_WITH_AIF */
  
***************
*** 940,943 ****
--- 953,1177 ----
  }
  
+ struct str_type
+ {
+ 	int     blen;
+ 	int     slen;
+ 	int     end;
+ 	char *  buf;
+ };
+ typedef struct str_type *	str_ptr;
+ 
+ #define STRSIZE	100
+ 
+ str_ptr	str_init(void);
+ void	str_add(str_ptr, char *, ...);
+ void	str_free(str_ptr);
+ char *	str_val(str_ptr);
+ str_ptr	str_dup(char *);
+ 
+ struct simple_type {
+ 	char *	type_c;
+ 	char *	type_fds;
+ 	int	type_len;
+ };
+ 
+ struct simple_type simple_types[] = {
+ 	{ "char", "c", 0 },
+ 	{ "unsigned char", "c", 0 },
+ 	{ "short", "is%d", sizeof(short) },
+ 	{ "unsigned short", "iu%d", sizeof(unsigned short) },
+ 	{ "int", "is%d", sizeof(int) },
+ 	{ "unsigned int", "iu%d", sizeof(unsigned int) },
+ 	{ "long", "is%d", sizeof(long) },
+ 	{ "unsigned long", "iu%d", sizeof(unsigned long) },
+ 	{ "long long", "is%d", sizeof(long long) },
+ 	{ "unsigned long long", "iu%d", sizeof(unsigned long long) },
+ 	{ "float", "f%d", sizeof(float) },
+ 	{ "double", "f%d", sizeof(double) },
+ 	{ NULL, NULL }
+ };
+ 
+ str_ptr
+ str_init(void)
+ {
+ 	str_ptr s;
+ 
+ 	s = (str_ptr)Alloc(sizeof(struct str_type));
+ 	s->buf = (char *)Alloc(STRSIZE);
+ 	s->blen = STRSIZE;
+ 	s->slen = 0;
+ 	*(s->buf) = '\0';
+ 
+ 	return s;
+ }
+ 
+ void
+ str_add(str_ptr s1, char *s2, ...)
+ {
+ 	va_list	ap;
+ 	int     l2;
+ 	char *	buf;
+ 
+ 	va_start(ap, s2);
+ 	vasprintf(&buf, s2, ap);
+ 	va_end(ap);
+ 
+ 	l2 = strlen(buf);
+ 
+ 	if (s1->slen + l2 >= s1->blen)
+ 	{
+ 		s1->blen += MAX(STRSIZE, l2);
+ 		s1->buf = (char *) Resize (s1->buf, s1->blen);
+ 	}
+ 
+ 	memcpy(&(s1->buf[s1->slen]), buf, l2);
+ 	s1->slen += l2;
+ 	s1->buf[s1->slen] = '\0';
+ 
+ 	free(buf);
+ }
+ 
+ void
+ str_free(str_ptr s)
+ {
+ 	free(s->buf);
+ 	free(s);
+ }
+ 
+ char *
+ str_val(str_ptr s)
+ {
+ 	return s->buf;
+ }
+ 
+ str_ptr
+ str_dup(char *s1)
+ {
+ 	str_ptr s = str_init();
+ 	str_add(s, s1);
+ 	return s;
+ }
+ 
+ int
+ SimpleTypeToFDS(char *type, str_ptr fds)
+ {
+ 	char *			p;
+ 	char *			last = &type[strlen(type) - 1];
+ 	struct simple_type *	s;
+ 
+ 	if ( strcmp(type, "<text variable, no debug info>") == 0 )
+ 		return -1;
+ 
+ 	switch ( *last )
+ 	{
+ 	case '*': /* pointer */
+ 		str_add(fds, "^");
+ 
+ 		/*
+ 		** get rid of '*'
+ 		*/
+ 		for ( p = last ; p != type && *(p-1) == ' ' ; p-- )
+ 			;
+ 
+ 		*p = '\0';
+ 		break;
+ 
+ 	case ')': /* function */
+ 		str_add(fds, "&");
+ 
+ 		/*
+ 		** get rid of '(..)' for now
+ 		*/
+ 		if ( (p = strrchr(type, '(')) != NULL )
+ 		{
+ 			for ( ; p != type && *(p-1) == ' ' ; p-- )
+ 				;
+ 
+ 			*p = '\0';
+ 		}
+ 
+ 		str_add(fds, "/");
+ 		break;
+ 
+ 	}
+ 
+ 	for (s = simple_types ; s->type_c != NULL ; s++ )
+ 	{
+ 		if ( strcmp(type, s->type_c) == 0 )
+ 		{
+ 			str_add(fds, s->type_fds, s->type_len);
+ 			break;
+ 		}
+ 	}
+ 
+ 	return 0;
+ }
+ 
+ dbgevent_t *
+ ConvertType(mi_gvar *gvar, str_ptr fds)
+ {
+ 	dbgevent_t *	e;
+ 
+ 	if ( gvar->numchild == 0 )
+ 	{
+ 		if ( !gmi_var_info_type(MIHandle, gvar) )
+ 		{
+ 			EVENT_ERROR(e, DBGERR_DEBUGGER, (char *)mi_get_error_str());
+ 			return e;
+ 		}
+ 
+ 		if ( SimpleTypeToFDS(gvar->type, fds) < 0 )
+ 		{
+ 			EVENT_ERROR(e, DBGERR_NOSYMS, "");
+ 			return e;
+ 		}
+ 
+ 	}
+ 	else
+ 	{
+ 
+ 		if ( !gmi_var_list_children(MIHandle, gvar) )
+ 		{
+ 			EVENT_ERROR(e, DBGERR_DEBUGGER, (char *)mi_get_error_str());
+ 			return e;
+ 		}
+ 
+ 		switch ( gvar->type[strlen(gvar->type) - 1] )
+ 		{
+ 		case ']': /* array */
+ 			str_add(fds, "[r0..%dis4]", gvar->numchild-1);
+ 
+ 			/*
+ 			** Just look at first child to determine type
+ 			*/
+ 			if ( (e = ConvertType(gvar->child, fds)) != NULL )
+ 				return e;
+ 
+ 			break;
+ #if 0
+ 		case '}': /* struct */
+ 			str_add(fds, "{|");
+ 			num = gvar->numchild;
+ 			gvar = gvar->child;
+ 			for ( i = 0 ; i < num ; i++ )
+ 			{
+ 				if ( (e = ConvertType(gvar, fds)) != NULL )
+ 					return e;
+ 				gvar = gvar->next;
+ 			}
+ 			add_to_str(fds, ";;;}");
+ 			break;
+ #endif
+ 		default:
+ 			EVENT_ERROR(e, DBGERR_DEBUGGER, "type not supported (yet)");
+ 			return e;
+ 			break;
+ 		}
+ 		
+ 	}
+ 
+ 	return NULL;
+ }
+ 
  /*
  ** Find type of variable.
***************
*** 951,954 ****
--- 1185,1189 ----
  #else /* GDB_WITH_AIF */
  	mi_gvar *	gvar;
+ 	str_ptr		fds;
  #endif /* GDB_WITH_AIF */
  
***************
*** 969,980 ****
  	gvar = gmi_var_create(MIHandle, -1, var);
  
! 	if ( gvar == NULL || !gmi_var_info_type(MIHandle, gvar) )
  	{
! 		EVENT_ERROR(e, DBGERR_DEBUGGER, (char *)mi_get_error_str());
  		return e;
  	}
  
  	e = NewEvent(DBGEV_TYPE);
! 	e->ev_type = strdup(gvar->type);
  
  	mi_free_gvar(gvar);
--- 1204,1222 ----
  	gvar = gmi_var_create(MIHandle, -1, var);
  
! 	if ( gvar == NULL )
  	{
! 		EVENT_ERROR(e, DBGERR_NOSYM, var);
  		return e;
  	}
  
+ 	fds = str_init();
+ 
+ 	if ( (e = ConvertType(gvar, fds)) != NULL )
+ 		return e;
+ 
  	e = NewEvent(DBGEV_TYPE);
! 	e->ev_type = strdup(fds->buf);
! 
! 	str_free(fds);
  
  	mi_free_gvar(gvar);
***************
*** 1610,1622 ****
  #endif
  
! AIF *
! GDBMIBuildAIFVar(char *type, char *data)
  {
! 	if ( strcmp(type, "int") == 0 )
  	{
! 		return IntToAIF(atoi(data));
  	}
! 	else
! 		return StringToAIF("no implemented for this type (yet)");
  }
  #endif /* LIBMIGDB */
--- 1852,1928 ----
  #endif
  
! char tohex[] =	{'0', '1', '2', '3', '4', '5', '6', '7', 
! 		 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
! 
! dbgevent_t *
! GDBMIBuildAIFVar(char *var, char *type, char *file)
  {
! 	int		n;
! 	int		fd;
! 	AIF *		aif;
! 	char *		data;
! 	char *		ap;
! 	char *		bp;
! 	char		buf[BUFSIZ];
! 	struct stat	sb;
! 	dbgevent_t *	e;
! 
! 	if ( stat(file, &sb) < 0 )
  	{
! 		EVENT_ERROR(e, DBGERR_DEBUGGER, (char *)strerror(errno));
! 		return e;
  	}
! 
! 	if ( FDSType(type) == AIF_FUNCTION )
! 	{
! 		/*
! 		** Data is function name
! 		*/
! 		ap = data = Alloc(strlen(var) * 2 + 1);
! 
! 		for ( bp = var ; *bp != '\0' ; bp++ )
! 		{
! 			*ap++ = tohex[(*bp >> 4) & 0xf];
! 			*ap++ = tohex[*bp & 0xf];
! 		}
! 
! 		*ap++ = '\0';
! 	}
! 	else 
! 	{
! 		if ( (fd = open(file, O_RDONLY)) < 0 )
! 		{
! 			EVENT_ERROR(e, DBGERR_DEBUGGER, (char *)strerror(errno));
! 			return e;
! 		}
! 
! 		ap = data = Alloc(sb.st_size * 2 + 1);
! 
! 		while ((n = read(fd, buf, BUFSIZ)) > 0)
! 		{
! 			bp = buf;
! 
! 			while ( n-- > 0 )
! 			{
! 				*ap++ = tohex[(*bp >> 4) & 0xf];
! 				*ap++ = tohex[*bp++ & 0xf];
! 			}
! 		}
! 
! 		*ap++ = '\0';
! 
! 		(void)close(fd);
! 	}
! 
! 	if ( (aif = AsciiToAIF(type, data)) == NULL )
! 	{
! 		EVENT_ERROR(e, DBGERR_DEBUGGER, AIFErrorStr());
! 		return e;
! 	}
! 
! 	e = NewEvent(DBGEV_DATA);
! 	e->ev_data = aif;
! 
! 	return e;
  }
  #endif /* LIBMIGDB */