Abstract: A system and method for generating test code software utilized by a test system for testing a circuit card assembly is provided. A translator provides an automatic translation of a test code from a first computer language to a second computer language. One or more pinmap documents are provided to map the pins of the circuit card assembly.

Abstract: A program-converting module for a multi-axis cooperated machine and a program-converting method. Machining programs and mechanism data of a plurality of first machines are input to a first input module. Mechanism data of a plurality of second machines are input to a second input unit. A setting unit sets at least one of the first machines to be a source machine, and sets one of the second machines to be a target machine. A conversion unit uses a kinematical method to convert the machining program of the source machine into a machining program applicable to the target machine based on the mechanism data of the source and target machines, without requiring CAD/CAM software.

Abstract: A generated grouped representation of existing source code can define regions of the existing source code. A set of the regions that can run in parallel can be identified based on the grouped representation. The grouped representation can be converted into a modified representation, such as modified source code or a modified intermediate compiler representation, which can be configured to be resolved or executed to self-schedule the set of regions to run in parallel as a set of tasks. Additionally, the source code can include one or more exception handling routines, and user input can be received to identify in one or more lambda expressions one or more regions of the source code to be run in parallel as one or more tasks.

Abstract: In an embodiment, a runtime callback function is a part of a code that is invoked upon execution of an associated function. To execute the runtime callback function associated with an in-memory computing engine, multidimensional analytical metadata associated with an application server is received and transformed into an in-memory executable metadata, to generate an instance of an in-memory executable calculation scenario. The instance of the in-memory executable calculation scenario is analyzed to determine process callbacks associated with nodes of the in-memory executable calculation scenario. Based upon the determined process callbacks, the runtime callback function is executed by executing a selection callback at the nodes and a transformation callback at part providers associated with the in-memory executable calculation scenario.

Abstract: Systems and methods are disclosed for providing sales or customer support using a telephone having a camera to capture at least a partial image of a product or service; wherein the at least partial image is used to select a database updated by one or more knowledgeable persons on the product or service.

Abstract: A content syndication platform, such as a web content syndication platform, manages, organizes and makes available for consumption content that is acquired from the Internet. In at least some embodiments, the platform can acquire and organize web content, and make such content available for consumption by many different types of applications. These applications may or may not necessarily understand the particular syndication format. An application program interface (API) exposes an object model which allows applications and users to easily accomplish many different tasks such as creating, reading, updating, deleting feeds and the like.

Abstract: A system and method for configuring an event-based process are disclosed. A configuration module receives input describing an event-based process or modifications to an event-based process. For example, the configuration module receives as input a graphical depiction of one or more states and state transitions that comprise at least a portion of the event-based process. Using the received input description, the configuration module generates executable data, such as data formatted as an event processing language, corresponding to the input. The executable data is then communicated to an event engine which executes the executable data to implement the event-based process or modifications to an event-based process corresponding to the received input. One or more aspects of the execution of the event-based process may also be visualized, and graphically modified, though an event monitoring module.

Abstract: A report representation system and method of transforming report outputs into a standard representation format are provided. The report representation system comprises a report parser for parsing a report output, a code generator for generating a standard representation code of the report output and a code compiler for converting the standard representation code into a format representable as a fixed schema repository. The method comprises the steps of parsing a report output, generating a standard representation code of the report output and converting the standard representation code into a format representable as a fixed schema repository.

Abstract: A computer readable medium is configured to receive a description of a COBOL copybook that can be represented in one of a plurality of disparate formats, to parse the COBOL copybook based on the description of the COBOL copybook, and to create a standardized data record schema based on the COBOL copybook. The description of the COBOL copybook includes information about the format of the COBOL copybook.

Abstract: A configurable memory allocation and management system may generate a configuration file with memory settings that may be deployed prior to runtime. A compiler or other pre-execution system may detect a memory allocation boundary and decorate the code. During execution, the decorated code may be used to look up memory allocation and management settings from a database or to deploy optimized settings that may be embedded in the decorations.

Abstract: A method, system, and computer program product are disclosed for creating an OWL ontology from a Java source code, wherein the Java source code includes a plurality of Java classes. Each of these Java classes includes one or more Java members and one or more Java objects. The Java objects are used to instantiate each of the Java classes. An OWL class is created for each of the Java classes, and an OWL concept is created for each of the Java members. Further, an OWL instance is created for each of the Java objects. Each of the OWL classes, the OWL concepts, and the OWL instances are assigned data type properties and object properties. Subsequently, each of the OWL classes and relations between them, each of the OWL concepts, and each of the OWL instances are included to form the OWL ontology.

Abstract: A configurable memory allocation and management system may generate a configuration file with memory settings that may be deployed at runtime. An execution environment may capture a memory allocation boundary, look up the boundary in a configuration file, and apply the settings when the settings are available. When the settings are not available, a default set of settings may be used. The execution environment may deploy the optimized settings without modifying the executing code.

Abstract: A system obtains code that includes sequences of code; identifies, within a first sequence of code and based on obtaining the code, a first routine that, when executed, enables an array of values to be generated. The array of values is associated with a variable included within the first routine. The system determines whether the routine includes a particular term, and identifies, within the routine, a first identifier when the routine includes the particular term. The first identifier corresponds to a second sequence of code that identifies a first data structure that stores information that identifies one or more second routines. The system identifies, within the data structure, a second routine based on the particular term and a second identifier corresponding to the first routine; executes, using the variable, the second routine to generate a result; and outputs the result based on executing the second routine.

Abstract: A mechanism is provided for improving single-thread performance for a multi-threaded, in-order processor core. In a first phase, a compiler analyzes application code to identify instructions that can be executed in parallel with focus on instruction-level parallelism and removing any register interference between the threads. The compiler inserts as appropriate synchronization instructions supported by the apparatus to ensure that the resulting execution of the threads is equivalent to the execution of the application code in a single thread. In a second phase, an operating system schedules the threads produced in the first phase on the hardware threads of a single processor core such that they execute simultaneously. In a third phase, the microprocessor core executes the threads specified by the second phase such that there is one hardware thread executing an application thread.

Abstract: Localizing display of applications for download, the method including receiving from a developer and ingesting into an online store an application localized in different languages, including a designated default language, determining a local language of a user desiring to download the application from the online store, presenting to the user an interface to download a version of the application in the user's local language if the application is available in the user's local language, and presenting to the user an interface to download the version of the application in the designated default language if the application is unavailable in the user's local language. In the case of people who speak more than one language, determining a local language of a user further includes determining one or more secondary local languages and/or assigning an order of priority to the secondary languages.

Abstract: A method, computer system and computer program product localize a source language user interface of software application to a target language user interface. While the software application is executing using the source language user interface, source language GUI component text of a GUI component is extracted from bytecode of the software application. The extracted source language GUI component text is formed into a localization pack file. The source language GUI component text of the localization pack file is translated to the target language. In response to the software application executing again, the translated GUI component text is loaded from the translated localization pack file. The GUI component is displayed with the translated GUI component text.

Abstract: Embodiments of the present invention address deficiencies of the art in respect to externally stored static elements for a document in a document editor and provide a method, system and computer program product for moving static elements for a document between an external file and the document in a document editor. A data processing system for moving static elements for a document between an external file and the document in a document editor can include an automated de-externalization and re-externalization processor coupled to a document editor. The automated de-externalization and re-externalization processor can include program code enabled both to replace static elements in a subject document with static element references while storing replaced static elements in entries in an external file, and also to replace static element references in the subject document with corresponding static elements stored in the entries in the external file.

Abstract: Disclosed herein are systems, methods, and computer-readable storage media for obfuscating by a common function. A system configured to practice the method identifies a set of functions in source code, generates a transformed set of functions by transforming each function of the set of functions to accept a uniform set of arguments and return a uniform type, and merges the transformed set of functions into a single recursive function. The single recursive function can allocate memory in the heap. The stack can contain a pointer to the allocated memory in the heap. The single recursive function can include instructions for creating and explicitly managing a virtual stack in the heap. The virtual stack can emulate what would happen to the real stack if one of the set of functions was called. The system can further compile the source code including the single recursive function.

Abstract: A method of localizing a computer program code comprises, with a manager node, updating a message catalog, localizing code at the manager node, and distributing the localize code to a number of client nodes. An apparatus for localizing computer program code comprises a processor, and a memory communicatively coupled to the processor, in which the memory comprises a message catalog, and in which the processor updates a message catalog, localizes code at the manager node, and distributes localize code to a number of client nodes.

Abstract: A program executing apparatus, includes: a nonvolatile memory that stores a program for activating an equipment and a variable used in the program and sustains the stored program and the variable even though power is not supplied, the program and the variable being able to be read out and written into the nonvolatile memory; and an executing unit that transmits the program and the variable to the nonvolatile memory when the activation of the equipment is instructed at an initial status where the program and the variable are not stored in the nonvolatile memory, and successively executes the program using the variable stored in the nonvolatile memory, and, when the activation of the equipment is re-instructed, executes the program using the variable stored in the nonvolatile memory.

Abstract: A system comprises a media framework component graph, a first media framework, a second media framework, and a media framework translator. The media framework component graph comprises one or more components. The one or more components are coupled with the first media framework. The first media framework is designed to run the media framework component graph. The media framework translator enables the first media framework and the media framework component graph to both function as a component for the second media framework.

Abstract: A method and apparatus for processor emulation using speculative forward translation are disclosed. A potential candidate for forward translation is identified from one or more portions of target system code. A priority for forward translation is assigned to the potential candidate. It is determined whether the potential candidate is a valid candidate for forward translation. If valid, the potential candidate is translated with a host system to produce one or more corresponding blocks of translated code executable by the host system.

Abstract: A computer implemented application development (authoring) system permits objects (such as VBX custom controls) to be graphically inserted into the program under development by dragging and dropping associated icons into one of four views. The properties associated with the object may then be assigned settings. Development of a complete application is accomplished by visually arranging, ordering, and interconnecting the objects without the necessity of writing any code. The four views of Output, Map, Multitrack, and Workform may be synchronized so that changes made to the program in one view are simultaneously reflected in all other views. The system generates as output a script listing the objects and their properties which is then executed by a separate run time program. The system permits use of objects written to a standard specification and the addition at any time of additional objects written to that.

Abstract: Embodiments of methods and systems for managing translation of a source code of a computer application, at a processing device, are described. A pre-translation analysis of the source code may be performed to determine a plurality of look-alike code snippets. Thereafter, a report may be generated for indicating at least one parameter associated with the plurality of look-alike code snippets. Subsequently, at least one of the plurality of look-alike code snippets may be modified with at least one pre-stored code snippet, based on the at least one parameter.

Abstract: A method and an apparatus that optimally compile a source code for a data transformation operation in response to a request from a run-time application are described. A current state of the run-time application is included in the request. The application executes a non-optimized library routine for the data transformation operation while a separate worker thread performs optimized code compilation on the source code for the data transformation operation based on the request at the same time. The request includes a current state of the run-time application. The non-optimized library routine has been pre-built during build time.

Abstract: In a managed execution environment, an error may be deferred until execution of the application, program, function, or other assemblage of code reaches a point at which calling the reference to a module associated with a missing type or type member becomes inevitable.

Abstract: A computer implemented method includes receiving a client programming language input and a server programming language input, processing the client and server programming language inputs, and translating the client programming language input into an executable client application and the server programming language input into an executable server application, the executable client and server applications operable to communicate with each other. Processing the client and server programming language inputs includes identifying any invocations of server procedures of the server programming language input in the client programming language input, producing a combined server procedure in the server programming language input for identified server procedures invoked by the client programming language input, and replacing invocations of the identified server procedures in the client programming language input with an invocation of the combined server procedure.

Abstract: Provided is an XML processing device capable of describing, using conventional XML processing language, a method of processing also an asynchronously inputted XML. The XML processing device converts, according to a predetermined rule, the XML inputted asynchronously from outside and outputs the XML. The XML processing device is characterized by including an XML conversion module which performs XML conversion of the XML inputted according to the rule, an output destination interpretation module which interprets an output destination described in the converted XML, and an output distribution module which allows the XML to be outputted to the output destination interpreted by the output destination interpretation module.

Abstract: Embodiments of the present invention provide an architecture for securely and efficiently executing byte code generated from a general programming language. In particular, a computer system is divided into a hierarchy comprising multiple types of virtual machines. A thin layer of software, known as a virtual machine monitor, virtualizes the hardware of the computer system and emulates the hardware of the computer system to form a first type of virtual machine. This first type of virtual machine implements a virtual operating domain that allows running its own operating system. Within a virtual operating domain, a byte code interpreter may further implement a second type of virtual machine that executes byte code generated from a program written in a general purpose programming language. The byte code interpreter is incorporated into the operating system running in the virtual operating domain.

Abstract: Systems and methods of code evaluation for in-order processing are disclosed. In an embodiment, the method includes identifying a first instruction having multiple execution source paths. The method also includes generating a first execution path model identifying an execution order of multiple instructions based on a first condition and generating a second execution path model identifying an execution order of a second instruction based on a second condition. The method includes evaluating at least one of the execution path models to identify a hazard condition.

Abstract: A computer-implemented method of generating output computer code, for an application executable via a server running application logic in communication with a client running a presentation layer for the application, from input computer code of a synchronous application in which logic and presentation layers run locally on a single computer. The output code runs asynchronously.

Abstract: Data transformation is initiated by first obtaining a technical design document comprising non-machine-executable expressions of rules for transforming input data into output data. In one embodiment, a graphical user interface is employed to specify how to obtain the technical design document, as well as to designate locations of the input and output data. Thereafter, the technical design document is parsed such that the non-machine-executable expressions of the rules may serve as the basis for generating machine-executable transformation expressions. The resulting machine-executable transformation expressions may be optionally stored and subsequently applied to input data residing in one or more suitable repositories. In this manner, the instant techniques eliminate the need to capture the data transform rules using a data transformation tool, and instead rely on capturing the rules directly from the technical design documents, thereby improving efficiency and accuracy.

Abstract: A business object model, which reflects data that is used during a given business transaction, is utilized to generate interfaces. This business object model facilitates commercial transactions by providing consistent interfaces that are suitable for use across industries, across businesses, and across different departments within a business during a business transaction. In some operations, software creates, updates, or otherwise processes information related to a business rule business object.

Abstract: Methods and systems for processing text input within a man-machine interface (MMI) application framework are provided and may comprise creating at least one text editor by an active application and generating at least one text edit view by the text editor. Text input, for example, predictive input, multi-tap input and/or numeric input, which may be associated with the text edit view, may be received by the text editor. At least one text editor feature may be associated with at least one text editor and the text editor feature may comprise a maximum string length characteristic and/or a cursor characteristic. The text editor feature may be customized for each text editor view and the text input may be buffered by a buffer within the MMI application framework.

Abstract: The invention relates to a method and an apparatus for processing information in images pictured by infrared cameras comprising the steps of receiving radiation from at least one object in an area; extracting radiometric information from the radiation; transforming the radiometric information into at least one digital image file; storing the at least one digital image file and at least one digital function file comprising an executable code characterized by the steps of merging the executable code of the at least one digital function file into or with the at least one digital image file, thereby generating an executable digital image file, wherein the executable code comprises at least one instruction and is written in a programming language independent of system architecture. The invention further relates to a computer program product.

Abstract: Tools and techniques for repositories and related services for managing localization of resources are described herein. These repositories may include representations of resources provided in first human languages, representations of software products that may incorporate these resources; and representations of other human languages into which the resources are localized. The repositories may relate the resources to the software products and to the other human languages. Methods provided by these tools may receive the resources as provided in the first human languages, send the resources for localization into other human languages, and receive localized resources. The methods may convert the localized resources into binary representations, and build software products that incorporate the binary representations. The tools may also provide systems that include processors, suitable bus systems, and computer-readable storage media that contains the resource repository.

Abstract: Apparatus and methods are provided for controlling the loading status of DLLs. Specifically, a streaming program compiler is provided. The compiler includes operation modules for calling DLLs during streaming program execution; association table generating units for generating association tables according to user-defined rules, where the association table includes entries indicating (i) stream branches of the streaming program and (ii) an operation module corresponding to the stream branches; and a trigger generating unit for generating a trigger based on user-defined rules, where the trigger generating unit (i) determines which conditions for loading and unloading DLLs fit the streaming program, (ii) matches these conditions to a particular stream branch to identify a matched stream branch, and (iii) sends out triggering signals indicating the matched stream branch. This invention also provides a corresponding method and controller.

Abstract: In one embodiment, a file includes data that is divided into a plurality of sections, and each section may include metadata that includes the revision history for that section. A specific section of the file may be selected and its revision history queried. In response to such a query, the revision history for the selected section is extracted from the section metadata and may be displayed. If a portion of a section has been copied from a source section and pasted into a target section, the section metadata for the target section may be updated to include information about the source section. For each change to the section data, the section metadata may also include a version number, a revision date and time, a revision author and the actual insertion, deletion or other change to the section data.

Abstract: An approach is provided to receive a request at a first computer system from a second system. The first system generates an encryption key, modifies retrieved source code by inserting the generated encryption key into the source code, and compiles the modified source code into an executable. A hash value of the executable program is calculated and is stored along with the encryption key in a memory area. The executable and the hash value are sent to the second system over a network. The executable is executed and it generates an encrypted result using the hash value and the embedded encryption key. The encrypted result is sent back to the first system where it is authenticated using the stored encryption key and hash value.

Abstract: A computer-implementable method includes providing an instruction set architecture that comprises features to generate diverse copies of a program, using the instruction set architecture to generate diverse copies of a program and providing a virtual machine for execution of one of the diverse copies of the program. Various exemplary methods, devices, systems, etc., use virtualization for diversifying code and/or virtual machines to thereby enhance software security.

Abstract: Aspects of the subject matter described herein relate to creating and using deltas to modify existing computer code. In aspects, computer code may be translated into a higher level language to make it easier for a software developer to modify the computer code. The translated computer code may be presented by an editing tool that presents a user interface that allows changes to be made to the translated computer code. A delta engine may then determine a delta that indicates the changes to perform on the existing computer code to create computer code that would result from compiling the translated computer code as changed via the editing tool. Later, this delta may be used to change the existing computer code after it has been loaded to add or change debugging hooks or other features of the computer code.

Abstract: A runtime system implemented in accordance with the present invention provides an application platform for parallel-processing computer systems. Such a runtime system enables users to leverage the computational power of parallel-processing computer systems to accelerate/optimize numeric and array-intensive computations in their application programs. This enables greatly increased performance of high-performance computing (HPC) applications.

Abstract: A flexible, platform-independent integration infrastructure is provided. The integration infrastructure may include an integration bridge and at least one plug-in, where the at least one plug-in may include translation rules, mapping rules, and other information associated with a component coupled to the plug-in. The translation rules, mapping rules, and other information may be used by the integration bridge during a mapping process to control communication between components. Based on the rules and information, a mapping translator of the integration bridge converts data received from component into a form readable by another component.

Abstract: An example embodiment disclosed is a method for reducing parallelism of computer source code. The method includes receiving multi-threaded program source code and representing the multi-threaded program source code as a polyhedral framework stored in computer readable memory. The polyhedral framework is used to convert the polyhedral framework from the multi-threaded program source code representation to a single-threaded program source code representation.

Abstract: Computer method, apparatus and system chains model-to-model transformations. In a series of model transformations, there are respective bridges before and after each model transformation. For each pair of consecutive model transformations in the series, the respective bridge (i) receives a model output from a first model transformation of the pair, the received model being in the respective output model format of the first model transformation of the pair, (ii) prepares the received model as input to a second model transformation of the pair, including preparing the received model to be in the respective input model format of the second model transformation of the pair, and (iii) inputs the prepared model to the second model transformation of the pair. The series of model transformations and respective bridges provide chaining of the model-to-model transformations. Each model transformation in the series is able to be separately configured.

Abstract: A system includes a source database storing a targeted source code having references to hard-coded configuration information. A converter is in communication with the source database and is configured to replace the hard-coded configuration information in the targeted source code with soft-coded configuration information. A method includes searching the targeted source code for references related to hard-coded configuration information, receiving new reference names for the references, each of the new reference names corresponding to at least one of the references and being related to soft-coded configuration information, and replacing the references related to hard-coded configuration information with the corresponding new reference name to generate a targetless source code with the soft-coded configuration information.

Abstract: Synthesizing a message sequence chart (MSC) from a communicating finite-state machine (CFSM), by transforming the CFSM to a Petri net model, generating a labeled finite digraph with each path representing a linearization of an occurrence net segment of the Petri net, decomposing the diagraph into segments, and mapping where each segment to a compositional MSC.

Abstract: A system, method, and computer readable medium for integrating an original language application with a target language application comprises receiving properties related to a source file in the original language application, parsing the source file based on the received properties into a common format for the original language application and the target language application, receiving the parsed source file by a repository module, and placing contents of the received parsed source file on an interface.

Abstract: Provided is a method of symbol-based merging of computer programs. A source program file and a destination program file, wherein the source file is a later generated version of the destination program file, is parsed to identify symbols present in the source program file and the destination program file. A mapping of the symbols present in the source program file and the destination program file is generated. From the mapping, symbols that were modified, added or deleted in the source program file since it was generated from the destination program file are identified. The identified symbols are merged.

Abstract: The present invention extends to methods, systems, and computer program products for representing various programming elements with compiler-generated tasks. Embodiments of the invention enable access to the future state of a method through a handle to a single and composable task object. For example, an asynchronous method is rewritten to generate and return a handle to an instance of a builder object, which represents one or more future states of the asynchronous method. Information about operation of the asynchronous method is then passed through the handle. Accordingly, state of the asynchronous method is trackable prior to and after completing.