home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / zip / gnu / gemlib27.lzh / GEMLIB27 / WINPROTO.C < prev    next >
C/C++ Source or Header  |  1993-07-30  |  5KB  |  263 lines
  1. /*
  2.  * This file contains the routines which implement the uw protocol.
  3.  * Code has been migrating here from winmain.c, but its not all here yet.
  4.  */
  5.  
  6. #ifdef __GNUC__
  7. #  include <gemfast.h>
  8. #  include <aesbind.h>
  9. #  include <vdibind.h>
  10. #else
  11. #  include <gemdefs.h>
  12. #endif
  13. #include <stdio.h>
  14. #include <osbind.h>
  15. #include "wind.h"
  16. #include "uw.h"
  17. #include "windefs.h"
  18.  
  19. #define LIMIT    300
  20.  
  21. extern    struct    wi_str    w[];
  22. extern int outport;            /* ports used with uw */
  23. extern int inwind, outwind;        /* windows for input/output */
  24. extern int uw_runs;            /* is uw running ? */
  25. FNT    *curfont;            /* font in use */
  26.  
  27. /* proto_out sends length chars from str to the window defined by outport. */
  28. proto_out(outport, str, length)
  29. int outport, length;
  30. char *str;
  31.  
  32. {
  33. static int oldoutport = 1;
  34. int key, i;
  35. int outwind;
  36.  
  37. outwind = find_wind(outport);
  38.   if (w[outwind].w_local == TRUE)    /* local window? */
  39.   {
  40.     char *found, *index();
  41.     char strcr[3] = "\r\n";
  42.  
  43.     str[length] = '\0';
  44.     while (found = index(str, '\r'))
  45.     {
  46.       char line[500];
  47.       strncpy(line, str, (long)(found - str));
  48.       line[found-str] = '\0';
  49.       w_output(outwind, line);
  50.       w_output(outwind, strcr);
  51.       str = found + 1;
  52.     }
  53.     w_output(outwind, str);
  54.     return;
  55.   }
  56.   for (key = *str, i = 0; i < length; key = str[++i])
  57.   {
  58.     if (uw_runs)
  59.     {
  60.       if (outport != oldoutport)
  61.       {
  62.         xmitcmd(CB_FN_ISELW|outport);
  63.         oldoutport = outport;
  64.       }
  65.       if (key & 0x80) {
  66.         key &= 0x7f;
  67.     xmitcmd(CB_FN_META);
  68.       }
  69.       switch (key)
  70.       {
  71.       case XON:
  72.         xmitcmd(CB_FN_CTLCH|CB_CC_ON);
  73.         break;
  74.  
  75.       case XOFF:
  76.         xmitcmd(CB_FN_CTLCH|CB_CC_OFF);
  77.         break;
  78.  
  79.       case IAC:
  80.         xmitcmd(CB_FN_CTLCH|CB_CC_IAC);
  81.         break;
  82.  
  83.       default:
  84.         Bconout(1, key);
  85.         break;
  86.       }
  87.     } else
  88.       Bconout(1, key);    /* need mask with 0x7f? */
  89.   }
  90. }
  91.  
  92. /*
  93.  * proto_close closes the current window and notifies the remote.  The new
  94.  * current window is returned.
  95.  */
  96. int proto_close(curwind)
  97. int curwind;
  98. {
  99.   long dummy;
  100.  
  101.   if (uw_runs && (find_port(curwind) < MAX_WIND))
  102.   {
  103.     xmitcmd(CB_FN_KILLW|find_port(curwind));
  104.   }
  105.   w_close(curwind);
  106.   wind_get(0, WF_TOP, &curwind, &dummy, &dummy, &dummy);
  107.   return (curwind);
  108. /*  } else
  109.   {
  110.     w_close(curwind);
  111.     return (0);
  112.   } */
  113. }
  114.  
  115. /* proto_in receives characters from the serial port. */
  116. proto_in()
  117. #define NORMSTATE 0
  118. #define IACSTATE 1
  119. /* #define METASTATE 2  replaced with seenmeta flag. */
  120. #define INITSTATE 3
  121. {
  122.   register char    *ptr;
  123.   char    str[LIMIT+2];
  124.   register char    chr;
  125.   register int    cnt;
  126.   long dummy;
  127.   static int state;
  128.   static int seenmeta = 0;
  129.  
  130.       ptr = str;
  131.       cnt = 0;
  132.       while (Bconstat(1) && cnt++<LIMIT)
  133.       {
  134.     chr = Bconin(1)&0x7f;
  135.     switch (state)
  136.     {
  137.     case NORMSTATE:
  138.       if (!chr || chr=='\177') continue;
  139.       if (chr == IAC)
  140.       {
  141.         if (uw_runs)
  142.           state = IACSTATE;
  143.         else
  144.           state = INITSTATE;
  145.         continue;
  146.       }
  147.       if (seenmeta) {
  148.         seenmeta = 0;
  149.         *ptr++ = chr|0x80;
  150.       }
  151.       else *ptr++ = chr;
  152.       break;
  153.     case INITSTATE:
  154.       if (chr == CB_FN_MAINT | CB_MF_ENTRY){
  155.         xmitcmd(CB_FN_MAINT|CB_MF_ENTRY);
  156.         uw_runs = 1;
  157.         outport = 0;
  158.         outwind = 0;
  159.       }
  160.       else {
  161.         *ptr++ = IAC;
  162.         *ptr++ = chr;
  163.       }
  164.       state = NORMSTATE;
  165.       break;
  166.     case IACSTATE:
  167.       state = NORMSTATE;
  168.       if (chr&CB_DIR_MTOH) continue;
  169.       switch (chr&CB_FN)
  170.       {
  171.       case CB_FN_NEWW:
  172.         outport = w_open(chr&CB_WINDOW, "Terminal", curfont->def_win_x,
  173.           curfont->def_win_y);
  174.         outwind = find_wind(outport);
  175.         xmitcmd(CB_FN_ISELW|outport);
  176.         break;
  177.  
  178.       case CB_FN_KILLW:
  179.         w_close(find_wind(chr&CB_WINDOW));
  180.         wind_get(0, WF_TOP, &outwind, &dummy, &dummy, &dummy);
  181.         outport = find_port(outwind);
  182.         break;
  183.  
  184.       case CB_FN_OSELW:
  185.         if (inwind != find_wind(chr&CB_WINDOW))
  186.         {
  187.           *ptr = '\0';
  188.           if (ptr != str)
  189.           {
  190.             if (w[inwind].kerm_act)
  191.           rpack(" ", NULL, str);
  192.         else
  193.           w_output(inwind, str);
  194.           }
  195.           ptr = str;
  196.         }
  197.         inwind = find_wind(chr&CB_WINDOW);
  198.         break;
  199.  
  200.       case CB_FN_META:
  201.         seenmeta = 1;
  202.         break;
  203.  
  204.       case CB_FN_CTLCH:
  205.         switch (chr&CB_CC)
  206.         {
  207.         case CB_CC_IAC:
  208.           if (seenmeta) {
  209.             seenmeta = 0;
  210.             *ptr++ = IAC|0x80;
  211.           }
  212.           else *ptr++ = IAC;
  213.           break;
  214.  
  215.         case CB_CC_ON:
  216.           if (seenmeta) {
  217.             seenmeta = 0;
  218.             *ptr++ = XON|0x80;
  219.           }
  220.           else *ptr++ = XON;
  221.           break;
  222.  
  223.         case CB_CC_OFF:
  224.           if (seenmeta) {
  225.             seenmeta = 0;
  226.             *ptr++ = XOFF|0x80;
  227.           }
  228.           else *ptr++ = XOFF;
  229.  
  230.           break;
  231.         }
  232.         break;
  233.  
  234.       case CB_FN_MAINT:
  235.         switch (chr&CB_MF)
  236.         {
  237.         case CB_MF_ENTRY:
  238.           xmitcmd(CB_FN_MAINT|CB_MF_ENTRY);
  239.           uw_runs = 1;
  240.           outport = 0;
  241.           outwind = 0;
  242.           break;
  243.  
  244.         case CB_MF_EXIT:
  245.           uw_runs = 0;
  246.           return (-1);
  247.         }
  248.         break;
  249.       }
  250.       break;
  251.     }
  252.       }
  253.       *ptr = '\0';
  254.       if (ptr!=str)
  255.       {
  256.         if (w[inwind].kerm_act)
  257.       rpack(" ", NULL, str);
  258.     else
  259.       w_output(inwind, str);
  260.       }
  261.       return (0);
  262. }
  263.