home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c005 / 1.ddi / BUTILITY.H < prev    next >
Encoding:
C/C++ Source or Header  |  1986-08-05  |  8.9 KB  |  245 lines
  1. /**
  2. *
  3. *  BUTILITY.H     Header file for C TOOLS PLUS Utility functions
  4. *
  5. *  Version 3.0     (C)Copyright Blaise Computing Inc.  1983, 1984, 1986
  6. *
  7. **/
  8.  
  9. #ifndef DEF_BUTILITY              /* Prevent redefinition.          */
  10.  
  11. #include <compiler.h>
  12.  
  13.     /* Definitions of data types                      */
  14.  
  15. struct segads                  /* ADS:  Physical address       */
  16. {                      /*   expressed as segment and   */
  17.                       /*   offset.              */
  18.     unsigned r;               /* Offset.              */
  19.     unsigned s;               /* Segment.              */
  20. };
  21. #define ADS    struct segads
  22.  
  23. struct address                  /* Physical address          */
  24. {                      /*   expressed as segment and   */
  25.                       /*   offset.              */
  26.     unsigned r;               /* Offset.              */
  27.     unsigned s;               /* Segment.              */
  28. };
  29.  
  30. typedef struct                  /* HALFREGS:  two halves of a   */
  31. {                      /*   16-bit general register.   */
  32.     unsigned char l;              /* Lower 8 bits.              */
  33.     unsigned char h;              /* Upper 8 bits.              */
  34. } HALFREGS;
  35.  
  36. typedef union                  /* DOUBLREG:  Two ways to       */
  37. {                      /*   express a 16-bit general   */
  38.                       /*   register.              */
  39.     HALFREGS hl;              /* Two separated halves.          */
  40.     unsigned x;               /* 16-bit unsigned quantity.    */
  41. } DOUBLREG;
  42.  
  43. typedef struct                  /* ALLREG:  complete CPU state  */
  44. {                      /*   (This must match version   */
  45.                       /*   in ISCALINT.ASM.)          */
  46.     DOUBLREG ax,bx,cx,dx;          /* General registers.          */
  47.     unsigned si,di;              /* Index     registers.          */
  48.     unsigned ds,es,ss,cs;          /* Segment registers.          */
  49.     unsigned flags,bp,sp,ip;          /* Other     registers.          */
  50. } ALLREG;
  51.  
  52. struct dreg                  /* DOSREG:  registers for call  */
  53. {                      /*   to DOS.              */
  54.     unsigned ax,bx,cx,dx,si,di,ds,es;
  55. };
  56. #define DOSREG    struct dreg
  57.  
  58.     /* Flag bits for use with ALLREG structure                  */
  59.  
  60. #define CF_FLAG     0x0001          /* Carry flag              */
  61. #define PF_FLAG     0x0002          /* Parity flag (1 means even)   */
  62. #define AF_FLAG     0x0010          /* Auxiliary carry flag          */
  63. #define ZF_FLAG     0x0040          /* Zero flag (1 means zero)     */
  64. #define SF_FLAG     0x0080          /* Sign flag (1 means negative) */
  65. #define TF_FLAG     0x0100          /* Trap flag (1 means single    */
  66.                       /* step)                  */
  67. #define IF_FLAG     0x0200          /* Interrupt enable flag          */
  68. #define DF_FLAG     0x0400          /* Direction flag (0 means up)  */
  69. #define OF_FLAG     0x0800          /* Overflow flag (1 means       */
  70.                       /* overflow)              */
  71. #define DEF_FLAGS   (IF_FLAG)          /* Commonest value for flags:   */
  72.                       /*   interrupts enabled,          */
  73.                       /*   single-stepping off,       */
  74.                       /*   direction up.          */
  75.  
  76.     /* Macros to combine and extract words, bytes, and nybbles.       */
  77.  
  78. #define uthiword(a)   (((a)>>16)&0xffffL)   /* High word of long a    */
  79. #define utloword(a)   ((a)&0xffffL)        /* Low  word of long a    */
  80.                         /* Combine high word a,   */
  81.                         /*           low  word b:   */
  82. #define utwdlong(a,b) ((((0xffffL&(long)(a)))<<16)|(0xffffL&(long)(b)))
  83.  
  84. #define uthibyte(a)   (((a)>>8)&0x00ff)     /* High byte of word a    */
  85. #define utlobyte(a)   ((a)&0x00ff)        /* Low  byte of word a    */
  86.                         /* Combine high byte a,   */
  87.                         /*           low  word b:   */
  88. #define utbyword(a,b) ((((a)&0x00ff)<<8)|((b)&0x00ff))
  89.  
  90. #define uthinyb(a)    (((a)>>4)&0x000f)     /* High nybble of byte a  */
  91. #define utlonyb(a)    ((a)&0x000f)        /* Low nybble  of byte a  */
  92.                         /* Combine high word a,   */
  93.                         /*           low  word b:   */
  94. #define utnybbyt(a,b) ((((a)&0x000f)<<4)|((b)&0x000f))
  95.  
  96.     /* Macros to perform range checking and limiting              */
  97.  
  98.                       /* Beware:  the following three */
  99.                       /* macros may have side effects */
  100.                       /* because they evaluate their  */
  101.                       /* arguments more than once:    */
  102. #ifndef max
  103. #define max(a,b)      ((a)>(b)?(a):(b))     /* Maximum of two values  */
  104. #endif
  105. #ifndef min
  106. #define min(a,b)      ((a)<=(b)?(a):(b))    /* Minimum of two values  */
  107. #endif
  108.                       /* Return 1 if a is outside the */
  109.                       /* range defined by b and c, 0  */
  110.                       /* if not.              */
  111. #define utrange(a,l,h)    (((a)<(l))||((a)>(h)))
  112. #define utoutrng(a,l,h) utrange(a,l,h)
  113.  
  114.                       /* Confine a to the range       */
  115.                       /* defined by b and c.          */
  116. #define utbound(a,b,c)                        \
  117.     {                                \
  118.     register int uttemp;                    \
  119.                                 \
  120.     if ((a) < (uttemp = (b)) || (a) > (uttemp = (c)))   \
  121.         (a) = uttemp;                    \
  122.     }
  123.  
  124.                       /* Prevent a from exceeding b.  */
  125. #define utuplim(a,b)                        \
  126.     {                                \
  127.     register int uttemp;                    \
  128.                                 \
  129.     if ((a) > (uttemp = (b)))                \
  130.         (a) = uttemp;                    \
  131.     }
  132.  
  133.                       /* Prevent a from being less    */
  134.                       /* than b.              */
  135. #define utlowlim(a,b)                        \
  136.     {                                \
  137.     register int uttemp;                    \
  138.                                 \
  139.     if ((a) < (uttemp = (b)))                \
  140.         (a) = uttemp;                    \
  141.     }
  142.  
  143.     /* Miscellanous convenience macros                      */
  144.  
  145. #define NIL        ((char *) 0)  /* Universal invalid data       */
  146.                       /* pointer.              */
  147.  
  148. #define utsign(a)    ((a)>0?1:((a)==0?0:-1))  /* Sign of a          */
  149. #define utalarm     utsound(450,9)         /* Sound for 1/2 sec */
  150. #define utskip        printf("\n")             /* CR/LF             */
  151.  
  152.                       /* Allocate and zero a data     */
  153.                       /* object of a given type,      */
  154.                       /* return a pointer to it.      */
  155. #define utalloc(type) ((type *) calloc(1,sizeof(type)))
  156.  
  157.                       /* Copy a data object, return   */
  158.                       /* pointer to target.          */
  159. #define utcopy(to,from,type)                    \
  160.         ((type *) memcpy((char *) (to),(char *) (from),sizeof(type)))
  161.  
  162.  
  163.     /* Compiler-specific data items                      */
  164.  
  165. #if LAT200 | LAT210 | LAT300
  166. extern    char _dos[2];              /* MS-DOS version number          */
  167. #define utdosmajor  (_dos[0])
  168. #define utdosminor  (_dos[1])
  169. extern    ADS _psp;
  170. #define utpspseg    (_psp.s)          /* Segment of PSP           */
  171. #endif
  172.  
  173. #if MSC300
  174. #include <stdlib.h>
  175. #define utdosmajor  ((char) _osmajor) /* MS-DOS version number          */
  176. #define utdosminor  ((char) _osminor)
  177. #define utpspseg    ((unsigned) _psp) /* Segment of PSP           */
  178. #endif
  179.  
  180.     /* Function declarations.                          */
  181.  
  182. int  bdsx(int,int);              /* DOS gate for some functions  */
  183.                       /*                  */
  184. extern unsigned b_cxreg,b_dxreg;      /* Used by BDSX              */
  185.                       /*                  */
  186. int  dos(DOSREG *);              /* DOS function call          */
  187.                       /*                  */
  188. int  bios(unsigned,int *,int *,       /* General BIOS gate          */
  189.           int *,int *,int *);     /*                  */
  190. extern unsigned b_bp,b_es;          /* Used by BIOS gate          */
  191.                       /*                  */
  192. int  utintoff(void);              /* Disable (maskable) hardware  */
  193.                       /* interrupts.              */
  194.                       /*                  */
  195. int  utinton(void);              /* Enable hardware interrupts.  */
  196.                       /*                  */
  197. int  utslmove(ADS *,ADS *,unsigned);  /* Segment memory move          */
  198.                       /*                  */
  199. int  utsreg(unsigned *,unsigned *,    /* Return segment registers     */
  200.         unsigned *,unsigned *);   /*                  */
  201.                       /*                  */
  202. unsigned utdefds(void);           /* Return current DS register   */
  203.                       /* value.               */
  204.                       /*                  */
  205. int  utinit(DOSREG *);              /* Initialize DOSREG structure  */
  206.                       /*                  */
  207. unsigned long utabsptr(char *,ADS *); /* Convert data pointer into    */
  208.                       /* physical address.          */
  209.                       /*                  */
  210. unsigned long utcodptr(int (*)(),     /* Return physical address of   */
  211.                ADS *);          /* function.              */
  212.                       /*                  */
  213. float utrnd(unsigned *);          /* Random number generator      */
  214.                       /*                  */
  215. int  utgetclk(long *);              /* Get BIOS clock count.          */
  216.                       /*                  */
  217. unsigned utsleep(unsigned);          /* Suspend processing for a     */
  218.                       /* period.              */
  219.                       /*                  */
  220. int  utpause(char *);              /* Display message, await       */
  221.                       /* keystroke.              */
  222.                       /*                  */
  223. void utabort(char *);              /* Abort program with message   */
  224.                       /* to standard output.          */
  225.                       /*                  */
  226. void utspkon(unsigned);           /* Turn speaker on.          */
  227.                       /*                  */
  228. void utspkoff(void);              /* Turn speaker off.          */
  229.                       /*                  */
  230. void utsound(unsigned,unsigned);      /* Sound a tone for a period of */
  231.                       /* time.                  */
  232.  
  233.     /* Aliases for older versions                      */
  234.  
  235. #define utrdykey(pch,pscan)    (kbready(pch,pscan))
  236. #define utinkey(pscan)        (kbin(pscan))
  237. #define utshfkey(pkeybd)    (kbshift(pkeybd))
  238. #define _cxreg        b_cxreg
  239. #define _dxreg        b_dxreg
  240.  
  241. #define DEF_BUTILITY  1           /* Prevent second reading of    */
  242.                       /* these definitions.          */
  243.  
  244. #endif                      /* Ends "#ifndef DEF_BUTILITY"  */
  245.