home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / win100b.zip / wktv10.l < prev    next >
Text File  |  1991-10-20  |  20KB  |  995 lines
  1. %{
  2. #define NOKANJI
  3. #define NOATOM
  4. #define NOMINMAX
  5. #define NOSOUND
  6. #include <windows.h>
  7. #ifdef COLUMBIA
  8. #include "wktsmt.h"
  9. #include "wkt100.h"
  10. #else
  11. #include "smterm.h"
  12. #include "win600.h"
  13. #endif
  14. #ifdef WIN600
  15. #include "grterm.h"
  16. #endif
  17.  
  18. #undef YYLEX
  19. #define YYLEX vt100
  20.  
  21. #undef YYLMAX
  22. #define YYLMAX (BUFSIZE + 1)
  23.  
  24. #define YY_PRESERVE
  25.  
  26. #undef YY_INTERACTIVE
  27. #define YY_INTERACTIVE    0
  28.  
  29. #undef output
  30. #define output(c)
  31.  
  32. #undef yygetc
  33. #define yygetc mygetc
  34.  
  35. #undef YY_FATAL
  36. #define YY_FATAL(msg) {HWND hError = GetTopWindow(MWnd.hWnd); \
  37.                if (!hError) hError = MWnd.hWnd; \
  38.                MessageBox(hError,msg,szAppName, \
  39.                   MB_OK | MB_ICONEXCLAMATION); \
  40.                PostMessage(MWnd.hWnd, WM_SYSCOMMAND, SC_CLOSE, 0L);}
  41.  
  42. static int accum;
  43. static int list[MAXPROTOLEN];
  44. static int lptr, hptr;
  45. static int *pn;
  46. static int * NEAR getnextelement(BOOL corr);
  47. static int NEAR mygetc(void);
  48. static void NEAR doesc(register BYTE c);
  49. static void NEAR dosharp(register BYTE c);
  50. static void NEAR doscsl(register BYTE c);
  51. static void NEAR doscsr(register BYTE c);
  52. static void NEAR docsi(register BYTE c);
  53. static int NEAR doendnum(register BYTE c);
  54. static BOOL NEAR doquesendnum(register BYTE c);
  55. static int oldstate;
  56.  
  57. %}
  58.  
  59. ENQ    [\005]
  60. BEL    [\007]
  61. BS    [\010]
  62. HT    [\011]
  63. LF    [\012]
  64. VT    [\013]
  65. FF    [\014]
  66. CR    [\015]
  67. SO    [\016]
  68. SI    [\017]
  69. CAN    [\030]
  70. EM    [\031]
  71. SUB    [\032]
  72. ESC    [\033]
  73. FS    [\034]
  74. GS    [\035]
  75. RS    [\036]
  76. US    [\037]
  77. SPC    [\040]
  78. DEL    [\177]
  79. IND    [\204]
  80. NEL    [\205]
  81. HTS    [\210]
  82. RI    [\215]
  83. SS2    [\216]
  84. SS3    [\217]
  85. DCS    [\220]
  86. CSI    [\233]
  87. ST    [\234]
  88. ANSI    [\040-\176\221-\222\240-\377]
  89. CTRL    [\000-\037\177\200-\220\223-\237]
  90.  
  91. %p    3000
  92.  
  93. %s esc csi sharp lpr rpr innum endnum ques quesinnum quesendnum
  94. %x crep
  95. %%
  96.  
  97. <crep>[\012-\014] {
  98.     SendMessage(hWndText,SMT_STRINGINPUT,yyleng,(LONG)(LPSTR)yytext);
  99.     SendMessage(hWndText, SMT_COMMAND, SM_NEXTLINE, (LONG)yyleng);
  100. }
  101.  
  102. <crep>[\000-\011\015-\377]+ {
  103.     SendMessage(hWndText,SMT_STRINGINPUT,yyleng,(LONG)(LPSTR)yytext);
  104. }
  105.  
  106. {ENQ}+ {
  107.     if (MWnd.AutoAnswer) {
  108.     while (yyleng--)
  109.         ShowAnswerBack();
  110.     }
  111. }
  112.  
  113. {BEL}+ {
  114.     if (MWnd.WarningBell) {
  115.     while (yyleng--)
  116.         MessageBeep(0);
  117.     }
  118. }
  119.  
  120. {BS}+ {
  121.     SendMessage(hWndText, SMT_COMMAND, SM_BKSP, (LONG)yyleng);
  122. }    
  123.  
  124. {HT}+ {
  125.     SendMessage(hWndText, SMT_COMMAND, SM_TAB, (LONG)yyleng);
  126. }    
  127.  
  128. [\012-\014]+ {
  129.     SendMessage(hWndText, SMT_COMMAND,
  130.         MWnd.LFCR ? SM_NEXTLINE : SM_INDEX, (LONG)yyleng);
  131. }
  132.  
  133. {CR}+ {
  134.     SendMessage(hWndText, SMT_COMMAND, SM_LEFTMARGIN, (LONG)yyleng);
  135. }
  136.  
  137. {SO}+ {
  138.     // select G1 character set into GL
  139.     MWnd.ActiveCharSet = 1;
  140.     SendMessage(hWndText,SMT_COMMAND,SM_SETCHARSET,(LONG)MWnd.CharSet[1]);
  141. }
  142.  
  143. {SI}+ {
  144.     // select G0 character set into GL
  145.     MWnd.ActiveCharSet = 0;
  146.     SendMessage(hWndText,SMT_COMMAND,SM_SETCHARSET,(LONG)MWnd.CharSet[0]);
  147. }
  148.  
  149. {CAN}+ {
  150.     BEGIN 0;
  151. }
  152.  
  153. {SUB}+ {
  154.     SendMessage(hWndText,SMT_STRINGINPUT,yyleng,(LONG)(LPSTR)yytext);
  155.     BEGIN 0;
  156. }
  157.  
  158. {IND}+ {
  159.     SendMessage(hWndText, SMT_COMMAND, SM_INDEX, (LONG)yyleng);
  160. }
  161.  
  162. {NEL}+ {
  163.     SendMessage(hWndText, SMT_COMMAND, SM_NEXTLINE, (LONG)yyleng);
  164. }
  165.  
  166. {HTS} {
  167.     SendMessage(hWndText, SMT_COMMAND, SM_SETTAB, 1L);
  168. }
  169.  
  170. {RI}+ {
  171.     SendMessage(hWndText, SMT_COMMAND, SM_REVERSEINDEX, (LONG)yyleng);
  172. }
  173.  
  174. {CSI} {
  175.     memset((char *)list, 0, 2 * MAXPROTOLEN);
  176.     lptr = hptr = -1;
  177.     accum = 0;
  178.     BEGIN csi;
  179. }
  180.  
  181. {ESC} {
  182.     BEGIN esc;
  183. }
  184.  
  185. {CTRL} {
  186.     ;
  187. }
  188.  
  189. <0>{ANSI}+ {
  190.     SendMessage(hWndText,SMT_STRINGINPUT,yyleng,(LONG)(LPSTR)yytext);
  191. }
  192.  
  193. <esc>[#\(\)78=\>DEHMZ\[c] {
  194.     doesc(*yytext);
  195. }
  196.  
  197. <sharp>[345678] {
  198.     dosharp(*yytext);
  199. }
  200.  
  201. <lpr>[012AB\<] {
  202.     doscsl(*yytext);
  203. }
  204.  
  205. <rpr>[012AB\<] {
  206.     doscsr(*yytext);
  207. }
  208.  
  209. <csi>[0-9] {
  210.     accum = *yytext - '0';
  211.     BEGIN innum;
  212. }
  213.  
  214. <csi>[\;\?ABCDHJKLMPcfgmr] {
  215.     docsi(*yytext);
  216. }
  217.  
  218. <innum>[0-9] {
  219.     accum = 10 * accum + *yytext - '0';
  220. }
  221.  
  222. <innum>\; {
  223.     if (lptr < (MAXPROTOLEN - 1))
  224.     list[++lptr] = accum;
  225.     accum = 0;
  226.     BEGIN endnum;
  227. }
  228.  
  229. <innum>{ANSI} {
  230.     unput(*yytext);
  231.     if (lptr < (MAXPROTOLEN - 1))
  232.     list[++lptr] = accum;
  233.     accum = 0;
  234.     BEGIN endnum;
  235. }
  236.  
  237. <endnum>[0-9] {
  238.     accum = 10 * accum + *yytext - '0';
  239.     BEGIN innum;
  240. }
  241.  
  242. <endnum>[\;ABCDHfJKLMPcghlmnr] {
  243.     if (doendnum(*yytext))
  244.     return 1;
  245. }
  246.  
  247. <ques>[0-9] {
  248.     accum = *yytext - '0';
  249.     BEGIN quesinnum;
  250. }
  251.  
  252. <ques>\; {
  253.     if (lptr < (MAXPROTOLEN - 1))
  254.     list[++lptr] = accum;
  255.     accum = 0;
  256.     BEGIN quesendnum;
  257. }
  258.  
  259. <quesinnum>[0-9] {
  260.     accum = 10 * accum + *yytext - '0';
  261. }
  262.  
  263. <quesinnum>\; {
  264.     if (lptr < (MAXPROTOLEN - 1))
  265.     list[++lptr] = accum;
  266.     accum = 0;
  267.     BEGIN quesendnum;
  268. }
  269.  
  270. <quesinnum>{ANSI} {
  271.     unput(*yytext);
  272.     if (lptr < (MAXPROTOLEN - 1))
  273.     list[++lptr] = accum;
  274.     accum = 0;
  275.     BEGIN quesendnum;
  276. }
  277.  
  278. <quesendnum>[0-9] {
  279.     accum = 10 * accum + *yytext - '0';
  280.     BEGIN quesinnum;
  281. }
  282.  
  283. <quesendnum>[\;hl] {
  284.     if (doquesendnum(*yytext))
  285.     return 1;
  286. }
  287.  
  288. <esc,sharp,lpr,rpr,csi,endnum,ques,quesendnum>{ANSI} {
  289.     BEGIN 0;
  290. }
  291.  
  292. %%
  293.  
  294. static BOOL NEAR doquesendnum(register BYTE c)
  295. {
  296.     switch(c) {
  297.     case ';':
  298.             if (lptr < (MAXPROTOLEN - 1))
  299.             list[++lptr] = accum;
  300.         accum = 0;
  301.         BEGIN quesendnum;
  302.         break;
  303.  
  304.     case 'h':
  305.         while ((pn = getnextelement(FALSE)) != NULL) {
  306.         switch(*pn) {
  307.             case 1:
  308.             MWnd.CurKeyMode = TRUE;
  309.             break;
  310.             case 3:
  311.             SetCols(132);
  312.             break;
  313.             case 4:
  314.             SendMessage(hWndText,SMT_SETATTRIBUTE,SM_SMOOTHSCROLL,(LONG)TRUE);
  315.             break;
  316.             case 5:
  317.                 if (!MWnd.Reverse) {
  318.                   MWnd.Reverse = TRUE;
  319.                 InvertScreen(TRUE);
  320.             }
  321.             break;
  322.             case 6:
  323.             SendMessage(hWndText, SMT_COMMAND, SM_ORIGINMODE, (LONG)TRUE);
  324.             break;
  325.             case 7:
  326.             SendMessage(hWndText, SMT_SETATTRIBUTE, SM_AUTOWRAP,(LONG)TRUE);
  327.             MWnd.Wrap = TRUE;
  328.             break;
  329.             case 25:
  330.                 if (!MWnd.Cursor) {
  331.                 MWnd.Cursor = TRUE;
  332.                 SendMessage(hWndText,SMT_CARETFUNCTION,SM_SHOWCARET,0L);
  333.             }
  334.                 break;
  335.         }
  336.         }
  337.         BEGIN 0;
  338.         break;
  339.  
  340.     case 'l':
  341.         while ((pn = getnextelement(FALSE)) != NULL) {
  342.         switch(*pn) {
  343.             case 1:
  344.             MWnd.CurKeyMode = FALSE;
  345.             break;
  346.             case 2:
  347.                 SendMessage(hWndText,SMT_COMMAND,SM_SETCHARSET,(LONG)0);
  348.                 SetAlphaParams(52);
  349.             if (input() != EOF)
  350.                 pushback();
  351.             return 1;
  352.             case 3:
  353.             SetCols(80);
  354.             break;
  355.             case 4:
  356.                 SendMessage(hWndText,SMT_SETATTRIBUTE,SM_SMOOTHSCROLL,(LONG)FALSE);
  357.                 break;
  358.             case 5:
  359.                 if (MWnd.Reverse) {
  360.                   InvertScreen(FALSE);
  361.                 MWnd.Reverse = FALSE;
  362.             }
  363.             break;
  364.             case 6:
  365.             SendMessage(hWndText,SMT_COMMAND, SM_ORIGINMODE, (LONG)FALSE);
  366.             break;
  367.             case 7:
  368.             SendMessage(hWndText, SMT_SETATTRIBUTE, SM_AUTOWRAP,(LONG)FALSE);
  369.             MWnd.Wrap = FALSE;
  370.             break;
  371.             case 25:
  372.                 if (MWnd.Cursor) {
  373.                     MWnd.Cursor = FALSE;
  374.                     SendMessage(hWndText,SMT_CARETFUNCTION,SM_HIDECARET,0L);
  375.                 }
  376.                 break;
  377.         }
  378.         }
  379.         BEGIN 0;
  380.         break;
  381.     }
  382.     return 0;
  383. }
  384.  
  385.  
  386. static int NEAR doendnum(register BYTE c)
  387. {
  388.     LONG lparam;
  389.  
  390.     switch (c) {
  391.     case ';':
  392.         if (lptr < (MAXPROTOLEN - 1))
  393.             list[++lptr] = accum;
  394.             accum = 0;
  395.         break;
  396.     case 'A':
  397.         SendMessage(hWndText, SMT_COMMAND, SM_CURSORUP,
  398.             (LONG)(list[0] ? list[0] : 1));
  399.         BEGIN 0;
  400.         break;
  401.     case 'B':
  402.         SendMessage(hWndText, SMT_COMMAND, SM_CURSORDOWN,
  403.             (LONG)(list[0] ? list[0] : 1));
  404.         BEGIN 0;
  405.         break;
  406.     case 'C':
  407.         SendMessage(hWndText, SMT_COMMAND, SM_CURSORRIGHT,
  408.             (LONG)(list[0] ? list[0] : 1));
  409.         BEGIN 0;
  410.         break;
  411.     case 'D':
  412.         SendMessage(hWndText, SMT_COMMAND, SM_CURSORLEFT,
  413.             (LONG)(list[0] ? list[0] : 1));
  414.         BEGIN 0;
  415.         break;
  416.  
  417.     case 'H':
  418.     case 'f':
  419.         SendMessage(hWndText, SMT_COMMAND, SM_POSITIONCURSOR,
  420.             MAKELONG((list[0] ? list[0] : 1),
  421.                 (list[1] ? list[1] : 1)));
  422.         BEGIN 0;
  423.         break;
  424.  
  425.     case 'J':
  426.         SendMessage(hWndText, SMT_COMMAND, 
  427.                 list[0] == 0 ? SM_CLRTOENDOFPAGE :
  428.             list[0] == 1 ? SM_CLEARTOTOPOFPAGE :
  429.             list[0] == 2 ? SM_CLEARSCREEN : 0, 0L);
  430.         BEGIN 0;
  431.         break;
  432.     case 'K':
  433.         SendMessage(hWndText, SMT_COMMAND, 
  434.                 list[0] == 0 ? SM_CLRTOENDOFLINE :
  435.             list[0] == 1 ? SM_CLEARTOLINESTART :
  436.             list[0] == 2 ? SM_CLEARLINE : 0, 0L);
  437.         BEGIN 0;
  438.         break;
  439.  
  440.     case 'L':
  441.         SendMessage(hWndText, SMT_COMMAND, SM_INSERTLINE,
  442.             (LONG)(list[0] ? list[0] : 1));
  443.         BEGIN 0;
  444.         break;
  445.  
  446.     case 'M':
  447.         SendMessage(hWndText, SMT_COMMAND, SM_DELETELINE,
  448.             (LONG)(list[0] ? list[0] : 1));
  449.         BEGIN 0;
  450.         break;
  451.  
  452.     case 'P':
  453.         SendMessage(hWndText, SMT_COMMAND, SM_DELETECHAR,
  454.             (LONG)(list[0] ? list[0] : 1));
  455.         BEGIN 0;
  456.         break;
  457.  
  458.     case 'c':
  459.         if (list[0] == 0)
  460.         IdentifyTerm(100);
  461.         BEGIN 0;
  462.         break;
  463.  
  464.     case 'g':
  465.         SendMessage(hWndText,SMT_COMMAND,SM_SETTAB,MAKELONG(0, list[0]));
  466.         BEGIN 0;
  467.         break;
  468.  
  469.     case 'h':
  470.         while ((pn = getnextelement(FALSE)) != NULL) {
  471.         switch(*pn) {
  472.                 case 3:
  473.                 SendMessage(hWndActive, SMT_SETATTRIBUTE, 
  474.                     SM_AUTOWRAP, (LONG)TRUE);
  475.             MWnd.ControlRep = TRUE;
  476.             if (input() != EOF)
  477.                 pushback();
  478.             vt100SetState(-1);
  479.             return 1;
  480.                 case 4:
  481.             SendMessage(hWndText,SMT_SETATTRIBUTE,SM_INSERT,(LONG)TRUE);
  482.             break;
  483.             case 12:
  484.                 LocalEcho = 0;
  485.                 if (LineState != LOCAL_ON)
  486.                     LineState = LINE_ON + LocalEcho;
  487.                 break;
  488.             case 20:
  489.                 MWnd.LFCR = TRUE;
  490.                 break;
  491.         }
  492.         }
  493.         BEGIN 0;
  494.         break;
  495.  
  496.     case 'l':
  497.         while ((pn = getnextelement(FALSE)) != NULL) {
  498.         switch(*pn) {
  499.             case 4:
  500.             SendMessage(hWndText,SMT_SETATTRIBUTE,SM_INSERT,(LONG)FALSE);
  501.             break;
  502.             case 12:
  503.             LocalEcho = TRUE;
  504.             if (LineState != LOCAL_ON)
  505.                 LineState = LINE_ON + LocalEcho;
  506.             break;
  507.             case 20:
  508.             MWnd.LFCR = FALSE;
  509.             break;
  510.         }
  511.         }
  512.         BEGIN 0;
  513.         break;
  514.  
  515.     case 'm':
  516.         while ((pn = getnextelement(FALSE)) != NULL)
  517.         SendMessage(hWndText, SMT_COMMAND, SM_VIDEOATTRIB, (LONG)*pn);
  518.         BEGIN 0;
  519.         break;
  520.  
  521.     case 'n':
  522.         switch(list[0]) {
  523.         case 5:
  524.             WriteToComm("\033[0n",4);
  525.             break;
  526.         case 6:
  527.             lparam = SendMessage(hWndText, SMT_CARETFUNCTION,
  528.                      SM_GETCARETPOS, 0L);
  529.             ReportCursorPos(LOWORD(lparam), HIWORD(lparam));
  530.             break;
  531.         }
  532.         BEGIN 0;
  533.         break;
  534.  
  535.     case 'r':
  536.         SendMessage(hWndText, SMT_COMMAND, SM_SCROLLREGION,
  537.             MAKELONG(list[0], list[1]));
  538.         BEGIN 0;
  539.         break;
  540.     }
  541.     return 0;
  542. }
  543.  
  544. static void NEAR docsi(BYTE c)
  545. {
  546.     switch(c) {
  547.     case ';':
  548.         if (lptr < (MAXPROTOLEN - 1))
  549.         list[++lptr] = accum;
  550.         accum = 0;
  551.         BEGIN endnum;
  552.         break;
  553.  
  554.     case '?':
  555.         BEGIN ques;
  556.         break;
  557.  
  558.     case 'A':
  559.         SendMessage(hWndText, SMT_COMMAND, SM_CURSORUP,1L);
  560.         BEGIN 0;
  561.         break;
  562.  
  563.     case 'B':
  564.         SendMessage(hWndText, SMT_COMMAND, SM_CURSORDOWN,1L);
  565.         BEGIN 0;
  566.         break;
  567.  
  568.     case 'C':
  569.         SendMessage(hWndText, SMT_COMMAND, SM_CURSORRIGHT,1L);
  570.         BEGIN 0;
  571.         break;
  572.  
  573.     case 'D':
  574.         SendMessage(hWndText, SMT_COMMAND, SM_CURSORLEFT,1L);
  575.         BEGIN 0;
  576.         break;
  577.  
  578.     case 'H':
  579.     case 'f':
  580.         SendMessage(hWndText, SMT_COMMAND, SM_CURSORHOME,0L);
  581.         BEGIN 0;
  582.         break;
  583.  
  584.     case 'J':
  585.         SendMessage(hWndText, SMT_COMMAND, SM_CLRTOENDOFPAGE,0L);
  586.         BEGIN 0;
  587.         break;
  588.  
  589.     case 'K':
  590.         SendMessage(hWndText, SMT_COMMAND, SM_CLRTOENDOFLINE, 0L);
  591.         BEGIN 0;
  592.         break;
  593.  
  594.     case 'L':
  595.         SendMessage(hWndText, SMT_COMMAND, SM_INSERTLINE, 1L);
  596.         BEGIN 0;
  597.         break;
  598.  
  599.     case 'M':
  600.         SendMessage(hWndText, SMT_COMMAND, SM_DELETELINE, 1L);
  601.         BEGIN 0;
  602.         break;
  603.  
  604.     case 'P':
  605.         SendMessage(hWndText, SMT_COMMAND, SM_DELETECHAR, 1L);
  606.         BEGIN 0;
  607.         break;
  608.  
  609.     case 'c':
  610.         IdentifyTerm(100);
  611.         BEGIN 0;
  612.         break;
  613.  
  614.     case 'g':
  615.         SendMessage(hWndText, SMT_COMMAND, SM_SETTAB,0L);
  616.         BEGIN 0;
  617.         break;
  618.  
  619.     case 'm':    
  620.         SendMessage(hWndText, SMT_COMMAND, SM_VIDEOATTRIB,0L);
  621.         BEGIN 0;
  622.         break;
  623.  
  624.     case 'r':
  625.         SendMessage(hWndText, SMT_COMMAND, SM_SCROLLREGION,0L);
  626.         BEGIN 0;
  627.         break;
  628.     }
  629. }
  630.  
  631. static void NEAR doscsr(BYTE c)
  632. {
  633.  
  634.     switch(c) {
  635.     case 'A':    // Select UK National into G1
  636.     case 'B':    // Select ASCII (default) into G1
  637.     case '1':    // Select Alternate ROM set into G1
  638.         MWnd.CharSet[1] = 0;
  639.         if (MWnd.ActiveCharSet == 1)
  640.         SendMessage(hWndText,SMT_COMMAND,
  641.             SM_SETCHARSET,(LONG)MWnd.CharSet[1]);
  642.         break;
  643.  
  644.     case '0':    // Select Dec special graphics into G1
  645.     case '2':    // Select Alternate char ROM special graphics into G0
  646.         MWnd.CharSet[1] = SYMBOL_CHARSET;
  647.         if (MWnd.ActiveCharSet == 1)
  648.         SendMessage(hWndText,SMT_COMMAND,
  649.             SM_SETCHARSET,(LONG)MWnd.CharSet[1]);
  650.         break;
  651.     case '<':    // Select Dec supplemental into G1
  652.         break;
  653.     }
  654.     BEGIN 0;
  655. }
  656.  
  657. static void NEAR doscsl(BYTE c)
  658. {
  659.  
  660.     switch(c) {
  661.     case 'A':    // Select UK National into G0
  662.     case 'B':    // Select ASCII (default) into G0
  663.     case '1':    // Select Alternate ROM set into G0
  664.         MWnd.CharSet[0] = 0;
  665.         if (MWnd.ActiveCharSet == 0)
  666.         SendMessage(hWndText,SMT_COMMAND,
  667.             SM_SETCHARSET,(LONG)MWnd.CharSet[0]);
  668.         break;
  669.  
  670.     case '0':    // Select Dec special graphics into G0
  671.     case '2':    // Select Alternate char ROM special graphics into G0
  672.         MWnd.CharSet[0] = SYMBOL_CHARSET;
  673.         if (MWnd.ActiveCharSet == 0)
  674.         SendMessage(hWndText,SMT_COMMAND,
  675.             SM_SETCHARSET,(LONG)MWnd.CharSet[0]);
  676.         break;
  677.  
  678.     case '<':
  679.         // Select Dec supplemental into G0        
  680.         break;
  681.  
  682.     }
  683.     BEGIN 0;
  684. }
  685.  
  686. static void NEAR dosharp(BYTE c)
  687. {
  688.  
  689.     switch(c) {
  690.     case '3':
  691.         // single high single width
  692.         break;
  693.     case '4':
  694.         // single high double width
  695.         break;
  696.     case '5':
  697.         // double high double width top line
  698.         break;
  699.     case '6':
  700.         // double high double width bottom line
  701.         break;
  702.     case '7':
  703.         SendMessage(hWndText, SMT_COMMAND, SM_FILLSCREEN, 0L);
  704.         break;
  705.     case '8':
  706.         SendMessage(hWndText, SMT_COMMAND, SM_ALIGNSCREEN, 0L);
  707.         break;
  708.     }
  709.     BEGIN 0;
  710. }
  711.  
  712. static void NEAR doesc(BYTE c)
  713. {
  714.     switch(c) {
  715.     case '#':
  716.         BEGIN sharp;
  717.         break;
  718.     case '(':
  719.         BEGIN lpr;
  720.         break;
  721.     case ')':
  722.         BEGIN rpr;
  723.         break;
  724.     case '7':
  725.         SendMessage(hWndText, SMT_COMMAND, SM_SAVECURSOR, (LONG)TRUE);
  726.         BEGIN 0;
  727.         break;
  728.     case '8':
  729.         SendMessage(hWndText, SMT_COMMAND, SM_SAVECURSOR, (LONG)FALSE);
  730.         BEGIN 0;
  731.         break;
  732.     case '=':
  733.         MWnd.ApplMode = TRUE;
  734.         BEGIN 0;
  735.         break;
  736.     case '>':
  737.         MWnd.ApplMode = FALSE;
  738.         BEGIN 0;
  739.         break;
  740.     case 'D':
  741.         SendMessage(hWndText, SMT_COMMAND, SM_INDEX, 1L);
  742.         BEGIN 0;
  743.         break;
  744.     case 'E':
  745.         SendMessage(hWndText, SMT_COMMAND, SM_NEXTLINE, 1L);
  746.         BEGIN 0;
  747.         break;
  748.     case 'H':
  749.         SendMessage(hWndText, SMT_COMMAND, SM_SETTAB, 1L);
  750.         BEGIN 0;
  751.         break;
  752.     case 'M':
  753.         SendMessage(hWndText, SMT_COMMAND, SM_REVERSEINDEX, 1L);
  754.         BEGIN 0;
  755.         break;
  756.     case 'Z':
  757.         IdentifyTerm(100);
  758.         BEGIN 0;
  759.         break;
  760.     case '[':
  761.         memset((char *)list, 0, 2 * MAXPROTOLEN);
  762.         lptr = hptr = -1;
  763.         accum = 0;
  764.         BEGIN csi;
  765.         break;
  766.     case 'c':
  767.         // Hard reset
  768.         BEGIN 0;
  769.         break;
  770.     }
  771. }
  772.  
  773. void FAR vt100SetState(int state)
  774. {
  775.     int temp = yy_start;
  776.  
  777.  
  778.     if (state < 0)
  779.     BEGIN crep;
  780.     else
  781.         BEGIN state;
  782. }
  783.  
  784. static int * NEAR getnextelement(BOOL corr)
  785. {
  786.  
  787.     if (hptr++ < lptr) {
  788.     if (corr)
  789.         if (list[hptr] == 0)
  790.         list[hptr] = 1;
  791.     return(&list[hptr]);
  792.     }
  793.     else
  794.     return(NULL);
  795. }
  796.  
  797. static int NEAR mygetc()
  798. {
  799.  
  800.     if (pBuf->len > 0) {
  801.     pBuf->len--;
  802.     return (*pBuf->ptr++) & curproto.mask;
  803.     }    
  804.     else
  805.     return EOF;
  806.     
  807. }
  808.  
  809. void FAR ANSISpecialKeys(int item)
  810. {
  811.  
  812.     int index;
  813.  
  814.     static char *ANSIKeys[] = {
  815.         "\033OA","\033[A",
  816.         "\033OB","\033[B",
  817.         "\033OC","\033[C",
  818.         "\033OD","\033[D",
  819.         "\033OH","\033[H",            // 9
  820.     "\033OP","\033OQ","\033OR","\033OS",    // 13
  821.     "\033Op","0",
  822.     "\033Oq","1",
  823.     "\033Or","2",
  824.     "\033Os","3",
  825.     "\033Ot","4",
  826.     "\033Ou","5",
  827.     "\033Ov","6",
  828.     "\033Ow","7",
  829.     "\033Ox","8",
  830.     "\033Oy","9",                // 33
  831.     "\033Ol","+",    // 35
  832.     "\033Om","-",   // 37
  833.     "\033On",".",   // 39
  834.     "\033OM","*",   // 41
  835.     };
  836.  
  837.     switch(item) {
  838.     case IDM_UP:
  839.     case IDM_S_UP:
  840.     case IDM_C_UP:
  841.     case IDM_CS_UP:
  842.         index = (MWnd.CurKeyMode ? 0 : 1);
  843.         break;
  844.  
  845.     case IDM_DOWN:
  846.     case IDM_S_DOWN:
  847.     case IDM_C_DOWN:
  848.     case IDM_CS_DOWN:
  849.         index = (MWnd.CurKeyMode ? 2 : 3);
  850.         break;
  851.  
  852.     case IDM_RIGHT:
  853.     case IDM_S_RIGHT:
  854.     case IDM_C_RIGHT:
  855.     case IDM_CS_RIGHT:
  856.         index = (MWnd.CurKeyMode ? 4 : 5);
  857.         break;
  858.  
  859.     case IDM_LEFT:
  860.     case IDM_S_LEFT:
  861.     case IDM_C_LEFT:
  862.     case IDM_CS_LEFT:
  863.         index = (MWnd.CurKeyMode ? 6 : 7);
  864.         break;
  865.  
  866.     case IDM_HOME:
  867.     case IDM_S_HOME:
  868.     case IDM_C_HOME:
  869.     case IDM_CS_HOME:
  870.         index = (MWnd.CurKeyMode ? 8 : 9);
  871.         break;
  872.  
  873.     case IDM_F1:
  874.         index = 10;
  875.         break;
  876.  
  877.     case IDM_F2:
  878.         index = 11;
  879.         break;
  880.  
  881.     case IDM_F3:
  882.         index = 12;
  883.         break;
  884.  
  885.     case IDM_F4:
  886.         index = 13;
  887.         break;
  888.  
  889.     case IDM_NUM0:
  890. //    case IDM_S_NUM0:
  891.     case IDM_C_NUM0:
  892. //    case IDM_CS_NUM0:
  893.         index = (MWnd.ApplMode ? 14 : 15);
  894.         break;
  895.  
  896.     case IDM_NUM1:
  897. //    case IDM_S_NUM1:
  898.     case IDM_C_NUM1:
  899. //    case IDM_CS_NUM1:
  900.         index = (MWnd.ApplMode ? 16 : 17);
  901.         break;
  902.  
  903.     case IDM_NUM2:
  904. //    case IDM_S_NUM2:
  905.     case IDM_C_NUM2:
  906. //    case IDM_CS_NUM2:
  907.         index = (MWnd.ApplMode ? 18 : 19);
  908.         break;
  909.  
  910.     case IDM_NUM3:
  911. //    case IDM_S_NUM3:
  912.     case IDM_C_NUM3:
  913. //    case IDM_CS_NUM3:
  914.         index = (MWnd.ApplMode ? 20 : 21);
  915.         break;
  916.  
  917.     case IDM_NUM4:
  918. //    case IDM_S_NUM4:
  919.     case IDM_C_NUM4:
  920. //    case IDM_CS_NUM4:
  921.         index = (MWnd.ApplMode ? 22 : 23);
  922.         break;
  923.  
  924.     case IDM_NUM5:
  925. //    case IDM_S_NUM5:
  926.     case IDM_C_NUM5:
  927. //    case IDM_CS_NUM5:
  928.         index = (MWnd.ApplMode ? 24 : 25);
  929.         break;
  930.  
  931.     case IDM_NUM6:
  932. //    case IDM_S_NUM6:
  933.     case IDM_C_NUM6:
  934. //    case IDM_CS_NUM6:
  935.         index = (MWnd.ApplMode ? 26 : 27);
  936.         break;
  937.  
  938.     case IDM_NUM7:
  939. //    case IDM_S_NUM7:
  940.     case IDM_C_NUM7:
  941. //    case IDM_CS_NUM7:
  942.         index = (MWnd.ApplMode ? 28 : 29);
  943.         break;
  944.  
  945.     case IDM_NUM8:
  946. //    case IDM_S_NUM8:
  947.     case IDM_C_NUM8:
  948. //    case IDM_CS_NUM8:
  949.         index = (MWnd.ApplMode ? 30 : 31);
  950.         break;
  951.  
  952.     case IDM_NUM9:
  953. //    case IDM_S_NUM9:
  954.     case IDM_C_NUM9:
  955. //    case IDM_CS_NUM9:
  956.         index = (MWnd.ApplMode ? 32 : 33);
  957.         break;
  958.  
  959.     case IDM_ADD:
  960. //    case IDM_S_ADD:
  961.     case IDM_C_ADD:
  962. //    case IDM_CS_ADD:
  963.         index = 
  964.         (MWnd.ApplMode && (GetKeyState(VK_NUMLOCK) & 1) ? 34 : 35);
  965.         break;
  966.  
  967.     case IDM_SUBTRACT:
  968. //    case IDM_S_SUBTRACT:
  969.     case IDM_C_SUBTRACT:
  970. //    case IDM_CS_SUBTRACT:
  971.         index = 
  972.         (MWnd.ApplMode && (GetKeyState(VK_NUMLOCK) & 1) ? 36 : 37);
  973.         break;
  974.  
  975.     case IDM_DECIMAL:
  976. //    case IDM_S_DECIMAL:
  977.     case IDM_C_DECIMAL:
  978. //    case IDM_CS_DECIMAL:
  979.         index = (MWnd.ApplMode ? 38 : 39);
  980.         break;
  981.  
  982.     case IDM_MULTIPLY:
  983. //    case IDM_S_MULTIPLY:
  984.     case IDM_C_MULTIPLY:
  985. //    case IDM_CS_MULTIPLY:
  986.         index = 
  987.         (MWnd.ApplMode && (GetKeyState(VK_NUMLOCK) & 1) ? 40 : 41);
  988.         break;
  989.  
  990.     default:
  991.         return;
  992.     }
  993.     WriteToComm(ANSIKeys[index], strlen(ANSIKeys[index]));
  994. }
  995.