| Class / Patent application number | Description | Number of patent applications / Date published |
|---|
| 717139000 | Interpreter | 68 |
| 20080222617 | SERVER SIDE APPLICATION INTEGRATION FRAMEWORK - A flexible, platform-independent integration infrastructure is provided. The integration infrastructure may include an integration bridge and at least one plug-in, where the at least one plug-in may include translation rules, mapping rules, and other information associated with a component coupled to the plug-in. The translation rules, mapping rules, and other information may be used by the integration bridge during a mapping process to control communication between components. Based on the rules and information, a mapping translator of the integration bridge converts data received from component into a form readable by another component. | 09-11-2008 |
| 20080222618 | Methods for User Interface Generation and Application Modification - A method of generating a user interface for presentation to a user. The method comprises executing a first application computer program to provide a user interface, executing agent computer program code to interrogate and modify said user interface during execution of said first application computer program, and presenting said modified user interface. The first application computer program may be run on a server, while the modified user interface may be presented to a user at a client connected to said server. | 09-11-2008 |
| 20080235671 | Injecting content into third party documents for document processing - Techniques for extracting content from a rendered page are provided. In one approach, a tool allows a user to specify executable code (e.g., JavaScript) to be inserted into a file (e.g., HTML file). The code-injected file is interpreted and the executable code is executed, including, optionally, any executable code already in the file. Content is subsequently generated and provided to another application for further processing. | 09-25-2008 |
| 20080263528 | High-level language, architecture-independent probe program compiler - A high-level language, architecture-independent probe program compiler is disclosed. A base program is executable by one or processors, and has one or more breakpoints. A probe program is associated with each breakpoint and is also indirectly executable by the one or more processors. The probe program is independent of the architecture of the processors, and is generated from source code written in a high-level language. The probe program associated with each breakpoint is executed when the breakpoint is reached during execution of the base program. The compiler may employ an abstract syntax tree to switch between an address space of the probe program and an address space of the base program, by traversing the tree. Some of the nodes of the tree may more simply represent address space-specific objects of the base program. The probe program may be able to pass messages by manipulating the state of the base program. | 10-23-2008 |
| 20080270999 | System And Method For Extending Capabilities And Execution Efficiency Of Script Based Applications - Scripting Language based applications can be limited in their ability to supply and execute sophisticated logic and complex processing. More traditional programming languages contain explicit function and/or procedure calls to implement more complex functionality, however, these languages use more complicated syntax and traditionally require mosophisticated programming knowledge to use. There are provided systems and methods for extending the capabilities of an application program for execution by a terminal. The application includes a script based workflow and non-executable content. One such method comprises loading the workflow for interpretation by a script interpreter, such that the workflow is configured for having a plurality of executable elements. This method also provides a global symbol structure for reference by the executable elements, the global symbol structure including addressing for coupling selected ones of the executable elements to corresponding external components. The external components are provided by a native runtime environment of the terminal for performing the action specified by the selected executable elements. This method also executes the executable elements in sequence such that execution of the selected ones of the execution elements are redirected to the respective external components through the corresponding global symbols of the global symbol structure. Predefined knowledge of the contents of the global symbol structure is shared by the runtime environment and the workflow of the application. | 10-30-2008 |
| 20090007082 | Method for the Translation of a Subprogram by an Interpreter in a Control Device - The invention relates to a method for the translation of a sub-programme ( | 01-01-2009 |
| 20090083718 | Using a command interpreter at design time - Various technologies and techniques are disclosed for using a command interpreter at design time of a software application. A command interpreter can be used to design and test the functionality of an application at design time. The command interpreter allows a user to identify a command to execute for a selected object at design time of an application being developed within a software application design environment. The command interpreter causes the identified command to be executed. A selected object can be sent from a visual tree to the command interpreter. The command interpreter receives the object sent from the visual tree and assigns a designated object name for referencing the object in the command interpreter. The designated object name is displayed within the command interpreter to allow a user to have an abbreviated way of issuing one or more commands for the object from the command interpreter. | 03-26-2009 |
| 20090133003 | COMMAND LANGUAGE FOR MEMORY TESTING - A memory testing system for testing a plurality of memory locations in an electronic memory device is provided. The system includes a programmable memory device integrated into the electronic memory device capable of receiving and storing a compiled memory testing program. A processor is in communication with the programmable memory device to read and execute instructions from the compiled testing program stored in the programmable memory device and a command interpreter is configured to receive data from the processor related to commands to be executed during memory testing. | 05-21-2009 |
| 20090133004 | GENERIC FRAMEWORK FOR RUNTIME INTERCEPTION AND EXECUTION CONTROL OF INTERPRETED LANGUAGES - A system and method for controlling execution of an interpreted language. Statements of the interpreted language to be executed by a script engine are intercepted by a protection module and control is passed to a script helper module that is associated with the script engine. The script helper module establishes a secure communications channel with an authorization component and passes the statements and an authorization request to the authorization component. The authorization component sends a reply to the script helper module which either permits the script engine to execute the statement or cancels the attempted execution. When the script engine is loaded, a list is updated identifying the script engine. If a script helper module is not present for the loaded script engine, a boot-strap loader is called to load the script helper module. A special information block contains data as to the location of the interception points. | 05-21-2009 |
| 20090193399 | PERFORMANCE IMPROVEMENTS FOR NESTED VIRTUAL MACHINES - Nested virtual machines cooperate with one another to improve system performance. In particular, an outer virtual machine performs tasks on behalf of an inner virtual machine to improve system performance. One such task includes translation of instructions for the inner virtual machine. | 07-30-2009 |
| 20090249311 | SHARING A NATIVE MODULE OF COMPILED CODE USING AN ABSTRACTION MODULE OF INTERPRETED CODE IN A VIRTUAL MACHINE ENVIRONMENT - Interpreted code modules configured to be executed within a virtual machine can be identified. Each of the interpreted code modules can be configured to interact with a native module such that dependency information for the native module can be programmatically utilized by each of the interpreted code modules. An abstraction module for the virtual machine written in the interpreted language can be established. The abstraction module can be configured to load an instance of the native module, wherein upon loading the instance of the native module the abstraction module is exposed to the dependency information associated with the instance of the native module. Each of the interpreted code modules can be configured to interact with the native mode module through the abstraction module. The abstraction module is configured to provide the dependency information associated with the instance of the native module to each of the interpreted code modules. | 10-01-2009 |
| 20090328010 | SYSTEM AND METHOD FOR PLATFORM-INDEPENDENT, SCRIPT-BASED APPLICATION GENERATION FOR SPREADSHEET SOFTWARE - A script-based application generation for spreadsheet software reads from one or more spreadsheets rendered by a spreadsheet program, description written in said text-based language, the text-based language for describing user interfaces, data models and/or workflow models or combinations thereof The text-based language is independent of the spreadsheet program. The description is parsed and from the description one or more user interfaces, data model or workflow model or combinations thereof are generated in the spreadsheet program. | 12-31-2009 |
| 20100070952 | Automation in IT Services and IT Enabled Services - A system for automation of processes in a working environment to achieve targeted deliverables, said system comprising: mapping means adapted to map discrete processes in a working environment; reader means adapted to read human instructions in relation to targeted deliverables at mapped discrete processes; interpreter means adapted to interpret said read instructions into a machine readable instruction format; compiler means adapted to compile said machine readable instruction format into a pre-defined operating system executable instruction format; packager means adapted to classify and package said operating system executable instruction format in a pre-defined format; and installer means adapted to install and deploy said packaged format in said working environment to complete the automation process and achieve targeted deliverables. | 03-18-2010 |
| 20100088684 | Calculating Resource Bounds Of Programs Manipulating Recursive Data Structures And Collections - Bounding resource consumption of code that processes recursive data structures and collections includes making use of quantitative functions (based on user input) that are associated with a tuple of data-structures and whose semantics is specified by describing the effect of various data-structure methods on the relevant quantitative functions. Counter variables are incorporated into source code to count loop iterations (and number of recursive procedure call invocations). Relevant quantitative functions are incorporated into the source code to allow computation of invariants (and hence bounds) on the incorporated counter variables in terms of the quantitative functions. | 04-08-2010 |
| 20100153929 | Converting javascript into a device-independent representation - A device-independent intermediate representation of a source code is generated and stored, e.g., in a memory or other storage mechanism. The stored intermediate representation of the source code is used to generate a device-specific machine code corresponding to the source code. The stored intermediate representation may be updated, e.g., periodically, for example by obtaining an updated version of the source code and compiling the updated source code to generate an updated intermediate representation. The stored intermediate representation may be based on source code received from a device that is synchronized with which a compiling device that generates the device-specific machine code. In some cases, the stored intermediate representation may be used to generate for each of a plurality of devices a corresponding device-specific machine code. | 06-17-2010 |
| 20100153930 | CUSTOMIZABLE DYNAMIC LANGUAGE EXPRESSION INTERPRETER - Embodiments described herein are directed to allowing a user to extend the functionality of a software code interpretation system. In one embodiment, a computer system receives user-defined conversion rules from a user for converting dynamic language code to continuation-based abstract memory representations. The computer system identifies portions of software code that are to be converted from dynamic language abstract memory representations into continuation-based abstract memory representations, where the identified code portions include undefined, extensible input primitives. The computer system also generates a dynamic, extensible set of output primitives interpretable by a continuation-based code interpretation system using the received conversion rules and converts the identified code portions including the undefined, extensible input primitives from dynamic language abstract memory representations into continuation-based abstract memory representations using the generated set of output primitives. | 06-17-2010 |
| 20100199268 | APPLICATION OF PLATFORM DEPENDENT ROUTINES IN VIRTUAL MACHINES BY EMBEDDING NATIVE CODE IN CLASS FILES - The deployment of native methods in a virtual machine environment may be significantly simplified by incorporating a corresponding native code segment into the application file, such as a JAVA class file, and using the embedded native code segment for library bind operations of the corresponding class file. | 08-05-2010 |
| 20100223601 | COMPILATION METHOD WITHOUT EXPLICIT SYMBOL TABLE FOR SAVING MEMORY - There is described a method of compiling source code for a computer programme into corresponding object code. The source code includes several declared variables. The method comprises, for each declared variable in the source code, including in the object code a declaration statement indicating an associated memory location for that variable and indicating the position in the object code of the next declaration statement. During compilation, the memory location for each declared variable can be retrieved from the object code by examining each declaration statement in turn, using the position information from each declaration statement to locate the next declaration statement. This is of particular advantage where the available volatile memory is limited, because there is not requirement for a look-up table of variables against memory locations. | 09-02-2010 |
| 20100235819 | ONE-PASS COMPILATION OF VIRTUAL INSTRUCTIONS - In embodiments, prior to compilation into machine code, a preprocessor generates directives by processing a source code and/or bytecode representation of a program and/or selecting default directives. The preprocessor embeds the directives in a bytecode representation of the program or a separate stream associated with the bytecode representation of the program. A just-in-time compiler may compile the bytecode representation into machine code directed by the embedded directives in one pass and/or a bytecode interpreter may interpret the bytecode representation of the program. In some embodiments, a computing device generates bytecodes during execution of a program, selects default directives, and embeds the default directives in the bytecodes or a separate stream associated with the bytecodes prior to compilation of the bytecodes into machine code. Subsequently, the bytecodes may be compiled into machine code with a just-in-time compiler directed by the embedded default directives in one pass and/or interpreted with an interpreter. | 09-16-2010 |
| 20100251224 | Interpreter-based program language translator using embedded interpreter types and variables - A programming language is extended to have embedded interpretive types (EIT) that define objects and variables to be resolved at translation time. A variable or data element having a type that is one of the EITs is referred to as an embedded interpretive variable (EIV). A control construct containing an EIV is interpreted (i.e. executed) at translation time. | 09-30-2010 |
| 20100281470 | METHOD FOR GENERATING INTERPRETABLE CODE FOR STORAGE IN A DEVICE HAVING LIMITED STORAGE - In some embodiments of the present invention, files are generated from .java files or .class files or .jar files. The generated files are directly linkable and interpretable by a Java Virtual Machine. The generated files may be stored in a directly addressable memory of a device. References between .class files may appear in the generated files as hard offsets or symbolic references. The generated files may be grouped so that cross-references between generated files in the same group appear as hard offsets. | 11-04-2010 |
| 20100287541 | Instrumenting An Application With Flexible Tracers To Provide Correlation Data And Metrics - A technique for flexibly adding instrumentation to an application. A file is created which includes a dynamic parameter syntax. The file identifies a trace point in the application, such as a method, and the syntax includes one or more parameters which are evaluated when the method is invoked. The parameters can be used to provide cross-process correlation and/or performance metrics. A client process which calls a server process can include the parameter in a message header according to any desired transport protocol, such as HTTP or JMS. Different application protocols and implementation can be accommodated to track a transaction which executes on different platforms. The dynamic parameter syntax is interpreted as uncompiled code and is designed to be added by the user in the field to augment a package of pre-built instrumentation software after the package has been deployed. | 11-11-2010 |
| 20100313188 | Method for Preventing Software Reverse Engineering, Unauthorized Modification, and Runtime Data Interception - A method for preventing the unauthorized modification of a software or unauthorized modification of runtime data. According to this method, a converter, which is capable of converting the software into a generalized machine code is provided. The converter is designed such that it cannot be reverse engineered, by using a conversion process that causes data loss. An interpreter, which the knowledge of its process method is kept restricted, is also provided. The interpreter interprets the general machine code into a specific machine code, while reconstructing the lost data during the interpretation process. | 12-09-2010 |
| 20100333075 | EXECUTING PLATFORM-INDEPENDENT CODE ON MULTI-CORE HETEROGENEOUS PROCESSORS - A virtual machine can be extended to be aware of secondary cores and specific capabilities of the secondary cores. If a unit of platform-independent code (e.g., a function, a method, a package, a library, etc.) is more suitable to be run on a secondary core, the primary core can package the unit of platform-independent code (“code unit”) and associated data according to the ISA of the secondary core. The primary core can then offload the code unit to an interpreter associated with the secondary core to execute the code unit. | 12-30-2010 |
| 20110010694 | Method for Creating Sub-Query Related Memory Stores - The present invention relates to a method for creating a memory store for enabling a computer to interpret sub-query programming code in which code reuse is explicitly defined, the method comprising steps for defining data sources for first-order quantified queries, also known as sub-queries, in which method the main query data sources can be used as the sub-query data source for any repeated execution of code over collections of data and combinations of collections of data, such as tables, arrays and object collections. The method is preferably able to create a memory store for enabling a computer to interpret programming code in which first-order quantified queries, also known as sub-queries, can explicitly or implicitly reuse data sources defined for any repeated execution. | 01-13-2011 |
| 20110016458 | SYSTEMS, METHODS, AND COMPUTER PROGRAMS FOR DYNAMIC BINARY TRANSLATION IN A MASTER CONTROL PROGRAM INTERPRETER - Various embodiments of systems and methods for dynamic binary translation in an interpreter are disclosed. An embodiment comprises a method for dynamic binary translation in an interpreter. One such method comprises: receiving non-native code comprising a sequence of one or more operators to be interpreted; building a static branch destination table associated with the operators, the static branch destination table specifying a static branch operator that branches to another operator in the sequence and a corresponding memory location to which the static branch operator branches; parsing the sequence of operators and building a cross-reference table that specifies a pointer to an operator function associated with the corresponding operator, an index of the operator in a native code sequence, and a call to a native operator; selecting a dynamic branch code template for the native operator; and based on the static branch table and the cross-reference table, emitting the native code sequence to be executed via a native processor. | 01-20-2011 |
| 20110016459 | SYSTEMS, METHODS, AND COMPUTER PROGRAMS FOR DYNAMIC BINARY TRANSLATION IN AN INTERPRETER - Various embodiments of systems and methods for dynamic binary translation in an interpreter are disclosed. An embodiment comprises a method for dynamic binary translation in an interpreter. One such method comprises: receiving non-native code comprising a sequence of one or more operators to be interpreted; building a static branch destination table associated with the operators, the static branch destination table specifying a static branch operator that branches to another operator in the sequence and a corresponding memory location to which the static branch operator branches; parsing the sequence of operators and building a cross-reference table that specifies a pointer to an operator function associated with the corresponding operator, an index of the operator in a native code sequence, and a call to a native operator; selecting a dynamic branch code template for the native operator; and based on the static branch table and the cross-reference table, emitting the native code sequence to be executed via a native processor. | 01-20-2011 |
| 20110093836 | MULTI-ENVIRONMENT OPERATING SYSTEM - A device with multiple, co-existing, and independent environments interacting with a common kernel, and related methods of operation, are disclosed herein. In at least one embodiment, the device is a mobile device on which a run-time method is performed. The run-time method includes interpreting a first software application on a register-based virtual machine coupled to a kernel. The method additionally includes concurrently executing a second software application also coupled to the kernel, where the second software application is a compiled software application. The interpreting of the first software application is performed using a first library, and the executing of the second software application is performed using a second library. | 04-21-2011 |
| 20110126178 | Computer program product containing instructions for providing a processor the capability of executing an application derived from a compiled form - An integrated circuit card is used with a terminal. The integrated circuit card includes a memory that stores an interpreter and an application that has a high level programming language format. A processor of the card is configured to use the interpreter to interpret the application for execution and to use a communicator of the card to communicate with the terminal. | 05-26-2011 |
| 20110161940 | MULTI-LANGUAGE SUPPORT FOR SERVICE ADAPTATION - A plurality of domain-specific service adaptation languages can be supported by a back-end service adaptation system to provide runtime access to a runtime instance of a data object comprising data stored in a repository. By defining a language-specific data access service and parser for each domain-specific service adaptation language, a single, service adaptation language-independent compiler and interpreter can prepare and execute a runtime load that includes an execution plan for retrieving and converting data from the repository for delivery in a data object according to a query request from a consumer runtime environment. A consumer using the consumer runtime environment can define the service adaptation language to be used and provide a parser and source code to enable access to business object data using the back-end service adaptation system. | 06-30-2011 |
| 20110179401 | ENGINE FOR RENDERING WIDGETS USING PLATFORM-SPECIFIC ATTRIBUTES - A widget engine renders widgets using operating system platform-specific attributes. A widget application written at least partly in platform non-specific code is rendered by the widget engine through a series of system calls and callbacks. Upon interpreting particular code, the widget engine issues a system call to a module for performing a particular type of action. The module, based on the operating system platform, calls a platform-specific library that specifies how to carry out the action according to the operating system platform. Thereafter, using the returned platform-specific data, the widget engine renders the widget. | 07-21-2011 |
| 20110191754 | SYSTEM USING A UNIQUE MARKER WITH EACH SOFTWARE CODE-BLOCK - A system and method for improving software maintainability, performance, and/or security by associating a unique marker to each software code-block; the system comprising of a plurality of processors, a plurality of code-blocks, and a marker associated with each code-block. The system may also include a special hardware register (code-block marker hardware register) in each processor for identifying the markers of the code-blocks executed by the processor, without changing any of the plurality of code-blocks. | 08-04-2011 |
| 20110265066 | METHODS AND SYSTEMS FOR EVALUATING BYTECODE IN AN ON-DEMAND SERVICE ENVIRONMENT INCLUDING TRANSLATION OF APEX TO BYTECODE - Techniques and mechanisms for conversion of code of a first type to bytecode. Apex provides various unique characteristics. When converting to bytecode, these characteristics are handled to provide bytecode functionality. Some of the unique characteristics of Apex include Autoboxing, SOQL, Properties, Comparisons, Modifiers, Code coverage mechanisms and Sharing mechanisms. | 10-27-2011 |
| 20110314457 | SCRIPTING FRAMEWORK FOR BUSINESS OBJECTS - A business object infrastructure may comprise a repository storing a business object having a plurality of nodes, including at least one exit node associated with a code snippet written in a programming language. The business object infrastructure may further include a scripting framework coupled to the repository. The scripting framework may, responsive to a request received from a client device, execute the business object at a processing framework until the exit node is reached. When the exit node is reached, the scripting framework may load the code snippet from the repository and, based on the programming language of the code snippet, select a virtual machine interpreter for the code snippet. | 12-22-2011 |
| 20120042305 | TRANSLATING DECLARATIVE MODELS - The present invention extends to methods, systems, and computer program products for translating declarative models. Embodiments of the present invention facilitate processing declarative models to perform various operations on applications, such as, for example, application deployment, application updates, application control such as start and stop, application monitoring by instrumenting the applications to emit events, and so on. Declarative models of applications are processed and realized onto a target environment, after which they can be executed, controlled, and monitored. | 02-16-2012 |
| 20120159460 | PREFERRED COMPILATION - A method and system to identify code entities suitable for preferred compilation is provided. An example method comprises detecting a request to start up a computer program comprising a plurality of code entities and commence interpreting code entities of the computer program. A numeric value associated with a code entity is compared with a threshold value. The code entity is designated for compilation at a next compilation tier based on a result of the comparing. | 06-21-2012 |
| 20120159461 | PROGRAM OPTIMIZING APPARATUS, PROGRAM OPTIMIZING METHOD, AND PROGRAM OPTIMIZING ARTICLE OF MANUFACTURE - An apparatus having a transactional memory enabling exclusive control to execute a transaction. The apparatus includes: a first code generating unit configured to interpret a program, and generate first code in which a begin instruction to begin a transaction and an end instruction to commit the transaction are inserted before and after an instruction sequence including multiple instructions to execute designated processing in the program; a second code generating unit configured to generate second code at a predetermined timing by using the multiple instructions according to the designated processing; and a code write unit configured to overwrite the instruction sequence of the first code with the second code or to write the second code to a part of the first code in the transaction. | 06-21-2012 |
| 20120167063 | COMMUNICATION PROTOCOL BETWEEN A HIGH-LEVEL LANGUAGE AND A NATIVE LANGUAGE - A system and a method are disclosed for communicating between two programming languages on a client device. Commands in a high-level language are encoded as character string containing a series of numbers separated by delimiters, with each component of the command encoded as a different number. The encoded character strings are passed to compiled code that runs natively on the client device, and the native code decodes the character strings into corresponding native commands and executes the native commands. This communication protocol allows applications written in high-level code to perform functions that are typically set aside for native code, such as communicating with web servers and modifying files saved in memory. High-level code may also be transferred to client devices without being subjected to the restrictions that some operating systems place on the transfer for application binaries, which allows application developers to automatically send application updates to users. | 06-28-2012 |
| 20120185833 | CODE GENERATOR AND METHOD FOR GENERATING EXTRA CODE FOR A VIRTUAL MACHINE - In a virtual machine that uses a just-in-time complier (JITC) as a software execution environment, an idle time of a core to which the JITC is allocated is utilized to generate machine code in advance, thereby reducing a load on an interpreter. Accordingly, code execution performance of the interpreter is improved, and the utilization of a multi-core system that executes applications is increased. | 07-19-2012 |
| 20120254843 | COMPUTER PROGRAM PRODUCT CONTAINING INSTRUCTIONS FOR PROVIDING A PROCESSOR THE CAPABILITY OF EXECUTING AN APPLICATION DERIVED FROM A COMPILED FORM - An integrated circuit card is used with a terminal. The integrated circuit card includes a memory that stores an interpreter and an application that has a high level programming language format. A processor of the card is configured to use the interpreter to interpret the application for execution and to use a communicator of the card to communicate with the terminal. | 10-04-2012 |
| 20120254844 | COMPUTER PROGRAM PRODUCT CONTAINING INSTRUCTIONS FOR PROVIDING A PROCESSOR THE CAPABILITY OF EXECUTING AN APPLICATION DERIVED FROM A COMPILED FORM - An integrated circuit card is used with a terminal. The integrated circuit card includes a memory that stores an interpreter and an application that has a high level programming language format. A processor of the card is configured to use the interpreter to interpret the application for execution and to use a communicator of the card to communicate with the terminal. | 10-04-2012 |
| 20120260237 | Portable Business Language and Automated Software Application Development System - A portable business language and automated software development system comprises one or more servers containing a set of requirement inputs and an application engine residing on at least one of the one or more servers. The application engine comprises a requirements input component receiving a subset of the set of requirement inputs, a compiler component transforming the subset of the set of requirement inputs into one or more machine-readable codes, and a preparation component. The preparation component uses one of the one or more machine-readable codes to prepare a user interaction device to execute a final application, prepare a memory of the one or more servers to store data that may be provided by a user of the user interaction device, and transform the one or more machine-readable codes into an interpreted platform-specific code having additional parameters that customize the interpreted platform-specific code for the platform. | 10-11-2012 |
| 20120266146 | PRODUCER GRAPH ORIENTED PROGRAMMING AND EXECUTION - A method and apparatus for producer graph oriented programming and execution. According to one aspect of the invention, a runtime is provided that interprets producer dependency declarations for methods. The producer dependency declarations identify at run time a set of zero or more producers, where a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance. The runtime automatically generates and executes, responsive to receiving a designation of a producer of interest whose method has a producer dependency declaration, a producer graph. The producer graph initially includes the producer of interest and is generated, from the producer of interest to source producers, through instantiation of producers based on the producer dependency declarations of the methods of the producers already in the producer graph. The runtime sequences the execution of the producers in the producer graph as indicated by the producer graph. | 10-18-2012 |
| 20130019229 | Embedding of a Non-Imperative Programming Language for Data Transformation Operations within an Imperative Programming LanguageAANM Bohlmann; KarstenAACI RauenbergAACO DEAAGP Bohlmann; Karsten Rauenberg DEAANM Bresch; StefanAACI OffenburgAACO DEAAGP Bresch; Stefan Offenburg DEAANM Walter; WelfAACI RauenbergAACO DEAAGP Walter; Welf Rauenberg DEAANM Boehm; ThiloAACI HeidelbergAACO DEAAGP Boehm; Thilo Heidelberg DE - In an embodiment, a method of computer program compilation is presented. In this method, a compiler for a first programming language is provided. In one example, the first programming language allows a data assignment to depend on a result of a previous data assignment. Source code including a first portion written in the first programming language and a second portion written in a second programming language is accessed, with the second portion representing a data transformation from a first data structure accessible in the first portion to a second data structure accessible in the first portion. In one example, the second programming language prevents a data assignment that depends on a result of a previous data assignment. The source code is compiled using the compiler to generate executable code to be executed by an engine for the first programming language, which includes an interpretation engine to interpret the second portion. | 01-17-2013 |
| 20130067441 | PROFILE GUIDED JIT CODE GENERATION - Methods, systems, and computer program products are provided for profiling source code to enable improved source code execution. A runtime engine includes a parser, a bytecode generator, an execution controller, an interpreter, a just-in-time (JIT) compiler, and a profile generator. The parser receives source code coded in a dynamic language and parses the source code to generate parsed source code. The bytecode generator converts the parsed source code to bytecode. The interpreter is configured to interpret the bytecode when enabled by the execution controller. The JIT compiler is configured to compile the bytecode when enabled by the execution controller. The profile generator generates profile information from the bytecode and stores the profile information. The execution controller enables the interpreter or the JIT compiler to perform their respective functions based on the profile information. | 03-14-2013 |
| 20130067442 | INFORMATION PROCESSING APPARATUS, METHOD OF CONTROLLING INFORMATION PROCESSING APPARATUS, AND PROGRAM FOR EXECUTING INTERMEDIATE CODE INSTRUCTIONS - The CPU includes a byte code interpretation unit that sequentially reads intermediate code instructions along an execution route, determining whether or not there is a compilation result of the read intermediate code instruction in the compilation result storage unit, interpreting the intermediate code instruction when there is no compilation result, and designating the compilation result if there is a compilation result; and a program execution unit that, if received the interpretation result of the intermediate code instruction from the byte code interpretation unit, executes the intermediate code instruction and, if received the designation of the compilation result, executes the program by executing designated native code. The CPU includes a compilation execution unit that compiles the intermediate code instruction interpreted by the byte code interpretation unit to generate the native code and stores them in the compilation result storage unit. | 03-14-2013 |
| 20130139132 | METHOD AND SYSTEM FOR PROGRAM BUILDING - An improved method for program building uses predefined source files and predefined build scripts comprising a sequence of build commands; wherein each build command comprises an origin command line interpretable by an operating system and addressed to at least one compiling tool. | 05-30-2013 |
| 20130205282 | TRANSFERRING PROGRAM EXECUTION FROM COMPILED CODE TO INTERPRETED CODE - Optimized compiled code can be generated from bytecode derived from a program written in a dynamic language such as JavaScript. Optimizations can be based on one or more assumptions. During execution of the optimized compiled code, the assumption or assumptions on which the optimization was based can be examined for validity. In response to determining that the optimization was based on an invalid assumption or assumptions, execution of the optimized code can stop, the state of variables used by an interpreter can be restored and execution of the program can resume in the interpreter using the unoptimized bytecode derived from the program. Resumption of the program can resume at the point in the bytecode analogous to the point in the optimized compiled code at which the assumption or assumptions was determined to be false. | 08-08-2013 |
| 20130227535 | HARDWARE IMPLEMENTATION OF INTERPRETED PROGRAMMING LANGUAGE STACKS - Methods and systems for implementing “virtual machine” interpreters in a hardware component. The virtual machine interpreter may be implemented in the hardware component (e.g., a processor) by configuring the hardware component to include programming language interpreter logic. The hardware component is configured to include multiple logic gates and arrays representing a hardware-based implementation of a virtual machine interpreter. | 08-29-2013 |
| 20130283249 | INSTRUCTION AND LOGIC TO PERFORM DYNAMIC BINARY TRANSLATION - A micro-architecture may provide a hardware and software co-designed dynamic binary translation. The micro-architecture may invoke a method to perform a dynamic binary translation. The method may comprise executing original software code compiled targeting a first instruction set, using processor hardware to detect a hot spot in the software code and passing control to a binary translation translator, determining a hot spot region for translation, generating the translated code using a second instruction set, placing the translated code in a translation cache, executing the translated code from the translated cache, and transitioning back to the original software code after the translated code finishes execution. | 10-24-2013 |
| 20130318508 | REMOTE CARD CONTENT MANAGEMENT USING SYNCHRONOUS SERVER-SIDE SCRIPTING - Remote card content management using synchronous server-side scripting is provided. A system includes a computer processor and a script interpreter executable by the computer processor. The script interpreter is configured to perform a method. The method includes parsing a script configured to perform a card content management operation as a sequence of operations for a secure element based on receiving a request from a mobile device located remotely from the computer processor. The method also includes creating an execution context for the script to identify the sequence of operations in the script as non-flushing and flushing nodes. A flushing node is identified as an operation that sends a response to the request and expects a subsequent request from the mobile device for the secure element. The method further includes pausing execution of the script upon sending the response at the flushing node. | 11-28-2013 |
| 20130326489 | METHOD AND SYSTEM FOR TRANSLATING NON-NATIVE INSTRUCTIONS - Method and system for translating a function in a computer programming language into a non-native instruction set, as part of a program that is otherwise in a native instruction set computer program. The method comprises translating the function into the non-native instruction set, prefixing the translated function with a preamble in the native instruction set format that implements the required conversion and non-native instruction set interpretation when called from native code segments, and incorporating into the translated function and/or the preamble a means of identifying the function as being in the non-native instruction set. | 12-05-2013 |
| 20140068571 | FACILITY - A facility is disclosed including a firmware, which calculates at least one electrical variable, having measuring inputs at which analog electrical signals are present, having a hardware controlled by the firmware, and having data with a number of interfaces, which allow for data to be input and output and for communication. It is proposed in an embodiment that the hardware be used as a platform for an application which extends the facility by a functionality and is created as application software, which an interpreter converts into a machine-readable code prior to loading such that a mechanism transmits the code to the facility, such that transmitted application runs in a predetermined environment, which the application cannot leave, and that the application can access data, the inputs and outputs and the communication by way of a programming interface which are permitted by the programming interface to a limited degree. | 03-06-2014 |
| 20140137085 | ELECTRONIC SYSTEM, ONBOARD MODULAR EXECUTION PLATFORM AND METHOD ENSURING PARTITIONING OF CONFIGURABLE DECISION-MAKING RULES - An electronic system, including:
| 05-15-2014 |
| 20140137086 | PRODUCER GRAPH ORIENTED PROGRAMMING AND EXECUTION - A method and apparatus for producer graph oriented programming and execution. According to one aspect of the invention, a runtime is provided that interprets producer dependency declarations for methods. The producer dependency declarations identify at run time a set of zero or more producers, where a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance. The runtime automatically generates and executes, responsive to receiving a designation of a producer of interest whose method has a producer dependency declaration, a producer graph. The producer graph initially includes the producer of interest and is generated, from the producer of interest to source producers, through instantiation of producers based on the producer dependency declarations of the methods of the producers already in the producer graph. The runtime sequences the execution of the producers in the producer graph as indicated by the producer graph. | 05-15-2014 |
| 20140143762 | SYMBOLIC EXECUTION OF DYNAMIC PROGRAMMING LANGUAGES - A method of symbolically executing a dynamic program may include receiving a portion of a dynamic program that includes multiple objects. The method may also include symbolically executing the dynamic program including constraint solving by managing runtime states of the symbolic execution within a native symbolic executor. Managing the runtime states of the symbolic execution may include constructing an object map of two or more of the objects that are interdependent and distinguishing code portions of one of the two or more objects in the object map from data portions of the one of the two or more objects. Managing the runtime states of the symbolic execution may also include performing one or more of state copying, state backtracking, state sharing, and state spawning based on characteristics of the dynamic program using the object map and the distinguished code portions and data portions. | 05-22-2014 |
| 20140143763 | Method and System to develop operating system agnostic software applications for mobile devices using a virtual machine - A system and method of developing software applications for mobile devices that (a) allows the application to be written once using a high-level application definition language and (b) deploys on devices running different operating systems (OS). The application definition language is agnostic to the operating system and that has constructs to define the complete application including its user interface, data sources, events and actions and business logic. The application definition language is interpreted by the App Virtual Machine at run-time and native Application Programming Interfaces (APIs) are called to create the user interface, display the data from different data sources and execute actions when events occur. The method aims to (a) increase the productivity of the app writers (b) reduce time and cost to develop such software programs for multiple operating systems (c) reduce the amount of source code needed to write an application. | 05-22-2014 |
| 20140157244 | RULE ENGINE SYSTEM CONTROLLING DEVICES OF DISPARATE TYPES AND PROTOCOLS - A rule engine system works with physical systems monitored by Internet-enabled endpoints on one hand and developer custom applications on the other. Endpoints operate in both the domain specific language of the rule engine, and communicate with participating applications in the native protocols thereof. Whether new or legacy, whether hardware, software, or firmware, whether having much, little, or no digital processing or communication capacity, the participating application may be monitored and controlled by an endpoint that communicates over the Internet with the rule engine. Individual developers prepare rule language files, containing data and instructions for the rule engine to implement through the end point. Any apparatus, whether exclusively mechanical, electrical, electronic, highly sophisticated electronic, or some combination may be monitored and controlled. Any participating application, from a mechanical lawn sprinkler to an Internet commerce server may be implemented thus. | 06-05-2014 |
| 20140189661 | SELF-OPTIMIZING INTERPRETER AND SNAPSHOT COMPILATION - A method for a compiler includes receiving, by the compiler and from an interpreter, a representation of a code section having a control path that changes the representation. The representation has profiling data, and the profiling data has a threshold. The method further includes performing, by the compiler and based on the threshold, a partial evaluation of the interpreter executing the representation, compiling, by the compiler, a machine code of the representation, with the control path replaced by a deoptimization point during the compilation of the machine code, triggering the deoptimization point during execution of the machine code, and returning execution to the interpreter based on the triggering. | 07-03-2014 |
| 20140258994 | ADAPTIVE THREADED VIRTUAL PROCESSOR - Systems and methods for generating and executing a translated code stream corresponding to a translation of a plurality of non-native operators are disclosed. One method includes, during interpreted execution of non-native code encountered by an interpreter, for a non-native operator included in a code sequence, selecting one or more native operators useable to perform a task defined at least in part by the non-native operator. The one or more native operators are further selected based on a data type of non-native operands associated with the non-native operator. The method also includes storing the one or more native operators in a shadow code array in a memory of the computing system, the shadow code array associated with the processing module. The method further includes executing the code sequence from the shadow code array, including executing the one or more native operators, thereby performing the task. | 09-11-2014 |
| 20140359585 | METHOD AND DEVICE FOR COMPILING A SOURCE PROGRAM - To compile a source program comprising first rule(s) not supported by a target environment and to enable the first rule(s) to be executed on the target environment, the method comprises generating a directed graph representative of the source program, generating a first data structure corresponding to a flat representation of the directed graph, first data structure comprising at least a first identifier associated with the at least a first rule, and generating a second data structure comprising first instructions adapted for interpreting the first data structure by using the at least a first identifier, the instructions being coded into a code supported by the target environment. | 12-04-2014 |
| 20140380285 | DYNAMICALLY EVOLVING COGNITIVE ARCHITECTURE SYSTEM BASED ON A NATURAL LANGUAGE INTENT INTERPRETER - A dynamically evolving cognitive architecture system based on a natural language intent interpreter is described. A system forms an intent based on a user input, and creates a plan based on the intent. The plan includes a first action object that transforms a first concept object associated with the intent into a second concept object and also includes a second action object that transforms the second concept object into a third concept object associated with a goal of the intent. The first action object and the second action object are selected from multiple action objects. The system executes the plan, and outputs a value associated with the third concept object. | 12-25-2014 |
| 20140380286 | DYNAMICALLY EVOLVING COGNITIVE ARCHITECTURE SYSTEM BASED ON TRAINING BY THIRD-PARTY DEVELOPERS - A dynamically evolving cognitive architecture system based on training by third-party developers is described. A system forms an intent based on a user input, and creates a plan based on the intent. The plan includes a first action object that transforms a first concept object associated with the intent into a second concept object and also includes a second action object that transforms the second concept object into a third concept object associated with a goal of the intent. The first action object and the second action object are selected from multiple action objects. The system executes the plan, and outputs a value associated with the third concept object. | 12-25-2014 |
| 20150012912 | INTERPRETER-BASED PROGRAM LANGUAGE TRANSLATOR USING EMBEDDED INTERPRETER TYPES AND VARIABLES - A programming language is extended to have embedded interpretive types (EIT) that define objects and variables to be resolved at translation time. A variable or data element having a type that is one of the EITs is referred to as an embedded interpretive variable (EIV). A control construct containing an EIV is interpreted (i.e. executed) at translation time. | 01-08-2015 |
| 20150113512 | SPECULATIVE OBJECT REPRESENTATION - A method for optimizing code includes receiving, by a compiler and from an interpreter, a code section representation including an object allocation, compiling, by the compiler, the code section representation into machine code with a compact allocated object of the object allocation, and triggering a deoptimization returning execution to the interpreter in response to an attempted access of the compact allocated object. The method further includes setting, by the interpreter and within the code section representation, a flag indicating that a new compact allocated object is required at a location of the attempted access, receiving, by the compiler, the code section representation including the flag, compiling, by the compiler and according to the flag, the code section representation into new machine code including the new compact allocated object, and executing the new machine code with the new compact allocated object. | 04-23-2015 |
| 20150293771 | SPECIFYING USER DEFINED OR TRANSLATOR DEFINITIONS TO USE TO INTERPRET MNEMONICS IN A COMPUTER PROGRAM - Provided are a method, system, and article of manufacture for specifying user defined or translator definitions to use to interpret mnemonics in a computer program. A mnemonic is processed in the computer program having a user defined definition and a translator definition. The mnemonic is interpreted according to the user defined definition in response to previously processing a mnemonic command specifying the mnemonic and the user defined definition. The mnemonic is interpreted according to the translator definition in response to previously processing a mnemonic command specifying the mnemonic and the translator definition. | 10-15-2015 |
| 20160026442 | METHOD AND SYSTEM FOR HOSTING AND RUNNING USER CONFIGURED DYNAMIC APPLICATIONS THROUGH A SOFTWARE CONTAINER ON A COMPUTING DEVICE - The embodiments herein provide a method and system for hosting and running user configured dynamic applications through a software container on a computing device. The system comprises a first program component for embedding a program interpreter along with a program logic for running a dynamic application; a second program component for processing the user interactions with the dynamic applications; a third program component for interacting with several computing device capabilities to provide an interface between the dynamic applications and several computing device capabilities; and a rendering engine program for rendering the dynamic applications. The first program component is an application interpreter while the second program component is a user interactions handler and the third program component is a device-bridge. The software container automatically pools and displays a specific data from the added dynamic applications to the user based on the user request. | 01-28-2016 |
| 20160077850 | METHODS, SYSTEMS, AND MEDIA FOR BINARY COMPATIBILITY - Methods, systems, and media for binary compatibility comprises: receiving, from a foreign application, a function call to at least one surrogate function, wherein the at least one surrogate function is contained in a surrogate library, and wherein the surrogate library corresponds to a foreign library associated with the foreign function call; identifying a domestic function corresponding to the surrogate function; setting a pointer identifying a block of memory that is local to a thread associated with the surrogate function to point to a first portion of memory associated with the domestic function; invoking the identified domestic function; storing values including one or more error codes returned from the invoked domestic function; setting the pointer to point to a second portion of memory associated with the foreign function call; copying the one or more error codes to the second portion of memory; and continuing to execute the foreign application | 03-17-2016 |
