Upgrading to DataFlex 3.2: Difference between revisions

# Highlight the file to convert.

:: To select all files, choose "Select All" from the "Filelist" menu.

Properly written source code from prior revisions of DataFlex is fully compatible with revision 3.2 and should compile and operate without problem. The DataFlex 2.3 compiler and runtime were not as strict as the newer versions. In some cases, improper code was allowed to compile and/or run under DataFlex 2.3b, but will generate compiler or runtime errors when used with a newer revision of DataFlex. Data Access Corporation cannot warrant the validity of source code written by someone outside of DAC in every case.

Many programmers, as well as end users, run multiple versions of DataFlex and use batch files to switch from version to version. Here at DAC we are always switching among versions: 3.1d, 3.2, Visual DataFlex 8.1, Visual DataFlex 8.2, etc..

DataFlex 3.2 comes with a brand new, object-oriented,  CUA compliant menu program. This is the default menu that will run with DataFlex 3.2.

DataFlex 3.2 uses CUA compliant accelerator keys, such as F2 to Save, F8 for "find gt", Shift+F2 to delete, etc.. These keys are quite different from their 2.x predecessors, but it is useful for your end users to learn these keys, because many other applications share the same accelerator keys, making it easier to remember them in the long run. Nevertheless, in the short term, your end user may want to continue using the accelerator keys that they are used to.

Note: If a program uses a dfini.cfg file and chains to another program, the second program will also use the settings defined in that dfini.cfg file.

By default, the DataFlex 3.2 runtime does not use a dfini.cfg file, all the defaults are hardcoded into the runtime. However, if the runtime encounters a file called dfini.cfg along dfpath, or if a read_dfini statement is in a DataFlex program, it will use the definitions in that file.

The standard mathematical logical operators (<, >, >=, <>,etc.) can be used in addition to the DataFlex logical operators used in DataFlex 2.3b (LT, GT, GE,etc.), provided the expression is used in parentheses.

The Boolean logic operators AND and OR have been added.

The MIN and MAX operators have been added to replace the use of < and > for this purpose, since < and > are now used as logical operators. It is important to realize how this affects evaluation of program code:

Let's use an example to illustrate this. Look at the following line of DataFlex code:

In DataFlex 2.3b, this line would evaluate to show "5".

In DataFlex 3.2, this line will evaluate to show "0" (meaning "False", since 4 is not greater than 5).

The corrected line of code for DataFlex 3.2 to evaluate as it did in DataFlex 2.3 would be:

The mathematical operators can now be used on strings, making their function more intuitive and compatible with other programming environments. However, this will result in some expressions evaluating differently in DataFlex 3.x than they did in 2.3.

Once again, let's look at an example to illustrate the differences. Consider the following lines of DataFlex code, and look at the results they will produce in DataFlex 2.3 and DataFlex 3.2:

Result:

Expression     DataFlex 2.3b DataFlex 3.2

showln (A + B)     5           "32"

showln (A * B)     6           "3 2"

showln (A - B)     1           "32"

In DataFlex 3.2, a compiled DataFlex program (a .flx file) will only be created if your source code compilation does not generate any errors.

The DataFlex 2.3 compiler was very forgiving; it allowed numerous types of incorrect syntax without generating error messages. The newer compiler version has been improved and will often catch errors the 2.3b compiler did not.

For example, the "Check=" entry option allowed checking for ascii characters without enclosing them in quotes. The DataFlex 3.2 compiler creates an error in this case.

Incorrect syntax (but not caught by 2.3 compiler):

Correct syntax:

For backward compatibility purposes, DAC provided the compiler flag -x23 (i.e. "dfcomp source.src -x23") for compiling programs as if they had been compiled in 2.3b. This flag was provided until revision 3.04 to allow time for developers to bring their existing programs up to date. Most of the changes in DataFlex that are outlined in this paper and affect existing 2.3 DataFlex code were made to DataFlex with revision 3.0, in about 1990. At some point, a choice must be made between backward compatibility and progress, and as of revision 3.05, the -x23 flag is no longer supported, so you must make the appropriate source code changes to existing DataFlex 2.3 programs.

We have received some reports of encountering this error from developers upgrading to DataFlex 3.2 or Visual DataFlex. This error will occur at runtime whenever a relationship is found between 2 database fields that are not of exactly the same type and length. Overlap fields are the only exception to this rule; they may relate to either other overlap fields or ASCII fields of the same length.

In newer revisions of DataFlex (Visual DataFlex, DataFlex 3.2), we have provided an easier method, both for creating new applications that are Y2K compliant and for updating existing, noncompliant applications to full Y2K compliance.

DataFlex has always had the capability to store dates with 4-digit years, so a properly written DataFlex application in any version of DataFlex will be Year-2000 (Y2K) compliant. However, in DataFlex 3.2 (caution: revisions of DataFlex prior to 3.1c do not have the Y2K-Enhancements), we have implemented additional support for easily making your applications Y2K compliant.

In DataFlex 3.2, DAC has provided a file called y2k.pkg, which contains the set_Date_Attribute command and default settings for Date4_State (dfTrue), SysDate4_State (dfTrue) and Epoch_Value (30).

===Use y2k.pkg===

TIP: In DataFlex 2.3b, all images had to be at the very top of the program. In DataFlex 3.2, this is no longer necessary, so you can place code in between images and even before any images at the top of the program. If you have a lot of programs (source files) to which you need to add the "Use y2k.pkg" statement, you could write a small DataFlex program to do this for you. See the DAW Technical Knowledge Base for more information.

This line of code toggles the runtime to execute sysdate4 instead of sysdate wherever sysdate is used in a program. This returns the computer's system date with a 4-digit year.

This line toggles the runtime to automatically convert dates to 4-digit years whenever a date is moved to a data variable or a date field.

This line of code tells the runtime the cutoff year that determines whether a date is converted to a 19XX year or a 20XX year during automatic conversion.

If you want to use a different cutoff year (Epoch value) from the default of 30, you can change the value here, then recompile all programs that contain "Use y2k.pkg". If you want a specific project to have a different cutoff year, you can copy y2k.pkg to the source code area for that project, then edit the Epoch_Value in that copy of y2k.pkg and recompile all programs containing "Use Y2K.pkg" for that project.

For programmers things have changed as well. It is common for application designers to develop with many different tools, even for a single application. We often have multiple versions of the same tools installed, if not for development, then to support customers who use these different tools and versions.

1. Create separate directories for the runtime files and application files, and separate data and source code in the process.

For the remainder of this paper we will assume that the directory where your 2.3b license resides is c:\df23 – you can substitute your actual installed directory name and drive letter for c:\df23.

c:\df23 - original 2.3b directory

              - 2.3 runtime files will remain here

              - a copy of the source code files will remain here to be used with 2.3

c:\app - directory for your application files

                \data - data files to be shared between revisions 2.3 and 3.2 (subdirectory of \app)

                \src - source code files to be used with 3.2 (subdirectory of \app)

Separating your existing 2.3b directory this way will give you numerous operating options:

Concurrently run DataFlex 2.3b and 3.2 (or just 3.2)

Have an existing directory structure to easily upgrade to Visual DataFlex

A. Files to be moved into c:\app\data directory:

:all data files for your application (*.dat, *.k*, *.tag, *.fd, *.def)

filelist.cfg

B. Files to be copied into c:\app\src directory:

One copy of the source code can remain in \df23 for use with (and to keep up) currently running 2.3b applications, and one copy will go into this directory for use with the new 3.2 version.

:all source code files (*.frm, *.src, *.inc, *.rpt, …)

C. Files to remain in c:\df23 (runtime) directory:

the most important are the executable files (*.exe) and termlist.cfg

see Appendix A for a complete list of files that are installed by a DataFlex 2.3b Development License – these are the files that should remain in the c:\df23 directory

2. Install 3.2 into a separate directory and install your DataFlex 3.2 registration code

For the remainder of this paper we will assume that the directory where your 3.2 license resides is c:\df32 – you can substitute your actual installed directory name and drive letter for c:\df32.

Note:

DOS/Windows: Remember to execute the c:\df32\usr\setpath.bat batch file before running DFSetup.exe to install your registration code.

Linux/Unix: Remember to execute the /usr/local/df32/usr/setpath script before running dfsetup to install your registration code.

3. Concurrently Running DataFlex 2.3b and 3.2

A. Running DataFlex 3.2

1. Edit the c:\df32\usr\dfenv.cfg file:

Change the DFPATH= statement to include the c:\app\data directory

Before:

dfpath=.;c:\df32\usr;c:\df32\usr\help;c:\df32\lib;c:\df32\bin;c:\df32\src\pkg;c:\df32\usr\examples\expense;c:\df32\usr\examples\dar;c:\df32\usr\examples\ordentry;c:\df32\usr\examples\big;c:\df32\usr\examples\report;c:\df32\usr\examples\data;

dfpath=.;c:\app\data;c:\df32\usr;c:\df32\usr\help;c:\df32\lib;c:\df32\bin;c:\df32\src\pkg;c:\df32\usr\examples\expense;c:\df32\usr\examples\dar;c:\df32\usr\examples\ordentry;c:\df32\usr\examples\big;c:\df32\usr\examples\report;c:\df32\usr\examples\data;

Note: the DFPath statements above may appear different depending on the software you use to view or print this document, but each DFPath statement is a single continuous statement.

2. Switch to c:\app\src directory

3. Execute c:\df32\usr\setpath.bat

4. Run DataFlex (dfrun programname, dfcomp, dfquery, etc.)

Note: You may want to use different dfenv.cfg files for different applications so that you can place numerous application specific environment variables into each file.

B. Running DataFlex 2.3b

*Switch to c:\df23 directory

*set DFPATH=.;c:\app\data

*Run DataFlex (dfrun ProgramName, dfcomp, dfquery, etc.)

== Moving on to Visual DataFlex ==

 

Now that Windows is the world's most prevalent operating system, the next step for many DataFlex programmers is moving on to Windows programming. When DataFlex 2.3 was released in 1987, the auto-design facility was so easy to use to create database applications that it was years ahead of the competition. With Visual DataFlex you can experience that feeling again in Windows. Visual DataFlex is a great environment for designing Windows applications and allows you to utilize your existing DataFlex knowledge.

 

Data files can be shared among DataFlex 2.3b, 3.2 and Visual DataFlex, so your customers can continue to run their existing character-mode applications while you incrementally upgrade them to Visual DataFlex. User interface components, such as data entry screens (views) must be redesigned in VDF using Windows GUI object classes. The Visual DataFlex tools, such as the Integrated Development Environment (IDE) and Database Builder, make writing Windows applications quite enjoyable.

 

Some parts of your character-mode DataFlex (2.3b or 3.2) source code can be reused (i.e. non-interfaced batch processes such as reports). You will be able to simply cut and paste many parts of your existing programming logic into your VDF applications.

 

Visual DataFlex, as well as the DataFlex 3.2 console-mode runtime, has the ability to load Windows drivers, such as the Pervasive.SQL Connectivity Kit (which provides an easy yet powerful client-server solution), ODBC drivers and native drivers for other databases such as DB2 and Oracle. You'll never again have to turn down a project because a prospective client is using DB2 and you do not have time to learn a new programming environment.

 

CUA - Common User Access, part of IBM's  SAA

SAA - Systems Application Architecture - a series of interfaces, conventions and protocols which provide a framework for consistent application development and execution

(Source: DataFlex 3.1 User's Guide, page 241.; DataFlex 3.1 UIMS Handbook)