![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bio.lst 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 / macro4|
Return to bio.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 root 1: 1 00000000 LL0:
2: 2 00000000 .data
3: 3 00000234 * .set SBR,0
4: 4 00000234 * .set SLR,1
5: 5 00000234 * .set P0BR,2
6: 6 00000234 * .set P0LR,3
7: 7 00000234 * .set P1BR,4
8: 8 00000234 * .set P1LR,5
9: 9 00000234 * .set P2BR,6
10: 10 00000234 * .set P2LR,7
11: 11 00000234 * .set IPL,8
12: 12 00000234 * .set MAPEN,9
13: 13 00000234 * .set MME,9
14: 14 00000234 * .set TBIA,10
15: 15 00000234 * .set TBIS,11
16: 16 00000234 * .set DCK,12
17: 17 00000234 * .set CCK,13
18: 18 00000234 * .set PCBB,14
19: 19 00000234 * .set KSP,19
20: 20 00000234 * .set USP,20
21: 21 00000234 * .set CPMDCB,21
22: 22 00000234 * .set PADC,25
23: 23 00000234 * .set DCR,27
24: 24 00000234 * .set DC_ON,1
25: 25 00000234 * .set DC_OFF,2
26: 26 00000234 * .text
27: 27 00000000 .align 1
28: 28 00000000 .globl _writec
29: 29 00000000 _writec:
30: 30 0000BA54 0000 .word L12
31: 31 0000BA56 #
32: 32 0000BA56 #
33: 33 0000BA56 # #include "definitions"
34: 34 0000BA56 #
35: 35 0000BA56 # /* I/O ROUTINES TO CPU2 CONSOLE */
36: 36 0000BA56 #
37: 37 0000BA56 # writec(c)
38: 38 0000BA56 # char c;
39: 39 0000BA56 # {
40: 40 0000BA56 11 0b jbr L14
41: 41 0000BA58 L15:
42: 42 0000BA58 # putchar(c);
43: 43 0000BA58 d9 ad07 pushb 7(fp)
44: 44 0000BA5B fe 08 effffffff2 callf $8,_putchar
45: 45 0000BA62 # }
46: 46 0000BA62 40 ret#2
47: 47 0000BA63 .set L12,0x0
48: 48 0000BA63 L14:
49: 49 0000BA63 11 f3 jbr L15
50: 50 0000BA65 .data
51: 51 00000234 * .text
52: 52 0000BA65 00 .align 1
53: 53 0000BA66 .globl _writes
54: 54 0000BA66 _writes:
55: 55 0000BA66 0000 .word L18
56: 56 0000BA68 #
57: 57 0000BA68 #
58: 58 0000BA68 # writes(s)
59: 59 0000BA68 # char *s;
60: 60 0000BA68 # {
61: 61 0000BA68 11 0b jbr L20
62: 62 0000BA6A L21:
63: 63 0000BA6A # putstr(s);
64: 64 0000BA6A dd ad04 pushl 4(fp)
65: 65 0000BA6D fe 08 efffffffe0 callf $8,_putstr
66: 66 0000BA74 # }
67: 67 0000BA74 40 ret#2
68: 68 0000BA75 .set L18,0x0
69: 69 0000BA75 L20:
70: 70 0000BA75 11 f3 jbr L21
71: 71 0000BA77 .data
72: 72 00000234 * .text
73: 73 0000BA77 00 .align 1
74: 74 0000BA78 .globl _writeh
75: 75 0000BA78 _writeh:
76: 76 0000BA78 1c00 .word L24
77: 77 0000BA7A #
78: 78 0000BA7A #
79: 79 0000BA7A # writeh(ix) /* 32 bits HEX */
80: 80 0000BA7A # long ix;
81: 81 0000BA7A # { register long count, mask, indx;
82: 82 0000BA7A 13 00a3 jbr L26
83: 83 0000BA7D L27:
84: 84 0000BA7D # char c, str[9];
85: 85 0000BA7D #
86: 86 0000BA7D # if (ix==0) { writec('0'); return; }
87: 87 0000BA7D 5d ad04 tstl 4(fp)
88: 88 0000BA80 21 0a jneq L28
89: 89 0000BA82 dd 30 pushl $48
90: 90 0000BA84 fe 08 efffffffc9 callf $8,_writec
91: 91 0000BA8B 40 ret#2
92: 92 0000BA8C # indx = 0; count = 28;
93: 93 0000BA8C L28:
94: 94 0000BA8C 4d 5a clrl r10
95: 95 0000BA8E 0d 1c 5c movl $28,r12
96: 96 0000BA91 # mask = 0xf0000000;
97: 97 0000BA91 0d 8ff0000000 5b movl $-268435456,r11
98: 98 0000BA98 # str[8]='\0';
99: 99 0000BA98 49 adc4 clrb -60(fp)
100: 100 0000BA9B # while (mask) {
101: 101 0000BA9B L29:
102: 102 0000BA9B 5d 5b tstl r11
103: 103 0000BA9D 31 54 jeql L30
104: 104 0000BA9F # c = ( (ix&mask) >> count )&0xf;
105: 105 0000BA9F bc 5b ad04 50 andl3 r11,4(fp),r0
106: 106 0000BAA4 5e 5c 50 50 shar r12,r0,r0
107: 107 0000BAA8 ac 0f 50 andl2 $15,r0
108: 108 0000BAAB 6f 50 adc8 cvtlb r0,-56(fp)
109: 109 0000BAAF # count -= 4;
110: 110 0000BAAF 2c 04 5c subl2 $4,r12
111: 111 0000BAB2 # if (indx==0) mask = 0xf000000;
112: 112 0000BAB2 5d 5a tstl r10
113: 113 0000BAB4 21 09 jneq L31
114: 114 0000BAB6 0d 8f0f000000 5b movl $251658240,r11
115: 115 0000BABD # else mask = mask >> 4;
116: 116 0000BABD 11 07 jbr L32
117: 117 0000BABF L31:
118: 118 0000BABF 5e 04 5b 50 shar $4,r11,r0
119: 119 0000BAC3 0d 50 5b movl r0,r11
120: 120 0000BAC6 L32:
121: 121 0000BAC6 # if ((c>=0)&&(c<=9)) c=c+'0';
122: 122 0000BAC6 59 adc8 tstb -56(fp)
123: 123 0000BAC9 91 13 jlss L33
124: 124 0000BACB 19 adc8 09 cmpb -56(fp),$9
125: 125 0000BACF 41 0d jgtr L33
126: 126 0000BAD1 89 adc8 50 cvtbl -56(fp),r0
127: 127 0000BAD5 0c 30 50 addl2 $48,r0
128: 128 0000BAD8 6f 50 adc8 cvtlb r0,-56(fp)
129: 129 0000BADC # else c=c+'7';
130: 130 0000BADC 11 0b jbr L34
131: 131 0000BADE L33:
132: 132 0000BADE 89 adc8 50 cvtbl -56(fp),r0
133: 133 0000BAE2 0c 37 50 addl2 $55,r0
134: 134 0000BAE5 6f 50 adc8 cvtlb r0,-56(fp)
135: 135 0000BAE9 L34:
136: 136 0000BAE9 # str[indx++] = c;
137: 137 0000BAE9 09 adc8 4aadbc movb -56(fp),-68(fp)[r10]
138: 138 0000BAEF 6d 5a incl r10
139: 139 0000BAF1 # }
140: 140 0000BAF1 11 a8 jbr L29
141: 141 0000BAF3 L30:
142: 142 0000BAF3 # indx = 0;
143: 143 0000BAF3 4d 5a clrl r10
144: 144 0000BAF5 # /* replace leading 0 with space */
145: 145 0000BAF5 # for (indx=0; indx<8; indx++) {
146: 146 0000BAF5 4d 5a clrl r10
147: 147 0000BAF7 L37:
148: 148 0000BAF7 1d 5a 08 cmpl r10,$8
149: 149 0000BAFA 81 12 jgeq L36
150: 150 0000BAFC # if (str[indx]!='0') break;
151: 151 0000BAFC 19 4aadbc 30 cmpb -68(fp)[r10],$48
152: 152 0000BB01 31 02 jeql L38
153: 153 0000BB03 11 09 jbr L36
154: 154 0000BB05 # else str[indx]=' ';
155: 155 0000BB05 L38:
156: 156 0000BB05 6f 20 4aadbc cvtlb $32,-68(fp)[r10]
157: 157 0000BB0A # }
158: 158 0000BB0A L35:
159: 159 0000BB0A 6d 5a incl r10
160: 160 0000BB0C 11 e9 jbr L37
161: 161 0000BB0E L36:
162: 162 0000BB0E # writes(&str[indx]);
163: 163 0000BB0E 3c 8844 5d 50 subl3 $68,fp,r0
164: 164 0000BB13 0c 5a 50 addl2 r10,r0
165: 165 0000BB16 dd 50 pushl r0
166: 166 0000BB18 fe 08 efffffff47 callf $8,_writes
167: 167 0000BB1F # }
168: 168 0000BB1F 40 ret#2
169: 169 0000BB20 .set L24,0x1C00
170: 170 0000BB20 L26:
171: 171 0000BB20 3c 8844 5d 5e subl3 $68,fp,sp
172: 172 0000BB25 13 ff55 jbr L27
173: 173 0000BB28 .data
174: 174 00000234 * .text
175: 175 0000BB28 .align 1
176: 176 0000BB28 .globl _write32h
177: 177 0000BB28 _write32h:
178: 178 0000BB28 1c00 .word L40
179: 179 0000BB2A #
180: 180 0000BB2A #
181: 181 0000BB2A # write32h(ix) /* 32 bits HEX - print leading 0's */
182: 182 0000BB2A # long ix;
183: 183 0000BB2A # { register long count, mask, indx;
184: 184 0000BB2A 11 76 jbr L42
185: 185 0000BB2C L43:
186: 186 0000BB2C # char c, str[9];
187: 187 0000BB2C #
188: 188 0000BB2C # indx = 0; count = 28;
189: 189 0000BB2C 4d 5a clrl r10
190: 190 0000BB2E 0d 1c 5c movl $28,r12
191: 191 0000BB31 # mask = 0xf0000000;
192: 192 0000BB31 0d 8ff0000000 5b movl $-268435456,r11
193: 193 0000BB38 # str[8]='\0';
194: 194 0000BB38 49 adc4 clrb -60(fp)
195: 195 0000BB3B # while (mask) {
196: 196 0000BB3B L44:
197: 197 0000BB3B 5d 5b tstl r11
198: 198 0000BB3D 31 54 jeql L45
199: 199 0000BB3F # c = ( (ix&mask) >> count )&0xf;
200: 200 0000BB3F bc 5b ad04 50 andl3 r11,4(fp),r0
201: 201 0000BB44 5e 5c 50 50 shar r12,r0,r0
202: 202 0000BB48 ac 0f 50 andl2 $15,r0
203: 203 0000BB4B 6f 50 adc8 cvtlb r0,-56(fp)
204: 204 0000BB4F # count -= 4;
205: 205 0000BB4F 2c 04 5c subl2 $4,r12
206: 206 0000BB52 # if (indx==0) mask = 0xf000000;
207: 207 0000BB52 5d 5a tstl r10
208: 208 0000BB54 21 09 jneq L46
209: 209 0000BB56 0d 8f0f000000 5b movl $251658240,r11
210: 210 0000BB5D # else mask = mask >> 4;
211: 211 0000BB5D 11 07 jbr L47
212: 212 0000BB5F L46:
213: 213 0000BB5F 5e 04 5b 50 shar $4,r11,r0
214: 214 0000BB63 0d 50 5b movl r0,r11
215: 215 0000BB66 L47:
216: 216 0000BB66 # if ((c>=0)&&(c<=9)) c=c+'0';
217: 217 0000BB66 59 adc8 tstb -56(fp)
218: 218 0000BB69 91 13 jlss L48
219: 219 0000BB6B 19 adc8 09 cmpb -56(fp),$9
220: 220 0000BB6F 41 0d jgtr L48
221: 221 0000BB71 89 adc8 50 cvtbl -56(fp),r0
222: 222 0000BB75 0c 30 50 addl2 $48,r0
223: 223 0000BB78 6f 50 adc8 cvtlb r0,-56(fp)
224: 224 0000BB7C # else c=c+'7';
225: 225 0000BB7C 11 0b jbr L49
226: 226 0000BB7E L48:
227: 227 0000BB7E 89 adc8 50 cvtbl -56(fp),r0
228: 228 0000BB82 0c 37 50 addl2 $55,r0
229: 229 0000BB85 6f 50 adc8 cvtlb r0,-56(fp)
230: 230 0000BB89 L49:
231: 231 0000BB89 # str[indx++] = c;
232: 232 0000BB89 09 adc8 4aadbc movb -56(fp),-68(fp)[r10]
233: 233 0000BB8F 6d 5a incl r10
234: 234 0000BB91 # }
235: 235 0000BB91 11 a8 jbr L44
236: 236 0000BB93 L45:
237: 237 0000BB93 #
238: 238 0000BB93 # writes( str );
239: 239 0000BB93 3c 8844 5d 50 subl3 $68,fp,r0
240: 240 0000BB98 dd 50 pushl r0
241: 241 0000BB9A fe 08 effffffec5 callf $8,_writes
242: 242 0000BBA1 # }
243: 243 0000BBA1 40 ret#2
244: 244 0000BBA2 .set L40,0x1C00
245: 245 0000BBA2 L42:
246: 246 0000BBA2 3c 8844 5d 5e subl3 $68,fp,sp
247: 247 0000BBA7 11 83 jbr L43
248: 248 0000BBA9 .data
249: 249 00000234 * .text
250: 250 0000BBA9 00 .align 1
251: 251 0000BBAA .globl _writed
252: 252 0000BBAA _writed:
253: 253 0000BBAA 180c .word L51
254: 254 0000BBAC #
255: 255 0000BBAC #
256: 256 0000BBAC # /* Function to write a 32_bit decimal to Console
257: 257 0000BBAC # */
258: 258 0000BBAC # writed(ix)
259: 259 0000BBAC # long ix;
260: 260 0000BBAC # { char c;
261: 261 0000BBAC 11 7d jbr L53
262: 262 0000BBAE L54:
263: 263 0000BBAE # register long div, lead0;
264: 264 0000BBAE #
265: 265 0000BBAE # if (ix==0) { writec('0'); return; }
266: 266 0000BBAE 5d ad04 tstl 4(fp)
267: 267 0000BBB1 21 0a jneq L55
268: 268 0000BBB3 dd 30 pushl $48
269: 269 0000BBB5 fe 08 effffffe98 callf $8,_writec
270: 270 0000BBBC 40 ret#2
271: 271 0000BBBD # if (ix<0) { writec('-'); ix = (~ix)+1; }
272: 272 0000BBBD L55:
273: 273 0000BBBD 5d ad04 tstl 4(fp)
274: 274 0000BBC0 81 13 jgeq L56
275: 275 0000BBC2 dd 2d pushl $45
276: 276 0000BBC4 fe 08 effffffe89 callf $8,_writec
277: 277 0000BBCB 2d ad04 50 mcoml 4(fp),r0
278: 278 0000BBCF 6d 50 incl r0
279: 279 0000BBD1 0d 50 ad04 movl r0,4(fp)
280: 280 0000BBD5 # lead0 = 1;
281: 281 0000BBD5 L56:
282: 282 0000BBD5 0d 01 5b movl $1,r11
283: 283 0000BBD8 # div = 1000000000;
284: 284 0000BBD8 0d 8f3b9aca00 5c movl $1000000000,r12
285: 285 0000BBDF # while (div) {
286: 286 0000BBDF L57:
287: 287 0000BBDF 5d 5c tstl r12
288: 288 0000BBE1 31 47 jeql L58
289: 289 0000BBE3 # c = (ix/div)+'0';
290: 290 0000BBE3 7c 5c ad04 50 divl3 r12,4(fp),r0
291: 291 0000BBE8 0c 30 50 addl2 $48,r0
292: 292 0000BBEB 6f 50 adc8 cvtlb r0,-56(fp)
293: 293 0000BBEF # ix = ix%div; /* Mod */
294: 294 0000BBEF 4d 50 clrl r0
295: 295 0000BBF1 0d ad04 51 movl 4(fp),r1
296: 296 0000BBF5 81 03 jgeq L9999
297: 297 0000BBF7 ec 01 50 mnegl $1,r0
298: 298 0000BBFA L9999:
299: 299 0000BBFA 3e 5c 50 52 53 ediv r12,r0,r2,r3
300: 300 0000BBFF 0d 53 ad04 movl r3,4(fp)
301: 301 0000BC03 # div /= 10;
302: 302 0000BC03 6c 0a 5c divl2 $10,r12
303: 303 0000BC06 # if ((c=='0')&&(lead0)) c=' ';
304: 304 0000BC06 19 adc8 30 cmpb -56(fp),$48
305: 305 0000BC0A 21 0a jneq L59
306: 306 0000BC0C 5d 5b tstl r11
307: 307 0000BC0E 31 06 jeql L59
308: 308 0000BC10 6f 20 adc8 cvtlb $32,-56(fp)
309: 309 0000BC14 # else lead0 = 0;
310: 310 0000BC14 11 02 jbr L60
311: 311 0000BC16 L59:
312: 312 0000BC16 4d 5b clrl r11
313: 313 0000BC18 L60:
314: 314 0000BC18 # if (c != ' ') writec(c);
315: 315 0000BC18 19 adc8 20 cmpb -56(fp),$32
316: 316 0000BC1C 31 0a jeql L61
317: 317 0000BC1E d9 adc8 pushb -56(fp)
318: 318 0000BC21 fe 08 effffffe2c callf $8,_writec
319: 319 0000BC28 # }
320: 320 0000BC28 L61:
321: 321 0000BC28 11 b5 jbr L57
322: 322 0000BC2A L58:
323: 323 0000BC2A # }
324: 324 0000BC2A 40 ret#2
325: 325 0000BC2B .set L51,0x180C
326: 326 0000BC2B L53:
327: 327 0000BC2B 3c 38 5d 5e subl3 $56,fp,sp
328: 328 0000BC2F 13 ff7c jbr L54
329: 329 0000BC32 .data
330: 330 00000234 * .text
331: 331 0000BC32 .align 1
332: 332 0000BC32 .globl _readc
333: 333 0000BC32 _readc:
334: 334 0000BC32 0000 .word L63
335: 335 0000BC34 #
336: 336 0000BC34 # /* Function read 1 char from Console
337: 337 0000BC34 # */
338: 338 0000BC34 # char readc()
339: 339 0000BC34 # { char c, rdchar();
340: 340 0000BC34 11 1a jbr L65
341: 341 0000BC36 L66:
342: 342 0000BC36 #
343: 343 0000BC36 # writec(c=rdchar());
344: 344 0000BC36 fe 04 effffffe17 callf $4,_rdchar
345: 345 0000BC3D 6f 50 adc8 cvtlb r0,-56(fp)
346: 346 0000BC41 dd 50 pushl r0
347: 347 0000BC43 fe 08 effffffe0a callf $8,_writec
348: 348 0000BC4A # return(c);
349: 349 0000BC4A 89 adc8 50 cvtbl -56(fp),r0
350: 350 0000BC4E 40 ret#1
351: 351 0000BC4F # }
352: 352 0000BC4F 40 ret#1
353: 353 0000BC50 .set L63,0x0
354: 354 0000BC50 L65:
355: 355 0000BC50 3c 38 5d 5e subl3 $56,fp,sp
356: 356 0000BC54 11 e0 jbr L66
357: 357 0000BC56 .data
358: 358 00000234 * .text
359: 359 0000BC56 .align 1
360: 360 0000BC56 .globl _reads
361: 361 0000BC56 _reads:
362: 362 0000BC56 1000 .word L69
363: 363 0000BC58 #
364: 364 0000BC58 # /* This function read a string of characters.
365: 365 0000BC58 # calling sequence : nochar = reads(s);
366: 366 0000BC58 # input argument : char *s;
367: 367 0000BC58 # return value : no. of char read; excluding NULL or CR.
368: 368 0000BC58 # */
369: 369 0000BC58 # reads(s)
370: 370 0000BC58 # char *s;
371: 371 0000BC58 # { register long ix;
372: 372 0000BC58 11 29 jbr L71
373: 373 0000BC5A L72:
374: 374 0000BC5A #
375: 375 0000BC5A # for(ix=0;;ix++) {
376: 376 0000BC5A 4d 5c clrl r12
377: 377 0000BC5C L75:
378: 378 0000BC5C # *s = readc();
379: 379 0000BC5C fe 04 efffffffcf callf $4,_readc
380: 380 0000BC63 6f 50 bd04 cvtlb r0,*4(fp)
381: 381 0000BC67 # if ((*s==NULL)||(*s==CR))
382: 382 0000BC67 59 bd04 tstb *4(fp)
383: 383 0000BC6A 31 06 jeql L9998
384: 384 0000BC6C 19 bd04 0a cmpb *4(fp),$10
385: 385 0000BC70 21 05 jneq L76
386: 386 0000BC72 L9998:
387: 387 0000BC72 # { *s = NULL; break; }
388: 388 0000BC72 49 bd04 clrb *4(fp)
389: 389 0000BC75 11 07 jbr L74
390: 390 0000BC77 # else s++;
391: 391 0000BC77 L76:
392: 392 0000BC77 6d ad04 incl 4(fp)
393: 393 0000BC7A # }
394: 394 0000BC7A L73:
395: 395 0000BC7A 6d 5c incl r12
396: 396 0000BC7C 11 de jbr L75
397: 397 0000BC7E L74:
398: 398 0000BC7E # return(ix);
399: 399 0000BC7E 0d 5c 50 movl r12,r0
400: 400 0000BC81 40 ret#1
401: 401 0000BC82 # }
402: 402 0000BC82 40 ret#1
403: 403 0000BC83 .set L69,0x1000
404: 404 0000BC83 L71:
405: 405 0000BC83 11 d5 jbr L72
406: 406 0000BC85 .data
407: 407 00000234 * #
408: 408 00000234 * #
409: 409 00000234 * # /* This function read a string of HEX digit and
410: 410 00000234 * # convert it to integer value.
411: 411 00000234 * # calling sequence : stat = readh(ix);
412: 412 00000234 * # input parameter : long *ix;
413: 413 00000234 * # return value : (stat < 0) if error else (stat = 0);
414: 414 00000234 * # */
415: 415 00000234 * #
416: 416 00000234 * # /*
417: 417 00000234 * # readh(ix)
418: 418 00000234 * # long *ix;
419: 419 00000234 * # { char line[ALINE], *getnum(), *del;
420: 420 00000234 * # int nochar;
421: 421 00000234 * #
422: 422 00000234 * # if ( (nochar = reads(line)) > 8 ) return(-1);
423: 423 00000234 * # if ( (del = getnum(line,ix,del,HEX)) < 0 ) return(-1);
424: 424 00000234 * # else return(0);
425: 425 00000234 * # }
426: 426 00000234 * #
427: 427 00000234 * # */
428: 428 00000234 * #
429: 429 00000234 * #
430: 430 00000234 * #
431: 431 00000234 * #
432: 432 00000234 * # /* This function read a string of DEC digit and
433: 433 00000234 * # convert it to integer value.
434: 434 00000234 * # calling sequence : stat = readd(ix);
435: 435 00000234 * # input parameter : long *ix;
436: 436 00000234 * # return value : (stat < 0) if error else (stat = 0);
437: 437 00000234 * # */
438: 438 00000234 * #
439: 439 00000234 * # /*
440: 440 00000234 * # readd(ix)
441: 441 00000234 * # long *ix;
442: 442 00000234 * # { char line[ALINE], *getnum(), *del;
443: 443 00000234 * # int nochar;
444: 444 00000234 * #
445: 445 00000234 * # if ( (nochar = reads(line)) > 11 ) return(-1);
446: 446 00000234 * # if ( (del = getnum(line,ix,del,DEC)) < 0 ) return(-1);
447: 447 00000234 * # else return(0);
448: 448 00000234 * # }
449: 449 00000234 * # */
450: 450 00000234 * #
451: 450 00000234 * #
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.