Decompiler Frequently Asked Questions (FAQ)

Q:  I have looked everywhere for a price.  How much does each decompiler cost?

Q:  You used to sell decompilers.  Why don't you do that anymore?

Q:  I really need a decompiler and I don't want to use the service.  What should I do?

Q:  I need a project decompiled  yesterday!  How can I get one ASAP (as soon as possible)?

Q:  I need to send a project to you to be decompiled  What do you need?

Q:  There are custom macros in my code.  Will those be decompiled?

Q:  My code uses include files.  Will the generated code use those include files?

Q:  Is it possible to download or purchase a trial version to evaluate your software?

Q:  I don't have PKZIP or WINZIP.  How should I bundle the files?

Q:  I think I found a bug.  What should I do?

Q:  I have an FLX file and a potentially accurate source file.  Can the DataFlex Decompilers help me?

A:  Decompiler prices are not listed on the web page because each project is quoted a price based on its size and the version(s) of DataFlex that need to be decompiled.  Contact us at for a current price quote.  Also see the Decompiler Project Order Page for instructions on what information we need to give you an accurate quote.

A:  The DataFlex market has changed over the past few years.  Because so many developers are using so many different versions of DataFlex, it's inconvenient for developers to purchase multiple decompiler versions just to be able to be able to decompile all of the programs for their projects.  Currently, if a developer needs to decompile a Web App that has some VDF programs, then they need to purchase two decompilers -- one that handles Web App programs and another that handles VDF programs.  This is very inconvenient and also very costly.  A decompiling service eliminates all of those problems by letting the project dictate which DataFlex decompilers need to be used.

A:  DataFlex Decompilers are only available as a service from The Database Managers, Inc.

There are many reasons for this, one of which is provided above.  If you're still not convinced, here are some other reasons:

• There are no registration hassles.  No need to know which DataFlex licenses you've ever registered, or which licenses were compiled into your project.
• Projects are decompiled using the most recent decompiler for that version.  There is never an upgrade cost.
• Projects can be redecompiled at any time at no charge.  See our Decompiler Guarantee.
• If a decompiler bug is discovered, recent projects will be redecompiled (at no charge) to see if any of the programs from those projects were affected by the bug.  If so, then the modifed source file(s) will be emailed to you.

A:  We prefer to receive projects via email.  We check our email periodically throughout the business day and sometimes on weekends. 

The ordering information is available here.

A:  Please include the following files:

• filelist.cfg
• all .TAG files
• all .FD files
• the FLX files that need to be decompiled

Bundle all of the files into a single .ZIP file using PKZIP. 

A:  There are two types of custom macros:  new commands and modifications to existing DataFlex commands.

New Commands:

New commands can be decompiled but the generated source code will use standard DataFlex commands instead of the new command name.  This is because the existence and definition of the custom macro is lost at compile-time.  In all cases, the generated code is guaranteed to be recompilable without changes, and the generated code is also guaranteed to be functionally identical to the original program.

Here is an example of a custom macro and its decompiled version:

/*
//  Show a string at a specified X,Y location
#COMMAND SHOWXY R "AT" R R
  gotoxy !3 !4
  show !1
#ENDCOMMAND

showxy "This is a sample at 10,15" at 10 15

When decompiled, looks like this:

/*
GOTOXY 10 15
SHOW "This is a sample at 10,15"

The decompiled program, when recompiled, will be functionally identical to the original program.

Modified DataFlex commands:

All of the decompilers generate code for an unmodified FMAC.  When a DataFlex program is compiled, all of the DataFlex commands (macros) are expanded and their contents are compiled into the FLX file.  The decompilers detect these expanded macros and compact them into more familiar commands.  The decompilers do this while guaranteeing that the compacted macro is functionally identical to the original expanded macro.

When a DataFlex macro is modified, one or more commands may be inserted or deleted.  This might change the signature of the expanded macro when it is compared to a 'normal' expanded macro.  Depending on the nature of the change, one of three things will happen:

1)  The decompiler will not detect any differences between the signatures because the customized macro didn't affect the compiled FLX file.  The decompiler will generate the same code as if the macro had not been changed.

2)  The decompiler will detect a change in the signature and because of that change, it will refuse to compact the macro.  This most often happens to large macros that have deep, internal changes such as the Enter and Report macros.  The generated source code will use DataFlex commands that internally comprise the original macro and have the change embedded in the expanded code.  When recompiled, the program will be functionally identical to the original program.

3)  When the customized change is at the very beginning or very end of the customized macro, the decompilers will generate extra instructions either before or after the normal, unmodified DataFlex command.  This preserves the functionality of the customized macro in the decompiled program while retaining the ability to use an unmodified FMAC to recompile the program.

A:  No.  The boundaries of a #include file, and indeed its name, are lost at compile-time.  The decompilers generate one .SRC file for each .FLX file.  The .SRC file contains all of the code that is needed to recompile the program.  Therefore, the functional contents of the #include file are inside of the .SRC file.  The recompiled program is guaranteed to be functionally identical to the original program.

Most programmers consider the decompiler's inability to use #include files as an advantage instead of a disadvantage.  If a #include file had been changed since the program was compiled, when it was recompiled, those changes would be introduced into the new program and then it wouldn't be functionally identical to the original -- thus breaking our guarantee. 

A:  No, because the source code generated by the decompilers is permanent.  Also, the decompilers are no longer available for retail sale.  Please see here and here for explanations.

A sample of decompiled DataFlex code is available on our web page.

A:  We have a limited ability to handle other archiving methods.  Contact us or just email to a very small sample (just the filelist.cfg in the archive) to see if we can extract it.  For security reasons, we will never execute (or run) self-extracting archives.

A:  Most decompilation bugs require the original FLX file to reproduce it.  Please email to a copy of the FLX file, the filelist.cfg and all of the .TAG files so that we can reproduce the problem you are having.  Reported bugs fall under our very generous Decompiler Guarantee as long as the FLX files pass the conditions in our Disclaimer.

Instructions for bundling the files for email shipment to us are here.

A:  Yes!  This is one of the best unadvertised uses of the decompilers:

We will work with you to help you identify the differences between the existing FLX file and the potential source file.  Here is what you should do:

1)  Compile the proposed source file.  Keep it separate from your existing FLX file (make sure dfcomp doesn't destroy your existing FLX file).

2)  Send to us both the newly compiled FLX file and the older (in-use) FLX file.

3)  We will decompile both FLX files and send the sources back to you.

4)  Compare the two source files of the decompiled programs. 

Any differences between the decompiled sources is the differences that need to be added or subtracted to/from the proposed source to make the proposed source file match the original source file.  This process can be repeated until the decompiled sources match as closely as possible.

More Information:

• DataFlex Decompiler Information
• DataFlex Decompiling Service
• FAQ (Frequently Asked Decompiler Questions)
• Sample Decompiled Source Code
• Decompiler Guarantee
• Guarantee Disclaimer
• Decompiling FMAC (flex.cfl) files