Abstract: A system and method for use with an enterprise system or software development system, for determining or checking for dependencies between software components, or between other components of said system. The system utilizes a module architecture specification language and toolkit to check system code for compliance against a set of rules or requisites. The module architecture specification can be structured into product-wide groundrules applicable to all subsystems, subsystem-, layer-, module-specific, and thin-client/server rules. In accordance with one embodiment, the system can be used to allow, forbid, or constrain certain dependencies between software modules, or between the building blocks, organization components, or products that make up a large enterprise system.

Abstract: A computer system which dynamically extracts multiple threads from a program using a thread binary compiler (TBC), and a simultaneous multithreading (SMT) method. The computer system loads the TBC to a cache and controls the cache such that the TBC divides the program into multiple threads, and the cache loads the program as a recompiled program, whenever the cache loads a program stored in main memory.

Abstract: A technique is presented for determining the defining ClassLoader class of a Java class as it is being defined within a Java Virtual Machine (JVM) by instrumenting the “java.lang.ClassLoader” class. Within a JVM, all ClassLoader instances call one of the “defineClass” methods of class “java.lang.ClassLoader” in order to pass the raw bytes for loaded a class to the JVM to have it defined as a Java class. Therefore, instrumentation code is inserted into the “defineClass” methods of class “java.lang.ClassLoader”; the instrumentation code stores an identity of the defining ClassLoader prior to the invocation of the class load hook by the JVM, which can use the identity of the defining ClassLoader for various purposes.

Abstract: A system and method are disclosed for enabling injection of non-native code into a JAVA environment. The method provides a software hook for detecting the loading of a JAVA interpreter, and then creates a connection that communicates with an executing JAVA application. A method is also provided that loads in a customized CLASSLOADER module, wherein the customized CLASSLOADER module identifies a location of non-native code, and then loads in the non-native code identified by the customized CLASSLOADER module.

Abstract: An apparatus and method provide a controlled, dynamically loaded, modular, cryptographic implementation for integration of flexible policy implementations on policy engines, and the like, into a base executable having at least one slot. The base executable may rely on an integrated loader to control loading and linking of fillers and submodules. A policy module may be included for use in limiting each module's function, access, and potential for modification or substitution. The policy may be implemented organically within a manager layer or may be modularized further in an underlying engine layer as an independent policy, or as a policy created by a policy engine existing in an engine layer. The policy module is subordinate to the manager module in the manager layer in that the manager module calls the policy module when it is needed by the manager module. The policy module is preferably dynamically linkable, providing flexibility, and is layered deeper within the filler module than the manager module.

Abstract: Provided is a method, system, program, and data structures for installing components in a computer runtime environment. A kit file is retrieved including information on program components to load into memory. The retrieved kit file information is used to retrieve the program components for the kit file. The retrieved program components for the kit file are loaded into the runtime environment. A determination is made as to whether there are dependency kit files associated with the retrieved kit file. Program components for each determined dependency kit file are maintained in the runtime environment, wherein classes and interfaces are resolved using the program components loaded into the runtime environment.

Abstract: An authoring system prepares a specified set of classes for preloading in client devices lacking a virtual memory manager. The authoring system converts the specified set of classes into a plurality of resource modules, a subset of the resource modules each including items that have pointers to items in other ones of the resource modules. The authoring system generates a load module, for loading into the client devices, that includes the plurality of resource modules, an interpreter and a startup procedure. The interpreter is for executing, on the client devices, programs in a predefined computer language. The specified set of classes includes methods in the predefined computer language. The startup procedure is for execution by the client devices when loading the interpreter for execution. The startup procedure replaces pointers in the resource modules with updated pointers in accordance with actual memory locations of the resource modules in any particular one of the client devices.

Abstract: A computer method for patching applications that are incompatible with an operating system is provided. The method determines if an application is compatible with an operating system, and if the application is determined to be incompatible, a shim dynamic link library is loaded that replaces all of the incompatible functions contained within the application's dynamic link libraries.

Abstract: The present invention relates to a mechanism for copying selected routines from shared libraries into application programs thereby generating optimized application programs for more rapid execution of the various applications within a computer system. Since optimized programs occupy space on disk and in RAM, programs are preferably selected for optimization based on their frequency of execution and the frequency with which calls are made to the shared libraries. Profile information may be used to identify the execution efficiency of the various application programs and thereby identify the best candidates for optimization. Further, profile information may be employed to copy individual routines contained within the libraries rather than having to copy an entire library where only one routine within the library was of interest.

Abstract: An architecture for extending the Java security model to allow a user or administrator to explicitly deny permissions. By itself, the Java 2 security model does not allow additions to the collections of policy permissions after they have been loaded from the Java policy file. The inventive architecture allows Java applets and applications to dynamically prompt the user to deny a permission that does not exist in the Java policy file. If the user denies the permission, the present invention denies the permission for the ProtectionDomain to which the class asking for the permission belongs. Attributes for the denied permission may be set during runtime and saved across browser sessions.

Abstract: Methods and apparatus for loading and unloading classes associated with an application are disclosed. A class loader adapted for loading classes associated with an application is constructed. The class loader is employed to load one or more classes associated with the application such that the class loader maintains a reference to the one or more classes. The class loader for the application is then de-referenced such that the class loader is unreachable.

Abstract: Critical code routines are identified, separated from other routines, and compiled into a set of one or more critical dynamic link libraries (“DLLs”). These are then recognized by a DLL loader and loaded at a reserved address space in the DLL memory space. Once all of the critical DLLs have been loaded, cache locking may be enabled for the reserved address space. Robust fault containment is facilitated through the use of code modules implemented as shared libraries that can be loaded and unloaded in a running system by individual processes. These code modules can be replaced individually as defects are found and fixed without requiring replacement of the entire system image or application image. What would normally be a monolithic application is modularized, and the sharing of common code among multiple applications is facilitated.

Abstract: Provided are a method, system, and program for loading program components into a runtime environment. A loader hierarchy is provided indicating an order in which loaders are invoked to load multiple types of program components. A plurality of first type loaders are used to load a first type of program components that are capable of being used by a second type of program components loaded by at least one second type loader. The second type loader is defined at a lower level in the loader hierarchy than the first type component loaders.

Abstract: A method, applications programming interfaces (API), and mechanism for converting between JAVA classes and XML. In a file containing JAVA data representations, each JAVA class having elements to be converted to an XML representation is annotated in a manner enabling appropriate conversion processing by an API generating therefrom an XML file. The annotation enables instances of Java class objects to be converted to an XML representation and XML representations to be converted to Java class objects.

Abstract: The present invention is a new method and apparatus to perform fast compilation of platform independent bytecode instruction listings into high quality machine code in a single sequential pass. More specifically, the present invention creates a new method and apparatus for the translation of platform neutral bytecode into high quality machine code in a single sequential pass in which information from the preceding instruction translation is used to mimic an optimizing compiler without the extensive memory and time requirements. Where the preceding instruction translation cannot be used due to no direct control flow, information from comprehensive stack maps is then used.

Abstract: Improved techniques for loading class files into virtual computing machines are disclosed. These techniques provide a mechanism that will generally improve the efficiency of virtual machines by selectively loading information into a virtual machine. As will be appreciated, this allows a better use of the resources of the virtual machine. This is especially effective in virtual machines that operate with limited memory resources (e.g., embedded systems). In one embodiment, class files suitable for loading into a virtual machine are initially loaded into a memory portion (e.g., heap memory). Then, information that is needed to be loaded into the virtual machine is selected. Finally, only the selected information is loaded into the virtual machine.

Abstract: A method of loading an object-oriented computer program comprises translating the program into compiled code and holding that code, ready for execution, in an execution environment which does not necessarily also hold the original program code. In a preferred embodiment, the original class file is discarded from memory prior to execution of the program. The invention is particularly applicable to wireless communications networks consisting of a plurality of client devices, such as mobile phones, each of which typically has only a small amount of memory available. Using the present invention, the original class file is discarded after compilation, and does not need to be retained in the client device memories.

Abstract: A system and method for providing dynamic class reloading using a modular, pluggable and maintainable class loader is described. Each application in an application server (or alternatively in any implementation) may include a dynamic class loader module. The class loader module may include a hierarchical stack of class loaders. Each module in the application may be associated with its own class loader. Each class loader may be responsible for loading one or more classes. When a class is changed, the changed class may be detected by the class loader module. Any notification for a class change may come to the class loader controller so that the concerned class loader can be replaced. The class loaders for all classes that depend on the changed class may also be replaced. The replaced class loaders may then reload the affected classes.

Abstract: A Java virtual machine 2, comprises an execution engine for executing Java byte code and a memory management system 14. The memory management system 14 performs garbage collection to remove objects that are not reachable from the current state of the Java program. In the prior art memory management system objects representing a class definition are only removed from memory if the classloader object which has loaded the class object is not reachable. According to the present invention the memory management system 14 is arranged for removing classes which do not have any instantiated objects which can be reached in the present state of the program even if the classloader is still reachable. This results in a substantial saving of memory. Preferably the objects representing a class definition have a method which can signal to it that the definition can be deleted from memory if it has no instantiated objects anymore.

Abstract: A method and system of automatically synthesizing object names. Variables are synthesized with object types associated with the variables. Buffers into which data is to be transferred are dynamically created to bind the objects of synthesized variables to the buffers. The method of the present invention invokes a function associated with synthesized names to perform transferring of data into the buffers. In the present invention, objects may be preceded by an object type, e.g., SQL@ symbol, for type identification during the synthesis process.

Abstract: As a program configuration, a step of requesting a basic side to change an application class as an application module and a core class for changing the application class to a new version by themselves is provided in them. In a platform side for loading each of programs, a sub-core class loader for loading a new version based on a request for changing is provided. In a program of the base class in which the sub-core class loader is provided, a step of starting an operation of the application after loading the new version is provided.

Abstract: In general, the invention relates to a method for optimized execution of a computer program including detecting a preservable static field in said computer program with a compiler, comprising detecting at least one selected from the group consisting of a getstatic instruction and a putstatic instruction, annotating said preservable static field to create an annotation indicating whether said field is preservable, compiling said computer program to produce an output using said annotation, wherein said output includes information about said field, encoding said output if backward compatibility is required, loading said output, and executing said output in an environment.

Abstract: The present system and method improves the way of forwarding a reference from an importing module to an exporting module. The present system and method allow forwarding of a reference(s) through a forwarder exporting module for a specified export(s) when an explicit entrypoint(s) does/do not exist for the specified export(s) in the forwarder exporting module and still allow correlation from the importing module to the exporting module when the loader is loading the importing module during a load time. One or more implicit forwarder record(s) is stored in the exporting module by a linker. Each implicit forwarder record designates a respective target module. The loader determines whether an explicit entrypoint exists in the exporting module for the reference of the specified export. The loader resolves the reference by using the explicit entrypoint to determine a location of the specified export if the explicit entrypoint exists.

Abstract: A system and method for loading software identifies versions of software modules to be loaded. The version identification allows a loader to request, access and load any level or version of a program that the application interacts with. Thus, the loader selects only specific versions of software that are known to be compatible with other software currently loaded or being loaded. The software includes specific compatibility information that is used to determine whether it should be selected or passed over for another version of the same software. In this manner, a “version aware” loader ensures that loaded software modules are compatible with one another and will therefore execute properly. The version aware loader may be implemented in an operating system or other loading software running on a personal computer or network router.

Abstract: A method and system that reduces the space allocated for internal data structures by a runtime engine. The internal data structures store member information for preloaded classes used by applications executed by the runtime engine. The system determines the different types of internal data structures represented in the classes and identifies thee possible values of each type's members. The system next determines the amount of space required to store the values for each type in a respective value table and the number of bits needed to index each entry of that table. The system determines based on the stored information whether occurrences of a member are optimally represented as a set of value table indices and a value table or, in the conventional manner, as a general variable that stores the member's value for each occurrence. The system then emits appropriate information for the member and its parent data structure.

Abstract: Techniques for developing and exchanging virtual machine implementations and/or support library implementations are described. In one embodiment, the virtual machine design specifies a set of functions for executing all or substantially all support library operations that are dependent on the implementation of the virtual machine. When a developer desires to substitute one virtual machine implementation for another, the developer is able to basically “plug-in” the second virtual machine implementation with minimal impact on the support libraries since both virtual machine implementations provide implementations for the set of specified functions that are dependent on the implementation of the respective virtual machine. Conversely, different support libraries may be utilized in conjunction with a particular virtual machine implementation.

Abstract: Disclosed is a system, method, and program for uninstalling an installed program comprised of installed components installed from file sets. A call is made to a first uninstall program to uninstall the installed program. The first uninstall program is in a first directory. A call is then made to a class loader to load a second uninstall program. The second uninstall program is maintained in a second directory. The first uninstall program processes the file sets to determine installed components to remove, and deletes the installed components. A call is made from the first uninstall program to the second uninstall program to perform uninstall operations.

Abstract: A unique class loader called the Firewall Class Loader is described wherein the firewall class loader either uses positive filters or a combination of positive and negative filters. Negative filters provide for a list of classes that a class loader will not pass load requests to its parent in the class loader hierarchy. On the other hand, positive filters provide for a list of classes that a class will pass load requests to its parent in the class loader hierarchy, and all other requests would be filtered out. Variations and combinations of Firewall Class Loaders enable specialized configurations to increase speed and ensure that each vendor's applications work correctly in all user deployments.

Abstract: A programming apparatus having an arrangement for formulating an automating task to be performed in the form of a programming language for automating apparatuses is described, which simplifies a process error analysis for an analysis unit. For this purpose, the programming apparatus is provided with an arrangement that store operands (9; 27), marked to be monitored, in the order in which they appear in the network in a logic list. Furthermore, the programming apparatus has an arrangement that store the operands of this network in an operand list in the order in which they appear in the network. The lists can be transferred into the analysis unit for analysis.

Abstract: A system and method for loading software identifies versions of software modules to be loaded. The version identification allows a loader to request, access and load any level or version of a program that the application interacts with. Thus, the loader selects only specific versions of software that are known to be compatible with other software currently loaded or being loaded. The software includes specific compatibility information that is used to determine whether it should be selected or passed over for another version of the same software. In this manner, a “version aware” loader ensures that loaded software modules are compatible with one another and will therefore execute properly. The version aware loader may be implemented in an operating system or other loading software running on a personal computer or network router.

Abstract: A mutability mechanism is provided for parsing an object at loading time. The mutability mechanism inserts a property into the object that indicates whether or not the object is immutable. The mutability mechanism looks at the code for the object and determines whether any other objects can modify the object. If the object cannot be modified after it is created, then the new property is set to indicate that the object is immutable; otherwise, the property is set to indicate that the object is mutable. This property can be inspected at runtime when a call is made to a program object. If an object passed as an argument is marked mutable, a clone of this object must be passed to the callee. However, if an object passed as an argument is marked immutable, a simple reference to the object may be passed as an argument to the callee.

Abstract: A custom class loader configured to dynamically locate and load classes in a virtual machine in accordance with an associated dependency specification. The custom class loader can include class loading logic configured to specifically and dynamically locate, define and load a class specified by name. The custom class loader also can include a list of peer class loaders arranged in a peer-to-peer fashion in accordance with the associated dependency specification in the virtual machine. In this regard, list generation logic can be included which can generate the list when the specified class has been replaced. Finally, the custom class loader can include deference logic configured to defer the location, definition and loading of the specified class to the peer class loaders in the list.

Abstract: A method, system, and computer program product for transparently loading resources (such as stored bitmaps, images, fonts, and sound files) from read-only memory (“ROM”) for an application program executing on a Java Virtual Machine (“JVM”). Typically, the invention will be used on an embedded computing device which has no disk storage and no file system software. A novel class loader is described, which loads resources from ROM and returns an input stream object as is expected by the existing application program. Therefore, when using the present invention, no change is required to existing application code to use resources stored in ROM. (In addition, no change to existing applications is required in order to invoke the code of the present invention.) The invention may be used with programs written in the Java programming language, or with programs written in other languages that execute on a JVM.

Abstract: A method is disclosed for a endian correction at load time, thereby eliminating the need to perform multiple endian correction routines during execution. The method comprises obtaining a platform endian context corresponding to the processor; obtaining a operand endian context indicating the ordering of operands contained in the set of instructions to be loaded; reading an instruction in the set of instructions; determining whether an operational code for the instruction is endian antithetical to the platform endian context; if the operational code for the instruction is endian antithetical, reversing the endian order of the instruction; loading the instruction into an appropriate memory location; and repeating the above steps as required for each instruction until all of the instructions have been loaded into memory.

Abstract: A system for creating a custom environment for executing application programs in a target device. The system broadens the applicability of software environments like Java by providing custom pre-loaded classes for application programs and by customizing the procedures for class loading to the available resources in the target device. The system includes tools for generating a pre-load class list that specifies a set of classes needed to support the application program. The tools build the custom environment including a set of code for a virtual machine and a set of code for each of a set of pre-loaded classes specified in the pre-load class list. The virtual machine loads classes from the pre-loaded classes, a file system class library, and/or a networked class library using widely available network protocols.

Abstract: Exemplary devices and/or methods optionally compile a programming language code associated with one framework to a code associated with another framework; and/or convert a code associated with one framework to a code associated with another framework. The aforementioned devices and/or methods optionally include, but are not limited to, features for supporting framework differences in object hierarchy, exceptions, type characteristics, reflection transparency, and/or scoping, and features for supporting differences in class loading.

Abstract: A method and apparatus for pre-processing and packaging class files. Embodiments remove duplicate information elements from a set of class files to reduce the size of individual class files and to prevent redundant resolution of the information elements. Memory allocation requirements are determined in advance for the set of classes as a whole to reduce the complexity of memory allocation when the set of classes are loaded. The class files are stored in a single package for efficient storage, transfer and processing as a unit. In an embodiment, a pre-processor examines each class file in a set of class files to locate duplicate information in the form of redundant constants contained in a constant pool. The duplicate constant is placed in a separate shared table, and all occurrences of the constant are removed from the respective constant pools of the individual class files.

Abstract: One embodiment of the present invention provides a system that determines class dependencies of a class. The system operates by: receiving a representation of the class; creating a model of the class from the representation; analyzing the model to detect references to supporting classes; and creating a list of all dependent classes. For each supporting class found, the system recursively determines the dependencies of that class and adds them to the list. In a variation on this embodiment, the system identifies classes that an object depends on by: receiving a representation of an object; parsing the object to identify any classes on which the object depends; and analyzing and documenting the class dependencies of the object and all dependent classes.

Abstract: A method and apparatus are provided for automatically integrating and executing application software modules. An application selects those software modules from a pool of software modules that match a particular criteria. For example, selection criteria may be that a software module be stored in files with file names that match a pre-defined character pattern. If the software module is configured so that it may be run by the application, then the application runs the software module. A software module invokes an application-supplied function that provides an output buffer. The software module may generate HTML code and store the code in the output buffer.

Abstract: An embedded desktop which can run multiple Java applications simultaneously under one instance of a Java™ virtual machine (JVM) and which allows open applications to communicate with one another in a system independent manner. The embedded desktop functionally exists between the JVM and the multiple Java™ applications and consists of a Core and various plug-ins. When applications are launched by a user (by communication between the Core, user interface plug-in and service vendor plug-in), an application class loader for each application is invoked using the class names of the respective applications. By segregating each application into an application class loader, class name collisions and resulting application crashes are avoided. Once application class loaders have been invoked, communication between applications is facilitated through the Core, avoiding the overhead and complexity of system dependent communication through the operating system and associated hardware.

Abstract: A system, comprising a stream source class loader retrieving streaming data to create a desired class object, an interface coupled to the stream source class loader and a plurality of streaming sources containing information including the location of data, wherein requests for data are communicated from the stream source class loader to the streaming sources via the interface and, data passes from the stream sources to the stream source class loader via the interface, the streaming sources searching the data locations for the requested data.

Abstract: A system, comprising a receiving module to receive a request to load a component, a stack to record the request and a loader to fulfill the request, wherein when the request has been fulfilled the request is removed from the stack and when the loading of the component is unsuccessful, contents of the stack are made available to a user to indicate the unsuccessfully loaded component.

Abstract: A Java compile-on-demand service system and method for accelerating a processing speed of Java program in a data processing system having a relatively low performance is provided. The Java COD service system compiles a Java class file to be executed in a data processing system into a pattern which can be executed more speedily on the data processing system, and then transmits the compiled result, upon a request of the data processing system connected via a network in order to execute the Java program at a relatively faster speed. The system includes Java program providing servers, data processing systems, and a compile-on-demand server for receiving a service request, downloading a requested Java class file, compiling the downloaded Java class file, and transmitting the compiled result.

Abstract: A resource access system and method for providing interpreters with the ability to provide interpreter applications access to any desired server resource regardless of type of server and current capability of the client node to access such server resources. The invention is an application-level extension of the interpreter, enabling the interpreter to provide server resource access independently of the type of operating system implemented in the client node. In addition, the invention utilizes existing techniques to communicate with the server, such as a distributed object system or an existing client redirector, enabling the invention to provide such access with minimal modifications to the client or server nodes, accommodating the client node's current capability to access the server resources. Also, the resource access system provides access without having to use a foreign application interface.

Abstract: A task executing at a server receives a request to package program code for remote execution on a client, and determines the software components that already reside at the client. The task uses this information to formulate a set of instructions to another task that creates the package. The created package is transmitted to the client, and program execution begins.

Abstract: This invention relates to the loading of classes in programming environments, and in particular, Java programming environments. This invention discloses a system and method that permits dynamic loading of classes during the execution of Java programs. This invention allows for classes to be loaded despite the fact that such classes may not reside in the current path or working directory within a Java programming environment. This invention also discloses a system and method for archiving files in an archive file that provides customized entry names for the archived files.

Abstract: A computer-implemented method and system for loading an object class into computer memory for access by an object-oriented application. A first object class is loaded into the computer memory, and initially a classload request for the first object class traverses from a first classloader to a second classloader. A destructible classloader is created that contains a second object class which may be a modification of the first object class. After creating the destructible classloader, the classload request traverses from the first classloader to the destructible classloader and then to the second classloader. The destructible classloader attempts to load into the computer memory the second object class if the second classloader fails to load the second object class.

Abstract: A method for including opcode information in an opcode includes numbering the opcode such that a property of the opcode is represented by at least one bit of the opcode. According to one aspect, the number of data units required to advance to the next opcode is encoded into the opcode value itself. According to another aspect, opcodes are numbered such that opcodes having the same properties have opcode values in the same opcode range.

Abstract: A dependency checking apparatus and method allows checking the version of classes in an object-oriented program to assure the proper version is being used for each release of the software. According to a first preferred embodiment, classes themselves include static code that checks dependencies when the class is loaded. The first embodiment is simple to implement for classes. According to a second preferred embodiment, information relating to version checking is stored separate from the classes and is used to check dependencies. This second embodiment is more flexible, allowing the checking of interfaces as well as classes, and allows the dependency information to be altered without recompiling the classes being checked.

Abstract: An application manager for managing applications in an embedded device is presented. The application manager allows remote control of loading, starting, stopping, unloading, application state querying of applications on an embedded device. Applications are cached in an application cache resident within the embedded device even after application termination to allow for higher efficiency when applications must be unloaded to handle low- or out-of memory conditions.