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