Data processing: database and file management or data structures – Database design – Data structure types
Reexamination Certificate
1999-04-27
2003-02-11
Jung, David (Department: 2175)
Data processing: database and file management or data structures
Database design
Data structure types
C709S241000, C709S241000
Reexamination Certificate
active
06519605
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates to a computer system, and deals more particularly with a method, system, and computer-readable code for run-time translation of legacy Emulator High Level Language Application Programming Interface (EHLLAPI) calls into object-based calls. Using the present invention, there is no need to rewrite or restructure existing application code which invokes procedurally-oriented EHLLAPI calls to access a host presentation space. Instead, the calls are translated automatically into calls that use an object-oriented host access interface.
2. Description of the Related Art
One of the challenges facing information services (“IS”) professionals today is the difficulty of bridging legacy mainframe host data to modern user interfaces. Most legacy host applications present their data in text-based user interfaces designed for use on specific, obsolete character-based terminals. The legacy applications were written with this character-based terminal presentation space as the only interface format in which the host data output is created, and in which host data input is expected. “Presentation space” is a term used abstractly to refer to the collection of information that together comprises the information to be displayed on a screen, as well as the control data that conveys how and where that information is to represented. This collection of information is stored in an area of computer storage and/or memory.
A typical character-based terminal is the IBM Model 3270. (IBM is a registered trademark of the International Business Machines Corporation.) This terminal model was designed to display information in a matrix of characters, where the matrix consisted of 24 rows each having 80 columns. When programs were written expecting this display format, programmers would specify placement of information on the screen using specific row and column locations. Information formatted for this display is sent as a “data stream” to the mechanism in the display hardware that is responsible for actually displaying the screen contents. The phrase “data stream” refers to the fact that the data is sent as a linear string, or stream, of characters. This stream of characters contains both the actual textual information to be displayed on the screen, as well as information specifying where and how the text is to be displayed. “Where” consists of the row and column where the text is to begin, and “how” consists of a limited number of presentation attributes such as what color (typically either green or white) to use when displaying that text. While the Model 3270 is a specific type of IBM display hardware, data formatted for any display having similar characteristics became a de facto standard format referred to as a “3270 data stream”. Similarly, the IBM Model 5250 is another type of character-based terminal. This terminal displays data in a slightly different manner from the IBM 3270, and consequently uses a different data stream format. The “5250 data stream” also became a de facto standard format for displays having similar characteristics. A third type of data stream format commonly used by legacy host applications is referred to simply as an “ASCII data stream”. While an ASCII data stream is not formatted for a specific model of display screen, a data stream in this format has certain predefined characteristics (for example, the manner in which a control character indicates the line spacing to be used).
The displays used with modern computer workstations (including personal computers, network computers, etc.) support graphics and video, in addition to text characters. These displays do not use a character-based row and column matrix approach to screen layout. Instead, the programmer has access to thousands of tiny display elements, allowing the various types of information to be placed virtually anywhere on the display screen.
When the modem computer workstation is used to access a legacy host application running on a mainframe, the output data created by that host application is often still formatted as one of the character-based data streams. The workstation (whether it is a personal computer, network computer, or other type of computer) has access to the host application and the presentation space it uses through mainframe emulator software. An example of mainframe emulator software is the Personal Communications product from IBM. Emulator software runs on the workstation. This software provides facilities to establish a telecommunications connection between the workstation and the host computer, to invoke execution of a software application stored on that host, and to transfer information between the host application and the workstation as the application runs. When a legacy application is accessed using an emulator, it appears to the legacy application as if it was interacting with a so-called “dumb terminal”, instead of an intelligent workstation. The emulator takes care of reformatting the character-based data sent by the legacy application (i.e. using the presentation space to transfer screen data), for display on a modern display screen.
Currently, there is movement in the computer information industry away from using mainframe emulators as the primary user interface to the host applications. Therein lies the problem. When an emulator is no longer used, the emulator's complicated interface logic for translating between the character-based data stream and the modem workstation display screen layout must be performed by some other service.
One solution to this problem is to rewrite the host applications, so that they create their output in a format recognized by modern displays. For most companies, this rewrite of host applications represents a monumental task. Not only are there literally millions of lines of code to rewrite, the skills that are required to program host applications (ability to use the COBOL programming language, for example) are in short supply.
There is an alternative solution to rewriting the host applications, which many IS professionals have chosen. The user interface facilities of many modern application programs accept the existing host presentation space format when retrieving data from the host application, but do not show the data to the user in this format. The new user interface facilities perform a “screen scraping” process, where data is extracted from the host presentation space, and present this scraped data to the user in a form that is appropriate for the modern display screen device. By convention, this form tends to be a graphical user interface where information is presented in a window-based layout. The user interacts with the application using this graphical user interface. When data needs to be returned to the application, for example in response to the user's input, the user interface facility converts this information automatically into a format that is recognized by the host application.
IBM's Emulator High Level Language Application Programming Interface, or “EHLLAPI”, was one of the first screen scraping application programming interfaces. EHLLAPI provides an application program with an interface to the presentation space with which legacy applications expect to exchange screen data. This interface has been implemented in a variety of software products, and by many different software vendors. One example of a product using this EHLLAPI interface is IBM's Personal Communications emulator product. EHLLAPI has been available for use for a number of years, and has become a de facto standard for screen scraping. Consequently, there is a great deal of application code in use today which uses EHLLAPI.
EHLLAPI is a procedural interface, and is well-suited for procedural programming languages such as the C programming language. Recently, however, developers have been presented with new object-oriented APIs that better model interaction with a legacy host screen. These new APIs are better suited for use with object-oriented programming languages than is EHLLAPI. On
Gilgen David Blair
Knowles Gregory Thomas
Quint Scott Matthew
Webb Brian Thomas
Doubet Marcia L.
International Business Machines - Corporation
Jung David
Ray-Yarletts Jeanine S.
LandOfFree
Run-time translation of legacy emulator high level language... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Run-time translation of legacy emulator high level language..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Run-time translation of legacy emulator high level language... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3133010