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