home *** CD-ROM | disk | FTP | other *** search
/ Boldly Go Collection / version40.iso / TS / 17A / DRWIN101.ZIP / SCRUTIL.C < prev    next >
C/C++ Source or Header  |  1991-12-06  |  21KB  |  454 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <dos.h>
  4. #include <conio.h>
  5.  
  6. #include "scrutil.h"
  7.  
  8. WORD far *scrseg=NULL;
  9.  
  10.  
  11. /****************************************************************************/
  12. /*  ptrcmp                                                                  */
  13. /****************************************************************************/
  14. /*-----------------------------Description----------------------------------*/
  15. /*  This function determines if two pointers are equal.  It is necessary    */
  16. /*  under the Intel 80x86 bullshit segmenting.                              */
  17. /*-----------------------------Arguments------------------------------------*/
  18. /*  void *p            first pointer to compare                             */
  19. /*  void *q            second pointer to compare                            */
  20. /*-----------------------------Return value---------------------------------*/
  21. /*  ptrcmp() returns 1 if the args point to the same place, 0 otherwise.    */
  22. /*-----------------------------Global constants-----------------------------*/
  23. /*-------------------Mod-------Global variables-----------------------------*/
  24. /*-----------------------------Functions called-----------------------------*/
  25. /*-----------------------------Constraints/Gotchas--------------------------*/
  26. /*--Date--------Programmer----------Comments--------------------------------*/
  27. /*  1990.01.01  D. Rogers           initial code                            */
  28. /****************************************************************************/
  29. int  ptrcmp(void far *p,void far *q)
  30. {
  31.   LWORD lp,lq;
  32.   lp=(LWORD)p;
  33.   lq=(LWORD)q;
  34.   lp=((lp>>12)&0x000FFFF0L)+(lp&0x0000FFFFL);   /*shift down segment and add*/
  35.   lq=((lq>>12)&0x000FFFF0L)+(lq&0x0000FFFFL);   /*shift down segment and add*/
  36.   return(lp==lq);
  37. }   /*ptrcmp*/
  38. /****************************************************************************/
  39.  
  40.  
  41. /****************************************************************************/
  42. /*  memcpynf, memcpyfn, memcpyi, memcpyifn, memcpyfni                       */
  43. /****************************************************************************/
  44. /*-----------------------------Description----------------------------------*/
  45. /*  These function are analogous to memcpy, but for mixed near:far or       */
  46. /*  far:near pointers.  Those which end in i are interruptable.             */
  47. /*-----------------------------Arguments------------------------------------*/
  48. /*-----------------------------Return value---------------------------------*/
  49. /*-----------------------------Global constants-----------------------------*/
  50. /*-------------------Mod-------Global variables-----------------------------*/
  51. /*-----------------------------Functions called-----------------------------*/
  52. /*-----------------------------Constraints/Gotchas--------------------------*/
  53. /*--Date--------Programmer----------Comments--------------------------------*/
  54. /*  1990.01.01  D. Rogers           initial code                            */
  55. /****************************************************************************/
  56. void memcpynf(void near *n,void far *f,WORD k)    /*copies to near from far*/
  57. {
  58.   BYTE far *bf;
  59.   BYTE near *bn;
  60.   bf=(BYTE far *)f;
  61.   bn=(BYTE near *)n;
  62.   while (k-->0) *bn++=*bf++;
  63. }   /*memcpynf*/
  64.  
  65.  
  66. void memcpyfn(void far *f,void near *n,WORD k)    /*copies to far from near*/
  67. {
  68.   BYTE far *bf;
  69.   BYTE near *bn;
  70.   bf=(BYTE far *)f;
  71.   bn=(BYTE near *)n;
  72.   while (k-->0) *bf++=*bn++;
  73. }   /*memcpyfn*/
  74.  
  75.  
  76. void memcpyi(void* dpp,void* spp,WORD n)
  77. {
  78. #if defined(__HUGE__)|defined(__LARGE__)|defined(__COMPACT__)
  79.  
  80.   asm push  si
  81.   asm push  di
  82.   asm push  ds
  83.   asm mov   cx,n
  84.   asm les   di,dpp
  85.   asm lds   si,spp
  86. looplin:
  87.   asm   movsb
  88.   asm loop  looplin
  89.   asm pop   ds
  90.   asm pop   di
  91.   asm pop   si
  92.  
  93. #else
  94.  
  95.   asm push  si
  96.   asm push  di
  97.   asm mov   cx,n
  98.   asm mov   di,dpp
  99.   asm mov   si,spp
  100.   asm mov   ax,ds
  101.   asm mov   es,ax
  102. looplin:
  103.   asm   movsb
  104.   asm loop  looplin
  105.   asm pop   di
  106.   asm pop   si
  107.  
  108. #endif
  109. }   //memcpyi
  110.  
  111.  
  112. void memcpyfni(void far* dpp,void near* spp,WORD n)
  113. {
  114.   asm push  si
  115.   asm push  di
  116.   asm mov   cx,n
  117.   asm les   di,dpp
  118.   asm mov   si,spp
  119. looplin:
  120.   asm   movsb
  121.   asm loop  looplin
  122.   asm pop   di
  123.   asm pop   si
  124. }   //memcpyfni
  125.  
  126.  
  127. void memcpynfi(void near* dpp,void far* spp,WORD n)
  128. {
  129.   asm push  si
  130.   asm push  di
  131.   asm push  ds
  132.   asm mov   cx,n
  133.   asm mov   di,dpp
  134.   asm mov   ax,ds
  135.   asm mov   es,ax
  136.   asm lds   si,spp
  137. looplin:
  138.   asm   movsb
  139.   asm loop  looplin
  140.   asm pop   ds
  141.   asm pop   di
  142.   asm pop   si
  143. }   //memcpynfi
  144. /****************************************************************************/
  145.  
  146.  
  147. /****************************************************************************/
  148. /*  getkey                                                                  */
  149. /****************************************************************************/
  150. /*-----------------------------Description----------------------------------*/
  151. /*  This function returns the key pressed.  If a special function key is    */
  152. /*  pressed, it returns the scan code of the key + 256.                     */
  153. /*  Constants are defined in [cutil.h] for use with this function.          */
  154. /*-----------------------------Arguments------------------------------------*/
  155. /*-----------------------------Return value---------------------------------*/
  156. /*  Returns 256+scan code for special keys, ASCII value for others.         */
  157. /*-----------------------------Global constants-----------------------------*/
  158. /*-------------------Mod-------Global variables-----------------------------*/
  159. /*-----------------------------Functions called-----------------------------*/
  160. /*-----------------------------Constraints----------------------------------*/
  161. /*--Date--------Programmer---------Comments---------------------------------*/
  162. /*  1990.01.01  D. Rogers          initial code                             */
  163. /****************************************************************************/
  164. int getkey(void)
  165. {
  166.   int c;
  167.   c=getch();
  168.   if (c)
  169.     return(c);
  170.   else
  171.     return(0x0100+getch());
  172. }   /*getkey*/
  173. /****************************************************************************/
  174.  
  175.  
  176. /****************************************************************************/
  177. /*  getcrow                                                                 */
  178. /****************************************************************************/
  179. /*-----------------------------Description----------------------------------*/
  180. /*  This function returns the current absolute cursor row.                  */
  181. /*-----------------------------Arguments------------------------------------*/
  182. /*-----------------------------Return value---------------------------------*/
  183. /*  getcrow() returns the current row as an unsigned int.                   */
  184. /*-----------------------------Global constants-----------------------------*/
  185. /*-------------------Mod-------Global variables-----------------------------*/
  186. /*-----------------------------Functions called-----------------------------*/
  187. /*-----------------------------Constraints/Gotchas--------------------------*/
  188. /*  Rows normally range from 0-24.                                          */
  189. /*--Date--------Programmer----------Comments--------------------------------*/
  190. /*  1990.01.01  D. Rogers           initial code                            */
  191. /****************************************************************************/
  192. WORD getcrow(void)
  193. {
  194.   union REGS r;
  195.  
  196.   r.x.bx=0;                            /*assume page 0*/
  197.   r.h.ah=0x03;                         /*indicate get-cursor-info*/
  198.   int86(0x10,&r,&r);                   /*call Video Services interrupt*/
  199.   return (r.h.dh);                     /*return row (0=first row)*/
  200. }   /*getcrow*/
  201. /****************************************************************************/
  202.  
  203.  
  204. /****************************************************************************/
  205. /*  getccol                                                                 */
  206. /****************************************************************************/
  207. /*-----------------------------Description----------------------------------*/
  208. /*  This function returns the current absolute cursor column.               */
  209. /*-----------------------------Arguments------------------------------------*/
  210. /*-----------------------------Return value---------------------------------*/
  211. /*  getccol() return the absolute cursor column as an unsigned int.         */
  212. /*-----------------------------Global constants-----------------------------*/
  213. /*-------------------Mod-------Global variables-----------------------------*/
  214. /*-----------------------------Functions called-----------------------------*/
  215. /*-----------------------------Constraints/Gotchas--------------------------*/
  216. /*  Columns usually range from 0-79.                                        */
  217. /*--Date--------Programmer----------Comments--------------------------------*/
  218. /*  1990.01.01  D. Rogers           initial code                            */
  219. /****************************************************************************/
  220. WORD getccol(void)
  221. {
  222.   union REGS r;
  223.  
  224.   r.x.bx=0;                            /*assume page 0*/
  225.   r.h.ah=0x03;                         /*indicate get-cursor-info*/
  226.   int86(0x10,&r,&r);                   /*call Video Services interrupt*/
  227.   return (r.h.dl);                     /*return column (0=first row)*/
  228. }   /*getccol*/
  229. /****************************************************************************/
  230.  
  231.  
  232. /****************************************************************************/
  233. /*  setcpos                                                                 */
  234. /****************************************************************************/
  235. /*-----------------------------Description----------------------------------*/
  236. /*  This function sets the current absolute cursor position to the row and  */
  237. /*  column specified.                                                       */
  238. /*-----------------------------Arguments------------------------------------*/
  239. /*  WORD row           absolute cursor row on screen (usually 0-24)         */
  240. /*  WORD col           absolute cursor column on screen (usually 0-79)      */
  241. /*-----------------------------Return value---------------------------------*/
  242. /*-----------------------------Global constants-----------------------------*/
  243. /*-------------------Mod-------Global variables-----------------------------*/
  244. /*-----------------------------Functions called-----------------------------*/
  245. /*-----------------------------Constraints/Gotchas--------------------------*/
  246. /*--Date--------Programmer----------Comments--------------------------------*/
  247. /*  1990.01.01  D. Rogers           initial code                            */
  248. /****************************************************************************/
  249. void setcpos(WORD row,WORD col)
  250. {
  251.   union REGS r;
  252.  
  253.   r.x.bx=0;                            /*assume page 0*/
  254.   r.h.dh=row;                          /*cursor row*/
  255.   r.h.dl=col;                          /*cursor col*/
  256.   r.h.ah=0x02;                         /*indicate set-cursor-position*/
  257.   int86(0x10,&r,&r);                   /*call Video Services interrupt*/
  258. }   /*setcpos*/
  259. /****************************************************************************/
  260.  
  261.  
  262. /****************************************************************************/
  263. /*  getcsiz                                                                 */
  264. /****************************************************************************/
  265. /*-----------------------------Description----------------------------------*/
  266. /*  This function finds out how big the current cursor is on the screen.    */
  267. /*-----------------------------Arguments------------------------------------*/
  268. /*-----------------------------Return value---------------------------------*/
  269. /*  getcsiz() returns the cursor size in an unsigned int whose most         */
  270. /*  significant byte contains the first scan line of the cursor and whose   */
  271. /*  least significant byte contains the last scan line of the cursor.       */
  272. /*-----------------------------Global constants-----------------------------*/
  273. /*-------------------Mod-------Global variables-----------------------------*/
  274. /*-----------------------------Functions called-----------------------------*/
  275. /*-----------------------------Constraints/Gotchas--------------------------*/
  276. /*--Date--------Programmer----------Comments--------------------------------*/
  277. /*  1990.01.01  D. Rogers           initial code                            */
  278. /****************************************************************************/
  279. WORD getcsiz(void)
  280. {
  281.   union REGS r;
  282.  
  283.   r.x.bx=0;                            /*assume page 0*/
  284.   r.h.ah=0x03;                         /*indicate get-cursor-info*/
  285.   int86(0x10,&r,&r);                   /*call Video Services interrupt*/
  286.   return (r.x.cx);                     /*return cursor scan lines*/
  287. }   /*getcsiz*/
  288. /****************************************************************************/
  289.  
  290.  
  291. /****************************************************************************/
  292. /*  setcsiz                                                                 */
  293. /****************************************************************************/
  294. /*-----------------------------Description----------------------------------*/
  295. /*  This function sets the cursor size using the same format as is          */
  296. /*  returned by getcsiz().                                                  */
  297. /*-----------------------------Arguments------------------------------------*/
  298. /*  WORD siz           cursor size (MSB: 1st scan line, LSB: last)          */
  299. /*-----------------------------Return value---------------------------------*/
  300. /*-----------------------------Global constants-----------------------------*/
  301. /*-------------------Mod-------Global variables-----------------------------*/
  302. /*-----------------------------Functions called-----------------------------*/
  303. /*-----------------------------Constraints/Gotchas--------------------------*/
  304. /*--Date--------Programmer----------Comments--------------------------------*/
  305. /*  1990.01.01  D. Rogers           initial code                            */
  306. /****************************************************************************/
  307. void setcsiz(WORD siz)
  308. {
  309.   union REGS r;
  310.  
  311.   r.x.bx=0;                            /*assume page 0*/
  312.   r.x.cx=siz;                          /*cursor size (start/stop scan line)*/
  313.   r.h.ah=0x01;                         /*indicate set-cursor-size*/
  314.   int86(0x10,&r,&r);                   /*call Video Services interrupt*/
  315. }   /*setcsiz*/
  316.  
  317.  
  318. /****************************************************************************/
  319. /*  getsmod                                                                 */
  320. /****************************************************************************/
  321. /*-----------------------------Description----------------------------------*/
  322. /*  This function returns the current video mode of the PC by making a      */
  323. /*  call to the DOS Video Services interrupt.                               */
  324. /*-----------------------------Arguments------------------------------------*/
  325. /*-----------------------------Return value---------------------------------*/
  326. /*  getsmod() returns the video mode as an unsigned int.                    */
  327. /*-----------------------------Global constants-----------------------------*/
  328. /*-------------------Mod-------Global variables-----------------------------*/
  329. /*-----------------------------Functions called-----------------------------*/
  330. /*-----------------------------Constraints/Gotchas--------------------------*/
  331. /*--Date--------Programmer----------Comments--------------------------------*/
  332. /*  1990.01.01  D. Rogers           initial code                            */
  333. /****************************************************************************/
  334. WORD getsmod(void)
  335. {
  336.   union REGS ir,or;                    /*register structs*/
  337.   WORD mode;                           /*mode value*/
  338.  
  339.   ir.x.bx=0;                           /*assume page 0*/
  340.   ir.h.ah=0x0F;                        /*indicate get-screen-mode*/
  341.   int86(0x10,&ir,&or);                 /*call Video Services interrupt*/
  342.   mode=or.h.al;                        /*see about mode*/
  343.  
  344.   if (or.h.al==TEXT_80_25) {           /*see if need to check for special*/
  345.     ir.x.bx=0x0003;
  346.     ir.x.ax=0x1130;
  347.     int86(0x10,&ir,&or);
  348.     switch(or.h.dl+1) {                /*look at rows..*/
  349.     case 43:
  350.     case 50:
  351.       mode=TEXT_80_HI;
  352.       break;
  353.     default: ;
  354.     }   /*switch*/
  355.   }   /*if checking for special*/
  356.   return mode;                         /*return video mode*/
  357. }   /*getsmod*/
  358.  
  359.  
  360. /****************************************************************************/
  361. /*  setsmod                                                                 */
  362. /****************************************************************************/
  363. /*-----------------------------Description----------------------------------*/
  364. /*  This function sets the current video mode of the PC by making a call    */
  365. /*  to the DOS Video Services interrupt.                                    */
  366. /*-----------------------------Arguments------------------------------------*/
  367. /*  WORD mod           video mode to be set                                 */
  368. /*-----------------------------Return value---------------------------------*/
  369. /*-----------------------------Global constants-----------------------------*/
  370. /*-------------------Mod-------Global variables-----------------------------*/
  371. /*-----------------------------Functions called-----------------------------*/
  372. /*-----------------------------Constraints/Gotchas--------------------------*/
  373. /*--Date--------Programmer----------Comments--------------------------------*/
  374. /*  1990.01.01  D. Rogers           initial code                            */
  375. /****************************************************************************/
  376. void setsmod(WORD mod)
  377. {
  378.   union REGS r;
  379.  
  380.   if (mod>0x1000) {                    /*if special mode..*/
  381.     r.x.bx=0;                          /*..*/
  382.     r.x.ax=TEXT_80_25;                 /*..first force to text mode*/
  383.     int86(0x10,&r,&r);                 /*..call video services interrupt*/
  384.   }   /*if higher mode*/
  385.   r.x.bx=0;                            /*force page 0*/
  386.   r.x.ax=mod;                          /*video mode to set*/
  387.   int86(0x10,&r,&r);                   /*call Video Services interrupt*/
  388. }   /*setsmod*/
  389.  
  390.  
  391. WORD getsrows(void)
  392. {
  393.   union REGS r;                        /*register-holding union*/
  394.  
  395.   switch (getsmod()) {                 /*go rows via mode*/
  396.   case TEXT_40_25_BW:
  397.   case TEXT_40_25:
  398.   case TEXT_80_25_BW:
  399.   case TEXT_80_25:
  400.   case MONO_80_25:
  401.     return 25;
  402.   case TEXT_80_HI:
  403.     r.x.ax=0x1130;                     /*.*/
  404.     r.x.bx=0x0003;                     /*.*/
  405.     int86(0x10,&r,&r);                 /*call video services interrupt*/
  406.     return r.h.dl+1;                   /*return number of rows on screen*/
  407.   default: ;
  408.   }   /*switch*/
  409.   return 0;                            /*must be in a text mode*/
  410. }   /*getsrows*/
  411.  
  412.  
  413. WORD getscols(void)
  414. {
  415.   return *((WORD far *)SCRCOLUMN);     /*columns per row*/
  416. }   /*getscols*/
  417.  
  418.  
  419. WORD getsrowscols(void)
  420. {
  421.   union REGS r;                        /*register-holding union*/
  422.   r.x.ax=0x1130;                       /*.*/
  423.   r.x.bx=0x0003;                       /*.*/
  424.   int86(0x10,&r,&r);                   /*call video services interrupt*/
  425.   r.h.dh=*((BYTE far *)SCRCOLUMN);     /*columns per row*/
  426.   return r.x.dx+1;                     /*return number of rows & columns*/
  427. }   /*getsrows*/
  428.  
  429.  
  430. /****************************************************************************/
  431. /*  setscrseg                                                               */
  432. /****************************************************************************/
  433. /*-----------------------------Description----------------------------------*/
  434. /*  This function sets the screen (video) segment variable, scrseg,         */
  435. /*  according to the video monitor available.                               */
  436. /*-----------------------------Arguments------------------------------------*/
  437. /*-----------------------------Return value---------------------------------*/
  438. /*-----------------------------Global constants-----------------------------*/
  439. /*-------------------Mod-------Global variables-----------------------------*/
  440. /*-----------------------------Functions called-----------------------------*/
  441. /*-----------------------------Constraints/Gotchas--------------------------*/
  442. /*--Date--------Programmer----------Comments--------------------------------*/
  443. /*  1990.01.01  A. Turing           initial code                            */
  444. /****************************************************************************/
  445. WORD far *setscrseg(void)
  446. {
  447.   if (getsmod() == MONO_80_25)
  448.     scrseg=(WORD far*)SCRSEG_MONO;
  449.   else
  450.     scrseg=(WORD far*)SCRSEG_COLOR;
  451.   return scrseg;
  452. }   /*setscrseg*/
  453.  
  454.