Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

...

Applies to: WG3.x

Editor's note: this chapter is new in the WG3 layer. It is from section 4 ("Data File Conversion") of the Developer's Addendum for Worldgroup 3.12 (wg312dev; the earlier 3.10 edition, devad3, is the same text apart from "3.10" for "3.12", BC5 for BC50, InstallShield V5.0 for V5.1 and spelling). The addendum has no figures. Prose is unrewritten; "Header check" notes record where the printed text disagrees with the WG3.2 headers. It extends chapter 9 (Databases), which only advises keeping spare bytes in records; the chapter documents WGSDFCVT.EXE, the .CVT file format and the dfc*() API (dfcapi2.h).

...

As an example, a .CVT file might provide information on the history of WGSUSR2.DAT in such a way that WGSDFCVT.EXE creates a list of files much like this:

Code Block
DOS Platform                                            NT/95 Platform

BBSUSR.DAT      (pre-Worldgroup 3.00)                   WGSUSR2.DAT (Current Version)
WGSUSR2.DAT (Current Version)

Installing and converting on NT/95:

...

The .CVT file formats are completely different from the older version. There is no longer a need to have multiple .CVT files for one data file. Each .CVT file contains all information pertaining to the life of its associated data file. Numerous examples of the new .CVT file structure can be found in \WGSERV\WGSDFCVT. The new .CVT file format is as follows:

Code Block
[;]
Description: <description>

Developer: <developer name>

[CustomConversion: <conversion file>]

[
BeginFile: <platform>,<file>[,<platform>,<file>...]
<tagname 1>     TYPE=<field type> [ELEMS=<length>]  [VARIABLE]
...
<fldtagN> TYPE
EndFile

[
BeginFile: <platform>,<file>[,<platform>,<file>,...]
...
]
]

The ; operator

The semi-colon “;” is used as a remark. All text after the semi-colon is ignored.

...

These are required fields for any NON-Custom Conversion .CVT file. For every BeginFile:, there is exactly one EndFile. Data Fields are required between each occurrence of BeginFile: and EndFile, and are discussed later in this document. The BeginFile: Line contains a list of platforms and data file names separated by commas. Only one platform/data file is required, however, you may include as many as you want. Each BeginFile:/EndFile combination is a list of data fields contained within a data file. It is quite possible that a data file has the same set of fields for both DOS and WNT, the only difference being the data alignment (DOS being packed, and WNT being unpacked). The following is an example taken from WGSUSR.CVT:

Code Block
BeginFile: DOS, WGSUSR2, WNT, WGSUSR2
(data fields here)
EndFile

This combination inside a .CVT file specifies that the data fields contained within BeginFile: and EndFile belong to the files: WGSUSR2.DAT on the DOS platform, and WGSUSR2.DAT on the WNT platform.

...

Data Fields are similar to their old versions. You must have at least one data field for every BeginFile:/EndFile combination. Data Fields are defined as follows:

Code Block
<Tag Name>      TYPE=<Field Type>       [ELEMS=<length>]        [VARIABLE]

Tag Name

A 19 character or less name for the data type. This generally is the same name as the variable it represents in the data structure. There can only be one occurrence of each Tag Name within each BeginFile:/EndFile combination.

...

This specifies the number of occurrences of this field type in this data field. For instance, if you are creating a field type for the following variable:

Code Block
SHORT MyString[500];

your data field would look like this:

Code Block
MYSTRING                TYPE=SHORT              ELEMS=500

ELEMS is not a required field and omitting it sets the number of elements to 1.

...

The previous version of the data file API had two serious flaws: You could only nest structures one deep, and you could not remove data fields that were within structures. This is no longer the case. Structures are now defined in the same way that BeginFile:/EndFile are used. The following is WGSMENU.CVT. It has an example of variable length structures:

Code Block
BeginFile: DOS,BBSMENU
MENUTYPE        TYPE=CHAR
PAGENAME        TYPE=CHAR       ELEMS=16
PARENTPAGE      TYPE=CHAR       ELEMS=16
FILENAME                TYPE=CHAR       ELEMS=80
MODULENAME      TYPE=CHAR       ELEMS=25
COMMANDSTG      TYPE=CHAR       ELEMS=60
GOLOCK                  TYPE=CHAR       ELEMS=16
FLAGS                   TYPE=SHORT
MENUTITLE       TYPE=CHAR       ELEMS=43
NPAGES                  TYPE=SHORT
ICHANGE                 TYPE=LONG
SPARE                   TYPE=CHAR       ELEMS=70
PGLINK                  TYPE=STRUCT     ELEMS=25                VARIABLE
        POSITION                TYPE=SHORT
        SELCHR                  TYPE=CHAR
        ICONAME                 TYPE=CHAR       ELEMS=9
        DESTPAGE                TYPE=CHAR       ELEMS=16
        OPTDSP                  TYPE=CHAR
        KEYREQ                  TYPE=CHAR       ELEMS=16
        SHORTD                  TYPE=CHAR       ELEMS=31
        LONGD                   TYPE=CHAR       ELEMS=50
EndStruct
EndFile

All field names are unique. Field names within substructs must have different names than any other fields in your .CVT files. You can not have a field named “KEY” inside a structure and outside a structure.

...

All previous data file conversion API’s still exist and are supported, however, you should migrate your software to the new API functions. The new API’s and structures are located in the file DFCAPI2.H.

DFCLIST structure

Code Block
typedef struct tagDFCLIST {        /*  Platform Specific list of files     */
     INT Platform;                 /*  Operating system for file list      */
     pDFCFILE file;                /*  Pointer to the file information     */
} DFCLIST,*pDFCLIST;

Used to create a list of files that the dfc library should check for conversion. An array of these structures are passed to dfcRegister(). Your DFCLIST array must end with a platform of DFC_END and a file of NULL.

...

pointer to an array of DFCFILE structures that contain a list of files specific to the given platform. This can be NULL when the Platform is DFC_END.

DFCFILE structure

Code Block
typedef struct tagDFCFILE {        /* Datafile information                 */
     CHAR Name[GCMAXPTH];          /*  Name of the datafile                */
     pDFCFUNCTION cnvfunc;         /*  Conversion function                 */
     pDFCDATAFIELDS cnvfields;     /*  Conversion fields                   */
} DFCFILE,*pDFCFILE;

Used to create an array of files that apply to a specific platform. The DFCFILE structure is directly related to the DFCLIST structure. All DFCFILE structure arrays must end with a blank name.

...

Pointer to an array of DFCDATAFIELDS structures. This array contains information on each data field within the data file similar to those used in .CVT files.

DFCDATAFIELDS structure

Code Block
typedef struct tagDFCDATAFIELDS {  /* Datafile fields definition           */
     CHAR Name[DFC_NAMSIZ];        /*  Name of the field                   */
     UINT Type;                    /*  Type of the field                   */
     INT nelems;                   /*  Number of elements                  */
     struct tagDFCDATAFIELDS *substruct;/*  Pointer to sub structure       */
} DFCDATAFIELDS,*pDFCDATAFIELDS;

Used to create a set of data fields contained within a data file. This structure is used in conjunction with the DFCFILE structure. All DFCDATAFIELDS must end with a blank name and a type of DFCFLD_END.

...

If the field type is DFCFLD_STRUCT or DFCFLD_VSTRUCT, you must supply another array of DFCDATAFIELDS for that structure, otherwise this parameter is NULL.

DFCOFFSETS structure

Code Block
typedef struct tagDFCOFFSETS {     /* Offset information structure         */
     CHAR Name[DFC_NAMSIZ];        /*  Name of the variable                */
     UINT Type;                    /*  Type of record it is                */
     INT nelems;                   /*  Number of elements                  */
     UINT Offset;                  /*  Offset within data record           */
} DFCOFFSETS,*pDFCOFFSETS;

A bunch of internal structures are created when you call dfcRegister() with your file list. The DFCOFFSETS structure is an internal list past to you as part of the DFCFILEINFO structure. This contains information on each one of your data fields. The DFCOFFSETS structure and the DFCDATAFIELDS structures are closely related. This structure is never created by you. You can obtain pointers to this structure from within your conversion functions by calling dfcFindOffset().

...

The offset within the data that this field is at. If you have the following structure:

Code Block
CHAR String[20];
CHAR Test[10];

and you called dfcFieldOffst() for the TEST data field, the offset would be 20. The offset does account for alignment. DOS versions and WNT versions of the same data fields may produce different offsets.

Applies to: WG3.x

Header check: no dfcFieldOffst() exists; the function is dfcFindOffset() (dfcapi2.h:127; section "dfcFindOffset()" below).

DFCFILEINFO structure

Code Block
typedef struct tagDFCFILEINFO {    /*  File info to pass to conversions    */
     INT Platform;                 /*  Current system Platform             */
     CHAR Name[GCMAXPTH];          /*  Conversion file                     */
     INT Type;                     /*  Conversion macros (CVTBIGEND...)    */
     pDFCDATAFIELDS Fields;        /*  Pointer to the fields in data       */
     pDFCOFFSETS Offsets;          /*  Pointers to offset information      */
     UINT Offsetsn;                /*  Number of offsets                   */
     struct flddef *fdef;          /*  Field definition array (set up)     */
     CHAR *Data;                   /*  Pointer to actual data              */
     size_t DataLength;            /*  Length of the data                  */
     struct flddef** fdefs;        /*  Used to allocate memory for fdef    */
     UINT fdefsn;                  /*  Number of field defs                */
} DFCFILEINFO,*pDFCFILEINFO;

If you have created conversion functions, you are passed two pointers to this structure. The structure contains a wealth of information about specific files being converted.

...

The number of fdefs in the array. This field should not be used or modified.

DFCPFCONVERT structure

Code Block
typedef struct tagDFCPFCONVERT {   /*  Platform conversion                 */
     INT PlatformFrom;             /*  Platform converting from            */
     INT PlatformTo;               /*  Platform converting to              */
     pDFCFUNCTION cnvfunc;         /*  Pointer to conversion function      */
} DFCPFCONVERT,*pDFCPFCONVERT;

Used to specify a list of conversion functions that convert data from one platform to another. Currently the only combination of platforms supported is DOS to WNT.

...

Pointer to a conversion function used to convert data from PlatformFrom to PlatformTo.

dfcAskBackup()

Code Block
VOID
dfcAskBackup(VOID);                /*  Ask the backup directory            */

Ask the user what directory they wish to back files up to. If you are using dfcRegister to convert your data files, this function is automatically called by the internal API’s.

...

Applies to: WG3.x

const CHAR * vs CHAR * hazard. CHAR *dfcBackupDirectory(VOID) returns a writable CHAR * (dfcapi2.h); treat it as read-only. The dfc* string parameters (descrp, FileFrom, FileTo, stg, file, FieldName, ModuleName) are const CHAR *.

Code Block
CHAR *
dfcBackupDirectory(VOID);          /*  Returns pointer to backup directory */

If you are using dfcRegister to convert your data files, this function is automatically called by the internal API’s.

...

Pointer to the directory the user has asked to back files up.

dfcBackupRequired()

Code Block
GBOOL
dfcBackupRequired(VOID);           /*  Is a backup required?               */

Returns

TRUE if the user has requested to back up their data files,

FALSE if they have not.

dfcConvertDefault()

Code Block
DFCFUNCTION                        /*  Pointer to new data                 */
dfcConvertDefault(                 /* Default conversion function          */
pDFCFILEINFO from,                 /*  File information converting from    */
pDFCFILEINFO to);                  /*  File information converting to      */

Default conversion function. This function is called if you do not supply your own custom conversion function.

...

A pointer to the converted data.

dfcConvertPFDefault()

Code Block
DFCFUNCTION                        /*  Pointer to new data                 */
dfcConvertPFDefault(               /* Default Platform conversion          */
pDFCFILEINFO from,                 /*  File information converting from    */
pDFCFILEINFO to);                  /*  File information converting to      */

Platform default conversion function. This function is called only when converting from one platform to another (i.e. DOS to WNT), unless you have provided your own platform conversion function.

...

A pointer to the converted data.

dfcDisplayBackup()

Code Block
VOID
dfcDisplayBackup(VOID);            /*  Display backup notice               */

Displays a notice that says “Backing up data files”. If you are using dfcRegister to convert your data files, this function is automatically called by the internal API’s.

dfcDisplayInfo()

Code Block
VOID
dfcDisplayInfo(                    /* Display DFC information              */
const CHAR *Description,           /*  Description to display              */
const CHAR *FileFrom,              /*  File converting from                */
const CHAR *FileTo,                /*  File converting to                  */
ULONG Records);                    /*  Number of records to display        */

Updates display information about your custom conversion on the screen. If you are using dfcRegister to convert your data files, this function is automatically called by the internal API’s.

...

Total number of records that are in the data file.

dfcDisplayStats()

Code Block
VOID
dfcDisplayStats(                   /*  Display the stats bar               */
ULONG TotalRecords,                /*  Total records in conversion         */
ULONG DoneRecords);                /*  Number of records completed         */

Used to update the number of records converted. If you are using dfcRegister to convert your data files, this function is automatically called by the internal API’s.

...

Total number already converted.

dfcDisplayShutdown()

Code Block
VOID
dfcDisplayShutdown(VOID);          /*  Release captured video screen       */

Closes all windows that may have been opened while using dfcDisplay... functions. If you are using dfcRegister to convert your data files, this function is automatically called by the internal API’s.

dfcError()

Code Block
VOID
dfcError(                          /*  Print an error to screen            */
const CHAR *stg,                   /*  String to print                     */
...);                              /*  Extra arguments                     */

A generic error handling routine. Calling this function causes your custom conversion program to immediately end.

...

A message to display upon the termination of your program.

dfcFieldSize()

Code Block
UINT                               /*  Number of bytes of field size       */
dfcFieldSize(                      /* Gets field size of data type         */
UINT Type);                        /*  Type of datafield                   */

Gets the size in bytes of a given data field type.

...

The size in bytes of the data type passed, or 0 if the data type is not found.

dfcFilePlatform()

Code Block
INT                                /*  DFC_DOS, DFC_WNT, DFC_END           */
dfcFilePlatform(                   /* Files platform                       */
const CHAR *file);                 /*  Pointer to file to check            */

Checks a data file and returns what platform the file belongs to (DOS/WNT). There are limitations to this function. If the program that is calling this function is compiled for DOS. It does not recognize WNT data files. We do not support data file conversion from Worldgroup NT/95 to Worldgroup DOS. If you are using dfcRegister to convert your data files, this function is automatically called by the internal API’s.

...

DFC_END on error.

dfcFindOffset()

Code Block
pDFCOFFSETS                        /*   returns ptr to field offset info   */
dfcFindOffset(                     /* find offset of a particular field    */
pDFCFILEINFO info,                 /*   file information converting from   */
const CHAR *FieldName);            /*   name of field to find              */

Find the offset of a data field within a DFCFILEINFO structure. This function is primarily used within a conversion function to get information on a particular field.

...

A pointer to a DFCOFFSETS structure, or NULL if FieldName does not exist.

dfcGetFDA()

Code Block
struct flddef *                    /*  Pointer to FDA structure            */
dfcGetFDA(                         /* Get an FDA from type of convert      */
UINT Type);                        /*  Type of option                      */

Gets an FDA for a given data type.

...

A pointer to a valid flddef structure or NULL. This structure could be used as part of a call to cvtData().

dfcRegister()

Code Block
GBOOL                              /*  TRUE if conversion took place       */
dfcRegister(                       /*  Register and search for files       */
const CHAR *descrp,                /*  Description name                    */
const DFCLIST *dfc,                /*  pointer to all DFCFILES             */
const DFCPFCONVERT *pfconv,        /*  Platform Converter                  */
INT Key,                           /*  Key number to use (-1 for physical) */
INT Direction);                    /*  Direction (DFC_FORWARD/DFC_BACKWARD)*/

Notifies the data file conversion API of a list of files to check for conversion.

...

FALSE if a conversion did not take place.

dfcRegisterGDB()

Code Block
GBOOL                              /*  TRUE if conversion took place       */
dfcRegisterGDB(                    /*  Register conversion for GDB         */
const CHAR *descrp,                /*  Description of conversion           */
const DFCLIST *dfc,                /*  Pointer to list of information      */
const DFCPFCONVERT *pfconv,        /*  Pointer to OS conversions           */
const CHAR *ModuleName);           /*  Module name registering             */

Notifies the data file conversion API of a conversion that takes place in the generic database.

...

Applies to: WG3.x

Header check: there is no type DFCCONVERT in WGDEV/INC. The conversion-function type is DFCFUNCTION (typedef VOID* DFCFUNCTION;) and pDFCFUNCTION in dfcapi2.h; dfcConvertDefault() returns DFCFUNCTION (dfcapi2.h:117). The heading and the sample in "Adding another data file version" use the name DFCCONVERT.

Code Block
typedef VOID* DFCFUNCTION;
typedef DFCFUNCTION (*pDFCFUNCTION)(pDFCFILEINFO from,pDFCFILEINFO to);

These functions are created to handle data conversion from one form to another. They are normally set up as part of a DFCFILE structure. Platform conversion functions handle modifying the latest version of DOS to the latest version of WNT only. If you are converting from an older version of a DOS file to WNT, your file is first converted to the newest version of DOS, then your platform conversion function is called to convert it to WNT.

...

The Worldgroup Variables data file exists on both DOS and NT/95 platforms. The following structure was created:

Code Block
static DFCLIST VariableList[]={
     {DFC_DOS, VariableDOS},
     {DFC_WNT, VariableWNT},
     {DFC_END, NULL},
};

VariableDOS and VariableWNT are pointers to DFCFILE structures.

...

The DOS versions of the Worldgroup Variables data file are BBSVBL.DAT and WGSVBL2.DAT. Thus, the following was created:

Code Block
static DFCFILE VariableDOS[]={
     {"BBSVBL",     NULL,               bbsvbl},
     {"WGSVBL2",    ConversionDOS1,     wgsvbl2},
     {"", NULL, NULL},
};

Both bbsvbl and wgsvbl2 are pointers to DFCDATAFIELDS structures that define the contents of each data file. ConversionDOS1 is a custom conversion function to convert BBSVBL.DAT to WGSVBL2.DAT.

There is only one version of the Worldgroup Variables data file for NT/95, Thus:

Code Block
static DFCFILE VariableWNT[]={
     {"WGSVBL2",    NULL,               wgsvbl2},
     {"", NULL, NULL},
};

The reason wgsvbl2 is contained within both file lists is because each file has the exact same data field layout. The only difference is the PACKED vs. UNPACKED.

...

As seen in the creation of the DFCFILE structures, that are two different DFCDATAFIELDS structures that need to be created:

Code Block
static DFCDATAFIELDS bbsvbl[]={
     {"KEY",        DFCFLD_CHAR,   4,             NULL},
     {"VARSTUFF",   DFCFLD_VCHAR,  OVBRECSZ-4,    NULL},
     {"", DFCFLD_END, NULL},
};
Code Block
static DFCDATAFIELDS wgsvbl2[]={
     {"KEY",        DFCFLD_CHAR,   4,                       NULL},
     {"VARSTUFF",   DFCFLD_VCHAR,  sizeof(struct sysvb3)-4, NULL},
     {"", DFCFLD_END, NULL},
};

Notice the DFCFLD_VCHAR fields (Variable CHAR) specify the largest record size that “VARSTUFF” could possibly be.

...

On most custom conversion programs there is no need for a special function to convert data from the DOS platform to the WNT platform. However, for WGSVBCVT.EXE, there was a need to modify the data manually before saving the WNT version. When this need arises, it is necessary to create a DFCPFCONVERT structure that contains a list of platform conversion functions:

Code Block
static DFCPFCONVERT PlatformConverts[]={
     {DFC_DOS, DFC_WNT,  PlatformConvert},
     {DFC_END, DFC_END, NULL},
};

The function PlatformConvert will be called when converting data from DOS to WNT.

...

As part of the DFCFILE structures, we specified one conversion function: ConversionDOS1(), and as part of the DFCPFCONVERT structure, we also specified on conversion function: PlatformConvert(). Custom conversion functions are created when you need to transform one version of a datafile to another version, and the transformation requires that you add new fields, or re-adjust somethings value. Custom conversion functions are passed two pointers to DFCFILEINFO structures which provide a wealth of information about both the file you are converting from and the file you are converting to. Here are the two custom conversion functions for WGSVBCVT.EXE:

Code Block
static DFCFUNCTION                 /*  Pointer to data                     */
ConversionDOS1(                    /* Converstion from BBSVBL to WGSVBL2   */
pDFCFILEINFO from,                 /*  Pointer to from data                */
pDFCFILEINFO to)                   /*  Pointer to to data                  */
{
     return(ConversionVBL(from,to,TRUE,FALSE,NGROUPS));
}
Code Block
static DFCFUNCTION                 /*  Pointer to data                     */
PlatformConvert(                   /* Converstion from BBSVBL to WGSVBL2   */
pDFCFILEINFO from,                 /*  Pointer to from data                */
pDFCFILEINFO to)                   /*  Pointer to to data                  */
{
     return(ConversionVBL(from,to,FALSE,TRUE,NUMGRPS));
}

The ConversionVBL() function handles all possible data conversions for WGSVBCVT.EXE, and takes the following paramaters:

Code Block
static DFCFUNCTION                 /*  Pointer to data                     */
ConversionVBL(                     /* Converstion function                 */
pDFCFILEINFO from,                 /*  Pointer to from data                */
pDFCFILEINFO to,                   /*  Pointer to to data                  */
GBOOL EatOldCreds,                 /*  Eat old credits up?                 */
GBOOL TakeLongs,                   /*  Take variables as longs? (or shorts)*/
INT nGrp)                          /*  Number of groups                    */

from

Pointer to DFCFILEINFO structure received in conversion function.

...

Now that every structure required for the conversion is complete, there is only one thing left: registering all of this information with the data file conversion API. Your programs main() routine should look like this:

Code Block
INT
main(VOID)
{
TRY
     dfcRegister("Worldgroup Variables",VariableList,PlatformConverts,
      -1,DFC_FORWARD);
EXCEPT
     return(0);
}

Your conversion programs no longer receive command line arguments to specify what is being converted. Instead, it is the conversion APIs job to figure out what needs to be converted based on the structures you have created. Calling dfcRegister() notifies the conversion API of the different files, datatypes and conversion functions, and everything else is handled for you. Your conversion functions are only called if a data file conversion takes place.

...

1. Add it to our files list, they would now look like this:

Code Block
static DFCFILE VariableDOS[]={
     {"BBSVBL",     NULL,               bbsvbl},
     {"WGSVBL2",    ConversionDOS1,     wgsvbl2},
     {"WGSVBL3",    ConvertTo3,         wgsvbl2},
     {"", NULL, NULL},
};
Code Block
static DFCFILE VariableWNT[]={
     {"WGSVBL2",    NULL,               wgsvbl2},
     {"WGSVBL3",    ConvertTo3,         wgsvbl3},
     {"", NULL, NULL},
};

2. Add our new data fields**:**

Code Block
static DFCDATAFIELDS wgsvbl3[]={
     {"KEY",        DFCFLD_CHAR,   4,                       NULL},
     {"NEWVAR",     DFCFLD_LONG,   1,                       NULL},
     {"VARSTUFF",   DFCFLD_VCHAR,  sizeof(struct sysvb3)-4, NULL},
     {"", DFCFLD_END, NULL},
};

3. Create the function ConvertTo3:

Code Block
static DFCCONVERT
ConvertTo3(
pDFCFILEINFO from,
pDFCFILEINFO to)
{
        UINT NewvarOffset;
        pDFCOFFSET pnewvar;
        LONG NewvarSet=10;
        DFCCONVERT Answer;

Applies to: WG3.x

Header check: pDFCOFFSET should read pDFCOFFSETS (} DFCOFFSETS,*pDFCOFFSETS;, dfcapi2.h; dfcFindOffset() returns pDFCOFFSETS); DFCCONVERT should read DFCFUNCTION (see the note under "DFCCONVERT"). The sample also uses NGROUPS, which is NUMGRPS in WG3.2 (MAJORBBS.H:62).

Code Block
        // Get the offset in the new data of our new variable
        pnewvar=dfcFindOffset(to,“NEWVAR”);
        NewvarOffset=pnewvar-
>Offset
>Offset;
Code Block
        // We can use the default conversion function because nothing is changing
        //  except the fact that we are adding a new variable
        Answer=dfcConvertDefault(from,to);
Code Block
        //  Add the new variable to the data
        memcpy(&Answer[NewvarOffset],&NewvarSet,sizeof(LONG));
Code Block
        //  return the new data.
        return(Answer);
}

4. Remove the Platform conversion functions:

Because our new data file does not require any special attention when going from DOS to WNT, we no longer need a platform conversion function. We need to remove our DFCPFCONVERT structure, and change our dfcRegister line to the following:

Code Block
dfcRegister("Worldgroup Variables",VariableList,NULL,-1,DFC_FORWARD);

...

Previous: Major BBS v10: 21 Development Environment (Worldgroup 3.x)  |  Contents  |  Next: Major BBS v10: 23 InstallShield