src/rt/devmain.c

#ifndef lint
static const char       RCSid[] = "$Id: devmain.c,v 2.5 2016/08/18 00:52:48 greg Exp $";
#endif
/*
 *  devmain.c - main for independent drivers.
 *
 *      Redefine your initialization routine to dinit.
 */

#include "copyright.h"

#include "standard.h"

#include "color.h"

#include "driver.h"

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

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

char    *progname;                              /* driver name */

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

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


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) {
                eputs("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) {
                eputs("connection failure\n");
                quit(1);
        }
                                                /* open device */
        if ((dev = dinit(argv[0], argv[3])) == NULL)
                quit(1);
        putw(COM_RECVM, devout);                /* verify initialization */
        sendstate();
        fflush(devout);
                                                /* loop on requests */
        while ((com = getc(devin)) != EOF) {
                if (com >= NREQUESTS || dev_func[com] == NULL) {
                        eputs("invalid request\n");
                        quit(1);
                }
                (*dev_func[com])();             /* process request */
        }
        quit(0);                        /* all done, clean up and exit */
}


void
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;

        getbinary((char *)col, sizeof(COLOR), 1, devin);
        xmin = getw(devin); ymin = getw(devin);
        xmax = getw(devin); ymax = getw(devin);
        (*dev->paintr)(col, xmin, ymin, xmax, ymax);
}


r_flush()                               /* flush output */
{
        if (dev->flush != NULL)
                (*dev->flush)();
        putc(COM_FLUSH, devout);
        sendstate();
        fflush(devout);
}


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);
}


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

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


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


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], *prompt;
                                        /* get prompt */
        if (getc(devin)) {
                mygets(buf, devin);
                prompt = buf;
        } else
                prompt = NULL;
                                        /* get string */
        (*dev->comin)(buf, prompt);
                                        /* reply */
        putc(COM_COMIN, devout);
        myputs(buf, devout);
        sendstate();
        fflush(devout);
}


void
eputs(const char *s)                            /* put string to stderr */
{
        static int  midline = 0;

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


sendstate()                             /* send driver state variables */
{
        putbinary(&dev->pixaspect, sizeof(dev->pixaspect), 1, devout);
        putw(dev->xsiz, devout);
        putw(dev->ysiz, devout);
        putw(dev->inpready, devout);
}
Revision:	2.6
Committed:	Thu Feb 9 21:54:11 2023 UTC (2 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R4, HEAD
Changes since 2.5:	+23 -26 lines
Log Message:	fix: compile error fixes related to redeclaration of eputs() and wputs()
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.6	static const char RCSid[] = "$Id: devmain.c,v 2.5 2016/08/18 00:52:48 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* devmain.c - main for independent drivers.
6			*
7			* Redefine your initialization routine to dinit.
8	greg	2.3	*/
9
10	greg	2.4	#include "copyright.h"
11	greg	1.1
12	gregl	2.2	#include "standard.h"
13	greg	1.1
14			#include "color.h"
15
16			#include "driver.h"
17
18			struct driver dev = NULL; / output device */
19
20			FILE devin, devout; /* communications channels */
21
22			char progname; / driver name */
23
24	greg	1.8	int r_clear(), r_paintr(), r_getcur(), r_comout(), r_comin(), r_flush();
25	greg	1.1
26			int (dev_func[NREQUESTS])() = { / request handlers */
27			r_clear, r_paintr,
28	greg	1.8	r_getcur, r_comout,
29			r_comin, r_flush
30	greg	1.1	};
31
32
33			main(argc, argv) /* set up communications and main loop */
34			int argc;
35			char *argv[];
36			{
37			extern struct driver *dinit();
38			int com;
39			/* set up I/O */
40			progname = argv[0];
41			if (argc < 3) {
42	gregl	2.2	eputs("arg count\n");
43	greg	1.1	quit(1);
44			}
45			devin = fdopen(atoi(argv[1]), "r");
46			devout = fdopen(atoi(argv[2]), "w");
47			if (devin == NULL \|\| devout == NULL \|\| getw(devin) != COM_SENDM) {
48	gregl	2.2	eputs("connection failure\n");
49	greg	1.1	quit(1);
50			}
51			/* open device */
52	greg	1.2	if ((dev = dinit(argv[0], argv[3])) == NULL)
53	greg	1.1	quit(1);
54			putw(COM_RECVM, devout); /* verify initialization */
55	greg	1.11	sendstate();
56	greg	1.1	fflush(devout);
57			/* loop on requests */
58			while ((com = getc(devin)) != EOF) {
59			if (com >= NREQUESTS \|\| dev_func[com] == NULL) {
60	gregl	2.2	eputs("invalid request\n");
61	greg	1.1	quit(1);
62			}
63			(dev_func[com])(); / process request */
64			}
65			quit(0); /* all done, clean up and exit */
66			}
67
68
69	greg	2.3	void
70	greg	1.1	quit(code) /* close device and exit */
71			int code;
72			{
73			if (dev != NULL)
74			(*dev->close)();
75			exit(code);
76			}
77
78
79			r_clear() /* clear screen */
80			{
81			int xres, yres;
82
83			xres = getw(devin);
84			yres = getw(devin);
85			(*dev->clear)(xres, yres);
86			}
87
88
89			r_paintr() /* paint a rectangle */
90			{
91			COLOR col;
92			int xmin, ymin, xmax, ymax;
93
94	greg	2.5	getbinary((char *)col, sizeof(COLOR), 1, devin);
95	greg	1.1	xmin = getw(devin); ymin = getw(devin);
96			xmax = getw(devin); ymax = getw(devin);
97			(*dev->paintr)(col, xmin, ymin, xmax, ymax);
98	greg	1.8	}
99
100
101			r_flush() /* flush output */
102			{
103			if (dev->flush != NULL)
104			(*dev->flush)();
105	greg	1.9	putc(COM_FLUSH, devout);
106	greg	1.11	sendstate();
107	greg	1.9	fflush(devout);
108	greg	1.1	}
109
110
111			r_getcur() /* get and return cursor position */
112			{
113			int c;
114			int x, y;
115			/* get it if we can */
116			if (dev->getcur == NULL) {
117			c = ABORT;
118			x = y = 0;
119			} else
120			c = (*dev->getcur)(&x, &y);
121			/* reply */
122			putc(COM_GETCUR, devout);
123			putc(c, devout);
124			putw(x, devout);
125			putw(y, devout);
126			fflush(devout);
127			}
128
129
130	greg	2.6	void
131			mygets(char s, FILE fp) /* get string from file (with nul) */
132			{
133			int c;
134
135			while ((c = getc(fp)) != EOF)
136			if ((*s++ = c) == '\0')
137			return;
138			*s = '\0';
139			}
140
141
142			void
143			myputs(const char s, FILE fp) /* put string to file (with nul) */
144			{
145			do
146			putc(*s, fp);
147			while (*s++);
148			}
149
150
151	greg	1.1	r_comout() /* print string to command line */
152			{
153			char str[256];
154
155			mygets(str, devin);
156			(*dev->comout)(str);
157			}
158
159
160			r_comin() /* read string from command line */
161			{
162	greg	1.7	char buf[256], *prompt;
163			/* get prompt */
164			if (getc(devin)) {
165			mygets(buf, devin);
166			prompt = buf;
167			} else
168			prompt = NULL;
169	greg	1.1	/* get string */
170	greg	1.7	(*dev->comin)(buf, prompt);
171	greg	1.1	/* reply */
172			putc(COM_COMIN, devout);
173			myputs(buf, devout);
174	greg	1.11	sendstate();
175	greg	1.1	fflush(devout);
176			}
177
178
179	greg	2.3	void
180	greg	2.6	eputs(const char s) / put string to stderr */
181	greg	1.1	{
182	greg	1.12	static int midline = 0;
183	greg	1.1
184	greg	1.13	if (!*s)
185			return;
186	greg	1.12	if (!midline++) {
187	greg	1.1	fputs(progname, stderr);
188			fputs(": ", stderr);
189			}
190			fputs(s, stderr);
191	greg	1.13	if (s[strlen(s)-1] == '\n') {
192	greg	1.1	fflush(stderr);
193	greg	1.12	midline = 0;
194	greg	1.1	}
195	greg	1.11	}
196
197
198			sendstate() /* send driver state variables */
199			{
200	greg	2.5	putbinary(&dev->pixaspect, sizeof(dev->pixaspect), 1, devout);
201	greg	1.11	putw(dev->xsiz, devout);
202			putw(dev->ysiz, devout);
203			putw(dev->inpready, devout);
204	greg	1.1	}