Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A computer-implemented method for constructing a graph data structure as an intermediate representation of a source code, for a compiler configured for compiling the source code into executable machine code running on one or more processors, wherein the source code is represented in an object-oriented programming language by objects of classes, the method being implemented by one or more processors and comprising: obtaining an operation in the source code, the operation comprising an operand; creating a first new node of the graph data structure using the operand, wherein the new node comprises a factory method; producing one or more new nodes of the graph data structure by calling the factory method of the first new node, and subsequently producing more new nodes by calling factory methods in existing nodes in the graph data structure until all nodes of the graph data structure are represented by symbols, wherein an existing node of the graph data structure comprises a factory method based on a type of the first new node of the graph data structure and is associated with a class, and wherein producing a new node using the existing node comprises calling a factory method of the class associated with the existing node and returning a corresponding function to provide a corresponding symbol to the new node; and using the symbols as proxies of the nodes of the graph data structure to generate functional calls for implementing the source code.
2. The method of claim 1 , wherein each node of the graph data structure is implemented as an object of a class.
A system and method for managing graph data structures involves representing nodes and edges in a graph using object-oriented programming techniques. The graph data structure is used to model relationships between entities, where nodes represent entities and edges represent relationships. Each node in the graph is implemented as an object of a class, allowing for encapsulation of node properties and behaviors. The class defines attributes and methods associated with the node, such as identifiers, data values, and operations for managing connections to other nodes. Edges between nodes are also implemented as objects, defining relationships with properties like directionality, weight, or type. The system enables dynamic creation, modification, and traversal of the graph structure, supporting operations such as adding or removing nodes, updating relationships, and querying the graph for specific patterns or paths. This approach leverages object-oriented principles to enhance modularity, reusability, and maintainability of graph-based data models. The method is particularly useful in applications requiring complex relationship modeling, such as social networks, recommendation systems, or knowledge graphs.
3. The method of claim 1 , wherein the symbols are used as typed proxies to the corresponding nodes of the graph data structure.
4. The method of claim 3 , wherein the factory methods use instances of the symbols, so that when a method of a symbol is called the corresponding method of the node is executed.
5. The method of claim 1 , wherein the factory methods are configured to produce the new nodes along with connections to the existing nodes.
6. The method of claim 1 , wherein the proxy comprises a class functioning as an interface to a subject.
7. The method of claim 1 , wherein using the symbols as proxies of the nodes of the graph data structure to generate functional calls for implementing the source code comprises providing a proxy with a factory method for delegating calls of a client calling the factory method of the proxy to a called subject.
8. The method of claim 1 , wherein the new nodes are produced according to a factory method design pattern, and the factory method design pattern is configured to design an interface for creating an object.
9. The method of claim 8 , wherein classes of the object-oriented programming language that implement the interface decide which class to instantiate.
10. The method of claim 1 , wherein the nodes of the graph data structure are one of the following: parts of the graph data structure, external entities represented by integer indices, external entities represented by references.
11. The method of claim 1 , wherein the object-oriented programming language comprises the following features: virtual methods, abstract methods and parameterized types.
12. A computing device capable of compiling a source code into executable machine code running on one or more processors, the computing device comprising: a memory storage comprising instructions; and one or more processors in communication with the memory storage, wherein the one or more processors execute the instructions for: constructing a graph data structure as an intermediate representation of the source code, wherein the source code is represented in an object-oriented programming language by objects of classes, the constructing further comprising: obtaining an operation in the source code, the operation comprising an operand; creating a first new node of the graph data structure using the operand, wherein the new node comprises a factory method; producing one or more new nodes of the graph data structure by calling the factory method of the first new node, and subsequently producing more new nodes by calling factory methods in existing nodes in the graph data structure until all nodes of the graph data structure are represented by symbols, wherein an existing node of the graph data structure comprises a factory method based on a type of the first new node of the graph data structure and is associated with a class, and wherein producing a new node using the existing node comprises calling a factory method of the class associated with the existing node and returning a corresponding function to provide a corresponding symbol to the new node; and using the symbols as proxies of the nodes of the graph data structure to generate functional calls for implementing the source code.
13. A non-transitory computer-readable medium storing computer instructions for implementing a method for constructing a graph data structure as an intermediate representation of source code for a compiler, that when executed by one or more processors, cause the one or more processors to compile the source code into executable machine code running on the one or more processors, wherein the source code is represented in an object-oriented programming language by objects of classes, the method comprising: obtaining an operation in the source code, the operation comprising an operand; creating a first new node of the graph data structure using the operand, wherein the new node comprises a factory method; producing one or more new nodes of the graph data structure by calling the factory method of the first new node, and subsequently producing more new nodes by calling factory methods in existing nodes in the graph data structure until all nodes of the graph data structure are represented by symbols, wherein an existing node of the graph data structure comprises a factory method based on a type of the first new node of the graph data structure and is associated with a class, and wherein producing a new node using the existing node comprises calling a factory method of the class associated with the existing node and returning a corresponding function to provide a corresponding symbol to the new node; and using the symbols as proxies of the nodes of the graph data structure to generate functional calls for implementing the source code.
This invention relates to compiler technology, specifically methods for constructing an intermediate graph representation of object-oriented source code to facilitate compilation into executable machine code. The problem addressed is efficiently representing and processing source code operations, particularly those involving objects and classes, in a structured way that enables optimization and code generation. The method involves creating a graph data structure where nodes represent operations and operands from the source code. For an operation containing an operand, a new node is created using the operand, incorporating a factory method. This factory method generates additional nodes by recursively calling factory methods in existing nodes until all nodes are symbolically represented. Each node's factory method is determined by its type and associated class, and calling it returns a function that provides a symbol for the new node. These symbols act as proxies for the nodes, enabling the generation of functional calls that implement the original source code. The approach allows the compiler to systematically process object-oriented constructs, improving code generation and optimization.
Unknown
January 19, 2021
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.