home *** CD-ROM | disk | FTP | other *** search
/ Transactor / Transactor_26_1988_Transactor_Publishing.d64 / cmast.c < prev    next >
Text File  |  2023-02-26  |  5KB  |  276 lines
  1. /* cmast.c - main for cmaster */
  2. /* W Mat Waites - Sept 1988 */
  3.  
  4. #include <stdio.h>
  5.  
  6. #define DEFBAUD 1200
  7. #define DEFDRIVE 9
  8.  
  9. /* globals */
  10. int echo;
  11. int baud;
  12. int bpchar;
  13. int stopbits;
  14. int parity;
  15. int ddrive;
  16. int done;
  17.  
  18. /* main() - main program for cmast */
  19. main(argc, argv)
  20. unsigned argc;
  21. char *argv[];
  22. {SHIFT-+}
  23.   int kbchar, serchar;
  24.   int outch;
  25.  
  26.   /* initialization */
  27.   done = 0;
  28.   echo = 0;
  29.   baud = DEFBAUD;
  30.   bpchar = 8;
  31.   stopbits = 1;
  32.   parity = 0;  /* 0 - none */
  33.   ddrive = DEFDRIVE;
  34.  
  35.   /* check for baud rate parameter */
  36.   if(argc > 1)
  37.     {SHIFT-+}
  38.     baud = atoi(argv[1]);
  39.     switch(baud)
  40.       {SHIFT-+}
  41.       case 300:
  42.       case 450:
  43.       case 1200:
  44.         break;
  45.       default:
  46.         baud = DEFBAUD;
  47.         break;
  48.       {SHIFT--}
  49.     {SHIFT--}
  50.  
  51.   /* open files */
  52.   openkb();
  53.   openserial();
  54.   setserial(baud, bpchar,
  55.     stopbits, parity);
  56.  
  57.   /* set colors */
  58.   setborder(15);
  59.   setbg(0);
  60.   setfg(1);
  61.  
  62.   initscr();
  63.   titlescr();
  64.   sleep(2);
  65.  
  66.   erase();
  67.   move(0, 0);
  68.   cursoron();
  69.   updatecursor();
  70.  
  71.   /* main loop */
  72.   while(!done)
  73.     {SHIFT-+}
  74.  
  75.     /* check for <C=> key */
  76.     if(chkstop())
  77.       {SHIFT-+}
  78.       cursoroff();
  79.       menu();
  80.       updatecursor();
  81.       cursoron();
  82.       {SHIFT--}
  83.  
  84.     /* check keyboard */
  85.     while(charsinq() > 0 && !done)
  86.       {SHIFT-+}
  87.       kbchar = getkb();
  88.  
  89.       if(kbchar >= 133 &&
  90.          kbchar <= 140)
  91.         {SHIFT-+}
  92.         /* function keys */
  93.         putfunct(kbchar);
  94.         {SHIFT--}
  95.       else
  96.         {SHIFT-+}
  97.         /* non-function keys */
  98.         if(echo)  /* local echo */
  99.           {SHIFT-+}
  100.           if(isprint(kbchar) {CBM-*}{CBM-*}
  101.             iscntrl(kbchar))
  102.             {SHIFT-+}
  103.             putchar((char)kbchar);
  104.             updatecursor();
  105.             {SHIFT--}
  106.           {SHIFT--}
  107.         outch = cbmtoasc(kbchar);
  108.         if(outch)
  109.           {SHIFT-+}
  110.           putserial((char)outch);
  111.           {SHIFT--}
  112.         {SHIFT--}
  113.       {SHIFT--}
  114.  
  115.     /* check serial port */
  116.     if(!done)
  117.       {SHIFT-+}
  118.       while((serchar=getserial()) >= 0)
  119.         {SHIFT-+}
  120.         /* mask to 7 bits */
  121.         serchar &= 0x7f;
  122.         switch(serchar)
  123.           {SHIFT-+}
  124.           case 7:   /* BEL */
  125.             break;
  126.           case 8:   /* BS */
  127.             putchar(157);
  128.             break;
  129.           case 9:   /* TAB */
  130.             putchar(' ');
  131.             putchar(' ');
  132.             break;
  133.           case 10:  /* LF */
  134.             putchar(17);
  135.             break;
  136.           case 12:  /* FF */
  137.             erase();
  138.             break;
  139.           case 13:  /* CR */
  140.             putchar(13);
  141.             putchar(145);  /* move up */
  142.             break;
  143.           default:
  144.             outch=asctocbm(serchar);
  145.             if(outch)
  146.               {SHIFT-+}
  147.               putchar((char)outch);
  148.               {SHIFT--}
  149.             else  /* unexpected char */
  150.               {SHIFT-+}
  151.               /*printf("[%d]", serchar);*/
  152.               /*putchar((char)serchar);*/
  153.               {SHIFT--}
  154.             break;
  155.           {SHIFT--}
  156.         updatecursor();
  157.         if(charsinq() > 0 {CBM-*}{CBM-*} chkstop())
  158.           {SHIFT-+}
  159.           break;
  160.           {SHIFT--}
  161.         {SHIFT--}
  162.       {SHIFT--}
  163.     {SHIFT--}
  164.  
  165.   /* shut down */
  166.   cursoroff();
  167.   erase();
  168.   closekb();
  169.   closeserial();
  170.   move(23, 0);
  171. {SHIFT--}
  172.  
  173. /* cmaster support routines */
  174.  
  175. /* titlescr() - initial display */
  176. titlescr()
  177. {SHIFT-+}
  178.   erase();
  179.   center(5, "Cmaster Terminal");
  180.   center(15, "Press <C=> for menu");
  181. {SHIFT--}
  182.  
  183. /* cbmtoasc() - convert cbm to ascii */
  184. cbmtoasc(cbmchar)
  185. int cbmchar;
  186. {SHIFT-+}
  187.   /* lower case */
  188.   if(cbmchar >= 65 && cbmchar <= 90)
  189.     {SHIFT-+}
  190.     return(cbmchar + 32);
  191.     {SHIFT--}
  192.  
  193.   /* upper case */
  194.   if(cbmchar >= 193 && cbmchar <= 218)
  195.     {SHIFT-+}
  196.     return(cbmchar - 128);
  197.     {SHIFT--}
  198.  
  199.   if(cbmchar == 20)  /* backspace */
  200.     {SHIFT-+}
  201.     return(8);
  202.     {SHIFT--}
  203.  
  204.   return(cbmchar);
  205. {SHIFT--}
  206.  
  207. /* asctocbm() - convert ascii to cbm */
  208. asctocbm(ascchar)
  209. int ascchar;
  210. {SHIFT-+}
  211.   /* upper case */
  212.   if(ascchar >= 65 && ascchar <= 90)
  213.     {SHIFT-+}
  214.     return(ascchar + 128);
  215.     {SHIFT--}
  216.  
  217.   /* lower case */
  218.   if(ascchar >= 97 && ascchar <= 122)
  219.     {SHIFT-+}
  220.     return(ascchar - 32);
  221.     {SHIFT--}
  222.  
  223.   if(ascchar >= 32 && ascchar <= 64)
  224.     {SHIFT-+}
  225.     return(ascchar);
  226.     {SHIFT--}
  227.  
  228.   if(ascchar >= 91 && ascchar <= 95)
  229.     {SHIFT-+}
  230.     return(ascchar);
  231.     {SHIFT--}
  232.  
  233.   return 0;
  234. {SHIFT--}
  235.  
  236. /* putserstr() - put string to port */
  237. putserstr(str)
  238. char *str;
  239. {SHIFT-+}
  240.   while(*str)
  241.     {SHIFT-+}
  242.     putserial((char)cbmtoasc((int)*str));
  243.     str++;
  244.     {SHIFT--}
  245. {SHIFT--}
  246.  
  247. static char *funcstr[8] =
  248.   {SHIFT-+}
  249.   "Function Key 1\n",
  250.   "Function Key 3\n",
  251.   "Function Key 5\n",
  252.   "Function Key 7\n",
  253.   "Function Key 2\n",
  254.   "Function Key 4\n",
  255.   "Function Key 6\n",
  256.   "Function Key 8\n"
  257.   {SHIFT--};
  258.  
  259. /* putfunct() - put function key string */
  260. putfunct(key)
  261. int key;
  262. {SHIFT-+}
  263.   unsigned lockey;
  264.  
  265.   if(key < 133 {CBM-*}{CBM-*} key > 140)
  266.     {SHIFT-+}
  267.     return;
  268.     {SHIFT--}
  269.  
  270.   lockey = key - 133;
  271.  
  272.   putserstr(funcstr[lockey]);
  273.  
  274. {SHIFT--}
  275. /* end of file */
  276.