Upload 42 files

dms/GNUmakefile

@@ -0,0 +1,69 @@
+# LIBDIR is the directory where a 'dms' subdirectory will be created,
+# in which the server binary (dmsd) and various support files will be installed
+LIBDIR  = /usr/local/lib
+
+# BINDIR is the directory where the dms binary will be installed
+BINDIR  = /usr/local/bin
+
+# PDBINC is the directory where the 'pdb.h' file from the UCSF PDB-reading
+# library got installed.  'pdb.h' is not installed by default by that
+# distribution, so you will have to install it by hand into PDBINC
+PDBINC  = libpdb
+
+# PDBLIB is the directory where libpdb.a from the UCSF PDB-reading library 
+# got installed.
+PDBLIB  = libpdb
+
+# MANDIR is the directory where the dms.1 manual page will be installed
+MANDIR  = /usr/local/man/man1
+
+ifeq ($(shell test -e /bin/cygwin1.dll && echo found),found)
+	PROG	= dms.exe
+else
+	PROG	= dms
+endif
+
+# you should not need to modify any of the following
+DESTLIB	= ${LIBDIR}/dms/
+SERVER	= ${DESTLIB}dmsd
+DEFS	= -DDESTLIB=\"${DESTLIB}\" -DSERVER_PATH=\"$(SERVER)\"
+OPT	= -O
+CFLAGS  = ${DEFS} -I${PDBINC} ${OPT}
+
+OBJS	= compute.o fwritev.o input.o ms.o output.o emalloc.o tokenize.o
+
+all:	${PROG}
+	cd dmsd ; ${MAKE} LIBDIR=${LIBDIR} OPT="${OPT}"
+
+${PROG}: pdb ${OBJS}
+	${CC} -L${PDBLIB} -o ${PROG} ${OBJS} -lpdb
+
+pdb:
+	cd libpdb ; ${MAKE} OPT="${OPT}"
+
+install: ${PROG} maninstall afterinstall
+afterinstall: realinstall
+realinstall: beforeinstall
+	cp ${PROG} ${BINDIR}
+	-strip ${BINDIR}/${PROG}
+
+maninstall:
+	-rm -f ${MANDIR}/dms.1
+	cp dms.1 ${MANDIR}
+
+beforeinstall:
+	if [ -d ${DESTLIB} ]; then true ; else mkdir ${DESTLIB}; fi
+	cd dmsd ; ${MAKE} LIBDIR=${LIBDIR} install
+
+afterinstall:
+	cp radii.proto ${DESTLIB}radii
+
+clean:
+	/bin/rm -f ${OBJS}
+	cd libpdb ; ${MAKE} clean
+	cd dmsd ; ${MAKE} clean
+
+spotless:
+	/bin/rm -f ${OBJS} ${PROG}
+	cd libpdb ; ${MAKE} spotless
+	cd dmsd ; ${MAKE} spotless

dms/README

@@ -0,0 +1,138 @@
+Description:
+
+	DMS is "Distributed MS", a version of the solvent-accessible
+	surface computation program.  This version splits the
+	computation into independent units and executes each unit on a
+	dms server which runs somewhere on the local area network.
+
+	Dms is distributed as open source, subject to the legal
+	restrictions noted at the end of this file.
+
+	Consult the dms manual page (dms.1) for details on usage.
+
+Prerequisites:
+
+	You need GNU make and a C compiler to build this software.
+	When we refer to the "make" command below, you should use
+	the actual GNU make executable file name.  On Linux and
+	Cygwin, the GNU make executable is called "make".  On IRIX,
+	the GNU make executable is part of the free software installed
+	in /usr/freeware/bin and is called "gmake".
+
+	This software has been built on Red Hat Enterprise Linux
+	and on Windows XP Professional with Cygwin.
+
+Installation:
+
+	Edit "GNUmakefile" and change LIBDIR and BINDIR to the
+	appropriate location for your system.
+
+	At this point, you could get away with typing "make install"
+	and be done.  You may or may not want to do the following
+	before that:
+
+	Edit the file "dms_param.h" and set the appropriate
+	parameters to the desired values.  You may need to twiddle with
+	the last few parameters if you want to get the optimal performance.
+
+	By default, dms runs on the local host only, instead of running
+	in parallel on multiple hosts.  If this behavior is sufficient
+	for your needs, type "make install" and stop here.  Otherwise...
+
+	Edit the file "dms_servers.proto" to contain a list of hosts that
+	will run dms servers.  All machines participating in a single dms
+	calculation must be binary compatible with the machine initiating
+	the calculation.  For sites with multiple machine architectures,
+	this may mean that there are several distinct "pools" of dms
+	servers, for calculations initiated by a machine within a pool.
+	Now type "make install".
+
+	Dms must be installed as above on each server machine, and on each
+	such machine the following steps must be performed as root:
+
+	1) Register the 'dms' service on the host.  On most UNIX systems
+	this is done by editing /etc/services and adding the following
+	line:
+		dms 14148/tcp
+	
+	On Mac OS X systems, instead execute the following command:
+
+		echo dms 14148/tcp | niload services .
+	
+	2) Add this line to /etc/inetd.conf:
+
+		dms stream tcp nowait daemon dmsd_location dmsd
+	
+	where 'dmsd_location' is where dmsd is installed.  (If you
+	didn't change the Makefile at all, then the location is
+	/usr/local/lib/dms/dmsd)
+
+	3) Make the inetd daemon reread the inetd.conf file.  This is
+	accomplished by sending the inetd process a HUP signal.  In
+	order to send the signal, you need to know inetd's process ID.
+	The process ID can be found by examining the output of 'ps agx'
+	or 'ps -e' (depending on your system).  The rightmost column
+	contains the process name, so look for the line that includes
+	'inetd' somewhere in the righthand column.  On that line, in
+	the 'PID' column, is inetd's process ID.  The signal is then 
+	sent with the command:
+
+		kill -HUP process_ID
+	
+	After performing the above steps on all servers, you should 
+	verify that dms is indeed performing distributed computations
+	as expected.  To do this, you need to have a PDB file available
+	to use as a test input (preferably a small one).  Once you do,
+	run the command:
+
+		dms your_PDB_file -v -o /dev/null
+	
+	If you have correctly installed dms for distributed computation,
+	the output will contain a line of the form:
+
+		Server request count:
+
+	followed by a list of hosts that dms ran on to do the calculation,
+	and the amount of calculation that each host performed.  If the
+	list of servers is what you expect, and no calculation count is
+	zero, then you have installed dms correctly.  If one or more
+	calculation counts are zero then you did not install dms correctly
+	on those hosts.  For those problem hosts you should verify that
+	the above steps were carried out correctly as well as insuring
+	that dmsd is installed in the correct location and is executable.  
+	If your list of server hosts is not what you expect and is simply
+	'localhost' instead, the you have not correctly completed step (1)
+	on the local machine.
+
+
+Legal Restrictions:
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

dms/atoms.h

@@ -0,0 +1,85 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#ifndef	__ATOM__
+#define	__ATOM__
+
+#define	TREENTRANT	0
+#define	SREENTRANT	1
+#define	CONTACT		2
+
+typedef struct point_def	{
+	double	coord[3];
+}	POINT;
+
+typedef struct surface_def	{
+	struct surface_def	*next;
+	int			npoint;
+	POINT			*position;
+	POINT			*normal;
+	double			area;
+	int			type;
+}	SURFACE;
+
+#define	AN_LEN	6
+#define	RN_LEN	9
+#define	RT_LEN	6
+
+typedef struct atom_def	{
+	struct atom_def	*next;
+	double		coord[3];
+	char		atname[AN_LEN];
+	char		resseq[RN_LEN];
+	char		restype[RT_LEN];
+	double		radius;
+	int		wanted, resindex;
+	SURFACE		*surface;
+}	ATOM;
+
+typedef int	AINDEX;
+
+typedef struct neighbor_def	{
+	int	nneighbor;
+	AINDEX	*neighbor;
+}	NEIGHBOR;
+
+typedef struct probe_def	{
+	struct probe_def	*next;
+	AINDEX			atom[3];
+	double			coord[3];
+	int			real;
+}	PROBE;
+
+#define	ATOM_IS(ap,aname,rname)	\
+	(strcmp((ap)->atname, aname) == 0 && strcmp((ap)->resseq, rname) == 0)
+
+#endif

dms/compute.c

@@ -0,0 +1,1460 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <netdb.h>
+#include <sys/types.h>
+#ifndef FD_SET
+#ifndef linux
+#include <sys/select.h>
+#endif
+#endif
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/time.h>
+#include <sys/uio.h>
+#include "dms_param.h"
+#include "atoms.h"
+#include "wanted.h"
+#include "protocol.h"
+
+extern void	*emalloc();
+
+#ifndef	FD_SET
+#define	FD_SET(n, p)	((p)->fds_bits[0] |= (1 << (n)))
+#define	FD_CLR(n, p)	((p)->fds_bits[0] &= ~(1 << (n)))
+#define	FD_ISSET(n, p)	((p)->fds_bits[0] & (1 << n))
+#define	FD_ZERO(p)	((p)->fds_bits[0] = 0)
+#define	FD_ISZERO(p)	((p)->fds_bits[0] == 0)
+#endif
+
+#ifndef	DEBUG
+#define STATIC static
+#else
+#define	STATIC
+#endif
+
+#ifndef	TRUE
+#define	TRUE	1
+#define	FALSE	0
+#endif
+
+typedef struct server_def	{
+	struct server_def	*next;
+	char			*host;
+	FILE			*in_fd, *out_fd;
+	int			state;
+	void			(*reply)();
+	void			(*retry)();
+	int			arg1, arg2;
+	int			nrequest;
+}	SERVER;
+
+#define	EXECUTING	0
+#define	AVAILABLE	1
+#define	DEAD		2
+#define	IDLE		3
+#define	STOPPED		4
+
+STATIC NEIGHBOR	*neighbor;
+STATIC PROBE	*probe;
+STATIC SERVER	*server;
+STATIC ATOM	**alist;
+STATIC int	natom;
+
+STATIC void	read_radii();
+STATIC void	assign_radius();
+STATIC void	print_astat();
+STATIC int	compute_comp();
+STATIC void	start_servers();
+STATIC int	try_host();
+STATIC void	stop_servers();
+STATIC SERVER	*get_server();
+STATIC void	wait_for_server();
+STATIC void	print_sstat();
+STATIC void	param_info();
+STATIC void	pi_reply();
+STATIC void	atom_info();
+STATIC void	ai_reply();
+STATIC void	ni_reply();
+STATIC void	probe_info();
+STATIC void	pri_reply();
+STATIC void	neighbors();
+STATIC void	c_reply();
+STATIC void	probes();
+STATIC void	p_reply();
+STATIC void	contact_surface();
+STATIC void	torus_surface();
+STATIC void	probe_surface();
+STATIC void	surface_reply();
+STATIC void	collapse_probes();
+STATIC void	cross();
+
+extern char	(*resseqs)[RN_LEN];
+extern int	numresseq;
+
+/*
+ * neighbor_info:
+ *	Send neighbor information to all servers
+ */
+void neighbor_info(nlist, natom)
+NEIGHBOR	*nlist;
+int		natom;
+{
+	register SERVER		*sp;
+	register NEIGHBOR	*np, *endnp;
+	register struct iovec	*ip;
+	register int		n;
+	struct iovec		*countv, *datav;
+	char			buf[BUFSIZ];
+
+	endnp = nlist + natom;
+	n = 0;
+	countv = (struct iovec *) emalloc(natom * sizeof (struct iovec));
+	for (np = nlist, ip = countv; np < endnp; np++, ip++) {
+		ip->iov_base = (caddr_t) &np->nneighbor;
+		ip->iov_len = sizeof (int);
+		if (np->nneighbor > 0)
+			n++;
+	}
+	if (n > 0) {
+		datav = (struct iovec *) emalloc(n * sizeof (struct iovec));
+		ip = datav;
+		for (np = nlist; np < endnp; np++) {
+			if (np->nneighbor <= 0)
+				continue;
+			ip->iov_base = (caddr_t) np->neighbor;
+			ip->iov_len = np->nneighbor * sizeof (AINDEX);
+			ip++;
+		}
+	}
+	(void) sprintf(buf, NI_COMMAND, natom);
+	for (sp = server; sp != NULL; sp = sp->next) {
+		if (sp->state == DEAD)
+			continue;
+		fputs(buf, sp->out_fd);
+		fwritev(sp->out_fd, countv, natom);
+		if (n > 0)
+			fwritev(sp->out_fd, datav, n);
+		(void) fflush(sp->out_fd);
+		sp->state = EXECUTING;
+		sp->reply = ni_reply;
+		sp->retry = NULL;
+	}
+	wait_for_server();
+	(void) free((char *) countv);
+	if (n > 0)
+		(void) free((char *) datav);
+}
+
+/*
+ * compute_ms:
+ *	Compute the molecular surface
+ */
+void compute_ms(aarray, nat, radius, density, want_normal, verbose)
+ATOM	**aarray;
+int	nat;
+double	radius, density;
+int	want_normal;
+int	verbose;
+{
+	register ATOM		**app, **endap;
+	register PROBE		*pp;
+	register int		i, j, k;
+
+	/*
+	 * Store the parameters so reply() routines can get at them
+	 */
+	alist = aarray;
+	natom = nat;
+	endap = alist + natom;
+
+	/*
+	 * Assign a radius for each atom
+	 */
+	read_radii();
+	for (app = alist; app < endap; app++) {
+		assign_radius(*app);
+		(*app)->surface = NULL;
+	}
+	if (verbose)
+		print_astat();
+
+	/*
+	 * Sort the atoms by coordinate so we can look just at slices
+	 * instead of all atoms when looking for neighbors
+	 */
+	qsort((char *) alist, natom, sizeof (ATOM *), compute_comp);
+
+	/*
+	 * Start up servers on all the machines that we can reach
+	 * and hand them the necessary parameters as well as atomic
+	 * coordinates
+	 */
+	start_servers();
+	param_info(radius, density, want_normal);
+	atom_info(alist, natom);
+	if (verbose)
+		fputs("Servers initialized\n", stderr);
+
+	/*
+	 * Loop through the atom list and assign selected atoms to
+	 * available servers (this should give us a list of neighbors).
+	 * We then pass out the neighbor information to all the compute
+	 * servers in preparation for surface computation.
+	 */
+	neighbor = (NEIGHBOR *) emalloc(natom * sizeof (NEIGHBOR));
+	for (app = alist; app < endap; app++)
+		neighbors(app - alist);
+	wait_for_server();
+	neighbor_info(neighbor, natom);
+	if (verbose)
+		fputs("Neighbors computed\n", stderr);
+
+	/*
+	 * Loop through the neighbor list and ask for probes which
+	 * contact both neighbor simultaneously.  We then pass the
+	 * probe information to all the compute servers as well.
+	 */
+	for (i = 0; i < natom; i++)
+		for (j = 0; j < neighbor[i].nneighbor; j++)
+			if (neighbor[i].neighbor[j] > i)
+				probes(i, neighbor[i].neighbor[j]);
+	wait_for_server();
+	probe_info(probe);
+	if (verbose)
+		fputs("Probes computed\n", stderr);
+
+	/*
+	 * Now we clean up the neighbor info and send it out again
+	 */
+	for (i = 0; i < natom; i++) {
+		for (j = 0, k = 0; j < neighbor[i].nneighbor; j++)
+			if (neighbor[i].neighbor[j] >= 0)
+				neighbor[i].neighbor[k++] =
+					neighbor[i].neighbor[j];
+		neighbor[i].nneighbor = k;
+	}
+#ifdef RETRANS_NB
+	neighbor_info(neighbor, natom);
+	if (verbose)
+		fputs("Neighbors sent\n", stderr);
+#endif
+
+	/*
+	 * Generate surface points
+	 * First the contact, then the toroid reentrant,
+	 * and finally spherical reentrant
+	 */
+	for (app = alist; app < endap; app++)
+		if ((*app)->wanted)
+			contact_surface(app - alist);
+	for (i = 0; i < natom; i++)
+		for (j = 0; j < neighbor[i].nneighbor; j++)
+			if (neighbor[i].neighbor[j] > i) {
+				if (!alist[i]->wanted
+				&& !alist[neighbor[i].neighbor[j]]->wanted)
+					continue;
+				torus_surface(i, neighbor[i].neighbor[j]);
+			}
+
+	/*
+	 * Collapse near-coincident probes and then compute surface area
+	 */
+	collapse_probes();
+	for (pp = probe, i = 0; pp != NULL; pp = pp->next, i++) {
+		if (!alist[pp->atom[0]]->wanted
+		&&  !alist[pp->atom[1]]->wanted
+		&&  !alist[pp->atom[2]]->wanted)
+			continue;
+		if (pp->real)
+			probe_surface(i);
+	}
+	wait_for_server();
+	if (verbose)
+		fputs("Surface computed\n", stderr);
+
+	/*
+	 * Ah...we're done.  Terminate the servers and return
+	 */
+	if (verbose)
+		print_sstat();
+	stop_servers();
+}
+
+typedef struct radius_def	{
+	struct radius_def	*next;
+	char			*name;
+	char			namelen;
+	double			radius;
+	int			natom;
+}	RADIUS;
+
+static RADIUS	*radius, *def_radius;
+
+/*
+ * read_radii:
+ *	Get radii from radii file
+ */
+STATIC
+void
+read_radii()
+{
+	register RADIUS	*rp;
+	register FILE	*fp;
+	char		buf[BUFSIZ], name[10];
+	double		length;
+
+	if ((fp = fopen(RADII_FILE, "r")) == NULL) {
+		if ((fp = fopen(DEF_RADII_FILE, "r")) == NULL) {
+			perror(DEF_RADII_FILE);
+			exit(1);
+		}
+	}
+	while (fgets(buf, sizeof buf, fp) != NULL) {
+		if (buf[0] == '#')
+			continue;
+		if (sscanf(buf, "%s%lf", name, &length) != 2) {
+			fputs("Syntax error in radii file\n", stderr);
+			fputs(buf, stderr);
+			continue;
+		}
+		if (strcmp(name, "default") == 0) {
+			def_radius = (RADIUS *) emalloc(sizeof (RADIUS));
+			def_radius->next = NULL;
+			def_radius->name = NULL;
+			def_radius->namelen = 0;
+			def_radius->radius = length;
+			def_radius->natom = 0;
+		}
+		else {
+			rp = (RADIUS *) emalloc(sizeof (RADIUS));
+			rp->next = radius;
+			rp->namelen = strlen(name);
+			rp->name = emalloc(rp->namelen + 1);
+			(void) strcpy(rp->name, name);
+			rp->radius = length;
+			rp->natom = 0;
+			radius = rp;
+		}
+	}
+	(void) fclose(fp);
+}
+
+/*
+ * assign_radius:
+ *	Assign a van der Waals radius to this atom
+ */
+STATIC
+void
+assign_radius(ap)
+ATOM	*ap;
+{
+	register RADIUS	*rp;
+
+	for (rp = radius; rp != NULL; rp = rp->next)
+		if (strncmp(rp->name, ap->atname, rp->namelen) == 0)
+			break;
+	if (rp == NULL) {
+		if (def_radius == NULL) {
+			fprintf(stderr, "Unknown atom type %s\n", ap->atname);
+			exit(1);
+		}
+		else
+			rp = def_radius;
+	}
+	ap->radius = rp->radius;
+	rp->natom++;
+}
+
+/*
+ * print_astat:
+ *	Print atom type statistics
+ */
+STATIC
+void
+print_astat()
+{
+	register struct radius_def	*rp;
+
+	for (rp = radius; rp != NULL; rp = rp->next)
+		if (rp->natom > 0)
+			fprintf(stderr, "\t%s\t%d\n", rp->name, rp->natom);
+	/*
+	 * The last entry is the default
+	 */
+	if (def_radius != NULL && def_radius->natom > 0)
+		fprintf(stderr, "\t???\t%d\n", def_radius->natom);
+}
+
+/*
+ * compute_comp:
+ *	Compare atoms based on coordinates
+ */
+STATIC
+int
+compute_comp(a1, a2)
+ATOM	**a1, **a2;
+{
+	register ATOM	*t1, *t2;
+
+	t1 = *a1;
+	t2 = *a2;
+	if (t1->coord[0] < t2->coord[0])
+		return -1;
+	else if (t1->coord[0] > t2->coord[0])
+		return 1;
+	if (t1->coord[1] < t2->coord[1])
+		return -1;
+	else if (t1->coord[1] > t2->coord[1])
+		return 1;
+	if (t1->coord[2] < t2->coord[2])
+		return -1;
+	else if (t1->coord[2] > t2->coord[2])
+		return 1;
+	return 0;
+}
+
+/*
+ * start_servers:
+ *	Start up servers on all available machines
+ *	For the first pass implementation, we will try to contact
+ *	known hosts only once and just use that set.  If hosts die,
+ *	they get marked as down and are no longer used.  No attempts
+ *	at retrying to connect to any host will be made.
+ */
+STATIC
+void
+start_servers()
+{
+	struct servent	*servp;
+
+	if ((servp = getservbyname("dms", "tcp")) == NULL) {
+		/* service entry not found, run in standalone mode */
+		int     pid, toserver[2], fromserver[2];
+
+		server = (SERVER *) emalloc(sizeof (SERVER));
+		server->nrequest = 0;
+		server->retry = NULL;
+		server->host = "localhost";
+		if (pipe(toserver) < 0 || pipe(fromserver) < 0) {
+			perror("Cannot create pipe");
+			exit(1);
+		}
+		if ((pid = fork()) < 0) {
+			perror("Cannot fork");
+			exit(1);
+		}
+		if (pid == 0) {
+			close(0);
+			close(1);
+			dup2(toserver[0], 0);
+			dup2(fromserver[1], 1);
+			close(toserver[0]);
+			close(toserver[1]);
+			close(fromserver[0]);
+			close(fromserver[1]);
+			execl(SERVER_PATH, "dmsd", NULL);
+			perror("execl");
+			exit(1);
+		}
+		server->in_fd = fdopen(fromserver[0], "r");
+		server->out_fd = fdopen(toserver[1], "w");
+		close(fromserver[1]);
+		close(toserver[0]);
+		if (server->in_fd == NULL || server->out_fd == NULL) {
+			fprintf(stderr, "Cannot open file descriptor.\n");
+			exit(1);
+		}
+		setlinebuf(server->out_fd);
+		server->state = AVAILABLE;
+		server->next = NULL;
+	} else {
+		/* service entry found, run in distributed processing mode */
+		register SERVER	*sp;
+		register FILE	*fp;
+		register char	*cp;
+		char		buf[BUFSIZ];
+
+		if ((fp = fopen(SERVER_FILE, "r")) == NULL) {
+			if ((fp = fopen(DEF_SERVER_FILE, "r")) == NULL) {
+				perror(DEF_SERVER_FILE);
+				exit(1);
+			}
+		}
+		sethostent(TRUE);
+		while (fgets(buf, sizeof buf, fp) != NULL) {
+			if ((cp = strchr(buf, '\n')) != NULL)
+				*cp = '\0';
+			sp = (SERVER *) emalloc(sizeof (SERVER));
+			sp->host = emalloc(strlen(buf) + 1);
+			sp->nrequest = 0;
+			sp->retry = NULL;
+			(void) strcpy(sp->host, buf);
+			if (try_host(buf, sp, servp->s_port) < 0)
+				(void) free((char *) sp);
+			else {
+				sp->next = server;
+				server = sp;
+			}
+		}
+		endhostent();
+		(void) fclose(fp);
+	}
+}
+
+/*
+ * try_host:
+ *	Try to contact a host.
+ */
+STATIC
+int
+try_host(host, sp, port)
+char	*host;
+SERVER	*sp;
+int	port;
+{
+	struct hostent		*hostp;
+	struct sockaddr_in	addr;
+	int			fd;
+	int			newfd;
+	extern int		errno;
+
+	if ((hostp = gethostbyname(host)) == NULL) {
+		fprintf(stderr, "%s: no such host\n", host);
+		return -1;
+	}
+	if ((fd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
+		perror("socket");
+		return -1;
+	}
+	addr.sin_family = PF_INET;
+	addr.sin_addr = *((struct in_addr *) hostp->h_addr);
+	addr.sin_port = port;
+	if (connect(fd, (struct sockaddr *) &addr, sizeof addr) < 0) {
+		perror(host);
+		if (errno != ETIMEDOUT) {
+			(void) close(fd);
+			return -1;
+		}
+		else {
+			(void) close(fd);
+			sp->state = DEAD;
+			return 0;
+		}
+	}
+
+	if ((sp->in_fd = fdopen(fd, "r")) == NULL) {
+		perror("fdopen");
+		(void) close(fd);
+		sp->state = DEAD;
+		return 0;
+	}
+
+#ifdef BSD
+	newfd = fd;
+#else
+	newfd = dup(fd);
+#endif
+	if ((sp->out_fd = fdopen(newfd, "w")) == NULL) {
+		perror("fdopen");
+		(void) close(fd);
+		sp->state = DEAD;
+		return 0;
+	}
+
+	sp->state = AVAILABLE;
+	return 0;
+}
+
+/*
+ * stop_servers:
+ *	Terminate all servers that are currently active
+ */
+STATIC
+void
+stop_servers()
+{
+	register SERVER	*sp, *nextsp;
+
+	for (sp = server; sp != NULL; sp = nextsp) {
+		nextsp = sp->next;
+		if (sp->state != DEAD) {
+			(void) fclose(sp->in_fd);
+			(void) fclose(sp->out_fd);
+		}
+		(void) free((char *) sp);
+	}
+}
+
+/*
+ * get_server:
+ *	Get an available server.  Bomb out if all servers are dead.
+ */
+STATIC
+SERVER *
+get_server()
+{
+	register SERVER	*sp;
+	register int	max_fd, any_live, n;
+	fd_set		mask, save_mask;
+
+	max_fd = 0;	/* In case _file is declared unsigned */
+	any_live = FALSE;
+	FD_ZERO(&save_mask);
+	n = 0;
+
+	/*
+	 * If there is an available server, return it.  Otherwise,
+	 * keep track of the list of currently executing servers
+	 */
+	for (sp = server; sp != NULL; sp = sp->next) {
+		switch (sp->state) {
+		  case AVAILABLE:
+			sp->nrequest++;
+			return sp;
+		  case EXECUTING:
+		  case STOPPED:
+			FD_SET(fileno(sp->in_fd), &save_mask);
+			n++;
+			if (fileno(sp->in_fd) > max_fd)
+				max_fd = fileno(sp->in_fd);
+			any_live = TRUE;
+			break;
+		  case IDLE:
+			any_live = TRUE;
+			break;
+		  case DEAD:
+			break;
+		}
+	}
+
+	if (!any_live) {
+		fputs("All servers died!\n", stderr);
+		exit(1);
+	}
+	if (n <= 0)
+		return NULL;
+	max_fd++;
+
+again:
+	mask = save_mask;
+	/*
+	 * Wait for a server to come back (either respond or die)
+	 */
+	if (select(max_fd, &mask, (fd_set *) NULL, (fd_set *) NULL,
+	(struct timeval *) NULL) <= 0) {
+		perror("select");
+		exit(1);
+	}
+	for (sp = server; sp != NULL; sp = sp->next) {
+		if (sp->state != EXECUTING && sp->state != STOPPED)
+			continue;
+		if (!FD_ISSET(fileno(sp->in_fd), &mask))
+			continue;
+		(*sp->reply)(sp);
+		switch (sp->state) {
+		  case AVAILABLE:
+			sp->nrequest++;
+			return sp;
+		  case EXECUTING:
+		  case STOPPED:
+			break;
+		  default:
+			FD_CLR(fileno(sp->in_fd), &save_mask);
+			n--;
+			break;
+		}
+	}
+	if (n <= 0) {
+		fputs("All servers died!\n", stderr);
+		exit(1);
+	}
+	goto again;
+}
+
+/*
+ * wait_for_server:
+ *	Wait for all servers to become idle.
+ *	If there are servers that died while handling requests that
+ *	need to be retried, handle that as well.  Since servers normally
+ *	do not die, we are willing to take a performance penalty to handle
+ *	the special case.
+ */
+STATIC
+void
+wait_for_server()
+{
+	register SERVER	*sp;
+	register int	n;
+
+again:
+	/*
+	 * Wait for all active servers to finish
+	 */
+	while ((sp = get_server()) != NULL) {
+		sp->state = IDLE;
+		continue;
+	}
+	for (sp = server; sp != NULL; sp = sp->next)
+		if (sp->state == IDLE)
+			sp->state = AVAILABLE;
+
+	/*
+	 * Check for servers that died in action.  If they need to
+	 * be retried, start them up and go back to the waiting stage
+	 */
+	n = 0;
+	for (sp = server; sp != NULL; sp = sp->next)
+		if (sp->state == DEAD && sp->retry != NULL) {
+			(*sp->retry)(sp->arg1, sp->arg2);
+			sp->retry = NULL;
+#ifdef DEBUG
+			fprintf(stderr, "Retrying after %s died\n", sp->host);
+#endif
+			n++;
+		}
+	if (n > 0)
+		goto again;
+}
+
+/*
+ * print_sstat:
+ *	Print server statistics
+ */
+STATIC
+void
+print_sstat()
+{
+	register SERVER	*sp;
+
+	fputs("Server request count:\n", stderr);
+	for (sp = server; sp != NULL; sp = sp->next)
+		fprintf(stderr, "\t%-8s\t%d\n", sp->host, sp->nrequest);
+}
+
+/*
+ * wanted:
+ *	Determine whether the given atom is in the "wanted list"
+ *	We "know" we are called with non-null arguments
+ */
+int
+wanted(ATOM *ap, WANTED *wlist)
+{
+	register WANTED	*wp;
+	int		from, to, at;
+
+	at = ap->resindex;
+	for (wp = wlist; wp != NULL; wp = wp->next)
+		switch (wp->type) {
+		  case W_RANGE:
+			from = wp->startres;
+			to = wp->w.endres;
+			if (from < 0 || to < 0)
+				continue;
+			if (from <= at && at <= to)
+				return TRUE;
+			break;
+		  case W_ANY:
+			if (at == wp->startres)
+				return TRUE;
+			break;
+		  case W_ATOM:
+			if (at != wp->startres)
+				continue;
+			if (strcmp(ap->atname, wp->w.atom) == 0)
+				return TRUE;
+			break;
+		}
+	return FALSE;
+}
+
+/*
+ * locres:
+ *	return the numeric index of the given resseq in the array of
+ *	all resseqs (which should be in the same order as the PDB file).
+ *	Returns -1 if not found.
+ */
+int
+locres(seq)
+char	*seq;
+{
+	register int	i;
+	int		index;
+
+	index = -1;
+	for (i = 0; i < numresseq; i++) {
+		if (strcmp(resseqs[i], seq) == 0) {
+			index = i;
+			break;
+		}
+	}
+	return index;
+}
+
+/*
+ * param_info:
+ *	Pass parameter (probe radius and whether we need normals)
+ *	to servers
+ */
+STATIC
+void
+param_info(radius, density, want_normal)
+double	radius, density;
+int	want_normal;
+{
+	register SERVER	*sp;
+	char		buf[BUFSIZ];
+
+	(void) sprintf(buf, PI_COMMAND, radius, density, want_normal);
+	for (sp = server; sp != NULL; sp = sp->next) {
+		if (sp->state == DEAD)
+			continue;
+		fputs(buf, sp->out_fd);
+		(void) fflush(sp->out_fd);
+		sp->state = EXECUTING;
+		sp->reply = pi_reply;
+		sp->retry = NULL;
+	}
+	wait_for_server();
+}
+
+/*
+ * pi_reply:
+ *	Wait for response to param info command
+ */
+STATIC
+void
+pi_reply(sp)
+SERVER	*sp;
+{
+	char		buf[BUFSIZ];
+
+	if (fgets(buf, sizeof buf, sp->in_fd) == NULL) {
+		fputs("server died\n", stderr);
+		sp->state = DEAD;
+		(void) fclose(sp->in_fd);
+		(void) fclose(sp->out_fd);
+		return;
+	}
+	if (strcmp(buf, PI_RESPONSE) != 0) {
+		fputs("pi_reply: unexpected response from server\n", stderr);
+		fputs(buf, stderr);
+		sp->state = DEAD;
+		(void) fclose(sp->in_fd);
+		(void) fclose(sp->out_fd);
+		return;
+	}
+	sp->state = AVAILABLE;
+}
+
+/*
+ * atom_info:
+ *	Pass atom information out to all servers
+ */
+STATIC
+void
+atom_info(alist, natom)
+ATOM	**alist;
+int	natom;
+{
+	register SERVER	*sp;
+	register ATOM	**app;
+	struct iovec	*iov, *ip, *endip;
+	char		buf[BUFSIZ];
+
+	iov = (struct iovec *) emalloc(natom * sizeof (struct iovec));
+	endip = iov + natom;
+	app = alist;
+	for (ip = iov; ip < endip; ip++) {
+		ip->iov_base = (caddr_t) *app++;
+		ip->iov_len = sizeof (ATOM);
+	}
+	(void) sprintf(buf, AI_COMMAND, natom);
+	for (sp = server; sp != NULL; sp = sp->next) {
+		if (sp->state == DEAD)
+			continue;
+		(void) fputs(buf, sp->out_fd);
+		fwritev(sp->out_fd, iov, natom);
+		(void) fflush(sp->out_fd);
+		sp->state = EXECUTING;
+		sp->reply = ai_reply;
+		sp->retry = NULL;
+	}
+	wait_for_server();
+	(void) free((char *) iov);
+}
+
+/*
+ * ai_reply:
+ *	Read a reply from a server that just received atom info
+ */
+STATIC
+void
+ai_reply(sp)
+SERVER	*sp;
+{
+	char		buf[BUFSIZ];
+
+	if (fgets(buf, sizeof buf, sp->in_fd) == NULL) {
+		fputs("ai_reply: server died\n", stderr);
+		goto bad;
+	}
+	if (strcmp(buf, AI_RESPONSE) != 0) {
+		fputs("ai_reply: unexpected response from server\n", stderr);
+		fputs(buf, stderr);
+		goto bad;
+	}
+	sp->state = AVAILABLE;
+	return;
+bad:
+	sp->state = DEAD;
+	(void) fclose(sp->in_fd);
+	(void) fclose(sp->out_fd);
+	return;
+}
+
+/*
+ * ni_reply:
+ *	Read a reply from a server that just received neighbor info
+ */
+STATIC
+void
+ni_reply(sp)
+SERVER	*sp;
+{
+	char		buf[BUFSIZ];
+
+	if (fgets(buf, sizeof buf, sp->in_fd) == NULL) {
+		fputs("ni_reply: server died\n", stderr);
+		goto bad;
+	}
+	if (strcmp(buf, NI_RESPONSE) != 0) {
+		fputs("ni_reply: unexpected response from server\n", stderr);
+		fputs(buf, stderr);
+		goto bad;
+	}
+	sp->state = AVAILABLE;
+	return;
+bad:
+	sp->state = DEAD;
+	(void) fclose(sp->in_fd);
+	(void) fclose(sp->out_fd);
+	return;
+}
+
+
+/*
+ * probe_info:
+ *	Send probe information to all servers
+ */
+STATIC
+void
+probe_info(plist)
+PROBE	*plist;
+{
+	register SERVER		*sp;
+	register PROBE		*pp;
+	register int		n;
+	register struct iovec	*ip;
+	struct iovec		*iov, *endip;
+	char			buf[BUFSIZ];
+
+	/*
+	 * Count up the number of probes and allocate
+	 * data structure for sending it down the line
+	 */
+	n = 0;
+	for (pp = probe; pp != NULL; pp = pp->next)
+		n++;
+	if (n > 0) {
+		iov = (struct iovec *) emalloc(n * sizeof (struct iovec));
+		endip = iov + n;
+		for (ip = iov, pp = plist; ip < endip; ip++, pp = pp->next) {
+			ip->iov_base = (caddr_t) pp;
+			ip->iov_len = sizeof (PROBE);
+		}
+	}
+
+	(void) sprintf(buf, PRI_COMMAND, n);
+	for (sp = server; sp != NULL; sp = sp->next) {
+		if (sp->state == DEAD)
+			continue;
+		fputs(buf, sp->out_fd);
+		if (n > 0)
+			fwritev(sp->out_fd, iov, n);
+		(void) fflush(sp->out_fd);
+		sp->state = EXECUTING;
+		sp->reply = pri_reply;
+		sp->retry = NULL;
+	}
+	wait_for_server();
+	if (n > 0)
+		(void) free((char *) iov);
+}
+
+/*
+ * pri_reply:
+ *	Read a reply from a server that just received probe info
+ */
+STATIC
+void
+pri_reply(sp)
+SERVER	*sp;
+{
+	char		buf[BUFSIZ];
+
+	if (fgets(buf, sizeof buf, sp->in_fd) == NULL) {
+		fputs("pri_reply: server died\n", stderr);
+		goto bad;
+	}
+	if (strcmp(buf, PRI_RESPONSE) != 0) {
+		fputs("pri_reply: unexpected response from server\n", stderr);
+		fputs(buf, stderr);
+		goto bad;
+	}
+	sp->state = AVAILABLE;
+	return;
+bad:
+	sp->state = DEAD;
+	(void) fclose(sp->in_fd);
+	(void) fclose(sp->out_fd);
+	return;
+}
+
+/*
+ * neighbors:
+ *	Send contact computation request for atom "n" in "alist"
+ *	out to an available server.  If none is available, wait for one.
+ */
+STATIC
+void
+neighbors(n)
+int	n;
+{
+	register SERVER	*sp;
+
+	if ((sp = get_server()) == NULL) {
+		fputs("neighbors: servers idling!\n", stderr);
+		exit(1);
+	}
+	fprintf(sp->out_fd, C_COMMAND, n);
+	(void) fflush(sp->out_fd);
+	sp->state = EXECUTING;
+	sp->reply = c_reply;
+	sp->retry = neighbors;
+	sp->arg1 = n;
+}
+
+/*
+ * c_reply:
+ *	Read the output of a server which completed a contact
+ *	computation.  Reset the server state when we are done.
+ */
+STATIC
+void
+c_reply(sp)
+SERVER	*sp;
+{
+	char		buf[BUFSIZ];
+	int		n, nn;
+
+	/*
+	 * Read the computed neighbors
+	 */
+	if (fgets(buf, sizeof buf, sp->in_fd) == NULL) {
+		fputs("c_reply: server died\n", stderr);
+		goto bad;
+	}
+	if (sscanf(buf, C_RESPONSE, &n, &nn) != 2) {
+		fputs("c_reply: unexpected response from server\n", stderr);
+		fputs(buf, stderr);
+		goto bad;
+	}
+	neighbor[n].nneighbor = nn;
+	if (nn > 0) {
+		neighbor[n].neighbor = (AINDEX *) emalloc(nn * sizeof (AINDEX));
+		if (fread((char *) neighbor[n].neighbor, sizeof (AINDEX), nn,
+		sp->in_fd) != nn) {
+			fputs("c_reply: unexpected EOF from server\n", stderr);
+			goto bad;
+		}
+	}
+	else
+		neighbor[n].neighbor = NULL;
+
+	/*
+	 * Reset the server state and return
+	 */
+	sp->state = AVAILABLE;
+	return;
+
+bad:
+	/*
+	 * Mark the server as dead and return
+	 */
+	sp->state = DEAD;
+	(void) fclose(sp->in_fd);
+	(void) fclose(sp->out_fd);
+	return;
+}
+
+/*
+ * probes:
+ *	Send contact computation request for atom "n" in "alist"
+ *	out to an available server.  If none is available, wait for one.
+ */
+STATIC
+void
+probes(n, m)
+int	n;
+AINDEX	m;
+{
+	register SERVER	*sp;
+
+	if ((sp = get_server()) == NULL) {
+		fputs("neighbors: servers idling!\n", stderr);
+		exit(1);
+	}
+	fprintf(sp->out_fd, P_COMMAND, n, m);
+	(void) fflush(sp->out_fd);
+	sp->state = EXECUTING;
+	sp->reply = p_reply;
+	sp->retry = probes;
+	sp->arg1 = n;
+	sp->arg2 = m;
+}
+
+/*
+ * p_reply:
+ *	Read the output of a server which completed a probe
+ *	computation.  Reset the server state when we are done.
+ */
+STATIC
+void
+p_reply(sp)
+SERVER	*sp;
+{
+	register int	i;
+	register PROBE	*pp;
+	char		buf[BUFSIZ];
+	int		n, m, np;
+
+	for (;;) {
+		if (fgets(buf, sizeof buf, sp->in_fd) == NULL) {
+			fputs("p_reply: server died\n", stderr);
+			goto bad;
+		}
+		if (sscanf(buf, P_BADNB, &n, &m) != 2)
+			break;
+		/*
+		 * These atoms are not real neighbors!  We should go and
+		 * remove the neighbor markings on them.
+		 */
+		for (i = 0; i < neighbor[n].nneighbor; i++)
+			if (neighbor[n].neighbor[i] == m)
+				neighbor[n].neighbor[i] = -1;
+		for (i = 0; i < neighbor[m].nneighbor; i++)
+			if (neighbor[m].neighbor[i] == n)
+				neighbor[m].neighbor[i] = -1;
+	}
+	if (sscanf(buf, P_RESPONSE, &np) != 1) {
+		fputs("p_reply: unexpected response from server\n",
+			stderr);
+		fputs(buf, stderr);
+		goto bad;
+	}
+	if (np > 0) {
+		pp = (PROBE *) emalloc(np * sizeof (PROBE));
+		if (fread((char *) pp, sizeof (PROBE), np, sp->in_fd) != np) {
+			fputs("p_reply: unexpected EOF from server\n", stderr);
+			goto bad;
+		}
+		for (i = 1; i < np; i++)
+			pp[i - 1].next = &pp[i];
+		pp[np - 1].next = probe;
+		probe = pp;
+	}
+
+	/*
+	 * Reset the server state and return
+	 */
+	sp->state = AVAILABLE;
+	return;
+
+bad:
+	/*
+	 * Mark the server as dead and return
+	 */
+	sp->state = DEAD;
+	(void) fclose(sp->in_fd);
+	(void) fclose(sp->out_fd);
+	return;
+}
+
+/*
+ * contact_surface:
+ *	Start a server on computing the contact surface for atom `n'
+ */
+STATIC
+void
+contact_surface(n)
+int	n;
+{
+	register SERVER	*sp;
+
+	if ((sp = get_server()) == NULL) {
+		fputs("contact_surface: servers idling!\n", stderr);
+		exit(1);
+	}
+	fprintf(sp->out_fd, CS_COMMAND, n);
+	(void) fflush(sp->out_fd);
+	sp->state = EXECUTING;
+	sp->reply = surface_reply;
+	sp->retry = contact_surface;
+	sp->arg1 = n;
+}
+
+/*
+ * torus_surface:
+ *	Start a server on computing the toroid reentrant surface between
+ *	atoms `n' and `m'
+ */
+STATIC
+void
+torus_surface(n, m)
+int	n, m;
+{
+	register SERVER	*sp;
+
+	if ((sp = get_server()) == NULL) {
+		fputs("torus_surface: servers idling!\n", stderr);
+		exit(1);
+	}
+	fprintf(sp->out_fd, TS_COMMAND, n, m);
+	(void) fflush(sp->out_fd);
+	sp->state = EXECUTING;
+	sp->reply = surface_reply;
+	sp->retry = torus_surface;
+	sp->arg1 = n;
+	sp->arg2 = m;
+}
+
+/*
+ * probe_surface:
+ *	Start a server on computing the probe reentrant surface
+ *	for probe `pp'
+ */
+STATIC
+void
+probe_surface(n)
+int	n;
+{
+	register SERVER	*sp;
+
+	if ((sp = get_server()) == NULL) {
+		fputs("probe_surface: servers idling!\n", stderr);
+		exit(1);
+	}
+	fprintf(sp->out_fd, PS_COMMAND, n);
+	(void) fflush(sp->out_fd);
+	sp->state = EXECUTING;
+	sp->reply = surface_reply;
+	sp->retry = probe_surface;
+	sp->arg1 = n;
+}
+
+/*
+ * surface_reply:
+ *	This routine is used by all surface computation requests.
+ *	We read surface data until we get an "END" message
+ */
+STATIC
+void
+surface_reply(sp)
+SERVER	*sp;
+{
+	register SURFACE	*surfp;
+	register int		cc;
+	char			buf[BUFSIZ];
+	int			n, nn, type, have_normal;
+	double			area;
+
+	for (;;) {
+		if (fgets(buf, sizeof buf, sp->in_fd) == NULL) {
+			fputs("surface_reply: server died\n", stderr);
+			goto bad;
+		}
+		if (strcmp(buf, SURFACE_END) == 0)
+			break;
+		if (sscanf(buf, SURFACE_RESPONSE, &n, &nn, &type, &area,
+		&have_normal) != 5) {
+			fputs("surface_reply: bad response from server\n",
+				stderr);
+			fputs(buf, stderr);
+			goto bad;
+		}
+		if (nn <= 0)
+			continue;
+		surfp = (SURFACE *) emalloc(sizeof (SURFACE));
+		surfp->next = alist[n]->surface;
+		alist[n]->surface = surfp;
+		surfp->type = type;
+		surfp->area = area;
+		surfp->npoint = nn;
+		surfp->position = (POINT *) emalloc(nn * sizeof (POINT));
+		if ((cc = fread((char *) surfp->position, sizeof (POINT), nn,
+		sp->in_fd)) != nn) {
+			fprintf(stderr,
+				"surface_reply: Read %d points, wanted %d\n",
+				cc, nn);
+			surfp->npoint = 0;
+			goto bad;
+		}
+		if (!have_normal) {
+			surfp->normal = NULL;
+			continue;
+		}
+		surfp->normal = (POINT *) emalloc(nn * sizeof (POINT));
+		if (fread((char *) surfp->normal, sizeof (POINT), nn,
+		sp->in_fd) != nn) {
+			fputs("surface_reply: EOF from server\n", stderr);
+			surfp->npoint = 0;
+			goto bad;
+		}
+	}
+
+	/*
+	 * Got all data, just reset state and return
+	 */
+	sp->state = AVAILABLE;
+	return;
+
+bad:
+	/*
+	 * Mark the server as dead and return
+	 */
+	sp->state = DEAD;
+	(void) fclose(sp->in_fd);
+	(void) fclose(sp->out_fd);
+	return;
+}
+
+/*
+ * collapse_probes:
+ *	Check for near-coincident probes and remove redundant
+ *	surface coverage
+ */
+STATIC
+void
+collapse_probes()
+{
+	int	i, j;
+	PROBE	*pp, *npp;
+	double	delta, distsq;
+	ATOM	*shared[3];
+	int	nshared;
+	double	plane[4];
+	double	v1[3], v2[3];
+	double	pside, npside;
+#define	EPSILON	1e-8
+
+	for (pp = probe; pp != NULL; pp = pp->next) {
+		if (!pp->real)
+			continue;
+		for (npp = pp->next; npp != NULL; npp = npp->next) {
+			distsq = 0;
+			for (i = 0; i < 3; i++) {
+				delta = pp->coord[i] - npp->coord[i];
+				distsq += delta * delta;
+			}
+			if (distsq > EPSILON)
+				continue;
+			nshared = 0;
+			for (i = 0; i < 3; i++)
+				for (j = 0; j < 3; j++)
+					if (pp->atom[i] == npp->atom[j]) {
+						shared[nshared++] =
+							alist[pp->atom[i]];
+						break;
+					}
+			if (nshared != 2)
+				continue;
+			for (i = 0; i < 3; i++) {
+				v1[i] = shared[0]->coord[i] - pp->coord[i];
+				v2[i] = shared[1]->coord[i] - pp->coord[i];
+			}
+			cross(v1, v2, plane);
+			plane[3] = 0;
+			for (i = 0; i < 3; i++)
+				plane[3] -= plane[i] * pp->coord[i];
+			for (i = 0; i < 3; i++) {
+				if (alist[pp->atom[i]] != shared[0]
+				&& alist[pp->atom[i]] != shared[1]) {
+					pside = plane[3];
+					for (j = 0; j < 3; j++)
+						pside += alist[pp->atom[i]]
+							->coord[j] * plane[j];
+				}
+				if (alist[npp->atom[i]] != shared[0]
+				&& alist[npp->atom[i]] != shared[1]) {
+					npside = plane[3];
+					for (j = 0; j < 3; j++)
+						npside += alist[npp->atom[i]]
+							->coord[j] * plane[j];
+				}
+			}
+			if ((npside < 0 && pside < 0)
+			|| (npside > 0 && pside > 0))
+				npp->real = 0;
+		}
+	}
+}
+
+/*
+ * cross:
+ *	Take cross product of a and b
+ */
+STATIC
+void
+cross(a, b, result)
+double a[3];
+double b[3];
+double result[3];
+{
+	result[0] = a[1] * b[2] - b[1] * a[2];
+	result[1] = a[2] * b[0] - b[2] * a[0];
+	result[2] = a[0] * b[1] - b[0] * a[1];
+}

dms/dms.1

@@ -0,0 +1,286 @@
+.TH DMS 1 "" "\fBAPPENDIX 6\fP" "\fBUCSF MidasPlus\fP"
+.iX zd start
+.SH NAME
+dms \- calculate a solvent-accessible molecular surface
+.SH SYNOPSIS
+.B dms
+\fIfile\fR [
+.B \-a
+] [
+.B \-d
+\fIdensity\fR] [
+.B \-g
+\fIfile\fR] [
+.B \-i
+\fIfile\fR] [\fB\-n\fR] [\fB\-w
+\fIradius\fR] [\fB\-v\fR] \fB\-o\fI file\fR
+.SH DESCRIPTION
+.I Dms
+calculates the molecular surface of a molecule.
+The molecular surface resembles the van der Waals
+surface of a molecule,
+except that crevices between atoms are smoothed over
+and interstices too small
+to accommodate the probe are eliminated.
+The surface includes cavities in the interior
+of the molecule,
+even if they are not accessible to a solvent molecule
+coming from the outside.
+.LP
+The molecular surface
+calculated is that defined by
+F. M. Richards (1977,
+.I "Ann. Rev. Biophys. Bioeng."
+).
+In particular,
+the calculated molecular surface is that traced out by the \fIsurface\fP
+of the probe sphere rather that the probe sphere's \fIcenter\fP.
+According to Richards' definition
+the molecular surface consists of two parts:
+.I "contact surface"
+and
+.I "reentrant surface."
+The contact surface is
+made up of
+``those parts of the molecular van der Waals
+surface that can actually be in contact
+with the surface of the probe.''
+The reentrant surface is defined by
+``the interior-facing part of the probe
+when it is simultaneously
+in contact with more than one atom.''
+.I Dms
+reports the amounts of contact and reentrant surface area,
+and the combined total surface area on the standard error output
+(see the \fB\-g\fP flag below).
+.LP
+.I File
+is an input file of coordinates.
+The input file must be in the Protein Data Bank format.
+The first letter or first two letters
+of the atom name is used
+to determine the element type.
+By default, implicit hydrogens are
+included for carbon,
+nitrogen and oxygen atoms,
+thus aromatic carbons
+and nitrogens
+will have van der Waals radii
+that are somewhat too big.
+Note that
+only amino acid and nucleic acid residues
+will be included unless \fB\-a\fR is also specified.
+.LP
+.SL
+.I Dms
+can be set up to run on multiple machines
+simultaneously for increased performance.
+By default, it only runs on the local host.
+The
+.SM UCSF
+MidasPlus Installation Guide
+that came with the MidasPlus
+.SM CD-ROM
+contains instructions
+on how to configure
+.I dms
+to use multiple machines.
+.EL
+.LP
+.SL
+If it is desired to simply visualize a small molecular surface
+from within 
+.SM MIDAS\c
+, it may be easier to use the \fImakems\fP(1) delegate,
+rather than run \fIdms\fP directly.
+Consult the \fImakems\fP manual page for further details.
+.EL
+.SH OPTIONS
+The flags may be in any order.
+The meanings of the flags are described below:
+.IP \fB\-a\fR
+Include all atoms,
+not just those in amino acid and nucleic acid residues.
+.IP \fB\-d\fR
+Change the density of points on the surface.
+.I Density
+is a factor affecting
+the density of points on the surface;
+the default of 1.0 produces about 5 points
+per square angstrom.
+Only values between 0.1 and 10.0 are permitted.
+For large proteins,
+a density of 0.5 is recommended.
+.IP \fB\-g\fR
+Write all the informative messages to
+.I file,
+instead of the standard error output.
+Genuine errors still go to the standard error output.
+This file is not rewound at any time,
+so messages from several runs may be accumulated.
+.IP \fB\-i\fR
+.iX 36
+Calculate the molecular surface
+only for those residues and atoms
+specified in
+.I file,
+but keeping the rest of the molecule
+for collision checks.
+The file consists of a series of lines
+such as the following:
+.nf
+ASP  205 CA
+TYR   13 *
+GLY  116 FRM
+HIS  178 TO
+.fi
+.IP
+The asterisk means all atoms of the residue
+and the ``FRM'' and ``TO'' mean all residues
+from 116 to 178 inclusive.
+The sequence number may contain letters,
+and if the
+.SM PDB
+input file contains chain identifiers,
+then those should be appended on the right of the sequence number.
+Residue insertion codes (if any) should be placed between
+the sequence number and any chain identifier.
+Residues contained in \fCHETATM\fP records should have
+an asterisk appended to the end of the residue identifier.
+The surface generated using the \fB\-i\fR flag
+is not always the same as the surface
+generated by running the entire molecule
+and afterwards selecting out the desired atoms.
+The first surface will not include
+reentrant surface lying between
+an atom in the \fB\-i\fR file and atoms not in the file.
+.iX bd
+The
+.IR pdb2site (1)
+utility may be useful for generating site files.
+Consult the
+.I pdb2site
+manual page for further details.
+.IP \fB\-n\fR
+Include the unit normals
+to the surface with
+each surface point record.
+.IP \fB\-v\fR
+Produce more verbose output.
+.I Dms
+will announce each computation phase as it is entered
+as well as a count of the atom types in the molecule
+and the number of computation requests handled by each
+host that participated in the
+.I dms
+calculation.
+.IP \fB\-o\fR
+The output is written to
+.I file.
+This flag is not optional.
+.IP \fB\-w\fR
+Change the water probe radius from the default
+radius of 1.4 angstroms.
+This parameter must be between
+1.0 and 201.0.
+.LP
+The output consists of
+a series of atom and surface point records,
+with the same format for the
+first six fields.
+Each atom is followed by
+the surface points (if any)
+which belong to it.
+These first six fields
+are in the following format:
+residue name,
+sequence number,
+atom name,
+x coordinate,
+y coordinate,
+z coordinate.
+For an atom record,
+the seventh field is ``A.''
+For a surface point record,
+the seventh field begins
+with an ``S,''
+followed by a ``C,'' ``R,'' or ``S''
+according to whether
+the point is part of
+contact, reentrant, or ``saddle'' surface
+(``saddle'' is a type of reentrant surface
+where the probe is in contact with exactly
+two atoms).
+This is followed a digit
+used for depicting
+different density levels.
+The eighth field is the
+molecular surface area associated
+with the point in
+square angstroms.
+If the \fB\-n\fR flag is specified,
+the next three fields are
+the unit normal vector
+pointing outward from the surface.
+Informative messages and errors are
+written to the standard error output
+unless a \fB\-g\fR file is specified.
+.LP
+.iX 27 start
+The chemical elements and radii
+that the program handles are detailed
+in the table below.
+The program gets these values from the file
+.IR /usr/local/midas/resource/dms/radii .
+If there is a file in the current directory called
+.IR radii ,
+then
+.I dms
+will use that file instead.
+So in order to add uncommon elements or
+use different radii, one should copy the
+default file and modify it.
+The file format is documented in the file itself.
+.sp
+.RS 1i
+.TS
+box;
+c c
+a n.
+Element	Radius
+_	_
+H	1.20
+C	1.90
+N	1.50
+O	1.40
+F	1.35
+P	1.90
+S	1.85
+Cl	1.8
+Fe	0.64
+Cu	1.28
+Zn	1.38
+Br	1.95
+I	2.15
+Other	1.90
+.TE
+.RE
+.SH "SEE ALSO"
+.SL
+pdb2site(1),
+The UCSF MidasPlus Installation Guide
+.EL
+.SH "AUTHOR"
+Conrad Huang
+.br
+University of California, San Francisco
+.SH FILES
+/usr/local/midas/resource/dms/radii        default atomic radii
+.iX 27 stop
+.br
+.SH DIAGNOSTICS
+Many and varied.
+.iX 37
+Be sure to examine the \fB\-g\fR file before you leave
+a background job running overnight.
+.iX zd stop

dms/dms.html

@@ -0,0 +1,183 @@
+<html>
+<head>
+<title>dms</title>
+</head>
+<body>
+<h4>NAME</h4>
+  <h3>dms - calculate a molecular surface</h3>
+
+<h4>SYNOPSIS</h4>
+<h3><b>dms</b> <i>pdbfile</i> [ -a ] [ -d <i>density</i>] [ -g <i>logfile</i> ]
+ [ -i <i>sitefile</i> ] [-n] [-w <i>radius</i> ] [-v] -o <i>outfile</i>
+</h3>
+
+<h4>DESCRIPTION</h4>
+<p>
+  <b>Dms</b> calculates the molecular surface of a molecule.
+  The molecular surface
+  resembles the van der Waals surface of a molecule, except that crevices
+  between atoms are smoothed over and interstices too small to accommodate
+  the probe are eliminated.  The surface includes cavities in the interior of
+  the molecule, even if they are not accessible to a solvent molecule coming
+  from the outside.
+</p><p>
+  The molecular surface calculated is that defined by Richards (see
+  the <a href="#ref">reference</a> below).
+  In particular, the calculated molecular surface is that traced out by
+  the surface of the probe sphere rather that the
+  probe sphere's center.  According to Richards' definition, the molecular
+  surface consists of two parts: contact surface and reentrant surface. The
+  contact surface is made up of "those parts of the molecular van der Waals
+  surface that can actually be in contact with the surface of the probe."
+  The reentrant surface is defined by "the interior-facing part of the probe
+  when it is simultaneously in contact with more than one atom."  <b>Dms</b>
+  reports the amounts of contact and reentrant surface area, and the combined
+  total surface area on the standard error output (see <a href="#gflag">
+  <b>-g</b></a>).
+</p><p>
+  <i>Pdbfile</i> is an input file of coordinates.
+  The input file must be in the Protein Data Bank format.
+  The first part of each atom
+  name is used to determine the element type.  By default, implicit hydrogens
+  are included for carbon, nitrogen and oxygen atoms; thus, aromatic carbons
+  and nitrogens will have van der Waals radii that are somewhat too big.
+  Note that only amino acid and nucleic acid residues will be included unless
+  <a href="#aflag"><b>-a</b></a> is also specified.
+</p>
+
+<h4>COMMAND-LINE ARGUMENTS</h4>
+
+<blockquote>
+<a name="aflag">
+  <tt><b>-a</b></tt>
+</a>
+<br>Include all atoms, not just those in amino acid and nucleic acid residues.
+</blockquote>
+
+<blockquote>
+  <tt><b>-d</b> <i>density</i></tt>
+<br>   <i>Density</i> is a factor affecting the density of points
+       on the surface; the default of <b>1.0</b>
+       produces about 5 points per square angstrom.  Only values between
+       <b>0.1</b> and <b>10.0</b> are permitted.
+       A density of <b>0.5</b> is recommended for large molecules.
+</blockquote>
+
+<blockquote>
+<a name="gflag">
+  <tt><b>-g</b> <i>logfile</i></tt>
+</a>
+<br>   Write all the informative messages to <i>logfile</i> instead of the
+       standard error output.  Genuine errors still go to the standard error
+       output.  New log information is appended to <i>logfile</i> rather than
+       overwriting it, and thus messages from several runs may be accumulated.
+</blockquote>
+
+<blockquote>
+<a name="iflag">
+  <tt><b>-i</b> <i>sitefile</i></tt>
+</a>
+<br>   Calculate the molecular surface only for those residues and atoms
+       specified in <i>sitefile</i>,
+       keeping the rest of the molecule for collision checks.
+       <i>Sitefile</i> consists of lines such as the following:
+<blockquote><tt>
+<table>
+<tr>
+<td>ASP</td> <td align="right">205</td> <td>CA</td>
+</tr><tr>
+<td>TYR</td> <td align="right">13</td> <td>*</td>
+</tr><tr>
+<td>GLY</td> <td align="right">116</td> <td>FRM</td>
+</tr><tr>
+<td>HIS</td> <td align="right">178</td> <td>TO</td>
+</tr>
+</table>
+</tt></blockquote>
+       The asterisk, <b>*</b>, means all atoms of the residue, and the 
+       "FRM" and "TO" lines mean all residues from 116 to 178 inclusive.
+       The sequence number may
+       contain letters, and if the PDB input file contains chain identifiers,
+       then those should be appended on the right of the sequence number.
+       Residue insertion codes (if any) should be placed between the sequence
+       number and any chain identifier.	 Residues contained in HETATM records
+       should have an asterisk appended to the end of the residue identifier.
+       The surface generated using <a href="#iflag"><b>-i</b></a>
+       is not always the same as the
+       surface generated by running the entire molecule and afterwards
+       selecting the desired atoms.  The first surface will not include
+       reentrant surface lying between an atom in <i>sitefile</i> and atoms not
+       in the file.
+</blockquote>
+
+<blockquote>
+<a name="nflag">
+  <tt><b>-n</b></tt>
+</a>
+<br>   Include the unit normals to the surface with each surface point record.
+</blockquote>
+
+<blockquote>
+  <tt><b>-w</b> <i>radius</i></tt>
+<br>   Change the "water" probe <i>radius</i> from the default of <b>1.4</b>
+       angstroms.  <i>Radius</i> must be between <b>1.0</b> and <b>201.0</b>.
+</blockquote>
+
+<blockquote>
+  <tt><b>-v</b></tt>
+<br>   Produce more verbose output.  <b>Dms</b>
+       will announce each computation phase
+       as it is entered as well as a count of the atom types in the molecule
+       and the number of computation requests handled by each host that
+       participated in the calculation.
+</blockquote>
+
+<blockquote>
+  <tt><b>-o</b> <i>outfile</i></tt>
+<br>   The output surface is written to <i>outfile</i>.
+       This flag is not optional.
+</blockquote>
+
+<p>
+  The output consists of a series of atom and surface point records, with the
+  same format for the first six fields.	 Each atom is followed by the surface
+  points (if any) which belong to it.  These first six fields are in the
+  following format: residue name, sequence number, atom name, x coordinate,
+  y coordinate, z coordinate.  For an atom record, the seventh field is "A."
+  For a surface point record, the seventh field begins with an "S,"
+  followed by a "C," "R," or "S" according to whether the point is part of
+  contact, reentrant, or saddle surface (saddle is a type of reentrant
+   surface where the probe is in contact with exactly two atoms).  This
+  is followed a digit used for depicting different density levels.  The
+  eighth field is the molecular surface area associated with the point in
+  square angstroms.  If <a href="#nflag"><b>-n</b></a> is specified, the
+  next three fields are
+  the unit normal vector pointing outward from the surface.
+  Messages and errors are written to the standard error output
+  unless a separate log file has been
+  specified with <a href="#gflag"><b>-g</b></a>.
+</p><p>
+  <b>Dms</b> reads the elements and radii from a file named <b>radii</b>.
+  If there is a file in the current
+  directory called <b>radii</b>, then <b>dms</b> will use that file instead.
+  To add uncommon elements or use different radii, one should copy the
+  default radii file from the distribution and modify it.
+  The file format is documented in the file itself.
+</p>
+
+<h4>SEE ALSO</h4>
+<p>
+<a name="ref">
+ Richards, F.M.,</a>
+ "Areas, volumes, packing and protein structure,"
+   <i>Ann. Rev. Biophys. Bioeng.</i> <b>6</b>, 151-176 (1977).
+</p>
+
+<h4>AUTHOR</h4>
+  Conrad Huang
+  <br>University of California, San Francisco
+
+<h4>DIAGNOSTICS</h4>
+  Many and varied.  Be sure to examine the output messages (standard error
+  or <i>logfile</i>, if specified) before leaving a background job running.
+</body></html>

dms/dms_param.h

@@ -0,0 +1,68 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+#define	DEF_DIR(x)	DESTLIB#x
+
+/*
+ * SERVER_FILE contains a list of hosts that run dms servers (and are
+ * binary-compatible with the host running dms)
+ */
+#define	SERVER_FILE	"dms_servers"
+#define	DEF_SERVER_FILE	DEF_DIR(dms_servers)
+
+/*
+ * RADII_FILE contains a list of radii
+ */
+#define	RADII_FILE	"radii"
+#define	DEF_RADII_FILE	DEF_DIR(radii)
+
+/*
+ * LOCK_FILE is the name of the file that a dms server tries to lock.
+ * If the file exists and the lock fails, then the server will exit.
+ */
+#define	LOCK_FILE	DEF_DIR(lockfile)
+
+/*
+ * NICE_PRIORITY is the priority that a dms server sets itself to.
+ */
+#define	NICE_PRIORITY	15
+
+/* 
+ * The following #defines are for possible code options.  The best
+ * combination for running on Suns is currently selected.  Your mileage
+ * may vary with other (e.g. vectorizing) compilers.
+ */
+#define SORTED_NB	/* Neighbor list sorted by distance */
+#undef	ONE_OCCLUDE	/* Only check occlusion after summing components */
+#define KEEP_REAL	/* Keep only non-hidden probes */
+#define RETRANS_NB	/* Retransmit shortened neighbor list to servers */

dms/dms_servers.proto

@@ -0,0 +1 @@
+localhost

dms/dmsd/GNUmakefile

@@ -0,0 +1,34 @@
+ifeq ($(shell test -e /bin/cygwin1.dll && echo found),found)
+PROG	= dmsd.exe
+else
+PROG	= dmsd
+endif
+
+DESTLIB	= ${LIBDIR}/dms
+
+DEFS	= -DDESTLIB=\"${DESTLIB}\"
+
+OBJS	= server.o viewat.o lookat.o freadv.o emalloc.o
+OPT	= -g
+CFLAGS	= -I.. ${DEFS} ${OPT}
+
+${PROG}: ${OBJS}
+	${CC} -o ${PROG} ${OBJS} -lm
+
+beforeinstall:
+	-mkdir ${DESTLIB}
+
+afterinstall:
+	cp ../dms_servers.proto ${DESTLIB}/dms_servers.proto
+
+install: ${PROG} afterinstall
+afterinstall: realinstall
+realinstall: beforeinstall
+	cp ${PROG} ${DESTLIB}
+	-strip ${DESTLIB}/${PROG}
+
+clean:
+	rm -f ${OBJS}
+
+spotless:
+	rm -f ${OBJS} ${PROG}

dms/dmsd/emalloc.c

@@ -0,0 +1,86 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+/*
+ * emalloc:
+ *	Same as malloc but exits when failure occurs
+ */
+char *
+emalloc(size)
+unsigned	size;
+{
+	register char	*cp;
+
+	if ((cp = malloc(size)) == NULL) {
+		fprintf(stderr, "emalloc(%u) failed\n", size);
+		exit(1);
+	}
+	return cp;
+}
+
+/*
+ * erealloc:
+ *	Same as realloc but exits when failure occurs
+ */
+char *
+erealloc(ptr, size)
+char		*ptr;
+unsigned	size;
+{
+	register char	*cp;
+
+	if ((cp = realloc(ptr, size)) == NULL) {
+		fprintf(stderr, "erealloc(ptr, %u) failed\n", size);
+		exit(1);
+	}
+	return cp;
+}
+
+/*
+ * ecalloc:
+ *	Same as calloc but exits when failure occurs
+ */
+char *
+ecalloc(nelem, elsize)
+unsigned nelem, elsize;
+{
+	register char	*cp;
+
+	if ((cp = calloc(nelem, elsize)) == NULL) {
+		fprintf(stderr, "calloc(%u, %u) failed\n", nelem, elsize);
+		exit(1);
+	}
+	return cp;
+}

dms/dmsd/freadv.c

@@ -0,0 +1,54 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+
+/*
+ * freadv:
+ *	Like readv system call except we use stdio library
+ */
+freadv(fp, iov, n)
+FILE		*fp;
+struct iovec	*iov;
+int		n;
+{
+	register struct iovec	*ip, *endip;
+	register int		cc;
+
+	cc = 0;
+	endip = iov + n;
+	for (ip = iov; ip < endip; ip++)
+		cc += fread(ip->iov_base, sizeof (char), ip->iov_len, fp);
+	return cc;
+}

dms/dmsd/lookat.c

@@ -0,0 +1,98 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include <math.h>
+
+/*
+ * This function is like the one from the E & S library which produces
+ * a matrix to rotate a vector to the Z axis.
+ *
+ * This version is much enhanced over the Pic Sys original, in that
+ * you give it both ends of the bond to be rotated about and it
+ * returns both the "m_lookat" tensor and its inverse.
+ *
+ * Martin Pensak:  1977
+ *
+ * Stolen and hacked for the PS300 by Conrad Huang 24feb84
+ */
+lookat(array, arrayinv, x, y)
+double	array[4][4];		/* the output array */
+double	arrayinv[4][4];		/* output array for the inverse of
+				 * the main output */
+double	x[3], y[3];		/* the vectors */
+{
+	register int	j, k;
+	double		a, b, c, l, d;
+	double		m[4][4];
+
+	a = y[0] - x[0];
+	b = y[1] - x[1];
+	c = y[2] - x[2];
+	l = sqrt(a*a + c*c);
+	d = sqrt(l*l + b*b);
+	if (d == 0.0) {
+		fprintf(stderr, "Illegal value passed to m_lookat\n");
+		return;
+	}
+
+	m[0][0] = (l != 0) ? (c / l) : 1;
+	m[0][1] = (l != 0) ? (-(a * b)/(l * d)) : 0;
+	m[0][2] = a / d;
+	m[0][3] = 0;
+	m[1][0] = 0;
+	m[1][1] = l / d;
+	m[1][2] = b / d;
+	m[1][3] = 0;
+	m[2][0] = (l != 0) ? ( - a / l) : 0;
+	m[2][1] = (l != 0) ? ( -(b * c)/(l * d)) : 1;
+	m[2][2] = c / d;
+	m[2][3] = 0;
+	m[3][0] = m[3][1] = m[3][2] = 0;
+	m[3][3] = 1;
+
+	for (j = 0; j < 4; j++)
+		for (k = 0; k < 4; k++)
+			array[j][k] = arrayinv[k][j] = m[j][k];
+
+	/* now set up the translations */
+	a = x[0];
+	b = x[1];
+	c = x[2];
+	arrayinv[3][0] = a;
+	arrayinv[3][1] = b;
+	arrayinv[3][2] = c;
+
+	array[3][0] = -(a*m[0][0] + b*m[1][0] + c*m[2][0]);
+	array[3][1] = -(a*m[0][1] + b*m[1][1] + c*m[2][1]);
+	array[3][2] = -(a*m[0][2] + b*m[1][2] + c*m[2][2]);
+}

dms/dmsd/server.c

@@ -0,0 +1,1834 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include <math.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/file.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include "dms_param.h"
+#include "atoms.h"
+#include "protocol.h"
+
+#ifndef	TRUE
+#define	TRUE	1
+#define	FALSE	0
+#endif
+
+#ifndef	PI
+#define	PI	3.141592
+#endif
+
+#define	ROUND(x)	((int) ((x) + 0.5))
+#define	ABS(x)		((x) < 0 ? -(x) : (x))
+
+#define LOG		/* Log input and output */
+
+#ifndef	DEBUG
+#undef	LOG
+#endif
+
+static void	execute(char *cp);
+static void	paramdata(double f1, double f2, int n);
+static void	atomdata(int n);
+static void	neighbordata(int n);
+static void	probedata(int n);
+static void	contacts(int n);
+static void	s_probes(int n, int m);
+static void	csurface(int n);
+static void	tsurface(int n, int m);
+static void	psurface(int n);
+
+extern char	*sbrk(unsigned long);
+extern char	*emalloc(unsigned int);
+
+/*
+ * SERVER:
+ *	Compute server for MS.
+ *	This server is started via inetd so the input comes from stdin
+ *	and output goes to stdout.
+ */
+main()
+{
+	char		buf[BUFSIZ];
+	int		lockfd;
+
+	(void) chdir("/tmp");
+#ifdef DEBUG
+	(void) freopen("/tmp/dmsdlog", "w", stderr);
+#ifdef BSD
+	(void) setlinebuf(stderr);
+#endif
+	fprintf(stderr, "server started\n");
+#endif
+
+	/*
+	 * Try locking the lock file.  If we fail, another dms
+	 * server is already running so we just exit.  If the file
+	 * doesn't exist, then we just assume that it's okay to run.
+	 */
+	lockfd = open(LOCK_FILE, 0);
+	if (lockfd >= 0 && flock(lockfd, LOCK_EX) < 0) {
+		printf("Go away, I'm busy.\n");
+		exit(0);
+	}
+
+	/*
+	 * Now we nice ourselves down to background priority so
+	 * normal jobs will still get the CPU
+	 */
+#ifdef BSD
+	(void) setpriority(PRIO_PROCESS, 0, NICE_PRIORITY);
+#else
+	(void) nice(NICE_PRIORITY);
+#endif
+
+	/*
+	 * Read commands and execute them until we reach EOF
+	 */
+	while (fgets(buf, sizeof buf, stdin) != NULL) {
+#ifdef LOG
+		fprintf(stderr, "<-- %s", buf);
+#endif
+		execute(buf);
+		(void) fflush(stdout);
+	}
+
+	/*
+	 * Cleanup and exit
+	 */
+#ifdef DEBUG
+	fprintf(stderr, "Memory high water mark: %d\n", sbrk(0));
+#endif
+	exit(0);
+}
+
+typedef struct	keyword_def	{
+	char	*string;
+	int	length;
+	int	type;
+}	KEYWORD;
+
+#define	C_PARAM		0
+#define	C_ATOM		1
+#define	C_NEIGHBOR	2
+#define	C_PROBEDATA	3
+#define	C_CONTACT	4
+#define	C_PROBE		5
+#define	C_CSURF		6
+#define	C_TSURF		7
+#define	C_PSURF		8
+
+static KEYWORD	keyword[] = {
+	{	"paramdata",	9,	C_PARAM,	},
+	{	"atomdata",	8,	C_ATOM,		},
+	{	"neighbordata",	12,	C_NEIGHBOR,	},
+	{	"probedata",	9,	C_PROBEDATA,	},
+	{	"contacts",	8,	C_CONTACT,	},
+	{	"probes",	6,	C_PROBE,	},
+	{	"csurface",	8,	C_CSURF,	},
+	{	"tsurface",	8,	C_TSURF,	},
+	{	"psurface",	8,	C_PSURF,	},
+};
+#define	NKEY	(sizeof keyword / sizeof (KEYWORD))
+
+/*
+ * execute:
+ *	Parse the given command and call the appropriate handler
+ */
+static
+void
+execute(char *cp)
+{
+	register KEYWORD	*kp, *endkp;
+	int			n, m;
+	double			f1, f2;
+
+	endkp = &keyword[NKEY];
+	for (kp = keyword; kp < endkp; kp++)
+		if (strncmp(cp, kp->string, kp->length) == 0)
+			break;
+	if (kp >= endkp) {
+		printf("Unknown command: %s", cp);
+#ifdef DEBUG
+		fprintf(stderr, "Unknown command: %s", cp);
+#endif
+		return;
+	}
+	switch (kp->type) {
+	  case C_PARAM:
+		if (sscanf(cp, PI_COMMAND, &f1, &f2, &n) != 3)
+			goto bad;
+		paramdata(f1, f2, n);
+		break;
+	  case C_ATOM:
+		if (sscanf(cp, AI_COMMAND, &n) != 1)
+			goto bad;
+		atomdata(n);
+		break;
+	  case C_NEIGHBOR:
+		if (sscanf(cp, NI_COMMAND, &n) != 1)
+			goto bad;
+		neighbordata(n);
+		break;
+	  case C_PROBEDATA:
+		if (sscanf(cp, PRI_COMMAND, &n) != 1)
+			goto bad;
+		probedata(n);
+		break;
+	  case C_CONTACT:
+		if (sscanf(cp, C_COMMAND, &n) != 1)
+			goto bad;
+		contacts(n);
+		break;
+	  case C_PROBE:
+		if (sscanf(cp, P_COMMAND, &n, &m) != 2)
+			goto bad;
+		s_probes(n, m);
+		break;
+	  case C_CSURF:
+		if (sscanf(cp, CS_COMMAND, &n) != 1)
+			goto bad;
+		csurface(n);
+		break;
+	  case C_TSURF:
+		if (sscanf(cp, TS_COMMAND, &n, &m) != 2)
+			goto bad;
+		tsurface(n, m);
+		break;
+	  case C_PSURF:
+		if (sscanf(cp, PS_COMMAND, &n) != 1)
+			goto bad;
+		psurface(n);
+		break;
+	}
+	return;
+bad:
+	printf("Malformed command: %s", cp);
+#ifdef DEBUG
+	fprintf(stderr, "Malformed command: %s", cp);
+#endif
+	return;
+}
+
+/*
+ * The remainder of this file consists of routines that correspond to
+ * commands.  All necessary types and global variables are declared here.
+ */
+
+typedef struct satom_def	{
+	struct satom_def	*next;		/* Pointer to next neighbor */
+	ATOM			atom;		/* Atom information */
+	int			nnb;		/* Number of neighbors */
+	AINDEX			*nb;		/* Neighbor list */
+	int			nprobe;		/* Number of probes */
+	int			*probe;		/* Probe list */
+	int			nused;
+#ifdef SORTED_NB
+	double			dist;
+#endif
+}	SATOM;
+
+typedef struct sphere_def	{
+	struct sphere_def	*next;		/* Pointer to next sphere */
+	double			radius;		/* Radius */
+	double			area;		/* Area per point */
+	int			npoint;		/* Number of points */
+	POINT			*point;		/* Point list */
+}	SPHERE;
+
+typedef struct snb_def	{
+	double	*coord;				/* Coordinate of neighbor */
+	double	dist;				/* Distance between atoms */
+	double	clip;				/* Clipping distance */
+}	SNB;
+
+typedef struct sangle_def	{
+	struct sangle_def	*next;		/* Pointer to next angle */
+	double			angle;		/* Probe angle */
+	int			start;		/* Starting or ending? */
+	int			real;		/* This section truly exist */
+}	SANGLE;
+
+double	radius, density;	/* Probe and surface parameters */
+double	arclength;		/* Approximate arc length between points */
+double	root3;			/* Square root of 3 */
+int	want_normal;		/* Whether we should report normals */
+int	natom;			/* Number of atoms */
+SATOM	*atom;			/* Atom list */
+int	nprobe;			/* Number of probes */
+PROBE	*probe;			/* Probe list */
+double	maxrad;			/* Maximum atomic radius */
+SPHERE	*sphere;		/* List of prototype spheres */
+int	maxsurf;		/* Size of surface list */
+POINT	*surface;		/* Surface points list */
+POINT	*normal;		/* Normal list (same size as surface) */
+
+static SATOM	*find_satom(double x);
+static int	touches(SATOM *s1, SATOM *s2, double *dp);
+static int	probe_position(SATOM *a0, SATOM *a1, SATOM *a2,
+		double ppos[2][3], int check_only);
+static int	hidden(SATOM *s0, SATOM *s1, SATOM *s2, double coord[3]);
+static int	occlude(SATOM *sap, double pos[3]);
+static SPHERE	*get_sphere(double r);
+static int	clipped(double coord[3], SNB *nlist, SNB *endsnp);
+static SANGLE	*compute_angles(SATOM *s1, SATOM *s2, double mat[4][4],
+		int *na);
+static void	draw_tsections(double invmat[4][4], double tradius,
+		double clip[2], int n, int m, SANGLE *alist);
+static int	torus_data(ATOM *a1, ATOM *a2, double tcenter[3],
+		double *tradius, double clip[2]);
+static SANGLE	*probe_angle(int pnum, double mat[4][4], int n, int m);
+static SANGLE	*insert_angle(SANGLE *head, SANGLE *new);
+static void	tsection(double invmat[4][4], double tradius, double clip[2],
+		double start, double end, int n, int m, int check);
+static void	send_points(POINT *plist, int np, AINDEX aindex, double area,
+		int type, POINT *nlist);
+static void	check_point(PROBE *prp, int at, int up, int side, int npoint,
+		POINT point[], short keep[]);
+
+/*
+ * paramdata:
+ *	Take the parameter data and put them in the right places
+ */
+static
+void
+paramdata(double f1, double f2, int n)
+{
+	radius = f1;
+	density = f2 * 2.75;
+	want_normal = n;
+	root3 = sqrt(3.0);
+
+	/*
+	 * The approximation
+	 *	arclength = sqrt( sqrt(3) / (3 * density) )
+	 * came from Eric Pettersen who approximated a sphere with a
+	 * plane (an infinite sphere, you know).
+	 */
+	arclength = 1.0 / sqrt(root3 * density);
+
+	fputs(PI_RESPONSE, stdout);
+#ifdef LOG
+	fputs(PI_RESPONSE, stderr);
+#endif
+}
+
+/*
+ * atomdata:
+ *	Read in atomic data
+ */
+static
+void
+atomdata(int n)
+{
+	register int		cc;
+	register SATOM		*sap, *endsap;
+	register struct iovec	*ip;
+	struct iovec		*iov, *endip;
+
+	/*
+	 * Update global variables
+	 */
+	natom = n;
+	atom = (SATOM *) emalloc(n * sizeof (SATOM));
+#ifdef DEBUG
+	fprintf(stderr, "Atom data = %d bytes\n", n * sizeof (SATOM));
+#endif
+
+	/*
+	 * Read in the data
+	 */
+	iov = (struct iovec *) emalloc(n * sizeof (struct iovec));
+	endip = iov + n;
+	for (ip = iov, sap = atom; ip < endip; ip++, sap++) {
+		ip->iov_base = (caddr_t) &sap->atom;
+		ip->iov_len = sizeof (ATOM);
+	}
+	if ((cc = freadv(stdin, iov, n)) != n * sizeof (ATOM)) {
+		printf("atomdata: got %d bytes instead of %d.\n",
+			cc, n * sizeof (ATOM));
+#ifdef DEBUG
+		fprintf(stderr, "atomdata: got %d bytes instead of %d.\n",
+			cc, n * sizeof (ATOM));
+#endif
+		return;
+	}
+
+	/*
+	 * Initialize data regarding spheres
+	 */
+	maxrad = 0;
+	endsap = atom + n;
+	for (sap = atom; sap < endsap; sap++) {
+		if (sap->atom.radius > maxrad)
+			maxrad = sap->atom.radius;
+		sap->nb = NULL;
+	}
+
+	/*
+	 * Cleanup and let caller know we've read things okay
+	 */
+	(void) free((char *) iov);
+	fputs(AI_RESPONSE, stdout);
+#ifdef LOG
+	fputs(AI_RESPONSE, stderr);
+#endif
+}
+
+/*
+ * neighbordata:
+ *	Read in neighbor data
+ */
+static
+void
+neighbordata(int n)
+{
+	register int		cc, size, total;
+	register SATOM		*sap, *endsap;
+	register struct iovec	*ip;
+	struct iovec		*iov;
+
+	/*
+	 * Check for consistency
+	 */
+	if (n != natom) {
+		printf("neighbordata: ncount(%d) != acount(%d)\n", n, natom);
+#ifdef DEBUG
+		fprintf(stderr, "neighbordata: ncount(%d) != acount(%d)\n",
+			n, natom);
+#endif
+		return;
+	}
+	endsap = atom + natom;
+
+	/*
+	 * Read in the neighbor count for each atom
+	 */
+	iov = (struct iovec *) emalloc(natom * sizeof (struct iovec));
+	for (sap = atom, ip = iov; sap < endsap; sap++, ip++) {
+		ip->iov_base = (caddr_t) &sap->nnb;
+		ip->iov_len = sizeof (int);
+	}
+	if ((cc = freadv(stdin, iov, n)) != n * sizeof (int)) {
+		printf("neighbordata: read %d bytes instead of %d.\n", cc,
+			n * sizeof (int));
+#ifdef DEBUG
+		fprintf(stderr, "neighbordata: read %d bytes instead of %d.\n",
+			cc, n * sizeof (int));
+#endif
+		return;
+	}
+
+	/*
+	 * Read in the actual data for each atom
+	 */
+	total = 0;
+	n = 0;
+	ip = iov;
+	for (sap = atom; sap < endsap; sap++) {
+		if (sap->nnb <= 0)
+			continue;
+		size = sap->nnb * sizeof (AINDEX);
+		if (sap->nb == NULL)
+			sap->nb = (AINDEX *) emalloc(size);
+		ip->iov_base = (caddr_t) sap->nb;
+		ip->iov_len = size;
+		total += size;
+		n++;
+		ip++;
+	}
+	if (n > 0 && (cc = freadv(stdin, iov, n)) != total) {
+		printf("neighbordata: read %d bytes instead of %d.\n", cc,
+			total);
+#ifdef DEBUG
+		fprintf(stderr, "neighbordata: read %d bytes instead of %d.\n",
+			cc, total);
+#endif
+		return;
+	}
+#ifdef DEBUG
+	fprintf(stderr, "Neighbor data = %d bytes\n", total + n * sizeof (int));
+#endif
+
+	/*
+	 * Cleanup and let caller know we've read things okay
+	 */
+	(void) free((char *) iov);
+	fputs(NI_RESPONSE, stdout);
+#ifdef LOG
+	fputs(NI_RESPONSE, stderr);
+#endif
+}
+
+/*
+ * probedata:
+ *	Read in probe and update atom information regarding probes
+ */
+static
+void
+probedata(int n)
+{
+	register int		i;
+	register SATOM		*sap, *endsap;
+	register PROBE		*pp, *endpp;
+	register int		cc, size;
+
+	/*
+	 * Update global variables
+	 */
+	nprobe = n;
+	if (n <= 0) {
+		fputs(PRI_RESPONSE, stdout);
+#ifdef LOG
+		fputs(PRI_RESPONSE, stderr);
+#endif
+		return;
+	}
+	size = n * sizeof (PROBE);
+	probe = (PROBE *) emalloc(size);
+#ifdef DEBUG
+	fprintf(stderr, "Probe data = %d bytes\n", size);
+#endif
+
+	/*
+	 * Read in the data
+	 */
+	if ((cc = fread((char *) probe, sizeof (PROBE), n, stdin)) != n) {
+		printf("probedata: got %d probes instead of %d.\n", cc, n);
+#ifdef DEBUG
+		fprintf(stderr, "probedata: got %d bytes instead of %d.\n",
+			cc, size);
+#endif
+		return;
+	}
+
+	/*
+	 * Now we update the atom data
+	 */
+	endsap = atom + natom;
+	for (sap = atom; sap < endsap; sap++)
+		sap->nprobe = sap->nused = 0;
+	endpp = probe + nprobe;
+	for (pp = probe; pp < endpp; pp++)
+		for (i = 0; i < 3; i++)
+			atom[pp->atom[i]].nprobe++;
+	for (sap = atom; sap < endsap; sap++)
+		if (sap->nprobe > 0)
+			sap->probe = (int *) emalloc(sap->nprobe *
+				sizeof (int));
+		else
+			sap->probe = NULL;
+	for (pp = probe; pp < endpp; pp++)
+		for (i = 0; i < 3; i++) {
+			sap = &atom[pp->atom[i]];
+			sap->probe[sap->nused++] = pp - probe;
+		}
+
+	/*
+	 * Cleanup and let caller know we've read things okay
+	 */
+	fputs(PRI_RESPONSE, stdout);
+#ifdef LOG
+	fputs(PRI_RESPONSE, stderr);
+#endif
+}
+
+/*
+ * contacts:
+ *	Compute the contacts for atom `n'
+ */
+static
+void
+contacts(int n)
+{
+	register int	i, nn;
+	register SATOM	*sp, *prevsp;
+	register SATOM	*sap, *me, *nlist;
+	register SATOM	*min, *max;
+	AINDEX		*narray;
+	double		distsq;
+
+	/*
+	 * Initialize local variables
+	 */
+	me = &atom[n];
+
+	/*
+	 * Locate set of atoms within `maxrad' of the given atom in
+	 * the X direction.  This gives us a set of atoms which is
+	 * guaranteed to include all neighbors but is still smaller
+	 * than the set of ALL atoms.  There are more efficient ways
+	 * to locate smaller sets but this one is easy.
+	 */
+	min = find_satom(me->atom.coord[0] - me->atom.radius
+		- 2 * radius - maxrad);
+	max = find_satom(me->atom.coord[0] + me->atom.radius
+		+ 2 * radius + maxrad) + 1;
+
+	/*
+	 * Loop through the set of atoms and locate neighbors
+	 */
+	nlist = NULL;
+	nn = 0;
+	for (sap = min; sap < max; sap++) {
+		if (sap == me || !touches(me, sap, &distsq))
+			continue;
+		nn++;
+#ifdef SORTED_NB
+		sap->dist = distsq;
+		prevsp = NULL;
+		for (sp = nlist; sp != NULL; sp = sp->next) {
+			if (sp->dist > distsq)
+				break;
+			prevsp = sp;
+		}
+		if (prevsp == NULL) {
+			sap->next = nlist;
+			nlist = sap;
+		}
+		else {
+			sap->next = prevsp->next;
+			prevsp->next = sap;
+		}
+#else
+		sap->next = nlist;
+		nlist = sap;
+#endif
+	}
+
+	/*
+	 * Report the neighbor list
+	 */
+	printf(C_RESPONSE, n, nn);
+#ifdef LOG
+	fprintf(stderr, C_RESPONSE, n, nn);
+#endif
+	if (nn > 0) {
+		narray = (AINDEX *) emalloc(nn * sizeof (AINDEX));
+		for (sap = nlist, i = 0; sap != NULL; sap = sap->next, i++)
+			narray[i] = sap - atom;
+		(void) fwrite((char *) narray, sizeof (AINDEX), nn, stdout);
+		(void) free((char *) narray);
+	}
+}
+
+/*
+ * find_satom:
+ *	When given an X coordinate, find the first atom whose
+ *	X coordinate is greater than or equal to the given one.
+ *	Note that the atoms are sorted by X already so we can
+ *	use a binary search.
+ */
+static
+SATOM *
+find_satom(double x)
+{
+	register int	hi, lo, mid;
+
+	hi = natom;
+	lo = 0;
+	mid = (hi + lo) / 2;
+	while (mid > lo) {
+		if (atom[mid].atom.coord[0] < x)
+			lo = mid;
+		else
+			hi = mid;
+		mid = (hi + lo) / 2;
+	}
+	return &atom[mid];
+}
+
+/*
+ * touches:
+ *	When given two atoms, determine whether they are neighbors
+ *	(i.e. a probe will NOT fit between them).
+ */
+static
+int
+touches(SATOM *s1, SATOM *s2, double *dp)
+{
+	register int	i;
+	double		distsq, delta;
+	double		maxdistsq;
+
+	/*
+	 * Compute the maximum distance between these two atoms and
+	 * still remain neighbors
+	 */
+	delta = s1->atom.radius + s2->atom.radius + 2 * radius;
+	maxdistsq = delta * delta;
+
+	/*
+	 * We determine the square of the distance between the two
+	 * atoms and compare against `maxdistsq'.  Note that we
+	 * compute the distance in the order Z, Y, X since we know
+	 * that X is probably okay and Z and Y will give quicker
+	 * failure if there is one.
+	 */
+	distsq = 0;
+	for (i = 2; i >= 0; i--) {
+		delta = s1->atom.coord[i] - s2->atom.coord[i];
+		distsq += delta * delta;
+		if (distsq >= maxdistsq)
+			return FALSE;
+	}
+	*dp = distsq;
+	return TRUE;
+}
+
+/*
+ * s_probes:
+ *	Compute the probes that are adjacent to both given atoms
+ */
+static
+void
+s_probes(int n, int m)
+{
+	register int	i, j, k;
+	register SATOM	*s0, *s1, *s2;
+	register PROBE	*plist, *pp;
+	register int	np;
+	double		ppos[2][3];
+	int		wanted;
+
+	/*
+	 * Initialize local variables
+	 */
+	s0 = &atom[n];
+	s1 = &atom[m];
+	wanted = s0->atom.wanted || s1->atom.wanted;
+
+	/*
+	 * Locate probes that may be in contact with the given
+	 * atoms.  We need not report any probe that involves any
+	 * atom whose index is less than `m' because it will already
+	 * have been computed
+	 */
+	plist = NULL;
+	np = 0;
+	for (i = 0; i < s0->nnb; i++)
+		for (j = 0; j < s1->nnb; j++) {
+			if (s0->nb[i] != s1->nb[j])
+				continue;
+			s2 = &atom[s0->nb[i]];
+			if (!wanted && !s2->atom.wanted)
+				continue;
+			k = probe_position(s0, s1, s2, ppos, s0->nb[i] <= m);
+			if (k < 0) {
+				/*
+				 * s2 is between s0 and s1.  Just report that
+				 * n and m cannot be neighbors and quit
+				 */
+				printf(P_BADNB, n, m);
+#ifdef LOG
+				fprintf(stderr, P_BADNB, n, m);
+#endif
+				goto bad;
+			}
+			if (k == 0)
+				break;
+			for (k = 0; k < 2; k++) {
+#ifdef KEEP_REAL
+				if (hidden(s0, s1, s2, ppos[k]))
+					continue;
+#endif
+				np++;
+				pp = (PROBE *) emalloc(sizeof (PROBE));
+				pp->next = plist;
+				plist = pp;
+				pp->coord[0] = ppos[k][0];
+				pp->coord[1] = ppos[k][1];
+				pp->coord[2] = ppos[k][2];
+				pp->atom[0] = n;
+				pp->atom[1] = m;
+				pp->atom[2] = s0->nb[i];
+#ifdef KEEP_REAL
+				pp->real = TRUE;
+#else
+				pp->real = !hidden(s0, s1, s2, ppos[k]);
+#endif
+			}
+			break;
+		}
+
+	/*
+	 * Report data back to user
+	 */
+	printf(P_RESPONSE, np);
+#ifdef LOG
+	fprintf(stderr, P_RESPONSE, np);
+#endif
+
+	/*
+	 * Send the data, clean up and go home
+	 */
+	for (pp = plist; pp != NULL; pp = plist) {
+		(void) fwrite((char *) pp, sizeof (PROBE), 1, stdout);
+		plist = pp->next;
+		free((char *) pp);
+	}
+	return;
+
+bad:
+	/*
+	 * We get here when we "know" that there can be no probes
+	 * sitting against bot given atoms.  Just report a zero
+	 * and release data structures.
+	 */
+	printf(P_RESPONSE, 0);
+#ifdef LOG
+	fprintf(stderr, P_RESPONSE, 0);
+#endif
+	for (pp = plist; pp != NULL; pp = plist) {
+		plist = pp->next;
+		free((char *) pp);
+	}
+}
+
+/*
+ * probe_position:
+ *	When given three atoms, find the two possible probe positions.
+ *	First we transform the coordinates such that a0 is at the origin,
+ *	a1 is on the z axis, and a2 is in the y-z plane.  This arrangement
+ *	constrains the two probe positions of have the same y and z coordinates
+ *	and complementary x coordinates.
+ *	The three equations constraining distances are:
+ *		sq(x) + sq(y) + sq(z) = sq(R0 + Rp)
+ *		sq(x) + sq(y) + sq(z - z1) = sq(R1 + Rp)
+ *		sq(x) + sq(y - y2) + sq(z - z2) = sq(R2 + Rp)
+ *	from which we can solve for z, then y in terms of z, then x in
+ *	terms of y and z.
+ *
+ *	probe_position returns one of three values:
+ *		 1 - where both probe positions have been found
+ *		 0 - where no probe position is found but a0 and a1
+ *		     can still be neighbors
+ *		-1 - where a0 and a1 cannot be neighbors because a2 is
+ *		     in the way
+ */
+static
+int
+probe_position(SATOM *a0, SATOM *a1, SATOM *a2, double ppos[2][3], int check_only)
+{
+	register int	i, j;
+	double		mat[4][4], invmat[4][4];
+	double		r0, r1, r2, dz1, dz2;
+	double		z1, y2, z2, t;
+	double		dy, dz;
+	double		c[3];
+
+	/*
+	 * Convert to simple coordinate system
+	 */
+	viewat(mat, invmat, a0->atom.coord, a1->atom.coord, a2->atom.coord);
+	z1 = a1->atom.coord[0] * mat[0][2] + a1->atom.coord[1] * mat[1][2] +
+		a1->atom.coord[2] * mat[2][2] + mat[3][2];
+	y2 = a2->atom.coord[0] * mat[0][1] + a2->atom.coord[1] * mat[1][1] +
+		a2->atom.coord[2] * mat[2][1] + mat[3][1];
+	z2 = a2->atom.coord[0] * mat[0][2] + a2->atom.coord[1] * mat[1][2] +
+		a2->atom.coord[2] * mat[2][2] + mat[3][2];
+
+	/*
+	 * Solve in simple coordinate system.
+	 */
+	r0 = a0->atom.radius + radius;
+	r1 = a1->atom.radius + radius;
+	c[2] = (r0 * r0 - r1 * r1 + z1 * z1) / (2 * z1);
+	r2 = a2->atom.radius + radius;
+	dz1 = c[2] - z1;
+	dz2 = c[2] - z2;
+	c[1] = (r1 * r1 - r2 * r2 - dz1 * dz1 + dz2 * dz2 + y2 * y2) / (2 * y2);
+	t = r0 * r0 - c[1] * c[1] - c[2] * c[2];
+
+	/*
+	 * Now check whether the probe position is in "real" space.  If
+	 * not determine which atom is in between the others.
+	 */
+	if (t <= 0) {
+		c[1] = -sqrt(r0 * r0 - c[2] * c[2]);
+		dy = y2 - c[1];
+		dz = z2 - c[2];
+		if (dy * dy + dz * dz <= r2 * r2)
+			return -1;
+		return 0;
+	}
+
+	/*
+	 * Probe positions are valid, convert back to original
+	 * coordinate system and return
+	 */
+	if (check_only)
+		return 0;
+	c[0] = sqrt(t);
+	for (i = 0; i < 3; i++) {
+		ppos[0][i] = invmat[3][i];
+		for (j = 0; j < 3; j++)
+			ppos[0][i] += c[j] * invmat[j][i];
+	}
+	c[0] = -c[0];
+	for (i = 0; i < 3; i++) {
+		ppos[1][i] = invmat[3][i];
+		for (j = 0; j < 3; j++)
+			ppos[1][i] += c[j] * invmat[j][i];
+	}
+	return 1;
+}
+
+/*
+ * hidden:
+ *	Determine whether the given coordinates is occluded by
+ *	any of the neighbors of the given atoms
+ */
+static
+int
+hidden(SATOM *s0, SATOM *s1, SATOM *s2, double coord[3])
+{
+	register int	i;
+
+	/*
+	 * First we unmark all the atoms that need work.
+	 * Then we mark the three that, by definition, cannot occlude
+	 * the probe position.
+	 */
+	for (i = 0; i < s0->nnb; i++)
+		atom[s0->nb[i]].nused = 0;
+	for (i = 0; i < s1->nnb; i++)
+		atom[s1->nb[i]].nused = 0;
+	for (i = 0; i < s2->nnb; i++)
+		atom[s2->nb[i]].nused = 0;
+	s0->nused = s1->nused = s2->nused = 1;
+
+	/*
+	 * Now we loop through all the atoms and check
+	 */
+	for (i = 0; i < s0->nnb; i++)
+		if (atom[s0->nb[i]].nused++ == 0)
+			if (occlude(&atom[s0->nb[i]], coord))
+				return TRUE;
+	for (i = 0; i < s1->nnb; i++)
+		if (atom[s1->nb[i]].nused++ == 0)
+			if (occlude(&atom[s1->nb[i]], coord))
+				return TRUE;
+	for (i = 0; i < s2->nnb; i++)
+		if (atom[s2->nb[i]].nused++ == 0)
+			if (occlude(&atom[s2->nb[i]], coord))
+				return TRUE;
+
+	/*
+	 * Nobody blocked it.  I guess it's okay
+	 */
+	return FALSE;
+}
+
+/*
+ * occlude:
+ *	Determine whether the given atom precludes placing a sphere
+ *	at the given position
+ */
+static
+int
+occlude(SATOM *sap, double pos[3])
+{
+	register int	i;
+	double		delta, distsq;
+#ifndef ONE_OCCLUDE
+	double		minds;
+#endif
+#define	EPSILON	1e-12
+
+#ifndef ONE_OCCLUDE
+	delta = sap->atom.radius + radius;
+	minds = delta * delta;
+#endif
+	distsq = EPSILON;
+	for (i = 0; i < 3; i++) {
+		delta = sap->atom.coord[i] - pos[i];
+		distsq += delta * delta;
+#ifndef ONE_OCCLUDE
+		if (distsq > minds)
+			return FALSE;
+#endif
+	}
+#ifdef ONE_OCCLUDE
+	delta = sap->atom.radius + radius;
+	if (distsq > delta * delta)
+		return FALSE;
+#endif
+	return TRUE;
+}
+
+/*
+ * csurface:
+ *	Compute the contact surface of the given atom
+ */
+static
+void
+csurface(int n)
+{
+	register POINT	*pp, *endpp;
+	register SATOM	*sap, *me;
+	register int	i, j;
+	register SNB	*nlist, *snp, *endsnp;
+	register SPHERE	*sp;
+	register POINT	*savepp, *savenp;
+	double		delta, distsq, len, t;
+	double		r1p, r1psq, r2psq, r1sq;
+	double		coord[3];
+
+	/*
+	 * Initialize local variables
+	 */
+	me = &atom[n];
+	if (me->nnb > 0) {
+		nlist = (SNB *) emalloc(me->nnb * sizeof (SNB));
+		endsnp = nlist + me->nnb;
+	}
+	else
+		nlist = NULL;
+
+	/*
+	 * Compute clipping distance for each neighbor
+	 */
+	r1p = me->atom.radius + radius;
+	r1psq = r1p * r1p;
+	r1sq = me->atom.radius * me->atom.radius;
+	for (i = 0; i < me->nnb; i++) {
+		sap = &atom[me->nb[i]];
+		snp = &nlist[i];
+		snp->coord = sap->atom.coord;
+		distsq = 0;
+		for (j = 0; j < 3; j++) {
+			delta = me->atom.coord[j] - sap->atom.coord[j];
+			distsq += delta * delta;
+		}
+		snp->dist = sqrt(distsq);
+		delta = sap->atom.radius + radius;
+		r2psq = delta * delta;
+		len = (r1psq - r2psq + distsq) / (2 * snp->dist);
+		t = len * me->atom.radius / r1p;
+		snp->clip = r1sq + distsq - 2 * snp->dist * t;
+	}
+
+	/*
+	 * Now get a sphere and find all points which are not clipped
+	 * by any of the neighbors.
+	 */
+	sp = get_sphere(me->atom.radius);
+	endpp = sp->point + sp->npoint;
+	if (sp->npoint > maxsurf) {
+		if (surface != NULL) {
+			(void) free((char *) surface);
+			if (want_normal)
+				(void) free((char *) normal);
+		}
+		maxsurf = sp->npoint;
+		surface = (POINT *) emalloc(maxsurf * sizeof (POINT));
+		if (want_normal)
+			normal = (POINT *) emalloc(maxsurf * sizeof (POINT));
+	}
+	savepp = surface;
+	savenp = normal;
+	for (pp = sp->point; pp < endpp; pp++) {
+		for (i = 0; i < 3; i++)
+			coord[i] = me->atom.coord[i] + pp->coord[i];
+		if (nlist != NULL && clipped(coord, nlist, endsnp))
+			continue;
+		for (i = 0; i < 3; i++)
+			savepp->coord[i] = coord[i];
+		savepp++;
+		if (want_normal) {
+			for (i = 0; i < 3; i++)
+				savenp->coord[i] = pp->coord[i] / sp->radius;
+			savenp++;
+		}
+	}
+
+	/*
+	 * Now that we have the points, just send them back to caller
+	 * and release the neighbor list
+	 */
+	i = savepp - surface;
+	printf(SURFACE_RESPONSE, n, i, CONTACT, sp->area, want_normal);
+#ifdef LOG
+	fprintf(stderr, SURFACE_RESPONSE, n, i, CONTACT, sp->area, want_normal);
+#endif
+	if (i > 0) {
+		(void) fwrite((char *) surface, sizeof (POINT), i, stdout);
+		if (want_normal) {
+			(void) fwrite((char *) normal, sizeof (POINT), i,
+				stdout);
+		}
+	}
+	fputs(SURFACE_END, stdout);
+#ifdef LOG
+	fputs(SURFACE_END, stderr);
+#endif
+
+	if (nlist != NULL)
+		(void) free((char *) nlist);
+}
+
+/*
+ * get_sphere:
+ *	Return a prototype sphere of the given radius
+ */
+static
+SPHERE *
+get_sphere(double r)
+{
+	register SPHERE	*sp;
+	register int	i, j;
+	register POINT	*pp;
+	register int	nlayer, npoint;
+	double		dphi, dtheta;
+	double		phi, theta, z, rsinphi;
+
+	/*
+	 * Look for one already on the list
+	 */
+	for (sp = sphere; sp != NULL; sp = sp->next)
+		if (sp->radius == r)
+			return sp;
+
+	/*
+	 * Okay, it doesn't exist yet.  Let's make one.
+	 */
+	sp = (SPHERE *) emalloc(sizeof (SPHERE));
+	sp->next = sphere;
+	sphere = sp;
+	sp->radius = r;
+
+	/*
+	 * Easy part is done.  Now figure out how many points there
+	 * should be on the sphere.
+	 */
+	dphi = arclength / r;
+	nlayer = ROUND(PI / dphi) + 1;
+	dphi = PI / nlayer;
+	sp->npoint = 0;
+	phi = 0;
+	for (i = 0; i < nlayer; i++) {
+		dtheta = (phi == 0) ? PI * 2 : arclength / (r * sin(phi));
+		npoint = ROUND(PI * 2 / dtheta);
+		if (npoint <= 0)
+			npoint = 1;
+		sp->npoint += npoint;
+		phi += dphi;
+	}
+	sp->area = (4 * PI * r * r) / sp->npoint;
+
+	/*
+	 * Allocate space for the points and, possibly, angles
+	 */
+	sp->point = (POINT *) emalloc(sp->npoint * sizeof (POINT));
+
+	/*
+	 * Now we actually generate the points
+	 */
+	pp = sp->point;
+	phi = 0;
+	for (i = 0; i < nlayer; i++) {
+		rsinphi = r * sin(phi);
+		z = r * cos(phi);
+		dtheta = (rsinphi == 0) ? PI * 2 : arclength / rsinphi;
+		npoint = ROUND(PI * 2 / dtheta);
+		if (npoint <= 0)
+			npoint = 1;
+		dtheta = PI * 2 / npoint;
+		theta = (i % 2) ? 0 : PI;
+		for (j = 0; j < npoint; j++) {
+			pp->coord[0] = rsinphi * cos(theta);
+			pp->coord[1] = rsinphi * sin(theta);
+			pp->coord[2] = z;
+			pp++;
+			theta += dtheta;
+			if (theta > PI * 2)
+				theta -= PI * 2;
+		}
+		phi += dphi;
+	}
+
+	return sp;
+}
+
+/*
+ * clipped:
+ *	Determine if the given coordinate is clipped by any
+ *	of the given neighbors
+ */
+static
+int
+clipped(double coord[3], SNB *nlist, SNB *endsnp)
+{
+	register SNB	*snp;
+	register int	i;
+	double		delta, distsq;
+
+	for (snp = nlist; snp < endsnp; snp++) {
+		distsq = 0;
+		for (i = 0; i < 3; i++) {
+			delta = snp->coord[i] - coord[i];
+			distsq += delta * delta;
+		}
+		if (distsq < snp->clip)
+			return TRUE;
+	}
+	return FALSE;
+}
+
+/*
+ * tsurface:
+ *	Compute torus surface for neighbor pair
+ */
+static
+void
+tsurface(int n, int m)
+{
+	register int	i, j;
+	register SATOM	*s1, *s2;
+	register SANGLE	*ap, *anext;
+	register SANGLE	*alist;
+	double		tcenter[3], tradius, clip[2], coord[3];
+	double		mat[4][4], invmat[4][4];
+	int		na;
+
+	/*
+	 * Initialize local variables
+	 */
+	s1 = &atom[n];
+	s2 = &atom[m];
+	if (!torus_data(&s1->atom, &s2->atom, tcenter, &tradius, clip)) {
+		fputs(SURFACE_END, stdout);
+#ifdef LOG
+		fputs(SURFACE_END, stderr);
+#endif
+		return;
+	}
+	if (clip[0] > 0)
+		lookat(mat, invmat, tcenter, s1->atom.coord);
+	else {
+		/* Note that we get the coordinates from s2 since clip[0]
+		 * may be zero which would result in division by zero if
+		 * we use coordinates from s1 */
+		for (i = 0; i < 3; i++)
+			coord[i] = tcenter[i] +
+				(tcenter[i] - s2->atom.coord[i]);
+		lookat(mat, invmat, tcenter, coord);
+	}
+
+	alist = compute_angles(s1, s2, mat, &na);
+	if (alist == NULL) {
+#ifdef KEEP_REAL
+		na = 0;
+		for (i = 0; i < s1->nnb; i++)
+			for (j = 0; j < s2->nnb; j++) {
+				if (s1->nb[i] != s2->nb[j])
+					continue;
+				na++;
+				break;
+			}
+#endif
+		if (na == 0) {
+			tsection(invmat, tradius, clip, 0.0, PI * 2,
+				n, m, TRUE);
+		}
+	}
+	else
+		draw_tsections(invmat, tradius, clip, n, m, alist);
+
+	/*
+	 * Release the angle list and return to caller
+	 */
+	for (ap = alist; ap != NULL; ap = anext) {
+		anext = ap->next;
+		(void) free((char *) ap);
+	}
+	fputs(SURFACE_END, stdout);
+#ifdef LOG
+	fputs(SURFACE_END, stderr);
+#endif
+}
+
+/*
+ * compute_angles:
+ *	Loop through the probe list for each atom and find those
+ *	probes which are on both list.
+ */
+#ifdef KEEP_REAL
+/*ARGSUSED*/
+#endif
+static
+SANGLE *
+compute_angles(SATOM *s1, SATOM *s2, double mat[4][4], int *na)
+{
+	register int	i, j;
+	register PROBE	*pp;
+	register SANGLE	*alist, *ap;
+
+	alist = NULL;
+	j = s2 - atom;
+#ifndef KEEP_REAL
+	*na = 0;
+#endif
+	for (i = 0; i < s1->nprobe; i++) {
+		pp = &probe[s1->probe[i]];
+		if (pp->atom[0] != j && pp->atom[1] != j && pp->atom[2] != j)
+			continue;
+#ifndef KEEP_REAL
+		(*na)++;
+#endif
+		ap = probe_angle(s1->probe[i], mat, s1 - atom, j);
+		ap->real = pp->real;
+		alist = insert_angle(alist, ap);
+	}
+	return alist;
+}
+
+/*
+ * draw_tsections:
+ *	Loop through the angle list and draw torus sections
+ */
+static
+void
+draw_tsections(double invmat[4][4], double tradius, double clip[2], int n, int m, SANGLE *alist)
+{
+	register SANGLE	*ap, *anext;
+
+	for (ap = alist; ap != NULL; ap = ap->next) {
+		if (!ap->start || !ap->real)
+			continue;
+		anext = (ap->next == NULL) ? alist : ap->next;
+		tsection(invmat, tradius, clip, ap->angle,
+			anext->angle, n, m, TRUE);
+	}
+}
+
+/*
+ * torus_data:
+ *	Compute data regarding the torus (e.g. center, radius, etc.)
+ */
+static
+int
+torus_data(ATOM *a1, ATOM *a2, double tcenter[3], double *tradius, double clip[2])
+{
+	register int	i;
+	double		distsq, dist;
+	double		r1p, r2p;
+	double		r1psq, r2psq, len;
+	double		lsq;
+
+	/*
+	 * Compute distance between atoms
+	 */
+	distsq = 0;
+	for (i = 0; i < 3; i++) {
+		dist = a1->coord[i] - a2->coord[i];
+		distsq += dist * dist;
+	}
+	dist = sqrt(distsq);
+
+	/*
+	 * Compute torus center and radius
+	 */
+	r1p = a1->radius + radius;
+	r1psq = r1p * r1p;
+	r2p = a2->radius + radius;
+	r2psq = r2p * r2p;
+	len = (r1psq - r2psq + distsq) / (2 * dist);
+	lsq = r1psq - len * len;
+	if (lsq <= 0)
+		return 0;
+	*tradius = sqrt(lsq);
+	for (i = 0; i < 3; i++)
+		tcenter[i] = a1->coord[i] +
+			(a2->coord[i] - a1->coord[i]) * len / dist;
+
+	/*
+	 * Now compute the clipping distance for the torus
+	 */
+	clip[0] = len * (1.0 - a1->radius / r1p);
+	clip[1] = (dist - len) * (1.0 - a2->radius / r2p);
+	return 1;
+}
+
+/*
+ * probe_angle:
+ *	Determine the angle that the probe lies at
+ */
+static
+SANGLE *
+probe_angle(int pnum, double mat[4][4], int n, int m)
+{
+	register int	i, j;
+	register PROBE	*pp;
+	register SANGLE	*sp;
+	register ATOM	*ap;
+	double		angle;
+	double		coord[3];
+
+	/*
+	 * Allocate space for angle structure
+	 */
+	sp = (SANGLE *) emalloc(sizeof (SANGLE));
+	sp->next = NULL;
+	pp = &probe[pnum];
+
+	/*
+	 * Compute the polar coordinates of the probe
+	 */
+	for (i = 0; i < 3; i++) {
+		coord[i] = mat[3][i];
+		for (j = 0; j < 3; j++)
+			coord[i] += pp->coord[j] * mat[j][i];
+	}
+	sp->angle = atan2(coord[1], coord[0]);
+
+	/*
+	 * Compute the polar coordinates of the atom which
+	 * is adjacent to both given atoms
+	 */
+	for (i = 0; i < 3; i++)
+		if (pp->atom[i] != n && pp->atom[i] != m)
+			break;
+	ap = &atom[pp->atom[i]].atom;
+	for (i = 0; i < 3; i++) {
+		coord[i] = mat[3][i];
+		for (j = 0; j < 3; j++)
+			coord[i] += ap->coord[j] * mat[j][i];
+	}
+	angle = atan2(coord[1], coord[0]);
+
+	/*
+	 * Now determine whether the torus section should start or
+	 * end here
+	 */
+	angle = angle - sp->angle;
+	while (angle < 0)
+		angle += PI * 2;
+	sp->start = (angle >= PI);
+	if (sp->angle < 0)
+		sp->angle += PI * 2;
+
+	return sp;
+}
+
+/*
+ * insert_angle:
+ *	Insert an angle into a list and return the head of the list.
+ *	If there are two identical angles, we put the start before the end
+ *	to eliminate the surface since this mostly occurs near rings.
+ */
+static
+SANGLE *
+insert_angle(SANGLE *head, SANGLE *new)
+{
+	register SANGLE	*ap;
+
+	/*
+	 * See if the new angle should be at the beginning
+	 */
+	if (head == NULL || new->angle < head->angle
+	|| (new->angle == head->angle && !head->start)) {
+		new->next = head;
+		return new;
+	}
+
+	/*
+	 * Find the angle whose successor is greater than the new angle.
+	 * Add the angle after this one and return the original head
+	 * of the list.
+	 */
+	for (ap = head; ap->next != NULL; ap = ap->next) {
+		if (ap->next->angle > new->angle
+		|| (ap->next->angle == new->angle && !ap->next->start))
+			break;
+	}
+	new->next = ap->next;
+	ap->next = new;
+	return head;
+}
+
+/*
+ * tsection:
+ *	Generate a section of a torus
+ *
+ *	The area of described by an arc swept through an angle is:
+ *		A = (integral) (integral) (r de) ds
+ *	where
+ *		 r = Rt - Rs cos a
+ *		ds = Rs da
+ *	so
+ *		A = (i) (i) (Rt - Rs cos a) Rs da de
+ *		  = e a Rt Rs - e Rs Rs (integral) cos a da
+ *		  = e Rt a Rs - e Rs Rs sin a
+ *	Symbols are:
+ *		Rs = radius of arc
+ *		Rt = arc displacement from origin
+ *		 a = angle of arc
+ *		 e = angle swept through
+ */
+static
+void
+tsection(double invmat[4][4], double tradius, double clip[2], double start, double end, int n, int m, int check)
+{
+	register int	i, j;
+	register int	npoint;
+	register POINT	*pp, *np;
+	register int	na, ne;
+	POINT		*plist, *nlist;
+	double		area;
+	double		mina, maxa;
+	double		aincr, eincr;
+	double		arange, erange;
+	double		e, a, mida;
+	double		nclip[2];
+	int		eoffset;
+	int		startm;
+	double		coord[3], xy;
+	double		cose, sine;
+	double		normal[3];
+
+	/*
+	 * First see whether the torus is really a torus.
+	 * If the probe extends below the center line between
+	 * the two atoms, only the portion which is above the center
+	 * line should be used for sweeping out the torus.
+	 */
+	if (check && tradius < radius) {
+		xy = sqrt(radius * radius - tradius * tradius);
+		clip[1] = -clip[1];
+		if (clip[1] < -xy && -xy < clip[0]) {
+			nclip[0] = -xy;
+			nclip[1] = -clip[1];
+			tsection(invmat, tradius, nclip, start, end,
+				n, m, FALSE);
+		}
+		if (clip[1] < xy && xy < clip[0]) {
+			nclip[0] = clip[0];
+			nclip[1] = -xy;
+			tsection(invmat, tradius, nclip, start, end,
+				n, m, FALSE);
+		}
+		return;
+	}
+
+	/*
+	 * Figure out basic parameters
+	 */
+	maxa = -acos(clip[0] / radius);
+	mina = -acos(-clip[1] / radius);
+	arange = maxa - mina;
+	if (end < start)
+		end += PI * 2;
+	erange = end - start;
+	area = erange * tradius * arange * radius -
+		erange * radius * radius *
+		(sin(maxa + PI / 2) + sin(-PI / 2  - mina));
+
+	/*
+	 * Now figure out the maximum number of points there might be
+	 * and allocate space for them
+	 */
+	ne = ROUND(erange * tradius / arclength);
+	if (ne <= 0)
+		return;
+	na = ROUND(arange * radius / (arclength * root3 / 2));
+	if (na <= 0)
+		return;
+	npoint = na * ne;
+	plist = (POINT *) emalloc(npoint * sizeof (POINT));
+	if (want_normal)
+		nlist = (POINT *) emalloc(npoint * sizeof (POINT));
+	else
+		nlist = NULL;
+
+	/*
+	 * Now loop through a and e and generate the points
+	 */
+	pp = plist;
+	np = nlist;
+	eoffset = 0;
+	mida = (mina + maxa) / 2;
+	aincr = arange / na;
+	a = mina + aincr / 2;
+	startm = 0;
+	while (na-- > 0) {
+		/*
+		 * Compute things that only depend on a
+		 */
+		coord[2] = radius * cos(a);
+		if (want_normal)
+			normal[2] = -coord[2] / radius;
+		xy = radius * sin(a) + tradius;
+
+		/*
+		 * Loop through e and generate points
+		 */
+		ne = ROUND(erange * xy / arclength);
+		if (ne > 0) {
+			eincr = erange / ne;
+			e = start + eincr / 2 * (eoffset + 1);
+			eoffset = 1 - eoffset;
+		}
+		while (ne-- > 0) {
+#ifdef DEBUG
+			if (pp >= plist + npoint) {
+				fprintf(stderr, "Point buffer overflow\n");
+				abort();
+			}
+#endif
+			cose = cos(e);
+			sine = sin(e);
+			coord[0] = xy * cose;
+			coord[1] = xy * sine;
+			for (i = 0; i < 3; i++) {
+				pp->coord[i] = invmat[3][i];
+				for (j = 0; j < 3; j++)
+					pp->coord[i] += coord[j] * invmat[j][i];
+			}
+			pp++;
+			e += eincr;
+			if (!want_normal)
+				continue;
+			normal[0] = (tradius * cose - coord[0]) / radius;
+			normal[1] = (tradius * sine - coord[1]) / radius;
+			for (i = 0; i < 3; i++) {
+				np->coord[i] = 0;	/* Just rotation */
+				for (j = 0; j < 3; j++)
+					np->coord[i] += normal[j] *
+						invmat[j][i];
+			}
+			np++;
+		}
+
+		/*
+		 * Increment a.  If we pass the -PI/2 threshold, we will
+		 * start generating points on atom m.
+		 */
+		a += aincr;
+		if (a > mida && startm == 0)
+			startm = pp - plist;
+	}
+
+	/*
+	 * Send point data back to the caller and clean up
+	 */
+	npoint = pp - plist;
+	if (npoint > 0) {
+		area = area / npoint;
+		send_points(plist, startm, m, area, TREENTRANT, nlist);
+		send_points(plist + startm, npoint - startm, n,
+			area, TREENTRANT, nlist + startm);
+	}
+	(void) free((char *) plist);
+	if (nlist != NULL)
+		(void) free((char *) nlist);
+}
+
+/*
+ * send_points:
+ *	Send points back to caller
+ */
+static
+void
+send_points(POINT *plist, int np, AINDEX aindex, double area, int type, POINT *nlist)
+{
+	if (np <= 0)
+		return;
+	printf(SURFACE_RESPONSE, aindex, np, type, area, want_normal);
+#ifdef LOG
+	fprintf(stderr, SURFACE_RESPONSE, aindex, np, type, area,
+		want_normal);
+#endif
+	(void) fwrite((char *) plist, sizeof (POINT), np, stdout);
+	if (want_normal)
+		(void) fwrite((char *) nlist, sizeof (POINT), np, stdout);
+}
+
+/*
+ * psurface:
+ *	Generate surface associated with a probe
+ */
+static
+void
+psurface(int n)
+{
+	register int	i, j, k;
+	register POINT	*pp;
+	register PROBE	*prp;
+	register SATOM	*sap;
+	register SPHERE	*sp;
+	int		which;
+	double		minr, r, delta;
+	POINT		*point, *plist[3], *normal, *nlist[3];
+	short		*keep, np[3];
+
+	/*
+	 * Initialize local variables and allocate space
+	 */
+	prp = &probe[n];
+	sp = get_sphere(radius);
+	for (i = 0; i < 3; i++) {
+		np[i] = 0;
+		plist[i] = (POINT *) emalloc(sp->npoint * sizeof (POINT));
+	}
+	point = (POINT *) emalloc(sp->npoint * sizeof (POINT));
+	keep = (short *) emalloc(sp->npoint * sizeof (short));
+	for (i = 0; i < sp->npoint; i++) {
+		keep[i] = TRUE;
+		pp = &point[i];
+		for (j = 0; j < 3; j++)
+			pp->coord[j] = sp->point[i].coord[j] + prp->coord[j];
+	}
+	if (want_normal) {
+		normal = (POINT *) emalloc(sp->npoint * sizeof (POINT));
+		for (i = 0; i < sp->npoint; i++) {
+			pp = &normal[i];
+			for (j = 0; j < 3; j++)
+				pp->coord[j] = -sp->point[i].coord[j] / radius;
+		}
+		for (i = 0; i < 3; i++)
+			nlist[i] = (POINT *) emalloc(sp->npoint *
+				sizeof (POINT));
+	}
+	else {
+		normal = NULL;
+		nlist[0] = nlist[1] = nlist[2] = NULL;
+	}
+
+	/*
+	 * Now we eliminate those points which do not fall within the
+	 * spherical triangle formed by the three specified atoms.
+	 * The way we do this is by defining a plane for each pair of
+	 * atoms and the probe center.  The plane divides space into two
+	 * half-spaces, one of which contains the third atom not used in
+	 * defining the plane.  If a point does not fall in the same
+	 * half-space as the third atom, then it is eliminated.  Only
+	 * the wanted points will remain after all three planes have been
+	 * used.
+	 */
+	for (i = 0; i < 3; i++)
+		for (j = i + 1; j < 3; j++)
+			check_point(prp, i, j, 3 - i - j,
+				sp->npoint, point, keep);
+
+	/*
+	 * Now we divide the points up among the three atoms.
+	 */
+	for (i = 0; i < sp->npoint; i++) {
+		if (!keep[i])
+			continue;
+		pp = &point[i];
+		which = -1;
+#ifdef lint
+		minr = 0;
+#endif
+		for (j = 0; j < 3; j++) {
+			sap = &atom[prp->atom[j]];
+			r = 0;
+			for (k = 0; k < 3; k++) {
+				delta = pp->coord[k] - sap->atom.coord[k];
+				r += delta * delta;
+			}
+			if (which == -1 || r < minr) {
+				minr = r;
+				which = j;
+			}
+		}
+		if (want_normal)
+			nlist[which][np[which]] = normal[i];
+		plist[which][np[which]++] = *pp;
+	}
+
+	/*
+	 * Send the points back to caller and clean up
+	 */
+	for (i = 0; i < 3; i++) {
+		send_points(plist[i], np[i], prp->atom[i], sp->area,
+			SREENTRANT, nlist[i]);
+		(void) free((char *) plist[i]);
+		if (want_normal)
+			(void) free((char *) nlist[i]);
+	}
+	fputs(SURFACE_END, stdout);
+#ifdef LOG
+	fputs(SURFACE_END, stderr);
+#endif
+	(void) free((char *) point);
+	(void) free((char *) keep);
+	if (want_normal)
+		(void) free((char *) normal);
+}
+
+/*
+ * check_point:
+ *	Determine which of the given points should be kept
+ */
+static
+void
+check_point(PROBE *prp, int at, int up, int side, int npoint, POINT point[], short keep[])
+{
+	register int	i, sign;
+	double		mat[4][4], invmat[4][4];
+	double		x;
+	double		*dp;
+	double		*fp;
+
+	/*
+	 * Construct a matrix which transforms the probe center to
+	 * the origin, the at atom to the z-axis, and the up atom
+	 * into the y-z plane.  Then transform the side atom to determine
+	 * the sign of the x-component of the half-space to keep.
+	 */
+	viewat(mat, invmat, prp->coord, atom[prp->atom[at]].atom.coord,
+		atom[prp->atom[up]].atom.coord);
+	dp = atom[prp->atom[side]].atom.coord;
+	x = dp[0] * mat[0][0] + dp[1] * mat[1][0] + dp[2] * mat[2][0]
+		+ mat[3][0];
+	sign = (x < 0) ? -1 : 1;
+
+	/*
+	 * Now we loop through the points and check each one
+	 */
+	for (i = 0; i < npoint; i++) {
+		if (!keep[i])
+			continue;
+		fp = point[i].coord;
+		x = fp[0] * mat[0][0] + fp[1] * mat[1][0] + fp[2] * mat[2][0]
+			+ mat[3][0];
+		if ((sign < 0 && x > 0) || (sign > 0 && x < 0))
+			keep[i] = FALSE;
+	}
+}

dms/dmsd/test.pdb

@@ -0,0 +1,14 @@
+USER  PDBRUN  6
+USER  EYEPOS    25.740    21.520   200.737
+USER  ATPOS     25.740    21.520    10.132
+USER  WINDOW   -29.271    29.271   -39.849    39.849   162.687   221.229
+USER  FOCUS    190.606
+USER  VIEWPORT     0.000   523.000     0.000   712.000
+USER  BGCOLOR 0.000 0.000 0.000
+USER  FILE    0 1gcn
+USER  COLOR 1.000 1.000 1.000 0
+USER  RADIUS   1.400
+ATOM      2  OX1 CYX     1       2.114  20.456  22.080  1.00 16.00
+USER  RADIUS   1.800
+ATOM      1  CX2 CYX     1       1.819  20.541  22.411  1.00 25.00
+END

dms/dmsd/viewat.c

@@ -0,0 +1,96 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include <math.h>
+
+static void	nmcrosprod();
+
+void viewat(M, invM, P1, P2, P3)
+double	M[4][4], invM[4][4];
+double	P1[3], P2[3], P3[3];
+{
+	double	d12;
+	double	P12X, P12Y, P12Z, P13X, P13Y, P13Z;
+	double	lm[3][3];
+	register int	i, j;
+
+	P12X = P2[0] - P1[0];
+	P12Y = P2[1] - P1[1];
+	P12Z = P2[2] - P1[2];
+	P13X = P3[0] - P1[0];
+	P13Y = P3[1] - P1[1];
+	P13Z = P3[2] - P1[2];
+
+	d12 = sqrt((P12X)*(P12X) + (P12Y)*(P12Y) + (P12Z)*(P12Z));
+	lm[0][2] = (P12X) / d12;
+	lm[1][2] = (P12Y) / d12;
+	lm[2][2] = (P12Z) / d12;
+	nmcrosprod(P13X, P13Y, P13Z, P12X, P12Y, P12Z,
+		&lm[0][0], &lm[1][0], &lm[2][0]);
+	nmcrosprod(lm[0][2], lm[1][2], lm[2][2],
+		lm[0][0], lm[1][0], lm[2][0], 
+		&lm[0][1], &lm[1][1], &lm[2][1]);
+
+	for (i = 0; i < 3; i++) {
+		invM[3][i] = P1[i];
+		M[i][3] = invM[i][3] = 0;
+		for (j = 0; j < 3; j++) {
+			M[i][j] = lm[i][j];
+			invM[j][i] = M[i][j];
+		}
+	}
+	M[3][0] = -P1[0]*M[0][0] - P1[1]*M[1][0] - P1[2]*M[2][0];
+	M[3][1] = -P1[0]*M[0][1] - P1[1]*M[1][1] - P1[2]*M[2][1];
+	M[3][2] = -P1[0]*M[0][2] - P1[1]*M[1][2] - P1[2]*M[2][2];
+	M[3][3] = invM[3][3] = 1;
+}
+
+static
+void
+nmcrosprod(x1, y1, z1, x2, y2, z2, x3, y3, z3)
+double	x1, y1, z1, x2, y2, z2;			/* r1 cross r2 */
+double	*x3, *y3, *z3;				/* Normalized crossproduct */
+{
+	double	dis;	/* length of crossproduct vector r1 x r2 */
+	double	x,y,z;
+
+	x = y1*z2 - y2*z1;
+	y = z1*x2 - z2*x1;
+	z = x1*y2 - x2*y1;
+
+	dis = sqrt((x*x) + (y*y) + (z*z));
+
+	*x3 = x / dis;
+	*y3 = y / dis;
+	*z3 = z / dis;
+}

dms/emalloc.c

@@ -0,0 +1,86 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+/*
+ * emalloc:
+ *	Same as malloc but exits when failure occurs
+ */
+char *
+emalloc(size)
+unsigned	size;
+{
+	register char	*cp;
+
+	if ((cp = malloc(size)) == NULL) {
+		fprintf(stderr, "emalloc(%u) failed\n", size);
+		exit(1);
+	}
+	return cp;
+}
+
+/*
+ * erealloc:
+ *	Same as realloc but exits when failure occurs
+ */
+char *
+erealloc(ptr, size)
+char		*ptr;
+unsigned	size;
+{
+	register char	*cp;
+
+	if ((cp = realloc(ptr, size)) == NULL) {
+		fprintf(stderr, "erealloc(ptr, %u) failed\n", size);
+		exit(1);
+	}
+	return cp;
+}
+
+/*
+ * ecalloc:
+ *	Same as calloc but exits when failure occurs
+ */
+char *
+ecalloc(nelem, elsize)
+unsigned nelem, elsize;
+{
+	register char	*cp;
+
+	if ((cp = calloc(nelem, elsize)) == NULL) {
+		fprintf(stderr, "calloc(%u, %u) failed\n", nelem, elsize);
+		exit(1);
+	}
+	return cp;
+}

dms/fwritev.c

@@ -0,0 +1,52 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+
+/*
+ * fwritev:
+ *	Like writev system call except we use stdio library
+ */
+void fwritev(fp, iov, n)
+FILE		*fp;
+struct iovec	*iov;
+int		n;
+{
+	register struct iovec	*ip, *endip;
+
+	endip = iov + n;
+	for (ip = iov; ip < endip; ip++)
+		(void) fwrite((char *) ip->iov_base, sizeof (char),
+			ip->iov_len, fp);
+}

dms/input.c

@@ -0,0 +1,324 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include <ctype.h>
+#include <math.h>
+#include <strings.h>
+#include <pdb.h>
+#include "dms_param.h"
+#include "atoms.h"
+#include "wanted.h"
+
+#ifndef	DEBUG
+#define	STATIC	static
+#else
+#define	STATIC
+#endif
+
+#ifndef	TRUE
+#define	TRUE	1
+#define	FALSE	0
+#endif
+
+STATIC int	is_aa();
+void scopy(char*, char*, int);
+char		(*resseqs)[RN_LEN];
+int		numresseq;
+
+/*
+ * read_pdb:
+ *	Read the given pdb file and put all the atoms into a list.
+ */
+ATOM *
+read_pdb(file, all)
+char	*file;
+int	all;
+{
+	register ATOM		*cp;
+	FILE			*fp;
+	ATOM			*alist, *ap;
+	pdb_record		r;
+	struct pdb_atom		*atp;
+	pdb_residue		*resp;
+	extern char		*emalloc();
+	char			prevresseq[RN_LEN];
+	int			index;
+
+	if ((fp = fopen(file, "r")) == NULL) {
+		perror(file);
+		return NULL;
+	}
+	alist = NULL;
+	prevresseq[0] = '\0';
+	numresseq = 0;
+	do {
+		r = pdb_read_record(fp);
+		switch(r.record_type) {
+		  case PDB_END:
+		  case PDB_UNKNOWN:
+		  case PDB_TER:
+			break;
+		  case PDB_HETATM:
+			if (!all)
+				break;
+			/* FALLTHROUGH */
+		  case PDB_ATOM:
+			atp = &r.pdb.atom;
+			resp = &atp->residue;
+			if (!all && !is_aa(resp->name))
+				break;
+			cp = (ATOM *) emalloc(sizeof (ATOM));
+			cp->coord[0] = r.pdb.atom.x;
+			cp->coord[1] = r.pdb.atom.y;
+			cp->coord[2] = r.pdb.atom.z;
+			scopy(cp->atname, atp->name, sizeof (atp->name));
+			scopy(cp->restype, resp->name, sizeof (resp->name));
+			/*
+			 * The residue sequence is composed of the
+			 * sequence number concatenated with the insertion
+			 * code and chain identifier (if they exist)
+			 */
+			(void) sprintf(cp->resseq, "%d", resp->seq_num);
+			if (isalnum(resp->insert_code))
+				(void) strncat(cp->resseq,
+					&resp->insert_code, 1);
+			if (isalnum(resp->chain_id))
+				(void) strncat(cp->resseq,
+					&resp->chain_id, 1);
+			if (r.record_type == PDB_HETATM)
+				(void) strncat(cp->resseq, "*", 1);
+			if (strcmp(cp->resseq, prevresseq) != 0) {
+				strcpy(prevresseq, cp->resseq);
+				numresseq++;
+			}
+			cp->resindex = numresseq-1;
+			cp->next = NULL;
+			if (alist == NULL)
+				alist = cp;
+			else
+				ap->next = cp;
+			ap = cp;
+			break;
+		  default:
+			break;
+		}
+	} while (r.record_type != PDB_END);
+	(void) fclose(fp);
+	if (alist == NULL)
+		return alist;
+	resseqs = (char (*)[RN_LEN]) emalloc(numresseq * RN_LEN);
+	strcpy(resseqs[0], alist->resseq);
+	index = 0;
+	for (ap = alist->next; ap != NULL; ap = ap->next) {
+		if (strcmp(ap->resseq, resseqs[index]) != 0) {
+			index++;
+			strcpy(resseqs[index], ap->resseq);
+		}
+	}
+	if (index+1 != numresseq) {
+		fprintf(stderr,
+		  "Internal error: residue ID numbering mismatch.\n");
+		exit(1);
+	}
+	return alist;
+}
+
+/*
+ * scopy:
+ *	Copy strings without copying blanks
+ */
+void scopy(to, from, max)
+register char	*to, *from;
+register int	max;
+{
+	while (max-- > 0 && *from != '\0')
+		if (!isspace(*from))
+			*to++ = *from++;
+		else
+			from++;
+	*to = '\0';
+}
+
+/*
+ * read_kraut:
+ *	Read the given kraut format file into an atom list
+ */
+/* ARGSUSED */
+ATOM *
+read_kraut(file, all)
+char	*file;
+int	all;
+{
+	/*
+	 * Not implemented yet (maybe never).  Just fake as if
+	 * we had not seen any atoms.
+	 */
+	fputs("-k is unimplemented\n", stderr);
+	return NULL;
+}
+
+/*
+ * read_midas:
+ *	Read the given midas format file into an atom list
+ */
+/* ARGSUSED */
+ATOM *
+read_midas(file, all)
+char	*file;
+int	all;
+{
+	/*
+	 * Not implemented yet (maybe never).  Just fake as if
+	 * we had not seen any atoms.
+	 */
+	fputs("-m is unimplemented\n", stderr);
+	return NULL;
+}
+
+static char	*aa[] = {
+	"  A", "  C", "  G", "  T", "  U",
+	"ALA", "ARG", "ASN", "ASP", "CPR", "CYS", "CYX", "CYZ", "GLN",
+	"GLU", "GLY", "HIS", "ILE", "LEU", "LYS", "MET", "PHE", "PRO",
+	"SER", "THR", "TRP", "TYR", "VAL",
+	(char *) NULL
+};
+
+/*
+ * is_aa:
+ *	Decide whether the given residue type is an amino acid
+ *	or nucleic acid.
+ */
+STATIC
+int
+is_aa(type)
+char	*type;
+{
+	register int	n;
+	register char	**aap;
+
+	for (aap = aa; *aap != NULL; aap++) {
+		n = strcmp(type, *aap);
+		if (n == 0)
+			return TRUE;
+		else if (n < 0)
+			break;
+	}
+	return FALSE;
+}
+
+/*
+ * read_wanted:
+ *	Read the "wanted list" of atoms from the given file
+ */
+WANTED *
+read_wanted(fp)
+FILE	*fp;
+{
+	register WANTED	*cp, *wp;
+	char		buf[BUFSIZ], atname[AN_LEN];
+	char		orig[BUFSIZ], orig2[BUFSIZ], *fields[4];
+	int		numfields;
+	extern char	*emalloc();
+	static char	*errmsg = "Residues with chain IDs and/or insertion codes should have those appended\n\twith no spaces, e.g. residue 55 of chain E with insertion code A\n\twould be identified as 55AE.\n";
+	static char	*errmsg2 = "Could not find residue '%s' in PDB file.\nThe residue was mentioned in site file line:\n%s\n";
+
+	if (fp == NULL)
+		return NULL;
+
+	wp = NULL;
+	while (fgets(buf, sizeof buf, fp) != NULL) {
+		strcpy(orig, buf);
+		if ((numfields = tokenize(buf, fields, 4)) != 3) {
+			if (numfields == 0)
+				/* don't penalize blank lines */
+				continue;
+			fputs("Illegal line in -i file:\n", stderr);
+			fputs(orig, stderr);
+			if (numfields > 3) {
+				fputs(errmsg, stderr);
+			}
+			exit(1);
+		}
+		strcpy(atname, fields[2]);
+		cp = (WANTED *) emalloc(sizeof (WANTED));
+		cp->startres = locres(fields[1]);
+		if (cp->startres < 0) {
+			/* no such residue */
+			fprintf(stderr, errmsg2, fields[1], orig);
+			exit(1);
+		}
+		if (strcmp(atname, "*") == 0) {
+			cp->type = W_ANY;
+		}
+		else if (strcmp(atname, "FRM") == 0) {
+			cp->type = W_RANGE;
+			if (fgets(buf, sizeof buf, fp) == NULL) {
+				fputs("Unexpected EOF in -i file\n", stderr);
+				(void) free((char *) cp);
+				break;
+			}
+			strcpy(orig2, buf);
+			numfields = tokenize(buf, fields, 4);
+			if (numfields == 0
+			  || strcmp(fields[numfields-1], "TO") != 0) {
+				fputs("No TO after FRM in -i file\n", stderr);
+				fprintf(stderr, "FRM line was: %s\n", orig);
+				(void) free((char *) cp);
+				exit(1);
+			}
+			if (numfields > 3) {
+				fputs(errmsg, stderr);
+				exit(1);
+			}
+			cp->w.endres = locres(fields[1]);
+			if (cp->w.endres < 0) {
+				fprintf(stderr, errmsg2, fields[1], orig2);
+				exit(1);
+			}
+			if (cp->w.endres < cp->startres) {
+				fprintf(stderr,
+				  "End of FRM/TO range before begining!\n");
+				fprintf(stderr, "FRM/TO lines were:%s%s\n",
+				  orig, orig2);
+				exit(1);
+			}
+		}
+		else {
+			cp->type = W_ATOM;
+			(void) strcpy(cp->w.atom, atname);
+		}
+		cp->next = wp;
+		wp = cp;
+	}
+	return wp;
+}

dms/libpdb/GNUmakefile

@@ -0,0 +1,34 @@
+SHELL		= /bin/sh
+ifeq ($(shell test -e /usr/bin/ranlib && echo found),found)
+	RANLIB		= ranlib
+else
+	RANLIB		= :
+endif
+
+OPT		= -g
+DEBUG		=
+CFLAGS		= $(OPT) $(DEBUG)
+LIBRARY		= pdb
+
+LIBDIR		= /usr/local/lib
+LIBARCH		= lib$(LIBRARY).a
+OBJS		= pdb_read.o pdb_sprntf.o pdb_sscanf.o pdb_write.o pdbrun.o ms.o
+SRCS		= pdb_read.c pdb_sprntf.c pdb_sscanf.c pdb_write.c pdbrun.c ms.c
+
+all:		$(LIBARCH)
+
+$(LIBARCH):     $(OBJS)
+		ar cru $(LIBARCH) $(OBJS)
+		$(RANLIB) $(LIBARCH)
+
+install:	$(LIBARCH)
+		cp $(LIBARCH) $(LIBDIR)
+		$(RANLIB) $(LIBDIR)/$(LIBARCH)
+
+clean:
+		rm -f $(OBJS)
+
+spotless:
+		rm -f $(OBJS) $(LIBARCH)
+
+tags:           $(HDRS) $(SRCS); @ctags -w $(HDRS) $(SRCS)

dms/libpdb/ms.3

@@ -0,0 +1,57 @@
+.\" Copyright (c) 1984,1989 by the Regents of the University of California.
+.\" All Rights Reserved.
+.\" $Id: ms.3,v 1.1 94/11/02 13:10:21 gregc Exp $
+.TH MS 3 "14 Sept 1989"
+.SH NAME
+ms_read_record, ms_parse, ms_write_record \- read and write Molecular Surface (ms) records
+.SH SYNOPSIS
+.nf
+.B #include <ms.h>
+.PP
+.B ms_record ms_read_record(f)
+.B FILE *f;
+.PP
+.B ms_record ms_parse(line_buffer)
+.B char *line_buffer;
+.PP
+.B void ms_write_record(f, m)
+.B FILE *f;
+.B ms_record *m;
+.fi
+.SH DESCRIPTION
+The routines listed above
+are subroutines for Molecular Surface record I/O
+and are available in the pdb library, typically
+.IR "-L/usr/local/lib/midas -lpdb" .
+.PP
+Although the header file is too long to reproduce here, it should be
+perused before using any of the above routines.
+It is typically found in
+.IR /usr/local/midas/include .
+.PP
+\fBms_read_record\fP reads the next line of input from the file \fBf\fP,
+and returns the contents parsed into a C structure.
+\fBms_parse\fP parses the contents of the line buffer
+and returns a C structure.
+\fBms_write_record\fP writes the contents of the MS record (\fB*m\fP) to 
+the file \fBf\fP.
+.SH "SEE ALSO"
+dms(1)
+.SH DIAGNOSTICS
+Upon reaching the end of the file, \fBms_read_record\fP will return
+a record with MS_END as its type.
+.SH COPYRIGHT
+Copyright \(co 1992 The Regents of the University of California.
+All rights reserved.
+.PP
+Redistribution and use in source and binary forms are permitted
+provided that the above copyright notice and this paragraph are
+duplicated in all such forms and that any documentation,
+advertising materials, and other materials related to such
+distribution and use acknowledge that the software was developed
+by the University of California, San Francisco.  The name of the
+University may not be used to endorse or promote products derived
+from this software without specific prior written permission.
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

dms/libpdb/ms.c

@@ -0,0 +1,289 @@
+/*
+ *	Copyright (c) 1989 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: ms.c,v 2.4 94/05/19 16:01:16 conrad Exp $
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+#include "pdb_int.h"
+#include "ms.h"
+
+#ifndef TRUE
+#define	TRUE	1
+#define	FALSE	0
+#endif
+
+/*
+ * ms_read_record:
+ *	Read an ms record from a file and return the corresponding
+ *	data structure
+ */
+ms_record
+#ifdef __STDC__
+ms_read_record(FILE *fp)
+#else
+ms_read_record(fp)
+	FILE	*fp;
+#endif
+{
+	char		buf[MS_BUFSIZ];
+	char		*cp;
+	int		c;
+	ms_record	record;
+
+	/*
+	 * If at end of file, just set the record type and return
+	 */
+	if (fgets(buf, sizeof buf, fp) == NULL) {
+		record.record_type = MS_END;
+		return record;
+	}
+
+	cp = strchr(buf, '\n');
+	if (cp != NULL)
+		*cp = '\0';
+	else
+		/* discard extra characters since line too long */
+		while ((c = getc(fp)) != '\n' && c != EOF)
+			continue;
+
+	return ms_read_string(buf);
+}
+
+#ifdef __STDC__
+	static void	crunch(char *);
+#else
+	static void	crunch();
+#endif
+
+/*
+ * ms_read_string
+ *	Construct the data structure corresponding to the given line
+ */
+ms_record
+#ifdef __STDC__
+ms_read_string(const char *buf)
+#else
+ms_read_string(buf)
+	char	*buf;
+#endif
+{
+	int		i;
+	const char	*cp;
+	char		*sp;
+	int		nfield;
+	double		area, extra;
+	double		coord[3], normal[3];
+	ms_record	record;
+	ms_atom		*map;
+	ms_surface	*msp;
+	char		type;
+	const char	*atom_fmt, *surf_fmt;
+
+	/*
+	 * If the head of the string is "user" (case-independently),
+	 * we copy the buffer into the string and return
+	 */
+	if (strncasecmp(buf, "user", 4) == 0) {
+		record.record_type = MS_USER;
+		for (cp = buf + 4; isspace(*cp); cp++)
+			continue;
+		sp = record.ms.user.string;
+		while (*cp != '\0' && *cp != '\n')
+			*sp++ = *cp++;
+		*sp = '\0';
+		return record;
+	}
+
+	/*
+	 * This is either an atom line, surface line, or an error
+	 */
+	if (strlen(buf) < 41) {
+		record.record_type = MS_UNKNOWN;
+		(void) strcpy(record.ms.unknown.string, buf);
+		return record;
+	}
+	type = buf[40];
+	atom_fmt = "%3s %4s %4s%8f %8f %8f A";
+	surf_fmt = "%3s %4s %4s%8f %8f %8f S%c%c %6f %6f %6f %6f %6f";
+	if (isspace(type)) {
+		type = buf[41];
+		atom_fmt = "%3s %5s %4s%8f %8f %8f A";
+		surf_fmt = "%3s %5s %4s%8f %8f %8f S%c%c %6f %6f %6f %6f %6f";
+	}
+	switch (type) {
+	  case 'A':
+		record.record_type = MS_ATOM;
+		map = &record.ms.atom;
+		nfield = pdb_sscanf(buf, atom_fmt,
+			map->residue_type, map->residue_sequence,
+			map->atom_name, &coord[0], &coord[1], &coord[2]);
+		if (nfield == 6) {
+			for (i = 0; i < 3; i++)
+				map->coord[i] = coord[i];
+			crunch(map->residue_type);
+			crunch(map->residue_sequence);
+			crunch(map->atom_name);
+			return record;
+		}
+		break;
+	  case 'S':
+		record.record_type = MS_SURFACE;
+		msp = &record.ms.surface;
+		nfield = pdb_sscanf(buf, surf_fmt,
+			msp->residue_type, msp->residue_sequence,
+			msp->atom_name, &coord[0], &coord[1], &coord[2],
+			&msp->type, &msp->level, &area,
+			&normal[0], &normal[1], &normal[2], &extra);
+		switch (nfield) {
+		  case 9:
+			normal[0] = 0;
+			/* FALLTHROUGH */
+		  case 10:
+			msp->has_normal = FALSE;
+			for (i = 0; i < 3; i++)
+				msp->coord[i] = coord[i];
+			msp->area = area;
+			msp->extra = normal[0];
+			crunch(msp->residue_type);
+			crunch(msp->residue_sequence);
+			crunch(msp->atom_name);
+			return record;
+		  case 12:
+			extra = 0;
+			/* FALLTHROUGH */
+		  case 13:
+			msp->has_normal = TRUE;
+			for (i = 0; i < 3; i++) {
+				msp->coord[i] = coord[i];
+				msp->normal[i] = normal[i];
+			}
+			msp->area = area;
+			msp->extra = extra;
+			crunch(msp->residue_type);
+			crunch(msp->residue_sequence);
+			crunch(msp->atom_name);
+			return record;
+		}
+		break;
+	}
+
+	/*
+	 * Okay.  We must not have recognized the record.  Set the
+	 * record type, copy the string into the string and return
+	 */
+	record.record_type = MS_UNKNOWN;
+	(void) strcpy(record.ms.unknown.string, buf);
+	return record;
+}
+
+/*
+ * crunch:
+ *	Remove blanks from a string
+ */
+static
+void
+#ifdef __STDC__
+crunch(char *s)
+#else
+crunch(s)
+	char	*s;
+#endif
+{
+	char	*last;
+
+	for (last = s; *s != '\0'; s++)
+		if (!isspace(*s))
+			*last++ = *s;
+	*last = '\0';
+}
+
+/*
+ * ms_write_record:
+ *	Write an ms record to a file from the corresponding
+ *	data structure
+ */
+void
+#ifdef __STDC__
+ms_write_record(FILE *fp, const ms_record *mp)
+#else
+ms_write_record(fp, mp)
+	FILE		*fp;
+	ms_record	*mp;
+#endif
+{
+	char	buffer[MS_RECLEN];
+
+	ms_write_string(buffer, mp);
+	fprintf(fp, "%s\n", buffer);
+}
+
+/*
+ * ms_write_string:
+ *	Write an ms record to a string from the corresponding
+ *	data structure
+ */
+void
+#ifdef __STDC__
+ms_write_string(char *buffer, const ms_record *mp)
+#else
+ms_write_string(buffer, mp)
+	char		*buffer;
+	ms_record	*mp;
+#endif
+{
+	const ms_atom		*map;
+	const ms_surface	*msp;
+	char			*cp;
+
+	switch (mp->record_type) {
+	  case MS_ATOM:
+		map = &mp->ms.atom;
+		(void) sprintf(buffer, "%-3s %4s %4s %7.3f  %7.3f  %7.3f A",
+			map->residue_type, map->residue_sequence,
+			map->atom_name, map->coord[0], map->coord[1],
+			map->coord[2]);
+		break;
+	  case MS_SURFACE:
+		msp = &mp->ms.surface;
+		(void) sprintf(buffer,
+			"%-3s %4s %4s %7.3f  %7.3f  %7.3f S%c%c %6.3f",
+			msp->residue_type, msp->residue_sequence,
+			msp->atom_name, msp->coord[0], msp->coord[1],
+			msp->coord[2], msp->type, msp->level, msp->area);
+		cp = strchr(buffer, '\0');
+		if (msp->has_normal) {
+			(void) sprintf(cp, " %6.3f %6.3f %6.3f",
+				msp->normal[0], msp->normal[1], msp->normal[2]);
+			cp = strchr(cp, '\0');
+		}
+		if (msp->extra != 0) {
+			if (msp->extra >= 1000 || msp->extra <= -100)
+				(void) sprintf(cp, " %6.1f", msp->extra);
+			else if (msp->extra >= 100 || msp->extra <= -10)
+				(void) sprintf(cp, " %6.2f", msp->extra);
+			else
+				(void) sprintf(cp, " %6.3f", msp->extra);
+		}
+		break;
+	  case MS_USER:
+		(void) sprintf(buffer, "USER %s\n", mp->ms.user.string);
+		break;
+	}
+}

dms/libpdb/ms.h

@@ -0,0 +1,95 @@
+/*
+ *	Copyright (c) 1989 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: ms.h,v 2.2 94/01/27 12:41:26 gregc Exp $
+ */
+
+#ifndef MS_H
+#define	MS_H
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define	MS_RECLEN	128
+#define	MS_BUFSIZ	(MS_RECLEN + 2)
+
+#define	MS_MAX_RESTYPE	8
+#define	MS_MAX_RESSEQ	8
+#define	MS_MAX_ATNAME	8
+
+#define	MS_UNKNOWN	0
+#define	MS_END		1
+#define	MS_ATOM		2
+#define	MS_SURFACE	3
+#define	MS_USER		4
+
+#define	MS_NUM_R	5
+
+typedef struct ms_atom	{
+	char	residue_type[MS_MAX_RESTYPE];
+	char	residue_sequence[MS_MAX_RESSEQ];
+	char	atom_name[MS_MAX_ATNAME];
+	float	coord[3];
+}	ms_atom;
+
+typedef struct ms_surf	{
+	char	residue_type[MS_MAX_RESTYPE];
+	char	residue_sequence[MS_MAX_RESSEQ];
+	char	atom_name[MS_MAX_ATNAME];
+	float	coord[3];
+	float	normal[3];
+	float	area;
+	float	extra;
+	char	has_normal;
+	char	type;
+	char	level;
+}	ms_surface;
+
+typedef struct ms_user	{
+	char	string[MS_BUFSIZ];
+}	ms_user;
+
+#define	ms_unknown	ms_user
+
+typedef struct ms_record	{
+	int	record_type;
+	union	{
+		ms_unknown	unknown;
+		ms_atom		atom;
+		ms_surface	surface;
+		ms_user		user;
+	}	ms;
+}	ms_record;
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern ms_record	ms_read_record(FILE *);
+extern ms_record	ms_read_string(const char *);
+extern void		ms_write_record(FILE *, const ms_record *);
+extern void		ms_write_string(char *, const ms_record *);
+#else
+extern ms_record	ms_read_record();
+extern ms_record	ms_read_string();
+extern void		ms_write_record();
+extern void		ms_write_string();
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif

dms/libpdb/pdb.3

@@ -0,0 +1,87 @@
+.\" Copyright (c) 1984,1989 by the Regents of the University of California.
+.\" All Rights Reserved.
+.\" $Id: pdb.3,v 1.16 94/11/06 19:55:29 gregc Exp $
+.TH PDB 3 "14 Sept 1989"
+.SH NAME
+pdb_read_record, pdb_parse, pdb_write_record \- read and write Brookhaven Protein DataBank records
+.SH SYNOPSIS
+.nf
+.B #include <pdb.h>
+.PP
+.B pdb_record pdb_read_record(f)
+.B FILE *f;
+.PP
+.B pdb_record pdb_parse(line_buffer)
+.B char *line_buffer;
+.PP
+.B "void pdb_write_record(f, r, name, line_num)"
+.B FILE *f;
+.B pdb_record *r;
+.B char *name;
+.B int line_num;
+.fi
+.SH DESCRIPTION
+The routines listed above
+are subroutines for Brookhaven Protein Data Bank record I/O
+and are available in the pdb library, typically
+.IR "-L/usr/local/lib/midas -lpdb" .
+.PP
+Although the header file is too long to reproduce here, it should be
+perused before using any of the above routines.
+It is typically found in
+.IR /usr/local/midas/include .
+\fBpdb_read_record\fP reads the next line of input from the file \fBf\fP,
+and returns the contents parsed into a C structure.
+\fBpdb_parse\fP parses the contents of the line buffer
+and returns a C structure.
+\fBpdb_write_record\fP writes the contents of the PDB record (\fB*r\fP) to 
+the file \fBf\fP.  If the \fBname\fP is non-null, then it and the line
+number given (\fBline_num\fP) are placed in columns 72 through 80 on the
+line in standard PDB format.
+.PP
+\fBpdb_read_record\fP and \fBpdb_write_record\fP automatically
+handle versions 5 and 6 of the UCSFCGL's PDB scene annotation records.
+The version number is automatically changed when a USER  PDBRUN record is read
+or written.
+Any other version number turns off the parsing of scene annotation records.
+.SH "SEE ALSO"
+``Protein Data Bank Atomic Coordinate and Bibliographic Entry Format Description,'' Febuary 1992,
+Brookhaven National Laboratory
+(URL: ftp://ftp.pdb.bnl.gov/pub/format_desc.ps),
+the January 1993 Protein Data Bank Quarterly Newsletter,
+and Couch, \fIet. al\fP, ``Annotating PDB Files with Scene Information'',
+(in press)
+(URL: http://cgl.ucsf.edu/????).
+.SH DIAGNOSTICS
+Upon reaching the end of the file, \fBpdb_read_record\fP will return
+a record with PDB_END as its type.
+.SH NOTES
+The subtype field of USERxx structure tells what the \fIxx\fP part was.
+The rest of the line, up to the card sequence portion, is the text field.
+.PP
+Due to the way Brookhaven encodes their files,
+atom names usually have leading blanks and sometimes have embedded blanks.
+Residue names occasionally have leading blanks too.
+To be entirely consistent with the PDB format, the programmer should put those
+blanks in before using \fBpdb_write_record\fP.
+.SH BUGS
+Doesn't allow exact duplication of the PDB card image sorting field
+(columns 73 through 80).
+.PP
+Routines are needed to convert to and from PDB typesetting conventions
+in COMPND, SOURCE, AUTHOR, and JRNL records.
+.SH COPYRIGHT
+Copyright \(co 1989 The Regents of the University of California.
+All rights reserved.
+.PP
+Redistribution and use in source and binary forms are permitted
+provided that the above copyright notice and this paragraph are
+duplicated in all such forms and that any documentation,
+advertising materials, and other materials related to such
+distribution and use acknowledge that the software was developed
+by the University of California, San Francisco.  The name of the
+University may not be used to endorse or promote products derived
+from this software without specific prior written permission.
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

dms/libpdb/pdb.h

@@ -0,0 +1,530 @@
+/*
+ *	Copyright (c) 1989 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdb.h,v 2.11 1995/01/20 01:20:36 gregc Exp $
+ *
+ *	Based on Brookhaven National Laboratory Protein Data Bank, March 1989
+ *
+ *	C structure declarations
+ */
+
+#ifndef PDB_H
+# define	PDB_H
+
+# include	<stdio.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+# define	PDB_RECLEN	80		/* PDB record length */
+# define	PDB_BUFSIZ	PDB_RECLEN + 2	/* + '\n' + '\0' */		
+
+# define	PDB_PDBRUN_VERSION	6
+
+# define	PDB_UNKNOWN	0
+
+/* records originally in alphabetical order */
+
+# define	PDB_ANISOU	1
+# define	PDB_ATOM	2
+# define	PDB_AUTHOR	3
+# define	PDB_COMPND	4
+# define	PDB_CONECT	5
+# define	PDB_CRYST1	6
+# define	PDB_END		7
+# define	PDB_FORMUL	8
+# define	PDB_FTNOTE	9
+# define	PDB_HEADER	10
+# define	PDB_HELIX	11
+# define	PDB_HET		12
+# define	PDB_HETATM	13
+# define	PDB_JRNL	14
+# define	PDB_MASTER	15
+# define	PDB_MTRIX	16
+# define	PDB_OBSLTE	17
+# define	PDB_ORIGX	18
+# define	PDB_REMARK	19
+# define	PDB_REVDAT	20
+# define	PDB_SCALE	21
+# define	PDB_SEQRES	22
+# define	PDB_SHEET	23
+# define	PDB_SIGATM	24
+# define	PDB_SIGUIJ	25
+# define	PDB_SITE	26
+# define	PDB_SOURCE	27
+# define	PDB_SPRSDE	28
+# define	PDB_SSBOND	29
+# define	PDB_TER		30
+# define	PDB_TURN	31
+# define	PDB_TVECT	32
+# define	PDB_USER	33
+# define	PDB_MODEL	34
+# define	PDB_ENDMDL	35
+# define	PDB_EXPDTA	36
+# define	PDB_SYMDES	37
+# define	PDB_SYMOP	38
+# define	PDB_MTXDES	39
+# define	PDB_CMPDES	40
+# define	PDB_CMPONT	41
+# define	PDB_TRNSFM	42
+# define	PDB_AGRDES	43
+# define	PDB_AGGRGT	44
+
+# define	PDB_NUM_R	45
+
+# define	PDB_USER_PDBRUN		0x100
+# define	PDB_USER_EYEPOS		0x101
+# define	PDB_USER_ATPOS		0x102
+# define	PDB_USER_WINDOW		0x103
+# define	PDB_USER_FOCUS		0x104
+# define	PDB_USER_VIEWPORT	0x105
+# define	PDB_USER_BGCOLOR	0x106
+# define	PDB_USER_ANGLE		0x107
+# define	PDB_USER_DISTANCE	0x108
+# define	PDB_USER_FILE		0x109
+# define	PDB_USER_MARKNAME	0x10a
+# define	PDB_USER_MARK		0x10b
+# define	PDB_USER_CNAME		0x10c
+# define	PDB_USER_COLOR		0x10d
+# define	PDB_USER_RADIUS		0x10e
+# define	PDB_USER_OBJECT		0x10f
+# define	PDB_USER_ENDOBJ		0x110
+# define	PDB_USER_CHAIN		0x111
+# define	PDB_USER_GFX_BEGIN	0x112
+# define	PDB_USER_GFX_END	0x113
+# define	PDB_USER_GFX_COLOR	0x114
+# define	PDB_USER_GFX_NORMAL	0x115
+# define	PDB_USER_GFX_VERTEX	0x116
+# define	PDB_USER_GFX_FONT	0x117
+# define	PDB_USER_GFX_TEXTPOS	0x118
+# define	PDB_USER_GFX_LABEL	0x119
+# define	PDB_USER_GFX_MOVE	0x11a	/* obsolete */
+# define	PDB_USER_GFX_DRAW	0x11b	/* obsolete */
+# define	PDB_USER_GFX_MARKER	0x11c	/* obsolete */
+# define	PDB_USER_GFX_POINT	0x11d	/* obsolete */
+
+# define	PDB_NUM_USER_R		(PDB_USER_GFX_POINT-PDB_USER_PDBRUN+1)
+
+# define	PDB_GFX_UNKNOWN		0x0
+# define	PDB_GFX_POINTS		0x1
+# define	PDB_GFX_MARKERS		0x2
+# define	PDB_GFX_LINES		0x3
+# define	PDB_GFX_LINE_STRIP	0x4
+# define	PDB_GFX_LINE_LOOP	0x5
+# define	PDB_GFX_TRIANGLES	0x6
+# define	PDB_GFX_TRIANGLE_STRIP	0x7
+# define	PDB_GFX_TRIANGLE_FAN	0x8
+# define	PDB_GFX_QUADS		0x9
+# define	PDB_GFX_QUAD_STRIP	0xa
+# define	PDB_GFX_POLYGON		0xb
+
+typedef char	pdb_date[10];
+typedef char	pdb_aname[5];		/* atom name - NO2* */
+typedef char	pdb_rname[5];		/* residue name - ALA */
+typedef char	pdb_pname[5];		/* pdb name - 9lyz */
+typedef char	pdb_id[4];		/* generic short id field */
+typedef double	pdb_float;		/* size of floating point */
+
+typedef struct {			/* residue info */
+	pdb_rname	name;
+	char		chain_id;
+	int		seq_num;
+	char		insert_code;
+} pdb_residue;
+
+/*
+ *	structures declarations for each record type
+ */
+
+struct pdb_unknown {
+	char	junk[81];
+};
+struct pdb_aggrgt {
+	int	serial_num;
+	int	num_components;
+	int	cmpont_serial_nums[14];
+};
+# define	pdb_agrdes	pdb_ftnote
+struct pdb_anisou {
+	int		serial_num;
+	pdb_aname	name;
+	char		alt_loc;
+	pdb_residue	residue;
+	int		u[6];
+};
+struct pdb_atom {
+	int		serial_num;
+	pdb_aname	name;
+	char		alt_loc;
+	pdb_residue	residue;
+	pdb_float	x, y, z;
+	pdb_float	occupancy, temp_factor;
+	int		ftnote_num;
+};
+struct pdb_author {
+	char	data[61];
+	char	continuation;
+};
+# define	pdb_cmpdes	pdb_ftnote
+struct pdb_cmpont {
+	int		seq_num;
+	pdb_residue	residues[2];
+};
+# define	pdb_compnd	pdb_author
+struct pdb_conect {
+	int	serial_num;
+	int	covalent[4];
+	struct {
+		int	hydrogen[2];
+		int	salt;
+	} bonds[2];
+};
+struct pdb_cryst1 {
+	pdb_float	a, b, c;
+	pdb_float	alpha, beta, gamma;
+	char		space_grp[12];
+	int		z;
+};
+/* no structure for PDB_END */
+/* no structure for PDB_ENDMDL */
+# define	pdb_expdta	pdb_author
+struct pdb_formul {
+	int		component;
+	pdb_rname	het_id;
+	int		continuation;
+	char		exclude;	/* * to exclude */
+	char		formula[52];
+};
+struct pdb_ftnote {
+	int	num;
+	char	text[60];
+};
+struct pdb_header {
+	char		class[41];
+	pdb_date	date;
+	pdb_pname	id;
+	char		type;
+};
+struct pdb_helix {
+	int		serial_num;
+	pdb_id		id;
+	pdb_residue	residues[2];
+	int		class;
+	char		comment[31];
+};
+struct pdb_het {
+	pdb_residue	het_grp;
+	int		num_atoms;
+	char		text[41];
+};
+# define	pdb_hetatm	pdb_atom
+# define	pdb_jrnl	pdb_author
+struct pdb_master {
+	int	num_remark;
+	int	num_ftnote;
+	int	num_het;
+	int	num_helix;
+	int	num_sheet;
+	int	num_turn;
+	int	num_site;
+	int	num_transform;
+	int	num_coordinate;
+	int	num_ter;
+	int	num_conect;
+	int	num_seqres;
+};
+struct pdb_model {
+	int	num;
+};
+struct pdb_mtrix {
+	int		row_num;
+	int		serial_num;
+	pdb_float	m1, m2, m3, v;
+	int		given;
+};
+# define	pdb_mtxdes	pdb_ftnote
+struct pdb_obslte {
+	int		continuation;
+	pdb_date	date;
+	pdb_pname	old_id;
+	pdb_pname	id_map[8];
+};
+struct pdb_origx {
+	int		row_num;
+	pdb_float	o1, o2, o3, t;
+};
+# define	pdb_remark	pdb_ftnote
+struct pdb_revdat {
+	int		modification;
+	int		continuation;
+	pdb_date	date;
+	char		id[8];
+	char		mod_type;
+	char		corrections[31];
+};
+struct pdb_scale {
+	int		row_num;
+	pdb_float	s1, s2, s3, u;
+};
+struct pdb_seqres {
+	int		serial_num;
+	char		chain_id;
+	int		count;
+	pdb_rname	names[13];
+};
+struct pdb_sheet {
+	int		strand_num;
+	pdb_id		id;
+	int		count;
+	pdb_residue	residues[2];
+	int		sense;
+	struct {
+		pdb_aname	name;
+		pdb_residue	residue;
+	} atoms[2];
+};
+# define	pdb_sigatm	pdb_atom
+# define	pdb_siguij	pdb_anisou
+struct pdb_site {
+	int		seq_num;
+	pdb_id		id;
+	int		count;
+	pdb_residue	residues[4];
+};
+# define	pdb_source	pdb_author
+struct pdb_sprsde {
+	int		continuation;
+	pdb_date	date;
+	pdb_pname	id;
+	pdb_pname	supersede[8];
+};
+struct pdb_ssbond {
+	int		seq_num;
+	pdb_residue	residues[2];
+	char		comment[31];
+};
+# define	pdb_symdes	pdb_ftnote
+struct pdb_symop {
+	int		row_num;
+	int		serial_num;
+	pdb_float	s1, s2, s3, t;
+};
+struct pdb_ter {
+	int		serial_num;
+	pdb_residue	residue;
+};
+struct pdb_trnsfm {
+	int		result_serial_num;
+	int		apply_serial_num;
+	int		source_serial_num;
+};
+struct pdb_turn {
+	int		seq_num;
+	pdb_id		id;
+	pdb_residue	residues[2];
+	char		comment[31];
+};
+struct pdb_tvect {
+	int		serial_num;
+	pdb_float	t1, t2, t3;
+	char		comment[31];
+};
+struct pdb_user {
+	char	subtype[3];
+	char	text[67];
+};
+struct pdb_user_pdbrun {
+	int	version;
+};
+struct pdb_user_eyepos {
+	pdb_float	xyz[3];
+};
+# define	pdb_user_atpos	pdb_user_eyepos
+struct pdb_user_window {
+	pdb_float	left, right, bottom, top, hither, yon;
+};
+struct pdb_user_focus {
+	pdb_float	focus;
+};
+struct pdb_user_viewport {
+	pdb_float	xmin, xmax, ymin, ymax;
+};
+struct pdb_user_bgcolor {
+	pdb_float	rgb[3];
+};
+struct pdb_user_angle {
+	int		atom0, atom1, atom2, atom3;
+	pdb_float	angle;
+	int		which;			/* version 5 -- obsolete */
+};
+struct pdb_user_distance {
+	int		atom0, atom1;
+	pdb_float	distance;
+	int		which;			/* version 5 -- obsolete */
+};
+struct pdb_user_file {
+	char		filename[62];		/* 57 in version 6 */
+	int		model;			/* not in version 5 */
+};
+struct pdb_user_markname {
+	char		markname[58];
+};
+# define	pdb_user_mark	pdb_user_markname
+struct pdb_user_cname {
+	pdb_float	rgb[3];
+	char		name[39];
+};
+struct pdb_user_color {
+	pdb_float	rgb[3];
+	char		spec[39];
+};
+struct pdb_user_radius {
+	pdb_float	radius;
+};
+struct pdb_user_object {
+	int		model;			/* version 5 -- obsolete */
+};
+struct pdb_user_endobj {
+	int		model;			/* version 5 -- obsolete */
+};
+struct pdb_user_chain {
+	int		atom0, atom1;
+};
+struct pdb_user_gfx_begin {			/* not in version 5 */
+	int		primitive;
+	char		unknown[33];
+};
+/* no structure for USER  GFX END */
+# define	pdb_user_gfx_color	pdb_user_color
+struct pdb_user_gfx_normal {
+	pdb_float	xyz[3];
+};
+# define	pdb_user_gfx_vertex	pdb_user_gfx_normal
+struct pdb_user_gfx_font {
+	int	size;
+	char	name[54];
+};
+struct pdb_user_gfx_textpos {			/* not in version 5 */
+	pdb_float	xyz[3];
+};
+struct pdb_user_gfx_label {
+	pdb_float	xyz[3];			/* version 5 -- obsolete */
+	char		text[57];		/* 27 in version 5 */
+};
+struct pdb_user_gfx_move {			/* version 5 -- obsolete */
+	pdb_float	xyz[3];
+};
+# define	pdb_user_gfx_draw	pdb_user_gfx_move	/* version 5 -- obsolete */
+# define	pdb_user_gfx_marker	pdb_user_gfx_move	/* "" */
+# define	pdb_user_gfx_point	pdb_user_gfx_move	/* "" */
+
+typedef struct pdb_record {
+	int	record_type;
+	union	{
+		struct pdb_unknown	unknown;
+		struct pdb_agrdes	agrdes;
+		struct pdb_aggrgt	aggrgt;
+		struct pdb_anisou	anisou;
+		struct pdb_atom		atom;
+		struct pdb_author	author;
+		struct pdb_cmpdes	cmpdes;
+		struct pdb_cmpont	cmpont;
+		struct pdb_compnd	compnd;
+		struct pdb_conect	conect;
+		struct pdb_cryst1	cryst1;
+		/* no pdb_end structure */
+		/* no pdb_endmdl structure */
+		struct pdb_expdta	expdta;
+		struct pdb_formul	formul;
+		struct pdb_ftnote	ftnote;
+		struct pdb_header	header;
+		struct pdb_helix	helix;
+		struct pdb_het		het;
+		struct pdb_hetatm	hetatm;
+		struct pdb_jrnl		jrnl;
+		struct pdb_master	master;
+		struct pdb_model	model;
+		struct pdb_mtrix	mtrix;
+		struct pdb_mtxdes	mtxdes;
+		struct pdb_obslte	obslte;
+		struct pdb_origx	origx;
+		struct pdb_remark	remark;
+		struct pdb_revdat	revdat;
+		struct pdb_scale	scale;
+		struct pdb_seqres	seqres;
+		struct pdb_sheet	sheet;
+		struct pdb_sigatm	sigatm;
+		struct pdb_siguij	siguij;
+		struct pdb_site		site;
+		struct pdb_source	source;
+		struct pdb_sprsde	sprsde;
+		struct pdb_ssbond	ssbond;
+		struct pdb_symdes	symdes;
+		struct pdb_symop	symop;
+		struct pdb_ter		ter;
+		struct pdb_trnsfm	trnsfm;
+		struct pdb_turn		turn;
+		struct pdb_tvect	tvect;
+		struct pdb_user		user;
+		struct pdb_user_pdbrun	user_pdbrun;
+		struct pdb_user_eyepos	user_eyepos;
+		struct pdb_user_atpos	user_atpos;
+		struct pdb_user_window	user_window;
+		struct pdb_user_focus	user_focus;
+		struct pdb_user_viewport	user_viewport;
+		struct pdb_user_bgcolor	user_bgcolor;
+		struct pdb_user_angle	user_angle;
+		struct pdb_user_distance	user_distance;
+		struct pdb_user_file	user_file;
+		struct pdb_user_markname	user_markname;
+		struct pdb_user_mark	user_mark;
+		struct pdb_user_cname	user_cname;
+		struct pdb_user_color	user_color;
+		struct pdb_user_radius	user_radius;
+		struct pdb_user_object	user_object;
+		struct pdb_user_endobj	user_endobj;
+		struct pdb_user_chain	user_chain;
+		struct pdb_user_gfx_begin	user_gfx_begin;
+		struct pdb_user_gfx_color	user_gfx_color;
+		struct pdb_user_gfx_normal	user_gfx_normal;
+		struct pdb_user_gfx_vertex	user_gfx_vertex;
+		struct pdb_user_gfx_font	user_gfx_font;
+		struct pdb_user_gfx_textpos	user_gfx_textpos;
+		struct pdb_user_gfx_label	user_gfx_label;
+		struct pdb_user_gfx_move	user_gfx_move;
+		struct pdb_user_gfx_draw	user_gfx_draw;
+		struct pdb_user_gfx_marker	user_gfx_marker;
+		struct pdb_user_gfx_point	user_gfx_point;
+	} pdb;
+} pdb_record;
+
+# if defined(__STDC__) || defined(__cplusplus)
+extern pdb_record	pdb_read_record(FILE *);
+extern pdb_record	pdb_read_string(const char *);
+extern void		pdb_write_record(FILE *, const pdb_record *, const char *, int);
+extern void		pdb_write_string(char *, const pdb_record *);
+# else
+extern pdb_record	pdb_read_record();
+extern pdb_record	pdb_read_string();
+extern void		pdb_write_record();
+extern void		pdb_write_string();
+# endif
+
+# ifdef __cplusplus
+}
+# endif
+#endif /* PDB_H */

dms/libpdb/pdb_int.h

@@ -0,0 +1,38 @@
+/*
+ *	Copyright (c) 1989 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdb_int.h,v 2.4 1994/11/17 00:58:58 gregc Exp $
+ */
+
+#include	"pdb.h"
+
+#ifndef __STDC__
+# define	const
+#endif
+
+extern int	pdb_pdbrun_version;
+
+#ifdef __STDC__
+extern int	pdb_sscanf(const char *, const char *, ...);
+extern void	pdb_sprintf(char *, const char *, ...);
+extern const char	*pdb_gfx_string(int i);
+extern int	pdb_gfx_type(const char *type);
+#else
+extern int	pdb_sscanf();
+extern void	pdb_sprintf();
+extern char	*pdb_gfx_string();
+extern int	pdb_gfx_type();
+#endif

dms/libpdb/pdb_read.c

@@ -0,0 +1,1143 @@
+/*
+ *	Copyright (c) 1989 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdb_read.c,v 2.20 1995/07/22 02:03:18 gregc Exp $
+ *
+ *	subroutine for reading PDB format files
+ *
+ */
+
+/* LINTLIBRARY */
+
+# include	<stdio.h>
+# include	<ctype.h>
+# include	<string.h>
+# include	"pdb_int.h"
+
+# ifndef _tolower
+# define	_tolower	tolower
+# endif
+
+# define	STREQN(a,b,n)	(strncmp(a, b, n) == 0)
+
+static const char * const pdb_record_format[PDB_NUM_R] = {
+#include "read_format.i"
+};
+
+static char const * const pdbrun5[] = {
+#include "pdbrun5_read.i"
+};
+
+static char const * const pdbrun6[] = {
+#include "pdbrun6_read.i"
+};
+
+/*
+ *	for each pdb record type there is a format reading in the
+ *	record values and for printing them out.
+ *
+ *	The actual format of a line written, is the print format
+ *	followed by blank padding to 72 characters, followed by
+ *	8 characters of file and line information.
+ */
+
+pdb_record
+# ifdef __STDC__
+pdb_read_record(FILE *f)
+# else
+pdb_read_record(f)
+	FILE		*f;
+# endif
+{
+
+	char			buffer[PDB_BUFSIZ];
+	char			*cp;
+	int			c;
+	static pdb_record	r_end = { PDB_END };
+
+	if (fgets(buffer, PDB_BUFSIZ, f) == NULL) {
+		/* at eof or error - default to eof */
+		return r_end;
+	}
+
+	cp = strchr(buffer, '\n');
+	if (cp != NULL)
+		*cp = '\0';
+	else
+		/* discard extra characters since line too long */
+		while ((c = getc(f)) != '\n' && c != EOF)
+			continue;
+
+	return pdb_read_string(buffer);
+}
+
+static int
+#ifdef __STDC__
+pdbrun5_type(const char *buf)
+#else
+pdbrun5_type(buf)
+	char	*buf;
+#endif
+{
+	switch (buf[0]) {
+	case 'A': case 'a':
+		if (strncasecmp(buf + 1, "NGLE ", 5) == 0)
+			return PDB_USER_ANGLE;
+		if (strncasecmp(buf + 1, "TPOS ", 5) == 0)
+			return PDB_USER_ATPOS;
+		break;
+	case 'B': case 'b':
+		if (strncasecmp(buf + 1, "GCOLOR ", 7) == 0)
+			return PDB_USER_BGCOLOR;
+		break;
+	case 'C': case 'c':
+		if (strncasecmp(buf + 1, "HAIN ", 5) == 0)
+			return PDB_USER_CHAIN;
+		if (strncasecmp(buf + 1, "NAME ", 5) == 0)
+			return PDB_USER_CNAME;
+		if (strncasecmp(buf + 1, "OLOR ", 5) == 0)
+			return PDB_USER_COLOR;
+		break;
+	case 'D': case 'd':
+		if (strncasecmp(buf + 1, "ISTANCE ", 8) == 0)
+			return PDB_USER_DISTANCE;
+		break;
+	case 'E': case 'e':
+		if (strncasecmp(buf + 1, "NDOBJ ", 6) == 0)
+			return PDB_USER_ENDOBJ;
+		if (strncasecmp(buf + 1, "YEPOS ", 6) == 0)
+			return PDB_USER_EYEPOS;
+		break;
+	case 'F': case 'f':
+		if (strncasecmp(buf + 1, "ILE ", 4) == 0)
+			return PDB_USER_FILE;
+		if (strncasecmp(buf + 1, "OCUS ", 5) == 0)
+			return PDB_USER_FOCUS;
+		break;
+	case 'G': case 'g':
+		if (strncasecmp(buf + 1, "FX ", 3) != 0)
+			break;
+		if (strncasecmp(buf + 4, "COLOR ", 6) == 0)
+			return PDB_USER_GFX_COLOR;
+		if (strncasecmp(buf + 4, "DRAW ", 5) == 0)
+			return PDB_USER_GFX_DRAW;
+		if (strncasecmp(buf + 4, "FONT ", 5) == 0)
+			return PDB_USER_GFX_FONT;
+		if (strncasecmp(buf + 4, "LABEL ", 6) == 0)
+			return PDB_USER_GFX_LABEL;
+		if (strncasecmp(buf + 4, "MARKER ", 7) == 0)
+			return PDB_USER_GFX_MARKER;
+		if (strncasecmp(buf + 4, "MOVE ", 5) == 0)
+			return PDB_USER_GFX_MOVE;
+		if (strncasecmp(buf + 4, "POINT ", 6) == 0)
+			return PDB_USER_GFX_POINT;
+		break;
+	case 'O': case 'o':
+		if (strncasecmp(buf + 1, "BJECT ", 6) == 0)
+			return PDB_USER_OBJECT;
+		break;
+	case 'P': case 'p':
+		if (strncasecmp(buf + 1, "DBRUN ", 6) == 0)
+			return PDB_USER_PDBRUN;
+		break;
+	case 'R': case 'r':
+		if (strncasecmp(buf + 1, "ADIUS ", 6) == 0)
+			return PDB_USER_RADIUS;
+		break;
+	case 'V': case 'v':
+		if (strncasecmp(buf + 1, "IEWPORT ", 8) == 0)
+			return PDB_USER_VIEWPORT;
+		break;
+	case 'W': case 'w':
+		if (strncasecmp(buf + 1, "INDOW ", 6) == 0)
+			return PDB_USER_WINDOW;
+		break;
+	}
+	return PDB_USER;
+}
+
+static int
+#ifdef __STDC__
+pdbrun6_type(const char *buf)
+#else
+pdbrun6_type(buf)
+	char	*buf;
+#endif
+{
+	switch (buf[0]) {
+	case 'A': case 'a':
+		if (strncasecmp(buf + 1, "NGLE ", 5) == 0)
+			return PDB_USER_ANGLE;
+		if (strncasecmp(buf + 1, "TPOS ", 5) == 0)
+			return PDB_USER_ATPOS;
+		break;
+	case 'B': case 'b':
+		if (strncasecmp(buf + 1, "GCOLOR ", 7) == 0)
+			return PDB_USER_BGCOLOR;
+		break;
+	case 'C': case 'c':
+		if (strncasecmp(buf + 1, "HAIN ", 5) == 0)
+			return PDB_USER_CHAIN;
+		if (strncasecmp(buf + 1, "NAME ", 5) == 0)
+			return PDB_USER_CNAME;
+		if (strncasecmp(buf + 1, "OLOR ", 5) == 0)
+			return PDB_USER_COLOR;
+		break;
+	case 'D': case 'd':
+		if (strncasecmp(buf + 1, "ISTANCE ", 8) == 0)
+			return PDB_USER_DISTANCE;
+		break;
+	case 'E': case 'e':
+		if (strncasecmp(buf + 1, "NDOBJ", 5) == 0
+		&& (buf[6] == '\0' || buf[6] == '\n' || buf[6] == ' '))
+			return PDB_USER_ENDOBJ;
+		if (strncasecmp(buf + 1, "YEPOS ", 6) == 0)
+			return PDB_USER_EYEPOS;
+		break;
+	case 'F': case 'f':
+		if (strncasecmp(buf + 1, "ILE ", 4) == 0)
+			return PDB_USER_FILE;
+		if (strncasecmp(buf + 1, "OCUS ", 5) == 0)
+			return PDB_USER_FOCUS;
+		break;
+	case 'G': case 'g':
+		if (buf[1] != 'F' || buf[2] != 'X' || buf[3] != ' ')
+			break;
+		switch (buf[4]) {
+		case 'B': case 'b':
+			if (strncasecmp(buf + 5, "EGIN ", 5) == 0)
+				return PDB_USER_GFX_BEGIN;
+			break;
+		case 'C': case 'c':
+			if (strncasecmp(buf + 5, "OLOR ", 5) == 0)
+				return PDB_USER_GFX_COLOR;
+			break;
+		case 'E': case 'e':
+			if (buf[5] == 'N' && buf[6] == 'D'
+			&& (buf[7] == '\0' || buf[7] == '\n' || buf[7] == ' '))
+				return PDB_USER_GFX_END;
+			break;
+		case 'F': case 'f':
+			if (strncasecmp(buf + 5, "ONT ", 4) == 0)
+				return PDB_USER_GFX_FONT;
+			break;
+		case 'L': case 'l':
+			if (strncasecmp(buf + 5, "ABEL ", 5) == 0)
+				return PDB_USER_GFX_LABEL;
+			break;
+		case 'N': case 'n':
+			if (strncasecmp(buf + 5, "ORMAL ", 6) == 0)
+				return PDB_USER_GFX_NORMAL;
+			break;
+		case 'T': case 't':
+			if (strncasecmp(buf + 5, "EXTPOS ", 7) == 0)
+				return PDB_USER_GFX_TEXTPOS;
+			break;
+		case 'V': case 'v':
+			if (strncasecmp(buf + 5, "ERTEX ", 6) == 0)
+				return PDB_USER_GFX_VERTEX;
+			break;
+		}
+		break;
+	case 'M': case 'm':
+		if (strncasecmp(buf + 1, "ARK ", 4) == 0)
+			return PDB_USER_MARK;
+		if (strncasecmp(buf + 1, "ARKNAME ", 6) == 0)
+			return PDB_USER_MARKNAME;
+		break;
+	case 'O': case 'o':
+		if (strncasecmp(buf + 1, "BJECT", 5) == 0
+		&& (buf[6] == '\0' || buf[6] == '\n' || buf[6] == ' '))
+			return PDB_USER_OBJECT;
+		break;
+	case 'P': case 'p':
+		if (strncasecmp(buf + 1, "DBRUN ", 6) == 0)
+			return PDB_USER_PDBRUN;
+		break;
+	case 'R': case 'r':
+		if (strncasecmp(buf + 1, "ADIUS ", 6) == 0)
+			return PDB_USER_RADIUS;
+		break;
+	case 'V': case 'v':
+		if (strncasecmp(buf + 1, "IEWPORT ", 6) == 0)
+			return PDB_USER_VIEWPORT;
+		break;
+	case 'W': case 'w':
+		if (strncasecmp(buf + 1, "INDOW ", 6) == 0)
+			return PDB_USER_WINDOW;
+		break;
+	}
+	return PDB_USER;
+}
+
+pdb_record
+# ifdef __STDC__
+pdb_read_string(const char *buffer)
+# else
+pdb_read_string(buffer)
+	char	*buffer;
+# endif
+{
+
+	pdb_record		r;
+	const char		*fmt;
+	struct pdb_sheet	*sh;
+	pdb_residue		*sha0, *sha1;
+	char			record_type[4];
+	int			i;
+	char			new_buffer[PDB_BUFSIZ];
+
+# if defined(__STDC__) || defined(vms)
+	(void) memset(&r, 0, sizeof r);
+# else
+	bzero((char *) &r, sizeof r);
+# endif
+
+# ifdef DEBUG
+	printf("%s", buffer);
+# endif /* DEBUG */
+
+	/* convert pdb record to C structure */
+
+	for (i = 0; buffer[i] != '\0' && buffer[i] != '\n' && i < 4; i += 1) {
+		if (isupper(buffer[i]))
+			record_type[i] = _tolower(buffer[i]);
+		else
+			record_type[i] = buffer[i];
+	}
+	if (i < 4)
+		for (; i < 4; i += 1)
+			record_type[i] = ' ';
+
+	r.record_type = PDB_UNKNOWN;
+	switch (record_type[0]) {
+
+	case 'a':
+		if (STREQN(record_type + 1, "tom", 3))
+			r.record_type = PDB_ATOM;
+		else if (STREQN(record_type + 1, "uth", 3))
+			r.record_type = PDB_AUTHOR;
+		else if (STREQN(record_type + 1, "nis", 3))
+			r.record_type = PDB_ANISOU;
+		else if (STREQN(record_type + 1, "grd", 3))
+			r.record_type = PDB_AGRDES;
+		else if (STREQN(record_type + 1, "ggr", 3))
+			r.record_type = PDB_AGGRGT;
+		break;
+
+	case 'c':
+		if (STREQN(record_type + 1, "omp", 3))
+			r.record_type = PDB_COMPND;
+		else if (STREQN(record_type + 1, "rys", 3))
+			r.record_type = PDB_CRYST1;
+		else if (STREQN(record_type + 1, "one", 3))
+			r.record_type = PDB_CONECT;
+		else if (STREQN(record_type + 1, "mpd", 3))
+			r.record_type = PDB_CMPDES;
+		else if (STREQN(record_type + 1, "mpo", 3))
+			r.record_type = PDB_CMPONT;
+		break;
+
+	case 'e':
+		if (STREQN(record_type + 1, "nd ", 3))
+			r.record_type = PDB_END;
+		else if (STREQN(record_type + 1, "ndm", 3))
+			r.record_type = PDB_ENDMDL;
+		else if (STREQN(record_type + 1, "xpd", 3))
+			r.record_type = PDB_EXPDTA;
+		break;
+
+	case 'f':
+		if (STREQN(record_type + 1, "tno", 3))
+			r.record_type = PDB_FTNOTE;
+		else if (STREQN(record_type + 1, "orm", 3))
+			r.record_type = PDB_FORMUL;
+		break;
+
+	case 'h':
+		if (STREQN(record_type + 1, "eta", 3))
+			r.record_type = PDB_HETATM;
+		else if (STREQN(record_type + 1, "ead", 3))
+			r.record_type = PDB_HEADER;
+		else if (STREQN(record_type + 1, "et ", 3))
+			r.record_type = PDB_HET;
+		else if (STREQN(record_type + 1, "eli", 3))
+			r.record_type = PDB_HELIX;
+		break;
+
+	case 'j':
+		if (STREQN(record_type + 1, "rnl", 3))
+			r.record_type = PDB_JRNL;
+		break;
+
+	case 'm':
+		if (STREQN(record_type + 1, "tri", 3))
+			r.record_type = PDB_MTRIX;
+		else if (STREQN(record_type + 1, "ast", 3))
+			r.record_type = PDB_MASTER;
+		else if (STREQN(record_type + 1, "ode", 3))
+			r.record_type = PDB_MODEL;
+		else if (STREQN(record_type + 1, "txd", 3))
+			r.record_type = PDB_MTXDES;
+		break;
+
+	case 'o':
+		if (STREQN(record_type + 1, "bsl", 3))
+			r.record_type = PDB_OBSLTE;
+		else if (STREQN(record_type + 1, "rig", 3))
+			r.record_type = PDB_ORIGX;
+		break;
+
+	case 'r':
+		if (STREQN(record_type + 1, "ema", 3))
+			r.record_type = PDB_REMARK;
+		else if (STREQN(record_type + 1, "evd", 3))
+			r.record_type = PDB_REVDAT;
+		break;
+
+	case 's':
+		switch (record_type[1]) {
+
+		case 'c':
+			if (STREQN(record_type + 2, "al", 2))
+				r.record_type = PDB_SCALE;
+			break;
+
+		case 'e':
+			if (STREQN(record_type + 2, "qr", 2))
+				r.record_type = PDB_SEQRES;
+			break;
+
+		case 'h':
+			if (STREQN(record_type + 2, "ee", 2))
+				r.record_type = PDB_SHEET;
+			break;
+
+		case 'i':
+			if (STREQN(record_type + 2, "te", 2))
+				r.record_type = PDB_SITE;
+			else if (STREQN(record_type + 2, "ga", 2))
+				r.record_type = PDB_SIGATM;
+			else if (STREQN(record_type + 2, "gu", 2))
+				r.record_type = PDB_SIGUIJ;
+			break;
+
+		case 'o':
+			if (STREQN(record_type + 2, "ur", 2))
+				r.record_type = PDB_SOURCE;
+			break;
+
+		case 'p':
+			if (STREQN(record_type + 2, "rs", 2))
+				r.record_type = PDB_SPRSDE;
+			break;
+
+		case 's':
+			if (STREQN(record_type + 2, "bo", 2))
+				r.record_type = PDB_SSBOND;
+			break;
+
+		case 'y':
+			if (STREQN(record_type + 2, "md", 2))
+				r.record_type = PDB_SYMDES;
+			else if (STREQN(record_type + 2, "mo", 2))
+				r.record_type = PDB_SYMOP;
+			break;
+		}
+		break;
+
+	case 't':
+		if (STREQN(record_type + 1, "urn", 3))
+			r.record_type = PDB_TURN;
+		else if (STREQN(record_type + 1, "vec", 3))
+			r.record_type = PDB_TVECT;
+		else if (STREQN(record_type + 1, "er ", 3))
+			r.record_type = PDB_TER;
+		else if (STREQN(record_type + 1, "rns", 3))
+			r.record_type = PDB_TRNSFM;
+		break;
+
+	case 'u':
+		if (STREQN(record_type + 1, "ser", 3)) {
+			r.record_type = PDB_USER;
+			switch (pdb_pdbrun_version) {
+			case 1: case 2: case 3: case 4: case 5:
+				r.record_type = pdbrun5_type(buffer + 6);
+				break;
+			case 6:
+				r.record_type = pdbrun6_type(buffer + 6);
+				break;
+			default:
+				if (strncasecmp(buffer + 6, "PDBRUN ", 7) == 0)
+					r.record_type = PDB_USER_PDBRUN;
+				break;
+			}
+		}
+		break;
+	}
+
+	if (r.record_type < PDB_USER_PDBRUN)
+		fmt = pdb_record_format[r.record_type];
+	else if (pdb_pdbrun_version < 6)
+		fmt = pdbrun5[r.record_type - PDB_USER_PDBRUN];
+	else
+		fmt = pdbrun6[r.record_type - PDB_USER_PDBRUN];
+	switch (r.record_type) {
+
+	default:
+	case PDB_UNKNOWN:
+unknown:
+		r.record_type = PDB_UNKNOWN;		/* in case of goto */
+		(void) pdb_sscanf(buffer, "%72s", r.pdb.unknown.junk);
+		break;
+
+	case PDB_AGGRGT:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.aggrgt.serial_num,
+				&r.pdb.aggrgt.num_components,
+				&r.pdb.aggrgt.cmpont_serial_nums[0],
+				&r.pdb.aggrgt.cmpont_serial_nums[1],
+				&r.pdb.aggrgt.cmpont_serial_nums[2],
+				&r.pdb.aggrgt.cmpont_serial_nums[3],
+				&r.pdb.aggrgt.cmpont_serial_nums[4],
+				&r.pdb.aggrgt.cmpont_serial_nums[5],
+				&r.pdb.aggrgt.cmpont_serial_nums[6],
+				&r.pdb.aggrgt.cmpont_serial_nums[7],
+				&r.pdb.aggrgt.cmpont_serial_nums[8],
+				&r.pdb.aggrgt.cmpont_serial_nums[9],
+				&r.pdb.aggrgt.cmpont_serial_nums[10],
+				&r.pdb.aggrgt.cmpont_serial_nums[11],
+				&r.pdb.aggrgt.cmpont_serial_nums[12],
+				&r.pdb.aggrgt.cmpont_serial_nums[13]))
+			goto unknown;
+		break;
+	case PDB_ANISOU:
+	case PDB_SIGUIJ:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.anisou.serial_num,
+				r.pdb.anisou.name, &r.pdb.anisou.alt_loc,
+				r.pdb.anisou.residue.name,
+				&r.pdb.anisou.residue.chain_id,
+				&r.pdb.anisou.residue.seq_num,
+				&r.pdb.anisou.residue.insert_code,
+				&r.pdb.anisou.u[0], &r.pdb.anisou.u[1],
+				&r.pdb.anisou.u[2], &r.pdb.anisou.u[3],
+				&r.pdb.anisou.u[4], &r.pdb.anisou.u[5]))
+			goto unknown;
+		break;
+
+	case PDB_ATOM:
+	case PDB_HETATM:
+	case PDB_SIGATM:
+		if (0 <= pdb_sscanf(buffer, fmt, &r.pdb.atom.serial_num,
+				r.pdb.atom.name, &r.pdb.atom.alt_loc,
+				r.pdb.atom.residue.name,
+				&r.pdb.atom.residue.chain_id,
+				&r.pdb.atom.residue.seq_num,
+				&r.pdb.atom.residue.insert_code,
+				&r.pdb.atom.x, &r.pdb.atom.y, &r.pdb.atom.z,
+				&r.pdb.atom.occupancy, &r.pdb.atom.temp_factor,
+				&r.pdb.atom.ftnote_num))
+			break;
+		/* handle atom serial number overflows */
+		if (strncmp(&buffer[6], "*****", 5) != 0)
+			goto unknown;
+		strncpy(new_buffer, buffer, PDB_BUFSIZ);
+		strncpy(&new_buffer[6], "00000", 5);
+		if (0 <= pdb_sscanf(new_buffer, fmt, &r.pdb.atom.serial_num,
+				r.pdb.atom.name, &r.pdb.atom.alt_loc,
+				r.pdb.atom.residue.name,
+				&r.pdb.atom.residue.chain_id,
+				&r.pdb.atom.residue.seq_num,
+				&r.pdb.atom.residue.insert_code,
+				&r.pdb.atom.x, &r.pdb.atom.y, &r.pdb.atom.z,
+				&r.pdb.atom.occupancy, &r.pdb.atom.temp_factor,
+				&r.pdb.atom.ftnote_num)) {
+			static int atom_serial_number = 10000;
+			r.pdb.atom.serial_num = atom_serial_number++;
+			break;
+		}
+		goto unknown;
+
+	case PDB_AUTHOR:
+	case PDB_COMPND:
+	case PDB_JRNL:
+	case PDB_SOURCE:
+	case PDB_EXPDTA:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.author.continuation,
+				r.pdb.author.data))
+			goto unknown;
+		break;
+
+	case PDB_CMPONT:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.cmpont.seq_num,
+				r.pdb.cmpont.residues[0].name,
+				&r.pdb.cmpont.residues[0].chain_id,
+				&r.pdb.cmpont.residues[0].seq_num,
+				&r.pdb.cmpont.residues[0].insert_code,
+				r.pdb.cmpont.residues[1].name,
+				&r.pdb.cmpont.residues[1].chain_id,
+				&r.pdb.cmpont.residues[1].seq_num,
+				&r.pdb.cmpont.residues[1].insert_code))
+			goto unknown;
+		break;
+
+	case PDB_CONECT:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.conect.serial_num,
+				&r.pdb.conect.covalent[0],
+				&r.pdb.conect.covalent[1],
+				&r.pdb.conect.covalent[2],
+				&r.pdb.conect.covalent[3],
+				&r.pdb.conect.bonds[0].hydrogen[0],
+				&r.pdb.conect.bonds[0].hydrogen[1],
+				&r.pdb.conect.bonds[0].salt,
+				&r.pdb.conect.bonds[1].hydrogen[0],
+				&r.pdb.conect.bonds[1].hydrogen[1],
+				&r.pdb.conect.bonds[1].salt))
+			goto unknown;
+		break;
+
+	case PDB_CRYST1:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.cryst1.a,
+				&r.pdb.cryst1.b, &r.pdb.cryst1.c,
+				&r.pdb.cryst1.alpha, &r.pdb.cryst1.beta,
+				&r.pdb.cryst1.gamma, r.pdb.cryst1.space_grp,
+				&r.pdb.cryst1.z))
+			goto unknown;
+		break;
+
+	case PDB_END:
+	case PDB_ENDMDL:
+		break;
+
+	case PDB_FORMUL:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.formul.component,
+				r.pdb.formul.het_id, &r.pdb.formul.continuation,
+				&r.pdb.formul.exclude, r.pdb.formul.formula))
+			goto unknown;
+		break;
+
+	case PDB_FTNOTE:
+	case PDB_REMARK:
+	case PDB_SYMDES:
+	case PDB_MTXDES:
+	case PDB_CMPDES:
+	case PDB_AGRDES:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.ftnote.num,
+				r.pdb.ftnote.text))
+			goto unknown;
+		break;
+
+	case PDB_HEADER:
+		if (0 > pdb_sscanf(buffer, fmt, r.pdb.header.class,
+				r.pdb.header.date, &r.pdb.header.type,
+				r.pdb.header.id))
+			goto unknown;
+		break;
+
+	case PDB_HELIX:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.helix.serial_num,
+				r.pdb.helix.id,
+				r.pdb.helix.residues[0].name,
+				&r.pdb.helix.residues[0].chain_id,
+				&r.pdb.helix.residues[0].seq_num,
+				&r.pdb.helix.residues[0].insert_code,
+				r.pdb.helix.residues[1].name,
+				&r.pdb.helix.residues[1].chain_id,
+				&r.pdb.helix.residues[1].seq_num,
+				&r.pdb.helix.residues[1].insert_code,
+				&r.pdb.helix.class, r.pdb.helix.comment))
+			goto unknown;
+		break;
+
+	case PDB_HET:
+		if (0 > pdb_sscanf(buffer, fmt, r.pdb.het.het_grp.name,
+				&r.pdb.het.het_grp.chain_id,
+				&r.pdb.het.het_grp.seq_num,
+				&r.pdb.het.het_grp.insert_code,
+				&r.pdb.het.num_atoms, r.pdb.het.text))
+			goto unknown;
+		break;
+
+	case PDB_MASTER:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.master.num_remark,
+				&r.pdb.master.num_ftnote,
+				&r.pdb.master.num_het, &r.pdb.master.num_helix,
+				&r.pdb.master.num_sheet, &r.pdb.master.num_turn,
+				&r.pdb.master.num_site,
+				&r.pdb.master.num_transform,
+				&r.pdb.master.num_coordinate,
+				&r.pdb.master.num_ter, &r.pdb.master.num_conect,
+				&r.pdb.master.num_seqres))
+			goto unknown;
+		break;
+
+	case PDB_MODEL:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.model.num))
+			goto unknown;
+		break;
+
+	case PDB_MTRIX:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.mtrix.row_num,
+				&r.pdb.mtrix.serial_num, &r.pdb.mtrix.m1,
+				&r.pdb.mtrix.m2, &r.pdb.mtrix.m3,
+				&r.pdb.mtrix.v, &r.pdb.mtrix.given))
+			goto unknown;
+		break;
+
+	case PDB_OBSLTE:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.obslte.continuation,
+				r.pdb.obslte.date, r.pdb.obslte.old_id,
+				r.pdb.obslte.id_map[0], r.pdb.obslte.id_map[1],
+				r.pdb.obslte.id_map[2], r.pdb.obslte.id_map[3],
+				r.pdb.obslte.id_map[4], r.pdb.obslte.id_map[2],
+				r.pdb.obslte.id_map[6], r.pdb.obslte.id_map[7]))
+			goto unknown;
+		break;
+
+	case PDB_ORIGX:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.origx.row_num,
+				&r.pdb.origx.o1, &r.pdb.origx.o2,
+				&r.pdb.origx.o3, &r.pdb.origx.t))
+			goto unknown;
+		break;
+
+	case PDB_REVDAT:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.revdat.modification,
+				&r.pdb.revdat.continuation, r.pdb.revdat.date,
+				r.pdb.revdat.id, &r.pdb.revdat.mod_type,
+				r.pdb.revdat.corrections))
+			goto unknown;
+		break;
+
+	case PDB_SCALE:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.scale.row_num,
+				&r.pdb.scale.s1, &r.pdb.scale.s2,
+				&r.pdb.scale.s3, &r.pdb.scale.u))
+			goto unknown;
+		break;
+
+	case PDB_SEQRES:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.seqres.serial_num,
+				&r.pdb.seqres.chain_id, &r.pdb.seqres.count,
+				r.pdb.seqres.names[0], r.pdb.seqres.names[1],
+				r.pdb.seqres.names[2], r.pdb.seqres.names[3],
+				r.pdb.seqres.names[4], r.pdb.seqres.names[5],
+				r.pdb.seqres.names[6], r.pdb.seqres.names[7],
+				r.pdb.seqres.names[8], r.pdb.seqres.names[9],
+				r.pdb.seqres.names[10], r.pdb.seqres.names[11],
+				r.pdb.seqres.names[12]))
+			goto unknown;
+		break;
+
+	case PDB_SHEET:
+		sh = &r.pdb.sheet;
+		sha0 = &sh->atoms[0].residue;
+		sha1 = &sh->atoms[1].residue;
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.sheet.strand_num,
+				sh->id, &r.pdb.sheet.count,
+				sh->residues[0].name, &sh->residues[0].chain_id,
+				&sh->residues[0].seq_num,
+				&sh->residues[0].insert_code,
+				sh->residues[1].name, &sh->residues[1].chain_id,
+				&sh->residues[1].seq_num,
+				&sh->residues[1].insert_code, &sh->sense,
+				sh->atoms[0].name, sha0->name, &sha0->chain_id,
+				&sha0->seq_num, &sha0->insert_code,
+				sh->atoms[1].name, sha1->name,
+				&sha1->chain_id, &sha1->seq_num,
+				&sha1->insert_code))
+			goto unknown;
+		break;
+
+	case PDB_SITE:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.site.seq_num,
+				r.pdb.site.id, &r.pdb.site.count,
+				r.pdb.site.residues[0].name,
+				&r.pdb.site.residues[0].chain_id,
+				&r.pdb.site.residues[0].seq_num,
+				&r.pdb.site.residues[0].insert_code,
+				r.pdb.site.residues[1].name,
+				&r.pdb.site.residues[1].chain_id,
+				&r.pdb.site.residues[1].seq_num,
+				&r.pdb.site.residues[1].insert_code,
+				r.pdb.site.residues[2].name,
+				&r.pdb.site.residues[2].chain_id,
+				&r.pdb.site.residues[2].seq_num,
+				&r.pdb.site.residues[2].insert_code,
+				r.pdb.site.residues[3].name,
+				&r.pdb.site.residues[3].chain_id,
+				&r.pdb.site.residues[3].seq_num,
+				&r.pdb.site.residues[3].insert_code))
+			goto unknown;
+		break;
+
+	case PDB_SPRSDE:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.sprsde.continuation,
+				r.pdb.sprsde.date, r.pdb.sprsde.id,
+				r.pdb.sprsde.supersede[0],
+				r.pdb.sprsde.supersede[1],
+				r.pdb.sprsde.supersede[2],
+				r.pdb.sprsde.supersede[3],
+				r.pdb.sprsde.supersede[4],
+				r.pdb.sprsde.supersede[5],
+				r.pdb.sprsde.supersede[6],
+				r.pdb.sprsde.supersede[7]))
+			goto unknown;
+		break;
+
+	case PDB_SSBOND:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.ssbond.seq_num,
+				r.pdb.ssbond.residues[0].name,
+				&r.pdb.ssbond.residues[0].chain_id,
+				&r.pdb.ssbond.residues[0].seq_num,
+				&r.pdb.ssbond.residues[0].insert_code,
+				r.pdb.ssbond.residues[1].name,
+				&r.pdb.ssbond.residues[1].chain_id,
+				&r.pdb.ssbond.residues[1].seq_num,
+				&r.pdb.ssbond.residues[1].insert_code,
+				r.pdb.ssbond.comment))
+			goto unknown;
+		break;
+
+	case PDB_SYMOP:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.symop.row_num,
+				&r.pdb.symop.serial_num, &r.pdb.symop.s1,
+				&r.pdb.symop.s2, &r.pdb.symop.s3,
+				&r.pdb.symop.t))
+			goto unknown;
+		break;
+
+	case PDB_TER:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.ter.serial_num,
+				r.pdb.ter.residue.name,
+				&r.pdb.ter.residue.chain_id,
+				&r.pdb.ter.residue.seq_num,
+				&r.pdb.ter.residue.insert_code))
+			goto unknown;
+		break;
+
+	case PDB_TRNSFM:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.trnsfm.result_serial_num,
+				&r.pdb.trnsfm.apply_serial_num,
+				&r.pdb.trnsfm.source_serial_num))
+			goto unknown;
+		break;
+
+	case PDB_TURN:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.turn.seq_num,
+				r.pdb.turn.id, r.pdb.turn.residues[0].name,
+				&r.pdb.turn.residues[0].chain_id,
+				&r.pdb.turn.residues[0].seq_num,
+				&r.pdb.turn.residues[0].insert_code,
+				r.pdb.turn.residues[1].name,
+				&r.pdb.turn.residues[1].chain_id,
+				&r.pdb.turn.residues[1].seq_num,
+				&r.pdb.turn.residues[1].insert_code,
+				r.pdb.turn.comment))
+			goto unknown;
+		break;
+
+	case PDB_TVECT:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.tvect.serial_num,
+				&r.pdb.tvect.t1, &r.pdb.tvect.t2,
+				&r.pdb.tvect.t3, r.pdb.tvect.comment))
+			goto unknown;
+		break;
+
+user:
+		r.record_type = PDB_USER;
+		fmt = pdb_record_format[r.record_type];
+	case PDB_USER:
+		if (0 > pdb_sscanf(buffer, fmt, r.pdb.user.subtype,
+				r.pdb.user.text))
+			goto unknown;
+		break;
+
+	case PDB_USER_PDBRUN:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_pdbrun.version))
+			goto user;
+		pdb_pdbrun_version = r.pdb.user_pdbrun.version;
+		break;
+
+	case PDB_USER_EYEPOS:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_eyepos.xyz[0],
+				&r.pdb.user_eyepos.xyz[1],
+				&r.pdb.user_eyepos.xyz[2]))
+			goto user;
+		break;
+
+	case PDB_USER_ATPOS:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_atpos.xyz[0],
+				&r.pdb.user_atpos.xyz[1],
+				&r.pdb.user_atpos.xyz[2]))
+			goto user;
+		break;
+
+	case PDB_USER_WINDOW:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_window.left,
+				&r.pdb.user_window.right,
+				&r.pdb.user_window.bottom,
+				&r.pdb.user_window.top,
+				&r.pdb.user_window.hither,
+				&r.pdb.user_window.yon))
+			goto user;
+		break;
+
+	case PDB_USER_FOCUS:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_focus.focus))
+			goto user;
+		break;
+
+	case PDB_USER_VIEWPORT:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_viewport.xmin,
+				&r.pdb.user_viewport.xmax,
+				&r.pdb.user_viewport.ymin,
+				&r.pdb.user_viewport.ymax))
+			goto user;
+		break;
+
+	case PDB_USER_BGCOLOR:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > sscanf(buffer, fmt, &r.pdb.user_bgcolor.rgb[0],
+					&r.pdb.user_bgcolor.rgb[1],
+					&r.pdb.user_bgcolor.rgb[2]))
+				goto user;
+		} else if (0 > pdb_sscanf(buffer, fmt,
+				&r.pdb.user_bgcolor.rgb[0],
+				&r.pdb.user_bgcolor.rgb[1],
+				&r.pdb.user_bgcolor.rgb[2]))
+			goto user;
+		break;
+
+	case PDB_USER_ANGLE:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_angle.which,
+					&r.pdb.user_angle.atom0,
+					&r.pdb.user_angle.atom1,
+					&r.pdb.user_angle.atom2,
+					&r.pdb.user_angle.atom3,
+					&r.pdb.user_angle.angle))
+				goto user;
+		} else if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_angle.atom0,
+				&r.pdb.user_angle.atom1,
+				&r.pdb.user_angle.atom2,
+				&r.pdb.user_angle.atom3,
+				&r.pdb.user_angle.angle))
+			goto user;
+		break;
+
+	case PDB_USER_DISTANCE:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > pdb_sscanf(buffer, fmt,
+					&r.pdb.user_distance.which,
+					&r.pdb.user_distance.atom0,
+					&r.pdb.user_distance.atom1,
+					&r.pdb.user_distance.distance))
+				goto user;
+		} else if (0 > pdb_sscanf(buffer, fmt,
+				&r.pdb.user_distance.atom0,
+				&r.pdb.user_distance.atom1,
+				&r.pdb.user_distance.distance))
+			goto user;
+		break;
+
+	case PDB_USER_FILE:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > pdb_sscanf(buffer, fmt,
+						r.pdb.user_file.filename))
+				goto user;
+		} else if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_file.model,
+						r.pdb.user_file.filename))
+			goto user;
+		break;
+
+	case PDB_USER_MARKNAME:
+		if (0 > pdb_sscanf(buffer, fmt, r.pdb.user_markname.markname))
+			goto user;
+		break;
+
+	case PDB_USER_MARK:
+		if (0 > pdb_sscanf(buffer, fmt, r.pdb.user_mark.markname))
+			goto user;
+		break;
+
+	case PDB_USER_CNAME:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > sscanf(buffer, fmt, r.pdb.user_cname.name,
+					&r.pdb.user_cname.rgb[0],
+					&r.pdb.user_cname.rgb[1],
+					&r.pdb.user_cname.rgb[2]))
+				goto user;
+		} else if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_cname.rgb[0],
+				&r.pdb.user_cname.rgb[1],
+				&r.pdb.user_cname.rgb[2],
+				r.pdb.user_cname.name))
+			goto user;
+		break;
+
+	case PDB_USER_COLOR:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > sscanf(buffer, fmt, r.pdb.user_color.spec,
+					&r.pdb.user_color.rgb[0],
+					&r.pdb.user_color.rgb[1],
+					&r.pdb.user_color.rgb[2]))
+				goto user;
+		} else if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_color.rgb[0],
+				&r.pdb.user_color.rgb[1],
+				&r.pdb.user_color.rgb[2],
+				r.pdb.user_color.spec))
+			goto user;
+		break;
+
+	case PDB_USER_RADIUS:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_radius.radius))
+			goto user;
+		break;
+
+	case PDB_USER_OBJECT:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > pdb_sscanf(buffer, fmt,
+					&r.pdb.user_object.model))
+				goto user;
+		}
+		break;
+
+	case PDB_USER_ENDOBJ:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > pdb_sscanf(buffer, fmt,
+					&r.pdb.user_endobj.model))
+				goto user;
+		}
+		break;
+
+	case PDB_USER_CHAIN:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > sscanf(buffer, fmt, &r.pdb.user_chain.atom0,
+					&r.pdb.user_chain.atom1))
+				goto user;
+		} else if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_chain.atom0,
+				&r.pdb.user_chain.atom1))
+			goto user;
+		break;
+
+	case PDB_USER_GFX_BEGIN:
+		if (0 > pdb_sscanf(buffer, fmt, r.pdb.user_gfx_begin.unknown))
+			goto user;
+		r.pdb.user_gfx_begin.primitive
+			= pdb_gfx_type(r.pdb.user_gfx_begin.unknown);
+		break;
+
+	case PDB_USER_GFX_END:
+		break;
+
+	case PDB_USER_GFX_COLOR:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > sscanf(buffer, fmt, r.pdb.user_gfx_color.spec,
+					&r.pdb.user_gfx_color.rgb[0],
+					&r.pdb.user_gfx_color.rgb[1],
+					&r.pdb.user_gfx_color.rgb[2]))
+				goto user;
+		} else if (0 > pdb_sscanf(buffer, fmt,
+				&r.pdb.user_gfx_color.rgb[0],
+				&r.pdb.user_gfx_color.rgb[1],
+				&r.pdb.user_gfx_color.rgb[2],
+				r.pdb.user_gfx_color.spec))
+			goto user;
+		break;
+
+	case PDB_USER_GFX_NORMAL:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_gfx_normal.xyz[0],
+				&r.pdb.user_gfx_normal.xyz[1],
+				&r.pdb.user_gfx_normal.xyz[2]))
+			goto user;
+		break;
+
+	case PDB_USER_GFX_VERTEX:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_gfx_vertex.xyz[0],
+				&r.pdb.user_gfx_vertex.xyz[1],
+				&r.pdb.user_gfx_vertex.xyz[2]))
+			goto user;
+		break;
+
+	case PDB_USER_GFX_FONT:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > sscanf(buffer, fmt, r.pdb.user_gfx_font.name,
+					&r.pdb.user_gfx_font.size))
+				goto user;
+		} else if (0 > pdb_sscanf(buffer, fmt,
+				&r.pdb.user_gfx_font.size,
+				r.pdb.user_gfx_font.name))
+			goto user;
+		break;
+
+	case PDB_USER_GFX_TEXTPOS:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_gfx_textpos.xyz[0],
+				&r.pdb.user_gfx_textpos.xyz[1],
+				&r.pdb.user_gfx_textpos.xyz[2]))
+			goto user;
+		break;
+
+	case PDB_USER_GFX_LABEL:
+		if (pdb_pdbrun_version < 6) {
+			if (0 > sscanf(buffer, fmt,
+					&r.pdb.user_gfx_label.xyz[0],
+					&r.pdb.user_gfx_label.xyz[1],
+					&r.pdb.user_gfx_label.xyz[2],
+					r.pdb.user_gfx_label.text))
+				goto user;
+		} else if (0 > pdb_sscanf(buffer, fmt,
+				r.pdb.user_gfx_label.text))
+			goto user;
+		/* TODO: process text? */
+		break;
+
+	case PDB_USER_GFX_MOVE:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_gfx_move.xyz[0],
+				&r.pdb.user_gfx_move.xyz[1],
+				&r.pdb.user_gfx_move.xyz[2]))
+			goto user;
+		break;
+
+	case PDB_USER_GFX_DRAW:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_gfx_draw.xyz[0],
+				&r.pdb.user_gfx_draw.xyz[1],
+				&r.pdb.user_gfx_draw.xyz[2]))
+			goto user;
+		break;
+
+	case PDB_USER_GFX_MARKER:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_gfx_marker.xyz[0],
+				&r.pdb.user_gfx_marker.xyz[1],
+				&r.pdb.user_gfx_marker.xyz[2]))
+			goto user;
+		break;
+
+	case PDB_USER_GFX_POINT:
+		if (0 > pdb_sscanf(buffer, fmt, &r.pdb.user_gfx_point.xyz[0],
+				&r.pdb.user_gfx_point.xyz[1],
+				&r.pdb.user_gfx_point.xyz[2]))
+			goto user;
+		break;
+	}
+	
+	return r;
+}
+
+# ifdef vms
+pdb_read_dummy()
+{
+	pdb_fmt_dummy();
+}
+# endif

dms/libpdb/pdb_sprntf.c

@@ -0,0 +1,511 @@
+/*
+ *	Copyright (c) 1989 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdb_sprntf.c,v 2.4 1994/04/15 22:34:24 gregc Exp $
+ */
+
+/* LINTLIBRARY */
+
+# include	<stdio.h>
+# include	<ctype.h>
+# include	<string.h>
+# ifdef __STDC__
+# include	<stdarg.h>
+# else
+# include	<varargs.h>
+# endif
+
+static char	scratch[BUFSIZ];
+
+# define	OVERFLOW_CHAR	'*'
+
+# ifdef __STDC__
+static char	*outint(int, int, int, char, char, int, char *, char);
+static char	*outunsigned(unsigned int, int, char, int, char *);
+static char	*outstr(char *, int, int, char, int, char *);
+static char	*outfloat(double, int, int, char, int, char *);
+static char	*outexp(double, int, int, char, int, char *);
+static char	*e_out(int, char *);
+# else
+static char	*outint(), *outunsigned(), *outstr(), *outfloat(), *outexp();
+static char	*e_out();
+# endif
+
+# ifdef __STDC__
+void
+pdb_sprintf(char *outbuf, const char *fmt, ...)
+# else
+/*VARARGS2*/
+void
+pdb_sprintf(outbuf, fmt, va_alist)
+char	*outbuf;
+char	*fmt;
+va_dcl
+# endif
+{
+	va_list		argv;
+	char		*p;
+	const char	*f;
+	int		field1, field2;
+	char		c, fill_char;
+	int		inum;
+	unsigned 	unum;
+	double		fnum;
+	int		left_justify;
+
+# ifdef __STDC__
+	va_start(argv, fmt);
+# else
+	va_start(argv);
+# endif
+	f = fmt;
+	p = outbuf;
+	while (*f) {
+		if (*f == '%') {
+			f++;
+			if (*f == '-')
+				left_justify = 1, f++;
+			else
+				left_justify = 0;
+
+			if (*f == '0')
+				fill_char = '0', f++;
+			else
+				fill_char = ' ';
+
+			if (isdigit(*f)) {
+				field1 = *f++ - '0';
+				while (isdigit(*f))
+					field1 = field1 * 10 + *f++ - '0';
+			}
+			else
+				field1 = -1;
+
+			if (*f == '.') {
+				f++;
+				field2 = 0;
+				while (isdigit(*f))
+					field2 = field2 * 10 + *f++ - '0';
+			}
+			else
+				field2 = -1;
+
+			if (*f == 'l' || *f == 'h')
+				f++;
+
+			while (isspace(*f))
+				f++;
+			switch (*f) {
+			  case 'c':
+				c = (char) va_arg(argv, int);
+				if (c == '\0')
+					c = ' ';
+				if (left_justify)
+					*p++ = c;
+				while (--field1 > 0)
+					*p++ = fill_char;
+				if (!left_justify)
+					*p++ = c;
+				break;
+			  case 'd':
+			  case 'D':
+				inum = va_arg(argv, int);
+				p = outint(inum, field1, 10, fill_char, 'a',
+					left_justify, p, (*f == 'D') ? ' ':'0');
+				break;
+			  case 'e':
+				fnum = va_arg(argv, double);
+				if (field2 < 0)
+					field2 = 6;
+				p = outexp(fnum, field1, field2, fill_char,
+					left_justify, p);
+				break;
+			  case 'f':
+				fnum = va_arg(argv, double);
+				if (field2 < 0)
+					field2 = 6;
+				p = outfloat(fnum, field1, field2, fill_char,
+					left_justify, p);
+				break;
+			  case 'o':
+				inum = va_arg(argv, int);
+				p = outint(inum, field1, 8, fill_char, 'a',
+					left_justify, p, '0');
+				break;
+			  case 's':
+				p = outstr(va_arg(argv, char *), field1, field2,
+					fill_char, left_justify, p);
+				break;
+			  case 'u':
+				unum = va_arg(argv, unsigned);
+				p = outunsigned(unum, field1, fill_char,
+					left_justify, p);
+				break;
+			  case 'x':
+				inum = va_arg(argv, int);
+				p = outint(inum, field1, 16, fill_char, 'a',
+					left_justify, p, '0');
+				break;
+			  case 'X':
+				inum = va_arg(argv, int);
+				p = outint(inum, field1, 16, fill_char, 'A',
+					left_justify, p, '0');
+				break;
+			  default:
+				if (left_justify)
+					*p++ = *f;
+				while (--field1 > 0)
+					*p++ = fill_char;
+				if (!left_justify)
+					*p++ = *f;
+				break;
+			}
+			f++;
+		}
+		else if (*f == '\\') {		/* Special character */
+			switch (*++f) {
+			  case 'n':
+				*p++ = '\n';
+				break;
+			  case 'r':
+				*p++ = '\r';
+				break;
+			  case 'b':
+				*p++ = '\b';
+				break;
+			  case 't':
+				*p++ = '\t';
+				break;
+			  case 'f':
+				*p++ = '\f';
+				break;
+			  case '0': case '1': case '2': case '3':
+			  case '4': case '5': case '6': case '7':
+				inum = *f++ - '0';
+				if (*f >= '0' && *f <= '7') {
+					inum = inum * 8 + *f++ - '0';
+					if (*f >= '0' && *f <= '7')
+						inum = inum * 8 + *f++ - '0';
+				}
+				f--;
+				*p++ = (char) inum;
+				break;
+			  default:
+				*p++ = *f;
+			}
+			f++;
+		}
+		else				/* Normal character */
+			*p++ = *f++;
+	}
+	*p = '\0';
+	va_end(argv);
+}
+
+static char *
+# ifdef __STDC__
+e_out(int width, char *where)
+# else
+e_out(width, where)
+	int	width;
+	char	*where;
+# endif
+{
+	while (width-- > 0)
+		*where++ = OVERFLOW_CHAR;
+	return where;
+}
+
+static char *
+# ifdef __STDC__
+outint(int value, int width, int radix, char fill_char, char hex,
+					int left_justify, char *p, char zero)
+# else
+outint(value, width, radix, fill_char, hex, left_justify, p, zero)
+	int	value, width;
+	int	radix;
+	char	fill_char;
+	char	hex;
+	int	left_justify;
+	char	*p;
+	char	zero;
+# endif
+{
+	char	*s;
+	int	n;
+	int	negative;
+
+	if (value < 0)
+		negative = 1, value = -value, width--;
+	else
+		negative = 0;
+	s = scratch;
+	if (value)
+		do {
+			n = value % radix;
+			*s++ = n < 10 ? '0' + n : hex + n - 10;
+			value /= radix;
+		} while (value);
+	else
+		*s++ = zero;
+	n = s - scratch;
+	if (width != -1 && n > width)
+		return e_out(width + negative, p);
+
+	if (negative && fill_char == '0')
+		*p++ = '-';
+	if (!left_justify)
+		while (width-- > n)
+			*p++ = fill_char;
+	if (negative && fill_char == ' ')
+		*p++ = '-';
+	while (--s >= scratch)
+		*p++ = *s;
+	if (left_justify)
+		while (width-- > n)
+			*p++ = fill_char;
+	return p;
+}
+
+static char *
+# ifdef __STDC__
+outunsigned(unsigned int value, int width, char fill_char, int left_justify,
+									char *p)
+# else
+outunsigned(value, width, fill_char, left_justify, p)
+	unsigned int	value;
+	int		width;
+	char		fill_char;
+	int		left_justify;
+	char		*p;
+# endif
+{
+	char	*s;
+	int	n;
+
+	s = scratch;
+	while (value) {
+		*s++ = value % 10 + '0';
+		value /= 10;
+	}
+	n = s - scratch;
+	if (n == 0)
+		*s++ = '0', n = 1;
+	if (width != -1 && n > width)
+		return e_out(width, p);
+
+	if (!left_justify)
+		while (width-- > n)
+			*p++ = fill_char;
+	while (--s >= scratch)
+		*p++ = *s;
+	if (left_justify)
+		while (width-- > n)
+			*p++ = fill_char;
+	return p;
+}
+
+static char *
+# ifdef __STDC__
+outstr(char *s, int width, int maxstr, char fill_char, int left_justify, char *p)
+# else
+outstr(s, width, maxstr, fill_char, left_justify, p)
+	char	*s;
+	int	width;
+	int	maxstr;
+	char	fill_char;
+	int	left_justify;
+	char	*p;
+# endif
+{
+	int	len;
+
+	len = strlen(s);
+	if (maxstr >= 0 && len > maxstr)
+		len = maxstr;
+	if (width != -1 && len > width)
+		return e_out(width, p);
+
+	if (!left_justify)
+		while (width-- > len)
+			*p++ = fill_char;
+	else
+		width -= len;
+	while (len--)
+		*p++ = *s++;
+	if (left_justify)
+		while (width-- > 0)
+			*p++ = fill_char;
+	return p;
+}
+
+static char *
+# ifdef __STDC__
+outfloat(double value, int width, int nplace, char fill_char, int left_justify,
+									char *p)
+# else
+outfloat(value, width, nplace, fill_char, left_justify, p)
+	double	value;
+	int	width, nplace;
+	char	fill_char;
+	int	left_justify;
+	char	*p;
+# endif
+{
+	int	i, intval;
+	char	*place, *to, *from;
+	int	negative;
+
+	negative = value < 0.0 ? 1 : 0;
+		
+	if (negative)
+		value = -value;
+
+	for (i = 0; i < nplace; i++)
+		value *= 10.0;
+
+	intval = value + 0.5;
+
+	if (width == -1)
+		width = nplace + 4;		/* TODO: fix */
+	else if (nplace + (nplace == 0 ? 1 : 2) > width)
+		return e_out(width, p);
+
+	for (place = p + width - 1; place >= p + width - nplace; place--) {
+		*place = '0' + intval % 10;
+		intval /= 10;
+	}
+
+	if (nplace > 0)
+		*place-- = '.';
+
+	if (intval == 0)
+		*place-- = '0';
+
+	for (; place >= p; place--) {
+		if (intval == 0)
+			break;
+		else {
+			*place = '0' + intval % 10;
+			intval /= 10;
+		}
+	}
+
+	if (intval != 0)
+		return e_out(width, p);
+
+	if (place < p && negative)
+		return e_out(width, p);
+
+	if (left_justify) {
+		for (from = place + 1, to = (negative ? p + 1 : p);
+						from < p + width; from++, to++)
+			*to = *from;
+		for (; to < p + width; to++)
+			*to = fill_char;
+		if (negative)
+			*p = '-';
+	} else {
+		for (to = place; to >= p; to--)
+			*to = fill_char;
+		if (negative)
+			if (fill_char == ' ')
+				*place = '-';
+			else
+				*p = '-';
+	}
+
+	return p + width;
+}
+
+static char *
+# ifdef __STDC__
+outexp(double value, int width, int nplace, char fill_char, int left_justify,
+									char *p)
+# else
+outexp(value, width, nplace, fill_char, left_justify, p)
+	double	value;
+	int	width, nplace;
+	char	*p;
+	char	fill_char;
+	int	left_justify;
+# endif
+{
+	int	n;
+	char	*s;
+	int	negative;
+	double	fraction;
+
+	if (value < 0)
+		negative = 1, value = -value, width--;
+	else
+		negative = 0;
+
+	n = 0;
+	while (value > 10)
+		n++, value /= 10;
+	if (value)
+		while (value < 1)
+			n--, value *= 10;
+
+	s = scratch;
+	if (n < 0) {
+		n = -n;
+		*s++ = n % 10 + '0';
+		*s++ = n / 10 + '0';
+		*s++ = '-';
+	}
+	else {
+		*s++ = n % 10 + '0';
+		*s++ = n / 10 + '0';
+		*s++ = '+';
+	}
+	*s = 'e';
+
+	s = scratch + nplace + 4;	/* 4 == strlen("e+00") */
+	fraction = value - (int) value;
+	for (n = 0; n < nplace; n++) {
+		fraction *= 10.0;
+		*--s = '0' + (int) fraction;
+		fraction -= (int) fraction;
+	}
+
+	s = scratch + nplace + 4;
+	if (nplace)
+		*s++ = '.';
+	n = (int) value;
+	if (n)
+		*s++ = n % 10 + '0';
+	else
+		*s++ = '0';
+	n = s - scratch;
+	if (width != -1 && n > width)
+		return e_out(width + negative, p);
+
+	if (negative && fill_char == '0')
+		*p++ = '-';
+	if (!left_justify)
+		while (width-- > n)
+			*p++ = fill_char;
+	if (negative && fill_char == ' ')
+		*p++ = '-';
+	while (--s >= scratch)
+		*p++ = *s;
+	if (left_justify)
+		while (width-- > n)
+			*p++ = fill_char;
+	return p;
+}

dms/libpdb/pdb_sscanf.c

@@ -0,0 +1,207 @@
+/*
+ *	Copyright (c) 1989 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdb_sscanf.c,v 2.8 1994/04/15 22:34:24 gregc Exp $
+ */
+
+/* LINTLIBRARY */
+
+# include	<stdio.h>
+# include	<ctype.h>
+# ifdef __STDC__
+# include	<stdarg.h>
+# include	<stdlib.h>
+# else
+# include	<varargs.h>
+
+extern int	atoi();
+extern double	atof();
+# endif
+
+/*
+ *	pdb_sscanf performs similarly to sscanf, execept that fields are of
+ *	fixed length and a complete line is always consumed.  The field
+ *	width defaults to one.  If the line is shorter than expected then
+ *	the default is returned.
+ *
+ *		d	get an integer.  Default:  0.
+ *		f	get a floating point number (C double).  Default:  0.0.
+ *		(space) ignore characters within field
+ *		s	get a C string, leading and trailing spaces are
+ *			stripped; the field width is used as a limit on
+ *			the string length, the null character is appended
+ *			to the end of the string.  Default:  empty string.
+ *		c	get a character(s); no stripping of spaces, nor is
+ *			a null character appended.  Default:  space(s).
+ */
+
+# define	MAXFIELDSIZE	64
+
+int
+# ifdef __STDC__
+pdb_sscanf(const char *buffer, const char *fmt, ...)
+# else
+/*VARARGS2*/
+pdb_sscanf(buffer, fmt, va_alist)
+	char	*buffer;
+	char	*fmt;
+	va_dcl
+# endif
+{
+	va_list	ap;
+	int	i, field_width;
+	int	nmatch;
+	char	*s, *t;
+	char	tmp[MAXFIELDSIZE];
+
+# ifdef __STDC__
+	va_start(ap, fmt);
+# else
+	va_start(ap);
+# endif
+	nmatch = 0;
+	for (; *fmt != '\0'; fmt++) {
+		if (*fmt != '%') {
+			if (*buffer == *fmt)
+				buffer++;
+			else if (*buffer != '\0' && *buffer != '\n')
+				return -1;
+			continue;
+		}
+
+		/* calculate field_width */
+		field_width = 0;
+		for (++fmt; isdigit(*fmt); fmt++)
+			field_width = field_width * 10 + *fmt - '0';
+		if (field_width == 0)
+			field_width = 1;	/* default */
+		if (*buffer != '\0' && *buffer != '\n')
+			nmatch++;
+
+		switch (*fmt) {
+
+		case 'd':			/* integer */
+			/* if we've already seen the end of the buffer, don't
+			   try to get anymore characters */
+			if (*buffer == '\0' || *buffer == '\n') {
+				*(va_arg(ap, int *)) = 0;
+				break;
+			}
+
+			s = tmp;
+			for (i = 0; i < field_width; i++) {
+				if (*buffer == '\0' || *buffer == '\n')
+					break;
+				*s++ = *buffer++;
+			}
+			*s = '\0';
+#ifndef __STDC__
+			*(va_arg(ap, int *)) = atoi(tmp);
+#else
+			/* remove trailing spaces */
+			while (s > tmp && isspace(*(s - 1)))
+				*--s = '\0';
+			*(va_arg(ap, int *)) = (int) strtol(tmp, &t, 10);
+			if (t != s)
+				return -1;
+#endif
+			break;
+
+		case 'f':			/* floating point */
+			/* if we've already seen the end of the buffer, don't
+			   try to get anymore characters */
+			if (*buffer == '\0' || *buffer == '\n') {
+				*(va_arg(ap, double *)) = 0.0;
+				break;
+			}
+
+			s = tmp;
+			for (i = 0; i < field_width; i++) {
+				if (*buffer == '\0' || *buffer == '\n')
+					break;
+				*s++ = *buffer++;
+			}
+			*s = '\0';
+#ifndef __STDC__
+			*(va_arg(ap, double *)) = atof(tmp);
+#else
+			/* remove trailing spaces */
+			while (s > tmp && isspace(*(s - 1)))
+				*--s = '\0';
+			*(va_arg(ap, double *)) = strtod(tmp, &t);
+			if (t != s)
+				return -1;
+#endif
+			break;
+
+		case 's':			/* string */
+			/* if we've already seen the end of the buffer, don't
+			   try to get anymore characters */
+			if (*buffer == '\0' || *buffer == '\n') {
+				*(va_arg(ap, char *)) = '\0';
+				break;
+			}
+
+			s = t = va_arg(ap, char *);
+			for (i = 0; i < field_width; i++) {
+				if (*buffer == '\0' || *buffer == '\n')
+					break;
+				*s++ = *buffer++;
+			}
+			*s = '\0';
+			/* remove trailing spaces */
+			while (s > t && isspace(*--s))
+				*s = '\0';
+			break;
+
+		case 'c':			/* character(s) */
+			s = va_arg(ap, char *);
+			for (i = 0; i < field_width; i++)
+				s[i] = ' ';	/* default */
+
+			/* if we've already seen the end of the buffer, don't
+			   try to get anymore characters */
+			if (*buffer == '\0' || *buffer == '\n')
+				break;
+
+			for (i = 0; i < field_width; i++) {
+				if (*buffer == '\0' || *buffer == '\n')
+					break;
+				*s++ = *buffer++;
+			}
+			break;
+
+		case ' ':			/* space (ignore) */
+			/* if we've already seen the end of the buffer, don't
+			   try to get anymore characters */
+			if (*buffer == '\0' || *buffer == '\n')
+				break;
+
+			for (i = 0; i < field_width; i++, buffer++)
+				if (*buffer == '\0' || *buffer == '\n')
+					break;
+			break;
+
+		default:
+			fprintf(stderr, "bad format '%c' in pdb_sscanf\n",
+									*fmt);
+			va_end(ap);
+			return -1;
+		}
+	}
+	va_end(ap);
+	return nmatch;
+}

dms/libpdb/pdb_write.c

@@ -0,0 +1,639 @@
+/*
+ *	Copyright (c) 1989 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdb_write.c,v 2.11 1995/01/20 01:20:36 gregc Exp $
+ *
+ *	subroutine for writing PDB format files
+ *
+ */
+
+/* LINTLIBRARY */
+
+# include	<stdio.h>
+# include	<ctype.h>
+# include	"pdb_int.h"
+
+static const char * const pdb_record_format[PDB_NUM_R] = {
+#include "write_format.i"
+};
+
+static char const * const pdbrun5[] = {
+#include "pdbrun5_write.i"
+};
+
+static char const * const pdbrun6[] = {
+#include "pdbrun6_write.i"
+};
+
+/*
+ *	for each pdb record type there is a format reading in the
+ *	record values and for printing them out.
+ *
+ *	The actual format of a line written, is the print format
+ *	followed by blank padding to 72 characters, followed by
+ *	8 characters of file and line information.
+ */
+
+void
+# ifdef __STDC__
+pdb_write_record(FILE *f, const pdb_record *r, const char *name, int line_num)
+# else
+pdb_write_record(f, r, name, line_num)
+	FILE		*f;
+	pdb_record	*r;
+	char		*name;		/* if NULL, don't print */
+	int		line_num;	/* if name == NULL, don't print */
+# endif
+{
+	char	buffer[PDB_BUFSIZ];
+
+	pdb_write_string(buffer, r);
+	if (name == NULL)
+		(void) fprintf(f, "%s\n", buffer);
+	else if (line_num >= 10000)
+		(void) fprintf(f, "%-72.72s%-4.4s%04d\n", buffer, name,
+							line_num % 10000);
+	else
+		(void) fprintf(f, "%-72.72s%-4.4s%4d\n", buffer, name,
+								line_num);
+}
+
+void
+# ifdef __STDC__
+pdb_write_string(char *buffer, const pdb_record *r)
+# else
+pdb_write_string(buffer, r)
+	char		*buffer;
+	pdb_record	*r;
+# endif
+{
+	const char		*fmt;
+	const struct pdb_sheet	*sh;
+	const pdb_residue	*shr0, *shr1, *sha0, *sha1;
+	char			*s, *t;
+
+	/* convert C structure to pdb record */
+
+
+	if (r->record_type < PDB_USER_PDBRUN)
+		fmt = pdb_record_format[r->record_type];
+	else if (pdb_pdbrun_version < 6)
+		fmt = pdbrun5[r->record_type - PDB_USER_PDBRUN];
+	else
+		fmt = pdbrun6[r->record_type - PDB_USER_PDBRUN];
+	switch (r->record_type) {
+
+	case PDB_UNKNOWN:
+		pdb_sprintf(buffer, fmt, r->pdb.unknown.junk);
+		break;
+
+	case PDB_AGGRGT:
+		pdb_sprintf(buffer, fmt, r->pdb.aggrgt.serial_num,
+			r->pdb.aggrgt.num_components,
+			r->pdb.aggrgt.cmpont_serial_nums[0],
+			r->pdb.aggrgt.cmpont_serial_nums[1],
+			r->pdb.aggrgt.cmpont_serial_nums[2],
+			r->pdb.aggrgt.cmpont_serial_nums[3],
+			r->pdb.aggrgt.cmpont_serial_nums[4],
+			r->pdb.aggrgt.cmpont_serial_nums[5],
+			r->pdb.aggrgt.cmpont_serial_nums[6],
+			r->pdb.aggrgt.cmpont_serial_nums[7],
+			r->pdb.aggrgt.cmpont_serial_nums[8],
+			r->pdb.aggrgt.cmpont_serial_nums[9],
+			r->pdb.aggrgt.cmpont_serial_nums[10],
+			r->pdb.aggrgt.cmpont_serial_nums[11],
+			r->pdb.aggrgt.cmpont_serial_nums[12],
+			r->pdb.aggrgt.cmpont_serial_nums[13]);
+		break;
+
+	case PDB_ANISOU:
+	case PDB_SIGUIJ:
+		pdb_sprintf(buffer, fmt, r->pdb.anisou.serial_num,
+			r->pdb.anisou.name, r->pdb.anisou.alt_loc,
+			r->pdb.anisou.residue.name,
+			r->pdb.anisou.residue.chain_id,
+			r->pdb.anisou.residue.seq_num,
+			r->pdb.anisou.residue.insert_code,
+			r->pdb.anisou.u[0], r->pdb.anisou.u[1],
+			r->pdb.anisou.u[2], r->pdb.anisou.u[3],
+			r->pdb.anisou.u[4], r->pdb.anisou.u[5]);
+		break;
+
+	case PDB_ATOM:
+	case PDB_HETATM:
+	case PDB_SIGATM:
+		pdb_sprintf(buffer, fmt, r->pdb.atom.serial_num,
+			r->pdb.atom.name, r->pdb.atom.alt_loc,
+			r->pdb.atom.residue.name,
+			r->pdb.atom.residue.chain_id,
+			r->pdb.atom.residue.seq_num,
+			r->pdb.atom.residue.insert_code,
+			r->pdb.atom.x, r->pdb.atom.y, r->pdb.atom.z,
+			r->pdb.atom.occupancy, r->pdb.atom.temp_factor,
+			r->pdb.atom.ftnote_num);
+		break;
+
+	case PDB_AUTHOR:
+	case PDB_COMPND:
+	case PDB_JRNL:
+	case PDB_SOURCE:
+	case PDB_EXPDTA:
+		pdb_sprintf(buffer, fmt, r->pdb.author.continuation,
+			r->pdb.author.data);
+		break;
+
+	case PDB_CONECT:
+		pdb_sprintf(buffer, fmt, r->pdb.conect.serial_num,
+			r->pdb.conect.covalent[0], r->pdb.conect.covalent[1],
+			r->pdb.conect.covalent[2], r->pdb.conect.covalent[3],
+			r->pdb.conect.bonds[0].hydrogen[0],
+			r->pdb.conect.bonds[0].hydrogen[1],
+			r->pdb.conect.bonds[0].salt,
+			r->pdb.conect.bonds[1].hydrogen[0],
+			r->pdb.conect.bonds[1].hydrogen[1],
+			r->pdb.conect.bonds[1].salt);
+		break;
+
+	case PDB_CMPONT:
+		pdb_sprintf(buffer, fmt, r->pdb.cmpont.seq_num,
+			r->pdb.cmpont.residues[0].name,
+			r->pdb.cmpont.residues[0].chain_id,
+			r->pdb.cmpont.residues[0].seq_num,
+			r->pdb.cmpont.residues[0].insert_code,
+			r->pdb.cmpont.residues[1].name,
+			r->pdb.cmpont.residues[1].chain_id,
+			r->pdb.cmpont.residues[1].seq_num,
+			r->pdb.cmpont.residues[1].insert_code);
+		break;
+
+	case PDB_CRYST1:
+		pdb_sprintf(buffer, fmt, r->pdb.cryst1.a, r->pdb.cryst1.b,
+			r->pdb.cryst1.c, r->pdb.cryst1.alpha,
+			r->pdb.cryst1.beta, r->pdb.cryst1.gamma,
+			r->pdb.cryst1.space_grp, r->pdb.cryst1.z);
+		break;
+
+	case PDB_END:
+	case PDB_ENDMDL:
+		pdb_sprintf(buffer, fmt);
+		break;
+
+	case PDB_FORMUL:
+		pdb_sprintf(buffer, fmt, r->pdb.formul.component,
+			r->pdb.formul.het_id, r->pdb.formul.continuation,
+			r->pdb.formul.exclude, r->pdb.formul.formula);
+		break;
+
+	case PDB_FTNOTE:
+	case PDB_REMARK:
+	case PDB_SYMDES:
+	case PDB_MTXDES:
+	case PDB_CMPDES:
+	case PDB_AGRDES:
+		pdb_sprintf(buffer, fmt, r->pdb.ftnote.num, r->pdb.ftnote.text);
+		break;
+
+	case PDB_HEADER:
+		pdb_sprintf(buffer, fmt, r->pdb.header.class,
+			r->pdb.header.date, r->pdb.header.type,
+			r->pdb.header.id);
+		break;
+
+	case PDB_HELIX:
+		pdb_sprintf(buffer, fmt, r->pdb.helix.serial_num,
+			r->pdb.helix.id,
+			r->pdb.helix.residues[0].name,
+			r->pdb.helix.residues[0].chain_id,
+			r->pdb.helix.residues[0].seq_num,
+			r->pdb.helix.residues[0].insert_code,
+			r->pdb.helix.residues[1].name,
+			r->pdb.helix.residues[1].chain_id,
+			r->pdb.helix.residues[1].seq_num,
+			r->pdb.helix.residues[1].insert_code,
+			r->pdb.helix.class, r->pdb.helix.comment);
+		break;
+
+	case PDB_HET:
+		pdb_sprintf(buffer, fmt, r->pdb.het.het_grp.name,
+			r->pdb.het.het_grp.chain_id, r->pdb.het.het_grp.seq_num,
+			r->pdb.het.het_grp.insert_code, r->pdb.het.num_atoms,
+			r->pdb.het.text);
+		break;
+
+	case PDB_MASTER:
+		pdb_sprintf(buffer, fmt, r->pdb.master.num_remark,
+			r->pdb.master.num_ftnote, r->pdb.master.num_het,
+			r->pdb.master.num_helix, r->pdb.master.num_sheet,
+			r->pdb.master.num_turn, r->pdb.master.num_site,
+			r->pdb.master.num_transform,
+			r->pdb.master.num_coordinate, r->pdb.master.num_ter,
+			r->pdb.master.num_conect, r->pdb.master.num_seqres);
+		break;
+
+	case PDB_MODEL:
+		pdb_sprintf(buffer, fmt, r->pdb.model.num);
+		break;
+
+	case PDB_MTRIX:
+		pdb_sprintf(buffer, fmt, r->pdb.mtrix.row_num,
+			r->pdb.mtrix.serial_num, r->pdb.mtrix.m1,
+			r->pdb.mtrix.m2, r->pdb.mtrix.m3, r->pdb.mtrix.v,
+			r->pdb.mtrix.given);
+		break;
+
+	case PDB_OBSLTE:
+		pdb_sprintf(buffer, fmt, r->pdb.obslte.continuation,
+			r->pdb.obslte.date, r->pdb.obslte.old_id,
+			r->pdb.obslte.id_map[0], r->pdb.obslte.id_map[1],
+			r->pdb.obslte.id_map[2], r->pdb.obslte.id_map[3],
+			r->pdb.obslte.id_map[4], r->pdb.obslte.id_map[2],
+			r->pdb.obslte.id_map[6], r->pdb.obslte.id_map[7]);
+		break;
+
+	case PDB_ORIGX:
+		pdb_sprintf(buffer, fmt, r->pdb.origx.row_num, r->pdb.origx.o1,
+			r->pdb.origx.o2, r->pdb.origx.o3, r->pdb.origx.t);
+		break;
+
+	case PDB_REVDAT:
+		pdb_sprintf(buffer, fmt, r->pdb.revdat.modification,
+			r->pdb.revdat.continuation, r->pdb.revdat.date,
+			r->pdb.revdat.id, r->pdb.revdat.mod_type,
+			r->pdb.revdat.corrections);
+		break;
+
+	case PDB_SCALE:
+		pdb_sprintf(buffer, fmt, r->pdb.scale.row_num, r->pdb.scale.s1,
+			r->pdb.scale.s2, r->pdb.scale.s3, r->pdb.scale.u);
+		break;
+
+	case PDB_SEQRES:
+		pdb_sprintf(buffer, fmt, r->pdb.seqres.serial_num,
+			r->pdb.seqres.chain_id, r->pdb.seqres.count,
+			r->pdb.seqres.names[0], r->pdb.seqres.names[1],
+			r->pdb.seqres.names[2], r->pdb.seqres.names[3],
+			r->pdb.seqres.names[4], r->pdb.seqres.names[5],
+			r->pdb.seqres.names[6], r->pdb.seqres.names[7],
+			r->pdb.seqres.names[8], r->pdb.seqres.names[9],
+			r->pdb.seqres.names[10], r->pdb.seqres.names[11],
+			r->pdb.seqres.names[12]);
+		break;
+
+	case PDB_SHEET:
+		sh = &r->pdb.sheet;
+		shr0 = &sh->residues[0];
+		shr1 = &sh->residues[1];
+		sha0 = &sh->atoms[0].residue;
+		sha1 = &sh->atoms[1].residue;
+		pdb_sprintf(buffer, fmt, sh->strand_num,
+			sh->id, sh->count,
+			shr0->name, shr0->chain_id, shr0->seq_num,
+			shr0->insert_code,
+			shr1->name, shr1->chain_id, shr1->seq_num,
+			shr1->insert_code,
+			sh->sense,
+			sh->atoms[0].name,
+			sha0->name, sha0->chain_id, sha0->seq_num,
+			sha0->insert_code,
+			sh->atoms[1].name,
+			sha1->name, sha1->chain_id, sha1->seq_num,
+			sha1->insert_code);
+		break;
+
+	case PDB_SITE:
+		shr0 = &r->pdb.site.residues[0];
+		shr1 = &r->pdb.site.residues[1];
+		sha0 = &r->pdb.site.residues[2];
+		sha1 = &r->pdb.site.residues[3];
+		pdb_sprintf(buffer, fmt, r->pdb.site.seq_num,
+			r->pdb.site.id, r->pdb.site.count,
+			shr0->name, shr0->chain_id, shr0->seq_num,
+			shr0->insert_code,
+			shr1->name, shr1->chain_id, shr1->seq_num,
+			shr1->insert_code,
+			sha0->name, sha0->chain_id, sha0->seq_num,
+			sha0->insert_code,
+			sha1->name, sha1->chain_id, sha1->seq_num,
+			sha1->insert_code);
+		break;
+
+	case PDB_SPRSDE:
+		pdb_sprintf(buffer, fmt, r->pdb.sprsde.continuation,
+			r->pdb.sprsde.date, r->pdb.sprsde.id,
+			r->pdb.sprsde.supersede[0], r->pdb.sprsde.supersede[1],
+			r->pdb.sprsde.supersede[2], r->pdb.sprsde.supersede[3],
+			r->pdb.sprsde.supersede[4], r->pdb.sprsde.supersede[5],
+			r->pdb.sprsde.supersede[6], r->pdb.sprsde.supersede[7]);
+		break;
+
+	case PDB_SSBOND:
+		pdb_sprintf(buffer, fmt, r->pdb.ssbond.seq_num,
+			r->pdb.ssbond.residues[0].name,
+			r->pdb.ssbond.residues[0].chain_id,
+			r->pdb.ssbond.residues[0].seq_num,
+			r->pdb.ssbond.residues[0].insert_code,
+			r->pdb.ssbond.residues[1].name,
+			r->pdb.ssbond.residues[1].chain_id,
+			r->pdb.ssbond.residues[1].seq_num,
+			r->pdb.ssbond.residues[1].insert_code,
+			r->pdb.ssbond.comment);
+		break;
+
+	case PDB_SYMOP:
+		pdb_sprintf(buffer, fmt, r->pdb.symop.row_num,
+			r->pdb.symop.serial_num, r->pdb.symop.s1,
+			r->pdb.symop.s2, r->pdb.symop.s3, r->pdb.symop.t);
+		break;
+
+	case PDB_TER:
+		pdb_sprintf(buffer, fmt, r->pdb.ter.serial_num,
+			r->pdb.ter.residue.name, r->pdb.ter.residue.chain_id,
+			r->pdb.ter.residue.seq_num,
+			r->pdb.ter.residue.insert_code);
+		break;
+
+	case PDB_TRNSFM:
+		pdb_sprintf(buffer, fmt, r->pdb.trnsfm.result_serial_num,
+			r->pdb.trnsfm.apply_serial_num,
+			r->pdb.trnsfm.source_serial_num);
+		break;
+
+	case PDB_TURN:
+		pdb_sprintf(buffer, fmt, r->pdb.turn.seq_num,
+			r->pdb.turn.id,
+			r->pdb.turn.residues[0].name,
+			r->pdb.turn.residues[0].chain_id,
+			r->pdb.turn.residues[0].seq_num,
+			r->pdb.turn.residues[0].insert_code,
+			r->pdb.turn.residues[1].name,
+			r->pdb.turn.residues[1].chain_id,
+			r->pdb.turn.residues[1].seq_num,
+			r->pdb.turn.residues[1].insert_code,
+			r->pdb.turn.comment);
+		break;
+
+	case PDB_TVECT:
+		pdb_sprintf(buffer, fmt, r->pdb.tvect.serial_num,
+			r->pdb.tvect.t1, r->pdb.tvect.t2, r->pdb.tvect.t3,
+			r->pdb.tvect.comment);
+		break;
+
+	case PDB_USER:
+		pdb_sprintf(buffer, fmt, r->pdb.user.subtype, r->pdb.user.text);
+		break;
+
+	case PDB_USER_PDBRUN:
+		pdb_sprintf(buffer, fmt, r->pdb.user_pdbrun.version);
+		pdb_pdbrun_version = r->pdb.user_pdbrun.version;
+		break;
+
+	case PDB_USER_EYEPOS:
+		pdb_sprintf(buffer, fmt, r->pdb.user_eyepos.xyz[0],
+			r->pdb.user_eyepos.xyz[1], r->pdb.user_eyepos.xyz[2]);
+		break;
+
+	case PDB_USER_ATPOS:
+		pdb_sprintf(buffer, fmt, r->pdb.user_atpos.xyz[0],
+			r->pdb.user_atpos.xyz[1], r->pdb.user_atpos.xyz[2]);
+		break;
+
+	case PDB_USER_WINDOW:
+		pdb_sprintf(buffer, fmt, r->pdb.user_window.left,
+			r->pdb.user_window.right, r->pdb.user_window.bottom,
+			r->pdb.user_window.top, r->pdb.user_window.hither,
+			r->pdb.user_window.yon);
+		break;
+
+	case PDB_USER_FOCUS:
+		pdb_sprintf(buffer, fmt, r->pdb.user_focus.focus);
+		break;
+
+	case PDB_USER_VIEWPORT:
+		pdb_sprintf(buffer, fmt, r->pdb.user_viewport.xmin,
+			r->pdb.user_viewport.xmax, r->pdb.user_viewport.ymin,
+			r->pdb.user_viewport.ymax);
+		break;
+
+	case PDB_USER_BGCOLOR:
+		if (pdb_pdbrun_version < 6)
+			sprintf(buffer, fmt, r->pdb.user_bgcolor.rgb[0],
+				r->pdb.user_bgcolor.rgb[1],
+				r->pdb.user_bgcolor.rgb[2]);
+		else
+			pdb_sprintf(buffer, fmt, r->pdb.user_bgcolor.rgb[0],
+				r->pdb.user_bgcolor.rgb[1],
+				r->pdb.user_bgcolor.rgb[2]);
+		break;
+
+	case PDB_USER_ANGLE:
+		if (pdb_pdbrun_version < 6)
+			pdb_sprintf(buffer, fmt, r->pdb.user_angle.which,
+				r->pdb.user_angle.atom0,
+				r->pdb.user_angle.atom1,
+				r->pdb.user_angle.atom2,
+				r->pdb.user_angle.atom3,
+				r->pdb.user_angle.angle);
+		else
+			pdb_sprintf(buffer, fmt, r->pdb.user_angle.atom0,
+				r->pdb.user_angle.atom1,
+				r->pdb.user_angle.atom2,
+				r->pdb.user_angle.atom3,
+				r->pdb.user_angle.angle);
+		break;
+
+	case PDB_USER_DISTANCE:
+		if (pdb_pdbrun_version < 6)
+			pdb_sprintf(buffer, fmt, r->pdb.user_distance.which,
+				r->pdb.user_distance.atom0,
+				r->pdb.user_distance.atom1,
+				r->pdb.user_distance.distance);
+		else
+			pdb_sprintf(buffer, fmt, r->pdb.user_distance.atom0,
+				r->pdb.user_distance.atom1,
+				r->pdb.user_distance.distance);
+		break;
+
+	case PDB_USER_FILE:
+		if (pdb_pdbrun_version < 6)
+			pdb_sprintf(buffer, fmt, r->pdb.user_file.filename);
+		else
+			pdb_sprintf(buffer, fmt, r->pdb.user_file.model,
+						r->pdb.user_file.filename);
+		break;
+
+	case PDB_USER_MARKNAME:
+		pdb_sprintf(buffer, fmt, r->pdb.user_markname.markname);
+		break;
+
+	case PDB_USER_MARK:
+		pdb_sprintf(buffer, fmt, r->pdb.user_mark.markname);
+		break;
+
+	case PDB_USER_CNAME:
+		if (pdb_pdbrun_version < 6)
+			sprintf(buffer, fmt, r->pdb.user_cname.name,
+				r->pdb.user_cname.rgb[0],
+				r->pdb.user_cname.rgb[1],
+				r->pdb.user_cname.rgb[2]);
+		else
+			pdb_sprintf(buffer, fmt, r->pdb.user_cname.rgb[0],
+				r->pdb.user_cname.rgb[1],
+				r->pdb.user_cname.rgb[2],
+				r->pdb.user_cname.name);
+		break;
+
+	case PDB_USER_COLOR:
+		if (pdb_pdbrun_version < 6)
+			sprintf(buffer, fmt, r->pdb.user_color.spec,
+				r->pdb.user_color.rgb[0],
+				r->pdb.user_color.rgb[1],
+				r->pdb.user_color.rgb[2]);
+		else
+			pdb_sprintf(buffer, fmt, r->pdb.user_color.rgb[0],
+				r->pdb.user_color.rgb[1],
+				r->pdb.user_color.rgb[2],
+				r->pdb.user_color.spec);
+		break;
+
+	case PDB_USER_RADIUS:
+		pdb_sprintf(buffer, fmt, r->pdb.user_radius.radius);
+		break;
+
+	case PDB_USER_OBJECT:
+		pdb_sprintf(buffer, fmt, r->pdb.user_object.model);
+		break;
+
+	case PDB_USER_ENDOBJ:
+		pdb_sprintf(buffer, fmt, r->pdb.user_endobj.model);
+		break;
+
+	case PDB_USER_CHAIN:
+		if (pdb_pdbrun_version < 6)
+			sprintf(buffer, fmt, r->pdb.user_chain.atom0,
+				r->pdb.user_chain.atom1);
+		else
+			pdb_sprintf(buffer, fmt, r->pdb.user_chain.atom0,
+				r->pdb.user_chain.atom1);
+		break;
+
+	case PDB_USER_GFX_BEGIN:
+		if (r->pdb.user_gfx_begin.primitive == PDB_GFX_UNKNOWN)
+			pdb_sprintf(buffer, fmt, r->pdb.user_gfx_begin.unknown);
+		else
+			pdb_sprintf(buffer, fmt, pdb_gfx_string(
+					r->pdb.user_gfx_begin.primitive));
+		break;
+
+	case PDB_USER_GFX_END:
+		pdb_sprintf(buffer, fmt);
+		break;
+
+	case PDB_USER_GFX_COLOR:
+		if (pdb_pdbrun_version < 6)
+			sprintf(buffer, fmt, r->pdb.user_gfx_color.spec,
+				r->pdb.user_gfx_color.rgb[0],
+				r->pdb.user_gfx_color.rgb[1],
+				r->pdb.user_gfx_color.rgb[2]);
+		else
+			pdb_sprintf(buffer, fmt, r->pdb.user_gfx_color.rgb[0],
+				r->pdb.user_gfx_color.rgb[1],
+				r->pdb.user_gfx_color.rgb[2],
+				r->pdb.user_gfx_color.spec);
+		break;
+
+	case PDB_USER_GFX_NORMAL:
+		pdb_sprintf(buffer, fmt, r->pdb.user_gfx_normal.xyz[0],
+			r->pdb.user_gfx_normal.xyz[1],
+			r->pdb.user_gfx_normal.xyz[2]);
+		break;
+
+	case PDB_USER_GFX_VERTEX:
+		pdb_sprintf(buffer, fmt, r->pdb.user_gfx_vertex.xyz[0],
+			r->pdb.user_gfx_vertex.xyz[1],
+			r->pdb.user_gfx_vertex.xyz[2]);
+		break;
+
+	case PDB_USER_GFX_FONT:
+		if (pdb_pdbrun_version < 6)
+			sprintf(buffer, fmt, r->pdb.user_gfx_font.name,
+				r->pdb.user_gfx_font.size);
+		else
+			pdb_sprintf(buffer, fmt, r->pdb.user_gfx_font.size,
+				r->pdb.user_gfx_font.name);
+		break;
+
+	case PDB_USER_GFX_TEXTPOS:
+		pdb_sprintf(buffer, fmt, r->pdb.user_gfx_textpos.xyz[0],
+			r->pdb.user_gfx_textpos.xyz[1],
+			r->pdb.user_gfx_textpos.xyz[2]);
+		break;
+
+	case PDB_USER_GFX_LABEL:
+		if (pdb_pdbrun_version < 6)
+			sprintf(buffer, fmt, r->pdb.user_gfx_label.xyz[0],
+				r->pdb.user_gfx_label.xyz[1],
+				r->pdb.user_gfx_label.xyz[2],
+				r->pdb.user_gfx_label.text);
+		else
+			pdb_sprintf(buffer, fmt, r->pdb.user_gfx_label.text);
+		break;
+
+	case PDB_USER_GFX_MOVE:
+		pdb_sprintf(buffer, fmt, r->pdb.user_gfx_move.xyz[0],
+			r->pdb.user_gfx_move.xyz[1],
+			r->pdb.user_gfx_move.xyz[2]);
+		break;
+
+	case PDB_USER_GFX_DRAW:
+		pdb_sprintf(buffer, fmt, r->pdb.user_gfx_draw.xyz[0],
+			r->pdb.user_gfx_draw.xyz[1],
+			r->pdb.user_gfx_draw.xyz[2]);
+		break;
+
+	case PDB_USER_GFX_MARKER:
+		pdb_sprintf(buffer, fmt, r->pdb.user_gfx_marker.xyz[0],
+			r->pdb.user_gfx_marker.xyz[1],
+			r->pdb.user_gfx_marker.xyz[2]);
+		break;
+
+	case PDB_USER_GFX_POINT:
+		pdb_sprintf(buffer, fmt, r->pdb.user_gfx_point.xyz[0],
+			r->pdb.user_gfx_point.xyz[1],
+			r->pdb.user_gfx_point.xyz[2]);
+		break;
+
+	default:
+		(void) sprintf(buffer, "unknown pdb record #%d",
+								r->record_type);
+		break;
+	}
+
+	/* find last non-blank in buffer, and shorten it */
+	t = NULL;
+	for (s = buffer; *s != '\0'; s++)
+		if (!isspace(*s))
+			t = s + 1;
+	if (t == NULL)		/* this should never happen, but ... */
+		t = buffer;
+	*t = '\0';
+}
+
+# ifdef vms
+pdb_write_dummy()
+{
+	pdb_fmt_dummy();
+}
+# endif

dms/libpdb/pdbrun.c

@@ -0,0 +1,99 @@
+/*
+ *	Copyright (c) 1994 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdbrun.c,v 1.4 1994/11/18 01:00:57 gregc Exp $
+ *
+ *	subroutine for reading PDB format files
+ *
+ */
+
+/* LINTLIBRARY */
+
+# include	"pdb_int.h"
+# include	<string.h>
+
+int	pdb_pdbrun_version = PDB_PDBRUN_VERSION;
+
+#ifdef __STDC__
+const char *
+pdb_gfx_string(int i)
+#else
+char *
+pdb_gfx_string(i)
+	int	i;
+#endif
+{
+	switch (i) {
+	default:			return "UNKNOWN";
+	case PDB_GFX_POINTS:		return "POINTS";
+	case PDB_GFX_MARKERS:		return "MARKERS";
+	case PDB_GFX_LINES:		return "LINES";
+	case PDB_GFX_LINE_STRIP:	return "LINE-STRIP";
+	case PDB_GFX_LINE_LOOP:		return "LINE-LOOP";
+	case PDB_GFX_TRIANGLES:		return "TRIANGLES";
+	case PDB_GFX_TRIANGLE_STRIP:	return "TRIANGLE-STRIP";
+	case PDB_GFX_TRIANGLE_FAN:	return "TRIANGLE-FAN";
+	case PDB_GFX_QUADS:		return "QUADS";
+	case PDB_GFX_QUAD_STRIP:	return "QUAD-STRIP";
+	case PDB_GFX_POLYGON:		return "POLYGON";
+	}
+}
+
+#ifdef __STDC__
+int
+pdb_gfx_type(const char *type)
+#else
+int
+pdb_gfx_type(type)
+	char	*type;
+#endif
+{
+	switch (type[0]) {
+	case 'L':
+		if (strcmp(type + 1, "INE-LOOP") == 0)
+			return PDB_GFX_LINE_LOOP;
+		if (strcmp(type + 1, "INE-STRIP") == 0)
+			return PDB_GFX_LINE_STRIP;
+		if (strcmp(type + 1, "INES") == 0)
+			return PDB_GFX_LINES;
+		break;
+	case 'M':
+		if (strcmp(type + 1, "ARKERS") == 0)
+			return PDB_GFX_MARKERS;
+		break;
+	case 'P':
+		if (strcmp(type + 1, "OINTS") == 0)
+			return PDB_GFX_POINTS;
+		if (strcmp(type + 1, "OLYGON") == 0)
+			return PDB_GFX_POLYGON;
+		break;
+	case 'Q':
+		if (strcmp(type + 1, "UAD-STRIP") == 0)
+			return PDB_GFX_QUAD_STRIP;
+		if (strcmp(type + 1, "UADS") == 0)
+			return PDB_GFX_QUADS;
+		break;
+	case 'T':
+		if (strcmp(type + 1, "RIANGLE-FAN") == 0)
+			return PDB_GFX_TRIANGLE_FAN;
+		if (strcmp(type + 1, "RIANGLE-STRIP") == 0)
+			return PDB_GFX_TRIANGLE_STRIP;
+		if (strcmp(type + 1, "RIANGLES") == 0)
+			return PDB_GFX_TRIANGLES;
+		break;
+	}
+	return PDB_GFX_UNKNOWN;
+}

dms/libpdb/pdbrun5_read.i

@@ -0,0 +1,48 @@
+/*
+ *	Copyright (c) 1994 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdbrun5_read.i,v 1.4 1994/11/16 22:09:29 gregc Exp $
+ */
+/* PDBRUN */	"%12  %2d",
+/* EYEPOS */	"%12  %9f %9f %9f",
+/* ATPOS */	"%11   %9f %9f %9f",
+/* WINDOW */	"%12  %9f %9f %9f %9f %9f %9f",
+/* FOCUS */	"%11  %9f",
+/* VIEWPORT */	"%14  %9f %9f %9f %9f",
+/* BGCOLOR */	"USER  BGCOLOR %lf %lf %lf",
+/* ANGLE */	"%11  %2d %6d %6d %6d %6d %8f",
+/* DISTANCE */	"%14  %2d %6d %6d %8f",
+/* FILE */	"%10  %61s",
+/* MARKNAME */	NULL,
+/* MARK */	NULL,
+/* CNAME */	"USER  CNAME %s %lf %lf %lf",
+/* COLOR */	"USER  COLOR %s %lf %lf %lf",
+/* RADIUS */	"%12  %7f",
+/* OBJECT */	"%12  %3d",
+/* ENDOBJ */	"%12  %3d",
+/* CHAIN */	"USER  CHAIN %d %d",
+/* GFX BEGIN */	NULL,
+/* GFX END */	NULL,
+/* GFX COLOR */	"USER  GFX COLOR %s %lf %lf %lf",
+/* GFX NORMAL */	NULL,
+/* GFX VERTEX */	NULL,
+/* GFX FONT */	"USER  GFX FONT %s %d",
+/* GFX TEXTPOS */	NULL,
+/* GFX LABEL */	"USER  GFX LABEL %lf %lf %lf %26[^\n]",
+/* GFX MOVE */	"%14  %9f %9f %9f",
+/* GFX DRAW */	"%14  %9f %9f %9f",
+/* GFX MARKER */	"%16  %9f %9f %9f",
+/* GFX POINT */	"%15  %9f %9f %9f",

dms/libpdb/pdbrun5_write.i

@@ -0,0 +1,48 @@
+/*
+ *	Copyright (c) 1994 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdbrun5_write.i,v 1.2 1994/11/16 22:09:29 gregc Exp $
+ */
+"USER  PDBRUN %2d",
+"USER  EYEPOS %9.3f %9.3f %9.3f",
+"USER  ATPOS  %9.3f %9.3f %9.3f",
+"USER  WINDOW %9.3f %9.3f %9.3f %9.3f %9.3f %9.3f",
+"USER  FOCUS %9.3f",
+"USER  VIEWPORT %9.3f %9.3f %9.3f %9.3f",
+"USER  BGCOLOR %.3f %.3f %.3f",
+"USER  ANGLE %2d %6d %6d %6d %6d %8.3f",
+"USER  DISTANCE %2d %6d %6d %8.3f",
+"USER  FILE %-61s",
+NULL,	/* USER  MARKNAME */
+NULL,	/* USER  MARK */
+"USER  CNAME %-.38s %.3f %.3f %.3f",
+"USER  COLOR %-.38s %5.3f %5.3f %5.3f",
+"USER  RADIUS %7.3f",
+"USER  OBJECT %3d",
+"USER  ENDOBJ %3d",
+"USER  CHAIN %d %d",
+NULL,	/* USER  GFX BEGIN */
+NULL,	/* USER  GFX END */
+"USER  GFX COLOR %-.38s %.3f %.3f %.3f",
+NULL,	/* USER  GFX NORMAL */
+NULL,	/* USER  GFX VERTEX */
+"USER  GFX FONT %-.53s %d",
+NULL,	/* USER  GFX TEXTPOS */
+"USER  GFX LABEL %9.3f %9.3f %9.3f \"%-.24s\"",
+"USER  GFX MOVE %9.3f %9.3f %9.3f",
+"USER  GFX DRAW %9.3f %9.3f %9.3f",
+"USER  GFX MARKER %9.3f %9.3f %9.3f",
+"USER  GFX POINT %9.3f %9.3f %9.3f",

dms/libpdb/pdbrun6_read.i

@@ -0,0 +1,48 @@
+/*
+ *	Copyright (c) 1994 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdbrun6_read.i,v 1.3 1995/01/20 01:20:36 gregc Exp $
+ */
+/* PDBRUN */	"%12  %2d",
+/* EYEPOS */	"%12  %9f %9f %9f",
+/* ATPOS */	"%11   %9f %9f %9f",
+/* WINDOW */	"%12  %9f %9f %9f %9f %9f %9f",
+/* FOCUS */	"%11   %9f",
+/* VIEWPORT */	"%14  %9f %9f %9f %9f",
+/* BGCOLOR */	"%13  %5f %5f %5f",
+/* ANGLE */	"%11  %6d %6d %6d %6d %9f",
+/* DISTANCE */	"%14  %6d %6d %9f",
+/* FILE */	"%10  %4d %56s",
+/* MARKNAME */	"%14  %57s",
+/* MARK */	"%10  %57s",
+/* CNAME */	"%11  %5f %5f %5f %38s",
+/* COLOR */	"%11  %5f %5f %5f %38s",
+/* RADIUS */	"%12  %7f",
+/* OBJECT */	"%12 ",
+/* ENDOBJ */	"%12 ",
+/* CHAIN */	"%11  %6d %6d",
+/* GFX BEGIN */	"%15  %32s",
+/* GFX END */	"%13 ",
+/* GFX COLOR */	"%15  %5f %5f %5f %38s",
+/* GFX NORMAL */	"%16  %9f %9f %9f",
+/* GFX VERTEX */	"%16  %9f %9f %9f",
+/* GFX FONT */	"%14  %3d %53s",
+/* GFX TEXTPOS */	"%17  %9f %9f %9f",
+/* GFX LABEL */	"%15  %56s",
+/* GFX MOVE */	NULL,
+/* GFX DRAW */	NULL,
+/* GFX MARKER */	NULL,
+/* GFX POINT */	NULL,

dms/libpdb/pdbrun6_write.i

@@ -0,0 +1,48 @@
+/*
+ *	Copyright (c) 1994 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: pdbrun6_write.i,v 1.3 1995/01/20 01:20:36 gregc Exp $
+ */
+"USER  PDBRUN %2d",
+"USER  EYEPOS %9.3f %9.3f %9.3f",
+"USER  ATPOS  %9.3f %9.3f %9.3f",
+"USER  WINDOW %9.3f %9.3f %9.3f %9.3f %9.3f %9.3f",
+"USER  FOCUS  %9.3f",
+"USER  VIEWPORT %9.3f %9.3f %9.3f %9.3f",
+"USER  BGCOLOR %5.3f %5.3f %5.3f",
+"USER  ANGLE %6d %6d %6d %6d %9.3f",
+"USER  DISTANCE %6d %6d %9.3f",
+"USER  FILE %4d %-56s",
+"USER  MARKNAME %-57s",
+"USER  MARK %-57s",
+"USER  CNAME %5.3f %5.3f %5.3f %-42s",
+"USER  COLOR %5.3f %5.3f %5.3f %-42s",
+"USER  RADIUS %7.3f",
+"USER  OBJECT",
+"USER  ENDOBJ",
+"USER  CHAIN %6d %6d",
+"USER  GFX BEGIN %-32s",
+"USER  GFX END",
+"USER  GFX COLOR %5.3f %5.3f %5.3f %s",
+"USER  GFX NORMAL %9.3f %9.3f %9.3f",
+"USER  GFX VERTEX %9.3f %9.3f %9.3f",
+"USER  GFX FONT %3d %-53s",
+"USER  GFX TEXTPOS %9.3f %9.3f %9.3f",
+"USER  GFX LABEL %-56s",
+NULL,	/* USER  GFX MOVE */
+NULL,	/* USER  GFX DRAW */
+NULL,	/* USER  GFX MARKER */
+NULL,	/* USER  GFX POINT */

dms/libpdb/read_format.i

@@ -0,0 +1,63 @@
+/*
+ *	Copyright (c) 1993 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: read_format.i,v 1.2 93/04/21 19:55:49 gregc Exp $
+ */
+/* UNKNOWN */	NULL,
+/* ANISOU */	"%6 %5d %4s%c%4s%c%4d%c %7d%7d%7d%7d%7d%7d",	/* SIGUIJ */
+/* ATOM */	"%6 %5d %4s%c%4s%c%4d%c   %8f%8f%8f%6f%6f %3d",	/* HETATM, SIGATM */
+/* AUTHOR */	"%9 %c%60s",		/* COMPND, EXPDTA, JRNL, SOURCE */
+/* COMPND */	"%9 %c%60s",			/* AUTHOR */
+/* CONECT */	"%6 %5d%5d%5d%5d%5d%5d%5d%5d%5d%5d%5d",
+/* CRYST1 */	"%6 %9f%9f%9f%7f%7f%7f %11s%4d",
+/* END */	NULL,
+/* FORMUL */	"%8 %2d  %4s%2d%c%51s",
+/* FTNOTE */	"%7 %3d %59s",	/*  REMARK, SYMDES, MTXDES, CMPDES, AGRDES */
+/* HEADER */	"%10 %40s%9s  %c%4s",
+/* HELIX */	"%7 %3d %3s %4s%c %4d%c %4s%c %4d%c%2d%30s",
+/* HET */	"%7 %4s %c%4d%c  %5d%5 %40s",
+/* HETATM */	"%6 %5d %4s%c%4s%c%4d%c   %8f%8f%8f%6f%6f %3d",	/* ATOM */
+/* JRNL */	"%9 %c%60s",			/* AUTHOR */
+/* MASTER */	"%10 %5d%5d%5d%5d%5d%5d%5d%5d%5d%5d%5d%5d",
+/* MTRIX */	"%5 %d %3d%10f%10f%10f%5 %10f   %2d",
+/* OBSLTE */	"%8 %2d %9s %4s%6 %4s %4s %4s %4s %4s %4s %4s %4s",
+/* ORIGX */	"%5 %d%4 %10f%10f%10f%5 %10f",	/* SCALE */
+/* REMARK */	"%7 %3d %59s",			/* FTNOTE */
+/* REVDAT */	"%7 %3d%2d %9s %7s %c%7 %31s",
+/* SCALE */	"%5 %d%4 %10f%10f%10f%5 %10f",
+/* SEQRES */	"%6 %4d %c %4d  %4s%4s%4s%4s%4s%4s%4s%4s%4s%4s%4s%4s%4s",
+/* SHEET */	"%6 %4d %3s%2d %4s%c%4d%c %4s%c%4d%c%2d %4s%4s%c%4d%c %4s%4s%c%4d%c",
+/* SIGATM */	"%6 %5d %4s%c%4s%c%4d%c   %8f%8f%8f%6f%6f %3d",	/* ATOM */
+/* SIGUIJ */	"%6 %5d %4s%c%4s%c%4d%c %7d%7d%7d%7d%7d%7d",	/* ANISOU */
+/* SITE */	"%7 %3d %3s %2d %4s%c%4d%c %4s%c%4d%c %4s%c%4d%c %4s%c%4d%c",
+/* SOURCE */	"%9 %c%60s",			/* AUTHOR */
+/* SPRSDE */	"%8 %2d %9s %4s%6 %4s %4s %4s %4s %4s %4s %4s %4s",
+/* SSBOND */	"%7 %3d %4s%c %4d%c   %4s%c %4d%c%4 %30s",
+/* TER */	"%6 %5d%6 %4s%c%4d%c",
+/* TURN */	"%7 %3d %3s %4s%c%4d%c %4s%c%4d%c%4 %30s",
+/* TVECT */	"%7 %3d%10f%10f%10f%30s",
+/* USER */	"%4 %2s%66s",
+/* MODEL */	"%9 %5d",
+/* ENDMDL */	NULL,
+/* EXPDTA */	"%9 %c%60s",			/* AUTHOR */
+/* SYMDES */	"%7 %3d %59s",			/* FTNOTE */
+/* SYMOP */	"%5 %d %3d%10f%10f%10f%5 %10f",
+/* MTXDES */	"%7 %3d %59s",			/* FTNOTE */
+/* CMPDES */	"%7 %3d %59s",			/* FTNOTE */
+/* CMPONT */	"%7 %3d %4s%c %4d%c %4s%c %4d%c",
+/* TRNSFM */	"%7 %3d %3d %3d",
+/* AGRDES */	"%7 %3d %59s",			/* FTNOTE */
+/* AGGRGT */	"%7 %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d",

dms/libpdb/write_format.i

@@ -0,0 +1,63 @@
+/*
+ *	Copyright (c) 1993 The Regents of the University of California.
+ *	All rights reserved.
+ *
+ *	Redistribution and use in source and binary forms are permitted
+ *	provided that the above copyright notice and this paragraph are
+ *	duplicated in all such forms and that any documentation,
+ *	advertising materials, and other materials related to such
+ *	distribution and use acknowledge that the software was developed
+ *	by the University of California, San Francisco.  The name of the
+ *	University may not be used to endorse or promote products derived
+ *	from this software without specific prior written permission.
+ *	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *	IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *	WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	$Id: write_format.i,v 1.3 93/06/24 11:53:47 gregc Exp $
+ */
+"UNKNOWN:  ??%-6.6s??",
+"ANISOU%5d %-4s%c%-4s%c%4d%c %7d%7d%7d%7d%7d%7d",	/* SIGUIJ */
+"ATOM  %5d %-4s%c%-4s%c%4d%c   %8.3f%8.3f%8.3f%6.2f%6.2f %3D", /* HETATM, SIGATM */
+"AUTHOR   %c%-60s",			/* COMPND, EXPDTA, JRNL, SOURCE */
+"COMPND   %c%-60s",					/* AUTHOR */
+"CONECT%5d%5D%5D%5D%5D%5D%5D%5D%5D%5D%5D",
+"CRYST1%9.3f%9.3f%9.3f%7.2f%7.2f%7.2f %-11s%4d",
+"END",
+"FORMUL  %2D  %-4s%2D%c%-51s",
+"FTNOTE %3D %-59s",					/* REMARK */
+"HEADER    %-40s%-11s%c%-4s",
+"HELIX  %3D %3s %-4s%c %4d%c %-4s%c %4d%c%2D%-30s",
+"HET    %-4s %c%4d%c  %5d     %-40s",
+"HETATM%5d %-4s%c%-4s%c%4d%c   %8.3f%8.3f%8.3f%6.2f%6.2f %3D",
+"JRNL     %c%-60s",					/* AUTHOR */
+"MASTER    %5d%5d%5d%5d%5d%5d%5d%5d%5d%5d%5d%5d",
+"MTRIX%1d %3d%10.6f%10.6f%10.6f     %10.5f   %2D",
+"OBSLTE  %2D %-9s %-10s%-5s%-5s%-5s%-5s%-5s%-5s%-5s%-4s",
+"ORIGX%1d    %10.6f%10.6f%10.6f     %10.5f",		/* SCALE */
+"REMARK %3D %-59s",
+"REVDAT %3D%2D %-9s %-7s %c       %-31s",
+"SCALE%1d    %10.6f%10.6f%10.6f     %10.5f",		/* ORIGX */
+"SEQRES%4d %c %4d  %-4s%-4s%-4s%-4s%-4s%-4s%-4s%-4s%-4s%-4s%-4s%-4s%-4s",
+"SHEET %4D %3s%2d %-4s%c%4d%c %-4s%c%4d%c%2d %-4s%-4s%c%4D%c %-4s%-4s%c%4D%c",
+"SIGATM%5d %-4s%c%-4s%c%4d%c   %8.3f%8.3f%8.3f%6.2f%6.2f %3D",
+"SIGUIJ%5d %-4s%c%-4s%c%4d%c %7D%7D%7D%7D%7D%7D",	/* ANISOU */
+"SITE   %3d %3s %2d %-4s%c%4D%c %-4s%c%4D%c %-4s%c%4D%c %-4s%c%4D%c",
+"SOURCE   %c%-60s",					/* AUTHOR */
+"SPRSDE  %2D %-9s %-10s%-5s%-5s%-5s%-5s%-5s%-5s%-5s%-4s",
+"SSBOND %3D %-4s%c %4d%c   %-4s%c %4D%c    %-30s",
+"TER   %5d      %-4s%c%4d%c",
+"TURN   %3D %3s %-4s%c%4d%c %-4s%c%4d%c    %-30s",
+"TVECT  %3D%10.5f%10.5f%10.5f%-30s",
+"USER%-2s%-66s",
+"MODEL    %5d",
+"ENDMDL",
+"EXPDTA   %c%-60s",					/* AUTHOR */
+"SYMDES %3d %59s",					/* FTNOTE */
+"SYMOP%1d %3d%10.6f%10.6f%10.6f     %10.5f",
+"MTXDES %3d %59s",					/* FTNOTE */
+"CMPDES %3d %59s",					/* FTNOTE */
+"CMPONT %3d %4s%c %4d%c %4s%c %4d%c",
+"TRNSFM %3d %3d %3d",
+"AGRDES %3d %59s",					/* FTNOTE */
+"AGGRGT %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d",

dms/ms.c

@@ -0,0 +1,302 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include "dms_param.h"
+#include "wanted.h"
+#include "atoms.h"
+
+#define	DEF_DENSITY	1.0		/* Default surface density */
+#define	MIN_DENSITY	0.1
+#define	MAX_DENSITY	10.0
+#define	DEF_PROBE	1.4		/* Default probe radius */
+#define	MIN_PROBE	1.0
+#define	MAX_PROBE	201.0
+
+#define	MODE_PDB	0
+#define	MODE_MIDAS	1
+#define	MODE_KRAUT	2
+
+#ifndef	TRUE
+#define	TRUE	1
+#define	FALSE	0
+#endif
+
+void usage(char *);
+
+/*
+ * MS:
+ *	Compute the solvent accessible surface of a molecule
+ *	as defined by Richards.
+ */
+main(ac, av)
+int	ac;
+char	**av;
+{
+	register int	c;
+	register ATOM	*ap;
+	int		input_mode;
+	int		aflg, nflg;
+	int		natom;
+	int		verbose;
+	int		fd;
+	int		any_wanted;
+	double		density, probe;
+	char		*in_file, *out_file;
+	FILE		*out_fp;
+	FILE		*wanted_fp;
+	WANTED		*wanted_list;
+	ATOM		*atom_list, **atom_array;
+	extern int	optind;
+	extern char	*optarg;
+	extern double	atof();
+	WANTED		*read_wanted();
+	ATOM		*read_pdb(), *read_midas(), *read_kraut();
+	ATOM		**make_array();
+
+	/*
+	 * Initialize variables to default values which may be
+	 * overridden by command line arguments
+	 */
+	verbose = FALSE;
+	aflg = FALSE;
+	nflg = FALSE;
+	density = DEF_DENSITY;
+	probe = DEF_PROBE;
+	input_mode = MODE_PDB;
+	out_fp = NULL;
+	wanted_fp = NULL;
+
+	/*
+	 * We process the arguments in a strange way because
+	 * we want to be backwards compatible with the old ms
+	 * program
+	 */
+	if (ac < 4) {
+		usage(av[0]);
+		exit(1);
+	}
+	in_file = av[1];
+	av[1] = av[0];
+	ac--;
+	av++;
+	while ((c = getopt(ac, av, "ad:e:g:i:kpmnr:w:o:v")) != EOF)
+		switch (c) {
+		  case 'a':
+			aflg = TRUE;
+			break;
+		  case 'd':
+			density = atof(optarg);
+			if (density < MIN_DENSITY || density > MAX_DENSITY) {
+				fprintf(stderr,
+				"Density must be between %.2f and %.2f\n",
+				MIN_DENSITY, MAX_DENSITY);
+				exit(1);
+			}
+			break;
+		  case 'g':
+			(void) fflush(stderr);
+			if ((fd = creat(optarg, 0666)) < 0) {
+				perror(optarg);
+				exit(1);
+			}
+			(void) dup2(fd, 2);
+			(void) close(fd);
+			break;
+		  case 'i':
+			if ((wanted_fp = fopen(optarg, "r")) == NULL) {
+				perror(optarg);
+				exit(1);
+			}
+			break;
+		  case 'p':
+			input_mode = MODE_PDB;
+			break;
+		  case 'w':
+			probe = atof(optarg);
+			if (probe < MIN_PROBE || probe > MAX_PROBE) {
+				fprintf(stderr,
+				"Probe size must be between %.2f and %.2f\n",
+				MIN_PROBE, MAX_PROBE);
+				exit(1);
+			}
+			break;
+		  case 'n':
+			nflg = TRUE;
+			break;
+		  case 'o':
+			if ((out_fp = fopen(optarg, "w")) == NULL) {
+				perror(optarg);
+				exit(1);
+			}
+			out_file = optarg;
+			break;
+		  case 'k':
+			input_mode = MODE_KRAUT;
+			break;
+		  case 'm':
+			input_mode = MODE_MIDAS;
+			break;
+		  case 'e':
+		  case 'r':
+			fprintf(stderr, "-%c is not implemented\n", c);
+			exit(1);
+		  case 'v':
+			verbose = TRUE;
+			break;
+		  default:
+			fprintf(stderr, "-%c is not recognized\n", c);
+			usage(av[0]);
+			exit(1);
+		}
+	if (out_fp == NULL) {
+		fprintf(stderr, "missing -o option\n");
+		usage(av[0]);
+		exit(1);
+	}
+#ifdef BSD
+	(void) setlinebuf(stderr);
+#endif
+
+	/*
+	 * Read in the atoms
+	 */
+	switch (input_mode) {
+	  case MODE_PDB:
+		atom_list = read_pdb(in_file, aflg);
+		break;
+	  case MODE_KRAUT:
+		atom_list = read_kraut(in_file, aflg);
+		break;
+	  case MODE_MIDAS:
+		atom_list = read_midas(in_file, aflg);
+		break;
+	}
+	if (atom_list == NULL) {
+		fprintf(stderr, "No atoms in input file!\n");
+		(void) fclose(out_fp);
+		(void) unlink(out_file);
+		exit(1);
+	}
+
+	/*
+	 * Read in the "ignore" file so we know what constraints
+	 * we have on input, and check them against atoms present
+	 */
+	wanted_list = read_wanted(wanted_fp);
+	if (wanted_fp != NULL)
+		(void) fclose(wanted_fp);
+
+	any_wanted = 0;
+	for (ap = atom_list; ap != NULL; ap = ap->next) {
+		ap->wanted = (wanted_list == NULL || wanted(ap, wanted_list));
+		if (ap->wanted)
+			any_wanted = 1;
+	}
+	if (any_wanted == 0) {
+		fprintf(stderr, "No atoms selected by site file.\n");
+		(void) fclose(out_fp);
+		(void) unlink(out_file);
+		exit(1);
+	}
+	atom_array = make_array(atom_list, &natom);
+	fprintf(stderr, "%d atoms\n", natom);
+
+	/*
+	 * Compute the surface
+	 */
+	compute_ms(atom_array, natom, probe, density, nflg, verbose);
+
+	/*
+	 * Output the surface in some appropriate format
+	 */
+	print_ms(out_fp, atom_list, nflg);
+	(void) fclose(out_fp);
+
+	/*
+	 * All done.  Clean up.
+	 */
+	exit(0);
+}
+
+/*
+ * usage:
+ *	Print a usage message and a description of each argument
+ */
+void usage(prog_name)
+char	*prog_name;
+{
+#if 0
+	fprintf(stderr, "Usage: %s input_file [-a] [-d density] [-e file] [-g file] [-i file] [-k] [-m] [-p] [-n] [-r b-e] [-w radius] -o file\n", prog_name);
+#else
+	fprintf(stderr, "Usage: %s input_file [-a] [-d density] [-g file] [-i file] [-n] [-w radius] [-v] -o file\n", prog_name);
+#endif
+	fputs("\t-a\tuse all atoms, not just amino acids\n", stderr);
+	fputs("\t-d\tchange density of points\n", stderr);
+	fputs("\t-g\tsend messages to file\n", stderr);
+	fputs("\t-i\tcalculate only surface for specified atoms\n", stderr);
+#if 0
+	fputs("\t-e\tcalculate only surface within ellipsoid\n", stderr);
+	fputs("\t-k\tinput file is in Kraut format\n", stderr);
+	fputs("\t-m\tinput file is in Midas format\n", stderr);
+	fputs("\t-p\tinput file is in Protein Data Bank format\n", stderr);
+	fputs("\t-r\tuse only specified residues\n", stderr);
+#endif
+	fputs("\t-n\tcalculate normals for surface points\n", stderr);
+	fputs("\t-w\tchange probe radius\n", stderr);
+	fputs("\t-v\tverbose\n", stderr);
+	fputs("\t-o\tspecify output file name (required)\n", stderr);
+}
+
+/*
+ * make_array:
+ *	Create an array which points at elements of a list
+ */
+ATOM **
+make_array(alist, nel)
+ATOM	*alist;
+int	*nel;
+{
+	register ATOM	*ap, **app, **aarray;
+	register int	n;
+	extern char	*emalloc();
+
+	n = 0;
+	for (ap = alist; ap != NULL; ap = ap->next)
+		n++;
+	aarray = (ATOM **) emalloc(n * sizeof (ATOM *));
+	app = aarray;
+	for (ap = alist; ap != NULL; ap = ap->next)
+		*app++ = ap;
+	*nel = n;
+	return aarray;
+}

dms/output.c

@@ -0,0 +1,207 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include <stdio.h>
+#include <math.h>
+#include "dms_param.h"
+#include "atoms.h"
+
+#ifdef BILD_OUTPUT
+#define	BYATOM	/* Color by atom ownership */
+#undef	BYTYPE	/* Color by type of surface */
+#endif
+#undef	CHECKPT	/* Make sure points are okay */
+
+static double	contact_area, reentrant_area;
+static int	contact_points, reentrant_points;
+
+void print_atom();
+
+/*
+ * print_ms:
+ *	Print surface data in some format
+ */
+void print_ms(fp, alist, have_normal)
+FILE	*fp;
+ATOM	*alist;
+int	have_normal;
+{
+	register ATOM	*ap;
+#ifdef BILD_OUTPUT
+	double		x, y, z;
+#endif
+
+#ifdef BILD_OUTPUT
+	x = y = z = 0;
+	for (ap = alist; ap != NULL; ap = ap->next) {
+		x += (*app)->coord[0];
+		y += (*app)->coord[1];
+		z += (*app)->coord[2];
+	}
+	fprintf(fp, ".tran %.3f %.3f %.3f\n",
+		-x / natom, -y / natom, -z / natom);
+#endif
+	for (ap = alist; ap != NULL; ap = ap->next)
+		print_atom(fp, ap, have_normal, alist);
+
+	/*
+	 * Report statistics
+	 */
+	fprintf(stderr, "%d points\t(%d contact, %d reentrant)\n",
+		contact_points + reentrant_points, contact_points,
+		reentrant_points);
+	fprintf(stderr, "%.2f sq. A\t(%.2f contact, %.2f reentrant)\n",
+		contact_area + reentrant_area, contact_area,
+		reentrant_area);
+	fprintf(stderr, "%.2f pts/sq.A\t(%.2f contact, %.2f reentrant)\n",
+		(contact_points + reentrant_points) /
+		(contact_area + reentrant_area),
+		contact_points / contact_area,
+		reentrant_area == 0 ? 0.0 : reentrant_points / reentrant_area);
+}
+
+#ifndef BILD_OUTPUT
+/* ARGSUSED */
+#endif
+/*
+ * print_atom:
+ *	Print the atom and its associated surface points
+ */
+void print_atom(fp, ap, have_normal, alist)
+FILE	*fp;
+ATOM	*ap;
+int	have_normal;
+ATOM	*alist;
+{
+	register SURFACE	*sp;
+	register POINT		*pp, *endpp;
+#ifndef BILD_OUTPUT
+	register char		*typep;
+	register POINT		*np;
+#else
+#ifdef BYATOM
+	static int		color = 1;
+#endif
+#endif
+
+#ifdef BILD_OUTPUT
+#ifdef BYATOM
+	fprintf(fp, ".color %d\n", color);
+	color = color % 7 + 1;
+#endif
+	fprintf(fp, ".cmov %.3f %.3f %.3f\n%s\n", ap->coord[0], ap->coord[1],
+		ap->coord[2], ap->atname);
+#else
+	fprintf(fp, "%3s %4s %4.4s%8.3f %8.3f %8.3f A\n", ap->restype,
+		ap->resseq, ap->atname, ap->coord[0], ap->coord[1],
+		ap->coord[2]);
+#endif
+	if (!ap->wanted)
+		return;
+	for (sp = ap->surface; sp != NULL; sp = sp->next) {
+		if (sp->type == CONTACT) {
+			contact_points += sp->npoint;
+			contact_area += sp->npoint * sp->area;
+		}
+		else {
+			reentrant_points += sp->npoint;
+			reentrant_area += sp->npoint * sp->area;
+		}
+#ifndef BILD_OUTPUT
+		switch (sp->type) {
+		  case CONTACT:
+			typep = "SC0";
+			break;
+		  case TREENTRANT:
+			typep = "SS0";
+			break;
+		  case SREENTRANT:
+			typep = "SR0";
+			break;
+		}
+		np = sp->normal;
+#else
+#ifdef BYTYPE
+		fprintf(fp, ".color %d\n", sp->type + 1);
+#endif
+#endif
+		endpp = sp->position + sp->npoint;
+		for (pp = sp->position; pp < endpp; pp++) {
+#ifdef CHECKPT
+			verify_point(pp, alist);
+#endif
+#ifdef BILD_OUTPUT
+			fprintf(fp, ".dot %.3f %.3f %.3f\n", pp->coord[0],
+				pp->coord[1], pp->coord[2]);
+#else
+			fprintf(fp, "%3s %4s %4.4s%8.3f %8.3f %8.3f %3s %6.3f",
+				ap->restype, ap->resseq, ap->atname,
+				pp->coord[0], pp->coord[1], pp->coord[2],
+				typep, sp->area);
+			if (have_normal) {
+				fprintf(fp, " %6.3f %6.3f %6.3f", np->coord[0],
+					np->coord[1], np->coord[2]);
+				np++;
+			}
+			(void) putc('\n', fp);
+#endif
+		}
+	}
+}
+
+#ifdef CHECKPT
+/*
+ * verify_point:
+ *	Verify that the point is not inside any atom
+ */
+verify_point(pp, alist)
+register POINT	*pp;
+ATOM		*alist;
+{
+	register ATOM	*ap;
+	register int	i;
+	double		delta, distsq;
+
+	for (ap = alist; ap != NULL; ap = ap->next) {
+		distsq = 0;
+		for (i = 0; i < 3; i++) {
+			delta = ap->coord[i] - pp->coord[i];
+			distsq += delta * delta;
+		}
+		if (distsq + 0.1 < ap->radius * ap->radius) {
+			fprintf(stderr, "Point too close to %s@%s\n",
+				ap->atname, ap->resseq);
+			break;
+		}
+	}
+}
+#endif

dms/protocol.h

@@ -0,0 +1,58 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#define	PI_COMMAND	"paramdata radius %lf, density %lf, wantnormal %d\n"
+#define	PI_RESPONSE	"received paramdata\n"
+
+#define	AI_COMMAND	"atomdata %d\n"
+#define	AI_RESPONSE	"received atomdata\n"
+
+#define	NI_COMMAND	"neighbordata %d\n"
+#define	NI_RESPONSE	"received neighbordata\n"
+
+#define	PRI_COMMAND	"probedata %d\n"
+#define	PRI_RESPONSE	"received probedata\n"
+
+#define	C_COMMAND	"contacts %d\n"
+#define	C_RESPONSE	"contactdata atom %d, %d neighbors\n"
+
+#define	P_COMMAND	"probes %d %d\n"
+#define	P_BADNB		"badneighbor %d %d\n"
+#define	P_RESPONSE	"probedata %d probes\n"
+
+#define	CS_COMMAND	"csurface %d\n"
+#define	TS_COMMAND	"tsurface %d %d\n"
+#define	PS_COMMAND	"psurface %d\n"
+
+#define	SURFACE_END	"surfacedata end\n"
+#define	SURFACE_RESPONSE \
+	"surfacedata atom %d, %d points, type %d, area %lf, havenormal %d\n"

dms/radii.proto

@@ -0,0 +1,30 @@
+# This file contains the atom radii used by dms.
+# The radii appears one per line, atom type followed by atom radius.
+# Note that the more specific the type (i.e. contains more characters)
+# the further down the list it appears.  This is VERY important
+# The default line is not required.  If it is not present, then dms
+# will quit when it encounters an atom of unknown type, otherwise
+# it will use the default radius.
+H	1.20
+D	1.20
+C	1.90
+N	1.50
+O	1.40
+F	1.35
+P	1.90
+S	1.85
+I	2.15
+CL	1.80
+FE	0.64
+CU	1.28
+ZN	1.38
+BR	1.95
+1H	1.20
+2H	1.20
+3H	1.20
+4H	1.20
+1D	1.20
+2D	1.20
+3D	1.20
+4D	1.20
+default	1.90

dms/tokenize.c

@@ -0,0 +1,124 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#include	<stdio.h>
+#include	<ctype.h>
+
+/*
+ * tokenize:
+ *	Break string into array of words at spaces, keeping strings
+ *	intact and recognizing backslash escapes, returning number
+ *	of words found or -1 if more than n found or -2 if non-printable
+ *	character encountered or -3 if mismatched quotes.
+ */
+int
+tokenize(string, array, n)
+char	*string,	/* string to be tokenized */
+	*array[];	/* returned array of pointers to tokens in string */
+int	n;		/* maximum number of tokens to look for */
+{
+	register int	i;
+
+	for (i = 0; i < n; i++) {
+		while (isspace(*string))
+			string++;
+		if (*string == '"') {
+			*array++ = ++string;
+			while (isprint(*string) && *string != '"') {
+				if (*string == '\\') { /* backslash escapes */
+					strcpy(string, string+1);
+					switch (*string) {
+					  case 't': /* tab */
+						*string = '\t';
+						break;
+					  case 'b': /* backspace */
+						*string = '\b';
+						break;
+					  case 'n': /* newline */
+						*string = '\n';
+						break;
+					  case 'r': /* carriage return */
+						*string = '\r';
+						break;
+					  case 'f': /* formfeed */
+						*string = '\f';
+						break;
+					  default: /* treat as normal */
+						break;
+					}
+				}
+				string++;
+			}
+			if (*string == '\0')
+				return -3;
+			if (!isprint(*string))
+				return -2;
+			*string++ = '\0';
+			continue;
+		}
+		*array++ = string;
+		if (*string == '\0')
+			break;
+		if (!isprint(*string))
+			return -2;
+		while (!isspace(*string) && isprint(*string)) {
+			if (*string == '\\') { /* backslash escapes */
+				strcpy(string, string+1);
+				switch (*string) {
+				  case 't': /* tab */
+					*string = '\t';
+					break;
+				  case 'b': /* backspace */
+					*string = '\b';
+					break;
+				  case 'n': /* newline */
+					*string = '\n';
+					break;
+				  case 'r': /* carriage return */
+					*string = '\r';
+					break;
+				  case 'f': /* formfeed */
+					*string = '\f';
+					break;
+				  default: /* treat as normal */
+					break;
+				}
+			}
+			string++;
+		}
+		if (isspace(*string))
+			*string++ = '\0';
+	}
+	while (isspace(*string))
+		string++;
+	return *string == '\0' ? i : -1;
+}

dms/wanted.h

@@ -0,0 +1,54 @@
+/*
+
+Copyright (c) <2002> The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions, and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions, and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+  3. Redistributions must acknowledge that this software was
+     originally developed by the UCSF Computer Graphics Laboratory
+     under support by the NIH National Center for Research Resources,
+     grant P41-RR01081.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#ifndef	__WANTED__
+#define	__WANTED__
+
+#include "atoms.h"
+
+#define	W_RANGE	0
+#define	W_ANY	1
+#define	W_ATOM	2
+
+typedef	struct wanted_def	{
+	struct wanted_def	*next;
+	int			type;
+	int			startres;
+	union {
+		int		endres;
+		char		atom[AN_LEN];
+	}			w;
+}	WANTED;
+
+extern int	wanted(ATOM *ap, WANTED *wlist);
+
+#endif