home *** CD-ROM | disk | FTP | other *** search
/ FreeWare Collection 2 / FreeSoftwareCollection2pd199x-jp.img / oricon / src / vdb.c < prev   
Text File  |  1990-06-14  |  17KB  |  782 lines
  1. #define TRUE    1
  2. #define FALSE   0
  3. #define ERR     (-1)
  4.  
  5. #define UCHAR   unsigned char
  6. #define SHORT   short int
  7. #define    UNSIG    unsigned int
  8.  
  9. #define    OFFSET(p,n)    *((unsigned int *)(&(p)))=n
  10. #define    SEGSET(p,n)    *((unsigned int *)(&(p))+1)=n
  11.  
  12. #define    HIGH(p)        ((unsigned char far *)(&(p))+1)
  13. #define    LOW(p)        ((unsigned char far *)(&(p)))
  14.  
  15. #define    U_AX    (reg->r_ax)
  16. #define U_AH    *((unsigned char far *)(&(reg->r_ax))+1)
  17. #define    U_AL    *((unsigned char far *)(&(reg->r_ax)))
  18.  
  19. #define    U_BX    (reg->r_bx)
  20. #define    U_BH    *((unsigned char far *)(&(reg->r_bx))+1)
  21. #define    U_BL    *((unsigned char far *)(&(reg->r_bx)))
  22.  
  23. #define    U_CX    (reg->r_cx)
  24. #define    U_CH    *((unsigned char far *)(&(reg->r_cx))+1)
  25. #define    U_CL    *((unsigned char far *)(&(reg->r_cx)))
  26.  
  27. #define    U_DX    (reg->r_dx)
  28. #define    U_DH    *((unsigned char far *)(&(reg->r_dx))+1)
  29. #define    U_DL    *((unsigned char far *)(&(reg->r_dx)))
  30.  
  31. #define    U_DI    (reg->r_di)
  32. #define    U_SI    (reg->r_si)
  33.  
  34. #define    U_DS    (reg->r_ds)
  35. #define    U_ES    (reg->r_es)
  36.  
  37. #define    U_CF    (reg->r_cf)
  38.  
  39. #define    CVRAM    0xC800
  40. #define    KVRAM    0xCA00
  41.  
  42. #define    SCR_X    80
  43. #define MAX_X   80
  44. #ifdef    LINE40
  45.   #define MAX_Y   40
  46. #else
  47.   #define MAX_Y   25
  48. #endif
  49.  
  50. #define DMYKAN  0xFE
  51. #define CRCHR   0x1F
  52. #define TABCHR  0x09
  53. #define    NULCHR    0x20
  54. #define TAB     8
  55. #define CONTRL  FALSE
  56. #define DEFCOL  COLOR
  57.  
  58. SHORT    CUR_X=0,CUR_Y=0;
  59. SHORT    CUR_TYPE=0x30;
  60. SHORT    CUR_OFF2=14,CUR_SIZE2=2;
  61. UCHAR    CUR_DSP_FLG=0;
  62. UCHAR    Con_mode=0xCE;
  63. SHORT    SCR_Y=MAX_Y;
  64. SHORT    COLOR=7,BAKCOL=0;
  65. UCHAR    Act_Dsp=FALSE;
  66.  
  67. struct _REGSET {
  68.     SHORT    r_es;
  69.     SHORT    r_ds;
  70.     SHORT    r_di;
  71.     SHORT    r_si;
  72.     SHORT    r_bp;
  73.     SHORT    r_sp;
  74.     SHORT    r_bx;
  75.     SHORT    r_dx;
  76.     SHORT    r_cx;
  77.     SHORT    r_ax;
  78.     SHORT    r_ip;
  79.     SHORT    r_cs;
  80.     SHORT    r_cf;
  81. };
  82.  
  83. /**************************************************************
  84.  
  85.     CONSOL BIOS (int 91h) 
  86.  
  87. ***************************************************************/
  88. void    VDB_00(reg)    /* 初期化 */
  89. register struct _REGSET far *reg;
  90. {
  91.     SCR_Y = MAX_Y - 1;
  92.     CUR_DSP_FLG = 0;
  93.     Con_mode = 0xCE;
  94.     CUR_X = CUR_Y = 0;
  95.     COLOR = 7;
  96.     colset(0,COLOR,(MAX_X * 2) * MAX_Y);
  97. }
  98. void    VDB_01(reg)
  99. register struct _REGSET far *reg;
  100. {
  101. }    /* 画面の表示制御 */
  102.  
  103. void    VDB_02(reg)    /* 全画面消去 */
  104. register struct _REGSET far *reg;
  105. {
  106.     colset(0,DEFCOL,(MAX_X * 2) * MAX_Y);
  107.     CUR_X = CUR_Y = 0;
  108. }
  109. void     VDB_03(reg)    /* 表示画面サイズの設定 */
  110. register struct _REGSET far *reg;
  111. {
  112.     if ( (SCR_Y = U_DH) > MAX_Y )
  113.     SCR_Y = MAX_Y;
  114.     if ( (Con_mode & 0x40) != 0 )
  115.     SCR_Y--;
  116. }
  117. void     VDB_04(reg)    /* 表示画面サイズの読み取り */
  118. register struct _REGSET far *reg;
  119. {
  120.     U_DL = SCR_X;
  121.     U_DH = SCR_Y;
  122. }
  123. void    VDB_05(reg)    /* 表示画面サイズレパ－トリの読み取り */
  124. register struct _REGSET far *reg;
  125. {
  126.     char far *p;
  127.  
  128.     SEGSET(p,U_DS);
  129.     OFFSET(p,U_DI);
  130.  
  131.     if ( *(p++) < 4 )
  132.     return;
  133.     *(p++) = 1;
  134.     *(p++) = 80;
  135.     *(p++) = 25;
  136. }
  137. void     VDB_06(reg)    /* アトリビュート機能範囲の読み取り */
  138. register struct _REGSET far *reg;
  139. {
  140.     char far *p;
  141.  
  142.     SEGSET(p,U_DS);
  143.     OFFSET(p,U_DI);
  144.     *(p++) = 0x03;    /* 漢字識別可能 */
  145.     *(p++) = 0x38;    /* ﾘﾊﾞ-ｽ & 強調　*/
  146.     *(p++) = 0x07;    /* 最大色数 */
  147.     *p = 0;
  148. }
  149. void    VDB_07(reg)    /* フォントパタ－ンの取り出し */
  150. register struct _REGSET far *reg;
  151. {
  152.     int     i;
  153.     char far *fp;
  154.     char far *p;
  155.  
  156.     SEGSET(p,U_DS);
  157.     OFFSET(p,U_DI);
  158.  
  159.     if ( U_BH == 0 ) {    /* ANK 8x8 or 8x16 */
  160.     if ( U_DH != 8 )
  161.         goto ERROR;
  162.     else if ( U_DL == 8 ) {
  163.         SEGSET(fp,0xCA00);
  164.         OFFSET(fp,U_BL * 8);
  165.         outp(0xFF99,1);
  166.         for ( i = 0 ; i < 8 ; i++ )
  167.         *(p++) = *(fp++);
  168.         outp(0xFF99,0);
  169.         return;
  170.     } else if ( U_DL == 16 ) {
  171.         SEGSET(fp,0xCB00);
  172.         OFFSET(fp,U_BL * 16);
  173.         outp(0xFF99,1);
  174.         for ( i = 0 ; i < 16 ; i++ )
  175.         *(p++) = *(fp++);
  176.         outp(0xFF99,0);
  177.         return;
  178.     } else
  179.         goto ERROR;
  180.     } else if ( U_DX == 0x1010 ) {    /* Kanji 16x16 */
  181.         outp(0xFF94,U_BL);
  182.         outp(0xFF95,U_BH);
  183.     for ( i = 0 ; i < 16 ; i++ ) {
  184.         *(p++) = inp(0xFF96);
  185.         *(p++) = inp(0xFF97);
  186.     }
  187.     return;
  188.     }
  189. ERROR:
  190.     U_AH = 0x02;
  191.     U_CF |= 0x0001;
  192. }
  193. void    VDB_08(reg)
  194. register struct _REGSET far *reg;
  195. {}    /* 外字パタ－ンの登録 */
  196.  
  197. void    VDB_09(reg)    /* カ－ソル形状の設定 */
  198. register struct _REGSET far *reg;
  199. {
  200.     switch(U_AL & 0x0F) {
  201.     case 0: CUR_OFF2 = 14; CUR_SIZE2 = 2; break;
  202.     case 1: CUR_OFF2 = 0;  CUR_SIZE2 = 16; break;
  203.     case 15: CUR_OFF2 = U_DH;
  204.          CUR_SIZE2 = U_DL - CUR_OFF2;
  205.         if ( CUR_OFF2 < 0 || CUR_OFF2 > 15 )
  206.             CUR_OFF2 = 15;
  207.         if ( CUR_SIZE2 < 0 || (CUR_SIZE2 + CUR_OFF2) > 16 )
  208.             CUR_SIZE2 = 16 - CUR_OFF2;
  209.         break;
  210.     }
  211.     if ( (U_AL & 0x60) == 0x20 )
  212.     CUR_DSP_FLG = 1;
  213.     else
  214.     CUR_DSP_FLG = 0;
  215.     CUR_TYPE = U_AL;
  216. }
  217. void    VDB_0A(reg)    /* カ－ソル形状の読み取り */
  218. register struct _REGSET far *reg;
  219. {
  220.     U_AL = CUR_TYPE;
  221.     U_DH = CUR_OFF2;
  222.     U_DL = CUR_OFF2 + CUR_SIZE2;
  223. }
  224. void    VDB_0B(reg)    /* カ－ソル表示状態の設定 */ 
  225. register struct _REGSET far *reg;
  226. {
  227.     CUR_DSP_FLG = U_AL;
  228. }
  229. void    VDB_0C(reg)    /* カ－ソル表示状態の読み取り */
  230. register struct _REGSET far *reg;
  231. {
  232.     U_AL = CUR_DSP_FLG;
  233. }
  234. void    VDB_0D(reg)    /* カーソル位置の指定 */
  235. register struct _REGSET far *reg;
  236. {
  237.     CUR_X = U_DL - 1;
  238.     CUR_Y = U_DH - 1;
  239.     if ( CUR_X < 0 ) CUR_X = 0;
  240.     if ( CUR_X >= SCR_X ) CUR_X = SCR_X - 1;
  241.     if ( CUR_Y < 0 ) CUR_Y = 0;
  242.     if ( CUR_Y >= MAX_Y ) CUR_Y = MAX_Y - 1;
  243. }
  244. void     VDB_0E(reg)    /* カーソル位置の読み取り */
  245. register struct _REGSET far *reg;
  246. {
  247.     U_DL = CUR_X + 1;
  248.     U_DH = CUR_Y + 1;
  249. }
  250. void    VDB_0F(reg)    /* アトリビュートの設定 */
  251. register struct _REGSET far *reg;
  252. {
  253.     int    at,x,y;
  254.     char   far *p;
  255.     UCHAR  far *vp;
  256.  
  257.     x = U_DL - 1;
  258.     y = U_DH - 1;
  259.     SEGSET(vp,CVRAM);
  260.     OFFSET(vp,(x * 2 + (MAX_X * 2) * y + 1));
  261.  
  262.     SEGSET(p,U_DS);
  263.     OFFSET(p,(U_DI + 1));
  264.     at = *vp & 0xC0;
  265.     *vp = at | (*p & 0x38) | (*(p+1) & 0x07);
  266. }
  267. void    VDB_10(reg)    /* アトリビュートの読み取り */
  268. register struct _REGSET far *reg;
  269. {
  270.     int    at,x,y;
  271.     char   far *p;
  272.     UCHAR  far *vp;
  273.  
  274.     x = U_DL - 1;
  275.     y = U_DH - 1;
  276.     SEGSET(vp,CVRAM);
  277.     OFFSET(vp,(x * 2 + (MAX_X * 2) * y + 1));
  278.     SEGSET(p,U_DS);
  279.     OFFSET(p,U_DI);
  280.     if ( (*vp & 0x40) != 0 )
  281.     *p = 0x01;
  282.     else if ( x > 0 && (*(vp-2) & 0x40) != 0 ) {
  283.     *p = 0x03;
  284.     vp -= 2;
  285.     } else
  286.     *p = 0x00;
  287.  
  288.     *(++p) = *vp & 0x38;
  289.     *(++p) = *vp & 0x07;
  290. }
  291. void    VDB_11(reg)    /* デフォルトアトリビュ－トの設定 */
  292. register struct _REGSET far *reg;
  293. {
  294.     char far *p;
  295.  
  296.     SEGSET(p,U_DS);
  297.     OFFSET(p,U_DI);
  298.     DEFCOL = (*(++p) & 0x38);
  299.     DEFCOL |= (*(++p) & 0x07);
  300. }
  301. void    VDB_12(reg)    /* デフォルトアトリビュ－トの読み取り */
  302. register struct _REGSET far *reg;
  303. {
  304.     char far *p;
  305.  
  306.     SEGSET(p,U_DS);
  307.     OFFSET(p,U_DI);
  308.     *(++p) = DEFCOL & 0x38;
  309.     *(++p) = DEFCOL & 0x07;
  310. }
  311. void    VDB_13(reg)    /* 文字設定 */
  312. register struct _REGSET far *reg;
  313. {
  314.     int    ch,x,y;
  315.     UCHAR  far *vp;
  316.  
  317.     x = U_DL - 1;
  318.     y = U_DH - 1;
  319.     ch = U_BL;
  320.     SEGSET(vp,CVRAM);
  321.     OFFSET(vp,(x * 2 + (MAX_X * 2) * y));
  322.     *(vp++) = ch;
  323.     if ( U_AL != 1 )
  324.     *vp = DEFCOL;
  325.     else
  326.     *vp &= 0x3F;
  327.     if ( U_BH == 0x01 )
  328.     *vp |= 0x40;
  329.     else if ( U_BH == 0x03 ) {
  330.     ch |= (*(vp-3) << 8);
  331.     *(vp-1) = *(vp-3) = DMYKAN;
  332.         SEGSET(vp,KVRAM);
  333.     *(vp-3) = ch >> 8;
  334.     *(vp-2) = ch;
  335.     }
  336. }
  337. void    VDB_14(reg)    /* 文字読み取り */
  338. register struct _REGSET far *reg;
  339. {
  340.     int    at,x,y;
  341.     UCHAR  far *vp;
  342.  
  343.     x = U_DL - 1;
  344.     y = U_DH - 1;
  345.     SEGSET(vp,CVRAM);
  346.     OFFSET(vp,(x * 2 + (MAX_X * 2) * y));
  347.     if ( (*(vp+1) & 0x40) != 0 ) {
  348.     U_BH = 0x01;
  349.         SEGSET(vp,KVRAM);
  350.         U_BL = *vp;
  351.     } else if ( x > 0 && (*(vp-1) & 0x40) != 0 ) {
  352.     U_BH = 0x03;
  353.         SEGSET(vp,KVRAM);
  354.         U_BL = *(vp-1);
  355.     } else {
  356.     U_BH = 0x00;
  357.         U_BL = *vp;
  358.     }
  359. }
  360. void    VDB_15(reg)    /* 矩形域設定 */
  361. register struct _REGSET far *reg;
  362. {
  363.     int     cx,ch;
  364.     int     x1,y1,x2,y2;
  365.     int     x,y,sx,sy;
  366.     UNSIG far *p;
  367.     UCHAR far *cp;
  368.     UCHAR far *ap;
  369.     UCHAR far *sp;
  370.     UCHAR far *vp;
  371.  
  372.     if ( (x1 = U_DL - 1) >= MAX_X || x1 < 0)
  373.     goto ERROR;
  374.     if ( (y1 = U_DH - 1) >= SCR_Y || y1 < 0 )
  375.     goto ERROR;
  376.     if ( (x2 = U_BL) > MAX_X )
  377.     goto ERROR;
  378.     if ( (y2 = U_BH) > SCR_Y )
  379.     goto ERROR;
  380.     sx = x2 - x1; sy = y2 - y1;
  381.     if ( sx <= 0 || sy <= 0 )
  382.     goto ERROR;
  383.     SEGSET(sp,CVRAM);
  384.     OFFSET(sp,(x1 * 2 + (MAX_X * 2) * y1));
  385.  
  386.     OFFSET(p,U_DI);
  387.     SEGSET(p,U_DS);
  388.  
  389.     OFFSET(cp,*(p++));
  390.     SEGSET(cp,*(p++));
  391.  
  392.     OFFSET(ap,*(p++));
  393.     SEGSET(ap,*(p++));
  394.  
  395.     for ( y = 0 ; y < sy ; y++ ) {
  396.     for ( x = 0,vp = sp ; x < sx ; x++ ) {
  397.         *(vp++) = *(cp++);
  398.         if ( *(ap++) == 0x03 ) {
  399.         *(vp-2) |= 0x40;
  400.         ch = *(vp-3) << 8 | *(vp-1);
  401.         SEGSET(vp,KVRAM);
  402.         *(vp-3) = ch >> 8;
  403.         *(vp-2) = ch;
  404.         SEGSET(vp,CVRAM);
  405.         } else
  406.         *vp &= 0x3F;
  407.         if ( U_AL == 1 ) {
  408.         *vp = *(ap++) & 0x38;
  409.         *vp |= *(ap++) & 0x07; ap++;
  410.         }
  411.         vp++;
  412.     }
  413.     sp += (MAX_X * 2);
  414.     }
  415.     return;
  416. ERROR:
  417.     U_AH = 0x02;
  418.     U_CF |= 0x0001;
  419. }
  420. void    VDB_16(reg)        /* 矩形域読み取り */
  421. register struct _REGSET far *reg;
  422. {
  423.     int     i;
  424.     int     x1,y1,x2,y2;
  425.     int     x,y,sx,sy;
  426.     UNSIG far *p;
  427.     UCHAR far *cp;
  428.     UCHAR far *ap;
  429.     UCHAR far *sp;
  430.     UCHAR far *vp;
  431.  
  432.     if ( (x1 = U_DL-1) >= MAX_X || x1 < 0)
  433.     goto ERROR;
  434.     if ( (y1 = U_DH-1) >= SCR_Y || y1 < 0 )
  435.     goto ERROR;
  436.     if ( (x2 = U_BL) > MAX_X )
  437.     goto ERROR;
  438.     if ( (y2 = U_BH) > SCR_Y )
  439.     goto ERROR;
  440.     sx = x2 - x1; sy = y2 - y1;
  441.     if ( sx <= 0 || sy <= 0 )
  442.     goto ERROR;
  443.     SEGSET(sp,CVRAM);
  444.     OFFSET(sp,(x1 * 2 + (MAX_X * 2) * y1));
  445.  
  446.     OFFSET(p,U_DI);
  447.     SEGSET(p,U_DS);
  448.  
  449.     OFFSET(cp,*(p++));
  450.     SEGSET(cp,*(p++));
  451.  
  452.     OFFSET(ap,*(p++));
  453.     SEGSET(ap,*(p++));
  454.  
  455.     for ( y = 0 ; y < sy ; y++ ) {
  456.     for ( x = 0,vp = sp ; x < sx ; x++ ) {
  457.         *(cp++) = *(vp++);
  458.         if ( (*vp & 0x40) != 0 ) {
  459.         *(ap++) = 0x01;
  460.         SEGSET(vp,KVRAM);
  461.         *(cp-1) = *(vp-1);
  462.         SEGSET(vp,CVRAM);
  463.         } else if ( x > 0 && (*(vp-2) & 0x40) != 0 ) {
  464.         *(ap++) = 0x03;
  465.         SEGSET(vp,KVRAM);
  466.         *(cp-1) = *(vp-2);
  467.         SEGSET(vp,CVRAM);
  468.         } else
  469.         *(ap++) = 0x00;
  470.         if ( U_AL == 1 ) {
  471.         *(ap++) = *vp & 0x38;
  472.         *(ap++) = *vp & 0x07; ap++;
  473.         }
  474.         vp++;
  475.     }
  476.     sp += (MAX_X * 2);
  477.     }
  478.     return;
  479. ERROR:
  480.     U_AH = 0x02;
  481.     U_CF |= 0x0001;
  482. }
  483. void    VDB_17(reg)    /* 矩形域複写 */
  484. register struct _REGSET far *reg;
  485. {
  486.     int     i;
  487.     int     x1,y1,x2,y2,x3,y3;
  488.     int     sx,sy;
  489.     UNSIG   sp;
  490.     UNSIG   dp;
  491.  
  492.     if ( (x1 = U_DL - 1) >= MAX_X || x1 < 0 )
  493.     goto ERROR;
  494.     if ( (y1 = U_DH - 1) >= SCR_Y || y1 < 0 )
  495.     goto ERROR;
  496.     if ( (x2 = U_BL) > MAX_X )
  497.     goto ERROR;
  498.     if ( (y2 = U_BH) > SCR_Y )
  499.     goto ERROR;
  500.     if ( (x3 = U_CL - 1) >= MAX_X || x3 < 0 )
  501.     goto ERROR;
  502.     if ( (y3 = U_CH - 1) >= SCR_Y || y3 < 0 )
  503.     goto ERROR;
  504.     sx = x2 - x1; sy = y2 - y1;
  505.     if ( sx <= 0 || sy <= 0 )
  506.     goto ERROR;
  507.     if ( (x3 + sx) > MAX_X || (y3 + sy) > SCR_Y )
  508.     goto ERROR;
  509.  
  510.     if ( sp < dp ) {
  511.     sp = (x2 - 1) * 2 + (MAX_X * 2) * (y2 - 1);
  512.     dp = (x3 + sx - 1) * 2 + (MAX_X * 2) * (y3 + sy - 1);
  513.     for ( i = 0 ; i < sy ; i++ ) {
  514.         vramrcpy(dp,sp,sx * 2);
  515.         sp -= (MAX_X * 2);
  516.         dp -= (MAX_X * 2);
  517.     }
  518.     } else {
  519.     sp = x1 * 2 + (MAX_X * 2) * y1;
  520.     dp = x3 * 2 + (MAX_X * 2) * y3;
  521.     for ( i = 0 ; i < sy ; i++ ) {
  522.         vramcpy(dp,sp,sx * 2);
  523.         sp += (MAX_X * 2);
  524.         dp += (MAX_X * 2);
  525.     }
  526.     }
  527.     return;
  528. ERROR:
  529.     U_AH = 0x02;
  530.     U_CF |= 0x0001;
  531. }
  532. void    VDB_18(reg)    /* 矩形域消去 */
  533. register struct _REGSET far *reg;
  534. {
  535.     int     i;
  536.     int     x1,y1,x2,y2;
  537.     int     sx,sy;
  538.     UNSIG   sp;
  539.  
  540.     if ( (x1 = U_DL - 1) >= MAX_X || x1 < 0 )
  541.     goto ERROR;
  542.     if ( (y1 = U_DH - 1) >= SCR_Y || y1 < 0 )
  543.     goto ERROR;
  544.     if ( (x2 = U_BL) > MAX_X )
  545.     goto ERROR;
  546.     if ( (y2 = U_BH) > SCR_Y )
  547.     goto ERROR;
  548.     sx = x2 - x1; sy = y2 - y1;
  549.     if ( sx <= 0 || sy <= 0 )
  550.     goto ERROR;
  551.     sp = (x1 * 2 + (MAX_X * 2) * y1);
  552.  
  553.     for ( i = 0 ; i < sy ; i++ ) {
  554.     colset(sp,DEFCOL,sx * 2);
  555.     sp += (MAX_X * 2);
  556.     }
  557.     return;
  558. ERROR:
  559.     U_AH = 0x02;
  560.     U_CF |= 0x0001;
  561. }
  562. void    VDB_19(reg)    /* 全画面スクロ－ル */ 
  563. register struct _REGSET far *reg;
  564. {
  565.     int     cx,i;
  566.     UNSIG   vp;
  567.  
  568.     if ( (cx = U_CX) == 0 || cx > SCR_Y )
  569.     cx = SCR_Y;
  570.     for ( ; cx > 0 ; cx-- ) {
  571.     switch(U_AL) {
  572.         case 1:    /* 下方向 */
  573.         i = (MAX_X * 2) * (SCR_Y - 1);
  574.         vramrcpy(i + (MAX_X * 2 - 2),i - 2,i);
  575.         colset(0,DEFCOL,(MAX_X * 2));
  576.         break;
  577.         case 2:    /* 右方向 */
  578.         i = (MAX_X * 2) * SCR_Y - 2;
  579.         vramrcpy(i,i - 2,i);
  580.         vp = 0;
  581.         for ( i = 0 ; i < SCR_Y ; i++ ) {
  582.             colset(vp,DEFCOL,2);
  583.             vp += (MAX_X * 2);
  584.         }
  585.         break;
  586.         case 3:    /* 左方向 */
  587.         vramcpy(0,2,(MAX_X * 2) * SCR_Y - 2);
  588.         vp = (MAX_X * 2) - 2;
  589.         for ( i = 0 ; i < SCR_Y ; i++ ) {
  590.             colset(vp,DEFCOL,2);
  591.             vp += (MAX_X * 2);
  592.         }
  593.         break;
  594.             default:     /* case 0 上方向 */
  595.         vramcpy(0,(MAX_X * 2),(MAX_X * 2) * (SCR_Y - 1));
  596.         colset((MAX_X * 2) * (SCR_Y - 1),DEFCOL,(MAX_X * 2));
  597.         break;
  598.     }
  599.     }
  600. }
  601. void    VDB_1A(reg)    /* 部分スクロ－ル */
  602. register struct _REGSET far *reg;
  603. {
  604.     int     cx,i;
  605.     int     x1,y1,x2,y2;
  606.     int     sx,sy;
  607.     UNSIG   sp;
  608.     UNSIG   vp;
  609.  
  610.     if ( (x1 = U_DL - 1) >= MAX_X || x1 < 0 )
  611.     goto ERROR;
  612.     if ( (y1 = U_DH - 1) >= SCR_Y || y1 < 0 )
  613.     goto ERROR;
  614.     if ( (x2 = U_BL) > MAX_X )
  615.     goto ERROR;
  616.     if ( (y2 = U_BH) > SCR_Y )
  617.     goto ERROR;
  618.     sx = x2 - x1; sy = y2 - y1;
  619.     if ( sx <= 0 || sy <= 0 )
  620.     goto ERROR;
  621.     sp = (x1 * 2 + (MAX_X * 2) * y1);
  622.  
  623.     if ( (cx = U_CX) == 0 || cx > sy )
  624.     cx = sy;
  625.     for ( ; cx > 0 ; cx-- ) {
  626.     switch(U_AL) {
  627.         case 1:    /* 下方向 */
  628.         vp = sp + (MAX_X * 2) * (sy - 1);
  629.         for ( i = 0 ; i < (sy-1) ; i++ ) {
  630.             vramcpy(vp,vp - (MAX_X * 2),sx * 2);
  631.             vp -= (MAX_X * 2);
  632.         }
  633.         colset(sp,DEFCOL,sx * 2);
  634.         break;
  635.         case 2:    /* 右方向 */
  636.         vp = sp + (sx * 2) - 2;
  637.         for ( i = 0 ; i < sy ; i++ ) {
  638.             vramrcpy(vp,vp - 2,sx * 2 - 2);
  639.             vp += (MAX_X * 2);
  640.         }
  641.         vp = sp;
  642.         for ( i = 0 ; i < sy ; i++ ) {
  643.             colset(vp,DEFCOL,2);
  644.             vp += (MAX_X * 2);
  645.         }
  646.         break;
  647.         case 3:    /* 左方向 */
  648.         vp = sp;
  649.         for ( i = 0 ; i < sy ; i++ ) {
  650.             vramcpy(vp,vp + 2,sx * 2 - 2);
  651.             vp += (MAX_X * 2);
  652.         }
  653.         vp = sp + (sx * 2) - 2;
  654.         for ( i = 0 ; i < sy ; i++ ) {
  655.             colset(vp,DEFCOL,2);
  656.             vp += (MAX_X * 2);
  657.         }
  658.         break;
  659.             default:     /* case 0 上方向 */
  660.         for ( vp = sp,i = 0 ; i < (sy-1) ; i++ ) {
  661.             vramcpy(vp,vp + (MAX_X * 2),sx * 2);
  662.             vp += (MAX_X * 2);
  663.         }
  664.         colset(vp,DEFCOL,sx * 2);
  665.         break;
  666.     }
  667.     }
  668.     return;
  669. ERROR:
  670.     U_AH = 0x02;
  671.     U_CF |= 0x0001;
  672. }
  673. void    VDB_1B(reg)    /* コンソ－ル機能の設定 */
  674. register struct _REGSET far *reg;
  675. {
  676.     int     i;
  677.  
  678.     i = Con_mode;
  679.     Con_mode = (U_AL & 0xC7) | 0x08;
  680.     if ( (i & 0x40) != (Con_mode & 0x40) ) {
  681.     if ( (Con_mode & 0x40) != 0 )
  682.         SCR_Y--;
  683.     else
  684.         SCR_Y++;
  685.     }
  686. }
  687. void    VDB_1C(reg)    /* コンソ－ル機能の読み取り */
  688. register struct _REGSET far *reg;
  689. {
  690.     U_AL = Con_mode;
  691. }
  692. void    VDB_1D(reg)    /* 文字の出力 */
  693. register struct _REGSET far *reg;
  694. {
  695.     Chr_out(U_AL);
  696. }
  697. void    VDB_1E(reg)    /* 文字列の出力 */
  698. register struct _REGSET far *reg;
  699. {
  700.     int     i;
  701.     UCHAR far *p;
  702.  
  703.     SEGSET(p,U_DS);
  704.     OFFSET(p,U_DI);
  705.     for ( i = U_CX ; i > 0 ; i-- )
  706.     Chr_out(*(p++));
  707. }
  708. void    VDB_1F(reg)    /* システム行書き込み */
  709. register struct _REGSET far *reg;
  710. {
  711.     int    ch,cx,at,md;
  712.     UNSIG far *p;
  713.     UCHAR far *cp;
  714.     UCHAR far *ap;
  715.     UCHAR far *vp;
  716.  
  717.     if ( (Con_mode & 0x40) == 0 )
  718.     return;
  719.  
  720.     OFFSET(p,U_DI);
  721.     SEGSET(p,U_DS);
  722.  
  723.     OFFSET(cp,*(p++));
  724.     SEGSET(cp,*(p++));
  725.  
  726.     OFFSET(ap,*(p++));
  727.     SEGSET(ap,*(p++));
  728.  
  729.     OFFSET(vp,((U_DL & 0x7F) - 1) * 2 + (MAX_X * 2) * SCR_Y);
  730.     SEGSET(vp,CVRAM);
  731.  
  732.     cx = U_CX;
  733.     for ( ; cx > 0 ; cx-- ) {
  734.     *(vp++) = *(cp++);
  735.     if ( U_AL != 1 ) {
  736.         at = DEFCOL;
  737.         md = *(ap++);
  738.     } else {
  739.         md = *(ap++);
  740.         at = *(ap++) & 0x38;
  741.         at |= (*(ap++) & 0x07); ap++;
  742.     }
  743.     *(vp++) = at;
  744.     if ( md == 0x03 ) {
  745.         ch = (*(vp-4) << 8) | *(vp-2);
  746.         *(vp-4) = *(vp-2) = DMYKAN;
  747.         *(vp-3) |= 0x40;
  748.         SEGSET(vp,KVRAM);
  749.         *(vp-4) = ch >> 8;
  750.         *(vp-3) = ch;
  751.         SEGSET(vp,CVRAM);
  752.     }
  753.     }
  754. }
  755. void    VDB_20(reg)    /* 背景色の読み取り */
  756. register struct _REGSET far *reg;
  757. {
  758.     U_DX = BAKCOL;
  759. }
  760. void    BIOS_91(reg)
  761. register struct _REGSET far *reg;
  762. {
  763.     int     cmd;
  764.     static void (*VDB_table[])()={
  765.     VDB_00,    VDB_01,    VDB_02,    VDB_03,    VDB_04,    VDB_05,    VDB_06,    VDB_07,
  766.     VDB_08,    VDB_09,    VDB_0A,    VDB_0B,    VDB_0C,    VDB_0D,    VDB_0E,    VDB_0F,
  767.     VDB_10,    VDB_11,    VDB_12,    VDB_13,    VDB_14,    VDB_15,    VDB_16,    VDB_17,
  768.     VDB_18,    VDB_19,    VDB_1A,    VDB_1B,    VDB_1C,    VDB_1D,    VDB_1E,    VDB_1F,
  769.     VDB_20 };
  770.  
  771. /*    Act_Dsp = TRUE;    */
  772.     if ( (cmd = U_AH) <= 0x20 ) {
  773.     U_AH = 0;
  774.     U_CF &= 0xFFFE;
  775.     (*VDB_table[cmd])(reg);
  776.     } else {
  777.         U_AH = 0x01;
  778.         U_CF |= 0x0001;
  779.     }
  780. /*    Act_Dsp = FALSE; */
  781. }
  782.