Class / Patent application number | Description | Number of patent applications / Date published |
717144000 | Including graph or tree representation (e.g., abstract syntax tree or AST) | 29 |
20080216062 | Method for Configuring a Dependency Graph for Dynamic By-Pass Instruction Scheduling - There is disclosed a method and system for configuring a data dependency graph (DDG) to handle instruction scheduling in computer architectures permitting dynamic by-pass execution, and for performing dynamic by-pass scheduling utilizing such a configured DDG. In accordance with an embodiment of the invention, a heuristic function is used to obtain a ranking of nodes in the DDG after setting delays at all identified by-pass pairs of nodes in the DDG to 0. From among a list of identified by-pass pairs of nodes, a node that is identified as being the least important to schedule early is marked as “bonded” to its successor, and the corresponding delay for that identified node is set to 0. Node rankings are re-computed and the bonded by-pass pair of nodes are scheduled in consecutive execution cycles with a delay of 0 to increase the likelihood that a by-pass can be successfully taken during run-time execution. | 09-04-2008 |
20090089765 | CRITICAL SECTION ORDERING FOR MULTIPLE TRACE APPLICATIONS - Critical sections in a programming code may be ordered based at least in part on code motions. A flow graph of the code including the critical section may be generated. Two initiative motions may be performed based on the flow graph to identify possible positions of critical codes in the flow graph. Dependence relationship of critical sections may be determined based on the positions of critical sections. Using the dependence relationship information, the order of critical sections may be determined. The determined order of critical sections may be further used by a compiler to perform optimizations for the code. | 04-02-2009 |
20090133006 | SEMANTIC VERSION CONTROL SYSTEM FOR SOURCE CODE - A computer implemented method and computer usable program product for version control of source code. In one embodiment, a source code file is scanned for relationships between source code sections. A semantic graph with dependencies and metadata describing the source code sections is constructed. The dependencies indicate the relationships between the source code sections. If changes are received for the semantic graph, the semantic graph is modified with the changes to form a modified semantic graph. | 05-21-2009 |
20090172650 | SYSTEM AND METHOD FOR COMPARING PARTIALLY DECOMPILED SOFTWARE - A method and computer program product for generating a suspect abstract syntax tree by partially decompiling a compiled software module. The suspect abstract syntax tree is compared to one or more reference abstract syntax trees. | 07-02-2009 |
20090193401 | PATH-SENSITIVE ANALYSIS THROUGH INFEASIBLE-PATH DETECTION AND SYNTACTIC LANGUAGE REFINEMENT - A system and method for infeasible path detection includes performing a static analysis on a program to prove a property of the program. If the property is not proved, infeasible paths in the program are determined by performing a path-insensitive abstract interpretation. Information about such infeasible paths is used to achieve the effects of path-sensitivity in path-insensitive program analysis. | 07-30-2009 |
20100037213 | GRAMMAR-BASED GENERATION OF TYPES AND EXTENSIONS - Parsing functionality is automatically generated. In particular, abstract syntax tree types and/or other programmatic constructs are created automatically from a grammar specification in a manner that resembles hand-written code. An abstract syntax tree can subsequently be constructed as a function of the generated types. Further, a plurality of supporting functionality can be generated to consume or produce abstract syntax tree types, among other things. | 02-11-2010 |
20100083240 | LOCATING SECURITY VULNERABILITIES IN SOURCE CODE | 04-01-2010 |
20100153933 | Path Navigation In Abstract Syntax Trees - The subject matter disclosed herein provides methods and apparatus, including computer program products, for navigating abstract syntax trees. In one aspect there is provided a method. The method may include receiving a plurality of nodes, the nodes configured as an abstract syntax tree representing program code. The method may also include identifying at least one node from the plurality of nodes by navigating the plurality of nodes using a path expression. Related systems, apparatus, methods, and/or articles are also described. | 06-17-2010 |
20100169871 | STRUCTURED SEARCH IN SOURCE CODE - Architecture allows a programmer to answer questions about the source code the programmer is authoring, questions that cannot be answered by other means. A searching mechanism is provided over a much more structured presentation of the source code. The architecture utilizes components that provide an intimate knowledge about the structure of the text, namely, the source code of some particular programming language. The search mechanism employs an abstract syntax tree representation of the code over which the search is conducted. The program source code (as edited by the programmer) is transformed into the abstract syntax tree to embody the structure of the program. If the syntax tree is provided in XML, for example, an XML search mechanism such as Xpath can be utilized to perform the actual searching. This tree is then queried, allowing richer searching criteria to be expressed (by virtue of the structured format of the tree). | 07-01-2010 |
20100192136 | OPTIMIZED JAVASERVER PAGES LIFECYCLE MODEL - Systems and methods are provided that service a JavaServer Page (“JSP”), including receiving a request for a JSP page, parsing source code for the JSP page, creating a tree of the parsed source code. executing the tree in memory, and returning the requested JSP page. Accordingly, JSP pages do not require repeated recompilation, and JSP pages with customized content may be quickly regenerated with a low performance overhead. | 07-29-2010 |
20100275188 | Intermediate Language Representation and Modification - A system and method for facilitating analysis and modification of a computer program. A directed graph is generated from an intermediate language representation of a computer program function, with a node representing each instruction. Meta-edges or meta-nodes are inserted into the directed graph to facilitate location of instruction nodes. One type of meta-edge is a back edge that identifies branch instruction nodes. Some meta-nodes may identify instructions of a specific type. Some meta-nodes may identify exception blocks and corresponding handlers. Analysis of a program function may include insertion of new instructions prior to execution of the function. | 10-28-2010 |
20110321020 | TRANSFORMING DECLARATIVE EVENT RULES INTO EXECUTABLE PROCEDURES - In an embodiment of the present invention, event handlers are used to trigger actions based on events occurring on a data stream. A process of the present invention involves creating the event handler, which may be embodied in, for example, software. The creation of the event handler involves parsing all of the rules in a manner that allows events themselves to trigger actions that will ultimately involve evaluation of rule and, if necessary, firing of those rules. | 12-29-2011 |
20120072892 | SYSTEMS AND METHODS PROVIDING A TOKEN SYNCHRONIZATION GATEWAY FOR A GRAPH-BASED BUSINESS PROCESS MODEL - According to some embodiments, a token synchronization gateway may be recognized in a graph-based business process model, such as a business process modeling notation model. A number of upstream artifacts located upstream from the token synchronization gateway may then be identified in the business process modeling notation model. In addition, a final artifact may be identified directly in front of the token synchronization gateway. The token synchronization gateway may then be compiled into code that will be executed at runtime to perform a synchronization process. The synchronization process may, for example, include handling tokens T | 03-22-2012 |
20120254845 | Vectorizing Combinations of Program Operations - System and method for vectorizing combinations of program operations. Program code is received that includes a combination of individually vectorizable program portions that collectively implement a first computation. Each individually vectorizable program portion has at least one array input and at least one array output. The combination of individually vectorizable program portions is transformed into a single vectorizable program portion that is or includes a functional composition of the combination of individually vectorizable program portions. Vectorized executable code implementing the first computation is generated based on the single vectorizable program portion. The generated executable code is directed to SIMD (Single-Instruction-Multiple-Data) computing units of a target processor. | 10-04-2012 |
20130263099 | COMMON INTERMEDIATE REPRESENTATION FOR DATA SCRIPTING LANGUAGE - A common intermediate representation for a data scripting language is provided for efficient representation and direct specification of programming constructs in memory. The common intermediate representation of data scripts allows data intensive applications to be created and analyzed in a machine accessible format, and the elements of the common intermediate representation can be stored independent of underlying storage specifics. Stored elements of the common intermediate representation of code are thus available for fast loading in memory when desired by other applications and programs by mapping the stored elements to the in memory intermediate representation. | 10-03-2013 |
20130283250 | Thread Specific Compiler Generated Customization of Runtime Support for Application Programming Interfaces - Mechanisms are provided for generating a customized runtime library for source code. Source code is analyzed to identify a region of code implementing an application programming interface or programming standard of interest. An invocation tree data structure is generated based on results of analysis of functions of the application programming interface or programming standard of interest that the region of code invokes. A custom runtime library is generated based on the invocation tree data structure. The custom runtime library comprises only a subset of runtime library functions, less than a total number of runtime library functions for the application programming interface or programming standard of interest, actually invoked by the region of code and does not include all runtime library functions in the total number of runtime library functions for the application programming interface or programming standard of interest. | 10-24-2013 |
20140337823 | AUTOMATIC GENERATION OF API CLASSES - A compiler for compiling a server application is disclosed wherein the server is configured to automatically generate an API (Application Programing Interface) for use is a client device. The API allows communication between the client device and the compiled server application. | 11-13-2014 |
20150020056 | METHODS AND SYSTEMS FOR FILE PROCESSING - The present disclosure relates to a method and system for file processing. The file processing method may include the steps of scanning a source files, identifying a target code block, and generating a first abstract syntax tree (AST) reflecting the structure of the target code block. The file processing method may further include the steps of identifying a position to place a plugin code, placing the plugin code into the first AST, generating a second AST reflecting the structure of the target code block with the plugin code, and using the write-back interface to write the second AST into the source file. The present disclosure may improve the efficiency and enhance the flexibility of the file processing system. | 01-15-2015 |
20150052506 | RUNTIME MEMORY THROTTLING - A system that implements a memory management policy at runtime when receiving a syntax tree in response to initiating the compiling of software code identifies a plurality of calls within the syntax tree and modifies each the plurality of calls with a corresponding memory-modified call to create a plurality of memory-modified calls. Each memory-modified call is linked with a memory management class and the modifying occurs during the compiling of the software code. Following modification of each of the plurality of calls, the system compiles the plurality of memory-modified calls to generate a bytecode. | 02-19-2015 |
20160062747 | COMPILING GRAPH-BASED PROGRAM SPECIFICATIONS - A graph-based program specification includes: a plurality of components, each corresponding to a processing task and including one or more ports, including scalar data ports for sending or receiving a single data element and collection data ports for sending or receiving a collection of multiple data elements; and one or more links, each connecting an output port of an upstream component to an input port of a downstream component. Prepared code is generated representing subsets of the plurality of components, including: identifying one or more subset boundaries, including identifying one or more links connecting a collection data port of a component to a scalar data port of a component; forming the subsets based on the identified subset boundaries; and generating prepared code for each formed subset that when used for execution by a runtime system causes processing tasks corresponding to the components in each formed subset to be performed. | 03-03-2016 |
20160062749 | EXECUTING GRAPH-BASED PROGRAM SPECIFICATIONS - A graph-based program specification includes components corresponding to tasks and directed links between ports of the components, including: a first type of link configuration between ports of linked components, corresponding to transfer of control or transfer of a single data element, and a second type of link configuration between ports of linked components, corresponding to transfer of multiple data elements. A compiler generates a target program specification including control code representing at least one control graph including graph nodes representing the components, where at least two are connected based on links of the first type. A computing node initiates execution of the target program specification, and manages computing resources for links of the second type, the computing resources including at least one of: (1) a buffer for storing data elements provided by an output port, or (2) a buffer for storing data elements provided to an input port. | 03-03-2016 |
20160124723 | GRAPHICALLY BUILDING ABSTRACT SYNTAX TREES - Graphically building an abstract syntax tree includes displaying a user interface comprising a canvas and a presentation pane; displaying on the canvas a depiction of the abstract syntax tree; and displaying within the presentation pane a plurality of elements, wherein each of the plurality of elements is selectable as a visual node to add to the depiction of the abstract syntax tree. The method also includes receiving first input indicating selection of one of the plurality of elements; and adding to the canvas a first node in the depiction of the abstract syntax tree with a first visual label related to the one of the plurality of elements. | 05-05-2016 |
20160132305 | PROGRAM GRAPH DISPLAY DEVICE, PROGRAM GRAPH DISPLAY METHOD, AND PROGRAM GRAPH DISPLAY PROGRAM - A command code extraction part extracts a command code indicated in an extraction target code list, from an instrument control program. A sub-control program creation part creates a sub-control program including the command code extracted. A sub-control parameter list creation part extracts, from each command code included in the sub-control program, each of one or more elements constituting the command code, as a parameter. A sub-control parameter graph display part creates data of a sub-control parameter graph in which one or more parameters of each command code that have been extracted are associated with each other, and displays the created sub-control parameter graph. | 05-12-2016 |
20160139894 | METHOD FOR CONSTRUCTING A GRAPH DATA STRUCTURE - The disclosure relates to a method for constructing a graph data structure as an intermediate representation of source code for a compiler configured for compiling the source code into executable machine code running on a processor of a computer system, wherein program operations of the source code are represented in an object-oriented programming language by objects of classes that form a hierarchy growing from a base node class of the graph data structure, the method comprising: producing new nodes of the graph data structure by calling factory methods associated with existing nodes of the graph data structure based on a factory method design pattern implemented in the nodes of the graph data structure, wherein the nodes of the graph data structure are identified by symbols; and using the symbols as proxies of the nodes of the graph data structure according to a proxy design pattern. | 05-19-2016 |
20160147511 | PRE-COMPILER - A method for reducing a compile time of a source program includes receiving, by a compiler hosted on a computer, the source program. The compiler may have a compile time that depends non-linearly on a size of a function in the source program. The method involves identifying a source function in the source program and splitting the source function in to two or more target functions having sizes smaller than a size of the source function. The method further includes compiling the source program with the two or more target functions having sizes smaller than a size of the source function replacing the source function in the source program. | 05-26-2016 |
20160179486 | SYSTEM AND METHOD FOR FACILITATING STATIC ANALYSIS OF SOFTWARE APPLICATIONS | 06-23-2016 |
20190146763 | KEY-BASED LOGGING FOR PROCESSING OF STRUCTURED DATA ITEMS WITH EXECUTABLE LOGIC | 05-16-2019 |
20220137939 | REPRESENTATION AND ANALYSIS OF WORKFLOWS USING ABSTRACT SYNTAX TREES - A workflow for an operational process may be defined using a functional programming language. A computer system may parse the workflow to generate an abstract syntax tree, which may include states of the workflow and transitions from one workflow state to another. The computer system may generate code paths from the abstract syntax tree representing sequences of execution. Reflection on the workflow may be performed using the abstract syntax tree and code paths to allow intelligent decision-making. | 05-05-2022 |
20220137940 | USING FUSION TO REDUCE ENCRYPTION IN STREAMING APPLICATIONS - An embodiment includes analyzing data associated with an original flow graph comprising a plurality of operators of a stream computing application, including identifying a secure network connection between a first operator and a second operator that uses encryption. The embodiment fuses the first operator with the second operator such that a first logical function of the first operator is combined with a second logical function of the second operator. The embodiment then generates a modified flow graph as a modification of the original flow graph that combines the first operator and the second operator and lacks encryption between the first operator and the second operator. | 05-05-2022 |