AU760867B2

AU760867B2 - Method of translating COBOL programming language variables to visual basic programming language variables

Info

Publication number: AU760867B2
Application number: AU60645/99A
Authority: AU
Inventors: Armen Grigorian
Original assignee: Individual
Current assignee: Individual
Priority date: 1998-11-26
Filing date: 1999-11-26
Publication date: 2003-05-22
Anticipated expiration: 2019-11-26
Also published as: AU6064599A

Description

AUSTRALIA

Patents Act 1990 COMPLETE SPECIFICATION STANDARD PATENT Applicant(s): ARMEN GRIGORIAN Invention

S

Title: METHOD OF TRANSLATING COBOL PROGRAMMING LANGUAGE VARIABLES TO VISUAL BASIC PROGRAMMING LANGUAGE

VARIABLES

The following statement is a full description of this invention, including the best method of performing it known to me/us: 2 METHOD OF TRANSLATING COBOL PROGRAMMING LANGUAGE VARIABLES TO VISUAL BASIC PROGRAMMING LANGUAGE VARIABLES FIELD OF THE INVENTION The present invention relates to a method and apparatus for translating computer code between programming languages, of particular but by no means exclusive application in translating COBOL into Visual Basic.

For many years the computer industry has been predicting the demise of COBOL, owing to the proliferation of personal computers and the continuous improvement in computer hardware and software. This has led to the development of a variety of new software application development environments that are more cost effective and affordable compared with traditional COBOL software development environments.

One of the major factors of change has been the ,sel: 20 overwhelming acceptance of the Windows environment. Users have become accustomed to such technology and have grown to expect graphical user interface.

However, even as many companies running such COBOL based systems embrace new and enhanced technologies with current tools to improve performance, reliability and provision of the most cost effective methods of maintenance for the future life of their systems, there remains a very large quantity of production code written in COBOL that remains 30 in demand and of value owing to its effectiveness and the familiarity of users with its operation, and to the fact that re-writing this existing COBOL software in new development languages would require a similar effort to that required in its original development.

The translation of code between languages, and in particular from COBOL to Visual Basic, is often inefficient H:\A.M\Keep\seC',ific.itionS\6645.9.dc 9/05/00 3 owing to the different data storage structure employed by different languages. Typically this problem is addressed in existing translation programs by defining large numbers of variables simply to ensure that all variables of the original program (even variables that are in fact merely components of other variables) are preserved in the translation. This can lead, however, to the duplication of variables and the need for subroutines or additional program steps to ensure that duplicated variables or variable components retain the same values when one of a duplicated pair is modified. Alternatively, it is not possible, in some languages, to access a portion of the memory location allocated to a variable (so that that portion may itself be treated as a variable), so again a separate duplicated variable corresponding to that portion is required.

It is an object of the present invention, therefore, to provide a method for translating between computer languages 20 that can overcome some or all of these limitations of existing systems.

o hSUMMARY OF THE INVENTION Accordingly, the present invention provides a method for translating a computer program in a first computer programming language into a second computer programming language, said first language permitting a first variable with a first memory location and a second variable with a second memory location to be defined wherein said second 30 variable corresponds to a portion of said first variable oo and said first and second memory locations overlap, said method involving: defining a get routine in said second language for getting the value of a variable stored in a specific memory location; defining a let routine in said second language for setting the value of a variable stored in a specific H:\AJ\Keep\,,ecifictions\6645.99.doc 9/05/00 4 memory location; replacing references to said second variable in said first language where the value of said second variable is retrieved with said get routine; replacing references to said second variable in said first language where the value of said second variable is set with said let routine; and outputting or storing a translated program being a translation of said computer program in said second computer programming language.

Preferably said first language is COBOL and said second language is basic. More preferably the second language is visual basic. Where this is the case, preferably said get procedure comprises a property having a get procedure, and said let procedure comprises a property having a let procedure.

Thus, while the method of the invention may be of value for translating between a range of programming languages, it will clearly be of greatest value for translating to programming languages that do not allow several variables to reference the same memory location.

Preferably said get routine and said let routine can accept arguments specifying the identity of said variable.

Thus, in some embodiments separate get and let routines will be defined for each variable, but it is preferred that 30 general get and let routines be defined that can accept as an argument the identity (generally simply the name) of the variable.

The present invention also provides an apparatus for translating a computer program in a first computer programming language into a second computer programming .RizN language, said first language permitting a first variable H:\AJM\Keep\sp~eci ficitons\60645.99.doc 9/05/00 5 with a first memory location and a second variable with a second memory location to be defined wherein said second variable corresponds to a portion of said first variable and said first and second memory locations overlap, said apparatus including: memory storage means for storing said program; computer program portions comprising or for generating a get routine in said second language for getting the value of a variable stored in a specific memory location; computer program portions comprising or for generating a let routine in said second language for setting the value of a variable stored in a specific memory location; and processing means operable to receive said program and to replace references to said second variable in said first language where the value of said second variable is retrieved with said get routine and to replace references to said second variable in said first language where the 20 value of said second variable is set with said let routine.

o Preferably said first language is COBOL and said second language is basic. More preferably the second language is visual basic.

The present invention also provides computer program *a 0.

30 portions for execution by a computer to perform the method oo described above.

The present invention still further provides a computer readable medium having computer program portions for execution by a computer to perform the method described above.

H:\A.JM\Keep\secificition\6Ob45A9.doc 9/05/00 -6 The present invention also provides a computer program product directly loadable into the internal memory of a computer, having software code portions for performing the steps of the method described above.

The present invention still further provides a computer program product stored on a computer readable medium, for causing a computer to perform the steps of the method described above.

The present invention still further provides a computer readable medium, having a program recorded thereon, where the program is to make a computer execute the method described above.

BRIEF DESCRIPTION OF THE DRAWINGS In order that the present invention may be more clearly ascertained, a preferred embodiment will now be described, by way of example, with reference to the accompanying 20 drawings, in which: Figure 1 is a schematic illustration of a typical .example of a COBOL base variable A; Figure 2 is a schematic illustration of an example of a number of Cobol variables stored in a single memory location; .ap Figure 3 is a schematic illustration of a further example of a number of Cobol variables stored in a single .memory location; and Figure 4 is a schematic illustration of a still 30 further example of a number of Cobol variables stored in a single memory location.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT A computer program consists of a working storage area and executable code. The way the executable code references the working storage is through the use of variables. In the programming language COBOL (and some other similar H: \MM\Keej\specification,,\6645.99.doc 9/05/00 7 languages) each variable must be defined by its length and type. In addition, variables in COBOL can be defined to represent various parts of other variables and they utilize the same memory location of those variables.

The Visual Basic programming language does not allow several variables to reference the same memory location, which makes the translation process from COBOL to Visual Basic difficult and the translated code essentially unmaintainable.

A translation method for translating COBOL code to Visual Basic code according to a preferred embodiment of the present invention identifies the Base Variable in COBOL and declares it as a normal variable in Visual Basic occupying the same amount storage in main memory as in COBOL.

All the sub-sequent variables in COBOL that reference different parts of the base variable are then declared as properties in Visual Basic.

In Visual Basic the properties can have 'Let' and 'Get' o procedures. The 'Get' procedure of a property accesses the property value and the 'Let' procedure sets the property value.

Figure 1 illustrates a typical example of a COBOL base variable A. In this example, variable A is a COBOL base variable which is a string of 100 characters length, 30 variable B occupies the first 10 characters of base variable A, and variable C occupies the next 10 characters starting from the llth position of base variable A.

According to the method of the present invention, to translate a COBOL instruction where variable C takes the value of variable B (C the following steps are used: ITPA. a) Define a Get Procedure for B which returns the H\AJM\Kep\ pecFjications\6b45.699.dc 9,05/00 8 first 10 value to from the value to characters of base variable A b) Define a Let Procedure for B which sets a the first 10 characters of the base variable A.

c) Define a Get Procedure for C which returns llth to 20th characters of the base variable A.

d) Define a Let Procedure for C which sets a the llth to 20th characters of the base variable Consequently, the statement C B (Let C Get B) performs the exact function as it would in Cobol.

Variables can have different types (numeric and strings) which means the 'Let' and 'Get' procedures can be defined to convert the incoming and outgoing variables to the corresponding types as defined in COBOL: the required data conversion code can be imbedded in the Get and Let procedures of any property.

20 This method, in more detail, is as follows.

The Cobol variables considered here have the following formats:

S

S.

S

5.55 25 Format-1 level number data-name-1

FILLER

REDEFINES

PICTURE

OCCURS

VALUE IS Format-2 88 condition-name VALUE IS data-name-2

COMP

COMP-3 integer-2 TIMES literal-1 literal-2 THRU literal-3

ARE

Translation Technique for Format-1: Using Format-i in the Cobol Language data-name-1 can be H:P1\Keep\specifications\60645.99.doc 9/05/00 9 defined as an Elementary Item or as a Group Level Item. To translate Cobol variables defined using Format-i the following technique is used.

GENERAL CASE: Insert_ is a function written in Visual Basic that inserts the contents of string_l into string_2 from a given starting position in string_2.

Example String_l String_2 String_l string_l

"ABCDEFGHIJKLMN"

"1234567" Insert_(String_1,4,String_2) [the contents of becomes "ABC1234567KLMN"] Cobol Variables: 0 *0 *00* 0**0 01 Group-Level-Item-Al.

03 Elementary-Item-Al 03 Elementary-Item-A2 03 Group-Level-Item-A2.

05 Elementary-Item-A3 PIC PIC PIC In this example, as shown in figure 2, the same memory location 10 (Group-Level-Item-Al) is referenced by different variable names: Elementary-Item-Al 12, Elementary-Item-A2 14, Group-Level-Item-A2 16, and Elementary-Item-A3 18, and when the contents of any variable is changed all the affected variable values get changed accordingly.

The following Visual Basic Code provides the same variable declarations to replicate the above Cobol Variable declarations. In the Get Property Procedure un-packed or packed numeric variables are converted to Visual Basic H:\AJ\Keep\secitfictions\60645.

9 q9.doc 9/05/00 10 string variables. In the Let Property Procedure string variables are converted to un-packed or packed numeric variables.

Visual Basic Variables: Dim group_level_item_al As String Private Property Get elementary_item_al() Const iLen Dim elementary_item_al_ As String iLen Const iStart 1 elementary_item al_ Mid(group_level_item_al, iStart, iLen) [any string to numeric data conversion can be inserted here] elementary_itemal elementary_itemal End Property Private Property Let elementary_item_al(vNewValue) Const iLen 25 Dim elementary_item_al_ As String iLen Const iStart 1 elementary_item al_ vNewValue [any string to numeric data conversion can be inserted 30 here] group_level_item_al Insert_(group_level_item_al, iStart, elementary_itemal_) o End Property Private Property Get elementary_item_a2() Const iLen Dim elementary_itema2_ As String iLen Const iStart 11 elementary_itema2 mid(group_level_itemal, iStart, iLen) [any string to numeric data conversion can be inserted here] elementary_item_a2 elementary_itema2 H:\AM\Keep\specificaitions\b03045.99.c 9/05/00 11 End Property Private Property Let elementary_item_a2(vNewValue) Const iLen Dim elementary_itema2_ As String iLen Const iStart 11 elementary_itema2_ vNewValue [any string to numeric data conversion can be inserted here] group_level_item_al Insert_(group_level_itemal, iStart, elementary_itema2_) End Property The above Get and Let Property declarations should be repeated for all elementary items defined under for Group_Level_Item_Al.

In situations where the subsequent level item is a Grouplevel-Item and has further group level items or elementary items then the process is repeated for all the subsequent levels until all elementary levels have been reached. This 25 is shown in the following code segment.

"oo Private Property Get group_level_itema2() Const iLen 30 Dim group level_item_a2_ As String iLen Const iStart 31 0 group_level_item_a2 mid(group_level_item_al, iStart, iLen) group_level_item_a2 group_level_itema2 End Property Private Property Let group_level_item_a2(vNewValue) Const iLen Dim group_level_itema2_ As String iLen H:\.JM\Keep\speciicditionS\60645A9.Oc 9/05/00 12 Const iStart 31 grouplevel_item_a2_ vNewValue group_level_item_al Insert_(group_level_item_al, iStart, group_level_item_a2_) End Property Private Property Get elementary_item_a3() Const iLen Dim elementary itema3_ As String iLen Const iStart 1 elementary_itema3_ group_level_item_a2 elementary_item_a3 elementaryitem_a3 End Property Private Property Let elementary_itema3(vNewValue) Const iLen Dim elementary_itema3_ As String iLen Const iStart 1 elementary_itema3_ vNewValue group_level_item_a2 elementary_itema3 30 End Property REDEFINES CLAUSE Redefines clause is translated similar to the general case described above except the group level variable or the parent variable it belongs to is defined by the REDEFINES

CLAUSE:

H:\AJM\Keep\specifictions\60645A 9 oc 9/05/00 13 Cobol Variables: 01 Group-Level-Item-Cl.

03 Elementary-Item-Cl 03 Elementary-Item-C2 Elementary-Item-C3 Elementary-Item-C4 PIC REDEFINES Elementary-Item-Cl.

PIC PIC *see 0 6 *too .40.

6

S

*000 a

SS**

00000 60 *0 0 0 g o *400

S

0 *005 a a 0 S. 0 0

S

00 .5 In this example, as shown in figure 3, the three top variables Group-Level-Item-Cl 20, Elementary-Item-Cl 22, and Group-Level-Item-C2 24 share exactly the same memory location, while the last two variables Elementary-Item-C3 26 and Elementary-Item-C4 28 refer to parts of the memory location referenced by the above three variables 20, 22 and 24.

Visual Basic Variables: 15 Dim group_level_item_cl As String Private Property Get elementary_item_cl() Const iLen 20 Dim elementary_itemcl_ As String iLen Const iStart 1 elementary_item cl group_level_item_cl elementary_item_cl elementary_item cl End Property Private Property Let elementary_item_cl(vNewValue) Const iLen Dim elementary_item_cl_ As String iLen Const iStart 1 H:\A\Keep\secificAtions\60645.99.oc 9/05/00 14 elementary item-cli vNewValue group levelitemci elementary itemci End Property Private Property Get elementary_itemc2() Const iLen Dim elementaryitemc2_ As String iLen Const iStart 1 elementary itemc2_ elementary itemci elementary itemc2 elementary itemc2_ End Property Private Property Let elementary_itemc2(vNewValue) Const iLen Dim elementary itemc2_ As String iLen Const iStart 1 elementary item c2 vNewValue elementary itemci elementary itemc2_ End Property Private Property Get elementary_itemc3() Const iLen Dim elementary itemc3_ As String iLen Const iStart 1 elementary item c3_= Mid(elementary item c2, iStart, iLen) elementary item c3 elementary_itemc3_ H:\AM\Keep\specifictions\fO645.'.rdoc 9/05/00 End Property Private Property Let elementary_item-c3(vNewValue) Const iLen Dim elementary item-c3_ As String iLen Const iStart 1 elementary item-c3_ vNewValue elementary item c2= Insert_ (elementary item c2, iStart, elementaryjitemc3_) End Property Private Property Get elementary_item-c4() Const iLen Dim elementary item-c4_ As String iLen Const iStart 6 elementary item c4_ mid(elementary item c2, iStart, iLen) elementary item c4 =elementary_item-c4- End Property Private Property Let elementary_item-c4(vNewValue) Const iLen Dim elementary item-c4_ As String iLen 30 Const iStart 6 elementary item-c4_ vNewValue elementary item c2 Insert_ (elementary item c2, iStart, elementary item-c4.) End Property X:\A.JM\Keer,\zp'ecificaitions\60645.9 9 ).cIoc 9/05/00 16 OCCURS CLAUSE: The Cobol OCCURS statement is translated, according to the present invention, as follows. The Group Level Item of the array is described as a string in Visual Basic with the exact length of the corresponding COBOL array. Each element of the array is declared with Get and Let Properties in visual basic as in the general case with the subscript or subscripts being passed as parameters. The subscripts are used to locate the correct position of the array element within its Group Level Variable.

The elements of the array are declared as let and get properties having the same name as the corresponding Cobol array element variable name.

Cobol Variables: 01 Group-Level-Item-Dl.

03 Group-Level-Item-D2 OCCURS 2 TIMES.

05 Elementary-Item-Dl OCCURS 3 TIMES PIC In this example, as shown in figure 4, there is only one 25 top variable Group-Level-Item-D1 30, while variables Group- Level-Item-D2(1) 32 and Group-Level-Item-D2(2) 34 refer to parts of the memory location referenced by variable Variables Elem-D2(1,1) 36, Elem-D2(1,2) 38 and Elem-D2(1,3) refer to parts of the memory location referenced by variable S 30 Group-Level-Item-D2(1) 32, while variables Elem-D2(2,1) 42, Elem-D2(2,2) 44 and Elem-D2(2,3) 46 refer to parts of the memory location referenced by variable Group-Level-Item- D2(2) 34.

Visual Basic Variables: Dim group_level_itemdl As String H:AJ\Keep\srecifica ions\60645.99 .doc 9/05/00 17 Private Property Get group level_item d2(iVarArrayPtrl) Const iLen Dim group level_itemd2_ As String iLen Const iElemStart =1 Dim iStart As Integer iStart iElemStart (iVarArrayPtrl 1) iLen group-levelitemd2_ mid(group levelitemdl, iStart, iLen) group-levelitemd2 group level_itemRd2_ End Property Private Property Let group levelitemd2(iVarArrayPtrl,vNewValue) Const iLen'= Dim group level_itemd2_ As String iLen Const iElemStart =1 Dim iStart As Integer iStart iElemStart (iVarArrayPtrl 1) iLen :o group levelitemd2 vNewValue group levelitem dl Insert_ (group levelitem dl, iStart, group levelitem d2) End Property Private Property Get elementary itemdl(iVarArrayPtrl,iVarArrayPtr2) Const iLen 35 Dim elementary item dl As String iLen Const iElemStart =1 Dim iStart As Integer H:\AM\Keep\specificcitions\6Ob45.99..doc9/05/00 18 iStart iElemStart (iVarArrayPtr2 1) iLen elementary_itemdl Mid(group_level_item_d2(iVarArrayPtrl), iStart, iLen) elementary_item_dl elementary_item dl End Property Private Property Let elementary_item_dl(iVarArrayPtrl,iVarArrayPtr2,vNewValue) Const iLen Dim elementary_item dl As String iLen Const iElemStart =1 Dim iStart As Integer iStart iElemStart (iVarArrayPtr2 1) iLen elementary_itemdl vNewValue group_level_itemd2(iVarArrayPtrl) Insert_(group_level_item_d2(iVarArrayPtrl), iStart, elementary_item_dl_) End Property Translation Technique for Format-2 CONDITION NAMES 88 LEVELS For each COBOL 88 level variable define a function in Visual Basic with no parameters that returns true if the becomes a function which gets evaluated just like it would in Cobol.

SconditCobol Variables: S CONDITIONCobol Variables: H:\pJM\Keep\recificitions\60645.

9 9.doc 9/05/00 19 01 Elementary-Item-El PIC X.

88 CONDITION-NAME-E1 VALUE 88 CONDITION-NAME-E2 VALUE THRU Visual Basic Variables: Dim elementary_item_el As String 1 Private Function condition_name_el() as Boolean condition_nameel False If elementary_item_el Then condition_name_el True End If If elementary_item_el Then conditionname_el True End If End Function Private Function condition_name_e2() as Boolean condition_namee2 False 25 If elementary_item_el And elementary_item_el Then conditionname_e2 True End If 30 End Function *e *9 Thus, a line by line translation of the original COBOL actual code from COBOL to Visual Basic can be effected.

The method thereby allows the conversion of COBOL variables into their corresponding Visual Basic variables, using the Property Get Statement, which gets the value of a variable H:\A4J\Kep\specificjtion\bO645.c .oc 9/05/00 20 and the Let Property statement, which assigns a value to a variable. This allows for exact conversion of Cobol Variables to Visual Basic and mimics the exact behaviour of Cobol Variables within the Visual Basic Language.

The translated variable names become procedures with Get and Let Properties and thereby provide complete compatibility with the COBOL variables.

Modifications within the spirit and scope of the invention may readily be effected by persons skilled in the art, so it is to be understood that this invention is not limited to the particular embodiments described by way of example hereinabove.

ea..

e *r H:\AJl\Kep\specificrtion\60645.99.ioc 9/05/00

Claims

1. A method for translating a computer program in a first computer programming language into a second computer programming language, said first language permitting a first variable with a first memory location and a second variable with a second memory location to be defined wherein said second variable corresponds to a portion of said first variable and said first and second memory locations overlap, baid method involving: defining a get routine in said second language for getting the value of a variable stored in a specific memory location; defining a let routine in said second language for setting the value of a variable stored in a specific memory location; replacing references to said second variable in said first language where the value of said second variable is retrieved with said get routine; replacing references to said second variable in said first language where the value of said second variable is set with said let routine; and outputting or storing a translated program being a translation of said computer program in said second computer programming language.

2. A method as claimed in claim 1, wherein said first language is COBOL and said second language is basic.

3. A method as claimed in claim 2, wherein said second language is visual basic.

4. A method as claimed in claim 3, wherein said get procedure comprises a property having a get procedure, and said let procedure comprises a property having a let procedure. w 22 A method as claimed in any one of the preceding claims, wherein said get routine and said let routine can accept arguments specifying the identity of said variable. An apparatus for translating a computer program in a first computer programming language into a second computer programming language, said first language permitting a first variable with a first memory location and a second variable with a second memory location to be defined wherein said ecdnd variable corresponds to a portion of said first variable and said first and second memory locations overlap, said apparatus including: memory storage means for storing said program; computer program portions comprising or for generating a get routine in said second language for getting the value of a variable stored in a specific memory location; computer program portions comprising or for generating a let routine in said second language for setting the value of a variable stored in a specific memory location; and processing means operable to receive said program and to replace references to said second variable in said first language where the value of-said second variable is retrieved with said get routine and to replace references to said second variable in said first language where the value of said second variable is set with said let routine.

7. An apparatus as claimed in claim 6, wherein said first language is COBOL and said second language is basic.

8. An apparatus as claimed in claim 7, wherein the second language is visual basic.

9. An apparatus as claimed in claim 8, wherein said get procedure comprises a property having a get procedure, and said let procedure comprises a property having a let 23 procedure. An apparatus as claimed in any one of claims 6 to 9, wherein said get routine and said let routine can accept arguments specifying the identity of said variable.

11. Computer program portions for execution by a computer to perform the method defined in any one of claims 1 to

12. A computer readable medium having computer program portions for execution by a computer to perform the method defined in any one of claims 1 to

13. A computer program product directly loadable into the internal memory of a computer, having software code portions for performing the steps of the method defined in any one of claims 1 to

14. A computer program product stored on a computer readable medium, for causing a computer to perform the steps of the method defined in any one of claims 1 to A computer readable medium, having a program recorded thereon, where the program is to make a computer execute the method defined in any one of claims 1 to

16. A method for translating a computer program in a first computer programming language into a second computer programming language substantially as herein described with reference to the accompanying drawings. 24

17. An apparatus for translating a computer program in a first computer programming language into a second computer programming language substantially as herein described with reference to the accompanying drawings. Dated this 9th day of May 2000 ARMEN GRIGORIAN By his Patent Attorneys GRIFFITH HACK Fellows Institte df Patent and Trade Mark Attorneys of Australia