Syntax coloring for comments have been restored.

The SET UP BY verb do not halt transmodeling anymore.

PERFORM X TIMES is now properly transmodeled as a loop.

VALUE ZERO is now properly modernized in LEVEL 88 context.

Commas in VALUE context are not interpreted as floats anymore, excepted if DECIMAL-POINT IS COMMA is present.

When using the file type detection and renaming feature of the reverse COBOL project creation wizard, the .ddl and .dat extensions are now left as is.

File type detection as been improved; binary files are not renamed as copybooks (.cpy) anymore.

More variants of the COPY REPLACING are now supported.

Replacements leading to lines wider than 72 columns are now properly parsed.

Copybooks whose last line is not EOL-terminated are now supported.

More variants of READ, PERFORM, MULTIPLY and EVALUATE verbs are now supported.

More PIC variants are parsed.

StringUtils.isBlank is now generated instead of ReverseUtils.isSpace.

When transmodeling a program containing PROCEDURE DIVISION statements not contained in a section or paragraph, they are collected in a simulated [Program Name]_MAIN paragraph.

Level 88 expressions are now modernized as <<Process>>-stereotyped activities containing a BAGS expression, which permits more generic code.

The service creation wizard is now robust with respect to homonymous UML objects stored in the same package.

The constructor required by exception handlers is now generated.

MagicDraw-created target pins on writers do not crash generation anymore.

TemplateLineWriter now properly logs application exceptions.

Setting the ftpEnabled property is not required to generate sort steps anymore. The sortEnabled property has been added for this purpose.

A recordLength tag was added to the SORT_STEP stereotype in order to specify the length of input file records, when they are not delimited by an LF character.

A list of input files can now be specified to the sort tasklet by separating them by a comma or semicolon.

A FILE_OPERATION_STEP is now available. When applied to a PK_STEP activity, its functionality is specified by the mode tag, which can take the following values:

Files to process are specified by the targets (mandatory) and sources properties, using the Spring resources syntax competed by wildcards if needed. Multiple patterns can be separated by commas or semicolons.

Spaces can be used as separators for the db.tables property.

Sonar warnings have been taken into account in code generation.

Javadoc on generated code and tools classes have been improved.

Use of fully qualified names for classes has been limited in generated code.

A useSonar property was added to the SpringBatch workflow. It will trigger the addition of the sonar plugin to the parent POM.

A useMavenAdditionalPlugins property has been added to the workflow. It is required for proper packaging of generated code with Maven (using mvn:package).

Any value of the language field of opaque actions different from “bags” is now ignored and lead to opaque content inclusion in the generated code. This works around a behavior of MagicDraw Properties Editor, which may set this field to “English” instead of leaving it empty.

The postprocessor can now have a return type of int, Boolean or String.

In some scenario the DataFlow view could disable selections in the COBOL annotations editor. This is fixed.

Slowdowns of the annotation editor when using BLU AGE in a remote (RDP) environment have been fixed.

Navigation in previously visited locations in legacy code (using the Ctrl+Click / Alt+Left / Alt+Right shortcuts) cannot be hampered by transmodeling or some views display anymore.

Explicit (literal) CALLs between COBOL programs can now be followed using Ctrl+Click.

Dependencies can now be defined between COBOL reverse projects using standard Eclipse project dependencies. For this purpose, right click on the project and use Properties > Project References. Once dependencies are defined, calls to COBOL programs from dependant projects can be followed.

The CRUD services or operations creation wizard now honor usual naming conventions (operation + entity name: “saveCurrency”, “udateCurrency”… or service + operation + entity name). Moreover, it is not necessary to input an operation name in the operations creation wizard: the generated operation will be named operation + entity name.

Multiple resource folders can now be added in the KDM configuration. The first one will then be standard generated resources; the following ones can be used through dir defs. They will then be taken into account in the classpath and POM.

The value of the append tag of the EBCDIC writer if now properly taken into account.

Generated parent POMs now properly reference modules.

BAGS arithmetic operators on BigDecimal values are now properly generated as operations.

CP1047 sort order is now properly implemented for all characters.

FI and BI are now supported in include omit sorts.

lineSeparator has been added to template writers. It has the same behavior as on the flat file writer: the lineSeparatorOut workflow option will be used, excepted if it is set to NO_VALUE.

The following modifications are mandatory in existing SubstitutionProperties.xml files for properties of template writers or write_template_line_operation:

A FORMAT property was added in SubstitutionProperties.xml. It controls the format specification of output fields and must take one of the following (case sensitive) values:

The PD (Packed Decimal) sort mode is now supported. Note that the file lines must be delimited through recordLength: CR and LF delimiters cannot be used since they may appear in a packed encoded value.

VB (Variable Block) files sort is now supported. For this purpose, the isVariableBlock tag of the SORT_STEP stereotype must be set to true.

The ebcdicDefaultValue workflow option can now be used to control which byte if written by EbcdicEncoder when a value is null. The possible values for this option are LOW_VALUE (its default), ZERO or SPACE.

It is now possible to control at runtime which copybook will be used by an EBCDIC writer. For this purpose:

Files packaged in the service jar (copybooks, data files, templates…) can now be properly accessed.

An encoding tag has been added to the following stereotypes (if this tag is not set, the workflow value is used):

<<process>> activities can now be owned by entities. This is especially useful to model synthetic attributes through getters and setters.

Order of generated artifacts for entities now follow Java standards: attribute definitions, constructors, then alternate getter and setter for each attributes.

Unneeded fully qualified names in context casts have been removed.

Duplicated constants in EbcdicDecoded and EbcdicEncoder have been factored.

Rare low-level errors could halt the parsing of COBOL programs (Eclipse message “An internal error occurred during: “Updating project”). Now, should those happen, they will be displayed in the “Problems” view, under the “Unexpected Parsing Error” type.

Parsing of the NOT INVALID KEY construct is more robust.

SOURCE-COMPUTER / OBJECT-COMPUTER entries in the CONFIGURATION section and SYMBOLIC CHARACTERS in the SPECIAL-NAMES section do not halt parsing anymore.

Parentheses in the replacement source of COPY REPLACING are supported.

“SYSLIB” and “FOR RESPONSE” are now accepted in “CALL” verbs.

“#” is now accepted in PIC formats.

More PIC variants are supported (order of specifications is more flexible).

More STRING/UNSTRING variants supported (DELIMITED is now optional).

Parsing of intrinsic FUNCTION expression has been improved.

The DO PERFORM variant is now supported.

File search results in COBOL programs are not offset anymore by copybooks inclusion.

An “ALL” category was added in statistics export and combo box.

Order of categories is preserved in statistics export.

The Category preference is now synchronized with the editor.

The Statistics view does not cause slowdowns anymore.

Included copybooks are now properly taken into account in lines count.

The GOTO … DEPENDING ON verb is now transmodeled as a “switch” construct.

Empty sections do not halt transmodeling anymore.

Signed numeric constants will not cause the generation of invalid Central Buffer Node names anymore.

Linking (Ctrl+Click) to FILE DESCRIPTION from file manipulation verbs is now available.

Linking to programs will now use in priority the PROGRAM-ID to identify the target program, then fallback to the file name.

Common COPYBOOKs are now included in programs (SQL ORACA, SQLSA and SQLCA).

Any textual file can now be annotated. For this purpose, use Right click > Open With > Annotation Text Editor. Statistics for those annotations can be generated from the Statistics View.

Transmodeling of intrinsic FUNCTION expression has been improved (parameters are now properly extracted).

The Business Object creation wizard is now robust to the existence of an activity diagram homonym with the entities folder.

XML special characters in sort cards configurations (sort, sum, omit, include, inrec and outrec) will not halt Spring configuration loading anymore.

An exception is now thrown when reading an RDW size of zero.

Sort with multiple inputs will not fail anymore when output file does not exist.

Comparison between a field and a differently-sized string (as specified in INCLUDE tag) now behaves similarly to DFSORT.

Abend of a job will not cause an error when closing EbcdicFileReader anymore.

The <<Datasource>> stereotype is not considered as invalid on Interface anymore by the batch model validator.

The “file” property of the <<read_ebcdic_operation>> is mandatory, and is now validated as such.

Steps not needing an Activity diagram (SORT, FTP…) do not generate initial and final validation errors anymore.

To write different template lines in a file while ensuring the lines order, a single operation stereotyped <<write_template_line_operation>> must be used. This operation must bear two parameters:

Note: in this case, do not use the “recordWriter” tagged value.

Multiple lines can be written at the same time in a <<write_template_line_operation>> while referencing only one line identifier. For this purpose, create a lines group with an empty identifier for all lines except for the first one, which contains the group identifier. As an example, the following lines define a group identified by “table header”, writing two lines when used:

table header:COLUMN 1    COLUMN 2    COLUMN 3             :--------    --------    --------

In configuration cards (sort, sum, omit, include), the field format must be either explicitly be specified, or a default format must be provided using “FORMAT=”. Failure to do so will now throw an exception.

Formatting of numeric fields using EDIT, SIGNS, LENGTH and predefined types (“Mx”) is now supported.

The EBCDIC reader now accepts leading spaces in zoned decimal values.

The EBCDIC reader now owns a “hasRDW” tagged value to specify that it contains RDWs. Similarly, the EBCDIC writer owns a “writeRDW” tagged value.

Attributes of sub-entities can now be accessed when using group readers. For this purpose, list the path to the final attribute, separated by ‘.’. Note that this will not work with fields having several occurrences.

An encoding tag was added to the following stereotypes:

If the tag is not set, the workflow value is used.

A <<return_generated_key>> stereotype can now be applied to <<sql_update_operation>> methods to specify that an automatically generated identifier must be returned. For this purpose, its “key” tagged value must specify the generated key name.

An <<EMAIL_STEP>> stereotype can now be placed on an Activity. It can be configured using the following tagged values:

At least one recipient must be provided (to, cc, or bcc). The message body is read in a file specified in substitution properties ("job.step.body").

The following methods are now available to handle counters in the StepContextManager and JobContextManager (Step and Job scopes):

The last three use a default value of “0” if the counter does not already exist.

The counter is a standard context variable and as such can be accessed using existing related methods (putInContext, getFromContext…).

A <<contextVariable>> stereotype is now available. Its “scope” tagged value (default: step) specifies whether it is a step or job scoped variable.

Generation Data Groups (GDG) can now be referenced in the substitution property by using the “gdg-read:” or “gdg-write:” prefix instead of “file:” to specify the file. The possible syntaxes are either:

Syntax detail:

As an example, an output specification of gdg-write:data/output/REPORT.(3).txt will first create a file named REPORT.G0000V00.txt, then a file named REPORT.G0001V00.txt, etc. At the fourth writing, REPORT.G0003V00.txt will be created and REPORT.G0000V00.txt will be deleted.

A “strict” tagged value (default: true) was added to jobs. If true, the job will fail when a resource (file to delete, to merge…) is missing. If false, a warning is logged and execution continues.

A “transactionTimeout” workflow property (default: 10) is now available to specify the value of the Atomikos transaction timeout in data-source-context.xml.

The code quality has been improved in Formatter, Sum, FilterBuilder and CharFilter classes.

log4j.properties is now generated in src/main/config when appAssemble is activated.

The compare feature now takes into account properties ending in “outputFile” in SpringBatch substitution properties files.

The SET TO XXX TRUE transmodeling has been restored.

Opaque nodes could be generated twice when mappings were missing. It does not happen anymore.

MOVE SPACES towards level 88 fields do not generate flush services any longer, but elementary assignments.

The renaming option for inputs proposed by the COBOL reverse projects creation wizard now searches for JCL scripts. When such a file is identified, it is renamed with the « .jcl » extension (and no longer « .cpy »).

Duration of initial built of COBOL reverse projects has been reduced.

ON [NOT] OVERFLOW construct is now recognized.

TIMEOUT is now valid as an identifier.

Handling of the COPY … REPLACING ==XXX== … syntax has been generalized.

When a COBOL paragraph and section have the same name and a PERFORM or a GO TO targets this name, Ctrl + Click from these verbs will reach the paragraph instead of the first element found.

The INDEXED BY construct does not cause a warning any longer, and can now be reached by Ctrl + Click.

Considering the following COBOL code:

IF <condition>

NEXT SENTENCE

ELSE

<Statements>

The STRING … INTO verb is now supported for DELIMITED BY SIZE and DELIMITED BY <literal> operators, with reading and writing into elementary fields.

The INITIALIZE verb is supported for the initialization of the elementary fields.

It is now possible to modernize (using the wizard Transient Object Modernization) and transmodel level 01 fields directly owning levels 88.

A caching mechanism is now provided. It can significantly improve the initialization time of the transmodeling wizard starting from its second launch. To activate it, tick the following checkbox in the preferences: « Blu Age ⇨ Blu Age Reverse ⇨ Model Transformation ⇨ Generic Model caching ».

A mechanism allowing to choose the type of activity diagrams generated by the COBOL transmodeling has been set up.

The hasrdw property of the <<ebcdic_read_operation>> is now generated at the right place.

The value of clientMode and fileType properties of the FTP_PUT_STEP stereotype is now correctly handled.

The behaviour regarding GDG numbering is as follows :

Accesses to boolean properties BAGS are now using the isXXX method when present.

The PreparedStatement are now correctly released in case of an exception.

Headers on the comparison results tables are now correctly generated.

When the HeaderSize attribute is not in the copybooks header, it is now considered as 0.

StringUtils#substringBefore, StringUtils#substringAfter and StringUtils#stripEnd utilities have been added to the UML profile.

The BigDecimalUtils#subtract utility has been added to the UML profile. It is still possible to generate the « substract » method when setting the option of « donotGenerateDeprecatedOperations » workflow to false.

A new "useDatabase" workflow option has been created. It is true by default (unchanged behaviour). In the case of a job that does not require an interaction with the database, the option can be set to false in order to avoid to specify connection information in the launch config.

It is now possible to generate a job only consisting of a <<FTP_PUT_STEP>> step.

It is now possible to generate a step only consisting of a sorting step.

It is now possible to generate a job consisting of two <<FTP_PUT_STEP>> steps.

A gdg-options property allows to specify the maximum number of generation for a GDG file. Each file is identified by its simple name followed by the string « (*) » and its extension (example: "file(*).txt"), then by two parameters : the limit (maximum number of generations in the dataset) and the mode (empty/noempty). The limit by default is 0 (in which case, all files are kept); the mode by default is noempty (see below).

For example:

When generating BAGS expressions in an activity diagram handled by a BO or an entity, « this » and its attributes (even the inherited ones) are now referenced.

The compare feature is now accessible via an Eclipse launch configuration.

The Output directory is optional, it is here by convenience. The output directory can be anywhere, its location has to be specified in the launch configuration (see screenshots below).

The launch Configuration consists of 5 tabs: Common, Database Comparison, Ebcdic Comparison, FlatFile Comparison and Save.

The Common tab contains all common properties of the comparisons. The name and the type of the comparison project must be entered : Ebcdic, Database, FlatFile :

The Database Comparison tab allows to enter the required properties when comparing BDD (see the following example).

The EBCDIC Comparison tab allows entering required properties for an Ebcdic comparison. The user must fill in the name of Ebcdic files directory that he wants to compare (see the following example).

The FlatFile Comparison tab allows to enter the required properties for a FlatFile comparison. The user must fill in the FlatFile files directory that he wants to compare (see the following example).

The Save tab saves the settings in the project (see the following example).

The CacsContext class and its ContextManager are automatically added in the entity/dm layer, provided the generateContextClasses workflow option is set. The context manager is automatically referenced in the Jobs, and can be invoked in the job configuration.

The context is also available through a new interface in the dwp profile:

This product uses the usual batch modelling, with some specificities. One of the main differences is that no substitution properties are used. Instead, step attributes and/or action pins must contain the file names. #{…} constructions may be used to reference other variables in such names. For example:

As usual <<PK_JOB>> will contain the Jobs and <<PK_STEP>> will contain the steps. But the target architecture requirement impose that the corresponding classes are in the same place. Thus, the <<PK_STEP>> and <<PK_JOB>> packages must be the same one.

The generated elements for each Job are the Job Launcher class and the Job configuration XML file. All these XML files are generated in the META-INF/batch-jobs folder.

The generated elements for each step are the some classes for readers, writers and processors as listed below, as well as tasklets for empty-file-checks.

A job diagram consists in a set of steps.

The allowed steps are of five types listed below.

The steps may be sequential or conditional. Decision and Merge nodes may be used as in normal batch modelling, with guard conditions.

Job may have inner attributes. Two attribute types are allowed: String and Object. If the type is String, the attribute default value will be used as the value, if the type is Object, the attribute default value will contain the fully qualified name of the class to reference. This can be used to obtain this kind of setup (excerpt of the sample application):

The most usual step type is the read/process/write step, which bears the <<STEP>> stereotype. It contains a reader, a processor and a writer as in normal modelling.

Empty-file-check steps are available through the <<STEP_EMPTY_FILE_CHECK>> stereotype. The guard conditions to use are “EMPTY” and “NOT_EMPTY”.

Merge steps are available through the <<FileMergeTasklet>> stereotype found in dwp profile. If no more setup is added, it will use the default implementation SimpleFileMerger found in the framework. The merger tagged value can be used to link a different class (fully qualified name expected) that may be supplied as a specific class.

Sort steps are available through the <<FileSortTasklet>> stereotype found in dwp profile. If no more setup is added, it will use the default implementation SimpleFileSorter found in the framework. The sorter tagged value can be used to link a different class (fully qualified name expected) that may be supplied as a specific class.

Fully specific tasklets can be used. The step must bear the <<CUSTOM_STEP>> stereotype and the implementation tag must be filled. The class must be supplied as a specific class.

The allowed readers are <<FlatFileReader>>, <<JDBCReader>> and <<JPAReader>>. <<GroupReader>> can also be used in addition.

The allowed writers are <<FlatFileWriter>>, <<JDBCWriter>>, <<JPAWriter>>, <<TemplateLineWriter>> and the special <<SQLScriptWriter>>.

The readers and writers setup is similar to normal batch modelling, except that:

The processor can be a Call Behavior Action referencing a process operation in the service layer, as in normal Batch modelling.

The processor can also be a Call Behavior Action referencing an inner process diagram. This kind of modelling is similar to the Rich UI event modelling.

This specificity can also be used for preprocessors and postprocessors. In these cases, as usual, the Call Behavior Action must bear the <<PreProcessor>> or <<PostProcessor>> stereotype, respectively.

For these inner process diagrams, the new <<Processor>> stereotype can be used. It is only an eye candy, so that the inner diagram is easily seen in the containment tree. It is not mandatory.

A spurious duplicated files warning popup will not be displayed anymore when renaming COBOL inputs during COBOL reverse project creation.

When the “Rename According To File Content” box of the COBOL reverse project creation wizard is unchecked, no more renaming take place. The previous behavior was that all files were renamed to a “.cblmf” extension.

Creation of patterns from the Pattern Search view has been restored.

Filtering of displayed mappings by UML field, class and package now works properly.

A rare case of transmodeling error (“More than one rule registered for PerformStatement”) was fixed.

Generated UML does not contain unneeded “TODO” anymore when transmodeling COBOL indexed access.

Unnamed associations between classes are now robustly handled by transmodeling when targeting BAGS.

Calls to BigDecimalUtils#subtract are not generated as “substract” anymore.

COBOL parsing speed has been increased.

Parsing of string literals “continuated” on multiple lines has been improved.

Those UNISYS-specific constructs are now properly parsed and linked:

A rare case of missing EXEC SQL PREPARE line after copybooks insertion was fixed.

Usual, unneeded star characters (*) at the beginning or end of COBOL comments are now removed during transmodeling when generating UML notes. Should the resulting comment be empty, or only composed of spaces, no note will be generated.

A report can now be generated to ensure that all “Modernized As” annotations properly point to existing model elements.

Writers using a non-parameterized SQL request are now properly generated.

Files merge using FILE_OPERATION_STEP is now robust in situations where the target file is part of input files. The behavior is the following:

FTPGetStep and FTPPutStep classes now properly take into account logger configuration when using a non-default one.

When a property is present in an entity / BO, and a getter or setter operation of the same name (either stereotyped <<formula>> or <<process>>) is modeled, the resulting java operation is now only generated once. In this situation, the modeled operation takes precedence, and the default accessor is not generated.

<<sql_update_operation>> methods executing non-parameterized requests are now properly generated.

“+” prefixed literals are now accepted in BAGS expressions.

The implementation of DateUtils has been improved.

Spurious “Reference from … cannot be exported” log messages will not be displayed during code generation anymore.

DROP VIEW statements are now properly generated.

Database comparison now works when the specific, copybook and expected folders are empty.

Dependency to the JDBC driver is now added when creating a SpringBatch project. For this purpose, a new wizard page has been added so as to specify database parameters. The “active” box must be checked to take those parameters into account. Should this box be checked and parameters also added to the existing page (see below), this new page takes precedence.

For coherency reasons with the previous point, the following wizard page has also been modified. Some of its properties are now only displayed in “Advanced” mode since they duplicate properties of the new page. Those are:

The latest version of the Compare Feature Launch Configuration is provided. All properties required by the different comparison modes (EBCDIC, DB, FlatFile) are available.

Headless execution of the compare feature requires the specification of the path to the Launch Configuration (as shown below).

More “SPECIAL-NAMES” entry syntaxes are now properly parsed.

The COBOL “IS NUMERIC” condition is now properly transmodeled as a call to the StringUtils.isNumeric Blu Age utility.

Constants are now properly generated.

The getDifferenceInDays() method of DataUtils now returns the proper value when provided dates range spans daylight saving time.

The JavaScript code required by the allcols variables is now available in generated views. Note that columns of the “Display/Hide columns mismatch” category are best displayed by the Firefox and Chrome browsers.

When using model caching to improve performances, annotations modifications are now properly taken into account by subsequent transmodelings.

The following constructs of the COBOL Unisys variant are now parsed:

Beans can now bear synthetic operations, stereotyped with <<formula>> or <<process>>.

Code quality was improved by taking into account the following SONAR warning:

The SCL/SCP annotation editor feature was restored.

The Legacy Object Modernization wizard (aka TOM) will now modernize OCCURS fields as associations of the proper cardinality (when subfields are present), or typed Lists (for scalar types). Optionally those choices can be manually overridden to Blu Age array data types (string[], etc.).

Transmodeling generates appropriate BAGS access expressions for legacy expressions accessing the following mapped fields:

While transmodeling COBOL OCCURS specificities (ambiguous subscripts, non-zero-based indexes) are taken into account.

Classes can now be deleted in the Legacy Object Modernization tree. This is useful in the scenario where the fields of multiple legacy entities are moved in a single modernized one, hence leaving “empty” classes.

FilenameBuilder can now be annotated with @Named. Its name tagged value property will then be used to generate the associated @Named annotation in the generated service implementation.

The @OrderBy(“name”) tagged value is now taken into account on entities and properly generated.

The process creation wizard can now use as types <<bean>> elements (hence residing in PK_SERVICE).

A new BSP was added in the product. It generates the various framework classes used by EBCDIC features. Its name is com.netfective.bluage.dwp.ebcdic.

The project where the classes will be generated is the Batch EPM one, due to dependencies between the framework classes and spring batch, which is only available in the EPM. They can then be dispatched in another location (e.g. in the foundation module) as usual.

The package where the classes will be generated is determined thanks to the ebcdicPackage workflow variable.

<<EBCDIC_READER>> was added as an allowed reader type in steps.

<<EBCDIC_WRITER>> was added as an allowed writer type in steps.

In the same way as the flat file readers, in the reader, the file tag contains the bean which will hold the values parsed from the input file.

In the same way as the flat file readers and writers, the reader input file must be supplied as an input pin and the writer output file must be supplied as an output pin.

The copybook location must be supplied as an extra input pin. Hence an EBCDIC reader will have two input pins: the first one is the input file, the second one is the copybook, and an EBCDIC writer will have an input pin and an output pin.

In the copybook, the record format may contain field groups. In this case, the target bean must have associations to other beans to reflect the format. The field group may even reflect a list of sub beans if occurs > 1.

In the copybook, there may be several record formats for polymorphic data. In this case, the file tag must contain several values.

In this case, all the involved beans must bear the <<Discriminator>> stereotype with the regex tag reflecting the distinguishFieldValue in the copybook.

The used beans must be in the EPM layer, because of a dependency on the EBCDIC specific framework. However, depending on where the framework is dispatched, this constraint might be lifted.

The NOT ON EXCEPTION and AT clauses in FIND statement.

The ON EXCEPTION clause in DELETE statement.

FUNCTION(DMERROR)

MYSELF(VALUE)

CHANGE ATTRIBUTE AREAS

The DOUBLE and BLANK features on PIC definition

The non-mandatory keyword IS in SIGN IS features on PIC definition

The RECORD feature on SEEK statement

The MOVE [A :B :C] form statement

The THRU features of RENAMES clause on data definition

The COBOL EVALUATE statement with ALSO feature is now properly transmodeled.

The nested IF Control Structures are now right after “CALL PROGRAM.” Statement.

With respect to the previous released evolution of the capability to map fields on synthetic getters and setters: the restriction of use on non-indexed access has been lifted. Thus, reading and writing access on fields can use these synthetic getters and setters as the shows the following screen shot.

Mapping on particular modernized entities was wrong and thus led to “TODO” opaque actions or invalid guard on conditions. This concerned level 01 or 77 with only level 88 entities. It was fixed.

Some wrong “Abstract::abs()” were generated in BAGS opaque action during transmodeling of a move statement from String to a signed type. In this case no conversion to absolute value is used anymore. If an incompatibility of type is detected, a warning note is added to generated UML.

Some wrong @ReverseUtils.NoName() operation were generated when transmodeling Perform XXX THRU YYY statement. It was fixed.

Lack of linking on entities defined from file description and database led to “TODO” opaque actions. Linking on these entities was established and solved the problem.

BAGS expression generated in opaque action are now lightened from specific type conversion, in particular for BigDecimal conversion. Conversion is delegated to BAGS framework on forward generation.

A workflow property specificPomPath has been added to the com.netfective.bluage.spring.batch BSP, in order to specify the path to the text file to inject.

If the project is configured to use a Maven parent pom, the content of this file will be injected into the parent pom.xml. Otherwise, it will be injected into the pom.xml of all modules.

Only top-level configuration elements can be injected this way, which means elements available under the <project> element.

String continuation construction now supports inserted comments.

Navigation from history in COBOL Annotation Editor works again.

Handle the ALTER statement.

Possibility to use the following keywords as data name.

Handle the POINTER VALUE NULL in segment definition.

Handle the EXTERNAL keyword in File Description definition.

Handle the CHARACTERS and AFTER keywords in COPY REPLACING BY statement.

Generated warnings about Integer to String conversion in transtyping have been removed, since they are not relevant for the supported target languages.

A Bean/Class creation action was added to the wizard. It enables the user to organize its modernized entities. Consider the following use case :

Comp-1 legacy format is now correctly read and written by EBCDIC_READERs and EBCDIC_WRITERs

It handles signed format and unsigned format, as well as decimals. It maps to BigDecimals in the java code.

The class was corrected and no longer issues a NullPointerException in case a polymorphic copybook is read.

Following the evolution made previously on the Ebcdic Readers and Writers, the Comp-1 Unisys legacy format is now correctly used by the compare feature.

A Sonar analysis was taken into account. For the Spring Batch stack, the Business Objects now have symmetric equals methods that use getClass() instead of instanceof.

By default, the Spring Batch generation generates the MYJOB-context.xml file under the src/test/resources folder.

This can now be changed thanks to the generateJobContextInTestFolder option in the launch configuration.

A @Cacheable stereotype is now available and can be put on operations in the model. It must be put with a cacheName tagged value.

The whole cache mechanics is activated thanks to the springCacheProperty in the project launch configuration.

Workflow options exist in the workflow for the global cache configuration. They will be generated in the ehcache.xml file.

Other workflow options exist for the configuration of all the operations marked as @Cacheable. These workflow options come with sensible default values but can be overridden by tagged values on the @Cacheable stereotype applied on the operation. They will also be generated in the ehcache.xml file.

Other tagged values can be added on the @Cacheable stereotype and will be used on the generated annotation in the java code:

All these options correspond exactly to the corresponding Spring/EHCache ones. Please refer to the Spring/EHCache documentation for more information on their exact meanings.

Command line parameters can now be added when launching a Spring Batch job. They must be added as key value pairs and separated by spaces.

These parameters can be accessed through the JobContext in the model.

If the key corresponds to a key in the SubstitutionProperties.xml file, the parameter will be used instead of the value in the file.

In order to allow arbitrary annotations on the generated code, a new feature was added which allows to add raw text on model elements, through the use of headerText stereotype and tagged value.

Following the migration of the base eclipse platform to Mars, integration was done with version 18.3 of Magicdraw.

The EBCDIC reader now correctly handles null values read from a file and to be stored in an Integer attribute.

The throws clause and the logging code can now be removed from the process operations in Business Objects.

The new generateLoggingInBOProcess workflow option defaults to true but can be set to false to remove the logging.

The new generateThrowsInBOProcess workflow option defaults to true but can be set to false to remove the throws clause.

The roundtrip feature was ported to the Spring Batch product. However, this functionality is deprecated. It means that while it can be used, it is provided as-is and it will not evolve anymore.

The reason is that it only works for Java opaque actions in the model, which are discouraged. Instead, BAGS language should be used, or, if there is a piece of Java code in the model, using a specific operation, thus externalizing this piece of code in a real java class (in which the roudtrip feature is useless).

A new sort operation was added in the modelization. There are now two possibilities:

This new operation type takes two tagged values:

Such an operation should be used does not take an argument nor yield a result. It is typically meant to be used in a processor with no reader nor writer. It works like a read_ebcdic_operation, followed by a sort, followed by a write_ebcdic_operation. Thus it needs the input file, the output file and the copybook in the substitution file. Example :

	Warning
	This feature can be used only for copybooks with only one record format. Example :

It is now possible to add a parent POM to the parent POM.