Return to bio.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / pits

Power 6/32 Unix version 1.21

#include "definitions"
#define LINE	80
#define CRTN	0x0d
#define EOL	'.'
int cyccnt;

/*	I/O ROUTINES TO CPU2 CONSOLE 	*/

writec(c)
char c;
{
	putchar(c);
}

writes(s)
char *s;
{
	putstr(s);
}

writeh(ix)	/* 32 bits HEX */
long ix;
{	register long count, mask, indx;
	char c, str[9];

	if (ix==0) { writec('0'); return; }
	indx = 0; count = 28;
	mask = 0xf0000000;
	str[8]='\0';
	while (mask)  {
		c = ( (ix&mask) >> count )&0xf;
		count -= 4;
		if (indx==0) mask = 0xf000000;
			else mask = mask >> 4;
		if ((c>=0)&&(c<=9)) c=c+'0';
			else c=c+'7';
		str[indx++] = c;
		}
	/* replace leading 0 with space */
	for (indx=0; indx<8; indx++) {
		if (str[indx]!='0') break;
			/* esle str[indx]=' '; */
		}
	writes(&str[indx]);
}

/* 	Function to write a 32_bit decimal to Console
*/
writed(ix)
long ix;
{	char c;
	register long div, lead0;

	if (ix==0) { writec('0'); return; }
	if (ix<0) { writec('-'); ix = (~ix)+1; }
	lead0 = 1;
	div = 1000000000;
	while (div) {
		c = (ix/div)+'0';
		ix = ix%div;		/* Mod */
		div /= 10;
		if ((c=='0')&&(lead0)) c=' ';
			else lead0 = 0;
		if (c != ' ') writec(c);
		}
}

/*	Function read 1 char from Console
*/
char readc()
{	char c, rdchar();

	writec(c = rdchar());
	return(c);
}

/*	This function read a string of characters.
	calling sequence : nochar = reads(s);
	input argument   : char *s;
	return value     : no. of char read; excluding NULL or CR.
*/
reads(s)
char *s;
{	register long ix;

	for(ix=0;;ix++) {
		*s = readc();
		if ((*s==NULL)||(*s==CR)) 
			{ *s = NULL; break; }
		     else s++;
		}
	return(ix);
}


/*	This function read a string of HEX digit and
	convert it to integer value.
	calling sequence : stat = readh(ix);
	input parameter  : long *ix;
	return value     : (stat < 0) if error else (stat = 0);
*/
/*
readh(ix)	
long *ix;
{	char line[ALINE], *getnum(), *del;
	int nochar;

	if ( (nochar = reads(line)) > 8 ) return(-1);
	if ( (del = getnum(line,ix,del,HEX)) < 0 ) return(-1);
		else return(0);
}

*/




/*	This function read a string of DEC digit and
	convert it to integer value.
	calling sequence : stat = readd(ix);
	input parameter  : long *ix;
	return value     : (stat < 0) if error else (stat = 0);
*/

/*
readd(ix)	
long *ix;
{	char line[ALINE], *getnum(), *del;
	int nochar;

	if ( (nochar = reads(line)) > 11 ) return(-1);
	if ( (del = getnum(line,ix,del,DEC)) < 0 ) return(-1);
		else return(0);
}
*/
echo(c)		/* routine to get a test number, validate it 
	  	   and set bits in a flag word.           */

int c;

{

#define ALL 0x8
#define MT 0xe
#define VIOC 0xd
#define VDDC 0xb
#define EXIT 0x7

int flag, valid;

flag = 0;
valid = 1;

while (valid){ 
	c = readc();
	switch(c){
	case '0':
		flag |= ALL;
		valid = 0;
		break;
	case '1':
		flag |= MT;
		valid = 0;
		break;
	case '2':
		flag |= VIOC;
		valid = 0;
		break;
	case '3':
		flag |= VDDC;
		valid = 0;
		break;
	case '4':
		flag |= EXIT;
		valid = 0;
		break;
	default:
		writes(" invalid test number\n");
		writes("\nRe-enter test number : ");
		valid = 1;
		break;
		}
	}
c = flag;
return(c);
}
getcont(c)	/* routine to get controller number */
int c;
{
int valid, cont;
valid = 1;
writes("\n\nController number [0-7] : ");
while(valid){
	c = readc();
	switch(c){
	case '0':
		cont = 0;
		valid = 0;
		break;
	case '1':
		cont = 1;
		valid = 0;
		break;
	case '2':
		cont = 2;
		valid = 0;
		break;
	case '3':
		cont = 3;
		valid = 0;
		break;
	case '4':
		cont = 4;
		valid = 0;
		break;
	case '5':
		cont = 5;
		valid = 0;
		break;
	case '6':
		cont = 6;
		valid = 0;
		break;
	case '7':
		cont = 7;
		valid = 0;
		break;
	default:
		writes(" invalid controller number\n");
		writes("\nRe-enter controller number : ");
		valid = 1;
		break;
		}
	}
return(cont);
}
gettype(c)	/* routine to get type of disk */
int c;
{
int valid, type;
valid = 1;
cyccnt = 30;
writes("\n\nEnter disk type [0 = fsd, 1 = smd, 2 = xfd, 3 = xsd] : ");
while(valid){
	c = readc();
	switch(c){
	case '0':
		type = 0;
		valid = 0;
		break;  
	case '1':
		type = 1;
		valid = 0;
		break;
	case '2':
		type = 2;
		valid = 0;
		break;
	case '3':
		type = 3;
		valid = 0;
		break;
	default:
		writes(" invalid disk type\n");
		writes("\nRe-enter disk type : ");
		valid = 1;
		break;
		}
	}
	writes("\n\nEnter number of cycles for seek test (default 30): ");
	c = getdec();
	if (c != 0) cyccnt = c;
return(type);
}
	/**********************************************************
	Hex input routine, call fill and validates the characters
	in the character buffer. Then returns the HEX value back to 
	the calling routine.
	**********************************************************/
gethex() 
{
	char s[LINE];
	int k[1],i,n;
	n=0x0;
	fill(s,k);			/* Fill s[] */ 
	for (i=0;i<k[0];++i) {
         if (s[i] >= 'a' && s[i] <= 'f')
	 n=0x10*n+s[i]-'W';
	 if (s[i] >= 'A' && s[i] <= 'F')
	 n=0x10*n+s[i]-'7';
	 if (s[i] >= '0' && s[i] <= '9')
	 n=0x10*n+s[i]-'0';
	 if ((s[i] < '0' ) || (s[i] > '9' && s[i] < 'A') || (s[i]  > 'F' 
	     && s[i] < 'a') || (s[i] > 'f')) 
	 {
	 writes("\nInvalid hex digit: "); writec(s[i]); writes(" (ignored)");
	 }
	}
	return(n);
}
	/**********************************************************
	Decimal input routine, call fill and validates the characters
	in the character buffer. Then returns the DECIMAL value back to 
	the calling routine.
	**********************************************************/
getdec()
{
	char s[LINE];
	int k[1],i,n;
	n=0;
	fill(s,k);			/* Fill s[] */ 
	for (i=0;i<k[0];++i) {
	 if (s[i] >= '0' && s[i] <= '9')
		 n=0x10*n+s[i]-'0';
	 if ((s[i] < '0' ) || (s[i] > '9'))
	 {
	 writes("\nInvalid decimal digit: "); writec(s[i]); writes(" (ignored)");
	 }
	}
	return(n);
}
	/****************************************************
	This routine fills a character buffer with characters
	that are input on the console.
	****************************************************/
fill(s,k)
char s[];
int k[];
{
	char c;
	int i;
	k[0]=0;
	for (i=0;(c=readc())!=CRTN;++i)
	{
	if (k[0]>LINE - 1) break;
	if (c==EOL)        break;
	s[i]=c;
	++k[0];
	}
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.