
GVG$SUPPORT                                                     30-MAR-1989 15:52:12    VAX C      V2.2-015                 Page 1
V1.0                                                            30-MAR-1989 15:48:49    GVG$SUPPORT.C;1 (1)



    1        	 
    2        	/*
    3        	 *	This module holds support routines that make life easy on
    4        	 *	the VAXIO routines, but do not do a lot of hard work.  Currently
    5        	 *	these are:
    6        	 *		gvg$special_read (fd)	- Returns index to vms termio block if fd needs special I/O
    7        	 *					  processing for read ops.
    8        	 *		gvg$special_fread (fp)	- Same as special_read but arg is a file pointer.
    9        	 *		gvg$special_write (fd)	- Returns index to vms termio block if fd needs special I/O
   10        	 *					  processing for write ops.
   11        	 *		gvg$special_fwrite (fp)	- Same as special_write but arg is a file pointer.
   12        	 *		gvg$do_flush_read (index)
   13        	 *					- Flushes input on channel.  Returns TRUE if flush was successful.
   14        	 *		gvg$do_flush_write (index)
   15        	 *					- Flushes output on channel.  Returns TRUE if flush was successful.
   16        	 *		gvg$do_qio_read1 (index, buff, buff_size)
   17        	 *					- Reads buff_size number of bytes into buff and returns the actual
   18        	 *					  number of bytes read.  The input is terminated when the specified
   19        	 *					  number of bytes (or an EOF) is read.  This is considered a direct
   20        	 *					  I/O operation.
   21        	 *		gvg$do_qio_readn (index, buff, buff_size, min_size)
   22        	 *					- Reads up to buff_size number of bytes into buff and returns the
   23        	 *					  actual number of bytes read.  This is a buffered input operation.
   24        	 *					  If an EOF condition is encountered before buff_size bytes have
   25        	 *					  been transfered to buff, the eof character is NOT appended and
   26        	 *					  the routine returns the actual number of characters read!
   27        	 *		gvg$do_qio_write (index, buff, buff_size)
   28        	 *					- Write buff_size number of characters from buff to chan.
   29        	 *		gvg$do_post (index, buff, nbytes)
   30        	 *					- Post process the buffer (usually after a read) according to
   31        	 *					  current terminal settings.
   32        	 */
   33        	 
   34        	# include	<ctype.h>
   67        	# include	<errno.h>
  110        	# include	<iodef.h>
  495        	# include	<ssdef.h>
  904        	# include	"sys_struct.h"
  944        	# include	<trmdef.h>
  997        	# include	"vmstermio.h"
 1291        	# define	bool	char
 1292        	# define	TRUE	(1)
 1293        	# define	FALSE	(0)
 1294        	 
 1295        	globalref struct vms_term_data		*vms_term_data_head;
 1296        	 
 1297        	# define	IFLAG(mask)	((index->termio->c_iflag & mask) != 0)
 1298        	# define	OFLAG(mask)	((index->termio->c_oflag & mask) != 0)
 1299        	 
 1300        	# define	CNT	index->_iobuf->_cnt
 1301        	# define	PTR	index->_iobuf->_ptr
 1302        	# define	BASE	index->_iobuf->_base
 1303        	# define	FLAG	index->_iobuf->_flag
 1304        	 
 1305        	struct vms_term_data *

GVG$SUPPORT                                                     30-MAR-1989 15:52:12    VAX C      V2.2-015                 Page 2
V1.0                                                            30-MAR-1989 15:48:49    GVG$SUPPORT.C;1 (1)

 1306        	gvg$special_read (fildes)
 1307        		int	fildes;
 1308        	{
 1309    1   		struct vms_term_data	*index;
 1310    1   	 
 1311    1   			/* Get the structure for this particular file descriptor. */
 1312    1   		for (index=vms_term_data_head;  index;  index=index->next)
 1313    1   		{	if (index->fildes == fildes)
 1314    2   			{	if (index->active)
 1315    3   					return (index);
 1316    3   				else
 1317    3   					return (0);
 1318    3   			}
 1319    2   		}
 1320    1   	 
 1321    1   			/* If it gets here, there is no structure yet.  (ioctl was not called yet.) */
 1322    1   		return (0);
 1323    1   	}
 1324        	 
 1325        	 
 1326        	 
 1327        	struct vms_term_data *
 1328        	gvg$special_fread (filptr)
 1329        		FILE	*filptr;
 1330        	{
 1331    1   		struct vms_term_data	*index;
 1332    1   	 
 1333    1   			/* Validate input parameter. */
 1334    1   		if (filptr < 0x200)
 1335    1   			return (0);
 1336    1   	 
 1337    1   			/* Get the structure for this particular file pointer. */
 1338    1   		for (index=vms_term_data_head;  index;  index=index->next)
 1339    1   		{	if (index->_iobuf == *filptr)
 1340    2   			{	if (index->active)
 1341    3   					return (index);
 1342    3   				else
 1343    3   					return (0);
 1344    3   			}
 1345    2   		}
 1346    1   	 
 1347    1   			/* If it gets here, there is no structure yet.  (ioctl was not called yet.) */
 1348    1   		return (0);
 1349    1   	}
 1350        	 
 1351        	 
 1352        	 
 1353        	struct vms_term_data *
 1354        	gvg$special_write (fildes)
 1355        		int	fildes;
 1356        	{
 1357    1   		struct vms_term_data	*index;
 1358    1   	 
 1359    1   			/* Get the structure for this particular file descriptor. */
 1360    1   		for (index=vms_term_data_head;  index;  index=index->next)
 1361    1   		{	if (index->fildes == fildes)
 1362    2   			{	if (!index->active)  return (0);

GVG$SUPPORT                                                     30-MAR-1989 15:52:12    VAX C      V2.2-015                 Page 3
V1.0                                                            30-MAR-1989 15:48:49    GVG$SUPPORT.C;1 (1)

 1363    3   				if (OFLAG (OLCUC) || OFLAG (OCRNL) || !OFLAG(ONLCR))
 1364    3   					return (index);
 1365    3   				else
 1366    3   					return (0);
 1367    3   			}
 1368    2   		}
 1369    1   	 
 1370    1   			/* If it gets here, there is no structure yet.  (ioctl was not called yet.) */
 1371    1   		return (0);
 1372    1   	}
 1373        	 
 1374        	 
 1375        	struct vms_term_data *
 1376        	gvg$special_fwrite (filptr)
 1377        		FILE	*filptr;
 1378        	{
 1379    1   		struct vms_term_data	*index;
 1380    1   	 
 1381    1   			/* Validate input parameter. */
 1382    1   		if (filptr < 0x200)
 1383    1   			return (0);
 1384    1   	 
 1385    1   			/* Get the structure for this particular file pointer. */
 1386    1   		for (index=vms_term_data_head;  index;  index=index->next)
 1387    1   		{	if (index->_iobuf == *filptr)
 1388    2   			{	if (!index->active)  return (0);
 1389    3   				if (OFLAG (OLCUC) || OFLAG (OCRNL) || !OFLAG(ONLCR))
 1390    3   					return (index);
 1391    3   				else
 1392    3   					return (0);
 1393    3   			}
 1394    2   		}
 1395    1   	 
 1396    1   			/* If it gets here, there is no structure yet.  (ioctl was not called yet.) */
 1397    1   		return (0);
 1398    1   	}
 1399        	 
 1400        	 
 1401        	gvg$do_flush_read (index)
 1402        		struct vms_term_data	*index;
 1403        	{
 1404    1   		unsigned short int	func=0;			/* QIO function code and modifiers. */
 1405    1   		unsigned short int	chan;			/* Channel for QIO. */
 1406    1   		unsigned int		p1=0, p2=0, p3=0;	/* QIO funciton dependent parameters. */
 1407    1   		struct iosb_struct	iosb;			/* I/O status block for call to QIO. */
 1408    1   		unsigned int		junk;			/* Buffer...just in case! */
 1409    1   	 
 1410    1   		func = IO$_READVBLK | IO$M_PURGE | IO$M_NOECHO | IO$M_TIMED;	/* Function value to flush buffer. */
 1411    1   		chan = index->vmstermio->chan;
 1412    1   		p1 = junk;		/* A buffer, just in case some data has to be written somewhere! */
 1413    1   		p2 = 0;			/* Indicate no room in buffer. */
 1414    1   		p3 = 0;			/* timeout value (immediate timeout). */
 1415    1   		if ((vaxc$errno = sys$qiow (0, chan, func, &iosb, 0, 0, p1, p2, p3, 0, 0, 0)) != SS$_NORMAL)
 1416    1   		{	if (vaxc$errno != SS$_TIMEOUT)
 1417    2   			{	errno = EVMSERR;
 1418    3   				return (FALSE);
 1419    3   			}

GVG$SUPPORT                                                     30-MAR-1989 15:52:12    VAX C      V2.2-015                 Page 4
V1.0                                                            30-MAR-1989 15:48:49    GVG$SUPPORT.C;1 (1)

 1420    2   		}
 1421    1   		if ((vaxc$errno = iosb.cond) != SS$_NORMAL)
 1422    1   		{	if (vaxc$errno != SS$_TIMEOUT)
 1423    2   			{	errno = EVMSERR;
 1424    3   				return (FALSE);
 1425    3   			}
 1426    2   		}
 1427    1   		CNT = 0;
 1428    1   		PTR = BASE;
 1429    1   		FLAG = 0;
 1430    1   	 
 1431    1   		return (TRUE);
 1432    1   	}
 1433        	 
 1434        	 
 1435        	gvg$do_flush_write (index)
 1436        		struct vms_term_data	*index;
 1437        	{
 1438    1   	/*
 1439    1   	 *	This function writes out any data that has been buffered, resets the
 1440    1   	 *	buffer pointers and returns TRUE upon successful completion.
 1441    1   	 */
 1442    1   		unsigned short int	func=0;			/* QIO function code and modifiers. */
 1443    1   		unsigned short int	chan;			/* Channel for QIO. */
 1444    1   		unsigned int		p1=0, p2=0;		/* QIO funciton dependent parameters. */
 1445    1   		struct iosb_struct	iosb;			/* I/O status block for call to QIO. */
 1446    1   		unsigned int		junk;			/* Buffer...just in case! */
 1447    1   	 
 1448    1   		if (PTR-BASE)
 1449    1   		{	chan = index->vmstermio->chan;
 1450    2   			func = IO$_WRITEVBLK;		/* The QIO function type. */
 1451    2   			p1 = BASE;			/* The output buffer. */
 1452    2   			p2 = PTR-BASE;
 1453    2   			if ((vaxc$errno = sys$qiow (0, chan, func, &iosb, 0, 0, p1, p2, 0, 0, 0, 0)) != SS$_NORMAL)
 1454    2   			{	errno = EVMSERR;
 1455    3   				FLAG |= _IOERR;
 1456    3   				CNT = BUFSIZ;
 1457    3   				PTR = BASE;
 1458    3   				return (FALSE);
 1459    3   			}
 1460    2   			else if ((vaxc$errno = iosb.cond) != SS$_NORMAL)
 1461    2   			{	errno = EVMSERR;
 1462    3   				FLAG |= _IOERR;
 1463    3   				CNT = BUFSIZ;
 1464    3   				PTR = BASE;
 1465    3   				return (FALSE);
 1466    3   			}
 1467    2   		}
 1468    1   	 
 1469    1   		CNT = BUFSIZ;
 1470    1   		PTR = BASE;
 1471    1   		return (TRUE);
 1472    1   	}
 1473        	 
 1474        	 
 1475        	gvg$do_qio_read1 (index, buff, buff_size)
 1476        		struct vms_term_data	*index;

GVG$SUPPORT                                                     30-MAR-1989 15:52:12    VAX C      V2.2-015                 Page 5
V1.0                                                            30-MAR-1989 15:48:49    GVG$SUPPORT.C;1 (1)

 1477        		char			*buff;
 1478        		int			buff_size;
 1479        	{
 1480    1   		unsigned short int	chan=0;			/* Channel for QIO. */
 1481    1   		unsigned short int	func=0;			/* QIO function code and modifiers. */
 1482    1   		char			*p1;			/* Buffer. */
 1483    1   		unsigned int		p2, p3, p4[2];		/* QIO funciton dependent parameters. */
 1484    1   		struct iosb_struct	iosb;			/* I/O status block for call to QIO. */
 1485    1   		bool			done;			/* True when EOF encountered. */
 1486    1   	 
 1487    1   			/* Set up the QIO parameters. */
 1488    1   		chan = index->vmstermio->chan;			/* This is the channel to operate on. */
 1489    1   		func = IO$_READVBLK | IO$M_NOFILTR;		/* The QIO function type (no line editing). */
 1490    1   		p2 = 1;						/* Indicate buffer size, get one character at a time. */
 1491    1   		p3 = 0;						/* Timout value...not used. */
 1492    1   		p4[0] = 0;					/* Indicate short form for terminator mask. */
 1493    1   		p4[1] = 0xffffffff;				/* All control characters are terminators. */
 1494    1   	 
 1495    1   			/* Issue the QIO and process any possible errors. */
 1496    1   		for (done=FALSE, p1=buff;  p1 < &(buff[buff_size]);  p1++)
 1497    1   		{	if ((vaxc$errno = sys$qiow (0, chan, func, &iosb, 0, 0, p1, p2, p3, &p4, 0, 0)) != SS$_NORMAL)
 1498    2   			{	errno = EVMSERR;
 1499    3   				FLAG |= _IOERR;
 1500    3   				return (0);
 1501    3   			}
 1502    2   			if ((vaxc$errno = iosb.cond) != SS$_NORMAL)
 1503    2   			{	errno = EVMSERR;
 1504    3   				FLAG |= _IOERR;
 1505    3   				return (0);
 1506    3   			}
 1507    2   			if (*p1 == (char)0x1a  &&  OFLAG(OPOST))
 1508    2   			{	done = TRUE;		/* CTRL-Z */
 1509    3   				FLAG |= _IOEOF;
 1510    3   			}
 1511    2   		}
 1512    1   	 
 1513    1   			/* Return the number of bytes actually read. */
 1514    1   		if (done)
 1515    1   			return (0);
 1516    1   		else
 1517    1   			return (p1-buff);
 1518    1   	}
 1519        	 
 1520        	 
 1521        	gvg$do_qio_readn (index, buff, buff_size, min_size)
 1522        		struct vms_term_data	*index;
 1523        		char			*buff;
 1524        		int			buff_size;
 1525        		int			min_size;		/* Minimum # bytes to be read in. */
 1526        	{
 1527    1   		unsigned short int	chan=0;			/* Channel for QIO. */
 1528    1   		unsigned short int	func=0;			/* QIO function code and modifiers. */
 1529    1   		unsigned int		p1, p2, p3, p4, p5, p6;	/* QIO funciton dependent parameters. */
 1530    1   		struct iosb_struct	iosb;			/* I/O status block for call to QIO. */
 1531    1   		struct item_list_struct	item_list[2] =	{	/* Item list for extended read function. */
 1532    1   							    { 0, TRM$_MODIFIERS, TRM$M_TM_NOEDIT | TRM$M_TM_NORECALL, 0 },
 1533    1   							    { 0, TRM$_TERM, 0, 0 },

GVG$SUPPORT                                                     30-MAR-1989 15:52:12    VAX C      V2.2-015                 Page 6
V1.0                                                            30-MAR-1989 15:48:49    GVG$SUPPORT.C;1 (1)

 1534    1   							};
 1535    1   		bool			done;			/* True when its O.K. to exit read loop. */
 1536    1   		bool			EOF_seen=FALSE;		/* True if EOF terminator seen. */
 1537    1   		char			*ptr;			/* Pointer into user buffer. */
 1538    1   	 
 1539    1   			/* Set up the QIO parameters. */
 1540    1   		chan = index->vmstermio->chan;			/* This is the channel to operate on. */
 1541    1   		func = IO$_READVBLK | IO$M_EXTEND;		/* The QIO function type (with itemlist read). */
 1542    1   		p1 = (unsigned int) BASE;			/* Base of internal buffer. */
 1543    1   		p2 = BUFSIZ;					/* Indicate internal buffer size. */
 1544    1   		p3 = 0;						/* Timout value...not used. */
 1545    1   		p4 = 0;
 1546    1   		item_list[1].buff_len = 0;			/* Indicate short form for terminator mask. */
 1547    1   		item_list[1].buff_addr = 1 << 26;		/* CTRL-Z is always a terminator. */
 1548    1   		if (IFLAG(ICRNL)) item_list[1].buff_addr |= 1 << '\r';	/* CR is a terminator in this case. */
 1549    1   		if (!IFLAG(INLCR)) item_list[1].buff_addr |= 1 << '\n';	/* NL is a terminator in this case. */
 1550    1   		p5 = (unsigned int) item_list;
 1551    1   		p6 = sizeof(item_list);
 1552    1   	 
 1553    1   			/* Transfer buffered input to user buffer until buffered input gone or
 1554    1   			   a terminator is seen. */
 1555    1   		for (done=FALSE, ptr=buff;  !done && (ptr < &(buff[buff_size]));  CNT--, PTR++, ptr++)
 1556    1   		{	if (!CNT)	/* No buffered input left...get some more! */
 1557    2   					/* Issue the QIO and process any possible errors. */
 1558    2   			{	if ((vaxc$errno = sys$qiow (0, chan, func, &iosb, 0, 0, p1,p2,p3,p4,p5,p6)) != SS$_NORMAL)
 1559    3   				{	errno = EVMSERR;
 1560    4   					FLAG |= _IOERR;
 1561    4   					return (ptr-buff);
 1562    4   				}
 1563    3   				if ((vaxc$errno = iosb.cond) != SS$_NORMAL)
 1564    3   				{	errno = EVMSERR;
 1565    4   					FLAG |= _IOERR;
 1566    4   					return (ptr-buff);
 1567    4   				}
 1568    3   				PTR = BASE;
 1569    3   				CNT = iosb.variant.read.offset + iosb.variant.read.term_size;
 1570    3   			}
 1571    2   			*ptr = *PTR;
 1572    2   			if (*ptr < 32)	/* Possible terminator. */
 1573    2   			{	if ((1 << *ptr) & item_list[1].buff_addr)	/* It IS a terminator! */
 1574    3   					if (ptr >= &(buff[min_size-1]))
 1575    3   						done = TRUE;
 1576    3   				if (*ptr == 26)
 1577    3   					EOF_seen = TRUE;
 1578    3   			}
 1579    2   		}
 1580    1   		if (EOF_seen)	/* EOF character is never returned in buffered read. */
 1581    1   		{	ptr--;
 1582    2   			FLAG |= _IOEOF;
 1583    2   		}
 1584    1   	 
 1585    1   			/* Return the number of bytes actually read. */
 1586    1   		return (ptr-buff);
 1587    1   	}
 1588        	 
 1589        	 
 1590        	gvg$do_qio_write (index, buff, nbytes)

GVG$SUPPORT                                                     30-MAR-1989 15:52:12    VAX C      V2.2-015                 Page 7
V1.0                                                            30-MAR-1989 15:48:49    GVG$SUPPORT.C;1 (1)

 1591        		struct vms_term_data	*index;
 1592        		char			*buff;
 1593        		int			nbytes;
 1594        	{
 1595    1   		unsigned short int	chan;			/* QIO channel number. */
 1596    1   		unsigned short int	func=0;			/* QIO function code and modifiers. */
 1597    1   		unsigned int		p1=0, p2=0;		/* QIO funciton dependent parameters. */
 1598    1   		struct iosb_struct	iosb;			/* I/O status block for call to QIO. */
 1599    1   		int			bytes_written=0;	/* Total number of bytes currently written. */
 1600    1   		char			*ptr, och;
 1601    1   	 
 1602    1   			/* Set up the QIO parameters. */
 1603    1   		chan = index->vmstermio->chan;	/* The QIO channel number. */
 1604    1   		func = IO$_WRITEVBLK;		/* The QIO function type. */
 1605    1   		p1 = BASE;			/* The output buffer. */
 1606    1   	 
 1607    1   			/* Validate the output buffer. */
 1608    1   		if (PTR == 0  || CNT == 0)
 1609    1   		{	PTR = BASE;
 1610    2   			CNT = BUFSIZ;
 1611    2   		}
 1612    1   	 
 1613    1   		for (ptr=buff;  ptr < &(buff[nbytes]);  ptr++, PTR++, CNT--)
 1614    1   		{		/* Xfer data to output buffer and convert if necessary. */
 1615    2   			och = *PTR = *ptr;
 1616    2   			if (OFLAG(ONLCR)  &&  och == '\n')
 1617    2   			{	*PTR++ = '\r';  CNT--;
 1618    3   				*PTR = '\n';
 1619    3   			}
 1620    2   			if (OFLAG(OCRNL)  &&  och == '\r')
 1621    2   				*PTR = '\n';
 1622    2   			if (OFLAG(OLCUC)  &&  islower(och))
 1623    2   				*PTR = _toupper(och);
 1624    2   	 
 1625    2   				/* Write the temporary buffer if it's full, done with I/O and un-buffered, or
 1626    2   				   buffered w/ newline and character is \n. */
 1627    2   			if ((CNT <= 1) ||
 1628    2   			    ((ptr == &(buff[nbytes-1])) && ((FLAG&_IONBF) != 0)) ||
 1629    2   			    ((FLAG&_IONBF)==0 && OFLAG(ONLCR) && *PTR=='\n') )
 1630    2   			{		/* Issue the QIO and process any possible errors. */
 1631    3   				p2 = PTR-BASE + 1;
 1632    3   				if ((vaxc$errno = sys$qiow (0, chan, func, &iosb, 0, 0, p1, p2, 0, 0, 0, 0)) != SS$_NORMAL)
 1633    3   				{	errno = EVMSERR;
 1634    4   					FLAG |= _IOERR;
 1635    4   					CNT = BUFSIZ;
 1636    4   					PTR = BASE;
 1637    4   					return (ptr-buff);
 1638    4   				}
 1639    3   				else if ((vaxc$errno = iosb.cond) != SS$_NORMAL)
 1640    3   				{	errno = EVMSERR;
 1641    4   					FLAG |= _IOERR;
 1642    4   					CNT = BUFSIZ;
 1643    4   					PTR = BASE;
 1644    4   					return (ptr-buff);
 1645    4   				}
 1646    3   				CNT = BUFSIZ+1;			/* Will get decremented at end of loop! */
 1647    3   				PTR = BASE;  PTR--;		/* Will get incremented at end of loop! */

GVG$SUPPORT                                                     30-MAR-1989 15:52:12    VAX C      V2.2-015                 Page 8
V1.0                                                            30-MAR-1989 15:48:49    GVG$SUPPORT.C;1 (1)

 1648    3   			}
 1649    2   		}
 1650    1   	 
 1651    1   			/* Return the number of bytes actually written. */
 1652    1   		return (ptr-buff);
 1653    1   	}
 1654        	 
 1655        	 
 1656        	gvg$do_post (index, buff, nbytes)
 1657        		struct vms_term_data	*index;		/* Pointer to I/O structure. */
 1658        		char			*buff;		/* Buffer that holds data to be post processed. */
 1659        		int			nbytes;		/* Number of bytes to post process. */
 1660        	{
 1661    1   		char	*ptr, och;
 1662    1   	 
 1663    1   		if ( IFLAG(INLCR) || IFLAG(IUCLC) || IFLAG(ICRNL) )
 1664    1   		{	for (ptr=buff;  ptr < &(buff[nbytes]);  ptr++)
 1665    2   			{	och = *ptr;
 1666    3   				if (IFLAG(INLCR) && och=='\n')
 1667    3   					*ptr = '\r';
 1668    3   				if (IFLAG(IUCLC) && isupper(och))
 1669    3   					*ptr = _tolower(och);
 1670    3   				if (IFLAG(ICRNL) && och == '\r')
 1671    3   					*ptr = '\n';
 1672    3   			}
 1673    2   		}
 1674    1   	}
 1675        	/*	
 1676        	/*	
 1677        	/*	void
 1678        	/*	startbuf (fildes)
 1679        	/*		int	fildes;
 1680        	/*	{
 1681        	/*		struct vms_term_data	*index;
 1682        	/*	
 1683        	/*			/* Get the structure for this particular file descriptor. */
 1684        	/*		for (index=vms_term_data_head;  index;  index=index->next)
 1685        	/*		{	if (index->fildes == fildes)
 1686        	/*			{	if (index->active)
 1687        	/*				{	FLAG &= ~_IONBF;
 1688        	/*					return;
 1689        	/*				}
 1690        	/*			}
 1691        	/*		}
 1692        	/*	}
 1693        	/*	
 1694        	/*	
 1695        	/*	void
 1696        	/*	endbuf (fildes)
 1697        	/*		int	fildes;
 1698        	/*	{
 1699        	/*		struct vms_term_data	*index;
 1700        	/*	
 1701        	/*			/* Get the structure for this particular file descriptor. */
 1702        	/*		for (index=vms_term_data_head;  index;  index=index->next)
 1703        	/*		{	if (index->fildes == fildes)
 1704        	/*			{	if (index->active)

GVG$SUPPORT                                                     30-MAR-1989 15:52:12    VAX C      V2.2-015                 Page 9
V1.0                                                            30-MAR-1989 15:48:49    GVG$SUPPORT.C;1 (1)

 1705        	/*				{	FLAG |= _IONBF;
 1706        	/*					return;
 1707        	/*				}
 1708        	/*			}
 1709        	/*		}
 1710        	/*	}
 1711        	 */

 
 
Command Line
------------
 
CC/LIST GVG$SUPPORT.C+SUPPORT.C

