# Patent

## Title
System for translating programming languages

## Abstract

A computer language translator that translates all or any portion thereof of source code in an original computer language to source code in a target computer language, which may then be translated back to the original language while still maintaining concept, syntax, form of expression, and formatting of the original source code.

## Background
CROSS-REFERENCE
This application claims the benefit of, under Title 35, United States Code, Section 119(e) U.S. Provisional Patent Application Ser. No. 60/427,733 filed Nov. 20, 2002.


FIELD OF THE INVENTION
The present invention relates to a system and method for translating source code between different computer languages and different operating environments. More specifically, the present invention relates to a bi-directional computer language translator where source code written in an original language may be translated to a target language, and then may be translated back to the original language while still maintaining concept, syntax, form of expression, and formatting of the original source code.
BACKGROUND OF THE INVENTION
Computer systems and applications have reached almost every market on a global scale. As a result, vast sums of money are spent in researching and developing new applications and programs. Typically, these applications are written in a computer language selected by a software developer or by a group of software developers.
A trend among software developers has been toward use of object-oriented programming (“OOP”) languages. Two major categories of OOP languages are (1) systems programming languages, which are generally unmanaged and natively compiled and, in turn, executed natively; and (2) productivity-oriented business application programming languages, which are generally managed and compiled to non-native bytecodes or a non-native intermediate language (“IL”) and, in turn, executed non-natively by a managed runtime environment or virtual machine.
Systems programming languages are typically used for developing performance critical applications, operating systems, operating environments, operating system specific applications, managed runtime environments and virtual machines, embedded systems, and hardware specific software, such as for instance, device drivers. Systems programming languages are generally lower-level languages which offer finer control over the run-time execution of applications. Systems programming languages include, for instance but are not limited to C and C++.
Productivity-oriented business application languages are typically used for developing applications for electronic commerce, wireless devices, multimedia devices and platforms, accessing databases, web applications, and other business-related needs. Productivity-oriented business application languages are generally higher-level languages which offer greater programmer productivity and increased reliability during the run-time execution of applications. Business application languages include, for instance but are not limited to Java® and C♯ (pronounced, “C-Sharp”). These however, are just a few of the many OOP languages that may be utilized in generating applications.
Traditionally, software developers choose one computer language for systems programming and another for business applications programming. In doing so, however, they must make sacrifices and accept the tradeoffs of the selected language. The application, design methodology, and business model may all factor into the choice of programming language used for a particular application.
For instance, C++ is typically viewed as an advantageous language for creating large-scale applications, whereas Java is typically viewed as optimized for the distribution of program objects in a network such as the Internet. Java is generally considered a higher level language than C++, that is, closer to the actual business application. As a result, many programmers prefer to write programs in Java because it is generally considered an easier language to use than C++.
Another advantage Java provides is that Java objects cannot contain references to data external to themselves or other known objects. This ensures that an instruction input by a programmer cannot contain an address of data storage in another application or in the operating system itself, either of which could cause the program and possibly even the operating system to terminate or crash. In addition, Java utilizes a virtual machine that makes a number of checks on each object to ensure integrity. This results in a finished application that is not prone to low-level memory errors and requires considerably less debugging. C++ on the other hand does not have these safety functions such that a programmer may inadvertently or maliciously cause problems with the operating system. In addition, many of the computer viruses seen today exploit this characteristic of C++ to cause widespread computer problems. Many of these problems could be avoided by utilizing Java because of the built-in safety checks and balances inherent to the language.
Alternatively, there are some distinct advantages associated with C++ as opposed to Java. For instance, C++ is generally considered a higher performance language than Java. Once an application is written in C++, it may be compiled to native code or machine code, as opposed to Java, which is typically compiled into bytecode. As a result, unlike Java, a program compiled into native code does not need to operate with a virtual machine, which results in increased application performance. Another advantage to compiling a program to native code is that it is very difficult to derive the C++ source code from the native code, whereas it is a fairly simple matter to derive the Java source code from the compiled bytecode. Therefore, C++ can provide greater protection for a company's intellectual property.
In view of the forgoing, there is an inherent tension between using Java and using C++. Many programmers would prefer to write programs in Java, however many companies want their end product to be completed in C++ so that it may be compiled into native code. However, companies also recognize the benefits of using Java, realizing that it may be a faster and less expensive way to get new products and services to market. This is because Java is generally considered an easier language to use and also because of the greatly reduced debugging time associated with new applications.
Historically it has been very difficult or nearly impossible to convert a program written in C++ to Java and/or vice versa. To do so requires manual porting, which is generally labor intensive, error prone, and requires extensive re-testing.
To address these issues and minimize the differences between computer languages, a number of existing systems have tried a number of approaches. These include for instance: (1) cross-language interoperability layers and object mapping mechanisms; (2) native compilers for traditionally non-natively compiled languages; (3) programs which convert or migrate computer programs from one language to another language; and (4) programs which translate computer programs between different computer languages. None of these approaches, however, have provided an acceptable solution.
For instance, one approach taken is cross-language interoperability layers and object mapping mechanisms including the Sun Microsystems® Java Native InterfaceTM (JNI), the Microsoft® Common Object ModelTM (COM), and the Object Management Group® (OMG) Common Object Request Broker ArchitectureTM (CORBA). Such solutions are generally suited for integrating two or more different computer languages and operating environments. However, they do not eliminate the need for middleware, such as virtual machines, managed runtime environments, and object request brokers (ORBs), but instead increase dependence on these. This dependence make these solutions unsuitable for demanding low-level systems programming for developing for instance, operating systems, virtual machines, and embedded systems.
A second approach taken includes native compilers for traditionally non-natively compiled languages including, for instance, the GNU® Compiler for Java (GCJ) and the Excelsior JET. The GNU Compiler for Java (GCJ) is a free (open source) software project and is disclosed in U.S. Pat. No. 6,110,226. These products compile Java source code or Java bytecode, a platform-independent intermediate language, to native binary executables. The GCJ compiler may generate native binary executables, which do not require a virtual machine to execute program, so long as the compiled Java program does not make use of Java classes or objects, which are externally referenced or otherwise not natively compiled. In the latter case, the compiled native binary executable requires an internal (statically-linked) or external (dynamically-linked) virtual machine, which suffers from the same drawbacks as cross-language interoperability layers and object mapping mechanisms. Alternatively, Excelsior JET for instance, generates native binary executables that generally depend on the presence of a virtual machine on the client system in order to run. However, these requirements carry the same drawbacks as common cross-language interoperability layers and therefore negate most of the benefits of native compilers.
While the GCJ compiler does support interoperability with C++ through CNI (Cygnus® Native Interface), this means of interoperability however, is effectively limited to the GNU C++ compiler. GCJ does not support interoperability with leading platform-specific C++ compilers, such as Microsoft Visual C++® for Microsoft Windows® operating system, nor does it support the industry-standard JNI to interoperate with leading Java virtual machines. Additionally, native compilers do not translate source code to another computer language, so they do not inherently benefit from wealth of available software development tools, such as compilers, linkers, optimizers, and debuggers, or features of other popular computer languages, such as C++.
A third approach has been to convert or migrate source code in one computer language to another computer language. This approach is disclosed in U.S. Pat. No. 6,453,464 (“the '464 patent”). This approach is directed toward migrating source code from an aging computer language, such as for instance COBOL, to an OOP language, such as Java. However, the resulting translated source code does not fully preserve the style and spirit of the original source code, is not easily human-readable, and does not support translation back to the original language. Therefore, the system disclosed in the '464 patent cannot be used for bi-directional translation between OOP languages to combine the best features of both languages.
A fourth approach taken has included computer language-to-computer language translation. Existing translators include Toba, C2J, and J2C, among others. These solutions, however, have severe limitations of their respective design and implementation. For instance, they fail to: manage objects exactly like the original language, manage arrays exactly like the original language, maintain the same high-level of thread safety characteristic in the original language, and support the full breadth of features of the original language. Additionally, none of these approaches support nor addresses bi-directional translation. Still further, these one-way translation approaches generally require translation of the entire application at one time, rather than providing for translation of only a file or a portion of a file.
What is desired then is a computer language translation system that accurately and reliably translates source code between divergent computer languages.
It is also desired to provide a computer language translation system that accurately and reliably translates source code between OOP languages.
It is further desired to provide a computer language translation system that may be coupled with associated software libraries and accurately and reliably translate source codes between higher-level productivity-oriented business application programming languages and systems programming languages.
It is still further desired to provide a bi-directional computer language translation system that may accurately and reliably translate source code from a higher-level productivity-oriented business application programming language to a systems programming language and back again.
It is yet further desired to provide a computer language translation system that is usable with multiple computing platforms, operating systems, and operating environments.
It is also desired to provide a computer language translation system that provides deterministic automated object management without a garbage collector in order to be suitable for embedded systems.
It is still further desired to provide a computer language translation system that may utilize industry-standard compiler tools, such as for instance, ANSI® C++ compilers.
It is yet further desired to provide a computer language translation system that will be virtual machine agnostic, specifically, that will be able to operate without a virtual machine, or conversely, if desired, able to interoperate with an industry standard virtual machine.
It is still further desired to provide a computer language translation system that adheres to industry standards for cross-language interoperability, such as JNI for interoperability between Java environments and C++ environments.
It is yet further desired to provide a computer language translation system that may be utilized to translate only a portion of the source code to be translated.
SUMMARY OF THE INVENTION
Accordingly, a bi-directional translator has been provided that translates source code from one computer language to another divergent computer language. The translated source code closely resembles the original program source code in: concept, syntax, form of expression, and formatting. The system may be utilized as either an automatic translator that automatically translates source code from one computer language to another, or may be utilized in connection with a software development library that enables programs to be manually ported from one computer language to another.
When the system is utilized to automatically translate, a software tool is provided that automatically translates programs written in for instance, the Java language to the C++ language. The tool makes use of tables and specific language knowledge of Java and C++. This tool does not require clean-up or hand editing after translation. The final translated programs may be built and run as is.
Alternatively, if the system is used by a programmer who is manually porting the source code, a software development library that implements the Java language and core APIs in ANSI standard C++ syntax is provided. Manually ported C++ programs, which make use of the library, closely resemble the original programs in the Java language.
Because of the nature of divergent OOP languages, such as Java and C++, the divergent languages are incompatible, meaning that one word does not simply translate straight to another word. For instance, the way variables are identified in Java is different than in C++. To achieve bi-directional translation, the system, in resolving incompatibilities performs a name adjustment that is consistently utilized throughout. Because the name adjustments are always consistent, the system may re-translate either the entire document or only small sections as desired.
The system also utilizes tagged elements or tags, which are inserted by the system to control how for instance; a specific section of source code is translated. The tagged element may include a Java instruction inserted into the C++ translation. In this manner, if the Java source code instruction is incompatible with any C++ source code instruction, the original is not lost, but instead is maintained in a tagged element within the C++ source code. This feature facilitates bi-directional translation because the original language may be exactly re-created from the translation, even with incompatibility problems.
Throughout this application the following definitions apply:
The term “data” as used herein means any indicia, signals, marks, domains, symbols, symbol sets, representations, and any other physical form or forms representing information, whether permanent or temporary, whether visible, audible, acoustic, electric, magnetic, electromagnetic, or otherwise manifested. The term “data” as used to represent particular information in one physical form shall be deemed to encompass any and all representations of the same particular information in a different physical form or forms.
The term “storage” as used herein means data storage devices, apparatus, programs, circuits, systems, subsystems, or other elements whether implemented in hardware, software, or both, and whether used to process data in analog or digital form, into which data may be entered, and from which data may be obtained, as desired. Storage can be primary and/or secondary and can store data in electromagnetic, magnetic, optical, magneto-optical chemical and/or holographic forms.
The term “processor” as used herein means data processing devices, apparatus, programs, circuits, systems, and subsystems, whether implemented in hardware, software, or both, and whether used to process data in analog or digital form. The processor can operate on data in electromagnetic, magnetic, optical, magneto-optical chemical and/or holographic forms.
The terms “communicate”, “communicating” and “communications” as used herein include both conveying data from a source to a destination, as well as delivering data to a communications medium, system or link to be conveyed to a destination. The term “communication” as used herein means the act of communicating or the data communicated, as appropriate.
The terms “coupling”, “coupled”, “coupled to”, and “coupled with” as used herein each mean a relationship between or among two or more devices, apparatus, files, programs, media, components, networks, systems, subsystems, and/or means, constituting any one or more of (a) a connection, whether direct or through one or more other devices, apparatus, files, programs, media, components, networks, systems, subsystems, or means, (b) a communications relationship, whether direct or through one or more other devices, apparatus, files, programs, media, components, networks, systems, subsystems, or means, or (c) a functional relationship in which the operation of any one or more of the relevant devices, apparatus, files, programs, media, components, networks, systems, subsystems, or means depends, in whole or in part, on the operation of any one or more others thereof.
The term “network” as used herein means the communications linkage used to join two or more units, such as systems, networks, links, nodes, equipment, circuits, buses, and devices and includes without limitation networks of all kinds, including coupling amongst components of a system, both intra-networks and inter-networks and including, but not limited to, the Internet, and is not limited to any particular such network.
The terms “computer language” and “computer programming language” as used herein mean a computer programming language for accomplishing software development and/or expressing the source code of a computer program. Furthermore, a “computer programming language” may or may not be classified as object-oriented. “Computer programming languages” include, but are not limited to, Java, C♯, and C++.
The terms “virtual machine (VM),” “virtual machine environment,” “managed runtime,” and “managed runtime environment (MRE)” as used herein refer to an apparatus, either software or hardware, which executes bytecode. Virtual machines may also include a platform application programming interface (API) or platform classes that bytecode programs may call or otherwise make use of. Virtual machines are designed to isolate software programs from the underlying native hardware and software platform, which facilitates the creation, deployment, and execution of distributed, secure, platform-independent software programs and components. Java and C♯ are designed for virtual machine environments, whereas C++ is not.
The term “bytecode” as used herein refers to a non-native binary representation of an executable program or software component. Bytecode is designed to be executed by a virtual machine. Bytecode may also be referred to as an “intermediate language (IL).”
The term “garbage collector” as used herein refers to an apparatus for automated object management, where allocated memory is automatically reclaimed when it is unneeded, which is accomplished through a housekeeping process. The housekeeping process may further include memory compaction. The housekeeping process is generally performed nondeterministically at the primary discretion of the garbage collector. Virtual machine environments, such as those for Java and C♯, include a garbage collector. Legacy and ANSI C++ programming environments do not include a garbage collector.
The term “SourceUnit” is the smallest unit of autonomous source code, which may be compiled, interpreted, or executed, depending on the capabilities of the source language. This generally refers to an individual source code file, such as in Java, C++, or C♯. In C++ and some other languages, a SourceUnit may be referred to as a “compilation unit.”
The term “Document Object Model (DOM)” is an object-oriented programming interface for representing the different conceptual elements of a document. Furthermore, the individual elements in a DOM may be stored in a hierarchy.
The term “SourceUnit DOM” is a specialized DOM for representing the different conceptual elements of a source code file or document. The SourceUnit DOM is only intended for representing source code files. The conceptual elements making up a SourceUnit DOM include: single line comment, multiple line comment, package statement, import statement, class definition, field definition, implementation block, implementation statement, method definition, static constructor definition, exception statement, control flow statement, and text. There is only one SourceUnit DOM per SourceUnit. The SourceUnit DOM is a complete representation of the original SourceUnit, including its formatting. Alternatively, the term “SourceUnit DOM” may also apply to an Abstract Syntax Tree (AST) that serves the same purpose of representing the different conceptual elements of a source code file or document.
The term “tagged element” is a note inserted by the translator that contains extra information to be preserved through the translation process. A tagged element is embedded inside specially denoted single line comment or multiple line comment elements. This extra information captures logic and other content from the original source files that typically cannot be preserved in translation but through such tagged elements allows such logic and content to be preserved in translated results.
The term “keyword” means a word that always has the same meaning and cannot be used for any other purpose, i.e., as identifiers.
The term “class” is a type in an object-oriented programming language. A class may have methods, data fields, and inner-classes (classes within classes), which may all be generically referred to as “class members.” The term “class” also can refer to an “interface.”
The term “object” is an instance of a class.
The term “method” is a function or procedure that a particular class may do. A method may or may not be provided with variable parameters, and it may or may not return a value. A method is always associated with a particular class, and it may be referred to as a “class member.” The term “method” also applies to constructors and destructors.
The term “constructor” is a function or procedure that will be used to initialize an object, which an instance of a particular class. A constructor may or may not be provided with variable parameters, and it may not return a value. A constructor is always associated with a particular class, and it may be referred to as a “class member.” A class must have at least one explicit or implicit constructor in order to instantiate instances of itself.
The term “destructor” is a function or procedure that will be used to destruct an object, which an instance of a particular class. A destructor may not be provided with variable parameters, and it may not return a value. A destructor is always associated with a particular class, and it may be referred to as a “class member.” A class may have only one destructor, which itself is optional. In Java, a destructor is called a “finalizer.”
The term “data field” is a variable that a particular class contains. A data field may be a numeric value, a Boolean value, an object reference, or an interface reference, or an array reference. A data field is always associated with a particular class, and it may be referred to as a “class member.”
The term “interface” is a class that declares one or more methods, but it does not define (implement) any of these methods. Instead, other classes which implement a particular interface must themselves define (implement) all of the interface's methods.
The term “class declaration” is the declaration of a new class (or interface) type. A class declaration is sometimes referred to as a “class interface.” It describes the constructors, destructor (finalizer), methods, data fields, and inner-classes (a class within a class) that make up a particular class. Constructors, destructor, methods, data fields, and inner-classes of a particular class may be referred to generically as “class members.” A class declaration defines the access control for each of its class members, be they constructors, destructor, methods, data fields, or inner-classes. A class declaration also details which class this class inherits from which includes its superclass and any interfaces it implements. Certain computer languages like C++ allow separating class declarations from class implementations, whereas other languages like Java and C♯ combine both the class declaration and class implementation into the class definition. A public class declaration makes a particular class accessible so that other (external) classes can create or interact with instances of the class. In turn, other (external) classes come to depend on the class declaration, which necessitates that the class declaration remains consistent.
The term “class implementation” is the implementation of a newly declared class type. It implements its constructors, destructor, methods, static data fields, and inner-classes. Certain computer languages like C++ allow separating class declarations from class implementations, whereas other language like Java and C♯ combine both the class declaration and class implementation into the class definition. The class implementation is not directly accessible to other (external) classes but only the class declaration is. This means that the internal class implementation may potentially be changed without adversely affecting other classes which depend on its class declaration.
The term “class definition” is the definition (implementation) of a new class type. The exact meaning of this term differs from computer language to computer language. For Java and C♯, this refers to the combined class declaration and class implementation. In C++, this refers only to the class implementation.
In one advantageous embodiment a computer language translating system for translating a first computer language source code to a second computer language source code is provided comprising, a computer, and a library accessible by the computer, the library including data indicative of types of data manipulations between the first computer language source code and the second computer language source code. The system further comprises software executing on the computer, the software analyzing the first computer language source code to identify a type of data manipulation that the first computer language source code performs. The software further accessing the library and correlating the type of data manipulation the first computer language source code performs to second computer language source code, the correlation being independent of the context in which the first computer language source code is used. The software still further generating second computer language source code that emulates the type of data manipulation the first computer language source code performs.
In another advantageous embodiment a computer language translating system for translating a first computer language source code to a second computer language source code is provided comprising, a library accessible by the translating system, the library including data indicative of types of data manipulations between the first computer language source code and the second computer language source code. The system further comprises a parser for parsing the first computer language source code into parsed elements, and an analyzer for analyzing the parsed elements to identify the type of data manipulation that the first computer language source code performs, the analyzer accessing the library and correlating the type of data manipulation the first computer language source code performs to second computer language source code, the correlation being independent of the context in which the first computer language source code is used. The system still further comprises a generator for generating second computer language source code that emulates the type of data manipulation the first computer language source code performs.
In still another advantageous embodiment a method for translating a first computer language source code to a second computer language source code is provided comprising the steps of, inputting the first computer language source code into a computer, parsing the first computer language source code into parsed elements, and analyzing the parsed elements to determine a type of data manipulation the first computer language source code performs. The method further comprises the steps of, building class declarations and class definitions from the parsed elements that are independent of the context of the first computer language source code, and generating the second computer language source code according to the class declarations and class definitions, the second computer language source code emulating the type of data manipulation the first computer language source code performs.
In yet another advantageous embodiment a method for translating a first computer language source code to a second computer language source code is provided comprising the steps of analyzing the first computer language source code to determine a type of data manipulation the first computer language source code performs. The method further comprises the steps of correlating the type of data manipulation of the first computer language source code performs to second computer language source code, the correlation being independent of the context in which the first computer language source code is used. The method still further comprises the steps of generating the second computer language source code, the second computer language source code emulating the type of data manipulation the first computer language source code performs.
In still another advantageous embodiment a computer language translating system for translating a Java source code to an OOP language source code is provided comprising, a library including data indicative of types of data manipulations between the Java source code and the an OOP language source code. The system further comprises an analyzer, for analyzing the Java source code to determine a type of data manipulation the Java source code performs, the analyzer accessing the library to correlate the type of data manipulation the Java source code performs to OOP language source code, the correlation being independent of the context in which the Java source code is used. The system still further comprises a generator, for generating OOP language source code that emulates the type of data manipulation the Java source code performs.
In yet another advantageous embodiment a method for translating a portion of Java source code that comprises at least one class to an OOP language source code is provided comprising the steps of, parsing the at least one class into multiple identifiers, and parsing one of the identifiers into name segments. The method further comprises the steps of, adjusting the name segments individually and independently from each other according to the OOP language source code, and generating OOP language source code based on the name segments where only a portion of the Java source code is translated to the OOP language source code, the OOP language source code emulating a type of data manipulation the portion of the Java source code performs.
In still another advantageous embodiment a method for translating a first computer language source code that performs a data manipulation with a virtual machine to a second computer language source code that performs a data manipulation without use of a virtual machine, comprising the steps of, analyzing the first computer language source code to determine a type of data manipulation the first computer language source code performs, and correlating the type of data manipulation of the first computer language source code performs to second computer language source code. The method further comprises the steps of, generating the second computer language source code, the second computer language source code emulating the type of data manipulation the first computer language source code performs, and performing a data manipulation with the second computer language source code that emulates the type of data manipulation the first computer language source code performs, the second computer language source code performing the data manipulation without use of a virtual machine.
In still another advantageous embodiment a method for translating a first computer language source code that performs a data manipulation with a garbage collector to a second computer language source code that performs a data manipulation without use of a garbage collector, comprising the steps of, analyzing the first computer language source code to determine a type of data manipulation the first computer language source code performs, and correlating the type of data manipulation of the first computer language source code performs to second computer language source code. The method further comprises the steps of, generating the second computer language source code, the second computer language source code emulating the type of data manipulation the first computer language source code performs, and performing a data manipulation with the second computer language source code that emulates the type of data manipulation the first computer language source code performs, the second computer language source code performing the data manipulation without use of a garbage collector.
The invention and its particular features and advantages will become more apparent from the following detailed description considered with reference to the accompanying drawings.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a block diagram illustrating an advantageous embodiment of the present invention.
FIG. 2A is a block diagram according to FIG. 1 illustrating an advantageous embodiment of the present invention.
FIG. 2B is a block diagram according to FIG. 1 illustrating an advantageous embodiment of the present invention.
FIG. 3 is a block diagram illustrating some steps involved in bi-directional translation according to another advantageous embodiment of the present invention.
FIG. 4 is a flow diagram illustrating another advantageous embodiment of the present invention.
FIG. 5 is a flow diagram according to FIG. 4 illustrating another advantageous embodiment of the present invention.
FIG. 6 is a flow diagram according to FIG. 4 illustrating another advantageous embodiment of the present invention.
FIG. 7 is a flow diagram according to FIG. 6 illustrating another advantageous embodiment of the present invention.
FIG. 8 is a flow diagram according to FIG. 7 illustrating another advantageous embodiment of the present invention.
FIG. 9 is a flow diagram according to FIG. 7 illustrating another advantageous embodiment of the present invention.
FIG. 10 is a flow diagram according to FIG. 7 illustrating another advantageous embodiment of the present invention.
FIG. 11 is a flow diagram according to FIG. 10 illustrating another advantageous embodiment of the present invention.
FIG. 12 is a flow diagram according to FIGS. 9 and 11 illustrating another advantageous embodiment of the present invention.
FIG. 13 is a flow diagram according to FIG. 11 illustrating another advantageous embodiment of the present invention.
FIG. 14 is a flow diagram according to FIG. 13 illustrating another advantageous embodiment of the present invention.



DETAILED DESCRIPTION OF THE DRAWINGS
FIG. 1 illustrates an advantageous embodiment of translation system 100. Translation system 100 is shown including, first computer language source code 102, computer 106, translator 108, library 110 and second computer language source code 104.
First computer language source code 102 may comprise any computer language however; in one advantageous embodiment comprise an OOP language such as for instance, Java, C♯, or C++. Computer 106 may also comprise any computer capable of receiving first computer language source code 102. Translator 108 in an advantageous embodiment comprises software, executing on computer 106 to received and process first computer language source code 102. While translator 108 executes on computer 106, it is not necessary that translator 108 reside on computer 106. For instance, translator 108 may comprise software residing on another computer (not shown) to which computer 106 is connected over, for instance, a network. The network connection may comprise for instance, a hard wired and/or wireless network, e.g. employing bus connections, parallel cable, serial cable, coaxial cable, fiber optic, twisted wire pair, USB cable, infrared link, radio frequency link, microwave link, satellite link and/or the like.
Also provided in FIG. 1 is library 110 which is coupled to and accessible by computer 106. In one advantageous embodiment, library 110 comprises data indicative of relationships between the first computer language source code 102 and the second computer language source code 104. In another advantageous embodiment, library 110 may comprise data for correlating particular functions of the first computer language source code 102 to the second computer language source code 104. In still another advantageous embodiment library 110 may comprise, for instance, a database.
Once translator 108 has analyzed first computer language source code 102, translator 108 then generates second computer language source code 104. Again, second computer language source code 104 may comprise any computer language such as for instance, an OOP language including Java, C♯, or C++. Translation system 100 may be operated in various modes of operation including, fully automated, manual and/or combinations thereof.
As illustrated in FIG. 1, translator 108 generates second computer language source code 104. For instance, when first computer language source code 102 comprises Java and second computer language source code 104 comprises C++, there is a C++ implementation of the Java language. There is true translation from, in this example Java to C++. This means that there is no requirement for interoperability between Java and C++ and therefore, no need to utilize a virtual machine after translation.
It should further be noted that the arrows indicated from first computer language source code 102 to computer 106 and from second computer language source code 104 to computer 106 are shown bi-directional. This illustrates the bi-directionality of translator 108. For instance, first computer language source code 102 may be input to computer 106 and be translated to second computer language source code 104. Subsequently, second computer language source code 104 may-then be input to computer 106 and be re-translated back to first computer language source code 102. Notably, as illustrated in FIG. 1, the re-translated first computer language source code is depicted as the same as the first computer language source code 102. This is possible because translator 108 translates first computer language source code 102 independent of the context of in which it is-used. In this manner, the translation of various elements of the source code is always consistent and therefore reversible because of the direct correlation between various elements of the first computer language source code 102 to the second computer language source code 104.
FIG. 2A illustrates one advantageous embodiment of the present invention that expands translator 108 into analyzer 114 and generator 116. In this embodiment the translation process is divided into two steps: (1) analysis and (2) generation.
First computer language source code 102 is input to translator 108, which has as a first block, analyzer 114. Analyzer 114 is also coupled to library 110 which, as previously discussed, comprises data indicative of relationships between the first computer language source code 102 and the second computer language source code 104. Analyzer 114 will analyze the function of the first computer language source code 102 and then correlate the function to second computer language source code 104. In one advantageous embodiment, analyzer 114 will logically traverse or cycle through first computer language source code 102 in order to build class declarations and/or class definitions.
Analysis encompasses traversing all the elements of a particular SourceUnit DOM in order to produce high-level programming entities. For converting Java to C++ for instance, such high-level programming entities include the main public class and any supporting classes. These classes may, in turn, be made up of methods, fields, static constructors, and inner-classes. In another advantageous embodiment, analysis may also entail some language-specific pre-generation work, such as organizing high-level programming entities differently for certain target languages, such as C++.
Once analyzer 114 has built the class declarations and/or class definitions, these are sent to generator 116 for generation of second computer language source code 104. Generation is the process of producing source code in the target language from the high-level programming entities, such as public classes, produced from the analysis step. Generation may further re-organize high-level programming entities for correctness in the target language. Generation may still further entail adding embedded tagged elements where necessary so as to preserve the full semantic meaning of the original language and to facilitate bi-directional translation, if desired.
One problem that the generator may encounter during generation is a conflict between keywords between the first computer language source code 102 and the second computer language source code 104. For instance, identifier names in the source language may conflict with keywords in destination language. Such conflicts must be resolved in a consistent manner and preserve the syntactical correctness and readability of the translated result. Name resolution may require name adjustment, which is a mild form of name mangling. Identifier names which conflict with keywords or other features of the destination language must be adjusted. In such a case, the name is mildly mangled with the best effort being made to preserve the name as readable as possible. More common standard conforming identifier names are usually mangled less than uncommon nonstandard identifiers. This strategy is weighted toward preserving the readability of content which is already deemed readable due to its standards conformance.
In an alternative embodiment, FIG. 2B illustrates another expanded view of translator 108 that includes: parser 112, analyzer 114, and generator 116. The translation process according to FIG. 2B may be divided into three steps: (1) parsing, (2) analysis, (3) generation.
First computer language source code 102 is input to parser 112. Parser 112 is provided to parse first computer language source code 102 into parsed elements prior to transmission to analyzer 114 for building of class declarations and/or class definitions. The parser is essentially provided to turn the document into a hierarchy of elements including, for instance but not limited to: comments (such as inserting a tagged element), class definitions, variable declarations, and/or method calls. Parsing entails breaking each original language source code file down into corresponding elements in a SourceUnit DOM.
The remaining elements are similar to those discussed in connection with FIG. 2A and will not be repeated here.
FIG. 3 illustrates the process 200 of converting original source files to a target language and translation back to the original language. As a first step, a source code file is generated in the original computer language 205. This original computer language may be any computer language as previously discussed in connection with FIG. 1. Once the source code in the original computer language is generated, the source code file in the original computer language is stored 210. This may be local storage, for instance on the computer where the original code was generated or over a network. In addition, the storage may be permanent, semi-permanent or temporary. For instance, the original source code may be stored on a magnetic or optical drive and/or disk, or may only be resident in RAM.
The next step is translation of source code file in original computer language to source code file in target computer language 215. This process would include for instance, the processes variously described in connection with FIGS. 1-2B. Once the translation process is completed, the resulting source code file in the target computer language may be (1) compiled into a binary executable program; (2) run; (3) debugged; and (4) profiled 220. To accomplish this step, any number of commercial compilers may be utilized, for instance, Java and C♯ may be compiled to bytecode while C++ may be compiled to native code. The steps of running the program, debugging and profiling will be minimized due to the translation step. Finally, the resulting source code file in the target language is modified (as necessary) and stored 225.
The result is a highly accurate translation of the original source code file to the target source code file that will function as seamlessly as the original source code file, preserving the syntax and function of the original source code file. The process 200 of converting original source files to a target language is reversible as illustrated in FIG. 3. The process is reversed by the translation of the source code file in the target computer language back to the original computer language 230. It should be noted however, the any modifications made to the source code file will be reflected in the re-translated source code. Once the target language source code file is re-translated to the original source code language, the resulting source code file in the original computer language may be (1) compiled into a binary executable program; (2) run; (3) debugged; and (4) profiled 235. As previously stated, any number of commercial compilers may be utilized to accomplish this step. As can be seen from FIG. 3, the process 200 has returned to the step of storing the source code file in the original computer language 210.
This bi-directional translation process 200 is possible in part, because the translation from the original source code to the target source code is accomplished without regard to the context. The translation of elements is always consistent, and thereby reversible. For instance, keywords and identifiers are always resolved in a consistent manner and preserve the syntactical correctness and readability of the translated result.
FIG. 4 is a flow diagram illustrating the steps taken in one advantageous embodiment by translation system 300 in translating source code from an original computer language to a target computer language. Translation system 300 provides the significant benefits of: maintaining the logic, expression, and formatting of the original source code files through translation, which in turn, facilitates re-translation back to the original computer language. The process may for instance, be user-initiated or initiated as a batch process and after initiation is fully automated, requiring no further user involvement.
Further, FIG. 4 details the various hierarchical array types and hierarchical array references types and their relationship to one another and other objects in the system. The array types support storing both one-dimensional and multi-dimensional storage of array elements. In addition, the hierarchical array reference types fully support inheritance for themselves and the elements they contain. In one advantageous embodiment, element count is read-only and is fixed when the array is created.
One problem associated with reference types is that external classes for instance, in C++ are stored in their own files called (“header files”). If one class makes use of another class, it must include the other class' header file before it declares its own class. A problem arises when the classes refer to each other creating a circular dependency. However, translation system 300 obviates this problem by declaring reference types in their own files. A reference type file then only needs to include the header file of its superclass and implemented interfaces. A superclass is a parent of the class that extends from it, and subclasses (or child classes) can never be their own parent thereby preventing the circular dependency problem.
Another advantage to this embodiment of the present invention is that the second computer language source code is utilized to implement types of data manipulations of the first computer language source code. When translating from Java or C♯ to C++, this provides the benefit of eliminating the need for a virtual machine because there is implementation of the original language's (i.e., Java or C♯) platform classes in the target language (i.e., C++).
In another advantageous embodiment of the present invention, no garbage collector is required to automatically manage objects. Rather, translation system 300 automatically provides for object management making translation system 300 suitable for use with embedded systems.
As an initial step, the user (or the script file of a batch process) specifies the following: directory path of source code file(s), directory path of pre-translated source code files (if any), and file types to generate in target language 302. Of course, this initial step assumes that, the source code files in the original language (i.e., Java or C♯) 304 have already been generated. In addition, pre-translated software class library (i.e., native implementation of Java platform classes, or C♯ and .NET platform classes in target language) 306, and pre-translated class declaration file(s) in target language 308 have been provided.
The next step is that the user (or the batch process) starts the translation process 310 followed by generation of the list of packages from the specified directory path of source code files 312. As used herein, source code projects are made up of one or more packages, which in turn variously comprise: classes, fields, methods, inner classes, blocks, statements and/or combinations thereof. A source code project includes all the source code files related to a particular software application program. Translation system 300 then iterates through the packages 314 so as to generate a package importation file(s) in the target language 316, which in turn results in a generated package importation file in the target language 318. The next step is to generate a list of source file(s) from the specified directory path(s) of source code files 320.
Translation system 300 then iterates through each source code file 322. At this point, translation system 300 resolves whether the source code file exists 324. If the source code file does not exist, translation system 300 will notify the user that the source code file does not exist 326 and will return to allowing the user to specify the directory path 302.
If however, the source code file does exist, translation system 300 proceeds to parse source file into tree of source code elements, including formatting, using an event-driven parser such as, for instance, Simple API for XML (SAX) 328. This high level parsing of the source code file results in the generation of source code document (SourceUnit DOM) 330. The parsing step is essentially provided to turn the source code file into a hierarchy of elements and is discussed in more detail in connection with FIG. 2B.
Next, translation system 300 performs an analysis of the source code by analyzing the source code element tree in the source code document into class definitions 332. The next step is to analyze imported pre-translated class declaration file(s) into class declarations 334. At this point, translation system 300 has logically traversed or gone through all of the parsed elements to build class definitions and class declarations to be used for generation of the target source code. In the building of the class definitions and class declarations, some preliminary broad pre-translation to the target language may also take place. This analysis has also been previously discussed in connection with FIG. 2A.
We next move to the actual generation of the target source code. As an initial step, translation system 300 generates a class importation file in the target language 336, which results in a generated class importation file in the target language 338. The next step is to generate a class reference type definition file in the target language 340, which also results in a generated class reference type file in the target language 342. Following this step is to generate a class declaration file in the target language 360, which too results in a generated class declaration file in the target language 344. The process of generating the class declaration file is described in more detail in connection with FIG. 5. Finally, translation system 300 generates a class implementation file in the target language 400, which results in a generated class implementation file in the target language 346. This step is also described in greater detail in connection with FIG. 6. This generation step has also been discussed in connection with FIG. 2A.
This completes the translation process of the specified source file such that translation system 300 proceeds to the next source file 348 and/or the next package 350, and returns to iterating through the packages 314. The process will be repeated until all packages have been translated.
FIG. 5 is an expanded view of the step of generating a class declaration file in the target language 360. As an initial step, analysis of class definitions in the original language 362 is performed, followed by generation of statements for referencing external classes in the target language 364. The next step is to iterate through the class definitions in the original language 366. For Java and C♯, this includes for instance, one public class and zero or more private implementation classes. Once this step is completed, the system may generate static field declarations 368. The system then iterates through the method definitions 370. In this context, method refers to static initializer, constructors, destructor (finalizer), and methods. Again, once this step is completed, the system may generate method declaration(s) in the target language 372. If there are additional method definitions 374 and/or additional class definitions 376, the system will continue to iterate through those; if not the system will complete this step and move on to generating a class implementation file in the target language 400 as shown in FIG. 4.
FIG. 6 is an expanded view of the step of generating a class implementation file in the target language 400. Initially, analysis of class definitions in the original language 402 is performed. For Java and C♯, this includes for instance, one public class and zero or more private implementation classes. This is followed by generation of statements for referencing external classes in the target language 404. This corresponds to “import” statements in Java and C♯, and “♯include” and “using” statements in C++. The system next iterates through class definitions in the original language 406 and then generates static field definitions 408. The system then proceeds to iterate through method definitions 410. Again, in this context, method refers to static initializer, constructors, destructor (finalizer), and methods. The system may then generate out-of-line classes corresponding to anonymous inner-classes 412. In Java, anonymous inner-classes are defined inline within individual statements. These anonymous inner-classes are produced, in one advantageous embodiment, during analysis by analyzing the statements making up a method definition. The system next proceeds to generate statements in the target language 414. Again, in one preferred embodiment, references to anonymous inner-classes in individual statements are replaced with references to the corresponding generated out-of-line class names. If there are additional method definitions 416 and/or additional class definitions in the original language 418, the system will continue to iterate through those. If there are none left, the system will complete this step and proceed to determining if there is another source file 348 as shown in FIG. 4.
FIG. 7 is an expanded view of the step of generating statements in the target language 414. FIG. 7 generally describes one advantageous embodiment of the process for translating a statement in the original language to the source language using simulated keywords and embedded tagged elements. This process enables results to be for instance, translated back to original language.
The system starts with a statement in the original language 420. Initially, the system parses the statement into sub-statements 422 and then iterates through the sub-statements 424. The system then determines if the sub-statement requires a reference type or a referenced type 426. This step is described further in connection with FIG. 8. If it is determined that a reference type is required, the system proceeds to parse the reference type name identifier 428, and replace the reference type name identifier with an adjusted name for the target language 430. This step is described further in connection with FIG. 9. Once this step is completed, the system proceeds to parse the sub-statement into expressions 432. Alternatively, in connection with determining if the sub-statement requires a reference type or a referenced type 426, if the system determines that a referenced type is required, the system will also proceed to parse the sub-statement into expressions 432. Once the sub-statements have been parsed into expressions, the system iterates through the expressions 434 and parses any type name identifier in the expression 436. At this point the system determines if the identifier name is compatible with the target language 438. If it is not, the system proceeds to replace the identifier with an adjusted name 440. This step is described further in connection with FIG. 10. Once the identifier is replaced with an adjusted name, or it is determined that the identifier name is compatible with the target language, the system proceeds to determine if the expression corresponds to a simulated keyword 442. If it is determined that the expression does correspond to a keyword, the expression is replaced with a simulated keyword 444. Once the expression is replaced with a simulated keyword or it is determined that the expression does not correspond to a simulated keyword, the system proceeds to determine if the translation is fully expressible in the target language 446. If the translation is not fully expressible in the target language, the system will proceed to embed tagged elements or a tag 448 in the translated language. Once the tagged element is embedded or it is determined that the translation is fully expressible in the target language, the system proceeds to the next expression 450 and/or the next sub-statement 452 to repeat the above-described process until all expressions and sub-statements are translated. If it is determined that there are no more expressions or sub-statements, the system proceeds back to the next step of determining if there are additional statements in the method definition that contains the statement. If it is determined that there are no more statements, the system proceeds back to the next step of determining if there are additional method definitions 416 as illustrated in FIG. 6.
The following is a table in extended BNF notation illustrating an example of a potential format of embedded content, which cannot be expressed in the target language and is therefore embedded as tagged elements within the comment sections:












Syntax













EmbeddedContent
::=
EmbeddedComment+
(Expression+







EmbeddedComment+)?


Expression ::= expression in target language related to embedded


content











EmbeddedComment
::=
CommentBeginSymbol
“//”
Tagged







ElementsCommentEndSymbol


TaggedElements ::= TaggedElement+


TaggedElement ::= (“<” Namespace “:” ElementName “ ”


ElementAttributes “>”) | (“</” Namespace “:” ElementName “ ”


ElementAttributes* “>”)


Namespace ::= namespace for embedded tags (i.e., “pie”)


ElementName ::= name of embedded element (i.e., “loopscope”)


ElementAttributes ::= attributes for embedded element


CommentBeginSymbol ::= language-specific symbol or keyword (“/*”


for C++, C#, Java)


CommentEndSymbol ::= language-specific symbol or keyword (“*/”


for C++, C#, Java)













Source Code in Original
Translated Source Code in Target



Language (Java)
Language (ANSI C++, Visual C++ 6.0)







for (int index = 0; index
/*//<pie:loopscope>*/{



< 10; index ++)
/*//</pie:loopscope>*/



{
for (pi_int index_ = 0; index—










index *= 2;
< 10; index_ ++)










}
{










int index = 10;
index_ *= 2;











}




/*//<pie:loopscope>*/{




/*//</pie:loopscope>*/




pi_int index_ = 10;










The following is a table illustrating an example of simulated keywords used to provide corresponding features and forms of expression of the original language in the target language. Simulated keywords fully preserve all details of the expression of the original language so that the translated results in the target language can be accurately translated back to the original language, producing identical or substantially identical results to the original expressions in the original language.











Expression in Original Language
Simulated Keyword Expression in


(Java)
Target Language (ANSI C++)







(className)objectInstance
pi_cast(className,



*objectInstance)


(className)this
pi_cast(className, this)


objectInstance instanceof className
pi_instanceof(*objectInstance,



className)


this instanceof className
pi_instanceof(this, className)


throws className
pi_throws(className)


throws className1, className2, . . .
pi_throwsbegin(className1)


className9
pi_throwsalso(className2)



pi_throwsalso(className9)



pi_throwsend( )


switch (expression) {
pi_beginswitch(type, expression)


} as used to end a switch block)
pi_endswitch( )


case value:
pi_case(value)


default:
pi_default( )


Null
pi_null


synchronized (as used within method
pi_synchronized


definitions)


interface interfaceName
class pi_interfaceclass



interfaceName


Boolean
pi_boolean









FIG. 8 is an expanded view of the step of determining if the sub-statement requires a reference type or a referenced type 426. FIG. 8 generally describes the process of determining if the statement requires a reference type or a referenced type. In this advantageous embodiment, the process is demonstrated by the example of translating a statement or expression in the Java language to the C++ language. However, it is contemplated that this process may be modified for applicable with conversion of any computer language.
The system starts with a statement or expression 454. A determination is then made as to whether the target language requires separate types for references 456. If not, the referenced type is used 466. If however, the target language does require separate types for references, the system proceeds to determine if the statement or expression is a variable declaration statement 458. If not, the reference type is used 464. If however, it is determined that the statement or expression is a variable declaration statement, the system proceeds to determine if it is cast or an instance of expression 460. If not, the referenced type is used 466. If however, it is determined that it is cast or an instance of expression, the system proceeds to determine if the parameter type is an array 462. If not, the referenced type is used 466. If so, the reference type is used 464. The system then proceeds according to FIG. 7 as previous discussed.
FIG. 9 is an expanded view of the step of replacing the reference type name identifier with an adjusted name for the target language 430. Generally, in this step the identifier name is adjusted for the target language. If the variable type is not an array or is not a primitive, the name is further adjusted to be a reference type for the target language.
In this step, the system begins with a reference type name identifier in the source language 468. It is then determined if the type name is a fundamental type in the source language 470. If not, then the class name identifier is adjusted for the target language 472, which is described in more detail in connection with FIG. 12. Once this is completed, it is determined if the name is an array reference 478. If not, then the system will proceed to append a character to the resultant identifier 482. This character may be for instance, any alphanumeric character depending on the computer language. For example, an uppercase “R” may be effectively utilized in connection with the Java language because it is uncommon for Java variable type names to end with an uppercase “R” and it further indicates “Reference” to the user. Other suffixes however, may be effectively utilized in connection with other computer languages. Once the character is appended, the system completes this step.
If on the other hand, it is determined that the type name is a fundamental type in the source language according to step 470, then a primitive type name is translated to the target language 474. The system may, in one advantageous embodiment, reference a table of primitive type names in the original language and target language 476 to facilitate this step. Once this is completed, it is determined if the name is an array reference 480. If not, then the system completes this step.
If however, it is determined that the name is an array reference 478 and/or 480, the system will then proceed to determine the array dimensions 484. If it is determined that there is one dimension, two characters are appended to the resultant identifier 488. Again, in one advantageous embodiment, uppercase “AR” may be effectively used because it is uncommon for Java variable types to end with uppercase “AR” and it may indicate for instance, “Array Reference” to the user. Alternatively, if it is determined that there are two dimensions, three characters are appended to the resultant identifier 486. For instance, uppercase “AAR” may be utilized and indicate for instance, “Array of Array References” to the user. It is however contemplated that other suffixes may be effectively utilized in connection with other computer languages. Once these characters are appended, the system completes this step.
FIG. 10 is an expanded view of the step of replacing the identifier with an adjusted name 440. FIG. 10 generally describes the process of adjusting referenced type name identifiers in the source language to a suitable name in the target language. The process of Identifier Name Adjustment is a mild form of name mangling that produces a fully human-readable name.
This step starts with a referenced type name identifier in the source language 490 and proceeds to determine if the type name is a fundamental type in the source language 492. If not, the class name identifier is adjusted for the target language 494. This step is described in greater detail in connection with FIG. 11. If however, the type name is a fundamental type in the source language, the system proceeds to translate the primitive type name to the target language 496. Again, in one advantageous embodiment, a reference table of primitive type names in the original language and target language 498 may be used to facilitate this step.
FIG. 11 is an expanded view of the step of adjusting a class name identifier for the target language 494. FIG. 11 generally describes the process of adjusting composite unparsed identifiers into package names, class names, method names, and variable names and identifiers in the source language to a suitable name in the target language.
An identifier in the original language 500 is analyzed to determine if the identifier name is qualified 502. For clarity, a qualified name contains one or more identifier name separator tokens, for instance, Java and C♯ use the period “.” character (i.e., java.lang.Object or System.object is qualified, but Object or object is not). If it is determined that the identifier name is qualified, the system proceeds to determine if the identifier name is an imported class 504, and in one advantageous embodiment may utilize a list of imported classes 506 to facilitate this determination. If the identifier name is an imported class, the system proceeds to adjust the class name identifier for the target language 506, which is discussed in greater detail in connection with FIG. 12. Alternatively, if the identifier name is not an imported class, the system proceeds to determining if the identifier is a method or a data field identifier 508. If it is determined to be a method identifier, the method name identifier is adjusted for the target language 510, which is again discussed in greater detail in connection with FIG. 12. However, if the identifier name is determined to be a data field, the data field name identifier is adjusted for the target language 512, which is discussed in greater detail in connection with FIG. 13.
Returning now to the step of determining if the identifier name is qualified 502, if it is determined to be qualified, the system proceeds to determine if the identifier is a fully qualified imported class 514. If so, the package/namespace of the identifier is parsed 516, and then the package or namespace of the identifier for the target language is adjusted 518, which is again described in greater detail in connection with FIG. 12. Once this step is completed or in the event the identifier is not a fully qualified imported class, the system proceeds to parse the class name identifier and method or data field identifier 520. It should also be noted that the class name identifier here may also comprise an inner-class. The class name identifier for the target language is then adjusted 522 as further described in connection with FIG. 12. Next it is determined whether an identifier is supplied after the class name 524. If not, this step is completed. If it is determined that an identifier is supplied after the class name, then the system proceeds to determine if the identifier is a method or a data field identifier 508 as previously discussed.
FIG. 12 is an expanded view of the step of adjusting the name identifier for the target language. There are various steps in the previous drawings that reference this process including: adjusting the class name identifier 472; adjusting the method name identifier 510; and adjusting the package name identifier 518. In this process, an identifier name is generally parsed into name segments, which are individually and independently adjusted for the target language so that the adjusted name is universal. This provides the benefit of allowing individual classes to be translated as modified without requiring retranslation of all related source code files in the entire project. It also facilitates automation because no human interaction is necessary to determine or specify named aliases.
An identifier name in the original computer language 526 is parsed into name segments 528. The system then iterates through the name segments 530 and further parses the identifier name segment in the original computer language 532. It is then determined if the name segment is a keyword in the target language 534. If the name segment is determined to be a keyword in the target language, the system will proceed to append an underscore (“_”) to the name segment 536 and proceeds to the next name segment 538. If however, the name segment is determined to not be a keyword in the target language, the system proceeds to determine if the name segment terminates or ends with an underscore (“_”) 540. If so, the system proceeds to append an underscore (“_”) to the name segment 542 and proceeds to the next name segment 538. If however, it is determined that the name segment does not terminate with an underscore (“_”), the system proceeds to determine whether the name segment ends with a selected character, such as for instance, with an uppercase “R” 544. If not, the system proceeds to the next name segment 538. If however, it is determined that the name segment ends with a selected character, an underscore (“_”) is inserted before the last character in the identifier name 546, after which the system proceeds to the next name segment 538.
FIG. 13 is an expanded view of the step of adjusting the data field name identifier for the target language 512. FIG. 13 generally describes the process of resolving conflicting syntactical rules between the original computer language and the target computer language. This process is a demonstration of one advantageous embodiment of the present invention providing an example of translating a class data field identifier name in a source language, such as Java, to a target language, such as C++. It should however be noted that this is merely an example specific to the computer languages used in the example and is equally applicable to any number of various computer languages.
This process begins with a class data field identifier name in the original computer language 548. It is then determined whether the source language supports both a method named “X” and a data field named “X” in the same class declaration 550. If so, the system proceeds to determine if the target language supports both a method named “X” and a data field named “X” in the same class declaration 552. If so, this process is completed. If not however, the field name identifier for the target language is adjusted 554, which is discussed in greater detail in connection with FIG. 14, after which the process is completed. Returning now to determining whether the source language supports both a method named “X” and a data field named “X” in the same class declaration 550, if not, then the system determines if the target language supports both a method named “X” and a data field named “X” in the same class declaration 556. If not, the process is completed. If however it does support both a method named “X” and a data field named “X” in the same class declaration, then the system translates the adjusted field name to the original name in the target language 558, after which the process is completed.
FIG. 14 is an expanded view of the step of adjusting the field name identifier for the target language 554. FIG. 14 starts with a data field name identifier or variable name identifier in the original language 560. It is then determined if the name ends with an underscore (“_”) 562. If not, the system proceeds to append an underscore (“_”) to the name segment 564. If however, it is determined that the name ends with an underscore (“_”), the system proceeds to append the text to a name indicating that it is a field name which ends with an underscore 566.
Although the invention has been described with reference to a particular arrangement of parts, features and the like, these are not intended to exhaust all possible arrangements or features, and indeed many other modifications and variations will be ascertainable to those of skill in the art.

## Claims

1. A computer language translating system for translating a first OOP computer language source code to a second OOP computer language source code, comprising:
a computer having a storage;
an emulated Application Programming Interface library having a table and accessible by said computer, said library including data indicative of types of data manipulations between the first computer language source code and the second computer language source code, said table including second computer language equivalent functions callable by said second computer language;
an analyzer analyzing the type of data manipulation the first computer language source code performs, said analyzer accessing said table of said emulation library and correlating the type of data manipulation the first computer language source code performs to a second computer language equivalent function; and
a generator generating second computer language source code based on the identified equivalent functions such that second computer language source code emulates the type of data manipulation the first computer language source code performs;
said second computer language source code providing discreet functionality that is independent from the first computer language source code such that said generated second computer language source code can independently provide the equivalent type of data manipulations provided in said first computer language source code without reference to the first computer language source code.

2. The computer language translating system according to claim 1 wherein the translating system is a bi-directional translator, and further comprises a parser parsing the first and second computer language source codes into parsed elements.

3. The computer language translator according to claim 1 wherein the translator is a bi-directional translator, said analyzer analyzing the second computer language source code to identify the type of data manipulation that the second computer language source code performs, accessing said emulation library and correlating the type of data manipulation the second computer language source code performs to first computer language source code, the correlation being independent of the context in which the second computer language source code is used, said generator generating re-translated first computer language source code that emulates the type of data manipulation the second computer language source code performs.

4. The computer language translator according to claim 1 wherein said generator performs a name adjustment when an incompatibility between the first computer language source code and the second computer language source code occurs during correlation of the type of data manipulation the first computer language source code performs to the second computer language source code to resolve the incompatibility, the name adjustment being independent of the context in which the incompatibility is located.

5. The computer language translator according to claim 1 wherein the first computer language source code comprises a class.

6. The computer language translator according to claim 5 wherein the class consists of: methods, data fields, inner-classes, and combination thereof.

7. The computer language translator according to claim 1 wherein the first computer language source code comprises an identifier.

8. The computer language translator according to claim 7 wherein said generator performs a name adjustment when an incompatibility between the identifier and the second computer language source code occurs during correlation of the type of data manipulation the identifier performs to the second computer language source code to resolve the incompatibility, the name adjustment being independent of the context in which the identifier is used.

9. The computer language translator according to claim 1 wherein said generator generates a tagged element inserted in the second computer language source code indicative of a type of data manipulation the first computer language source code performs.

10. The computer language translator according to claim 9 wherein the tagged element comprises information selected from the group consisting of: formatting, translation data, and first computer language source code.

11. The computer language translator according to claim 1 wherein the first computer language is Java and the second computer language is C++.

12. The computer language translator according to claim 1 wherein the first computer language is Java and the second computer language is C♯.

13. The computer language translator according to claim 1 wherein the first computer language is C♯ and the second computer language is C++.

14. A method for translating a first OOP computer language source code to a second OOP computer language source code comprising the steps of:
inputting the first computer language source code into a computer;
parsing the first computer language source code into parsed elements;
analyzing the parsed elements to determine a type of data manipulation the first computer language source code performs;
referencing an emulation Application Programming Interface library including second computer language equivalent functions that emulate the first computer language data manipulations;
selecting second computer language equivalent functions from the emulation library that emulate the first computer language data manipulations;
building class declarations and class definitions from the parsed elements that independently provide the equivalent type of data manipulations provided in the first computer language source code without reference to the first computer language source code;
generating the second computer language source code according to the class declarations and class definitions, the second computer language source code emulating the type of data manipulation the first computer language source code performs;
the second computer language source code referencing the Application Programming Interface library based on the selected equivalent functions emulating the first computer language.

15. The translation method according to claim 14 further comprising the steps of:
parsing the second computer language source code into parsed elements;
analyzing the parsed elements to determine a type of data manipulation the second computer language source code performs;
building class declarations and class definitions from the parsed elements that are independent of the context of the second computer language source code;
generating the re-translated first computer language source code according to the class declarations and class definitions, the first computer language source code emulating the type of data manipulation the second computer language source code performs.

16. The translation method according to claim 14 further comprising the step of, performing a name adjustment when an incompatibility between the first computer language source code and the second computer language source code occurs during translation, the name adjustment being independent of the context in which the incompatibility is located.

17. The translation method according to claim 14 wherein the first computer language source code comprises an identifier.

18. The translation method according to claim 17 further comprising the step of, performing a name adjustment when an incompatibility between the identifier and the second computer language source code occurs during translation, the name adjustment being independent of the context in which the identifier is located.

19. The translation method according to claim 14 further comprising the step of,
generating a tagged element indicative of the type of data manipulation the first computer language source code performs; and
inserting the tagged element in the second computer language source code.

20. The translation method according to claim 14 wherein the first computer language is Java and the second computer language is C++.

21. The computer language translating system according to claim 14 wherein the first computer language is Java and the second computer language is C♯.

22. The translation method according to claim 14 wherein the first computer language is C♯ and the second computer language is C++.

23. A computer language translating system for translating a Java source code to an OOP language source code, comprising:
a computer having a storage;
an emulation Application Programming Interface library having a table and accessible by said computer including data indicative of types of data manipulations between the Java source code and the OOP language source code, said table including OOP language equivalent functions callable by said OOP computer language;
an analyzer analyzing the Java source code to determine a type of data manipulation the Java source code performs, said analyzer accessing said table of said emulation library and correlating the type of data manipulation the Java source code performs to a OOP language equivalent function; and
a generator generating OOP language source code based on the identified equivalent functions such that OOP language source code emulates the type of data manipulation the Java source code performs;
said OOP language source code providing discreet functionality that is independent from the Java source code such that said generated OOP source code can independently provide the equivalent type of data manipulations provided in said Java source code without reference to Java source code.

24. The computer language translating system according to claim 23 wherein said analyzer analyzes the OOP language source code to determine a type of data manipulation the OOP language source code performs, said analyzer accessing said library to correlate the type of data manipulation the OOP language source code performs to Java source code, the correlation being independent of the context in which the OOP language source code is used, and said generator generates retranslated Java source code that emulates the type of data manipulation the OOP language source code performs.

25. The computer language translating system according to claim 23 wherein said analyzer builds class declarations and class definitions based on the type of data manipulation the Java source code performs and said generator generates OOP language source code based upon the class declarations and class definitions.

26. A method for translating a first OOP computer language source code that performs a data manipulation with a virtual machine to a second OOP computer language source code that performs a data manipulation without use of a virtual machine, comprising the steps of:
analyzing the first OOP computer language source code to determine a type of data manipulation the first OOP computer language source code performs;
referencing an emulation Application Programming Interface library including second OOP computer language equivalent functions that emulate the first OOP computer language data manipulations;
correlating the type of data manipulation of the first OOP computer language source code performs to a second OOP computer language equivalent function;
generating the second OOP computer language source code based on the identified equivalent functions such that the second OOP language source code emulates the type of data manipulation the first OOP computer language source code performs; and
the second OOP computer language referencing the Application Programming Interface library to perform a data manipulation with the second OOP computer language source code that emulates the type of data manipulation the first OOP computer language source code performs, the second OOP computer language source code performing the data manipulation without use of a virtual machine.

27. A method for translating a first OOP computer language source code that performs a data manipulation with a garbage collector to a second OOP computer language source code that performs a data manipulation without use of a garbage collector, comprising the steps of:
analyzing the first OOP computer language source code to determine a type of data manipulation the first OOP computer language source code performs;
referencing an emulation Application Programming Interface library including second OOP computer language equivalent functions that emulate the first OOP computer language data manipulations;
correlating the type of data manipulation of the first OOP computer language source code performs to a second OOP computer language equivalent function;
generating the second OOP computer language source code based on the identified equivalent functions such that the second OOP language source code emulates the type of data manipulation the first OOP computer language source code performs; and
the second OOP computer language referencing the Application Programming Interface library to perform a data manipulation with the second OOP computer language source code that emulates the type of data manipulation the first OOP computer language source code performs, the second OOP computer language source code performing the data manipulation without use of a garbage collector.