# US 2001/0044811 A1 · Method and system for reporting XML data based on precomputed context and a document object model

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2001/0044811 A1
- Document ID: US20010044811A1
- Status: Published application
- Kind: A1
- Application number: 09/840,727
- Filed: 2001-04-23
- Published: 2001-11-22
- Earliest claimed: 2000-03-09
- Assignees: Electronic Data Systems Corporation
- Inventors: Alando M. Ballantyne; Michael K. Smith; Larry M. Hines
- Web page: https://patentgrep.com/patent/US20010044811A1

## CPC

- G06F 8/76: Adapting program code to run in a different environment; Porting
- G06F 16/84: Mapping; Conversion
- G06F 16/972: {Access to data in other repository systems, e.g. legacy data or dynamic Web page generation}
- G06F 40/143: Markup, e.g. Standard Generalized Markup Language [SGML] or Document Type Definition [DTD]
- G06F 40/154: Tree transformation for tree-structured or markup documents, e.g. XSLT, XSL-FO or stylesheets
- G06F 8/30: Creation or generation of source code
- G06F 40/221: Parsing markup language streams (streaming G06F40/149)
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

A method and system for modifying program applications of a legacy computer system to directly output data as XML using a DOM instance, models the legacy computer system, maps the model to an XML schema and automatically modifies one or more applications to directly output XML formatted data from an internally constructed DOM instance in cooperation with a writer engine. The writer engine allows for an arbitrary number of contexts to be simultaneously active and builds a complete DOM instance by using the multiple contexts to buffer output data. The writer engine directly loads XML schema information to construct and output DOM instances in accordance with the schema and subject to further transformation by XSLT stylesheets.

## Claims

### Claim 1

A method for reporting data from a legacy computer system using Extensible Markup Language, the method comprising:
generating a model of the legacy computer system;
mapping the model of the legacy computer system to an Extensible Markup Language schema; and
automatically modifying one or more applications of the legacy computer system, the modified application operable to output data written using a Document Object Model from the legacy computer system in Extensible Markup Language.

### Claim 2 (depends on 1)

The method of claim 1 wherein automatically modifying one or more applications further comprises:
providing the legacy computer system with a writer engine, the writer engine having the Extensible Markup Language Schema loaded as a data file; and
calling the writer engine with the modified applications, the writer engine populating the Document Object Model according to the Extensible Markup Language schema by building a Document Object Model instance with one or more contexts.

### Claim 3 (depends on 3)

The method of claim 3 further comprising:
applying one or more XSLT stylesheets to restructure the Document Object Model instance for outputting data in a predetermined format.

### Claim 4

A system for reporting data from a legacy computer system in an Extensible Markup Language format, the system comprising:
a modeling engine in communication with the legacy computer system, the modeling engine operable to generate a model of reported data written by an application residing on the legacy computer system;
a mapping engine in communication with the modeling engine, the mapping engine operable to generate a modification specification by mapping the model to an Extensible Markup Language schema; and
a code generation engine in communication with the mapping engine and the legacy computer system, the code generation engine operable to modify legacy computer system application code to directly output data from a Document Object Model as Extensible Markup Language.

### Claim 5 (depends on 4)

The system of claim 4 further comprising:
a context table associated with the legacy computer system, the context table providing the Extensible Markup Language schema to the legacy computer system; and
a writer engine loaded on the legacy computer system and having the Extensible Markup Language schema stored as a data file, the writer engine communicating with the modified legacy computer system applications to buffer data in plural contexts within a Document Object Model for output as Extensible Markup Language.

### Claim 6 (depends on 5)

The system of claim 5 wherein the writer engine is coded in the computer language of the legacy computer system.

### Claim 7

A method for outputting data from an application running on a computer system, the data output as Extensible Markup Language, the method comprising:
establishing a relationship of the output data and one or more Extensible Markup Language Document Object Model contexts;
building a Document Object Model instance with the one or more contexts; and
outputting the data from the Document Object Model instance as Extensible Markup Language.

### Claim 8 (depends on 7)

The method of claim 7 wherein establishing a relationship further comprises:
activating plural contexts simultaneously to buffer data for output as a complete Document Object Model instance.

### Claim 9 (depends on 8)

The method of claim 8 wherein establishing a relationship further comprises:
creating a node for an output data; and
ensuring the correct cardinality of the created node.

### Claim 10 (depends on 7)

The method of claim 7 further comprising:
generating output data with an application;
calling a writer engine with the application;
providing the generated output data to the writer engine;
outputting data from a Document Object Model instance from the writer engine according to the Extensible Markup Language schema.

### Claim 11 (depends on 10)

The method of claim 10 wherein the application comprises a legacy computer system application.

### Claim 12 (depends on 11)

The method of claim 11 wherein the writer engine comprises an application run in the computer language of the legacy computer system application.

### Claim 13

A system for outputting data from a Document Object Model as Extensible Markup Language, the system comprising:
a computer system having an application that outputs data; and
a writer engine loaded on the computer system and interfaced with the application, the writer engine having an Extensible Markup Language schema as a data file and the writer engine operable to write the output data in plural active contexts;
wherein the application calls the writer engine when the application outputs data, the writer engine operable to build a Document Object Model instance for output of the data in accordance with the Extensible Markup Language schema.

### Claim 14 (depends on 13)

The system of claim 13 wherein the writer engine populates a Document Object Model as a schema element aligned with the current one of the contexts by creating Extensible Markup Language tagged nodes down through the schema element of the output data if the schema element of the output data is a descendant of the current context.

### Claim 15 (depends on 14)

The system of claim 14 wherein the writer engine is further operable to determine a minimal mutual ancestor of the schema element and the current context and to traverse the Extensible Markup Language tagged nodes for the current context up to the minimal mutual ancestor and to create Extensible Markup Language tags for the schema element down from the mutual ancestor.

### Claim 16 (depends on 12)

The system of claim 12 wherein the computer system comprises a legacy computer system.

### Claim 17 (depends on 16)

The system of claim 16 wherein the application comprises a legacy computer system application modified to output an Extensible Markup Language schema element with output data.

### Claim 18 (depends on 17)

The system of claim 17 wherein the writer engine is written in the code of the legacy computer system.

### Claim 19 (depends on 18)

The system of claim 18 wherein the code comprises COBOL.

### Claim 20

A method for outputting data from a legacy computer system from a DOM instance as Extensible Markup Language, the method comprising:
modifying an application of the legacy computer system to output data having a schema element;
generating data from the modified application;
aligning the schema element and the current context;
writing the output data schema element to a current one of plural contexts of an Extensible Markup Language schema; and
populating a Document Object Model with the data to output an Extensible Markup Language instance.

### Claim 21 (depends on 20)

The method of claim 20 wherein aligning the schema element further comprises:
determining that the schema element is a descendant of the current context; and
creating the Extensible Markup Language tags down through the schema element.

### Claim 22 (depends on 21)

The method of claim 21 wherein aligning the schema element further comprises:
determining a minimal mutual ancestor of the schema element and the current context;
traversing the Extensible Markup Language tags for the current context up to the mutual ancestor; and
creating the Extensible Markup Language tags for the schema element down from the mutual ancestor.

### Claim 23

A method for modeling a legacy computer system comprising:
identifying incidents of applications of the legacy computer system that output data;
associating the incidents with an Extensible Markup Language schema; and
defining a control flow graph of the output incidents; and
creating a specification to modify the legacy computer system applications to provide output from a Document Object Model instance as Extensible Markup Language.

### Claim 24 (depends on 23)

The method of claim 23 further comprising:
automatically modifying the legacy computer system applications in accordance with the specification.

### Claim 25

A system for modeling an output application of a legacy computer system comprising:
a modeling engine interfaced with the legacy computer system, the modeling engine operable to analyze an application loaded on the legacy computer system to identify incidents within the application that output data from the legacy computer system;
a control flow graph of the output operations within the applications, the control flow graph having plural nodes, each node associated with an output incident; and
a graphical user interface in communication with the modeling engine, the graphical user interface operable to display the control flow graph and the incidents;
wherein the graphical user interface maps the incidents of the applications with the control flow graph and an Extensible Markup Language schema.
