Abstract: A system, method and computer program product for compiling a source file and to generate a unitary data structure (UDS) containing information relating to symbols and associated global registers. The UDS permits assessment of symbol conflicts for global registers. The compiler also generates object files from related source files. The object files include the global symbol information relating to particular global registers, to enable diagnosis of conflicts between global symbols and registers.

Abstract: A method and system for advertising software applications by placing application shortcuts on a start menu or desktop and writing entries to the system registry enabling file extension-based activation and Class ID-based activation of those applications, thereby advertising the applications as available even if not installed. In network settings, advertised applications may be assigned to a user via a policy. To this end, an advertising script is stored with a policy associated with computer or user policy recipients, and the advertising script includes assigned application identifier information. One or more scripts are applied, such as to a user at logon or a machine at re-boot. The scripts are processed by an installer mechanism to advertise the application. Applications advertised as available to the user prior to any installation thereof are installed by an installer as needed upon user activation.

Abstract: A method and several variants for optimizing the detection of out of bounds array references in computer programs are described, while preserving the semantics of the computer program. Depending on the variant implemented, the program is divided at run-time or compile-time into two or more regions. The regions are differentiated by the number of checks that need to be performed at run-time on the array accesses within the region. In particular, some regions of the program will not need any array bounds checks performed at run-time, which will increase the speed at which the computer program executes. As well, the state of program variables at the time any out of bounds access is detected is the same as the state of the program variables would have been had the transformation not been performed. Moreover, the regions not needing any checks at run-time will be known at compile-time, enabling further compiler optimizations on the region.

Abstract: A compiler for a distributed object system in which functional requirements on system performance criteria can be entered as comments fields in an object oriented language (e.g. C++) which are ignored by a conventional compiler (to allow compilation of a single processor version of the program for debugging) but are interpreted by a pre-compiler to take into account system data when compiling code for the host computers of the distributed system. The system may be a telecommunications system.

Abstract: A pre-processor is utilized to create multi-instantiated code from single instance code so that multiple copies of the single instance code can be run without changing the source code of the single instance code. Exemplary implementations include modems running multi-instantiated code, for example in a protocol stack or in a data link control element. Multiple instances of entire modem code set(s) or of portions of a modem code set can be run on the processor of a modem or on a host processor of a software modem. Another application permits a processor having no memory management unit to operate as if it had one. Another implementation enables a single task operating system, such as DOS, to run as a multi-task system. This document describes a simple method of converting ordinary single-instance software into software that supports multiple instances, each with its own data, running simultaneously on a system.

Abstract: The present invention integrates data prefetching into a modulo scheduling technique to provide for the generation of assembly code having improved performance. Modulo scheduling can produce optimal steady state code for many important cases by sufficiently separating defining instructions (producers) from using instructions (consumers), thereby avoiding machine stall cycles and simultaneously maximizing processor utilization. Integrating data prefetching within modulo scheduling yields high performance assembly code by prefetching data from memory while at the same time using modulo scheduling to efficiently schedule the remaining operations. The invention integrates data prefetching into modulo scheduling by postponing prefetch insertion until after modulo scheduling is complete. Actual insertion of the prefetch instructions occurs in a postpass after the generation of appropriate prologue-kernel-epilogue code.

Abstract: A technique for automatically generating browsable language grammars. A grammar specification is used to identify the structure of an input grammar, so that a specification pre-processor, grammar parser and grammar generator can work together to generate a marked up grammar that is a browsable representation of the input grammar. The specification defines how a terminal is represented, how a non-terminal is represented, how production rules are represented, etc. Using the specification, the specification pre-processor generates the grammar parser for subsequent use with production rules found in the input grammar. When an actual set of production rules in the input grammar are provided to the grammar parser, it generates an intermediate form of the grammar that is then used by the grammar generator to generate the browsable, marked up version of the production rules.

Abstract: A software application is analyzed to identify its “core functionalities”, and object-oriented core objects containing no application-specific control behavior are created to perform these essential functions. The event traces in which the core objects participate are identified, and this control behavior is embodied in one or more “control objects”, which invoke the operation of various core objects as needed to execute a particular event trace. Because the core functionalities and control behaviors are separated, the core objects are application-independent, and can be re-used in other applications without modification by modifying their associated control objects to different application-specific event traces.

Abstract: Apparatus and method are provided for accomplishing on-line replacement of a script running in a process. The apparatus and method utilize a script registry that keeps track of the most current script for a particular service. The request for service is presented to the script registry to identify the location of the most current script that provides the requested service. Because this script registry is an internal data structure, it is therefore lightly portable between different operating system machine types. A superscript is further utilized to transfer script state information between execution of the service-providing scripts. This ensures that data information (i.e., execution mode, environment information, and variable data) is passed from a terminating service script to an initializing service script.

Abstract: The present invention is an applet server which accepts requests for applets from client computers. A request specifies the format in which an applet is to be delivered to the requesting client computer. The applet server has a cache which it uses to store applets for distribution to client computers. If the specified form of the requested applet is available in the cache, the applet server transmits the applet to the requesting client. If the applet is not available in the cache, the server will attempt to build the applet from local resources (program code modules and compilers) and transformer programs (verifiers and optimizers). If the applet server is able to build the requested applet, it will then transmit the applet to the requesting client computer. If the applet server is unable to build the requested applet, it will pass the request to another applet server on the network for fulfillment of the request.

Abstract: An automated development system which allows developers to more easily incorporate functionality from enterprise-based On-Line Transaction Processing (OLTP) services within an application running on a DCOM-based platform. View files (which describe how parameters will be provided to and received from an OLTP service) are transferred from the enterprise OLTP system to a DCOM environment. These view files and an associated set of interactively supplied user parameters are provided as input to a function builder utility (DGateAce) which generates function files and Interface Definition Language files as output.

Abstract: A system for identifying the file structure of a computer program, preserving the file structure of the code after translation of source code from one high-level computer language to another, combining pieces of a source file that were generated in different translation sessions, and ensuring textual consistency of each piece of generated code in the resultant code files.

Abstract: An electronic system having a communication unit executes specified processing by software and, in particular, an information processing system enables freely controlling upgrading of a facility of the system. The information processing system comprises a communication unit, a plurality of processing facilities run by the information processing system, a unit allocating inherent data and which is used to enable or to disable use of at least one of the processing facility, and a unit enabling the disabled use of the processing facility associated with data received via the communication unit.

Abstract: A translating software emulator designed for converting code from a legacy system to a target system and fully preserving the synchronous exception state while still allowing for full and aggressive optimization in the translation. A user application is translated to a target system using full optimization techniques. The translation may be done dynamically by an emulator emulating the legacy system on the target system, or the translation may be a static translation or a compilation, fully generating a new executable program operable on the target system. The invention recovers from the exception properly by restoring the target machine state to the machine state expected by the legacy system. This recovery is done by using an exception delivery mechanism to restore the machine state of the target system before executing the exception handling code.

Abstract: A method of resolving arbitrarily-complex expressions during the linking operation of an object file is disclosed. This is accomplished by including stack operations in the relocation entries of relocatable object files. By adding stack operations to the relocation entries, postfix notation (also known as “reverse Polish notation”) can be utilized to allow the resolution of the arbitrarily-complex expressions during the linking operation and within the object file itself.

Abstract: A method and apparatus for handling asynchronous exceptions in a dynamic translation system. In accordance with the present invention, the dynamic translation system utilizes an interpreter to determine when a point in the translated code has been reached at which application state is recoverable. When an asynchronous event occurs, execution of translated instructions in hardware is halted and control is transferred to the interpreter at the point at which the exception occurred during the translation. The interpreter then executes the translated code from the point of interruption and checks for a guaranteed application state recoverable point, or GAR point, at the end of each instruction or block of instructions. Once a GAR point is reached, control is transferred to an asynchronous exception handler.

Abstract: A method and computer product for facilitating automatic testing during the development and other life cycle phases of a software application comprised of transactions. A transaction tester evaluates the integrity of a transaction by generating test data from the definition of the transaction under test. Typical values for fields may be included within the transaction definition and reused as typical test values. Test results are generated and compared against known-good values or, alternatively, against expected test results also generated from the transaction definition. Other software components may also be tested including menu structures. A definition of the menu structure is rigorously traversed such that each entry of each menu is thoroughly tested and reported. Results are automatically compared and verified against known good results or test results are automatically reviewed. Both transaction testing and menu testing may be incorporated into regression testing.

Abstract: A software system is selectively installed from a source into a target system according to a profile. The software system comprises a plurality of components. Only selected components are needed by the target system. A profile of the target system is created when the target system is defined; the profile defines the components needed by the target system. To configure the target system, an installation process installs in the target system only components from the source that are defined in the profile for the target system. The source may be a storage medium or a separate installation system.

Abstract: A system, method and computer program product for compiling and linking a source file and to generate a symbol table associating a global symbol with a register referenced in the source file. The symbol table enables a linker to initialize the global registers using a relocation entry which holds an initializer. The compiler also generates an object file from the source file. The object file includes the global symbol information. A linker links the object file potentially with at least one other object file or shared library to thereby generate an executable file or shared library. The linker uses the global symbol information contained in the object file to initialize the global registers and to perform relocation operations.

Abstract: To efficient generate native processor code from operand stack based code, a mimic stack is introduced. The mimic stack is a compile time data structure that stores the location of operands pushed onto the operand stack. When an operation is detected that operates on operand stack values, the locations from the mimic stack are popped off and used to generate efficient code that directly accesses the operands.