Liren Large Software Subsidy 5

home *** CD-ROM | disk | FTP | other *** search

/ Liren Large Software Subsidy 5 / 05.iso / a / a011 / 2.ddi / INTRFACE.DOC < prev next >

Wrap

Text File | 1990-05-24 | 38.3 KB | 1,100 lines

May 1990 Btrieve DOS v5.10 *************************** NEW INTERFACES ************************** BASIC: BC7RBTRV.OBJ, BC7XBTRV.ASM Microsoft BASIC v7.0 QB6PBTRV.OBJ Microsoft BASIC v6.0; Microsoft QuickBasic v4.0, v6.0 IBM BASIC v1.0, v2.0, v3.0 IBM BASIC/2 for OS/2 C: *C2XBTRV.C IBM C/2 for OS/2 C2FXBTRV.C IBM C/2 for OS/2(family application) LCXBTRV3.C Lattice C v3.0 WAT2BTRV.C WATCOM C COBOL: COBPBTRV.OBJ Micro Focus COBOL/2 Microsoft v3.0 RM8XBTRV.EXE RM/COBOL-8X PASCAL: TUR5BTRV.PAS Borland Turbo Pascal v5.0 * Not distributed with Btrieve v5.1 for DOS ************************ UPDATED INTERFACES ************************* The code for these interfaces has been updated. The documentation is located with the other interface documentation for that language. BASIC: QB6RBTRV.OBJ Microsoft BASIC v6.0 Microsoft QuickBasic v4.0, v6.0 IBM BASIC v1.0, v2.0, v3.0 IBM BASIC/2 for OS/2 See "NEW INTERFACE WITH THIS RELEASE/QB6PBTRV.OBJ" section COBOL: COBRBTRV.OBJ Micro Focus COBOL/2 Microsoft v3.0 Realia COBOL See "NEW INTERFACE WITH THIS RELEASE/COBPBTRV.OBJ" section Note: We changed the name of RCOBBTRV.OBJ(Btrieve v5.0 and Btrieve v5.1 VAP) to COBRBTRV.OBJ for this release because of the naming convention adopted for all Btrieve interfaces. COBXBTRV.OBJ Microsoft COBOL See Appendix E of Btrieve Programmer's Manual RMXBTRV.EXE RM COBOL PASCAL: TUR4BTRV.PAS Borland Turbo Pascal v4.0 ************************* CURRENT INTERFACES ************************ BASIC: BASIC interface for the TI Borland Turbo Basic Digital Research CBASIC (CB-86) Generic BASIC Microsoft QuickBasic v3.0 Notes on Microsoft QuickBasic v4.0 C: Ci-C86 DeSmet C Lattice C Mark Williams C Turbo C COBOL: MBP COBOL-85 MBP COBOL Micro Focus COBOL/2 Micro Focus COBOL Realia COBOL RM COBOL FORTRAN: Microsoft Fortran MODULA: Logitech Modula-2/86 PASCAL: Borland Turbo Pascal Metaware Pascal SBB Pascal ********************************************************************* HOW TO USE THE NOTES ON INTERFACES: This document describes interfaces for languages and implementations of languages not included in the manual. The descriptions here should be used in addition to the information in the manual. For example, to use Metaware Pascal, read the "Interfacing Btrieve with Pascal" section of Appendix D in the Btrieve Programmer's Manual then refer to this document for differences between the Microsoft Pascal implementations described in the manual and Metaware Pascal. ===================================================================== NEW INTERFACES WITH THIS RELEASE --------------------------------------------------------------------- Microsoft Basic v7.0 File: BC7RBTRV.OBJ (DOS or OS/2 Real mode interface) BC7XBTRV.ASM (Source file) Calling Procedure from Microsoft Basic v7.0 BTRVFAR(Op%,Status%,PosBlk$,VARPTR(DataBuf),VARSEG(DataBuf), DLen%,KeyBuf$,KeyNum%) or BTRVFAR(Op%,Status%,PosBlk$,SADD(DataBuf$),SSEG(DataBuf$), DLen%,KeyBuf$,KeyNum%) Note: 1. Use VARPTR/VARSEG pair if DataBuf parameter is defined using the record method. (Ex. Defined as TYPE --- END TYPE) 2. USE SADD/SSEG pair if DataBuf parameter is defined using the field method. (Ex. Defined using Field statement). 3. Don't pass a fixed-length string as any of Btrieve parameters since BASIC's sending and receiving parameters can only be variable-length string (Microsoft Basic v7.0 Programmer's Guide p.489). Example: A is variable-length string: A$ = "valiable length string" A is fixed-length string: DIM A AS STRING * 10 For more information about Variable- and Fixed- length strings, please see Microsoft Basic v7.0 Programmer's Guide p.135. 4. OS.INC is needed for assembling BC7XBTRV.ASM. Set the value in OS.INC according to your environment. --------------------------------------------------------------------- Microsoft BASIC v6.0 Microsoft QuickBasic v4.0, v6.0 IBM BASIC v1.0, v2.0, v3.0 IBM BASIC/2 for OS/2 Files: QB6RBTRV.OBJ (DOS or OS/2 Real mode interface) ==> UPDATED QB6PBTRV.OBJ (OS/2 Protect mode interface) These interfaces are for Basic programs that need to use both near and far pointers. This interface supports two different calls to Btrieve in one interface. If you are accessing NEAR (16-bit data buffer pointers) then use the BTRV call with 7 parameters; if you are accessing FAR (32-bit data buffer pointers) then use the BTRVFAR call with 8 parameters. If you are using the OS/2 requester, the interface QB6PBTRV.OBJ must be linked with the application as well as the static library BTRCALLS.LIB. The Btrieve dynamically linked library should be in a directory specified in your LIBPATH environmental variable. This interface module is not a family application. It runs in protected mode only. If you are writing a DOS application, the interface QB6RBTRV.OBJ must be linked with the application. You do NOT need BTRCALLS.LIB. To call the interfaces, the format is the same for QB6RBTRV and QB6PBTRV. For near data buffer pointers: BTRV (op%, Status%, PosBlk$, VARPTR (dBuf(1)),_ dlen%, KeyBuf$, KeyNum%) For far data buffer pointers: BTRVFAR (op%, Status%, PosBlk$, VARPTR (dBuf(1)),VARSEG (dBuf(1)),_ dlen%, KeyBuf$, KeyNum%) Note: If an array variable is dimensioned with REDIM, BASIC places that array in ITS own data segment creating the need for a "far" call. If the array is dimensioned with simply DIM, it is defined locally. --------------------------------------------------------------------- IBM C/2 for OS/2 File: *C2XBTRV.C (OS/2) C2FXBTRV.C (famliy application) See C interface section * Not distributed with Btrieve v5.1 for DOS --------------------------------------------------------------------- Lattive C v3.0 File: LCXBTRV3.C See C interface section --------------------------------------------------------------------- WATCOM C File: WAT2BTRV.C See C interface section --------------------------------------------------------------------- Micro Focus COBOL/2 Microsoft COBOL v3.0 Realia COBOL(COBRBTRV.OBJ only) Files: COBRBTRV.OBJ (DOS or OS/2 Real mode interface) ==>UPDATED COBPBTRV.OBJ (OS/2 Protect mode interface) These interfaces are similar to MF2BTRV.OBJ, but it does not require the CSUPPORT.OBJ file, nor the C compiler. The .OBJ file appropriate to your environment is linked with your COBOL program. In order to use this COBOL interface, compile your COBOL program and link it with the .OBJ file. Refer to the documentation on MF2BTRV.OBJ for the call to Btrieve and the data types that should be used, as they are the same. NOTE: COBRBTRV.OBJ may also be used with Realia COBOL. --------------------------------------------------------------------- Ryan-McFarland COBOL-8x File: RM8XBTRV.EXE The interface to RM COBOL-8x is loaded by the COBOL runtime during the first call to Btrieve. Note: Please refer to RM/COBOL interface if you are using RM/COBOL (the versions before RM/COBOL-8x). Calling Procedure from COBOL CALL "RM8XBTRV.EXE" USING FUNCTION, STATUS, POSITION-BLOCK, DATA-RECORD, DATA-LEN, KEY-VALUE, KEY-NUMBER. where: FUNCTION - function number for request (COMP-1) STATUS - return status from request (COMP-1) POSITION-BLOCK - 128-byte buffer DATA-RECORD - User data buffer DATA-LEN - Length of data buffer (COMP-1) KEY-VALUE - string pointer to key buffer KEY-NUMBER - key number to be processed (COMP-1) Note: For Create, Status, and Create Supplemental Index, the Extended-Key-Type field of Key Specs should be declared as follows: Ext-Key-Type COMP-6 --------------------------------------------------------------------- Borland Turbo Pascal v5.0 File: TUR5BTRV.PAS (source file) TUR5BTRV.TPU (compiled TPU file) 1.TUR5BTRV.PAS is defined as a unit and should be compiled as a TPU file. 2.Turbo Pascal v5.0 requires this interface which uses the same calling and type conventions as TURXBTRV.PAS. This interface cannot be used with previous versions of Turbo Pascal. ===================================================================== CURRENT INTERFACES --------------------------------------------------------------------- BASIC on the TI Files: BTIXBTRV.OBJ for compiled BASIC and BTIXBTRV.EXE for interpretive BASIC on the TI. Previous documentation on BASIC for the TI incorrectly stated that the use of this interface is the same as the BASIC described in the manual. This is not correct. The interface uses a string variable defined within the program, called the position block. Because the position block is a separate variable from the Basic file buffer, it must be passed as a separate parameter on the Btrieve call. The format for the Btrieve call is: call BTRV(op%,stat%,posblk$,fileptr%,dbuflen%,keybuf$,keynum%) where: op% = Btrieve operation number stat% = Btrieve status return posblk$ = Btrieve position block fileptr% = varptr value to file buffer dbuflen% = data buffer length keybuf$ = key buffer keynum% = file index path number The position block variable, posblk$, is placed in the parameter list ahead of the file pointer. The following is a list of do's and don't's for using the position block. 1. Create a unique position block for each Btrieve file you open. 2. Initialize each position block to 128 spaces. 3. Never write to the position block once you have initialized it to 128 spaces. 4. Be sure to pass the correct position block for the file you are accessing on the Btrieve call. Failure to do so may result in corrupted files, or a Btrieve error 2. --------------------------------------------------------------------- Borland Turbo Basic File: TURBBTRV.BAS - for Btrieve v4.0x and above The interface is written in Turbo Basic; using the metastatement $INCLUDE "TURBBTRV.BAS" allows the application to access the interface. This interface has two differences from most BASIC interfaces. First, it uses a separate string variable for the position block, instead of using the FCB within the file buffer. Second, the data buffer address is not obtained using the fileptr function, but the first field of the field statement of the file is sent. The format for the Btrieve call using the Turbo Basic interface is: CALL BTRV (OP%, STATUS%, POSITION$, FILE$, DATALEN%, KEYBUF$, KEYNUM%) where: OP% - function number for request STATUS% - return status from request POSITION$ - 128-byte data area for FCB and positioning, not to be changed by user FILE$ - address of data buffer from FIELD function DATALEN% - length of user data buffer KEYBUF$ - string pointer to key buffer KEYNUM% - key number to be processed The position block variable, POSITION$, has been inserted into the parameter list ahead of the data buffer pointer. The following is a list of do's and don't's for using the position block. 1. Create a unique position block for each Btrieve file you open. 2. Initialize each position block to 128 spaces. 3. Never write to the position block once you have initialized it to 128 spaces. 4. Be sure to pass the correct position block for the file you are accessing on the Btrieve call. Failure to do so may result in corrupted files, or a Btrieve error 2. It is important to keep the position blocks for the files distinct from each other. Btrieve will sometimes write back to the position block variable, and use that information on the next access to that file. This sample code illustrates how to open a file and get the first record by key path 0 using Turbo Basic. Note that the extra fielding statement for FILE1.BUF is not necessary, but ensures that the correct field is sent to Btrieve. $INCLUDE "TURBBTRV.BAS" OPEN "NUL" AS #1 LEN = 40 FIELD #1, 40 AS FILE1.BUF$ FIELD #1, 5 AS F1.KEY1$, 4 AS F1.KEY2$, 31 AS F1.REST$ DLEN% = 0 OP1% = 0 FileName$ = "example.btr" + CHR$(0) POSITION$ = SPACE$ (128) LET KEYNUM% = 0 CALL BTRV (OP1%, STATUS1%, POSITION$, FILE1.BUF$,_ DLEN%, FileName$, KEYNUM%) IF (STATUS1% <> 0), THEN PRINT "operation is " OP1% "status is" STATUS1% END IF KEYNUM% = 0 DLEN% = 40 OP1% = 12 CALL BTRV (OP1%, STATUS1%, POSITION$, FILE1.BUF$,_ DLEN%, F1.KEY1$, KEYNUM%) IMPORTANT NOTES: This interface changes the data segment which is used by BLOAD, BSAVE, CALL ABSOLUTE, PEEK, and POKE, because it does a DEF SEG. Thus, if these commands are used after a call to BTRV, it is important to do a DEF SEG after the BTRV call and before using the above statements. Unlike some BASIC interpreters, Turbo Basic checks that the number and type of the arguments to a procedure (such as BTRV) agree with the formal parameters. Static variables are not visible outside the subroutine, so it is not possible for another part of the application to change them. They must be static because their values must be retained between calls to BTRV. Note that all string parameters must be within the string segment. --------------------------------------------------------------------- Digital Research CBASIC (CB-86) Files: CBXBTRV.OBJ - the CB-86 interface for BTRV; CBTESTVA.BAS - a CB-86 program to demonstrate use of the interface; CBIGET.OBJ - a subroutine used by CB-86 routines calling Btrieve; CBISET.OBJ - a subroutine used by CB-86 routines calling Btrieve; The DOS commands listed below, for CBTESTVA, illustrate how to compile and link a program that can call the Btrieve Record Manager. These commands assume that the compiler and its ".OR?" files, the linker, and the CB-86 object library exist on the default directory. 1) CB86 cbtestva 2) LINK86 cbtestva,cbxbtrv,cbiget,cbiset You may then execute the demo program with the following DOS command: 3) cbtestva The subroutines CBISET and CBIGET are provided for your convenience only and are not needed if you have another method for transferring integer data to/from string variables. --------------------------------------------------------------------- Generic BASIC Files: B86XBTRV.OBJ for compiled BASIC and B86XBTRV.EXE for interpretive Generic BASIC. Previous documentation on Generic BASIC incorrectly stated that the use of this interface is the same as the BASIC described in the manual. This is not correct. See the description under TI BASIC for the proper format for the Btrieve call. --------------------------------------------------------------------- Microsoft QuickBasic v3.0 File: QBIXBTRV.OBJ - for Btrieve v4.0x and above Note: Releases of this documentation before Btrieve 4.11 contained an error in the example code. The statement fileptr% = varptr(f%) should have read fileptr% = varptr(#(f%)) This interface to Microsoft QuickBasic prevents several inconsistent errors which QuickBasic returned when data files were closed. The most common errors were: Device I/O error Bad File Mode Bad File Number. Use this interface, QBIXBTRV.OBJ, instead of BASXBTRV.OBJ. You can also use it for the IBM Basic Compiler v2.0, but NOT for interpreted Basic. The BASXBTRV.OBJ interface, which worked correctly with earlier versions of Quick Basic, used the Basic FCB to store information concerning the Btrieve file. It appears that QuickBasic looks at the FCB space before the close operation. If that area has been written to, it issues an error. The new interface does not write to the Basic FCB space, but uses a string variable defined within the program instead. This variable is called the position block. Because the position block is a separate variable from the Basic file buffer, it must be passed as a separate parameter on the Btrieve call. The format for the Btrieve call using this QBIXBTRV.OBJ interface is: call BTRV(op%,stat%,posblk$,fileptr%,dbuflen%,keybuf$,keynum%) where: op% = Btrieve operation number stat% = Btrieve status return posblk$ = Btrieve position block fileptr% = varptr value to file buffer dbuflen% = data buffer length keybuf$ = key buffer keynum% = file index path number The position block variable, posblk$, has been inserted into the parameter list ahead of the file pointer. The following is a list of do's and don't's for using the position block. 1. Create a unique position block for each Btrieve file you open. 2. Initialize each position block to 128 spaces. 3. Never write to the position block once you have initialized it to 128 spaces. 4. Be sure to pass the correct position block for the file you are accessing on the Btrieve call. Failure to do so may result in corrupted files, or a Btrieve error 2. Tip: Set up a string array for the position blocks, with the array element number corresponding to the file number of the file you are accessing. The array element is then passed to Btrieve on the call. This assures that the correct position block is always passed. The following code segment illustrates one way this might be done. numfiles% = 3 '3 Btrieve files option base 1 'use 1 as base of array 'because first file number 'is 1. Option base 1 is used 'here for convenience. dim posarray$(numfiles%) 'number of position block 'array elements set to number 'of Btrieve files for i = 1 to numfiles% posarray$(i) = space$(128) 'initialize array to blanks next i . . . f% = 1 'set file number fileptr% = varptr(#(f%)) 'set file pointer call BTRV(op%,stat%,posarray(f%),fileptr%,dbuflen%,keybuf$, keynum%) It is important to keep the position blocks for the files distinct from each other. That is why this example passes the position block as an element of an array. Btrieve will sometimes write back to the position block variable, and use that information on the next access to the file. Also, be sure not to define the position blocks in a subroutine or library which is compiled separately from the main program, and then try to declare them as shared ( see the QuickBasic manual, p.122 ). Either the field method or the record type method may be used. To use the field method, you must replace your varptr statement with SADD (first fielded variable). To use the record type method, you must define your type, dimension an array as that type, and use varptr (array name) to identify the buffer. --------------------------------------------------------------------- Notes on Microsoft QuickBasic v4.0 Files: QB6PBTRV.OBJ (OS2 or Protect mode interface) QB6RBTRV.OBJ (DOS or Real mode interface) ==> UPDATED QBIXBTRV.OBJ with patch With versions of QuickBasic prior to 4, when the FCB% was evaluated, VARPTR (#1), QBIXBTRV had to skip 188 bytes of overhead from the address returned, to get to the actual data. Therefore, the QBIXBTRV interface would add 188 to the FCB% address that was passed in. If you are using version 4 of QuickBasic, the way that the FCB% is calculated gives the actual address at which the data starts. Since the QBIXBTRV interface still adds 188 to the address passed to it, we previously recommended that the application subtract 188 from the address prior to passing it to QBIXBTRV. This can cause problems if the actual address is less than 188! To avoid this problem, apply the following patch to QBIXBTRV and do NOT subtract 188 from your FCB%. The patched interface will NOT work with versions of QuickBasic before 4. type: DEBUG QBIXBTRV.OBJ type: -E 167 system returns: xxxx:0167 BC. type: 00 <enter> type: -W system returns: Writing xxx bytes type: -Q Either use the field method or the record type method may be used. To use the field method, you must replace your varptr statement with SADD (first fielded variable). To use the record type method, you must define your type, dimension an array as that type, and use varptr (array name) to identify the buffer. FIELD METHOD: ---------------------------------------------------- OPEN "NUL" AS #1 LEN=40 FIELD #1,20 AS F1NAME$, 10 AS F1TEL$, 2 AS F1ID$, 8 AS F1BAL$ OP% = 0 POSBLK$ = SPACE$ (128) KEYBUF$ = "MYFILE.BTR " KEYNUM% = 0 FCB% = SADD (F1NAME$) BUFLEN% = 40 CALL BTRV (OP%, STAT%, POSBLK$, FCB%, BUFLEN%, KEYBUF$, KEYNUM%) RECORD METHOD ---------------------------------------------------- TYPE DATABUFFER NAME AS STRING * 20 TEL AS STRING * 10 ID AS INTEGER BAL AS DOUBLE END TYPE DIM FIL1 AS DATABUFFER OP% = 0 POSBLK$ = SPACE$ (128) KEYBUF$ = "MYFILE.BTR " KEYNUM% = 0 FCB% = VARPTR (FIL1) 'or = VARPTR (FIL1.NAME) BUFLEN% = 40 CALL BTRV (OP%, STAT%, POSBLK$, FCB%, BUFLEN%, KEYBUF$, KEYNUM%) ===================================================================== C Interfaces Files: Borland Turbo C see next section Ci-C86 v1.0 C86XBTRV.C Ci-C86 v2.0 C86XBTV2.C DeSmet C DESXBTRV.C Lattice C v3.0, v6.0 LCXBTRV3.C Lattice C v2.0, v6.0 LCXBTRV2.C Lattice C v1.0 LCXBTRV.OBJ Mark Williams C MWCXBTRV.C Microsoft C MSCXBTRV.C IBM C/2 *C2XBTRV.C ==> NEW IBM C/2 C2FXBTRV.C(family application) ==> NEW Watcom C WAT2BTRV.C ==> NEW *Not distributed with Btrieve v5.1 for DOS The only difference in using the interfaces is the name of the file to include when you link your program. The format of the calls to Btrieve is identical for each. To use an interface with large model, look at the source code of the interface to see if comments must be removed from a statement. If a Microsoft C program is compiled specifically for Microsoft Windows, a comment in the source must be removed. After your C program has been successfully compiled, it must be linked with the C Interface. For a complete explanation of linking, which varies slightly depending on the compiler being used, refer to your operating system manual and your C reference manual. Special Notes: Ci-C86: Since version v1.0 and v2.0 of the Ci-C86 compiler generate different object files, you should compile the interface with your own compiler. Then link the resulting object file with your C program. Lattice C: Since version v1.0 of the Lattice C compiler uses different calling conventions from versions v2.0 and v3.0, there are 3 kinds of Lattice C interfaces on the Btrieve Diskette. If you are using Version v1.0, link your program with interface LCXBTRV.OBJ. Otherwise compile and use LCXBTRV2.C or LCXBTRV3.C. LCXBTRV3.C eliminates complier warnings that occurred when LCXBTRV2.C was used with Version v3.0. If you are using version 6.0 of Lattice C, recompile the interface ICXBTRV3.C with version 6.0. --------------------------------------------------------------------- Borland Turbo C TURCBTRV.C - for Btrieve v4.0x and above This interface is written in Turbo C. You may use the preprocessor control line #include "TURCBTRV.C" or link the compiled interface with the rest of the application. It is important that the interface is compiled in the same model as the rest of the program. The format for the Btrieve call using the Turbo C interface is the same as for the other C compilers. IMPORTANT NOTE: If you compile the program using a memory model which allows more than one data segment, such as compact, large, or huge, the preprocessor statement which defines LMODEL must be uncommented. The interface will not work in these models if you send an integer constant for character arrays, even if Btrieve does not require the parameter. This is because only the integer will be placed on the stack when an offset and segment is expected. For example, use BTRV (op, pos, databuf, &dblen, key, 0); /* pos, data, key buf are arrays */ not BTRV (op, 0, databuf, &dblen, key, 0); ===================================================================== MBP COBOL-85 Files: MBP85BTV.OBJ, MBP85FAC.OBJ MBP has supplied the above files to allow MBP COBOL-85 to interface with Btrieve. The parameters are the same type as for the other MBP COBOL interface. Link the .OBJ file with your other MBP COBOL files. The MBP85BTV file has the following calling convention: CALL "BTRV" USING FUNCTION, STATUS, POSITION-BLOCK, DATA-RECORD, DATA-LEN, KEY-VALUE, KEY-NUMBER. The MBP85XFAC file is for use with Btrieve v3.15 or earlier: CALL "BTRIEVE" USING FUNCTION, STATUS, POSITION-BLOCK, DATA-RECORD, KEY-VALUE, KEY-NUMBER. --------------------------------------------------------------------- MBP COBOL Files: MBPXBTRV.OBJ. All calls to Btrieve from an MBP COBOL program must be in the following format: CALL 'BTRV' USING OPERATION, B-STATUS, POSITION-BLOCK, DATA-BUFFER, DATA-LEN, KEY-BUFFER, KEY-NUMBER. where: FUNCTION - function number for request COMP-1 STATUS - return status from request COMP-1 POSITION-BLOCK - 128 byte buffer record DATA-RECORD - User data buffer record DATA-LEN - Length of the user's data buffer COMP-1 KEY-VALUE - string pointer to key buffer record KEY-NUMBER - key number to be processed COMP-1 All integer variables you pass to Btrieve should have a picture of COMP-1. This includes the function code, the key number, the return status, the data length, and the integer variables in the file description required for a Create or Stat operation. The other parameters are record variables. --------------------------------------------------------------------- Micro Focus COBOL/2 Files: MF2BTRV.OBJ, CSUPPORT.OBJ An interface is available for the new Micro Focus COBOL/2 which supports the default model, HUGE. The two .OBJ files are linked with your COBOL program. In order to use this COBOL interface, write the Btrieve call as described below, compile your COBOL program and link it with the .OBJ files. You may need to specify additional link parameters, such as the COBOL library LCOBOL. NOTE: Unresolved externals errors were returned during linking when MINITC was being used. Micro Focus supplies alternate routines MSSTART and MS2COB. They are available on the Micro Focus bulletin board as MSSTART.ARC (415-856-1942) or under CompuServe as MF2LNK.ARC. CALL "_BTRV" USING FUNCTION, STATUS, POSITION-BLOCK, DATA-RECORD, DATA-LEN, KEY-VALUE, KEY-NUMBER. where: FUNCTION - function number for request PIC 9999 COMP-5. STATUS - return status from request PIC 9999 COMP-5. POSITION-BLOCK - 128-byte buffer DATA-RECORD - User data buffer DATA-LEN - Length of user data buffer PIC 9999 COMP-5. KEY-VALUE - string pointer to key buffer KEY-NUMBER - key number to be processed PIC 9999 COMP-5. All integer variables you pass to Btrieve should have a picture of 9(4) COMP-5. This includes the function code, the key number, the return status, the data buffer length, and the integer variables in the file description required for a create or stat operation. A COBOL program which uses previous versions of Micro Focus COBOL will have to make the following changes to work with COBOL/2. 1) change call from "MFXBTRV.BIN" to call "_BTRV" 2) Change Btrieve operation, status, and key number parameters from PIC 9999 COMP to PIC 9(4) COMP-5. Other considerations include the following: 1) No BY VALUE or BY REFERENCE phrases are needed for the BTRV parameters. 2) The status of the BTRV call is put in both the COBOL/2 predefined variable RETURN-CODE and the STATUS parameter to Btrieve. Either variable may be checked, but the STATUS parameter must always be sent. 3) Some additional COBOL PICS are supported as key types with 4.10 Btrieve. COMP-5, if it is 2 bytes, ie, the PIC is 99 or 9999, is SIGNED type if the PIC is signed; is UNSIGNED or BINARY if the PIC is unsigned. COMP-3 or PACKED-DECIMAL is DECIMAL. --------------------------------------------------------------------- Micro Focus COBOL Files: MFXBTRV.BIN. The interface to Micro Focus COBOL is loaded by the COBOL runtime during the first call to Btrieve. In order to use the Micro Focus COBOL Interface, call Btrieve as follows: CALL "MFXBTRV.BIN" USING FUNCTION, STATUS, POSITION-BLOCK, DATA-RECORD, DATA-LEN, KEY-VALUE, KEY-NUMBER. where: FUNCTION - function number for request PIC 9999 COMP. STATUS - return status from request PIC 9999 COMP. POSITION-BLOCK - 128-byte buffer DATA-RECORD - User data buffer DATA-LEN - Length of user data buffer PIC 9999 COMP. KEY-VALUE - string pointer to key buffer KEY-NUMBER - key number to be processed PIC 9999 COMP. All integer variables you pass to Btrieve should have a picture of 9999 COMP. This includes the function code, the key number, the return status, the data buffer length, and the integer variables in the file description required for a Create or Stat operation. --------------------------------------------------------------------- Realia COBOL Files: REAXBTRV.OBJ. Link the interface with your Realia COBOL application. In order to use the Realia COBOL Interface, call Btrieve as follows: CALL 'BTRV' USING FUNCTION, POSITION-BLOCK, DATA-RECORD, DATA-LEN, KEY-VALUE, KEY-NUMBER. where: FUNCTION - function number for request POSITION-BLOCK - 128-byte buffer DATA-RECORD - data buffer DATA-LEN - data buffer length KEY-VALUE - string pointer to key buffer KEY-NUMBER - key number to be processed Your application should check the RETURN-CODE variable after each call for the status of the operation. This is a requirement of the compiler. Refer to the Realia COBOL compiler documentation for more information. All integer variables you pass to Btrieve should be of type COMP-5. This includes the function code, the key number, the data buffer length, and the integer variables in the file description required for the create or stat operations. --------------------------------------------------------------------- RM COBOL Files: RMXBTRV.EXE. The interface to RM COBOL is loaded by the COBOL runtime during the first call to Btrieve. Note: If you are using 2.x of RM, it is recommended you use the shown calling sequence. (Previously, the calling procedure called "RMXFACE.COM".) Calling Procedure from COBOL CALL "RMXBTRV.EXE" USING FUNCTION, STATUS, POSITION-BLOCK, DATA-RECORD, DATA-LEN, KEY-VALUE, KEY-NUMBER. where: FUNCTION - function number for request (COMP) STATUS - return status from request (COMP) POSITION-BLOCK - 128 byte buffer DATA-RECORD - User data buffer DATA-LEN - Length of data buffer (COMP) KEY-VALUE - string pointer to key buffer KEY-NUMBER - key number to be processed (COMP) ===================================================================== Microsoft Fortran Files: FORXBTRV.OBJ and FORXBTRV.ASM. A sample program, SAMPLE.FOR, illustrates how to use the Fortran interface. ===================================================================== Logitech Modula-2/86 Files: MODXBTRV.MOD, MODXBTRV.DEF. The interface for Logitech Modula-2/86 may be accessed from the module ModXBTRV. This module exports the function BTRV. To access function BTRV from an application program, the user must include the following statements in the import list: FROM ModXBTRV IMPORT BTRV; FROM SYSTEM IMPORT ADR; BTRV may be called from the application program in the following manner: status := BTRV (Op, ADR(Pos), ADR(Data), DataLen, ADR(KeyBuf), Key); where: Op: CARDINAL; (* Operation *) Pos: any data type;(* Position Block *) Data: any data type;(* Data Buffer *) DataLen: CARDINAL; (* Data Length *) KeyBuf: any data type;(* Key Buffer *) Key: INTEGER; (* Key Number *) status: INTEGER; (* Btrieve error code *) Be sure to use the ADR function on the Pos, Data, and KeyBuf variables before sending them to the BTRV function. The ADR function makes sure they are in the format expected by BTRV. The definition module (ModXBTRV.def) of the interface must be compiled prior to its implementation module (ModXBTRV.mod). The interface must be compiled prior to the application which imports it. The following line compiles the interface: M2 comp Modxbtrv.def Modxbtrv.mod A modula-2 application program could be compiled, linked and run by typing the following lines: M2 comp Application.def Application.mod M2 link Application.lnk M2 Application ===================================================================== Borland Turbo Pascal v4.0 File: TUR4BTRV.PAS Turbo Pascal v4.0 requires this interface which uses the same calling and type conventions as TURXBTRV.PAS.(see Appendix D of the Btrieve Manual). This interface connot be used with previous versions of Turbo Pascal. --------------------------------------------------------------------- Metaware Pascal Files: MPMXBTRV.OBJ, MPLXBTRV.OBJ, and MPXBTRV.PAS When you compile your application program, include the MPXBTRV.PAS source file in your application program. This file defines the Btrieve function and includes a pragma to specify the name of the interface object file. If you are using the small or medium model compiler, link your compiled program to the MPMXBTRV.OBJ interface file. If you are using the large model compiler, link your compiled program to the MPLXBTRV.OBJ interface file. The external function, BTRV, is defined as follows: type STR128 = PACKED ARRAY[1..128] of CHAR; function btrv(fcn:Integer; VAR cur_block : STR128; VAR data_buf : STRING; VAR data_len : Integer; VAR key_buf : STRING; key_number : Integer): Integer; External; pragma Alias(btrv,'BTRV'); --------------------------------------------------------------------- SBB Pascal Files: SBBXBTRV.OBJ and SBBEXTRN.PAS. The Btrieve function should be declared as external for SBB Pascal. Btrieve provides a small assembly language routine which you must link with your Pascal application as an external function. If you are programming in SBB Pascal, use the $I command to include the file SBBEXTRN.PAS. The external function, BTRV, is defined as follows: function BTRV ( OP : integer; var POS_BLOCK : string0; var DATA_BUFFER : integer; var DATA_LENGTH : integer; var KEY_BUFFER : integer; KEY_NUMBER : integer) : integer; external; After your SBB Pascal program has been successfully compiled with the external function BTRV defined, link it with the Pascal Interface, SBBXBTRV.OBJ. In order to link a Pascal program whose object is stored in the file, "pasprog", with the SBB Pascal Interface, you would respond to the linker prompt for object modules as follows: Object Modules [.OBJ]: pasprog+sbbxbtrv For a complete explanation of linking, refer to your operating system manual and your Pascal reference manual. The position block must be allocated as a 128-byte long string. For the operation parameter, data buffer length, and key number, the variable you specify must be of type integer. The data buffer and key buffer are passed as type integer. It is often desirable to define a record structure in Pascal to describe these variables. Refer to the "Calling Btrieve From Pascal" section of Appendix D in the Btrieve Programmer's Manual for an explanation of using variant records for the data buffer and key buffer. The variant should be of type integer. =====================================================================