Initial creation of sourceware repositorygdb-4_18-branchpoint

1 files changed, 427 insertions, 0 deletions

diff --git a/gdb/29k-share/udi/udr.c b/gdb/29k-share/udi/udr.c
new file mode 100644
index 0000000..10a9f38
--- /dev/null
+++ b/gdb/29k-share/udi/udr.c
@@ -0,0 +1,427 @@
+/* This module supports sending and receiving data objects over a
+   socket conection.
+
+   Copyright 1993 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+static char udr_c[]="@(#)udr.c	2.8  Daniel Mann";
+static char udr_c_AMD[]="@(#)udr.c	2.3, AMD";
+/* 
+*	All data is serialised into a character stream,
+*	and de-serialised back into the approproiate objects.
+********************************************************************** HISTORY
+*/
+/* This is all unneeded on DOS machines.  */
+#ifndef __GO32__
+
+#include <stdio.h>
+#include <sys/types.h>
+
+/* This used to say sys/fcntl.h, but the only systems I know of that
+   require that are old (pre-4.3, at least) BSD systems, which we
+   probably don't need to worry about.  */
+#include <fcntl.h>
+
+#include <sys/socket.h>
+#include "udiproc.h"
+#include "udisoc.h"
+
+extern	int	errno;
+extern	char*	malloc();
+
+/* local type decs. and macro defs. not in a .h  file ************* MACRO/TYPE
+*/
+
+/* global dec/defs. which are not in a .h   file ************* EXPORT DEC/DEFS
+*/
+int		udr_errno;		/* error occurs during UDR service */
+
+/* local dec/defs. which are not in a .h   file *************** LOCAL DEC/DEFS
+*/
+
+/****************************************************************** UDR_CREATE
+* Build UDR structure for character stream processing.
+*/
+int udr_create(udrs, sd, size)
+UDR*	udrs;
+int	sd;
+int	size;
+{
+    udrs->sd = sd;
+    if(!udrs->buff) udrs->buff = malloc(size);
+    udrs->getbytes = udrs->buff;	/* set the buffer to the start */
+    udrs->putbytes = udrs->buff;
+    udrs->putend = udrs->buff;
+    udrs->udr_op = -1;			/* don't know the direction */
+    udrs->previous_op = -1;		/* don't know the direction */
+    udrs->bufsize = size;
+    return 0;
+}
+
+/******************************************************************** UDR_FREE
+* Free USR structure and close socket.
+*/
+int udr_free(udrs)
+UDR*	udrs;
+{
+    close(udrs->sd);
+    free(udrs->buff);
+    return 0;
+}
+
+/****************************************************************** UDR_SIGNAL
+* Send a signal to the process at the other end of the socket,
+* indicating that it should expect to recieve a new message shortly.
+*/
+int udr_signal(udrs)
+UDR*	udrs;
+{
+    if(send(udrs->sd, "I", 1, MSG_OOB) == -1)
+    {	perror("ERROR, udr_signal(), send(...MSG_OOB)");
+	udr_errno =  UDIErrorIPCInternal;
+    	return -1;		/* return error code */
+    }
+    return 0;
+}
+
+/***************************************************************** UDR_SENDNOW
+* used to flush the current character stream buffer to
+* the associated socket.  */
+int udr_sendnow(udrs)
+UDR*	udrs;
+{
+    int size = (UDIUInt32)(udrs->putend) - (UDIUInt32)(udrs->buff);
+    if(udrs->previous_op == 0)
+    {   udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+    udrs->putbytes = udrs->buff;
+    udrs->putend = udrs->buff;
+    if (write(udrs->sd, udrs->buff, size) == -1)
+    {	perror("ERROR, udr_sendnow(), write() call: ");
+	udr_errno =  UDIErrorIPCInternal;
+    	return -1;		/* return error code */
+    }
+    return 0;
+}
+
+/******************************************************************** UDR_WORK
+* Function to send or recieve data from the buffers supporting
+* socket communication. The buffer contains serialised objects
+* sent/recieved over a socket connection.
+*/
+int udr_work(udrs, object_p, size)
+UDR*	udrs;
+void*	object_p;
+int	size;
+{
+    int	    cnt, remain;
+
+    if(udrs->udr_op != udrs->previous_op)
+    {	if(udrs->previous_op == 0)
+	{   udr_errno =  UDIErrorIPCInternal;
+	    return -1;
+        }
+	udrs->previous_op= udrs->udr_op;
+	udrs->putbytes = udrs->buff;
+	udrs->getbytes = udrs->buff;
+    }
+
+    if(udrs->udr_op == UDR_ENCODE)
+    {			/* write data into character stream buffer */
+    	if( (UDIUInt32)(udrs->putbytes) + size >
+	    (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize) )
+	{   udr_errno =  UDIErrorIPCInternal;
+	    return -1;
+        }
+	memcpy(udrs->putbytes, (char*)object_p, size);
+    	udrs->putbytes += size;
+    	if(udrs->putbytes > udrs->putend) udrs->putend = udrs->putbytes;
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+    	if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
+	{		 /* need more data in character stream buffer */
+       	    remain = (UDIUInt32)(udrs->bufsize) -
+		( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) );
+       	    if( ((UDIUInt32)(udrs->bufsize) + (UDIUInt32)(udrs->buff)
+		- (UDIUInt32)(udrs->getbytes)) < size)
+	    {   udr_errno =  UDIErrorIPCInternal;
+	        return -1;
+            }
+    	    cnt = read(udrs->sd, (char*)udrs->putbytes, remain);
+	    if(cnt == -1) perror("ERROR udr_work(),  read() failure: ");
+	    udrs->putbytes += cnt;
+    	    if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
+	    {	udr_errno =  UDIErrorIPCInternal;
+	        return -1;		/* return error code */
+    	    }
+    	}		/* read data from character stream buffer */
+	memcpy((char*)object_p,  udrs->getbytes, size);
+    	udrs->getbytes += size;
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+    return 0;
+}
+
+/************************************************************* UDR_UDIResource
+*/
+int udr_UDIResource(udrs, object_p)
+UDR*	udrs;
+UDIResource*	object_p;
+{
+    int	retval;
+
+    retval = udr_CPUSpace(udrs, &object_p->Space);
+    retval = retval |  udr_CPUOffset(udrs, &object_p->Offset);
+    return retval;
+}
+
+/**************************************************************** UDR_UDIRange
+*/
+int udr_UDIRange(udrs, object_p)
+UDR*		udrs;
+UDIRange*	object_p;
+{
+    int	retval;
+
+    retval = udr_CPUOffset(udrs, &object_p->Low);
+    retval = retval | udr_CPUOffset(udrs, &object_p->High);
+    return retval;
+}
+
+/********************************************************** UDR_UDIMemoryRange
+*/
+int udr_UDIMemoryRange(udrs, object_p)
+UDR*		udrs;
+UDIMemoryRange*	object_p;
+{
+    int	retval;
+
+    retval = udr_CPUSpace(udrs, &object_p->Space);
+    retval = retval | udr_CPUOffset(udrs, &object_p->Offset);
+    retval = retval | udr_CPUSizeT(udrs, &object_p->Size);
+    return retval;
+}
+
+/****************************************************************** UDR_string
+*/
+int udr_string(udrs, sp)
+UDR*	udrs;
+char*	sp;
+{
+    int	len, retval;
+
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+	if(sp)
+    	{   len = strlen(sp) + 1;
+    	    retval = udr_UDIInt32(udrs, &len);
+    	    retval = retval | udr_work(udrs, sp, len);
+	}
+	else	/* deal with NULL pointer */
+	{   len = 0;
+    	    retval = udr_UDIInt32(udrs, &len);
+	}
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+    	retval = udr_UDIInt32(udrs, &len);
+	if(len)
+    	    retval = retval | udr_work(udrs, sp, len);
+	else	*sp = '\0';			/* terminate string */
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+    return retval;
+}
+
+/******************************************************************* UDR_BYTES
+*/
+int udr_bytes(udrs, ptr, len)
+UDR*	udrs;
+char*	ptr;
+int	len;
+{
+    return udr_work(udrs, ptr, len);
+}
+
+/********************************************************************* UDR_INT
+*/
+int udr_int(udrs, int_p)
+UDR*	udrs;
+int*	int_p;
+{
+    int ret_val;
+    UDIInt32  udr_obj;			/* object of know size */
+
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+        udr_obj = *int_p;		/* copy into know object size */
+        return udr_UDIInt32(udrs, &udr_obj);
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+        ret_val = udr_UDIInt32(udrs, &udr_obj);	/* get object of known size */
+	*int_p = udr_obj;
+	return ret_val;
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+}
+
+/****************************************************************** UDR_INLINE
+*/
+char* udr_inline(udrs, size)
+UDR*	udrs;
+int	size;
+{
+    if(udrs->udr_op != udrs->previous_op)
+    {	if(udrs->previous_op == 0)
+	{   udr_errno =  UDIErrorIPCInternal;
+	    return 0;
+        }
+    	udrs->previous_op= udrs->udr_op;
+	udrs->putbytes = udrs->buff;
+	udrs->getbytes = udrs->buff;
+    }
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+    	if(udrs->putbytes + size > udrs->bufsize + udrs->buff)
+	   return 0;
+    	udrs->putbytes += size;
+	return udrs->putbytes - size;
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+    	if(udrs->getbytes + size > udrs->bufsize + udrs->buff)
+	   return 0;
+    	udrs->getbytes += size;
+	return udrs->getbytes - size;
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return 0;
+    }
+}
+
+/****************************************************************** UDR_GETPOS
+*/
+char*	udr_getpos(udrs)
+UDR*	udrs;
+{
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+	return udrs->putbytes;
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+	return udrs->getbytes;
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return 0;
+    }
+}
+
+/****************************************************************** UDR_SETPOS
+*/
+int	udr_setpos(udrs, pos)
+UDR*	udrs;
+char*	pos;
+{
+    if( ((UDIUInt32)pos > (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize))
+     || ((UDIUInt32)pos < (UDIUInt32)(udrs->buff) ) )
+    {	udr_errno =  UDIErrorIPCInternal;
+	return 0;
+    }
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+	udrs->putbytes = pos;
+	return 1;
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+	udrs->getbytes = pos;
+	return 1;
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return 0;
+    }
+}
+
+/***************************************************************** UDR_READNOW
+* Try and ensure "size" bytes are available in the
+* receive buffer character stream.
+*/
+int	udr_readnow(udrs, size)
+UDR*	udrs;
+int	size;
+{
+    int	cnt, remain;
+
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+	udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+    	if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
+	{		 /* need more data in character stream buffer */
+       	    remain = (UDIUInt32)(udrs->bufsize) -
+		( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) );
+    	    cnt = read(udrs->sd, (char*)udrs->putbytes, remain);
+	    if(cnt == -1) perror("ERROR udr_work(),  read() failure: ");
+	    udrs->putbytes += cnt;
+    	    if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
+    	    {  fprintf(stderr,"ERROR, udr_readnow() too few bytes in stream\n");
+	       return -1;		/* return error code */
+    	    }
+    	}		
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+    return 0;
+}
+
+/******************************************************************* UDR_ALIGN
+*/
+int udr_align(udrs, size)
+UDR*	udrs;
+int	size;
+{
+    char*   align;
+    int	    offset;	
+
+    align = udr_getpos(udrs);
+    offset = size - ((int)align & (size -1));
+    offset = offset & (size -1);
+    if(offset) udr_setpos(udrs, align + offset);
+}
+#endif /* __GO32__ */