![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / pits|
Return to bio.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / pits |
1.1 root 1:
2: #include "definitions"
3: #define LINE 80
4: #define CRTN 0x0d
5: #define EOL '.'
6:
7: /* I/O ROUTINES TO CPU2 CONSOLE */
8:
9: writec(c)
10: char c;
11: {
12: putchar(c);
13: }
14:
15: writes(s)
16: char *s;
17: {
18: putstr(s);
19: }
20:
21: writeh(ix) /* 32 bits HEX */
22: long ix;
23: { register long count, mask, indx;
24: char c, str[9];
25:
26: if (ix==0) { writec('0'); return; }
27: indx = 0; count = 28;
28: mask = 0xf0000000;
29: str[8]='\0';
30: while (mask) {
31: c = ( (ix&mask) >> count )&0xf;
32: count -= 4;
33: if (indx==0) mask = 0xf000000;
34: else mask = mask >> 4;
35: if ((c>=0)&&(c<=9)) c=c+'0';
36: else c=c+'7';
37: str[indx++] = c;
38: }
39: /* replace leading 0 with space */
40: for (indx=0; indx<8; indx++) {
41: if (str[indx]!='0') break;
42: /* esle str[indx]=' '; */
43: }
44: writes(&str[indx]);
45: }
46:
47: /* Function to write a 32_bit decimal to Console
48: */
49: writed(ix)
50: long ix;
51: { char c;
52: register long div, lead0;
53:
54: if (ix==0) { writec('0'); return; }
55: if (ix<0) { writec('-'); ix = (~ix)+1; }
56: lead0 = 1;
57: div = 1000000000;
58: while (div) {
59: c = (ix/div)+'0';
60: ix = ix%div; /* Mod */
61: div /= 10;
62: if ((c=='0')&&(lead0)) c=' ';
63: else lead0 = 0;
64: if (c != ' ') writec(c);
65: }
66: }
67:
68: /* Function read 1 char from Console
69: */
70: char readc()
71: { char c, rdchar();
72:
73: writec(c = rdchar());
74: return(c);
75: }
76:
77: /* This function read a string of characters.
78: calling sequence : nochar = reads(s);
79: input argument : char *s;
80: return value : no. of char read; excluding NULL or CR.
81: */
82: reads(s)
83: char *s;
84: { register long ix;
85:
86: for(ix=0;;ix++) {
87: *s = readc();
88: if ((*s==NULL)||(*s==CR))
89: { *s = NULL; break; }
90: else s++;
91: }
92: return(ix);
93: }
94:
95:
96: /* This function read a string of HEX digit and
97: convert it to integer value.
98: calling sequence : stat = readh(ix);
99: input parameter : long *ix;
100: return value : (stat < 0) if error else (stat = 0);
101: */
102: /*
103: readh(ix)
104: long *ix;
105: { char line[ALINE], *getnum(), *del;
106: int nochar;
107:
108: if ( (nochar = reads(line)) > 8 ) return(-1);
109: if ( (del = getnum(line,ix,del,HEX)) < 0 ) return(-1);
110: else return(0);
111: }
112:
113: */
114:
115:
116:
117:
118: /* This function read a string of DEC digit and
119: convert it to integer value.
120: calling sequence : stat = readd(ix);
121: input parameter : long *ix;
122: return value : (stat < 0) if error else (stat = 0);
123: */
124:
125: /*
126: readd(ix)
127: long *ix;
128: { char line[ALINE], *getnum(), *del;
129: int nochar;
130:
131: if ( (nochar = reads(line)) > 11 ) return(-1);
132: if ( (del = getnum(line,ix,del,DEC)) < 0 ) return(-1);
133: else return(0);
134: }
135: */
136: echo(c) /* routine to get a test number, validate it
137: and set bits in a flag word. */
138:
139: int c;
140:
141: {
142:
143: #define ALL 00
144: #define VDDC 03
145: #define VIOC 05
146: #define MT 06
147:
148: int flag, valid;
149:
150: flag = 0;
151: valid = 1;
152:
153: while (valid){
154: c = readc();
155: switch(c){
156: case '0':
157: flag |= ALL;
158: valid = 0;
159: break;
160: case '1':
161: flag |= MT;
162: valid = 0;
163: break;
164: case '2':
165: flag |= VIOC;
166: valid = 0;
167: break;
168: case '3':
169: flag |= VDDC;
170: valid = 0;
171: break;
172: default:
173: writes(" invalid test number\n");
174: writes("\nRe-enter test number : ");
175: valid = 1;
176: break;
177: }
178: }
179: c = flag;
180: return(c);
181: }
182: getcont(c) /* routine to get controller number */
183: int c;
184: {
185: int valid, cont;
186: valid = 1;
187: writes("\n\nController number [0-3] : ");
188: while(valid){
189: c = readc();
190: switch(c){
191: case '0':
192: cont = 0;
193: valid = 0;
194: break;
195: case '1':
196: cont = 1;
197: valid = 0;
198: break;
199: case '2':
200: cont = 2;
201: valid = 0;
202: break;
203: case '3':
204: cont = 3;
205: valid = 0;
206: break;
207: default:
208: writes(" invalid controller number\n");
209: writes("\nRe-enter controller number : ");
210: valid = 1;
211: break;
212: }
213: }
214: return(cont);
215: }
216: gettype(c) /* routine to get type of disk */
217: int c;
218: {
219: int valid, type;
220: valid = 1;
221: writes("\n\nDisk type [0 = fsd, 1 = smd, 2 = xfd] : ");
222: while(valid){
223: c = readc();
224: switch(c){
225: case '0':
226: type = 0;
227: valid = 0;
228: break;
229: case '1':
230: type = 1;
231: valid = 0;
232: break;
233: case '2':
234: type = 2;
235: valid = 0;
236: break;
237: default:
238: writes(" invalid disk type\n");
239: writes("\nRe-enter disk type : ");
240: valid = 1;
241: break;
242: }
243: }
244: return(type);
245: }
246: /**********************************************************
247: Hex input routine, call fill and validates the characters
248: in the character buffer. Then returns the HEX value back to
249: the calling routine.
250: **********************************************************/
251: gethex()
252: {
253: char s[LINE];
254: int k[1],i,n;
255: n=0x0;
256: fill(s,k); /* Fill s[] */
257: for (i=0;i<k[0];++i) {
258: if (s[i] >= 'a' && s[i] <= 'f')
259: n=0x10*n+s[i]-'W';
260: if (s[i] >= 'A' && s[i] <= 'F')
261: n=0x10*n+s[i]-'7';
262: if (s[i] >= '0' && s[i] <= '9')
263: n=0x10*n+s[i]-'0';
264: if ((s[i] < '0' ) || (s[i] > '9' && s[i] < 'A') || (s[i] > 'F'
265: && s[i] < 'a') || (s[i] > 'f'))
266: {
267: writes("\nInvalid hex digit: "); writec(s[i]); writes(" (ignored)");
268: }
269: }
270: return(n);
271: }
272: /****************************************************
273: This routine fills a character buffer with characters
274: that are input on the console.
275: ****************************************************/
276: fill(s,k)
277: char s[];
278: int k[];
279: {
280: char c;
281: int i;
282: k[0]=0;
283: for (i=0;(c=readc())!=CRTN;++i)
284: {
285: if (k[0]>LINE - 1) break;
286: if (c==EOL) break;
287: s[i]=c;
288: ++k[0];
289: }
290: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.