CobolTransformer 3.1 Announce

CobolTransformer 3.1 Announce
-----------------------------


Siber Systems is pleased to announce availability of Version 3.1 of
CobolTransformer http://www.siber.com/sct/ and Specific Converter
Tools based on it.


CobolTransformer is a complete toolkit with well-designed API that
allows you to focus on particulars of your Cobol reengineering
projects and not worry about handling complexity of quality Cobol
lexing, parsing, and code generation.


If you need to automate analysis and/or conversion of your legacy
Cobol code and you want the automated solution to be delivered fast
and have high quality, then it is time to get a CobolTransformer
license.


CobolTransformer includes:
- Cobol *Parser* that parses 16 most popular Cobol dialects. This
parser could parse everything in the Federal Compiler Test Suite
CCVS. Unlike many other Cobol parsers, it can parse Micro Focus Cobol
too.


- Cobol *Program Tree* and library of routines used to browse and
transform the Program Tree. Definition-Use links attached to the
Program Tree effectively make it a general case Program Graph.


- *PrettyPrint* and *SourcePrint* code generators that transform
Program Tree into human-readable Cobol source.


To get more information, please direct your browser to
http://www.siber.com/sct/


Major New features in CobolTransformer 3.1
------------------------------------------


** SourcePrint **


The most important feature of 3.1. is revolutionary SourcePrint
capability that allows you to fully restore the unchanged parts of the
Cobol program, while using the full power of the tree-based program
transformation engine.


Details.
Our general sequence of steps needed to perform
a program transformation is fairly standard:
(1) parse the program making it a Program Tree,
(2) transform the Program Tree, and
(3) generate the converted Cobol code from the transformed Program Tree.


The only problem with this approach is that the Cobol code generated
from the Program Tree usually differs from the original source code.
The differences are minor -- words appear in different columns, some
optional words may be skipped or added.


These differences are result of a process of automatic code generation
which cannot exactly reproduce the original program. While these
differences may seem insignificant, they do not allow to use *diff* or
any other automatic file comparison utility to independently verify
what lines were changed by the converter. This is because the little
differences introduced by beautification make every line look
different to these diff utilities.


Enters the SourcePrint. We store additional data in the tree nodes
that allows us to generate Cobol code that does not differ from the
original code -- down to a single byte -- for the tree fragments that
were not changed by transformations.


Code that is generated from the new tree nodes is generated in the
beautified mode as was the case in the SCT versions prior to 3.1.


What does it mean for you? It means that Cobol converters that use
SourcePrint are easily and inexpensively verifiable. That is, upon
finishing the conversion, you can run line diff utility that compares
original directory with the full source of your application to the
directory with the converted source. The generated difference logs
are guaranteed to be minimal and reflect only changes made by the
converter (and not the changes introduced by beautification or other
parsing/printing side effects).




** Copybook Generation **


The other important feature of the Version 3.1 is its ability to fully
control the copybook structure generation.


As you may already know, a Cobol program consists of the main file and
copy library (or copy book) files that are included in the main
program by a preprocessor. Cobol parser needs to inline all the
copybooks in order to correctly parse the program and build the
complete Program Tree.


However, when it comes to code generation, the almost universal desire
of the conversion engineers is to have their copybook structure back.
That is, the converted main file must contain COPY statements that
refer to the converted copybooks.


Since the copybooks also may be affected by a conversion, this creates
a non-trivial problem of un-inlining the copybooks. By un-inlining we
mean process of code generation in which a main program with COPY
statements and series of copybooks used by these statements is
generated from a single Program Tree.


The correct and fully functioning implementation of copybook
un-inlining is the new feature available in CobolTransformer 3.1.


In addition to restoring the original copybook structure you can
easily change the layout of copybooks: fully inline the existing
copybooks, separate a fragment of code into a new copybook, or
generate a totally new hierarchy of copybooks. All this is made
possible by storing the copybook-related information on the Program
Tree.




** Client-Server **


Another big advance in CobolTransformer is Client-Server Packaging.
This is in addition to the previously standard Library Packaging.


In client-server packaging all non-trivial functions such as parsing
and pretty-printing occur in CobolTransformer server executables that
run in a process/task that is separate from the process/task of your
converter.


The thin CobolTransformer client linked in with your conversion
application contains only the tree transformation functions and proxy
functions for parsing and pretty-printing that call the
CobolTransformer server.


Client-Server Packaging makes CobolTransformer a bit slower,
because some time is spent on Program Tree externalization and
internalization. However, it provides numerous advantages
that are well worth the price:


- It is possible to have CobolTransformer client library in different
languages. In addition to C++, client libraries in C, Perl and Cobol
are planned.


- Memory allocation problems such as leaks and dangling pointers
cannot possibly propagate from your application to CobolTransformer
and back, because your application and CobolTransformer run in
separate address spaces.


- We are able to provide you with a Free Trial Copy of CobolTransformer.
It was not possible when CobolTransformer was a static library.


The Library Packaging of SCT is still available.




** Free Evaluation Package **


Now, with introduction of Client-Server Packaging you can try
CobolTransformer for free.


You can actually write your own conversion/analysis application that
uses CobolTransformer and see how it works on small (less than 256
lines) programs.


Once you are satisfied with the results, you can purchase a
CobolTransformer license and the application that you wrote will then
work on program of any size.


This is a new risk free way to appreciate the power and flexibility of
CobolTransformer.


Best regards,
Vadim Maslov
Siber Systems
--

Return to the comp.compilers page.
Search the comp.compilers archives again.