home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 300-399 / ff369.lzh / VaxTerm / src / inter.c < prev    next >
C/C++ Source or Header  |  1990-08-15  |  28KB  |  702 lines
  1. #include <exec/types.h>
  2. #include <exec/io.h>
  3. #include <devices/keymap.h>
  4. #include <hardware/blit.h>
  5. #include <graphics/rastport.h>
  6. #include <graphics/text.h>
  7. #include <libraries/dos.h>
  8. #include <proto/graphics.h>
  9.  
  10. #include "main.h"
  11.  
  12. char    posreq[]    = "\x9B%d;%dR";
  13. char    primda[]    = "\x9B?62;9c";
  14. char    secda[]     = "\x9B>1;10;0c";
  15. char    tstat[]     = "\x9B""0n";
  16. char    pstat[]     = "\x9B?13n";
  17. char    ustat[]     = "\x9B?21n";
  18. char    klang[]     = "\x9B?27;6n";
  19.  
  20. interpret(register struct console *con,register LONG len)
  21. {
  22. register SHORT  cnt,lim;
  23. register char   *scp;
  24. char            c,com[16];
  25.  
  26. scp = con->buf;
  27. while (len--) {
  28.     c = *scp++;
  29.     if (con->stat) {
  30.         cnt = con->stat;
  31.         con->stat = 0;
  32.         switch (cnt) {
  33.             case SEQ_ESC:
  34.                 switch (c) {
  35.                     case '[':
  36.                         con->stat = SEQ_CSI;
  37.                         con->argi = 0;
  38.                         con->carg = 0;
  39.                         break;
  40.                     case '#':
  41.                         con->stat = SEQ_LWIDTH;
  42.                         break;
  43.                     case 'P':
  44.                         con->stat = SEQ_DCS;
  45.                         break;
  46.                     case ' ':
  47.                         con->stat = SEQ_SPC;
  48.                         break;
  49.                     case '(':
  50.                         con->stat = SEQ_G0;
  51.                         break;
  52.                     case ')':
  53.                         con->stat = SEQ_G1;
  54.                         break;
  55.                     case '*':
  56.                         con->stat = SEQ_G2;
  57.                         break;
  58.                     case '+':
  59.                         con->stat = SEQ_G3;
  60.                         break;
  61.                     case '~':
  62.                         setrset(con,1);
  63.                         break;
  64.                     case 'n':
  65.                         setlset(con,2);
  66.                         break;
  67.                     case '}':
  68.                         setrset(con,2);
  69.                         break;
  70.                     case 'o':
  71.                         setlset(con,3);
  72.                         break;
  73.                     case '|':
  74.                         setrset(con,3);
  75.                         break;
  76.                     case 'N':
  77.                         con->slset = con->lset;
  78.                         con->tstat |= GXGL;
  79.                         setlset(con,2);
  80.                         break;
  81.                     case 'O':
  82.                         con->slset = con->lset;
  83.                         con->tstat |= GXGL;
  84.                         setlset(con,3);
  85.                         break;
  86.                     case '<':
  87.                     case '=':
  88.                         keypadmode(TRUE);
  89.                         activate(&appl);
  90.                         break;
  91.                     case '>':
  92.                         keypadmode(FALSE);
  93.                         activate(&num);
  94.                         break;
  95.                     case 'D':
  96.                         cursordown(con,1);
  97.                         break;
  98.                     case 'M':
  99.                         cursorup(con,1);
  100.                         break;
  101.                     case 'E':
  102.                         cursornextline(con);
  103.                         break;
  104.                     case '7':
  105.                         con->s_row = con->row;
  106.                         con->s_col = con->col;
  107.                         con->s_attr = con->attr;
  108.                         for (cnt = 0; cnt < SETS; cnt++) {
  109.                             con->s_gset[cnt] = con->gset[cnt];
  110.                             con->s_mset[cnt] = con->mset[cnt];
  111.                             }
  112.                         con->s_lset = con->lset;
  113.                         con->s_rset = con->rset;
  114.                         con->s_tstat = con->tstat;
  115.                         break;
  116.                     case '8':
  117.                         if (con->ordc) textout(con);
  118.                         con->row = con->s_row;
  119.                         con->col = con->s_col;
  120.                         con->attr = con->s_attr;
  121.                         for (cnt = 0; cnt < SETS; cnt++) {
  122.                             con->gset[cnt] = con->s_gset[cnt];
  123.                             con->mset[cnt] = con->s_mset[cnt];
  124.                             }
  125.                         setlset(con,con->s_lset);
  126.                         setrset(con,con->s_rset);
  127.                         con->tstat = con->s_tstat &
  128.                             (WRAP | INSERT | NEWLINE | CONVERT | CURSOR);
  129.                         if (con->tstat & WRAP) activate(&wrap);
  130.                         else activate(&trunc);
  131.                         if (con->tstat & INSERT) activate(&ins);
  132.                         else activate(&over);
  133.                         if (con->tstat & NEWLINE) {
  134.                             entermode(TRUE);
  135.                             activate(&newl);
  136.                             }
  137.                         else {
  138.                             entermode(FALSE);
  139.                             activate(&cret);
  140.                             }
  141.                         if (con->tstat & CONVERT) activate(&bit_7);
  142.                         else activate(&bit_8);
  143.                         modifyattr(con);
  144.                         break;
  145.                     case 'H':
  146.                         con->tabs[con->col] = 1;
  147.                         break;
  148.                     case 'c':
  149.                         reset(con);
  150.                         break;
  151.                     case 'Z':
  152.                         sendstring(con,primda);
  153.                         break;
  154.                     default: ;
  155.                     }
  156.                 break;
  157.             case SEQ_CSI:
  158.                 if (isdigit(c)) {
  159.                     con->carg = con->carg * 10;
  160.                     con->carg += (USHORT)(c - '0');
  161.                     con->stat = SEQ_CSI;
  162.                     }
  163.                 else {
  164.                     switch (c) {
  165.                         case ';':
  166.                             con->args[con->argi] = con->carg;
  167.                             con->carg = 0;
  168.                             con->argi++;
  169.                             if (con->argi > ARGUMENTS)
  170.                                 con->argi = ARGUMENTS;
  171.                             con->stat = SEQ_CSI;
  172.                             break;
  173.                         case '?':
  174.                             con->stat = SEQ_MOD;
  175.                             break;
  176.                         case '>':
  177.                             con->stat = SEQ_SEC;
  178.                             break;
  179.                         case '!':
  180.                             con->stat = SEQ_RES;
  181.                             break;
  182.                         case '"':
  183.                             con->stat = SEQ_SET;
  184.                             break;
  185.                         case '\x27':
  186.                         case '^':
  187.                             con->stat = SEQ_ONE;
  188.                             break;
  189.                         case 'h':
  190.                             switch (con->carg) {
  191.                                 case 2:
  192.                                     con->gstat |= LOCKED;
  193.                                     break;
  194.                                 case 4:
  195.                                     if (con->ordc) textout(con);
  196.                                     con->tstat |= INSERT;
  197.                                     activate(&ins);
  198.                                     break;
  199.                                 case 20:
  200.                                     entermode(TRUE);
  201.                                     con->tstat |= NEWLINE;
  202.                                     activate(&newl);
  203.                                     break;
  204.                                 default: ;
  205.                                 }
  206.                             break;
  207.                         case 'l':
  208.                             switch (con->carg) {
  209.                                 case 2:
  210.                                     con->gstat &= (MASK - LOCKED);
  211.                                     break;
  212.                                 case 4:
  213.                                     if (con->ordc) textout(con);
  214.                                     con->tstat &= (MASK - INSERT);
  215.                                     activate(&over);
  216.                                     break;
  217.                                 case 20:
  218.                                     entermode(FALSE);
  219.                                     con->tstat &= (MASK - NEWLINE);
  220.                                     activate(&cret);
  221.                                     break;
  222.                                 default: ;
  223.                                 }
  224.                             break;
  225.                         case 'A':
  226.                             cnt = con->carg;
  227.                             if (cnt == 0) cnt = 1;
  228.                             cursorup(con,cnt);
  229.                             break;
  230.                         case 'B':
  231.                             cnt = con->carg;
  232.                             if (cnt == 0) cnt = 1;
  233.                             cursordown(con,cnt);
  234.                             break;
  235.                         case 'C':
  236.                             cnt = con->carg;
  237.                             if (cnt == 0) cnt = 1;
  238.                             cursorright(con,cnt);
  239.                             break;
  240.                         case 'D':
  241.                             cnt = con->carg;
  242.                             if (cnt == 0) cnt = 1;
  243.                             cursorleft(con,cnt);
  244.                             break;
  245.                         case 'f':
  246.                         case 'H':
  247.                             if (con->ordc) textout(con);
  248.                             if (con->argi) con->row = con->args[0];
  249.                             else con->row = con->carg;
  250.                             if (con->row == 0) con->row = 1;
  251.                             if (con->row > rows) con->row = rows;
  252.                             if ((con->argi)&&(con->carg)) {
  253.                                 con->col = con->carg;
  254.                                 if (con->col > COLUMNS) con->col = COLUMNS;
  255.                                 }
  256.                             else con->col = 1;
  257.                             break;
  258.                         case 'g':
  259.                             if (con->carg == 0) con->tabs[con->col] = 0;
  260.                             if (con->carg == 3) setmem(con->tabs,COLUMNS,0);
  261.                             break;
  262.                         case 'm':
  263.                             if (con->ordc) textout(con);
  264.                             con->args[con->argi] = con->carg;
  265.                             con->argi++;
  266.                             for (cnt = 0; cnt < con->argi; cnt++) {
  267.                                 switch(con->args[cnt]) {
  268.                                     case 0:  con->attr= 0;
  269.                                              break;
  270.                                     case 1:  con->attr|=FSF_BOLD;
  271.                                              break;
  272.                                     case 3:  con->attr|=FSF_ITALIC;
  273.                                              break;
  274.                                     case 4:  con->attr|=FSF_UNDERLINED;
  275.                                              break;
  276.                                     case 7:  con->attr|=NEGATIVE;
  277.                                              break;
  278.                                     case 22: con->attr&=(MASK-FSF_BOLD);
  279.                                              break;
  280.                                     case 23: con->attr&=(MASK-FSF_ITALIC);
  281.                                              break;
  282.                                     case 24: con->attr&=(MASK-FSF_UNDERLINED);
  283.                                              break;
  284.                                     case 27: con->attr&=(MASK-NEGATIVE);
  285.                                              break;
  286.                                     default:    ;
  287.                                     }
  288.                                 }
  289.                             modifyattr(con);
  290.                             break;
  291.                         case 'L':
  292.                             cnt = con->carg;
  293.                             if (cnt == 0) cnt = 1;
  294.                             insertlines(con,cnt);
  295.                             break;
  296.                         case 'M':
  297.                             cnt = con->carg;
  298.                             if (cnt == 0) cnt = 1;
  299.                             deletelines(con,cnt);
  300.                             break;
  301.                         case '@':
  302.                             cnt = con->carg;
  303.                             if (cnt == 0) cnt = 1;
  304.                             insertchars(con,cnt);
  305.                             break;
  306.                         case 'P':
  307.                             cnt = con->carg;
  308.                             if (cnt == 0) cnt = 1;
  309.                             deletechars(con,cnt);
  310.                             break;
  311.                         case 'X':
  312.                             cnt = con->carg;
  313.                             if (cnt == 0) cnt = 1;
  314.                             erasechars(con,cnt);
  315.                             break;
  316.                         case 'K':
  317.                             switch (con->carg) {
  318.                                 case 0:
  319.                                     erasechars(con,
  320.                                         (USHORT)((COLUMNS + 1) - con->col));
  321.                                     break;
  322.                                 case 1:
  323.                                     eraselinebeg(con);
  324.                                     break;
  325.                                 case 2:
  326.                                     eraselinebeg(con);
  327.                                     erasechars(con,
  328.                                         (USHORT)((COLUMNS + 1) - con->col));
  329.                                     break;
  330.                                 default:    ;
  331.                                 }
  332.                             break;
  333.                         case 'J':
  334.                             switch (con->carg) {
  335.                                 case 0:
  336.                                     if (con->row < rows) {
  337.                                         if (con->ordc) textout(con);
  338.                                         con->row++;
  339.                                         eraselines(con,
  340.                                             (USHORT)(rows - con->row));
  341.                                         con->row--;
  342.                                         }
  343.                                     erasechars(con,
  344.                                         (USHORT)((COLUMNS + 1) - con->col));
  345.                                     break;
  346.                                 case 1:
  347.                                     erasescrbeg(con);
  348.                                     eraselinebeg(con);
  349.                                     break;
  350.                                 case 2:
  351.                                     SetRast(con->rp,BACKGROUND_PEN);
  352.                                     for (cnt = 0; cnt < rows; cnt++)
  353.                                         *(con->rows + cnt + 1) = 0;
  354.                                     break;
  355.                                 default:    ;
  356.                                 }
  357.                             break;
  358.                         case 'r':
  359.                             if (con->ordc) textout(con);
  360.                             if ((con->argi)&&(con->carg))
  361.                                 con->bot = con->carg;
  362.                             else con->bot = rows;
  363.                             if (con->argi) con->top = con->args[0];
  364.                             else con->top = con->carg;
  365.                             if (con->top == 0) con->top = 1;
  366.                             con->row = 1;
  367.                             con->col = 1;
  368.                             break;
  369.                         case 'c':
  370.                             if (con->carg == 0) sendstring(con,primda);
  371.                             break;
  372.                         case 'n':
  373.                             switch (con->carg) {
  374.                                 case 5: sendstring(con,tstat);
  375.                                         break;
  376.                                 case 6: sprintf(com,posreq,con->row,con->col);
  377.                                         sendstring(con,com);
  378.                                         break;
  379.                                 default:    ;
  380.                                 }
  381.                             break;
  382.                         default:    ;
  383.                         }
  384.                     }
  385.                 break;
  386.             case SEQ_MOD:
  387.                 if (isdigit(c)) {
  388.                     con->carg = con->carg * 10;
  389.                     con->carg += (USHORT)(c - '0');
  390.                     con->stat = SEQ_MOD;
  391.                     }
  392.                 else {
  393.                     switch (c) {
  394.                         case ';':
  395.                             con->args[con->argi] = con->carg;
  396.                             con->carg = 0;
  397.                             con->argi++;
  398.                             if (con->argi > ARGUMENTS)
  399.                                 con->argi = ARGUMENTS;
  400.                             con->stat = SEQ_MOD;
  401.                             break;
  402.                         case 'h':
  403.                             switch (con->carg) {
  404.                                 case 1:
  405.                                     cursormode(FALSE);
  406.                                     break;
  407.                                 case 7:
  408.                                     con->tstat |= WRAP;
  409.                                     activate(&wrap);
  410.                                     break;
  411.                                 case 25:
  412.                                     showcursor(con);
  413.                                     activate(&curson);
  414.                                     break;
  415.                                 case 42:
  416.                                     con->nstat |= NATIONAL;
  417.                                     setlset(con,con->lset);
  418.                                     setrset(con,con->rset);
  419.                                     activate(&nat);
  420.                                     modifyattr(con);
  421.                                     break;
  422.                                 default: ;
  423.                                 }
  424.                             break;
  425.                         case 'l':
  426.                             switch (con->carg) {
  427.                                 case 1:
  428.                                     cursormode(TRUE);
  429.                                     break;
  430.                                 case 7:
  431.                                     con->tstat &= (MASK - WRAP);
  432.                                     activate(&trunc);
  433.                                     break;
  434.                                 case 25:
  435.                                     hidecursor(con);
  436.                                     activate(&cursoff);
  437.                                     break;
  438.                                 case 42:
  439.                                     con->nstat &= (MASK - NATIONAL);
  440.                                     setlset(con,con->lset);
  441.                                     setrset(con,con->rset);
  442.                                     activate(&mult);
  443.                                     modifyattr(con);
  444.                                     break;
  445.                                 default: ;
  446.                                 }
  447.                             break;
  448.                         case 'n':
  449.                             switch (con->carg) {
  450.                                 case 15:    sendstring(con,pstat);
  451.                                             break;
  452.                                 case 25:    sendstring(con,ustat);
  453.                                             break;
  454.                                 case 26:    sendstring(con,klang);
  455.                                             break;
  456.                                 default: ;
  457.                                 }
  458.                             break;
  459.                         }
  460.                     }
  461.                 break;
  462.             case SEQ_LWIDTH:
  463.                 if (*(con->rows + con->row)) break;
  464.                 switch (c) {
  465.                     case '3':   *(con->rows + con->row) = UPPER_SIDE;
  466.                                 break;
  467.                     case '4':   *(con->rows + con->row) = LOWER_SIDE;
  468.                                 break;
  469.                     case '6':   *(con->rows + con->row) = HORIZ_ONLY;
  470.                                 break;
  471.                     default:    ;
  472.                     }
  473.                 if (*(con->rows + con->row)) {
  474.                     if (con->ordc) textout(con);
  475.                     stretch(con->rp,0,(con->row - 1) * YSIZE,
  476.                             WIDTH / 2,YSIZE,*(con->rows + con->row));
  477.                     }
  478.                 break;
  479.             case SEQ_SET:
  480.                 if (c == 'p') {
  481.                     if (con->args[0] == 62) {
  482.                         if (con->argi == 0) {
  483.                             con->tstat &= (MASK - CONVERT);
  484.                             activate(&bit_8);
  485.                             }
  486.                         else {
  487.                             if (con->args[1] == 1) {
  488.                                 con->tstat |= CONVERT;
  489.                                 activate(&bit_7);
  490.                                 }
  491.                             else {
  492.                                 con->tstat &= (MASK - CONVERT);
  493.                                 activate(&bit_8);
  494.                                 }
  495.                             }
  496.                         }
  497.                     else if (con->args[0] == 61) {
  498.                         con->tstat |= CONVERT;
  499.                         activate(&bit_7);
  500.                         }
  501.                     }
  502.                 break;
  503.             case SEQ_DCS:
  504.                 if (c != ST) con->stat = SEQ_DCS;
  505.                 else if (c == ESC) con->stat = SEQ_ENDDCS;
  506.                 break;
  507.             case SEQ_SPC:
  508.                 if (c == 'F') {
  509.                     con->tstat |= CONVERT;
  510.                     activate(&bit_7);
  511.                     }
  512.                 else if (c == 'G') {
  513.                     con->tstat &= (MASK - CONVERT);
  514.                     activate(&bit_8);
  515.                     }
  516.                 break;
  517.             case SEQ_SEC:
  518.                 if (isdigit(c)) con->stat = SEQ_SEC;
  519.                 else if (c == 'c') sendstring(con,secda);
  520.                 break;
  521.             case SEQ_RES:
  522.                 if (c == 'p') reset(con);
  523.                 break;
  524.             case SEQ_G0:
  525.                 setset(con,cset(c),0);
  526.                 break;
  527.             case SEQ_G1:
  528.                 setset(con,cset(c),1);
  529.                 break;
  530.             case SEQ_G2:
  531.                 setset(con,cset(c),2);
  532.                 break;
  533.             case SEQ_G3:
  534.                 setset(con,cset(c),3);
  535.                 break;
  536.             case SEQ_ENDDCS:
  537.                 if (c != '/') con->stat = SEQ_DCS;
  538.                 break;
  539.             default: ;
  540.             }
  541.         }
  542.     else {
  543.         cnt = 0;
  544.         if (c & '\x80') {
  545.             cnt = 4;
  546.             if (con->tstat & DCONTHI) {
  547.                 if (con->ordc) textout(con);
  548.                 cnt |= 2;
  549.                 }
  550.             if ((c >= '\xA0')&&(c < '\xFF')) {
  551.                 cnt |= 1;
  552.                 if (con->nstat & NATIONAL) c &= '\x7F';
  553.                 }
  554.             }
  555.         else {
  556.             if (con->tstat & DCONTLO) {
  557.                 if (con->ordc) textout(con);
  558.                 cnt = 2;
  559.                 }
  560.             if ((c >= ' ')&&(c < '\x7F')) cnt |= 1;
  561.             }
  562.         if (cnt & 3) {
  563.             if (*(con->rows + con->row)) lim = COLUMNS / 2;
  564.             else lim = COLUMNS;
  565.             if (con->col > lim) {
  566.                 if (con->ordc) textout(con);
  567.                 if (con->tstat & WRAP) cursornextline(con);
  568.                 else con->col = lim;
  569.                 }
  570.             if (con->ordc == 0) con->ordcol = con->col;
  571.             con->ordtext[con->ordc] = c;
  572.             con->ordc++;
  573.             if (!(cnt & 2)) con->col++;
  574.             if (con->tstat & GXGL) {
  575.                 setlset(con,con->slset);
  576.                 con->tstat &= (MASK - GXGL);
  577.                 }
  578.             }
  579.         if (!(cnt & 1)) {
  580.             if (con->ordc) textout(con);
  581.             if (cnt & 4) {
  582.                 switch (c) {
  583.                     case CSI:
  584.                         con->stat = SEQ_CSI;
  585.                         con->argi = 0;
  586.                         con->carg = 0;
  587.                         break;
  588.                     case IND:
  589.                         cursordown(con,1);
  590.                         break;
  591.                     case NEL:
  592.                         cursornextline(con);
  593.                         break;
  594.                     case HTS:
  595.                         con->tabs[con->col] = 1;
  596.                         break;
  597.                     case RI:
  598.                         cursorup(con,1);
  599.                         break;
  600.                     case SS2:
  601.                         con->slset = con->lset;
  602.                         con->tstat |= GXGL;
  603.                         setlset(con,2);
  604.                         break;
  605.                     case SS3:
  606.                         con->slset = con->lset;
  607.                         con->tstat |= GXGL;
  608.                         setlset(con,3);
  609.                         break;
  610.                     case DCS:
  611.                         con->stat = SEQ_DCS;
  612.                         break;
  613.                     default: ;
  614.                     }
  615.                 }
  616.             else {
  617.                 switch (c) {
  618.                     case ESC:
  619.                         con->stat = SEQ_ESC;
  620.                         break;
  621.                     case BEL:
  622.                         beep(con);
  623.                         DisplayBeep(NULL);
  624.                         break;
  625.                     case BS:
  626.                         if (con->col > 1) con->col--;
  627.                         break;
  628.                     case HT:
  629.                         while (con->col < COLUMNS) {
  630.                             con->col++;
  631.                             if (con->tabs[con->col]) break;
  632.                             }
  633.                         break;
  634.                     case VT:
  635.                     case FF:
  636.                     case LF:
  637.                         if (con->tstat & NEWLINE) newline(con);
  638.                         else cursordown(con,1);
  639.                         break;
  640.                     case CR:
  641.                         con->col = 1;
  642.                         break;
  643.                     case SI:
  644.                         setlset(con,0);
  645.                         break;
  646.                     case SO:
  647.                         setlset(con,1);
  648.                         break;
  649.                     default: ;
  650.                     }
  651.                 }
  652.             }
  653.         }
  654.     }
  655. return(0);
  656. }
  657.  
  658. setset(struct console *con,USHORT set,USHORT seq)
  659. {
  660. con->mset[seq] = set;
  661. switch(set) {
  662.     case BRITISH:
  663.         activate(&br_set);
  664.         break;
  665.     case DUTCH:
  666.         activate(&du_set);
  667.         break;
  668.     case FINNISH:
  669.         activate(&fi_set);
  670.         break;
  671.     case FRENCH:
  672.         activate(&fr_set);
  673.         break;
  674.     case FRENCH_CANADIAN:
  675.         activate(&fc_set);
  676.         break;
  677.     case GERMAN:
  678.         activate(&ger_set);
  679.         break;
  680.     case ITALIAN:
  681.         activate(&ita_set);
  682.         break;
  683.     case NORWEGIAN:
  684.         activate(&nor_set);
  685.         break;
  686.     case SPANISH:
  687.         activate(&spa_set);
  688.         break;
  689.     case SWEDISH:
  690.         activate(&swe_set);
  691.         break;
  692.     case SWISS:
  693.         activate(&swi_set);
  694.         break;
  695.     default:
  696.     con->gset[seq] = set;
  697.     }
  698. if (con->lset == seq) setlset(con,seq);
  699. if (con->rset == seq) setrset(con,seq);
  700. return(0);
  701. }
  702.