Home | History | Annotate | Download | only in csh
      1 /*
      2  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
      3  * Use is subject to license terms.
      4  */
      5 
      6 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
      7 /*	  All Rights Reserved  	*/
      8 
      9 /*
     10  * Copyright (c) 1980 Regents of the University of California.
     11  * All rights reserved. The Berkeley Software License Agreement
     12  * specifies the terms and conditions for redistribution.
     13  */
     14 
     15 #pragma ident	"%Z%%M%	%I%	%E% SMI"
     16 
     17 #include "sh.h"
     18 
     19 void	p2dig_ull(unsigned long long);
     20 void	p2dig_int(int);
     21 void	flush(void);
     22 void	Putchar(tchar);
     23 
     24 
     25 /*
     26  * C Shell
     27  */
     28 
     29 void
     30 psecs_ull(unsigned long long l)
     31 {
     32 	unsigned long long i;
     33 
     34 	i = l / 3600;
     35 	if (i) {
     36 		printf("%llu:", i);
     37 		i = l % 3600;
     38 		p2dig_ull(i / 60);
     39 		goto minsec;
     40 	}
     41 	i = l;
     42 	printf("%llu", i / 60);
     43 minsec:
     44 	i %= 60;
     45 	printf(":");
     46 	p2dig_ull(i);
     47 }
     48 
     49 void
     50 psecs_int(int l)
     51 {
     52 	int i;
     53 
     54 	i = l / 3600;
     55 	if (i) {
     56 		printf("%d:", i);
     57 		i = l % 3600;
     58 		p2dig_int(i / 60);
     59 		goto minsec;
     60 	}
     61 	i = l;
     62 	printf("%d", i / 60);
     63 minsec:
     64 	i %= 60;
     65 	printf(":");
     66 	p2dig_int(i);
     67 }
     68 
     69 void
     70 p2dig_ull(unsigned long long i)
     71 {
     72 	printf("%llu%llu", i / 10, i % 10);
     73 }
     74 
     75 void
     76 p2dig_int(int i)
     77 {
     78 	printf("%d%d", i / 10, i % 10);
     79 }
     80 
     81 char linbuf[128];
     82 char *linp = linbuf;
     83 
     84 #ifdef MBCHAR
     85 
     86 /*
     87  * putbyte() send a byte to SHOUT.  No interpretation is done
     88  * except an un-QUOTE'd control character, which is displayed
     89  * as ^x.
     90  */
     91 void
     92 putbyte(int c)
     93 {
     94 
     95 	if ((c & QUOTE) == 0 && (c == 0177 || c < ' ' && c != '\t' &&
     96 	    c != '\n')) {
     97 		putbyte('^');
     98 		if (c == 0177) {
     99 			c = '?';
    100 		} else {
    101 			c |= 'A' - 1;
    102 		}
    103 	}
    104 	c &= TRIM;
    105 	*linp++ = c;
    106 
    107 	if (c == '\n' || linp >= &linbuf[sizeof (linbuf) - 1 - MB_CUR_MAX]) {
    108 		/* 'cause the next Putchar() call may overflow the buffer.  */
    109 		flush();
    110 	}
    111 }
    112 
    113 /*
    114  * Putchar(tc) does what putbyte(c) do for a byte c.
    115  * Note that putbyte(c) just send the byte c (provided c is not
    116  * a control character) as it is, while Putchar(tc) may expand the
    117  * character tc to some byte sequnce that represents the character
    118  * in EUC form.
    119  */
    120 void
    121 Putchar(tchar tc)
    122 {
    123 	int	n;
    124 
    125 	if (isascii(tc&TRIM)) {
    126 		putbyte((int)tc);
    127 		return;
    128 	}
    129 	tc &= TRIM;
    130 	n = wctomb(linp, tc);
    131 	if (n == -1) {
    132 		return;
    133 	}
    134 	linp += n;
    135 	if (linp >= &linbuf[sizeof (linbuf) - 1 - MB_CUR_MAX]) {
    136 		flush();
    137 	}
    138 }
    139 
    140 #else	/* !MBCHAR */
    141 
    142 /*
    143  * putbyte() send a byte to SHOUT.  No interpretation is done
    144  * except an un-QUOTE'd control character, which is displayed
    145  * as ^x.
    146  */
    147 void
    148 putbyte(int c)
    149 {
    150 
    151 	if ((c & QUOTE) == 0 && (c == 0177 || c < ' ' && c != '\t' &&
    152 	    c != '\n')) {
    153 		putbyte('^');
    154 		if (c == 0177) {
    155 			c = '?';
    156 		} else {
    157 			c |= 'A' - 1;
    158 		}
    159 	}
    160 	c &= TRIM;
    161 	*linp++ = c;
    162 	if (c == '\n' || linp >= &linbuf[sizeof (linbuf) - 2]) {
    163 		flush();
    164 	}
    165 }
    166 
    167 /*
    168  * Putchar(tc) does what putbyte(c) do for a byte c.
    169  * For single-byte character only environment, there is no
    170  * difference between Putchar() and putbyte() though.
    171  */
    172 void
    173 Putchar(tchar tc)
    174 {
    175 	putbyte((int)tc);
    176 }
    177 
    178 #endif	/* !MBCHAR */
    179 
    180 void
    181 draino(void)
    182 {
    183 	linp = linbuf;
    184 }
    185 
    186 void
    187 flush(void)
    188 {
    189 	int unit;
    190 	int lmode;
    191 
    192 	if (linp == linbuf) {
    193 		return;
    194 	}
    195 	if (haderr) {
    196 		unit = didfds ? 2 : SHDIAG;
    197 	} else {
    198 		unit = didfds ? 1 : SHOUT;
    199 	}
    200 #ifdef TIOCLGET
    201 	if (didfds == 0 && ioctl(unit, TIOCLGET,  (char *)&lmode) == 0 &&
    202 	    lmode&LFLUSHO) {
    203 		lmode = LFLUSHO;
    204 		(void) ioctl(unit, TIOCLBIC,  (char *)&lmode);
    205 		(void) write(unit, "\n", 1);
    206 	}
    207 #endif
    208 	(void) write(unit, linbuf, linp - linbuf);
    209 	linp = linbuf;
    210 }
    211 
    212 /*
    213  * Should not be needed.
    214  */
    215 void
    216 write_string(char *s)
    217 {
    218 	int unit;
    219 	/*
    220 	 * First let's make it sure to flush out things.
    221 	 */
    222 	flush();
    223 
    224 	if (haderr) {
    225 		unit = didfds ? 2 : SHDIAG;
    226 	} else {
    227 		unit = didfds ? 1 : SHOUT;
    228 	}
    229 
    230 	(void) write(unit, s, strlen(s));
    231 }
    232