src/rt/devmain.c

/* Copyright (c) 1989 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  devmain.c - main for independent drivers.
 *
 *      Redefine your initialization routine to dinit.
 *
 *      10/25/89
 */

#include <stdio.h>

#include <signal.h>

#include "color.h"

#include "driver.h"

int     (*wrnvec)(), (*errvec)(), (*cmdvec)();  /* error vectors, unused */

long    nrays = 0;                              /* fake it */

struct driver   *dev = NULL;                    /* output device */

FILE    *devin, *devout;                        /* communications channels */

int     notified = 0;                           /* notified parent of input? */

char    *progname;                              /* driver name */

int     r_clear(), r_paintr(), r_getcur(), r_comout(), r_comin(), r_mycomin();

int     (*dev_func[NREQUESTS])() = {            /* request handlers */
                r_clear, r_paintr,
                r_getcur, r_comout, r_comin
        };

char    mybuf[512] = "";

char    *mybufp();


main(argc, argv)                /* set up communications and main loop */
int     argc;
char    *argv[];
{
        extern struct driver    *dinit();
        int  com;
                                                /* set up I/O */
        progname = argv[0];
        if (argc < 3) {
                stderr_v("arg count\n");
                quit(1);
        }
        devin = fdopen(atoi(argv[1]), "r");
        devout = fdopen(atoi(argv[2]), "w");
        if (devin == NULL || devout == NULL || getw(devin) != COM_SENDM) {
                stderr_v("connection failure\n");
                quit(1);
        }
                                                /* open device */
        if ((dev = dinit(argv[0], argv[3])) == NULL)
                quit(1);
        putw(COM_RECVM, devout);                /* verify initialization */
        putw(dev->xsiz, devout);
        putw(dev->ysiz, devout);
        fflush(devout);
                                                /* loop on requests */
        while ((com = getc(devin)) != EOF) {
                if (com >= NREQUESTS || dev_func[com] == NULL) {
                        stderr_v("invalid request\n");
                        quit(1);
                }
                (*dev_func[com])();             /* process request */
        }
        quit(0);                        /* all done, clean up and exit */
}


quit(code)                              /* close device and exit */
int     code;
{
        if (dev != NULL)
                (*dev->close)();
        exit(code);
}


r_clear()                               /* clear screen */
{
        int     xres, yres;

        xres = getw(devin);
        yres = getw(devin);
        (*dev->clear)(xres, yres);
}


r_paintr()                              /* paint a rectangle */
{
        COLOR   col;
        int     xmin, ymin, xmax, ymax;

        nrays += 5;                     /* pretend */
        fread(col, sizeof(COLOR), 1, devin);
        xmin = getw(devin); ymin = getw(devin);
        xmax = getw(devin); ymax = getw(devin);
        (*dev->paintr)(col, xmin, ymin, xmax, ymax);
                                        /* check for input */
        if (!notified && dev->inpready > 0) {
                notified = 1;
                kill(getppid(), SIGIO);
        }
}


r_getcur()                              /* get and return cursor position */
{
        int     c;
        int     x, y;
                                        /* get it if we can */
        if (dev->getcur == NULL) {
                c = ABORT;
                x = y = 0;
        } else
                c = (*dev->getcur)(&x, &y);
                                        /* reply */
        putc(COM_GETCUR, devout);
        putc(c, devout);
        putw(x, devout);
        putw(y, devout);
        fflush(devout);
}


r_comout()                              /* print string to command line */
{
        char    str[256];

        mygets(str, devin);
        (*dev->comout)(str);
}


r_comin()                               /* read string from command line */
{
        char    buf[256];
                                        /* get string */
        (*dev->comin)(buf);
                                        /* reply */
        putc(COM_COMIN, devout);
        myputs(buf, devout);
        fflush(devout);
                                        /* reset notify */
        notified = 0;
}


mygets(s, fp)                           /* get string from file (with nul) */
register char   *s;
register FILE   *fp;
{
        register int    c;

        while ((c = getc(fp)) != EOF)
                if ((*s++ = c) == '\0')
                        return;
        *s = '\0';
}


myputs(s, fp)                           /* put string to file (with nul) */
register char   *s;
register FILE   *fp;
{
        do
                putc(*s, fp);
        while (*s++);
}


r_mycomin()                             /* get command from my buffer */
{
        register char   *cp;
                                                /* get next command */
        for (cp = mybuf; *cp != '\n'; cp++)
                ;
        *cp++ = '\0';
        (*dev->comout)(mybuf);                  /* echo my command */
                                                /* send it as reply */
        putc(COM_COMIN, devout);
        myputs(mybuf, devout);
        fflush(devout);
                                                /* get next command */
        (*dev->comout)("\n");
        strcpy(mybuf, cp);
        if (mybuf[0])
                kill(getppid(), SIGIO);                 /* signal more */
        else
                dev_func[COM_COMIN] = r_comin;          /* else reset */
}


stderr_v(s)                             /* put string to stderr */
register char  *s;
{
        static int  inline = 0;

        if (!inline++) {
                fputs(progname, stderr);
                fputs(": ", stderr);
        }
        fputs(s, stderr);
        if (*s && s[strlen(s)-1] == '\n') {
                fflush(stderr);
                inline = 0;
        }
}


char *
mybufp()                                /* return buffer for my command */
{
        if (dev_func[COM_COMIN] != r_mycomin) {
                dev_func[COM_COMIN] = r_mycomin;
                kill(getppid(), SIGIO);
        }
        return(mybuf+strlen(mybuf));
}


repaint(xmin, ymin, xmax, ymax)         /* repaint section of display */
int     xmin, ymin, xmax, ymax;
{
        sprintf(mybufp(), "repaint %d %d %d %d\n",
                        xmin, ymin, xmax, ymax);
}
Revision:	1.3
Committed:	Wed Nov 1 16:12:22 1989 UTC (34 years, 6 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+44 -6 lines
Log Message:	Added ability to call repaint in detached drivers
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1989 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* devmain.c - main for independent drivers.
9			*
10			* Redefine your initialization routine to dinit.
11			*
12			* 10/25/89
13			*/
14
15			#include <stdio.h>
16
17			#include <signal.h>
18
19			#include "color.h"
20
21			#include "driver.h"
22
23			int (wrnvec)(), (errvec)(), (cmdvec)(); / error vectors, unused */
24
25	greg	1.2	long nrays = 0; /* fake it */
26
27	greg	1.1	struct driver dev = NULL; / output device */
28
29			FILE devin, devout; /* communications channels */
30
31			int notified = 0; /* notified parent of input? */
32
33			char progname; / driver name */
34
35	greg	1.3	int r_clear(), r_paintr(), r_getcur(), r_comout(), r_comin(), r_mycomin();
36	greg	1.1
37			int (dev_func[NREQUESTS])() = { / request handlers */
38			r_clear, r_paintr,
39			r_getcur, r_comout, r_comin
40			};
41
42	greg	1.3	char mybuf[512] = "";
43	greg	1.1
44	greg	1.3	char *mybufp();
45
46
47	greg	1.1	main(argc, argv) /* set up communications and main loop */
48			int argc;
49			char *argv[];
50			{
51			extern struct driver *dinit();
52			int com;
53			/* set up I/O */
54			progname = argv[0];
55			if (argc < 3) {
56			stderr_v("arg count\n");
57			quit(1);
58			}
59			devin = fdopen(atoi(argv[1]), "r");
60			devout = fdopen(atoi(argv[2]), "w");
61			if (devin == NULL \|\| devout == NULL \|\| getw(devin) != COM_SENDM) {
62			stderr_v("connection failure\n");
63			quit(1);
64			}
65			/* open device */
66	greg	1.2	if ((dev = dinit(argv[0], argv[3])) == NULL)
67	greg	1.1	quit(1);
68			putw(COM_RECVM, devout); /* verify initialization */
69			putw(dev->xsiz, devout);
70			putw(dev->ysiz, devout);
71			fflush(devout);
72			/* loop on requests */
73			while ((com = getc(devin)) != EOF) {
74			if (com >= NREQUESTS \|\| dev_func[com] == NULL) {
75			stderr_v("invalid request\n");
76			quit(1);
77			}
78			(dev_func[com])(); / process request */
79			}
80			quit(0); /* all done, clean up and exit */
81			}
82
83
84			quit(code) /* close device and exit */
85			int code;
86			{
87			if (dev != NULL)
88			(*dev->close)();
89			exit(code);
90			}
91
92
93			r_clear() /* clear screen */
94			{
95			int xres, yres;
96
97			xres = getw(devin);
98			yres = getw(devin);
99			(*dev->clear)(xres, yres);
100			}
101
102
103			r_paintr() /* paint a rectangle */
104			{
105			COLOR col;
106			int xmin, ymin, xmax, ymax;
107
108	greg	1.2	nrays += 5; /* pretend */
109	greg	1.1	fread(col, sizeof(COLOR), 1, devin);
110			xmin = getw(devin); ymin = getw(devin);
111			xmax = getw(devin); ymax = getw(devin);
112			(*dev->paintr)(col, xmin, ymin, xmax, ymax);
113			/* check for input */
114	greg	1.3	if (!notified && dev->inpready > 0) {
115			notified = 1;
116	greg	1.1	kill(getppid(), SIGIO);
117			}
118			}
119
120
121			r_getcur() /* get and return cursor position */
122			{
123			int c;
124			int x, y;
125			/* get it if we can */
126			if (dev->getcur == NULL) {
127			c = ABORT;
128			x = y = 0;
129			} else
130			c = (*dev->getcur)(&x, &y);
131			/* reply */
132			putc(COM_GETCUR, devout);
133			putc(c, devout);
134			putw(x, devout);
135			putw(y, devout);
136			fflush(devout);
137			}
138
139
140			r_comout() /* print string to command line */
141			{
142			char str[256];
143
144			mygets(str, devin);
145			(*dev->comout)(str);
146			}
147
148
149			r_comin() /* read string from command line */
150			{
151			char buf[256];
152			/* get string */
153			(*dev->comin)(buf);
154			/* reply */
155			putc(COM_COMIN, devout);
156			myputs(buf, devout);
157			fflush(devout);
158			/* reset notify */
159			notified = 0;
160			}
161
162
163			mygets(s, fp) /* get string from file (with nul) */
164			register char *s;
165			register FILE *fp;
166			{
167			register int c;
168
169			while ((c = getc(fp)) != EOF)
170			if ((*s++ = c) == '\0')
171			return;
172			*s = '\0';
173			}
174
175
176			myputs(s, fp) /* put string to file (with nul) */
177			register char *s;
178			register FILE *fp;
179			{
180			do
181			putc(*s, fp);
182			while (*s++);
183			}
184
185
186	greg	1.3	r_mycomin() /* get command from my buffer */
187	greg	1.1	{
188	greg	1.3	register char *cp;
189			/* get next command */
190			for (cp = mybuf; *cp != '\n'; cp++)
191			;
192			*cp++ = '\0';
193			(dev->comout)(mybuf); / echo my command */
194			/* send it as reply */
195			putc(COM_COMIN, devout);
196			myputs(mybuf, devout);
197			fflush(devout);
198			/* get next command */
199			(*dev->comout)("\n");
200			strcpy(mybuf, cp);
201			if (mybuf[0])
202			kill(getppid(), SIGIO); /* signal more */
203			else
204			dev_func[COM_COMIN] = r_comin; /* else reset */
205	greg	1.1	}
206
207
208			stderr_v(s) /* put string to stderr */
209			register char *s;
210			{
211			static int inline = 0;
212
213			if (!inline++) {
214			fputs(progname, stderr);
215			fputs(": ", stderr);
216			}
217			fputs(s, stderr);
218			if (*s && s[strlen(s)-1] == '\n') {
219			fflush(stderr);
220			inline = 0;
221			}
222	greg	1.3	}
223
224
225			char *
226			mybufp() /* return buffer for my command */
227			{
228			if (dev_func[COM_COMIN] != r_mycomin) {
229			dev_func[COM_COMIN] = r_mycomin;
230			kill(getppid(), SIGIO);
231			}
232			return(mybuf+strlen(mybuf));
233			}
234
235
236			repaint(xmin, ymin, xmax, ymax) /* repaint section of display */
237			int xmin, ymin, xmax, ymax;
238			{
239			sprintf(mybufp(), "repaint %d %d %d %d\n",
240			xmin, ymin, xmax, ymax);
241	greg	1.1	}