Abstract: A data processing system 118 is provided that supports execution of both native instructions using a processor core and non-native instructions that are interpreted using either a hardware translator 122 or a software interpreter. Separate explicit return to non-native instructions and return to native instructions are provided for terminating subroutines whereby intercalling between native and non-native code may be achieved with reduced processing overhead. Veneer non-native subroutines may be used between native code and non-native main subroutines. The veneer non-native subroutines may be dynamically created within the stack memory region of the native mode system.

Abstract: In a data processing apparatus 2 having a first mode of operation in which JAVA® bytecodes 46, 48 specify the processing operations and a second mode of operation in which other instructions specify the processing operations. In order to speed operation, the JAVA® Local Variable 0, or another such variable, is stored within a register of a register bank 14 to be available for rapid access. This storage is in a write-through manner such that reads of the value will be directly serviced from the register R4 and writes to the data value will be made in both the register R4 and back in the original memory location for that data value as determined by the JAVA® Virtual Machine.

Abstract: Techniques for increasing the performance of virtual machines are disclosed. It can be determined whether a program instruction which is to be executed by the virtual machine is a branch instruction, and whether a basic block of code is present in a code cache. If so, the basic block of code can be executed. The basic block includes code that can be executed for the program instruction. A cache can be used to store the basic block for program instructions that are executed by the virtual machine. The program instruction may be a bytecode and the code cache can be implemented as a native code cache.

Abstract: Techniques for customization of JAVA runtime environments are disclosed. The techniques can be used to provide JAVA runtime environments that are specifically tailored for various JAVA applications. Accordingly, for a particular JAVA application, an optimized runtime environment can be created. One or more optional attributes which represent the desired runtime customizations are generated. As will be appreciated, the optional attributes can be generated in the attribute table in the class file. The optional attributes can then be parsed and appropriate features can be loaded into the virtual machine. In this way, JAVA runtime environments can be customized based on a particular JAVA application requirement. Moreover, customizations can be automated using a runtime performance manager that interacts with various other components that operate to first generate and then load optional attributes into the JAVA runtime environment.

Abstract: A mobile information device may execute a Java MIDlet or a non-MIDlet application. The mobile information device may further include an object-oriented application program interface that allows one or more object-oriented object classes to allow input and output data to be communicated between Java MIDlets in different MIDlet Suites and between non-MIDlet applications. The application program interface may be used to allow applications to access a universal message handler executing on the mobile information device.

Abstract: Improved techniques for representation of objects in a Java™ programming environment are disclosed. The techniques are highly suitable for representation of Java™ objects inside virtual machines, especially those that operate with limited resources (e.g., embedded systems). In accordance with one embodiment, a Java™ object representation is disclosed. As will be appreciated, the Java™ object representation provides a reference that can be used to directly access the internal class representation associated with the object. The internal class representation provides information regarding the Java™ object (e.g., object size, object type, static fields, etc.) As a result, information regarding Java™ objects can quickly be accessed. This means that the processing time conventionally needed to access information regarding Java™ objects is reduced. Thus, performance of virtual machines, especially in systems with limited computing power and/or memory, can be enhanced.

Abstract: A hardware Java™ accelerator is provided to implement portions of the Java™ virtual machine in hardware in order to accelerate the operation of the system on Java™ bytecodes. The Java™ hardware accelerator preferably includes Java™ bytecode translation into native CPU instructions. The combination of the Java™ hardware accelerator and a CPU provides a embedded solution which results in an inexpensive system to run Java™ programs for use in commercial appliances.

Abstract: Methods and apparatuses for dynamic type checking are described. For one embodiment runtime code generation is used to effect dynamic type checking by generating code specialized to different object types. For one embodiment a virtual dynamic type check (DTC) function is generated for each object at run time. The virtual DTC function contains a sequence of instructions to type check every element (type) within an object's type hierarchy. The virtual DTC function is tailored for a particular type and thus conducts dynamic type checking more efficiently for objects of the particular type. For one embodiment the DTC function can complete type checking of interface type hierarchies. For one embodiment a compiler may determine whether a type is a class type or interface type and may generate a virtual DTC function only for interface types.

Abstract: To meet the current trend in computer programming, a multi-programming-language compiler system is designed to include a compiler framework which creates a general environment in which to carry out compilation and language modules to encapsulate the details of various programming languages. Such a system makes it easy for tool vendors and end users to adapt to a world where computer programs are written in multiple languages. New language modules may be written that add support for new languages to the compiler framework. It may also be possible to extend existing language modules so that a variant on an existing language may be added to the compiler framework. Such a system may also be adapted to permit several different clients to access detailed language information from the compiler framework. These clients may include a standard command-line shell or a sophisticated multi-language integrated development environment.

Abstract: The invention provides a method, system and computer program product for creating a form definition data file using a visual programming development environment on a computer system. The data file is for interpretation by a dialogue management system and is XML-based markup. A graphical program representation of the data file is created in the development environment and is then compiled and executed in order to generate the data file. The program itself is built by linking a main Java bean component and a plurality of Java bean sub-components, all containing characteristic data file information. On running the executable, the main Java bean outputs its respective data file information into the data file and does this by creating a file output stream and writing its respective data file information to that output stream. This action also causes the next and subsequent java bean components to output their respective data file information into the data file.

Abstract: An enhanced Java Bytecode verifier suitable for operation in a Java computing environment is disclosed. The enhanced Java Bytecode verifier operates to determine whether one or more Java conventional Bytecode commands within a stream of Bytecodes are likely to place a reference to a Java object on the execution stack. In one embodiment, the conventional Java Bytecode commands identified as such are translated by the enhanced Java Bytecode verifier into one or more corresponding Java commands. When a corresponding command is executed, the reference associated with the conventional Java command is placed on a reference stack as well as the execution stack.

Abstract: A smaller footprint is loaded into the virtual machine by loading only those methods of library classes that the executed application actually requires. This is accomplished by taking the classes of the targeted application and statically determining which methods of these classes, as well as of the library classes, can actually be used by the application. A generated method usage map of usable methods for each class are saved in a file. At runtime, the virtual machine consults this file and selectively loads into memory only those classes listed in the file. This saves memory space in the virtual machine and speeds execution.

Abstract: Custom application development environment modules may be designed to work with a first application development environment. This functionality may be extended to a second application development environment by first creating user interface elements for the second application development environment. User interface elements from the custom application development environment modules may be separated, forming user interface elements for the first application development environment. New general elements may then be created, which are compatible with both the first application development environment and the second application development environment. The general elements may be combined with non-user interface elements from the custom application development environment modules to arrive at a series of generalized classes.

Abstract: Methods and apparatus for eliminating C recursion from interpreter loops are disclosed. According to one aspect of the present invention, a computer-implemented method for substantially eliminating C recursion from the execution of static initializer methods in a virtual machine environment includes rewriting native C code associated with a static initializer as a Java programming language method, and using a transition frame in a Java programming language stack to execute the Java programming language method. The method also includes using a native method to manipulate the Java programming language stack, and using a first opcode in the transition frame. In one embodiment, using the first opcode in the transition frame includes using the first opcode to determine that the transition frame is associated with the static initializer.

Abstract: An embodiment of the present invention is a consolidated package for diverse platforms to interoperate and transfer data. It allows otherwise incompatible systems to communicate with each other, exchange information, and otherwise interact. An embodiment of the present invention translates requests for information into a predetermined format that can be transmitted from a first platform to a second platform. One embodiment may transfer the information in an XML format over the Internet using HTTP or HTTPS. The receiving computer translates the XML stream into a properly formatted request and finds the requested information. The requested information is translated into an XML stream and transmitted over the Internet using HTTPS. The information is then translated into a format that the requesting computer can use. The system and method described herein can be used to exchange data between two computing systems.

Abstract: A method and system for handling device driver interrupts in a computer system. An interrupt handling Method is initiating prior to the occurrence of any interrupts in the computer system. The interrupt handling Method is executed to a waiting state, and execution is then resumed when an interrupt occurs. When an interrupt is detected control is transferred to the operating system and the interrupt is dismissed.

Abstract: A problem determination method, system and program product are provided. Specifically, the present invention identifies problems with software programs by inserting compiled problem determination probes into program classes while the computer system on which the program is loaded is running. Once the probes have been inserted, the classes will be run and trace data will be generated. The trace data can be retrieved and analyzed to identify and address the problem. When the probes are no longer needed, they can be removed while the computer system continues to run.

Abstract: A method for arithmetic overflow detection includes receiving a first instruction defined for a first processor having a first base, where the instruction comprises an operator and at least one operand having an operand type. The method also includes indicating whether the at least one operand has potential overflow based at least in part on the operator and the relationship between the operand type and a result type associated with the operator.

Abstract: A method, system and program product for providing domain level business object keys in Enterprise JavaBeans (EJB) applications. An instance of an EntityBean object is provided with both a primary key and a domain key class. The primary key class is associated with a home selected for the EntityBean object, and the domain key class is associated with a particular business application within which the EntityBean object is being utilized. The EntityBean and associated home is utilized across different business applications, while ensuring uniqueness across the different applications.

Abstract: Disclosed is a system, method, and program for accessing variables, such as environment variables, from an operating system. An application program executes a command to store at least one variable maintained by the operating system in a data object accessible to the application program. The application program is executing on the operating system. An operating system command is executed in response to the command from the application program to retrieve the requested at least one variable andn store the retrieved at least one variable in the data object.

Abstract: One embodiment of the present invention provides a system that dynamically compiles byte codes into native code to facilitate faster execution. This method operates in a mixed-mode system that supports execution of both compiled code and interpreter code. During operation, the system periodically determines if a currently executing thread is executing through the interpreter. If so, the system locates the method being executed by the thread and compiles the byte codes of the method into native code. Subsequent executions of the method utilize the faster-executing native code.

Abstract: A method for designing a software program including multiple modules includes defining an initialization sequence wherein each of the modules is initialized according to a predetermined order. The method also includes defining calling order constraints wherein a first module may call a second module if the first module succeeds the second module in the allowed order. The method also includes creating a program specification for the software program. The program specification includes a module specification for each of the modules and each module specification indicates other modules called by an implementation of the module. According to one aspect, one of a plurality of initialization sequences is selected based upon the presence of one or more markers in a memory.

Abstract: Disclosed are novel methods and apparatus for providing a permissions manager capable of assisting an applet, for example, in determination and/or grant of the permissions required for an operation. In an embodiment, an apparatus for managing permissions is disclosed. The apparatus includes a software application, a permissions manager coupled to the software application and receiving a request sent by the software application, and a programming environment coupled to the permissions manager. The request may indicate a permission, which may be requested by the permissions manager. The permissions manager may access the programming environment to determine a required permission corresponding to the permission and to determine how to grant the required permission.

Abstract: Techniques for generation of Java™ macro instructions suitable for use in Java™ computing environments are disclosed. As such, the techniques can be implemented in a Java™ virtual machine to efficiently execute Java™ instructions. As will be appreciated, a Java™ macro instruction can be substituted for two or more Java™ Bytecode instructions. This, in turn, reduces the number of Java™ instructions that are executed by the interpreter. As a result, the performance of virtual machines, especially those operating with limited resources, is improved. A Java™ macro instruction can be generated for conventional Java™ instruction sequences or sequences of Java™ instruction that are provided in a reduced set of instruction. In any case, sequences that are frequently encountered can be replaced by a Java™ macro instruction. These sequences are typically encountered when Java™ objects are instantiated, during programming loops, and when a local variables are assigned a value.

Abstract: Objects of one object model (e.g., a Common Object Model (COM)) are called by programs of another object model (e.g., Java). To facilitate the call, a set of interfaces is generated that corresponds to the interfaces of a COM typelib. The interfaces include enough information to enable type-checking of the generated code to be performed during compilation, but do not include implementations of the interfaces. The implementations are included in a proxy object, which is employed in making the call to the COM object.

Abstract: A bytecode execution system and method for increasing the execution speed of invoking and returning from Methods while minimizing the memory footprint required to support this. The system includes a virtual machine with a class loader and an interpreter or, alternatively, a hardware accelerator. Speed and memory enhancements are realized by establishing an activation stack frame template with a set of criteria. Each Method from subject code is examined to determine whether the Method conforms to the criteria of the stack frame template. If the Method conforms, an activation frame for that Method based on the activation stack frame template is created when the Method is invoked. Otherwise, an activation frame based on standard virtual machine criteria is created. An access structure is associated with each Method and a Method routing structure is created for each class.

Abstract: The present invention is a method and system to support debug. A function is re-compiled when a field watch for a field is activated. The function includes a byte code sequence having a field byte code that accesses or modifies the field. The re-compiled function provides a native code and occupies a code space. An instrumentation code corresponding to the field watch of the field is generated. The instrumentation code is inserted to the native code.

Abstract: The present invention is a method and system to support debug. A function is compiled. The function includes a byte code sequence having a field byte code that accesses or modifies a field. The compiled function provides a native code and occupies a code space. An instrumentation code corresponding to a field match of a field is generated. The instrumentation code is inserted to the native code.

Abstract: The present invention is a new method and apparatus to perform combined compilation and verification of platform independent bytecode instruction listings into optimized machine code. More specifically, the present invention creates a new method and apparatus in which bytecode compilation instructions are combined with bytecode verification instructions, producing optimized machine code on the target system in fewer programming steps than traditionally known. The new method, by combining the steps required for traditional bytecode verification and compilation, increases speed and applicability of platform independent bytecode instructions.

Abstract: Techniques for customization of Java runtime environments are disclosed. The techniques can be used to provide Java runtime environments that are specifically tailored for various Java applications. Accordingly, for a particular Java application, an optimized runtime environment can be created. One or more optional attributes which represent the desired runtime customizations are generated. As will be appreciated, the optional attributes can be generated in the attribute table in the class file. The optional attributes can then be parsed and appropriate features can be loaded into the virtual machine. In this way, Java runtime environments can be customized based on a particular Java application requirement. Moreover, customizations can be automated using a runtime performance manager that interacts with various other components that operate to first generate and then load optional attributes into the Java runtime environment.

Abstract: Improved techniques for representation of Java data types in Java computing environments are disclosed. A word consisting of four bytes is used to represent primitive and non-primitive Java data types. As will be appreciated, the Java data type representations can be used by a Java virtual machine to efficiently represent various Java data types encountered in Java computing environments. As a result, various components that can represent Java data types (e.g., signatures of Java methods) can efficiently be constructed.

Abstract: A dual instruction set processor can decode and execute both code received from a network and other code supplied from a local memory. Thus, the dual instruction set processor is capable of executing two different types of instructions, from two different sources, permitting the dual instruction set processor to have maximum efficiency. A computer system with the foregoing described dual instruction set processor, a local memory, and a communication interface device, such as a modem, for connection to a network, such as the Internet or an intranet, can be optimized to execute, for example, JAVA code from the network, and to execute non-JAVA code stored locally, or on the network but in a trusted environment or an authorized environment.

Abstract: The present invention pertains to techniques for creating and maintaining objects in object-oriented environments. The techniques are especially well suited for Java programming environments. In accordance with one aspect of the invention, specialized Java heaps are disclosed. In contrast to conventional heaps, the specialized Java heap is designated for storing Java objects with similar traits in the same memory portion. As such, objects with similar traits can be allocated and maintained in a designated memory portion. Another aspect of the invention provides methods for allocating objects in the heap memory. These methods can be used to create and associate objects with similar traits in a specialized heap. As will be appreciated, objects can be created and maintained more efficiently in this manner. As a result, the performance of virtual machines, especially those operating with relatively limited resources (e.g., embedded systems), is improved.

Abstract: Techniques for implementing virtual machine instructions suitable for execution in virtual machines are disclosed. The operations performed by conventional instructions can be performed by relatively fewer inventive virtual machine instructions. Furthermore, the virtual machine instructions can be used to perform operations that cannot readily be performed by conventional Java Bytecode instructions. Thus, a more elegant, yet robust, virtual machine instruction set can be implemented.

Abstract: Disclosed is a system, method, and program for translating source code statements to executable code. A source code statement including an application program interface (API) that is a member of a set of standard APIs calling an object in a first format is processed. A mapping is used to determine at least one user interface API corresponding to the determined standard API. The user interface API provides an implementation of the standard APIs in a user interface program. A mapping is determined of the called object to a corresponding object in a second format utilized by the user interface program is accessed. The source code statement comprising the standard API calling the object in the first format is converted to the determined user interface API calling the corresponding object in the second format. The user interface program is capable of executing the user interface API calling the corresponding object.

Abstract: When a program transmission apparatus divides a program into a plurality of partial programs before transmission, a program reception execution apparatus executes a partial program when the partial program has already been received, and, when the execution needs to proceed to from a present partial program to a next partial program, executes the other partial program when the next partial program has been received.

Abstract: A system and method for isolating the execution of a plurality of applications. The applications may utilize or share one or more “original” classes. Only one copy of each original class is maintained, regardless of how many applications utilize it. Static fields are extracted from the original classes. A separate copy of the static fields is created for each of the utilizing applications. A static field class which includes instance fields corresponding to the static fields may be created, wherein each instance of the static field class corresponds to one of the utilizing applications. Access methods for the one or more static fields may be created, wherein the access methods are operable to access the corresponding separate copy of the static fields based upon the identity of the utilizing application. A single access methods class may be created for each original class, wherein the single access methods class includes the access methods for accessing the extracted fields from the original class.

Abstract: A computer system has one or more program classes loaded in it. Each class includes a constant pool which is used for storing data items related to the program class. At least some of these data items need to undergo a resolution before they can be used, which transforms them from their initially loaded value into a usable value. In accordance with the invention, the system maintains both the unresolved value and the resolved value in the constant pool entry for a resolved data item. This allows the resolution process to be performed without using locks, thereby avoiding potential system delays due to contention for locks.

Abstract: A modified JAVA(™) execution environment is described. The modified environment supports multiple JAVA(™) applications on a single JAVA(™) virtual machine (JVM). This modified environment provides significant memory and performance improvements when running multiple applications on a single computer system. Notably, no changes are needed to the source code of an application to take advantage of the modified environment. Further, embodiments of the invention may support shared access to base classes through the use of overlays. Additionally, system resource permissions can be enforced based upon the user permissions associated with a running application. Notably, embodiments of the invention allow multiple applications to share the abstract window toolkit (AWT) on a per display basis. Since only a single garbage collection routine is necessary, applications see improved performance relative to running in different JVMs. Further, the shared base classes eliminate significant memory overhead.

Abstract: A method is provided that enables native code, dynamically compiled from platform-independent code by one task of a multitasking virtual machine, to be used by other tasks. The system interprets the platform-independent code of a method for a threshold number of interpretations, and then produces class initialization dependent (CID) native code. The runtime of the system guarantees that a task uses CID code of a method only when all of the classes of an initialized set associated with the CID code have been initialized by the task, and otherwise, interprets the platform-independent code of the method. This allows the compiler to avoid generating class initialization barriers for classes from the initialized set. After a threshold number of failures to execute the CID code of a method, task re-entrant code is generated to replace the interpretation of its platform-independent code.

Abstract: A method and system for detecting and counting bytecode sequences in a data processing system is provided. A bytecode tree data structure is used to represent sequences of bytecodes. A bytecode sequence is a subset of consecutive bytecodes within the set of bytecodes. The bytecode tree data structure contains a set of nodes in which each node represents a bytecode in a bytecode sequence or subsequence and in which a path through the bytecode tree data structure represents a bytecode sequence or subsequence. Each node of the bytecode tree data structure records one or more bytecode occurrence statistics for its corresponding bytecode in a set of bytecode sequences or subsequences. In order to determine the frequency of occurrence of common bytecode sequences and subsequences, a bytecode sequence tree data structure is generated from a set of bytecode sequences.

Abstract: Techniques for executing synchronized Java methods are disclosed. As such, the techniques can be implemented in a Java virtual machine to efficiently execute Java instructions. As will be appreciated, monitors (e.g., locks) associated with Java objects for which the synchronized method are being performed are accessed quickly. In other words, the monitors can be quickly released without having to repeat several time-consuming operations which have to be performed in conventional systems. This, in turn, reduces the number of operations that need to be performed to execute synchronized Java methods. As a result, the performance of virtual machines, especially those operating with limited resources, is improved.

Abstract: According to the preferred embodiments, an object oriented mechanism and method allow creating system level Java code that is protected, and therefore cannot be accessed or extended by unauthorized users or programs. Several new tests are performed during loading, linking, and initialization of a class that assure that the class is as the operating system expects. In addition, one or more runtime tests may be performed to prevent programs from getting into the Java system level code via a runtime “back door.” By providing additional tests when classes are loaded and when certain types of methods and functions are invoked at runtime, the Java system level code is protected from unauthorized access and use.

Abstract: Methods and apparatus for eliminating C recursion from interpreter loops are disclosed. According to one aspect of the present invention, a computer-implemented method for substantially eliminating C recursion from the execution of static initializer methods in a virtual machine environment includes rewriting native C code associated with a static initializer as a Java™ method, and using a transition frame in a Java™ stack to execute the Java™ method. The method also includes using a native method to manipulate the Java™ stack, and using a first opcode in the transition frame. In one embodiment, using the first opcode in the transition frame includes using the first opcode to determine that the transition frame is associated with the static initializer. In another embodiment, the method further includes causing the static initializer to run, wherein the static initializer using a second opcode, and resuming execution at the second opcode after the static initializer has run.

Abstract: A method of software development comprising the steps of determining, through Java reflection API calls, a current software signature for each Java object, from a Java software application comprising Java application code, to be administered by a software development wizard, retrieving from a deployment descriptor a Java object deployment description for each said Java object, and detecting changes in the Java application code, wherein detecting changes includes contrasting the current software signatures and the retrieved Java object deployment descriptions. Exemplary embodiments also include displaying, for user revision through a user interface, representations of the detected changes in the Java application code, wherein user revision includes user confirmation of detected changes, recording user revisions in the deployment descriptor, and conforming the Java application code to the user revisions.

Abstract: A method and apparatus which comprises, as part of compiling source code into native code, identifying a source code block in the source code to optimize using register promotion, and optimizing the source code block using a register promotion transformation. Thereafter, compensation native code is generated to update those memory locations whose values were promoted using register promotion with the up-to-date values from registers associated with the memory locations. As a result native code corresponding to any existing source code exception handler associated with the source code block will have access to the up-to-date memory locations during program execution.

Abstract: A generic Java rule engine framework that will permit a rule engine to be called based upon events captured from objects without requiring object programmers to explicitly insert hooks for calling the rule engine within the objects. A business-to-business electronic marketplace can be outfitted with such a framework for acting upon events occurring within objects. The framework comprises utilizing a standard Java debugging interface to accept events and a rule engine to act upon such events.

Abstract: Methods and apparatus for a platform independent object to bind to and access platform dependent software are disclosed. According to one aspect of the present invention, a software object that includes a wrapper and an associated platform dependent software. The platform independent object calls the wrapper. The wrapper, in turn, directly calls the associated platform dependent method. In this way, a platform independent object accesses the platform dependent method by directly calling the wrapper associated with the method.

Abstract: Disclosed is a system, method, and program for providing a plurality of translator programs for translating source code in a cross-platform computer language, such as Java, to program statements capable of executing on multiple operating system platforms. The translator programs determine whether a source code statement in an application program comprises an application program interface (API) that is a member of a set of standard API interfaces, such as the API interfaces specified in the W3C DOM specification. The translator programs determine from a mapping at least one native operating system API interface corresponding to the determined standard API interface. Native operating system API interfaces provide an implementation of the standard API interfaces. The translator programs further convert the source code statement comprising the standard API interface to the determined native operating system API interface.

Abstract: A process and system for dynamically compiling a partially interpreted method is provided. A set of bytecodes for a method is interpreted within a virtual machine. During the interpretation of the method, it is determined, according to the satisfaction of predetermined criteria, that the method contains an execution hot spot and should be just-in-time compiled (JITed) in order to increase the processing speed of the method. The interpretation of the method is halted with a halted execution state and at a halted execution location. Another method is constructed using information from the partially interpreted method and its execution state. The newly constructed method is just-in-time compiled and invoked in such a manner that the newly constructed method recreates the execution state of the partially interpreted method. Once the newly constructed method recreates the execution state of the partially interpreted method, the execution flow follows the bytecode sequence of the partially interpreted method.