Abstract: System and method for performing program-related operations over a network via a web browser. A network connection is established between a server computer and a client computer over a network. A universal resource identifier (URI) is sent from the client computer to the server computer over the network, where the URI indicates a program, e.g., a graphical program (GP), or at least a portion of a graphical program interactive development environment (GPIDE), e.g., a graphical program editor, an execution engine, a static or dynamic analyzer, and/or compiler. The at least a portion of the GPIDE is received from the server computer over the network in response to the URI, and executed in a web browser of the client computer to perform some specified functionality with respect to the GP.

Abstract: Methods are disclosed for providing virtual objects and associating semantic annotations with the virtual objects. A user may be enabled to take virtual photographs of the virtual objects, wherein the semantic annotations associated with the virtual objects visible in the virtual photograph are stored with the virtual photograph. The virtual objects may be included in a virtual world. The user may be enabled to query a computer-controlled character about a virtual object in the virtual photograph, or in a virtual world in realtime, wherein the computer-controlled character is enabled to respond to the query by combining the semantic annotation associated with the virtual object in the virtual photograph with additional semantic annotations tagged to the computer-controlled character or a context of the virtual world to dynamically provide a semantic output, in various embodiments.

Abstract: A system including spreadsheet sheets, makes calculations and data transformations, which is available through a programming interface, and conforms to the grammar and syntax of a target software development language is presented. The system includes an Object Model with Data Structures representing entities involved in spreadsheets. The system includes a Parser and Code Generator that extracts data from a body of spreadsheet data, instantiates instances of Data Structures of the Object Model to represent the spreadsheet data, parses the data and formulas contained in the cells of the spreadsheets, iterates through the instantiated instances of the Data Structures, and generates source code that performs the calculations and data transformations embodied in the spreadsheet data. The system includes a Calculation Engine with software base classes that implement the common structural and data access features of spreadsheet data, and further implement the operations of common spreadsheet functions and operators.

Abstract: Improved computer interface system using multiple independent hardware and virtual human-computer input devices and related enabling subroutines is disclosed. Multiple independent data input devices allow users to input data independently from multiple independent data input devices to operating system. Input device driver decodes input from multiple independent input devices. Operating system interface software interprets data from input device driver. Operating system software further generates and controls multiple cursors or control points. Input device aware program obtains and interprets input devices event message, and controls input device aware objects.

Abstract: Methods, systems, and articles of manufacture consistent with the present invention provide an improved technique for analyzing statements that use pointer or array syntax to access dynamically-allocated arrays to determine whether the statement generates a reference that is outside the bounds of the array's allocated memory. Statements that use pointer or array syntax to access dynamically-allocated arrays can be either statically (at compile-time) or dynamically bounds (at run-time) checked. Methods and systems in accordance with the present invention determine at compile-time if an array reference can be determined to always be in bounds or definitely out of bounds at least once, and if not, insert code into the program to check the array bounds dynamically at run-time before the access of the array reference.

Abstract: A technique for flexibly adding instrumentation to an application. A file is created which includes a dynamic parameter syntax. The file identifies a trace point in the application, such as a method, and the syntax includes one or more parameters which are evaluated when the method is invoked. The parameters can be used to provide cross-process correlation and/or performance metrics. A client process which calls a server process can include the parameter in a message header according to any desired transport protocol, such as HTTP or JMS. Different application protocols and implementation can be accommodated to track a transaction which executes on different platforms. The dynamic parameter syntax is interpreted as uncompiled code and is designed to be added by the user in the field to augment a package of pre-built instrumentation software after the package has been deployed.

Abstract: Provided is a file conversion device which converts a file form written in a given language to a file form that can be interpreted by another language, which includes: a file readout device which reads description contents of an inputted file by each line, and manages the description contents by adding an index to each line of the read description contents; a syntax tree creating device which converts the description contents into a syntax tree of a tree structure based on the indexes through linearly scanning the indexes of the file managed by the file readout device; a syntax tree optimizing device which optimizes the tree structure of the syntax tree as a flowchart according to an optimization rule; and a file dividing device which divides the inputted file by having controllers in the flowchart optimized by the syntax tree optimizing device as identifiers.

Abstract: In some embodiments of the present invention, files are generated from .java files or .class files or .jar files. The generated files are directly linkable and interpretable by a Java Virtual Machine. The generated files may be stored in a directly addressable memory of a device. References between .class files may appear in the generated files as hard offsets or symbolic references. The generated files may be grouped so that cross-references between generated files in the same group appear as hard offsets.

Abstract: A Java bytecode translation method and a Java interpreter performing the Java bytecode translation method are provided. The Java bytecode translation method includes extracting a number of successive Java bytecodes from a Java class, determining whether the extracted successive Java bytecodes are successive field access bytecodes for accessing a field in the Java class and translating the extracted successive Java bytecodes into predefined bytecode if the extracted successive Java bytecodes are determined to be the successive field access bytecodes, and executing the predefined bytecode.

Abstract: Systems and techniques for testing machine-readable instructions. In one aspect, a method includes identifying a subroutine in a set of machine-readable instructions that can request a service from a service provider, modifying the identified subroutine to convey a description of a service request to a recorder, and storing the modified subroutine so that the modified subroutine is accessed during subsequent data processing activities and the description of the service request is conveyed to the recorder in response to a request for the service from the service provider during the data processing activities.

Abstract: The adaptation of at least a portion of an object provided by a previous script component to a subsequent script component, despite the subsequent component being incapable of recognizing a format of the at least a portion of the object as provided by the previous component. The previous component generates an object having a property. Adaptation script identifies adaptation(s) to perform on the property prior to being used by the subsequent component. The adaptation is performed, and the adapted property is then used by the subsequent component.

Abstract: An integrated circuit card is used with a terminal. The integrated circuit card includes a memory that stores an interpreter and an application that has a high level programming language format. A processor of the card is configured to use the interpreter to interpret the application for execution and to use a communicator of the card to communicate with the terminal.

Abstract: A signal processing board including a resource board substrate, an external interface on the board substrate, adapted to receive signals for processing, at least one slot adapted to receive a plug-in module with at least one processor thereon and an interface unit adapted to at least participate in converting signals exchanged between the external interface and a processor on a module received by the slot, between a format of signals received by the external interface and a signal format of the processor. The interface unit is suitable to at least participate in the conversion for a plurality of types of processors that differ in the format in which they transmit or receive signals.

Abstract: A method for executing a target application on a host processor including the steps of translating each target instruction being to be executed into host instructions, storing the translated host instructions, executing the translated host instructions, responding to an exception during execution of a translated instruction by rolling back to a point in execution at which correct state of a target processor is known, and interpreting each target instruction in order from the point in execution at which correct state of a target processor is known.

Abstract: A method, system and computer program product for performing error correction are disclosed. The method includes performing on source code a selected compilation operation from among a set of compilation operations and, responsive to encountering an error in the selected compilation operation, running an error handler to isolate the error utilizing data logged for the compilation operation. Responsive to determining that the error handler has not sufficiently isolated the error, a source code modifier is run to modify a portion of the source code selected by reference to the data logged for the compilation operation.

Abstract: A programming language is extended to have embedded interpretive types (EIT) that define objects and variables to be resolved at translation time. A variable or data element having a type that is one of the EITs is referred to as an embedded interpretive variable (EIV). A control construct containing an EIV is interpreted (i.e. executed) at translation time.

Abstract: In a method for the optimisation of compiler-generated program code, the compiler-generated program code is searched for program code fragments which correspond, at least in their effect, to respectively one library code fragment contained in a predefined library. The program code fragments found thereby are replaced by respectively one call of the corresponding library code fragment. A computer program product comprises program instructions for the execution of this method. A portable data carrier contains both the program code optimised according to this method and the library.

Abstract: Computerized facilitation of an assessment of risk associated with running interpretable code. The interpretable code under evaluation is parsed to identify a command unit within the interpretable code. One or more risk factors associated with the identified command unit is then identified using the parsed code. A report is then made of including identification of the command unit found the interpretable code along with the identified associated one or more risk factors. Thus, a user need not have to read and evaluate the interpretable code itself, but may instead review the much less complex report to evaluate the risks associated with running the interpretable code.

Abstract: Improved computer interface system using multiple independent graphical data input devices is disclosed. Multiple independent graphical data input devices allow users to input data independently from multiple independent graphical data input devices to operating system. Graphical input device driver decodes input from multiple independent graphical input devices. Operating system interface software interprets data from graphical input device driver. Operating system software further generates and controls multiple cursors or control points. Graphical input device aware program obtains and interprets graphical input devices event message, and controls graphical input device aware objects.

Abstract: A method for configuring software modules that includes accessing a properties repository that includes a plurality of properties of the execution environment of the computer system. The method further includes generating a configuration file for each software module. Generating a configuration file includes obtaining a generator module defined for the software module, and executing the generator module to instantiate the configuration file for the software module. The generator module is configured to identify a property required for the configuration file, obtain the value for the property from the properties repository, and store the value for the property in the configuration file in accordance with a customized format required by the software module. The method further includes storing the configuration file for each of the software modules.

Abstract: In embodiments, prior to compilation into machine code, a preprocessor generates directives by processing a source code and/or bytecode representation of a program and/or selecting default directives. The preprocessor embeds the directives in a bytecode representation of the program or a separate stream associated with the bytecode representation of the program. A just-in-time compiler may compile the bytecode representation into machine code directed by the embedded directives in one pass and/or a bytecode interpreter may interpret the bytecode representation of the program. In some embodiments, a computing device generates bytecodes during execution of a program, selects default directives, and embeds the default directives in the bytecodes or a separate stream associated with the bytecodes prior to compilation of the bytecodes into machine code.

Abstract: The present invention provides a method, system, and program product for composing a virtualized computing environment. Specifically, under the present invention, data and a definition file that contains application runtime requirements for the data are stored on a portable memory device. Application runtime requirements can be anything related to an environment in which the data was previously used. When the portable memory device is received in a computerized device, an auto-insert script can be executed that signals a provisioning system and/or transports the definition file to the provisioning system. The provisioning system will then interpret the definition file on the computerized device to retrieve the application runtime requirements. Then, the virtualized computing environment will be composed by adapting an environment of the computerized device according to the application runtime requirements retrieved from the definition file.

Abstract: There is described a method of compiling source code for a computer programme into corresponding object code. The source code includes several declared variables. The method comprises, for each declared variable in the source code, including in the object code a declaration statement indicating an associated memory location for that variable and indicating the position in the object code of the next declaration statement. During compilation, the memory location for each declared variable can be retrieved from the object code by examining each declaration statement in turn, using the position information from each declaration statement to locate the next declaration statement. This is of particular advantage where the available volatile memory is limited, because there is not requirement for a look-up table of variables against memory locations.

Abstract: A method is disclosed for reducing dynamic pauses during dynamic compilation. Applications running on a system detect the rendering of dynamic output to a user. The dynamic output represents a change in visual or audio data while any application is running. When an application detects such output it notifies the system, which monitors the frequency of the dynamic output. If the frequency of the dynamic output exceeds a threshold, the system informs a compiler on the system to suspend compilation. Compilation normally occurs when an interpreter on the system is instructed to pass processing control to the compiler. One way this occurs is if a method currently being processed by the interpreter has been marked for compilation. Thus, in order to suspend compilation, the compiler ceases to mark methods for compilation so that the interpreter will not be instructed to pass processing control to the compiler.

Abstract: An object-oriented management device for ASN.1 message is provided, which includes: an ASN.1 bottom supporting module for compiling the ASN.1 message into programming language example code; a common manipulation module for processing the message to support the message applications; a message plug-in for creating the message corpus plug-in from the code generated by the common manipulation module, with the class description table being the plug-in interface. The present invention solves the problem that the message structure example should be re-established after the message is persistently saved, overcomes the disadvantage that the data type of the bit stream must be known in advance for decoding, decreases the difficulty of message construction, and significantly lessens the workload of the message development and maintenance.

Abstract: Traditional control systems are first designed by subject matter experts that create business rules and scenarios. Then, the systems are developed by system developers, people who translate business rules and scenarios into technology. The invention allows business rules and scenarios to be directly included in a control system and via the Scenario Player and other components directly drive the controlling services, providing for knowledge-driven architecture control systems. These systems can easily adjust its controlling behavior, improving flexibility to a variety of control systems including but not limited to video and audio systems, distributed networks and their combinations for medical, military and transportation applications. This description is not intended to be a complete description of, or limit the scope of, the invention.

Abstract: The deployment of native methods in a virtual machine environment may be significantly simplified by incorporating a corresponding native code segment into the application file, such as a JAVA class file, and using the embedded native code segment for library bind operations of the corresponding class file.

Abstract: A system that includes a shared variable scope configured to store at least one shared variable binding, a first interpreter configured to search the shared variable scope to determine a variable binding for a variable, and a second interpreter configured to search the shared variable scope to determine the variable binding for the variable.

Abstract: A virtual project system is described herein that creates a virtual project to provide information during remote debugging similar to the project information available for local debugging. The virtual project contains each of a document's local and original Uniform Resource Identifiers (URIs) for documents that are downloaded and compiled locally. At debug-time, the virtual project system injects the virtual project with information resolved by the debugger, including the original URI and the locally compiled version of the document. This allows the virtual project to associate the local to original URI mappings so that when the IDE receives symbol information at debug-time and attempts to open the document that has the current debug context, the IDE opens the correct remote document rather than a local copy. This ensures that any changes made by the user during debugging affect the remote document, rather than the temporary local copy.

Abstract: A method, system and computer program product for collecting profiling information during runtime of a multithreaded program. According to the method, a plurality of instructions of the program for execution in an application thread are first received; a plurality of variable size profiling records are then stored in a buffer assigned exclusively to the application thread during execution of the plurality of instructions; and the plurality of profiling records in the buffer are then processed. The program may be written in Java bytecode for execution in a Java virtual machine with the processing of profiling buffers performed by a component of a JIT compiler for insertion into a repository in internal JIT format, e.g. a hash table, for later optimization processing.

Abstract: A method for executing a target application on a host processor including the steps of translating each target instruction being to be executed into host instructions, storing the translated host instructions, executing the translated host instructions, responding to an exception during execution of a translated instruction by rolling back to a point in execution at which correct state of a target processor is known, and interpreting each target instruction in order from the point in execution at which correct state of a target processor is known.

Abstract: In some embodiments of the present invention, files are generated from java files or class files or jar files. The generated files are directly linkable and interpretable by a Java Virtual Machine. The generated files may be stored in a directly addressable memory of a device. References between class files may appear in the generated files as hard offsets or symbolic references. The generated files may be grouped so that cross-references between generated files in the same group appear as hard offsets.

Abstract: Embodiments of the present invention relate to systems, methods and computer storage media for providing Structured Computations Optimized for Parallel Execution (SCOPE) that facilitate analysis of a large-scale dataset utilizing row data of those data sets. SCOPE includes, among other features, an extract command for extracting data bytes from a data stream and structuring the data bytes as data rows having strictly defined columns. SCOPE also includes a process command and a reduce command that identify data rows as inputs. The reduce command also identifies a reduce key that facilitates the reduction based on the reduce key. SCOPE additionally includes a combine command that identifies two data row sets that are to be combined based on an identified joint condition. Additionally, SCOPE includes a select command that leverages SQL and C# languages to create an expressive script that is capable of analyzing large-scale data sets in a parallel computing environment.

Abstract: Embodiments described herein are directed to allowing a user to extend the functionality of a software code interpretation system. In one embodiment, a computer system receives user-defined conversion rules from a user for converting dynamic language code to continuation-based abstract memory representations. The computer system identifies portions of software code that are to be converted from dynamic language abstract memory representations into continuation-based abstract memory representations, where the identified code portions include undefined, extensible input primitives. The computer system also generates a dynamic, extensible set of output primitives interpretable by a continuation-based code interpretation system using the received conversion rules and converts the identified code portions including the undefined, extensible input primitives from dynamic language abstract memory representations into continuation-based abstract memory representations using the generated set of output primitives.

Abstract: A device-independent intermediate representation of a source code is generated and stored, e.g., in a memory or other storage mechanism. The stored intermediate representation of the source code is used to generate a device-specific machine code corresponding to the source code. The stored intermediate representation may be updated, e.g., periodically, for example by obtaining an updated version of the source code and compiling the updated source code to generate an updated intermediate representation. The stored intermediate representation may be based on source code received from a device that is synchronized with which a compiling device that generates the device-specific machine code. In some cases, the stored intermediate representation may be used to generate for each of a plurality of devices a corresponding device-specific machine code.

Abstract: A method for anti-piracy protection of a software application by obfuscation of the execution of portions of the applications code is described. The method includes providing a language specification and library to implement the functions of the language, providing a compiler to translate the language into byte codes, and providing an interpreter to execute the byte codes using the library. The method further includes providing the language specifications, library, compiler, interpreter, and instructions to a software publisher, where the software publisher embeds the library and interpreter in the application to be protected, and selects and prepares application code segments for processing into byte codes by the compiler. The application is then executed using the embedded library and interpreter, where the execution of the application is obfuscated by the use of byte codes.

Abstract: A business software framework includes an application framework that has a process model. The process model provides desired services to the business components. The process model arranges operations into activities. The process model can also use an agent/service arrangement.

Abstract: A system and method is provided for generating and executing specialized code executables. The system includes a virtual subsystem that processes a generic code image and logs information relating to an operating environment of the virtual subsystem. The logged information is employed as feedback to generate a specialized native executable, wherein the specialized native executable is utilized to provide improved performance of the virtual subsystem. The specialized native executable is selected for execution by the virtual subsystem by matching a current operating environment setting with the logged information.

Abstract: A method and system is provided that allows a well-behaved program to execute more quickly than dynamically typed programming languages did in the past, thereby allowing a the dynamically typed language to be competitive with static declarative programming languages. A method includes converting lines of source code representing functions to byte-codes representing functions, selecting a subsequence of the byte-codes based on the byte-codes and the dynamic run-time properties of program variables, generating processor instructions in a compiler for the subsequence, and interpreting the byte-codes not contained in the subsequence.

Abstract: Systems and methods for executing business processes over a network. In an exemplary embodiment of a method of executing business processes via a computer network, the method comprises the steps of creating and installing software resources available over a network, browsing a database of software resources using a process model builder to identify software resource definitions, loading the software resource definitions identified by the process model builder to create a business process model comprising the software resources from the database of software resources, mapping inputs and outputs of the database of software resources to allow the business process model to be executed, saving the business process model on a storage medium accessible by the network, and initiating a collaborative business process by loading the business process model into a process interpreter and executing the software resources defined within the business process model.

Abstract: A device for processing a program code with a plurality of subprogram calls, a subprogram corresponding to a subprogram call taking place by means of an allocation table, has a security module having the allocation table and a processor for using the program code. Access to the allocation table in the security module is restricted. The processor for using the program code is formed to retrieve, responsive to a request for subprogram data, using authorization information, subprogram data via the allocation table in the security module.

Abstract: The present invention translation verification system and method verifies code fragment translations and/or optimizations that are bounded by externally observable information.

Abstract: Selected regions of native instructions translated in a DBT environment from non-native instructions are compressed based on the independent compression of different fields of selected instructions using compression tables to reduce a length of selected fields. The regions of compressed instructions are stored and de-compressed into the native instructions during subsequent execution using de-compression tables. Specifically, for native instructions of a selected region, selected types of opcodes and/or operands may be compressed independently. The types may be selected by profiling the opcodes using benchmark programs and creating an opcode conversion table prior to compression, and scanning of the operands and creating an operand conversion table during compression of the opcodes.

Abstract: An efficient, logical and expressive type system supports the combination of refinement types and type membership expressions, as well as a top type that encompasses all valid values as members. A bidirectional type checking algorithm is provided for the type system including synthesis and checking steps to statically verify types of code based on the type system.

Abstract: Bounding resource consumption of code that processes recursive data structures and collections includes making use of quantitative functions (based on user input) that are associated with a tuple of data-structures and whose semantics is specified by describing the effect of various data-structure methods on the relevant quantitative functions. Counter variables are incorporated into source code to count loop iterations (and number of recursive procedure call invocations). Relevant quantitative functions are incorporated into the source code to allow computation of invariants (and hence bounds) on the incorporated counter variables in terms of the quantitative functions.

Abstract: A method for supporting input/output for a virtual machine. The method includes the step of executing virtual machine application instructions, wherein the application instructions are executed using micro architecture code of a processor architecture. An I/O access is received from the virtual machine application. Virtual memory protection is used to generate an exception, wherein the exception is caused by the I/O access. A single step mode is entered to perform the I/O access using a host operating system. State data for the virtual machine application is updated in accordance with the I/O access. Subsequently, execution of the virtual machine application is resumed.

Abstract: A method and protocol tester for decoding data for the performance of a measurement task, which data is encoded in accordance with a protocol description, includes modifying the protocol description with respect to the measurement task by compressing protocol elements that are of no relevance to the measurement task and decoding the encoded data according to the modified protocol description to provide only decoded data relevant to the measurement task. The decoded data may be filtered before further processing according to a filter condition determined by the measurement task. Alternatively the filter condition may be installed as part of the modified protocol description. Then additional filtering may be applied when there are further filter conditions determined by the measurement task. The result is a protocol tester that permanently stores the protocol description while allowing modification of the protocol description for each measurement task, reducing storage and calculation requirements.

Abstract: An adjustable precision exception handling technique is providing for handling exceptions encountered during translation of subject code to target code at varying levels of precision, depending upon the particular type of exception encountered. As an exception signal is detected by the translator, the state of the subject processor is captured at a precision determined to be sufficient for the detected exception.

Abstract: A system for automation of processes in a working environment to achieve targeted deliverables, said system comprising: mapping means adapted to map discrete processes in a working environment; reader means adapted to read human instructions in relation to targeted deliverables at mapped discrete processes; interpreter means adapted to interpret said read instructions into a machine readable instruction format; compiler means adapted to compile said machine readable instruction format into a pre-defined operating system executable instruction format; packager means adapted to classify and package said operating system executable instruction format in a pre-defined format; and installer means adapted to install and deploy said packaged format in said working environment to complete the automation process and achieve targeted deliverables.

Abstract: Reference architecture instructions are translated into target architecture operations. In some embodiments, an execution unit of a processor executes a function determined from a collection of operations, the function specifying functionality based on instructions, the collection selected from operations translated from the instructions. In further embodiments, the function is specified as a fused operation. Sequences of operations are optimized by fusing collections of operations; fused operations specify a same observable function as respective collections, but advantageously enable more efficient processing. In some embodiments, a collection comprises multiple register operations. Sequences of operations, in a predicted execution order in some embodiments, form traces. In some embodiments, fusing operations requires setting only final architectural state, such as final flag state; intermediate architectural state is used implicitly in a fused operation.