home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 5 / 05.iso / a / a011 / 2.ddi / C86XBTV2.C < prev    next >
Encoding:
C/C++ Source or Header  |  1986-04-28  |  4.2 KB  |  135 lines
  1.  
  2. /*                                    */
  3. /*   Computer Innovations C86 interface to the                */
  4. /*         Btrieve Record Manager, version 4            */
  5. /*    Note: if compiling for the LARGE memory model, remove the    */
  6. /*          comments surrounding the following definition.        */
  7. /*
  8. #define _C86_BIG 1
  9. */
  10. #define BTRERR        20            /* record manager not started */
  11. #define BTRINT        0x7B        /* Btrieve interrupt vector */
  12. #define BTRVECTOR   BTRINT*4        /* offset for interrupt */
  13. #define BTROFFSET   0x33        /* Btrieve offset within segment */
  14. #define VARIABLE_ID 0x6176        /* id for variable length */
  15.                     /*   records - 'va' */
  16.  
  17. /* ProcId is used for communicating with the Multi Tasking Version of  */
  18. /* Btrieve. It contains the process id returned from BMulti and should */
  19. /* not be changed once it has been set.                    */
  20. /*                                       */
  21. int ProcId = 0;             /* initialize to no process id */
  22. static char MULTI = 0;              /* flag set to true if MultiUser */
  23. static char VSet = 0;        /* flag set to true if checked version */
  24.  
  25. struct regval { int ax,bx,cx,dx,si,di,ds,es; };
  26. struct segregs { int cs, ss, ds2, es2; };
  27.  
  28. btrv (op, pos, databuf, datalen, keybuf, keynum)
  29. int op;                 /* operation */
  30. char *pos;                /* position block */
  31. char *databuf;                /* data buffer */
  32. int  *datalen;                /* data buffer length */
  33. char *keybuf;                /* key buffer */
  34. int keynum;                /* key number */
  35. {
  36.     struct regval regs;        /* registers */
  37.     int stat;            /* Btrieve return status */
  38.     struct {
  39.       int  dataoff;         /* data buffer offset */
  40.       int  dataseg;         /* data buffer segment */
  41.       int  datalen;         /* data buffer length */
  42.       int  posoff;            /* position block offset */
  43.       int  posseg;            /* position block segment */
  44.       int  fcboff;            /* fcb offset */
  45.       int  fcbseg;            /* fcb segment */
  46.       int  opcode;            /* operation code */
  47.       int  keyoff;            /* key buffer offset */
  48.       int  keyseg;            /* key buffer segment */
  49.       char keylen;            /* key length */
  50.       char keynum;            /* key number */
  51.       int  statoff;         /* key buffer offset */
  52.       int  statseg;         /* key buffer segment */
  53.       int  language;        /* language id */
  54.       } btrparms;            /* Btrieve parameter block */
  55.  
  56. #ifndef _C86_BIG
  57. #define ptoreg(ptr,seg,off) ((off)=(ptr),(seg)=(rv.ds2))
  58.     struct segregs rv;        /* segment registers */
  59.  
  60.     segread (&rv);            /* get contents of segment regs */
  61. #else
  62. #define ptoreg(ptr,seg,off) ((off)=(unsigned long)(ptr),(seg)=((unsigned long)ptr)>>16)
  63. #endif
  64.  
  65.     /* verify that Btrieve is loaded */
  66.  
  67.     regs.ax = 0x3500 + BTRINT;    /* set DOS function */
  68.     sysint (0x21, ®s, ®s);    /* get interrupt vector */
  69.     if (regs.bx != BTROFFSET)    /* check for Btrieve not loaded */
  70.       return (BTRERR);        /* return bad status */
  71.  
  72.     if (!VSet)
  73.      {
  74.       VSet = 1;
  75.       regs.ax = 0x3000;
  76.       sysint (0x21, ®s, ®s);
  77.       if ((regs.ax & 0x00FF) >= 3)
  78.        {
  79.         regs.ax = 0xAB00;
  80.         sysint (0x2F, ®s, ®s);
  81.         MULTI = ((regs.ax & 0x00FF) == 'M');
  82.        }
  83.      }
  84.  
  85.     /* set up the Btrieve parameter block */
  86.  
  87.     ptoreg (databuf, regs.ds, regs.dx);
  88.     btrparms.dataoff = regs.dx;
  89.     btrparms.dataseg = regs.ds;
  90.     btrparms.datalen = *datalen;
  91.     ptoreg (&pos[38], regs.ds, regs.dx);
  92.     btrparms.posoff = regs.dx;
  93.     btrparms.posseg = regs.ds;
  94.     ptoreg (pos, regs.ds, regs.dx);
  95.     btrparms.fcboff = regs.dx;
  96.     btrparms.fcbseg = regs.ds;
  97.     btrparms.opcode = op;
  98.     ptoreg (keybuf, regs.ds, regs.dx);
  99.     btrparms.keyoff = regs.dx;
  100.     btrparms.keyseg = regs.ds;
  101.     btrparms.keylen = 255;
  102.     btrparms.keynum = keynum;
  103.     ptoreg (&stat, regs.ds, regs.dx);
  104.     btrparms.statoff = regs.dx;
  105.     btrparms.statseg = regs.ds;
  106.     btrparms.language = VARIABLE_ID;
  107.  
  108.     /* invoke the Btrieve record manager */
  109.  
  110.     ptoreg (&btrparms, regs.ds, regs.dx);
  111.  
  112.     if (!MULTI)
  113.       sysint(0x7B, ®s,®s);
  114.     else
  115.      {
  116.       while (1)
  117.        {
  118.         regs.ax = 1;              /* assume no process id */
  119.         if ((regs.bx = ProcId) != 0)/* already have a process id? */
  120.           regs.ax = 2;              /* yes, let BMulti know */
  121.         regs.ax += 0xAB00;
  122.         sysint (0x2F, ®s, ®s);          /* call Btrieve */
  123.         if ((regs.ax & 0x00FF) == 0) break;
  124.         regs.ax = 0x0200;
  125.         sysint (0x7F, ®s, ®s);
  126.        }
  127.       if (ProcId == 0) ProcId = regs.bx;
  128.      }
  129.  
  130.     /* return status code and length of data returned */
  131.  
  132.     *datalen = btrparms.datalen;
  133.     return (stat);
  134. }
  135.