home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 5 / FREESOFT.BIN / wink2 / src / consim.c < prev    next >
Text File  |  1992-08-19  |  11KB  |  502 lines
  1. #include    <stdlib.h>
  2. #include    <ctype.h>
  3. #include    "defs.h"
  4.  
  5. #define DMYKAN  0xFE
  6. #define CRCHR   0x1F
  7. #define TABCHR  0x09
  8.  
  9. extern void colset(UCHAR *vp,int cl,int cnt);
  10. extern void PutChr();
  11. extern void memcpy();
  12. extern void memset();
  13. extern void Dsp_vram();
  14.  
  15.        UCHAR   *cvram=NULL;
  16.        int     MAX_SCR=MAX_Y;
  17.        int     TrmCol=7;
  18.        int     DspCnt=0;
  19. static int     KanMod=TRUE;
  20. static int     BakCh1=0,KanCod=0;
  21. static int     ExtFlg=FALSE;
  22. static void    (*ExtAdr)();
  23. static int     EscCnt=0,Bak_X=0,Bak_Y=0;
  24. static char    EscPrm[8];
  25.  
  26. void    Col_cnv()
  27. {
  28.     int   c;
  29.  
  30.     c = TrmCol & 0x07;
  31.     if ( (TrmCol & 0x18) != 0 )
  32.     c |= 0x10;
  33.     if ( (TrmCol & 0x20) != 0 )
  34.     c |= 0x08;
  35.     TrmCol = c;
  36. }
  37. BOOL    Con_init()
  38. {
  39.     if ( cvram == NULL ) {
  40.     if ( (cvram = (UCHAR *)malloc(MAX_X*MAX_Y*2)) == NULL )
  41.         return ERR;
  42.         colset(cvram,TrmCol,MAX_X*MAX_Y*2);
  43.         Cur_X = Cur_Y = 0;
  44.     } else {
  45.     Cur_X = Bak_X; Cur_Y = Bak_Y;
  46.     }
  47.     Dsp_vram(cvram);
  48.     MAX_SCR = MAX_Y2;
  49.     return FALSE;
  50. }
  51. void    Con_end()
  52. {
  53.     Bak_X = Cur_X; Bak_Y = Cur_Y;
  54.     MAX_SCR = MAX_Y;
  55. }
  56. static void    NextChr(sub)
  57. void     (*sub)();
  58. {
  59.     ExtFlg = TRUE;
  60.     ExtAdr = sub;
  61. }
  62. static void    Scrool()
  63. {
  64.     memcpy(cvram,cvram + (MAX_X * 2),(MAX_X * 2) * (MAX_Y2 - 1));
  65.     colset(cvram + (MAX_X * 2) * (MAX_Y2 - 1),TrmCol,(MAX_X * 2));
  66. /**************
  67.     Disp_Scrool(cvram,TrmCol);
  68. **************/
  69. }
  70. static void    PutBS()
  71. {
  72.     if ( --Cur_X < 0 ) {
  73.         Cur_X = MAX_X - 1;
  74.         if ( --Cur_Y < 0 )
  75.             Cur_Y = 0;
  76.     }
  77. }
  78. static void    PutTAB()
  79. {
  80.     int     i;
  81.     extern void    PutChr();
  82.  
  83.     i = ((Cur_X + TAB) / TAB) * TAB - Cur_X;
  84.  
  85.     if ( DspCnt > 1 && i-- > 0 )
  86.     PutChr(0x20|(TrmCol-2),TABCHR);
  87.     while ( i-- > 0 )
  88.     PutChr(TrmCol,' ');
  89. }
  90. static void    PutLF()
  91. {
  92.     if ( ++Cur_Y >= MAX_Y2 ) {
  93.     Cur_Y = (MAX_Y2 - 1);
  94.     Scrool();
  95.     }
  96. }
  97. static void    PutHOME()
  98. {
  99.     Cur_X = Cur_Y = 0;
  100. }
  101. static void    PutCLS()
  102. {
  103.     colset(cvram,TrmCol,(MAX_X * 2) * MAX_Y2);
  104.     Cur_X = Cur_Y = 0;
  105. }
  106. static void    PutCR()
  107. {
  108.     extern void     PutChr();
  109.  
  110.     if ( DspCnt > 1 )
  111.     PutChr(0x20|(TrmCol-2),CRCHR);
  112.     Cur_X = 0;
  113. }
  114. static void    CurRit()
  115. {
  116.     if ( ++Cur_X >= MAX_X )
  117.         Cur_X = 0;
  118. }
  119. static void    CurLft()
  120. {
  121.     if ( --Cur_X < 0 )
  122.         Cur_X = MAX_X - 1;
  123. }
  124. static void    CurUp()
  125. {
  126.     if ( --Cur_Y < 0 )
  127.         Cur_Y = MAX_Y2 - 1;
  128. }
  129. static void    CurDwn()
  130. {
  131.     if ( ++Cur_Y >= MAX_Y2 )
  132.         Cur_Y = 0;
  133. }
  134. void    SVidAt(ch)
  135. int     ch;
  136. {
  137.     TrmCol = ch & 0x3F;
  138.     Col_cnv();
  139. }
  140. void    SetDC2_s(ch)
  141. int     ch;
  142. {
  143.     Cur_X = BakCh1;
  144.     Cur_Y = ch;
  145.     if ( Cur_X < 0 ) Cur_X = 0;
  146.     if ( Cur_X >= MAX_X ) Cur_X = MAX_X - 1;
  147.     if ( Cur_Y < 0 ) Cur_Y = 0;
  148.     if ( Cur_Y >= MAX_Y2 ) Cur_Y = MAX_Y2 - 1;
  149. }
  150. void    SetDC2(ch)
  151. int     ch;
  152. {
  153.     extern void    SetDC2_s();
  154.  
  155.     BakCh1 = ch;
  156.     NextChr(SetDC2_s);
  157. }
  158. void    SetDC3_s(ch)
  159. int     ch;
  160. {
  161.     extern void    PutChr();
  162.  
  163.     while ( BakCh1-- > 0 )
  164.         PutChr(0x20|TrmCol,ch);
  165. }
  166. void    SetDC3(ch)
  167. int     ch;
  168. {
  169.     extern void    SetDC3_s();
  170.  
  171.     BakCh1 = ch;
  172.     NextChr(SetDC3_s);
  173. }
  174. static void    EraLin()
  175. {
  176.     colset(cvram + (Cur_X * 2) + (MAX_X * 2) * Cur_Y,TrmCol,(MAX_X - Cur_X) * 2);
  177. }
  178. static void    EraScr()
  179. {
  180.     colset(cvram + (Cur_X * 2) + (MAX_X * 2) * Cur_Y,TrmCol,
  181.         (MAX_X * 2) * MAX_Y2 - ((Cur_X * 2) + (MAX_X * 2) * Cur_Y));
  182. }
  183. static void    InsLin()
  184. {
  185.     int     i;
  186.     UCHAR   *p;
  187.  
  188.     p = cvram + (MAX_X * 2) * (MAX_Y2 - 1);
  189.     for ( i = MAX_Y2 - 1 ; i > Cur_Y ; i-- ) {
  190.         memcpy(p,p-(MAX_X * 2),(MAX_X * 2));
  191.         p -= (MAX_X * 2);
  192.     }
  193.     colset(cvram + (MAX_X * 2) * Cur_Y,TrmCol,MAX_X * 2);
  194. }
  195. static void    DelLin()
  196. {
  197.     int     i;
  198.     UCHAR   *p;
  199.  
  200.     p = cvram + (MAX_X * 2) * Cur_Y;
  201.     for ( i = Cur_Y ; i < (MAX_Y2 - 1) ; i ++ ) {
  202.         memcpy(p,p+(MAX_X * 2),(MAX_X * 2));
  203.         p += (MAX_X * 2);
  204.     }
  205.     colset(cvram + (MAX_X * 2) * (MAX_Y2 - 1),TrmCol,MAX_X * 2);
  206. }
  207. void    SCurPs_s(ch)
  208. int     ch;
  209. {
  210.     Cur_Y = BakCh1 - ' ';
  211.     Cur_X = ch - ' ';
  212.     if ( Cur_X < 0 ) Cur_X = 0;
  213.     if ( Cur_X >= MAX_X ) Cur_X = MAX_X - 1;
  214.     if ( Cur_Y < 0 ) Cur_Y = 0;
  215.     if ( Cur_Y >= MAX_Y2 ) Cur_Y = MAX_Y2 - 1;
  216. }
  217. void    SCurPs(ch)
  218. int     ch;
  219. {
  220.     extern void    SCurPs_s();
  221.  
  222.     BakCh1 = ch;
  223.     NextChr(SCurPs_s);
  224. }
  225. void    CurAtt_s()
  226. {
  227. }
  228. void    CurAtt(ch)
  229. int    ch;
  230. {
  231.     extern void    CurAtt_s();
  232.  
  233.     NextChr(CurAtt_s);
  234. }
  235. static void    AnsiH()
  236. {
  237.     if ( EscPrm[0] > 0 ) EscPrm[0]--;
  238.     if ( EscPrm[1] > 0 ) EscPrm[1]--;
  239.     Cur_Y = EscPrm[0];
  240.     Cur_X = EscPrm[1];
  241.     if ( Cur_X < 0 ) Cur_X = 0;
  242.     if ( Cur_X >= MAX_X ) Cur_X = MAX_X - 1;
  243.     if ( Cur_Y < 0 ) Cur_Y = 0;
  244.     if ( Cur_Y >= MAX_Y2 ) Cur_Y = MAX_Y2 - 1;
  245. }
  246. static void    AnsiA()
  247. {
  248.     if ( (Cur_Y -= EscPrm[0]) < 0 )
  249.         Cur_Y = 0;
  250. }
  251. static void    AnsiB()
  252. {
  253.     if ( (Cur_Y += EscPrm[0]) >= MAX_Y2 )
  254.         Cur_Y = MAX_Y2 - 1;
  255. }
  256. static void    AnsiC()
  257. {
  258.     if ( (Cur_X += EscPrm[0]) >= MAX_X )
  259.         Cur_X = MAX_X - 1;
  260. }
  261. static void    AnsiD()
  262. {
  263.     if ( (Cur_X -= EscPrm[0]) < 0 )
  264.         Cur_X = 0;
  265. }
  266. static void    Ansis()
  267. {
  268.     Bak_X = Cur_X;
  269.     Bak_Y = Cur_Y;
  270. }
  271. static void    Ansiu()
  272. {
  273.     Cur_X = Bak_X;
  274.     Cur_Y = Bak_Y;
  275. }
  276. static void    AnsiJ()
  277. {
  278.     switch(EscPrm[0]) {
  279.         case 0: EraScr(); break;
  280.         case 1: colset(cvram,TrmCol,(Cur_X * 2) + (MAX_X * 2) * Cur_Y); break;
  281.         case 2: PutCLS(); break;
  282.     }
  283. }
  284. static void    AnsiK()
  285. {
  286.     switch(EscPrm[0]) {
  287.         case 0: EraLin(); break;
  288.         case 1:
  289.             if ( Cur_X > 0 )
  290.         colset(cvram + (MAX_X * 2) * Cur_Y,TrmCol,Cur_X * 2);
  291.             break;
  292.         case 2: colset(cvram + (MAX_X * 2) * Cur_Y,TrmCol,MAX_X * 2); break;
  293.     }
  294. }
  295. static void    AnsiM()
  296. {
  297.     while ( EscPrm[0]-- > 0 )
  298.         DelLin();
  299.     Cur_X = 0;
  300. }
  301. static void    AnsiL()
  302. {
  303.     while ( EscPrm[0]-- > 0 )
  304.         InsLin();
  305.     Cur_X = 0;
  306. }
  307. static void    Ansim()
  308. {
  309.     int     c=7;
  310.     int     i,n;
  311.     static char ansiatt[]={ 0x00,0x08,0x00,0x00,0x00,0x10,0x00,0x08,0x00 };
  312.     static char ansicol[]={ 0,2,4,6,1,3,5,7 };
  313.  
  314.     for ( n = 0 ; n < EscCnt ; n++ ) {
  315.         if ( (i = EscPrm[n]) >= 1 && i <= 7 ) {
  316.             c |= ansiatt[i];
  317.     } else if ( i == 0 ) {
  318.         c = 7;
  319.         } else if ( i >= 30 && i <= 38 ) {
  320.             c &= 0xF8;
  321.             c |= ansicol[i-30];
  322.         } else if ( i >= 40 && i <= 47 ) {
  323.             c &= 0xF8;
  324.             c |= ansicol[i-40];
  325.             c |= 0x10;
  326.         }
  327.     }
  328.     TrmCol = c;
  329. }
  330. void    AnsiCom(ch)
  331. int     ch;
  332. {
  333.     if ( ch == ';' && EscCnt < 8 )
  334.         EscCnt++;
  335.     else if ( ch >= '0' && ch <= '9' )
  336.         EscPrm[EscCnt] = EscPrm[EscCnt] * 10 + (ch - '0');
  337.     else if ( ch != ' ' ) {
  338.         EscCnt++;
  339.         switch(ch) {
  340.             case 'H': AnsiH(); break;
  341.             case 'f': AnsiH(); break;
  342.             case 'A': AnsiA(); break;
  343.             case 'B': AnsiB(); break;
  344.             case 'C': AnsiC(); break;
  345.             case 'D': AnsiD(); break;
  346.             case 's': Ansis(); break;
  347.             case 'u': Ansiu(); break;
  348.             case 'J': AnsiJ(); break;
  349.             case 'K': AnsiK(); break;
  350.             case 'm': Ansim(); break;
  351.             case 'M': AnsiM(); break;
  352.             case 'L': AnsiL(); break;
  353.         }
  354.         return;
  355.     }
  356.     NextChr(AnsiCom);
  357. }
  358. static void    AnsiESC()
  359. {
  360.     extern void    AnsiCom();
  361.  
  362.     memset(EscPrm,0,8);
  363.     EscCnt = 0;
  364.     NextChr(AnsiCom);
  365. }
  366. void    EscCom(ch)
  367. int     ch;
  368. {
  369.     extern void    SCurPs(),SVidAt(),CurAtt();
  370.  
  371.     switch(ch) {
  372.         case '*': PutCLS(); break;
  373.         case 'T': EraLin(); break;
  374.         case 'Y': EraScr(); break;
  375.         case 'E': InsLin(); break;
  376.         case 'R': DelLin(); break;
  377.         case '=': NextChr(SCurPs); break;
  378.         case 'G': NextChr(SVidAt); break;
  379.         case 'K': KanMod = TRUE; break;
  380.         case 'C': KanMod = FALSE; break;
  381.     case '.': NextChr(CurAtt); break;
  382.         case '[': AnsiESC(); break;
  383.         default: PutChr(TrmCol|0x20,ch); break;
  384.     }
  385. }
  386. static void    PutCnt(ch)
  387. int     ch;
  388. {
  389.     extern void    SetDC2(),SetDC3(),EscCom();
  390.  
  391.     if ( DspCnt != 0 ) {
  392.     switch(ch) {
  393.         case 0x08: PutBS(); break;
  394.             case 0x09: PutTAB(); break;
  395.         case 0x0A: PutLF(); break;
  396.         case 0x0D: PutCR(); break;
  397.         default: 
  398.         if ( DspCnt > 1 )
  399.             PutChr(TrmCol|0x20,ch);
  400.         break;
  401.     }
  402.     return;
  403.     }
  404.     switch(ch) {
  405.         case 0x08: PutBS(); break;
  406.         case 0x09: PutTAB(); break;
  407.     case 0x0A: PutLF(); break;
  408.         case 0x0B: PutHOME(); break;
  409.     case 0x0C: PutCLS(); break;
  410.         case 0x0D: PutCR(); break;
  411.  
  412.     case 0x12: NextChr(SetDC2); break;
  413.         case 0x13: NextChr(SetDC3); break;
  414.         case 0x15: PutCLS(); break;
  415.     case 0x16: PutCLS(); break;
  416.  
  417.     case 0x1B: NextChr(EscCom); break;
  418.  
  419.     case 0x1C: CurRit(); break;
  420.         case 0x1D: CurLft(); break;
  421.         case 0x1E: CurUp(); break;
  422.         case 0x1F: CurDwn(); break;
  423.  
  424.         default:
  425.         if ( DspCnt > 1 )
  426.         PutChr(TrmCol|0x20,ch);
  427.         break;
  428.     }
  429. }
  430. void    PutChr(att,ch)
  431. int     att,ch;
  432. {
  433.     UCHAR   *p;
  434.  
  435.     if ( (att & 0x20) == 0 ) {
  436.     if ( ch < ' ' || ch == 0x7f ) {
  437.         PutCnt(ch);
  438.         return;
  439.     }
  440.     }
  441.  
  442.     if ( ch == '\0' )
  443.     return;
  444.  
  445.     p = cvram + Cur_X * 2 + (MAX_X * 2) * Cur_Y;
  446.     *(p++) = (att & 0xDF); *p = ch;
  447.  
  448.     if ( ++Cur_X >= MAX_X ) {
  449.         Cur_X = 0;
  450.     if ( ++Cur_Y >= MAX_Y2 ) {
  451.             Cur_Y = MAX_Y2 - 1;
  452.             Scrool();
  453.         }
  454.     }
  455. }
  456. void    BakPut(ch)
  457. int     ch;
  458. {
  459.     ch &= 0xff;
  460.  
  461.     if ( ExtFlg != FALSE ) {
  462.     ExtFlg = FALSE;
  463.     (*ExtAdr)(ch);
  464.         return;
  465.     }
  466.  
  467.     if ( KanMod != FALSE ) {
  468.         if ( KanCod != '\0' ) {
  469.             if ( iskanji2(ch) != FALSE ) {
  470.         if ( Cur_X == (MAX_X - 1) ) {
  471.                     PutChr(TrmCol,DMYKAN);
  472.                     PutChr(TrmCol,DMYKAN);
  473.         } else {
  474. #ifdef    TOWNS
  475.             PutChr(0x40|TrmCol,KanCod);
  476.                     PutChr(0x80|TrmCol,ch);
  477. #else
  478.             ch = sjistojis((KanCod << 8) | ch);
  479.             PutChr(0x40|TrmCol,ch >> 8);
  480.                     PutChr(0x80|TrmCol,ch & 0xff);
  481. #endif
  482.                 }
  483.             } else {
  484.         PutChr(TrmCol,KanCod);
  485.         PutChr(TrmCol,ch);
  486.         }
  487.             KanCod = '\0';
  488.         return;
  489.         } else if ( iskanji(ch) != FALSE ) {
  490.         KanCod = ch;
  491.             return;
  492.         }
  493.     }
  494.     PutChr(TrmCol,ch);
  495. }
  496. void    BakStr(str)
  497. char    *str;
  498. {
  499.     while ( *str != '\0' )
  500.     BakPut(*(str++));
  501. }
  502.