![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tty_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to tty_subr.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* Copyright (c) 1997 Apple Computer, Inc. All Rights Reserved */
23: /*
24: * Copyright (c) 1993, 1994 Theo de Raadt
25: * All rights reserved.
26: *
27: * Redistribution and use in source and binary forms, with or without
28: * modification, are permitted provided that the following conditions
29: * are met:
30: * 1. Redistributions of source code must retain the above copyright
31: * notice unmodified, this list of conditions, and the following
32: * disclaimer.
33: * 2. Redistributions in binary form must reproduce the above copyright
34: * notice, this list of conditions and the following disclaimer in the
35: * documentation and/or other materials provided with the distribution.
36: *
37: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
38: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
39: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
40: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
41: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
42: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
43: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
45: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
46: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47: * SUCH DAMAGE.
48: *
49: */
50:
51: #ifdef NeXT
52: /*
53: * We use the NetBSD based clist system, it is much more efficient than the
54: * old style clist stuff used by free bsd.
55: */
56:
57: #include <sys/param.h>
58: #include <sys/systm.h>
59: #include <sys/buf.h>
60: #include <sys/ioctl.h>
61: #include <sys/tty.h>
62: #include <sys/malloc.h>
63:
64: #include <machine/spl.h>
65:
66: /*
67: * At compile time, choose:
68: * There are two ways the TTY_QUOTE bit can be stored. If QBITS is
69: * defined we allocate an array of bits -- 1/8th as much memory but
70: * setbit(), clrbit(), and isset() take more cpu. If QBITS is
71: * undefined, we just use an array of bytes.
72: *
73: * If TTY_QUOTE functionality isn't required by a line discipline,
74: * it can free c_cq and set it to NULL. This speeds things up,
75: * and also does not use any extra memory. This is useful for (say)
76: * a SLIP line discipline that wants a 32K ring buffer for data
77: * but doesn't need quoting.
78: */
79: #define QBITS
80:
81: #ifdef QBITS
82: #define QMEM(n) ((((n)-1)/NBBY)+1)
83: #else
84: #define QMEM(n) (n)
85: #endif
86:
87:
88: /*
89: * Initialize clists.
90: */
91: void
92: cinit()
93: {
94: }
95:
96: /*
97: * Initialize a particular clist. Ok, they are really ring buffers,
98: * of the specified length, with/without quoting support.
99: */
100: int
101: clalloc(clp, size, quot)
102: struct clist *clp;
103: int size;
104: int quot;
105: {
106:
107: MALLOC(clp->c_cs, u_char *, size, M_TTYS, M_WAITOK);
108: if (!clp->c_cs)
109: return (-1);
110: bzero(clp->c_cs, size);
111:
112: if(quot) {
113: MALLOC(clp->c_cq, u_char *, QMEM(size), M_TTYS, M_WAITOK);
114: if (!clp->c_cq) {
115: FREE(clp->c_cs, M_TTYS);
116: return (-1);
117: }
118: bzero(clp->c_cs, QMEM(size));
119: } else
120: clp->c_cq = (u_char *)0;
121:
122: clp->c_cf = clp->c_cl = (u_char *)0;
123: clp->c_ce = clp->c_cs + size;
124: clp->c_cn = size;
125: clp->c_cc = 0;
126: return (0);
127: }
128:
129: void
130: clfree(clp)
131: struct clist *clp;
132: {
133: if(clp->c_cs)
134: FREE(clp->c_cs, M_TTYS);
135: if(clp->c_cq)
136: FREE(clp->c_cq, M_TTYS);
137: clp->c_cs = clp->c_cq = (u_char *)0;
138: }
139:
140:
141: /*
142: * Get a character from a clist.
143: */
144: int
145: getc(clp)
146: struct clist *clp;
147: {
148: register int c = -1;
149: int s;
150:
151: s = spltty();
152: if (clp->c_cc == 0)
153: goto out;
154:
155: c = *clp->c_cf & 0xff;
156: if (clp->c_cq) {
157: #ifdef QBITS
158: if (isset(clp->c_cq, clp->c_cf - clp->c_cs) )
159: c |= TTY_QUOTE;
160: #else
161: if (*(clp->c_cf - clp->c_cs + clp->c_cq))
162: c |= TTY_QUOTE;
163: #endif
164: }
165: if (++clp->c_cf == clp->c_ce)
166: clp->c_cf = clp->c_cs;
167: if (--clp->c_cc == 0)
168: clp->c_cf = clp->c_cl = (u_char *)0;
169: out:
170: splx(s);
171: return c;
172: }
173:
174: /*
175: * Copy clist to buffer.
176: * Return number of bytes moved.
177: */
178: int
179: q_to_b(clp, cp, count)
180: struct clist *clp;
181: u_char *cp;
182: int count;
183: {
184: register int cc;
185: u_char *p = cp;
186: int s;
187:
188: s = spltty();
189: /* optimize this while loop */
190: while (count > 0 && clp->c_cc > 0) {
191: cc = clp->c_cl - clp->c_cf;
192: if (clp->c_cf >= clp->c_cl)
193: cc = clp->c_ce - clp->c_cf;
194: if (cc > count)
195: cc = count;
196: bcopy(clp->c_cf, p, cc);
197: count -= cc;
198: p += cc;
199: clp->c_cc -= cc;
200: clp->c_cf += cc;
201: if (clp->c_cf == clp->c_ce)
202: clp->c_cf = clp->c_cs;
203: }
204: if (clp->c_cc == 0)
205: clp->c_cf = clp->c_cl = (u_char *)0;
206: splx(s);
207: return p - cp;
208: }
209:
210: /*
211: * Return count of contiguous characters in clist.
212: * Stop counting if flag&character is non-null.
213: */
214: int
215: ndqb(clp, flag)
216: struct clist *clp;
217: int flag;
218: {
219: int count = 0;
220: register int i;
221: register int cc;
222: int s;
223:
224: s = spltty();
225: if ((cc = clp->c_cc) == 0)
226: goto out;
227:
228: if (flag == 0) {
229: count = clp->c_cl - clp->c_cf;
230: if (count <= 0)
231: count = clp->c_ce - clp->c_cf;
232: goto out;
233: }
234:
235: i = clp->c_cf - clp->c_cs;
236: if (flag & TTY_QUOTE) {
237: while (cc-- > 0 && !(clp->c_cs[i++] & (flag & ~TTY_QUOTE) ||
238: isset(clp->c_cq, i))) {
239: count++;
240: if (i == clp->c_cn)
241: break;
242: }
243: } else {
244: while (cc-- > 0 && !(clp->c_cs[i++] & flag)) {
245: count++;
246: if (i == clp->c_cn)
247: break;
248: }
249: }
250: out:
251: splx(s);
252: return count;
253: }
254:
255: /*
256: * Flush count bytes from clist.
257: */
258: void
259: ndflush(clp, count)
260: struct clist *clp;
261: int count;
262: {
263: register int cc;
264: int s;
265:
266: s = spltty();
267: if (count == clp->c_cc) {
268: clp->c_cc = 0;
269: clp->c_cf = clp->c_cl = (u_char *)0;
270: goto out;
271: }
272: /* optimize this while loop */
273: while (count > 0 && clp->c_cc > 0) {
274: cc = clp->c_cl - clp->c_cf;
275: if (clp->c_cf >= clp->c_cl)
276: cc = clp->c_ce - clp->c_cf;
277: if (cc > count)
278: cc = count;
279: count -= cc;
280: clp->c_cc -= cc;
281: clp->c_cf += cc;
282: if (clp->c_cf == clp->c_ce)
283: clp->c_cf = clp->c_cs;
284: }
285: if (clp->c_cc == 0)
286: clp->c_cf = clp->c_cl = (u_char *)0;
287: out:
288: splx(s);
289: }
290:
291: /*
292: * Put a character into the output queue.
293: */
294: int
295: putc(c, clp)
296: int c;
297: struct clist *clp;
298: {
299: register int i;
300: int s;
301:
302: s = spltty();
303: if (clp->c_cc == 0) {
304: if (!clp->c_cs) {
305: #if DIAGNOSTIC
306: //printf("putc: required clalloc\n");
307: #endif
308: if(clalloc(clp, 1024, 1)) {
309: out:
310: splx(s);
311: return -1;
312: }
313: }
314: clp->c_cf = clp->c_cl = clp->c_cs;
315: }
316:
317: if (clp->c_cc == clp->c_cn)
318: goto out;
319:
320: *clp->c_cl = c & 0xff;
321: i = clp->c_cl - clp->c_cs;
322: if (clp->c_cq) {
323: #ifdef QBITS
324: if (c & TTY_QUOTE)
325: setbit(clp->c_cq, i);
326: else
327: clrbit(clp->c_cq, i);
328: #else
329: q = clp->c_cq + i;
330: *q = (c & TTY_QUOTE) ? 1 : 0;
331: #endif
332: }
333: clp->c_cc++;
334: clp->c_cl++;
335: if (clp->c_cl == clp->c_ce)
336: clp->c_cl = clp->c_cs;
337: splx(s);
338: return 0;
339: }
340:
341: #ifdef QBITS
342: /*
343: * optimized version of
344: *
345: * for (i = 0; i < len; i++)
346: * clrbit(cp, off + len);
347: */
348: void
349: clrbits(cp, off, len)
350: u_char *cp;
351: int off;
352: int len;
353: {
354: int sby, sbi, eby, ebi;
355: register int i;
356: u_char mask;
357:
358: if(len==1) {
359: clrbit(cp, off);
360: return;
361: }
362:
363: sby = off / NBBY;
364: sbi = off % NBBY;
365: eby = (off+len) / NBBY;
366: ebi = (off+len) % NBBY;
367: if (sby == eby) {
368: mask = ((1 << (ebi - sbi)) - 1) << sbi;
369: cp[sby] &= ~mask;
370: } else {
371: mask = (1<<sbi) - 1;
372: cp[sby++] &= mask;
373:
374: mask = (1<<ebi) - 1;
375: cp[eby] &= ~mask;
376:
377: for (i = sby; i < eby; i++)
378: cp[i] = 0x00;
379: }
380: }
381: #endif
382:
383: /*
384: * Copy buffer to clist.
385: * Return number of bytes not transfered.
386: */
387: int
388: b_to_q(cp, count, clp)
389: u_char *cp;
390: int count;
391: struct clist *clp;
392: {
393: register int cc;
394: register u_char *p = cp;
395: int s;
396:
397: if (count <= 0)
398: return 0;
399:
400: s = spltty();
401:
402: if (clp->c_cc == 0) {
403: if (!clp->c_cs) {
404: #if DIAGNOSTIC
405: printf("b_to_q: required clalloc\n");
406: #endif
407: if(clalloc(clp, 1024, 1))
408: goto out;
409: }
410: clp->c_cf = clp->c_cl = clp->c_cs;
411: }
412:
413: if (clp->c_cc == clp->c_cn)
414: goto out;
415:
416: /* optimize this while loop */
417: while (count > 0 && clp->c_cc < clp->c_cn) {
418: cc = clp->c_ce - clp->c_cl;
419: if (clp->c_cf > clp->c_cl)
420: cc = clp->c_cf - clp->c_cl;
421: if (cc > count)
422: cc = count;
423: bcopy(p, clp->c_cl, cc);
424: if (clp->c_cq) {
425: #ifdef QBITS
426: clrbits(clp->c_cq, clp->c_cl - clp->c_cs, cc);
427: #else
428: bzero(clp->c_cl - clp->c_cs + clp->c_cq, cc);
429: #endif
430: }
431: p += cc;
432: count -= cc;
433: clp->c_cc += cc;
434: clp->c_cl += cc;
435: if (clp->c_cl == clp->c_ce)
436: clp->c_cl = clp->c_cs;
437: }
438: out:
439: splx(s);
440: return count;
441: }
442:
443: static int cc;
444:
445: /*
446: * Given a non-NULL pointer into the clist return the pointer
447: * to the next character in the list or return NULL if no more chars.
448: *
449: * Callers must not allow getc's to happen between firstc's and getc's
450: * so that the pointer becomes invalid. Note that interrupts are NOT
451: * masked.
452: */
453: u_char *
454: nextc(clp, cp, c)
455: struct clist *clp;
456: register u_char *cp;
457: int *c;
458: {
459:
460: if (clp->c_cf == cp) {
461: /*
462: * First time initialization.
463: */
464: cc = clp->c_cc;
465: }
466: if (cc == 0 || cp == NULL)
467: return NULL;
468: if (--cc == 0)
469: return NULL;
470: if (++cp == clp->c_ce)
471: cp = clp->c_cs;
472: *c = *cp & 0xff;
473: if (clp->c_cq) {
474: #ifdef QBITS
475: if (isset(clp->c_cq, cp - clp->c_cs))
476: *c |= TTY_QUOTE;
477: #else
478: if (*(clp->c_cf - clp->c_cs + clp->c_cq))
479: *c |= TTY_QUOTE;
480: #endif
481: }
482: return cp;
483: }
484:
485: /*
486: * Given a non-NULL pointer into the clist return the pointer
487: * to the first character in the list or return NULL if no more chars.
488: *
489: * Callers must not allow getc's to happen between firstc's and getc's
490: * so that the pointer becomes invalid. Note that interrupts are NOT
491: * masked.
492: *
493: * *c is set to the NEXT character
494: */
495: u_char *
496: firstc(clp, c)
497: struct clist *clp;
498: int *c;
499: {
500: register u_char *cp;
501:
502: cc = clp->c_cc;
503: if (cc == 0)
504: return NULL;
505: cp = clp->c_cf;
506: *c = *cp & 0xff;
507: if(clp->c_cq) {
508: #ifdef QBITS
509: if (isset(clp->c_cq, cp - clp->c_cs))
510: *c |= TTY_QUOTE;
511: #else
512: if (*(cp - clp->c_cs + clp->c_cq))
513: *c |= TTY_QUOTE;
514: #endif
515: }
516: return clp->c_cf;
517: }
518:
519: /*
520: * Remove the last character in the clist and return it.
521: */
522: int
523: unputc(clp)
524: struct clist *clp;
525: {
526: unsigned int c = -1;
527: int s;
528:
529: s = spltty();
530: if (clp->c_cc == 0)
531: goto out;
532:
533: if (clp->c_cl == clp->c_cs)
534: clp->c_cl = clp->c_ce - 1;
535: else
536: --clp->c_cl;
537: clp->c_cc--;
538:
539: c = *clp->c_cl & 0xff;
540: if (clp->c_cq) {
541: #ifdef QBITS
542: if (isset(clp->c_cq, clp->c_cl - clp->c_cs))
543: c |= TTY_QUOTE;
544: #else
545: if (*(clp->c_cf - clp->c_cs + clp->c_cq))
546: c |= TTY_QUOTE;
547: #endif
548: }
549: if (clp->c_cc == 0)
550: clp->c_cf = clp->c_cl = (u_char *)0;
551: out:
552: splx(s);
553: return c;
554: }
555:
556: /*
557: * Put the chars in the from queue on the end of the to queue.
558: */
559: void
560: catq(from, to)
561: struct clist *from, *to;
562: {
563: int c;
564:
565: while ((c = getc(from)) != -1)
566: putc(c, to);
567: }
568:
569: #endif /* NeXT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.