Inventors list

Assignees list

Classification tree browser

Top 100 Inventors

Top 100 Assignees


Translation of code

Subclass of:

717 - Data processing: software development, installation, and management

717100000 - SOFTWARE PROGRAM DEVELOPMENT TOOL (E.G., INTEGRATED CASE TOOL OR STAND-ALONE DEVELOPMENT TOOL)

Patent class list (only not empty are listed)

Deeper subclasses:

Class / Patent application numberDescriptionNumber of patent applications / Date published
717140000 Compiling code 844
717137000 Source-to-source programming language translation 50
717139000 Interpreter 48
717138000 Emulation 9
Entries
DocumentTitleDate
20090144707METHOD FOR CLIENT-SIDE AGGREGATION OF ASYNCHRONOUS, CONTEXT-SENSITIVE REQUEST OPERATIONS FOR JAVA SERVER PAGES (JSP) - A method, system, and computer program product for efficiently fulfilling java server page (JSP) requests for dynamic web content, in a computer network system. An asynchronous processing (AP) utility pre-defines a number of custom classes to enable the asynchronous processing of requests. A JSP which contains a custom “async:include” tag indicates an asynchronous request for dynamic content. When a set of asynchronous requests are received by an application server, an “AsyncRequestDispatcher” is called to handle the asynchronous processing of each associated request dispatcher include fragment. For each fragment, a separate request thread is initiated. A placeholder corresponding to each “async:include” request is written to a servlet response buffer. HyperText Markup Language (HTML) content, which includes the placeholders, and a number of javascripts are then written to the client browser. The original thread is closed. The Javascripts enable the retrieval of all response fragments which replace the corresponding placeholders.06-04-2009
20100077386SYSTEM AND A METHOD FOR CROSS-PLATFORM PORTING OF BUSINESS APPLICATIONS AND MAKING THEM CONTEXUALLY-AWARE ON TARGET PLATFORMS - A method for cross-platform porting of applications includes extracting one or more platform independent models from an existing one or more composite applications running on a given source platform. These platform independent models are then transformed into implementation artifacts on another, target platform, thereby effectively porting the composite application from one platform to another. The generated implementation artifacts on the target platform leverage existing assets in the target environment, which makes these generated artifacts “contextually-aware”.03-25-2010
20100115498ADAPTIVE PRODUCTION OF ASSEMBLER - A system for providing an assembler for a microprocessor has a file which contains data describing the instruction set of the microprocessor. A translation device for translating into machine language accesses the instruction set descriptors to constrain the machine code output of the assembler to conform to the architecture of the instruction set.05-06-2010
20100115497HANDLING SIGNALS AND EXCEPTIONS IN A DYNAMIC TRANSLATION ENVIRONMENT - A method for executing non-native binaries on a host computer architecture comprises receiving the guest executable binary into a computer readable medium. The guest executable binary is executed on the host computer architecture by translating the guest executable binary into a translated executable binary. Each instruction of the translated executed binary is then executed on the host computer architecture. Signals are responded to by placing signal information on a signal queue and deferring signal handling until a safe point is reached. A computer system implementing the method is also provided.05-06-2010
20100042979METHODS AND APPARATUS FOR DYNAMIC BEST FIT COMPILATION OF MIXED MODE INSTRUCTIONS - Methods and an apparatus for dynamic best fit compilation of mixed mode instructions are provided. In one embodiment, a provided method includes receiving a non-native software instruction at a device, generating a first native software instruction from a first instruction set based on the non-native software instruction, the generation of the first native software instruction occurring at the device, executing the first native software instruction at the device, generating a second native software instruction from a second instruction set based on the non-native software instruction, the generation of the second native software instruction occurring at the device, and executing the second native software instruction at the device.02-18-2010
20090271770METHOD, SYSTEM, AND COMPUTER PROGRAM PRODUCT FOR GENERATING UNIT TESTING SCRIPTS - A method, system, and computer program product are provided for generating unit testing scripts. The method includes receiving programming code having a condition expressed therein, and transforming the code by wrapping the condition into a mock function. The mock function receives a Boolean argument as an input and provides a Boolean value as an output irrespective of a pre-transformed input and a pre-transformed output of the condition. The Boolean value is capable of selectively being the Boolean argument received as the input or a different value specified by a user. The method further includes receiving a user input specifying a behavior relating to how a return value is generated for the mock function. The Boolean value is provided in accordance with the specified behavior. At least one pre-transformation output of the condition prior to the transforming step is direct-function independent.10-29-2009
20120117547EMBEDDING CLASS HIERARCHY INTO OBJECT MODELS FOR MULTIPLE CLASS INHERITANCE - A model is provided for transforming a program with a priori given class hierarchy that is induced by inheritance. An inheritance remover is configured to remove inheritance from a given program to produce an analysis-friendly program which does not include virtual-function pointer tables and runtime libraries associated with inheritance-related operations. The analysis-friendly program preserves the semantics of the given program with respect to a given class hierarchy. A clarifier is configured to identify implicit expressions and function calls and transform the given program into at least one intermediate program having explicit expressions and function calls.05-10-2012
20100299657AUTOMATIC PARALLELIZATION USING BINARY REWRITING - Binary rewriters that do not require relocation information and automatic parallelizers within binary rewriters are provided, as well as methods for performing binary rewriting and automatic parallelization. The method, in certain embodiments. includes disassembling a binary file and determining functions in the disassembled binary file. The method can further include rewriting the binary file without relying on relocation information or object files. Optionally, the method can further include performing automatic parallelization of the binary before rewriting the binary file.11-25-2010
20090254890APPARATUS AND METHOD FOR GENERATING INSTALL-LESS SOFTWARE FROM INSTALLATION PACKAGE OF SOFTWARE - Disclosed is a system and method for completely converting software into a form that can be used without an installation process by using an operating system and a converted software generating module which are disposed at a remote place. The software converting system for generating a converted software executable without being installed from an installation package of the target software includes: a clean operating system without software installation information for the target software; an installation module for installing the target software in the clean operating system by executing the installation package; a converted software generating module for generating the converted software for the target software by comparing the clean operating system before and after the installation of the target software; and a system communication module for receiving the installation package and transmitting the generated converted software to the user terminal.10-08-2009
20120272222Software Tool for Automation - A software tool for automation having a functionality for output conversion, where a plurality of applications, which are each intended for a dedicated object domain, are or can be combined with the software tool at the same time, each application comprises at least one first software interface for access to the output conversion, and where the output conversion comprises at least one mapping component for conversion of objects from an object domain of the application to an object of an abstract object model which is defined for the output component.10-25-2012
20090007080METHOD AND APPARATUS FOR DETERMINING AN ALTERNATIVE CHARACTER STRING - The present invention is directed to a method and apparatus for determining an alternative character string, in response to an invalid character string being received by a consumer application, wherein the invalid character string is derived from the selection of a series of keyboard keys in combination with a modifier key and wherein each key is associated with at least one glyph. An apparatus in accordance with an embodiment includes: a converter component for converting each glyph of the invalid character string into a first format; a converter component for parsing each of the converted first formats into a second format; an alternatives engine for determining from each of the second formats a third format which can be derived from a combination of a selection of the key and an alternative modifier key; and a converter component for converting each of the determined third formats into their associated glyphs for compiling into a list of alternative character strings.01-01-2009
20080295082PROGRAM RE-WRITING APPARATUS - A program re-writing method which re-writes an inputted program into a program for a processor for controlling whether or not a process is executed based on a yes or no execution flag, said program re-writing method including: inserting a comparison process into the inputted program, the comparison process comparing first address information, which is memory address information accessed by a first memory access process included in the inputted program, and second address information, which is address information of a memory accessed by a second memory access process included in the inputted program, and writing a comparison result into the yes or no execution flag; and inserting a yes or no execution flag-attached logic preservation process into the inputted program, the yes or no execution flag-attached logic preservation process being a process executed based on a value of the yes or no execution flag and preserving the same result as a result of the inputted program when executed.11-27-2008
20120089969DECLARATIVE PROGRAMMING MODEL WITH A NATIVE PROGRAMMING LANGUAGE - An execution environment in a computer system supports a declarative programming model where user code is written with a query syntax in a native programming language to express inherent parallelism in terms of data flow. The execution environment translates queries in the user code into a runtime agnostic representation and dynamically selects an execution runtime for executing the runtime agnostic representation.04-12-2012
20090094586METHOD AND APPARATUS FOR PERFORMING NATIVE BINDING - A native binding technique is provided for inserting calls to native functions during translation of subject code to target code, such that function calls in the subject program to subject code functions are replaced in target code with calls to native equivalents of the same functions. Parameters of native function calls are transformed from target code representations to be consistent with native code representations, native code calling conventions, and native function prototypes.04-09-2009
20100138814SYSTEM AND METHOD FOR MANAGING LONG NAMES IN AN APPLICATION PROGRAMMING INTERFACE - Software managing long names in an application programming interface receives a request to perform a requested operation on one or more fields, the application comprising a first operation operable to perform the requested operation on at least one field type. The software determines whether the field type of any of the fields is incompatible with the first operation. If the field types of the one or more fields are compatible with the first operation, then the software performs the requested operation on the one or more fields using the first operation. If the software determines that the field type of at least one of the fields is incompatible with the first operation, then it converts the request into a call for a second operation operable to perform the requested operation on the one or more fields and performs the requested operation using the second operation.06-03-2010
20090007081System and Method of Generating Applications for Mobile Devices - A system and method for transforming a reference application written for a reference mobile device into a target application for a target mobile device is disclosed. The system includes: a) transforms and metadata associated with each transform, where the transform includes instructions to modify a portion of the reference application and the metadata includes at least one of device-specific information and application-specific information; b) a plug-in containing links to a selected portion of the transforms, where the selected portion of the transforms is selected using the metadata; and c) a transformation engine which communicates with the with the plug-in to execute the instructions in each of the transforms in the selected portion.01-01-2009
20110219362Virtual Execution Environment for Streaming Languages - A virtual execution environment (VEE) for a streaming Intermediate Language (IL), wherein the streaming IL represents a streaming program, communicates streaming data in queues, stores data-at-rest in variables, and determines data by functions, where inputs are read from the queues and the variables, and outputs are written to the queues and the variables.09-08-2011
20110219361CORRECT REFACTORING OF CONCURRENT SOFTWARE - Automated refactorings as implemented in modern IDEs for Java usually make no special provisions for concurrent code. Thus, refactored programs may exhibit unexpected new concurrent behaviors. We analyze the types of such behavioral changes caused by current refactoring engines and develop techniques to make them behavior-preserving, ranging from simple techniques to deal with concurrency-related language constructs to a framework that computes and tracks synchronization dependencies. By basing our development directly on the Java Memory Model we can state and prove precise correctness results about refactoring concurrent programs. We show that a broad range of refactorings are not influenced by concurrency at all, whereas other important refactorings can be made behavior-preserving for correctly synchronized programs by using our framework. Experience with a prototype implementation shows that our techniques are easy to implement and require only minimal changes to existing refactoring engines.09-08-2011
20100169868Unifying Type Checking and Property Checking for Low Level Programs - This document describes a unified type checker and property checker for a low level program's heap and its types. The type checker can use the full power of the property checker to express and verify subtle, program specific type and memory safety invariants well beyond what the native low level program system can check. Meanwhile, the property checker can rely on the type checker to provide structure and disambiguation for the program's heap, enabling more concise and more powerful type-based specifications. This approach makes use of a fully automated Satisfiability Modulo Theories (SMT) solver and a decision procedure for checking type safety, which means that the programmer's only duty is to provide high-level type and property annotations as part of the original program's source.07-01-2010
20100083238Binary manipulation of intermediate-language code - One or more embodiments, described herein, are directed towards a technology for performing transformations and/or modifications to managed byte code. In order to perform the transformations and/or modifications, a mutable programmable representation (MPR) is laid out. A programmer then performs an arbitrary adjustment using the MPR.04-01-2010
20080276229INCREMENTAL MODEL REFINEMENT AND TRANSFORMATION IN GENERATING COMMERCE APPLICATIONS USING A MODEL DRIVEN ARCHITECTURE - In one embodiment of the invention, a method for profile mapped model transformation for model driven architecture (MDA) development of service provisioning applications can be provided. Them method can include mapping elements of a platform independent domain specific model to a platform specific domain specific model for a target platform with stereotypes in a uniform modeling language (UML) profile defined for the target platform. The method further can include transforming a platform independent domain specific model into a platform specific domain specific model for a target platform by applying the stereotypes of the UML profile defined for the target platform. Finally, the method can include generating shell source code for the transformed platform specific domain specific model.11-06-2008
20080288928Methods and Systems for Converting Application Code in Turbine Control Systems - Embodiments of the invention are generally directed to systems and methods for converting application code in a turbine control system. According to one embodiment of the invention, a method for converting a turbine control system may be provided for. The method may include providing a first application code format including one or more elements, providing a second application code format including one or more elements, and identifying mappings of the one or more first application code format elements to the one or more second application code format elements. The method may further include retrieving a first control system application code written in the first application code format, and generating application data from the first control system application code based at least in part on the identified mappings. Additionally, the method may include converting the application data to a second control system application code written in the second application code format.11-20-2008
20080222615Processing application data - Electronic devices and methods of processing and preparing processing application data are disclosed. Application data are operated on a first electronic device (09-11-2008
20090187895DEVICE, METHOD, PROGRAM, AND RECORDING MEDIUM FOR CONVERTING PROGRAM - Provided is a program converting device that facilitates processing of assigning each of process units to be executed in parallel, with information (a relative priority, for example) that directs an OS or a scheduler regarding processing performance to be allocated to all or a part of the process units. The program converting device of the present invention includes: a requirement information receiving unit that receives requirement information that indicates required performance required on all or a part of an object program; a dividing unit that calculates a processing amount of each of at least one of process units executable in parallel and then divides at least a part of an input program into the process units to satisfy the required performance; and a direction information generation unit that generates an direction information file that directs, to a processor, regarding processing performance to be allocated to at least one of the divided process units.07-23-2009
20090199164Interoperability method and software - Interoperability software modules comprise an architected .NET layer, an architected interpreter, an automatic interpreter and a library of COM objects. The architected interpreter where they are mapped to intermediate .NET interfaces compatible with the automatic interpreter by means of a Runtime Callable Wrapper (RCW). The architected interpreter also comprises an architected COM Callable Wrapper (CCW) that maps the intermediate COM interfaces into architected interfaces.08-06-2009
20090199166PROGRAM CONVERTING DEVICE - In a program converting device, an initial-value-of-variable recognizing unit recognizes variables and initial values of the variables included in a source program. A place-of-variable determining unit, when the recognized variables are variables having a large number of specific values of the initial values, determines that the variables are to be placed in specific value areas that are each initialized with the specific value before execution of a program. An specific-value-area variable placing unit places variables having a large number of specific values of the initial values in the specific value area, and further, when the initial values of the variables include a value other than the specific value, generates an initialization code for the value other than the specific value.08-06-2009
20090199165METHODS, SYSTEMS, AND COMPUTER PROGRAM PRODUCTS FOR INTERNATIONALIZING USER INTERFACE CONTROL LAYOUTS - Methods, systems, and computer program products internationalize a user interface (UI) control layout for an application by extracting a translatable text resource comprising a pattern of a message for performing the control layout from a source code of the application. Language information is received that is indicative of one or more languages for the UI control layout. Based upon the received language information, the pattern is constructed and dynamically laid out at run time for graphical presentation to one or more users. The graphical presentation is used to implement the UI control layout in accordance with the one or more languages.08-06-2009
20090055807FAST IMAGE LOADING MECHANISM IN CELL SPU - The present invention provides a method and system for loading and running program images rapidly in a multi-processor system. The method comprises the steps of: starting in a synergistic processor a synergistic processing program listener, which is configured to listen to a notification from a main processor; calling in the main processor a run-synergistic-processing-program function which is configured to notify the synergistic processing program listener to run a synergistic processing program image which is part of the program image and has been transferred to the local store of the synergistic processor; and the synergistic processing program listener running the synergistic processing program image in response to receiving the notification.02-26-2009
20090249310AUTOMATIC CODE TRANSFORMATION WITH STATE TRANSFORMER MONADS - Stateful computations are transformed into stateless computations automatically to facilitate scalability. Programmers can write code in a traditional imperative stateful style, which is subsequently transformed automatically into a stateless, state transformer monadic style. After the transformation, state is passed as an additional argument in a call and returns as a new state as an additional result.10-01-2009
20080313619Method and apparatus for a configurable java server pages processing framework - A method, apparatus, and computer instructions for a configurable JAVASERVER pages processing framework to process JAVASERVER pages (JSP). A JSP document or page is translated into a document object model (DOM) object that encapsulates elements of the JSP. The syntax of the JSP is validated by a JSP translator with built-in classes and errors are returned if necessary. A JSP visitor configuration file, which defines user configured classes and sequence of execution, is used by the JSP translator to invoke methods of user-defined classes in the order specified by the user to process or visit elements of the DOM object. Result of user-defined class processing may be passed from one class to another within the set.12-18-2008
20090259996PARTITIONING CUDA CODE FOR EXECUTION BY A GENERAL PURPOSE PROCESSOR - One embodiment of the present invention sets forth a technique for translating application programs written using a parallel programming model for execution on multi-core graphics processing unit (GPU) for execution by general purpose central processing unit (CPU). Portions of the application program that rely on specific features of the multi-core GPU are converted by a translator for execution by a general purpose CPU. The application program is partitioned into regions of synchronization independent instructions. The instructions are classified as convergent or divergent and divergent memory references that are shared between regions are replicated. Thread loops are inserted to ensure correct sharing of memory between various threads during execution by the general purpose CPU.10-15-2009
20090293046Notification-based constraint set translation to imperative execution - A method is provided for translating sets of constraint declarations to imperative code sequences based on defining an instantiatable object per set, inserting calls to a notification callback mechanism on state modification and defining calls in the constraint context as imperative code sequences that, in response to these callbacks, take actions to maintain these constraints.11-26-2009
20100229160CONVERTING PROGRAM CODE OF A MULTI-THREADED PROGRAM INTO PROGRAM CODE CAUSING LESS LOCK CONTENTIONS - A method, computer system, and computer readable article of manufacture for converting a first program code in a multi-threaded program into a second program code which causes less lock contention. A processing unit determines whether the first program code includes either a first class having a method call to a third class that operates while taking synchronization by locking, or a second class inheriting a parent class that operates while taking synchronization by locking. If the first class, then it is converted into a class with a method call to a concurrent operation executable class that is functionally equivalent and a shorter lock holding section. If the second class, then it is converted into a class with a method call to a concurrent operation executable class that is functionally equivalent to that of the parent class, and a shorter lock holding section.09-09-2010
20090077543AUTOMATIC DERIVATIVE METHOD FOR A COMPUTER PROGRAMMING LANGUAGE - The disclosed system provides a transformation-based implementation of forward-mode and reverse-mode automatic differentiation as a built-in, first-class function in a functional programming language. Each of these constructs imposes only a small constant factor of the computational burden (time) of the function itself, and the forward construct has the same properties in terms of space. The functions can be applied to any function, including those involving derivatives and nested closures.03-19-2009
20120036502CONSISTENCY CHECKING FOR TRANSLATED INTRUCTIONS - In one embodiment, after translating a plurality of target instructions from a target memory location into a plurality of host instructions, a write operation to a target memory portion which includes said target memory location is detected. In response to the detecting, a copy of the target instructions is stored in a host memory. In response to an attempt to execute the host instructions, the copy is compared with a plurality of current target instructions presently stored in the target memory location. Further, in response to a mismatch based on the comparison, the host instructions are disabled.02-09-2012
20100211936METHODS AND APPARATUS FOR INTEGRATING ENGINEERING MODELS FROM DISPARATE TOOLS IN SUPPORT OF MODEL RESUE - A computer system having stored in memory a set of executable software tools that include both producer tools and consumer tools, wherein one or more of the tools may be both a producer tool and a consumer tool, a model repository, and a set of software engines that include hybrid models each bridging semantics of a corresponding producer tool or a corresponding consumer tool that is importing or exporting to or from a neutral model representation of the information, wherein instantiations of the neutral models reside in the model repository.08-19-2010
20090259997VARIANCE ANALYSIS FOR TRANSLATING CUDA CODE FOR EXECUTION BY A GENERAL PURPOSE PROCESSOR - One embodiment of the present invention sets forth a technique for translating application programs written using a parallel programming model for execution on multi-core graphics processing unit (GPU) for execution by general purpose central processing unit (CPU). Portions of the application program that rely on specific features of the multi-core GPU are converted by a translator for execution by a general purpose CPU. The application program is partitioned into regions of synchronization independent instructions. The instructions are classified as convergent or divergent and divergent memory references that are shared between regions are replicated. Thread loops are inserted to ensure correct sharing of memory between various threads during execution by the general purpose CPU.10-15-2009
20090282394PRODUCT LOCALIZATION DEVICE AND METHOD - A system and method for localization facilitates checking resource files in a first format out of a source code management system. Prior stored translated strings are leveraged to produce a partially translated translation memory corresponding to the resource files. Translations of strings are obtained to complete translation of the partially translated translation memory. Translated strings are stored in a database, and the translated resource files in the first format are checked back into the source code management system.11-12-2009
20090113401USING ANNOTATIONS TO REUSE VARIABLE DECLARATIONS TO GENERATE DIFFERENT SERVICE FUNCTIONS - Provided are a method, system, and article of manufacture for using annotations to reuse variable declarations to generate different service functions. A declaration file has variable declarations in a first programming language environment for use by application functions. The declaration file includes a plurality of sets of annotations for a plurality of service functions. Each of the sets of annotations identifies variables in the declaration file to use with one of the service functions. The declaration file is processed to generate one of the service functions. The set of annotations in the declaration file for the service function to generate is determined. The determined set of annotations is processed to determine variables to include with the service function to generate. The determined variables from the declaration file are used to generate the service function.04-30-2009
20090106743METHODS AND SYSTEMS FOR CONVERTING AUTOMATION SOFTWARE - A method for converting a software environment defined using flat name space into an equipment model is provided. The method includes decomposing the flat name space into a plurality of tokens, and assigning each token to a corresponding level of a plurality of levels included in an equipment hierarchy. The method also includes translating each token into a human-readable name, and creating an equipment model based on the human-readable name and the corresponding level assigned to each token.04-23-2009
20100306746BINARY REWRITING WITHOUT RELOCATION INFORMATION - A binary rewriter that can provide complete code coverage without relocation information is provided, together with a method of performing such rewriting. The method can include processing a binary file as an original binary file. The method can also include disassembling the binary file to provide a disassembled binary file. The method can further include rewriting the disassembled binary file without relocation information to provide a rewritten binary file. The rewriting can provide a physical transformation in a recording medium relative to the binary file in the recording medium prior to the rewriting. The processing the binary file, disassembling the binary file, and rewriting the disassembled binary file can be performed by a particular machine.12-02-2010
20100333074Automatic conversion of MPI source code programs into MPI thread-based programs - A method, system, and computer program product containing instructions for automatically converting an MPI source code program into an MPI thread-based program. In response to inputs in the form of an MPI source code program and a command, a converter declares a global variable of the MPI source code program as a thread private variable to create a first private variable for a first thread and a second private variable for a second thread. A library is identified to support converting processes to threads during execution of the MPI thread-based program, and the identified library is used to build an executable version of the MPI thread-based program. The identified library may include code to identify instantiation of a new process when the MPI thread-based program is executing, and in response, to cause a corresponding thread for the MPI thread-based program to be instantiated.12-30-2010
20110113408PARTIAL ON-DEMAND LAZY SEMANTIC ANALYSIS - Computing responses to semantic queries. A method includes accessing a plurality of objects that represent source code for an input program. The source code is transformed into a plurality of immutable objects that are structured such that the immutable objects can be used to derive any response as defined by the semantic rules about the source code. A query is received from a requestor requesting a semantic characteristic of the input program. The semantic characteristic is calculated. The semantic characteristic is returned to the requestor. The semantic characteristic is cached in a cache. Information describing a dependency between the cached semantic characteristic and one or more of the objects in the plurality of objects is stored.05-12-2011
20110126177METHOD, SYSTEM AND COMPUTER PROGRAM FOR BYTECODE WEAVING - A method, computer apparatus and computer program product for bytecode weaving is described herein. The method includes determining when a code module such as an OSGi bundle that requires bytecode weaving becomes available for loading into a system. Code associated with the code module is loaded. This code may be part of the module itself or part of a separate entity, such as an OSGI bundle fragment, but does not require weaving. Responsive to loading the code associated with the code module, a reference is received to the entity responsible for loading the code associated with the code module. A code entity (which does require weaving) within the code module is identified and a woven set of bytes are provided to the code loading entity identified via the returned reference. Consequently, the woven set of bytes represents a transformed version of the identified code entity.05-26-2011
20100251223SYSTEM AND METHOD FOR THE DISTRIBUTION OF A PROGRAM AMONG COOPERATING PROCESSING ELEMENTS - A Veil program analyzes the source code and/or data of an existing sequential target program without user interaction and determines how best to distribute the target program and data among the processing elements of a multi-processing element computing system. The Veil program analyzes source code loops, data sizes and types to prepare a set of distribution attempts or strategies, whereby each strategy is run under a run-time evaluation system and evaluated to determine the optimal decomposition and distribution across the available processing elements.09-30-2010
20090313612METHOD AND APPARATUS FOR ENREGISTERING MEMORY LOCATIONS - One embodiment of the present invention provides a system that improves program performance by enregistering memory locations. During operation, the system receives program object code which has been generated for a given hardware implementation, and hence is optimized to use a specified number of registers that are available in that hardware implementation. Next, the system translates this object code to execute on a second hardware implementation which includes more registers than the first hardware implementation. The system makes use of these additional registers to improve the performance of the translated object code for the second hardware implementation. More specifically, the system identifies a memory access in the object code, where the memory access is associated with a memory location. The system then rewrites an instruction associated with this memory access to access the available register instead of the memory location. To preserve program semantics, the system subsequently moderates accesses to the memory location to ensure that no threads access a stale value in the enregistered memory location.12-17-2009
20090217250GRAPHICAL USER INTERFACE METADATA EVOLUTION TOOL - A metadata migration tool helps GUI application developers keep track of institutional knowledge that may be lost between application versions. The maintenance and transference of this knowledge from one application version to another aids developers in conforming future applications to restrictions and requirements imposed on previous versions that may not be immediately apparent. The architecture and processes facilitate the migration of this institutional knowledge, thus greatly reducing the time, cost, and resource expenditures spent re-creating similar components in an updated application and updated scripts to test those application components.08-27-2009
20100070951GENERIC ASSEMBLER - The present invention relates to a method for realizing a generic assembler capable of translating a source code into machine codes for various processor-architectures comprising the steps of: (a) providing an assembler capable of reading a definitions file for translating source code commands into machine code commands; (b) loading said definitions file, which holds definitions related to a processor-architecture, into said assembler; (c) parsing and assessing, by said assembler, said definitions file for finding errors; (d) preparing the internal data structures of said assembler based on said definitions of said definitions file; and (e) translating a source code into a machine code, by said assembler, using said definitions from said definitions file.03-18-2010
20120204157Quicker Translation of a Computer Program Source Code - 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.08-09-2012
20120204158CONVERTER, SERVER SYSTEM, CONVERSION METHOD AND PROGRAM - A converter for converting an application program that is executed for every job request into a batch processing program for collectively processing a plurality of job requests. The converter includes: a code identifier for identifying a portion of the application program that includes a service request to another server, and a portion that does not include a service request; an integration unit for converting the service request into a collective service request that collectively issues a plurality of service requests corresponding to the plurality of job requests; a multiplexing unit for converting the processing code in the application program into a multiplexed code for executing multiple processings corresponding to the plurality of job requests; and an output unit for outputting, as the batch processing program, the application program that the integration unit and the multiplexing unit have processed.08-09-2012
20080320452Software diversity using context-free grammar transformations - A method may include mapping a first program to a context-free grammar. Grammar transformations may be performed on the context-free grammar to produce a transformed context-free grammar representing the first program. A second program having a program structure different than a program structure of the first program may be constructed from the transformed context-free grammar.12-25-2008
20090125892Computer Software Development System and Method - A method of implementing a software system on a target-platform is disclosed. The method includes preparing a specification document including statements that collectively specify requirements of the software system. The requirement statements are expressed with language elements of a specification language, and the specification document has an associated source file. In an embodiment, the source file is provided to a driver-code generator which translates the source file into a driver-code file readable by a run-time engine resident on the target-platform to provide, on execution of the driver-code file by the run-time engine, a software system compliant with the specified requirements.05-14-2009
20120311546TRANSFORMING DYNAMIC SOURCE CODE BASED ON SEMANTIC ANALYSIS - Transforming dynamic code. The method includes obtaining one or more first data structures defining constructs in a body of dynamic language source code. From the one or more first data structures, identifier information is extracted for one or more of the defined constructs. Knowledge about the constructs is augmented. Using the identifier information and augmented knowledge, metadata is generated about the body of the dynamic language source code. The generated metadata is represented as a symbol table. Using the symbol table, the body of dynamic language source code is transformed.12-06-2012
20110131555EXTERNAL PROGRAMMATIC INTERFACE FOR IOS CLI COMPLIANT ROUTERS - A method of receiving and translating data within an external programmatic interface (EPI) is described. The method calls for receiving input into the EPI. The input is traversed. Where the input is presented in a prescribed format other than CLI, it is translated into a corresponding CLI statement, with reference to a representation of the CLI syntax. Where the input is presented in CLI, it is translated into a corresponding prescribed output format, with reference to a model of the prescribed output format derived from the CLI syntax. The translated input is output.06-02-2011
20130198726MAPPING AND FORMATTING INPUT COMMANDS TO A THIRD PARTY PROTOCOL - A method and apparatus of translating and mapping received commands between operating system languages and/or protocol-based languages. One example method may provide receiving an action initiated by an external source, such as a person or automated action selection operation. The method may also include identifying the action as a predetermined command of a first computer operating language stored in a memory and mapping the predetermined command to a corresponding protocol command of a different computer operating language, and executing the corresponding protocol command after the mapping operation.08-01-2013
20110138370Typed-Data Translation for Platform Independence - A method, computer program and device for the translation of typed data objects in a heterogeneous computational environment is described. The operating system (or installed shared code libraries) translates typed data objects from a first format (e.g., big-endian) to a second format (e.g., little-endian) if the application sending the object and the application receiving the object utilize different formats. By placing data object format translation capabilities into the operating system, the software development effort required to permit an application (e.g., a user-level application) to execute in a heterogeneous environment is significantly reduced.06-09-2011
20090293045Dynamic collection attribute-based computer programming language methods - Simplified handling of dynamic collections having a variable number of elements at run time is achieved by providing for specification of collective properties of dynamic collections by a programmer. Such collective properties are distinct from type-member properties of the collection that follow from the types and type qualifiers of its members. Preferably, such dynamic collections are attributes (i.e., members) of an application defined type.11-26-2009
20090204953Transforming data structures between different programming languages - Transforming data structures between different programming languages is disclosed. In some embodiments, a transformation module is configured to transform objects between a first programming language and a second programming language. In some embodiments, an object defined in a first programming language is received, and data comprising the object defined in the first programming language is copied and used to create a corresponding object defined in a second programming language.08-13-2009
20100017790CODE ASSIST FOR MULTIPLE STATEMENT PATTERNS INCLUDING AUTOMATED TRANSLATION OF CODE EXAMPLES TO A USER CONTEXT - A process and system for assisting a user to write new lines of code of a computer program based on code examples. A first line in each code sample matching a specified anchor line. A loop having a custom line branch and a code assist branch is executed. The custom line branch generates a new line for the computer program via a custom line provided by the user. The code assist branch generates a new line for the computer program via code assist. The code assist determines a set of assist lines from the code samples, translates the assist lines to a user context in each code example, selects from the assist lines set of preferred lines sequenced in an order of preference, presents the set of preferred lines to the user, receives a preferred line selected by the user, and stores the preferred line as a new line.01-21-2010
20120042304PROGRAM CONVERSION APPARATUS AND COMPUTER READABLE MEDIUM - According to one embodiment, as to a first program code including a plurality of variables, an access pattern of each variable by a processor is decided. The first program code is converted to a second program code including a plurality of threads. Each thread is executed by one of a plurality of cores of the processor. The second program code includes, (a) a first member structure including variables decided as a first access pattern, (b) a first route-pointer indicating the first member structure, the first route-pointer having a first access property representing accessibility by a core to execute a first thread, (c) a second member structure including variables decided as a second access pattern, (d) a second route-pointer indicating the second member structure, the second route-pointer having a second access property representing accessibility by the core to execute the first thread and a core to execute a second thread.02-16-2012
20120159458RECONSTRUCTING PROGRAM CONTROL FLOW - The present invention extends to methods, systems, and computer program products for reconstructing program control flow. Embodiments include implementing or morphing a control flow graph (“CFG”) into an arbitrary loop structure to reconstruct (preserve) control flow from original source code. Loop structures can be optimized and can adhere to target platform constraints. In some embodiments, C++ source code (a first higher level format) is translated into a CFG (a lower level format). The CFG is then translated into HLSL source code (a second different higher level format) for subsequent compilation into SLSL bytecode (that can then be executed at a Graphical Processing Unit (“GPU”)). The control flow from the C++ source code is preserved in the HLSL source code.06-21-2012
20110078668SYSTEMS AND METHODS FOR PROVIDING AN EMBEDDED SERVICE-ORIENTED USER INTERFACE INTEGRATION BUS - Embodiments of the invention can provide systems and methods for providing an embedded service-oriented user interface integration bus. According to one embodiment, a system can be provided having a memory for storing computer executable instructions and a processor in communication with the memory via a computer interface. The processor can be adapted to execute computer executable instructions for receiving a user interface service request from an application module associated with a first platform. The processor can also be adapted to transform the user interface service request from the application module to a user interface service request for a host platform. The processor can also be adapted to match the transformed user interface service request to a platform service on the host platform and to transform the platform service for the host platform into a platform service for the client.03-31-2011
20120254842SYSTEM AND METHOD FOR THE STRUCTURING AND INTERPRETATION OF ORGANIC COMPUTER PROGRAMS - In various aspects, a system and method for structuring and interpreting organic computer programs may provide for programs to expand, grow and evolve analogous to the way plants, animals, and organisms in nature grow and evolve. The organic computing system and method may unify program design time and program run time, may provide for program structure and program state to change at run time, and may provide for programs to continuously change and evolve through the addition of member functions, inputs, and outputs as the program is running. The organic computing system provides continuous means of differentiation, creating asymmetries and the opportunity for competition, and integration, creating symmetries and the opportunity for cooperation. Together, these factors provide a programming system wherein normalization occurs over time through the exchange and integration of differences and evolution and diversification through the creation of new differences, thereby introducing a differential form of computer science.10-04-2012
20120079462SYSTEMS AND METHODS OF SOURCE SOFTWARE CODE OBFUSCATION - One or more selected portions of computer-executable instructions stored on non-transient storage media of a computer system are modified according to a method. In various embodiments, the method includes any one or combination of: (1) applying, with a processor of the computer system, a data transformation to one or more value representations in the computer-executable instructions to create one or more transformed code segments, the data transformation comprising at least one of a nonlinear transformation and a function composition transformation; (2) generating, with a processor of the computer system, transformed computer-executable instructions based on the transformed code segments; and (3) storing the one or more transformed code segments with corresponding computer-executable instructions on the non-transient storage media.03-29-2012
20120079461EXTENSIBLE DEVICE OBJECT MODEL - Systems and/or methods are provided relating to an extensible framework. The extensible framework provides constructs with which device developers can model devices within the framework to enable a host application utilizing the framework to interact with the devices. New devices can be supported by the framework without disrupting existing devices or the host application.03-29-2012
20110099541Context-Sensitive Slicing For Dynamically Parallelizing Binary Programs - In one embodiment of the invention a method comprising (1) receiving an unstructured binary code region that is single-threaded; (2) determining a slice criterion for the region; (3) determining a call edge, a return edge, and a fallthrough pseudo-edge for the region based on analysis of the region at a binary level; and (4) determining a context-sensitive slice based on the call edge, the return edge, the fallthrough pseudo-edge, and the slice criterion. Embodiments of the invention may include a program analysis technique that can be used to provide context-sensitive slicing of binary programs for slicing hot regions identified at runtime, with few underlying assumptions about the program from which the binary is derived. Also, in an embodiment a slicing method may include determining a context-insensitive slice, when a time limit is met, by determining the context-insensitive slice while treating call edges as a normal control flow edges.04-28-2011
20100175054SYSTEM AND METHOD FOR TRANSFORMING A UML MODEL INTO AN OWL REPRESENTATION - A system and method for transforming a human-readable Unified Mark-Up Language (UML) model having a plurality of packages for design purposes into a machine-readable Web Ontology Language (OWL) representation having a plurality of OWL namespaces or a plurality of OWL documents for controlling network elements in a telecommunications network. A processor translates the human-readable UML model into one or more machine-readable OWL ontologies. In one embodiment, the processor produces one ontology (one file) with several namespaces. Thus, the translated ontology corresponds to the UML model, and each UML package in the UML model corresponds to a namespace. In another embodiment, the processor produces several ontologies (several files) corresponding to the UML packages in the UML model, wherein each ontology has just one namespace for its elements. The UML model in this embodiment corresponds to a base ontology importing all created ontologies.07-08-2010
20120174080OBJECT LEVEL COMPATIBILITY AND CLASS RESIZING UTILIZING SEMANTIC VALUES - A method of converting software code to an object on a computing device may include receiving the software code at the computing device and translating at the computing device the software code to an object file. Translating the software to the object file may include determining that the software code includes an item of interest that requires a value being coded into the object. The method may also include creating a variable to represent the coded value and storing the variable, which is linked to the coded value, in a table of variables associated with the object file.07-05-2012
20130174129Model Matching for Trace Link Generation - Implementations of the present disclosure include methods, systems, and computer-readable storage mediums for identifying matching elements between a source model and a target model comprising receiving a source model and a target model, the source model and the target model each being stored in computer-readable memory; processing the source model and the target model to generate a plurality of similarity values, each similarity value being associated with an element of the source model and an element of the target model; generating a similarity value construct based on the plurality of similarity values and elements of the source model and the target model; and identifying matching elements between the source model and the target model based on the similarity value construct.07-04-2013
20120089968RUNTIME AGNOSTIC REPRESENTATION OF USER CODE FOR EXECUTION WITH SELECTED EXECUTION RUNTIME - An execution environment in a computer system allows user code to be executed using multiple execution runtimes. The execution environment translates the user code into a runtime agnostic representation, selects an execution runtime for executing the runtime agnostic representation, and invokes a scheduler for the selected execution runtime. The scheduler dispatches tasks from the runtime agnostic representation for execution by the computer system using concurrency mechanisms in the selected execution runtime.04-12-2012
20120089967DYNAMIC DATA AND COMPUTE RESOURCE ELASTICITY - An execution environment in a computer system provides dynamic data and compute resources elasticity for user code to improve execution efficiency. The execution environment translates the user code into a runtime agnostic representation with a set of tasks. For each task, the execution environment determines a level of concurrency for executing the task based on the size of the set of input data for the task, the amount of compute resources available at the time of invocation of the task, and any context-sensitive heuristics provided by the user code.04-12-2012
20100131932DEVICE, METHOD, AND PROGRAM FOR GENERATING AND EXECUTING EXECUTION BINARY IMAGE, AND COMPUTER-READABLE RECORDING MEDIUM CONTAINING THE EXECUTION BINARY IMAGE EXECUTION PROGRAM - It is possible to reduce a data amount of an execution binary image. An execution binary reading section (05-27-2010
20080235670Method and Apparatus for Creation of an Interface for Constructing Conversational Policies - A method and apparatus for taking a visual or verbal representation of a conversational policy and translating the representation into an XML file. The XML file can then be output in one or more formats, such as code used in a policy, a Word version of the XML file, or a visual representation of the XML file.09-25-2008
20080229289Bitmapped Data String Conversions - A method for converting bitmapped messages in one codeset into a message of another codesets is disclosed. In one step a bitmapped message is parsed into a bitmapped field and a data field. The binary representation of the bitmapped field is used to determine which data elements are present within the data field and the length of the data elements. The data elements may then be converted into a new codeset.09-18-2008
20130174130METHOD AND SYSTEM FOR EXECUTING A 3GL PROGRAM AND/OR AN ASSEMBLER PROGRAM WITHIN A 4GL RUNTIME ENVIRONMENT - The present invention relates the transformation of a 3GL and/or an Assembler program (07-04-2013
20130179869Adaptive Diversity for Compressible Return Oriented Programs - A method of transforming return oriented programming executables into functionally equivalent yet different forms with specific structural and/or functional characteristics that can assist in the use of such executables. A method automatically biases the structural and/or functional diversity of the return oriented programming software executables to achieve specific program representation objectives while preserving the programmatic capabilities of the original executable.07-11-2013
20080263526MULTILINGUAL SOFTWARE TESTING TOOL - A software product testing system may include a knowledge base with a data set that includes multiple possible actions and, for each action, language-specific format rules for inputs and outputs associated with the action. The software product testing system may include a test case generator that selects a test case in a target language for a software product. The test case may include a selected action to be taken by a software product, an input to prompt the action, and an expected output that corresponds to the selected action and the input. The expected output has a format corresponding to a language-specific format rule of the target language. The software product testing system may also include a test verifier that determines whether an output generated by application of the test case to the software product matches the expected output.10-23-2008
20080201695COMPUTER GRAPHICS RENDERING - Techniques for rendering computer graphics are described. The techniques include binarization of graphics files generated using a vector graphics language (e.g., Scalable Vector Graphics (SVG)). In exemplary applications, the method is used for rendering video information in cellular phones, video game consoles, personal digital assistants (PDA), or laptop computers, among other video-enabled or audio/video-enabled wireless or wired devices.08-21-2008
20130125097Method and system for converting a single-threaded software program into an application-specific supercomputer - The invention comprises (i) a compilation method for automatically converting a single-threaded software program into an application-specific supercomputer, and (ii) the supercomputer system structure generated as a result of applying this method. The compilation method comprises: (a) Converting an arbitrary code fragment from the application into customized hardware whose execution is functionally equivalent to the software execution of the code fragment; and (b) Generating interfaces on the hardware and software parts of the application, which (i) Perform a software-to-hardware program state transfer at the entries of the code fragment; (ii) Perform a hardware-to-software program state transfer at the exits of the code fragment; and (iii) Maintain memory coherence between the software and hardware memories. If the resulting hardware design is large, it is divided into partitions such that each partition can fit into a single chip. Then, a single union chip is created which can realize any of the partitions.05-16-2013
20110314456System and Method for Mapping Structured Document to Structured Data of Program Language and Program for Executing Its Method - The data transcription processing unit is prepared. This unit is beforehand provided with the document-structure definition information on the structured documents, i.e., the processing target, the structure definition information on the program language, and the correspondence information between the document-structure definition and the structure definition. Then, a reading/writing request is issued from the application program to the data transcription processing unit. The issue of the request accomplishes the data transcription on each element basis between the structured documents and the structure of the program language.12-22-2011
20080235669Method, system, and program product for accessing required software to process a file - A system, method, and program product for accessing or retrieving on a computer network the required software to process a file is disclosed. According to the invention, it is determined, when accessing a file, whether or not software required to process this file is already installed on the user's computing device, depending upon the type of the file. If the required software is not installed on the user's device, the address of a server from which this software can be downloaded or accessed through the network is extracted and decoded from the filename of the accessed file. A browser or file transfer program is launched on the user's computing device and a request for the required software package is sent from the user's computing device to the server corresponding to the decoded address from which it is downloaded or accessed. The software is then unpacked, if necessary, and installed so as to process the accessed file.09-25-2008

Patent applications in class Translation of code

Patent applications in all subclasses Translation of code