WO1999031583A1 - Apparatus and method for cross-compiling source code - Google Patents
Apparatus and method for cross-compiling source code Download PDFInfo
- Publication number
- WO1999031583A1 WO1999031583A1 PCT/US1998/026285 US9826285W WO9931583A1 WO 1999031583 A1 WO1999031583 A1 WO 1999031583A1 US 9826285 W US9826285 W US 9826285W WO 9931583 A1 WO9931583 A1 WO 9931583A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- program
- computer
- constants
- inheriting
- language
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
Definitions
- This invention relates generally to software system management tools. More particularly, this invention relates to a software system management tool that is used to combine different source code programs written in multiple computer languages into a single program.
- Software system management tools define software modules, their interdependencies, and the rules that are required to combine the software modules into a final software program.
- Software system management tools are necessary in view of the fact that a large software program typically includes a large number of individual software modules in the form of source code programs that are compiled and then linked into a single executable final software program.
- the large number of individual software modules and their individual processing requirements result in the need for sophisticated software system management tools.
- each source code program may require a distinct compiler.
- a mechanism must be developed to coordinate a source code program with the appropriate compiler.
- the software system management tool should provide an automatic technique for determining the constants and fields needed by the inheriting code. Further, the software system management tool should make it easy to recompile the inheriting code automatically. Such a software system management tool would simplify the development of source code written in different languages.
- a method of cross-compiling computer programs includes the step of extracting constants from an inheriting computer program written in a first (inheriting) computer language.
- the extracted constants refer to a generating computer program written in a second (generating) computer language.
- a new program in the second computer language is then created using the constants.
- the new program is then compiled for a target computer to ascertain compiled constant values.
- the compiled constant values are then substituted into the inheriting computer program to produce a final inheriting computer program.
- the invention provides a software system management tool that allows an inheriting computer program to make use of information from a generating computer program, regardless of the computer on which the compilation will take place or of the target computer. That is, the cross-compiler of the invention provides an automatic technique for determining the constants and fields needed by the inheriting computer program. Further, the cross-compiler facilitates automatic recompilation of the inheriting computer program. The technique of the invention efficiently compiles source code written in different languages.
- FIG. 1 illustrates a software system management apparatus in accordance with an embodiment of the invention.
- FIG. 2 illustrates processing operations associated with the software system management apparatus of Fig. 1.
- FIG. 3 is a more detailed depiction of the operation of the cross compiler of Fig. 2.
- FIG. 4 illustrates processing steps associated with an embodiment of a cross compiler constructed in accordance with the invention.
- FIG. 5 illustrates a software system management apparatus in accordance with another embodiment of the invention.
- FIG. 1 illustrates a software system management apparatus 20.
- the apparatus
- processor 22 which communicates with a memory module 24 and a set of input/output devices (e.g., keyboard, mouse, monitor, printer, etc.) 26 through a bus 28.
- input/output devices 26 e.g., keyboard, mouse, monitor, printer, etc.
- An individual working at the input/output devices 26 inputs a software system description, which is down-loaded into a memory module 24.
- the software system description 30 is an integrated description of software modules, their interdependencies, and the rules that are used to construct an executable program.
- the memory module 24 stores a number of executable programs including a software user interface 32 (such as a graphical user interface) and a rule execution engine 34, which produces system construction commands 36.
- the executable programs stored in the memory module 24 also include a tool controller 38, compilers 40, linkers 42, and a cross compiler 46.
- the tool controller 38 receives the system construction commands 36 and existing program files 44.
- the tool controller 38 operates in conjunction with the compilers 40, linkers 42, and cross compiler 46 to execute the system construction commands 36 on the existing program files 44 to yield an executable program 48.
- the processing associated with this software system management apparatus 20 is more fully appreciated with reference to Fig. 2.
- the input data to the apparatus is a software system description specifying a set of software source code modules, their interdependencies, and the rules that are required to combine the software modules into a final software program.
- the software user interface 32 receives this information and passes it to a rule execution engine 34, which produces a set of system construction commands 36. For instance, if the rule-based software configuration description 30 specifies that files A, B, and C are to be combined to form file D, then the system construction commands 36 would constitute a set of commands that could be executed by the tool controller 38 to compile and link existing files A, B, and C to form file D.
- the tool controller 38 executes the system construction commands 36 by interacting with the compilers 40, linkers 42, existing program files 44, and a cross compiler 46. After the tool controller 38 has executed the system construction commands 36, an executable program 48 is produced.
- the present invention is directed toward the operation of the cross compiler 46.
- the other tools with which it operates e.g., the other elements of Fig. 2 are generally known in the art.
- the cross compiler 46 interacts with the tool controller 38 to execute system construction commands 36. More particularly, the cross compiler 46 interprets the system construction commands 36 to identify when two existing program files written in different languages are to be compiled into a single program. That is, the cross compiler 46 identifies when an existing program file written in a generating language is to be combined with an existing program file written in an inheriting language.
- the cross compiler 46 allows the inheriting language to make use of information from the generating language. That is, the cross compiler 46 provides an automatic technique for determining the constants and fields needed by the inheriting code, regardless of the target machine on which the program will be compiled. The cross compiler 46 does this in such a manner that it is still easy to automatically recompile the inheriting code. In sum, the cross compiler 46 facilitates the compilation of source code written in different languages. As a result, the other software system management tools of Fig. 2 operate more efficiently to produce an executable program 48.
- the cross compiler 46 processes commands from the tool controller 38 by accessing a generating language program 44 A and an inheriting language program 44B of the existing program files 44.
- a constants and fields locator software module 50 identifies in the inheriting language program 44B references to the generating language program 44A.
- a constants and fields processor module 52 then extracts the constants and fields and preferably removes duplicate references, thereby producing a constants and fields file.
- a generating language program constructor module 54 then uses the constants and fields file to create a new and stylized generating language program.
- a constants and fields value identifier module 56 identifies compiled constant and field values in cross compiled code corresponding to the new generating language program.
- An inheriting language program modifier module 58 is then used to substitute the compiled constants and field parameters into the inheriting language program. This results in a final inheriting language program 47, which uses the constants and fields from the generating language program 44A.
- the tool controller 38 may then use the final inheriting language program 47 in connection with the compilers 40 and linkers 42 to produce an executable program 48.
- FIG. 4 illustrates the cross compiler 46 of the invention receiving an inheriting language program 44B and generating a final inheriting language program 47, consistent with the description of Fig. 3.
- the first processing step for the cross compiler 46 of Fig. 4 is to modify the inheriting language program to identify references to the generating language program (step 60). This operation may be performed by the constants and fields locator module 50.
- the references to the generating language program are in the form of constants and fields. Modifications to the constants and fields, discussed below, makes them implementation independent.
- the next processing step executed by the cross compiler 46 is to extract the identified constants and fields (step 62). Thereafter, duplicate lines containing the identified constants and fields are preferably removed to create a constants and fields file (step 64). These operations may be performed with the constants and fields processor module 52.
- the next processing step is to create, from the constants and fields file written in the inheriting language, a corresponding generating language program with a stylized header and footer (step 66).
- This operation entails converting each line from the constants and fields file of step 64 into a macro, as discussed below. This operation may be performed by the generating language program constructor 54.
- the program is then compiled for a target machine or machines (step 68).
- This aspect of the invention provides cross compiled code for multiple target machines. Observe that the cross compiled code only relates to the constants and fields of the original inheriting language program 44B. Thus, when changes are made to the original inheriting language program 44B, it is relatively efficient to recompile the code in accordance with the invention. That is, the entire inheriting language program 44B need not be recompiled, rather only the constants and fields file needs to be recompiled.
- the next processing step is to identify compiled constants and field parameters in the code (step 70). This operation may be performed with the constants and fields value identifier 56. The identified compiled constants and field parameters are then combined with the original inheriting language program (step 72) to yield the final inheriting language program 47. This step may be performed with the inheriting language program modifier module 58.
- the software system description 30 includes a MAKE file with the following lines.
- Lines (1) and (2) of the code indicate that if any of the four files (1) "extract_offsets.nawk”, (2) “opcodes.wide”, (3) “opcodes.h”, or (4) "executeJava_sparc.m4.s” change, then line (3) should be executed.
- the software system description 30 will result in system construction commands 36 that are processed by the tool controller 38. If the tool controller 38 identifies that any of the four files have changed, it will invoke the cross compiler 46.
- the file “extract_offsets.nawk” contains portions of the cross compiler 46 of the invention. In particular, it contains instructions to implement steps 62 and 66 of Fig. 4. If this file changes, then the result should be re-computed. If the files “opcodes.wide” or “opcodes.h” have changed, then it's possible that some of the constants have changed value. Any change to the file “executeJava_sparc.m4.s” means that there may be new constants or field offsets of interest or that some previously interesting constants or field offsets are no longer important.
- This code corresponds to the operations performed by the cross compiler 46.
- the code causes "execute Java_sparc.m4.s” to run through processor m4 with the two flags JAVAOS and EXTRACT_OFFSETS set to 1.
- This causes the processor m4 to modify the inheriting language program to identify generating program references (step 60).
- the processor m4 can be thought of as the constants and fields locator module 50.
- all references to constants are written as "DEFI ⁇ ED_CO ⁇ STA ⁇ T ( ⁇ constant>)”.
- all references and updates to fields are written in such a way that it is unnecessary to know the size, signedness, or offset of the particular field in the record.
- each "GET_FIELD ( ⁇ reg>, ⁇ structure>, ⁇ field>, ⁇ result>)" term is converted into a line of the form LOAD_STORE ⁇ structure> ⁇ field>.
- EXTRACT_OFFSET ( ⁇ mystruct>, ⁇ myfield>), GET_FIELD( ⁇ base>, ⁇ mystruct>, ⁇ myf ⁇ eld>, ⁇ reg>), and SET_FIELD( ⁇ value>, ⁇ base>, ⁇ mystruct>, ⁇ myfield>), where each of the lower-case strings is, in fact, a text string.
- Each occurrence of DEFINED_CONSTANT( ⁇ baz>) is output as "CONST ⁇ baz>”.
- Each occurrence of EXTRACT_OFFSET( ⁇ mystruct>, ⁇ myfield>) is output as "FIELD ⁇ mystruct>, ⁇ myfield>”.
- Each occurrence of GET_FIELD( ⁇ base>, ⁇ mystruct>, ⁇ myfield>, ⁇ reg>) and SET_FIELD( ⁇ value>, ⁇ base>, ⁇ mystruct>, ⁇ myfield>) is output as "LDST ⁇ mystruct>, ⁇ myfield>".
- the code in the file is written such that it makes use of these macros. For example, If gr, methodblock, ClassClass, reg2) is written. If reg3 is to be compared to the constant "opc_wide”, “cmp reg3, DEFINED_CONSTANT (opc_wide)" is written. In particular, all references to constants are wrapped inside DEFINED_CONSTANT(..).
- the GET_FIELD instruction is used.
- the SET_FIELD instruction is used.
- "STRUCTURE_ OFFSET(..)” is added to the pointer.
- steps 60 and 62 results in a line for each reference to a constant and a line for each reference to a field. If there are multiple references to a field, each of those references will generate a separate line. It is easier, although not necessary, to process each defined constant and each field only once.
- duplicate lines are deleted to create a constants and fields file (step 64). This may be accomplished by passing the result through "sort -u", a standard utility, which sorts lines and deletes duplicate lines. The sorting of lines is an artifact of the "sort" utility and therefore is unimportant.
- a new generating language program with a stylized header and footer is then created (step 66). Each line is associated with a macro call, which is defined in the header.
- the line LOAD_STORE ⁇ structure> ⁇ field> becomes LOAD STORE ( ⁇ structure>, ⁇ field>).
- the specific header and trailer information and the exact code generated for each line is dependent on the generating language. This operation is more fully appreciated with the following example.
- the constants and fields file created by step 64 is processed by a text processor called "nawk".
- the program that the text processor runs is contained in the file "extract_offsets.nawk”.
- the "nawk” program generates a C program (a generating language program) that has three parts.
- the first part is a stylized header, for example:
- the compiler is given specific switches to tell it to generate assembly language for the target machine, rather than to generate a binary file.
- the stylized generating language file from step 66 is specifically designed so that it generates highly stylized assembly-language code.
- the code may be stylized to the point that it cannot be actually assembled into machine code. All that is necessary is that the resulting assembly language code be machine- parseable so that one can determine (1) the value that the compiler gave to each constant and (2) the size (number of bytes), offset, and signedness of each of the fields.
- the result of this step will always be assembly language, regardless of the inheriting language. It is coincidental that in the present example, that the original inheriting language is also assembly language.
- the .s file has the following form for each of the SHOWME, CONSTANT, and FIELDOFF items, respectively:
- SET_STRUCTURE_INFO ( ⁇ structure>, ⁇ field>, ⁇ size>, ⁇ offset>, ⁇ signedness>)
- SET_VALUE ( ⁇ name>, ⁇ value>)
- SET_FIELD_OFFSET ( ⁇ structure>, ⁇ field>, ⁇ offset>).
- the 16 is again the offset of the field.
- the "2” indicates that this is a 2-byte quantity.
- the "1” indicates that this is a signed value (an unsigned value would assign a "0" to this field).
- the .s file generated will have additional information. It will specifically have the lines:
- the .c file is compiled into assembly for the target platform.
- the macros are written in such a way that all the constant values, field offsets, etc., are generated for the target machine.
- the .s file is processed by extracting lines that contain the word SET. For example, one can create the file “executeJava_sparc.include” by extracting lines containing the word SET. This can be done using the UNIX command "grep”, e.g., "grep SET extractoffsets.s executeJava_sparc.include”.
- the next processing step is to combine the compiled constants and field parameters with the original inheriting language program. That is, for each occurrence of DEFINED_CONSTANT( ⁇ name>), replace it with the exact value of the constant.
- GET_FIELD( ⁇ reg>, ⁇ structure>, ⁇ field>, ⁇ result>) convert it into specific inheriting language instructions necessary to access the value.
- the final inheriting language program 47 is a combination of the original program text with the result of the processing of the cross compiler 46.
- the opcodes st.1.0, st.1.1, st.2.0, st.2.1, st.4.0, st.4.1, Id.1.0, Id.1.1, ld.2.0, ld.2.1, ld.4.0, ld.4.1 are defined to be the appropriate opcodes for storing and loading the appropriately sized field of the appropriate sign.
- "ld.2.1” is defined to be "ldsh' (load a signed half-word).
- Fig. 5 illustrates an alternate apparatus for practicing the invention.
- Fig. 5 corresponds to Fig. 1 , but includes a storage device 80, a commxmications interface 82, a network link 84, and a network 86.
- the programs stored in the memory 24 may be downloaded from a computer-readable medium associated with the storage device 80, or alternately, may be executed from the computer-readable medium associated with the storage device 80.
- the term "computer-readable medium” refers to any medium that participates in providing instructions to the processor 22 for execution. Such a medium may take many forms, including but not limited to, non- volatile media, volatile media, and transmission media.
- Non-volatile media includes, for example, optical or magnetic disks, associated with the storage device 110.
- Volatile media includes dynamic memory.
- Transmission media includes coaxial cables, copper wire and fiber optics, including the wires that comprise bus 28. Transmission media can also take the form of acoustic or light waves, such as those generated during radio- wave and infra-red data communications.
- Common forms of computer-readable media include, for example, a floppy disk, a flexible disk, hard disk, magnetic tape, or any other magnetic medium, a CD- ROM, any other optical medium, punchcards, papertape, any other physical medium with patterns of holes, a RAM, a PROM, EPROM, a FLASH-EPROM, any other memory chip or cartridge, a carrier wave as described below, or any other medium from which a computer can read.
- Various forms of computer readable media may be involved in carrying one or more sequences of one or more instructions to processor 22 for execution.
- the instructions may initially be carried on a magnetic disk of a remote computer.
- the remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem.
- a modem local to the computer system 20 can receive the data on the telephone line and use an infra-red transmitter to convert the data to an infra-red signal.
- An infra-red detector coupled to the bus 28 can receive the data carried in the infra-red signal and place the data on bus 28.
- the bus 28 then carries the data to the memory 24, from which the processor 22 retrieves and executes the instructions.
- the instructions received by the memory 24 may optionally be stored on the storage device 80 either before or after execution by the processor 22.
- the computer system 20 also includes a communication interface 82 coupled to the bus 28.
- the communication interface 82 provides a two-way data communication coupled to a network link 84 that is connected to a network 86.
- the communication interface 82 may be an integrated services digital network (ISDN) card or a modem to provide a data communication connection to a corresponding type of telephone line.
- the communication interface 82 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN.
- LAN local area network
- Wireless links may also be implemented.
- the communication interface 82 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.
- the network link 84 typically provides data commumcation through one or more networks, represented by the network 86.
- the network link 84 may provide a connection to a network 88 that includes a host computer operated as an Internet Service Provider (ISP).
- ISP Internet Service Provider
- the ISP in turn provides data communication services through the world wide packet data communication network now commonly referred to as the "Internet”.
- the network 86 uses electrical, electromagnetic or optical signals that carry digital data streams.
- the signals through the various networks and the signals on the network link 84 and through the communication interface 82, which carry the digital data to and from the computer system 20, are exemplary forms of carrier waves transporting the information.
- the computer system 20 can send messages and receive data, including program code, through the network 86, the network link 84, and the commumcation interface 82.
- a server on the network 86 may transmit a requested code for an application program through the network 86, the network link 84, and the communication interface 82.
- the received code may be executed by the processor 22 as it is received and or stored in the storage device 80, or other nonvolatile storage for subsequent execution. In this manner, the computer system 20 may obtain application code in the form of a carrier wave.
Abstract
Description
Claims
Priority Applications (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
EP98963049A EP0960370A4 (en) | 1997-12-12 | 1998-12-10 | Apparatus and method for cross-compiling source code |
AU18155/99A AU1815599A (en) | 1997-12-12 | 1998-12-10 | Apparatus and method for cross-compiling source code |
CA002280698A CA2280698A1 (en) | 1997-12-12 | 1998-12-10 | Apparatus and method for cross-compiling source code |
JP53273499A JP2001511283A (en) | 1997-12-12 | 1998-12-10 | Apparatus and method for cross-compiling source code |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US08/989,848 US5946489A (en) | 1997-12-12 | 1997-12-12 | Apparatus and method for cross-compiling source code |
US08/989,848 | 1997-12-12 |
Publications (1)
Publication Number | Publication Date |
---|---|
WO1999031583A1 true WO1999031583A1 (en) | 1999-06-24 |
Family
ID=25535528
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US1998/026285 WO1999031583A1 (en) | 1997-12-12 | 1998-12-10 | Apparatus and method for cross-compiling source code |
Country Status (6)
Country | Link |
---|---|
US (1) | US5946489A (en) |
EP (1) | EP0960370A4 (en) |
JP (1) | JP2001511283A (en) |
AU (1) | AU1815599A (en) |
CA (1) | CA2280698A1 (en) |
WO (1) | WO1999031583A1 (en) |
Families Citing this family (44)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6960133B1 (en) | 2000-08-28 | 2005-11-01 | Igt | Slot machine game having a plurality of ways for a user to obtain payouts based on selection of one or more symbols (power pays) |
US6195743B1 (en) * | 1999-01-29 | 2001-02-27 | International Business Machines Corporation | Method and system for compressing reduced instruction set computer (RISC) executable code through instruction set expansion |
US6442680B1 (en) | 1999-01-29 | 2002-08-27 | International Business Machines Corporation | Method and system for compressing reduced instruction set computer (RISC) executable code |
US6769985B1 (en) | 2000-05-31 | 2004-08-03 | Igt | Gaming device and method for enhancing the issuance or transfer of an award |
US7695363B2 (en) | 2000-06-23 | 2010-04-13 | Igt | Gaming device having multiple display interfaces |
US7699699B2 (en) | 2000-06-23 | 2010-04-20 | Igt | Gaming device having multiple selectable display interfaces based on player's wagers |
US7100153B1 (en) * | 2000-07-06 | 2006-08-29 | Microsoft Corporation | Compiler generation of a late binding interface implementation |
US7150010B1 (en) | 2000-07-06 | 2006-12-12 | Microsoft Corporation | Unification of a programming language and a definition language |
US6935955B1 (en) | 2000-09-07 | 2005-08-30 | Igt | Gaming device with award and deduction proximity-based sound effect feature |
US6739973B1 (en) | 2000-10-11 | 2004-05-25 | Igt | Gaming device having changed or generated player stimuli |
US6993744B2 (en) * | 2000-12-19 | 2006-01-31 | Tajen Corporation | Method for enabling a compiler or interpreter to use identifiers found at run time in a map container object in a manner similar or identical to identifiers declared at compile time |
US7040983B2 (en) | 2001-03-21 | 2006-05-09 | Igt | Gaming device having a multi-round, multi-characteristic matching game |
US20030005048A1 (en) * | 2001-06-13 | 2003-01-02 | Rivar Technologies, Inc. | System and method for integrated web-based software code environment |
US6984176B2 (en) * | 2001-09-05 | 2006-01-10 | Pointstreak.Com Inc. | System, methodology, and computer program for gathering hockey and hockey-type game data |
US7901291B2 (en) | 2001-09-28 | 2011-03-08 | Igt | Gaming device operable with platform independent code and method |
US7666098B2 (en) | 2001-10-15 | 2010-02-23 | Igt | Gaming device having modified reel spin sounds to highlight and enhance positive player outcomes |
US7708642B2 (en) | 2001-10-15 | 2010-05-04 | Igt | Gaming device having pitch-shifted sound and music |
US6848996B2 (en) | 2001-10-15 | 2005-02-01 | Igt | Gaming device with sound recording changes associated with player inputs |
US7073168B2 (en) * | 2001-12-06 | 2006-07-04 | Microsoft Corporation | Customizing binary content files |
US7237233B2 (en) * | 2002-12-19 | 2007-06-26 | Texas Instruments Incorporated | Assembly directives for the support of multi-language programming |
US7143400B2 (en) * | 2003-02-07 | 2006-11-28 | Sun Microsystems, Inc. | Configuration description language value management method and system |
US7789748B2 (en) * | 2003-09-04 | 2010-09-07 | Igt | Gaming device having player-selectable music |
US7105736B2 (en) | 2003-09-09 | 2006-09-12 | Igt | Gaming device having a system for dynamically aligning background music with play session events |
US20060074910A1 (en) * | 2004-09-17 | 2006-04-06 | Become, Inc. | Systems and methods of retrieving topic specific information |
US8043155B2 (en) | 2004-10-18 | 2011-10-25 | Igt | Gaming device having a plurality of wildcard symbol patterns |
US7668822B2 (en) * | 2004-12-23 | 2010-02-23 | Become, Inc. | Method for assigning quality scores to documents in a linked database |
US7797344B2 (en) * | 2004-12-23 | 2010-09-14 | Become, Inc. | Method for assigning relative quality scores to a collection of linked documents |
JP2008537248A (en) | 2005-04-22 | 2008-09-11 | エヌエックスピー ビー ヴィ | Perform multitasking on a digital signal processor |
CN100442234C (en) * | 2005-06-21 | 2008-12-10 | 国际商业机器公司 | Software package constructing method and system for embedded system |
US8356053B2 (en) * | 2005-10-20 | 2013-01-15 | Oracle International Corporation | Managing relationships between resources stored within a repository |
US7917856B2 (en) * | 2005-10-24 | 2011-03-29 | Sap Ag | Converting between user interface technologies |
US7693868B2 (en) | 2005-12-30 | 2010-04-06 | Sap Ag | Separation of employee data for different applications |
US9058203B2 (en) * | 2006-11-20 | 2015-06-16 | Freescale Semiconductor, Inc. | System, apparatus and method for translating data |
US8591308B2 (en) | 2008-09-10 | 2013-11-26 | Igt | Gaming system and method providing indication of notable symbols including audible indication |
CA2698066A1 (en) * | 2009-07-31 | 2011-01-31 | Nitobi Software Inc. | System and method for remotely compiling multi-platform native applications for mobile devices |
US9262778B2 (en) * | 2011-04-06 | 2016-02-16 | Ebay Inc. | Methods and systems for storefront generation |
US8460090B1 (en) | 2012-01-20 | 2013-06-11 | Igt | Gaming system, gaming device, and method providing an estimated emotional state of a player based on the occurrence of one or more designated events |
US8910115B2 (en) * | 2012-04-02 | 2014-12-09 | Kony Solutions, Inc. | Systems and methods for application development |
US9245407B2 (en) | 2012-07-06 | 2016-01-26 | Igt | Gaming system and method that determines awards based on quantities of symbols included in one or more strings of related symbols displayed along one or more paylines |
US8740689B2 (en) | 2012-07-06 | 2014-06-03 | Igt | Gaming system and method configured to operate a game associated with a reflector symbol |
US9192857B2 (en) | 2013-07-23 | 2015-11-24 | Igt | Beat synchronization in a game |
US9329875B2 (en) * | 2014-04-28 | 2016-05-03 | International Business Machines Corporation | Global entry point and local entry point for callee function |
US9740463B2 (en) | 2015-08-10 | 2017-08-22 | Oracle International Corporation | Mechanism for increasing the performance of multiple language programs by inserting called language IR into the calling language |
US9947170B2 (en) | 2015-09-28 | 2018-04-17 | Igt | Time synchronization of gaming machines |
Citations (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4558413A (en) * | 1983-11-21 | 1985-12-10 | Xerox Corporation | Software version management system |
US5511167A (en) * | 1990-02-15 | 1996-04-23 | Hitachi, Ltd. | Program processing method and apparatus for producing a data flow type program |
US5768593A (en) * | 1996-03-22 | 1998-06-16 | Connectix Corporation | Dynamic cross-compilation system and method |
US5778233A (en) * | 1996-10-11 | 1998-07-07 | International Business Machines Corporation | Method and apparatus for enabling global compiler optimizations in the presence of exception handlers within a computer program |
US5857093A (en) * | 1996-09-20 | 1999-01-05 | Allen-Bradley Company, Llc | Cross-compiled simulation timing backannotation |
Family Cites Families (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4667290A (en) * | 1984-09-10 | 1987-05-19 | 501 Philon, Inc. | Compilers using a universal intermediate language |
CA1248238A (en) * | 1985-10-17 | 1989-01-03 | Francis D. Lawlor | Compiler including retargetable data generation |
US5557776A (en) * | 1992-05-18 | 1996-09-17 | International Business Machines Corporation | Apparatus which allows data sharing amongst computer program from different program environments |
-
1997
- 1997-12-12 US US08/989,848 patent/US5946489A/en not_active Expired - Lifetime
-
1998
- 1998-12-10 EP EP98963049A patent/EP0960370A4/en not_active Withdrawn
- 1998-12-10 JP JP53273499A patent/JP2001511283A/en not_active Ceased
- 1998-12-10 CA CA002280698A patent/CA2280698A1/en not_active Abandoned
- 1998-12-10 WO PCT/US1998/026285 patent/WO1999031583A1/en not_active Application Discontinuation
- 1998-12-10 AU AU18155/99A patent/AU1815599A/en not_active Abandoned
Patent Citations (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4558413A (en) * | 1983-11-21 | 1985-12-10 | Xerox Corporation | Software version management system |
US5511167A (en) * | 1990-02-15 | 1996-04-23 | Hitachi, Ltd. | Program processing method and apparatus for producing a data flow type program |
US5768593A (en) * | 1996-03-22 | 1998-06-16 | Connectix Corporation | Dynamic cross-compilation system and method |
US5857093A (en) * | 1996-09-20 | 1999-01-05 | Allen-Bradley Company, Llc | Cross-compiled simulation timing backannotation |
US5778233A (en) * | 1996-10-11 | 1998-07-07 | International Business Machines Corporation | Method and apparatus for enabling global compiler optimizations in the presence of exception handlers within a computer program |
Non-Patent Citations (4)
Title |
---|
CHEN H, ET AL.: "EXPERIENCES IN DEVELOPING AN ADA CROSS COMPILER", TRI-ADA. CONFERENCE PROCEEDINGS, XX, XX, 1 October 1991 (1991-10-01), XX, pages 54 - 62, XP002917562 * |
PERUGINI M A: "A FLEXIBLE APPROACH TO TEST PROGRAM CROSS COMPILERS", PROCEEDINGS OF THE INTERNATIONAL TEST CONFERENCE. NASHVILLE, OCT. 28 - 30, 1991., NEW YORK, IEEE., US, 1 October 1991 (1991-10-01), US, pages 1079 - 1086, XP002917561, ISBN: 978-0-8186-9156-0 * |
See also references of EP0960370A4 * |
WESLEY A: "COMPILERS PRINCIPLES, TECHNIQUES, AND TOOLS", COMPILERS PRINCIPLES, TECHNIQUES AND TOOLS, XX, XX, 1 March 1988 (1988-03-01), XX, pages 723 - 732, XP002917560 * |
Also Published As
Publication number | Publication date |
---|---|
EP0960370A4 (en) | 2006-01-04 |
US5946489A (en) | 1999-08-31 |
JP2001511283A (en) | 2001-08-07 |
CA2280698A1 (en) | 1999-06-24 |
AU1815599A (en) | 1999-07-05 |
EP0960370A1 (en) | 1999-12-01 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US5946489A (en) | Apparatus and method for cross-compiling source code | |
US7032210B2 (en) | Method and system for generating program source code of a computer application from an information model | |
Wile | Abstract syntax from concrete syntax | |
US7665073B2 (en) | Compile time meta-object protocol systems and methods | |
US8701081B2 (en) | Hardware specific code generation | |
US5161216A (en) | Interprocedural slicing of computer programs using dependence graphs | |
EP1178404B1 (en) | Method and system for compiling multiple languages | |
JP3762867B2 (en) | Compiler device, compiling method, and storage medium storing program therefor | |
US7565364B1 (en) | Annotation processor discovery | |
US20080046868A1 (en) | Method and system for template-based code generation | |
US20040172234A1 (en) | Hardware accelerator personality compiler | |
JP4118456B2 (en) | Program language processing system, code optimization method, and machine-readable storage medium | |
JP2006085740A (en) | Application software configuration method | |
Miecznikowski et al. | Decompiling Java using staged encapsulation | |
JP2001084147A (en) | Device and method for converting character string, and recording medium | |
JP2002525744A (en) | Compiling method and system for text object | |
US8615729B2 (en) | Extending existing model-to-model transformations | |
JPH09509271A (en) | Methods and processes for inter-computer communication and generalized methods for writing programs therefor | |
CN112379917A (en) | Browser compatibility improving method, device, equipment and storage medium | |
US8935657B2 (en) | Model-to-model transformation by kind | |
US20040268323A1 (en) | Program converting method, program and storage medium | |
US20030115571A1 (en) | Construction of a software application from a plurality of programming languages | |
JP3266097B2 (en) | Automatic reentrant method and system for non-reentrant program | |
GB2420638A (en) | Method of substituting code fragments in Internal Representation | |
CN110502483A (en) | Data processing method, device, computer equipment and storage medium |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AK | Designated states |
Kind code of ref document: A1 Designated state(s): AL AM AT AU AZ BA BB BG BR BY CA CH CN CU CZ DE DK EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT UA UG UZ VN YU ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A1 Designated state(s): GH GM KE LS MW SD SZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
ENP | Entry into the national phase |
Ref document number: 2280698 Country of ref document: CA Ref country code: CA Ref document number: 2280698 Kind code of ref document: A Format of ref document f/p: F |
|
ENP | Entry into the national phase |
Ref country code: JP Ref document number: 1999 532734 Kind code of ref document: A Format of ref document f/p: F |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
WWE | Wipo information: entry into national phase |
Ref document number: 1998963049 Country of ref document: EP |
|
WWP | Wipo information: published in national office |
Ref document number: 1998963049 Country of ref document: EP |
|
REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
WWW | Wipo information: withdrawn in national office |
Ref document number: 1998963049 Country of ref document: EP |