System and method for creating target byte code

A system and method for converting byte code of a first type into byte code of a second type. Byte code of a first type is received as input. The first byte code is converted into constituent byte code data elements that can comprise any logical unit or grouping of at least a portion of a software application. The first byte code data elements are mapped to data elements of a second byte code type. The second byte code data elements are assembled into a resulting second byte code.

BACKGROUND OF THE INVENTION

1. Technical Field

The present invention relates generally to computer code, and more specifically to a system and method for improved conversion of computer code to target computer byte code of a second type.

2. Description of the Related Art

Traditionally, most computer programs comprised machine-dependent, system-level instructions. A program would be written in a higher level language (source code), such as C or C++, and converted into machine instructions (object code) that could be executed by a computer processor. While the resulting object code could be executed very efficiently, source code compiled on one computer architecture (for example, the Microsoft Windows® operating system environment on an Intel Pentium® processor-based computer system) could not subsequently run on a different architecture (such as an Apple Macintosh® operating system environment on a PowerPC™ processor-based computer system) (WINDOWS is a registered trademark of Microsoft Corp., PENTIUM is a registered trademark of Intel Corp., MACINTOSH is a registered trademark of Apple Computer, Inc., and POWERPC is a trademark of International Business Machines Corp.). To properly execute a program on different computer architectures, programmers typically undertook steps to re-compile source code for each target architecture. Additionally, machine-specific differences often required significant revision to the program's source code in order to even enable recompilation for a different architecture.

A modern innovation to this traditional method of compiling source code into machine-level object code is to use intermediate byte languages and byte code interpreters. Byte code (also known as “bytecode” or “byte-code”) is a form of intermediate language that is typically more abstract than object code, but closer to machine language than a higher level language. Examples of languages that compile to byte code include Java™ from Sun Microsystems, Inc. and languages that target the Common Language Infrastructure (CLI) from Microsoft Corporation (JAVA is a trademark of Sun Microsystems, Inc.). A program that utilizes byte code is initially programmed in source code. The source code is then compiled into byte code. Compiled Java byte codes, for example, are typically in the form of “.class” or “.jar” files. The Common Language Infrastructure is an implementation of the Standard ECMA-335 specification. Source code written under the Common Language Infrastructure can be compiled to Common Intermediate Language (CIL) byte code. Common Intermediate Language byte code is typically packaged in a .Net Assembly, which can comprise Common Intermediate Language byte code, assembly metadata, type metadata and other resources. A .Net Assembly may be a standalone file or comprise multiple files. Metadata known as the assembly manifest describes how the elements in a given assembly relate to each other. Compiled byte code, whether standalone or contained in a larger package, can be interpreted by a byte code interpreter (also called a virtual machine) that translates the byte codes into machine level instructions. Examples of virtual machines include the Java Virtual Machine from Sun Microsystems and the Common Language Runtime (CLR), also called the Virtual Execution System, from Microsoft Corporation.

Thus, by way of example, a programmer using the Common Language Infrastructure can program an application in higher-level language such as Microsoft's C# or Visual Basic .Net and compile the program source code into Common Intermediate Language byte code and package it into a .Net Assembly. The resulting byte code can then be run in the CLR.

Typically, a virtual machine is available for different computer architectures. The virtual machine can take input from a program compiled in a standard byte code form and run the program on the native computer architecture in which the machine resides. Thus, in contrast to machine-specific object code, a byte code program can run in a virtual machine on any different architecture (that has a virtual machine) without a recompilation or reprogramming of the underlying source code. By way of example, a Java program compiled into byte code could run without modification in a virtual machine on both an Apple Macintosh computer and a Microsoft Windows computer.

During this same time, markup languages such as eXtensible Markup Language (XML) have gained popularity for their data description capabilities. Markup languages generally describe data and user interfaces as well as the details of the structure and appearance of both. Although most markup languages typically comprise ASCII text, markup language files may alternatively be serialized in a binary form, such as Microsoft's Binary extensible Application Markup Language (BAML). Markup languages such as HTML are well known for defining text and layout descriptions. Graphics markup languages such as the Scalable Vector Graphic (SVG) XML-based markup language can describe two-dimensional vector graphics. Scripting markup languages allow a programmer to add functional program code to markup language code that may then execute in a web server and dynamically output different markup language code. Exemplary scripting markup languages include Java Server Pages (JSP), Hypertext Preprocessor (PHP), Cold Fusion Markup Language (CFML) and Active Server Pages (ASP). For example, a programmer could create a web page comprised of mostly HTML tags and further including a CFML tag that inserted the current date and time every time the page was accessed. Upon access by a client web browser, the CFML code would execute and the web browser would receive an HTML page with the current date and time inserted as HTML data by the CFML code. Additionally, extensible languages such as XML allow programmers to define their own customized tags. This extensibility allows programmers to define, validate and interpret data exchanged between applications, even as the underlying data formats change over time.

When used in conjunction with functional programming language code, markup languages can be used inter alia to define the layout and appearance of objects in a program. For example, Microsoft's eXtensible Application Markup Language (XAML), an XML-based language, allows a programmer to define user interfaces and instantiate objects defined in Common Intermediate Language and contained in .Net Assembly packages. XAML and Common Intermediate Language code can be cross-referenced and executed by the Common Language Runtime. As an alternate example, XML User Interface Language (XUL) from the Mozilla Foundation is an XML-based language that can similarly describe the window layouts and user interfaces for modular software components written in languages including C, C++, and JavaScript using the Cross Platform Component Object Model (XPCOM) framework.

While byte code software applications, particularly when used in conjunction with markup language code, are quite useful and portable, one disadvantage of these approaches is that byte code of one type cannot be easily executed by a byte code interpreter of another type or converted efficiently to byte code of another type. Thus, although byte code may generally overcome machine-dependency, there is some level of dependency on a specific byte code interpreter application. Developers generally have to manually re-code applications for different byte code interpreters, which can be quite difficult in the case where source code is unavailable and only compiled byte code is on hand. Although some tools exist to disassemble compiled byte code into an assembly language or higher level language, a developer still has to port that source code to a different byte code language type in order to convert byte code of a first type into byte code of another type. In these respects, creation of target byte code according to the present invention substantially departs from the conventional concepts and designs of the prior art, and in doing so provides a system and method of byte code creation that is more flexible, robust and efficient than conventional byte code creation methods.

SUMMARY OF THE INVENTION

The present invention is directed toward a system and method for converting data of a first type into data of a second type. Preferably, in accordance with an embodiment of the present invention, byte code of a first type can be converted into byte code of a second type. An example environment in which this embodiment can be applied is a computer system. For example, in this environment, a developer can run a byte code conversion software application taking byte code of a first type as input and create byte code of a second type as output.

In accordance with one embodiment of the present invention, byte code of a first type is converted into byte code of a second type. Byte code can comprise an intermediate code format that is typically lower-level than source code, but typically more abstract and machine-independent than object code. In an exemplary embodiment, Common Intermediate Language byte code is converted into SWF byte code. In one optional embodiment, source code of a first type is developed against a development library that contains references to byte code instructions of a second type. Source code can be compiled to byte code of a first type, which can be further converted into byte code of a second type. An advantage of this aspect of the invention is that the source code portions that were developed against the development library should, for the most part, effectively map to data and instructions of byte code of a second type because the development library already contains first byte code to second byte code mappings.

In one embodiment of the invention, byte code of a first type is converted into byte code of a second type by transforming table structures in the first byte code into table structures in the second byte code. Table structures include tables, arrays and indexes. Table structures contain entries for one or more data elements of the first byte code that refer to class definitions, members, types, methods, local variables, metadata, and/or arguments in the first byte code. Multiple source byte code table structures for classes and types, can, for example, be combined into a single global type array. One aspect of the invention permits classes to be represented by index reference instead of conventional class names. Referencing classes, methods and types by index can reduce the memory size and increase lookup speed, resulting in smaller and faster byte code of a second type.

According to an alternate embodiment of the present invention, byte code of a first type is converted into an intermediate data structure. The intermediate data structure preserves and represents at least a portion of the semantics, syntax and metadata contained in the byte code of a first type. An intermediate data structure can be implemented, for example, as an abstract syntax tree or abstract semantic graph. According to an optional embodiment, an intermediate data structure may be created by disassembling byte code of a first type into an intermediate language format. Intermediate language format source code generally represents the lowest-level human-readable language that can be derived from the byte code and is typically in the form of ASCII text. For example, Common Intermediate Language compiled byte code can be disassembled into CIL Assembly Language source code (an intermediate language format). The intermediate language source code can then be parsed into an intermediate data structure. Other byte code languages that can be converted or created include JAVA application or SHOCKWAVE FLASH (“SWF”). According to an alternative embodiment, higher-level source code can be converted directly into an intermediate data structure without first converting the source code into byte code. Exemplary higher-level source code languages include any of the Common Language infrastructure languages, and the JAVA and ActionScript programming languages. Such an embodiment is advantageous when the higher-level source code language cannot natively be compiled into the target byte code format. An intermediate data structure generated from any of these embodiments, as well as alternate embodiments, can be converted into byte code of a second type.

In accordance with an embodiment of the invention, byte code of a first type is converted into one or more constituent data elements of a first byte code type. The data elements of a first type can be mapped to one or more data elements of a second type. For example, Common Intermediate language opcode data elements can be mapped to SWF action tag data elements. Where a direct mapping of first to second byte code language formats is not possible or desired, one or more second byte code data elements can be combined and mapped in order to mimic the layout or functionality of the first byte code data element. The mapped data elements of a second type can be assembled into byte code of a second type. Data elements can include any logical unit or grouping that comprises at least a portion of a software application. Data elements may include, for example, objects, instructions, metadata, variables, classes, functions, methods, or groupings thereof. Optionally, data elements may comprise remote “stub” functions, which contain instructions to remotely connect to a network resource. For example, remote data elements may execute a method on a network resource not available in the byte code of a second type, or may connect to information stores like a relational database for information. Optionally, byte code of a first type may be converted into an intermediate data structure, as described above. The intermediate data structure may then be parsed into data elements of a first type. According to another aspect of the invention, the step of mapping data elements of a first type to data elements of a second type may reference one or more mapping libraries. A mapping library can contain instructions for mapping specific data elements of a first type to one or more data elements of a second type. A mapping library may comprise data structures such as hash tables, lookup tables, and/or arrays to facilitate efficient lookup and mapping of data elements.

According to an aspect of the invention, bridging byte code of a second type may be inserted into byte code of a second type. During the data element mapping step, it is possible that not all of the data elements of a first type can be successfully matched and mapped to data elements of a second type. In this case, an embodiment of the present invention can insert additional byte code of a second type to replace or substitute missing data or functionality. The bridging byte code may be inserted automatically in response to the data element mapping process, according to one embodiment of the present invention. In an alternative embodiment, a developer or external software application may insert bridging byte code into byte code of a second type.

In one exemplary embodiment of the invention, Common Intermediate Language byte code is converted into constituent data elements. Common Intermediate Language data elements can include, for example, namespaces, types, attributes and members. These exemplary data element types can be discerned into further sub-categories of Common Intermediate data element types. Common Intermediate Language data elements can be mapped through various and alternative mapping steps to SWF data elements. The resulting SWF data elements can include SWF tags, records, action tags, and combinations thereof. SWF byte code can be created from one or more SWF data elements.

In one embodiment of the present invention, target byte code of a second type is transmitted across a network. The network can optionally comprise a peer-to-peer, server-client or other network topology.

According to a further aspect of the invention, source byte code may be transformed into one or more byte code components of a second type. When a user requests byte code of a second type, the computer can return target second byte code by creating new byte code components and/or reusing existing byte code components, and assembling all of the necessary components into byte code of a second type. The second byte code components can be replaced individually to form new second byte code without requiring download or creation of all portions of the new second byte code.

In another embodiment of the present invention, an application plug-in performs the process of converting byte code of a first type into byte code of a second type. An application plug-in for byte code conversion may be used by applications including web servers, web browsers, media servers, and graphics applications. In another embodiment, an integrated development environment can utilize plug-ins or other computer instructions to perform byte code conversion. A developer can program source code, compile the source code to a first byte code, and test the first byte code software application. After the developer has sufficiently tested the first byte code application, the first byte code can be transformed into a second byte code by a byte code converter within the integrated development environment. The second byte code can be further tested by, for example, executing and displaying the second byte code in a display window of the integrated development environment, or executing the second byte code in a debugging environment. The byte code conversion process can seamlessly be inserted into the integrated development environment to allow a developer to easily develop in a programming language and development environment of a first type and produce byte code of a second type.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

The present invention is directed toward a system and method for converting data of a first type into data of a second type. More specifically, according to one embodiment of the invention, a byte code converter is provided for a computer system, allowing a user or program to convert byte code of a first type and related markup language into byte code of a second, different type.

For example, according to one embodiment of the invention, byte code files and markup language files that contain references to data and objects in the compiled byte code are received. At least a portion of the compiled byte code is converted into one or more intermediate data structures. At least a portion of the markup language files are similarly converted into one or more object graph structures. The byte code converter can parse and examine these intermediate structures created from the original byte code and markup language, and map data elements from both to new byte code data elements of a different target type. As a result of the byte code conversion process, a new target byte code file can be produced. Various alternative methods can be used to convert byte code and markup language into intermediate data forms, as well as convert both the original byte code and markup language into target byte code of different types.

FIG. 1illustrates an exemplary computer hardware environment in which the present invention can be implemented. In this exemplary environment, a computer system102is comprised of one or more processors104connected to one or more electronic storage devices116, such as hard disks, floppy disks, tape, CD-ROMs and other magnetic, optical, or other computer-accessible storage devices. Typically, one or more software applications120,122, or124are loaded by a processor104from a storage device116into memory118, which is typically RAM, SRAM, or other computer-accessible memory device. The processor104can execute a software application120,122, or124by executing instructions stored in the software application120,122, or124. Software applications can include executable programs such as a byte code interpreter122or a byte code converter software application124which performs at least a portion of instructions and processes in accordance with embodiments of the present invention. Input/output devices106, such as graphic cards108, keyboards112, mice114, disk controllers, network cards, or other computer-operable input/output devices may be included in the computer system. Input/output devices106may be used to relay signals and data during execution of a software application120,122, or124to and from the computer system102to peripheral devices such as external storage devices or other computers outside the computer system102. Input/output devices106such as network cards may be used to connect to networks such as Local Area Networks (LANs), Wide Area Networks (WANs) or the internet. Typically, an input/output device106such as a graphic card108is used to connect a monitor110to the computer system102, so that graphical and textual output from the execution of software applications120,122, or124may be viewed by a computer user.

Conventional software applications120can be stored as object code and comprise machine-specific instructions, which can be executed by a processor104on a specific computer system102. For example, an object code software application120written for a computer system102with an Intel Pentium processor104and the Microsoft Windows operating system typically could not be executed by a different computer system102with a PowerPC G5 processor104and the Apple Macintosh operating system.

One approach to overcome this machine-specific dependency utilizes byte code. Byte code can be created by first programming a software application source code in a higher level language such as JAVA, C#, J#, or Visual Basic .Net. Source code is typically compiled into byte code. Byte code is an intermediate form of code that is created by reducing higher level source code commands into very basic language instructions. Nonetheless, byte code is more abstract than object code, contains additional metadata such as namespaces and classes, and most notably is generally not comprised of machine-specific instructions. Software applications in byte code form can be executed by a byte code interpreter122.

A byte code interpreter122(also called a virtual machine) parses byte code files and translates the byte code operations into machine-specific instructions for a given computer system102. The byte code interpreter122itself is typically stored and executed as object code, similar to a conventional software application120. Thus, a separate byte code interpreter122must be created for each different computer system102architecture. The advantage to such a system is that software applications in byte code can then be executed without substantial modification on a byte code interpreter122for many different types of computer systems102. Accordingly, byte code is much more portable than object code across computer systems102. Thus, by way of example, because JAVA byte code interpreter applications122exist for both the Apple Macintosh and Microsoft Windows operating system environments, JAVA byte code that runs on an APPLE MACINTOSH JAVA byte code interpreter122should also run unmodified on a MICROSOFT WINDOWS JAVA byte code interpreter122.

Although byte code software applications can contain all of the operations and instructions used to execute a full program in a byte code interpreter122, other types of code can be used in conjunction with byte code files to provide a more extensible development environment. Byte code files can be used in conjunction with markup language files, where the markup language interacts with the byte code files to define user interface elements in a program. “Markup language” refers generally to types of languages that encode text to represent text, data and interfaces, as well as details of the structure and appearance of the text, data and/or interfaces. Examples of markup languages include SGML, HTML, XML, as well as any derived or related languages. For example, XUL and XAML are both XML-based markup languages. Markup languages may also be sub- or super-sets of other markup languages. For example, HTML is a subset of XML, which in turn is a subset of SGML.

In the present exemplary environment, the functional aspects and object definitions of a program can be written in a higher level language and compiled to intermediate byte codes. Markup languages can instantiate objects and data elements from the intermediate byte code, as well as define a user interface for the program. A byte code interpreter122can take both the byte code and markup language files and execute a program using the functional aspects of the byte code and display aspects of the markup language code.

The present invention is described in terms of this example environment. Description in these terms is provided for convenience only. It is not intended that the invention be limited to application in this example environment. Although particular computer systems and components are shown, those of ordinary skill in the art will appreciate that the present invention also works with a variety of other computers and components. Moreover, after reading the following description, it will become apparent to a person of ordinary skill in the relevant art how to implement the invention in alternative environments.

Although byte code is portable from a byte code interpreter on one computer architecture to a byte code interpreter on another, byte code of one type is conventionally not compatible with a byte code interpreter of another type. For example, a JAVA class file (compiled byte code) will run on its native runtime environment, the JAVA Virtual Machine (a byte code interpreter). However, a JAVA class file will not run without modification on the Macromedia Flash® Player (a different byte code interpreter) (FLASH is a registered trademark of Macromedia, Inc.).

Some systems allow a number of different source code files in different programming languages to compile to a single byte code file or set of related byte code files that run on a specific byte code interpreter. For example, the Common Language Infrastructure used in .Net allows software development in a set of higher-level source languages, such as Visual Basic .Net, Visual C++ .Net, C# and J#. Source code in any of these languages can then be compiled into Common Intermediate Language byte code that will run on a specific runtime environment, the Common Language Runtime (a byte code interpreter). Other examples of source code languages include the JAVA programming language, which compiles to JAVA byte code and the Flash programming language, which compiles to SWF byte code. However, even in these systems, once compiled byte code is created the byte code is still tied to a specific byte code interpreter. Thus, similar to a JAVA class file, Common Intermediate Language byte code will not run on the Flash Player.

Currently, programmers may use “disassembler” programs to, in some cases, convert portions of byte code into more easily understood source code. Disassembled source code can be used in porting and reprogramming the code to a target byte code of a different type. However, such methods that presently exist are cumbersome and require significant additional programming to create a byte code of a different type. What is needed is a means of converting byte code of one type into byte code of another type, so that byte code programs can not only run on a variety of different computer system architectures, but run on a variety of different byte code interpreters as well.

FIG. 2is an operational flow diagram illustrating a method of converting byte code of a first type into byte code of a second type, according to one embodiment of the present invention. Referring now toFIG. 2, byte code files of one type202are converted in a transformation step204into byte code files of a different type206. In an exemplary embodiment, Common Intermediate Language byte code202contained in a .Net Assembly is converted in a transformation step204into a SWF byte code file206, wherein at least some of the objects, data, functions and structures of the byte code and metadata in the .Net Assembly are converted into SWF data elements, typically called “tags.” SWF is a tag-based file format displayed using the Flash Player. SWF tags can generate or reference vector graphics, animations, display information and other functionality during execution by the Flash Player. The set of SWF data elements can comprise types, tags, records and actions which in embodiments in accordance with the present invention can represent objects, data and structures from Common Intermediate Language byte code files202within a .Net Assembly. In alternate exemplary embodiments, compiled Java byte code202is converted into SWF byte code206or Common Intermediate Language byte code206. Several additional methods of converting byte code of a first type into byte code of a second type will be explained in more detail below, and will become apparent to one of ordinary skill in the art from this description.

FIG. 3is an operational flow diagram illustrating a method in accordance with one embodiment of the present invention of developing source code of a first type302with references to development libraries of a second type304and producing byte code of a first type202. As previously explained, source code302is typically compiled in a compiling step308into byte code202. Exemplary source code languages include Java, Flash, or any Common Language Infrastructure language. It should be further noted that although Microsoft's implementation of the Common Language Infrastructure is detailed herein, methods and aspects in accordance with the present invention would similarly apply to any other implementation of a Common Language Infrastructure according to the ECMA-335 specification. Development libraries306provide data structures, instructions and subroutines in a source code language of a first type that are already known to be capable of conversion to byte code of a second type. A developer programming source code302with references306to data, types and functions in development libraries306can create a first byte code202that should substantially map to a second byte code202for each data structure, type or function reference built on top of the development libraries304. Although the development libraries304are not required for other embodiments of the present invention, they are useful tools when the target second byte code type is known at development time.

Referring again toFIG. 2, in one embodiment of the present invention, the byte code transformation step204is performed by referencing table structures within the source byte code202. Many forms of byte code202,206, such as CIL byte code202,206, contain data such as class definitions and types that can be stored in table structures, such as tables, arrays or indexes. One or more table structures in the first byte code202can be mapped to one or more table or array structures in the second byte code206. The mapping of data elements from a first byte code202to data elements from a second byte code206is described in more detail below and illustrated inFIGS. 7-9. In one configuration, the second byte code206table structure can be substantially similar to that in the first byte code202. In an alternate configuration, the second byte code206table structure can be different than that in the first byte code202. For example, CIL source byte code files202can contain multiple tables for data elements such as methods, types and classes. In a transformation step204, the data in the multiple tables from the CIL source byte code202can be stored in rows or “slots” within a single global type array in a target SWF byte code file206. Even different types of rows from multiple tables in CIL source byte code202can be stored in a single heterogeneous table in SWF target byte code206. Thus, instead of reflecting the multiple table structure of the source CIL byte code202, the resulting SWF byte code206hones down all class and type references to a single array, or lesser number of arrays. In another example, JAVA source byte code202can contain multiple table structures for classes in different JAVA class files. Similarly, these table structures can be pared down to less tables upon conversion to a byte code of a second type206. By using fewer table structures than the source byte code202, the target byte code206can be smaller in size and data and objects are more quickly located within a single or limited number of tables, instead of constantly cross-referencing a great number of tables. Moreover, in one configuration, data and objects unused by the target byte code206can be omitted from the destination byte code206table structure.

Additionally, instantiated objects in many byte code languages, such as those compiled from ECMA scripting languages like ActionScript, JavaScript, or JScript can also be referenced as arrays/tables. Thus, one or more global table structures according to the invention can reference instantiated object methods in array notation, such as “object[23]( )” instead of a name-based lookup, such as “object.MethodCall( )”. Additionally, in one exemplary embodiment according to the invention, metadata for an object in source byte code202such as the visibility of types and members (private, public, etc.) and custom defined attributes can be stored in an array for the corresponding object in the target byte code206. The metadata can similarly be referenced by index to the metadata array, and external references to elements of the metadata array can be stored in a global table structure.

In a further configuration, numerical indexes in the destination table structure can be referenced for types and classes in the target byte code206. Conventionally, data and objects such as classes, members, types, local variables and arguments are stored as string literals in byte code202,206and then looked up at execution time. Conventional systems create additional byte code for each different class, increasing the amount of memory used for storage and the amount of data that must be parsed for lookups. Moreover, if a class namespace comprises multiple sub-classes, such as “My.Long.Namespace”, then a lookup for the type information of the class must execute individual computer instructions for “My”, “Long”, “Namespace” and “Type”. By contrast, if the type information “My.Long.Namespace.Type” was stored in an array index, such as “223”, then only one instruction to array address “223” would be required for the same type lookup. The present embodiment according to the present invention can replace these inefficient string lookups with a fast index or offset lookup for the data or object. Another advantage of the present embodiment is that method and constructor overloading instructions in the source byte code202can be converted into a more efficient implementation in the target byte code206. Conventionally, overloaded methods and constructors programmed in object-oriented languages require inefficient namespace lookups up the chain of parent objects to find the computer instructions and data to execute the method or constructor. In the present embodiment according to the invention, overloaded methods and constructors simply occupy a different array index than the parent method or constructor, allowing a single lookup instruction to find the method or constructor.

Additionally, because data elements such as class members and variables can be stored in, for example, a single table, operations or methods performed on multiple data elements can often be performed in a single table operation, as opposed to individual byte code instructions. For example, if CIL source byte code202contained instructions to set twenty variables to zero upon execution, the conversion process could create SWF target byte code206containing a table structure further containing all twenty variables. Instead of executing multiple byte code instructions to set each variable to zero, the SWF target byte code206could contain one byte code instruction to set the twenty rows in the table structure representing the variables all to zero in a single table loop operation.

In another embodiment of the present invention, identifying strings such as class names can be removed because an index is used for all data elements and objects. Class names in byte code can be used to discover portions of the structure and functionality of the instructions in byte code files202,206. Removing such strings allows the target byte code206to be obfuscated, making it more difficult for end users to decompile, disassemble or reverse engineer.

An alternate embodiment according to the invention to the table/array conversion method is illustrated inFIG. 4.FIG. 4is an operational flow diagram illustrating one method in accordance with the present invention of converting byte code of a first type202into an intermediate data structure406, which is then converted into byte code of a second type206. In one embodiment, byte code files of a first type202are received by a byte code parser402and converted in a converting step404into an intermediate data structure406. Alternately, in another embodiment according to the present invention, source code files of a first type can be compiled directly into an intermediate data structure. The intermediate data structure406in these embodiments preserves and represents at least a portion of the semantics, syntax and metadata contained in a compiled byte code202in an organized structure. An intermediate data structure406can be implemented as a graph data structure, such as an abstract syntax tree or abstract semantic graph. Examples of intermediate data structures406formed as graph data structures include implementations of the Document Object Model (DOM) from the World Wide Web Consortium (W3C) in languages such as XML or HTML. In a converting step408, the intermediate data structure406is converted into byte code of a second type206. In the embodiment illustrated inFIG. 4, the converting step408is carried out by a byte code parser402that reads the byte code files202directly and parses out the data elements into an intermediate data structure406. Further details and alternative embodiments of the conversion from intermediate data structure406to byte code206are provided below.

One method of creating an intermediate data structure406is illustrated inFIG. 5.FIG. 5is an operational flow diagram illustrating a method in accordance with one embodiment of the invention of disassembling byte code files202into an intermediate language format506, which is parsed to produce an intermediate data structure406. Byte code files202are typically in binary format, and thus are not easily read by human programmers or software applications, aside from byte code interpreters. However, byte code files202can be changed into an intermediate language format506, which generally comprises a much more comprehensible and structured format than pure byte code. The phrase “intermediate language format” generally refers to the lowest-level human-readable language that can be derived from a byte code file202(typically intermediate language source code) and includes code in ASCII text format. Compiled byte code202can often be changed to and from intermediate language source code506. For example, the Common Language Infrastructure allows source code in higher-level languages to be compiled into Common Intermediate Language, which contains representations of the Common Language Infrastructure processing instructions as defined by ECMA-335 specification. Common Intermediate Language byte code can take digital forms including a source representation known as CIL Assembly Language and a binary representation as byte codes. CIL Assembly Language is one example of an intermediate language format506according to aspects of the present invention and it textually represents the data and functionality in .Net Assembly and Common Intermediate Language byte code. As implied by the “Common” in Common Intermediate Language, analogous programs written in different higher-level languages should compile to fairly similar Common Intermediate Language byte code. Common Intermediate Language is an object-oriented language and has a stack-based structure. Common Intermediate Language byte code is typically packaged in a .Net Assembly file. Both Common Intermediate Language binary byte code and .Net Assemblies can be assembled from, as well as disassembled into, constituent CIL Assembly Language source code.

Byte code files202can be converted into intermediate language files506in a disassembly step504. In one embodiment according to the invention, byte code files202can be disassembled by a byte code disassembler502into intermediate language formats506. Intermediate language source files506are examined in a parsing step510for structure and content that is used to create an intermediate data structure406that preserves the syntax and attributes of the underlying compiled byte code202and intermediate language source code506. In a preferred embodiment, the parsing step510can be carried out by an intermediate language parser508, which is a software application that can read intermediate language source code506and produce an intermediate data structure406. The resulting intermediate data structure406is then converted to byte code206as explained previously and detailed further below.

An alternative method of creating an intermediate data structure406is shown inFIG. 6.FIG. 6is an operational flow diagram illustrating a method in accordance with the present invention of converting higher-level source code files302into an intermediate data structure406. The phrase “source code” refers to computer programs or instructions written in a human-readable language format that, in some cases, loosely resembles human spoken language. Source code files302are typically composed of ASCII text and are often compiled into machine-specific or intermediate code formats to actually execute as programs. Higher-level source code302is typically compiled into byte code of a corresponding (or “native”) type. For example, JAVA source code is natively compiled by the JAVA Compiler into JAVA byte code. Some development frameworks also allow multiple source languages to be natively compiled to a single type of byte code. For example, as described previously, any source code language within the Common Language Infrastructure can be compiled into Common Intermediate Language byte code. In contrast to these approaches, as shown inFIG. 6, a source code compiler602can compile source code files302directly into an intermediate data structure406in a compiling step604without converting the source code302into byte code of a corresponding type. For example, source code written in C#programming language could be compiled directly into an abstract syntax tree without ever directly converting the code to Common Intermediate Language byte code or packaged code in a .Net Assembly.

One method of converting byte code of a first type202into byte code of a second type206is explored in further detail inFIG. 7.FIG. 7is an operational flow diagram illustrating a method in accordance with one embodiment of the present invention of mapping data elements706a-cfrom a first byte code202to data elements710a-cof a second byte code206. Byte code files202are converted into data elements706a-cin a converting step702. As used herein, the phrase “data element” refers to any logical unit or grouping that comprises a part or portion of a software application. For instance, data elements706a-c,710a-ccan include any objects, instructions, metadata, variables, type definitions, classes, functions, or groupings thereof, within a computer program. Sources such as byte code202,206and markup language code may be comprised of one or more data elements. As an example, the data elements706a-cof Common Intermediate Language byte code202include namespaces, types, members, fields, constants, events, properties, indexers, methods, constructors and Common Intermediate Language opcodes. Moreover, each instance and type of Common Intermediate Language opcode could comprise individual data elements706a-cfor the purpose of mapping. In a mapping step704, byte code of a first type202is parsed into its constituent data elements706a-c. At least a portion of data elements of a first type706a-ccan be mapped to data elements of a second type710a-c. For example, a data element comprising an instruction to create an object in Common Intermediate Language byte code in a .Net Assembly could be mapped to an instruction to create a substantially equivalent object in SWF byte code. Using the results of the mapping step704, data elements of a second type710a-ccan be assembled into the resulting byte code of a second type206in a converting step712.

Exploring the data element mapping step704in further detail, mapping step704is carried out in one embodiment in accordance with the present invention by referencing byte code mapping libraries708. The byte code mapping libraries708can contain computer instructions or subprograms that take as input a data element of a first byte code type706a-c, determine if any mapping exists from the data element of a first type706a-cto one or more data elements of a second type710a-c, and return information indicating appropriate data elements of a second type710a-cor a status message indicating that no mapping was found. In one embodiment of the invention, a byte code mapping library708for mapping Common Intermediate Language data elements to SWF data elements could, for example, map the Common Intermediate Language opcodes to the SWF actions and return information indicating the designated SWF action.

The byte code mapping libraries708can be implemented, for example, as statically linked, dynamically linked, or remote libraries. The byte code mapping libraries708may comprise one or more reference data structures to facilitate the process of matching data elements of a first type706a-cto data elements of a second type710a-c, including for example, structures such as lookup tables, hash tables, associative arrays or arrays. In one preferred embodiment in accordance with the present invention, the byte code mapping libraries708contain a lookup table. The lookup table in this embodiment can index input values of data elements of a first type706a-cto stored return values of data elements of a second type710a-c. By using a data structure such as a lookup table, one of ordinary skill in the art could increase the speed and efficiency with which the data element mapping step704is carried out.

When converting between byte code202,206based in similar languages, such as C# and Java, the data elements706a-c,710a-cbetween the source byte code202and target byte code206should substantially map in nearly a 1:1 ratio. Thus, the data element mapping process can be relatively straightforward to perform for languages that contain analogous objects, classes, members, types and other data elements. A more difficult situation is presented when the source and target languages differ substantially in available data elements706a-c,710a-c. For example, as described below in more detail and illustrated inFIGS. 8aand8bandFIGS. 9aand9b, heterogeneous byte code source languages, like .Net and SWF, often lack single, analogous data elements706a-c,710a-cbetween the two languages. Thus, in the case of heterogeneous byte code conversion, the data element mapping step704can map a first data element706a-cto a second data element710a-cthat has been created to mimic an analogous data element in the destination byte code language or format. For example, if a first data element706a-chas no direct matching data element710a-cin the destination language, then one or more second data elements710a-c(such as methods, types, etc.) can be assembled to mimic the behavior or appearance of the first data element706a-c. For example, a source CIL method call data element706a-ccould be mapped to one or more destination SWF stack instruction data elements710a-c. In this case, the data elements aren't exactly analogous, but both exhibit the same functionality. Alternately, first data elements706a-cmay be mapped to remote second data elements710a-c, eliminating the need for analogous specific second data elements710a-cto map to, as described in further detail below and illustrated inFIGS. 21 and 22. Additionally, some first data elements706a-cmay not be necessary in the target byte code206, and can safely be ignored in the mapping step704. For example, a source CIL byte code202may contain a data element706a-cthat is a byte code instruction for a string conversion method. When converting to a target SWF byte code206, the data element mapping step704can be configured to ignore the string conversion data element706a-cbecause the SWF language and byte code interpreter automatically converts any data used as a string to a string format.

With further reference toFIG. 7, additional embodiments in accordance with the present invention can aid the conversion step712by inserting bridging byte code of a second type714. As previously described, not all byte code languages will have data elements that entirely match up to data elements of other languages. Moreover, during the mapping step704, it might not always be possible to map a first data element706a-cto a contrived second data element710a-c, internally comprised of two or more second data elements710a-c. In such a case, the computer-implemented process carrying out the data element mapping704and/or the second byte code conversion712could abort the byte code conversion operation. Alternately, the process may just ignore the data elements of a first type706a-cthat could not be mapped and assemble a second byte code206from the collection of second data elements710a-cthat were successfully mapped. However, the resulting second byte code206from the latter exemplary scenario could potentially lack portions of data and/or functionality from the first byte code202due to the ignored data elements706a-c.

One solution to such a scenario is found in embodiments of the present invention that insert bridging byte code of a second type714into the second byte code206in an inserting step716. In one embodiment according to the present invention, in the case that not all first data elements706a-care mapped to second data elements710a-cduring the mapping step704, bridging byte code714is generated automatically by a computer-implemented process in response. The process that automatically inserts bridging byte code714could be part of the same software application or applications performing the byte code conversion process, or the process could be embodied in an external software application. For example, in the case that not all first data elements706a-care mapped, an external software application could be called to examine unmapped first data elements706a-cor the resulting second byte code206. A bridging second byte code714could be created in response to enhance the functionality of the second byte code206and/or compensate for lost data or functionality in the second byte code206. The generated bridging byte code of a second type714is inserted into said second byte code206in an inserting step716.

In an alternate embodiment of the present invention, custom bridging byte code714could be inserted by an external computer program or by a programmer. In this embodiment, for example, a computer programmer familiar with the first byte code202could examine the second byte code206and discover any data or functionality lost in one or more of the conversion steps702,704,712. The programmer could then program and compile custom bridging byte code of a second type714and insert this code into the target byte code206. Thus, the optional step of inserting bridging byte code716can enable embodiments of the present invention to overcome inherent structural differences between different byte code languages and may permit developers more control than they would otherwise have over the conversion process.

In addition, a base set of bridging byte code714can be inserted to provide additional functionality to the target byte code206. Even in the scenario where all data elements706a-c,710a-chave been successfully mapped, ignored or substituted, additional functionality not present in the first byte code202may be desired for the second byte code206. For example, if it was desirable to have an added information dialog window available in all target byte code206for a given software application, bridging byte code714containing byte code instructions for a dialog window could be inserted, even if the original source byte code202contained no such dialog window.

With reference toFIGS. 4 and 7, an intermediate data structure406may be used in embodiments in accordance with the present invention to facilitate the step704of mapping data elements of a first type706a-cto data elements of a second type710a-c. As previously described, at least a portion of byte code of a first type202is parsed in a parsing step402into an intermediate data structure406. Portions of the graph data structure comprising the intermediate data structure406may be further processed into data elements of a first type706a-c. Because exemplary intermediate data structures406typically have a graph or hierarchical object structure, each object within the intermediate data structure406is a logical unit of data and the relationships between objects facilitates grouping families of objects. Accordingly, these logical units and/or groupings of objects in an intermediate data structure406facilitate converting step702by presenting the underlying data of a first byte code202in a discernible and differentiable structure that may more easily be parsed. The resulting data elements706a-ccan be mapped to data elements of a second type710a-cand assembled into byte code of a second type206, as previously described. For example, Common Intermediate Language byte code files202could be parsed along with other files in a .Net Assembly into an XML DOM intermediate data structure406, wherein XML tags represent at least some of the semantics, syntax and structure of the .Net Assembly. Each XML tag or hierarchical group of tags in the XML DOM intermediate data structure406could be processed, from which some or all could be mapped to SWF action or tag byte code instructions and assembled into a SWF byte code file206.

Yet another embodiment according to the present invention that addresses complexities during a mapping step is presented inFIG. 21.FIG. 21is an operational flow diagram illustrating a method in accordance with one embodiment of the present invention of mapping data elements706a-bto data elements2102and2104of a second byte code206. Byte code files of a first type202are converted to data elements of a first type in a converting step702. Similar to the method illustrated inFIG. 7, data elements of a first type706aand706bare mapped to data elements2102and2104of a second type in a mapping step2110. However, a mapping step2110can map at least a portion of data elements of a first type706ato local second data elements2102. Local data elements2102include data elements, functionality, objects or information that are natively included in a destination byte code language. For example, if a first byte code202comprising Common Intermediate Language byte code included a data element706acomprising the stack “push” operation, the data element706acould be mapped to a local data element2102in SWF which similarly comprises a “push” operation. The “push” operation is natively included in the SWF byte code language. A mapping step2110can also map at least a portion of first data elements706bto remote data elements of a second type2104. Remote data elements2104include data elements, functionality, objects or information that are not natively included in a destination byte code language, but may be available from network resource. For example, if a first byte code202comprising Common Intermediate language byte code included a data element706bcomprising a regular expression operation, the data element706bcould be mapped to a remote second data element2104in SWF in the case that the SWF language did not natively implement regular expressions. The remote second data element2104could contain SWF instructions for connecting to one or more network resources to access regular expression functionality. Like the embodiment illustrated inFIG. 7, a byte code mapping library708can be used to map first data elements706a-bto local and remote data elements2102and2104, respectively. The byte code mapping library708ofFIG. 7can further contain instructions indicating whether a given data element706a-bshould be converted to a local or remote data element. Turning back toFIG. 21, external data or information can optionally or additionally be used to determine whether a local or remote data element of a second type is appropriate during the mapping step2110. Optionally, external data can include data or information stored in an entirely separate file. Or, external data could, for example, include data or information that is part of the same greater file containing both the external data and first byte code202. For example, metadata contained in a .Net Assembly comprising Common Intermediate Language byte code could be used, in part or in whole, to determine whether a given Common Intermediate Language data element706a-bshould be mapped to one or more local or remote SWF data elements2102and2104. In step712, local and remote data elements of a second type2102and2104are assembled into byte code of a second type206. The second byte code206contains both local functions2106and remote functions2108. Local functions2106can include functions, methods, or operations that are native to the second byte code language. Remote functions2108can include functions, methods, or operations that are not native to the second byte code language. Remote functions2108can act as stubs or proxies to connect to one or more network resources that can execute the desired function and then return the result to the calling second byte code206at runtime.

One method of invoking a remote function in transformed second byte code is illustrated inFIG. 22.FIG. 22is diagram of a computer2202comprising a computer system102containing a second byte code206according to one embodiment of the present invention. The second byte code206can contain both local functions2106and/or remote functions2108created as described above forFIG. 21. Returning toFIG. 22, when local functions2106are called from the second byte code206, the functions can be executed natively in a second byte code language on the computer system102. When remote functions2108are called from the second byte code206, the functions can connect to one or more computers2206a-band2210across a network2204to execute a function on that computer. Examples of a network2204can include LANs, WANs or the internet, and topology of the network2204can include client-server, peer-to-peer or other network configurations as would be apparent to one of skill in the art. Remote functions can connect to one or more server computers2206a-b, as well as other types of computers, including workstations2210, laptops and other peer computers. Once a remote function has connected to a computer2206a-b,2210, the computer2206a-b,2210can perform a requested function or operation, retrieve data or invoke other computer processes. The computer2206a-b,2210can then optionally return a response to the remote function2108. Continuing a previous exemplary scenario, if a converted SWF byte code application206contains a remote function2108for a regular expression operation, the remote function2108can connect to a server2206athat implements the desired regular expression operation in Common Intermediate Language (the original source byte code language), or any additional compiled or byte code language which implements the desired functionality. The server2206acan then optionally return a response, such as text that matched the sought regular expression, to the calling SWF remote function2108. One advantage of utilizing both local and remote data elements and constituent functions, as illustrated inFIGS. 21 and 22, is that missing functionality or data from the transformation process can be substituted with analogous remote functionality, which can allow the target second byte code to behave in a similar fashion to a fully native application comprising a second byte code.

It should be noted that the embodiment according to the present invention illustrated inFIG. 22is not limited in application to those scenarios where a first byte code cannot completely map to a second byte code. Additional scenarios where it may be desirable to map data elements of a first type to remote data types of a second type2108include situations where sensitive data or information should not be present in a local byte code file206. For example, if a first byte code contains a database connection function, the username and password may be stored in the first byte code and retrievable by skilled computer programmers. One embodiment according to the present invention could take data elements of a first type containing such sensitive database information and map the data elements to remote data elements of a second byte code type. For example, in the case that a second byte code206executes a database call, a remote data function2108can connect to a remote server2206b. The remote server2206bcan securely store the database username and password, and use it to retrieve data from the database2208directly. The remote server2206bcan return the database results to the remote function2108without the second byte code206ever storing the database username and password. Thus, another useful aspect of the present invention is the ability to keep sensitive information away from target byte code applications206that can potentially be compromised.

FIGS. 8aand8b, together, further illustrate the data element mapping step802in accordance with one embodiment of the present invention. In the mapping step802, an exemplary Common Intermediate Language data element804is mapped to a SWF data element858. The mapping step802can optionally reference mapping instructions contained in a byte code mapping library806as described previously. Or, alternately, the mapping step802can be carried out with instructions and functionality in the native software application carrying out the mapping step802.

Common Intermediate Language data elements804can be broken down into several sub-types including, for example, namespaces808, types810, attributes812, and members814. Namespaces808serve as a means of partitioning types within a .Net Assembly by preserving unique names and may be preserved or shortened to SWF namespace data elements858in a mapping step838. Common Intermediate Language types810include classes816, enumerations818, interfaces820and delegates822. Common Intermediate Language classes816comprise a namespace808, a name and zero or more members814. Classes816can map to SWF object and/or function data elements858in a mapping step840. Enumerations818associate names with integer values and may be mapped to SWF integer or object data elements858in a mapping step842. Interfaces820define properties and methods to be implemented by classes816. Interfaces820can match overloaded names on classes816that implement given interfaces820in a matching step843. Delegates822define signatures for callback functions. In mapping step844, delegates822map to SWF code that simulates Common Intermediate Language delegates822using various combinations of SWF actions, tags, and/or records.

Members814comprise fields824, constants826, events828, properties830, indexers832, methods834and constructors836. Fields824have names, hold values and can be mapped to SWF object property data elements858in a mapping step848. Constants826represent immutable values such as the number Pi or a string constant. Constants826may be inserted as inline data elements858into SWF byte code or mapped to SWF object property data elements858during a mapping step850. Events828are capable of firing one or more delegates822when a state change occurs within a class and may be mapped to SWF event methods during a mapping step852. Programmer-defined events can be mapped to one or more additional SWF Methods to simulate added event behavior. Properties830are a special type of Common Intermediate Language methods834that allow a developer to read and set states associated with a Common Intermediate Language object. Indexers832are a special type of property830in which parameters may be passed. Properties830and indexers832may be mapped to SWF object methods and SWF action data elements858during a mapping step854.

Methods834have a name and zero or more parameters and contain instructions in the form of CIL opcodes. Constructors836are a special type of method834that are called when a new object is instantiated. Methods834and constructors836are mapped to SWF action data elements858in a mapping step856.

Mapping step856is explored in further detail inFIGS. 9aand9b.FIGS. 9aand9b, together, illustrate an operational flow diagram in accordance with one embodiment of the present invention illustrating the mapping of Common Intermediate Language methods834and constructors836to SWF action data elements950. As explained previously, Common Intermediate Language methods834and constructors836include one or more Common Intermediate Language opcodes902. Common Intermediate Language opcodes902are separated into different types and mapped to SWF actions in a mapping step904. Note also that in alternative embodiments according to the present invention, Common Intermediate Language opcodes902may additionally or alternatively map to one or more SWF tags or records.

Categories of Common Intermediate Language opcodes include instantiations906, stack operators908, field access operators910, method calls912, argument access operators914, comparison operators916, flow control918, bit operators920, mathematical operators922, casting and conversion operators924, and exception handlers926. Instantiation opcodes906create new instances of a class and map to SWF action data elements950New Method, NewObject, InitObject and InitArray in a mapping step928. Stack operator opcodes908manipulate the stack machine in the Common Language Infrastructure Virtual Execution System and map to SWF action data elements950Push, Pop, StackSwap and PushDuplicate in a mapping step930. Field Access Operators910control field values and map to SWF action data elements950Get Variable, SetVariable, GetMember and SetMember in a mapping step932. Method calls912map to SWF action data elements950CallFunction, CallMethod and Call in a mapping step934. Argument access operators914provide access to the passed arguments in a method834and map to SWF action data elements950Arguments, Array, GetVariable and Push in a mapping step936. Comparison operators916map to SWF action data elements950Equals, Less, Less2, StrictEquals, Greater and StringGreater in a mapping step938. Flow control opcodes918control the flow of execution of byte code and map to SWF action data elements950If, Jump and Call in a mapping step940. Bit operators920can manipulate individual bits and map to SWF action data elements950BitAnd, BitLShift, BitOr, BitRShift, BitURShift and BitXOR in a mapping step942. Mathematical operators922perform operations on numbers and map to SWF data elements950Add2, Less2, Modulo, Decrement, Increment, Add, Divide, Multiply and Subtract in a mapping step944. Casting and conversion operators924are not mapped in an ignoring step946because the SWF Engine is type free. Exception handling opcodes926map to SWF action data elements950Try and Throw in a mapping step948.

FIG. 10is an operational flow diagram illustrating a method of converting byte code of a first type and markup language files into byte code of a second type, according to one embodiment of the present invention. Referring toFIG. 10, a first set of byte code files202and markup language files1002can be converted in a transformation step1004into byte codes of a different type206. Markup language files1002can refer to objects, data elements and other information in the first byte code files202. Markup language files1002may also associate and refer to other external resources including text files, digital media files, other markup language files and additional types of byte code files. Markup language files1002may further include tags or references for graphically creating a user interface by defining such elements as layout, positioning and vector graphics manipulation. In an embodiment in accordance with the present invention, markup language files1002can define the graphical layout of a software application and instantiate objects and data elements from the first set of byte code files202to provide the software application with functionality. For example, a XAML markup language file1002could define a graphical user interface and associate objects in a Common Intermediate Language byte code file202as well as other elements in a .Net Assembly with the user interface. Alternative markup languages capable of mapping to a second byte code206include, for example, XML or XUL. XAML is an XML-based language defined by Microsoft Corporation to describe, for instance, user interfaces, vector graphics, animation and data binding. Common Language Infrastructure object data structures following guidelines for serialization can be represented using XAML markup. Both the XAML markup language files1002and a .Net Assembly containing Common Intermediate Language byte code202can be transformed in a transforming step1004into a SWF byte code file206, wherein at least a portion of the objects, data and structure of the .Net Assembly, as well as XAML instantiation and layout tags, are converted to SWF data elements.

In one embodiment of the invention, one or more markup language files are represented in ASCII text files. The text markup language files are converted into a binary markup language format. A binary markup language format often has a smaller file size because it does not require the overhead of textual semantics to designate structure, and can be utilized more efficiently than text markup language because text markup language files can require more extensive parsing to use. For example, as an intermediate step in a byte code conversion process, a XAML text markup language file can be converted into a BAML binary markup language representation of the XAML file. The BAML file and a first byte code can then be converted into a second byte code as described forFIG. 10and further described below.

In another embodiment according to the present invention, first byte code files202and markup language files1002can be converted in the same or related processing step1004by a byte code converter application to produce a second byte code206. In an alternate embodiment, conversion of byte code files202and markup language files1002may take place at different times and/or as part of different computer processes. For example, a computer user could request a first byte code file202through a proxy application. The request could initiate the byte code conversion process and create a second byte code206. The second byte code206could then begin execution on a byte code interpreter as described previously. The second byte code206could contain instructions or references to markup language files1002. The proxy application could dynamically load the markup language files1002and initiate further conversion of the markup language code1002into additional second byte code206that could be loaded into the already running second byte code206for further execution. An exemplary scenario can include a user request for Common Intermediate Language byte code202from an application that can only execute SWF byte code206. Upon request, a proxy application can receive Common Intermediate Language byte code202and convert it in a transformation step1004into SWF byte code206. Execution of the SWF byte code206could then reference or call a XAML markup language file1002. The proxy application can then receive the XAML markup language code1002and convert the markup into additional SWF byte code206that is dynamically loaded into the already executing SWF byte code206. Thus, alternate embodiments of the present invention allow for dynamic byte code conversion of all or portions of a first byte code202and markup language code1002.

FIG. 23is an operational flow diagram illustrating an alternative method of converting byte code of a first type and markup language into byte code of a second type. Referring toFIG. 23, markup language files1002are transformed into source code files2304in a transformation step2302. At least a portion of the objects, data elements, display items and other information within a markup language file1002are converted into an analogous representation in source code2304. For example, at least a portion of a XAML markup language file1002can be converted into one or more source code language files2304in the C#, J#, JScript, Visual C++ .Net or Visual Basic .Net languages. In an alternate example, at least a portion of a XUL markup language file1002can be converted into one or more source code language files2304in JAVA or JavaScript. Moreover, references to the first byte code files202and external resource references contained in the markup language files, such as those described below forFIG. 11, can be similarly converted to analogous references in source code2304. For example, if a XAML markup language file1002contained display and layout instructions for a button object defined in a source CIL byte code file202, the instructions can be transformed into display and layout C#programming language instructions for the button in a C#source code file2304. In step2306, source code files2304are compiled to form additional byte code files2308. Source code files2304can be compiled into byte code files2308as described previously. For example, source code2304could be compiled by a byte code compiler into CIL byte code2308. The resulting converted byte code2308can be of the same type or of a different type from the source first byte code202. In step2310, both the source byte code files202and converted byte code files2308are transformed into byte code files of a second type206. The source byte code files202and converted byte code files2308can be transformed into a byte code of a different type using the process and methods described previously for transforming a single type of byte code into a target byte code of a different type. In the case that the source code files2304contain references to the source byte code202or external resources, those references are compiled with the rest of the source code2304and preserved in the resulting byte code2308. The source byte code files202and converted byte code files2308may be of similar and/or different types from each other and the resulting byte code206. For example, source CIL byte code202and converted JAVA byte code2308could be transformed into target SWF byte code206. Alternately, source CIL byte code202and converted SWF byte code2308could be transformed into target SWF byte code206.

FIG. 11is an operational flow diagram illustrating one method in accordance with the present invention of converting byte code of a first type202into an intermediate data structure406and markup language files1002into an object graph1106, and converting both into byte code of a second type206. Byte code files of a first type202can be received by a byte code parser402and converted in a converting step404into one or more intermediate data structures406, as previously described.

Alternately, or in addition, markup language files1002can be received and converted to an object graph1106in a converting step1104. An object graph1106is typically a directed graph or tree data structure consisting of objects linked to other related or associated objects. Object graphs1106may be encapsulated in markup language files, custom text-based languages, or in other binary formats. In context of an embodiment in accordance with the present invention, an object graph1106can represent some or all markup language tags and constructs as objects within the graph structure. Further, an object graph1106can reference1102a first byte code202and serve as a serialization format that preserves typing for data elements of a first byte code202, type values, and the relationship of types to other types. As an example, a XAML markup language file1002containing references to data elements in a .Net Assembly comprising Common Intermediate Language byte code202could be parsed to generate a Common Language Infrastructure object tree1106where at least a portion of the object tree objects correspond to Common Language Infrastructure classes in the Common Intermediate Language byte code202, and at least a portion of the object tree object properties correspond to class properties. The Common Language Infrastructure object tree1106and Common Intermediate Language byte code202or .Net XML DOM intermediate data structure406could then be converted in a converting step1108into byte code of a different type206like, for example, SWF byte code206. In yet another embodiment according to the present invention, first byte code202and an object graph of a first type1106can be converted into a second byte code206as well as an object graph of a second type. Similar to the object graph1106illustrated inFIG. 11, an object graph of a second type can reference data elements, objects and other information in a second byte code206, as well as define an object hierarchy and object relationships.

One method of generating an object graph1106is illustrated in further detail inFIG. 12.FIG. 12is an operational flow diagram illustrating a method in accordance with one embodiment of the invention of parsing markup language files1002into an intermediate graph structure1206, which is then traversed to produce an object graph1106. In a parsing step1204, a markup language parser1202receives markup language files1002, parses the markup language tag structure and creates an intermediate graph structure1206. The intermediate graph structure1206reflects the original structure of the markup language document and is typically a tree structure. The intermediate graph structure1206provides the underlying framework for creating an object graph1106. In a generating step1210, an object graph generator1208traverses the intermediate graph structure1206and creates an object graph1106. During the generating step1210, any markup language code1002references to data elements in byte code of a first type may be associated with objects and properties in the resulting object graph1106. For example, an XML markup language source file1002could be parsed into an intermediate tree format1206representing the hierarchical structure of tags in the XML document. The intermediate tree format1206could then be traversed to generate objects and properties for an object graph1106and to associate each XML tag in the hierarchy byte code data elements where the XML markup language source file1002contained external byte code references.

A method of converting byte code of a first type202and markup language code1002into byte code of a second type206is examined in greater detail inFIG. 13.FIG. 13is an operational flow diagram illustrating a method in accordance with an embodiment of the present invention of mapping data elements706from a first byte code202and data elements1306from markup language code1002to data elements710a,dof a second byte code206. In converting step702, byte code files of a first type202can be converted into one or more byte code data elements706. Similarly, in a converting step1302, markup language files1002can be converted into one or more markup language data elements1306. As described above, data elements706,1306can include objects, instructions, and numerous other structural elements within a computer program. Turning to markup language data elements1306specifically, markup language data elements1306most typically include information relating to the appearance and displayed structure of a computer program as well as references to data and functionality in a first byte code202. For example, markup language data elements1306could include data structures defining colors, lines, shapes, text and layout positions in markup language code1002, as well as many other data structures as would be apparent to one of ordinary skill in the art and as will be described in further detail below. In an exemplary embodiment, a XAML markup language file1002could be parsed into a group of data elements1306including external file references, colors, brushes, pens, shapes, text, images, animations, transforms, sound, video and controls. It should also be noted that because many markup languages are extensible, the list of constituent data elements1306comprising a markup language file1002is not bounded and extensible as well.

In a mapping step1304, data elements of a first byte code706and data elements of markup language1306are parsed from byte code202and markup language files1002, respectively. At least a portion of the data elements706,1306can be mapped to data elements of a second type710a,d. Information contained in the source byte code202may also be used to assist the mapping process1304for markup language data elements1306and vice versa. Alternatively, markup language data elements1306may be mapped to data elements of a second type710dwithout reference to the first byte code202or byte code data elements706and vice versa. In a converting step712, data elements of a second type710a,dcan be received and assembled into a resulting byte code of a second type206.

In one embodiment in accordance with the present invention, the mapping step1304is carried out by referencing markup language mapping libraries1308. Markup language mapping libraries1308can contain instructions or subroutines that receive input from markup language data elements1306, determine if any mapping exists to one or more data elements of a second type710d, and return information indicating which, if any, data elements of a second type710dhave matches. Markup language mapping libraries1308can comprise mapping instructions for mapping display and layout elements defined in the markup language code1002, as well as mapping and association instructions for references to first byte code data elements706in the markup language code1002. Markup language mapping libraries1308can be implemented in any similar digital format as byte code mapping libraries708, as previously described. In an embodiment in accordance with the present invention, a markup language mapping library1308could contain instructions for mapping XAML tag data elements1306to SWF data elements710d, as explained in further detail below.

In another embodiment in accordance with the present invention, the mapping step1304is augmented by referencing byte code mapping libraries708. Byte code mapping libraries708, as previously described, can contain instructions or code for mapping first byte code data elements706to one or more second byte code data elements710a.

In another embodiment in accordance with the present invention the mapping step1304is carried out by referencing both byte code mapping libraries708and markup language mapping libraries1308, as individually explained above. Moreover, information in one mapping library708,1308may be used to help data element matching for either or both forms of data elements706,1306. The mapping libraries708,1308may be stored and executed as part of the same library file or packaged set of libraries. In the alternative, the mapping libraries708,1308may comprise physically separate digital files. In addition, either or both of the mapping libraries708,1308may be implemented in preferred embodiments in accordance with the present invention as lookup tables, as previously described in greater detail. Alternatively, the mapping libraries708,1308could comprise data structures such as hash tables, associative arrays or arrays.

Additional embodiments in accordance with the present invention illustrated inFIG. 13can carry out an insertion step716to insert bridging byte code of a second type714in the resulting second byte code206. During the data element mapping step1304, it is possible that either first byte code data elements706and/or markup language data elements1306will not be successfully mapped to second byte code data elements710a,d. As described above, in such cases where not all data elements706,1306are mapped, the resulting byte code206may lack portions of functionality or data in source byte code202or markup language code1002.

One method to redress this situation, according to an embodiment in accordance with the present invention, is to insert bridging byte code714in an insertion step716. The bridging byte code714may comprise, for example, additional functional or data code in the case that one or more first byte code data elements706failed to map. Alternately, or in addition, the bridging byte code714may comprise, for example, layout instructions or display elements in the case that some of the markup language data elements1306were not mapped.

In one embodiment according to the present invention, bridging byte code714is generated automatically by a computer process in response to mapping step1304and/or conversion step712, as described in detail above. The bridging byte code714may be generated by a software application that is part of the one or more software applications executing the overall byte code conversion process, or the bridging byte code714may alternately be generated by a standalone software application that is called as necessary. The generated bridging byte code714is then inserted into the resulting byte code206.

In yet another embodiment according to the present invention, a programmer or external software application can initiate the insertion step716and insert custom bridging byte code714. As described previously, a developer may examine the second byte code716and discover functionality or data missing that was originally contained in the first byte code202and/or markup language code1002. The developer may then create custom bridging byte code714and insert the code into the second byte code206in an insertion step716. Alternately, a computer program may be executed which performs the tasks of analyzing missing functionality, generation of bridging byte code714and insertion in an insertion step716.

FIGS. 14aand14b, together, show in greater detail one preferred embodiment for a mapping step1402.FIGS. 14aand14btogether illustrate an operational flow diagram of a data element mapping step1402according to an exemplary embodiment in accordance with the present invention in which XAML markup language data elements1404are mapped to SWF data elements1452. As previously noted, XAML is an implementation of XML and thus, any specific discussion of XAML in the present preferred embodiment necessarily applies to XML, as well as serving as a general example of the capabilities of markup languages in the present invention. A mapping step1402can optionally reference mapping instructions contained in a markup language mapping library1406. Alternately, a mapping step1402can be performed with instructions in the native software application that performs the mapping step1402.

XAML data elements1404can be further categorized into various XAML data element types1408-1428. It is important to note that because XAML, XML and other “extensible” markup languages are extensible, the set of different constituent tags, categories, types and data elements1404is potentially limitless. Thus, the categories noted in this exemplary embodiment are provided for illustrative purposes and are not intended to limit the scope of the present invention. XAML data elements1404can comprise constructs such as colors1408, brushes1410, pens1412, shapes1414, text1416, images1418, animation1420, transforms1422, sound1424, video1426and controls1428. XAML colors1408are represented as four bytes, one for each color channel (red, green and blue) and one for the alpha channel. In mapping steps1430-1450, XAML constructs1408-1428are mapped where possible to analogous SWF constructs comprised of one or more SWF tags, records and/or actions. It should also be noted that although specific SWF tags, records and/or actions are specified for mapping XAML data elements1404, XAML data element types1408-1428can be mapped in respective mapping steps1430-1450in varying combinations of SWF tags, records and/or actions. Where no direct analogous elements between XAML and SWF exist, embodiments in accordance with the present invention may simulate XAML elements by substituting combinations of two or more SWF tags, records and/or actions that together approximate a given XAML element.

XAML colors1408can be mapped to SWF RGB or RGBA records in a mapping step1430. Brushes1410are used to fill regions of a vector graphic shape and typically comprise solid, gradient or bitmap type brushes. Brushes1410are translated to SWF FillStyle records in a mapping step1432. Pens1412are used to draw the contours of shapes and comprise properties such as brush, thickness, starting line cap, ending line cap, dash array, dash cap and line join. Pens1412can be translated to SWF LineStyle records in a mapping step1434. XAML shapes1414include, for example, ellipses, lines, paths, polygons, polylines, rectangles and rounded rectangles and are translated to SWF Edge records in a mapping step1436. Specifically, ellipses are converted to SWF CurvedEdge records. Lines, polygons, polylines and rectangles are converted SWF StraightEdge records. Paths and rounded rectangles are converted into series of SWF CurvedEdge and StraightEdge records. Text1416comprises a series of Unicode characters and is translated to SWF DefineFont2, DefineFontInfo2, DefineText2 or DefineEditText SWF tags in a mapping step1438. Images1418consist of a grid of pixel data that can be compressed or represented in a variety of formats including: BMP, EMG, EXIF, GIF, JPEG, PNG, TIFF, WMF and SWF. JPEG images are converted to SWF DefineBits, DefineBitsJPEG2 and DefineBitsJPEG3 tags in a mapping step1440. The other exemplary formats mentioned above are converted to SWF DefineBitsLossless and DefineBitsLossless2 tags in a mapping step1440. XAML defines animation1420as values that change over time and will animate values including: Boolean, Byte, Int16, Int32, Int64, Single, Double, Color, Length, Size, Thickness, Point, Rect, Vector, Matrix and Path. SWF defines animation using frames and change values for each frame. The step1442of converting XAML animation1420to SWF animation comprises matching time-based animation values to the target frame rate of the resulting SWF file. XAML transforms1422are used to place and modify objects, fills, text and buttons. XAML presently supports many transformation types including: rotate, scale, skew and translate, as well as concatenations of transforms using matrix multiplication. XAML transforms1422are converted to SWF Matrix records in a mapping step1444. SWF Matrix records may then be associated with tags and records for other SWF data elements1452to perform transformations on those data elements1452. XAML sound elements1424link to embedded or streaming sound files comprising series of samples at a given sample rate. In a mapping step1446, XAML embedded sound references1424are converted to SWF DefineSound tags, and XAML streaming sound references1424are converted to SWF SoundStreamHead and SoundStreamBlock tags. XAML video references1426link to video files comprising series of raster image frames. Video files are typically streamed from an external source. XAML streamed video references1426are converted to SWF DefineVideoStream tags in a mapping step1448.

XAML controls1428may comprise any of the XAML elements described inFIG. 14or other XAML elements. Examples of controls include: Button, Canvas, CheckBox, ComboBox, Group, Image, Label, ListBox, Menu, Panel, RadioButton, ScollBar, TabControl, TextBox, Timer, and Window. In addition, custom controls may be created, leading to an unbounded list of potentially applicable controls1428. Controls may contain both display elements and functionality, typically by referring to external byte code such as Common Intermediate Language byte code in a .Net Assembly. In a conversion step1450, controls1428can be converted into SWF data elements1452using the previously described techniques for mapping XAML to SWF data elements and mapping .Net Assemblies and Common Intermediate Language data elements to SWF data elements.

With reference toFIGS. 11,12and13, an object graph1106may be utilized in embodiments in accordance with the present invention in the step1302of converting markup language files1002into data elements1306. Referring toFIG. 11, and as described above, markup language files1002may be converted into an object graph1106in a converting step1104. The resulting object graph1106comprises a graph structure of markup language tags and/or first byte code202associations. With reference toFIG. 12, and as previously detailed, in one embodiment in accordance with the present invention, an object graph1106is optionally generated by first converting markup language code1002into an intermediate graph structure1206. Referring now toFIGS. 11 and 13, during a conversion step1302some or all of the individual objects in the object graph1106may be converted to markup language data elements1306. Because an object graph1106comprises an ordered structure of markup language objects, it is more readily parsed into individual data elements.

Referring now toFIG. 11, when an intermediate data structure406is generated from first byte code202and used in conjunction with an object graph1106, the structure and contents of an overall software program become much more apparent and distinguishable. Thus, with reference toFIGS. 11 and 13, a preferred embodiment in accordance with the present invention converts first byte code intermediate data structures406into first byte code data elements706, and converts markup language object graphs1106into markup language data elements1306. In this preferred embodiment, at least a portion of both the byte code202and markup language code1002is already in a structured and ordered format prior to respective data element conversions702,1302.

FIG. 16is an operational flow diagram illustrating one method in accordance with the present invention of extracting inline byte code of a first type1604and inline markup language code of a first type1606from a second markup language wrapping file1602and converting both to byte code of a second type206. As described above, markup languages can describe many types of data including text, graphics, user interfaces and references to byte code data. In addition, markup languages can store byte code1604and/or other markup language code1606as inline data within a wrapping markup language file1602. In one embodiment, inline data can be designated by “markers” that indicate the beginning and end of various sections of inline markup code1606and/or inline byte code1604. Inline byte code1604is extracted in an extracting step1608to form stand-alone or separate byte code of a first type. Inline byte code1604may be in either binary format or in an intermediate language format, as previously described. Inline markup language code1606is extracted in an extracting step1610from the wrapping markup language file1602to form stand-alone or separate markup language code. Exemplary wrapping markup language formats include any scripting markup language, such as ASP, PHP or CFML, as well as extensible markup languages, such as XML and XAML. Exemplary inline markup language formats include any markup language format discussed herein. The extracted byte code of a first type and markup language code are then converted to byte code of a second type206in a transformation step1612. In one embodiment according to the present invention, a request for a wrapping markup language file1602initiates the extraction and conversion processes1608,1610and1612. For example, a web browser request to an ASP scripting markup language file1602containing inline XAML markup language1606and byte code1604could initiate the extraction steps1608and1610, as well as the conversion step1612to form SWF byte code206for display within the ASP markup page1602using a Flash plug-in executing within a web browser. Moreover, the extracted byte code of a first type and markup language code can be transformed according to any of the embodiments of the present invention disclosed herein, as well as variations that will become apparent to those of skill in the art upon reading the description herein.

FIG. 17is an operational flow diagram illustrating one method in accordance with the present invention of extracting source code1704and inline markup language code of a first type1606from a second markup language wrapping file1702and converting both to byte code206. Markup languages can further store program source code1704as inline data in a wrapping markup language file1702. Inline source code1704is extracted in an extracting step1706and mapped to a byte code206in a transformation step1708. Exemplary inline source code languages include Java, ActionScript, or any Common Language Infrastructure language. Similar toFIG. 16, inline markup language code1606is extracted in step1610and mapped to byte code206in step1708.

In addition to embodiments converting byte code and markup language code into byte code of a second type, further embodiments in accordance with the present invention can produce byte code of a second type as well as markup language of a different type.FIG. 19is an operational flow diagram illustrating a method of converting byte code of a first type202and/or markup language code of a first type1002into byte code of a second type206and markup language code of a second type1904in a transforming step1902, according to an alternate embodiment of the present invention. It should be noted that markup languages may be of different types while at the same time being sub- or super-sets of one another. For instance, XAML and XML could be considered different types of markup languages, despite the fact that XAML is an XML-based language. As an exemplary scenario, SWF byte code202and optionally XML markup language code1002could be converted into Common Intermediate Language byte code206and XAML markup language code1904, wherein at least a portion of the objects, data, data descriptions, display instructions and structures of the SWF and optional XML code are converted to either Common Intermediate Language or XAML data elements.

The method illustrated inFIG. 19can extend and enhance many of the various methods, intermediate procedures and embodiments according to the present invention previously described. With reference toFIG. 4,FIG. 4illustrates a method of converting a first byte code202into an intermediate data structure406. Similarly, an embodiment in accordance with the method illustrated inFIG. 19may create an intermediate data structure corresponding to a second byte code type, which is used to then create a second byte code206. Turning toFIG. 5,FIG. 5illustrates a method of converting byte code202into an intermediate language format506. Similarly, in an embodiment in accordance with the illustration inFIG. 19, an intermediate data structure of a second type may be further converted into an intermediate language format of a second byte code type. The intermediate language format of a second byte code type may be compiled into second byte code206. With reference toFIG. 7,FIG. 7discloses a method of mapping data elements of a first byte code type706a-cto data elements of a second byte code type710a-c. Similarly, another embodiment in accordance with the method illustrated inFIG. 19can map data elements of a first byte code type to both data elements of a second byte code type and/or data elements of a second markup language type. With reference now toFIG. 19in view ofFIG. 13, data elements of a first markup language type can also be mapped to both data elements of a second byte code type and/or data elements of a second markup language type. The second byte code and second markup language data elements can be assembled into second byte code files and second markup language files, respectively. Additionally, bridging byte code of a second type or bridging markup language of a second type can be inserted into the resulting byte and markup language code as described for bridging byte code insertion above.

With reference toFIG. 12,FIG. 12illustrates a method of converting a markup language file into an intermediate graph structure1206. The intermediate graph structure1206can be converted into an object graph1106for further conversion, as illustrated inFIG. 11. Turning toFIG. 19, an alternate embodiment of the method illustrated inFIG. 19can create an object graph of a second markup language type that can represent some or all markup language tags from an optional first markup language code, as well as references to data and objects in a destination second byte code. Additionally, a second markup language object graph may be further processed into an intermediate graph structure reflecting the structure of a destination markup language file1904. The object graph and/or the intermediate data structures may be converted into markup language of a second type1904. With reference to the method illustrated inFIG. 19viewed in light ofFIG. 13, byte code and markup language mapping libraries can be optionally used to map input data elements to byte code data elements of a second type and markup language data elements of a second type.

With reference now toFIG. 19, as a further exemplary scenario, SWF byte code202and optionally XML markup language code1002can be mapped to data elements of a Common Intermediate Language byte code type and data elements of a XAML markup language type. The Common Intermediate Language byte code data elements can be converted in step1902into a DOM or abstract syntax tree intermediate data structure. The intermediate data structure can be further converted into CIL assembly language (an intermediate language format). The CIL assembly language files can be assembled into a resulting Common Intermediate Language byte code206. The XAML markup language data elements may be assembled into an intermediate XAML graph structure and further assembled into a XAML object graph. The resulting XAML object graph can then be parsed into a XAML markup language file1904.

FIG. 20is an operational flow diagram illustrating a method of converting byte code of a first type202and/or markup language code of a first type1002into source code of a second type2004and markup language code of a second type1904in a transforming step2002, according to an alternate embodiment of the present invention. The method illustrated inFIG. 20incorporates the transformations described previously for first byte code files202, first markup language files1002and second markup language files1904. In an embodiment illustrated inFIG. 20, byte code files202and optionally first markup language files1002are converted to source code files2004. Source code files2004can be created by mapping data elements of first byte code files202and markup language files1002to data elements of a target source code, as similarly described above. Alternately, or in addition, first byte code files202and first markup language files1002can be converted into an intermediate data structure of a destination source code type. The intermediate data structure may then be disassembled directly to source code. For example, SWF byte code202and optional XML markup language code1002can be converted into XAML destination markup language code1904in a similar fashion as that previously described while additionally converting at least a portion of the SWF and/or XML codes into C# source code file2004. In an alternate example, CIL byte code202and optional XAML markup language code1002can be converted into HTML or XML destination markup language code1904and JavaScript source code2004. Additionally, the JavaScript source code2004could be stored within an HTML or XML destination markup language code file1904, or in a separate source code file.

FIG. 24is an operational flow diagram illustrating a method of converting byte code of a first type202and markup language code1002into byte code of a second type206and one or more media files2404. The method illustrated inFIG. 24also incorporates the transformations described previously for first byte code files202, first markup languages files1002and producing second markup language files. In an embodiment illustrated inFIG. 24, one or more byte code files of a first type202and one or more markup language files1002are converted in a transforming step2402into byte code files of a second type206and one or more media files2404. Media files generally comprise any format in which digital media can be stored or compressed, including images, sounds or video. In a further embodiment according to the invention, display elements from a first markup language1002are converted into analogous display elements in a media file2404. For example, a graphical display object in a XAML markup language file1002could be converted into an image bitmap media file2404, or converted into other image formats such as Portable Network Graphics (PNG), Joint Photographic Experts Group (JPEG), or Graphics Interchange Format (GIF) formats. Alternatively, sound media files2404in such formats as Audio Interchange File Format (AIFF), MP3, WAVEform audio format (WAV), Windows Media Audio (WMA), Advanced Audio Coding (AAC), Ogg Vorbis, or RealAudio could be produced. Video media files2404in such formats as QuickTime, MPEG, RealVideo, Audio Video Interleave (AVI), or Windows Media Video (WMV) could also be produced. In an alternate embodiment, graphical or media data elements of a first byte code202are converted into analogous elements in a media file2404. Such embodiments are useful for portable display devices, like personal digital assistants, that might not be able to correctly render a second byte code206and/or produced second markup language code, but can display media such as basic image formats from a media file2404.

FIG. 15describes in greater detail various embodiments according to the present invention for utilizing byte code files206created in a computer system102by a byte code converter124.FIG. 15is a diagram of a workstation computer1502connected to client computers1506a-band servers1508a-bacross a network1504. A workstation1502comprises an exemplary computer system environment102and a byte code converter124as previously described. The byte code converter124produces byte code of a second type206according to the exemplary systems and methods described previously, as well as variations that will become apparent to those of skill in the art after reading this description. The byte code conversion process may be initiated by a user action on a workstation1502, or it may be automatically initiated by some other process or application running on a workstation1502or another computer across a network1504. Workstation1502may alternately be any type of computer system that is capable of producing a second byte code206according to the present invention, including, for example, client computers1506a-b, servers1508, and laptop computers. Examples of a network1504can include LANs, WANs or the internet. In one embodiment according to the present invention, a workstation1502may transmit second byte code files206across a network1504directly to a client computer1506ain a peer-to-peer network configuration. In an alternate embodiment, a workstation1502may transmit second byte code files206across a network1504to server computers1508a-b. Servers1508a-bcan make the second byte code files206available for transmission to other computers on the network1504. For example, a server1508amay serve second byte code files206to a client computer1506bin a server-client network configuration. Examples of applications that may transmit second byte code files206across a network1504include web server applications, File Transfer Protocol (FTP) applications, peer-to-peer sharing applications, email server applications, and multimedia server applications. As an illustrative example, a Windows server could receive second byte code files206and serve the files to web browser clients by posting the files for download through Microsoft Internet Information Server (IIS) (a web server application). It should be further noted that additional network configurations, such as ring topologies, hub, and spoke topologies could also be implemented to receive and distribute second byte code files206according to the present invention.

In one exemplary embodiment according the present invention, a byte code converter application on a server performs the step of converting byte code2602of a first type202into byte code components2604a-d. Alternate embodiments that would be apparent to one of skill in the art upon reading the following description include byte code converting systems implemented on peer-to-peer networks and other network topologies, as well as over mail, web or other network protocols. Returning to the server embodiment, the server computer can contain a byte code converter and serve second byte code files206a-bto client computers or other server computers, as described more fully above forFIG. 15. The byte code converter could run as a stand-alone application on a server or as a plug-in, as described in more detail below forFIG. 18. In the present embodiment, a server computer can convert first byte code files202into and serve second byte code files206a-bto other computers over a network. Ideally, the server computer can serve a specific second byte code206ato one client, while serving a different second byte code206bto another client, based on factors such as the environment, available applications and operating system of the receiving client computer.

In one exemplary configuration, a client computer initiates a request to the server for a second byte code206a-bspecific to the client. If the request is the first request, then the byte code converter on the server converts the byte code of a first type202into byte code components2604a-c, which are retained on the server computer and assembled into a client-specific second byte code206a. The specific target byte code206ais then returned to the client. In a subsequent client request for the same target byte code206a, the byte code206acan be assembled from the retained byte code components2604a-c. If a subsequent client connects to the server computer and requests a different second byte code206b, the server performs a determination step to see if the client request can be satisfied with target byte code206a-bcomprised of the existing, retained byte code components2604a-d, or if additional byte code components2604a-dmust be produced to create a client-specific target byte code206a-b. In this fashion, the present embodiment of the invention allows efficient reuse of common byte code components2604a-d. In the current example, the server computer determines that the target byte code206brequires byte code components2604b-c, which are already retained on the server, and byte code component2604d, which has not yet been created. The server performs converting step2602to produce missing byte code component2604dfrom source byte code202. Byte code component2604dis then retained by the server and combined with byte code components2604b-cto form the client-specific byte code of a second type206b. For example, a server containing CIL source byte code202could be configured to convert and serve SWF target byte code206acontaining a Windows-specific interface to a Windows operating system client computer. The server can then reuse the generic old byte code components2604b-cfrom one or more earlier byte code conversions and create a new byte code component2604dto server SWF target byte code206bto a Mac OS X-specific interface on a Mac OS X operating system client computer.

In an alternate exemplary configuration, a server can convert byte code files202into one or more byte code components2604a-dbefore receiving a client request requiring those specific components2604a-d. Upon a client request for a specific target byte code206a, the server can perform a determination step to decide if the necessary byte code components2604a-chave already been created and retained among the pre-created byte code components2604a-c. If the necessary byte code components2604a-care present, then the target byte code206ais assembled. If not, the additional byte code components2604a-dmissing from the target byte code206acan then be converted from the source byte code202. Thus, in this configuration, the server can be set up to accommodate the most likely target byte code files206a-bto be requested by client computers by predicting and compiling anticipated byte code components2604a-d.

In another embodiment of the invention, after receiving a target byte code206a-b, a client computer from the client-server example may cache the target byte code206a-bor individual byte code components2604a-d. If the client computer requires an updated version of the target byte code206a-b, it can initiate another request to the server. The server determines which byte code components2604a-dthe client already has by, for example, communicating with the client or referencing a log of byte code component2604a-dtransfers, and optionally converts and sends only the different updated byte code components2604a-dto the client computer. The client computer can then invoke the byte code application using the cached older byte code components2604a-dthat did not require updating, and updated byte code components2604a-dfor the portion of the byte code application that did require updating. The assembling step2606a-bmay be required on the client end to produce a workable target byte code206a-b, or the byte code components2604a-dmay already be able to interact without any assembling step2606a-b. Moreover, if certain byte code components are determined to regularly require updating, the assembly step2606a-bcan be performed to make one or more groups of byte code files that remain substantially static and one or more other groups of byte code files expected to change over time. The static and dynamic groups are sent together to a client as a target byte code206a-b, but remain replaceable in parts, should the byte code206a-brequire updating. Moreover, in an alternate embodiment, a byte code of a second type206a-bcan be created from only a portion of the source byte code202and/or second byte code components2604a-dand sent to another computer. When additional functionality or methods are needed from the invocation of the resulting byte code206a-b, a communication can be made to the converting computer to convert additional source byte code202, or return other byte code components2604a-d.

In one exemplary embodiment according to the invention, the byte code components2604a-dretained by a computer after a source byte code conversion step2602are stored in a database. For example, a database reference to a byte code component2604a-dcould include such information as the byte code language, the program definition, the client operating system to which the byte code component2604a-dtargets, and other information. The database can later be referenced for easy lookup of byte code components2604a-dto reuse in assembling specific target byte code files206a-b. In alternate embodiments, a flat file system or other data storage medium could be used to store byte code components2604a-d.

FIG. 18is a diagram of a computer system102embodied in a computer1802and containing a software application1804, an application plug-in1806and a byte code converter124according to one embodiment of the present invention. Suitable computers1802can include workstations, client computers and servers. A software application1804calls a plug-in application1806that invokes a byte code converter124to convert first byte code and/or first markup language code into second byte code and/or second markup language code according to the exemplary systems and methods described previously, as well as variations that will become apparent to those of skill in the art after reading this description. A plug-in application1806is typically a module or application that adds features or functionality to another application. One advantage of plug-ins1806is that they allow users to enhance the functionality of a software application1804with only specifically chosen additional features available in different plug-ins1806. Plug-in applications1806may run within a restricted environment in a software application1804for security. Software applications1804usually provide means for plug-ins1806to be registered and protocols for data exchanges with plug-ins1806and software applications1804. Software applications1804allowing for plug-ins1806typically provide a plug-in Application Programming Interface (API) to allow software developers to create custom plug-in applications1806. Examples of web browser applications1804allowing for plug-ins1806include Internet Explorer, Mozilla Firefox, and Netscape Navigator. Examples of web server applications1804allowing for plug-ins1806(often called “modules” in this context) include IIS and the Apache Software Foundation's Apache HTTP Server. In one embodiment according to the present invention, a web server application1804may offer markup language files and/or byte code files for download by web browser clients. A web server plug-in1806can be invoked in response to a client browser request to dynamically convert markup language code and/or byte code to different types of markup language and/or byte code in accordance with various embodiments of the present invention as previously described. Additionally, a web server application1804and/or web server plug-in1806to provide authentication services in connection with transmitted byte code and/or markup language files. For example, an IIS web server1804may distribute a converted SWF byte code file to a client web browser. As a prerequisite to execution in the client web browser, the converted SWF byte code file may contain instructions to contact the IIS web server1804and authenticate itself. Upon successful authentication, the SWF byte code can then execute.

Many types of applications1804such as graphics applications, like Adobe® Acrobat®, Adobe® Illustrator®, and integrated development environments, and multimedia servers, such as audio and video streaming servers, similarly allow for the use of plug-ins1806(ADOBE, PHOTOSHOP, and ILLUSTRATOR are either registered trademarks or trademarks of Adobe Systems Incorporated). A plug-in application1806may comprise an application that accesses a separate byte converter application124. Alternately, a plug-in application1806may be comprised within the same larger application as byte converter application124.

Also, a software application1804may be modified with software application extensions comprising similar functionality to a plug-in1806. A software extension is typically created using extension APIs for a software application1804and allows modifications or additions to the functionality of an application, usually with fewer restrictions than an application plug-in1806. A software extension to a software application1804could contain or invoke a byte code converter124for converting byte code and markup language files, as previously described.

FIG. 25illustrates an exemplary scenario utilizing byte code conversion within a software application.FIG. 25is an operational flow diagram illustrating one embodiment in accordance with the invention of developing source code of a first type302and optionally markup language code of a first type1002in an integrated development environment and producing target byte code of a second type206. In a developing step2502, source code of a first type302and optionally markup language of a first type1002can be programmed. Source code302and markup language1002can be developed in an integrated development environment (IDE), a software application typically consisting of a source code editor, a compiler and/or interpreter, build tools, a debugger, and other useful programming tools. Exemplary IDEs include Visual Studio® and Eclipse from the Eclipse Foundation (VISUAL STUDIO is a registered trademark of Microsoft Corp.). In one example according to the present invention, a developer can develop C# source code302and XAML markup language code1002in Visual Studio. Alternately, source code files302and/or markup language files1002can be created elsewhere and opened or linked within Visual Studio. In compiling step308, the source code files of a first type302are compiled into byte code of a first type202. For example, C# source code302can be compiled in Visual Studio into CIL byte code202. In an alternate example, Java source code302can be compiled in Eclipse into Java byte code202. In step2504, if further development is needed for the native application of a first type (comprising first byte code202and optional first markup language1002) under development, a developer or an automated IDE process can take further development steps2506, such as building, launching, testing, and debugging the application. Typically, such testing reveals errors or areas for improvement that can be addressed by repeating a development step2502, wherein a developer can enhance the original source code302or markup language files1002and continuing through the steps as described above. Returning to step2504, if the byte code202requires no further development, or the developer wishes to test what has been developed at that point, the source first byte code202can be transformed in a transforming step1004into byte code of a second type206as previously described in this description. In one exemplary embodiment, this transformation step1004is performed by a developer selecting the target byte code206as the development target and deselecting the native byte code202target in an IDE. The selection of a new development target in the IDE invokes computer instructions to transform source code302into source byte code202and then to target byte code206as described above. In an alternate embodiment, the transformation step1004can occur as a post-build process, after the IDE has finished compilation of the first source code302into first byte code202. Additionally, first markup language files1002can also be transformed with the source byte code202into target byte code206. The first markup language files1002can also be converted in a converting step into markup language files of a second type as previously described in this description.

The byte code transforming step1004and markup language transforming step can be performed within an IDE. In one exemplary embodiment, a byte code converter software application takes the form of an application plug-in for an IDE. Upon compiling and producing native byte code202and markup language files1002, the IDE can communicate instructions to invoke the byte code converter plug-in to carry out the transformation step1004. For example, both Visual Studio and Eclipse have plug-in architectures that enable developers to write software application plug-ins that can be invoked from within the IDE. Turning to Visual Studio, C# source code302can be natively compiled by the Visual Studio IDE into CIL byte code202and packaged with XAML markup language code1002to form a .Net application. Following automatic instructions or user input, Visual Studio can then invoke a byte code converting plug-in according to the present invention, which can convert the CIL byte code202and XAML markup language code1002into target SWF byte code and optionally one or more target markup language files. Alternately, computer instructions containing logic to convert byte code in transformation step1004may be natively built in to an IDE, which could invoke the transformation instructions directly from the application. In a preferred embodiment, a menu command, graphical button or build instruction in the Visual Studio IDE graphical interface invokes or designates the execution of the byte code converting IDE plug-in or native computer instructions. One advantage of allowing for development and testing in one language, and producing a target byte code206in another language as part of a build process is that debugging and coding in the native environment can be more useful and efficient. For example, developers might have great expertise at the source code302language and source byte code202instructions, but very little experience with the target byte code206instruction set or intermediate language.

In optional step2508, if further development is needed for the converted target application of a second type (comprising second byte code206and optional markup language files), a developer or an automated IDE process can take further development steps2510, such as building, launching, testing, and debugging the converted application. Similar to the steps of testing a native application of a first type, if testing reveals errors or possible improvements, development step2502can be repeated with all subsequent development steps proceeding again as described above. In the case that no further development is needed, an optional step2512can be performed, wherein the target byte code of a second type206may be launched. For example, if SWF byte code206is created in an exemplary byte code converter plug-in, a live instance of execution of the SWF byte code206may be displayed. Additionally, the resulting byte code206may be displayed to a developer within an IDE, so that a developer may review and edit the created target byte code206further.

In an alternate embodiment according to the present invention, the transformation step1004can take place at any time during the development of the first source code302or markup language1002. Many conventional IDEs provide for a “preview” function, in which at least some portion of source code302or markup language1002is compiled during development and before explicit compilation into first byte code202. Typically, a background computer process can compile incremental portions of source code302or markup language1002as the files are developed. When a developer invokes a preview command in the IDE, or if an automatic preview window in an IDE is activated, at least some portion of the compiled byte code202and/or markup language code1002is displayed. In the present embodiment according to the invention, the preview process includes the additional step of converting at least a portion of the source byte code202or markup language1002into target second byte code206and/or second markup language as described previously. The preview of an application or display executing converted byte code206and/or markup language code can be invoked explicitly, such as with a developer pressing a “preview” graphical IDE button, or implicitly, such as every time first source code file302is saved or edited. For example, if a developer working with C# source code302and XAML markup language code1002in Visual Studio invoked the preview function according to the invention, a byte code converting plug-in could dynamically create a SWF byte code file206from at least a portion of the C# source code302and XAML markup language1002using steps described above. The resulting SWF byte code file206could then be executed and displayed graphically in a Visual Studio preview window. The byte code transformation step1004can run as a process that continually creates target byte code206output, or incrementally transforms source byte code202when the preview functionality requires updated target byte code206.

In yet another embodiment according to the invention, the transforming step1004can adjust the target platform for the created second byte code206. Byte code such as SWF can “target” a certain computer platform, such as the Windows, Mac OS X or Linux platforms, and display graphical objects in the application in a manner consistent with the platform. A developer or automatic IDE process can select an appropriate target platform, and step1004will transform first byte code202into a second byte code206targeting one or more specific computer platforms. Moreover, some graphical IDEs include visual object editors containing a graphical user interface for programming an application. Typically, a developer can manipulate application objects, such as display items or controls, using the visual editor and without resorting to typing text source code. An IDE visual object editor conventionally uses some similar functionality to the “preview” functionality described above, in that graphical controls and display items are laid out in an analogous manner to how they will appear in a compiled native byte code application. The present embodiment of the invention extends the visual editor to graphically display visual objects as they will substantially appear in the converted target byte code206. For example, if a developer is programming C# source code302in Visual Studio and intending to target SWF byte code206, the Visual Studio visual object editor will display graphical objects as they will substantially appear in an executing instance of SWF byte code206, and not like an application executing native compiled CIL byte code202, which typically appears in accordance with the native System.Windows.Forms, System.Drawing, and System.Drawing.Drawing2D APIs from the .Net Framework.

In a further embodiment, if the first source code302is developed against development libraries of a second type, such as those described forFIG. 3, the native compiled first byte code202can utilize one or more display elements to appear as will the second byte code206. For example, C# source code302developed against a SWF target development library can be compiled in Visual Studio to a first CIL byte code202. However, the resulting CIL byte code202can appear when executed to display objects in substantially the same manner as an analogous SWF byte code application. The advantage of this embodiment is that a developer can develop a byte code application in a native first byte code format and observe the application display as it will when converted to a second byte code206. This way, a developer can perform nearly all program development using only native source code302, markup language1002, and byte code202, and wait until the end of the development process to create a target byte code of a different type206.