Synergy/DE is the foundation of your powerful business applications. Version 9 builds on this foundation and provides you with an exciting new level of capabilities. And the latest revisions deliver even more capabilities.

Synergy/DE 9.1.5 Features and Benefits

This section lists the new 9.1.5 features. See below for a 9.1.3 and 9.1.1 features.

The ability to embed .NET forms, .NET controls, and Windows Presentation Foundation (WPF) elements in UI Toolkit windows. You will now be able to leverage third-party .NET components in your UI Toolkit applications to enhance user interfaces or add new capabilities, such as .NET’s XML parser or DataTables.

If you use ActiveX controls, this feature enables you to “upgrade” your controls to more current technology. (ActiveX controls require old Visual Studio technology to create them, where .NET forms and controls of course use more current technologies.)

New FOREACH statement, which gives you new syntax to use when looping through entire collections. The syntax is

      FOREACH <loop_var> in <collection>

      <iteration processing>

where <loop_var> is a loop variable whose value is set to each element in sequence as FOREACH iterates through them, and <collection> is one of the following:

      - A dynamic array ([#]@obj)
      - A real array ([10]a5)
      - The System.Collections.ArrayList class or a descendant
      - The Synergex.SynergyDE.Collections.ArrayList class or a descendant

FOREACH gives you added flexibility. It can be simpler than other FOR loops because it doesn’t need a loop counter, and it will be especially useful if you use System.Collections.ArrayList arrays, which use 0-based indexers. (Other Synergy arrays use 1-based indexers.) You can use FOREACH with all arrays, and you won’t have to be aware of which are 0-based and which are 1-based.

New linker option, “-R”, which enables you to create an ELB that includes only the routines from the OLB(s) that are needed to resolve the routines in the ELB. For example,

       dblink -l test1.elb test1.dbo -R test2.olb -R test3.olb

This feature will be especially useful when you use gennet to generate Synergy classes to wrap the classes in .NET assemblies. It’s not unusual for the OLBs created from the classes generated by gennet to be 80-100 megabytes, when developers want to use only 1-2% of those classes. This feature may significantly reduce the size of ELBs.

New compiler option, “-WD”, which enables you to disable specific compiler warnings by error number. For example,

      dbl -W4 -WD=885,777 filename.dbl

disables warning errors 885 and 777. This option will be especially useful if you encounter a lot of level 4 warnings when compiling your code with v9. You can now disable these warnings to make it easier to upgrade.

New gennet option, “-impdir <directory>”, which enables you to specify a directory or logical for which gennet will generate an IMPORT statement, as follows:

      IMPORT System DIRECTORY 'MYLOGICAL:'

This gives you some added flexibility when generating Synergy classes that wrap classes defined in a .NET assembly.

Ability to parse and load larger XML files. The Synergy XML API now uses less memory when parsing XML files. (It now uses about the same memory footprint as commercially available DOM parsers.) In addition, the performance of loading large XML files has been enhanced.

Ability to change a program’s priority class. A new function on Windows, SET_PRIORITY_CLASS, allows a program to change its priority class if privileges allow. This is especially useful for scheduled tasks on Vista and Server 2008. Scheduled tasks typically run with low priority on these platforms and thus may be slow, even when the CPU is idle. This feature will enable you to speed up these scheduled tasks.

MISMATCH modifier on alpha parameters for use when prototyping. You can specify the MISMATCH modifier on an alpha type parameter for functions and subroutines to allowpassing a decimal or an implied-decimal argument to the alpha parameter. This may simplify the code changes you need to make to resolve prototype-related errors when you migrate legacy code to v9.

Improved performance when writing to sequential and relative output files. Performance has been improved for WRITES, FORMS, and DISPLAY to sequential and relative output files. This will be especially helpful when writing to log files (since sequential and relative files are typically used).

xfODBC support for CAST, TOP, SKIP, and CASE. The CAST scalar function enables you to convert an expression or a null value to a specified data type. The TOP subclause enables you to specify the number of rows to be returned for a query;  the SKIP subclause enables you to specify the number of rows to be trimmed from the beginning of a result set. Together, they can be used for paging, which is particularly useful for creating cached result sets for Web sites that use ADO.NET. CASE clauses evaluate lists of conditions and return results for conditions that are true. These new capabilities give you more flexibility when accessing your Synergy DBMS data via xfODBC, and they enable you to more easily support ADO.NET

Synergy/DE 9.1.3 Features and Benefits

This section lists the 9.1.3 features. See below for 9.1.1 features.

Synergy .NET assembly API
This new API enables you to access .NET assemblies in your Synergy applications, giving you new opportunities to leverage the vast resources of Microsoft .NET. The .NET assemblies that you incorporate might include visual components, such as forms, or non-visual components, such as .NET’s XML parser or DataTables. The API enables you to load .NET assemblies; instantiate types defined in the assemblies; and communicate with the assemblies’ methods, properties, fields, and events. The new API is similar in function to the Synergy ActiveX API, and it has a debugging system equivalent to that of the Synergy ActiveX API.

More powerful xfNetLink .NET development tools
The new xfNetLink .NET features in 9.1.3 add power to your programming—new capabilities and added flexibility.

• Support for Synergy System.String data type. You can now use System.String as a parameter or return value when communicating with .NET clients. (Currently alpha variables are converted to String and vice versa. System.String was added to Synergy Language in version 9.1.1.)
  
  
• Support for Synergy System.Collections.ArrayList parameter. You can now pass an ArrayList parameter from a Synergy routine to a .NET application and vice versa. Previously, if you wanted an ArrayList on the client side, you would have to pass a collection parameter (an array of structures) from Synergy Language, where it is a memory handle, to .NET, where it is converted to an ArrayList. Support for ArrayList parameters not only enables you to pass data either to or from Synergy Language, but the ArrayList is not limited to structures; it can be composed of alpha, decimal, implied decimal, integer, or System.String values. (It may contain only one of these data types, not a mixture.) (The System.Collections.ArrayList class was added to Synergy Language in version 9.1.1.)



• Support for DataTables. You can now define a structure parameter that is an ArrayList or structure collection as a DataTable in the Method Definition Utility, and it will be created as a DataTable in the generated assembly. The generated DataTable extends the Framework class System.Data.DataTable, which gives you access to all the methods available in that class. Your DataTable will also include methods that enable you to manipulate the structure classes in the DataTable. Access to DataTables is useful when working with databases. You can also use DataTables to display tabular data in Web applications.



• Ability to “coerce” data types for return values, parameters, and fields in structure classes. Synergy data types are currently mapped to C# data types in the generated assembly. For example, decimal types are mapped to either int or long, depending on the length. You now have control over this mapping—you can change the mapping for decimal, implied decimal, and integer data types to non-default data types such as Boolean and DateTime. (For return values and parameters, you will select the coerced types when you define data in the MDU. For fields in structure classes, you will specify the coerced types in Repository.)



• Equals() and Clone() methods, plus Changed property, now in the generated structure classes. The structure classes in the generated assembly now include the following:
• The Equals() method tests whether data in two structure classes is the same, making it easier for you to make this comparison.
• The Clone() method returns an exact copy of the structure class on which it is called. This can be useful when you change some fields in a structure and then want to compare it to the original.
• The Changed property lets you determine if any fields in a structure have been changed using the “set” method for a property value. This is especially useful when using DataTables--once you determine which records have been changed, you can then send only those records to your Synergy application. (The Changed property is available only when structure members are generated as properties.)
• Ability to generate a structure class that has read-only properties. You can now use a structure class that contains read-only properties within a .NET application. When structure members are generated as properties, fields that are flagged as read-only in Repository will now be generated as read-only properties in the C# class. (They will have a “get” method but no “set” method.) Having read-only properties can be useful for key fields that you do not want to be changed on the xfNetLink side.
  
  
• Ability to include C# compiler options. It’s now easy to specify C# compiler options when building your assembly. You can set a new environment variable, SYNCSCOPT, to any valid C# compiler options that you want added to the command line when the assembly is built (either from Workbench or from the command line).



• AssemblyInfo.cs file is not overwritten. We no longer overwrite the AssemblyInfo file when classes are regenerated. This means that any edits you have made to the file, such as for assembly version number, will be retained.



• Ability to run the Verify Catalog utility from the MDU command line. You can now run the Verify Catalog utility from the command line with the new –v option. This utility updates the structures in your SMC definitions with the current structure sizes from the repository. In addition, genxml will now issue a warning if the SMC and repository structure sizes are out of sync. (In Workbench, this warning displays when you generate classes.) These features will make it easier for you to keep your SMC and repository in sync and thus avoid any errors that may be caused if they are out of sync.



• Date/Time stamp is now recorded in the log for each packet sent/received. If protocol logging is enabled, the log now includes a date/time stamp for each packet sent and received. This gives you additional troubleshooting information.

Windows Server 2008, SQL Server 2008, and Visual Studio 2008
Synergy/DE 9.1.3 is the first version to support Microsoft’s latest releases. Even if you do not need to upgrade to these new Microsoft versions now, we recommend that you upgrade to 9.1.3 so that you will be ready when you do need them.

GO/DEBUG debugger command
Instructs the debugger to go to the next statement or routine that is compiled with debug. This will be especially useful to UI Toolkit developers who will be able to skip code in TKLIB.ELB but still break in UI Toolkit methods.

B_INFO UI Toolkit routine
Provides information about buttons on Windows.

SlickEdit upgrade for Workbench
Synergy/DE 9.1.3 includes an upgrade to SlickEdit version 12.

Synergy/DE 9.1.1 Features and Benefits

Redeveloped Compiler
The new Synergy/DE 9.1.1 compiler is a multi-pass compiler that enforces correct syntax more strictly than earlier Synergy/DE compilers. This means it will detect errors that previously may or may not have been caught by the Runtime. You will save valuable development time by finding errors earlier in your development cycle, and you will produce higher-quality applications because these errors will not slip through.(Note that any changes you make to your code to comply with the enhanced error checking will still be supported under Synergy/DE 8.3.)

• Strong prototyping significantly enhances error reporting
• Optional for subroutines & functions, required for classes
• All Synergex-supplied APIs will be strongly prototyped where possible
• New -qrelaxed compiler option (/RELAXED on OpenVMS) enables you to turn off most of this error checking to assist you during your upgrade to version 9.
• New -qstrict option enforces real array bounds checking at runtime (without the overhead of qcheck). Provides improved warning detection for questionable code and is strongly recommended for production code.
• New SYNCMPOPT environment variable can be used to set compiler options for all subsequent compiles. (Helpful for adding or removing the new -qstrict or -qrelaxed compiler options.
• Higher-performance code generation
  • Code translation
    • a += 1  becomes incr
    • if a.eq. 0  becomes if .not.a
    • Better integer literal inlining for prototyped routine calls
  • New opcodes for improved performance
• Better error detection. Includes some security-focused error detection and some error detection that has been moved from runtime to the compiler.
• Support for arrayed arguments when passing structures mapped to handles to a subroutine
• Support for calling a function with no return value
  • my_function(a,b)
• Support for endrecord/endmethod, etc.
• Repository and .INCLUDE caching in multi-module compilation units for better performance
• The maximum number of include levels is now 65,535, up from 8.
• A new prototype generation utility, dblproto, enables you to strongly prototype your own routines.
  
  

Synergy/DE 9.1.1 provides a level of object support that matches other industry-leading OO languages. It supports all features that typical OO programmers would expect to find in an OO language, including inheritance and encapsulation. You can incorporate OO techniques into existing applications, or create full-blown OO applications that leverage all the benefits of OO programming. These benefits include the ability to develop new programs more quickly, and to create programs that are easier to maintain and reuse.

• Uses new analysis engine to support all current and future syntax; limitations related to the previous parser have been removed (for example, it now supports GROUP subroutine arguments)
• Full support for Synergy objects in the tagging and indentation engines. For example, when you request a field list, Workbench displays all variables that are defined as class types within the current routine being edited, in the same manner as it displays variables. Also, when you type a method name after a class handle, followed by a parenthesis, Workbench brings up the context-sensitive help for the method.
• Upgrade to SlickEdit v11
• Improved colorization of Synergy/DE statements and routines
• Improved support for alt. (alt dot), which moves to the definition of a variable/routine in a .include file
• Improved syntax expansion and completion
• Addition of return types for tagged functions
• Ability to launch prototype generator
• Additional .NET component support. You can now generate structure members as fields instead of properties, and you can generate multiple copies of classes.
• Improved tagging performance
• A new "Generate Synergy Prototypes" function on the Build menu enables you to generate Synergy Language prototypes for the source files in your project.
  
  

With the new ablity to establish parent/child relationships between UI Toolkit windows, you can now create "composite" windows. A composite window consists of a parent window and child windows, and it functions and appears to the user as a single window. For example, a composite window could have input fields at the top for header information, a table in the middle for line item entry, a multi-line field that supports rich text editing through an ActiveX control, and buttons. You will implement composite windows via the new %C_CONTAINER function.

The redeveloped compiler and other foundational changes provide a new infrastructure for Synergy Language that will enable Synergy/DE to continue to grow.

• New "analysis engine"
  • A new internal parsing & analysis engine is used by Workbench, the version 9 pseudo (existing) compiler, the new version 9 compiler (prototype generator), and in the future it will be used by the .NET IL compiler.
• Foundation for future support of Microsoft .NET
  • Additional data-types for .NET
  • Enumeration
  • New -qnet compiler option enables you to prepare your code for the Synergy.NET release. It instructs the compiler to display warnings and information regarding how your code will work with our future .NET support. This includes deprecated data types, syntax, APIs, compiler options, and alignment warnings.
    
    

These features provide additional benefits that will further enhance your productivity and streamline development efforts.

• Dynamic arrays for classes. You can declare a dynamic array of reference types whose upper bounds are determined at runtime by specifying a "#" for each array dimension (for example, [#,#])
• INIT statement initializes a field or record to its declared default value.
• (Windows, Unix) We now support relative files larger than 2GB. (On Unix, this support is limited to modes other than update mode.)
• Improved runtime performance
  • Integer FOR statements
  • Integer literals passed to strongly prototyped routines
  • Same data type stores (for example, A=A and D=D)
  • (OpenVMS) Improved sharing of loop code internal information across processes
• Structured exception handling
  • TRY/CATCH/FINALLY
  • Enables you to obtain the following information about an error:
    • Error message
    • Error number
    • Name of application or object that caused the error
    • Call stack at the time the current exception was thrown
    • Line where exception was thrown
    • System error number
    • File number of source file
• Enhancements to .INCLUDE from a repository
  • You can now specify DIMENSION.
  • You can now specify PUBLIC, PRIVATE, or PROTECTED for records, structions, or groups.
  • You can specify IN, OUT, or INOUT when including a group as a parameter to a method, function, or subroutine.
• Debugger enhancements
• (Windows) You can now scroll the debugger window to view more than 25 lines of text. By default, 300 lines of display are saved, and you can change this with an environment variable setting. (This enhancement has also been added to the UI Toolkit debugger, DTKDBG.)
• Ability to debug all aspects of Synergy objects, including inspecting and setting class member values (“Show objects”)
• New command line parser that includes support for objects
• You can now log a debugger session to a file.
• When you examine a named record or group, the debugger now shows all named members.
• You can now specify /PAGE at the end of the command line for SHOW, HELP, and EXAMINE
• New %U_HTMLHELP routine in UI Toolkit enables UI Toolkit programs to invoke Windows HTML Help (.chm files).
• (Windows) For xfODBC, we increased the maximum number of rows that can be returned when a statement is optimized with multimerge to 999,999 rows.
• MySQL (version 5.0.24 and higher) is now supported on Linux.
• We enhanced the sample programs that are distributed with SQL Connection.
  
  

Synergy/DE 9.1.1 was the first Synergy/DE version to support Windows x64 and Windows Vista.