





                         9.  EGA  VGA



                           EGA
                        ﬠ   ࠭
                         祪
                        ⥭ ⮢ 
                        ⮢  EGA
                         横᪮ ᤢ 
                         ⮡ࠦ 256 梥⮢ VGA
                        祭





             ᮢ襭⢮ ᪨  (EGA)     
         ᪠  (VGA) । ࠧࠡ稪 ⢥-
           ᢮ த .  EGA ⠭ ࠤ樮 ᪮
         ⮩   MS-DOS.    ,   ᮢ襭
         ࠧ ᪨ ⠭ প EGA:

             1. ᪨ ०, ᮢ⨬  CGA.
             2.    ᪨ ० EGA  200- 梥
                ஢.
             3.  ᪨ ० EGA  350- 梥 -
                ஢.
             4.   ᪨ ० EGA  ᯮ짮  ஬-
                묨 (⥪⮢묨) ࠬ.

               㪠 ०, VGA ন  ᪮쪮
         .    ⮩   ᬠਢ 楯樨 ணࠬ஢
           ᪮ ० EGA,  ⠪  ० VGA.
          墠뢠 ᮢ⨬  CGA ⥪⮢  ᪨ ०,
         ⠪    ਥ   CGA.
             ਣ쭠   EGA  IBM 㯠  64 ᪮
         .     ७  256.    EGA,
         ⥬  ᪨  .  EGA-ᮢ⨬ 
         㣨 ந⥫ 筮 㯠  㦥  ⠭묨 256
         .    VGA   設⢥  ᮭ 
         IBM System 2 祭  ꥤ⥫ ;   㣨  VGA
         㯭  ⢥  ७.    砥 VGA ᥣ
         㤥  ⠭묨 256 .
             㭪樨    IBM  PC 뢠 뢠 BIOS
         10h.  㭪樨  ணࠬ ⠭ ⥪⮢
           ᪨  ०,  뢠      窨
            ᨬ  ࠭.  EGA   BIOS,
            ਣ 㭪樨 ᮭ쭮 -
            ᪮쪮 .  㭪樨 EGA  ।-
           ᨬ,   ࠢ ன  뢮  
         ⥪⮢ ப.


                                      - 9-2 -

                               EGA

              EGA ᮧ  ࠡ  ६ ࠧ묨 ⨯ -
         ஢: 梥 ᯫ IBM, ᮢ襭⢮ 梥 ᯫ
         IBM  ஬ ᯫ IBM,   ⠪  묨 -
         ﬨ 㣨 ந⥫.  筮,  ⨯ ᯮ㥬 
         ।  ᪮ ࠧ襭,  ᨬ쭮 ⢮ 梥-
         ⮢, 梥⮢   ᫮ ⮢ , ⠢饥 -
          ᨬ.   VGA  ᯮ짮  梥  -
         ஬  ஬.   ᬮ    ,    
          㭪樮쭮 ⫨砥  ஢ ( ) ,
         ணࠬ  ᬠਢ   ஢   -
          ࠧ饩 ᯮᮡ.   ⮫쪮   
         , 梥⭮   ஬.
             ⭮   IBM    ᨬ ࠧ ᯮᮡ-
          640  200 ⮢ ࠦ.  ⭮  ࠭祭
         200  ⨪묨  ப  ࠧ⪨  ⮣,    
         ਬ ⮫쪮  ⨪  ᪠஢.   -
         짮    梥  ஬  EGA ᮢ⨬  ᥬ
         ⥪⮢  ᪨ ० 梥⭮ ᪮  -
         .    ᪨ ०,  ० 13  14, ᯮ 
         16 梥⮢  ࠧ襭 320  200  640    200.      ,
         梥⭮   ࠭稢 16-梥⭮ 䨪஢ ன
          200- ⨪묨 ﬨ ࠧ⪨.  ஢  
         ᯮ   16 梥⮢,   CGA  ⥪⮢ ०. ᯮ-
         㥬  㬮砭 אַ㣮쭨    樨  ᨬ  
         ࠧ 8  8 ⮢ ࠦ.  ० ᫥  ⠡-
          9-1.
                                                          9-1
                     ᯮ짮 EGA c 梥 ஬ IBM
         
         -       -     - - -
                   쭮(⮫ אַ- 쭮 襭
         -          ᫮          㣮- ᫮  - 
                  梥⮢  ப)    ࠭࠳
         
          0        16    4025    88   8      800 320200
          1        16    4025    88   8      800 320200
          2        16    8025    88   4/8/8* 800 640200
          3        16    8025    88   4/8/8* 800 640200
          4   䨪    4    4025    88   1      800 320200
          5   䨪    4    4025    88   1      800 320200
          6   䨪    2    8025    88   1      800 640200
         13   䨪   16    4025    88   2/4/8* 000 320200
         14   䨪   16    8025    88   1/2/4* 000 640200
         
         (*) -   ꥬ ⠭  EGA


                      ᮢ襭⢮ ᪨ ᯫ

             ᮢ襭⢮ ᪨ ᯫ   IBM  ᮢ⨬
           ᥬ ० 梥⭮ ᯫ  ᯮ   ० 
         ᮪  ࠧ饩  ᯮᮡ.  ᮢ襭⢮  梥⭮
         ᯫ ᯮᮡ ਬ  ⨪  ᪠஢,
           200- ०      350-  ०.

                                      - 9-3 -
         ஬  ⠭ ⨪  ᪠஢,  -
         㥬 EGA,    ᨭ஭樥  ᯮ짮 
           ᮪      祭  ᮪ ࠧ饩
         ᯮᮡ.   ᮪ ࠧ襭 - ० 16,   ਬ-
          ⮫쪮  ᮢ襭⢮ 梥 ᯫ IBM, -
          ஬  ஬  ᨭ஭樥,  ⠪  
         ⨪쭮 ࠧ襭  祭 350 ப,  梥⭮ -
           ⮡ࠦ ⮫쪮 200 ப.
              ᯮ짮    ᮢ襭⢮ 梥 ஬ 
         設⢥ ० EGA  ⮡ࠦ 16 梥⮢   64-梥⭮
         . 16 梥⮢ 㯭 ⮫쪮  ० 16  ⮬ 砥, ᫨
          EGA   64 .    4   6,  ᪨
         ०,  ᮢ⨬  CGA, ࠭祭 ⮩  16-梥⭮ 䨪-
          ன,   CGA. ⮢ ० ᮢ襭⢮
         梥⭮ ᯫ ᯮ 814 ⮢ ࠦ  
         ᨬ,   ᨬ   ᮪ ࠧ饩 ᯮᮡ,
         祬 ᨬ, 㥬  ० CGA.  ᮢ襭⢮
         梥⭮  ᯫ  (  ᨭ஭樮 ⮢) -
         ᫥  ⠡ 9-2.

                                                          9-2
                      ᯮ짮 EGA c ᮢ襭⢮
               ஬ IBM ( ஬  ᨭ஭樥)
         
         -       -     - - -
                   쭮(⮫ אַ- 쭮 襭
         -          ᫮          㣮- ᫮  -  
                  梥⮢  ப)    ࠭ 
         
          0        16    4025   814   8      800 320350
                       64                              
          1        16    4025   814   8      800 320350
                       64                              
          2        16    8025   814   4/8/8* 800 640350
                       64                              
          3        16    8025   814   4/8/8* 800 640350
                       64                              
          4   䨪    4    4025   88    1      800 320200
          5   䨪    4    4025   88    1      800 320200
          6   䨪    2    8025   88    1      800 640200
         13   䨪   16    4025   88    2/4/8* 000 320200
                       64                              
         14   䨪   16    8025   88    1/2/4* 000 640200
                       64                              
         16   䨪  4/16   8025   814   1/2*   000 640350
                       64*                             
         
         (*) -   ꥬ ⠭  EGA.

                          ஬ ᪨ ०

             ஬ ᯫ  IBM ᯮ  ᭮ ⮫쪮  -
         ⢥ ⥪⮢ ᯫ.  ⮢ ० ᮢ⨬  ஬-
          ஬ IBM.   ,   ०,  -
          䨪  ࠧ饩  ᯮᮡ  640350    
         "梥⠬": , , 騬   ⥭ᨢ -
         .  ᫨ ஬  祭  EGA,   EGA   

                                      - 9-4 -
         ᯮ짮       ᢮ 梥 ᪨ ०,  
         ᯮᮡ ਬ  ஬ ᪨ ०.
             EGA ८ࠧ  814,  ᯮ㥬  ७ 梥-
          ஬  MDA-ᮢ⨬  914.   ⨣ -
         ७  ᨬ,  ନ ப,    ⮣
          ࠦ.   ⠩ 祭 EGA   ஬
            祭 VGA   ஬ .
         VGA  ⮬ 砥 ࠪ  祭  梥⭮ 
          ᮪ ࠧ襭   ஢ ஬   -
         ᨬ  ⠭ ४⥫ VGA.
              讥   ⠭⭮ MDA ० 7,  ⥪-
           ०,   EGA.    砥   -
         쪨 ࠭. ਣ ஬  ᯮ
         ⮫쪮  ࠭. EGA  ࠭  8 ⤥ -
            ᨬ  ꥬ  EGA.   ࠭ ।-
           ॣ  ய 8086  ᯮ짮 ⥪-
          㭪権 BIOS.   ஥ ணࠬ ᯥ祭 ᯮ
         ॣ   㣨   ௨ 㤠    ⪥  
         樠樨,  ⮬  ⥫ ⥪    
         㦭 ࠭.
             EGA-ᮢ⨬   ந⥫   ।
         Hercules-ᮢ⨬  ᪨  ०  ᯮ짮  -
         ஬ ᯫ.  ०  ஬ ᯫ ਢ 
         ⠡ 9-3.

                                                          9-3
                     ᯮ짮 EGA c ஬ ஬
         
         -       -     - - -
                   쭮(⮫ אַ- 쭮 襭
         -          ᫮          㣮- ᫮  -  
                  梥⮢  ப)    ࠭ 
         
          7        4     8025   914   4/8*   000 720350
         15   䨪   4     8025   814   1/2*   000 640350
         
         (*) -   ꥬ ⠭  EGA

              ᯮ짮  VGA IBM  ।⠢    ஬,
         ⠪  梥  . VGA  ⠭ ⠪ -
         ࠧ,     ࠪ⮢     ஢
         ஬       ஢ 梥⭮ .  㣨
         ᫮, VGA   ⠭ ⠪,    ࠪ⮢
         梥⭮      ஢ ஬ ,  
         ஬    ஢ ஬  
         ᮪ ࠧ饩 ᯮᮡ.     
         ⭮ ᮢ⨬  EGA ,   ⠭  ࠡ    -
         ⢥ EGA  ஬ ஬, ᢮⢠ VGA  ⫨ 
         ᢮ EGA  祭 ஬ ⥪⮢ ஬.
             ணࠬ ᠬ஢   祭 ⠭ ࠨ
          VGA  ࠡ ᫥ 㧪  ᮭ쭮    
         ⢥  ஬ ,  梥⭮ . -
          ⠭  ⢥ ஬  㯭 ⮫쪮 -
         ०, ᫥  ⠡ 9-3. ᫥ ⠭  -
          梥⭮  㯭 ०, 㪠  ⠡. 9-4.


                                      - 9-5 -
                                                          9-4
                                VGA,
                       䨣஢  梥⭮ ०
         
         -          -     - - -
                쭮(⮫ אַ- 쭮 襭
         -          ᫮          㣮- ᫮  - 
                  梥⮢  ப)    ࠭࠳
         
          0        16    4025   916     8    800 360400
                      256                            
          1        16    4025   916     8    800 360400
                      256                            
          2        16    8025   916     8    800 720400
                      256                            
          3        16    8025   916     8    800 720400
                      256                            
          4   䨪    4    4025   88      1    800 320200
          5   䨪    4    4025   88      1    800 320200
          6   䨪    2    8025   88      1    800 640200
         13   䨪   16    4025   88      8    000 320200
                      256                            
         14   䨪   16    8025   88      4    000 640200
                      256                            
         16   䨪   16    8025   814     2    000 640350
                      256                            
         17   䨪    2    8030   816     1    000 640480
                      256                            
         18   䨪   16    8030   816     1    000 640480
                      256                            
         19   䨪   256   4025   88      1    000 320200
                      256                            
         


                    ࠦ  ⠭  ஢ઠ 

              EGA   ⨯   ꥬ    
          EGA.   ।,  ० ᯮ짮
          䨪  ⥪,   ꥬ  EGA । ᫮  -
         㯭 梥⮢  ࠭.    ணࠬ 祭  㧭,
            ᮭ쭮   稨 EGA,   ⮣, 
          ⠥  ᯮ짮,  ⠪ ⨯ ਬ塞 
          ꥬ 㯭 .     ணࠬ,  ਢ  
         ⨭ 9-1.   040:087 ८ࠧ ଠ  䨣-
         樨 EGA,    .        ⮢
         ﭨ,   EGA BIOS ᮤন  ७ ᯮ짮-
           ᯥ祭 ணࠬ 室  ଠ樥.
              㥬  ⠬ 5  6,   뢠  -
          EGA;  ⮬ 3,   뢠,   EGA ⨢
         ᯫ;   ⮬ 1,  㪠뢠 ⨯ ᯮ㥬 -
         .
             㭪 ⠪  뢠    맮 BIOS EGA,  -
         ୠ⨢ 㭪 10,   頥 ଠ  EGA.  EGA
         뢠  饭  012  ॣ   010  ॣ BL,  
         ⠪ ᯮ짮 뢠 10h. 맮 EGA BIOS ᮤন ᫥-
          ଠ:

                                      - 9-6 -

                           頥 ଠ  EGA

             :  Int 0x10
             뢠: AH = 012
                          롮 ୠ⨢ 㭪権 EGA
                         BL = 0x10
                         ୠ⨢ 㭪  ଠ樨 EGA
             頥: BH =  0 = ⭮ 
                               1 = ஬ 
                         BL =  ஢  EGA:
                               0 = 64
                               1 = 128
                               2 = 192
                               3 = 256
                          =   ਧ
                         CL =  ⠭ ४⥫  EGA

               BIOS ᮭ쭮     ᯮ  -
         㭪  012,   맮   ᯮ짮  ⢥ -
         ન  EGA.  BIOS ᮭ쭮  ᯮ ⪫-
            ⭮    뢠  10h        ﭨ
         ॣ஢.   ࠧ,  ᫨ 室騥 ॣ  
         맮  室騥 ॣ  ᮮ⢥    -
         ଠ樨 EGA,  EGA . ᫨ EGA   稨,
           ⨯ ᯮ㥬  । 뢠 
         ⠭ ४⥫.   ।,   짮⥫
         ࠢ쭮  ⠭  ४⥫     ᮮ⢥
         ⨯ .
             ᫥ 㦥  EGA  㭪 ஢ ஢ ⥬
          稥  VGA. 設⢮ ॣ஢ EGA ⮫쪮 뢠-
         ,    ६   VGA   뢠묨/뢠-
         .  ⠭  । 祭  ⥬ -
           ⪠      祭.  ᫨  ⠭    
         ᮮ⢥ ᠭ,     - EGA,  ⨢
         砥 - VGA. ᯮ㥬 ॣ  ॣ஬ ᪨ ,
           㤥 ⠫쭮 ᬮ७.
             ணࠬ EGACHECK.C,  ਢ  ⨭ 9-1,  믮
         ஢ ⨢  EGA. ( ⥬  ⢮ -
          ᯫ . ᫨ ⨢ 㣠 ,   3  0
         40:087 㤥  祭 1). ᫨ 㦥 ⨢  
         EGA,  ࠭ ଠ  ⠭.
             ப PEEK_BYTE(seg,off),  ।⠢    ⨭
         9-1,  롨      ᮭ쭮
         .  ப ࠡ⠥ ⥬ ᤢ 祭 ᥣ
              ᫮ (16 )  ᫥騬 ᪨ ᫮
          ᬥ饭  ନ஢  뢠.   뢠-
          ⥬ 뢠  㪠⥫ far.

                         ⨭ 9-1. ணࠬ EGACHECK.C

         ----------------------------------------------------------------

         /* egacheck.c */
         /* ஢ 稥  EGA  VGA */
         /*  宦   , ଠ ࠭ */
         #include <conio.h>

                                      - 9-7 -
         #include <dos.h>
         #include <stdio.h>

         #define PEEK_BYTE(seg,off) \
              (*(char far *) ( (long)(seg)<<16 | (off) ) )

         struct Ega_info     /*  ࠭ ଠ樨  EGA */
         {
           char card ;       /*  ࠭ ⨯  */
           char monitor ;    /*  ࠭ ⨯  */
           int memory ;      /* ꥬ : 64, 128, 192, 256 */
           char high_res_graphics ;
           char text_mode ;
         }  ;

         int get_ega_info(struct Ega_info *) ;

         main()
         {
         struct Ega_info info ;

         if(get_ega_info(&info))   /*   稥 EGA */
          {
          if(info.card == 'E')
            {
            printf("\n\nᯮ EGA.") ;
            printf("\n祭 ") ;
            switch(info.monit)
            {
              case 'C': puts(" 梥⭮ ") ;
                        break ;
              case 'M': puts(" ஬ ") ;
                        break ;
              case 'H': puts("ᮢ襭⢮ 梥⭮ ");
                        break ;
              default:  break ;  /*  । */
            }
            printf("n\%K   EGA.", info.memory);
            }
            else
               printf("\n\nᯮ VGA.") ;
            printf("\n %#2i - 䨪  ᮪ ࠧ襭.",
                  (int)info.high_res_graphics) ;
            printf("\n %#2i - ⥪⮢ ०.\n\n",
                  (int)info.text_mode) ;
          }
         else
          puts("\n ⨢ EGA.") ;
         }                               /*  main() */


         int get_ega_info(info)
         struct Ega_info *info ;

         /*  㭪 ஢,    ⥬ ⨢ EGA */
         {
         union REGS regs ;

                                      - 9-8 -
         int i, test_mask = 1 ;
         /* ਭ  ଠ樨 EGA    BIOS */
            char bios_info = PEEK_BYTE(0x40,0x87) ;

            /*  3 뢠, ⨢ EGA  
             * ᫨ ,  ஢ 稥 */
            if(bios_info & 0x8)
               return (0) ; /* ᫨  3 = 1, EGA  ⨢ */

            regs.h.ah = 0x12 ; /* ୠ⨢ 㭪 BIOS EGA */
            regs.h.bl = 0x10 ; /*  ଠ */
            regs.h.bh = 0xFF ; /*   祭 */
            int86(0x10, &regs, &regs) ; /*  맮 EGA BIOS */

         /* bios_info  5 + 6  BL(஢  EGA)  */
         /* bios_info  1     ࠢ  EGA */
         if((regs.h.bl != ((bios_info & 0x60) >> 5 || /*  */
            (regs.h.bh != ((bios_info & 0x2) >> 1  || /*  */
            (regs.h.bh == 0xFF))            /*   */
           /* EGA , ࠭ ⨯  */
           /*  ⨯ :
                'C'  梥⭮,
                'M'  ஬,
                'H'  hercules */
          switch(regs.h.cl) /* cl  ⠭ ४⥫ EGA */
          {
             case 0: /* ࢮ砫쭮 , EGA 梥⭮ 4025 */
             case 6: /*  ன, EGA 梥⭮ 4025 */
                    info->monitor = 'C' ;
                    info->high_res_graphics = 0xD ;
                    info->text_mode = 0x1 ;
                    break ;
             case 1:  /* ࢮ砫쭮 , EGA 梥⭮ 8025 */
             case 2:  /*  ,  1 */
             case 7:  /*  ன, EGA 梥⭮ 8025 */
             case 8:  /*  ,  7 */
                    info->monitor = 'C' ;
                    info->high_res_graphics = 0xD ;
                    info->text_mode = 0x3 ;
                    break ;
             case 3: /* ࢮ砫쭮 , EGA  ᮪ ࠧ襭 */
             case 9: /* ᭠砫 EGA  ᮪ ࠧ襭, ⮬  */
                    info->monitor = 'H' ;
                    info->high_res_graphics = 0x10 ;
                    info->text_mode = 0x3 ;
                    break ;
             case 4:  /* ᭠砫 40 梥⭮, EGA  */
             case 5:  /* ᭠砫 80 梥⭮, EGA  */
             case 10: /* ᭠砫 EGA , ⥬ 40 梥⭮ */
             case 11: /* ᭠砫 EGA , ⥬ 80 梥⭮ */
                    info->monitor = 'M' ;
                    info->high_res_graphics = 0xF ;
                    info->text_mode = 0x7 ;
                    break ;
             default: /* १ࢨ஢ ⠭ ४⥫ */
             return (0) ;
          }

                                      - 9-9 -
          info->memory = 64 * (regs.h.bl + 1) ;

          /*  EGA  VGA: */
          /*  믮 ।⢮  祭  ⮫쪮
             뢠 ॣ  EGA,  뢠/뢠
              VGA */
         outp(0x3CE, 8) ;         /* ᪠  EGA/VGA */
         outp(0x3CF, test_mask) ; /* ࠢ 祭  */
         outp(0x3CE, 8) ;         /* ᭮ ᪠  */
         if(inp(0x3CF) == test_mask)
            {
            info->card = 'V' ;    /* ॣ   */
            if(info->monitor != 'M')
               {
               info->high_res_graphics = 0x12 ;
               info->text_mode = 0x3 ;
               }
            /* ᫨ 祭  ஬,  祭 㦥
             * ⠭.
             */
            }
         else
            info->card = 'E' ; /* EGA */
         outp(0x3CE, 8) ;      /*    */
         outp(0x3CF, 0xFF) ;
         /*  ⮩ ⥬ ⨢ EGA/VGA,   */
         return(info->memory) ;
         }
         ---------------------------------------------------------------

                䠩,  ega.h,   -
           ⨯  㭪樨 get_ega_info()  ᪥  Ega_info.
          㭪  ᪥  ᯮ짮  ᫥ ਬ.
               ,   ०  ᯮ짮  䨪 
          ࠧ -  ᯫ.  EGA BIOS,  ⠪    
         BIOS  ᮭ쭮   맮 Write Dot ( -
         ).   맮 ࠡ⠥ ,  祭    -
         ᪨  IBM.   ࠪ⨪ 맮 EGA BIOS
         Write Dot:

             Write Dot

             :  Int 0x10

             뢠:  =  0  롮 㭪樨 Write Dot
                         BH =  ࠭
                         DX =   ப
                          =   ⮫
                         AL =  祭 梥

             頥: 祣

                    ࠭. ᫨ 
         ८ࠧ  ஥ ணࠬ ᯥ祭  ࠡ  EGA, 
         㡥,   ࠭ 室   । 맮 -
           10h.  ணࠬ,  ᠭ  ஬  

                                      - 9-10 -
         CGA  ᪮ ०,   ⢨⥫  ⮬  -
         .
             맮 BIOS  ४祭  ᪨ ०  筮  ⠪
         ,    㭪 0 뢠 10h ᮭ쭮 . 
          , BIOS  믮 ஢  । ⮣,  ।
          ࠭  ०  . ஬ , -
         祭  EGA,   ० ᨣ ० 梥⭮ ⥪-
           䨪,  ⮬  ஢ ᮢ⨬  
         ० ࠡ.   ணࠬ 9-1 㭪  get_ega_info(&info)  -
             ஢ન   宦 ᭮  -
         짮 ० ࠡ    ᮪  ࠧ饩  ᯮᮡ.
         ணࠬ, ।⠢  ⨭ 9-2,  ᯮ짮-
          㭪樨 set_crt_mode()  ⠭ ᪮  ० 
         ᯮ짮  dot(),    ਬ 㭪 BIOS Write Dot.
          ணࠬ   ࠫ  .

                         ⨭ 9-2. ணࠬ DIAGONAL.C
         ---------------------------------------------------------------

         /* diagonal.c */
         /*  ᪨ ०  ᮪ ࠧ襭 */
         #include <conio.h>
         #include <dos.h>
         #include <stdio.h>

         void set_crt_mode( char ) ;   /*    "ega.h" */
         void dot( int, int, int, int ) ;

         main()
         {
           registr i,j ;
           struct Ega_info info ;
           if(get_ega_info(&info))
              set_crt_mode(info.high_res_graphics);
           else
              return(1) ;

           for(j = 0; j <= 500; j += 5)
           for(i = 0; i <= 100; ++i)
               dot(i,i+j,13,0) ;
           getch() ;   /*  ᨬ,   ࠧ */
           set_crt_mode(info.text_mode) ;
           return(0) ;
         }

         /*==========================================================*/
         void dot(row,col,color,page)
         int row, col, color, page;
         {
            union REGS regs ;
            regs.x.dx = row ;
            regs.x.cx = col ;
            regs.h.al = (char)color ;
            regs.h.ah = (char)0xC ;      /* 맮 Write Dot */
            regs.h.bh = (char)page ;
            int86(0x10, &regs, &regs) ;
         }

                                      - 9-11 -

         /*==========================================================*/
         void set_crt_mode(mode)
         char mode ;
         {
           union REGS regs ;
           regs.h.al = mode ;         /* al = ⠭ ० */
           regs.h.ah = (char)0 ;      /* 㭪 "⠭ ०" */
           int86(0x10, &regs, &regs); /*믮 뢠 BIOS 10h*/
         }
         /*==========================================================*/

         ---------------------------------------------------------------


              ⮫쪮  㢨,     ࠡ⠥  㭪  BIOS
         Write Dot,  ,  ⭮, ,   ᪮  ࠡ.
          ⮣ ॡ 室 EGA BIOS    饭  ⮢
         ࠦ ।⢥   EGA.    ,  ᭠砫
           ,   ࠧ ࣠  EGA,    ,
            ࠢ.


                                ࣠ 

              䨪 EGA ᯮ  ࠧ  ᯮᮡ ࣠樨
          ᯫ.   ०  4  6 EGA ᯮ ⠪  ࣠-
          ,    CGA.   ० ᥣ  ᯫ
         稭  0800  ᯮ 80 ⮢   ப ᪠-
         ஢ ( ࠧ⪨).    ࠧ⪨ 200, ᯮ-
           16,000  ⮢.    ०  । ࠧ饩 ᯮᮡ
         320200,    ।⠢ 4  ࠦ  
           梥⮢,       ࠦ.  ०
         6   ।⠢ 8 ⮢ ࠦ   梥-
         ,       ࠦ. ᫨   祭
         0,   ᮮ⢥騩  ࠦ 몫祭.  ஬ ⮣,
           ࠧ⪨ ᯮ   8 ᯫ ,
               8 .    
         ࠧ⪨ ॡ ஢  ᬥ饭   -
           । ⮣, ⭮   ⭮.
             ᯫ   ०  13  16 ( ० 18 VGA) -
           ᥣ 0000  ᯮ  64 ᭮ ࠭-
         ⢠  業ࠫ쭮    8086.    ।⠢ 8
         ⮢ ࠦ,  祬 ᠬ 稬  ᯮ -
          ᫥.   ࠧ⪨  ࠧ  ,    ०
         CGA, ⮬ ᬥ饭   ࠦ   ᫥-
         .    ० 16 EGA  ᨬ ࠧ ᯮᮡ
         640  350,   224,000 ⮢ ࠦ.    
         16 梥⮢,    ࠦ  ᯮ짮 4 
          । 梥.      ⠢  ᯮ짮
         饩 , ࠢ (640  350 ⮢ ࠦ / 8 -
         ⮢ ࠦ    4    ࠦ) 109.
             ࠫ    8086,   ਬ塞    ᮭ쭮
          ,   ᮢ뢠 ⮫쪮    ᥣ  ꥬ
         64.  EGA ᯮᠡ  64 ᥣ⭮ । ⥬ -
          128   256    ⮢  ꥬ 32.
           ⮢  ( ⮢ ᨢ) ᮮ⢥ 

                                      - 9-12 -
          梥  ࠦ.  ।⠢,      ⮢
           ᫮   㣠    業ࠫ쭮 -
         .      ᯫ   ॠ쭮  ।⠢
         4   EGA.
              ० VGA 17  18 ࣠  EGA   -
           ᫥騥 130  ࠧ⪨. VGA  ० ࠧ襭
         320  200  256 梥⠬.    ० 㤥  ᬮ७  -
         쭮.

                                 -饫

             ⥭   4 ࠧ ⮢ (   -
          )     業ࠫ쭮    
         ஡.   ८ EGA    ॣ-饫.
         -饫 EGA ६ ࠭ 1      -
           ⮢  .  ᪠ 奬 EGA   
          ॣ஢-饫 ⮬  ⮢    -
         ,  業ࠫ  ⠫ ᫥.    業-
         ࠫ   뫠   ᫥ ⠭ ,
         ᮤঠ    ॣ஢     -
         ,  ஢      묨 業-
         ࠫ쭮 .  ঠ ॣ-饫  ⥬  
         ⭮    ⮢  EGA.
             ᫥ ⭮   ᮤঠ ॣ஢-饫  ⮢
          EGA,  ॣ ᭮ "᪫",  ࠭    
               ⮢,  ନ 4-⮢ 梥  쬨
         ⮢ ࠦ. ⭮襭   ॣࠬ-饫-
           ⮢묨 栬 ந஢  㭪 9-1, 
          ﭨ  EGA  ᮤঠ  ॣ஢
         -饫 ᫥ 뢠 業ࠫ ஬   
         000:0000.  ᥬ ⮢ ࠦ   ᮤঠ 梥 
         0  7.
              ,   , 饭 業ࠫ ஬
         ᫥ ⥭ 000:0000,  ᯮ.   ⮫쪮 ⠥-
           ⠭ ⮣,    ⠬ ࠦ  ࠡ-
          (  砥,   ࠦ  0  7  ப 0)
           "⮢" ॣ஢-饫,      業-
         ࠫ쭮   㫨஢  ⤥묨  ⠬  ⮢
         .       業ࠫ쭮    ᮭ쭮
          ஢,     ᥬ ⮢
         ࠦ,  ᮤঠ   .  ࠡ  -
         ⠬ ࠦ  㣮 ப  ⮫, ந室 ᬥ饭
           A000  業ࠫ  뢠  ,  ᮤঠ騩
          ࠦ.
             ⠭ ᪮쪨  ࠢ ॣ஢ EGA   ,
          業ࠫ    ,    ⠢
         묨 ॣ-饫.   ⨬ ॣࠬ ⢫-
          ।⢮    ஢ 稯  ᢥ塮-
           ⥣ࠫ 奬 ()   EGA.  ⠭ 稯 
         ந室 ࠢ  ,  ᮮ⢥饣 -
          㭪樨,   ७ ॣ஢ EGA,  ᫥饩 
         ஬ ଠ樥  ⮩ 㭪樨.  ⢥ ,  
         ᮮ⢥    ७ ॣ஢ EGA,   
         ॣ 易  ⢥ ⮬ 뢮 ᮭ쭮  -
         .     ॣ஢ ࠢ   

                                      - 9-13 -
                    Ŀ   
                    00000000 ⮢     
                      3       - 饫
                  Ŀ        Ŀ
                  00001111 ⮢           00000000 3
                    2        
                Ŀ          Ŀ
                00110011 ⮢           00001111 2
                  1          
              Ŀ          Ŀ
     A000:000001010101 ⮢            00110011 1
                0           
                                                   Ŀ
                                                    01010101 0
                                                   
                                                      樨 ᥫ
                       


                  .9-1. ⮢   ॣ-饫 EGA


         OUT  8086  筮 㭪樨 몠  outp().
             ਬ, EGA   ॣ ⮢ ᪨,   頥
           ⤥  ॣ஢-饫.  ⠭   ⮬
         ॣ   0 ᪨ ᮮ⢥騩   ॣ-饫-
         ,   ⠭  1 ࠧ蠥      業-
         ࠫ ஬.  ஬ ⮣, ॣ ⮢ ᪨ 
          ⤥   ࠦ      ᬥ
         ⮢ ࠦ, 㥬 ⮬.
              ⮢ ᪨   㭪樨 8  ᪮ -
           1   2 EGA.   ணࠬ ࠢ  8  
         03   ᪨    0CF.  騥  몠
          ⠭  ॣ ᪨     ⮢, ஬ -
          2:

         outp(0x3CE, 8) ;      /*  ᪨  */
         outp(0x3CF, 0x2) ;    /*  , ஬ 2,  0 */

                ࠧ,   ஬ ஢
         ⮣,   .     ᬮਬ ப ,
           ன  ⠭ ॣ EGA.
              ॣ஬ EGA,  騬  १ ᮤঠ  -
         -饫,  ॣ ᪨ . ᫨   -
          ⮢ ⮣ ॣ 㫥,  ᮮ⢥騥 ⮢ -
           (⮢ ᨢ) 饭  .  ࠢ ᫠
          0  15  ॣ ᪨      ⮢  
         EGA 梥,  ᮮ⢥騩 ⮬ .   , ० -
         ঠ ⮢ ᨢ  ࠥ.       
         ।  ⠭   祭 梥 ᪨ ,   ᫥
         ⠭ ᪨ ,     , ᮤঠ騩 塞
           ࠦ.   ᪨    稯
         ஢騪 EGA.  㯥 ।⢮ ࠢ  2 
           034    ࠢ ᪨    035.  ﭨ
         ᪨   ᪨  ந஢  㭪 9-2.



                                      - 9-14 -




        Ŀ  Ŀ              Ŀ
     Ĵ1Ĵ  1     Ĵ  1      ⮢  
                         3
       Ŀ  Ŀ            Ŀ 
     Ĵ1Ĵ  1     Ĵ  1      ⮢   
                       2 
       Ŀ  Ŀ          Ŀ  
     Ĵ0Ĵ        Ĵ         ⮢    
                     1  
       Ŀ  Ŀ        Ŀ   
     Ĵ1Ĵ  1     Ĵ  1      ⮢    
                   0  
     Ŀ                                            
                 Ŀ                               
                 00100000                              
                                               
                 Ŀ    
                 11111111
                 

                  .9-2.  ⮢ ᪨  ᪨ 


                              ﬠ   ࠭

                ॣ  ᪨   ᪨ ,   ⠪  -
         -饫 EGA,   筮 ଠ樨  ᮧ
         ணࠬ  몥 ,     ।⢥  -
         ࠭ .  ணࠬ ࠡ⠥ ॥, 祬 筠 
         ணࠬ  BIOS    EGA.    ࠡ  8- ᮭ
         ஬ , EGA BIOS   ᯫ  祭 1 -
         㭤  2.56  窨 (2.56 祪/).  ணࠬ,  ।⠢ 
         ⨭ 9-3,  頥  ᯫ 7.55 祪/  - ᪮ -
         ⠥  185 業⮢.  ⪮  ,  fastdot()
          ࠡ ⮫쪮  ᪨ ० EGA,     ࠡ 
         㣮 ᯫ ⮩  室 ९ ணࠬ.
             騥 ப  ணࠬ 9-3 ⠭ -
           ,    ,    ⠪  㣨 ७ ॣ.
         #define EGA_GRFX(index, value) { outp(0X3CE, index) ; \
                                          outp(0x3CF, value) ;}
         #define EGA_SQNC(index, value) { outp(0X3C4, index) ; \
                                          outp(0x3C5, value) ;}

             ࢠ ப,  EGA_GRFX, ਭ  ⢥ 㬥-
         ⮢  ,  ᮮ⢥饣 㭪樨,  ࠭   稯
         ஫ 䨪 1  2,   ⠪  祭, ࠢ塞 稯.
         ᪨ 稯 1  2 EGA ࠢ 㯮  ⮢ ᨢ.
         (  ,   ॠ쭮 ।⠢ ᮡ  稯, ᯮ-
            ,       稯.)  
          ᪨ 稯 1  2 0x3CE,    0x3CF. -
         ப 墠뢠   몠 .    -
         뫠 稯 祭 ,  ன  뫠 .
               ப,  EGA_SQNC,  室   EGA_GRFG. ,

                                      - 9-15 -
         EGA_SQNC    㣮 稯, 稯 ஢騪 EGA, -
         ࠢ    ࠧ ⠬ 뢮.  訩 -
           稯 ஢騪 ।⠢ ॣ ᪨ .
              騥  ப  ணࠬ   
         ᥣ:ᬥ饭     ᭮ ࠭⢠ ᮭ-
          :

         #define PEEK_BYTE(s,o) (*(char far *) ( (long)(s)<<16 | (o) ))
         #define PEEK_WORD(s,o) (*(int far *) ( (long)(s)<<16 | (o) ))

             ⥫ ப  ।騥.  ப-
          GET_CRT_COLS() 頥 祭  ᯮ짮   -
         ⢥ ᫠ ⮢    ᪨ ० EGA.  ᫮ -
         ⮢   ࠢ  ᨬ  ,   ᫮  
         ᮬ   0x40:0x4A            BIOS.   ப
         EGA_BIT_MASK  EGA_MAP_MASK ⠭ ᮮ⢥⢥ ॣ
         ᪨   ᪨ .

         #define GET_CRT_COLS()   PEEK_WORD(0x40, 0x4A)
         #define EGA_BIT_MASK(mask)   EGA_GRFX(8, mask)
         #define EGA_MAP_MASK(mask)   EGA_SQNC(2, mask)
               ப  ⥭      
         ணࠬ,  ᠭ  㫨஢ 묨 ।⢠
         EGA.   ப  ᯮ   ணࠬ ⮩
         .
             設⢮ ॣ஢ EGA 㯭 ⮫쪮   . 
         ணࠬ, ᯮ ᯫ, 㦤  ଠ樨  -
          EGA, ⠪  ⮫쪮 뢠 ॣ  . -
         ⮬, ᠬ  ﭨ ॣ஢ EGA  -
          EGA BIOS,  ⠭  㬮砭.  ஬ ⮣,  EGA BIOS
         ।,    ᨬ  ᯫ ॣ EGA -
         室  ﭨ,  ⠭   㬮砭.  ᫨  ॣ
         ᪨  ⠭  ﭨ ᪨஢ ,  ᨬ 
         ⠥묨.   ᪨   ᪨  ﭨ, ⠭-
           㬮砭,   몫祭 ० ᪨஢, -
         ⮬,  ⠭  ᪨  0xF    0xFF    ᫥   ப
         fastdot() ⠭ ﭨ   㬮砭.  २⢮
         ॣ஢  VGA   ,    㯭   ⥭  
         .  (  EGA  VGA 뫨 ᯮ짮   ணࠬ
         EGACHECK.C    㦥    VGA.) ⮬,  ॣ VGA
           ⠢  ﭨ  㬮砭.
             ,   ,        ணࠬ,
         ਢ  ⨭ 9-3,    ࠦ:

         char far *rgen = (char far *)(0xA0000000L +
                          (col >> 3) +
                          (row * GET_CRT_COLS()) );

              ((ப    ப) + ⮫
         / 8   ).  楫 襭 ᪮    8
         ᯮ  ࠢ ᤢ 몠 , >>.

                         ⨭ 9-3. ணࠬ FASTDOT.C
         ---------------------------------------------------------------

         /* fastdot.c */
         #include <conio.h>

                                      - 9-16 -

         fasdot(row, col, color)
         /*  ணࠬ     ᯫ  EGA
         ** ᯮ짮 ⮫쪮  ᪨ ० EGA (13, 14, 15
         **  16)    EGA  128
         **   VGA  ० 13, 14, 15, 16, 17  18
         */
         int  row, col, color;
         {
         char latch ;
         /* ⠭  塞  */
         /*   = 000:((ப*⮢/ப)+⮫/8) */
           unsigned char far *rgen = (char far *)(0xA0000000L +
                                     (col >> 3)  +
                                     (row * GET_CRT_COLS()) ) ;
         /* ᫨ 塞 : */
           char bit_mask = (char)(0x80 >> (col & 7)) ;
           EGA_BIT_MASK(bit_mask) ;   /* ⠭   */
           latch = *(rgen) ;          /* ⮢ 饫 */
           *(rgen) = 0 ;              /*   */
           EGA_MAP_MASK(color) ;      /* ⠭ 梥 */
           *(rgen) = 0xFF ;           /* ⠭  */
           EGA_MAP_MASK(0xF) ;        /*    */
           EGA_BIT_MASK(0xFF) ;       /*    */
         }
         ---------------------------------------------------------------

          ⮣, ⮡ 㧭 ᫮   ப, 祭 ண -
           ࠢ 40 ⠬  ० 13  80 ⠬  ०
          14  16, ᬮ  祭 ᫠ ᨬ  ப  -
           BIOS ( 040:04).  ᫮   ப  ᫮
         ᨬ    ப  ᪨ ० EGA    .  -
          ᥣ ᫥   0xA0000000L,  ।⠢-
         騬 ᮡ ᥣ ᪨ ० EGA.   祭 ⥬
         뢠  㪠⥫ far.
                  ,  ᮮ⢥饬  塞  
         ࠦ,   (col~&~7).  ⮫쪮 㤥 ⥭
           ,  ᪠  ⠭  祭 080 >> 
          (080 -  010000000b).
             ।  ணࠬ ।,  ᯮ ࠭
         0.  ⮣, ⮡   樨  ࠭, -
         筮  0, ⠢ ᫥騥 ப:

         while(page){
          rgen += PEEK_WORD(0x40, 0x4C) ; /*   ࠭ */
          --page ;}

          page  -  㥬 ࠭.     040:04
         ᮤন     ᯫ ,  ᯮ㥬  -
         ணࠬ EGA BIOS.
             ⠩ ணࠬ, ਢ  ⨭ 9-2,  -
           dot  ஬ fastdot().   - ࠧ ॥, 祬
         ணࠬ BIOS.




                                      - 9-17 -
                                     祪

              ⨦ ᨬ쭮 ந⥫쭮 㭨 -
          । EGA 室   㭪権. ਬ,
         ணࠬ fastdot() ⠭      
         ॡ㥬 祭  砫,   ⥬   뢠   -
             ࢮ砫쭮  ﭨ BIOS.  ᫨ 㭪 뢠
         ணࠬ fastdot ⭮,  ॣ   fastdot
          易⥫쭮.   ࠡ 㭪樨.
             ணࠬ, ।⠢  ⨭ 9-4,  砥  ண-
         ࠬ  稢  ,  ᭮   ⬥ ᥭ.
           ࢮ砫쭮 ᯮ짮  ࠢ ஢-
          ࠬ,    ⠪ ਥ  ᯫ 䨪  -
         ⮢묨 栬.  ᥣ 㢥稢 ( 㬥蠥)
           1   ࠢ  X  Y.  롮 ࠢ X  Y -
         ⢫ 㢥祭  .  ᫨ ꥬ  (ࠢ
         Y)  ,    㢥稢  ( 㬥蠥) Y;  ᫨ ண
         (ࠢ X) ,   㢥稢  (  㬥蠥)  X.
         祭   㬥襭 X  Y 롨ࠥ ࠢ .
         ନ "ᮢ㯭 訡" ᯮ  㢥祭  㬥-
         襭  ௥୮ ࠢ.
              맮 ணࠬ fastdot(), 窨  -
         ।⢥    ࠭  ᯫ.   EGA 뢠 ⮫쪮
          ࠧ    㭪 ࠡ⠥ ࠧ ॥ 㭪樨,  -
           맮 fastdot().

                           ⨭ 9-4. ணࠬ BRES.C
         ---------------------------------------------------------------

         /* bres.c */
         /*     樨 㭪樨 line() */
         #include <conio.h>
         #include <dos.h>
         #include <stdio.h>
         #include "ega.h"
         void line(int, int, int, int, int); /*    ega.h */

         main()
         {
           int x1, y1, x2, y2 ;
           int step = 10, color = 13, scan_lines ;
           struct Ega_info info ;

           if(get_ega_info(&info) >= 128  /* ⨢ EGA? ? */
           {
             set_crt_mode(info.high_res_grahics) ;
             scan_lines = (PEEK_BYTE(0x40, 0x84) + 1)
                           * PEEK_WORD(0x40, 0x85) ;
             y2 = (scan_lines - 1) - ((scan_lines - 1) % step) ;
             for (y1 = 0, x1 = 0, x2 = 0;
                  y1 <= y2;
                  y1 += step, x2 += step)
                line(x1,y1,x2,y2,color) ;
             getchar() ;  /*    */
           set_crt_mode(info.text_mode);
           }
           else

                                      - 9-18 -
           puts("\n EGA  ⨢   ⠭.\n") ;
         }

         void line(x1,y1,x2,y2,color)
         int x1,y1,x2,y2,color ;
         /*  㭪  - ᯮ  ᥭ */
         /* न ப(Y)  ⮫殢(X)   ࠢ묨 */
         #define sign(x) (((x) < 0) ? (-1) : (1))
         #define qabs(x) (((x) < 0) ? -(x) : (x))
         {
         int dx = qabs(x2 - x1) ; /* ண */
         int dy = qabs(y2 - y1) ; /* ꥬ */
         int s1 = sign(x2 - x1) ; /*  㢥祭/㬥襭 */
         int s2 = sign(y2 - y1) ;
         int dx2, dy2, bytes_per_line = GET_CRT_COLS() ;
         registr error_term, i ;
         unsigned char far *rgen = (char far *)(0xA0000000L) ;
         unsigned char exchange = (char)0 ;

         /* 襥 祭 ꥬ  ண ।,
         **  㢥稢  横
         */
         if(dy > dx)
           { int temp = dx; dx = dy; dy = temp; exchange = (char)1; }

           dx2=(dx << 1); /* ᯮ짮 ୮, ᫨ ᥩ */
           dy2=(dy << 1);
           error_term=(dy - dx) << 1; /* 樠஢ error_term */
           EGA_GRFX(0, color) ;  /* ᯮ짮 ॣ  EGA
                                    ⠭/ */
           EGA_GRFX(1, 0xF) ;    /* ࠧ  ⮢ ᨢ */
           for (i=1; i<=dx; ++i) /*   ࠦ   */
           {
           EGA_BIT_MASK(0x80 >> (x1 & 7) ) ;
           rgen[ ((x1 >> 3) + (y1 * bytes_per_line)) ] += 0x1 ;
              while (error_term >= 0)  /* 横  ᫥饣  */
              {
               if (exchange)
                   x1 += s1 ;
               else
                   y1 += s2 ;
              error_term -= dx2 ;
              }
              if (exchange)
                   y1 += s2 ;
              else
                   x1 += s1 ;
              error_term += dy2 ;
           }
         EGA_GRFX(1, 0) ;   /*  ॣ ⠭/ */
         EGA_BIT_MASK(0xFF) ; /*    */
         }
         ---------------------------------------------------------------

              ࠭ ᪮ ࠧ  ࠭  ணࠬ  
               ਭ ᯫ   ࠦ.  ਭ
         ᯫ   ࠦ 㪠뢠   GET_CRT_COLS() x

                                      - 9-19 -
          8 ⮢/.    筮 ।  ⠡-
         , ᮤঠ饩 ⢮ ⨪  ࠧ⪨  -
          ०.  ,    ,    ᯮᮡ. 
         ᫮ ப ᨬ,  ࠧ 窨 (  ᨬ)  -
         ணࠬ஢, ஬ ⮣,     .  -
          אַ㣮쭨  ᨬ     ᫮  ப  ࠧ⪨
         ।  ⢮  ப.    ᫮  ᮬ 040:085
         ᮤন   ᨬ    ᮬ 0:400:84 ᮤন  -
         ⢮ ப,     ᯮ짮  ᫥ ᫠
         ப ࠧ⪨   ०.  몠 

         scan_lines = (PEEK_BYTE(0x40, 0x84) + 1)
                      * PEEK_WORD(0x40, 0x85) ;

          ਡ⥫쭮  祭 饣 ᫠  ࠧ⪨.
         祭  ਡ⥫쭮,  ⠪  ᫮ ப -
               ᥣ  1.   ⮫쪮 ⠭   EGA,
         ணࠬ   ,     ᯮ㥬
         ᪮ ० EGA.


                      ᯮ짮 ॣ ⠭/

              ணࠬ,  ।⠢  ⨭ 9-4,  㭪  line()
         ᯮ 㣮 ⮤ । 梥 祪  ᯫ, -
          ணࠬ fastdot().  ணࠬ fastdot() ਬ  
         ।  梥  ॣ ᪨ .     ⠪  ।
         ᪨  ॣ ᪨   頥 ।  , 
           窠    ᭠砫 襭   ⠭ -
          ᪨   0xF  ᫥饩 ⠭ 梥   
         窨.  㣨 ᫮,   ⠭ । 梥 窨
            ᪥ ,     EGA   ⢫
         .
             㭪 line() ᯮ ॣ ⠭/    -
         । 梥 ࠧ蠥 믮 ⠭/ ॣ. -
          ⠭/ ⠭    0xFF      ⮢
         ᨢ EGA,   ண  ⮬ ॣ ࠢ ,  -
            0   ⮢ ᨢ,   ண ࠢ  .
         ⥫쭮, ।饥 ᮤঠ ॣ஢-饫 
         ஬ 梥,  ᮮ⢥饣 祭,  ⠭   -
           ⠭/.   ᪨     -
          ⠭/,   ॣ ᪨    
         ᬥ ⮢ ࠦ.
             ⮡ ᯮ짮 ॣ ⠭/,  ᭠砫 -
           ࠧ    ॣ ࠧ襭 ⠭/.
          ⠭/   ॣ  ࠧ襭  ⠭/
            ᪮ ஫ EGA.  ﭨ BIOS 
         㬮砭  ॣ ࠧ襭 ⠭/  0,   -
         砥,   ॣ ⠭/ 몫祭.    -
         塨⮢  祭, ࠢ塞  ॣ  ࠧ襭  -
         /, ᮮ⢥ ⮢  EGA. ᫨     -
          ࠧ襭  ⠭/  0,  ᮮ⢥  ⮢
          饭   ॣ஬ ⠭/.
              ⠭/ 㯥 ࠢ    0  
           03  ᫥騬 ࠢ 塨⮢  梥
           0x3CF.   ⠭/ 뢠 ﭨ  ⮫쪮
           ⮢  ,  ࠧ襭  ॣ஬ ࠧ襭 ⠭-

                                      - 9-20 -
         /.  ࠧ襭 ⠭/ 㯥 ࠢ-
           1   03  ᫥騬 ࠢ 塨-
         ⮢ ᪨    0x3CF.
                 rgen[ ((x1 >> 3) + (y1 * bytes_
         per_line)) ]+@ 0x1 ;   ணࠬ 9-4. ᪮ ᯫ 
         EGA  ,        .  ࠦ
          ᪮  ᬥ饭  塞 .  -
         ,   ࠢ ஭  ਡ 1  ,  業-
         ࠫ   ⠥ த.     ,  ⢨-
         ⥫쭮    楫      ।࠭   ᬥ   ⮢
         ࠦ,  ᮤঠ  .    ᯮ  ॣ
         ᪨  ,  室 ᭠砫  ᯫ   -
          ॣ஢-饫 ⠪ ࠧ,  ⮡  㣨    
         ⮬   뫨 饭.   ⫨稥  ⮤ ⠭ 梥 
          ॣ ᪨ ,  ᯮ짮 ॣ ⠭
         / ,  뫠 業ࠫ ஬,  㦨 ⮫쪮
          ⠭  塞 .
              ࠧ,  ࠦ +=1 믮  㭪樨:  -
         뢠 ᯫ   楫  ⠭  ॣ஢-饫,  
         ⠪ 頥 ,  砥 ॣ ⠭/.
           ࠭樨 ஬ 몠   樨    
          8086 1  ਭ  祭, ஥ ᭠-
          뢠,  ⥬ ࠭   ᯫ  EGA.


                         ᯮ짮 ०  EGA

             EGA   ० : 0, 1  2.  ० -
           ॠ  । EGA  ࠢ 業ࠫ-
          ஬   ᯫ .  ०  -
         ⨬஢  ࠧ筮 ᯮ짮.   0 
         ०    饣 祭,  ०  1 ⨬஢
          ஢ ⥩  EGA  ०    2  訬
         ࠧ  ᯮ   訢.   ० 
          ⢥ ᪮ 믮 樨.
                0  ०,  ਬ塞 EGA BIOS.  
          騩 ० .  ० 0 梥  ࠦ
           ⠭    ॣ ᪨ , ⠪ 
         ॣ ⠭/.  ᪨  ᯮ EGA
         BIOS  ணࠬ fastdot().  㭪 line() ਬ ॣ
         ⠭/  । 梥.  ᯮ짮 ॣ-
           ᪨  ⤥  ࠦ   -
          뫠 業ࠫ ஬ ⮬  ᮮ⢥-
         騬 ⠬,  ⠭묨  1.    , ᬥ 
         ࠦ     饭   ॣ ᪨
         .    ਬ ॣ ⠭/  뫠
         業ࠫ ஬   ᮮ⢥ ⠬  -
         .  뢠 ⮫쪮  । ᬥ饭 -
           ⮢  ࠦ.    ।  ॣ -
         /,  ॣ ᪨   ࠢ ⤥묨
         ⠬ ࠦ.
                2  祭  宦   ०  0.   ० 2
         ,  뫠 業ࠫ ஬,  ᪮॥  ⠭
         梥, 祬 ⤥  ࠦ.  ᪨  -
          ࠢ ⤥묨 ⠬ ࠦ  ,  ᫨  -
           ᪨   ⠭,    ⮢ ࠦ
          梥⮬, 祭 ண 뫠 業ࠫ -

                                      - 9-21 -
         ஬.    ।   0  1 , ࠢ-
         塞 ॣ஬ ० ᪨ 稯 1  2.   ०
           5. ணࠬ, ਢ  ⨭ 9-5, -
          ०  2.  ணࠬ rect() ᯮ ० 2  
          אַ㣮쭨  梥⮬.

                           ⨭ 9-5. ணࠬ RECT.C
         ---------------------------------------------------------------

         /* rect.c */
         /*  ணࠬ  ०  2 */
         #include <conio.h>
         #include <dos.h>
         #include <stdio.h>
         #include "ega.h"

         void line(int,int,int,int,char); /*    ega.h */

         main()
         {
         int i,j;
         struct Ega_info info ;
         if(get_ega_info(&info))
            set_crt_mode(info.high_res_graphics) ;
         else
            return(1) ;
         printf("\n #:\n");
         for (i=0,j=0;i<16;++i,j+=40)
         {
            printf(" %2i  ",i);
            rect(50,j,349,j+39,(char)i);
         }
         getchar();
         set_crt-mode(3) ;
         }
         void rect(row1,col1,row2,col2,color)
         int col1,row1,col2,row2 ;
         char color ;
         { /*  㭪   אַ㣮쭨 */
           /* ।,  row1 < row2  col1 < col2 */
         unsigned char far *rgen = (char far *)(0xA0000000L) ;
         int rows = row2 - row1 ;  /* ᫮ ப */
         int cols = (col2 >> 3) - (col1 >> 3) - 1; /* ᥣ ⮫殢 */
         char left = (char)(0xFF >> (col1 & 7)) ;  /*  ᪠ */
         char rght = (char)~(0xFF >> (col2 & 7)) ; /* ࠢ ᪠ */
         char next_row ;
         char byte_per_line = (char)GET_CRT_COLS() ;
         register x,y ;
         char latch ;

         if (cols < 0)   /* 室  col1  col2   ? */
             left @= rght, cols = 0, rght = 0 ;
         rgen += bytes_per_line*row1 +(col1 >> 3) ;
         next_row = bytes_per_line - cols - 2 ;

         EGA_GRFX(5,2);               /* ⠭ ०  2 */
         for(y = 0 ; y < rows ; y++)  /* 믮  ப */

                                      - 9-22 -
         {
           EGA_BIT_MASK(left) ; /* ⠭    */
           latch = *(rgen) ;    /* 饫 ⮢  EGA */
           *(rgen++) = color ;  /* ⠭ 梥, 㪠 
                                   ᫥饣  */
           EGA_BIT_MASK(0xFF) ; /* ⬥  業 */
           for(x = 0; x < cols; x++)  /* 믮  ⮫ */
              {
                 latch = *(rgen) ;
                 *(rgen++) = color ;
              }
           EGA_BIT_MASK(rght) ; /* ⠭ ࠢ   */
           latch = *(rgen) ;    /* 饫 ⮢  EGA */
           *(rgen++) = color ;  /* ⠭ 梥 */
           rgen += next_row ;   /* ३  ᫥饩 ப */
         }
         EGA_BIT_MASK(0xFF) ;   /* ⬥   */
         EGA_GRFX(5,0) ;        /*  ०  */
         }
         ----------------------------------------------------------------

              ணࠬ  9-5 ०  2 ⠭ ப
         EGA_GRFX(5,2).     ⥫묨   뫠 -
         , ⫨  0, 1,  2  EGA (0, 1, 2  3  VGA), ⠪
          㣨  , ࠢ塞 ॣ ०,  -
           EGA.  ᪨   ᪨  䥪⨢  -
           2,  ॣ ⠭/ ᯮ.  -
          0,  ०  BIOS  㬮砭,  ⠭  
         EGA_GRFX(5,0).  । ᯮ짮  㣨 ணࠬ  맮
         BIOS ०    襭  0.
               1 ਬ  ண ஢  -
           EGA  .  祭   ப⪨, -
         ⨯樨,  ⠪ ࠭  ⠭ ⥩  -
         .     1   ஢ 4    
          ⮢    横 ⥭   業ࠫ쭮-
              ࠧ ॥ ⥭ 4 ⤥ ⮢ 
         ⮢   ᫥饩  4 ⮢   .
              ஢  8 ⮢ ᬥ饭 ࠦ  EGA,
         ᮤঠ饥 8 ⮢ ࠦ,  뢠    ⮢
         ॣ஢-饫; ⥬ ᬥ饭, ᮤঠ饥 祭, -
          業ࠫ ஬.  業ࠫ  -
         뢠 ,   ०  ⠭  1,  EGA 뢠 
         業ࠫ쭮    ᮤঠ ॣ஢-饫 
          ⮢ .   ᪨   ᯮ  -
           1.     ॣ-饫 뢠-
                ⮢  ᨬ  ⠭ ᪨
         .  ᪨    ᯮ짮   -
          ⮢ .
             ணࠬ, ।⠢  ⨭ 9-6,  ०
          1.      孥  ࠭. ⥬ 
            ᯮ짮 ०  1.  , -
           ࠧ  稢  樨 
         ⨯樨.



                                      - 9-23 -
                          ⨭ 9-6. ணࠬ MODEL.C
         ---------------------------------------------------------------
         /* mode1.c */
         /*  ணࠬ  ०  1 EGA */
         #include <conio.h>
         #include <dos.h>
         #include <stdio.h>
         #include "ega.h"
         void copy( int,int,int,int,int );
         void main()
         {
            registr i,j;
            int k = 0;
            set_crt_mode(16) ; /*⮫쪮 ᮢ襭⢮ !*/
            /*   : */
            for(k = 0; k <= 4; ++k)
            for(j = 0+k; j <= 500+k; j += 5)
            for(i = 0+k; i <= 100+k; ++i)
               fastdot(i,i+j,13) ;
            for(k = 0; k <= 3; ++k)
            for(j = 0+k; j <= 500+k; j += 5)
            for(i = 0+k; i <= 100+k; ++i)
               fastdot(i,i+j,3) ;
            /* ஢   120 ப : */
            copy(0,0,105,639,   120,0) ;
            while(!kbhit())
            {
         /* ஢ ࠭ ୮,
         ** ᮧ  : */
                copy(99,100,106,592,   219,100) ;
                copy(99,100,106,592,   219,108) ;
            }
            set_crt_modes(3) ;
         }

         void copy(r1_1, c1_1, r2_1, c2_1, r1_2, c1_2)
         int  r1_1, c1_1,   /* 孨  㣮 筨 */
              r2_1, c2_1,   /*  ࠢ 㣮 筨 */
              r1_2, c1_2 ;  /* 孨  㣮 祭 */
         {
         /*     ࠭  .
         ** ᯮ ०  1.   ⮫쪮
         ** 孨 㣮 祭.
         */
            char far *source = (char far *)(0xA0000000L) ;
            char far *destination = (char far *)(0xA0000000) ;
            int rows = r2_1 - r1_1 ;
            int cols = (c2_1 >> 3) - (c1_1 >> 3) ;
            int bytes_per_line = GET_CRT_COLS() ;
            int next_row = bytes_per_line - cols ;
            registr x,y ;
            source += bytes_per_line * r1_1 + (c1_1 >> 3) ;
            destination += bytes_per_line * r1_2 + (c1_2 >> 3) ;

            EGA_GRFX(5,1) ;     /* ⠭ ०  1 */
            for(y = 0 ; y < rows ; y++)
            {

                                      - 9-24 -
               for(x = 0; x < cols; x++)
                 *(destination++) = *(source++) ;
               source += next_row ;
               destination += next_row ;
            }
            EGA_GRFX(5,0) ;   /*  ०  */
         }
         ----------------------------------------------------------------

             ᪮ ॣ  ᪨   ਣ  ᯮ짮 
         ०  1, ணࠬ copy() 㤥 ஢ ᥬ -
         ⮢  ࠦ  室 ⮢   祭.  㣨
         ᫮,  ०  1 ਬ  㫨஢ ⠬,
             ⠬ ࠦ.    1  ᯮ짮
          ࠭  ࠭   ࠭.   
           ॠ樨 ᪠ .    ᪠騬 
           ࠭   ࠭   ⥬ ⠭
         ᫥ ᯮ짮 .   1 ᯮᮡ ஢ -
          ⮫쪮     EGA.  ⥭ 梥  -
          EGA ॡ ⤥쭮 ⥭  ⮢ .
             VGA    ० .    3 VGA 室
          ᯮ짮  ॣ஢ ⠭/  ࠧ襭 -
         ⠭/  ०  0 EGA  ⠭ 梥  (ਬ-
          ணࠬ line() ணࠬ 9-4).  砥 
         ⮬,   ०  3 ॣ ࠧ襭 ⠭/ 
         ᯮ,  ⮬ 祭, ᮤঠ饥  ॣ ⠭-
         /  ᪨ ॣ஬ ࠧ襭 ⠭/.


                               ⥭ ⮢ 

             ᪮     ᭮  ࠭⢠  業ࠫ쭮
         , १ࢨ஢  EGA, ।⠢ 4  -
         ᪮  ,    EGA    ⠭ ।-
         ⢥ 業ࠫ ஬.  EGA       ⮢
         , ࠭  ॣ 롮 ⥭ ⮢ . -
         뢠  室  ⠭  ।  ⥭  ᬥ饭
         EGA, ᮤঠ饣 騥   ࠦ.
              । 梥   ࠦ ॡ-
          ⤥쭮 ⥭   ⮢ .   4--
          祭 梥 ᯮ     ⮢ .
           稬  祭 梥 室  ⮢  3,
           稬   ⮢  0.   롮  ⥭
               4  ᪨ 稯 1  2 EGA.   
          ⮢  EGA  뢠  ⤥쭮, 祭
         ॣ 롮 ⥭  ᮮ⢥ ⮫쪮  ⮢
          EGA    ६.
             㭪   ணࠬ 9-7 頥 梥  ࠦ
          ᯫ.      fastdot(),   ⠥ 梥 窨  -
         ᪮쪮 ࠧ ॥, 祬 ⭠ ணࠬ BIOS.
             饭 , ᮤঠ饣  ࠦ, ।
         筮 ⠪,     ணࠬ fastdot(). 祭 ᪨ 
          ।   塞 .  -
           ᪨    뫠  ॣ ᪨  EGA.  
         ᪨  EGA    ,  ⠥ EGA.  ᪠  -
           樨  ࠦ  ,  뢠-
           ⮢  EGA.   ⥬ ਡ   

                                      - 9-25 -
         楩   梥  ࠦ.  롮 ⥭
          롨ࠥ   ⥭.  ⮢    
         ⭮  浪 ( 3,  2,  1,  0),  ⠪   砥
         ࠭ .   ,   ॣ  롮  ⥭
           뢠   ணࠬ.  믮 横-
           ᫥ ࠧ ॣ 롮 ⥭   ⠭
          0, 祭  㬮砭.

          ⨭ 9-7. ணࠬ,  梥  ࠦ
         -----------------------------------------------------------------

         /* 頥 梥  ࠦ */
         int readdot(row,col)
         int row,col;
         {
            registr color = 0 ;
            registr latch ;
            unsigned char far *rgen = (char far *)(0xA0000000L +
                                      (col >> 3) +
                                      (row * GET_CRT_COLS())) ;
            int bit_number = (col & 7)^7 ;
            int bit_mask = (1 << bit_number) ;
            int plane ;
            /* ன १  ᨢ 3, 2, 1, 0 */
            for(plane = 3; plane >= 0; plane--)
            {
               EGA_GRFX(4,plane) ;           /*  ᨢ */
               latch = *(rgen) & bit_mask ;  /*   ⮣ ᨢ */
               latch >>= bit_number ;        /* ஢ ࠢ */
               color <<= 1 ;            /*   ᫥饣  */
               color |= latch ;         /* ਡ  */
            }
            return(color) ;
         }
         ----------------------------------------------------------------

                               ⮢  EGA

              ᯮ짮   ᮢ襭⢮ 梥 ᯫ EGA
          ⮡ࠦ   16  梥⮢    64-梥⭮  .  
         ।⠢  16  梥⮢ ॡ 4 .     ⮢
         ᮮ⢥    ⮢  EGA.   ०  CGA
           室  EGA 4  ᮮ⢥ ᭮, -
         , ᨭ  ન   梥⠬,   筮 뢠 IRGB.   
         ⮫쪮 室  EGA ,  4-⮢  梥 -
          ।⠢ ᮡ    .
             64-梥⭠       ᭮  梥  (,
         ,   ᨭ),      16-梥⭠  ,      મ
         .     梥  2   મ -
         쭮 梥,     ஢ મ  梥.  
         ࠧ 64-梥⭠     ।⠢  6  ⠬  (3
         梥    2 /梥).   襩 મ  梥⮢ 
         ᠬ묨 稬묨 ⠬  6-⮢ 祭    ॢ  rgb
         ᮮ⢥  ᭮,     ᨭ 梥⠬  મ.
          稬 3  ।⠢ ,   ᨭ 梥-
           ᮪  મ     ᮮ⢥ ॢ RGB.  饥
         6-⮢ 祭,  rgbRGB   ᯮ  롮   64

                                      - 9-26 -
         梥⮢.  ⮫쪮   16  ⮡ࠦ  梥⮢  ⠭  
         祭 rgbRGB,   梥   ࠭   4-⮢
         祭  IRGB.    祭  rgbRGB    ᥣ  뢠
         ,    ᨭ  १饣 梥,    
         祭 ᮢ襭⢮ 梥 ᯫ,  祭  IRGB
           ᮬ ⥪饩 .
              rgbRGB  ਬ ⮫쪮   EGA,  祭  
         ७  梥⭮  .    EGA 祭  梥⭮
         ᯫ,  ᯮ짮 ⮫쪮 16 梥⮢ 室 . 
         ⥪⮢ ०  ᪨ ० EGA ⤥ ॣ -
            ⠭    16 室 梥⮢.   -
         ,  ᮢ⨬  CGA,     ᯮ짮-
          CGA-ᮢ⨬ 맮 BIOS.
             EGA ⠪    ॣ  室饩  ப ࠧ⪨.  ,
         뫠   ॣ, ⮡ࠦ  ࠭.   ,
         室  ப ࠧ⪨ ਥ ⮫쪮  ०  200 -
          ࠧ⪨.
                EGA  ᥣ ⠭   -
          맮 EGA BIOS.  맮 BIOS  ⠭     16
         梥⮢,   16 梥⮢ ࠧ. 맮 BIOS  㭪樥 010
         뢠 010.    㭪樨:  0 ⠭  -
          ॣ    祭 rgbRGB (   -
         祭 IRGB,  ᫨ EGA  祭  ᮢ襭⢮ 梥⭮
         ᯫ),  1  ⠭ ॣ 室饩 ப ࠧ⪨,  2
         ⠭  ॣ   ॣ 室饩 ப ࠧ-
         ⪨,    4  㦨  ४⥫  栭 ⥪  -
         . 㭪 롨ࠥ  ॣ AL.

                                ⠭ 

             :  Int   0x10
             뢠: AH =  010
                         AL =  0, ⠭ ⤥ ॣ 
                         BL =  塞  梥 (IRGB)
                         BH =  ⠭ 祭 rgbRGB
                         AL =  1, ⠭ ॣ 室饩 ப
                               ࠧ⪨
                         BH =   ⠭ 梥
                         AL =  2, ⠭  ॣ   -
                                室饩 ப ࠧ⪨
                               ES:DX 㪠뢠  17-⮢ ⠡
                                0 - 15  16 祭 rgbRGB 
                               梥⮢ 0 - 15
                                16  ஬ 梥  -
                                室饩 ப ࠧ⪨
                         AL =  3, ४砥  મ/栭
                                祭  7  ਡ
                               ⥪
                         BL =  0, 蠥 મ 䮭
                         BL =  1, 蠥 栭 । 
              ᮦ,  ॣ   EGA  ⮫쪮  뢠.  
         筮  ﭨ   ।,   祭 rgbRGB
         ।⠢   梥.   ॣ஢ -
          EGA BIOS ஢ 稥 256-⮢ ⠡, 뢠 -
          ࠭ ࠬ஢.  ᫨  ⠡ ,   BIOS
         ࠭   祭 rgbRGB.   ᬠਢ ᮧ
          ᮯ஢  ࠭ ࠬ஢,   ᯮ짮-

                                      - 9-27 -
           맮 BIOS  ⠭  ⠪ ࠧ,  ⮡ 
         ⠡ ࠬ஢ 﫠.
             VGA   뢠/뢠 ॣ , ⮬
         ⤥ 梥 rgbRGB   । ⥭ ᮮ⢥-
         饣 ॣ .  VGA ⠪   ப , 
         ன   16 ⮡ࠦ 梥⮢   梥⮬   -
          262.144   梥⮢.  2 ⮢  梥  EGA, VGA
         ᯮ 6 ⮢  梥 (2  3 梥 = 262.144 梥).
             ணࠬ, ।⠢   ⨭ 9-8,   -
         짮 ॣ஢ .   ணࠬ ࠡ⠥  ⮫쪮  
         ⠭  EGA   ᮢ襭⢮ 梥 ᯫ ( VGA).
         砫 ணࠬ,  ਬ 㭪 rect() ணࠬ 9-5, -
           16  梥 אַ㣮쭨.  ⥬  㤥 뢭
         .

                         ⨭ 9-8. ணࠬ PALETTE.C
         ---------------------------------------------------------------

         /* palette.c */
         /*   64 梥⮢ */
         #include <conio.h>
         #include <dos.h>
         #include <stdio.h>
         #include "ega.h"

         void set_all_pal(char*) ;
         void gotoXY(int,int) ;
         main()
         {
         int i,j,ch = 0;
         char palette[17] ;  /*   ᮤন  */
         set_crt_mode(16) ;  /*  ࠢ ! */

         /*  ᪮쪮 梥 客: */
         printf("\n #:\n") ;
         for (i=0,j=0;i<16;++i,j+=40)
         {
            printf (" %2i ",i);
            rect(50,j,300,j+39,i);    /*  ணࠬ 9-5 */
            palette[i] = (char)i ;    /* 樠஢  */
         }
            gotoXY(15,22) ;
            printf("rgbRGB 梥 7") ;
            printf("%c%c%c%c%c%c",205,205,205,205,205,190) ;
            gotoXY(20,0) ;
            printf(" Space   ஡, Esc  室");

            palette[16] = (char)0 ;
            while(ch != 27)          /*     Esc */
               {
               if (kbhit())          /* ᫨  , */
                 ch = getch() ;      /* ਭ ᨬ */
               for (i = 1; i<=15; ++i)
                 {
                    palette[i]++;
                    if (palette[i] == 64)
                    /* ᨬ쭮 祭 rgbRGB */

                                      - 9-28 -
                        palette[i] = 1 ;
                 }
                 set_all_pal(palette) ;   /* ⠭  */
                 gotoXY(15,23) ;
                 /* ॢ 祭 rgbRGB  筮 */
                 for(i = 5;i>=0; --i)
                 if(palette[7] & 1<<i)
                    putchar('1') ;
                 else
                    putchar('0') ;
                 if(ch == 32)         /* ०  ஡ */
                    while(!kbhit());
               }

         set_crt_mode(3) ;
         }

         /*==========================================================*/
         void set_all_pal(palette)
         char *palette ;
         /*  㭪 ⠭   */
         {
         union REGS regs ;       /* ॣ 8086 */
         struct SREGS segregs ;
         char far *fr = (char far *)palette ;
         regs.h.ah = 0x10 ;
         regs.h.al = 2 ;           /* 㭪  ⠭ ᥣ */
         segregs.es = FP_SEG(fp);  /* ES  ᥣ  */
         regs.x.dx = FP_OFF(fp) ;  /* DX  ᬥ饭  */
         int86x(0x10, &regs, &regs, &segregs) ;
         }

         /*==========================================================*/
         void gotoXY(x,y)
         int x,y ;
         /*  㭪 ६頥  ⥪  x,y */
         {
            union REGS regs ;
            regs.h.ah = 2 ;            /* ⠭ 㭪  */
            regs.h.bh = 0 ;               /* ࠭ 0 */
            regs.h.dh = (char)y ;         /* ப */
            regs.h.dl = (char)x ;         /* ⮫ */
            int86(0x10, &regs, &regs) ;   /* 맮 뢠 010 */
         }
         ----------------------------------------------------------------

                         横᪮ ᤢ 

              横᪮ ᤢ     ᯮ-
         ᮡ ஢ ,  ࠢ塞 業ࠫ ஬,
          ॣ-饫 EGA.  ⥫ ࠬ, 騥 -
         ,    ᪨  㬭,  ᫮, ᫮   
         ⠢ 묨  ⮬  ॣ-饫. ᬮ  
         ,    ॣ 横᪮ ᤢ   ᤢ ,
         ࠢ塞 業ࠫ ஬,  ࠪ⨪ ⮬ ਤ
           祭.  ࠫ  ॥ ⢫ ᤢ
           ॡ  த⥫  ⠭.  騥  

                                      - 9-29 -
         ॣ  横᪮  ᤢ    㭪 9-3,  
         ਬ ᯮ짮 ⮣ ॣ ਢ  ணࠬ 9-9.

            Ŀ
            76543210
            
               
                        稪 横᪮ ᤢ  CPU
                   
                    롮 㭪樨
                                      
                                      4  3
                                      0  0    
                                      0  1  CPU AND 饫
                                      1  0  CPU OR 饫
                                      1  1  CPU XOR 饫
                 ᯮ  EGA

                   .9-3.  横᪮ ᤢ 



              ⨭ 9-9. ਬ ᯮ짮 ॣ 横᪮
                                   ᤢ 
         ---------------------------------------------------------------

         main()
         {
            int i,j,k ;
            for(k=1;k<16;k++)
               {
               set_crt_mode(16) ;
               rect(0,0,200,639,k) ;    /* 䮭 */
               EGA_GRFX(3,0) ;          /*  ॣ */
               for(i=0;i<13;i++)
               printf("\n") ;
               printf("        ᪨ 㬭") ;
               printf("   \t ᪨ ᫮    ᫮  ") ;
               for(i=0, j=0, i<4; j=160*(i+1),i++)
               {
                   switch(i)
                   {
                     case 1:EGA_GRFX(3,8) ;
                     /* ᪨ 㬭 ᮤঠ ॣ */
                     case 2:EGA_GRFX(3,16) ;
                     /* ᪨ ᫮ ᮤঠ ॣ */
                     case 3:EGA_GRFX(3,24) ;
                     /* ᫮   ᮤঠ ॣ */
                   }
                     /*   אַ㣮쭨: */
                     rect(20,20+j,100,99+j,1) ;
                     rect(40,40+j,120,119+j,1<<1) ;
                     rect(60,60+j,140,139+j,1<<2) ;
                     rect(80,80+j,160,159+j,1<<3) ;
                   }
               gerch() ;
               }

                                      - 9-30 -
         set_crt_mode(3) ;
         }
         ---------------------------------------------------------------

                          ⮡ࠦ 256 梥⮢ VGA

             VGA   ०,  ० 19,    ⮡-
          256 梥⮢   262.144 梥⮢. 楯㠫쭮 ० 19
         筮 .      ࠦ ।⠢-
           ⮬ ᯫ , 饭 ᫥, ।-
         騥 ᬥ饭   ࠦ.   ணࠬ,  ।-
         ⠢   ⨭  9-10,  㦨  ਬ஬  ०  19  VGA.
         ⮡ࠦ  256 梥⮢.  16 梥⮢ ⠪ ,  梥
          CGA,  VGA  EGA.  騥  21  梥  ਭ  ஬
         ᯥ.  ⥫ 216 梥⮢ ।⠢ ᮡ  㯯
          72 梥.    㯯 梥  室  ᨭ  
         ᭮  .  㯯 ᮮ⢥ 㬥襭 饭-
           㢥祭 .

                        ⨭ 9-10. ਬ ० 19 VGA.
         ---------------------------------------------------------------

         void fast(int, int, int) ;

         main()
         {
           registr i, j ;
           struct Ega_info info ;
           if(get_ega_info(&info))
              if(info.card == 'V')       /*  VGA? */
                 set_crt_mode(19) ;
              else
                 return ;
           else
              return ;

           for(i=0x0; i<=0xFF; i++)      /* 뢥  */
              for(j=0; j<200; j++)
              fast19(j,i,i) ;
         }
         void fast19(row,col,color)
         int row, col, color ;
         {
            /* ⠪     ⮬ ࠦ,
            ** ᬥ饭  ࠦ 
            ** (ப * 320 ⮢/ப) + ⮫
            ** ⠪  ᪠  */
            unsigned char far *rgen = (char far *)(0xA0000000L +
                                      (row * 320) + col) ;
            *rgen = (unsigned char)color ;
         }
         --------------------------------------------------------------

              ணࠬ 9-10 祭 ணࠬ ।⢥ -
          窨  , fast19(),  ० ⮡ࠦ 256 梥-
         ⮢ VGA.  ᪮   ࠦ ᯮ 1  
         ᯫ  ,  ணࠬ    祭 ࠢ.

                                      - 9-31 -
          室   ᫥    樨 
         ᪮   ᪮ . 宦,  ணࠬ, -
          祭  ࠦ,   אַ ।. 
           *rgen = color ; ஬ return(*rgen) ;.


                                    祭

              ᯮ짮 EGA  ⠭.  ଠ  IBM  ࠧࠡ뢠
         EGA    প  ᮢ襭 ࠧ ⠭⮢ ⮡ࠦ
         (CGA  MDA).   饥 ६ ন  
         ᫮ ० VGA.  訬 ᯮᮡ ᮧ ணࠬ -
         祭,  ࠡ饣  EGA  VGA     饣  ᮢ-
         ,   ࠧ ⭮-ᨬ   -
         -ᨬ 㭪樨. ਬ, ணࠬ fastdot() ணࠬ-
          9-5  ९   ० ⮡ࠦ  256 梥⮢
         VGA.      ᫮   ணࠬ  뢮,    뢠
         fastdot()  稢 祪,    ९뢠,  ⠪ 
         fastdot() ন  ०.
              ⮩  ᬮ७ ᪮쪮 ᭮ ᪨ 㭪-
         権:  line(), fastdot(), readdot()  rect(). 㦤 ⠪ -
           EGA,   ॣ-饫.     ᯮᮡ
         ⠭ 梥 EGA - ॣ ᪨  ,  ॣ   ⠭-
         /ᡮ  ०  2.  ᬮ   ,    㪠 -
         ணࠬ ࠡ ,   ᮢ襭⢮. ᮪-
         ⥫ ᪨ ணࠬ, ᯮ騥 EGA  VGA,
             ᫥.
