home *** CD-ROM | disk | FTP | other *** search
/ Oakland CPM Archive / oakcpm.iso / sigm / vol150 / 211ctdl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1984-04-29  |  18.6 KB  |  796 lines
  1. /************************************************************************/
  2. /*                ctdl.c                    */
  3. /*        Command-interpreter code for Citadel            */
  4. /************************************************************************/
  5. #include "b:210ctdl.h"
  6. /************************************************************************/
  7. /*                history                 */
  8. /* 83Jul14 BAK    ...                            */
  9. /* 83Jun11 BAK  Edited to fix <typo>.hlp problem.              */
  10. /* 83Mar08 CrT    Aide-special functions installed & tested...        */
  11. /* 83Feb24 CrT/SB Menus rearranged.                    */
  12. /* 82Dec06 CrT    2.00 release.                        */
  13. /* 82Nov05 CrT    removed main() from room2.c and split into sub-fn()s    */
  14. /************************************************************************/
  15. /************************************************************************/
  16. /*                Contents                */
  17. /*                                    */
  18. /*    doAide()        handles Aide-only commands        */
  19. /*    doChat()        handles C(hat)        command     */
  20. /*    doEnter()        handles E(nter)     command     */
  21. /*    doGoto()        handles G(oto)        command     */
  22. /*    doHelp()        handles H(elp)        command     */
  23. /*    doKnown()        handles K(nown rooms)    command     */
  24. /*    doLogin()        handles L(ogin)     command     */
  25. /*    doLogout()        handles T(erminate)    command     */
  26. /*    doRead()        handles R(ead)        command     */
  27. /*    doRegular()        fanout for above commands        */
  28. /*    doSysop()        handles sysop-only commands        */
  29. /*    getCommand()        prints prompt and gets command char    */
  30. /*    greeting()        System-entry blurb etc            */
  31. /*    main()            has the central menu code        */
  32. /************************************************************************/
  33.  
  34. /************************************************************************/
  35. /*    doAide() handles the aide-only menu                */
  36. /*        return FALSE to fall invisibly into default error msg    */
  37. /************************************************************************/
  38. char doAide(moreYet, first)
  39. char moreYet;
  40. char first;    /* first parameter if TRUE        */
  41. {
  42.     char oldName[NAMESIZE];
  43.     int  rm;
  44.  
  45.     if (!aide)     return FALSE;
  46.  
  47.     if (moreYet)   first = '\0';
  48.  
  49.     mprintf("ide special fn: ");
  50.  
  51.     if (first)       oChar(first);
  52.  
  53.     switch (toUpper(   first ? first : iChar()      )) {
  54.     case 'D':
  55.     mPrintf("elete empty rooms\n ");
  56.     strCpy(oldName, roomBuf.rbname);
  57.     indexRooms();
  58.  
  59.     if ((rm=roomExist(oldName)) != ERROR)    getRoom(rm,    &roomBuf);
  60.     else                    getRoom(LOBBY, &roomBuf);
  61.  
  62.     sprintf(msgBuf.mbtext, "Empty rooms deleted by %s", logBuf.lbname);
  63.     aideMessage( /* noteDeletedMessage== */ FALSE );
  64.     break;
  65.     case 'E':
  66.     mprintf("dit room\n  \n");
  67.     strCpy(oldName, roomBuf.rbname);
  68.     if (!renameRoom())   break;
  69.     sPrintf(
  70.         msgBuf.mbtext,
  71.         "%s> edited to %s> by %s",
  72.         oldName,
  73.         roomBuf.rbname,
  74.         logBuf.lbname
  75.     );
  76.     aideMessage( /* noteDeletedMessage == */ FALSE);
  77.     break;
  78.     case 'I':
  79.     mPrintf("nsert message\n ");
  80.     if (
  81.         thisRoom   == AIDEROOM
  82.         ||
  83.         pulledMLoc == ERROR
  84.     )   {
  85.         mPrintf("nope!");
  86.         break;
  87.     }
  88.     note2Message(pulledMId, pulledMLoc);
  89.     putRoom(thisRoom, &roomBuf);
  90.     noteRoom();
  91.     sPrintf(
  92.         msgBuf.mbtext,
  93.         "Following message inserted in %s> by %s",
  94.         roomBuf.rbname,
  95.         logBuf.lbname
  96.     );
  97.     aideMessage( /* noteDeletedMessage == */ TRUE);
  98.     break;
  99.     case 'K':
  100.     mPrintf("ill room\n ");
  101.     if (
  102.         thisRoom == LOBBY
  103.         ||
  104.         thisRoom == MAILROOM
  105.         ||
  106.         thisRoom == AIDEROOM
  107.     ) {
  108.         mPrintf(" not here!");
  109.         break;
  110.     }
  111.     if (!getYesNo("confirm"))   break;
  112.  
  113.     sPrintf(
  114.         msgBuf.mbtext,
  115.         "%s> killed by %s",
  116.         roomBuf.rbname,
  117.         logBuf.lbname
  118.     );
  119.     aideMessage( /* noteDeletedMessage == */ FALSE);
  120.  
  121.     roomBuf.rbflags ^= INUSE;
  122.     putRoom(thisRoom, &roomBuf);
  123.     noteRoom();
  124.     getRoom(LOBBY, &roomBuf);
  125.     break;
  126.     case '?':
  127.     tutorial("aide.mnu");
  128.     break;
  129.     default:
  130.     if (!expert)    mprintf(" ?(Type '?' for menu)\n "    );
  131.     else        mprintf(" ?\n "             );
  132.     break;
  133.     }
  134.     return TRUE;
  135. }
  136.  
  137. /************************************************************************/
  138. /*    doChat()                            */
  139. /************************************************************************/
  140. doChat(moreYet, first)
  141. char moreYet;    /* TRUE to accept folliwng parameters    */
  142. char first;    /* first paramter if TRUE        */
  143. {
  144.     if (moreYet)   first = '\0';
  145.  
  146.     if (first)       oChar(first);
  147.  
  148.     mPrintf("hat ");
  149.  
  150.     if (noChat)   {
  151.     tutorial("nochat.blb");
  152.     return;
  153.     }
  154.  
  155.     if (whichIO == MODEM)    ringSysop();
  156.     else            interact() ;
  157. }
  158.  
  159. /************************************************************************/
  160. /*    doEnter() handles E(nter) command                */
  161. /************************************************************************/
  162. doEnter(moreYet, first)
  163. char moreYet;    /* TRUE to accept following parameters    */
  164. char first;    /* first parameter if TRUE        */
  165. {
  166. #define CONFIGURATION    0
  167. #define MESSAGE     1
  168. #define PASSWORD    2
  169. #define ROOM        3
  170. #define FILE        4
  171.     char what;            /* one of above five */
  172.     char abort, done, WC;
  173.     char iChar(), toUpper();
  174.  
  175.  
  176.     if (moreYet)   first = '\0';
  177.  
  178.     abort    = FALSE  ;
  179.     done    = FALSE  ;
  180.     WC        = FALSE  ;
  181.     what    = MESSAGE;
  182.  
  183.     mprintf("nter ");
  184.  
  185.     if (!loggedIn  &&  !unlogLoginOk  &&  thisRoom!=MAILROOM)    {
  186.     mprintf("--Must log in to enter (except in Mail>)\n ");
  187.     return;
  188.     }
  189.  
  190.     if (first)       oChar(first);
  191.  
  192.     do    {
  193.     outFlag = OUTOK;
  194.  
  195.     switch (toUpper(   first ? first : iChar()   )) {
  196.     case '\r':
  197.     case '\n':
  198.         moreYet    = FALSE;
  199.         break;
  200.     case 'F':
  201.         if (roomBuf.rbflags & CPMDIR) {
  202.         mprintf("ile upload ");
  203.         what    = FILE;
  204.         done    = TRUE;
  205.         break;
  206.         }
  207.     default:
  208.         mprintf("? ");
  209.         abort    = TRUE;
  210.         if (expert)  break;
  211.     case '?':
  212.         tutorial("entopt.mnu");
  213.         abort    = TRUE;
  214.         break;
  215.     case 'C':
  216.         mprintf("onfiguration ");
  217.         what    = CONFIGURATION;
  218.         done    = TRUE;
  219.         break;
  220.     case 'F':
  221.         mprintf("ile upload "    );
  222.         WC        = TRUE;
  223.         done    = TRUE;
  224.         break;
  225.     case 'M':
  226.         mprintf("essage "       );
  227.         what    = MESSAGE      ;
  228.         done    = TRUE;
  229.         break;
  230.     case 'P':
  231.         mprintf("assword "       );
  232.         what    = PASSWORD     ;
  233.         done    = TRUE;
  234.         break;
  235.     case 'R':
  236.         mprintf("oom "       );
  237.         if (!nonAideRoomOk && !aide)   {
  238.         mPrintf(" ?-- must be aide to create room\n ");
  239.         abort    = TRUE;
  240.         break;
  241.         }
  242.         what    = ROOM           ;
  243.         done    = TRUE;
  244.         break;
  245.     }
  246.     first = '\0';
  247.     } while (!done && moreYet && !abort);
  248.  
  249.     doCR();
  250.  
  251.     if (!abort) {
  252.     switch (what) {
  253.     case CONFIGURATION  :    configure()    ;    break;
  254.     case MESSAGE        :    makeMessage(WC) ;    break;
  255.     case PASSWORD        :    newPW()     ;    break;
  256.     case ROOM        :    makeRoom()    ;    break;
  257.     case FILE        :    upLoad()    ;    break;
  258.     }
  259.     }
  260. }
  261.  
  262. /************************************************************************/
  263. /*    doGoto() handles G(oto) command                 */
  264. /************************************************************************/
  265. doGoto(expand, first)
  266. char expand;    /* TRUE to accept following parameters    */
  267. char first;    /* first parameter if TRUE        */
  268. {
  269.     char roomName[NAMESIZE];
  270.  
  271.     mprintf("oto ");
  272.  
  273.     if (!expand) {
  274.     gotoRoom("");
  275.     return;
  276.     }
  277.  
  278.     getString("", roomName, NAMESIZE);
  279.     normalizeString(roomName);
  280.  
  281.     if (roomName[0] == '?')    listRooms(/* doDull== */ TRUE);
  282.     else            gotoRoom(roomName);
  283. }
  284.  
  285. /************************************************************************/
  286. /*    doHelp() handles H(elp) command                 */
  287. /************************************************************************/
  288. doHelp(expand, first)
  289. char expand;    /* TRUE to accept following parameters    */
  290. char first;    /* first parameter if TRUE        */
  291. {
  292.     char fileName[NAMESIZE];
  293.  
  294.     if (!expand) {
  295.     mprintf("elp\n \n ");
  296.     tutorial("dohelp.hlp");
  297.     return;
  298.     }
  299.  
  300.     mprintf("elp ");
  301.     getString("", fileName, NAMESIZE);
  302.     normalizeString(fileName);
  303.     if (fileName[0] == '?'  || strLen(fileName) > 8 ) {
  304.     /*  File names over 8 characters log clobbered bdos in version 2.1 */
  305.     tutorial("helpopt.hlp");
  306.    } else {
  307.     /* adding the extention makes things look simpler for        */
  308.     /* the user... and restricts the files which can be read    */
  309.     strcat(fileName, ".hlp");
  310.     tutorial(fileName);
  311.     }
  312. }
  313.  
  314. /************************************************************************/
  315. /*    doKnown() handles K(nown rooms) command.            */
  316. /************************************************************************/
  317. doKnown(expand, first)
  318. char expand;    /* TRUE to accept following parameters    */
  319. char first;    /* first parameter if TRUE        */
  320. {
  321.     mprintf("nown rooms\n ");
  322.     listRooms(/* doDull== */ TRUE);
  323. }
  324.  
  325. /************************************************************************/
  326. /*    doLogin() handles L(ogin) command                */
  327. /************************************************************************/
  328. doLogin(moreYet, first)
  329. char moreYet;    /* TRUE to accept following parameters    */
  330. char first;    /* first parameter if TRUE        */
  331. {
  332.     char passWord[NAMESIZE];
  333.  
  334.     mprintf("ogin ");
  335.     if (!moreYet)   mPrintf("\n");
  336.     if (loggedIn)   {
  337.     mprintf("\n ?Already logged in!\n ");
  338.     return;
  339.     }
  340.     echo    = CALLER;
  341.     getString(moreYet ? "" : " password", passWord, NAMESIZE);
  342.     normalizeString(passWord);
  343.     echo    = BOTH;
  344.     login(passWord);
  345. }
  346.  
  347. /************************************************************************/
  348. /*    doLogout() handles T(erminate) command                */
  349. /************************************************************************/
  350. doLogout(expand, first)
  351. char expand;    /* TRUE to accept following parameters    */
  352. char first;    /* first parameter if TRUE        */
  353. {
  354.     char iChar(), toUpper();
  355.  
  356.     if (expand)   first = '\0';
  357.  
  358.     mprintf("erminate ");
  359.  
  360.     if (first)     oChar(first);
  361.  
  362.     switch (toUpper(    first ? first : iChar()    )) {
  363.     case '?':
  364.     mprintf("\n Logout options:\n \n ");
  365.  
  366.     mprintf("Quit-also\n "        );
  367.     mprintf("Stay\n "        );
  368.     break;
  369.     case 'Q':
  370.     mprintf("uit-also\n ");
  371.     if (!expand)   {
  372.        if (!getYesNo("confirm"))   break;
  373.     }
  374.     terminate( /* hangUp == */ TRUE);
  375.     break;
  376.     case 'S':
  377.     mprintf("tay\n ");
  378.     terminate( /* hangUp == */ FALSE);
  379.     break;
  380.     }
  381. }
  382.  
  383. /************************************************************************/
  384. /*    doRead() handles R(ead) command                 */
  385. /************************************************************************/
  386. doRead(moreYet, first)
  387. char moreYet;    /* TRUE to accept following parameters    */
  388. char first;    /* first parameter if TRUE        */
  389. {
  390.     char iChar(), toUpper();
  391.     int  fileDir(), transmitFile();
  392.     char abort, doDir, done, hostFile, whichMess, revOrder, status, WC;
  393.     char fileName[NAMESIZE];
  394.  
  395.  
  396.     if (moreYet)   first = '\0';
  397.  
  398.     mprintf("\bread ");
  399.  
  400.     if (!loggedIn  &&  !unlogReadOk)   {
  401.     mPrintf("Must log in to read\n ");
  402.     return;
  403.     }
  404.  
  405.     if (first)       oChar(first);
  406.  
  407.     abort    = FALSE;
  408.     doDir    = FALSE;
  409.     done    = FALSE;
  410.     hostFile    = FALSE;
  411.     revOrder    = FALSE;
  412.     status    = FALSE;
  413.     WC        = FALSE;
  414.     whichMess    = NEWoNLY;
  415.  
  416.     do {
  417.     outFlag = OUTOK;
  418.  
  419.     switch (toUpper(   first ? first : iChar()   )) {
  420.     case '\n':
  421.     case '\r':
  422.         moreYet    = FALSE;
  423.         break;
  424.     case 'A':
  425.         mprintf("ll ");
  426.         whichMess    = OLDaNDnEW;
  427.         break;
  428.     case 'F':
  429.         mprintf("orward ");
  430.         revOrder    = FALSE;
  431.         whichMess    = OLDaNDnEW;
  432.         break;
  433.     case 'G':
  434.         mPrintf("lobal new-messages ");
  435.         whichMess    = GLOBALnEW;
  436.         break;
  437.     case 'N':
  438.         mprintf("ew ");
  439.         whichMess    = NEWoNLY;
  440.         break;
  441.     case 'O':
  442.         mPrintf("ld ");
  443.         revOrder    = TRUE;
  444.         whichMess    = OLDoNLY;
  445.         break;
  446.     case 'R':
  447.         mprintf("everse ");
  448.         revOrder    = TRUE;
  449.         whichMess    = OLDaNDnEW;
  450.         break;
  451.     case 'S':
  452.         mprintf("tatus ");
  453.         status    = TRUE;
  454.         done    = TRUE;
  455.         break;
  456.     case 'W':
  457.         mprintf("C protocol ");
  458.         WC        = TRUE;
  459.         break;
  460.     case 'B':
  461.         if (roomBuf.rbflags & CPMDIR)   {
  462.         mprintf("inary file(s) ");
  463.         done        = TRUE ;
  464.         hostFile    = TRUE ;
  465.         textDownload    = FALSE;
  466.         break;
  467.         }
  468.     case 'D':
  469.         if (roomBuf.rbflags & CPMDIR)   {
  470.         mprintf("irectory ");
  471.         doDir    = TRUE;
  472.         done    = TRUE;
  473.         break;
  474.         }
  475.     case 'T':
  476.         if (roomBuf.rbflags & CPMDIR)   {
  477.         mprintf("extfile(s) ");
  478.         done        = TRUE;
  479.         hostFile    = TRUE;
  480.         textDownload    = TRUE;
  481.         break;
  482.         }
  483.     default:
  484.         mprintf("? ");
  485.         abort    = TRUE;
  486.         setUp(FALSE);
  487.         if (expert)   break;
  488.     case '?':
  489.         tutorial("readopt.mnu");
  490.         abort    = TRUE;
  491.         break;
  492.     }
  493.     first = '\0';
  494.     } while (!done && moreYet && !abort);
  495.  
  496.     if (abort) return;
  497.  
  498.     if (status) {
  499.     systat();
  500.     return;
  501.     }
  502.  
  503.     if (doDir) {
  504.     FDSectCount    = 0;    /* global fileDir() totals sectors in    */
  505.  
  506.     getString("", fileName, NAMESIZE);
  507.  
  508.     normalizeString(fileName);
  509.  
  510.     if (strLen(fileName))    wildCard(fileDir, fileName);
  511.     else            wildCard(fileDir, "*.*"   );
  512.  
  513.     mprintf("\n %d sectors total\n ", FDSectCount);
  514.     return;
  515.     }
  516.  
  517.     if (hostFile) {
  518.     getString("afn", fileName, NAMESIZE);
  519.     normalizeString(fileName);
  520.     usingWCprotocol = WC;
  521.     wildCard(transmitFile, fileName);
  522.     usingWCprotocol = FALSE;
  523.     return;
  524.     }
  525.  
  526.     doCR();
  527.     if (WC) {
  528.     download(whichMess, revOrder);
  529.     return;
  530.     }
  531.  
  532.     if (whichMess != GLOBALnEW)   {
  533.     showMessages(whichMess, revOrder);
  534.     } else {
  535.     while (outFlag != OUTSKIP   &&     gotoRoom(""))     {
  536.         givePrompt();
  537.         mPrintf("read new\n ");
  538.         showMessages(NEWoNLY, revOrder);
  539.     }
  540.     }
  541. }
  542.  
  543. /************************************************************************/
  544. /*    doRegular()                            */
  545. /************************************************************************/
  546. char doRegular(x, c)
  547. char x, c;
  548. {
  549.     char toReturn;
  550.  
  551.     toReturn = FALSE;
  552.  
  553.     switch (c) {
  554.  
  555.     case 'C': doChat(  x, '\0');            break;
  556.     case 'E': doEnter( x, 'm' );            break;
  557.     case 'F': doRead(  x, 'f' );            break;
  558.     case 'G': doGoto(  x, '\0');            break;
  559.     case 'H': doHelp(  x, '\0');            break;
  560.     case 'K': doKnown( x, '\0');            break;
  561.     case 'L': doLogin( x, '\0');            break;
  562.     case 'N': doRead(  x, 'n' );            break;
  563.     case 'O': doRead(  x, 'o' );            break;
  564.     case 'R': doRead(  x, 'r' );            break;
  565.     case 'T': doLogout(x, 'q' );            break;
  566.  
  567.     case 0:
  568.     if (newCarrier)   {
  569.         greeting();
  570.         newCarrier    = FALSE;
  571.     }
  572.     if (justLostCarrier) {
  573.         justLostCarrier = FALSE;
  574.         if (loggedIn) terminate(FALSE);
  575.     }
  576.     break;    /* irrelevant value */
  577.     case '?':
  578.     tutorial("mainopt.mnu");
  579.     if (whichIO == CONSOLE)   mprintf(" ^p: privileged fns\n ");
  580.     break;
  581.  
  582.     case 'A': if (!doAide(x, 'E'))  toReturn=TRUE;    break;
  583.     default:
  584.     toReturn=TRUE;
  585.     break;
  586.     }
  587.     return  toReturn;
  588. }
  589.  
  590. /************************************************************************/
  591. /*    doSysop() handles the sysop-only menu                */
  592. /*        return FALSE to fall invisibly into default error msg    */
  593. /************************************************************************/
  594. char doSysop(c, first)
  595. char c;
  596. char first;    /* first parameter if TRUE        */
  597. {
  598.     char        who[NAMESIZE];
  599.     struct logBuffer    lBuf;
  600.     int         logNo, ltabSlot;
  601.  
  602.     if (!onConsole)   return TRUE;
  603.  
  604.     while (TRUE)   {
  605.  
  606.     mprintf("\n privileged fn: ");
  607.  
  608.     switch (toUpper(   first ? first : iChar()    )) {
  609.     case 'A':
  610.         mPrintf("bort\n ");
  611.         return FALSE;
  612.     case 'C':
  613.         mprintf("hat mode %sabled\n ",
  614.         (noChat = !noChat)
  615.         ?
  616.         "dis"
  617.         :
  618.         "en"
  619.         );
  620.         break;
  621.     case 'D':
  622.         debug = !debug;
  623.         mprintf("ebug switch=%d\n \n", debug);
  624.         break;
  625.     case 'K':
  626.         mPrintf("ill account\n ");
  627.         if (!getYesNo("Confirm"))    break;
  628.         getString("who", who, NAMESIZE);
  629.         normalizeString(who);
  630.         logNo   = findPerson(who, &lBuf);
  631.         if (logNo == ERROR)   {
  632.         mPrintf("No such person\n ");
  633.         break;
  634.         }
  635.         mPrintf(
  636.         "%s deleted\n ",
  637.         who
  638.         );
  639.         ltabSlot = PWSlot(lBuf.lbpw);
  640.         lBuf.lbname[0] = '\0';
  641.         lBuf.lbpw[0  ] = '\0';
  642.  
  643.         putLog(&lBuf, logNo);
  644.  
  645.         logTab[ltabSlot].ltpwhash        = 0;
  646.         logTab[ltabSlot].ltnmhash        = 0;
  647.  
  648.         break;
  649.     case 'M':
  650.         mprintf("\bSystem now on MODEM\n ");
  651.         whichIO = MODEM;
  652.         setUp(FALSE);
  653.         mprintf("Chat mode %sabled\n ", noChat  ?  "dis"  :  "en");
  654.         if (debug)         mPrintf("Debug mode on\n "  );
  655.         if (visibleMode) mPrintf("Visible mode on\n ");
  656.         return FALSE;
  657.     case 'P':
  658.         mPrintf("\baide privilege set/clear\n ");
  659.         getString("who", who, NAMESIZE);
  660.         normalizeString(who);
  661.         logNo   = findPerson(who, &lBuf);
  662.         if (logNo == ERROR)   {
  663.         mPrintf("No such person\n ");
  664.         break;
  665.         }
  666.  
  667.         lBuf.lbflags ^= AIDE;
  668.         mPrintf(
  669.         "%s %s aide privileges\n ",
  670.         who,
  671.         (lBuf.lbflags & AIDE)  ?  "gets"  :  "loses"
  672.         );
  673.         if (!getYesNo("Confirm"))    break;
  674.  
  675.         putLog(&lBuf, logNo);
  676.  
  677.         /* see if it is us: */
  678.         if (loggedIn  &&  strCmpU(logBuf.lbname, who)==SAMESTRING)     {
  679.         aide = lBuf.lbflags & AIDE;
  680.         }
  681.         break;
  682.     case 'R':
  683.         patchDebug();
  684.         break;
  685.     case 'S':
  686.         mprintf("et date\n \n");
  687.         interpret(pInitDate);
  688.         break;
  689.     case 'V':
  690.         mprintf(" VisibleMode==%d\n ",  visibleMode = !visibleMode);
  691.         break;
  692.     case 'X':
  693.         mprintf("\bexit to CP/M\n \n");
  694.         exitToCpm = TRUE;
  695.         return FALSE;
  696.     case '?':
  697.         tutorial("ctdlopt.mnu");
  698.         break;
  699.     default:
  700.         if (!expert)    mprintf(" ?(Type '?' for menu)\n "        );
  701.         else        mprintf(" ?\n "                );
  702.         break;
  703.     }
  704.     }
  705. }
  706.  
  707. /************************************************************************/
  708. /*    getCommand() prints menu prompt and gets command char        */
  709. /*    Returns: char via parameter and expand flag as value  --    */
  710. /*         i.e., TRUE if parameters follow else FALSE.        */
  711. /************************************************************************/
  712. char getCommand(c)
  713. char *c;
  714. {
  715.     char BBSCharReady(), iChar(), toUpper();
  716.     char expand;
  717.  
  718.     outFlag = OUTOK;
  719.  
  720.   /*if (*c)*/ givePrompt();
  721.     while (BBSCharReady())   iChar();          /* eat type-ahead       */
  722.  
  723.     *c = toUpper(iChar());
  724.  
  725.     expand  = (
  726.     *c == ' '
  727.     ||
  728.     *c == '.'
  729.     ||
  730.     *c == ','
  731.     ||
  732.     *c == '/'
  733.     );
  734.     if (expand) *c = toUpper(iChar());
  735.  
  736.     if (justLostCarrier) {
  737.     justLostCarrier = FALSE;
  738.     if (loggedIn) terminate(FALSE);
  739.     }
  740.     return expand;
  741. }
  742.  
  743. /************************************************************************/
  744. /*    greeting() gives system-entry blurb etc             */
  745. /************************************************************************/
  746. greeting() {
  747.     if (loggedIn) terminate(FALSE);
  748.  
  749.     setUp(TRUE);     pause(10);
  750.  
  751.     mprintf("\n Welcome to the %S \n ", nodeTitle );
  752.     mprintf("\n node of Citadel Version 2.1\n \n ");
  753.     printDate(
  754.     interpret(pGetYear ),
  755.     interpret(pGetMonth),
  756.     interpret(pGetDay  )
  757.     );
  758.     mprintf("\n H for Help\n ");
  759.     Mprintf("\n L for Login\n");
  760.     printf("\n 'MODEM' mode.\n "     );
  761.     printf("(<ESC> for CONSOLE mode.)\n ");
  762.  
  763.     gotoRoom("Lobby");
  764. }
  765.  
  766. /************************************************************************/
  767. /*    main() contains the central menu code                */
  768. /************************************************************************/
  769. main() {
  770.     char c, x;
  771.     char getCommand(), init();
  772.     
  773.     if (FALSE) putChar();    /* pick up our own in modem.c    */
  774.     if (FALSE)     getNumber();    /* dummy to force load */
  775.  
  776.     /* don't put any code above init()... readSysTab() will defeat it.    */
  777.     init();
  778.     initCitadel();
  779.     weAre    = CITADEL;
  780.     greeting();
  781.  
  782.     while (!exitToCpm) {
  783.     x    = getCommand(&c);
  784.  
  785.     outFlag = OUTOK;
  786.  
  787.     if ((c==CNTRLp)  ?  doSysop(0, '\0')  :  doRegular(x, c))  {
  788.         if (!expert)    mprintf(" ? (Type '?' for menu)\n \n"   );
  789.         else        mprintf(" ?\n \n"                );
  790.     }
  791.     }
  792.     if (loggedIn) terminate( /* hangUp == */ TRUE);
  793.     writeSysTab(); 
  794. }
  795.  
  796.