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