home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 5 / 05.iso / a / a011 / 2.ddi / LCXBTRV3.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-12-08  |  6.1 KB  |  159 lines
  1. #include <dos.h>
  2.  
  3. /*                                                                      */
  4. /* Lattice C interface to the Btrieve Record Manager, version 3.x and above */
  5. /*                                                                      */
  6. /*      Note: if compiling for the "D" or "L" memory model, remove      */
  7. /*            the comments surrounding the following definition.        */
  8. /*                                                                      */
  9. /*                                  LMODEL means 32-bit pointers in use */
  10. /* #define LMODEL 1      */
  11.  
  12.  
  13. #define BTR_ERR     20                    /* record manager not started */
  14. #define BTR_INT     0x7B                    /* Btrieve interrupt vector */
  15. #define BTR2_INT    0x2F                 /* multi-user interrupt vector */
  16. #define BTR_VECTOR  BTR_INT * 4                 /* offset for interrupt */
  17. #define BTR_OFFSET  0x33               /* Btrieve offset within segment */
  18. #define VARIABLE_ID 0x6176     /* id for variable length records - 'va' */
  19. #define _2FCODE     0xAB00       /* function code for int 2F to btrieve */
  20.  
  21. /* ProcId is used for communicating with the Multi Tasking Version of  */
  22. /* Btrieve. It contains the process id returned from BMulti and should */
  23. /* not be changed once it has been set.                                */
  24. /*                                                                     */
  25.  
  26. static unsigned ProcId = 0;             /* initialize to no process id */
  27. static char MULTI = 0;                /* flag set to true if MultiUser */
  28. static char VSet = 0;           /* flag set to true if checked version */
  29.  
  30. BTRV (OP, POS_BLK, DATA_BUF, DATA_LEN, KEY_BUF, KEY_NUM)
  31.   int  OP;
  32.   char POS_BLK[];
  33.   char DATA_BUF[];
  34.   int  *DATA_LEN;
  35.   char KEY_BUF[];
  36.   int  KEY_NUM;
  37.  
  38. {
  39. struct REGVAL { short AX, BX, CX, DX, SI, DI; } REGS;
  40.  
  41. struct SEGREG { short ES, CS, SS, DS; } SREGS;
  42.  
  43. struct BTRIEVE_PARMS      /* structure passed to Btrieve Record Manager */
  44.  {
  45.    char *BUF_OFFSET;                      /* callers data buffer offset */
  46. #ifndef LMODEL
  47.    int   BUF_SEG;                        /* callers data buffer segment */
  48. #endif
  49.    int   BUF_LEN;                              /* length of data buffer */
  50.    char *CUR_OFFSET;                      /* user position block offset */
  51. #ifndef LMODEL
  52.    int   CUR_SEG;                        /* user position block segment */
  53. #endif
  54.    char *FCB_OFFSET;                              /* offset of disk FCB */
  55. #ifndef LMODEL
  56.    int   FCB_SEG;                                /* segment of disk FCB */
  57. #endif
  58.    int   FUNCTION;                                /* requested function */
  59.    char *KEY_OFFSET;                     /* offset of user's key buffer */
  60. #ifndef LMODEL
  61.    int   KEY_SEG;                       /* segment of user's key buffer */
  62. #endif
  63.    char  KEY_LENGTH;                     /* length of user's key buffer */
  64.    char  KEY_NUMBER;                    /* key of reference for request */
  65.    int  *STAT_OFFSET;                          /* offset of status word */
  66. #ifndef LMODEL
  67.    int   STAT_SEG;                            /* segment of status word */
  68. #endif
  69.    int   XFACE_ID;                               /* language identifier */
  70.  } XDATA;
  71.  
  72. int STAT = 0;                                 /* status of Btrieve call */
  73.  
  74. /*                                                                      */
  75. /*  Check to see that the Btrieve Record Manager has been started.      */
  76. /*                                                                      */
  77.  
  78. REGS.AX = 0x3500 + BTR_INT;
  79. int86x (0x21, (union REGS *) ®S, (union REGS *) ®S, (struct SREGS *) &SREGS);
  80. if (REGS.BX != BTR_OFFSET)
  81.    return (BTR_ERR);
  82.  
  83. if (!VSet)
  84.  {
  85.   VSet = 1;
  86.   REGS.AX = 0x3000;
  87.   int86x (0x21, (union REGS *) ®S, (union REGS *) ®S, (struct SREGS *) &SREGS);
  88.   if ((REGS.AX & 0x00FF) >= 3)
  89.    {
  90.     REGS.AX = _2FCODE;
  91.     int86x (BTR2_INT, (union REGS *) ®S, (union REGS *) ®S, (struct SREGS *) &SREGS);
  92.     MULTI = ((REGS.AX & 0xFF) == 'M');
  93.    }
  94.  }
  95.  
  96. /*  Read segment registers and initialize segment part of addresses to  */
  97. /*  user's data segment.                                                */
  98. /*                                                                      */
  99.  
  100. segread ((struct SREGS *) &SREGS);
  101. #ifndef LMODEL
  102. XDATA.BUF_SEG = XDATA.CUR_SEG = XDATA.FCB_SEG =
  103.   XDATA.KEY_SEG = XDATA.STAT_SEG = SREGS.SS;
  104. #endif
  105.  
  106. /*                                                                      */
  107. /*  Move user parameters to XDATA, the block where Btrieve expects them.*/
  108. /*                                                                      */
  109.  
  110. XDATA.FUNCTION    = OP;
  111. XDATA.STAT_OFFSET = &STAT;
  112. XDATA.FCB_OFFSET  = POS_BLK;
  113. XDATA.CUR_OFFSET  = POS_BLK + 38;
  114. XDATA.BUF_OFFSET  = DATA_BUF;
  115. XDATA.BUF_LEN     = *DATA_LEN;
  116. XDATA.KEY_OFFSET  = KEY_BUF;
  117. XDATA.KEY_LENGTH  = 255;                 /* use max since we don't know */
  118. XDATA.KEY_NUMBER  = KEY_NUM;
  119. XDATA.XFACE_ID    = VARIABLE_ID;
  120.  
  121. /*                                                                      */
  122. /*  Make call to the Btrieve Record Manager.                            */
  123. /*                                                                      */
  124.  
  125. #ifdef LMODEL
  126. REGS.DX = (int) FP_OFF(&XDATA);                /* parameter block in DX */
  127. #else
  128. REGS.DX = (int) &XDATA;
  129. #endif
  130.  
  131. SREGS.DS = SREGS.SS;
  132. if (!MULTI)
  133.   int86x (BTR_INT, (union REGS *) ®S, (union REGS *) ®S, (struct SREGS *) &SREGS);
  134. else
  135.  {
  136.   while (1)
  137.    {
  138.     REGS.AX = 1;
  139.     if ((REGS.BX = ProcId) != 0)
  140.       REGS.AX = 2;
  141.     REGS.AX += _2FCODE;
  142. #ifdef LMODEL
  143.     REGS.DX = (int) FP_OFF(&XDATA);           /* parameter block in DX */
  144. #else
  145.     REGS.DX = (int) &XDATA;
  146. #endif
  147.     SREGS.DS = SREGS.SS;
  148.     int86x (BTR2_INT, (union REGS *) ®S, (union REGS *) ®S, (struct SREGS *) &SREGS);
  149.     if ((REGS.AX & 0x00FF) == 0) break;
  150.     REGS.AX = 0x0200;
  151.     int86x (0x7F, (union REGS *) ®S, (union REGS *) ®S, (struct SREGS *) &SREGS);
  152.    }
  153.   if (ProcId == 0) ProcId = REGS.BX;
  154.  }
  155.  
  156. *DATA_LEN = XDATA.BUF_LEN;
  157. return (STAT);                                         /* return status */
  158. }
  159.