Abstract: Methods and systems are provided for expressing one or more associations between source language declarations and implementations in a language neutral fashion. A determination is made as to whether a source language association rule related to a declaration is different from a default association rule for a target runtime. If so, an override association is expressed between the declaration and the implementation, and if not, a default association is expressed. Methods and systems are also provided for interpreting an association between a declaration and an implementation in a runtime system, wherein a determination is made as to whether the association comprises an override association. If so, the association is interpreted according to an override association rule for the runtime system, and if not, the association is interpreted according to a default association rule.

Abstract: A method, computer program product and data processing system for identifying non-externalized strings that are not hard-coded. In one embodiment, a method comprises the step of scanning a code, e.g., Java, line by line until a pair of string delimiters is identified. Once a pair of string delimiters is identified, the method further comprises the step of determining whether the string within the pair of string delimiters identified is a path name to a resource file, e.g., resource bundle. If the string is a path name to the resource file, then the string is a non-externalized string that is not hard-coded. If the string is not a path name to the resource file, then the string may be identified as a possible hard-coded string.

Abstract: A configuration system for an intelligent assist system is provided. The intelligent assist system includes a module, and a computational node on the module. The configuration system includes a host computer system capable of executing a stored program. The host computer system is in communication with the computational node via a communication link. The system also includes a graphical user interface enabling a user to manipulate objects related to the module or the computational node, and a plurality of visual indicators corresponding to a status of the module, the computational node, or the communication link.

Abstract: An inherently safe code format for representing computer programs is disclosed. The format provides incorruptible referential integrity and uses type separation to achieve intrinsic type safety. The format preserves a safety guarantee found in a source code language representation of the computer program while the computer program proceeds through various stages of the code compilation process.

Abstract: One embodiment of the invention is a method for producing a hardware solver for intermediate code comprising analyzing intermediate code for at least one instantiation that may cause at least one of wire delay and congestion in the solver, forming compensation for the at least one instantiation, and forming the solver in accordance with the compensation.

Abstract: A data storage system including data sending/receiving nodes and a relay node, which is provided between the data sending/receiving nodes and a network, for relaying data between said data sending/receiving nodes and said network. The relay node has a meta-data memory for registering data processes which should be conducted in the relay node as meta-data, and a data processor for conducting data process in accordance with the processes defined by the meta-data registered in said meta-data registering memory. In the relay node, meta-data designated by said data sending/receiving node is selected from the meta-data registering memory, and data sent from said data sending/receiving node or data received by said data sending/receiving node is processed in accordance with the processes defined by the selected meta-data.

Abstract: A method for compiling a cycle-based design involves generating a parsed cycle-based design from the cycle-based design, elaborating the parsed cycle-based design to an annotated syntax tree, translating the annotated syntax tree to an intermediate form, and converting the intermediate form to an executable form.

Abstract: A method and an apparatus for adapting for a kernel on a target system a compiled kernel module corresponding to another kernel version which is different from the kernel on the target system are provided. A kernel analyzer extracts from the kernel on the target system an error check measure and a kernel version identification. A module adaptation component inserts in the compiled kernel module an error check parameter corresponding to the error check measure extracted by the kernel analyzer from the kernel on the target system, and replaces a version identification in the compiled kernel module with the kernel version identification extracted by the kernel analyzer from the kernel on the target system.

Abstract: A compiler has a detection unit, a conversion unit, and a expansion unit. The detection unit detects a predetermined target from an input source program. The conversion unit converts the target detected by the detection unit into a procedure call. The expansion unit generates an online code describing a definition of a procedure to be called by the procedure call obtained by the detection unit. The compiler outputs a program in which the target detected by the detection unit is replaced with a procedure call, and an online code corresponding to the procedure call.

Abstract: Method and apparatus for switching between multiple implementations of a routine. A plurality of implementations of a routine are compiled into respective object code modules. In one embodiment, each implementation of the routine is adapted for a particular hardware configuration. The different object code modules are associated with respective sets of hardware characteristics and with the name of the routine. When the application program and library are loaded into memory of the computer system, a references to the routine are resolved using the sets of hardware characteristics and the hardware configuration of the system.

Abstract: An emulation system, computer program product, and method for emulating the execution of a target program comprising instructions of an instruction set of a target computer on a host computer having a different instruction set operate by performing a static translation of the instructions of the target program into a series of instructions of an intermediate instruction set, the intermediate instruction set being optimized for interpretation on the host computer, and then executing the series of instructions of the intermediate instruction set by interpretation on the host computer.

Abstract: A search request input processing unit holds an input query word in a query word holding unit. An associative word unfolding processing unit acquires associative words in association with the query word held in the query word holding unit with reference to an associative word dictionary. An image content search processing unit using associative words makes a keyword search of image information on the basis of the obtained associative words and the query word. A sensory pattern unfolding processing unit obtains the query word and sensory patterns corresponding to associative words of the query word, and searches image information using feature amounts of the obtained sensory patterns. A search result integration processing unit integrates the search results obtained by the image content word search processing unit and sensory pattern search processing unit.

Abstract: A program generation apparatus for generating light-weight class files for each terminal apparatus by linking class files. The program generation apparatus includes: a storage unit for prestoring the class files for each terminal apparatus, where each class defines (a) dependent variables unique to each terminal apparatus and (b) non-dependent variables common to all the terminal apparatuses, each variable is identified by a variable name, and each class file includes a variable name for each variable; an assignment unit for assigning an offset number to each variable defined in the class files so that the same offset numbers are assigned to non-dependent variables having the same variable names; and a generation unit for generating the light-weight class files for each terminal apparatus by replacing each variable name in each class file with an offset number assigned by the assignment unit.

Abstract: A system and method for generating a source schema-to-target schema mapping includes grouping user-defined value correspondences into potential sets such that, for each potential set, at most one value correspondence per target attribute exists. The value correspondences represent functions and filters for deriving values of target attributes from values of source attributes. Candidate sets are selected from the potential sets and then grouped into ranked covers. Using the best cover, an SQL query representing a source schema-to-target schema mapping is generated.

Abstract: An optimizing compiler and method thereof performs a sequence of optimizing changes to an intermediate language representation of a routine, and measures an execution characteristic of each optimization, such as a timing of the machine language representation performed on an architecture similar to the target machine using a user selectable initialization state. The sequence of optimizations is selected according to a criterion that includes a lexicographic search and other methods. The pre-optimized code is also broken into segments wherein discrete optimizations are performed on each segment and measured using a user provided routine. The target routine is tested with the object code in main memory if not the cache if possible and optimizations are chosen only if they improve the target subroutine according to the user defined metric. After a stopping criterion is achieved, the most optimized code is selected.

Abstract: A compiler that completes compilation upon identifying unresolvable input during compilation instead of aborting compilation. This can be accomplished by inserting an exception-throwing instruction, and/or handlers in place of the unresolvable input in the compiled code output. If the section of the compiled code containing the inserted exception throwing instruction is later executed, an exception is thrown and/or handled. Compilation of code from a trusted source can be completed without inserting an exception throwing instruction when the code has only suspected but unverifiable problems.

Abstract: A Java preprocessor method is provided. A Java template file is received that includes Java programming language code and meta code. The Java template is then processed to create an intermediate program using the meta code, wherein the intermediate program is a Java program. The intermediate program is compiled to create an intermediate class, which is a Java based class, and an object text file is generated using the intermediate class.

Abstract: The present invention provides a system and method for optimizing compilation time of a program. In architecture, the system includes a compiler that generates the least one block of code from the program; and a compilation optimizer. The compilation optimizer generates a hash value for a block of code in the program and stores the hash value with the block of code if the hash value is not equal to a prior hash value for the block of code; and skips the optimization of the block of code if the hash value equals the prior hash value. The present invention can also be viewed as a method for optimizing compilation time of a program. The method operates by generating a current hash value for a block of code in the program, skipping the optimization of the block of code if the current hash value equals a prior hash value, and storing the current hash value with the block of code if the hash value is not equal to the prior hash value for the block of code.

Abstract: Methods for embedding codes executable in a first system having a first microprocessor into codes executable in a second system having a second microprocessor are described herein. In one aspect of the invention, an exemplary method includes providing first codes having a routine, the first codes being compilable to be executed in the first system, and compiling the first codes, resulting in second codes; the second codes comprising opcodes of the routine executable by the first system, which convert the second codes into third codes automatically, the third codes being compilable to be executed by the second system; this is followed by compiling the third codes, resulting in the fourth codes being executable in the second system, and linking the fourth codes, generating an executable image and executing the executable image in the second system. Other methods and apparatuses are also described.

Abstract: This invention describes a method and several variants for compiling programs or components of programs in a mixed static and dynamic environment, so as to reduce the amount of time and memory spent in run-time compilation, or to exercise greater control over testing of the executable code for the program, or both. The invention involves generating persistent code images prior to program execution based on static compilation or dynamic compilation from a previous run, and then, adapting those images during program execution. We describe a method for generating auxiliary information in addition to the executable code that is recorded in the persistent code image. Further, we describe a method for checking the validity of those code images, adapting those images to the new execution context, and generating new executable code to respond to dynamic events, during program execution.

Abstract: A method for converting interface definitions within a source code program into an intermediate format includes identifying with a computer system objects in a source code program and interfaces in the objects. Interface properties are determined including an internal interface for producing a link from an object with interfaces located outside the source code program, and an input and/or output interface. Links are identified including an internal link between an interface and an input interface between identified objects, and an external link of an external interface. An intermediate format table is created having rows in a dimension, second rows in another dimension, and cells disposed at intersections thereof. Designation are assigned for each identified object to rows in the first and for each identified link to rows in the second. Designations for associated interfaces are inserted in the cells.

Abstract: The invention concerns a data compaction method and system for an intermediate program. The method consists in searching the program (1000) for identical sequences (Si) and counting Ni number of occurrences of each sequence (Si), a comparison test (1001) to find the superiority of a function f(Ni) to a reference value enables to generate (1003) a specific instruction of a specific code (Ci) with which the sequence (Si) is associated, replacing (1004) each occurrence in the sequence (Si) by the specific code (Ci) in the intermediate program to create a compacted intermediate program (FCC) with which an executing file (FEX) is associated. The invention is applicable to multiple application portable objects such as microprocessor cards, onboard systems of the like.

Abstract: The invention relates to a computer program interpreter and a method for the same, using statistics to group (SR89, SR17 . . . SR6; SR4, SR34 . . . SR16) frequently used service routines (SR) in the same program function and to control encoding of instructions. Frequently used service routines are assigned shorter codes thus enhancing the performance of a simulator or emulator.

Abstract: Systems and methods are described for an encrypted compiler. A method includes generating a first sub-file of source code; then encrypting said first sub-file of source code; then writing said first sub-file of source code to a buffer; then reading a second sub-file of source code from said buffer; then decrypting said second sub-file of source code; and then compiling said second sub-file of source code.

Abstract: A method, apparatus and article of manufacture for performing alias refinement is disclosed. Initially, a determination is made as to whether a load of an address exists for a variable in an intermediate representation of the source code. If a load of the address exists for the variable, a further determination is made whether each use of the address is for an indirect reference of the variable. If a particular use of the address is for an indirect reference of the variable, the indirect reference is replaced with a direct reference in the intermediate representation. If all uses of the address are for an indirect reference of the variable, the variable is removed from an alias set used with the intermediate representation.

Abstract: A system and method for generic and dynamic mapping of managed object metadata. The data to be mapped may include type information about an attribute, action, or notification of a managed object. The first data type is entered into the mapping system, and then a corresponding second data type is determined and returned. In this manner, data types related to the attributes, events, or other parameters of managed objects are converted between various data description languages, such as OMG IDL and ASN1. A single interface is defined to describe substantially all data types and all managed objects. Having a single object interface for all TMN managed objects saves significant resources in that there is no need to statically compile and store separate interfaces for the many objects, which may increase the scalability of a network management system dramatically.

Abstract: The invention provides a Software Development Program having a compiled programming language, Compiler for that language, and a built-in text Editor. The programming language has a block structure and simple syntax. The Software Development Program is distributed free to developers, but programs created with the Software Development Program must be licensed. In addition to machine-readable Object Code, Executable Files created with the Compiler include the embedded Source Code (including independent function libraries that help form an Executable Shell) from which they were created. Separate Source Code and Object Code files are not required. The Compiler edits the Executable Files directly, thereby eliminating the need for source code control.

Abstract: A system and method of recognising command related items in a body of object code, such as command names and/or associated option names involves entering a list of required command names and/or option names in programming language form into a filter table. The object code is then scanned for all bit strings potentially representing command names and identifying such names. For each potential command name, succeeding bits are then examined for bits which represent valid options for each said command name so as to further confirm the identity of commands having valid combinations of command names and/or options. Optionally, the command/option syntax may also be checked. The candiate commands, including options, now identified in programming language form are then compared with the entries in the filter table to determine whether or not they match the required list, which may be further refined by use of logical operators.

Abstract: An annotation source representation is supported by a compiler and/or linker to annotate program code, so that analysis tools, such as debuggers and profilers, have more information with which to analyze an executable program. The annotation source representation in the source code is compiled into annotation information so that the annotation remains in the executable code, but is not executed. The annotation information in the executable program is associated with the code that the annotation function is associated with. The present invention eliminates the need of parallel/companion input command files, eliminates the need of compiling a special version of the executable program for purposes of analysis, and eliminates the need of implementing debug statements in the source code.

Abstract: A system and method are disclosed for a host platform interface (HPI), which defines a common set of functions implementing the native methods of Component Peer classes within the Java AWT. This allows the diverse native method implementations currently used in different versions of the AWT to be combined into a single body of source code, greatly improving code maintainability. Since the same source code defines a Component Peer class for each supported platform, changes or bug fixes need only be made in one body of code.

Abstract: A search request input processing unit holds an input query word in a query word holding unit. An associative word unfolding processing unit acquires associative words in association with the query word held in the query word holding unit with reference to an associative word dictionary. An image content search processing unit using associative words makes a keyword search of image information on the basis of the obtained associative words and the query word. A sensory pattern unfolding processing unit obtains the query word and sensory patterns corresponding to associative words of the query word, and searches image information using feature amounts of the obtained sensory patterns. A search result integration processing unit integrates the search results obtained by the image content word search processing unit and sensory pattern search processing unit.

Abstract: Techniques for automatically modifying behavior of a compiled application include receiving a first set of compiled instructions for the application. The first set of compiled instructions is modified to generate a modified set of compiled instructions. Modifying the first set of compiled instructions includes inserting a new set of one or more instructions for invoking a first routine that provides new behavior. The first routine is not part of the first set of compiled instructions. These techniques allow an administrator to automatically instrument compiled code of an application to provide new behavior for the application without taking the application offline for substantial periods of time. In particular, the techniques allow a service provider to automatically instrument existing applications, components, and sub-components to measure and respond to server-side performance without taking the applications offline.

Abstract: A verification module evaluates intermediate language code to verify that the code is type safe before passing the code for execution. Code that is not deemed type safe can cause execution errors, corrupt the runtime environment in which the code is executing, or cause unauthorized access to protected system resources. As such, the verification module protects a computer system from intentional or inadvertent breaches of the computer system's defenses. The verification module verifies the type safety of intermediate language code that supports significant high-level language constructs prohibited by verification modules in the prior art. One exemplary verification module verifies intermediate language code that includes one or more reference-based parameter, such as a pointer (or reference), a value class containing pointers, a RefAny parameter, or a nested pointer.

Abstract: A software wrapper for interfacing to pre-existing software code is provided. The software wrapper is capable of inheriting from a first application program interface (API) and a second API. For calls to the first API, the software wrapper delegates to a pre-existing enumeration of objects. The wrapper creates a vector identifying elements of the enumeration. Iterators provided by the wrapper maintain positional cursors for calls to the second API. A comparison is made between each of the positional cursors and the vector. If a positional cursor exceeds the size of the vector, additional elements are extracted from the enumeration, placed in the vector, and returned on the second API. Otherwise, if the positional cursor is smaller than the vector size, the wrapper delegates directly to the vector. The first API can be a java-based enumeration API and the second API can be a java-based collection API.

Abstract: As described herein, an intermediate representation of a source code file may be used to explicitly express exception handling control flow prior to generating object code for the source code. As further described herein, a single uniform set of instructions of the intermediate representation may be used for expressing multiple different exception handling mechanisms related to multiple different programming languages. The intermediate form of the exception handling instructions may be generated by translating an intermediate language representation of the source code file. Representations of the source code in multiple different intermediate languages may be translated to a single uniform set of instructions of the intermediate representation. The intermediate form of the exception handling instructions may then be used by software development tools for such tasks as code generation, code optimization, code analysis etc.

Abstract: Various intermediate representation techniques for software development tool scenarios are described. An intermediate representation format can be used for both high level and low level representations. The intermediate representation can be built from various operands and instructions types. Various annotations can be added to the intermediate representation without modifying its format. For example, flow control and data control can be explicitly represented by threading a graph through the intermediate representation.

Abstract: A JavaScript interpreter may be interfaced with a JavaScript library of host objects implemented in Java. A JavaScript program may be accessed and parsed, an intermediate representation of the program may be generated, and the intermediate representation may be executed by interfacing with the library of host objects. In one embodiment, the JavaScript program is embedded in HTML documents in a Web browser. The browser is programmed to intercept the JavaScript code and pass execution control to an interpreter engine implemented in Java. The interpreter engine may access the program's library of host objects through an interface to the library and execute the intermediate representation to produce the desired results as programmed in the original JavaScript source program. The implementation of the interface enables the implementation of the interpreter engine to be independent from the implementation of the library of host objects and independent from the implementation of the browser.

Abstract: A method for processing program files by formatting the program file information for storage in permanent memory in a device memory, allowing later additions without requiring storage in dynamic memory. A mapping mechanism is used to allow references to previously processed files. In one embodiment, the mapping mechanism is a link file. The original preprocessing is typically done during manufacture and stores the programming for basic functionality in a device. Later user-specific functions are added by using the mapping mechanism and preprocessing just the use-specific code. Multiple program file units may be added to the application, where the application device either includes the preprocessing tool or has access to it from a desktop or other application. The preprocessing tool may be implemented in software or hardware, and may be resident on the application device or used via a desktop application.

Abstract: The invention automatically executes, in a single execution medium, a number of programs written in source languages to which respective execution media are dedicated, without constraining a programmer to a single source language for a respective execution medium type. Each program is compiled into a program expressed in an intermediate language representing a minimum subset of the source languages. In a data processing means such as a smart card, an execution medium is dedicated to the intermediate language. The intermediate language program is loaded with a respective programming library adapting the respective source language to the intermediate language in order to execute the intermediate language program in the execution medium.

Abstract: Each component binary in a heterogeneous program is translated from a platform-specific instruction set into a set of intermediate representation (IR) instructions that are platform-neutral. The IR instructions are grouped into IR code blocks, the IR code blocks into IR procedures, and the IR procedures into IR components to create an intermediate representation hierarchy for the program. An application program interface is provided that permits user access to the IR hierarchy for instrumentation, optimization, navigation, and manipulation of the IR hierarchy. The transformed IR hierarchy is then translated into platform-specific instructions and output as a modified binary. The user can designate a different platform for the output translation of a code block than the platform for which the code block was originally written. Prologue and epilog code is added to contiguous blocks that are translated into different architectures.

Abstract: A proxy component system having dispatch proxies and object proxies is disclosed. The computerized system includes an operating system supporting component interfaces. In addition, the system includes a first interface to a target component, with the first interface having an early bound method. The system further includes a second interface to a proxy component, with the second interface having a late bound method. Also included in the system is a dispatch proxy operative to invoke the early bound method of the first interface from an invocation of the late bound method of the second interface.

Abstract: This system sets up a framework that allows for separating debug information from executable code. The system is comprised of a compiler, a linker and a debugger. The compiler produces optimized object code and a debugging information file that contains information necessary for symbolic debugging. The linker merges the optimized object files to produce an optimized executable file as well as debugging information files to produce a composite debugging information file. This debugging information file can be further refined when the program is executed to include runtime dependencies. The debugger provides a source code debugging environment and a core dump debugging environment for the optimized code. The debugger allows monitoring of variable values, placement of watches on changes in variable values, setting breakpoints by location or by name and performing program debugging at a source code level.

Abstract: A method and apparatus for using a single computer program code base to provide a program that is operable in either a client-server mode or a standalone mode are provided. In one embodiment, a client logic element has one or more proxy objects, each of which implement an interface that is neutral with respect to the client-server mode and the standalone mode. A server logic element has one or more service objects. Each of the service objects implements the interface. The interface implementations are not bound to any code that is specific to the client-server version or the standalone version. In the stand-alone version, the client side logic invokes the server side logic directly through the interfaces, as implemented by the service objects. In the client-server version, the client side logic invokes the server side logic through the same set of Java interfaces.

Abstract: The invention provides an improved digital data processing system, e.g., storage area network (SAN), of the type having a first digital data processor, e.g., a SAN server, and a second digital data processor, e.g., a SAN client, coupled to one another and to one or more storage units, e.g., disk drives. A volume is stored on one or more of the storage devices, with at least two of its blocks residing at locations that are not contiguous with one another. The improvement is characterized, according to aspects of the invention, by transmission from the first to the second digital data processor of one or more addresses. These can constitute, in total, fewer such addresses than would be provided in a canonical map of the volume and, indeed, can comprise (by way of non-limiting example) a start address for each file and/or a portion of the volume on each storage device where the volume resides.

Abstract: A parallel data processing system is provided for increasing the program execution rate of a target machine. A parallelizer converts intermediate code, which has been generated by a compiler front end, into a parallelly executable form. An execution order determiner determines the order of the basic blocks to be executed. An expanded basic block parallelizer subdivides the intermediate code of the basic blocks into execution units, each of which is made up of parallelly executable instructions, following the order determined and on the basic block basis. When a particular one of the basic blocks is subdivided into execution units, an instruction belonging to the first execution unit of the next basic block, which has already been subdivided into execution units, is also used.

Abstract: A process for packing an instruction word including providing a word value representing an instruction word into which an operation is to be fit be equal to some initial value having a plurality of portions representing constraints, operating on the initial value of the value word with operation class values having a plurality of portions representing constraints of a new operation as the new operation is attempted to be fit into the instruction to affect the processor word value in a manner to indicate when the limit of any constraint for the instruction is reached, and determining a violation of any constraint to determine that the new operation does not fit the format.

Abstract: A one-pass, greedy-pattern-matching, finite-state-machine code generator is disclosed. The code generator generates local code (such as processor-native code) from intermediate code (such as Java byte code). In one embodiment of the invention, a computer-implemented method for generating local code from intermediate code first includes receiving a current element of a post-fix-notated intermediate code. The method receives a current element of a postfix-notated intermediate code, and matches the current element to a base rule within a predetermined intermediate code-to-local code grammar. The method then selects and applies a matching base rule based on a predetermined criteria. A local code is then generated according to the matching base rule applied to the current element. A next element of the intermediate code is then advanced to as the current element.

Abstract: The invention provides a program conversion apparatus which performs parallelization for a multi-thread microprocessor on an intermediate program level. A parallelization apparatus of the program conversion apparatus includes a fork spot determination section, a register allocation section and an instruction reordering section. The fork spot determination section determines a fork spot and a fork system based on a result of a register allocation trial performed by the register allocation section, the number of spots at which memory data dependence is present, and branching probabilities and a data dependence occurrence frequency obtained from a profile information file.

Abstract: In one aspect of the invention, the frames of a thread stack that associated with the misbehaving code are popped from the thread stack. Exception handling code is allowed to execute for trusted code by popping the trusted code frame via processing an exception, but exception handling is not allowed to execute for untrusted code. In a second aspect, frames are popped on all thread stacks of all threads that are associated with the misbehaving code. Threads are generally deemed to be associated with the misbehaving code when the threads share a same object or the same resources as the thread that is associated with the misbehaving code.

Abstract: A system and method for providing access to a server by a wireless computing device is described. A server and a wireless computing device and a communications link between the wireless computing device and the server are provided. The wireless computing device includes a hardware component including a processor and a memory. The server generates instructions and converted data based on data requested by the wireless computing device. The wireless computing device also includes an identification module. The identification module can provide identification data to the server.