Code Generator for Dynamic XML Processing in Legacy COBOL Systems
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Traditional COBOL programming language lacks flexibility in reading and processing XML documents, requiring complex modifications and additional layers that increase costs and complexity, especially when transforming XML messages to COBOL layouts.
Innovation Solution
A code generator creates programs to read dynamic XML documents at runtime by parsing a template document to determine data structures, generating COBOL code that minimizes the need for complex XML Parse statements and middleware layers, thereby reducing development and maintenance costs and improving processing efficiency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional COBOL programming language is used to read and process XML documents, then legacy system compatibility is maintained, but flexibility and processing capability deteriorate
Solution Approach 1:
The patent introduces an intermediary component that translates between XML documents and COBOL data structures. This mediator enables COBOL programs to process XML documents without requiring direct XML parsing capability in the COBOL language itself, thus maintaining legacy system compatibility while enabling XML processing functionality.
Solution Approach 2:
The solution segments the XML processing functionality into separate, modular components that can be independently managed. By dividing the complex XML parsing and transformation tasks into discrete segments, the system maintains COBOL's core functionality while adding XML capabilities through separable interface layers.
2Adaptability or versatility
If complex modifications and additional layers are added to COBOL to support XML processing, then XML processing capability is improved, but system complexity and development costs increase
Solution Approach 1:
The patent creates a universal interface layer that handles multiple XML processing functions through a single standardized mechanism. This multi-functional approach allows the same intermediary component to handle various XML document types and processing requirements without requiring separate complex modifications for each scenario.
Solution Approach 2:
The solution uses template-based copying where standardized COBOL data structure templates are created that can be replicated and adapted for different XML processing scenarios. Instead of creating custom complex structures for each XML type, the system copies and modifies standardized templates, reducing overall system complexity.
3Adaptability or versatility
If manual transformation logic is implemented on middleware layer, then XML to COBOL transformation capability is achieved, but development cost and maintenance effort increase
Solution Approach 1:
The patent implements self-service automation where the system automatically generates COBOL code and transformation logic based on XML document schemas and templates. Instead of requiring manual programming of transformation rules, the system serves itself by auto-generating the necessary code, significantly reducing development and maintenance costs while maintaining transformation capability.
Solution Approach 2:
The solution performs preliminary actions by pre-defining COBOL data structure templates and transformation rules before actual XML processing occurs. These pre-configured templates and rules are prepared in advance, allowing the system to automatically handle transformations without requiring manual intervention during runtime or subsequent maintenance.
Data Source
AI summary
A method for facilitating the processing of markup language documents, e.g., XML documents, uses a code generator that creates programs configured to read dynamic XML documents at run time, avoiding many of the complexities arising from the use of conventional “XML Parse” statements. In one embodiment, this process involves (1) creating a template document using the markup language, wherein the template document includes a set of tags associated with the markup language documents; (2) parsing the template document to determine a data structure corresponding to the tags in the template document; and (3) generating an application program in the programming language (e.g., COBOL), wherein the application program includes a definition of the data structure, and is configured to read, during run-time, the markup language document and generate a corresponding set of data elements corresponding to the data structure.