Commit | Line | Data |
---|---|---|
27821c6a KT |
1 | #include <stdio.h> |
2 | ||
3 | #define CHAR 01 | |
4 | #define BLOCK 02 | |
5 | #define INTR 04 | |
6 | #define EVEN 010 | |
7 | #define KL 020 | |
8 | #define ROOT 040 | |
9 | #define SWAP 0100 | |
10 | #define PIPE 0200 | |
11 | ||
12 | char *btab[] = | |
13 | { | |
14 | "rk", | |
15 | "rp", | |
16 | "rf", | |
17 | "tm", | |
18 | "tc", | |
19 | "hs", | |
20 | "hp", | |
21 | "ht", | |
22 | "rl", | |
23 | 0 | |
24 | }; | |
25 | char *ctab[] = | |
26 | { | |
27 | "console", | |
28 | "pc", | |
29 | "lp", | |
30 | "dc", | |
31 | "dh", | |
32 | "dp", | |
33 | "dj", | |
34 | "dn", | |
35 | "mem", | |
36 | "rk", | |
37 | "rf", | |
38 | "rp", | |
39 | "tm", | |
40 | "hs", | |
41 | "hp", | |
42 | "ht", | |
43 | "du", | |
44 | "tty", | |
45 | "rl", | |
46 | 0 | |
47 | }; | |
48 | struct tab | |
49 | { | |
50 | char *name; | |
51 | int count; | |
52 | int address; | |
53 | int key; | |
54 | char *codea; | |
55 | char *codeb; | |
56 | char *codec; | |
57 | char *coded; | |
58 | char *codee; | |
59 | char *codef; | |
60 | char *codeg; | |
61 | } table[] = | |
62 | { | |
63 | "console", | |
64 | -1, 60, CHAR+INTR+KL, | |
65 | " klin; br4\n klou; br4\n", | |
66 | ".globl _klrint\nklin: jsr r0,call; jmp _klrint\n", | |
67 | ".globl _klxint\nklou: jsr r0,call; jmp _klxint\n", | |
68 | "", | |
69 | " klopen, klclose, klread, klwrite, klioctl, nulldev, 0,", | |
70 | "", | |
71 | "int klopen(), klclose(), klread(), klwrite(), klioctl();", | |
72 | ||
73 | "mem", | |
74 | -1, 300, CHAR, | |
75 | "", | |
76 | "", | |
77 | "", | |
78 | "", | |
79 | " nulldev, nulldev, mmread, mmwrite, nodev, nulldev, 0, ", | |
80 | "", | |
81 | "int mmread(), mmwrite();", | |
82 | ||
83 | "pc", | |
84 | 0, 70, CHAR+INTR, | |
85 | " pcin; br4\n pcou; br4\n", | |
86 | ".globl _pcrint\npcin: jsr r0,call; jmp _pcrint\n", | |
87 | ".globl _pcpint\npcou: jsr r0,call; jmp _pcpint\n", | |
88 | "", | |
89 | " pcopen, pcclose, pcread, pcwrite, nodev, nulldev, 0, ", | |
90 | "", | |
91 | "int pcopen(), pcclose(), pcread(), pcwrite();", | |
92 | ||
93 | "clock", | |
94 | -2, 100, INTR, | |
95 | " kwlp; br6\n", | |
96 | ".globl _clock\n", | |
97 | "kwlp: jsr r0,call; jmp _clock\n", | |
98 | "", | |
99 | "", | |
100 | "", | |
101 | "", | |
102 | ||
103 | "parity", | |
104 | -1, 114, INTR, | |
105 | " trap; br7+7. / 11/70 parity\n", | |
106 | "", | |
107 | "", | |
108 | "", | |
109 | "", | |
110 | "", | |
111 | "", | |
112 | ||
113 | /* | |
114 | * 110 unused | |
115 | * 114 memory parity | |
116 | * 120 XY plotter | |
117 | * 124 DR11-B | |
118 | * 130 AD01 & RL01 | |
119 | */ | |
120 | ||
121 | "rl", | |
122 | 0, 130, BLOCK+CHAR+INTR, | |
123 | " rlio; br5\n", | |
124 | ".globl _rlintr\n", | |
125 | "rlio: jsr r0,call; jmp _rlintr\n", | |
126 | " nulldev, nulldev, rlstrategy, &rltab,", | |
127 | " rlopen, rlclose, rlread, rlwrite, nodev, nulldev, 0,", | |
128 | "int rlstrategy();\nstruct buf rltab;", | |
129 | "int rlopen(), rlclose(), rlread(), rlwrite();", | |
130 | ||
131 | /* | |
132 | * 134 AFC11 | |
133 | * 140 AA11 | |
134 | * 144 AA11 | |
135 | * 150-174 unused | |
136 | */ | |
137 | ||
138 | "lp", | |
139 | 0, 200, CHAR+INTR, | |
140 | " lpou; br4\n", | |
141 | "", | |
142 | ".globl _lpint\nlpou: jsr r0,call; jmp _lpint\n", | |
143 | "", | |
144 | " lpopen, lpclose, nodev, lpwrite, nodev, nulldev, 0,", | |
145 | "", | |
146 | "int lpopen(), lpclose(), lpwrite();", | |
147 | ||
148 | "rf", | |
149 | 0, 204, BLOCK+CHAR+INTR, | |
150 | " rfio; br5\n", | |
151 | ".globl _rfintr\n", | |
152 | "rfio: jsr r0,call; jmp _rfintr\n", | |
153 | " nulldev, nulldev, rfstrategy, &rftab, ", | |
154 | " nulldev, nulldev, rfread, rfwrite, nodev, nulldev, 0,", | |
155 | "int rfstrategy();\nstruct buf rftab;", | |
156 | "int rfread(), rfwrite();", | |
157 | ||
158 | "hs", | |
159 | 0, 204, BLOCK+CHAR+INTR, | |
160 | " hsio; br5\n", | |
161 | ".globl _hsintr\n", | |
162 | "hsio: jsr r0,call; jmp _hsintr\n", | |
163 | " nulldev, nulldev, hsstrategy, &hstab, ", | |
164 | " nulldev, nulldev, hsread, hswrite, nodev, nulldev, 0,", | |
165 | "int hsstrategy();\nstruct buf hstab;", | |
166 | "int hsread(), hswrite();", | |
167 | ||
168 | /* | |
169 | * 210 RC | |
170 | */ | |
171 | ||
172 | "tc", | |
173 | 0, 214, BLOCK+INTR, | |
174 | " tcio; br6\n", | |
175 | ".globl _tcintr\n", | |
176 | "tcio: jsr r0,call; jmp _tcintr\n", | |
177 | " nulldev, tcclose, tcstrategy, &tctab,", | |
178 | "", | |
179 | "int tcstrategy(), tcclose();\nstruct buf tctab;", | |
180 | "", | |
181 | ||
182 | "rk", | |
183 | 0, 220, BLOCK+CHAR+INTR, | |
184 | " rkio; br5\n", | |
185 | ".globl _rkintr\n", | |
186 | "rkio: jsr r0,call; jmp _rkintr\n", | |
187 | " nulldev, nulldev, rkstrategy, &rktab,", | |
188 | " nulldev, nulldev, rkread, rkwrite, nodev, nulldev, 0,", | |
189 | "int rkstrategy();\nstruct buf rktab;", | |
190 | "int rkread(), rkwrite();", | |
191 | ||
192 | "tm", | |
193 | 0, 224, BLOCK+CHAR+INTR, | |
194 | " tmio; br5\n", | |
195 | ".globl _tmintr\n", | |
196 | "tmio: jsr r0,call; jmp _tmintr\n", | |
197 | " tmopen, tmclose, tmstrategy, &tmtab, ", | |
198 | " tmopen, tmclose, tmread, tmwrite, nodev, nulldev, 0,", | |
199 | "int tmopen(), tmclose(), tmstrategy();\nstruct buf tmtab;", | |
200 | "int tmread(), tmwrite();", | |
201 | ||
202 | "ht", | |
203 | 0, 224, BLOCK+CHAR+INTR, | |
204 | " htio; br5\n", | |
205 | ".globl _htintr\n", | |
206 | "htio: jsr r0,call; jmp _htintr\n", | |
207 | " htopen, htclose, htstrategy, &httab,", | |
208 | " htopen, htclose, htread, htwrite, nodev, nulldev, 0,", | |
209 | "int htopen(), htclose(), htstrategy();\nstruct buf httab;", | |
210 | "int htread(), htwrite();", | |
211 | ||
212 | "cr", | |
213 | 0, 230, CHAR+INTR, | |
214 | " crin; br6\n", | |
215 | "", | |
216 | ".globl _crint\ncrin: jsr r0,call; jmp _crint\n", | |
217 | "", | |
218 | " cropen, crclose, crread, nodev, nodev, nulldev, 0,", | |
219 | "", | |
220 | "int cropen(), crclose(), crread();", | |
221 | ||
222 | /* | |
223 | * 234 UDC11 | |
224 | */ | |
225 | ||
226 | "rp", | |
227 | 0, 254, BLOCK+CHAR+INTR, | |
228 | " rpio; br5\n", | |
229 | ".globl _rpintr\n", | |
230 | "rpio: jsr r0,call; jmp _rpintr\n", | |
231 | " nulldev, nulldev, rpstrategy, &rptab,", | |
232 | " nulldev, nulldev, rpread, rpwrite, nodev, nulldev, 0,", | |
233 | "int rpstrategy();\nstruct buf rptab;", | |
234 | "int rpread(), rpwrite();", | |
235 | ||
236 | "hp", | |
237 | 0, 254, BLOCK+CHAR+INTR, | |
238 | " hpio; br5\n", | |
239 | ".globl _hpintr\n", | |
240 | "hpio: jsr r0,call; jmp _hpintr\n", | |
241 | " nulldev, nulldev, hpstrategy, &hptab,", | |
242 | " nulldev, nulldev, hpread, hpwrite, nodev, nulldev, 0,", | |
243 | "int hpstrategy();\nstruct buf hptab;", | |
244 | "int hpread(), hpwrite();", | |
245 | ||
246 | /* | |
247 | * 260 TA11 | |
248 | * 264-274 unused | |
249 | */ | |
250 | ||
251 | "dc", | |
252 | 0, 308, CHAR+INTR, | |
253 | " dcin; br5+%d.\n dcou; br5+%d.\n", | |
254 | ".globl _dcrint\ndcin: jsr r0,call; jmp _dcrint\n", | |
255 | ".globl _dcxint\ndcou: jsr r0,call; jmp _dcxint\n", | |
256 | "", | |
257 | " dcopen, dcclose, dcread, dcwrite, dcioctl, nulldev, dc11,", | |
258 | "", | |
259 | "int dcopen(), dcclose(), dcread(), dcwrite(), dcioctl();\nstruct tty dc11[];", | |
260 | ||
261 | "kl", | |
262 | 0, 308, INTR+KL, | |
263 | " klin; br4+%d.\n klou; br4+%d.\n", | |
264 | "", | |
265 | "", | |
266 | "", | |
267 | "", | |
268 | "", | |
269 | "", | |
270 | ||
271 | "dp", | |
272 | 0, 308, CHAR+INTR, | |
273 | " dpin; br6+%d.\n dpou; br6+%d.\n", | |
274 | ".globl _dprint\ndpin: jsr r0,call; jmp _dprint\n", | |
275 | ".globl _dpxint\ndpou: jsr r0,call; jmp _dpxint\n", | |
276 | "", | |
277 | " dpopen, dpclose, dpread, dpwrite, nodev, nulldev, 0,", | |
278 | "", | |
279 | "int dpopen(), dpclose(), dpread(), dpwrite();", | |
280 | ||
281 | /* | |
282 | * DM11-A | |
283 | */ | |
284 | ||
285 | "dn", | |
286 | 0, 304, CHAR+INTR, | |
287 | " dnou; br5+%d.\n", | |
288 | "", | |
289 | ".globl _dnint\ndnou: jsr r0,call; jmp _dnint\n", | |
290 | "", | |
291 | " dnopen, dnclose, nodev, dnwrite, nodev, nulldev, 0,", | |
292 | "", | |
293 | "int dnopen(), dnclose(), dnwrite();", | |
294 | ||
295 | "dhdm", | |
296 | 0, 304, INTR, | |
297 | " dmin; br4+%d.\n", | |
298 | "", | |
299 | ".globl _dmint\ndmin: jsr r0,call; jmp _dmint\n", | |
300 | "", | |
301 | "", | |
302 | "", | |
303 | "", | |
304 | ||
305 | /* | |
306 | * DR11-A+ | |
307 | * DR11-C+ | |
308 | * PA611+ | |
309 | * PA611+ | |
310 | * DT11+ | |
311 | * DX11+ | |
312 | */ | |
313 | ||
314 | "dl", | |
315 | 0, 308, INTR+KL, | |
316 | " klin; br4+%d.\n klou; br4+%d.\n", | |
317 | "", | |
318 | "", | |
319 | "", | |
320 | "", | |
321 | "", | |
322 | "", | |
323 | ||
324 | /* | |
325 | * DJ11 | |
326 | */ | |
327 | ||
328 | "dh", | |
329 | 0, 308, CHAR+INTR+EVEN, | |
330 | " dhin; br5+%d.\n dhou; br5+%d.\n", | |
331 | ".globl _dhrint\ndhin: jsr r0,call; jmp _dhrint\n", | |
332 | ".globl _dhxint\ndhou: jsr r0,call; jmp _dhxint\n", | |
333 | "", | |
334 | " dhopen, dhclose, dhread, dhwrite, dhioctl, dhstop, dh11,", | |
335 | "", | |
336 | "int dhopen(), dhclose(), dhread(), dhwrite(), dhioctl(), dhstop();\nstruct tty dh11[];", | |
337 | ||
338 | /* | |
339 | * GT40 | |
340 | * LPS+ | |
341 | * DQ11 | |
342 | * KW11-W | |
343 | */ | |
344 | ||
345 | "du", | |
346 | 0, 308, CHAR+INTR, | |
347 | " duin; br6+%d.\n duou; br6+%d.\n", | |
348 | ".globl _durint\nduin: jsr r0,call; jmp _durint\n", | |
349 | ".globl _duxint\nduou: jsr r0,call; jmp _duxint\n", | |
350 | "", | |
351 | " duopen, duclose, duread, duwrite, nodev, nulldev, 0,", | |
352 | "", | |
353 | "int duopen(), duclose(), duread(), duwrite();", | |
354 | ||
355 | "tty", | |
356 | 1, 0, CHAR, | |
357 | "", | |
358 | "", | |
359 | "", | |
360 | "", | |
361 | " syopen, nulldev, syread, sywrite, sysioctl, nulldev, 0,", | |
362 | "", | |
363 | "int syopen(), syread(), sywrite(), sysioctl();", | |
364 | ||
365 | 0 | |
366 | }; | |
367 | ||
368 | char *stra[] = | |
369 | { | |
370 | "/ low core", | |
371 | "", | |
372 | ".data", | |
373 | "ZERO:", | |
374 | "", | |
375 | "br4 = 200", | |
376 | "br5 = 240", | |
377 | "br6 = 300", | |
378 | "br7 = 340", | |
379 | "", | |
380 | ". = ZERO+0", | |
381 | " br 1f", | |
382 | " 4", | |
383 | "", | |
384 | "/ trap vectors", | |
385 | " trap; br7+0. / bus error", | |
386 | " trap; br7+1. / illegal instruction", | |
387 | " trap; br7+2. / bpt-trace trap", | |
388 | " trap; br7+3. / iot trap", | |
389 | " trap; br7+4. / power fail", | |
390 | " trap; br7+5. / emulator trap", | |
391 | " start;br7+6. / system (overlaid by 'trap')", | |
392 | "", | |
393 | ". = ZERO+40", | |
394 | ".globl start, dump", | |
395 | "1: jmp start", | |
396 | " jmp dump", | |
397 | "", | |
398 | 0, | |
399 | }; | |
400 | ||
401 | char *strb[] = | |
402 | { | |
403 | "", | |
404 | ". = ZERO+240", | |
405 | " trap; br7+7. / programmed interrupt", | |
406 | " trap; br7+8. / floating point", | |
407 | " trap; br7+9. / segmentation violation", | |
408 | 0 | |
409 | }; | |
410 | ||
411 | char *strc[] = | |
412 | { | |
413 | "", | |
414 | "/ floating vectors", | |
415 | ". = ZERO+300", | |
416 | 0, | |
417 | }; | |
418 | ||
419 | char *strd[] = | |
420 | { | |
421 | "", | |
422 | "//////////////////////////////////////////////////////", | |
423 | "/ interface code to C", | |
424 | "//////////////////////////////////////////////////////", | |
425 | "", | |
426 | ".text", | |
427 | ".globl call, trap", | |
428 | 0 | |
429 | }; | |
430 | ||
431 | char *stre[] = | |
432 | { | |
433 | "#include \"../h/param.h\"", | |
434 | "#include \"../h/systm.h\"", | |
435 | "#include \"../h/buf.h\"", | |
436 | "#include \"../h/tty.h\"", | |
437 | "#include \"../h/conf.h\"", | |
438 | "#include \"../h/proc.h\"", | |
439 | "#include \"../h/text.h\"", | |
440 | "#include \"../h/dir.h\"", | |
441 | "#include \"../h/user.h\"", | |
442 | "#include \"../h/file.h\"", | |
443 | "#include \"../h/inode.h\"", | |
444 | "#include \"../h/acct.h\"", | |
445 | "", | |
446 | "int nulldev();", | |
447 | "int nodev();", | |
448 | 0 | |
449 | }; | |
450 | ||
451 | char *stre1[] = | |
452 | { | |
453 | "struct bdevsw bdevsw[] =", | |
454 | "{", | |
455 | 0, | |
456 | }; | |
457 | ||
458 | char *strf[] = | |
459 | { | |
460 | " 0", | |
461 | "};", | |
462 | "", | |
463 | 0, | |
464 | }; | |
465 | ||
466 | char *strf1[] = | |
467 | { | |
468 | "", | |
469 | "struct cdevsw cdevsw[] =", | |
470 | "{", | |
471 | 0, | |
472 | }; | |
473 | ||
474 | char strg[] = | |
475 | { | |
476 | " 0\n\ | |
477 | };\n\ | |
478 | int rootdev = makedev(%d, %d);\n\ | |
479 | int swapdev = makedev(%d, %d);\n\ | |
480 | int pipedev = makedev(%d, %d);\n\ | |
481 | int nldisp = %d;\n\ | |
482 | daddr_t swplo = %ld;\n\ | |
483 | int nswap = %l;\n\ | |
484 | "}; | |
485 | ||
486 | char strg1[] = | |
487 | { | |
488 | " \n\ | |
489 | struct buf buf[NBUF];\n\ | |
490 | struct file file[NFILE];\n\ | |
491 | struct inode inode[NINODE];\n" | |
492 | }; | |
493 | ||
494 | char *strg1a[] = | |
495 | { | |
496 | "int mpxchan();", | |
497 | "int (*ldmpx)() = mpxchan;", | |
498 | 0 | |
499 | }; | |
500 | ||
501 | char strg2[] = | |
502 | { | |
503 | "struct proc proc[NPROC];\n\ | |
504 | struct text text[NTEXT];\n\ | |
505 | struct buf bfreelist;\n\ | |
506 | struct acct acctbuf;\n\ | |
507 | struct inode *acctp;\n" | |
508 | }; | |
509 | ||
510 | char *strh[] = | |
511 | { | |
512 | " 0", | |
513 | "};", | |
514 | "", | |
515 | "int ttyopen(), ttyclose(), ttread(), ttwrite(), ttyinput(), ttstart();", | |
516 | 0 | |
517 | }; | |
518 | ||
519 | char *stri[] = | |
520 | { | |
521 | "int pkopen(), pkclose(), pkread(), pkwrite(), pkioctl(), pkrint(), pkxint();", | |
522 | 0 | |
523 | }; | |
524 | ||
525 | char *strj[] = | |
526 | { | |
527 | "struct linesw linesw[] =", | |
528 | "{", | |
529 | " ttyopen, nulldev, ttread, ttwrite, nodev, ttyinput, ttstart, /* 0 */", | |
530 | 0 | |
531 | }; | |
532 | ||
533 | char *strk[] = | |
534 | { | |
535 | " pkopen, pkclose, pkread, pkwrite, pkioctl, pkrint, pkxint, /* 1 */", | |
536 | 0 | |
537 | }; | |
538 | ||
539 | int pack; | |
540 | int mpx; | |
541 | int rootmaj = -1; | |
542 | int rootmin; | |
543 | int swapmaj = -1; | |
544 | int swapmin; | |
545 | int pipemaj = -1; | |
546 | int pipemin; | |
547 | long swplo = 4000; | |
548 | int nswap = 872; | |
549 | int pack; | |
550 | int nldisp = 1; | |
551 | ||
552 | main() | |
553 | { | |
554 | register struct tab *p; | |
555 | register char *q; | |
556 | int i, n, ev, nkl; | |
557 | int flagf, flagb, dumpht; | |
558 | ||
559 | while(input()); | |
560 | ||
561 | /* | |
562 | * pass1 -- create interrupt vectors | |
563 | */ | |
564 | nkl = 0; | |
565 | flagf = flagb = 1; | |
566 | freopen("l.s", "w", stdout); | |
567 | puke(stra); | |
568 | ev = 0; | |
569 | for(p=table; p->name; p++) | |
570 | if(p->count != 0 && p->key & INTR) { | |
571 | if(p->address>240 && flagb) { | |
572 | flagb = 0; | |
573 | puke(strb); | |
574 | } | |
575 | if(p->address >= 300) { | |
576 | if(flagf) { | |
577 | ev = 0; | |
578 | flagf = 0; | |
579 | puke(strc); | |
580 | } | |
581 | if(p->key & EVEN && ev & 07) { | |
582 | printf(" .=.+4\n"); | |
583 | ev += 4; | |
584 | } | |
585 | printf("/%s %o\n", p->name, 0300+ev); | |
586 | } else | |
587 | printf("\n. = ZERO+%d\n", p->address); | |
588 | n = p->count; | |
589 | if(n < 0) | |
590 | n = -n; | |
591 | for(i=0; i<n; i++) { | |
592 | if(p->key & KL) { | |
593 | printf(p->codea, nkl, nkl); | |
594 | nkl++; | |
595 | } else | |
596 | printf(p->codea, i, i); | |
597 | if (p->address<300) | |
598 | fprintf(stderr, "%s at %d\n", p->name, p->address+4*i); | |
599 | else | |
600 | fprintf(stderr, "%s at %o\n", p->name, 0300+ev); | |
601 | ev += p->address - 300; | |
602 | } | |
603 | } | |
604 | if(flagb) | |
605 | puke(strb); | |
606 | puke(strd); | |
607 | for(p=table; p->name; p++) | |
608 | if(p->count != 0 && p->key & INTR) | |
609 | printf("\n%s%s", p->codeb, p->codec); | |
610 | ||
611 | /* | |
612 | * pass 2 -- create configuration table | |
613 | */ | |
614 | ||
615 | freopen("c.c", "w", stdout); | |
616 | /* | |
617 | * declarations | |
618 | */ | |
619 | puke(stre); | |
620 | for (i=0; q=btab[i]; i++) { | |
621 | for (p=table; p->name; p++) | |
622 | if (equal(q, p->name) && | |
623 | (p->key&BLOCK) && p->count && *p->codef) | |
624 | printf("%s\n", p->codef); | |
625 | } | |
626 | puke(stre1); | |
627 | for(i=0; q=btab[i]; i++) { | |
628 | for(p=table; p->name; p++) | |
629 | if(equal(q, p->name) && | |
630 | (p->key&BLOCK) && p->count) { | |
631 | printf("%s /* %s = %d */\n", p->coded, q, i); | |
632 | if(p->key & ROOT) | |
633 | rootmaj = i; | |
634 | if (p->key & SWAP) | |
635 | swapmaj = i; | |
636 | if (p->key & PIPE) | |
637 | pipemaj = i; | |
638 | goto newb; | |
639 | } | |
640 | printf(" nodev, nodev, nodev, 0, /* %s = %d */\n", q, i); | |
641 | newb:; | |
642 | } | |
643 | if (swapmaj == -1) { | |
644 | swapmaj = rootmaj; | |
645 | swapmin = rootmin; | |
646 | } | |
647 | if (pipemaj == -1) { | |
648 | pipemaj = rootmaj; | |
649 | pipemin = rootmin; | |
650 | } | |
651 | puke(strf); | |
652 | for (i=0; q=ctab[i]; i++) { | |
653 | for (p=table; p->name; p++) | |
654 | if (equal(q, p->name) && | |
655 | (p->key&CHAR) && p->count && *p->codeg) | |
656 | printf("%s\n", p->codeg); | |
657 | } | |
658 | puke(strf1); | |
659 | for(i=0; q=ctab[i]; i++) { | |
660 | for(p=table; p->name; p++) | |
661 | if(equal(q, p->name) && | |
662 | (p->key&CHAR) && p->count) { | |
663 | printf("%s /* %s = %d */\n", p->codee, q, i); | |
664 | goto newc; | |
665 | } | |
666 | printf(" nodev, nodev, nodev, nodev, nodev, nulldev, 0, /* %s = %d */\n", q, i); | |
667 | newc:; | |
668 | } | |
669 | puke(strh); | |
670 | if (pack) { | |
671 | nldisp++; | |
672 | puke(stri); | |
673 | } | |
674 | puke(strj); | |
675 | if (pack) | |
676 | puke(strk); | |
677 | printf(strg, rootmaj, rootmin, | |
678 | swapmaj, swapmin, | |
679 | pipemaj, pipemin, | |
680 | nldisp, | |
681 | swplo, nswap); | |
682 | printf(strg1); | |
683 | if (!mpx) | |
684 | puke(strg1a); | |
685 | printf(strg2); | |
686 | if(rootmaj < 0) | |
687 | fprintf(stderr, "No root device given\n"); | |
688 | freopen("mch0.s", "w", stdout); | |
689 | dumpht = 0; | |
690 | for (i=0; table[i].name; i++) { | |
691 | if (equal(table[i].name, "ht") && table[i].count) | |
692 | dumpht = 1; | |
693 | } | |
694 | if (dumpht) { | |
695 | printf("HTDUMP = 1\n"); | |
696 | printf("TUDUMP = 0\n"); | |
697 | } else { | |
698 | printf("HTDUMP = 0\n"); | |
699 | printf("TUDUMP = 1\n"); | |
700 | } | |
701 | } | |
702 | ||
703 | puke(s, a) | |
704 | char **s; | |
705 | { | |
706 | char *c; | |
707 | ||
708 | while(c = *s++) { | |
709 | printf(c, a); | |
710 | printf("\n"); | |
711 | } | |
712 | } | |
713 | ||
714 | input() | |
715 | { | |
716 | char line[100]; | |
717 | register struct tab *q; | |
718 | int count, n; | |
719 | long num; | |
720 | char keyw[32], dev[32]; | |
721 | ||
722 | if (fgets(line, 100, stdin) == NULL) | |
723 | return(0); | |
724 | count = -1; | |
725 | n = sscanf(line, "%d%s%s%ld", &count, keyw, dev, &num); | |
726 | if (count == -1 && n>0) { | |
727 | count = 1; | |
728 | n++; | |
729 | } | |
730 | if (n<2) | |
731 | goto badl; | |
732 | for(q=table; q->name; q++) | |
733 | if(equal(q->name, keyw)) { | |
734 | if(q->count < 0) { | |
735 | fprintf(stderr, "%s: no more, no less\n", keyw); | |
736 | return(1); | |
737 | } | |
738 | q->count += count; | |
739 | if(q->address < 300 && q->count > 1) { | |
740 | q->count = 1; | |
741 | fprintf(stderr, "%s: only one\n", keyw); | |
742 | } | |
743 | return(1); | |
744 | } | |
745 | if (equal(keyw, "nswap")) { | |
746 | if (n<3) | |
747 | goto badl; | |
748 | if (sscanf(dev, "%ld", &num) <= 0) | |
749 | goto badl; | |
750 | nswap = num; | |
751 | return(1); | |
752 | } | |
753 | if (equal(keyw, "swplo")) { | |
754 | if (n<3) | |
755 | goto badl; | |
756 | if (sscanf(dev, "%ld", &num) <= 0) | |
757 | goto badl; | |
758 | swplo = num; | |
759 | return(1); | |
760 | } | |
761 | if (equal(keyw, "pack")) { | |
762 | pack++; | |
763 | return(1); | |
764 | } | |
765 | if (equal(keyw, "mpx")) { | |
766 | mpx++; | |
767 | return(1); | |
768 | } | |
769 | if(equal(keyw, "done")) | |
770 | return(0); | |
771 | if (equal(keyw, "root")) { | |
772 | if (n<4) | |
773 | goto badl; | |
774 | for (q=table; q->name; q++) { | |
775 | if (equal(q->name, dev)) { | |
776 | q->key |= ROOT; | |
777 | rootmin = num; | |
778 | return(1); | |
779 | } | |
780 | } | |
781 | fprintf(stderr, "Can't find root\n"); | |
782 | return(1); | |
783 | } | |
784 | if (equal(keyw, "swap")) { | |
785 | if (n<4) | |
786 | goto badl; | |
787 | for (q=table; q->name; q++) { | |
788 | if (equal(q->name, dev)) { | |
789 | q->key |= SWAP; | |
790 | swapmin = num; | |
791 | return(1); | |
792 | } | |
793 | } | |
794 | fprintf(stderr, "Can't find swap\n"); | |
795 | return(1); | |
796 | } | |
797 | if (equal(keyw, "pipe")) { | |
798 | if (n<4) | |
799 | goto badl; | |
800 | for (q=table; q->name; q++) { | |
801 | if (equal(q->name, dev)) { | |
802 | q->key |= PIPE; | |
803 | pipemin = num; | |
804 | return(1); | |
805 | } | |
806 | } | |
807 | fprintf(stderr, "Can't find pipe\n"); | |
808 | return(1); | |
809 | } | |
810 | fprintf(stderr, "%s: cannot find\n", keyw); | |
811 | return(1); | |
812 | badl: | |
813 | fprintf(stderr, "Bad line: %s", line); | |
814 | return(1); | |
815 | } | |
816 | ||
817 | equal(a, b) | |
818 | char *a, *b; | |
819 | { | |
820 | return(!strcmp(a, b)); | |
821 | } |