![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to amitty.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / vi|
Return to amitty.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* amitty.c */
2:
3: /*-
4: * Mike Rieser Dale Rahn
5: * 2410 Happy Hollow Rd. Apt D-10 540 Vine St.
6: * West Lafayette, IN 47906 West Lafayette, IN 47906
7: * [email protected] [email protected]
8: */
9:
10: #include <stdio.h>
11: #include <stdlib.h>
12: #include <string.h>
13: #include <exec/memory.h>
14: #include <devices/conunit.h>
15: #include <dos/dos.h>
16: #include <clib/macros.h>
17: #include <clib/exec_protos.h>
18: #include <clib/dos_protos.h>
19:
20: #if AZTEC_C
21: #include <pragmas/exec_lib.h>
22: #include <pragmas/dos_lib.h>
23: #else
24: #include <pragmas/exec.h>
25: #include <pragmas/dos.h>
26: #endif
27:
28: #include "config.h"
29:
30: /*-
31: * Defines for amigatty.
32: *
33: * Note: Amiga <CSI> Control Sequence Introducer is either:
34: * 0x9b or <ESC>[ == 0x1b 0x5b.
35: *
36: * The Amiga always responds with 0x9b.
37: *
38: * For you octal fans: 0x9b == \233, 0x1b == \033.
39: */
40: #define CSI '\233'
41: #define TIME_FACTOR (100000)/* convert 1/10 sec to microsecs */
42:
43: /* Amiga Console Control Sequences */
44: #define ENABLE_SCROLL ((UBYTE *) "\233>1h") /* Amiga default */
45: #define DISABLE_SCROLL ((UBYTE *) "\233>1l")
46: #define AUTOWRAP_ON ((UBYTE *) "\233?7h") /* Amiga default */
47: #define AUTOWRAP_OFF ((UBYTE *) "\233?7l")
48: #define CURSOR_ON ((UBYTE *) "\233 p") /* Amiga default */
49: #define CURSOR_OFF ((UBYTE *) "\2330 p")
50:
51: #define RAW_EVENTS_ON ((UBYTE *) "\23312{") /* Set Window Resize Reports */
52: #define RAW_EVENTS_OFF ((UBYTE *) "\23312}") /* Reset Window Resize Reports */
53:
54: /* take out for compiling with elvis */
55:
56: #ifndef ctrl
57: #define ctrl(ch) ((ch)&037)
58: #endif
59:
60: /* Variables */
61: static BPTR fh = 0, inputFH, outputFH, oldinputFH, oldoutputFH;
62: static UBYTE title[]= "RAW:0/0/999/999/Amiga Elvis 1.5/SIMPLE";
63: static int amigaterm = 0;
64:
65: /* Function prototypes for amitty.c */
66: void amiopenwin(char *termtype);
67: void amiclosewin(void);
68: void ttysetup(void);
69: void ttyshutdown(void);
70: int ttywrite(char *buf, int len);
71: int ttyread(char *buf, int len, int time);
72: int CheckforSpecial(char *buf, long len);
73: LONG setRawCon(LONG toggle);
74: LONG sendpkt(struct MsgPort *pid, LONG action, LONG args[], LONG nargs);
75:
76: /*
77: * amiopenwin - opens a window if we don't already have one.
78: */
79: void
80: amiopenwin(char *termtype)
81: {
82: if (!IsInteractive(Input()))
83: {
84: /* open our own window in RAW mode */
85: if (isOldDOS() || (BPTR) 0 == (fh = Open(title, MODE_READWRITE)))
86: {
87: PutStr((UBYTE *) "Couldn't open RAW: window");
88: clean_exit(2);
89: } else
90: {
91: oldinputFH = SelectInput(fh);
92: oldoutputFH = SelectOutput(fh);
93: }
94: }
95: inputFH = Input();
96: outputFH = Output();
97:
98: if (!strcmp(termtype, TERMTYPE))
99: {
100: amigaterm = 1;
101: Write(outputFH, AUTOWRAP_OFF, sizeof(AUTOWRAP_OFF));
102: }
103: return;
104: }
105:
106:
107: /*
108: * amiclosewin - closes a window if we opened one.
109: */
110: void
111: amiclosewin()
112: {
113: if (amigaterm)
114: {
115: Write(outputFH, AUTOWRAP_ON, sizeof(AUTOWRAP_ON)); /* Amiga default */
116: }
117: if (fh)
118: { /* Close down the window */
119: SelectInput(oldinputFH);
120: SelectOutput(oldoutputFH);
121: Close(fh);
122: }
123: return;
124: }
125:
126:
127: /*
128: * ttysetup - console initalization routine for Amiga Computers.
129: *
130: * Sets raw mode and enables resize notifications.
131: */
132: void
133: ttysetup()
134: {
135: if (isOldDOS())
136: {
137: setRawCon(DOSTRUE);
138: } else
139: {
140: SetMode(inputFH, 1); /* Enter RAW mode */
141: }
142:
143: if (amigaterm)
144: {
145: Write(outputFH, RAW_EVENTS_ON, sizeof(RAW_EVENTS_ON));
146: }
147: return;
148: }
149:
150:
151: /*
152: * ttyshutdown - console shutdown routine for Amiga Computers.
153: *
154: * Resets raw mode and disables resize notifications.
155: */
156: void
157: ttyshutdown()
158: {
159: if (amigaterm)
160: {
161: Write(outputFH, RAW_EVENTS_OFF, sizeof(RAW_EVENTS_OFF));
162: }
163: if (isOldDOS())
164: {
165: setRawCon(DOSFALSE);
166: } else
167: {
168: SetMode(inputFH, 0); /* Leave RAW mode */
169: }
170:
171: return;
172: }
173:
174:
175: /*
176: * ttywrite - amiga version of ttywrite.
177: *
178: * This version makes small writes to the console as suggested in the RKM.
179: * Also turns off the cursor to speed output to the screen.
180: */
181: int
182: ttywrite(buf, len)
183: char *buf;
184: int len;
185: {
186: int cursor_off;
187: register int bytes;
188: register UBYTE *pc = (UBYTE *) buf;
189:
190: /* See if turning off the cursor is worthwhile */
191: if (cursor_off = amigaterm && len > 2 * sizeof(CURSOR_OFF))
192: {
193: Write(outputFH, CURSOR_OFF, sizeof(CURSOR_OFF)); /* Turn Cursor OFF */
194: }
195:
196: /* The console.device doesn't like large writes */
197: for (bytes = 0; len; pc += bytes, len -= bytes)
198: {
199: bytes = Write(outputFH, pc, MIN((LONG) len, 256L));
200: }
201:
202: if (cursor_off)
203: {
204: Write(outputFH, CURSOR_ON, sizeof(CURSOR_ON)); /* Turn Cursor ON */
205: }
206: return pc - buf;
207: }
208:
209:
210: /*
211: * ttyread - amiga version of ttyread.
212: */
213: int
214: ttyread(buf, len, time)
215: char *buf; /* where to store the gotten characters */
216: int len; /* maximum number of characters to read */
217: int time; /* maximum time in 1/10 sec for reading */
218: {
219: LONG bytes = 0; /* number of bytes actually read */
220:
221: if (!time || WaitForChar(inputFH, time * TIME_FACTOR))
222: { /* Read() if time == 0 or chars waiting */
223: bytes = Read(inputFH, (UBYTE *) buf, (LONG) len);
224: bytes = CheckforSpecial(buf, bytes);
225: }
226: return bytes; /* the number of bytes read in buf */
227: }
228:
229:
230: /*
231: * CheckforSpecial - crude parser for raw console events.
232: */
233: int
234: CheckforSpecial(buf, len)
235: char *buf;
236: long len;
237: {
238: int isnewsize = 0;
239: char *pb, *peor, *pend;
240:
241: pb = buf;
242: pend = &buf[len];
243: do
244: {
245: if (CSI != *pb)
246: continue;
247:
248: if (WaitForChar(inputFH, 1))
249: {
250: pend += Read(inputFH, pend, 72);
251: }
252: if (peor = strchr((char *) pb, '|')) /* Window Resize Event */
253: { /* bug == <CSI> seq <CSI> event '|' */
254: *pb = ctrl('L'); /* force redraw */
255: isnewsize = 1;
256: memmove(pb + 1, peor + 1, pend - peor);
257: pend -= peor - pb;
258: }
259: }
260: while (*pb++);
261:
262: if (isnewsize)
263: getsize(0);
264:
265: return pend - buf;
266: }
267:
268:
269: /* INDENT OFF */
270: /* sendpkt code - A. Finkel, P. Lindsay, C. Scheppner CBM */
271:
272: LONG setRawCon(toggle)
273: LONG toggle; /* DOSTRUE (-1L) or DOSFALSE (0L) */
274: {
275: struct MsgPort *conid;
276: struct Process *me;
277: LONG myargs[8] ,nargs, res1;
278:
279: me = (struct Process *) FindTask(NULL);
280: conid = (struct MsgPort *) me->pr_ConsoleTask;
281:
282: myargs[0]= toggle;
283: nargs = 1;
284: res1 = (LONG)sendpkt(conid,ACTION_SCREEN_MODE,myargs,nargs);
285: return(res1);
286: }
287:
288:
289:
290: LONG sendpkt(pid,action,args,nargs)
291: struct MsgPort *pid; /* process indentifier ... (handlers message port ) */
292: LONG action, /* packet type ... (what you want handler to do ) */
293: args[], /* a pointer to a argument list */
294: nargs; /* number of arguments in list */
295: {
296: struct MsgPort *replyport;
297: struct StandardPacket *packet;
298:
299: LONG count, *pargs, res1;
300:
301: replyport = (struct MsgPort *) CreatePort(NULL,0);
302: if(!replyport) return((LONG)NULL);
303:
304: packet = (struct StandardPacket *)
305: AllocMem((long)sizeof(struct StandardPacket),MEMF_PUBLIC|MEMF_CLEAR);
306: if(!packet)
307: {
308: DeletePort(replyport);
309: return((LONG)NULL);
310: }
311:
312: packet->sp_Msg.mn_Node.ln_Name = (char *)&(packet->sp_Pkt);
313: packet->sp_Pkt.dp_Link = &(packet->sp_Msg);
314: packet->sp_Pkt.dp_Port = replyport;
315: packet->sp_Pkt.dp_Type = action;
316:
317: /* copy the args into the packet */
318: pargs = &(packet->sp_Pkt.dp_Arg1); /* address of first argument */
319: for(count=0;count < nargs;count++)
320: pargs[count]=args[count];
321:
322: PutMsg(pid,(struct Message *)packet); /* send packet */
323:
324: WaitPort(replyport);
325: GetMsg(replyport);
326:
327: res1 = packet->sp_Pkt.dp_Res1;
328:
329: FreeMem(packet,(long)sizeof(struct StandardPacket));
330: DeletePort(replyport);
331:
332: return(res1);
333: }
334:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.