Entries |
Document | Title | Date |
20080201695 | COMPUTER 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 |
20080222615 | Processing 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 |
20080229289 | Bitmapped 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 |
20080235669 | Method, 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 |
20080235670 | Method 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 |
20080263526 | MULTILINGUAL 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 |
20080276229 | INCREMENTAL 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 |
20080288928 | Methods 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 |
20080295082 | PROGRAM 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 |
20080313619 | Method 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 |
20080320452 | Software 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 |
20090007080 | METHOD 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 |
20090007081 | System 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 |
20090055807 | FAST 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 |
20090077543 | AUTOMATIC 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 |
20090094586 | METHOD 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 |
20090106743 | METHODS 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 |
20090113401 | USING 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 |
20090125892 | Computer 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 |
20090144707 | METHOD 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 |
20090187895 | DEVICE, 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 |
20090199164 | Interoperability 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 |
20090199165 | METHODS, 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 |
20090199166 | PROGRAM 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 |
20090204953 | Transforming 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 |
20090217250 | GRAPHICAL 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 |
20090249310 | AUTOMATIC 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 |
20090254890 | APPARATUS 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 |
20090259996 | PARTITIONING 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 |
20090259997 | VARIANCE 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 |
20090271770 | METHOD, 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 |
20090282394 | PRODUCT 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 |
20090293045 | Dynamic 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 |
20090293046 | Notification-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 |
20090313612 | METHOD 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 |
20100017790 | CODE 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 |
20100042979 | METHODS 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 |
20100070951 | GENERIC 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 |
20100077386 | SYSTEM 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 |
20100083238 | Binary 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 |
20100115497 | HANDLING 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 |
20100115498 | ADAPTIVE 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 |
20100131932 | DEVICE, 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 |
20100138814 | SYSTEM 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 |
20100169868 | Unifying 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 |
20100175054 | SYSTEM 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 |
20100211936 | METHODS 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 |
20100229160 | CONVERTING 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 |
20100251223 | SYSTEM 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 |
20100299657 | AUTOMATIC 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 |
20100306746 | BINARY 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 |
20100333074 | Automatic 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 |
20110078668 | SYSTEMS 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 |
20110099541 | Context-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 |
20110113408 | PARTIAL 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 |
20110126177 | METHOD, 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 |
20110131555 | EXTERNAL 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 |
20110138370 | Typed-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 |
20110219361 | CORRECT 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 |
20110219362 | Virtual 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 |
20110314456 | System 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 |
20120036502 | CONSISTENCY 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 |
20120042304 | PROGRAM 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 |
20120079461 | EXTENSIBLE 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 |
20120079462 | SYSTEMS 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 |
20120089967 | DYNAMIC 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 |
20120089968 | RUNTIME 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 |
20120089969 | DECLARATIVE 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 |
20120117547 | EMBEDDING 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 |
20120159458 | RECONSTRUCTING 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 |
20120174080 | OBJECT 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 |
20120204157 | Quicker 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 |
20120204158 | CONVERTER, 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 |
20120254842 | SYSTEM 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 |
20120272222 | Software 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 |
20120311546 | TRANSFORMING 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 |
20130125097 | Method 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 |
20130174129 | Model 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 |
20130174130 | METHOD 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 |
20130179869 | Adaptive 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 |
20130198726 | MAPPING 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 |
20130227532 | APPLICATION GENERATION SYSTEM AND METHOD FOR GENERATING AN APPLICATION - The application generation system includes: a first managing unit to extract at least one execution component from at least one application; and a second management unit to generate an extracted execution component into a container application. The system provides the ability to generate an application configured by extracting operations among the operations of applications stored in a terminal. | 08-29-2013 |
20130247016 | METHOD AND SYSTEM FOR CONTAINMENT OF USAGE OF LANGUAGE INTERFACES - Client software is modified by a translator to use unique variant of linguistic interface of a service. An interceptor pre-processes subsequent client service requests from translated unique linguistic interface to standard linguistic interface implemented by service. Usage of linguistic interfaces of service is contained, rendering service incapable of executing arbitrary input, even if such input is crafted specifically for the service interface. | 09-19-2013 |
20130254751 | Parallelism From Functional Decomposition - A system and method for performing functional decomposition of a software design to generate a computer-executable finite state machine. Initially, the software design is received in a form wherein functions in the software design are repetitively decomposed into (1) data and control transformations. Included between the functions are control flow indicators which have transformation-selection conditions associated therewith. The data transformations and the control transformations are translated into states in the finite state machine. The transformation-selection conditions associated with the control transformations are translated into state transitions in the finite state machine. | 09-26-2013 |
20130283248 | METHOD, APPARATUS AND PRODUCT FOR PORTING APPLICATIONS TO EMBEDDED PLATFORMS - A computer-implemented method and apparatus for transforming code to embedded environments, the method comprising: receiving program code not complying with a limitation of an embedded computing environment; transforming at least part of the program code to modified program code in order for the modified program code to be in compliance with the limitation; and storing the modified program code on a storage device. wherein the modified program code complies with the limitation of the embedded computing environment. | 10-24-2013 |
20130290940 | SYMBOL-BASED MERGING OF COMPUTER PROGRAMS - 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. | 10-31-2013 |
20140033184 | LOCALIZING COMPUTER PROGRAM CODE - 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. | 01-30-2014 |
20140047418 | MECHANISM FOR REPLACING AN ARRAY CREATION ROUTINE WITHIN CODE - 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. | 02-13-2014 |
20140130021 | SYSTEM AND METHOD FOR TRANSLATING PROGRAM FUNCTIONS FOR CORRECT HANDLING OF LOCAL-SCOPE VARIABLES AND COMPUTING SYSTEM INCORPORATING THE SAME - A system and method of translating functions of a program. In one embodiment, the system includes: (1) a local-scope variable identifier operable to identify local-scope variables employed in the at least some of the functions as being either thread-shared local-scope variables or thread-private local-scope variables and (2) a function translator associated with the local-scope variable identifier and operable to translate the at least some of the functions to cause thread-shared memory to be employed to store the thread-shared local-scope variables and thread-private memory to be employed to store the thread-private local-scope variables. | 05-08-2014 |
20140189659 | HANDLING OF BINARY TRANSLATED SELF MODIFYING CODE AND CROSS MODIFYING CODE - A processor core includes a processor to execute a first translated instruction translated from a first instruction stored in first page of a memory. The processor also includes a translation indicator agent (XTBA) to store a first translation indicator that is read from a physical map (PhysMap) in the memory. In an embodiment, the first translation indicator is to indicate whether the first page has been modified after the first instruction is translated. Other embodiments are described as claimed. | 07-03-2014 |
20140282437 | METHOD AND APPARATUS TO SCHEDULE STORE INSTRUCTIONS ACROSS ATOMIC REGIONS IN BINARY TRANSLATION - A method and system to support scheduling of memory store instructions across atomic regions in binary translation in a processing unit or processor. In one embodiment of the invention, the processing unit has a store buffer that allows store instructions to be issued in different order than the source binary program order but still retire in source binary program order. This facilitates a small atomic region that maps to each iteration of a source binary code and these atomic regions are joined together into a pipelined region. In one embodiment of the invention, the processing unit executes commit instruction(s) once every loop iteration instead of executing the commit instruction(s) once after the loop exit. | 09-18-2014 |
20140289713 | Dynamic Media Content Instantiation Framework - Methods and apparatus for the dynamic instantiation of media platform components, for example Adobe® Flash® visual components, in runtime environments. A dynamic media content instantiation framework may enable media platform components to be dynamically instantiated within runtime environments without requiring extensive code. A developer may obtain a library of media platform component definitions. Instead of coding a view's interface in the programming language of the runtime environment, the developer can simply reference the desired media platform resource in the library with as little as a single line of code. At runtime, the framework dynamically instantiates a requested media platform component from the definition of the component in the library, attaches the component instance to a stage, and provides a reference to the stage back to the runtime environment layer so that the content can be displayed. | 09-25-2014 |
20140304690 | Systems and Methods for Outputting an Application to Another Environment - Methods for outputting an application are disclosed. One exemplary embodiment provides a software tool for outputting an application to one or more environments. The tool may be able to receive and use output task plug-ins that specify output characteristics for outputting to different environments. The use of such plug-ins may make the tool easily extensible with respect to outputting an application to many different mobile devices, including devices that are not yet released, as well as to other local, device, and network environments. Another exemplary embodiment involves a output tool that may receive and save user specified output parameters for an output task as an output task instance. The tool makes the output task instance available for outputting an application according to the received output parameters without requiring that the parameters be specified again. | 10-09-2014 |
20140366008 | NOTIFICATION-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. | 12-11-2014 |
20150058830 | SYSTEMS AND METHODS FOR CONVERTING TYPED CODE - Techniques provided implement automatic data type annotation in dynamically-typed source code. A codebase, which may comprise a plurality of source code files, is scanned at a global level. The resulting scanned data may describe characteristics of the codebase, including variable and function usage. Based on inferences drawn from the scanning, data types are determined for different variables, expressions, or functions to facilitate conversion from dynamically-typed source code to statically-typed source code. For example, if a function is called once with a parameter value of data type A (e.g., class A), and another time with a parameter value of data type B (e.g., class B), a conversion tool may annotate the parameter variable in the declaration of the function with a data type D (e.g., class d) when data type D is identified as a common ancestor (e.g., superclass) to both data type A and data type B. | 02-26-2015 |
20150293753 | DEVICE AND METHOD FOR GENERATING APPLICATION PACKAGE - A method of a server and an electronic device are provided. The method includes receiving a package generated with an intermediate representation from a first electronic device; receiving build environment information on at least one third electronic device from a second electronic device; and generating an application package to be executed in the at least one third electronic device, based on the package or the build environment information. The electronic device includes a build unit configured to generate a Central Processing Unit (CPU-independent) binary and build information for CPUs involved in two or more third electronic devices; a package generation unit configured to generate a CPU-independent application package using the generated CPU-independent binary and the generated build information; and a package registration unit configured to transmit the generated CPU-independent application package to a server. | 10-15-2015 |
20150293754 | CONTROLLING EXECUTION OF BINARY CODE - An apparatus for controlling an execution of a binary code by multiple threads includes a detection unit configured to detect an occurrence of modification of a first part that is a part of a first binary code by a self-modifying code; a specifying unit configured to specify a second part that is a part corresponding to the first part in a second binary code acquired by converting the first binary code, in response to detection of the occurrence of modification of the first part by the self-modifying code; and a correction unit configured to correct the second part such that a specific thread that executes the second part of the second binary code among the multiple threads causes an exception. | 10-15-2015 |
20150301841 | BINARY TRANSLATION REUSE IN A SYSTEM WITH ADDRESS SPACE LAYOUT RANDOMIZATION - Generally, this disclosure provides systems, methods and computer readable media for binary translation (BT) reuse. The system may include a (BT) module to translate a region of code from a first instruction set architecture (ISA) to a second ISA, for execution associated with a first process. The BT module may also be configured to store a first physical page number associated with the translated code and the first process. The system may also include a processor to execute the translated code and to update a virtual address instruction pointer associated with the execution. The system may further include a translation reuse module to validate the translated code for reuse by a second process. The validation may include generating a second physical page number based on a page table mapping of the updated virtual address instruction pointer and matching the second physical page number to the stored first physical page number. | 10-22-2015 |
20150332027 | PROGRAM CABLE OBFUSCATION BASED UPON RECENTLY EXECUTED PROGRAM CODE - A method of obscuring software code including a plurality of instructions, comprising: determining, by a processor, a number N prior instructions to a current instruction; encoding the current instruction based upon a first function, a second function, and the N prior instructions, wherein the second function is based upon the N prior instructions, and wherein the first function is based upon the current instruction and an output of the second function. | 11-19-2015 |
20160034277 | Software Defined SaaS Platform - A system that transforms non-SaaS applications into tenant-aware SaaS applications is disclosed, which analyzes the non SaaS applications to determine which intercepts to external libraries need to be translated into SaaS intercepts that utilize SaaS tenancy services, SaaS operations services, and/or SaaS business services. The system transforms the non-SaaS applications into SaaS applications by providing intercept handlers that call SaaS services on demand when the transformed SaaS application throws a transformed SaaS interrupt. | 02-04-2016 |
20160110177 | MAPPING 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. | 04-21-2016 |
20160124722 | JSON STYLESHEET LANGUAGE TRANSFORMATION - Systems and methods are provided for specifying transformations of JSON objects using other JSON objects. A first object is received specified using JavaScript Object Notation. The first object includes a set of one or more attributes where each attribute is of a predetermined JSON data type and has at least one value. A second object is also received specified using JavaScript Object Notation. The second object includes a set of one or more attributes each corresponding to at least one attribute in the set of attributes of the first object and having at least one value defining one or more transformations. A third object specified using JavaScript Object Notation is generated based on transforming the first object using the second object. | 05-05-2016 |
20160179492 | CONTROLLING EXECUTION OF BINARY CODE | 06-23-2016 |
20160378446 | SYSTEM FOR BINARY TRANSLATION VERSION PROTECTION - The present disclosure is directed to a system for binary translation version protection. Activity occurring in a device that may potentially cause native code to be altered may cause the device to prevent binary translations corresponding to the native code from being executed until a determination is made as to whether the binary translation needs to be regenerated. The native code may be stored in a memory page having an access permission that does not permit writes. Attempts to alter the native code would require the access permission of the memory page to be set to writable, which may cause a binary translation (BT) module to be notified of the potential change. The BT module may mark any binary translations corresponding to the native code as stale, and may cause a page permission control module to update memory pages including the binary translations to have an access permission of non-executable. | 12-29-2016 |